Update app.py

app.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
-# app.py - Background Remover Pro v31.4.1
-# Free-tier tuned. Frame-batch video pipeline. 2 concurrent image users + 1 video user.
+# app.py - Background Remover v32.0.0
+# Tuned for Hugging Face free tier + Vercel frontend.
 
 import io
 import time
@@ -15,27 +15,21 @@ import gc
 import shutil
 import zipfile
 import json
-import hashlib
 import resource
 import uuid
 import base64
 import urllib.parse
-import subprocess
 from collections import defaultdict, Counter, deque
 from datetime import datetime
 from pathlib import Path
-from typing import Dict, Optional, List, Tuple, Any
+from typing import Dict, Optional, List, Any
 from concurrent.futures import ThreadPoolExecutor
 
 import psutil
 
 # ============================================================
-# ONNX RUNTIME MONKEYPATCH — arena ON, threads limited
+# ONNX RUNTIME — arena ON, threads limited
 # ============================================================
-# We previously had enable_cpu_mem_arena=False which caused every
-# intermediate tensor to allocate fresh. silueta's int8-quantized
-# Conv nodes need ~118MB per tensor and this caused OOM storms.
-# Arena ON lets ORT reuse buffers between inferences.
 try:
     import onnxruntime as _ort
     _orig_session_init = _ort.InferenceSession.__init__
@@ -46,8 +40,8 @@ try:
                 so = _ort.SessionOptions()
                 so.intra_op_num_threads = 2
                 so.inter_op_num_threads = 1
-                so.enable_cpu_mem_arena = True      # ⬅ FIXED: was False
-                so.enable_mem_pattern = True        # ⬅ FIXED: was False
+                so.enable_cpu_mem_arena = True
+                so.enable_mem_pattern = True
                 so.graph_optimization_level = _ort.GraphOptimizationLevel.ORT_ENABLE_ALL
                 kwargs['sess_options'] = so
             except Exception:
@@ -55,13 +49,13 @@ try:
         return _orig_session_init(self, *args, **kwargs)
 
     _ort.InferenceSession.__init__ = _patched_session_init
-    print("✅ ONNX Runtime patched: arena=ON, mem_pattern=ON, threads=2/1")
+    print("ONNX Runtime patched: arena=ON, threads=2/1")
 except Exception as e:
-    print(f"⚠️ Could not patch ONNX Runtime: {e}")
+    print(f"Could not patch ONNX Runtime: {e}")
 
 import numpy as np
-from fastapi import FastAPI, File, UploadFile, HTTPException, Query, BackgroundTasks, Form, Request
-from fastapi.responses import StreamingResponse, JSONResponse, FileResponse, HTMLResponse
+from fastapi import FastAPI, File, UploadFile, HTTPException, Query, Form, Request
+from fastapi.responses import StreamingResponse, JSONResponse, HTMLResponse
 from fastapi.middleware.cors import CORSMiddleware
 from PIL import Image, ImageDraw
 import cv2
@@ -79,7 +73,7 @@ logger = logging.getLogger(__name__)
 
 
 # ============================================================
-# MANAGER CLASSES
+# MEMORY + ENV
 # ============================================================
 class ResolutionManager:
     RECOMMENDED = {
@@ -141,7 +135,7 @@ def get_container_memory() -> Dict:
 
 
 class ModelManager:
-    def __init__(self, max_models: int = 4, memory_limit_mb: int = 10000):
+    def __init__(self, max_models: int = 3, memory_limit_mb: int = 8000):
         self.models: Dict[str, Any] = {}
         self.load_times: Dict[str, float] = {}
         self.use_counts: Dict[str, int] = {}
@@ -155,7 +149,7 @@ class ModelManager:
         try:
             mem = get_container_memory()
             if 'cgroup' in mem.get('source', '') and mem['percent'] > 82:
-                logger.warning(f"⚠️ Container RAM {mem['percent']:.1f}% — evicting")
+                logger.warning(f"Container RAM {mem['percent']:.1f}% — evicting")
                 self._evict_models()
                 gc.collect()
         except Exception:
@@ -171,7 +165,7 @@ class ModelManager:
             gc.collect()
             try:
                 mem = get_container_memory()
-                logger.info(f"  📊 After {name}: {mem['used_mb']}MB "
+                logger.info(f"After {name}: {mem['used_mb']}MB "
                             f"({mem['percent']:.1f}% of {mem['total_mb']}MB)")
             except Exception:
                 pass
@@ -187,7 +181,7 @@ class ModelManager:
         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: {to_remove}")
         del self.models[to_remove]
         self.use_counts.pop(to_remove, None)
         gc.collect()
@@ -421,16 +415,13 @@ class ContentClassifier:
         return 'complex'
 
 
-# ============================================================
-# MEMORY + ENV
-# ============================================================
 def limit_memory():
     try:
         soft, hard = resource.getrlimit(resource.RLIMIT_AS)
         resource.setrlimit(resource.RLIMIT_AS, (12 * 1024 * 1024 * 1024, hard))
-        logger.info("✅ Memory limit set to 12GB")
+        logger.info("Memory limit set to 12GB")
     except Exception as e:
-        logger.warning(f"⚠️ Could not set memory limit: {e}")
+        logger.warning(f"Could not set memory limit: {e}")
 
 
 limit_memory()
@@ -448,12 +439,9 @@ for d in ["/tmp/u2net_models", "/tmp/uploads", "/tmp/outputs", "/tmp/frames"]:
 cpu_executor = ThreadPoolExecutor(max_workers=2)
 
 
-# ============================================================
-# SINGLETONS
-# ============================================================
 content_classifier = ContentClassifier()
 resolution_manager = ResolutionManager()
-model_manager = ModelManager(max_models=4, memory_limit_mb=10000)
+model_manager = ModelManager(max_models=3, memory_limit_mb=8000)
 mask_checker = MaskQualityChecker()
 hair_refiner = HairRefiner()
 graphic_processor = GraphicProcessor()
@@ -462,13 +450,14 @@ graphic_processor = GraphicProcessor()
 # ============================================================
 # MODEL CONFIG
 # ============================================================
+# Only preload the two most useful models. isnet lazy-loads.
 PRELOAD_MODELS = [
     ("u2netp",                "~4.7 MB disk / ~180 MB RAM"),
-    ("isnet-general-use",     "~176 MB disk / ~800 MB RAM"),
     ("birefnet-general-lite", "~12 MB disk / ~250 MB RAM"),
 ]
 
 LAZY_MODELS = {
+    "isnet-general-use": "~176 MB disk / ~800 MB RAM",
     "silueta":           "~43 MB disk / ~200 MB RAM",
     "u2net":             "~176 MB disk / ~800 MB RAM",
     "u2net_human_seg":   "~176 MB disk / ~800 MB RAM",
@@ -528,11 +517,6 @@ MODEL_RES_CAPS = {
 
 CLASSICAL_PROCESSORS = {'flood_fill', 'graphic_classical'}
 DEFAULT_MODEL_NAME = 'isnet-general-use'
-
-# ⬅ ADDED: default model for the video frame-batch path.
-# silueta was causing OOM storms on free-tier HF and silently
-# returning transparent frames. birefnet-general-lite is stable
-# and pre-loaded.
 DEFAULT_VIDEO_MODEL = 'birefnet-general-lite'
 
 DISPLAY_NAMES = {
@@ -543,7 +527,7 @@ DISPLAY_NAMES = {
     'u2net_human_seg': 'U2-Net Human',
     'u2net_cloth_seg': 'U2-Net Cloth',
     'silueta': 'Silueta',
-    'isnet-general-use': 'InSPyReNet (ISNet)',
+    'isnet-general-use': 'ISNet',
     'isnet-anime': 'ISNet Anime',
     'birefnet-general': 'BiRefNet',
     'birefnet-general-lite': 'BiRefNet Lite',
@@ -551,18 +535,15 @@ DISPLAY_NAMES = {
 }
 
 
-# ============================================================
-# SESSION LOADER
-# ============================================================
 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 → isnet-general-use")
+        logger.warning(f"'{resolved}' not valid -> isnet-general-use")
         resolved = 'isnet-general-use'
     if resolved != name:
-        logger.info(f"🔁 Alias: {name} → {resolved}")
-    logger.info(f"📥 Loading {resolved}...")
+        logger.info(f"Alias: {name} -> {resolved}")
+    logger.info(f"Loading {resolved}...")
     return new_session(resolved)
 
 
@@ -683,9 +664,6 @@ def process_with_neural(image, session, model_name, force_no_matting=False):
     return None, diagnostics
 
 
-# ============================================================
-# CLASSICAL FALLBACK
-# ============================================================
 def process_graphic_classical(image):
     try:
         if image.mode != 'RGBA':
@@ -757,24 +735,24 @@ 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
+    from pymatting.util.util import stack_images
     PYMATTING_AVAILABLE = True
-    logger.info("✅ pymatting available")
+    logger.info("pymatting available")
 except ImportError as e:
-    logger.warning(f"⚠️ pymatting not available: {e}")
+    logger.warning(f"pymatting not available: {e}")
 
 
 def pre_download_models():
-    logger.info(f"📥 Preloading {len(PRELOAD_MODELS)} hot 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")
+                logger.info(f"  {name} ready")
         except Exception as e:
-            logger.warning(f"  ⚠️ {name}: {e}")
-    logger.info(f"✅ Preload complete")
+            logger.warning(f"  {name}: {e}")
+    logger.info("Preload complete")
 
 
 def initialize_models():
@@ -795,7 +773,7 @@ def initialize_models():
                     default_model_name = loaded[0] if loaded else 'u2netp'
             AI_AVAILABLE = len(loaded) > 0
             if AI_AVAILABLE:
-                logger.info(f"✅ AI ready with {len(loaded)} models")
+                logger.info(f"AI ready with {len(loaded)} models")
         except Exception as e:
             logger.error(f"AI setup failed: {e}")
             AI_AVAILABLE = False
@@ -805,7 +783,7 @@ def _prewarm_models():
     global remove_func
     if remove_func is None:
         return
-    logger.info("🔥 Pre-warming sessions...")
+    logger.info("Pre-warming sessions...")
     try:
         test_img = Image.new('RGB', (64, 64), (255, 255, 255))
         ImageDraw.Draw(test_img).rectangle([20, 20, 44, 44], fill=(220, 40, 40))
@@ -815,36 +793,33 @@ def _prewarm_models():
                 continue
             try:
                 t0 = time.time()
-                remove_func(test_img, session=session, alpha_matting=False)
-                t1 = time.time()
                 result = remove_func(test_img, session=session, alpha_matting=False)
-                t2 = time.time()
+                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
                 ca = int(arr[cy, cx, 3]); corner = int(arr[2, 2, 3])
                 if ca > 200 and corner < 50:
-                    logger.info(f"  ✅ {name} OK — center={ca} corner={corner} | "
-                                f"first={t1-t0:.2f}s warm={t2-t1:.2f}s")
+                    logger.info(f"  {name} OK ({dt:.2f}s)")
                 else:
-                    logger.warning(f"  ⚠️ {name} WRONG — center={ca} corner={corner}")
+                    logger.warning(f"  {name} WRONG (center={ca} corner={corner})")
             except Exception as e:
-                logger.warning(f"  ❌ {name}: {type(e).__name__}: {e}")
+                logger.warning(f"  {name}: {type(e).__name__}: {e}")
     except Exception as e:
         logger.warning(f"Pre-warm skipped: {e}")
 
 
 logger.info("=" * 60)
-logger.info("🚀 Background Remover Pro v31.4.1")
+logger.info("Background Remover v32.0.0")
 logger.info("=" * 60)
 pre_download_models()
 initialize_models()
 _prewarm_models()
 mem = get_container_memory()
-logger.info(f"📊 AI: {AI_AVAILABLE} | Default: {default_model_name}")
-logger.info(f"💾 RAM: {mem['used_mb']}MB / {mem['total_mb']}MB ({mem['percent']:.1f}%)")
-logger.info(f"🎬 Video default: {DEFAULT_VIDEO_MODEL}")
+logger.info(f"AI: {AI_AVAILABLE} | Default: {default_model_name}")
+logger.info(f"RAM: {mem['used_mb']}MB / {mem['total_mb']}MB ({mem['percent']:.1f}%)")
+logger.info(f"Video default: {DEFAULT_VIDEO_MODEL}")
 logger.info("=" * 60)
 
 
@@ -869,9 +844,14 @@ def get_session_for_model(model_name):
 
 
 # ============================================================
-# ROUTER (image pipeline)
+# ROUTER
 # ============================================================
 def detect_hair_complexity(image):
+    """
+    FIXED: Previous thresholds fired 'wispy_hair' on almost every image.
+    Now requires both a high composite score AND a high fine/coarse ratio.
+    Typical photos land in 'simple_hair' or 'complex_hair'.
+    """
     try:
         gray = image.convert('L').resize((100, 100), Image.Resampling.LANCZOS)
         np_img = np.array(gray, dtype=np.float32)
@@ -880,10 +860,12 @@ def detect_hair_complexity(image):
         fine = np.sum(em > 10) / 10000
         coarse = np.sum(em > 40) / 10000
         fr = fine / (coarse + 0.001)
-        score = min(100, fr * 30 + np.var(np_img) / 5000 * 30)
-        if score > 40 and fr > 0.5:
+        # Reduced multipliers so the score is not inflated by luminance variance.
+        score = min(100, fr * 15 + np.var(np_img) / 8000 * 20)
+
+        if score > 65 and fr > 0.80:
             return {'complexity_score': score, 'route': 'wispy_hair'}
-        if score > 25:
+        if score > 45 and fr > 0.55:
             return {'complexity_score': score, 'route': 'complex_hair'}
         return {'complexity_score': score, 'route': 'simple_hair'}
     except Exception:
@@ -1000,7 +982,7 @@ def detect_fragments(image):
 # IMAGE PIPELINE
 # ============================================================
 def process_image_sync(image_data, model_name=None, transparent=True,
-                       max_size=2048, quality=95, preserve_hair=True,
+                       max_size=1024, quality=95, preserve_hair=True,
                        use_alpha_matting=True, border_pixels=20, sharpen=True):
     req = str(uuid.uuid4())[:8]
     logger.info(f"[REQ {req}] === START ===")
@@ -1026,7 +1008,7 @@ def process_image_sync(image_data, model_name=None, transparent=True,
                     'media_type': mt, 'extension': ext,
                     'original_size': original_size, 'processed_size': image.size,
                     'fragment_ratio': 0.0, 'quality_score': 100.0,
-                    'quality_label': 'Skipped', 'quality_emoji': '⚡',
+                    'quality_label': 'Skipped', 'quality_emoji': '',
                     'has_fragments': False, 'issues': [],
                     'needs_reprocess': False, 'router_enabled': False,
                     'router_score': 0.0, 'router_reason': 'already transparent',
@@ -1102,10 +1084,10 @@ def process_image_sync(image_data, model_name=None, transparent=True,
             frag = detect_fragments(result)
 
         qs = frag['quality_score']
-        if qs >= 90: ql, qe = 'Excellent', '✨'
-        elif qs >= 75: ql, qe = 'Good', '👍'
-        elif qs >= 50: ql, qe = 'Fair', '⚠️'
-        else: ql, qe = 'Poor', '❌'
+        if qs >= 90: ql = 'Excellent'
+        elif qs >= 75: ql = 'Good'
+        elif qs >= 50: ql = 'Fair'
+        else: ql = 'Poor'
 
         buf = io.BytesIO()
         if transparent:
@@ -1124,7 +1106,7 @@ def process_image_sync(image_data, model_name=None, transparent=True,
                 'original_size': original_size, 'processed_size': result.size,
                 'fragment_ratio': frag['fragment_ratio'],
                 'quality_score': frag['quality_score'],
-                'quality_label': ql, 'quality_emoji': qe,
+                'quality_label': ql, 'quality_emoji': '',
                 'has_fragments': frag['has_fragments'], 'issues': frag['issues'],
                 'needs_reprocess': frag['has_fragments'],
                 'router_enabled': router_enabled,
@@ -1143,22 +1125,10 @@ def process_image_sync(image_data, model_name=None, transparent=True,
         raise
 
 
-def cleanup_temp_files(*file_paths):
-    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"Cleanup failed for {path}: {e}")
-
-
 # ============================================================
 # FASTAPI
 # ============================================================
-app = FastAPI(title="Background Remover Pro", version="31.4.1")
+app = FastAPI(title="Background Remover", version="32.0.0")
 app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True,
                    allow_methods=["*"], allow_headers=["*"])
 
@@ -1177,7 +1147,7 @@ def _get_client_ip(request):
 @app.middleware("http")
 async def rate_limit_middleware(request, call_next):
     if request.url.path in ("/api/health", "/", "/docs", "/redoc", "/openapi.json",
-                            "/api/debug/env", "/api/debug/model-report"):
+                            "/api/warmup", "/api/debug/env", "/api/debug/model-report"):
         return await call_next(request)
     cid = _get_client_ip(request)
     now = datetime.now()
@@ -1200,16 +1170,13 @@ def timeout_handler(seconds=90):
     return deco
 
 
-# ============================================================
-# IMAGE ENDPOINTS
-# ============================================================
 @app.post("/api/process/image")
 @timeout_handler(seconds=90)
 async def process_image_api(
     file: UploadFile = File(...),
     model: str = Query(None),
     transparent: bool = Query(True),
-    max_size: int = Query(2048, ge=512, le=4096),
+    max_size: int = Query(1024, ge=512, le=2048),
     quality: int = Query(95, ge=70, le=100),
     preserve_hair: bool = Query(True),
     use_alpha_matting: bool = Query(True),
@@ -1242,7 +1209,6 @@ async def process_image_api(
 
         pt = time.time() - t0
         fn = Path(file.filename).stem
-        emoji = urllib.parse.quote(result_data.get('quality_emoji', ''), safe='')
         headers = {
             'X-Processing-Time': f'{pt:.3f}',
             'X-Model-Used': result_data['model'],
@@ -1250,7 +1216,6 @@ async def process_image_api(
             'X-Transparent': str(result_data['transparent']).lower(),
             '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}",
             'X-Needs-Reprocess': str(result_data.get('needs_reprocess', False)).lower(),
             'X-Router-Enabled': str(result_data.get('router_enabled', False)).lower(),
@@ -1269,59 +1234,6 @@ async def process_image_api(
         raise HTTPException(500, f"Processing failed: {str(e)[:200]}")
 
 
-@app.post("/api/process/image-png")
-@timeout_handler(seconds=90)
-async def process_image_png(
-    file: UploadFile = File(...),
-    model: str = Query(None),
-    preserve_hair: bool = Query(True),
-    use_alpha_matting: bool = Query(True),
-    border_pixels: int = Query(20, ge=5, le=50),
-    sharpen: bool = Query(True),
-):
-    t0 = time.time()
-    try:
-        if not file.content_type or not file.content_type.startswith('image/'):
-            raise HTTPException(400, "Not an image")
-        contents = await file.read()
-        if not contents: raise HTTPException(400, "Empty")
-        if len(contents) > 30 * 1024 * 1024: raise HTTPException(400, "Too large")
-        if not AI_AVAILABLE: raise HTTPException(503, "AI unavailable")
-        user_model = None
-        if model:
-            resolved = MODEL_ALIASES.get(model, model)
-            if resolved in VALID_REMBG_MODELS or resolved in CLASSICAL_PROCESSORS:
-                user_model = resolved
-        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, sharpen=sharpen)
-        result_data = await loop.run_in_executor(cpu_executor, pf)
-        pt = time.time() - t0
-        fn = Path(file.filename).stem
-        emoji = urllib.parse.quote(result_data.get('quality_emoji', ''), safe='')
-        headers = {
-            'X-Processing-Time': f'{pt:.3f}',
-            'X-Model-Used': result_data['model'],
-            'X-Model-Id': result_data['model_id'],
-            'X-Transparent': 'true',
-            'X-Quality-Score': f"{result_data['quality_score']:.1f}",
-            'X-Quality-Label': result_data.get('quality_label', ''),
-            'X-Quality-Emoji': emoji,
-            'Content-Disposition': f"attachment; filename=processed_{fn}.png",
-        }
-        return StreamingResponse(io.BytesIO(result_data['data']),
-                                 media_type='image/png', headers=headers)
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"PNG error: {e}")
-        raise HTTPException(500, str(e)[:200])
-
-
 @app.post("/api/process/bulk")
 @timeout_handler(seconds=300)
 async def process_bulk_images(
@@ -1391,38 +1303,19 @@ async def process_bulk_images(
         raise HTTPException(500, str(e)[:200])
 
 
-@app.post("/api/process/bulk-png")
-@timeout_handler(seconds=300)
-async def process_bulk_png(
-    files: List[UploadFile] = File(...),
-    model: str = Query(None),
-    preserve_hair: bool = Query(True),
-    use_alpha_matting: bool = Query(True),
-    border_pixels: int = Query(20, ge=5, le=50),
-    sharpen: bool = Query(True),
-):
-    return await process_bulk_images(files=files, model=model, transparent=True,
-                                     max_size=2048, preserve_hair=preserve_hair,
-                                     use_alpha_matting=use_alpha_matting,
-                                     border_pixels=border_pixels, sharpen=sharpen)
-
-
 # ============================================================
-# FRAME-BATCH ENDPOINT — client-side video pipeline
+# FRAME-BATCH ENDPOINT
 # ============================================================
-# Key fixes over v31.4.0:
-#   1. Default model changed to birefnet-general-lite (silueta was
-#      OOMing on free-tier HF and producing blank frames).
-#   2. Detects fully-transparent AND fully-opaque frames (silent
-#      failures) and falls through a model chain instead of shipping
-#      garbage to the client.
-#   3. Returns the actual model used per batch.
 @app.post("/api/process/frames-batch")
 async def process_frames_batch(
     files: List[UploadFile] = File(...),
     model: str = Query(DEFAULT_VIDEO_MODEL),
     transparent: bool = Query(True),
 ):
+    # HARD CAP to prevent OOM on free tier.
+    if len(files) > 4:
+        raise HTTPException(400, "Max 4 frames per batch")
+
     resolved = MODEL_ALIASES.get(model, model)
     if resolved not in VALID_REMBG_MODELS:
         resolved = DEFAULT_VIDEO_MODEL
@@ -1431,8 +1324,6 @@ async def process_frames_batch(
     if session is None:
         raise HTTPException(503, f"No session for {resolved}")
 
-    # Chain of models to try in order. First is user-selected, then
-    # stable fallbacks.
     fallback_chain = [resolved]
     for candidate in ('birefnet-general-lite', 'isnet-general-use', 'u2netp'):
         if candidate not in fallback_chain:
@@ -1468,20 +1359,13 @@ async def process_frames_batch(
                 min_a = int(alpha.min())
                 max_a = int(alpha.max())
 
-                # Reject fully-transparent (silent fail)
                 if max_a < 10:
-                    logger.warning(
-                        f"[frames-batch] {candidate} blank (max_a={max_a}); "
-                        f"frame {idx} trying next"
-                    )
+                    logger.warning(f"[frames-batch] {candidate} blank (max_a={max_a}); "
+                                   f"frame {idx} trying next")
                     continue
-
-                # Reject fully-opaque (no-op / model didn't segment)
                 if min_a > 245:
-                    logger.warning(
-                        f"[frames-batch] {candidate} no-op (min_a={min_a}); "
-                        f"frame {idx} trying next"
-                    )
+                    logger.warning(f"[frames-batch] {candidate} no-op (min_a={min_a}); "
+                                   f"frame {idx} trying next")
                     continue
 
                 result = res
@@ -1489,8 +1373,6 @@ async def process_frames_batch(
                 break
 
             if result is None:
-                # Every model failed on this frame. Send the original
-                # through, flagged so the client can count fallbacks.
                 logger.error(f"[frames-batch] frame {idx}: all models failed")
                 buf = io.BytesIO()
                 img.convert("RGBA").save(buf, format="PNG", compress_level=3)
@@ -1517,18 +1399,10 @@ async def process_frames_batch(
             })
         except Exception as e:
             logger.error(f"[frames-batch] frame {idx} failed: {e}")
-            results.append({
-                "data": "",
-                "format": "png",
-                "error": str(e)[:120],
-            })
+            results.append({"data": "", "format": "png", "error": str(e)[:120]})
 
     used = next((r.get("model") for r in results if r.get("model")), resolved)
-    return {
-        "frames": results,
-        "count": len(results),
-        "model": used,
-    }
+    return {"frames": results, "count": len(results), "model": used}
 
 
 # ============================================================
@@ -1607,57 +1481,6 @@ async def editor_inpaint(
         raise HTTPException(500, f"Inpainting failed: {str(e)[:200]}")
 
 
-@app.post("/api/editor/compose")
-async def editor_compose(
-    foreground: UploadFile = File(...),
-    background: UploadFile = File(None),
-    bg_color: str = Form('#FFFFFF'),
-    bg_gradient_end: str = Form(None),
-    fg_offset_x: int = Form(0),
-    fg_offset_y: int = Form(0),
-    fg_scale: float = Form(1.0),
-    canvas_w: int = Form(0),
-    canvas_h: int = Form(0),
-):
-    try:
-        fg_contents = await foreground.read()
-        fg = Image.open(io.BytesIO(fg_contents)).convert('RGBA')
-        if canvas_w > 0 and canvas_h > 0:
-            cw, ch = canvas_w, canvas_h
-        else:
-            cw, ch = fg.size
-        if fg_scale != 1.0:
-            fg = fg.resize((max(1, int(fg.width * fg_scale)),
-                            max(1, int(fg.height * fg_scale))), Image.Resampling.LANCZOS)
-        if background is not None:
-            bg_contents = await background.read()
-            bg_img = Image.open(io.BytesIO(bg_contents)).convert('RGBA')
-            scale = max(cw / bg_img.width, ch / bg_img.height)
-            bg_img = bg_img.resize((int(bg_img.width * scale), int(bg_img.height * scale)),
-                                   Image.Resampling.LANCZOS)
-            left = (bg_img.width - cw) // 2
-            top = (bg_img.height - ch) // 2
-            canvas = bg_img.crop((left, top, left + cw, top + ch))
-        elif bg_gradient_end:
-            c1 = _hex_to_rgb(bg_color); c2 = _hex_to_rgb(bg_gradient_end)
-            arr = np.zeros((ch, cw, 3), dtype=np.uint8)
-            for y in range(ch):
-                t = y / max(1, ch - 1)
-                arr[y, :] = [int(c1[i] * (1 - t) + c2[i] * t) for i in range(3)]
-            canvas = Image.fromarray(arr, 'RGB').convert('RGBA')
-        else:
-            c = _hex_to_rgb(bg_color)
-            canvas = Image.new('RGBA', (cw, ch), c + (255,))
-        canvas.paste(fg, (fg_offset_x, fg_offset_y), fg)
-        buf = io.BytesIO()
-        canvas.save(buf, format='PNG', optimize=True)
-        buf.seek(0)
-        return StreamingResponse(buf, media_type='image/png')
-    except Exception as e:
-        logger.error(f"compose failed: {e}")
-        raise HTTPException(500, f"Compose failed: {str(e)[:200]}")
-
-
 def _hex_to_rgb(hex_str):
     h = hex_str.lstrip('#')
     if len(h) == 3:
@@ -1666,8 +1489,14 @@ def _hex_to_rgb(hex_str):
 
 
 # ============================================================
-# DEBUG / HEALTH
+# DEBUG / HEALTH / WARMUP
 # ============================================================
+@app.get("/api/warmup")
+async def warmup():
+    """Lightweight keep-alive endpoint for Vercel cron."""
+    return {"status": "warm", "ts": datetime.now().isoformat()}
+
+
 @app.get("/api/debug/env")
 async def debug_env():
     m = get_container_memory()
@@ -1686,69 +1515,25 @@ async def debug_env():
             'matting_models': sorted(MATTING_MODELS)}
 
 
-@app.get("/api/debug/model-report")
-async def model_report():
-    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))
-    report = {}
-    for name in sorted(VALID_REMBG_MODELS):
-        entry = {'model': name}
-        try:
-            session = get_session_for_model(name)
-            if session is None:
-                entry['error'] = 'session-load-failed'
-                report[name] = entry
-                continue
-            t0 = time.time()
-            try:
-                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)
-                stats = {'min': int(arr[:, :, 3].min()), 'max': int(arr[:, :, 3].max()),
-                         'mean': round(float(arr[:, :, 3].mean()), 2),
-                         'center_alpha': int(arr[64, 64, 3]),
-                         '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': verdict})
-            except Exception as e:
-                entry['error'] = f'{type(e).__name__}: {str(e)[:200]}'
-        except Exception as e:
-            entry['error'] = f'{type(e).__name__}: {str(e)[:200]}'
-        report[name] = entry
-    return JSONResponse({
-        'generated_at': datetime.now().isoformat(),
-        'models': report,
-        'summary': {'total': len(report),
-                    'ok': sum(1 for v in report.values() if v.get('verdict') == 'OK'),
-                    'broken': sum(1 for v in report.values() if v.get('verdict') == 'BROKEN'),
-                    'errored': sum(1 for v in report.values() if 'error' in v)}})
-
-
 @app.get("/")
 async def home():
     stats = model_manager.get_stats()
     mem = get_container_memory()
     return HTMLResponse(f"""
     <!DOCTYPE html><html><head><meta charset="UTF-8">
-    <title>Background Remover Pro v31.4.1</title>
-    <style>body{{font-family:system-ui;background:linear-gradient(135deg,#667eea,#764ba2);
+    <title>Background Remover v32.0.0</title>
+    <style>body{{font-family:system-ui;background:#0A0A0A;
     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);
-    backdrop-filter:blur(10px);border-radius:20px;padding:40px;text-align:center;
-    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>
+    margin:0;padding:20px}}.c{{max-width:900px;background:#111;
+    border-radius:20px;padding:40px;text-align:center;
+    border:1px solid #222}}.s{{padding:15px;border-radius:12px;
+    margin:20px 0;background:#1a1a1a}}a{{color:#7ED957}}</style>
     </head><body><div class="c">
-    <h1>Background Remover Pro v31.4.1</h1>
-    <div class="s">AI Online · {len(stats['loaded_models'])} models ·
+    <h1>Background Remover v32.0.0</h1>
+    <div class="s">AI Online &middot; {len(stats['loaded_models'])} models &middot;
     RAM {mem['percent']:.0f}% ({mem['used_mb']}/{mem['total_mb']}MB)</div>
     <p>Video default: <strong>{DEFAULT_VIDEO_MODEL}</strong></p>
-    <p><a href="/docs">API Docs</a> · <a href="/api/debug/model-report">Model Report</a></p>
+    <p><a href="/docs">API Docs</a></p>
     </div></body></html>
     """)
 
@@ -1770,7 +1555,7 @@ async def health_check():
         'pymatting_available': PYMATTING_AVAILABLE,
         'image_formats': ['png', 'jpg', 'jpeg', 'webp', 'bmp'],
         'bulk_limit': 20,
-        'version': '31.4.1',
+        'version': '32.0.0',
         'default_model': get_default_model(),
         'default_video_model': DEFAULT_VIDEO_MODEL,
         'preload_models': [n for n, _ in PRELOAD_MODELS],
@@ -1778,7 +1563,7 @@ async def health_check():
         'matting_models': sorted(MATTING_MODELS),
         'pad_models': sorted(PAD_MULTIPLE_32_MODELS),
         'frame_batch_endpoint': '/api/process/frames-batch',
-        'editor_endpoints': ['auto-crop', 'inpaint', 'compose'],
+        'editor_endpoints': ['auto-crop', 'inpaint'],
     }
 
 
@@ -1798,10 +1583,10 @@ async def gen_exc(request, exc):
 @app.on_event("startup")
 async def startup():
     logger.info("=" * 60)
-    logger.info("🚀 v31.4.1 ready")
-    logger.info("🎬 Video pipeline: client-side frame batching")
-    logger.info(f"🎬 Video default model: {DEFAULT_VIDEO_MODEL}")
-    logger.info("🔧 ONNX: arena=ON, mem_pattern=ON")
+    logger.info("v32.0.0 ready")
+    logger.info("Video pipeline: client-side frame batching")
+    logger.info(f"Video default model: {DEFAULT_VIDEO_MODEL}")
+    logger.info("ONNX: arena=ON, mem_pattern=ON")
     logger.info("=" * 60)