Update app.py

app.py

@@ -1,8 +1,18 @@
 #!/usr/bin/env python3
-# app.py - Background Remover Pro v30.2.0
-# FIX: pre-warm runs AFTER remove_func is set
-# FIX: no-op on ALL models → proper HTTP error (not silent pass-through)
-# FIX: /api/debug/model-report endpoint
+# app.py - Background Remover Pro v31.0.0
+# COMPLETE - All fixes applied:
+#   • 2 preload models only (memory safe)
+#   • LRU max_models=3
+#   • ORT graph opt disabled for BirefNet
+#   • BirefNet input padded to multiples of 32
+#   • Full fallback chain (tries every model)
+#   • No-op detection
+#   • Alpha passthrough
+#   • Pre-warm AFTER remove_func is set
+#   • URL-encoded emoji headers
+#   • CPU memory arena OFF
+#   • Video: matting off, u2netp default
+#   • Debug endpoints
 
 import io
 import time
@@ -39,9 +49,11 @@ import cv2
 import threading
 from io import BytesIO
 
+# ========== VERSION CHECK ==========
 if sys.version_info < (3, 8):
     raise RuntimeError("Python 3.8 or higher required")
 
+# ========== LOGGING ==========
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
@@ -50,38 +62,49 @@ logger = logging.getLogger(__name__)
 
 
 # ============================================================
-# INLINE MANAGERS
+# ===== INLINE MANAGER CLASSES =====
 # ============================================================
 
 class ResolutionManager:
     RECOMMENDED = {
-        'simple_graphic': 600, 'human_hair': 1024, 'human': 1024,
-        'anime': 800, 'logo_icon': 600, 'product_white_bg': 700,
-        'general_photo': 1024, 'complex': 1024,
+        'simple_graphic': 600,
+        'human_hair': 1024,
+        'human': 1024,
+        'anime': 800,
+        'logo_icon': 600,
+        'product_white_bg': 700,
+        'general_photo': 1024,
+        'complex': 1024,
     }
+
     @classmethod
-    def get_resolution(cls, category, original_size):
+    def get_resolution(cls, category: str, original_size: tuple) -> int:
         base = cls.RECOMMENDED.get(category, 1024)
         return min(base, max(original_size))
 
 
 class ModelManager:
-    def __init__(self, max_models=5, memory_limit_mb=12000):
-        self.models = {}
-        self.load_times = {}
-        self.use_counts = {}
+    def __init__(self, max_models: int = 3, memory_limit_mb: int = 10000):
+        self.models: Dict[str, Any] = {}
+        self.load_times: Dict[str, float] = {}
+        self.use_counts: Dict[str, int] = {}
         self.max_models = max_models
         self.memory_limit_mb = memory_limit_mb
 
-    def get_model(self, name, loader_func):
+    def get_model(self, name: str, loader_func) -> Optional[Any]:
         if name in self.models:
             self.use_counts[name] = self.use_counts.get(name, 0) + 1
             return self.models[name]
+
         try:
-            if psutil.virtual_memory().percent > 85:
+            mem = psutil.virtual_memory()
+            if mem.percent > 82:
+                logger.warning(f"⚠️ Memory at {mem.percent}% — evicting before load")
                 self._evict_models()
+                gc.collect()
         except Exception:
             pass
+
         start = time.time()
         try:
             session = loader_func(name)
@@ -90,23 +113,35 @@ class ModelManager:
             self.models[name] = session
             self.load_times[name] = time.time() - start
             self.use_counts[name] = 1
+
+            gc.collect()
+            try:
+                mem = psutil.virtual_memory()
+                logger.info(
+                    f"  📊 After {name}: {mem.used/1024/1024:.0f}MB used "
+                    f"({mem.percent:.0f}%)"
+                )
+            except Exception:
+                pass
+
             if len(self.models) > self.max_models:
                 self._evict_models()
             return session
         except Exception as e:
             logger.warning(f"Loader failed for {name}: {e}")
+            gc.collect()
             return None
 
     def _evict_models(self):
         if len(self.models) <= 1:
             return
         to_remove = min(self.models.keys(), key=lambda x: self.use_counts.get(x, 0))
-        logger.info(f"♻️  Evicting LRU: {to_remove}")
+        logger.info(f"♻️  Evicting LRU model: {to_remove}")
         del self.models[to_remove]
         self.use_counts.pop(to_remove, None)
         gc.collect()
 
-    def get_stats(self):
+    def get_stats(self) -> Dict:
         return {
             'loaded_models': list(self.models.keys()),
             'model_count': len(self.models),
@@ -123,11 +158,12 @@ class MaskQualityChecker:
         self.max_components = 100
         self.min_confidence = 0.40
 
-    def check(self, mask):
+    def check(self, mask: np.ndarray) -> dict:
         if mask.dtype != np.uint8:
             mask = (mask * 255).astype(np.uint8)
         h, w = mask.shape
         fg = float(np.sum(mask > 128) / (h * w))
+
         border_pixels = 0
         border_total = 0
         for x in range(w):
@@ -139,6 +175,7 @@ class MaskQualityChecker:
             if mask[y, w - 1] > 128: border_pixels += 1
             border_total += 2
         border_ratio = border_pixels / border_total if border_total > 0 else 0
+
         try:
             from scipy.ndimage import label
             labeled, num_components = label(mask > 128)
@@ -148,6 +185,7 @@ class MaskQualityChecker:
         except Exception:
             num_components = 1
             fragmentation = 0
+
         confidence = 1.0
         issues = []
         if fg < self.min_foreground:
@@ -158,6 +196,7 @@ class MaskQualityChecker:
             confidence -= 0.2; issues.append('border_contamination')
         if num_components > self.max_components:
             confidence -= 0.1; issues.append('too_many_components')
+
         confidence = max(0.0, min(1.0, confidence))
         return {
             'passed': confidence >= self.min_confidence,
@@ -171,7 +210,7 @@ class MaskQualityChecker:
 
 
 class HairRefiner:
-    def refine(self, mask):
+    def refine(self, mask: np.ndarray) -> np.ndarray:
         if mask.dtype != np.uint8:
             mask = (mask * 255).astype(np.uint8)
         mask_float = mask.astype(np.float32) / 255.0
@@ -216,7 +255,7 @@ class GraphicProcessor:
     def __init__(self):
         self.tolerance = 25
 
-    def remove_background(self, image):
+    def remove_background(self, image: Image.Image) -> Image.Image:
         if image.mode != 'RGBA':
             image = image.convert('RGBA')
         np_img = np.array(image)
@@ -269,7 +308,7 @@ class GraphicProcessor:
 
 
 class ContentClassifier:
-    def classify(self, image):
+    def classify(self, image: Image.Image) -> dict:
         if image.mode != 'RGB':
             image = image.convert('RGB')
         small = image.copy()
@@ -283,7 +322,8 @@ class ContentClassifier:
             'texture': self._tex(np_img),
         }
         category = self._cls(signals)
-        return {'category': category, 'confidence': 0.7, 'signals': signals}
+        confidence = self._conf(category, signals)
+        return {'category': category, 'confidence': confidence, 'signals': signals}
 
     def _border(self, np_img):
         h, w = np_img.shape[:2]
@@ -343,9 +383,19 @@ class ContentClassifier:
             return 'general_photo'
         return 'complex'
 
+    def _conf(self, category, s):
+        base = 0.7
+        if category == 'simple_graphic' and s['border_uniformity'] > 0.8:
+            base += 0.2
+        elif category == 'human_hair' and s['skin_score'] > 0.2 and s['texture'] > 0.4:
+            base += 0.2
+        elif category == 'human' and s['skin_score'] > 0.15:
+            base += 0.2
+        return min(1.0, base)
+
 
 # ============================================================
-# ENV / PATHS
+# ===== MEMORY + ENV =====
 # ============================================================
 def limit_memory():
     try:
@@ -376,29 +426,33 @@ os.makedirs(CHUNK_DIR, exist_ok=True)
 cpu_executor = ThreadPoolExecutor(max_workers=2)
 
 # ============================================================
-# SINGLETONS
+# ===== SINGLETONS =====
 # ============================================================
 content_classifier = ContentClassifier()
 resolution_manager = ResolutionManager()
-model_manager = ModelManager(max_models=5, memory_limit_mb=12000)
+model_manager = ModelManager(max_models=3, memory_limit_mb=10000)
 mask_checker = MaskQualityChecker()
 hair_refiner = HairRefiner()
 graphic_processor = GraphicProcessor()
 
+# ============================================================
+# ===== MODEL CONFIG =====
+# ============================================================
+# Only 2 preload — memory safe on HF free tier
 PRELOAD_MODELS = [
-    ("birefnet-general-lite", "~12 MB"),
-    ("u2netp",                "~4.7 MB"),
-    ("silueta",               "~43 MB"),
-    ("isnet-general-use",     "~176 MB"),
-    ("u2net_human_seg",       "~176 MB"),
+    ("birefnet-general-lite", "~12 MB disk / ~250 MB RAM"),
+    ("u2netp",                "~4.7 MB disk / ~180 MB RAM"),
 ]
 
 LAZY_MODELS = {
-    "u2net":            "~176 MB",
-    "isnet-anime":      "~176 MB",
-    "birefnet-general": "~900 MB",
-    "u2net_cloth_seg":  "~176 MB",
-    "sam":              "~375 MB",
+    "silueta":          "~43 MB disk / ~200 MB RAM",
+    "isnet-general-use": "~176 MB disk / ~800 MB RAM",
+    "u2net":            "~176 MB disk / ~800 MB RAM",
+    "u2net_human_seg":  "~176 MB disk / ~800 MB RAM",
+    "isnet-anime":      "~176 MB disk / ~800 MB RAM",
+    "birefnet-general": "~900 MB disk / ~2.5 GB RAM",
+    "u2net_cloth_seg":  "~176 MB disk / ~800 MB RAM",
+    "sam":              "~375 MB disk / ~1 GB RAM",
 }
 
 VALID_REMBG_MODELS = {
@@ -423,7 +477,18 @@ MODEL_ALIASES = {
     'u2net_cloth': 'u2net_cloth_seg',
 }
 
-MATTING_MODELS = {'isnet-general-use', 'u2net_human_seg'}
+# Models with known ORT graph optimization bugs (atrous_conv Sum crash)
+ORT_OPT_DISABLED_MODELS = {
+    'birefnet-general-lite',
+    'birefnet-general',
+    'u2net_cloth_seg',
+}
+
+# Alpha matting only for these (slower but better edges)
+MATTING_MODELS = {
+    'isnet-general-use',
+    'u2net_human_seg',
+}
 
 NEURAL_CONFIGS = {
     'birefnet-general-lite': {'fg': 240, 'bg': 10, 'erode': 10},
@@ -438,11 +503,18 @@ NEURAL_CONFIGS = {
     'sam':                   {'fg': 240, 'bg': 10, 'erode': 10},
 }
 
+# Lower res caps to keep peak RAM low
 MODEL_RES_CAPS = {
-    'u2netp': 512, 'silueta': 512, 'u2net': 768,
-    'u2net_human_seg': 1024, 'birefnet-general-lite': 1024,
-    'birefnet-general': 1024, 'isnet-general-use': 1024,
-    'isnet-anime': 1024, 'u2net_cloth_seg': 768, 'sam': 1024,
+    'u2netp': 512,
+    'silueta': 512,
+    'u2net': 640,
+    'u2net_human_seg': 640,
+    'birefnet-general-lite': 640,
+    'birefnet-general': 640,
+    'isnet-general-use': 640,
+    'isnet-anime': 640,
+    'u2net_cloth_seg': 512,
+    'sam': 512,
 }
 
 CLASSICAL_PROCESSORS = {'flood_fill', 'graphic_classical'}
@@ -451,80 +523,86 @@ DEFAULT_MODEL_NAME = 'birefnet-general-lite'
 DISPLAY_NAMES = {
     'flood_fill': 'Flood Fill (Classical)',
     'graphic_classical': 'Flood Fill (Classical)',
-    'u2netp': 'U2-Net P', 'u2net': 'U2-Net',
-    'u2net_human_seg': 'U2-Net Human', 'u2net_cloth_seg': 'U2-Net Cloth',
-    'silueta': 'Silueta', 'isnet-general-use': 'InSPyReNet (ISNet)',
-    'isnet-anime': 'ISNet Anime', 'birefnet-general': 'BiRefNet',
-    'birefnet-general-lite': 'BiRefNet Lite', 'sam': 'SAM',
+    'u2netp': 'U2-Net P',
+    'u2net': 'U2-Net',
+    'u2net_human_seg': 'U2-Net Human',
+    'u2net_cloth_seg': 'U2-Net Cloth',
+    'silueta': 'Silueta',
+    'isnet-general-use': 'InSPyReNet (ISNet)',
+    'isnet-anime': 'ISNet Anime',
+    'birefnet-general': 'BiRefNet',
+    'birefnet-general-lite': 'BiRefNet Lite',
+    'sam': 'SAM',
 }
 
+
 # ============================================================
-# MODEL LOADING
+# ===== SESSION LOADER (memory + ORT tuned) =====
 # ============================================================
-AI_AVAILABLE = False
-remove_func = None
-_model_loading_lock = threading.Lock()
-default_model_name = DEFAULT_MODEL_NAME
-
-PYMATTING_AVAILABLE = False
-try:
-    from pymatting import cutout, estimate_foreground_ml, estimate_alpha_cf
-    from pymatting.util.util import stack_images  # noqa
-    PYMATTING_AVAILABLE = True
-    logger.info("✅ pymatting available")
-except ImportError as e:
-    logger.warning(f"⚠️ pymatting not available: {e}")
-
-
 def _load_session(name: str):
     from rembg import new_session
+
     resolved = MODEL_ALIASES.get(name, name)
     if resolved not in VALID_REMBG_MODELS:
         logger.warning(f"⚠️ '{resolved}' not valid → birefnet-general-lite")
         resolved = 'birefnet-general-lite'
+
     if resolved != name:
         logger.info(f"🔁 Alias: {name} → {resolved}")
+
     try:
         import onnxruntime as ort
         so = ort.SessionOptions()
         so.intra_op_num_threads = 2
         so.inter_op_num_threads = 1
-        so.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
-        so.enable_cpu_mem_arena = True
+        # ⚠️ Memory: disable arena so RAM is released after inference
+        so.enable_cpu_mem_arena = False
+        so.enable_mem_pattern = False
+
+        # ⚠️ BirefNet atrous_conv crash under default optimization
+        if resolved in ORT_OPT_DISABLED_MODELS:
+            so.graph_optimization_level = ort.GraphOptimizationLevel.ORT_DISABLE_ALL
+            logger.info(f"⚠️ {resolved}: ORT graph opt DISABLED (known bug)")
+        else:
+            so.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+
         return new_session(resolved, sess_opts=so)
     except TypeError:
+        logger.info(f"⚠️ {resolved}: rembg doesn't accept sess_opts kwarg")
         return new_session(resolved)
     except Exception as e:
-        logger.warning(f"ORT tuning failed for {resolved}: {e}")
-        return new_session(resolved)
+        logger.warning(f"⚠️ ORT tuning failed for {resolved}: {e}")
+        try:
+            import onnxruntime as ort
+            so = ort.SessionOptions()
+            so.graph_optimization_level = ort.GraphOptimizationLevel.ORT_DISABLE_ALL
+            so.enable_cpu_mem_arena = False
+            return new_session(resolved, sess_opts=so)
+        except Exception:
+            return new_session(resolved)
 
 
 # ============================================================
-# NO-OP DETECTION + ALPHA STATS
+# ===== ALPHA STATS + NO-OP DETECTION =====
 # ============================================================
-def _alpha_stats(image):
-    """Return (min, max, mean, pct_transparent) of the alpha channel."""
+def _alpha_stats(image: Image.Image) -> Dict:
     try:
         arr = np.array(image.convert('RGBA'))
         a = arr[:, :, 3]
         return {
             'min': int(a.min()),
             'max': int(a.max()),
-            'mean': float(a.mean()),
-            'pct_transparent': float((a < 128).sum() / a.size * 100),
-            'pct_opaque': float((a > 250).sum() / a.size * 100),
+            'mean': round(float(a.mean()), 2),
+            'pct_transparent': round(float((a < 128).sum() / a.size * 100), 2),
+            'pct_opaque': round(float((a > 250).sum() / a.size * 100), 2),
         }
     except Exception:
         return {'min': 0, 'max': 255, 'mean': 255,
                 'pct_transparent': 0, 'pct_opaque': 100}
 
 
-def _is_noop(original, result):
-    """
-    A result is a no-op if the alpha channel is fully opaque AND
-    the RGB channels are essentially identical to the input.
-    Returns (bool, reason_str).
-    """
+def _is_noop(original: Image.Image, result: Image.Image) -> Tuple[bool, str]:
+    """Returns (is_noop, reason)."""
     try:
         orig = np.array(original.convert('RGBA'))
         res = np.array(result.convert('RGBA'))
@@ -532,7 +610,6 @@ def _is_noop(original, result):
             return False, 'shape-differs'
 
         res_alpha = res[:, :, 3]
-        # Fully opaque output → check if RGB changed
         if int(res_alpha.min()) > 250:
             rgb_diff = np.abs(
                 orig[:, :, :3].astype(np.int16) - res[:, :, :3].astype(np.int16)
@@ -545,137 +622,49 @@ def _is_noop(original, result):
         return False, f'check-failed:{e}'
 
 
-# ============================================================
-# PRE-WARM — MUST run after initialize_models()
-# ============================================================
-def _prewarm_models():
-    global remove_func
-    if remove_func is None:
-        logger.error("❌ Pre-warm skipped: remove_func is None")
-        return
-
-    logger.info("🔥 Pre-warming sessions with a real test image...")
-    test_img = Image.new('RGB', (128, 128), (255, 255, 255))
-    ImageDraw.Draw(test_img).rectangle([40, 40, 88, 88], fill=(220, 40, 40))
-
-    for name, _ in PRELOAD_MODELS:
-        session = model_manager.models.get(name)
-        if session is None:
-            logger.warning(f"  ⚠️ {name}: no session")
-            continue
-        try:
-            t0 = time.time()
-            result = remove_func(test_img, session=session, alpha_matting=False)
-            dt = time.time() - t0
-            if result.mode != 'RGBA':
-                result = result.convert('RGBA')
-            stats = _alpha_stats(result)
-            noop, reason = _is_noop(test_img, result)
-            if noop:
-                logger.warning(
-                    f"  ❌ {name} BROKEN — {reason} | stats={stats} | {dt:.2f}s"
-                )
-            else:
-                logger.info(
-                    f"  ✅ {name} OK — {reason} | "
-                    f"center_a={int(np.array(result)[64,64,3])} "
-                    f"corner_a={int(np.array(result)[5,5,3])} | {dt:.2f}s"
-                )
-        except Exception as e:
-            logger.warning(f"  ❌ {name} EXCEPTION: {type(e).__name__}: {e}")
-
-
-# ============================================================
-# BOOT
-# ============================================================
-logger.info("=" * 60)
-logger.info("🚀 Background Remover Pro v30.2.0")
-logger.info("=" * 60)
-
-# Phase 1: download weights + create sessions (remove_func not needed)
-logger.info(f"📥 Preloading {len(PRELOAD_MODELS)} hot models...")
-for name, size in PRELOAD_MODELS:
-    try:
-        session = model_manager.get_model(name, _load_session)
-        logger.info(f"  ✅ {name} weights ready ({size})" if session else f"  ⚠️ {name} failed")
-    except Exception as e:
-        logger.warning(f"  ⚠️ {name}: {e}")
-
-
-def initialize_models():
-    global AI_AVAILABLE, remove_func, default_model_name
-    with _model_loading_lock:
-        try:
-            from rembg import remove
-            remove_func = remove
-            loaded = model_manager.get_stats().get('loaded_models', [])
-
-            if DEFAULT_MODEL_NAME in loaded:
-                default_model_name = DEFAULT_MODEL_NAME
-            else:
-                for m in ('birefnet-general-lite', 'isnet-general-use', 'silueta', 'u2netp'):
-                    if m in loaded:
-                        default_model_name = m
-                        break
-                else:
-                    default_model_name = loaded[0] if loaded else 'u2netp'
-
-            AI_AVAILABLE = len(loaded) > 0
-            logger.info(f"✅ AI ready — {len(loaded)} models loaded")
-        except ImportError as e:
-            logger.error(f"Failed to import rembg: {e}")
-            AI_AVAILABLE = False
-        except Exception as e:
-            logger.error(f"AI setup failed: {e}")
-            AI_AVAILABLE = False
-
-
-# Phase 2: wire up remove_func
-initialize_models()
-
-# Phase 3: NOW the pre-warm actually works
-_prewarm_models()
-
-logger.info(f"📊 AI Available: {AI_AVAILABLE}")
-logger.info(f"🔧 Default: {default_model_name}")
-logger.info("=" * 60)
-
-
-# ============================================================
-# SESSION LOOKUP
-# ============================================================
-def get_session_for_model(model_name):
-    resolved = MODEL_ALIASES.get(model_name, model_name)
-    if resolved in model_manager.models:
-        model_manager.use_counts[resolved] = model_manager.use_counts.get(resolved, 0) + 1
-        return model_manager.models[resolved]
-    logger.info(f"🔄 Lazy-loading: {resolved}")
+def _has_meaningful_alpha(image: Image.Image) -> bool:
     try:
-        session = _load_session(resolved)
-        if session is None:
-            return None
-        model_manager.models[resolved] = session
-        model_manager.use_counts[resolved] = 1
-        model_manager.load_times[resolved] = 0.0
-        if len(model_manager.models) > model_manager.max_models:
-            model_manager._evict_models()
-        return session
-    except Exception as e:
-        logger.error(f"Lazy-load failed for {resolved}: {e}")
-        return None
+        if image.mode not in ('RGBA', 'LA', 'P'):
+            return False
+        if image.mode == 'P':
+            if 'transparency' not in image.info:
+                return False
+            image = image.convert('RGBA')
+        if image.mode == 'LA':
+            image = image.convert('RGBA')
+        arr = np.array(image)
+        if len(arr.shape) < 3 or arr.shape[2] < 4:
+            return False
+        a = arr[:, :, 3]
+        return (a < 200).sum() / a.size > 0.08
+    except Exception:
+        return False
 
 
 # ============================================================
-# NEURAL PROCESSOR — clean and explicit
+# ===== NEURAL PROCESSOR (with padding for BirefNet) =====
 # ============================================================
-def process_with_neural(image, session, model_name, force_no_matting=False):
+def process_with_neural(
+    image: Image.Image,
+    session,
+    model_name: str,
+    force_no_matting: bool = False,
+) -> Tuple[Optional[Image.Image], List[Dict]]:
     """
-    Returns (result_image, diagnostics).
-    Diagnostics = list of {attempt, result, elapsed, alpha_stats, reason}
+    Returns (result_image_or_None, diagnostics_list).
     """
     cfg = NEURAL_CONFIGS.get(model_name, {'fg': 240, 'bg': 10, 'erode': 10})
     use_matting = (model_name in MATTING_MODELS) and not force_no_matting
 
+    # Memory check
+    try:
+        mem = psutil.virtual_memory()
+        if mem.percent > 82:
+            logger.warning(f"⚠️ Memory {mem.percent}% — GC before {model_name}")
+            gc.collect()
+    except Exception:
+        pass
+
     attempts = []
     if use_matting:
         attempts.append(('with-matting', {
@@ -692,26 +681,51 @@ def process_with_neural(image, session, model_name, force_no_matting=False):
         t0 = time.time()
         try:
             logger.info(f"  🧪 {model_name} [{label}] starting")
-            result = remove_func(image, session=session, **kwargs)
+
+            # ⚠️ BirefNet: pad to multiples of 32 to avoid atrous_conv crash
+            img_for_inference = image
+            pad_info = None
+            if model_name in ORT_OPT_DISABLED_MODELS:
+                w, h = image.size
+                tw = ((w + 31) // 32) * 32
+                th = ((h + 31) // 32) * 32
+                if (tw, th) != (w, h):
+                    padded = Image.new('RGB', (tw, th), (255, 255, 255))
+                    padded.paste(image.convert('RGB'), (0, 0))
+                    img_for_inference = padded
+                    pad_info = (w, h)
+                    logger.info(f"  📐 {model_name} padded {w}x{h} → {tw}x{th}")
+
+            result = remove_func(img_for_inference, session=session, **kwargs)
             dt = time.time() - t0
 
             if result is None:
-                diagnostics.append({'attempt': label, 'result': 'None', 'elapsed': dt})
-                logger.warning(f"  ⚠️ {model_name} [{label}] returned None")
+                diagnostics.append({
+                    'attempt': label, 'result': 'None', 'elapsed': round(dt, 3),
+                })
                 continue
 
             if result.mode != 'RGBA':
                 result = result.convert('RGBA')
 
+            # Crop back if we padded
+            if pad_info:
+                ow, oh = pad_info
+                if result.size != (ow, oh):
+                    result = result.crop((0, 0, ow, oh))
+
             stats = _alpha_stats(result)
             noop, reason = _is_noop(image, result)
             diagnostics.append({
-                'attempt': label, 'result': 'noop' if noop else 'ok',
-                'elapsed': round(dt, 3), 'stats': stats, 'reason': reason,
+                'attempt': label,
+                'result': 'noop' if noop else 'ok',
+                'elapsed': round(dt, 3),
+                'stats': stats,
+                'reason': reason,
             })
 
             if noop:
-                logger.warning(f"  ⚠️ {model_name} [{label}] NOOP — {reason} | {stats}")
+                logger.warning(f"  ⚠️ {model_name} [{label}] NOOP — {reason}")
                 continue
 
             logger.info(f"  ✅ {model_name} [{label}] OK in {dt:.2f}s | {stats}")
@@ -719,11 +733,14 @@ def process_with_neural(image, session, model_name, force_no_matting=False):
 
         except Exception as e:
             dt = time.time() - t0
+            err_str = f"{type(e).__name__}: {str(e)[:200]}"
             diagnostics.append({
-                'attempt': label, 'result': 'exception',
-                'elapsed': round(dt, 3), 'error': f"{type(e).__name__}: {e}",
+                'attempt': label,
+                'result': 'exception',
+                'elapsed': round(dt, 3),
+                'error': err_str,
             })
-            logger.warning(f"  ⚠️ {model_name} [{label}] raised: {type(e).__name__}: {e}")
+            logger.warning(f"  ⚠️ {model_name} [{label}] raised: {err_str}")
 
     logger.error(f"  ❌ {model_name}: all attempts failed")
     return None, diagnostics
@@ -737,18 +754,19 @@ def _make_generic_processor(model_name):
 
 
 # ============================================================
-# CLASSICAL FALLBACK
+# ===== CLASSICAL FALLBACK =====
 # ============================================================
-def process_graphic_classical(image):
+def process_graphic_classical(image: Image.Image) -> Optional[Image.Image]:
+    logger.info("🎨 [PROCESS] Classical flood-fill")
     try:
         if image.mode != 'RGBA':
             image = image.convert('RGBA')
         np_img = np.array(image)
         h, w = np_img.shape[:2]
-        bg = _find_bg(np_img)
+        bg_colors = _find_bg(np_img)
         mask = np.ones((h, w), dtype=np.uint8) * 255
-        for c in bg:
-            _flood(np_img, mask, c, 30)
+        for c in bg_colors:
+            _flood(np_img, mask, c, tolerance=30)
         gray = cv2.cvtColor(np_img, cv2.COLOR_RGB2GRAY)
         edges = cv2.dilate(cv2.Canny(gray, 50, 150), np.ones((2, 2), np.uint8))
         mask[edges > 0] = 255
@@ -822,9 +840,163 @@ def get_model_specific_processor(model_name):
 
 
 # ============================================================
-# ROUTING
+# ===== AI MODEL BOOT =====
 # ============================================================
-def detect_hair_complexity(image):
+AI_AVAILABLE = False
+remove_func = None
+_model_loading_lock = threading.Lock()
+default_model_name = DEFAULT_MODEL_NAME
+
+PYMATTING_AVAILABLE = False
+try:
+    from pymatting import cutout, estimate_foreground_ml, estimate_alpha_cf
+    from pymatting.util.util import stack_images  # noqa
+    PYMATTING_AVAILABLE = True
+    logger.info("✅ pymatting available")
+except ImportError as e:
+    logger.warning(f"⚠️ pymatting not available: {e}")
+
+
+def pre_download_models():
+    logger.info(f"📥 Preloading {len(PRELOAD_MODELS)} hot models...")
+    for name, size in PRELOAD_MODELS:
+        try:
+            logger.info(f"  Downloading {name} ({size})...")
+            session = model_manager.get_model(name, _load_session)
+            if session is not None:
+                logger.info(f"  ✅ {name} ready")
+            else:
+                logger.warning(f"  ⚠️ {name} returned None")
+        except Exception as e:
+            logger.warning(f"  ⚠️ Could not preload {name}: {e}")
+
+    lazy_list = ", ".join(LAZY_MODELS.keys())
+    logger.info(f"✅ Preload complete. Lazy models: {lazy_list}")
+
+
+def initialize_models():
+    global AI_AVAILABLE, remove_func, default_model_name
+    with _model_loading_lock:
+        try:
+            from rembg import remove
+            remove_func = remove
+
+            loaded_names = model_manager.get_stats().get("loaded_models", [])
+            if DEFAULT_MODEL_NAME in loaded_names:
+                default_model_name = DEFAULT_MODEL_NAME
+            else:
+                for m in ('birefnet-general-lite', 'u2netp'):
+                    if m in loaded_names:
+                        default_model_name = m
+                        break
+                else:
+                    default_model_name = loaded_names[0] if loaded_names else 'u2netp'
+
+            AI_AVAILABLE = len(loaded_names) > 0
+            if AI_AVAILABLE:
+                logger.info(f"✅ AI ready with {len(loaded_names)} models")
+            else:
+                logger.error("❌ No models loaded")
+        except ImportError as e:
+            logger.error(f"Failed to import rembg: {e}")
+            AI_AVAILABLE = False
+        except Exception as e:
+            logger.error(f"AI setup failed: {e}")
+            AI_AVAILABLE = False
+
+
+def _prewarm_models():
+    """Runs AFTER initialize_models() so remove_func is set."""
+    global remove_func
+    if remove_func is None:
+        logger.error("❌ Pre-warm skipped: remove_func is None")
+        return
+
+    logger.info("🔥 Pre-warming sessions with test image...")
+    try:
+        test_img = Image.new('RGB', (64, 64), (255, 255, 255))
+        ImageDraw.Draw(test_img).rectangle([20, 20, 44, 44], fill=(220, 40, 40))
+
+        for name, _ in PRELOAD_MODELS:
+            session = model_manager.models.get(name)
+            if session is None:
+                logger.warning(f"  ⚠️ {name}: no session")
+                continue
+            try:
+                t0 = time.time()
+                result = remove_func(test_img, session=session, alpha_matting=False)
+                dt = time.time() - t0
+                if result.mode != 'RGBA':
+                    result = result.convert('RGBA')
+                arr = np.array(result)
+                cy, cx = arr.shape[0] // 2, arr.shape[1] // 2
+                center_a = int(arr[cy, cx, 3])
+                corner_a = int(arr[2, 2, 3])
+                if center_a > 200 and corner_a < 50:
+                    logger.info(
+                        f"  ✅ {name} OK — center={center_a} corner={corner_a} | {dt:.2f}s"
+                    )
+                else:
+                    logger.warning(
+                        f"  ⚠️ {name} produced WRONG output — "
+                        f"center={center_a} corner={corner_a}"
+                    )
+            except Exception as e:
+                logger.warning(f"  ❌ {name} warm-up failed: {type(e).__name__}: {e}")
+    except Exception as e:
+        logger.warning(f"Pre-warm skipped: {e}")
+
+
+# ========== BOOT SEQUENCE ==========
+logger.info("=" * 60)
+logger.info("🚀 Background Remover Pro v31.0.0")
+logger.info("=" * 60)
+
+# Phase 1: download weights (remove_func not needed yet)
+pre_download_models()
+
+# Phase 2: wire up remove_func
+initialize_models()
+
+# Phase 3: now pre-warm actually works
+_prewarm_models()
+
+logger.info(f"📊 AI Available: {AI_AVAILABLE}")
+logger.info(f"🔧 Default Model: {default_model_name}")
+logger.info("=" * 60)
+
+
+def get_session_for_model(model_name: str):
+    resolved = MODEL_ALIASES.get(model_name, model_name)
+
+    if resolved in model_manager.models:
+        model_manager.use_counts[resolved] = model_manager.use_counts.get(resolved, 0) + 1
+        return model_manager.models[resolved]
+
+    logger.info(f"🔄 Lazy-loading model: {resolved}")
+
+    try:
+        session = _load_session(resolved)
+        if session is None:
+            return None
+
+        model_manager.models[resolved] = session
+        model_manager.use_counts[resolved] = 1
+        model_manager.load_times[resolved] = 0.0
+
+        if len(model_manager.models) > model_manager.max_models:
+            model_manager._evict_models()
+
+        return session
+    except Exception as e:
+        logger.error(f"Lazy-load failed for {resolved}: {e}")
+        return None
+
+
+# ============================================================
+# ===== ROUTER =====
+# ============================================================
+def detect_hair_complexity(image: Image.Image) -> Dict:
     try:
         gray = image.convert('L').resize((100, 100), Image.Resampling.LANCZOS)
         np_img = np.array(gray, dtype=np.float32)
@@ -853,18 +1025,20 @@ def _skin_score(rgb):
     return skin / len(sample) if len(sample) else 0
 
 
-def analyze_image_complexity(image):
+def analyze_image_complexity(image: Image.Image) -> Dict:
     try:
         small = image.copy()
         small.thumbnail((10, 10), Image.Resampling.LANCZOS)
         gray = np.array(small.convert('L'))
         rgb = np.array(small.convert('RGB'))
+
         var = float(np.var(gray))
         gx = np.gradient(gray.astype(np.float32), axis=1)
         gy = np.gradient(gray.astype(np.float32), axis=0)
         em = np.sqrt(gx ** 2 + gy ** 2)
         edge = float(np.sum(em > 10) / 100)
         colors = len(np.unique(rgb.reshape(-1, 3), axis=0))
+
         is_graphic = colors < 15 and edge > 0.08
         is_human = _skin_score(rgb) > 0.1
         hc = detect_hair_complexity(image)
@@ -882,41 +1056,45 @@ def analyze_image_complexity(image):
         avail = model_manager.get_stats().get('loaded_models', [])
 
         def _route(proc, cat, strat, reason):
-            return {'processor': proc, 'model': proc, 'model_id': proc,
-                    'category': cat, 'strategy': strat, 'reason': reason,
-                    'score': complexity, 'is_human': is_human,
-                    'is_graphic': is_graphic, 'hair_complexity': hc,
-                    'cc_category': cc_cat, 'cc_confidence': 0.7}
+            return {
+                'processor': proc, 'model': proc, 'model_id': proc,
+                'category': cat, 'strategy': strat, 'reason': reason,
+                'score': complexity, 'is_human': is_human,
+                'is_graphic': is_graphic, 'hair_complexity': hc,
+                'cc_category': cc_cat, 'cc_confidence': 0.7,
+            }
 
         if is_graphic:
             return _route('flood_fill', 'simple_graphic', 'classical', 'simple graphic')
         if is_human and hc['route'] in ('wispy_hair', 'complex_hair'):
-            m = 'birefnet-general-lite' if 'birefnet-general-lite' in avail else 'u2net_human_seg'
+            m = 'birefnet-general-lite' if 'birefnet-general-lite' in avail else 'u2netp'
             return _route(m, 'human_hair', 'neural', f'human+{hc["route"]}')
         if is_human:
-            m = 'u2net_human_seg' if 'u2net_human_seg' in avail else 'isnet-general-use'
+            m = 'birefnet-general-lite' if 'birefnet-general-lite' in avail else 'u2netp'
             return _route(m, 'human', 'neural', 'human')
         if 25 <= complexity <= 55:
-            m = 'isnet-general-use' if 'isnet-general-use' in avail else 'u2netp'
+            m = 'birefnet-general-lite' if 'birefnet-general-lite' in avail else 'u2netp'
             return _route(m, 'medium', 'neural', 'medium')
         if complexity > 55:
-            m = 'birefnet-general-lite' if 'birefnet-general-lite' in avail else 'isnet-general-use'
+            m = 'birefnet-general-lite' if 'birefnet-general-lite' in avail else 'u2netp'
             return _route(m, 'complex', 'neural', 'complex')
-        return _route('birefnet-general-lite', 'fallback', 'neural', 'fallback')
+        return _route('u2netp', 'simple', 'neural', 'simple')
     except Exception as e:
         logger.warning(f"Router failed: {e}")
         avail = model_manager.get_stats().get('loaded_models', [])
         m = avail[0] if avail else 'u2netp'
-        return {'processor': m, 'model': m, 'model_id': m, 'category': 'error',
-                'strategy': 'neural', 'reason': f'router-error: {e}',
-                'score': 0, 'is_human': False, 'is_graphic': False,
-                'hair_complexity': {'route': 'simple_hair'}, 'cc_category': 'general_photo',
-                'cc_confidence': 0.5}
+        return {
+            'processor': m, 'model': m, 'model_id': m, 'category': 'error',
+            'strategy': 'neural', 'reason': f'router-error: {e}',
+            'score': 0, 'is_human': False, 'is_graphic': False,
+            'hair_complexity': {'route': 'simple_hair'},
+            'cc_category': 'general_photo', 'cc_confidence': 0.5,
+        }
 
 
 def get_default_model():
     loaded = model_manager.get_stats().get('loaded_models', [])
-    for m in ('birefnet-general-lite', 'isnet-general-use', 'silueta', 'u2netp'):
+    for m in ('birefnet-general-lite', 'u2netp'):
         if m in loaded:
             return m
     return loaded[0] if loaded else 'u2netp'
@@ -926,15 +1104,10 @@ def get_default_video_model():
     loaded = model_manager.get_stats().get('loaded_models', [])
     if 'u2netp' in loaded:
         return 'u2netp'
-    if 'silueta' in loaded:
-        return 'silueta'
     return loaded[0] if loaded else 'u2netp'
 
 
-# ============================================================
-# FRAGMENT CHECK + ALPHA PASSTHROUGH
-# ============================================================
-def detect_fragments(image):
+def detect_fragments(image: Image.Image) -> Dict:
     if image.mode != 'RGBA':
         return {'fragment_ratio': 0, 'quality_score': 100,
                 'has_fragments': False, 'issues': []}
@@ -961,33 +1134,20 @@ def detect_fragments(image):
             'has_fragments': fr > 0.01, 'issues': issues}
 
 
-def _has_meaningful_alpha(image):
-    try:
-        if image.mode not in ('RGBA', 'LA', 'P'):
-            return False
-        if image.mode == 'P':
-            if 'transparency' not in image.info:
-                return False
-            image = image.convert('RGBA')
-        if image.mode == 'LA':
-            image = image.convert('RGBA')
-        arr = np.array(image)
-        if len(arr.shape) < 3 or arr.shape[2] < 4:
-            return False
-        a = arr[:, :, 3]
-        return (a < 200).sum() / a.size > 0.08
-    except Exception:
-        return False
-
-
 # ============================================================
-# IMAGE PIPELINE
+# ===== IMAGE PIPELINE =====
 # ============================================================
 def process_image_sync(
-    image_data, model_name=None, transparent=True, max_size=2048,
-    quality=95, preserve_hair=True, use_alpha_matting=True,
-    border_pixels=20, sharpen=True,
-):
+    image_data: bytes,
+    model_name: str = None,
+    transparent: bool = True,
+    max_size: int = 2048,
+    quality: int = 95,
+    preserve_hair: bool = True,
+    use_alpha_matting: bool = True,
+    border_pixels: int = 20,
+    sharpen: bool = True,
+) -> Dict:
     req = str(uuid.uuid4())[:8]
     logger.info(f"[REQ {req}] === START ===")
 
@@ -996,7 +1156,7 @@ def process_image_sync(
         original_size = image.size
         logger.info(f"[REQ {req}] Input: {image.size} mode={image.mode} bytes={len(image_data)}")
 
-        # Fast path: image already transparent
+        # Fast path: alpha passthrough
         if _has_meaningful_alpha(image) and model_name is None:
             logger.info(f"[REQ {req}] Already has alpha — passthrough")
             if image.mode != 'RGBA':
@@ -1051,7 +1211,7 @@ def process_image_sync(
             image.thumbnail((target_res, target_res), Image.Resampling.LANCZOS)
             logger.info(f"[REQ {req}] Resized → {image.size}")
 
-        # Process
+        # Full fallback chain — try every model until one works
         diagnostics = []
         result = None
         session = None
@@ -1060,31 +1220,42 @@ def process_image_sync(
             result = process_graphic_classical(image)
             if result is not None:
                 logger.info(f"[REQ {req}] Classical: {selected}")
-        else:
-            session = get_session_for_model(selected)
-            if session is None:
-                logger.warning(f"[REQ {req}] No session for {selected}, trying u2netp")
-                session = get_session_for_model('u2netp')
-                selected = 'u2netp'
 
-            if session is not None:
-                result, diagnostics = process_with_neural(image, session, selected)
-
-                # If no-op, try u2netp as last resort
-                if result is None:
-                    logger.warning(f"[REQ {req}] {selected} failed, u2netp fallback")
-                    u2_sess = get_session_for_model('u2netp')
-                    if u2_sess is not None:
-                        result, u2_diag = process_with_neural(image, u2_sess, 'u2netp')
-                        diagnostics.extend([{'fallback': 'u2netp', **d} for d in u2_diag])
-                        if result is not None:
-                            selected = 'u2netp'
+        if result is None:
+            # Try the selected model first, then fallbacks
+            tried = set()
+            fallback_order = [selected, 'birefnet-general-lite', 'u2netp', 'silueta']
+
+            for candidate in fallback_order:
+                if candidate in tried or candidate in CLASSICAL_PROCESSORS:
+                    continue
+                tried.add(candidate)
+
+                cand_session = get_session_for_model(candidate)
+                if cand_session is None:
+                    logger.warning(f"[REQ {req}] No session for {candidate}")
+                    continue
+
+                logger.info(f"[REQ {req}] Trying {candidate}...")
+                cand_result, cand_diag = process_with_neural(image, cand_session, candidate)
+                diagnostics.extend([{'model_tried': candidate, **d} for d in cand_diag])
+
+                if cand_result is not None:
+                    result = cand_result
+                    session = cand_session
+                    selected = candidate
+                    logger.info(f"[REQ {req}] ✅ {candidate} succeeded")
+                    break
+                else:
+                    logger.warning(f"[REQ {req}] {candidate} failed, trying next")
 
         if result is None:
             logger.error(f"[REQ {req}] ALL MODELS FAILED")
+            for d in diagnostics:
+                logger.error(f"    {d}")
             raise HTTPException(
                 500,
-                f"All models failed for this image. Diagnostics: {json.dumps(diagnostics)[:300]}"
+                f"All models failed. First error: {json.dumps(diagnostics[:2])[:400]}"
             )
 
         # Hair refine
@@ -1096,6 +1267,7 @@ def process_image_sync(
                 q = mask_checker.check(alpha)
                 mask_quality = q
                 if not q['passed']:
+                    logger.info(f"[REQ {req}] Poor mask — HairRefiner")
                     refined = hair_refiner.refine(alpha)
                     arr = np.array(result.convert('RGBA'))
                     arr[:, :, 3] = refined
@@ -1161,29 +1333,51 @@ def process_image_sync(
         raise
 
 
+def cleanup_temp_files(*file_paths: str) -> None:
+    for path in file_paths:
+        if path and os.path.exists(path):
+            try:
+                if os.path.isdir(path):
+                    shutil.rmtree(path)
+                else:
+                    os.unlink(path)
+            except Exception as e:
+                logger.warning(f"Failed to cleanup {path}: {e}")
+
+
 # ============================================================
-# FASTAPI
+# ===== FASTAPI =====
 # ============================================================
-app = FastAPI(title="Background Remover Pro", version="30.2.0")
-app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True,
-                   allow_methods=["*"], allow_headers=["*"])
+app = FastAPI(title="Background Remover Pro", version="31.0.0")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
 rate_limits = defaultdict(list)
 RATE_LIMIT = 30
 
 
-def _get_client_ip(request):
-    xff = request.headers.get('x-forwarded-for')
-    if xff: return xff.split(',')[0].strip()
-    xri = request.headers.get('x-real-ip')
-    if xri: return xri.strip()
-    return request.client.host if request.client else 'unknown'
+def _get_client_ip(request: Request) -> str:
+    xff = request.headers.get("x-forwarded-for")
+    if xff:
+        return xff.split(",")[0].strip()
+    xri = request.headers.get("x-real-ip")
+    if xri:
+        return xri.strip()
+    return request.client.host if request.client else "unknown"
 
 
 @app.middleware("http")
-async def rate_limit_middleware(request, call_next):
-    if request.url.path in ('/api/health', '/', '/docs', '/redoc', '/openapi.json',
-                            '/api/debug/model-report'):
+async def rate_limit_middleware(request: Request, call_next):
+    if request.url.path in (
+        "/api/health", "/", "/docs", "/redoc", "/openapi.json",
+        "/api/debug/env", "/api/debug/model-report",
+    ):
         return await call_next(request)
     cid = _get_client_ip(request)
     now = datetime.now()
@@ -1194,7 +1388,7 @@ async def rate_limit_middleware(request, call_next):
     return await call_next(request)
 
 
-def timeout_handler(seconds=90):
+def timeout_handler(seconds: int = 90):
     def deco(func):
         @functools.wraps(func)
         async def wrap(*a, **kw):
@@ -1207,7 +1401,7 @@ def timeout_handler(seconds=90):
 
 
 # ============================================================
-# ENDPOINTS
+# ===== ENDPOINTS =====
 # ============================================================
 @app.post("/api/process/image")
 @timeout_handler(seconds=90)
@@ -1242,10 +1436,16 @@ async def process_image_api(
 
         loop = asyncio.get_event_loop()
         pf = functools.partial(
-            process_image_sync, image_data=contents, model_name=user_model,
-            transparent=transparent, max_size=max_size, quality=quality,
-            preserve_hair=preserve_hair, use_alpha_matting=use_alpha_matting,
-            border_pixels=border_pixels, sharpen=sharpen,
+            process_image_sync,
+            image_data=contents,
+            model_name=user_model,
+            transparent=transparent,
+            max_size=max_size,
+            quality=quality,
+            preserve_hair=preserve_hair,
+            use_alpha_matting=use_alpha_matting,
+            border_pixels=border_pixels,
+            sharpen=sharpen,
         )
         result_data = await loop.run_in_executor(cpu_executor, pf)
 
@@ -1270,7 +1470,8 @@ async def process_image_api(
         }
         return StreamingResponse(
             io.BytesIO(result_data['data']),
-            media_type=result_data['media_type'], headers=headers,
+            media_type=result_data['media_type'],
+            headers=headers,
         )
     except HTTPException:
         raise
@@ -1309,9 +1510,15 @@ async def process_image_png(
 
         loop = asyncio.get_event_loop()
         pf = functools.partial(
-            process_image_sync, image_data=contents, model_name=user_model,
-            transparent=True, max_size=2048, quality=95, preserve_hair=preserve_hair,
-            use_alpha_matting=use_alpha_matting, border_pixels=border_pixels,
+            process_image_sync,
+            image_data=contents,
+            model_name=user_model,
+            transparent=True,
+            max_size=2048,
+            quality=95,
+            preserve_hair=preserve_hair,
+            use_alpha_matting=use_alpha_matting,
+            border_pixels=border_pixels,
             sharpen=sharpen,
         )
         result_data = await loop.run_in_executor(cpu_executor, pf)
@@ -1327,12 +1534,12 @@ async def process_image_png(
             'X-Quality-Score': f"{result_data['quality_score']:.1f}",
             'X-Quality-Label': result_data.get('quality_label', ''),
             'X-Quality-Emoji': emoji,
-            'X-Fragment-Ratio': f"{result_data.get('fragment_ratio', 0):.3f}",
             'Content-Disposition': f"attachment; filename=processed_{fn}.png",
         }
         return StreamingResponse(
             io.BytesIO(result_data['data']),
-            media_type='image/png', headers=headers,
+            media_type='image/png',
+            headers=headers,
         )
     except HTTPException:
         raise
@@ -1442,7 +1649,7 @@ async def process_bulk_png(
 
 
 # ============================================================
-# VIDEO
+# ===== VIDEO =====
 # ============================================================
 MAX_VIDEO_DURATION = 30
 MAX_VIDEO_FRAMES = 240
@@ -1482,6 +1689,11 @@ async def process_video_api(
         session = get_session_for_model(model_name) or get_session_for_model('u2netp')
         if session is None:
             raise HTTPException(503, "No model")
+        if model_name not in model_manager.models:
+            model_name = 'u2netp'
+            session = get_session_for_model('u2netp')
+
+        logger.info(f"🎬 Video: model={model_name} max_size={max_size} skip={frame_skip}")
 
         inp = Path(file.filename).suffix or '.mp4'
         input_path = tempfile.mktemp(suffix=inp, dir='/tmp/uploads')
@@ -1493,7 +1705,19 @@ async def process_video_api(
 
         cap = cv2.VideoCapture(input_path)
         if not cap.isOpened():
-            raise HTTPException(400, "Cannot open video")
+            file_size = os.path.getsize(input_path)
+            logger.error(f"❌ Cannot open video: size={file_size}B mime={file.content_type}")
+            raise HTTPException(
+                400,
+                f"Cannot decode video (size={file_size}B). Try H.264 MP4."
+            )
+
+        # Verify readable
+        ok, test_frame = cap.read()
+        if not ok or test_frame is None:
+            cap.release()
+            raise HTTPException(400, "Video opened but no frames readable")
+        cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
 
         w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
         h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
@@ -1522,10 +1746,33 @@ async def process_video_api(
         if not frames:
             raise HTTPException(400, "No frames")
 
-        logger.info(f"🎬 Video: {len(frames)} frames at {nw}x{nh} with {model_name}")
+        logger.info(f"🎬 Processing {len(frames)} frames at {nw}x{nh} with {model_name}")
+
+        # Try codecs
+        if out_ext == 'mp4':
+            codecs = [('mp4v', 'MP4V'), ('avc1', 'H264')]
+        elif out_ext == 'webm':
+            codecs = [('VP80', 'VP8'), ('VP90', 'VP9')]
+        elif out_ext == 'avi':
+            codecs = [('XVID', 'XVID'), ('MJPG', 'MJPG')]
+        else:
+            codecs = [('mp4v', 'MP4V')]
+
+        out = None
+        for cc, cname in codecs:
+            try:
+                fourcc = cv2.VideoWriter_fourcc(*cc)
+                trial = cv2.VideoWriter(output_path, fourcc, tfps, (nw, nh))
+                if trial.isOpened():
+                    out = trial
+                    logger.info(f"✅ VideoWriter: {cname}")
+                    break
+                trial.release()
+            except Exception as e:
+                logger.warning(f"Codec {cname} failed: {e}")
 
-        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-        out = cv2.VideoWriter(output_path, fourcc, tfps, (nw, nh))
+        if out is None or not out.isOpened():
+            raise HTTPException(500, "No codec available")
 
         for i, frame in enumerate(frames):
             try:
@@ -1540,7 +1787,9 @@ async def process_video_api(
                 out.write(cv2.cvtColor(np.array(res), cv2.COLOR_RGBA2BGRA))
             except Exception as e:
                 logger.error(f"Frame {i}: {e}")
-                out.write(cv2.cvtColor(np.array(Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)).convert('RGBA')), cv2.COLOR_RGBA2BGRA))
+                fallback = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                fallback = cv2.cvtColor(fallback, cv2.COLOR_RGB2RGBA)
+                out.write(cv2.cvtColor(np.array(Image.fromarray(fallback)), cv2.COLOR_RGBA2BGRA))
 
             if (i + 1) % 10 == 0:
                 logger.info(f"  📸 {i+1}/{len(frames)}")
@@ -1560,7 +1809,7 @@ async def process_video_api(
             'X-Video-Frames': str(len(frames)),
             'Content-Disposition': f'attachment; filename=processed_{fn}.{out_ext}',
         }
-        logger.info(f"✅ Video done: {len(frames)} frames in {pt:.1f}s")
+        logger.info(f"✅ Video: {len(frames)} frames in {pt:.1f}s")
         return FileResponse(
             output_path, media_type=mt,
             filename=f'processed_{fn}.{out_ext}', headers=headers,
@@ -1589,8 +1838,10 @@ async def upload_video_chunk(
         os.makedirs(cd, exist_ok=True)
         with open(os.path.join(cd, f"chunk_{chunkIndex:04d}"), 'wb') as f:
             f.write(await chunk.read())
-        return JSONResponse({'status': 'ok', 'chunkId': chunkIndex,
-                             'sessionId': sid, 'totalChunks': totalChunks})
+        return JSONResponse({
+            'status': 'ok', 'chunkId': chunkIndex,
+            'sessionId': sid, 'totalChunks': totalChunks,
+        })
     except Exception as e:
         raise HTTPException(500, str(e))
 
@@ -1623,9 +1874,11 @@ async def assemble_video(
                 with open(cp, 'rb') as cf:
                     f.write(cf.read())
         background_tasks.add_task(cleanup_temp_files, cd)
-        return FileResponse(ap, media_type='video/mp4',
-                            filename=f'processed_{filename}',
-                            background=background_tasks.add_task(cleanup_temp_files, ap))
+        return FileResponse(
+            ap, media_type='video/mp4',
+            filename=f'processed_{filename}',
+            background=background_tasks.add_task(cleanup_temp_files, ap),
+        )
     except HTTPException:
         raise
     except Exception as e:
@@ -1633,11 +1886,34 @@ async def assemble_video(
 
 
 # ============================================================
-# DEBUG — model report
+# ===== DEBUG ENDPOINTS =====
 # ============================================================
+@app.get("/api/debug/env")
+async def debug_env():
+    """Memory + loaded models snapshot."""
+    m = psutil.virtual_memory()
+    return {
+        'total_mb': m.total // 1024 // 1024,
+        'available_mb': m.available // 1024 // 1024,
+        'used_mb': m.used // 1024 // 1024,
+        'percent_used': m.percent,
+        'models_loaded': list(model_manager.models.keys()),
+        'model_count': len(model_manager.models),
+        'remove_func_ready': remove_func is not None,
+        'ai_available': AI_AVAILABLE,
+        'default_model': default_model_name,
+        'preload_models': [n for n, _ in PRELOAD_MODELS],
+        'ort_opt_disabled': sorted(ORT_OPT_DISABLED_MODELS),
+        'matting_models': sorted(MATTING_MODELS),
+    }
+
+
 @app.get("/api/debug/model-report")
 async def model_report():
-    """Runs every model on a synthetic test image and reports alpha stats."""
+    """Test every model on a synthetic image."""
+    if remove_func is None:
+        return JSONResponse({'error': 'remove_func not ready'}, status_code=503)
+
     test_img = Image.new('RGB', (128, 128), (255, 255, 255))
     ImageDraw.Draw(test_img).rectangle([40, 40, 88, 88], fill=(220, 40, 40))
 
@@ -1666,12 +1942,13 @@ async def model_report():
                     'corner_alpha': int(arr[5, 5, 3]),
                 }
                 noop, reason = _is_noop(test_img, result)
+                verdict = 'OK' if (stats['center_alpha'] > 200 and stats['corner_alpha'] < 50) else 'BROKEN'
                 entry.update({
                     'elapsed_s': round(dt, 3),
                     'stats': stats,
                     'is_noop': noop,
                     'reason': reason,
-                    'verdict': 'OK' if (stats['center_alpha'] > 200 and stats['corner_alpha'] < 50) else 'BROKEN',
+                    'verdict': verdict,
                 })
             except Exception as e:
                 entry['error'] = f'{type(e).__name__}: {str(e)[:200]}'
@@ -1681,7 +1958,7 @@ async def model_report():
 
     return JSONResponse({
         'generated_at': datetime.now().isoformat(),
-        'test_image': '128x128 white with red square at 40,40-88,88',
+        'test_image': '128x128 white with red square',
         'expected': 'center_alpha > 200, corner_alpha < 50',
         'models': report,
         'summary': {
@@ -1694,14 +1971,15 @@ async def model_report():
 
 
 # ============================================================
-# HEALTH
+# ===== HEALTH =====
 # ============================================================
 @app.get("/")
 async def home():
     stats = model_manager.get_stats()
+    mem = psutil.virtual_memory()
     return HTMLResponse(f"""
     <!DOCTYPE html><html><head><meta charset="UTF-8">
-    <title>Background Remover Pro v30.2.0</title>
+    <title>Background Remover Pro v31.0.0</title>
     <style>body{{font-family:system-ui;background:linear-gradient(135deg,#667eea,#764ba2);
     color:#fff;min-height:100vh;display:flex;align-items:center;justify-content:center;
     margin:0;padding:20px}}.c{{max-width:900px;background:rgba(255,255,255,.1);
@@ -1709,9 +1987,9 @@ async def home():
     box-shadow:0 20px 60px rgba(0,0,0,.3)}}.s{{padding:15px;border-radius:12px;
     margin:20px 0;background:rgba(126,217,87,.2)}}a{{color:#a78bfa}}</style>
     </head><body><div class="c">
-    <h1>Background Remover Pro v30.2.0</h1>
-    <div class="s">AI Online · {len(stats['loaded_models'])} models</div>
-    <p><a href="/docs">API Docs</a> · <a href="/api/debug/model-report">Model Report</a></p>
+    <h1>Background Remover Pro v31.0.0</h1>
+    <div class="s">AI Online · {len(stats['loaded_models'])} models · RAM {mem.percent:.0f}%</div>
+    <p><a href="/docs">API Docs</a> · <a href="/api/debug/model-report">Model Report</a> · <a href="/api/debug/env">Env</a></p>
     </div></body></html>
     """)
 
@@ -1719,45 +1997,56 @@ async def home():
 @app.get("/api/health")
 async def health_check():
     stats = model_manager.get_stats()
+    mem = psutil.virtual_memory()
     return {
         'status': 'healthy' if AI_AVAILABLE else 'degraded',
         'ai_available': AI_AVAILABLE,
         'models_loaded': stats['loaded_models'],
         'models_count': stats['model_count'],
+        'memory_percent': mem.percent,
+        'memory_available_mb': mem.available // 1024 // 1024,
         'pymatting_available': PYMATTING_AVAILABLE,
         'video_formats': ['mp4', 'avi', 'webm', 'mov'],
         'image_formats': ['png', 'jpg', 'jpeg', 'webp', 'bmp'],
         'bulk_limit': 20,
-        'version': '30.2.0',
+        'version': '31.0.0',
         'default_model': get_default_model(),
         'default_video_model': get_default_video_model(),
         'preload_models': [n for n, _ in PRELOAD_MODELS],
         'lazy_models': sorted(LAZY_MODELS.keys()),
-        'valid_models': sorted(VALID_REMBG_MODELS),
         'matting_models': sorted(MATTING_MODELS),
-        'aliases': MODEL_ALIASES,
+        'ort_opt_disabled': sorted(ORT_OPT_DISABLED_MODELS),
     }
 
 
 @app.exception_handler(HTTPException)
 async def http_exc(request, exc):
-    return JSONResponse(status_code=exc.status_code,
-                        content={'error': exc.detail, 'status_code': exc.status_code})
+    return JSONResponse(
+        status_code=exc.status_code,
+        content={'error': exc.detail, 'status_code': exc.status_code}
+    )
 
 
 @app.exception_handler(Exception)
 async def gen_exc(request, exc):
     logger.error(f"Unhandled: {exc}")
-    return JSONResponse(status_code=500,
-                        content={'error': 'Internal error', 'detail': str(exc)[:200]})
+    return JSONResponse(
+        status_code=500,
+        content={'error': 'Internal error', 'detail': str(exc)[:200]}
+    )
 
 
 @app.on_event("startup")
 async def startup():
+    stats = model_manager.get_stats()
+    mem = psutil.virtual_memory()
     logger.info("=" * 60)
-    logger.info("🚀 v30.2.0 ready")
+    logger.info("🚀 v31.0.0 ready")
     logger.info(f"📊 AI: {AI_AVAILABLE}")
-    logger.info(f"🤖 Models: {model_manager.get_stats()['loaded_models']}")
+    logger.info(f"🤖 Models: {stats['loaded_models']}")
+    logger.info(f"💾 RAM: {mem.used//1024//1024}MB / {mem.total//1024//1024}MB ({mem.percent}%)")
+    logger.info(f"🎨 Matting: {sorted(MATTING_MODELS)}")
+    logger.info(f"⚠️ ORT opt disabled: {sorted(ORT_OPT_DISABLED_MODELS)}")
     logger.info("=" * 60)
 
 
@@ -1774,6 +2063,11 @@ async def shutdown():
 
 if __name__ == '__main__':
     import uvicorn
-    uvicorn.run('app:app', host='0.0.0.0',
-                port=int(os.environ.get('PORT', 7860)),
-                timeout_keep_alive=300, log_level='info', reload=False)
+    uvicorn.run(
+        'app:app',
+        host='0.0.0.0',
+        port=int(os.environ.get('PORT', 7860)),
+        timeout_keep_alive=300,
+        log_level='info',
+        reload=False,
+    )