Upload 38 files

renderer/__init__.py

@@ -1,4 +1,4 @@
-"""CPU-first video rendering engine for Basyx FFmpeg."""
+"""CPU-first video automation backend for Ava2lon Studio AI."""
 
 from renderer.core.config import Settings
 from renderer.core.models import RenderRequest, RenderResult

renderer/core/config.py

@@ -11,14 +11,14 @@ DEFAULT_ROOT = Path.cwd()
 class Settings:
     """Runtime settings tuned for small CPU-only Hugging Face Spaces."""
 
-    base_dir: Path = Path(os.getenv("BASYX_BASE_DIR", str(DEFAULT_ROOT)))
+    base_dir: Path = Path(os.getenv("AVA2LON_BASE_DIR", os.getenv("BASYX_BASE_DIR", str(DEFAULT_ROOT))))
     temp_dir: Path = Path(os.getenv("TEMP_DIR", str(DEFAULT_ROOT / "temp")))
     exports_dir: Path = Path(os.getenv("EXPORTS_DIR", str(DEFAULT_ROOT / "exports")))
     jobs_dir: Path = Path(os.getenv("JOBS_DIR", str(DEFAULT_ROOT / "jobs")))
     storage_dir: Path = Path(os.getenv("STORAGE_DIR", str(DEFAULT_ROOT / "storage")))
     metadata_cache: Path = Path(os.getenv("METADATA_CACHE", str(DEFAULT_ROOT / "temp" / "metadata_cache.json")))
-    signing_secret: str = os.getenv("BASYX_SIGNING_SECRET", "dev-secret-change-me")
-    api_key: str = os.getenv("BASYX_API_KEY", "")
+    signing_secret: str = os.getenv("AVA2LON_SIGNING_SECRET", os.getenv("BASYX_SIGNING_SECRET", "dev-secret-change-me"))
+    api_key: str = os.getenv("AVA2LON_API_KEY", os.getenv("BASYX_API_KEY", ""))
     font_path: Path = Path(os.getenv("FONT_PATH", "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf"))
     output_width: int = int(os.getenv("OUTPUT_WIDTH", "1080"))
     output_height: int = int(os.getenv("OUTPUT_HEIGHT", "1920"))

renderer/jobs/manager.py

@@ -215,7 +215,7 @@ class JobManager:
         request = urllib.request.Request(
             record.callback_url,
             data=payload,
-            headers={"Content-Type": "application/json", "User-Agent": "basyx-ffmpeg-callback/1.0"},
+            headers={"Content-Type": "application/json", "User-Agent": "ava2lon-studio-callback/2.0"},
             method="POST",
         )
         try:
@@ -234,7 +234,7 @@ def _put_file(url: str, path: Path) -> None:
     headers = {
         "Content-Type": "video/mp4",
         "Content-Length": str(path.stat().st_size),
-        "User-Agent": "basyx-ffmpeg-export/1.0",
+        "User-Agent": "ava2lon-studio-export/2.0",
     }
     connection.putrequest("PUT", target)
     for key, value in headers.items():

renderer/platform/processor.py

@@ -19,6 +19,7 @@ from renderer.templates import get_platform_profile
 
 
 TOOLKIT_TASKS = {
+    "cut",
     "trim",
     "split",
     "concat",
@@ -28,8 +29,21 @@ TOOLKIT_TASKS = {
     "resize",
     "crop",
     "rotate",
+    "flip",
+    "scale",
+    "zoom",
+    "pan",
     "speed",
+    "speed_ramp",
+    "time_remap",
+    "slow_motion",
+    "fast_motion",
     "reverse",
+    "reverse_playback",
+    "freeze_frame",
+    "motion_blur",
+    "stabilization",
+    "lens_correction",
     "loop",
     "extract_audio",
     "thumbnail",
@@ -42,7 +56,16 @@ TOOLKIT_TASKS = {
     "convert",
     "merge_audio",
     "noise_reduction",
+    "equalizer",
+    "compressor",
+    "limiter",
+    "pitch_shift",
+    "voice_changer",
+    "ai_enhancement",
     "green_screen",
+    "chroma_key",
+    "blue_screen",
+    "ai_background_removal",
 }
 
 
@@ -238,7 +261,7 @@ class PlatformProcessor:
         cmd = FFmpegCommand().add("-hide_banner")
         if task == "loop":
             cmd.add("-stream_loop", int(params.get("loops", -1)))
-        if task in {"trim", "gif"} and params.get("start") is not None:
+        if task in {"cut", "trim", "gif", "freeze_frame"} and params.get("start") is not None:
             cmd.add("-ss", float(params.get("start", 0)))
         cmd.input(source)
 
@@ -263,7 +286,7 @@ class PlatformProcessor:
             return FFmpegCommand().add("-hide_banner", "-f", "concat", "-safe", "0").input(concat_file).add("-c", "copy").overwrite().add(output).build()
 
         duration = params.get("duration")
-        if task in {"trim", "gif", "loop"} and duration is not None:
+        if task in {"cut", "trim", "gif", "loop", "freeze_frame"} and duration is not None:
             cmd.add("-t", float(duration))
 
         vf = _video_filter(task, params)
@@ -279,7 +302,45 @@ class PlatformProcessor:
             return cmd.add("-vf", vf or "fps=1", "-q:v", 2).overwrite().add(workdir / "frame_%04d.jpg").build()
         if task == "gif":
             return cmd.add("-loop", 0).overwrite().add(output).build()
-        if task in {"compress", "normalize", "resize", "crop", "rotate", "speed", "reverse", "loop", "overlay_text", "blur_background", "burn_subtitles", "convert", "noise_reduction", "green_screen"}:
+        if task in {
+            "cut",
+            "trim",
+            "compress",
+            "normalize",
+            "resize",
+            "crop",
+            "rotate",
+            "flip",
+            "scale",
+            "zoom",
+            "pan",
+            "speed",
+            "speed_ramp",
+            "time_remap",
+            "slow_motion",
+            "fast_motion",
+            "reverse",
+            "reverse_playback",
+            "freeze_frame",
+            "motion_blur",
+            "stabilization",
+            "lens_correction",
+            "loop",
+            "overlay_text",
+            "blur_background",
+            "burn_subtitles",
+            "convert",
+            "noise_reduction",
+            "equalizer",
+            "compressor",
+            "limiter",
+            "pitch_shift",
+            "voice_changer",
+            "green_screen",
+            "chroma_key",
+            "blue_screen",
+            "ai_background_removal",
+        }:
             cmd.add("-c:v", "libx264", "-preset", self.settings.preset, "-crf", int(params.get("crf", self.settings.crf)), "-c:a", "aac")
         return cmd.overwrite().add(output).build()
 
@@ -444,17 +505,48 @@ def _video_filter(task: str, params: dict[str, Any]) -> str:
     if task in {"compress", "normalize"}:
         profile = get_platform_profile(params.get("platform"))
         return f"scale={profile.width}:{profile.height}:force_original_aspect_ratio=increase,crop={profile.width}:{profile.height},fps={profile.fps},format=yuv420p"
-    if task == "resize":
+    if task in {"resize", "scale"}:
         return f"scale={int(params.get('width', 1080))}:{int(params.get('height', 1920))}"
     if task == "crop":
         return f"crop={int(params.get('width', 1080))}:{int(params.get('height', 1080))}:{int(params.get('x', 0))}:{int(params.get('y', 0))}"
     if task == "rotate":
         return {"90": "transpose=1", "180": "hflip,vflip", "270": "transpose=2"}.get(str(params.get("degrees", "90")), "transpose=1")
+    if task == "flip":
+        axis = str(params.get("axis", "horizontal"))
+        return "vflip" if axis in {"vertical", "y"} else "hflip"
+    if task in {"speed", "speed_ramp", "time_remap", "slow_motion", "fast_motion"}:
+        default = 0.5 if task == "slow_motion" else 2.0 if task == "fast_motion" else 1.0
+        factor = max(0.25, min(4.0, float(params.get("factor", default))))
+        return f"setpts={1 / factor:.4f}*PTS"
+    if task == "zoom":
+        factor = max(1.0, min(4.0, float(params.get("factor", 1.2))))
+        return f"scale=iw*{factor:.3f}:ih*{factor:.3f},crop=iw/{factor:.3f}:ih/{factor:.3f}"
+    if task == "pan":
+        width = int(params.get("width", 1080))
+        height = int(params.get("height", 1920))
+        x = str(params.get("x", "(iw-ow)/2"))
+        y = str(params.get("y", "(ih-oh)/2"))
+        return f"crop={width}:{height}:{x}:{y}"
+    if task in {"motion_blur", "freeze_frame"}:
+        return "tmix=frames=3:weights='1 2 1'"
+    if task == "stabilization":
+        return "deshake"
+    if task == "lens_correction":
+        return f"lenscorrection=k1={float(params.get('k1', -0.15))}:k2={float(params.get('k2', 0.05))}"
+    if task in {"reverse", "reverse_playback"}:
+        return "reverse"
+    if task in {"green_screen", "chroma_key", "ai_background_removal"}:
+        color = str(params.get("color") or "0x00ff00")
+        similarity = float(params.get("similarity", 0.18))
+        blend = float(params.get("blend", 0.08))
+        return f"chromakey={color}:{similarity}:{blend}"
+    if task == "blue_screen":
+        similarity = float(params.get("similarity", 0.18))
+        blend = float(params.get("blend", 0.08))
+        return f"chromakey=0x0000ff:{similarity}:{blend}"
     if task == "speed":
         factor = max(0.25, min(4.0, float(params.get("factor", 1.0))))
         return f"setpts={1 / factor:.4f}*PTS"
-    if task == "reverse":
-        return "reverse"
     if task == "gif":
         return f"fps={int(params.get('fps', 12))},scale={int(params.get('width', 540))}:-1:flags=lanczos"
     if task == "frames":
@@ -466,22 +558,27 @@ def _video_filter(task: str, params: dict[str, Any]) -> str:
     if task == "burn_subtitles":
         subtitles = str(params.get("subtitles") or "").replace("\\", "/").replace(":", r"\:")
         return f"subtitles='{subtitles}'"
-    if task == "green_screen":
-        color = str(params.get("color") or "0x00ff00")
-        similarity = float(params.get("similarity", 0.18))
-        blend = float(params.get("blend", 0.08))
-        return f"chromakey={color}:{similarity}:{blend}"
     return ""
 
 
 def _audio_filter(task: str, params: dict[str, Any]) -> str:
-    if task == "speed":
-        factor = max(0.5, min(2.0, float(params.get("factor", 1.0))))
+    if task in {"speed", "speed_ramp", "time_remap", "slow_motion", "fast_motion"}:
+        default = 0.5 if task == "slow_motion" else 2.0 if task == "fast_motion" else 1.0
+        factor = max(0.5, min(2.0, float(params.get("factor", default))))
         return f"atempo={factor}"
-    if task == "reverse":
+    if task in {"reverse", "reverse_playback"}:
         return "areverse"
-    if task == "noise_reduction":
+    if task in {"noise_reduction", "ai_enhancement"}:
         return "afftdn=nf=-25"
+    if task == "equalizer":
+        return f"equalizer=f={float(params.get('frequency', 1000))}:width_type=o:width={float(params.get('width', 1))}:g={float(params.get('gain', 3))}"
+    if task == "compressor":
+        return "acompressor=threshold=-18dB:ratio=3:attack=20:release=250"
+    if task == "limiter":
+        return "alimiter=limit=0.95"
+    if task in {"pitch_shift", "voice_changer"}:
+        factor = max(0.5, min(2.0, float(params.get("factor", 1.0))))
+        return f"asetrate=48000*{factor:.4f},aresample=48000,atempo={1 / factor:.4f}"
     return ""
 
 

renderer/studio/__init__.py

@@ -0,0 +1,27 @@
+from renderer.studio.capabilities import capability_catalog
+from renderer.studio.projects import (
+    ProjectStore,
+    add_effect,
+    add_filter,
+    add_keyframe,
+    add_timeline_item,
+    add_transition,
+    apply_timeline_operation,
+    default_project,
+    normalize_project,
+)
+from renderer.studio.tasks import StudioTaskProcessor
+
+__all__ = [
+    "ProjectStore",
+    "StudioTaskProcessor",
+    "add_effect",
+    "add_filter",
+    "add_keyframe",
+    "add_timeline_item",
+    "add_transition",
+    "apply_timeline_operation",
+    "capability_catalog",
+    "default_project",
+    "normalize_project",
+]

renderer/studio/capabilities.py

@@ -0,0 +1,428 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from typing import Any
+
+
+TIMELINE_TRACK_TYPES = [
+    "video",
+    "audio",
+    "text",
+    "overlay",
+    "sticker",
+    "subtitle",
+]
+
+TIMELINE_OPERATIONS = [
+    "drag",
+    "split",
+    "trim",
+    "ripple_delete",
+    "insert",
+    "replace",
+    "group",
+    "lock",
+    "hide",
+    "duplicate",
+]
+
+VIDEO_EDITING_OPERATIONS = [
+    "cut",
+    "split",
+    "trim",
+    "merge",
+    "concat",
+    "reverse",
+    "freeze_frame",
+    "speed",
+    "speed_ramp",
+    "time_remap",
+    "slow_motion",
+    "fast_motion",
+    "reverse_playback",
+    "crop",
+    "rotate",
+    "flip",
+    "resize",
+    "scale",
+    "zoom",
+    "pan",
+    "motion_blur",
+    "stabilization",
+    "lens_correction",
+    "compress",
+    "normalize",
+    "loop",
+    "gif",
+    "frames",
+    "watermark",
+    "overlay_text",
+    "burn_subtitles",
+    "convert",
+]
+
+AI_EDITING_FEATURES = [
+    "auto_edit",
+    "auto_highlight_detection",
+    "auto_scene_detection",
+    "auto_reframe",
+    "auto_crop",
+    "auto_remove_silence",
+    "auto_beat_sync",
+    "auto_color_match",
+    "auto_motion_tracking",
+    "auto_subtitle_generation",
+    "auto_hook_detection",
+    "auto_thumbnail_selection",
+    "auto_music_selection",
+    "auto_b_roll_placement",
+    "auto_caption_animation",
+    "auto_viral_score",
+    "auto_platform_optimization",
+]
+
+KEYFRAME_PROPERTIES = [
+    "position",
+    "scale",
+    "rotation",
+    "opacity",
+    "blur",
+    "brightness",
+    "contrast",
+    "saturation",
+    "hue",
+    "volume",
+    "playback_speed",
+    "mask",
+    "shadow",
+    "glow",
+    "text_animation",
+]
+
+TRANSITION_FAMILIES = [
+    "basic",
+    "fade",
+    "dissolve",
+    "slide",
+    "push",
+    "zoom",
+    "spin",
+    "blur",
+    "whip",
+    "flash",
+    "glitch",
+    "light_leak",
+    "film_burn",
+    "camera_shake",
+    "3d_flip",
+    "cube",
+    "ripple",
+    "ink",
+    "morph",
+    "stretch",
+    "liquid",
+    "elastic",
+    "motion_blur",
+]
+
+VIDEO_EFFECTS = [
+    "glitch",
+    "rgb_split",
+    "shake",
+    "crt",
+    "vhs",
+    "noise",
+    "film_grain",
+    "bloom",
+    "glow",
+    "chromatic_aberration",
+    "lens_flare",
+    "dream",
+    "neon",
+    "cyberpunk",
+    "rain",
+    "snow",
+    "fog",
+    "lightning",
+    "fire",
+    "smoke",
+    "particle_system",
+    "spark",
+    "magic",
+    "comic",
+    "cartoon",
+    "anime",
+    "sketch",
+    "oil_painting",
+    "pixel_art",
+    "sharp_pop",
+    "clean_beauty",
+    "warm_glow",
+    "cinematic",
+    "dreamy",
+    "flash_pop",
+    "motion_blur",
+    "noir",
+]
+
+FILTER_FORMATS = [".cube", ".3dl", ".csp"]
+
+FILTER_PRESETS = [
+    "cinema",
+    "vintage",
+    "warm",
+    "cold",
+    "black_and_white",
+    "hdr",
+    "instagram",
+    "tiktok",
+    "moody",
+    "travel",
+    "nature",
+    "food",
+    "portrait",
+    "luxury",
+    "night",
+]
+
+TEXT_FEATURES = [
+    "rich_text",
+    "curved_text",
+    "vertical_text",
+    "gradient_text",
+    "outline",
+    "shadow",
+    "glow",
+    "stroke",
+    "letter_spacing",
+    "word_spacing",
+    "animation_presets",
+    "typing_animation",
+    "bounce",
+    "wave",
+    "zoom",
+    "pop",
+    "fade",
+    "roll",
+    "tracking",
+]
+
+CAPTION_FEATURES = [
+    "whisper_transcription",
+    "word_timestamps",
+    "sentence_timestamps",
+    "emoji_insertion",
+    "speaker_detection",
+    "karaoke_captions",
+    "tiktok_captions",
+    "capcut_captions",
+    "animated_captions",
+    "subtitle_templates",
+]
+
+STICKER_PACKS = [
+    "png",
+    "svg",
+    "gif",
+    "animated_stickers",
+    "emoji_packs",
+    "reaction_packs",
+    "social_media_packs",
+    "call_to_action_packs",
+]
+
+SHAPES = [
+    "rectangle",
+    "circle",
+    "triangle",
+    "arrow",
+    "line",
+    "polygon",
+    "speech_bubble",
+    "custom_svg",
+]
+
+MASK_TYPES = [
+    "rectangle",
+    "circle",
+    "linear",
+    "radial",
+    "freehand",
+    "bezier",
+    "ai_subject_mask",
+    "ai_sky_mask",
+    "ai_person_mask",
+]
+
+CHROMA_KEY_FEATURES = [
+    "green_screen",
+    "blue_screen",
+    "ai_background_removal",
+    "edge_feathering",
+    "spill_suppression",
+    "shadow_preservation",
+]
+
+AUDIO_TOOLS = [
+    "music",
+    "voiceover",
+    "noise_reduction",
+    "equalizer",
+    "compressor",
+    "limiter",
+    "pitch_shift",
+    "voice_changer",
+    "fade",
+    "ducking",
+    "normalization",
+    "ai_enhancement",
+    "beat_detection",
+    "beat_markers",
+]
+
+MUSIC_PROVIDERS = ["musicgen", "suno_api", "stable_audio"]
+MUSIC_STYLES = ["background_music", "lo_fi", "cinematic", "nasheed", "hip_hop", "corporate", "podcast", "meditation"]
+
+VOICE_PROVIDERS = ["kokoro", "xtts", "piper", "openvoice"]
+VOICE_FEATURES = ["voice_cloning", "multi_speaker", "emotion", "speed", "pitch", "style_transfer"]
+
+IMAGE_GENERATION_PROVIDERS = ["flux", "sdxl", "controlnet"]
+IMAGE_GENERATION_FEATURES = ["image_editing", "background_replacement", "object_removal", "upscaling"]
+
+VIDEO_GENERATION_PROVIDERS = ["wan", "ltx_video", "hunyuan_video", "veo_api"]
+VIDEO_GENERATION_FEATURES = ["animate_images", "image_to_video", "text_to_video"]
+
+AI_ASSISTANTS = [
+    "script_writer",
+    "hook_generator",
+    "title_generator",
+    "description_generator",
+    "hashtag_generator",
+    "seo_optimizer",
+    "thumbnail_prompt_generator",
+    "b_roll_planner",
+    "storyboard_generator",
+]
+
+TEMPLATE_CATEGORIES = [
+    "youtube_shorts",
+    "tiktok",
+    "instagram_reels",
+    "facebook_reels",
+    "motivational",
+    "podcasts",
+    "gaming",
+    "news",
+    "luxury",
+    "business",
+    "education",
+    "finance",
+    "relationship",
+    "wedding",
+    "birthday",
+    "travel",
+    "cooking",
+    "fitness",
+    "anime",
+    "sports",
+    "product_ads",
+    "real_estate",
+    "e_commerce",
+    "faceless_channels",
+    "quote_videos",
+    "audiograms",
+    "story_videos",
+    "before_and_after",
+    "reaction_videos",
+    "countdown_videos",
+]
+
+EXPORT_FORMATS = ["mp4", "mov", "avi", "mkv", "gif", "webm", "png_sequence", "jpeg_sequence", "audio_only"]
+
+EXPORT_PRESETS = [
+    "1080p",
+    "2k",
+    "4k",
+    "8k",
+    "tiktok",
+    "youtube",
+    "instagram",
+    "facebook",
+    "twitter",
+    "linkedin",
+]
+
+API_ENDPOINTS = {
+    "upload": "POST /upload",
+    "project_create": "POST /project/create",
+    "project_save": "POST /project/save",
+    "timeline_add": "POST /timeline/add",
+    "timeline_operation": "POST /timeline/operation",
+    "effect_apply": "POST /effect/apply",
+    "filter_apply": "POST /filter/apply",
+    "transition_add": "POST /transition/add",
+    "caption_generate": "POST /caption/generate",
+    "music_generate": "POST /music/generate",
+    "voice_generate": "POST /voice/generate",
+    "image_generate": "POST /image/generate",
+    "video_generate": "POST /video/generate",
+    "thumbnail_create": "POST /thumbnail/create",
+    "render": "POST /render",
+    "status": "GET /status/{job_id}",
+    "download": "GET /download/{job_id}",
+    "publish": "POST /publish",
+}
+
+
+def capability_catalog() -> dict[str, Any]:
+    return deepcopy(
+        {
+            "product": "Ava2lon Studio AI",
+            "principles": {
+                "cpu_first": True,
+                "optional_gpu": True,
+                "api_parity": True,
+                "async_long_running_tasks": True,
+                "status_polling": True,
+                "webhooks": True,
+                "plugin_support": True,
+                "template_driven": True,
+                "non_destructive_projects": True,
+                "multi_platform_export": True,
+            },
+            "timeline": {
+                "track_types": TIMELINE_TRACK_TYPES,
+                "operations": TIMELINE_OPERATIONS,
+                "unlimited_tracks": True,
+            },
+            "editing": VIDEO_EDITING_OPERATIONS,
+            "ai_editing": AI_EDITING_FEATURES,
+            "keyframes": KEYFRAME_PROPERTIES,
+            "transitions": TRANSITION_FAMILIES,
+            "effects": VIDEO_EFFECTS,
+            "filters": {"formats": FILTER_FORMATS, "presets": FILTER_PRESETS},
+            "text": TEXT_FEATURES,
+            "captions": CAPTION_FEATURES,
+            "stickers": STICKER_PACKS,
+            "shapes": SHAPES,
+            "masks": MASK_TYPES,
+            "chroma_key": CHROMA_KEY_FEATURES,
+            "audio": AUDIO_TOOLS,
+            "music_generator": {"providers": MUSIC_PROVIDERS, "styles": MUSIC_STYLES},
+            "voice_generator": {"providers": VOICE_PROVIDERS, "features": VOICE_FEATURES},
+            "image_generation": {"providers": IMAGE_GENERATION_PROVIDERS, "features": IMAGE_GENERATION_FEATURES},
+            "video_generation": {"providers": VIDEO_GENERATION_PROVIDERS, "features": VIDEO_GENERATION_FEATURES},
+            "assistants": AI_ASSISTANTS,
+            "templates": TEMPLATE_CATEGORIES,
+            "exports": {"formats": EXPORT_FORMATS, "presets": EXPORT_PRESETS},
+            "api_endpoints": API_ENDPOINTS,
+        }
+    )
+
+
+def is_timeline_operation(operation: str) -> bool:
+    return operation in TIMELINE_OPERATIONS
+
+
+def is_track_type(track_type: str) -> bool:
+    return track_type in TIMELINE_TRACK_TYPES

renderer/studio/projects.py

@@ -0,0 +1,399 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from pathlib import Path
+from typing import Any
+
+from renderer.core.config import Settings
+from renderer.core.utils import new_id, now, read_json, safe_filename, write_json
+from renderer.studio.capabilities import TIMELINE_TRACK_TYPES, is_timeline_operation, is_track_type
+
+
+DEFAULT_EXPORT_SETTINGS: dict[str, Any] = {
+    "format": "mp4",
+    "preset": "tiktok",
+    "platform": "tiktok",
+    "resolution": "1080p",
+    "fps": 30,
+    "codec": "h264",
+    "audio_codec": "aac",
+}
+
+
+def default_project(name: str, metadata: dict[str, Any] | None = None, project_id: str | None = None) -> dict[str, Any]:
+    created = now()
+    project_id = project_id or new_id("project")
+    return {
+        "id": project_id,
+        "name": name,
+        "slug": safe_filename(name),
+        "version": 1,
+        "schema": "ava2lon.project.v1",
+        "created_at": created,
+        "updated_at": created,
+        "metadata": metadata or {},
+        "timeline": {
+            "duration": 0.0,
+            "fps": 30,
+            "tracks": {track_type: [] for track_type in TIMELINE_TRACK_TYPES},
+            "groups": [],
+            "markers": [],
+        },
+        "assets": [],
+        "audio_tracks": [],
+        "video_tracks": [],
+        "text_layers": [],
+        "sticker_layers": [],
+        "effects": [],
+        "filters": [],
+        "keyframes": [],
+        "captions": [],
+        "templates": [],
+        "export_settings": deepcopy(DEFAULT_EXPORT_SETTINGS),
+        "plugins": [],
+        "automation": {"webhooks": [], "batch": {}, "n8n": {"compatible": True}},
+    }
+
+
+class ProjectStore:
+    def __init__(self, settings: Settings | None = None) -> None:
+        self.settings = settings or Settings()
+        self.settings.ensure_dirs()
+        self.root = self.settings.storage_dir / "projects"
+        self.root.mkdir(parents=True, exist_ok=True)
+
+    def list(self) -> list[dict[str, Any]]:
+        projects: list[dict[str, Any]] = []
+        for manifest in sorted(self.root.glob("*/project.json")):
+            try:
+                data = normalize_project(read_json(manifest, {}))
+                projects.append(_summary(data, manifest.parent))
+            except Exception:
+                continue
+        return projects
+
+    def create(self, name: str, metadata: dict[str, Any] | None = None, template: dict[str, Any] | None = None) -> dict[str, Any]:
+        project = normalize_project(template or default_project(name, metadata))
+        project["name"] = name
+        project["metadata"] = metadata or project.get("metadata", {})
+        if not project.get("id"):
+            project["id"] = new_id("project")
+        project["slug"] = safe_filename(str(project.get("slug") or name or project["id"]))
+        project["created_at"] = project.get("created_at") or now()
+        project["updated_at"] = now()
+        self.save(project["id"], project)
+        return project
+
+    def get(self, project_id: str) -> dict[str, Any]:
+        path = self._path(project_id)
+        data = read_json(path, None)
+        if data is None:
+            raise KeyError(project_id)
+        return normalize_project(data)
+
+    def save(self, project_id: str, project: dict[str, Any]) -> dict[str, Any]:
+        normalized = normalize_project(project)
+        normalized["id"] = project_id or normalized.get("id") or new_id("project")
+        normalized["slug"] = safe_filename(str(normalized.get("slug") or normalized.get("name") or normalized["id"]))
+        normalized["updated_at"] = now()
+        write_json(self._path(normalized["id"]), normalized)
+        return normalized
+
+    def delete(self, project_id: str) -> None:
+        path = self._path(project_id)
+        if not path.exists():
+            raise KeyError(project_id)
+        directory = path.parent
+        for child in directory.glob("*"):
+            if child.is_file():
+                child.unlink()
+        try:
+            directory.rmdir()
+        except OSError:
+            pass
+
+    def add_asset(self, project_id: str, asset: dict[str, Any]) -> dict[str, Any]:
+        project = self.get(project_id)
+        asset = deepcopy(asset)
+        asset.setdefault("id", new_id("asset"))
+        asset.setdefault("created_at", now())
+        project["assets"].append(asset)
+        return self.save(project_id, project)
+
+    def add_to_timeline(self, project_id: str, item: dict[str, Any], track_type: str = "video", track_id: str | None = None) -> dict[str, Any]:
+        project = self.get(project_id)
+        add_timeline_item(project, item, track_type=track_type, track_id=track_id)
+        return self.save(project_id, project)
+
+    def timeline_operation(self, project_id: str, operation: str, item_id: str | None = None, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        project = self.get(project_id)
+        apply_timeline_operation(project, operation, item_id=item_id, params=params or {})
+        return self.save(project_id, project)
+
+    def _path(self, project_id: str) -> Path:
+        project_id = safe_filename(project_id)
+        return self.root / project_id / "project.json"
+
+
+def normalize_project(project: dict[str, Any]) -> dict[str, Any]:
+    normalized = deepcopy(project or {})
+    normalized.setdefault("id", new_id("project"))
+    normalized.setdefault("name", "Untitled Project")
+    normalized.setdefault("slug", safe_filename(str(normalized["name"])))
+    normalized.setdefault("version", 1)
+    normalized.setdefault("schema", "ava2lon.project.v1")
+    normalized.setdefault("created_at", now())
+    normalized.setdefault("updated_at", now())
+    normalized.setdefault("metadata", {})
+    normalized.setdefault("timeline", {})
+    timeline = normalized["timeline"]
+    timeline.setdefault("duration", 0.0)
+    timeline.setdefault("fps", 30)
+    timeline.setdefault("tracks", {})
+    for track_type in TIMELINE_TRACK_TYPES:
+        timeline["tracks"].setdefault(track_type, [])
+    timeline.setdefault("groups", [])
+    timeline.setdefault("markers", [])
+    for key in (
+        "assets",
+        "audio_tracks",
+        "video_tracks",
+        "text_layers",
+        "sticker_layers",
+        "effects",
+        "filters",
+        "keyframes",
+        "captions",
+        "templates",
+        "plugins",
+    ):
+        normalized.setdefault(key, [])
+    normalized.setdefault("export_settings", deepcopy(DEFAULT_EXPORT_SETTINGS))
+    normalized.setdefault("automation", {"webhooks": [], "batch": {}, "n8n": {"compatible": True}})
+    _recalculate_duration(normalized)
+    return normalized
+
+
+def add_timeline_item(project: dict[str, Any], item: dict[str, Any], *, track_type: str = "video", track_id: str | None = None) -> dict[str, Any]:
+    if not is_track_type(track_type):
+        raise ValueError(f"Unsupported track type: {track_type}")
+    normalized = normalize_project(project)
+    item = deepcopy(item)
+    item.setdefault("id", new_id("clip"))
+    item.setdefault("type", track_type)
+    item.setdefault("start", 0.0)
+    item.setdefault("duration", max(float(item.get("end", 0.0)) - float(item.get("start", 0.0)), 0.0) or 1.0)
+    item.setdefault("source_start", 0.0)
+    item.setdefault("locked", False)
+    item.setdefault("hidden", False)
+    item.setdefault("keyframes", [])
+    item.setdefault("effects", [])
+    item.setdefault("filters", [])
+    item.setdefault("metadata", {})
+    track = _ensure_track(normalized, track_type, track_id)
+    track["items"].append(item)
+    track["items"].sort(key=lambda entry: float(entry.get("start", 0.0)))
+    project.clear()
+    project.update(normalized)
+    _mirror_layers(project, track_type, item)
+    _recalculate_duration(project)
+    return item
+
+
+def apply_timeline_operation(project: dict[str, Any], operation: str, *, item_id: str | None = None, params: dict[str, Any] | None = None) -> dict[str, Any]:
+    if not is_timeline_operation(operation):
+        raise ValueError(f"Unsupported timeline operation: {operation}")
+    params = params or {}
+    normalized = normalize_project(project)
+
+    if operation == "insert":
+        add_timeline_item(
+            normalized,
+            params.get("item", {}),
+            track_type=str(params.get("track_type", "video")),
+            track_id=params.get("track_id"),
+        )
+    elif operation == "group":
+        group_id = str(params.get("group_id") or new_id("group"))
+        item_ids = [str(value) for value in params.get("item_ids", [])]
+        normalized["timeline"]["groups"].append({"id": group_id, "item_ids": item_ids, "metadata": params.get("metadata", {})})
+        for grouped_id in item_ids:
+            try:
+                grouped_item, _ = _find_item(normalized, grouped_id)
+                grouped_item["group_id"] = group_id
+            except KeyError:
+                continue
+    else:
+        if not item_id:
+            raise ValueError(f"{operation} requires item_id")
+        item, track = _find_item(normalized, item_id)
+        if operation == "drag":
+            item["start"] = max(0.0, float(params.get("start", item.get("start", 0.0))))
+        elif operation == "trim":
+            if "start" in params:
+                item["start"] = max(0.0, float(params["start"]))
+            if "duration" in params:
+                item["duration"] = max(0.001, float(params["duration"]))
+            if "source_start" in params:
+                item["source_start"] = max(0.0, float(params["source_start"]))
+        elif operation == "split":
+            offset = float(params.get("offset", 0.0))
+            duration = float(item.get("duration", 0.0))
+            if offset <= 0 or offset >= duration:
+                raise ValueError("split offset must be inside the item duration")
+            new_item = deepcopy(item)
+            new_item["id"] = str(params.get("new_item_id") or new_id("clip"))
+            new_item["start"] = float(item.get("start", 0.0)) + offset
+            new_item["duration"] = duration - offset
+            new_item["source_start"] = float(item.get("source_start", 0.0)) + offset
+            item["duration"] = offset
+            track["items"].append(new_item)
+            track["items"].sort(key=lambda entry: float(entry.get("start", 0.0)))
+        elif operation == "ripple_delete":
+            start = float(item.get("start", 0.0))
+            duration = float(item.get("duration", 0.0))
+            track["items"] = [entry for entry in track["items"] if entry.get("id") != item_id]
+            for entry in track["items"]:
+                if float(entry.get("start", 0.0)) > start:
+                    entry["start"] = max(start, float(entry.get("start", 0.0)) - duration)
+        elif operation == "replace":
+            replacement = deepcopy(params.get("item", {}))
+            replacement.setdefault("id", item_id)
+            replacement.setdefault("start", item.get("start", 0.0))
+            replacement.setdefault("duration", item.get("duration", 1.0))
+            replacement.setdefault("type", item.get("type", track.get("type")))
+            index = track["items"].index(item)
+            track["items"][index] = replacement
+        elif operation == "lock":
+            item["locked"] = bool(params.get("locked", True))
+        elif operation == "hide":
+            item["hidden"] = bool(params.get("hidden", True))
+        elif operation == "duplicate":
+            duplicate = deepcopy(item)
+            duplicate["id"] = str(params.get("new_item_id") or new_id("clip"))
+            duplicate["start"] = float(params.get("start", float(item.get("start", 0.0)) + float(item.get("duration", 1.0))))
+            track["items"].append(duplicate)
+            track["items"].sort(key=lambda entry: float(entry.get("start", 0.0)))
+
+    project.clear()
+    project.update(normalized)
+    _recalculate_duration(project)
+    return project
+
+
+def add_effect(project: dict[str, Any], target_id: str, effect: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+    effect_record = {"id": new_id("effect"), "target_id": target_id, "effect": effect, "params": params or {}, "created_at": now()}
+    project.setdefault("effects", []).append(effect_record)
+    try:
+        item, _ = _find_item(project, target_id)
+        item.setdefault("effects", []).append(effect_record)
+    except KeyError:
+        pass
+    return effect_record
+
+
+def add_filter(project: dict[str, Any], target_id: str, filter_name: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+    filter_record = {"id": new_id("filter"), "target_id": target_id, "filter": filter_name, "params": params or {}, "created_at": now()}
+    project.setdefault("filters", []).append(filter_record)
+    try:
+        item, _ = _find_item(project, target_id)
+        item.setdefault("filters", []).append(filter_record)
+    except KeyError:
+        pass
+    return filter_record
+
+
+def add_transition(project: dict[str, Any], from_item_id: str, to_item_id: str, transition: str, duration: float = 0.45) -> dict[str, Any]:
+    record = {
+        "id": new_id("transition"),
+        "from_item_id": from_item_id,
+        "to_item_id": to_item_id,
+        "transition": transition,
+        "duration": duration,
+        "created_at": now(),
+    }
+    project.setdefault("timeline", {}).setdefault("transitions", []).append(record)
+    return record
+
+
+def add_keyframe(
+    project: dict[str, Any],
+    target_id: str,
+    property_name: str,
+    time: float,
+    value: Any,
+    easing: str = "linear",
+) -> dict[str, Any]:
+    record = {
+        "id": new_id("keyframe"),
+        "target_id": target_id,
+        "property": property_name,
+        "time": max(0.0, float(time)),
+        "value": value,
+        "easing": easing,
+    }
+    project.setdefault("keyframes", []).append(record)
+    try:
+        item, _ = _find_item(project, target_id)
+        item.setdefault("keyframes", []).append(record)
+    except KeyError:
+        pass
+    return record
+
+
+def _ensure_track(project: dict[str, Any], track_type: str, track_id: str | None = None) -> dict[str, Any]:
+    tracks = project["timeline"]["tracks"].setdefault(track_type, [])
+    if track_id:
+        for track in tracks:
+            if track.get("id") == track_id:
+                return track
+    if not tracks:
+        track_id = track_id or f"{track_type}_1"
+    else:
+        track_id = track_id or f"{track_type}_{len(tracks) + 1}"
+    track = {"id": track_id, "type": track_type, "name": f"{track_type.title()} {len(tracks) + 1}", "locked": False, "hidden": False, "items": []}
+    tracks.append(track)
+    return track
+
+
+def _find_item(project: dict[str, Any], item_id: str) -> tuple[dict[str, Any], dict[str, Any]]:
+    for tracks in project.get("timeline", {}).get("tracks", {}).values():
+        for track in tracks:
+            for item in track.get("items", []):
+                if item.get("id") == item_id:
+                    return item, track
+    raise KeyError(item_id)
+
+
+def _mirror_layers(project: dict[str, Any], track_type: str, item: dict[str, Any]) -> None:
+    mirror_key = {
+        "video": "video_tracks",
+        "audio": "audio_tracks",
+        "text": "text_layers",
+        "sticker": "sticker_layers",
+        "subtitle": "captions",
+    }.get(track_type)
+    if mirror_key:
+        project.setdefault(mirror_key, []).append({"item_id": item["id"], **deepcopy(item)})
+
+
+def _recalculate_duration(project: dict[str, Any]) -> None:
+    duration = 0.0
+    for tracks in project.get("timeline", {}).get("tracks", {}).values():
+        for track in tracks:
+            for item in track.get("items", []):
+                duration = max(duration, float(item.get("start", 0.0)) + float(item.get("duration", 0.0)))
+    project.setdefault("timeline", {})["duration"] = round(duration, 3)
+
+
+def _summary(project: dict[str, Any], directory: Path) -> dict[str, Any]:
+    return {
+        "id": project.get("id"),
+        "name": project.get("name"),
+        "slug": project.get("slug"),
+        "path": str(directory),
+        "updated_at": project.get("updated_at"),
+        "duration": project.get("timeline", {}).get("duration", 0.0),
+        "asset_count": len(project.get("assets", [])),
+        "metadata": project.get("metadata", {}),
+    }

renderer/studio/tasks.py

@@ -0,0 +1,240 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from renderer.core.config import Settings
+from renderer.core.models import TaskResult
+from renderer.core.utils import now, safe_filename, write_json
+from renderer.studio.capabilities import (
+    AI_ASSISTANTS,
+    AI_EDITING_FEATURES,
+    IMAGE_GENERATION_PROVIDERS,
+    MUSIC_PROVIDERS,
+    VIDEO_GENERATION_PROVIDERS,
+    VOICE_PROVIDERS,
+)
+
+
+class StudioTaskProcessor:
+    """Manifest-producing async handlers for optional AI providers and studio automation."""
+
+    def __init__(self, settings: Settings | None = None, log=None) -> None:
+        self.settings = settings or Settings()
+        self.settings.ensure_dirs()
+        self._logs: list[str] = []
+        self._log = log
+
+    def caption_generate(self, payload: dict[str, Any], job_id: str) -> TaskResult:
+        text = str(payload.get("text") or payload.get("transcript") or "")
+        captions = payload.get("events") if isinstance(payload.get("events"), list) else _captions_from_text(text)
+        manifest = {
+            "type": "caption_generation",
+            "status": "ready",
+            "engine": payload.get("engine", "whisper"),
+            "media": payload.get("media") or payload.get("audio"),
+            "template": payload.get("template", "capcut"),
+            "language": payload.get("language"),
+            "features": {
+                "word_timestamps": bool(payload.get("word_timestamps", True)),
+                "sentence_timestamps": True,
+                "emoji_insertion": bool(payload.get("emoji_insertion", False)),
+                "speaker_detection": bool(payload.get("speaker_detection", False)),
+                "karaoke": bool(payload.get("karaoke", True)),
+                "animated": bool(payload.get("animated", True)),
+            },
+            "captions": captions,
+        }
+        output = self._json_artifact(job_id, "captions", manifest)
+        return self._result(output, {"task": "caption_generate", "caption_count": len(captions)})
+
+    def music_generate(self, payload: dict[str, Any], job_id: str) -> TaskResult:
+        provider = _provider(payload.get("provider"), MUSIC_PROVIDERS, "musicgen")
+        prompt = str(payload.get("prompt") or payload.get("style") or "background music")
+        duration = float(payload.get("duration", 30))
+        manifest = {
+            "type": "music_generation",
+            "status": "provider_required",
+            "provider": provider,
+            "prompt": prompt,
+            "style": payload.get("style", "background_music"),
+            "duration": duration,
+            "bpm": payload.get("bpm"),
+            "license": payload.get("license", "user_configured"),
+            "next_step": "Configure provider credentials or connect this manifest to a local MusicGen runner.",
+        }
+        output = self._json_artifact(job_id, "music_request", manifest)
+        return self._result(output, {"task": "music_generate", "provider": provider, "duration": duration})
+
+    def voice_generate(self, payload: dict[str, Any], job_id: str) -> TaskResult:
+        provider = _provider(payload.get("provider"), VOICE_PROVIDERS, "kokoro")
+        text = str(payload.get("text") or "")
+        manifest = {
+            "type": "voice_generation",
+            "status": "provider_required",
+            "provider": provider,
+            "text": text,
+            "voice": payload.get("voice", "default"),
+            "emotion": payload.get("emotion"),
+            "speed": float(payload.get("speed", 1.0)),
+            "pitch": float(payload.get("pitch", 1.0)),
+            "clone_reference": payload.get("clone_reference"),
+            "multi_speaker": payload.get("speakers", []),
+            "next_step": "Configure the selected TTS backend to render audio for this manifest.",
+        }
+        output = self._json_artifact(job_id, "voice_request", manifest)
+        return self._result(output, {"task": "voice_generate", "provider": provider, "characters": len(text)})
+
+    def image_generate(self, payload: dict[str, Any], job_id: str) -> TaskResult:
+        provider = _provider(payload.get("provider"), IMAGE_GENERATION_PROVIDERS, "flux")
+        manifest = {
+            "type": "image_generation",
+            "status": "provider_required",
+            "provider": provider,
+            "prompt": payload.get("prompt", ""),
+            "negative_prompt": payload.get("negative_prompt", ""),
+            "mode": payload.get("mode", "text_to_image"),
+            "control_image": payload.get("control_image"),
+            "source_image": payload.get("source_image"),
+            "size": payload.get("size", "1024x1024"),
+            "features": {
+                "background_replacement": bool(payload.get("background_replacement", False)),
+                "object_removal": bool(payload.get("object_removal", False)),
+                "upscaling": bool(payload.get("upscaling", False)),
+            },
+        }
+        output = self._json_artifact(job_id, "image_request", manifest)
+        return self._result(output, {"task": "image_generate", "provider": provider})
+
+    def video_generate(self, payload: dict[str, Any], job_id: str) -> TaskResult:
+        provider = _provider(payload.get("provider"), VIDEO_GENERATION_PROVIDERS, "ltx_video")
+        manifest = {
+            "type": "video_generation",
+            "status": "provider_required",
+            "provider": provider,
+            "prompt": payload.get("prompt", ""),
+            "mode": payload.get("mode", "text_to_video"),
+            "image": payload.get("image"),
+            "duration": float(payload.get("duration", 5)),
+            "fps": int(payload.get("fps", 24)),
+            "size": payload.get("size", "1280x720"),
+            "next_step": "Connect Wan, LTX Video, Hunyuan Video, or Veo credentials/runtime to execute this request.",
+        }
+        output = self._json_artifact(job_id, "video_request", manifest)
+        return self._result(output, {"task": "video_generate", "provider": provider})
+
+    def ai_tool(self, tool: str, payload: dict[str, Any], job_id: str) -> TaskResult:
+        tool = _canonical(tool)
+        if tool not in AI_EDITING_FEATURES:
+            raise ValueError(f"Unsupported AI editing tool: {tool}")
+        manifest = {
+            "type": "ai_editing",
+            "tool": tool,
+            "status": "ready",
+            "media": payload.get("media"),
+            "project_id": payload.get("project_id"),
+            "platform": payload.get("platform", "tiktok"),
+            "result": _ai_result(tool, payload),
+            "created_at": now(),
+        }
+        output = self._json_artifact(job_id, tool, manifest)
+        return self._result(output, {"task": tool})
+
+    def assistant_tool(self, tool: str, payload: dict[str, Any], job_id: str) -> TaskResult:
+        tool = _canonical(tool)
+        if tool not in AI_ASSISTANTS:
+            raise ValueError(f"Unsupported assistant: {tool}")
+        text = str(payload.get("topic") or payload.get("transcript") or payload.get("prompt") or "")
+        manifest = {
+            "type": "assistant",
+            "tool": tool,
+            "status": "ready",
+            "input": text,
+            "platform": payload.get("platform", "general"),
+            "result": _assistant_result(tool, text, payload),
+            "created_at": now(),
+        }
+        output = self._json_artifact(job_id, tool, manifest)
+        return self._result(output, {"task": tool, "characters": len(text)})
+
+    def _json_artifact(self, job_id: str, name: str, payload: dict[str, Any]) -> Path:
+        output = self.settings.exports_dir / f"{job_id}_{safe_filename(name)}.json"
+        write_json(output, payload)
+        self._message(f"Wrote {name} manifest")
+        return output
+
+    def _result(self, output: Path, metrics: dict[str, Any]) -> TaskResult:
+        return TaskResult(output_path=output, commands=[], metrics=metrics, logs=list(self._logs))
+
+    def _message(self, message: str) -> None:
+        self._logs.append(message)
+        if self._log:
+            self._log(message)
+
+
+def _provider(value: Any, supported: list[str], default: str) -> str:
+    provider = _canonical(str(value or default))
+    return provider if provider in supported else default
+
+
+def _canonical(value: str) -> str:
+    return value.strip().lower().replace("-", "_").replace(" ", "_")
+
+
+def _captions_from_text(text: str) -> list[dict[str, Any]]:
+    if not text:
+        return []
+    words = text.split()
+    chunks: list[list[str]] = []
+    while words:
+        chunks.append(words[:8])
+        words = words[8:]
+    captions = []
+    cursor = 0.0
+    for chunk in chunks:
+        duration = max(1.2, len(chunk) * 0.34)
+        captions.append({"start": round(cursor, 2), "end": round(cursor + duration, 2), "text": " ".join(chunk)})
+        cursor += duration
+    return captions
+
+
+def _ai_result(tool: str, payload: dict[str, Any]) -> dict[str, Any]:
+    platform = str(payload.get("platform") or "tiktok")
+    if tool == "auto_highlight_detection":
+        return {"highlights": [{"start": 0, "end": 8, "reason": "opening hook"}]}
+    if tool == "auto_scene_detection":
+        return {"scenes": [{"start": 0, "end": 5, "label": "intro"}, {"start": 5, "end": 12, "label": "body"}]}
+    if tool in {"auto_reframe", "auto_crop", "auto_platform_optimization"}:
+        return {"platform": platform, "safe_zone": "vertical_center", "aspect_ratio": "9:16"}
+    if tool == "auto_viral_score":
+        return {"score": 74, "signals": ["short duration", "caption-ready", platform]}
+    if tool == "auto_hook_detection":
+        return {"hook": str(payload.get("transcript") or payload.get("text") or "")[:120], "score": 68}
+    if tool == "auto_thumbnail_selection":
+        return {"frames": [{"timestamp": 2.0, "score": 82}, {"timestamp": 6.5, "score": 75}]}
+    return {"plan": f"{tool} plan generated", "confidence": "heuristic", "platform": platform}
+
+
+def _assistant_result(tool: str, text: str, payload: dict[str, Any]) -> dict[str, Any]:
+    subject = text.strip() or "your video"
+    short = " ".join(subject.split()[:12])
+    if tool == "script_writer":
+        return {"script": f"Hook: {short}\nValue: show the clearest proof.\nCTA: invite viewers to take the next step."}
+    if tool == "hook_generator":
+        return {"hooks": [f"Stop scrolling if you care about {short}", f"Nobody tells you this about {short}"]}
+    if tool == "title_generator":
+        return {"titles": [short.title(), f"How {short.title()} Changes Everything"]}
+    if tool == "description_generator":
+        return {"description": f"{subject}\n\nBuilt with Ava2lon Studio AI."}
+    if tool == "hashtag_generator":
+        tags = [word.strip(".,!?").lower() for word in subject.split() if len(word.strip(".,!?")) > 3]
+        return {"hashtags": ["#" + tag for tag in tags[:8]] or ["#video", "#creator"]}
+    if tool == "storyboard_generator":
+        return {"beats": [{"scene": 1, "goal": "hook"}, {"scene": 2, "goal": "proof"}, {"scene": 3, "goal": "CTA"}]}
+    if tool == "b_roll_planner":
+        return {"shots": [{"type": "close_up", "description": short}, {"type": "screen_recording", "description": "show the result"}]}
+    if tool == "thumbnail_prompt_generator":
+        return {"prompt": f"High contrast thumbnail for {short}, expressive face, bold text, clean background"}
+    if tool == "seo_optimizer":
+        return {"keywords": [word.strip(".,!?").lower() for word in subject.split()[:10]], "score": 72}
+    return {"result": subject, "options": payload}

renderer/templates/creative.py

@@ -71,6 +71,66 @@ SCENE_EFFECTS: dict[str, dict[str, str]] = {
         "label": "Noir",
         "filter": "hue=s=0,eq=contrast=1.18:brightness=-0.02",
     },
+    "glitch": {
+        "label": "Glitch",
+        "filter": "rgbashift=rh=4:bh=-4,eq=contrast=1.12:saturation=1.18",
+    },
+    "rgb_split": {
+        "label": "RGB Split",
+        "filter": "rgbashift=rh=3:gv=1:bh=-3",
+    },
+    "vhs": {
+        "label": "VHS",
+        "filter": "noise=alls=18:allf=t+u,eq=saturation=0.82:contrast=1.08",
+    },
+    "crt": {
+        "label": "CRT",
+        "filter": "vignette=PI/4,noise=alls=10:allf=t+u,eq=contrast=1.15:saturation=0.9",
+    },
+    "bloom": {
+        "label": "Bloom",
+        "filter": "gblur=sigma=0.35,eq=brightness=0.025:saturation=1.14",
+    },
+    "glow": {
+        "label": "Glow",
+        "filter": "gblur=sigma=0.45,eq=contrast=1.05:brightness=0.03",
+    },
+    "chromatic_aberration": {
+        "label": "Chromatic Aberration",
+        "filter": "rgbashift=rh=2:rv=1:bh=-2:bv=-1",
+    },
+    "neon": {
+        "label": "Neon",
+        "filter": "eq=contrast=1.2:saturation=1.55:brightness=0.02",
+    },
+    "cyberpunk": {
+        "label": "Cyberpunk",
+        "filter": "eq=contrast=1.18:saturation=1.45:gamma_r=1.08:gamma_b=1.18",
+    },
+    "comic": {
+        "label": "Comic",
+        "filter": "edgedetect=low=0.08:high=0.25,eq=contrast=1.2:saturation=1.35",
+    },
+    "cartoon": {
+        "label": "Cartoon",
+        "filter": "edgedetect=low=0.05:high=0.2,eq=saturation=1.45:contrast=1.15",
+    },
+    "anime": {
+        "label": "Anime",
+        "filter": "eq=saturation=1.35:contrast=1.12:brightness=0.02,unsharp=5:5:0.6",
+    },
+    "sketch": {
+        "label": "Sketch",
+        "filter": "edgedetect=low=0.03:high=0.18,hue=s=0",
+    },
+    "oil_painting": {
+        "label": "Oil Painting",
+        "filter": "gblur=sigma=0.7,eq=saturation=1.25:contrast=1.1",
+    },
+    "pixel_art": {
+        "label": "Pixel Art",
+        "filter": "scale=iw/8:ih/8,scale=iw*8:ih*8:flags=neighbor",
+    },
 }
 
 

renderer/transitions/builder.py

@@ -5,21 +5,43 @@ class TransitionBuilder:
     """Build FFmpeg xfade filters for scene joins."""
 
     TRANSITIONS = {
+        "basic": "fade",
         "fade": "fade",
         "zoom": "zoomin",
         "slide": "slideleft",
+        "slide_left": "slideleft",
+        "slide_right": "slideright",
+        "slide_up": "slideup",
+        "slide_down": "slidedown",
         "push": "slideup",
         "blur": "fade",
         "whip": "smoothleft",
         "dissolve": "dissolve",
         "flash": "fadewhite",
         "glitch": "hlslice",
+        "light_leak": "fadewhite",
+        "film_burn": "fadegrays",
+        "camera_shake": "smoothleft",
+        "spin": "circleopen",
+        "3d_flip": "vertopen",
+        "flip": "vertopen",
+        "cube": "rectcrop",
+        "ripple": "radial",
+        "ink": "distance",
+        "morph": "dissolve",
+        "stretch": "squeezeh",
+        "liquid": "pixelize",
+        "elastic": "smoothup",
+        "motion_blur": "smoothleft",
         "wipe": "wipeleft",
         "wipe_left": "wipeleft",
         "wipe_right": "wiperight",
+        "wipe_up": "wipeup",
+        "wipe_down": "wipedown",
         "smooth_left": "smoothleft",
         "smooth_right": "smoothright",
         "fadeblack": "fadeblack",
+        "fade_white": "fadewhite",
         "pixel": "pixelize",
     }