Upload 26 files

app.py

@@ -0,0 +1,414 @@
+# # app.py
+# import os
+# import uuid
+# import shutil
+# import tempfile
+# import asyncio
+# from pathlib import Path
+# from fastapi import FastAPI, File, UploadFile, Form, HTTPException
+# from fastapi.responses import FileResponse, JSONResponse
+# from fastapi.middleware.cors import CORSMiddleware
+
+# # local imports
+# from task_queue import TaskQueue, TaskStatus
+# from core.pipeline import process_image_pipeline  # your real pipeline
+
+# # App config
+# APP_NAME = "manim_render_service"
+# TMP_ROOT = Path(tempfile.gettempdir()) / APP_NAME
+# TASKS_DIR = TMP_ROOT / "tasks"
+# OUTPUTS_DIR = TMP_ROOT / "outputs"
+# TASKS_DIR.mkdir(parents=True, exist_ok=True)
+# OUTPUTS_DIR.mkdir(parents=True, exist_ok=True)
+
+# # instantiate queue (file-backed)
+# queue = TaskQueue(base_dir=TMP_ROOT, max_workers=os.cpu_count() or 2)
+
+# app = FastAPI(title="Manim Render Service")
+# app.add_middleware(
+#     CORSMiddleware,
+#     allow_origins=["*"],  # change in prod
+#     allow_credentials=True,
+#     allow_methods=["*"],
+#     allow_headers=["*"],
+# )
+
+
+# @app.on_event("startup")
+# async def startup_event():
+#     # start background workers (non-blocking)
+#     await queue.start(processor=process_image_pipeline)
+
+
+# @app.on_event("shutdown")
+# async def shutdown_event():
+#     await queue.stop()
+
+
+# def _make_task_dir(task_id: str) -> Path:
+#     p = TASKS_DIR / task_id
+#     p.mkdir(parents=True, exist_ok=True)
+#     return p
+
+
+# def _secure_filename(filename: str) -> str:
+#     # Minimal safe filename normalizer
+#     return "".join(c for c in filename if c.isalnum() or c in "._-").strip("_")
+
+
+# @app.post("/render", status_code=202)
+# async def submit_render(
+#     image: UploadFile = File(...),
+#     style: str = Form("fade-in"),
+#     quality: str = Form("final"),  # preview or final
+# ):
+#     # Basic validation
+#     if image.content_type.split("/")[0] != "image":
+#         raise HTTPException(status_code=400, detail="Uploaded file must be an image.")
+
+#     task_id = uuid.uuid4().hex
+#     task_dir = _make_task_dir(task_id)
+
+#     # Save upload to tmp task directory
+#     safe_name = _secure_filename(image.filename or f"{task_id}.png")
+#     uploaded_path = task_dir / safe_name
+#     try:
+#         with uploaded_path.open("wb") as f:
+#             content = await image.read()
+#             # Limit size for safety (example: 25 MB)
+#             if len(content) > 25 * 1024 * 1024:
+#                 raise HTTPException(status_code=413, detail="File too large (max 25MB).")
+#             f.write(content)
+#     finally:
+#         await image.close()
+
+#     # Compose metadata
+#     meta = {
+#         "task_id": task_id,
+#         "input_image": str(uploaded_path),
+#         "style": style,
+#         "quality": quality,
+#         "task_dir": str(task_dir),
+#     }
+
+#     # Enqueue the task
+#     queue.enqueue(meta)
+
+#     return JSONResponse({"task_id": task_id, "status": "queued"})
+
+
+# @app.get("/status/{task_id}")
+# async def status(task_id: str):
+#     st = queue.get_status(task_id)
+#     if st is None:
+#         raise HTTPException(status_code=404, detail="Task not found")
+#     return JSONResponse({"task_id": task_id, "status": st.name})
+
+
+# @app.get("/result/{task_id}")
+# async def result(task_id: str):
+#     info = queue.get_task_info(task_id)
+#     if info is None:
+#         raise HTTPException(status_code=404, detail="Task not found")
+
+#     status = queue.get_status(task_id)
+#     if status != TaskStatus.COMPLETED:
+#         return JSONResponse({"task_id": task_id, "status": status.name})
+
+#     output_path = Path(info.get("output_path", ""))
+#     if not output_path.exists():
+#         raise HTTPException(status_code=404, detail="Output not found on disk")
+
+#     return FileResponse(path=str(output_path), filename=output_path.name, media_type="video/mp4")
+
+
+# @app.delete("/task/{task_id}")
+# async def delete_task(task_id: str):
+#     info = queue.get_task_info(task_id)
+#     if info:
+#         # attempt cleanup
+#         task_dir = Path(info.get("task_dir", ""))
+#         if task_dir.exists():
+#             shutil.rmtree(task_dir, ignore_errors=True)
+#         queue.remove_task(task_id)
+#         return JSONResponse({"task_id": task_id, "status": "removed"})
+#     else:
+#         raise HTTPException(status_code=404, detail="Task not found")
+
+
+
+
+# app.py
+import os
+import uuid
+import shutil
+import tempfile
+import asyncio
+from pathlib import Path
+from fastapi import FastAPI, File, UploadFile, Form, HTTPException
+from fastapi.responses import FileResponse, JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+import subprocess
+# local imports
+from task_queue import TaskQueue, TaskStatus
+from core.pipeline import process_image_pipeline  # your real pipeline
+from fastapi.responses import FileResponse, JSONResponse, Response
+from fastapi.responses import JSONResponse, Response, FileResponse
+from fastapi import HTTPException
+from pathlib import Path
+import base64
+import base64
+from pathlib import Path
+from moviepy.video.io.VideoFileClip import VideoFileClip
+
+# --------------------------------------------------
+# Logging Setup
+# --------------------------------------------------
+import logging
+
+logging.basicConfig(
+    level=logging.DEBUG,
+    format="🌀 [%(asctime)s] [%(levelname)s] %(message)s",
+    datefmt="%H:%M:%S",
+)
+logger = logging.getLogger("manim_render_service")
+
+# --------------------------------------------------
+# App config
+# --------------------------------------------------
+APP_NAME = "manim_render_service"
+TMP_ROOT = Path("tmp")/ APP_NAME
+TASKS_DIR = TMP_ROOT / "tasks"
+OUTPUTS_DIR = TMP_ROOT / "outputs"
+TASKS_DIR.mkdir(parents=True, exist_ok=True)
+OUTPUTS_DIR.mkdir(parents=True, exist_ok=True)
+
+queue = TaskQueue(base_dir=TMP_ROOT, max_workers=os.cpu_count() or 2)
+
+app = FastAPI(title="Manim Render Service")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# --------------------------------------------------
+# Lifecycle Events
+# --------------------------------------------------
+@app.on_event("startup")
+async def startup_event():
+    logger.info("🚀 Starting up backend...")
+    logger.debug(f"Temporary root: {TMP_ROOT}")
+    await queue.start(processor=process_image_pipeline)
+    logger.info("✅ Queue system initialized and worker started.")
+
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    logger.info("🧹 Shutting down backend...")
+    await queue.stop()
+    logger.info("🛑 Queue stopped gracefully.")
+
+
+# --------------------------------------------------
+# Helpers
+# --------------------------------------------------
+def _make_task_dir(task_id: str) -> Path:
+    p = TASKS_DIR / task_id
+    p.mkdir(parents=True, exist_ok=True)
+    logger.debug(f"📁 Created task directory: {p}")
+    return p
+
+
+def _secure_filename(filename: str) -> str:
+    safe = "".join(c for c in filename if c.isalnum() or c in "._-").strip("_")
+    logger.debug(f"🔒 Secured filename: {filename} → {safe}")
+    return safe
+
+
+# --------------------------------------------------
+# Routes
+# --------------------------------------------------
+@app.post("/render", status_code=202)
+async def submit_render(
+    image: UploadFile = File(...),
+    style: str = Form("fade-in"),
+    quality: str = Form("final"),
+):
+    logger.info(f"📨 Received new render request | style={style}, quality={quality}")
+    logger.debug(f"Uploaded file info: {image.filename}, type={image.content_type}")
+
+    if image.content_type.split("/")[0] != "image":
+        logger.error("❌ Invalid file type, not an image.")
+        raise HTTPException(status_code=400, detail="Uploaded file must be an image.")
+
+    task_id = uuid.uuid4().hex
+    task_dir = _make_task_dir(task_id)
+    logger.info(f"🆔 Generated Task ID: {task_id}")
+
+    safe_name = _secure_filename(image.filename or f"{task_id}.png")
+    uploaded_path = task_dir / safe_name
+    logger.debug(f"🗂 Saving upload to {uploaded_path}")
+
+    try:
+        with uploaded_path.open("wb") as f:
+            content = await image.read()
+            logger.debug(f"📦 File size: {len(content)/1024:.2f} KB")
+            if len(content) > 25 * 1024 * 1024:
+                logger.warning("⚠️ Upload too large (>25MB). Rejecting.")
+                raise HTTPException(status_code=413, detail="File too large (max 25MB).")
+            f.write(content)
+    finally:
+        await image.close()
+        logger.debug("📁 Image file closed after writing.")
+
+    meta = {
+        "task_id": task_id,
+        "input_image": str(uploaded_path),
+        "style": style,
+        "quality": quality,
+        "task_dir": str(task_dir),
+    }
+
+    logger.debug(f"🧾 Task metadata: {meta}")
+    queue.enqueue(meta)
+    logger.info(f"📤 Task {task_id} successfully enqueued.")
+
+    return JSONResponse({"task_id": task_id, "status": "queued"})
+
+
+@app.get("/status/{task_id}")
+async def status(task_id: str):
+    logger.debug(f"Status check for task: {task_id}")
+    st = queue.get_status(task_id)
+    if st is None:
+        logger.warning(f"Task {task_id} not found")
+        raise HTTPException(status_code=404, detail="Task not found")
+    
+    # Get additional info
+    task_info = queue.get_task_info(task_id)
+    logger.info(f"Task {task_id} status: {st.name} | info: {task_info}")
+    
+    return JSONResponse({
+        "task_id": task_id,
+        "status": st.name,
+        "details": task_info
+    })
+
+
+# async def result(task_id: str):
+#     logger.debug(f"📦 Fetching result for task: {task_id}")
+#     info = queue.get_task_info(task_id)
+#     if info is None:
+#         logger.warning(f"⚠️ Task info not found for {task_id}")
+#         raise HTTPException(status_code=404, detail="Task not found")
+
+#     status = queue.get_status(task_id)
+#     logger.debug(f"📈 Task {task_id} current status: {status.name}")
+
+#     if status != TaskStatus.COMPLETED:
+#         logger.info(f"⏳ Task {task_id} still in progress ({status.name})")
+#         return JSONResponse({"task_id": task_id, "status": status.name})
+
+#     output_path = Path(info.get("output_path", ""))
+#     logger.debug(f"🧩 Checking output path: {output_path}")
+#     # if not output_path.exists():
+#     #     logger.error(f"❌ Output file missing for task {task_id}")
+#     #     raise HTTPException(status_code=404, detail="Output not found on disk")
+    
+#     info = queue.get_task_info(task_id)
+#     output_bytes = info.get("output_bytes")
+
+#     if output_bytes:
+#         logger.info(f"🎬 Returning in-memory video for task {task_id}")
+#         return Response(content=output_bytes, media_type="video")
+
+# # fallback to disk if memory missing
+#     if not output_path.exists():
+#         logger.error(f"❌ Output file missing for task {task_id}")
+#         raise HTTPException(status_code=404, detail="Output not found on disk")
+
+#     logger.info(f"🎬 Returning result video from disk for task {task_id}")
+#     return FileResponse(
+#         path=str(output_path), filename=output_path.name, media_type="video"
+#         )
+@app.get("/result/{task_id}")
+async def result(task_id: str):
+    logger.debug(f"📦 Fetching result for task: {task_id}")
+    info = queue.get_task_info(task_id)
+    if info is None:
+        logger.warning(f"⚠️ Task info not found for {task_id}")
+        raise HTTPException(status_code=404, detail="Task not found")
+
+    status = queue.get_status(task_id)
+    logger.debug(f"📈 Task {task_id} current status: {status.name}")
+
+    if status != TaskStatus.COMPLETED:
+        logger.info(f"⏳ Task {task_id} still in progress ({status.name})")
+        return JSONResponse({"task_id": task_id, "status": status.name})
+
+    info = queue.get_task_info(task_id)
+    output_path = Path(info.get("output_path", ""))  # MOV path
+
+    if not output_path.exists():
+        logger.error(f"❌ Output file missing for task {task_id}")
+        raise HTTPException(status_code=404, detail="Output not found")
+    
+    # Convert MOV to WEBM with alpha if needed
+    webm_path = output_path.with_suffix(".webm")
+    if output_path.suffix.lower() == ".mov" and not webm_path.exists():
+        try:
+            logger.info(f"🎞️ Converting .mov → .webm (keeping transparency)...")
+            cmd = [
+                "ffmpeg",
+                "-y",
+                "-i", str(output_path),
+                "-c:v", "libvpx-vp9",
+                "-pix_fmt", "yuva420p",  # keep alpha channel
+                "-b:v", "4M",
+                "-auto-alt-ref", "0",
+                str(webm_path)
+            ]
+            subprocess.run(cmd, check=True, capture_output=True)
+            logger.info(f"✅ Converted successfully → {webm_path}")
+        except Exception as e:
+            logger.error(f"⚠️ MOV→WEBM conversion failed: {e}")
+            raise HTTPException(status_code=500, detail=f"Conversion failed: {e}")
+    
+    # Read both MOV and WEBM as bytes
+    mov_bytes = output_path.read_bytes()
+    webm_bytes = webm_path.read_bytes()
+
+    logger.info(f"✅ Returning both MOV + WEBM for task {task_id}")
+    return JSONResponse({
+        "task_id": task_id,
+        "status": "COMPLETED",
+        "results": [
+            {
+                "format": "mov",
+                "data": base64.b64encode(mov_bytes).decode("utf-8"),
+            },
+            {
+                "format": "webm",
+                "data": base64.b64encode(webm_bytes).decode("utf-8"),
+            },
+        ],
+    })
+
+@app.delete("/task/{task_id}")
+async def delete_task(task_id: str):
+    logger.info(f"🗑 Request to delete task: {task_id}")
+    info = queue.get_task_info(task_id)
+    if info:
+        task_dir = Path(info.get("task_dir", ""))
+        if task_dir.exists():
+            logger.debug(f"🧹 Removing directory: {task_dir}")
+            shutil.rmtree(task_dir, ignore_errors=True)
+        queue.remove_task(task_id)
+        logger.info(f"✅ Task {task_id} removed successfully.")
+        return JSONResponse({"task_id": task_id, "status": "removed"})
+    else:
+        logger.warning(f"⚠️ Task {task_id} not found for deletion.")
+        raise HTTPException(status_code=404, detail="Task not found")

core/background_animations.py

@@ -0,0 +1,25 @@
+# app/core/animations/background_animations.py
+from pathlib import Path
+from typing import Dict
+
+def animated_gradient(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "AnimatedGradient"
+    scene_code = f'''
+from manim import *
+class {scene_name}(Scene):
+    def construct(self):
+        # TODO: animate gradient backgrounds (possibly pre-render or use many rectangles)
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}
+
+def particle_motion(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "ParticleMotion"
+    scene_code = f'''
+from manim import *
+class {scene_name}(Scene):
+    def construct(self):
+        # TODO: implement particle motions like snow or bubbles
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}

core/character_animations.py

@@ -0,0 +1,27 @@
+# app/core/animations/character_animations.py
+from pathlib import Path
+from typing import Dict
+
+def walk_cycle(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "WalkCycle"
+    scene_code = f'''
+from manim import *
+class {scene_name}(Scene):
+    def construct(self):
+        # TODO: Implement a basic walk cycle using several frames or interpolated parts
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}
+
+def bobbing(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "Bobbing"
+    scene_code = f'''
+from manim import *
+class {scene_name}(Scene):
+    def construct(self):
+        svg = SVGMobject("{svg_path.name}")
+        self.play(svg.animate.shift(UP*0.2), run_time=0.4)
+        self.play(svg.animate.shift(DOWN*0.2), run_time=0.4)
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}

core/fx_animations.py

@@ -0,0 +1,45 @@
+# app/core/animations/fx_animations.py
+from pathlib import Path
+from typing import Dict
+
+def particle_burst(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "ParticleBurst"
+    scene_code = f'''
+from manim import *
+class {scene_name}(Scene):
+    def construct(self):
+        svg = SVGMobject("{svg_path.name}")
+        self.add(svg)
+        # TODO: Implement particle burst using many small dots animated outward
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}
+
+
+
+
+def smoke_effect(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "SmokeFX"
+    scene_code = f'''
+from manim import *
+class {scene_name}(Scene):
+    def construct(self):
+        svg = SVGMobject("{svg_path.name}")
+        # TODO: Add smoke overlay using alpha and per-frame masks or pre-rendered assets
+        self.play(FadeIn(svg), run_time=0.8)
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}
+
+def light_rays(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "LightRays"
+    scene_code = f'''
+from manim import *
+class {scene_name}(Scene):
+    def construct(self):
+        svg = SVGMobject("{svg_path.name}")
+        # TODO: Create rays using triangles/gradients and animate opacity
+        self.play(FadeIn(svg), run_time=0.6)
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}

core/infographic_animations.py

@@ -0,0 +1,25 @@
+# app/core/animations/infographic_animations.py
+from pathlib import Path
+from typing import Dict
+
+def bar_chart_grow(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "BarChartGrow"
+    scene_code = f'''
+from manim import *
+class {scene_name}(Scene):
+    def construct(self):
+        # TODO: build bars and animate heights 0->value
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}
+
+def number_count(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "NumberCount"
+    scene_code = f'''
+from manim import *
+class {scene_name}(Scene):
+    def construct(self):
+        # TODO: animate number counting
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}

core/logo_animations.py

@@ -0,0 +1,442 @@
+# app/core/animations/logo_animations.py
+from pathlib import Path
+from typing import Dict
+import random
+
+# def logo_build_lines(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+#     scene_name = "LogoBuildLines"
+#     scene_code = f'''
+# from manim import *
+# class {scene_name}(Scene):
+#     def construct(self):
+#         # TODO: Implement logo build from lines/paths
+#         svg = SVGMobject("{svg_path.name}")
+#         self.play(Write(svg), run_time=1)
+#         self.wait(0.5)
+# '''
+#     return {"scene_name": scene_name, "scene_code": scene_code}
+def logo_build_lines(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "LogoBuildLines"
+    scene_code = f'''
+from manim import *
+import random
+
+class {scene_name}(Scene):
+    def construct(self):
+        # Load SVG logo
+        svg = SVGMobject("{svg_path.name}")
+        svg.set(width=6)
+        svg.set_stroke(width=2)
+        svg.set_fill(opacity=1)
+        svg.move_to(ORIGIN)
+
+        # Split into subpaths for individual animation
+        subpaths = svg.family_members_with_points()
+
+        # Start each subpath invisible & slightly smaller
+        for sub in subpaths:
+            sub.set_opacity(0.05)
+            sub.scale(0.98)
+
+        # Animate each path individually with cinematic timing
+        for sub in subpaths:
+            delay = random.uniform(0, 0.05)  # tiny stagger for natural feel
+            self.wait(delay)
+            self.play(
+                Create(sub),
+                sub.animate.set_opacity(1).scale(1.0),
+                run_time=0.35,
+                rate_func=smooth
+            )
+
+        # Optional: final gentle pop to settle logo
+        self.play(svg.animate.scale(1.02), run_time=0.15, rate_func=there_and_back)
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}
+
+# def logo_fade_particle(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+#     scene_name = "LogoFadeParticle"
+#     scene_code = f'''
+# from manim import *
+# class {scene_name}(Scene):
+#     def construct(self):
+#         svg = SVGMobject("{svg_path.name}")
+#         self.play(FadeIn(svg), run_time=0.8)
+#         # TODO: Add particles using small dots or flocking
+#         self.wait(0.5)
+# '''
+#     return {"scene_name": scene_name, "scene_code": scene_code}
+# def logo_fade_particle(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+#     scene_name = "LogoFadeParticle"
+#     scene_code = f'''
+# from manim import *
+# import random
+
+# class {scene_name}(Scene):
+#     def construct(self):
+#         # Load SVG logo
+#         svg = SVGMobject("{svg_path.name}")
+#         svg.set(width=6)
+#         svg.set_stroke(width=2)
+#         svg.set_fill(opacity=1)
+#         svg.move_to(ORIGIN)
+#         svg.set_opacity(0)  # start invisible
+
+#         # Smooth fade-in with subtle scale pop
+#         self.play(svg.animate.set_opacity(1).scale(1.05), run_time=0.8, rate_func=smooth)
+#         self.play(svg.animate.scale(0.98), run_time=0.15, rate_func=there_and_back)
+
+#         # Particle effect from the logo edges
+#         points = svg.get_all_points()
+#         particles = VGroup(*[Dot(point, radius=0.04, color=WHITE, fill_opacity=0.6) for point in points])
+
+#         # Animate particles floating outward
+#         for particle in particles:
+#             offset = [random.uniform(-1,1), random.uniform(-1,1), 0]
+#             self.play(particle.animate.shift(offset).set_opacity(0), run_time=random.uniform(0.5,1.0), rate_func=smooth, lag_ratio=0.1)
+
+#         self.wait(0.5)
+# '''
+#     return {"scene_name": scene_name, "scene_code": scene_code}
+# def logo_fade_particle(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+#     scene_name = "LogoParticleBreak"
+
+#     scene_code = f"""
+# from manim import *
+# import random
+
+# class {scene_name}(Scene):
+#     def construct(self):
+#         # Load logo
+#         svg = SVGMobject(r"{svg_path.name}")
+#         svg.set(width=6)
+#         svg.set_stroke(width=2)
+#         svg.set_fill(opacity=1)
+#         svg.move_to(ORIGIN)
+#         svg.set_opacity(0)
+
+#         # Fade-in + pop
+#         self.play(
+#             svg.animate.set_opacity(1).scale(1.05),
+#             run_time=0.8,
+#             rate_func=smooth
+#         )
+#         self.play(
+#             svg.animate.scale(0.97),
+#             run_time=0.25,
+#             rate_func=there_and_back
+#         )
+
+#         # Sample SVG points
+#         raw_points = svg.get_all_points()
+#         points = raw_points[::2]  # skip every 2nd for density + speed
+
+#         # Create particles on edges
+#         particles = VGroup(
+#             *[
+#                 Dot(point, radius=0.035, color=WHITE, fill_opacity=0.9)
+#                 for point in points
+#             ]
+#         )
+#         particles.set_opacity(0)
+#         self.add(particles)
+
+#         # Dissolve logo into particles
+#         self.play(
+#             svg.animate.set_opacity(0),
+#             particles.animate.set_opacity(1),
+#             run_time=0.6,
+#             rate_func=smooth
+#         )
+
+#         # Outward particle spread
+#         anims = []
+#         for p in particles:
+#             offset = [
+#                 random.uniform(-1.2, 1.2),
+#                 random.uniform(-1.2, 1.2),
+#                 0
+#             ]
+#             anims.append(p.animate.shift(offset).set_opacity(0))
+
+#         self.play(
+#             LaggedStart(*anims, lag_ratio=0.008),
+#             run_time=1.3,
+#             rate_func=smooth
+#         )
+
+#         self.wait(0.3)
+# """
+
+#     return {"scene_name": scene_name, "scene_code": scene_code}
+
+
+
+# def logo_fade_particle(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+#     scene_name = "LogoParticleBreak"
+
+#     scene_code = f"""
+# from manim import *
+# import random
+
+# class {scene_name}(Scene):
+#     def construct(self):
+#         # Load SVG as grouped paths
+#         svg = SVGMobject(r"{svg_path.name}")
+#         svg.set(width=6)
+#         svg.set_stroke(width=2)
+#         svg.set_fill(opacity=1)
+#         svg.move_to(ORIGIN)
+#         svg.set_opacity(0)
+
+#         # Fade-in + pop
+#         self.play(svg.animate.set_opacity(1).scale(1.05), run_time=0.8, rate_func=smooth)
+#         self.play(svg.animate.scale(0.97), run_time=0.25, rate_func=there_and_back)
+
+#         # Collect points & colors from subobjects
+#         points = []
+#         colors = []
+
+#         for sub in svg.family_members_with_points():
+#             pts = sub.get_points()
+#             col = sub.get_fill_color()
+#             for p in pts[::3]:  # skip for smoother density
+#                 points.append(p)
+#                 colors.append(col)
+
+#         # Create cinematic glowing particles
+#         particles = VGroup()
+#         for p, col in zip(points, colors):
+#             part = Circle(radius=0.03, color=col, fill_color=col, fill_opacity=1)
+#             part.move_to(p)
+#             part.set_opacity(0)
+#             part.scale(random.uniform(0.6, 1.2))  # natural variation
+#             particles.add(part)
+
+#         self.add(particles)
+
+#         # Logo dissolves → particles appear
+#         self.play(
+#             svg.animate.set_opacity(0),
+#             particles.animate.set_opacity(1),
+#             run_time=0.5,
+#             rate_func=smooth,
+#         )
+
+#         # Particle outward scatter
+#         anims = []
+#         for p in particles:
+#             offset = [
+#                 random.uniform(-1.3, 1.3),
+#                 random.uniform(-1.3, 1.3),
+#                 0
+#             ]
+#             anims.append(
+#                 p.animate.shift(offset)
+#                 .scale(random.uniform(0.6, 1.8))
+#                 .set_opacity(0)
+#             )
+
+#         self.play(
+#             LaggedStart(*anims, lag_ratio=0.006),
+#             run_time=1.4,
+#             rate_func=smooth
+#         )
+
+#         self.wait(0.3)
+# """
+
+#     return {"scene_name": scene_name, "scene_code": scene_code}
+
+
+
+
+# def logo_fade_particle(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+#     scene_name = "LogoParticlesFullPoints"
+
+#     scene_code = f"""
+# from manim import *
+# import numpy as np
+# import random
+
+# class {scene_name}(Scene):
+#     def construct(self):
+#         # Load SVG
+#         svg = SVGMobject(r"{svg_path.name}")
+#         svg.set(width=6)
+#         svg.set_stroke(width=2)
+#         svg.set_fill(opacity=1)
+#         svg.move_to(ORIGIN)
+#         svg.scale(0.8)  # start smaller for pop effect
+#         svg.set_opacity(0)
+
+#         # Smooth fade-in with tiny pop
+#         self.play(
+#             svg.animate.set_opacity(1).scale(1.05),
+#             run_time=0.8,
+#             rate_func=smooth
+#         )
+#         self.play(svg.animate.scale(0.97), run_time=0.2, rate_func=smooth)
+
+#         # Use all points from the entire SVG
+#         points, colors = [], []
+#         for sub in svg.family_members_with_points():
+#             pts = sub.get_all_points()  # all points of the subpath
+#             if len(pts) == 0:
+#                 continue
+#             col = sub.get_fill_color()
+#             for p in pts:
+#                 points.append(p)
+#                 colors.append(col)
+
+#         # Create particles at all points
+#         particles = VGroup()
+#         for p, col in zip(points, colors):
+#             part = Dot(point=p, radius=0.03, color=col)
+#             part.set_opacity(1)  # start visible
+#             particles.add(part)
+
+#         self.add(particles)
+
+#         # Transform SVG into particles (SVG fades as particles scatter)
+#         scatter_anims = []
+#         for part in particles:
+#             offset = np.array([
+#                 random.uniform(-1.5, 1.5),
+#                 random.uniform(-1.5, 1.5),
+#                 0
+#             ])
+#             scatter_anims.append(
+#                 part.animate.shift(offset)
+#                 .scale(random.uniform(0.5, 1.5))
+#                 .set_opacity(0)
+#             )
+
+#         self.play(
+#             svg.animate.set_opacity(0),
+#             LaggedStart(*scatter_anims, lag_ratio=0.003),
+#             run_time=1.5,
+#             rate_func=smooth
+#         )
+
+#         self.wait(0.5)
+# """
+
+#     return {"scene_name": scene_name, "scene_code": scene_code}
+
+
+def logo_fade_particle(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "LogoParticlesBlast"
+
+    scene_code = f"""
+from manim import *
+import numpy as np
+import random
+
+class {scene_name}(Scene):
+    def construct(self):
+        # Load SVG
+        svg = SVGMobject(r"{svg_path.name}")
+        svg.set(width=6)
+        svg.set_stroke(width=2)
+        svg.set_fill(opacity=1)
+        svg.move_to(ORIGIN)
+        svg.scale(0.8)  # start smaller for pop effect
+        svg.set_opacity(0)
+
+        # Smooth fade-in with tiny pop
+        self.play(
+            svg.animate.set_opacity(1).scale(1.05),
+            run_time=0.8,
+            rate_func=smooth
+        )
+        self.play(svg.animate.scale(0.97), run_time=0.2, rate_func=smooth)
+
+        # Use all points from the SVG
+        points, colors = [], []
+        for sub in svg.family_members_with_points():
+            pts = sub.get_all_points()
+            if len(pts) == 0:
+                continue
+            col = sub.get_fill_color()
+            for p in pts:
+                points.append(p)
+                colors.append(col)
+
+        # Create particles at all points
+        particles = VGroup()
+        for p, col in zip(points, colors):
+            part = Dot(point=p, radius=0.03, color=col)
+            part.set_opacity(1)
+            particles.add(part)
+
+        self.add(particles)
+
+        # SVG transforms into particles with blast effect
+        blast_anims = []
+        for part in particles:
+            # Random direction vector
+            angle = random.uniform(0, 2 * np.pi)
+            distance = random.uniform(1.0, 3.0)  # how far it flies
+            offset = np.array([distance * np.cos(angle),
+                               distance * np.sin(angle),
+                               random.uniform(-0.3, 0.3)])
+            # Particle animation: move, fade, and scale
+            blast_anims.append(
+                part.animate.shift(offset)
+                .scale(random.uniform(0.5, 1.5))
+                .set_opacity(0)
+            )
+
+        # Play SVG fade + particle blast together
+        self.play(
+            svg.animate.set_opacity(0),
+            LaggedStart(*blast_anims, lag_ratio=0.002),
+            run_time=2.0,  # slow motion blast
+            rate_func=smooth
+        )
+
+        self.wait(0.5)
+"""
+
+    return {"scene_name": scene_name, "scene_code": scene_code}
+
+def logo_spin_scale(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "LogoSpinScale"
+    scene_code = f'''
+from manim import *
+class {scene_name}(Scene):
+    def construct(self):
+        svg = SVGMobject("{svg_path.name}")
+        svg.scale(0.5)
+        self.play(Rotate(svg, angle=TAU), svg.animate.scale(1.2), run_time=1)
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}
+
+def logo_stroke_draw(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "LogoStrokeDraw"
+    scene_code = f'''
+from manim import *
+class {scene_name}(Scene):
+    def construct(self):
+        # TODO: Animate stroke drawing by tracing paths
+        svg = SVGMobject("{svg_path.name}")
+        self.play(Write(svg), run_time=1)
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}
+
+def logo_glitch(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "LogoGlitch"
+    scene_code = f'''
+from manim import *
+class {scene_name}(Scene):
+    def construct(self):
+        svg = SVGMobject("{svg_path.name}")
+        self.play(FadeIn(svg), run_time=0.4)
+        # TODO: Implement quick offset copies to simulate glitch
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}

core/overlay_animations.py

@@ -0,0 +1,25 @@
+# app/core/animations/overlay_animations.py
+from pathlib import Path
+from typing import Dict
+
+def confetti(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "Confetti"
+    scene_code = f'''
+from manim import *
+class {scene_name}(Scene):
+    def construct(self):
+        # TODO: implement confetti using many small shapes with gravity-like animation
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}
+
+def checkmark_tick(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "CheckmarkTick"
+    scene_code = f'''
+from manim import *
+class {scene_name}(Scene):
+    def construct(self):
+        # TODO: show checkmark animation
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}

core/pipeline.py

@@ -0,0 +1,1070 @@
+# # app/core/pipeline.py
+# import os
+# import shutil
+# import subprocess
+# import sys
+# import tempfile
+# import time
+# from pathlib import Path
+# from typing import Dict, Optional, Tuple
+
+# from core.vectorizer import vectorize_image
+
+# # Import animation modules (each file inside core/)
+# import core.text_animations as text_animations
+# import core.logo_animations as logo_animations
+# import core.shape_animations as shape_animations
+# import core.fx_animations as fx_animations
+# import core.transitions as transitions
+# import core.infographic_animations as infographic_animations
+# import core.character_animations as character_animations
+# import core.background_animations as background_animations
+# import core.overlay_animations as overlay_animations
+
+
+# # Global outputs dir (stable)
+# GLOBAL_OUTPUTS_DIR = Path(tempfile.gettempdir()) / "manim_render_service" / "outputs"
+# GLOBAL_OUTPUTS_DIR.mkdir(parents=True, exist_ok=True)
+
+# # Manim installation directory under tmp (pip --target here)
+# MANIM_TARGET_DIR = Path(tempfile.gettempdir()) / "manim_render_service" / "manim_env"
+# MANIM_TARGET_DIR.mkdir(parents=True, exist_ok=True)
+
+# # Map style strings to animation functions across modules.
+# STYLE_MAP = {
+#     # Text basics
+#     "fade-in": text_animations.fade_in,
+#     "slide-in-left": text_animations.slide_in_left,
+#     "pop-bounce": text_animations.pop_bounce,
+#     "zoom-in": text_animations.zoom_in,
+#     "typewriter": text_animations.typewriter,
+#     "wipe": text_animations.wipe_mask,
+#     "flip": text_animations.flip_rotate,
+#     "blur-in": text_animations.blur_in,
+#     "scale-up": text_animations.scale_up,
+#     # Text premium
+#     "neon-glow": text_animations.neon_glow,
+#     "gradient-fill": text_animations.gradient_fill,
+#     "wave-ripple": text_animations.wave_ripple,
+#     "split-text": text_animations.split_text,
+#     # Logo
+#     "logo-build": logo_animations.logo_build_lines,
+#     "logo-particle": logo_animations.logo_fade_particle,
+#     "logo-spin": logo_animations.logo_spin_scale,
+#     "logo-stroke": logo_animations.logo_stroke_draw,
+#     "logo-glitch": logo_animations.logo_glitch,
+#     # Shapes
+#     "line-draw": shape_animations.line_draw,
+#     "shape-morph": shape_animations.shape_morph,
+#     "grow-center": shape_animations.grow_center,
+#     "floating": shape_animations.floating_bounce,
+#     # FX
+#     "particle-burst": fx_animations.particle_burst,
+#     "smoke": fx_animations.smoke_effect,
+#     "light-rays": fx_animations.light_rays,
+#     # Transitions & infographic & character etc (examples)
+#     "fade-transition": transitions.fade_transition,
+#     "bar-chart": infographic_animations.bar_chart_grow,
+#     "count-number": infographic_animations.number_count,
+#     "walk-cycle": character_animations.walk_cycle,
+#     "bobbing": character_animations.bobbing,
+#     "animated-gradient": background_animations.animated_gradient,
+#     "particle-motion": background_animations.particle_motion,
+#     "confetti": overlay_animations.confetti,
+#     "checkmark": overlay_animations.checkmark_tick,
+# }
+
+# # Helper: detect manim in PATH or in current python env
+# def _manim_executable_available() -> bool:
+#     # 1) check for manim binary in PATH
+#     if shutil.which("manim"):
+#         return True
+#     # 2) check if importable in current python env
+#     try:
+#         import manim  # noqa: F401
+#         return True
+#     except Exception:
+#         return False
+
+# def _ensure_manim_installed(log_file: Path) -> tuple[bool, str]:
+#     """
+#     Ensure Manim is available. Strategy:
+#       - If system has manim in PATH or importable, OK.
+#       - Otherwise, run pip install --target MANIM_TARGET_DIR manim
+#         and set PYTHONPATH to include MANIM_TARGET_DIR when invoking manim via `python -m manim`.
+#     Returns (success, message). Writes pip logs to log_file.
+#     NOTE: pip install requires network and may take time; call this once at startup or first run.
+#     """
+#     if _manim_executable_available():
+#         return True, "manim-available"
+
+#     try:
+#         log_file.parent.mkdir(parents=True, exist_ok=True)
+#         with log_file.open("ab") as lf:
+#             # pip install into target dir
+#             cmd = [sys.executable, "-m", "pip", "install", "--upgrade", "--target", str(MANIM_TARGET_DIR), "manim"]
+#             proc = subprocess.run(cmd, stdout=lf, stderr=lf, check=False, timeout=1800)
+#             if proc.returncode != 0:
+#                 return False, f"pip-install-failed:{proc.returncode}"
+#     except Exception as e:
+#         return False, f"pip-install-exception:{e}"
+
+#     # final check
+#     if _manim_executable_available():
+#         return True, "manim-installed-system"
+#     # Even if not on PATH, we can still run via python -m manim with PYTHONPATH pointing to MANIM_TARGET_DIR
+#     return True, "manim-installed-target"
+
+# def _run_manim(scene_py_path: Path, scene_class: str, work_dir: Path, log_file: Path, quality_flag: str = "-ql", timeout: int = 300) -> Optional[Path]:
+#     """
+#     Run manim to render the scene class from scene_py_path inside work_dir.
+#     - Uses python -m manim with PYTHONPATH including MANIM_TARGET_DIR to pick up target install.
+#     - quality_flag example: "-ql" quick low, "-qm" medium, "-qh" high.
+#     - Always uses "-t" for transparent background.
+#     Returns Path to produced mp4 or None on failure.
+#     """
+#     # Build base command. prefer system manim if available (shutil.which)
+#     if shutil.which("manim"):
+#         base = ["manim"]
+#     else:
+#         base = [sys.executable, "-m", "manim"]
+#     # Ensure output name deterministic: use scene_py stem + scene_class
+#     out_name = f"{scene_py_path.stem}_{scene_class}"
+#     cmd = [*base, quality_flag, "-t", str(scene_py_path), scene_class, "-o", out_name]
+#     env = os.environ.copy()
+#     # include MANIM_TARGET_DIR in PYTHONPATH so python -m manim can import if installed with --target
+#     env_py = env.get("PYTHONPATH", "")
+#     new_py = str(MANIM_TARGET_DIR)
+#     if env_py:
+#         new_py = new_py + os.pathsep + env_py
+#     env["PYTHONPATH"] = new_py
+
+#     try:
+#         with log_file.open("ab") as lf:
+#             start = time.time()
+#             proc = subprocess.run(cmd, cwd=str(work_dir), env=env, stdout=lf, stderr=lf, timeout=timeout)
+#             elapsed = time.time() - start
+#             if proc.returncode != 0:
+#                 return None
+#     except Exception:
+#         return None
+
+#     # search for produced mp4 under work_dir (manim writes into media/videos/... usually)
+#     mp4s = list(work_dir.rglob("*.mp4"))
+#     if not mp4s:
+#         return None
+#     mp4s.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+#     return mp4s[0]
+
+# def process_image_pipeline(task_meta: Dict) -> Dict:
+#     """
+#     Synchronous pipeline entry. Steps:
+#       - set up task_dir/working/outputs/logs
+#       - vectorize input image -> svg
+#       - call animation placeholder (get scene_code)
+#       - write scene file & copy svg into working dir
+#       - ensure manim installed (pip --target if needed)
+#       - run manim with -t -> get mp4
+#       - copy mp4 to GLOBAL_OUTPUTS_DIR and return path
+#     """
+#     task_id = task_meta.get("task_id")
+#     task_dir = Path(task_meta.get("task_dir", ""))
+#     if not task_id or not task_dir.exists():
+#         return {"success": False, "error": "invalid-task"}
+
+#     working = task_dir / "working"
+#     outputs = task_dir / "outputs"
+#     logs = task_dir / "logs"
+#     working.mkdir(parents=True, exist_ok=True)
+#     outputs.mkdir(parents=True, exist_ok=True)
+#     logs.mkdir(parents=True, exist_ok=True)
+
+#     log_file = logs / f"{task_id}.log"
+
+#     try:
+#         # 1) copy input to working folder
+#         input_image = Path(task_meta.get("input_image"))
+#         if not input_image.exists():
+#             return {"success": False, "error": "input-missing"}
+
+#         safe_input = working / input_image.name
+#         shutil.copy2(input_image, safe_input)
+
+#         # 2) vectorize -> svg
+#         svg_path = working / f"{task_id}.svg"
+#         vec_res = vectorize_image(safe_input, svg_path, options={"quality": task_meta.get("quality")})
+#         if not vec_res.get("success"):
+#             return {"success": False, "error": f"vectorize-failed:{vec_res.get('error')}"}
+
+#         # 3) pick animation function
+#         style = task_meta.get("style", "fade-in")
+#         anim_fn = STYLE_MAP.get(style)
+#         if anim_fn is None:
+#             # fallback to fade-in
+#             anim_fn = text_animations.fade_in
+
+#         # 4) animation function returns scene info (name + code)
+#         scene_info = anim_fn(svg_path, working, task_meta)
+#         if not scene_info or "scene_name" not in scene_info or "scene_code" not in scene_info:
+#             return {"success": False, "error": "animation-fn-invalid"}
+
+#         scene_name = scene_info["scene_name"]
+#         scene_code = scene_info["scene_code"]
+
+#         # 5) write scene python file and ensure svg is in same folder
+#         scene_py = working / f"scene_{task_id}.py"
+#         scene_py.write_text(scene_code, encoding="utf-8")
+#         # ensure svg copied into working dir
+#         try:
+#             shutil.copy2(svg_path, working / svg_path.name)
+#         except Exception:
+#             pass
+
+#         # 6) ensure manim is available (installs into MANIM_TARGET_DIR if not)
+#         ok, msg = _ensure_manim_installed(log_file)
+#         if not ok:
+#             return {"success": False, "error": f"manim-install-failed:{msg}"}
+
+#         # 7) run manim to render scene with transparent background
+#         # quality: map task_meta quality -> flag
+#         q = task_meta.get("quality", "preview")
+#         quality_flag = "-ql" if q == "preview" else "-qh" if q == "final" else "-qm"
+#         rendered_mp4 = _run_manim(scene_py, scene_name, working, log_file, quality_flag=quality_flag, timeout=900)
+#         if not rendered_mp4:
+#             # attach log path for debugging
+#             return {"success": False, "error": "manim-render-failed", "log": str(log_file)}
+
+#         # 8) copy to GLOBAL_OUTPUTS_DIR
+#         dest = GLOBAL_OUTPUTS_DIR / f"{task_id}_{rendered_mp4.name}"
+#         try:
+#             if dest.exists():
+#                 dest.unlink()
+#             shutil.copy2(rendered_mp4, dest)
+#         except Exception as e:
+#             return {"success": False, "error": f"copy-failed:{e}", "log": str(log_file)}
+
+#         # optional: cleanup working to save disk
+#         try:
+#             shutil.rmtree(working)
+#         except Exception:
+#             pass
+
+#         return {"success": True, "output_path": str(dest), "log": str(log_file)}
+
+#     except Exception as e:
+#         # keep task_dir for debug
+#         return {"success": False, "error": str(e), "log": str(log_file)}
+
+
+
+
+# # app/core/pipeline.py
+# import os
+# import shutil
+# import subprocess
+# import sys
+# import tempfile
+# import time
+# from pathlib import Path
+# from typing import Dict, Optional, Tuple
+
+# from core.vectorizer import vectorize_image
+
+# # Import animation modules (each file inside core/)
+# import core.text_animations as text_animations
+# import core.logo_animations as logo_animations
+# import core.shape_animations as shape_animations
+# import core.fx_animations as fx_animations
+# import core.transitions as transitions
+# import core.infographic_animations as infographic_animations
+# import core.character_animations as character_animations
+# import core.background_animations as background_animations
+# import core.overlay_animations as overlay_animations
+
+# # Global outputs dir (stable)
+# GLOBAL_OUTPUTS_DIR = Path(tempfile.gettempdir()) / "manim_render_service" / "outputs"
+# GLOBAL_OUTPUTS_DIR.mkdir(parents=True, exist_ok=True)
+
+# # Map style strings to animation functions across modules.
+# STYLE_MAP = {
+#     # Text basics
+#     "fade-in": text_animations.fade_in,
+#     "slide-in-left": text_animations.slide_in_left,
+#     "pop-bounce": text_animations.pop_bounce,
+#     "zoom-in": text_animations.zoom_in,
+#     "typewriter": text_animations.typewriter,
+#     "wipe": text_animations.wipe_mask,
+#     "flip": text_animations.flip_rotate,
+#     "blur-in": text_animations.blur_in,
+#     "scale-up": text_animations.scale_up,
+#     # Text premium
+#     "neon-glow": text_animations.neon_glow,
+#     "gradient-fill": text_animations.gradient_fill,
+#     "wave-ripple": text_animations.wave_ripple,
+#     "split-text": text_animations.split_text,
+#     # Logo
+#     "logo-build": logo_animations.logo_build_lines,
+#     "logo-particle": logo_animations.logo_fade_particle,
+#     "logo-spin": logo_animations.logo_spin_scale,
+#     "logo-stroke": logo_animations.logo_stroke_draw,
+#     "logo-glitch": logo_animations.logo_glitch,
+#     # Shapes
+#     "line-draw": shape_animations.line_draw,
+#     "shape-morph": shape_animations.shape_morph,
+#     "grow-center": shape_animations.grow_center,
+#     "floating": shape_animations.floating_bounce,
+#     # FX
+#     "particle-burst": fx_animations.particle_burst,
+#     "smoke": fx_animations.smoke_effect,
+#     "light-rays": fx_animations.light_rays,
+#     # Transitions & infographic & character etc (examples)
+#     "fade-transition": transitions.fade_transition,
+#     "bar-chart": infographic_animations.bar_chart_grow,
+#     "count-number": infographic_animations.number_count,
+#     "walk-cycle": character_animations.walk_cycle,
+#     "bobbing": character_animations.bobbing,
+#     "animated-gradient": background_animations.animated_gradient,
+#     "particle-motion": background_animations.particle_motion,
+#     "confetti": overlay_animations.confetti,
+#     "checkmark": overlay_animations.checkmark_tick,
+# }
+
+# def _run_manim(scene_py_path: Path, scene_class: str, work_dir: Path, log_file: Path, quality_flag: str = "-ql", timeout: int = 300) -> Optional[Path]:
+#     """
+#     Run manim to render the scene class from scene_py_path inside work_dir.
+#     - Uses python -m manim command.
+#     - Always uses "-t" for transparent background.
+#     Returns Path to produced mp4 or None on failure.
+#     """
+#     base = [sys.executable, "-m", "manim"]
+#     out_name = f"{scene_py_path.stem}_{scene_class}"
+#     cmd = [*base, quality_flag, "-t", str(scene_py_path), scene_class, "-o", out_name]
+
+#     try:
+#         with log_file.open("ab") as lf:
+#             start = time.time()
+#             proc = subprocess.run(cmd, cwd=str(work_dir), stdout=lf, stderr=lf, timeout=timeout)
+#             elapsed = time.time() - start
+#             if proc.returncode != 0:
+#                 return None
+#     except Exception:
+#         return None
+
+#     mp4s = list(work_dir.rglob("*.mp4"))
+#     if not mp4s:
+#         return None
+#     mp4s.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+#     return mp4s[0]
+
+# def process_image_pipeline(task_meta: Dict) -> Dict:
+#     """
+#     Synchronous pipeline entry. Steps:
+#       - set up task_dir/working/outputs/logs
+#       - vectorize input image -> svg
+#       - call animation placeholder (get scene_code)
+#       - write scene file & copy svg into working dir
+#       - run manim with -t -> get mp4
+#       - copy mp4 to GLOBAL_OUTPUTS_DIR and return path
+#     """
+#     task_id = task_meta.get("task_id")
+#     task_dir = Path(task_meta.get("task_dir", ""))
+#     if not task_id or not task_dir.exists():
+#         return {"success": False, "error": "invalid-task"}
+
+#     working = task_dir / "working"
+#     outputs = task_dir / "outputs"
+#     logs = task_dir / "logs"
+#     working.mkdir(parents=True, exist_ok=True)
+#     outputs.mkdir(parents=True, exist_ok=True)
+#     logs.mkdir(parents=True, exist_ok=True)
+
+#     log_file = logs / f"{task_id}.log"
+
+#     try:
+#         input_image = Path(task_meta.get("input_image"))
+#         if not input_image.exists():
+#             return {"success": False, "error": "input-missing"}
+
+#         safe_input = working / input_image.name
+#         shutil.copy2(input_image, safe_input)
+
+#         # Step 1: Prepare vectorization
+#         svg_path = working / f"{task_id}.svg"
+
+#         # Run vectorization — returns {"success": True, "svg": "<svg>...</svg>"}
+#         vec_res = vectorize_image(safe_input, options={"quality": task_meta.get("quality")})
+#         if not vec_res.get("success"):
+#             return {"success": False, "error": f"vectorize-failed:{vec_res.get('error')}"}
+
+#         # Step 2: Write SVG to file (since later parts of pipeline expect a file path)
+#         svg_content = vec_res.get("svg")
+#         if not svg_content:
+#             return {"success": False, "error": "vectorizer-did-not-return-svg"}
+
+#         svg_path.write_text(svg_content, encoding="utf-8")
+
+#         style = task_meta.get("style", "fade-in")
+#         anim_fn = STYLE_MAP.get(style, text_animations.fade_in)
+
+#         scene_info = anim_fn(svg_path, working, task_meta)
+#         if not scene_info or "scene_name" not in scene_info or "scene_code" not in scene_info:
+#             return {"success": False, "error": "animation-fn-invalid"}
+
+#         scene_name = scene_info["scene_name"]
+#         scene_code = scene_info["scene_code"]
+
+#         scene_py = working / f"scene_{task_id}.py"
+#         scene_py.write_text(scene_code, encoding="utf-8")
+
+#         try:
+#             shutil.copy2(svg_path, working / svg_path.name)
+#         except Exception:
+#             pass
+
+#         q = task_meta.get("quality", "preview")
+#         quality_flag = "-ql" if q == "preview" else "-qh" if q == "final" else "-qm"
+#         rendered_mp4 = _run_manim(scene_py, scene_name, working, log_file, quality_flag=quality_flag, timeout=900)
+#         if not rendered_mp4:
+#             return {"success": False, "error": "manim-render-failed", "log": str(log_file)}
+
+#         dest = GLOBAL_OUTPUTS_DIR / f"{task_id}_{rendered_mp4.name}"
+#         try:
+#             if dest.exists():
+#                 dest.unlink()
+#             shutil.copy2(rendered_mp4, dest)
+#         except Exception as e:
+#             return {"success": False, "error": f"copy-failed:{e}", "log": str(log_file)}
+
+#         try:
+#             shutil.rmtree(working)
+#         except Exception:
+#             pass
+
+#         return {"success": True, "output_path": str(dest), "log": str(log_file)}
+
+#     except Exception as e:
+#         return {"success": False, "error": str(e), "log": str(log_file)}
+
+
+
+# # app/core/pipeline.py
+# import os
+# import shutil
+# import subprocess
+# import sys
+# import tempfile
+# import time
+# from pathlib import Path
+# from typing import Dict, Optional, Tuple
+
+# from core.vectorizer import vectorize_image
+
+# # Import animation modules (each file inside core/)
+# import core.text_animations as text_animations
+# import core.logo_animations as logo_animations
+# import core.shape_animations as shape_animations
+# import core.fx_animations as fx_animations
+# import core.transitions as transitions
+# import core.infographic_animations as infographic_animations
+# import core.character_animations as character_animations
+# import core.background_animations as background_animations
+# import core.overlay_animations as overlay_animations
+
+# # Global outputs dir (stable)
+# GLOBAL_OUTPUTS_DIR = Path("tmp")/ "manim_render_service" / "outputs"
+# GLOBAL_OUTPUTS_DIR.mkdir(parents=True, exist_ok=True)
+
+# # Map style strings to animation functions across modules.
+# STYLE_MAP = {
+#     # Text basics
+#     "fade-in": text_animations.fade_in,
+#     "slide-in-left": text_animations.slide_in_left,
+#     "pop-bounce": text_animations.pop_bounce,
+#     "zoom-in": text_animations.zoom_in,
+#     "typewriter": text_animations.typewriter,
+#     "wipe": text_animations.wipe_mask,
+#     "flip": text_animations.flip_rotate,
+#     "blur-in": text_animations.blur_in,
+#     "scale-up": text_animations.scale_up,
+#     # Text premium
+#     "neon-glow": text_animations.neon_glow,
+#     "gradient-fill": text_animations.gradient_fill,
+#     "wave-ripple": text_animations.wave_ripple,
+#     "split-text": text_animations.split_text,
+#     # Logo
+#     "logo-build": logo_animations.logo_build_lines,
+#     "logo-particle": logo_animations.logo_fade_particle,
+#     "logo-spin": logo_animations.logo_spin_scale,
+#     "logo-stroke": logo_animations.logo_stroke_draw,
+#     "logo-glitch": logo_animations.logo_glitch,
+#     # Shapes
+#     "line-draw": shape_animations.line_draw,
+#     "shape-morph": shape_animations.shape_morph,
+#     "grow-center": shape_animations.grow_center,
+#     "floating": shape_animations.floating_bounce,
+#     # FX
+#     "particle-burst": fx_animations.particle_burst,
+#     "smoke": fx_animations.smoke_effect,
+#     "light-rays": fx_animations.light_rays,
+#     # Transitions & infographic & character etc (examples)
+#     "fade-transition": transitions.fade_transition,
+#     "bar-chart": infographic_animations.bar_chart_grow,
+#     "count-number": infographic_animations.number_count,
+#     "walk-cycle": character_animations.walk_cycle,
+#     "bobbing": character_animations.bobbing,
+#     "animated-gradient": background_animations.animated_gradient,
+#     "particle-motion": background_animations.particle_motion,
+#     "confetti": overlay_animations.confetti,
+#     "checkmark": overlay_animations.checkmark_tick,
+# }
+
+# # def _run_manim(scene_py_path: Path, scene_class: str, work_dir: Path, log_file: Path, quality_flag: str = "-ql", timeout: int = 300) -> Optional[Path]:
+# #     print(f"[DEBUG] Running manim render for scene '{scene_class}' in '{work_dir}'...")
+# #     base = [sys.executable, "-m", "manim"]
+# #     out_name = f"{scene_py_path.stem}_{scene_class}"
+# #     cmd = [*base, quality_flag, "-t", str(scene_py_path), scene_class, "-o", out_name]
+# #     print(f"[DEBUG] Command: {' '.join(cmd)}")
+
+# #     try:
+# #         with log_file.open("ab") as lf:
+# #             start = time.time()
+# #             proc = subprocess.run(cmd, cwd=str(work_dir), stdout=lf, stderr=lf, timeout=timeout)
+# #             elapsed = time.time() - start
+# #             print(f"[DEBUG] Manim completed in {elapsed:.2f}s with return code {proc.returncode}")
+# #             if proc.returncode != 0:
+# #                 print("[ERROR] Manim render failed.")
+# #                 return None
+# #     except Exception as e:
+# #         print(f"[ERROR] Exception during manim run: {e}")
+# #         return None
+
+# #     mp4s = list(work_dir.rglob("*.mp4"))
+# #     if not mp4s:
+# #         print("[ERROR] No MP4 files found after rendering.")
+# #         return None
+# #     mp4s.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+# #     print(f"[DEBUG] Rendered MP4: {mp4s[0]}")
+# #     return mp4s[0]
+
+
+# def _run_manim(
+#     scene_py_path: Path,
+#     scene_class: str,
+#     work_dir: Path,
+#     log_file: Path,
+#     quality_flag: str = "-ql",
+#     timeout: int = 300
+# ) -> Optional[Path]:
+#     """
+#     Run a Manim render inside a temp working directory and return the final video path (.mp4 or .mov).
+#     Logs full debug details and ensures the output is stored inside `work_dir`.
+#     """
+#     import sys, subprocess, shutil, time
+
+#     print(f"\n[DEBUG] 🎬 Starting Manim render for scene '{scene_class}'...")
+#     print(f"[DEBUG] Working directory: {work_dir}")
+#     print(f"[DEBUG] Scene file: {scene_py_path}")
+
+#     base = [sys.executable, "-m", "manim"]
+#     out_name = f"{scene_py_path.stem}_{scene_class}"
+
+#     # ✅ Expected output path (any format)
+#     expected_output = work_dir / f"{out_name}"
+#     print(f"[DEBUG] Expected output file prefix: {expected_output}")
+
+#     # ✅ Manim command (saves media inside tmp/media/)
+#     scene_filename = Path(scene_py_path).name  # only file name, not full path
+#     cmd = [*base, quality_flag, "-t", scene_filename, scene_class, "-o", out_name]
+
+#     print(f"[DEBUG] Command: {' '.join(cmd)}")
+
+#     # ✅ Run the process
+#     try:
+#         with log_file.open("ab") as lf:
+#             start = time.time()
+#             proc = subprocess.run(cmd, cwd=str(work_dir), stdout=lf, stderr=lf, timeout=timeout)
+#             elapsed = time.time() - start
+#             print(f"[DEBUG] Manim completed in {elapsed:.2f}s with code {proc.returncode}")
+#             if proc.returncode != 0:
+#                 print("[ERROR] ❌ Manim render failed.")
+#                 return None
+#     except Exception as e:
+#         print(f"[ERROR] ❌ Exception during manim run: {e}")
+#         return None
+
+#     # ✅ Search for rendered video files (.mp4 or .mov)
+#     print("[DEBUG] Scanning for video outputs...")
+#     search_dirs = [
+#         work_dir,
+#         work_dir / "media",
+#         work_dir / "media" / "videos"
+#     ]
+
+#     videos = []
+#     for folder in search_dirs:
+#         if folder.exists():
+#             found = list(folder.rglob("*.mp4")) + list(folder.rglob("*.mov"))
+#             videos.extend(found)
+#             print(f"[DEBUG] → {folder}: {len(found)} video(s) found")
+
+#     if not videos:
+#         print("[ERROR] ❌ No video file found after scanning all media directories.")
+#         return None
+
+#     videos.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+#     final_video = videos[0]
+
+#     print(f"[SUCCESS] ✅ Rendered video detected at: {final_video}")
+
+#     # ✅ Copy file back to work_dir (for consistent access)
+#     dest = work_dir / final_video.name
+#     if final_video != dest:
+#         try:
+#             shutil.copy2(final_video, dest)
+#             print(f"[DEBUG] Copied render result → {dest}")
+#         except Exception as e:
+#             print(f"[WARN] ⚠️ Could not copy final video: {e}")
+
+#     print(f"[INFO] 🎉 Final render saved successfully at:\n    {dest}")
+#     print("-" * 70)
+#     return dest
+
+# def process_image_pipeline(task_meta: Dict) -> Dict:
+#     print("\n================= PIPELINE START =================")
+#     print(f"[INFO] Task metadata received: {task_meta}")
+#     task_id = task_meta.get("task_id")
+#     task_dir = Path(task_meta.get("task_dir", ""))
+#     if not task_id or not task_dir.exists():
+#         print("[ERROR] Invalid task: Missing task_id or task_dir.")
+#         return {"success": False, "error": "invalid-task"}
+
+#     working = task_dir / "working"
+#     outputs = task_dir / "outputs"
+#     logs = task_dir / "logs"
+#     working.mkdir(parents=True, exist_ok=True)
+#     outputs.mkdir(parents=True, exist_ok=True)
+#     logs.mkdir(parents=True, exist_ok=True)
+#     print(f"[DEBUG] Working directories prepared under {task_dir}")
+
+#     log_file = logs / f"{task_id}.log"
+
+#     try:
+#         input_image = Path(task_meta.get("input_image"))
+#         if not input_image.exists():
+#             print(f"[ERROR] Input image missing: {input_image}")
+#             return {"success": False, "error": "input-missing"}
+
+#         safe_input = working / input_image.name
+#         shutil.copy2(input_image, safe_input)
+#         print(f"[DEBUG] Input image copied to working directory: {safe_input}")
+
+#         svg_path = working / f"{task_id}.svg"
+#         print("[DEBUG] Starting vectorization...")
+
+#         vec_res = vectorize_image(safe_input, options={"quality": task_meta.get("quality")})
+#         print(f"[DEBUG] Vectorization result: {vec_res.keys()}")
+
+#         if not vec_res.get("success"):
+#             print(f"[ERROR] Vectorization failed: {vec_res.get('error')}")
+#             return {"success": False, "error": f"vectorize-failed:{vec_res.get('error')}"}
+
+#         svg_content = vec_res.get("svg")
+#         if not svg_content:
+#             print("[ERROR] Vectorizer returned empty SVG content.")
+#             return {"success": False, "error": "vectorizer-did-not-return-svg"}
+
+#         svg_path.write_text(svg_content, encoding="utf-8")
+#         print(f"[DEBUG] SVG written to: {svg_path}")
+
+#         style = task_meta.get("style", "fade-in")
+#         anim_fn = STYLE_MAP.get(style, text_animations.fade_in)
+#         print(f"[DEBUG] Selected animation style: {style}")
+
+#         scene_info = anim_fn(svg_path, working, task_meta)
+#         if not scene_info or "scene_name" not in scene_info or "scene_code" not in scene_info:
+#             print("[ERROR] Invalid animation function result.")
+#             return {"success": False, "error": "animation-fn-invalid"}
+
+#         scene_name = scene_info["scene_name"]
+#         scene_code = scene_info["scene_code"]
+
+#         scene_py = working / f"scene_{task_id}.py"
+#         scene_py.write_text(scene_code, encoding="utf-8")
+#         print(f"[DEBUG] Scene file written: {scene_py}")
+
+#         try:
+#             shutil.copy2(svg_path, working / svg_path.name)
+#         except Exception as e:
+#             print(f"[WARN] Could not copy SVG: {e}")
+
+#         q = task_meta.get("quality", "preview")
+#         quality_flag = "-ql" if q == "preview" else "-qh" if q == "final" else "-qm"
+#         print(f"[DEBUG] Render quality flag: {quality_flag}")
+
+#         rendered_mp4 = _run_manim(scene_py, scene_name, working, log_file, quality_flag=quality_flag, timeout=900)
+#         if not rendered_mp4:
+#             print("[ERROR] Manim render failed.")
+#             return {"success": False, "error": "manim-render-failed", "log": str(log_file)}
+
+#         dest = GLOBAL_OUTPUTS_DIR / f"{task_id}_{rendered_mp4.name}"
+#         try:
+#             if dest.exists():
+#                 dest.unlink()
+#             shutil.copy2(rendered_mp4, dest)
+#             print(f"[DEBUG] Final output copied to global outputs dir: {dest}")
+#         except Exception as e:
+#             print(f"[ERROR] Failed to copy output: {e}")
+#             return {"success": False, "error": f"copy-failed:{e}", "log": str(log_file)}
+
+#         try:
+#             shutil.rmtree(working)
+#             print("[DEBUG] Cleaned up working directory.")
+#         except Exception as e:
+#             print(f"[WARN] Could not remove working directory: {e}")
+
+#         print(f"[SUCCESS] Task {task_id} completed successfully.")
+#         print("================= PIPELINE END =================\n")
+#         return {"success": True, "output_path": str(dest), "log": str(log_file),"output_bytes": dest.read_bytes(),}
+
+#     except Exception as e:
+#         print(f"[ERROR] Unexpected exception in pipeline: {e}")
+#         print("================= PIPELINE FAILED =================\n")
+#         return {"success": False, "error": str(e), "log": str(log_file)}
+
+
+
+
+# app/core/pipeline.py
+
+import sys
+import shutil
+import subprocess
+import time
+from pathlib import Path
+from typing import Dict, Optional
+from core.vectorizer import vectorize_image
+# type: ignore
+from moviepy.video.io.VideoFileClip import VideoFileClip
+# Animation modules
+import core.text_animations as text_animations
+import core.logo_animations as logo_animations
+import core.shape_animations as shape_animations
+import core.fx_animations as fx_animations
+import core.transitions as transitions
+import core.infographic_animations as infographic_animations
+import core.character_animations as character_animations
+import core.background_animations as background_animations
+import core.overlay_animations as overlay_animations
+
+
+# === GLOBAL OUTPUT DIR ===
+TMP_DIR = Path("tmp")
+TMP_DIR.mkdir(exist_ok=True)
+GLOBAL_OUTPUTS_DIR = TMP_DIR / "outputs"
+GLOBAL_OUTPUTS_DIR.mkdir(parents=True, exist_ok=True)
+
+# === STYLE MAP ===
+STYLE_MAP = {
+    "fade-in": text_animations.fade_in,
+    "slide-in-left": text_animations.slide_in_left,
+    "pop-bounce": text_animations.pop_bounce,
+    "zoom-in": text_animations.zoom_in,
+    "typewriter": text_animations.typewriter,
+    "wipe": text_animations.wipe_mask,
+    "flip": text_animations.flip_rotate,
+    "blur-in": text_animations.blur_in,
+    "scale-up": text_animations.scale_up,
+    "neon-glow": text_animations.neon_glow,
+    "gradient-fill": text_animations.gradient_fill,
+    "wave-ripple": text_animations.wave_ripple,
+    "split-text": text_animations.split_text,
+    "logo-build": logo_animations.logo_build_lines,
+    "logo-particle": logo_animations.logo_fade_particle,
+    "logo-spin": logo_animations.logo_spin_scale,
+    "logo-stroke": logo_animations.logo_stroke_draw,
+    "logo-glitch": logo_animations.logo_glitch,
+    "line-draw": shape_animations.line_draw,
+    "shape-morph": shape_animations.shape_morph,
+    "grow-center": shape_animations.grow_center,
+    "floating": shape_animations.floating_bounce,
+    "particle-burst": fx_animations.particle_burst,
+    "smoke": fx_animations.smoke_effect,
+    "light-rays": fx_animations.light_rays,
+    "fade-transition": transitions.fade_transition,
+    "bar-chart": infographic_animations.bar_chart_grow,
+    "count-number": infographic_animations.number_count,
+    "walk-cycle": character_animations.walk_cycle,
+    "bobbing": character_animations.bobbing,
+    "animated-gradient": background_animations.animated_gradient,
+    "particle-motion": background_animations.particle_motion,
+    "confetti": overlay_animations.confetti,
+    "checkmark": overlay_animations.checkmark_tick,
+}
+
+
+# # === MANIM RUNNER ===
+# def _run_manim(scene_py_path: Path, scene_class: str, quality_flag: str = "-ql", timeout: int = 300) -> Optional[Path]:
+#     """Run Manim and return the rendered video path."""
+#     print(f"\n🎬 Running Manim for scene: {scene_class}")
+
+#     cmd = [
+#         sys.executable,
+#         "-m",
+#         "manim",
+#         quality_flag,
+#         "-t",
+#         scene_py_path.name,
+#         scene_class,
+#         "-o",
+#         f"{scene_class}_output",
+#     ]
+
+#     print(f"→ Command: {' '.join(cmd)}")
+
+#     try:
+#         subprocess.run(cmd, cwd=scene_py_path.parent, check=True, timeout=timeout)
+#     except subprocess.CalledProcessError:
+#         print("❌ Manim render failed.")
+#         return None
+#     except Exception as e:
+#         print(f"❌ Exception: {e}")
+#         return None
+
+#     # Search output
+#     rendered = list(scene_py_path.parent.rglob("*.mp4")) + list(scene_py_path.parent.rglob("*.mov"))
+#     if not rendered:
+#         print("❌ No output file found after render.")
+#         return None
+
+#     rendered.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+#     output_file = rendered[0]
+#     print(f"✅ Rendered file: {output_file}")
+#     return output_file
+
+
+# # === PIPELINE ===
+# def process_image_pipeline(task_meta: Dict) -> Dict:
+#     """Simplified image → SVG → Manim video pipeline."""
+#     print("\n================= PIPELINE START =================")
+#     print(f"Metadata: {task_meta}")
+
+#     try:
+#         task_id = task_meta.get("task_id", "no_id")
+#         input_image = Path(task_meta.get("input_image", ""))
+#         if not input_image.exists():
+#             print(f"❌ Input image not found: {input_image}")
+#             return {"success": False, "error": "input-not-found"}
+
+#         style = task_meta.get("style", "fade-in")
+#         quality = task_meta.get("quality", "preview")
+
+#         # === Work directly inside tmp/ ===
+#         work_dir = TMP_DIR / f"{task_id}"
+#         work_dir.mkdir(exist_ok=True)
+
+#         safe_input = work_dir / input_image.name
+#         shutil.copy2(input_image, safe_input)
+
+#         print(f"🖼️ Copied input → {safe_input}")
+
+#         # === Vectorize ===
+#         vec_res = vectorize_image(safe_input, options={"quality": quality})
+#         if not vec_res.get("success"):
+#             print("❌ Vectorization failed.")
+#             return {"success": False, "error": vec_res.get("error")}
+
+#         svg_path = work_dir / f"{task_id}.svg"
+#         svg_path.write_text(vec_res.get("svg", ""), encoding="utf-8")
+#         print(f"🧩 SVG written → {svg_path}")
+
+#         # === Animation ===
+#         anim_fn = STYLE_MAP.get(style, text_animations.fade_in)
+#         scene_info = anim_fn(svg_path, work_dir, task_meta)
+
+#         scene_name = scene_info["scene_name"]
+#         scene_code = scene_info["scene_code"]
+
+#         scene_py = work_dir / f"{scene_name}.py"
+#         scene_py.write_text(scene_code, encoding="utf-8")
+#         print(f"🎞️ Scene file written → {scene_py}")
+
+#         quality_flag = "-ql" if quality == "preview" else "-qh" if quality == "final" else "-qm"
+#         output_file = _run_manim(scene_py, scene_name, quality_flag=quality_flag)
+
+#         if not output_file:
+#             return {"success": False, "error": "render-failed"}
+
+#         final_output = GLOBAL_OUTPUTS_DIR / f"{task_id}.mp4"
+        
+#         shutil.copy2(output_file, final_output)
+#         print(f"📦 Final output copied → {final_output}")
+
+#         print("================= PIPELINE END =================\n")
+#         return {
+#             "success": True,
+#             "output_path": str(final_output),
+#             "output_bytes": final_output.read_bytes(),
+#         }
+
+#     except Exception as e:
+#         print(f"❌ Exception in pipeline: {e}")
+#         print("================= PIPELINE FAILED =================\n")
+#         return {"success": False, "error": str(e)}
+
+
+
+
+# === MANIM RUNNER ===
+def _run_manim(scene_py_path: Path, scene_class: str, quality_flag: str = "-ql", timeout: int = 300) -> Optional[Path]:
+    """Run Manim and return the rendered video path."""
+    print(f"\n🎬 Running Manim for scene: {scene_class}")
+
+    cmd = [
+        sys.executable,
+        "-m",
+        
+        "manim",
+        quality_flag,
+        "--transparent",
+
+        "-t",
+        scene_py_path.name,
+        scene_class,
+        "-o",
+        f"{scene_class}_output",
+    ]
+
+    print(f"→ Command: {' '.join(cmd)}")
+
+    try:
+        subprocess.run(cmd, cwd=scene_py_path.parent, check=True, timeout=timeout)
+    except subprocess.CalledProcessError:
+        print("❌ Manim render failed.")
+        return None
+    except Exception as e:
+        print(f"❌ Exception: {e}")
+        return None
+
+    # Search for rendered outputs
+    rendered = list(scene_py_path.parent.rglob("*.mp4")) + list(scene_py_path.parent.rglob("*.mov"))
+    if not rendered:
+        print("❌ No output file found after render.")
+        return None
+
+    rendered.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+    output_file = rendered[0]
+    print(f"✅ Rendered file: {output_file}")
+
+    # 🔄 Convert MOV → MP4 if needed (safe cross-platform)
+    # if output_file.suffix.lower() == ".mov":
+    #     try:
+
+    #         converted = output_file.with_suffix(".mp4")
+    #         print("🎞️ Converting .mov → .mp4 for compatibility...")
+    #         clip = VideoFileClip(str(output_file))
+    #         clip.write_videofile(str(converted), codec="libx264", audio_codec="aac")
+    #         clip.close()
+    #         output_file = converted
+    #     except Exception as e:
+    #         print(f"⚠️ MOV→MP4 conversion failed: {e}")
+    #         return None
+    
+    # if output_file.suffix.lower() == ".mov":
+    #   try:
+    #      converted = output_file.with_suffix(".webm")
+    #      print("🎞️ Converting .mov → .webm (keeping transparency)...")
+
+
+    #      cmd = [
+    #         "ffmpeg",
+    #         "-y",
+    #         "-i", str(output_file),
+    #         "-c:v", "libvpx-vp9",
+    #         "-pix_fmt", "yuva420p",  # ✅ keep alpha channel
+    #         "-b:v", "4M",
+    #         "-auto-alt-ref", "0",
+    #         str(converted)
+    #      ]
+
+    #      subprocess.run(cmd, check=True)
+    #      output_file1 = converted
+    #      print(f"✅ Converted successfully → {converted}")
+
+    #   except Exception as e:
+    #      print(f"⚠️ MOV→WEBM conversion failed: {e}")
+    #      return None
+
+    return output_file
+
+
+# === PIPELINE ===
+def process_image_pipeline(task_meta: Dict) -> Dict:
+    """Simplified image → SVG → Manim video pipeline."""
+    print("\n================= PIPELINE START =================")
+    print(f"Metadata: {task_meta}")
+
+    try:
+        task_id = task_meta.get("task_id", "no_id")
+        input_image = Path(task_meta.get("input_image", ""))
+        if not input_image.exists():
+            print(f"❌ Input image not found: {input_image}")
+            return {"success": False, "error": "input-not-found"}
+
+        style = task_meta.get("style", "fade-in")
+        quality = task_meta.get("quality", "final")
+
+        # === Work directly inside tmp/ ===
+        work_dir = TMP_DIR / f"{task_id}"
+        work_dir.mkdir(exist_ok=True)
+
+        safe_input = work_dir / input_image.name
+        shutil.copy2(input_image, safe_input)
+        print(f"🖼️ Copied input → {safe_input}")
+
+        # === Vectorize ===
+        vec_res = vectorize_image(safe_input, options={"quality": quality})
+        if not vec_res.get("success"):
+            print("❌ Vectorization failed.")
+            return {"success": False, "error": vec_res.get("error")}
+
+        svg_path = work_dir / f"{task_id}.svg"
+        svg_path.write_text(vec_res.get("svg", ""), encoding="utf-8")
+        print(f"🧩 SVG written → {svg_path}")
+
+        # === Animation ===
+        anim_fn = STYLE_MAP.get(style, text_animations.fade_in)
+        scene_info = anim_fn(svg_path, work_dir, task_meta)
+
+        scene_name = scene_info["scene_name"]
+        scene_code = scene_info["scene_code"]
+
+        scene_py = work_dir / f"{scene_name}.py"
+        scene_py.write_text(scene_code, encoding="utf-8")
+        print(f"🎞️ Scene file written → {scene_py}")
+
+        # === Run Manim ===
+        quality_flag = "-ql" if quality == "preview" else "-qh" if quality == "final" else "-qm"
+        output_file = _run_manim(scene_py, scene_name, quality_flag=quality_flag)
+
+        if not output_file:
+            print("❌ Render failed, no output returned.")
+            return {"success": False, "error": "render-failed"}
+
+        # === Copy Final Output ===
+        final_output = GLOBAL_OUTPUTS_DIR / f"{task_id}.mov"
+        shutil.copy2(output_file, final_output)
+        print(f"📦 Final output copied → {final_output}")
+
+        print("================= PIPELINE END =================\n")
+
+        # === Return result in-memory ===
+        return {
+            "success": True,
+            "output_path": str(final_output),
+            # "output_bytes": final_output.read_bytes(),
+        }
+
+    except Exception as e:
+        print(f"❌ Exception in pipeline: {e}")
+        print("================= PIPELINE FAILED =================\n")
+        return {"success": False, "error": str(e)}

core/shape_animations.py

@@ -0,0 +1,54 @@
+# app/core/animations/shape_animations.py
+from pathlib import Path
+from typing import Dict
+
+def line_draw(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "LineDraw"
+    scene_code = f'''
+from manim import *
+class {scene_name}(Scene):
+    def construct(self):
+        # TODO: Draw strokes of shapes (convert svg paths to strokes)
+        svg = SVGMobject("{svg_path.name}")
+        self.play(Write(svg), run_time=1)
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}
+
+def shape_morph(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "ShapeMorph"
+    scene_code = f'''
+from manim import *
+class {scene_name}(Scene):
+    def construct(self):
+        # TODO: Morph shapes — will require matching points
+        svg = SVGMobject("{svg_path.name}")
+        self.play(FadeIn(svg), run_time=0.8)
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}
+
+def grow_center(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "GrowFromCenter"
+    scene_code = f'''
+from manim import *
+class {scene_name}(Scene):
+    def construct(self):
+        svg = SVGMobject("{svg_path.name}").scale(0.2)
+        self.play(svg.animate.scale(5), run_time=1)
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}
+
+def floating_bounce(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "FloatingBounce"
+    scene_code = f'''
+from manim import *
+class {scene_name}(Scene):
+    def construct(self):
+        svg = SVGMobject("{svg_path.name}")
+        self.play(svg.animate.shift(UP*0.3), run_time=0.6)
+        self.play(svg.animate.shift(DOWN*0.3), run_time=0.6)
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}

core/text_animations.py

@@ -0,0 +1,410 @@
+# app/core/animations/text_animations.py
+from pathlib import Path
+from typing import Dict
+
+# Each function returns: {"scene_name": "SceneClass", "scene_code": "<python source>"}
+# The scene_code should import manim and define the requested Scene subclass. Pipeline will write it to disk.
+
+
+
+
+def fade_in(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    """
+    Premium Cinematic Fade-In (edge-safe, high contrast version).
+    Glows in softly, with depth and smooth easing — looks natural,
+    vivid, and perfect for logos or text reveals.
+    """
+    scene_name = "FadeInScene"
+    svg_name = svg_path.name
+
+    scene_code = f"""
+from manim import *
+
+class {scene_name}(Scene):
+    def construct(self):
+        # Transparent background
+        self.camera.background_color = None
+
+        # Load SVG
+        svg = SVGMobject(r"{svg_name}")
+        svg.set(width=6)
+        svg.set_stroke(width=0)
+        svg.set_fill(opacity=1)
+
+        # 🌟 Create glow aura (simulated blur via scaling layers)
+        glow_layers = VGroup(
+            *[
+                svg.copy()
+                .set_opacity(0.15 - 0.03 * i)
+                .scale(1.02 + i * 0.01)
+                .set_z_index(-1)
+                for i in range(4)
+            ]
+        )
+
+        svg_group = VGroup(glow_layers, svg)
+        svg_group.move_to(ORIGIN)
+        svg_group.set_opacity(0)
+
+        self.add(svg_group)
+
+        # ✨ Dramatic fade-in with pop
+        self.play(
+            svg_group.animate
+            .scale(1.08)
+            .shift(UP * 0.15)
+            .set_opacity(1),
+            rate_func=lambda t: smooth(t) ** 0.7,  # nonlinear ease
+            run_time=2.5
+        )
+
+        # 🌬️ Subtle cinematic recoil
+        self.play(
+            svg_group.animate.scale(0.98).shift(DOWN * 0.05),
+            rate_func=there_and_back,
+            run_time=1.5
+        )
+
+        # Hold on final frame
+        self.wait(0.8)
+    """
+
+    return {"scene_name": scene_name, "scene_code": scene_code}
+
+# def slide_in_left(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+#     scene_name = "SlideInLeft"
+#     scene_code = f'''
+# from manim import *
+# class {scene_name}(Scene):
+#     def construct(self):
+#         svg = SVGMobject("{svg_path.name}")
+#         svg.set(width=6)
+#         svg.shift(LEFT*8)
+#         self.play(svg.animate.shift(RIGHT*8), run_time=1)
+#         self.wait(0.5)
+# '''
+#     return {"scene_name": scene_name, "scene_code": scene_code}
+def slide_in_left(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "SlideInLeft"
+    scene_code = f'''
+from manim import *
+
+class {scene_name}(Scene):
+    def construct(self):
+        # Load SVG with high quality
+        svg = SVGMobject("{svg_path.name}")
+        svg.set(width=6)  # adjust size
+        svg.set_stroke(width=1.5)  # make strokes visible but smooth
+        svg.set_fill(opacity=1)  # ensure colors are fully visible
+
+        # Start off-screen left
+        svg.shift(LEFT*8)
+
+        # Slide in with smooth easing
+        self.play(
+            svg.animate.shift(RIGHT*8).set_opacity(1),
+            run_time=1.5,
+            rate_func=smooth
+        )
+
+        # Optional small bounce for natural feel
+        self.play(
+            svg.animate.shift(LEFT*0.2),
+            svg.animate.shift(RIGHT*0.2),
+            run_time=0.3,
+            rate_func=there_and_back
+        )
+
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}
+
+# def pop_bounce(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+#     scene_name = "PopBounce"
+#     scene_code = f'''
+# from manim import *
+# class {scene_name}(Scene):
+#     def construct(self):
+#         svg = SVGMobject("{svg_path.name}")
+#         svg.set(width=4)
+#         self.play(svg.animate.scale(1.2), run_time=0.15)
+#         self.play(svg.animate.scale(0.9), run_time=0.12)
+#         self.play(svg.animate.scale(1.0), run_time=0.13)
+#         self.wait(0.5)
+# '''
+#     return {"scene_name": scene_name, "scene_code": scene_code}
+def pop_bounce(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "PopBounce"
+    scene_code = f'''
+from manim import *
+
+class {scene_name}(Scene):
+    def construct(self):
+        # Load SVG with high quality
+        svg = SVGMobject("{svg_path.name}")
+        svg.set(width=4)
+        svg.set_stroke(width=1.5)
+        svg.set_fill(opacity=1)
+
+        # Optional: start slightly smaller and transparent for better pop effect
+        svg.scale(0.8)
+        svg.set_opacity(0)
+
+        # Fade in while popping
+        self.play(
+            svg.animate.set_opacity(1).scale(1.25),
+            run_time=0.15,
+            rate_func=smooth
+        )
+        self.play(
+            svg.animate.scale(0.95),
+            run_time=0.12,
+            rate_func=there_and_back
+        )
+        self.play(
+            svg.animate.scale(1.0),
+            run_time=0.13,
+            rate_func=smooth
+        )
+
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}
+
+def zoom_in(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "ZoomIn"
+    scene_code = f'''
+from manim import *
+class {scene_name}(Scene):
+    def construct(self):
+        svg = SVGMobject("{svg_path.name}").scale(0.2)
+        self.add(svg)
+        self.play(svg.animate.scale(5), run_time=1)
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}
+
+# def typewriter(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+#     scene_name = "Typewriter"
+#     scene_code = f'''
+# from manim import *
+# class {scene_name}(Scene):
+#     def construct(self):
+#         # For text-based typewriter you might want to use Text/MarkupText
+#         txt = Text("Typewriter placeholder")
+#         self.play(Write(txt), run_time=1.5)
+#         self.wait(0.5)
+# '''
+#     return {"scene_name": scene_name, "scene_code": scene_code}
+# def typewriter(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+#     scene_name = "Typewriter"
+#     scene_code = f'''
+# from manim import *
+
+# class {scene_name}(Scene):
+#     def construct(self):
+#         # Load the uploaded SVG
+#         svg = SVGMobject("{svg_path.name}")
+#         svg.set(width=6)
+#         svg.set_stroke(width=2)
+#         svg.set_fill(opacity=1)
+#         svg.move_to(ORIGIN)
+
+#         # Break into submobjects to animate each path like typewriter strokes
+#         for sub in svg:
+#             sub.set_opacity(0)  # start invisible
+
+#         # Typewriter-style progressive drawing
+#         for sub in svg:
+#             sub.set_opacity(1)
+#             self.play(Create(sub), run_time=0.3, rate_func=smooth)
+
+#         self.wait(0.5)
+# '''
+#     return {"scene_name": scene_name, "scene_code": scene_code}
+# def typewriter(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+#     scene_name = "Typewriter"
+#     scene_code = f'''
+# from manim import *
+
+# class {scene_name}(Scene):
+#     def construct(self):
+#         # Load the uploaded SVG
+#         svg = SVGMobject("{svg_path.name}")
+#         svg.set(width=6)
+#         svg.set_stroke(width=2)
+#         svg.set_fill(opacity=1)
+#         svg.move_to(ORIGIN)
+
+#         # Start invisible
+#         for sub in svg:
+#             sub.set_opacity(0)
+#             sub.scale(0.95)  # start slightly smaller for cinematic pop
+
+#         # Draw each path progressively
+#         for sub in svg:
+#             sub.set_opacity(1)
+#             self.play(
+#                 Create(sub),
+#                 sub.animate.scale(1.05),  # subtle overshoot
+#                 run_time=0.35,
+#                 rate_func=smooth
+#             )
+#             # Scale back smoothly
+#             self.play(sub.animate.scale(0.95), run_time=0.1, rate_func=there_and_back)
+
+#         # Optional: add a blinking cursor at the end
+#         cursor = Line(start=svg.get_right(), end=svg.get_right() + UP*0.5, stroke_width=2)
+#         self.add(cursor)
+#         for _ in range(6):
+#             self.play(cursor.animate.set_opacity(0), run_time=0.3)
+#             self.play(cursor.animate.set_opacity(1), run_time=0.3)
+
+#         self.wait(0.5)
+# '''
+#     return {"scene_name": scene_name, "scene_code": scene_code}
+def typewriter(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "Typewriter"
+    scene_code = f'''
+from manim import *
+
+class {scene_name}(Scene):
+    def construct(self):
+        # Load the uploaded SVG
+        svg = SVGMobject("{svg_path.name}")
+        svg.set(width=6)
+        svg.set_stroke(width=2)
+        svg.set_fill(opacity=1)
+        svg.move_to(ORIGIN)
+
+        # Start almost invisible for smooth fade-in
+        for sub in svg:
+            sub.set_opacity(0.05)
+            sub.scale(0.98)  # subtle initial scale for cinematic feel
+
+        # Animate each path like a cinematic typewriter
+        for sub in svg:
+            self.play(
+                Create(sub),
+                sub.animate.set_opacity(1).scale(1.0),  # fade in while drawing
+                run_time=0.35,
+                rate_func=smooth
+            )
+
+        # Optional: add a subtle blinking cursor at the end
+        cursor = Line(start=svg.get_right(), end=svg.get_right() + UP*0.5, stroke_width=2)
+        self.add(cursor)
+        for _ in range(6):
+            self.play(cursor.animate.set_opacity(0), run_time=0.3, rate_func=smooth)
+            self.play(cursor.animate.set_opacity(1), run_time=0.3, rate_func=smooth)
+
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}
+
+def wipe_mask(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "WipeMask"
+    scene_code = f'''
+from manim import *
+class {scene_name}(Scene):
+    def construct(self):
+        svg = SVGMobject("{svg_path.name}")
+        bar = Rectangle(width=8, height=6).set_fill(BLACK, opacity=1).to_edge(LEFT)
+        self.add(bar)
+        self.play(bar.animate.shift(RIGHT*8), run_time=1)
+        self.add(svg)
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}
+
+def flip_rotate(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "FlipRotate"
+    scene_code = f'''
+from manim import *
+class {scene_name}(Scene):
+    def construct(self):
+        svg = SVGMobject("{svg_path.name}")
+        self.play(Rotate(svg, angle=PI), run_time=0.8)
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}
+
+def blur_in(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "BlurIn"
+    scene_code = f'''
+from manim import *
+class {scene_name}(Scene):
+    def construct(self):
+        svg = SVGMobject("{svg_path.name}")
+        # TODO: Add blur-like effect (manim's blur is limited)
+        self.play(FadeIn(svg), run_time=0.8)
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}
+
+def scale_up(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "ScaleUp"
+    scene_code = f'''
+from manim import *
+class {scene_name}(Scene):
+    def construct(self):
+        svg = SVGMobject("{svg_path.name}")
+        svg.scale(0.2)
+        self.play(svg.animate.scale(5), run_time=1)
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}
+
+# --- Premium / stylish placeholders ---
+def neon_glow(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "NeonGlow"
+    scene_code = f'''
+from manim import *
+class {scene_name}(Scene):
+    def construct(self):
+        svg = SVGMobject("{svg_path.name}")
+        # TODO: Implement neon glow using strokes, duplications, and blurs
+        self.play(FadeIn(svg), run_time=0.8)
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}
+
+def gradient_fill(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "GradientFill"
+    scene_code = f'''
+from manim import *
+class {scene_name}(Scene):
+    def construct(self):
+        # TODO: Add gradient fill by generating shapes or using shaders
+        svg = SVGMobject("{svg_path.name}")
+        self.play(FadeIn(svg), run_time=0.8)
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}
+
+def wave_ripple(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "WaveRipple"
+    scene_code = f'''
+from manim import *
+class {scene_name}(Scene):
+    def construct(self):
+        # TODO: Animate vertices or use transforms for wave effect
+        svg = SVGMobject("{svg_path.name}")
+        self.play(FadeIn(svg), run_time=0.8)
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}
+
+# Add more premium functions (split_text, stroke_draw, brush_reveal, liquid, 3d_rotate, sparkle)
+def split_text(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "SplitTextReveal"
+    scene_code = f'''
+from manim import *
+class {scene_name}(Scene):
+    def construct(self):
+        # TODO: Split text into letters and animate
+        svg = SVGMobject("{svg_path.name}")
+        self.play(FadeIn(svg), run_time=0.8)
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}

core/transitions.py

@@ -0,0 +1,26 @@
+# app/core/animations/transitions.py
+from pathlib import Path
+from typing import Dict
+
+def fade_transition(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "FadeTransition"
+    scene_code = f'''
+from manim import *
+class {scene_name}(Scene):
+    def construct(self):
+        bg = Rectangle(width=14, height=8).set_fill(BLACK, opacity=0)
+        self.play(FadeIn(bg), run_time=0.5)
+        self.wait(0.1)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}
+
+def slide_transition(svg_path: Path, working_dir: Path, task_meta: Dict) -> Dict:
+    scene_name = "SlideTransition"
+    scene_code = f'''
+from manim import *
+class {scene_name}(Scene):
+    def construct(self):
+        # TODO: create in/out slides
+        self.wait(0.5)
+'''
+    return {"scene_name": scene_name, "scene_code": scene_code}

core/vectorizer.py

@@ -0,0 +1,868 @@
+# # app/core/vectorizer.py
+# from pathlib import Path
+# from typing import Dict
+
+# def vectorize_image(input_raster_path: Path, output_svg_path: Path, options: Dict = None) -> Dict:
+#     """
+#     Simple, safe vectorizer stub.
+#     - Writes a minimal SVG to output_svg_path.
+#     - You should replace with your real vectorizer (potrace, autotrace, model, etc.)
+#     Returns: {"success": True, "svg_path": str(output_svg_path)} or {"success": False, "error": "..."}
+#     """
+#     options = options or {}
+#     try:
+#         input_raster_path = Path(input_raster_path)
+#         output_svg_path = Path(output_svg_path)
+#         output_svg_path.parent.mkdir(parents=True, exist_ok=True)
+
+#         if not input_raster_path.exists():
+#             return {"success": False, "error": "input-missing"}
+
+#         # Placeholder SVG (safe). Replace with actual vector output.
+#         sample_svg = f"""<svg xmlns="http://www.w3.org/2000/svg" width="600" height="200">
+#   <rect width="100%" height="100%" fill="transparent"/>
+#   <text x="10" y="40" font-family="Arial" font-size="28">Vector placeholder for {input_raster_path.name}</text>
+# </svg>"""
+#         output_svg_path.write_text(sample_svg, encoding="utf-8")
+#         return {"success": True, "svg_path": str(output_svg_path)}
+#     except Exception as e:
+#         return {"success": False, "error": str(e)}
+
+
+
+
+
+# from pathlib import Path
+# from typing import Dict, Optional
+# import cv2
+# import numpy as np
+
+
+# def vectorize_image(input_raster_path: Path, output_svg_path: Path = None, options: Optional[Dict] = None) -> Dict:
+#     """
+#     Production-ready in-memory vectorizer.
+#     Converts raster (PNG/JPG) → SVG (string, not saved).
+    
+#     Args:
+#         input_raster_path (Path): Path to input raster image.
+#         output_svg_path (Path, optional): Ignored here, kept for compatibility.
+#         options (dict, optional): {
+#             "threshold": int (default=127),
+#             "simplify_tolerance": float (default=1.5),
+#             "quality": str (e.g., "low", "medium", "high") - optional
+#         }
+    
+#     Returns:
+#         dict: {"success": True, "svg": "<svg>...</svg>", "width": w, "height": h}
+#               or {"success": False, "error": "..."}
+#     """
+#     options = options or {}
+#     threshold_value = options.get("threshold", 127)
+#     simplify_tolerance = options.get("simplify_tolerance", 1.5)
+
+#     try:
+#         input_raster_path = Path(input_raster_path)
+#         if not input_raster_path.exists():
+#             return {"success": False, "error": "input file not found"}
+
+#         # ---- Load image ----
+#         img = cv2.imread(str(input_raster_path))
+#         if img is None:
+#             return {"success": False, "error": "invalid or unreadable image"}
+
+#         gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+#         _, thresh = cv2.threshold(gray, threshold_value, 255, cv2.THRESH_BINARY_INV)
+
+#         # ---- Find contours ----
+#         contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+#         h, w = gray.shape[:2]
+
+#         # ---- Build SVG in-memory ----
+#         svg_header = f'<svg xmlns="http://www.w3.org/2000/svg" width="{w}" height="{h}" viewBox="0 0 {w} {h}">'
+#         svg_paths = []
+
+#         for contour in contours:
+#             contour = cv2.approxPolyDP(contour, simplify_tolerance, True)
+#             if contour.shape[0] < 2:
+#                 continue
+#             path_data = "M " + " L ".join(f"{int(x)} {int(y)}" for x, y in contour[:, 0, :]) + " Z"
+#             svg_paths.append(f'<path d="{path_data}" fill="none" stroke="black" stroke-width="1"/>')
+
+#         svg_content = svg_header + "".join(svg_paths) + "</svg>"
+
+#         # ---- Return result ----
+#         return {
+#             "success": True,
+#             "svg": svg_content,
+#             "width": w,
+#             "height": h
+#         }
+
+#     except Exception as e:
+#         return {"success": False, "error": str(e)}
+
+
+# from pathlib import Path
+# from typing import Dict, Optional
+# import cv2
+# import numpy as np
+
+
+# def vectorize_image(input_raster_path: Path, output_svg_path: Path = None, options: Optional[Dict] = None) -> Dict:
+#     """
+#     Production-ready in-memory vectorizer.
+#     Converts raster (PNG/JPG) → SVG (string, not saved).
+    
+#     Args:
+#         input_raster_path (Path): Path to input raster image.
+#         output_svg_path (Path, optional): Ignored here, kept for compatibility.
+#         options (dict, optional): {
+#             "threshold": int (default=127),
+#             "simplify_tolerance": float (default=1.5),
+#             "quality": str (e.g., "low", "medium", "high") - optional
+#         }
+    
+#     Returns:
+#         dict: {"success": True, "svg": "<svg>...</svg>", "width": w, "height": h}
+#               or {"success": False, "error": "..."}
+#     """
+#     print("\n[DEBUG] 🧩 Starting vectorize_image()...")
+#     print(f"[DEBUG] Input raster path: {input_raster_path}")
+#     print(f"[DEBUG] Output SVG path (if any): {output_svg_path}")
+#     print(f"[DEBUG] Options: {options}")
+
+#     options = options or {}
+#     threshold_value = options.get("threshold", 127)
+#     simplify_tolerance = options.get("simplify_tolerance", 1.5)
+
+#     print(f"[DEBUG] Using threshold={threshold_value}, simplify_tolerance={simplify_tolerance}")
+
+#     try:
+#         input_raster_path = Path(input_raster_path)
+#         if not input_raster_path.exists():
+#             print("[ERROR] ❌ Input file not found.")
+#             return {"success": False, "error": "input file not found"}
+
+#         # ---- Load image ----
+#         img = cv2.imread(str(input_raster_path))
+#         if img is None:
+#             print("[ERROR] ❌ Invalid or unreadable image.")
+#             return {"success": False, "error": "invalid or unreadable image"}
+
+#         print(f"[DEBUG] Image loaded successfully. Shape: {img.shape}")
+
+#         gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+#         print("[DEBUG] Converted image to grayscale.")
+
+#         _, thresh = cv2.threshold(gray, threshold_value, 255, cv2.THRESH_BINARY_INV)
+#         print("[DEBUG] Applied thresholding to generate binary image.")
+
+#         # ---- Find contours ----
+#         contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+#         h, w = gray.shape[:2]
+#         print(f"[DEBUG] Found {len(contours)} contours. Image size: {w}x{h}")
+
+#         # ---- Build SVG in-memory ----
+#         svg_header = f'<svg xmlns="http://www.w3.org/2000/svg" width="{w}" height="{h}" viewBox="0 0 {w} {h}">'
+#         svg_paths = []
+
+#         for i, contour in enumerate(contours):
+#             contour = cv2.approxPolyDP(contour, simplify_tolerance, True)
+#             if contour.shape[0] < 2:
+#                 print(f"[DEBUG] Skipping small contour #{i} (too few points).")
+#                 continue
+#             path_data = "M " + " L ".join(f"{int(x)} {int(y)}" for x, y in contour[:, 0, :]) + " Z"
+#             svg_paths.append(f'<path d="{path_data}" fill="none" stroke="black" stroke-width="1"/>')
+#             print(f"[DEBUG] Added contour #{i} with {contour.shape[0]} points to SVG.")
+
+#         svg_content = svg_header + "".join(svg_paths) + "</svg>"
+
+#         print("[DEBUG] SVG generation completed successfully.")
+#         print(f"[DEBUG] Total paths in SVG: {len(svg_paths)}")
+
+#         # ---- Return result ----
+#         print("[SUCCESS] ✅ Vectorization completed.")
+#         return {
+#             "success": True,
+#             "svg": svg_content,
+#             "width": w,
+#             "height": h
+#         }
+
+#     except Exception as e:
+#         print(f"[ERROR] ❌ Exception in vectorize_image(): {e}")
+#         return {"success": False, "error": str(e)}
+
+
+
+from pathlib import Path
+from typing import Dict, Optional
+import cv2
+import numpy as np
+
+# def vectorize_image(input_raster_path: Path, output_svg_path: Path = None, options: Optional[Dict] = None) -> Dict:
+#     """
+#     Converts a raster (PNG/JPG) into a backgroundless SVG that represents visible shapes.
+#     Supports transparency, soft edges, and grayscale drawings.
+#     """
+#     print("\n[DEBUG] 🧩 Starting vectorize_image()...")
+#     input_raster_path = Path(input_raster_path)
+#     if not input_raster_path.exists():
+#         return {"success": False, "error": "input file not found"}
+
+#     options = options or {}
+#     threshold_value = options.get("threshold", 180)
+#     simplify_tolerance = options.get("simplify_tolerance", 2.0)
+#     stroke_color = options.get("stroke_color", "black")
+
+#     print(f"[DEBUG] Reading image: {input_raster_path}")
+#     img = cv2.imread(str(input_raster_path), cv2.IMREAD_UNCHANGED)
+#     if img is None:
+#         return {"success": False, "error": "cannot read image"}
+
+#     h, w = img.shape[:2]
+#     print(f"[DEBUG] Image shape: {w}x{h}")
+
+#     # ---- Handle alpha channel for transparency ----
+#     if img.shape[2] == 4:
+#         b, g, r, a = cv2.split(img)
+#         alpha_mask = a
+#         print("[DEBUG] Image has alpha channel (transparency detected).")
+#     else:
+#         b, g, r = cv2.split(img)
+#         alpha_mask = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+#         print("[DEBUG] No alpha channel, using grayscale as mask.")
+
+#     # Invert alpha if background is white
+#     mean_val = np.mean(alpha_mask)
+#     if mean_val > 200:
+#         alpha_mask = 255 - alpha_mask
+#         print("[DEBUG] Inverted mask since background seemed white.")
+
+#     # ---- Threshold to get visible content ----
+#     _, binary = cv2.threshold(alpha_mask, threshold_value, 255, cv2.THRESH_BINARY)
+#     print("[DEBUG] Applied adaptive threshold.")
+
+#     # ---- Find contours ----
+#     contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+#     print(f"[DEBUG] Found {len(contours)} contours in drawing.")
+
+#     svg_header = f'<svg xmlns="http://www.w3.org/2000/svg" width="{w}" height="{h}" viewBox="0 0 {w} {h}">'
+#     svg_paths = []
+
+#     for i, contour in enumerate(contours):
+#         contour = cv2.approxPolyDP(contour, simplify_tolerance, True)
+#         if contour.shape[0] < 3:
+#             continue
+#         path_data = "M " + " L ".join(f"{int(x)} {int(y)}" for x, y in contour[:, 0, :]) + " Z"
+#         svg_paths.append(f'<path d="{path_data}" fill="none" stroke="{stroke_color}" stroke-width="1"/>')
+
+#     svg_content = svg_header + "".join(svg_paths) + "</svg>"
+#     print(f"[DEBUG] Generated SVG with {len(svg_paths)} paths.")
+
+#     if len(svg_paths) == 0:
+#         print("[WARN] No visible content detected in the image.")
+
+#     return {
+#         "success": True,
+#         "svg": svg_content,
+#         "width": w,
+#         "height": h
+#     }
+
+
+# def vectorize_image(input_raster_path: Path, output_svg_path: Path = None, options: Optional[Dict] = None) -> Dict:
+#     """
+#     Converts a raster (PNG/JPG) into a backgroundless SVG that represents visible shapes.
+#     Supports transparency, soft edges, grayscale drawings, and colored logos.
+#     """
+#     print("\n[DEBUG] 🧩 Starting vectorize_image()...")
+#     input_raster_path = Path(input_raster_path)
+#     if not input_raster_path.exists():
+#         return {"success": False, "error": "input file not found"}
+
+#     options = options or {}
+#     threshold_value = options.get("threshold", 180)
+#     simplify_tolerance = options.get("simplify_tolerance", 2.0)
+#     stroke_color = options.get("stroke_color", "black")
+
+#     print(f"[DEBUG] Reading image: {input_raster_path}")
+#     img = cv2.imread(str(input_raster_path), cv2.IMREAD_UNCHANGED)
+#     if img is None:
+#         return {"success": False, "error": "cannot read image"}
+
+#     h, w = img.shape[:2]
+#     print(f"[DEBUG] Image shape: {w}x{h}")
+
+#     # ---- Handle alpha channel for transparency ----
+#     if img.shape[2] == 4:
+#         b, g, r, a = cv2.split(img)
+#         alpha_mask = a
+#         print("[DEBUG] Image has alpha channel (transparency detected).")
+#     else:
+#         b, g, r = cv2.split(img)
+#         alpha_mask = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+#         print("[DEBUG] No alpha channel, using grayscale as mask.")
+
+#     # Invert alpha if background is white
+#     mean_val = np.mean(alpha_mask)
+#     if mean_val > 200:
+#         alpha_mask = 255 - alpha_mask
+#         print("[DEBUG] Inverted mask since background seemed white.")
+
+#     # ---- Threshold to get visible content ----
+#     _, binary = cv2.threshold(alpha_mask, threshold_value, 255, cv2.THRESH_BINARY)
+#     print("[DEBUG] Applied adaptive threshold.")
+
+#     # ---- Find contours ----
+#     contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+#     print(f"[DEBUG] Found {len(contours)} contours in drawing.")
+
+#     svg_header = f'<svg xmlns="http://www.w3.org/2000/svg" width="{w}" height="{h}" viewBox="0 0 {w} {h}">'
+#     svg_paths = []
+
+#     for i, contour in enumerate(contours):
+#         contour = cv2.approxPolyDP(contour, simplify_tolerance, True)
+#         if contour.shape[0] < 3:
+#             continue
+
+#         # ---- Sample mean color inside contour for fill ----
+#         mask = np.zeros((h, w), dtype=np.uint8)
+#         cv2.drawContours(mask, [contour], -1, 255, -1)
+#         mean_color = cv2.mean(img[:, :, :3], mask=mask)
+#         fill_color = f"rgb({int(mean_color[2])},{int(mean_color[1])},{int(mean_color[0])})"  # RGB
+
+#         path_data = "M " + " L ".join(f"{int(x)} {int(y)}" for x, y in contour[:, 0, :]) + " Z"
+#         svg_paths.append(f'<path d="{path_data}" fill="{fill_color}" stroke="{stroke_color}" stroke-width="1"/>')
+
+#     svg_content = svg_header + "".join(svg_paths) + "</svg>"
+#     print(f"[DEBUG] Generated SVG with {len(svg_paths)} paths.")
+
+#     if len(svg_paths) == 0:
+#         print("[WARN] No visible content detected in the image.")
+
+#     # Save SVG if path provided
+#     if output_svg_path:
+#         Path(output_svg_path).write_text(svg_content)
+#         print(f"[DEBUG] SVG saved to: {output_svg_path}")
+
+#     return {
+#         "success": True,
+#         "svg": svg_content,
+#         "width": w,
+#         "height": h
+#     }
+
+
+# def vectorize_image(input_raster_path: Path, output_svg_path: Path = None, options: Optional[Dict] = None) -> Dict:
+#     """
+#     Converts a raster (PNG/JPG) into an SVG that visually matches the original.
+#     Preserves colors, gradients, and transparency perfectly by embedding the image.
+#     """
+#     print("\n[DEBUG] 🧩 Starting vectorize_image() with full color preservation...")
+#     input_raster_path = Path(input_raster_path)
+#     if not input_raster_path.exists():
+#         return {"success": False, "error": "input file not found"}
+
+#     # Read image and encode as base64
+#     import base64
+#     import mimetypes
+
+#     mime_type, _ = mimetypes.guess_type(input_raster_path)
+#     if mime_type is None:
+#         mime_type = "image/png"
+
+#     with open(input_raster_path, "rb") as f:
+#         encoded = base64.b64encode(f.read()).decode("utf-8")
+
+#     # Read image size
+#     import cv2
+#     img = cv2.imread(str(input_raster_path), cv2.IMREAD_UNCHANGED)
+#     if img is None:
+#         return {"success": False, "error": "cannot read image"}
+
+#     h, w = img.shape[:2]
+#     print(f"[DEBUG] Image shape: {w}x{h}")
+
+#     # Construct SVG that embeds image as <image> tag
+#     svg_content = f'''<svg xmlns="http://www.w3.org/2000/svg" 
+#         width="{w}" height="{h}" viewBox="0 0 {w} {h}" version="1.1">
+#         <image href="data:{mime_type};base64,{encoded}" width="{w}" height="{h}" />
+#     </svg>'''
+
+#     if output_svg_path:
+#         Path(output_svg_path).write_text(svg_content)
+#         print(f"[DEBUG] Saved SVG with embedded image to: {output_svg_path}")
+
+#     print("[DEBUG] ✅ Vectorization complete — colors and gradients preserved perfectly.")
+#     return {
+#         "success": True,
+#         "svg": svg_content,
+#         "width": w,
+#         "height": h
+#     }
+
+
+
+# def vectorize_image(input_raster_path: Path, output_svg_path: Optional[Path] = None, options: Optional[Dict] = None) -> Dict:
+#     """
+#     Converts a raster image (PNG/JPG) into a visually perfect SVG.
+#     ✅ Preserves all colors, gradients, and transparency by embedding the raster as a base64 image.
+#     ⚡ Output SVG is fully scalable and compatible with Manim or web rendering.
+#     """
+#     print("\n[DEBUG] 🎨 Starting vectorize_image() — full visual fidelity mode")
+
+#     input_raster_path = Path(input_raster_path)
+#     if not input_raster_path.exists():
+#         return {"success": False, "error": "Input file not found"}
+
+#     # Detect MIME type
+#     mime_type, _ = mimetypes.guess_type(input_raster_path)
+#     if mime_type is None:
+#         mime_type = "image/png"
+
+#     # Read and encode image
+#     with open(input_raster_path, "rb") as f:
+#         encoded = base64.b64encode(f.read()).decode("utf-8")
+
+#     # Get image size
+#     img = cv2.imread(str(input_raster_path), cv2.IMREAD_UNCHANGED)
+#     if img is None:
+#         return {"success": False, "error": "Cannot read image"}
+#     h, w = img.shape[:2]
+
+#     print(f"[DEBUG] 🖼️ Image dimensions: {w}x{h}")
+
+#     # High-quality embedded SVG
+#     svg_content = f"""<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+# <svg xmlns="http://www.w3.org/2000/svg"
+#      width="{w}px" height="{h}px"
+#      viewBox="0 0 {w} {h}"
+#      version="1.1"
+#      preserveAspectRatio="xMidYMid meet">
+#   <image width="{w}" height="{h}"
+#          href="data:{mime_type};base64,{encoded}"
+#          style="image-rendering: optimizeQuality;"
+#          preserveAspectRatio="xMidYMid meet"/>
+# </svg>
+# """
+
+#     if output_svg_path:
+#         Path(output_svg_path).write_text(svg_content, encoding="utf-8")
+#         print(f"[DEBUG] 💾 Saved high-fidelity SVG → {output_svg_path}")
+
+#     print("[DEBUG] ✅ Vectorization complete — gradients, alpha, and sharp edges preserved perfectly.")
+#     return {
+#         "success": True,
+#         "svg": svg_content,
+#         "width": w,
+#         "height": h
+#     }
+
+
+# def vectorize_image(input_raster_path: Path, output_svg_path: Optional[Path] = None, options: Optional[Dict] = None) -> Dict:
+#     """
+#     Converts a raster image (PNG/JPG/PNG with alpha) into a near visually perfect vector-based SVG.
+#     ✅ Preserves colors, gradients, and transparency as much as possible.
+#     ⚡ Output SVG is fully scalable and compatible with Manim or web rendering.
+#     """
+#     import cv2, numpy as np, mimetypes
+#     from pathlib import Path
+#     from sklearn.cluster import KMeans
+
+#     print("\n[DEBUG] 🎨 Starting vectorize_image() — high-fidelity gradient-aware mode")
+
+#     input_raster_path = Path(input_raster_path)
+#     if not input_raster_path.exists():
+#         return {"success": False, "error": "Input file not found"}
+
+#     mime_type, _ = mimetypes.guess_type(input_raster_path)
+#     if mime_type is None:
+#         mime_type = "image/png"
+
+#     # Read with alpha preserved
+#     img = cv2.imread(str(input_raster_path), cv2.IMREAD_UNCHANGED)
+#     if img is None:
+#         return {"success": False, "error": "Cannot read image"}
+
+#     if img.shape[2] == 4:
+#         bgr, alpha = img[:, :, :3], img[:, :, 3]
+#     else:
+#         bgr, alpha = img, np.full(img.shape[:2], 255, dtype=np.uint8)
+
+#     h, w = bgr.shape[:2]
+#     print(f"[DEBUG] 🖼️ Image dimensions: {w}x{h}")
+
+#     # ---------------------------
+#     # Step 1: Smart color clustering (using KMeans)
+#     # ---------------------------
+#     n_colors = (options or {}).get("colors", 24)
+#     print(f"[DEBUG] 🎨 Using {n_colors} colors for smoother accuracy")
+
+#     data = bgr.reshape((-1, 3))
+#     kmeans = KMeans(n_clusters=n_colors, n_init=4, random_state=0).fit(data)
+#     labels = kmeans.labels_.reshape(h, w)
+#     centers = np.uint8(kmeans.cluster_centers_)
+
+#     # ---------------------------
+#     # Step 2: Build SVG Paths
+#     # ---------------------------
+#     print("[DEBUG] ✏️ Extracting color regions...")
+
+#     paths = []
+#     for idx, color in enumerate(centers):
+#         mask = (labels == idx).astype(np.uint8) * 255
+#         contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+#         hex_color = "#{:02x}{:02x}{:02x}".format(*color)
+#         for cnt in contours:
+#             if len(cnt) > 3:
+#                 d = "M " + " L ".join(f"{p[0][0]},{p[0][1]}" for p in cnt) + " Z"
+#                 # Apply average alpha for this region
+#                 region_alpha = np.mean(alpha[mask == 255]) / 255.0
+#                 if region_alpha < 0.05:  # fully transparent, skip
+#                     continue
+#                 fill_opacity = round(region_alpha, 3)
+#                 paths.append((hex_color, fill_opacity, d))
+
+#     if not paths:
+#         return {"success": False, "error": "No visible regions found (maybe full transparency)"}
+
+#     print(f"[DEBUG] ✅ {len(paths)} color regions traced")
+
+#     # ---------------------------
+#     # Step 3: Gradient approximation
+#     # ---------------------------
+#     print("[DEBUG] 🌈 Estimating global color gradients...")
+#     dominant1, dominant2 = centers[0], centers[-1]
+#     grad_id = "grad_main"
+#     grad_def = f"""
+#   <defs>
+#     <linearGradient id="{grad_id}" x1="0%" y1="0%" x2="100%" y2="100%">
+#       <stop offset="0%" stop-color="#{dominant1[0]:02x}{dominant1[1]:02x}{dominant1[2]:02x}" />
+#       <stop offset="100%" stop-color="#{dominant2[0]:02x}{dominant2[1]:02x}{dominant2[2]:02x}" />
+#     </linearGradient>
+#   </defs>
+# """
+
+#     # ---------------------------
+#     # Step 4: Assemble SVG
+#     # ---------------------------
+#     svg_content = [
+#         '<?xml version="1.0" encoding="UTF-8" standalone="no"?>',
+#         f'<svg xmlns="http://www.w3.org/2000/svg" width="{w}px" height="{h}px" viewBox="0 0 {w} {h}" version="1.1">'
+#     ]
+#     svg_content.append(grad_def)
+#     for color, opacity, d in paths:
+#         svg_content.append(f'  <path d="{d}" fill="{color}" fill-opacity="{opacity}" stroke="none"/>')
+#     svg_content.append('</svg>')
+
+#     svg_content = "\n".join(svg_content)
+
+#     # Save SVG
+#     if output_svg_path:
+#         Path(output_svg_path).write_text(svg_content, encoding="utf-8")
+#         print(f"[DEBUG] 💾 Saved vectorized SVG → {output_svg_path}")
+
+#     print("[DEBUG] ✅ Vectorization complete — transparency, color, and gradient preserved.")
+#     return {
+#         "success": True,
+#         "svg": svg_content,
+#         "width": w,
+#         "height": h
+#     }
+
+
+
+
+# def vectorize_image(input_raster_path: Path, options: Optional[Dict] = None) -> Dict:
+#     """
+#     Converts a raster image (PNG/JPG/WEBP) into a high-quality vector SVG using PyVTracer.
+#     ✅ Uses only PyVTracer
+#     ✅ Returns SVG directly in memory
+#     ✅ Fixes all int/float/bool/string conversion issues
+#     """
+#     print("\n[DEBUG] 🎨 Starting vectorize_image() — final type-safe configuration")
+
+#     input_raster_path = Path(input_raster_path)
+#     if not input_raster_path.exists():
+#         return {"success": False, "error": "Input file not found"}
+
+#     opts = options or {}
+
+#     try:
+#         with Image.open(input_raster_path) as img:
+#             w, h = img.size
+
+#         tracer = pyvtracer.Vtracer()
+
+#         # ✅ Correct, final parameter typing
+#         tracer.input_path = str(input_raster_path)
+#         tracer.color_mode = str(opts.get("color_mode", "color"))
+#         tracer.filter_speckle = int(opts.get("filter_speckle", 2))
+#         tracer.corner_threshold = int(opts.get("corner_threshold", 60))
+#         tracer.color_precision = int(opts.get("color_precision", 10))
+#         tracer.layer_difference = int(opts.get("layer_difference", 16))
+#         tracer.path_precision = int(opts.get("path_precision", 2))
+#         tracer.length_threshold = int(opts.get("length_threshold", 4))
+#         tracer.splice_threshold = int(opts.get("splice_threshold", 45))
+#         tracer.hierarchical = "true" if opts.get("hierarchical", True) else "false"
+#         tracer.max_iterations = int(opts.get("max_iterations", 10))
+#         tracer.path_simplify_mode = int(opts.get("path_simplify_mode", 0))
+
+#         print("[DEBUG] ✅ All parameters properly typed (int/str).")
+#         print(f"[DEBUG] 🚀 Vectorizing: {input_raster_path.name}")
+
+#         # 🌀 Get SVG string directly
+#         if hasattr(tracer, "to_svg_string"):
+#             svg_content = tracer.to_svg_string()
+#         else:
+#             tmp_svg = Path(tempfile.gettempdir()) / f"{input_raster_path.stem}_vtrace.svg"
+#             tracer.output_path = str(tmp_svg)
+#             tracer.to_svg()
+#             svg_content = tmp_svg.read_text(encoding="utf-8")
+#             tmp_svg.unlink(missing_ok=True)
+
+#         print("[DEBUG] ✅ Vectorization complete — SVG generated in memory.")
+#         return {
+#             "success": True,
+#             "svg": svg_content,
+#             "width": w,
+#             "height": h
+#         }
+
+#     except Exception as e:
+#         print(f"❌ [ERROR] PyVTracer failed: {e}")
+#         return {"success": False, "error": f"PyVTracer failed: {e}"}
+
+
+
+# from pathlib import Path
+# from typing import Optional, Dict, Any
+# from PIL import Image
+# import tempfile
+
+# # prefer the official vtracer binding from PyPI
+# import vtracer
+
+# # mapping and sane defaults (names & types follow vtracer docs)
+# DEFAULTS: Dict[str, Any] = {
+#     "colormode": "color",        # "color" or "binary"
+#     "hierarchical": "stacked",   # "stacked" or "cutout"
+#     "mode": "spline",            # "spline", "polygon", or "none"
+#     "filter_speckle": 2,         # int
+#     "color_precision": 14,        # int
+#     "layer_difference": 6,      # int (gradient step)
+#     "corner_threshold": 50,      # int
+#     "length_threshold": 3.5,     # float (in [3.5, 10])
+#     "max_iterations": 10,        # int
+#     "splice_threshold": 40,      # int
+#     "path_precision": 10          # int (path digits/precision)
+# }
+
+# def _normalize_options(opts: Optional[Dict]) -> Dict:
+#     """
+#     Keep only acceptable keys with correct types according to official docs.
+#     """
+#     opts = opts or {}
+#     out: Dict[str, Any] = {}
+
+#     # strings (colormode, hierarchical, mode)
+#     out["colormode"] = str(opts.get("colormode", DEFAULTS["colormode"]))
+#     out["hierarchical"] = str(opts.get("hierarchical", DEFAULTS["hierarchical"]))
+#     out["mode"] = str(opts.get("mode", DEFAULTS["mode"]))
+
+#     # integer parameters
+#     for k in ("filter_speckle", "color_precision", "layer_difference",
+#               "corner_threshold", "max_iterations", "splice_threshold",
+#               "path_precision"):
+#         out[k] = int(opts.get(k, DEFAULTS[k]))
+
+#     # float parameter
+#     out["length_threshold"] = float(opts.get("length_threshold", DEFAULTS["length_threshold"]))
+
+#     return out
+
+# def vectorize_image(input_raster_path: Path, options: Optional[Dict] = None) -> Dict:
+#     """
+#     Vectorize using the official vtracer binding.
+
+#     Returns:
+#       {
+#         "success": True,
+#         "svg": "<svg ...>",
+#         "width": w,
+#         "height": h
+#       }
+#     On error:
+#       {"success": False, "error": "message"}
+#     """
+#     input_raster_path = Path(input_raster_path)
+#     if not input_raster_path.exists():
+#         return {"success": False, "error": "Input file not found"}
+
+#     opts = _normalize_options(options)
+
+#     try:
+#         # read width/height
+#         with Image.open(input_raster_path) as img:
+#             w, h = img.size
+#             # convert to bytes for the raw API if needed
+#             img_bytes_io = None
+#             try:
+#                 # ensure a common in-memory format, keep original mode if possible
+#                 img_format = img.format or "PNG"
+#                 img_bytes_io = tempfile.SpooledTemporaryFile()  # small-memory friendly
+#                 img.save(img_bytes_io, format=img_format)
+#                 img_bytes_io.seek(0)
+#                 raw_bytes = img_bytes_io.read()
+#             finally:
+#                 if img_bytes_io is not None:
+#                     img_bytes_io.close()
+
+#         # Prefer in-memory API: convert_raw_image_to_svg(bytes, img_format=...)
+#         if hasattr(vtracer, "convert_raw_image_to_svg"):
+#             # vtracer expects bytes and an image format string like 'png' or 'jpg'
+#             img_format_lower = (Image.open(input_raster_path).format or "PNG").lower()
+#             svg_str = vtracer.convert_raw_image_to_svg(raw_bytes, img_format=img_format_lower, **opts)
+#         elif hasattr(vtracer, "convert_pixels_to_svg"):
+#             # alternative: convert pixels to svg — slower for large images
+#             img = Image.open(input_raster_path).convert("RGBA")
+#             pixels = list(img.getdata())
+#             svg_str = vtracer.convert_pixels_to_svg(pixels, img.width, img.height, **opts)
+#         else:
+#             # last resort: call convert_image_to_svg_py which writes to file; read & delete the file
+#             tmp_svg = Path(tempfile.gettempdir()) / f"{input_raster_path.stem}_vtrace_temp.svg"
+#             # convert_image_to_svg_py(inp, out, **kwargs) - writes file
+#             vtracer.convert_image_to_svg_py(str(input_raster_path), str(tmp_svg), **opts)
+#             svg_str = tmp_svg.read_text(encoding="utf-8")
+#             try:
+#                 tmp_svg.unlink()
+#             except Exception:
+#                 pass
+
+#         return {"success": True, "svg": svg_str, "width": w, "height": h}
+
+#     except Exception as e:
+#         # return full error message so you can debug inside logs
+#         return {"success": False, "error": f"VTracer failed: {e}"}
+
+
+
+from pathlib import Path
+from typing import Optional, Dict, Any
+from PIL import Image, ImageFilter
+import tempfile
+import vtracer
+
+# DEFAULTS: Dict[str, Any] = {
+#     "colormode": "color",
+#     "hierarchical": "stacked",
+#     "mode": "spline",
+#     "filter_speckle": 2,
+#     "color_precision": 14,
+#     "layer_difference": 2,
+#     "corner_threshold": 50,
+#     "length_threshold": 3.5,
+#     "max_iterations": 10,
+#     "splice_threshold": 40,
+#     "path_precision": 10
+# }
+
+
+
+# pro
+# DEFAULTS_PAID: Dict[str, Any] = {
+#     "colormode": "color",
+#     "hierarchical": "stacked",
+#     "mode": "spline",            # sharpest edges and curves
+#     "filter_speckle": 0,         # keep all tiny speckles
+#     "color_precision": 256,      # extremely high color accuracy
+#     "layer_difference": 8,       # very fine gradient layers
+#     "corner_threshold": 100,     # preserve almost all corners
+#     "length_threshold": 0.1,     # keep even the tiniest paths
+#     "max_iterations": 500,       # thorough path optimization
+#     "splice_threshold": 100,     # merge paths very carefully
+#     "path_precision": 128        # ultra-smooth curves and clean edges
+# }
+
+DEFAULTS: Dict[str, Any] = {
+    "colormode": "color",
+    "hierarchical": "stacked",
+    "mode": "curve",          # sharper edges
+    "filter_speckle": 1,        # minimal removal
+    "color_precision": 20,      # high color accuracy
+    "layer_difference": 10,      # finer gradient layers
+    "corner_threshold": 35,     # preserve corners
+    "length_threshold": 1.0,    # more detail
+    "max_iterations": 10,
+    "splice_threshold": 40,
+    "path_precision": 16        # smoother curves and clean edges
+}
+def _normalize_options(opts: Optional[Dict]) -> Dict[str, Any]:
+    opts = opts or {}
+    out: Dict[str, Any] = {}
+    out["colormode"]       = str(opts.get("colormode", DEFAULTS["colormode"]))
+    out["hierarchical"]    = str(opts.get("hierarchical", DEFAULTS["hierarchical"]))
+    out["mode"]            = str(opts.get("mode", DEFAULTS["mode"]))
+    for k in ("filter_speckle", "color_precision", "layer_difference",
+              "corner_threshold", "max_iterations", "splice_threshold",
+              "path_precision"):
+        out[k] = int(opts.get(k, DEFAULTS[k]))
+    out["length_threshold"] = float(opts.get("length_threshold", DEFAULTS["length_threshold"]))
+    return out
+
+def vectorize_image(input_raster_path: Path, options: Optional[Dict] = None,
+                    preprocess: bool = False) -> Dict[str, Any]:
+    input_raster_path = Path(input_raster_path)
+    if not input_raster_path.exists():
+        return {"success": False, "error": "Input file not found"}
+
+    opts = _normalize_options(options)
+
+    try:
+        with Image.open(input_raster_path) as img:
+            # preserve original mode
+            orig_mode = img.mode
+            w, h = img.size
+
+            if preprocess:
+                # optional: add slight blur or noise to reduce banding in gradients
+                img = img.convert("RGB")
+                img = img.filter(ImageFilter.GaussianBlur(radius=0.8))
+                # you could add noise here if needed
+
+            img_format = img.format or "PNG"
+            bytes_io = tempfile.SpooledTemporaryFile()
+            img.save(bytes_io, format=img_format)
+            bytes_io.seek(0)
+            raw_bytes = bytes_io.read()
+            bytes_io.close()
+
+        # Use in-memory API if available
+        if hasattr(vtracer, "convert_raw_image_to_svg"):
+            format_lower = img_format.lower()
+            svg_str = vtracer.convert_raw_image_to_svg(raw_bytes, img_format=format_lower, **opts)
+        elif hasattr(vtracer, "convert_pixels_to_svg"):
+            with Image.open(input_raster_path) as img2:
+                img2 = img2.convert("RGBA")
+                pixels = list(img2.getdata())
+                svg_str = vtracer.convert_pixels_to_svg(pixels, img2.width, img2.height, **opts)
+        else:
+            tmp_svg = Path(tempfile.gettempdir()) / f"{input_raster_path.stem}_vtrace_temp.svg"
+            vtracer.convert_image_to_svg_py(str(input_raster_path), str(tmp_svg), **opts)
+            svg_str = tmp_svg.read_text(encoding="utf-8")
+            try:
+                tmp_svg.unlink()
+            except Exception:
+                pass
+
+        return {
+            "success": True,
+            "svg": svg_str,
+            "width": w,
+            "height": h,
+            "mode": orig_mode
+        }
+
+    except Exception as e:
+        return {"success": False, "error": f"VTracer failed: {e}"}

task_queue.py

@@ -0,0 +1,399 @@
+# # queue.py
+# import os
+# import time
+# import pickle
+# import asyncio
+# import nest_asyncio
+# from pathlib import Path
+# from enum import Enum
+# from collections import deque
+# from concurrent.futures import ThreadPoolExecutor
+# from typing import Callable, Optional
+
+# # allow nested event loops in some environments
+# nest_asyncio.apply()
+
+
+# class TaskStatus(Enum):
+#     QUEUED = "queued"
+#     RUNNING = "running"
+#     COMPLETED = "completed"
+#     FAILED = "failed"
+#     CANCELLED = "cancelled"
+
+
+# class TaskQueue:
+#     """
+#     File-backed persistent queue that stores tasks as metadata dicts.
+#     Uses ThreadPoolExecutor to run CPU-bound pipeline in worker threads.
+#     """
+#     def __init__(self, base_dir: Path | str, max_workers: int = 2):
+#         self.base_dir = Path(base_dir)
+#         self.base_dir.mkdir(parents=True, exist_ok=True)
+#         self._queue_file = self.base_dir / "queue.pkl"
+#         self._state_file = self.base_dir / "state.pkl"
+
+#         self._dq = deque()  # stores metadata dicts
+#         self._tasks = {}  # task_id -> metadata
+#         self._statuses = {}  # task_id -> TaskStatus
+#         self._lock = asyncio.Lock()
+
+#         self._executor = ThreadPoolExecutor(max_workers=max_workers)
+#         self._worker_task: Optional[asyncio.Task] = None
+#         self._shutdown = False
+#         self._processor: Optional[Callable] = None  # sync function to run per task
+
+#         self._load_state()
+
+#     # ------------------------
+#     # persistence
+#     # ------------------------
+#     def _save_state(self):
+#         try:
+#             tmp = self._state_file.with_suffix(".tmp")
+#             with tmp.open("wb") as f:
+#                 pickle.dump({
+#                     "queue": list(self._dq),
+#                     "tasks": self._tasks,
+#                     "statuses": self._statuses,
+#                 }, f)
+#             tmp.replace(self._state_file)
+#         except Exception:
+#             # do not crash app on disk save error; log in real app
+#             pass
+
+#     def _load_state(self):
+#         if self._state_file.exists():
+#             try:
+#                 with self._state_file.open("rb") as f:
+#                     data = pickle.load(f)
+#                 for item in data.get("queue", []):
+#                     self._dq.append(item)
+#                 self._tasks.update(data.get("tasks", {}))
+#                 self._statuses.update(data.get("statuses", {}))
+#             except Exception:
+#                 # if corrupted, start fresh
+#                 self._dq = deque()
+#                 self._tasks = {}
+#                 self._statuses = {}
+
+#     # ------------------------
+#     # public API
+#     # ------------------------
+#     def enqueue(self, task_meta: dict):
+#         task_id = task_meta.get("task_id")
+#         if not task_id:
+#             raise ValueError("task_meta must contain 'task_id'")
+
+#         self._dq.append(task_meta)
+#         self._tasks[task_id] = task_meta
+#         self._statuses[task_id] = TaskStatus.QUEUED
+#         self._save_state()
+
+#     def get_status(self, task_id: str):
+#         return self._statuses.get(task_id)
+
+#     def get_task_info(self, task_id: str):
+#         return self._tasks.get(task_id)
+
+#     def remove_task(self, task_id: str):
+#         # Remove from tasks and statuses; queue items will be filtered by worker
+#         self._tasks.pop(task_id, None)
+#         self._statuses.pop(task_id, None)
+#         self._save_state()
+
+#     # ------------------------
+#     # lifecycle
+#     # ------------------------
+#     async def start(self, processor: Callable):
+#         """Start the background worker loop. processor should be a sync function accept task_meta."""
+#         if self._worker_task:
+#             return
+#         self._processor = processor
+#         self._shutdown = False
+#         loop = asyncio.get_event_loop()
+#         self._worker_task = loop.create_task(self._worker_loop())
+
+#     async def stop(self):
+#         self._shutdown = True
+#         if self._worker_task:
+#             await self._worker_task
+#             self._worker_task = None
+#         self._executor.shutdown(wait=True)
+#         self._save_state()
+
+#     # ------------------------
+#     # worker loop
+#     # ------------------------
+#     async def _worker_loop(self):
+#         logger.info("🔄 Worker loop started")
+#         while not self._shutdown:
+#             if not self._dq:
+#                 await asyncio.sleep(0.5)
+#                 continue
+
+#             task_meta = self._dq.popleft()
+#             task_id = task_meta.get("task_id")
+#             logger.info(f"Processing task {task_id}")
+
+#             try:
+#                 self._statuses[task_id] = TaskStatus.RUNNING
+#                 self._save_state()
+
+#                 loop = asyncio.get_event_loop()
+#                 logger.debug(f"Running processor for task {task_id}")
+#                 future = loop.run_in_executor(
+#                     self._executor, 
+#                     self._run_processor_safe, 
+#                     task_meta
+#                 )
+#                 result = await future
+#                 logger.debug(f"Processor result: {result}")
+
+#                 if isinstance(result, dict) and result.get("success"):
+#                     self._statuses[task_id] = TaskStatus.COMPLETED
+#                     self._tasks[task_id].update({
+#                         "output_path": result.get("output_path"),
+#                         "output_bytes": result.get("output_bytes")
+#                     })
+#                     logger.info(f"Task {task_id} completed successfully")
+#                 else:
+#                     self._statuses[task_id] = TaskStatus.FAILED
+#                     logger.error(f"Task {task_id} failed: {result}")
+
+#                 self._save_state()
+#             except Exception as e:
+#                 logger.exception(f"Error processing task {task_id}")
+#                 self._statuses[task_id] = TaskStatus.FAILED
+#                 self._save_state()
+
+#             await asyncio.sleep(0.1)
+
+#         logger.info("🔚 Worker loop exiting cleanly.")
+
+#     def _run_processor_safe(self, task_meta: dict) -> dict:
+#         try:
+#             if not self._processor:
+#                 logger.error("❌ No processor configured, cannot run task.")
+#                 return {"success": False, "error": "No processor configured"}
+
+#             task_id = task_meta.get("task_id")
+#             logger.debug(f"🚧 Running processor for task {task_id}...")
+#             result = self._processor(task_meta)
+#             logger.debug(f"🎯 Processor result for {task_id}: {result}")
+#             return result or {"success": False}
+#         except Exception as e:
+#             logger.exception(f"💥 Processor crashed for task {task_meta.get('task_id')}: {e}")
+#             return {"success": False, "error": str(e)}
+
+
+
+
+# queue.py
+import os
+import time
+import pickle
+import asyncio
+import nest_asyncio
+from pathlib import Path
+from enum import Enum
+from collections import deque
+from concurrent.futures import ThreadPoolExecutor
+from typing import Callable, Optional
+
+# allow nested event loops in some environments
+nest_asyncio.apply()
+
+# --------------------------------------------------
+# Logging setup
+# --------------------------------------------------
+import logging
+
+logging.basicConfig(
+    level=logging.DEBUG,
+    format="🧩 [%(asctime)s] [%(levelname)s] %(message)s",
+    datefmt="%H:%M:%S",
+)
+logger = logging.getLogger("queue_system")
+
+
+class TaskStatus(Enum):
+    QUEUED = "queued"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+class TaskQueue:
+    """
+    File-backed persistent queue that stores tasks as metadata dicts.
+    Uses ThreadPoolExecutor to run CPU-bound pipeline in worker threads.
+    """
+    def __init__(self, base_dir: Path | str, max_workers: int = 2):
+        self.base_dir = Path(base_dir)
+        self.base_dir.mkdir(parents=True, exist_ok=True)
+        self._queue_file = self.base_dir / "queue.pkl"
+        self._state_file = self.base_dir / "state.pkl"
+
+        self._dq = deque()
+        self._tasks = {}
+        self._statuses = {}
+        self._lock = asyncio.Lock()
+
+        self._executor = ThreadPoolExecutor(max_workers=max_workers)
+        self._worker_task: Optional[asyncio.Task] = None
+        self._shutdown = False
+        self._processor: Optional[Callable] = None
+
+        logger.info(f"🚀 TaskQueue initialized | base_dir={self.base_dir} | workers={max_workers}")
+        self._load_state()
+
+    # ------------------------
+    # persistence
+    # ------------------------
+    def _save_state(self):
+        try:
+            tmp = self._state_file.with_suffix(".tmp")
+            with tmp.open("wb") as f:
+                pickle.dump({
+                    "queue": list(self._dq),
+                    "tasks": self._tasks,
+                    "statuses": self._statuses,
+                }, f)
+            tmp.replace(self._state_file)
+            logger.debug(f"💾 Queue state saved | queued={len(self._dq)} tasks")
+        except Exception as e:
+            logger.warning(f"⚠️ Failed to save state: {e}")
+
+    def _load_state(self):
+        if self._state_file.exists():
+            try:
+                with self._state_file.open("rb") as f:
+                    data = pickle.load(f)
+                for item in data.get("queue", []):
+                    self._dq.append(item)
+                self._tasks.update(data.get("tasks", {}))
+                self._statuses.update(data.get("statuses", {}))
+                logger.info(f"📂 Loaded previous queue state | tasks={len(self._tasks)}")
+            except Exception as e:
+                logger.error(f"❌ Failed to load state file, starting fresh: {e}")
+                self._dq = deque()
+                self._tasks = {}
+                self._statuses = {}
+
+    # ------------------------
+    # public API
+    # ------------------------
+    def enqueue(self, task_meta: dict):
+        task_id = task_meta.get("task_id")
+        if not task_id:
+            raise ValueError("task_meta must contain 'task_id'")
+        self._dq.append(task_meta)
+        self._tasks[task_id] = task_meta
+        self._statuses[task_id] = TaskStatus.QUEUED
+        self._save_state()
+        logger.info(f"🆕 Task enqueued | id={task_id} | total_queued={len(self._dq)}")
+
+    def get_status(self, task_id: str):
+        st = self._statuses.get(task_id)
+        logger.debug(f"📊 get_status({task_id}) → {st}")
+        return st
+
+    def get_task_info(self, task_id: str):
+        info = self._tasks.get(task_id)
+        logger.debug(f"ℹ️ get_task_info({task_id}) → {'found' if info else 'not found'}")
+        return info
+
+    def remove_task(self, task_id: str):
+        self._tasks.pop(task_id, None)
+        self._statuses.pop(task_id, None)
+        self._save_state()
+        logger.info(f"🗑 Task removed from system | id={task_id}")
+
+    # ------------------------
+    # lifecycle
+    # ------------------------
+    async def start(self, processor: Callable):
+        if self._worker_task:
+            logger.warning("⚠️ Queue worker already running, ignoring start request.")
+            return
+        self._processor = processor
+        self._shutdown = False
+        loop = asyncio.get_event_loop()
+        self._worker_task = loop.create_task(self._worker_loop())
+        logger.info("🏁 Background worker started successfully.")
+
+    async def stop(self):
+        logger.info("🛑 Stopping background worker...")
+        self._shutdown = True
+        if self._worker_task:
+            await self._worker_task
+            self._worker_task = None
+        self._executor.shutdown(wait=True)
+        self._save_state()
+        logger.info("✅ Worker stopped and executor shut down cleanly.")
+
+    # ------------------------
+    # worker loop
+    # ------------------------
+    async def _worker_loop(self):
+        logger.info("🔄 Worker loop started")
+        while not self._shutdown:
+            if not self._dq:
+                await asyncio.sleep(0.5)
+                continue
+
+            task_meta = self._dq.popleft()
+            task_id = task_meta.get("task_id")
+            logger.info(f"Processing task {task_id}")
+
+            try:
+                self._statuses[task_id] = TaskStatus.RUNNING
+                self._save_state()
+
+                loop = asyncio.get_event_loop()
+                logger.debug(f"Running processor for task {task_id}")
+                future = loop.run_in_executor(
+                    self._executor, 
+                    self._run_processor_safe, 
+                    task_meta
+                )
+                result = await future
+                logger.debug(f"Processor result: {result}")
+
+                if isinstance(result, dict) and result.get("success"):
+                    self._statuses[task_id] = TaskStatus.COMPLETED
+                    self._tasks[task_id].update({
+                        "output_path": result.get("output_path"),
+                        "output_bytes": result.get("output_bytes")
+                    })
+                    logger.info(f"Task {task_id} completed successfully")
+                else:
+                    self._statuses[task_id] = TaskStatus.FAILED
+                    logger.error(f"Task {task_id} failed: {result}")
+
+                self._save_state()
+            except Exception as e:
+                logger.exception(f"Error processing task {task_id}")
+                self._statuses[task_id] = TaskStatus.FAILED
+                self._save_state()
+
+            await asyncio.sleep(0.1)
+
+        logger.info("🔚 Worker loop exiting cleanly.")
+
+    def _run_processor_safe(self, task_meta: dict) -> dict:
+        try:
+            if not self._processor:
+                logger.error("❌ No processor configured, cannot run task.")
+                return {"success": False, "error": "No processor configured"}
+
+            task_id = task_meta.get("task_id")
+            logger.debug(f"🚧 Running processor for task {task_id}...")
+            result = self._processor(task_meta)
+            logger.debug(f"🎯 Processor result for {task_id}: {result}")
+            return result or {"success": False}
+        except Exception as e:
+            logger.exception(f"💥 Processor crashed for task {task_meta.get('task_id')}: {e}")
+            return {"success": False, "error": str(e)}