Upload 34 files

renderer/core/config.py

@@ -18,6 +18,7 @@ class Settings:
     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", "")
     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/core/models.py

@@ -24,6 +24,7 @@ class RenderRequest:
     scenes: list[Scene]
     template: str = "tiktok_classic"
     preset: str | None = None
+    creative_style: str | None = None
     platform: str | None = None
     output_name: str = "render.mp4"
     voiceover: str | None = None
@@ -59,6 +60,7 @@ class AIReelsRequest:
     voiceover: str
     assets: list[str]
     template: str = "tiktok_classic"
+    creative_style: str | None = None
     platform: str | None = None
     output_name: str = "ai_reel.mp4"
     background_music: str | None = None
@@ -79,6 +81,14 @@ class RenderResult:
     logs: list[str] = field(default_factory=list)
 
 
+@dataclass
+class TaskResult:
+    output_path: Path | None = None
+    commands: list[list[str]] = field(default_factory=list)
+    metrics: dict[str, Any] = field(default_factory=dict)
+    logs: list[str] = field(default_factory=list)
+
+
 @dataclass
 class AssetMetadata:
     path: str

renderer/core/render_engine.py

@@ -17,7 +17,7 @@ from renderer.ffmpeg.normalize import Normalizer
 from renderer.ffmpeg.runner import FFmpegRunner
 from renderer.scenes import Timeline
 from renderer.subtitles import SubtitleGenerator
-from renderer.templates import PlatformProfile, get_platform_profile
+from renderer.templates import PlatformProfile, get_creative_style, get_platform_profile, scene_effect_filter
 from renderer.transcription import WhisperTranscriber
 from renderer.transitions import TransitionBuilder
 
@@ -74,6 +74,8 @@ class RenderEngine:
             "render_time_seconds": round(time.time() - started, 3),
             "output_size_bytes": output.stat().st_size,
             "scene_count": len(request.scenes),
+            "creative_style": request.creative_style or request.metadata.get("creative_style"),
+            "scene_effects": [scene.effect for scene in request.scenes if scene.effect],
             "platform": profile.metadata(),
         }
         return RenderResult(output_path=output, commands=list(self._commands), metrics=metrics, logs=list(self._logs))
@@ -86,8 +88,9 @@ class RenderEngine:
         with temp_workdir(self.settings.temp_dir, job_id) as work:
             workdir = Path(work)
             resolved = self.ingest.resolve_ai_reels_request(request, workdir)
+            style = get_creative_style(resolved.creative_style)
             voice_meta = self.assets.probe(resolved.voiceover)
-            duration = max(voice_meta.duration, len(resolved.script.split()) * 0.35, 3.0)
+            duration = max(voice_meta.duration, len(resolved.script.split()) * 0.35, style.scene_duration * len(resolved.assets), 3.0)
             per_scene = duration / max(1, len(resolved.assets))
             captions = _split_script(resolved.script, len(resolved.assets))
             scenes = [
@@ -96,6 +99,8 @@ class RenderEngine:
                     "duration": round(per_scene, 3),
                     "media": asset,
                     "caption": captions[idx] if idx < len(captions) else "",
+                    "transition": style.transition_sequence[idx % len(style.transition_sequence)],
+                    "effect": style.scene_effect_sequence[idx % len(style.scene_effect_sequence)],
                 }
                 for idx, asset in enumerate(resolved.assets)
             ]
@@ -113,6 +118,8 @@ class RenderEngine:
                 music_start=resolved.music_start,
                 music_ducking=resolved.music_ducking,
                 voice_volume=resolved.voice_volume,
+                creative_style=resolved.creative_style,
+                metadata={"creative_style": style.key, "creative_style_label": style.label},
             )
             return self._render_resolved(render_request, job_id, workdir)
 
@@ -171,6 +178,8 @@ class RenderEngine:
             "render_time_seconds": round(time.time() - started, 3),
             "output_size_bytes": output.stat().st_size,
             "scene_count": len(request.scenes),
+            "creative_style": request.creative_style or request.metadata.get("creative_style"),
+            "scene_effects": [scene.effect for scene in request.scenes if scene.effect],
             "platform": profile.metadata(),
         }
         return RenderResult(output_path=output, commands=list(self._commands), metrics=metrics, logs=list(self._logs))
@@ -193,6 +202,9 @@ class RenderEngine:
                 preview = workdir / f"scene_{idx:03d}_preview.mp4"
                 self._scale_preview(target, preview)
                 target = preview
+            effected = self._apply_scene_effect(target, scene.effect, workdir / f"scene_{idx:03d}_effect.mp4")
+            if effected != target:
+                target = effected
             prepared.append(target)
         return prepared
 
@@ -347,6 +359,23 @@ class RenderEngine:
         )
         self._run(command)
 
+    def _apply_scene_effect(self, source: Path, effect: str | None, output: Path) -> Path:
+        vf = scene_effect_filter(effect)
+        if not vf:
+            return source
+        command = (
+            FFmpegCommand()
+            .add("-hide_banner")
+            .input(source)
+            .add("-vf", vf, "-c:v", "libx264", "-preset", self.settings.preset, "-crf", self.settings.crf, "-c:a", "copy")
+            .overwrite()
+            .add(output)
+            .build()
+        )
+        self._run(command)
+        self._logs.append(f"Applied scene effect '{effect}' to {source.name}")
+        return output
+
     def _run(self, command: list[str]) -> None:
         result = self.runner.run(command)
         if result.stderr:
@@ -366,4 +395,3 @@ def _split_script(script: str, chunks: int) -> list[str]:
 
 def _ffmpeg_subtitle_path(path: Path) -> str:
     return str(path).replace("\\", "/").replace(":", r"\:")
-

renderer/jobs/manager.py

@@ -35,6 +35,15 @@ class JobManager:
     def submit_ai_reels(self, request: AIReelsRequest) -> str:
         return self._submit(lambda job_id, log: RenderEngine(self.settings, log=log).ai_reels(request, job_id))
 
+    def submit_task(
+        self,
+        handler: Callable[[str, Callable[[str], None]], object],
+        *,
+        callback_url: str | None = None,
+        export_target: str | None = None,
+    ) -> str:
+        return self._submit(handler, callback_url=callback_url, export_target=export_target)
+
     def submit_batch(self, requests: list[RenderRequest]) -> list[str]:
         job_ids: list[str] = []
         for request in requests:
@@ -75,6 +84,34 @@ class JobManager:
             shutil.rmtree(uploads, ignore_errors=True)
         return {"removed_jobs": removed_jobs, "removed_exports": removed_exports}
 
+    def summary(self) -> dict:
+        records: list[JobRecord] = []
+        for path in self.settings.jobs_dir.glob("*.json"):
+            try:
+                records.append(JobRecord(**read_json(path, {})))
+            except Exception:
+                continue
+        state_counts: dict[str, int] = {}
+        for record in records:
+            state_counts[record.state] = state_counts.get(record.state, 0) + 1
+        active = [
+            {
+                "job_id": record.job_id,
+                "state": record.state,
+                "created_at": record.created_at,
+                "updated_at": record.updated_at,
+                "metrics": record.metrics,
+            }
+            for record in sorted(records, key=lambda item: item.updated_at, reverse=True)
+            if record.state in {"PENDING", "RUNNING", "CANCEL_REQUESTED"}
+        ]
+        return {
+            "total_jobs": len(records),
+            "state_counts": state_counts,
+            "active_jobs": active,
+            "max_workers": self.settings.max_workers,
+        }
+
     def _submit(
         self,
         handler: Callable[[str, Callable[[str], None]], object],
@@ -110,15 +147,16 @@ class JobManager:
                     return
                 result = handler(job_id, lambda message: self.append_log(job_id, message))
                 record = self.get(job_id)
-                export_path = self._export_copy(result.output_path, record.export_target, job_id)
+                output_path = getattr(result, "output_path", None)
+                export_path = self._export_copy(output_path, record.export_target, job_id) if output_path else None
                 self._update(
                     job_id,
                     state="COMPLETED",
-                    output_path=str(result.output_path),
+                    output_path=str(output_path) if output_path else None,
                     export_path=export_path,
-                    commands=result.commands,
-                    logs=result.logs,
-                    metrics=result.metrics | {"attempt": attempts},
+                    commands=getattr(result, "commands", []),
+                    logs=getattr(result, "logs", []),
+                    metrics=getattr(result, "metrics", {}) | {"attempt": attempts},
                 )
                 self._send_callback(job_id)
                 return

renderer/platform/__init__.py

@@ -0,0 +1,3 @@
+from renderer.platform.processor import PlatformProcessor, supported_toolkit_tasks
+
+__all__ = ["PlatformProcessor", "supported_toolkit_tasks"]

renderer/platform/processor.py

@@ -0,0 +1,506 @@
+from __future__ import annotations
+
+import json
+import math
+import mimetypes
+import shutil
+import zipfile
+from pathlib import Path
+from typing import Any
+
+from renderer.core.config import Settings
+from renderer.core.ingest import AssetIngestor
+from renderer.core.models import TaskResult
+from renderer.core.utils import safe_filename, temp_workdir, write_json
+from renderer.ffmpeg.assets import AssetProbe
+from renderer.ffmpeg.command import FFmpegCommand
+from renderer.ffmpeg.runner import FFmpegRunner
+from renderer.templates import get_platform_profile
+
+
+TOOLKIT_TASKS = {
+    "trim",
+    "split",
+    "concat",
+    "merge",
+    "compress",
+    "normalize",
+    "resize",
+    "crop",
+    "rotate",
+    "speed",
+    "reverse",
+    "loop",
+    "extract_audio",
+    "thumbnail",
+    "gif",
+    "frames",
+    "watermark",
+    "overlay_text",
+    "blur_background",
+    "burn_subtitles",
+    "convert",
+    "merge_audio",
+    "noise_reduction",
+    "green_screen",
+}
+
+
+class PlatformProcessor:
+    def __init__(self, settings: Settings | None = None, log=None) -> None:
+        self.settings = settings or Settings()
+        self.settings.ensure_dirs()
+        self._commands: list[list[str]] = []
+        self._logs: list[str] = []
+        self.runner = FFmpegRunner(self.settings.ffmpeg_timeout_seconds, log=log, on_command=self._record_command)
+        self.ingest = AssetIngestor(self.settings)
+        self.assets = AssetProbe(self.settings.metadata_cache)
+
+    def ingest_sources(self, sources: list[dict[str, Any]], job_id: str) -> TaskResult:
+        with temp_workdir(self.settings.temp_dir, f"{job_id}_ingest") as work:
+            workdir = Path(work)
+            staged: list[dict[str, Any]] = []
+            for index, source in enumerate(sources):
+                url = str(source.get("url") or source.get("source") or "").strip()
+                if not url:
+                    continue
+                source_type = str(source.get("type") or _source_type(url))
+                if source_type == "youtube":
+                    staged.append(
+                        {
+                            "source": url,
+                            "source_type": source_type,
+                            "status": "registered",
+                            "note": "YouTube ingestion is registered for automation; provide a direct downloadable media URL or install yt-dlp for local extraction.",
+                        }
+                    )
+                    continue
+                resolved = self.ingest.resolve(url, workdir / "inputs", f"source_{index:03d}")
+                metadata = self.assets.probe(resolved).__dict__
+                staged.append({"source": url, "source_type": source_type, "path": str(resolved), "metadata": metadata})
+            output = self._json_artifact(job_id, "ingest_manifest", {"assets": staged, "asset_count": len(staged)})
+        return self._result(output, {"task": "ingest", "asset_count": len(staged)})
+
+    def analyze(self, media: str, job_id: str, *, transcript: str = "", platform: str | None = None) -> TaskResult:
+        with temp_workdir(self.settings.temp_dir, f"{job_id}_analyze") as work:
+            workdir = Path(work)
+            source = self.ingest.resolve(media, workdir / "inputs", "media")
+            metadata = self.assets.probe(source)
+            duration = max(0.0, metadata.duration)
+            words = transcript.split()
+            words_per_minute = (len(words) / duration * 60) if duration > 0 and words else None
+            highlights = _highlight_windows(duration)
+            viral_score = _viral_score(duration, bool(words), metadata.width, metadata.height)
+            analysis = {
+                "media": str(source),
+                "metadata": metadata.__dict__,
+                "transcript": transcript,
+                "highlight_moments": highlights,
+                "viral_score": viral_score,
+                "hook_quality": _hook_quality(transcript),
+                "audience_retention_estimate": _retention_estimate(duration, viral_score),
+                "engagement_prediction": _engagement_prediction(viral_score),
+                "audience_persona": _persona(transcript),
+                "platform_recommendations": _platform_recommendations(duration, metadata.width, metadata.height, platform),
+                "scene_segmentation": highlights,
+                "speech_pacing": {
+                    "words_per_minute": round(words_per_minute, 1) if words_per_minute else None,
+                    "label": _pacing_label(words_per_minute),
+                },
+                "silence_detection": {
+                    "estimated_silence_ratio": 0.0 if transcript else 0.18,
+                    "note": "Heuristic estimate; use transcription with word timestamps for precise silence spans.",
+                },
+            }
+            output = self._json_artifact(job_id, "analysis", analysis)
+        return self._result(output, {"task": "analyze", "viral_score": viral_score, "duration": duration})
+
+    def metadata(self, job_id: str, *, topic: str = "", transcript: str = "", platform: str | None = None) -> TaskResult:
+        text = transcript or topic or "Untitled video"
+        title = _title_from_text(text, platform)
+        tags = _hashtags(text, platform)
+        payload = {
+            "title": title,
+            "description": _description(text, tags),
+            "hashtags": tags,
+            "keywords": _keywords(text),
+            "chapters": _chapters(text),
+            "seo_tags": _keywords(text) + [platform] if platform else _keywords(text),
+            "suggested_upload_schedule": _schedule(platform),
+            "platform": platform or "general",
+        }
+        output = self._json_artifact(job_id, "metadata", payload)
+        return self._result(output, {"task": "metadata", "keyword_count": len(payload["keywords"])})
+
+    def publish(self, payload: dict[str, Any], job_id: str) -> TaskResult:
+        platforms = payload.get("platforms") or [payload.get("platform") or "draft"]
+        manifest = {
+            "publish_state": "draft_ready" if payload.get("draft", True) else "credentials_required",
+            "platforms": platforms,
+            "scheduled_at": payload.get("scheduled_at"),
+            "asset": payload.get("asset") or payload.get("media"),
+            "title": payload.get("title"),
+            "description": payload.get("description"),
+            "retry_policy": {"max_attempts": 3, "backoff_seconds": 60},
+            "note": "Direct publishing requires platform OAuth/API credentials configured outside this CPU render worker.",
+        }
+        output = self._json_artifact(job_id, "publish_manifest", manifest)
+        return self._result(output, {"task": "publish", "platform_count": len(platforms)})
+
+    def clips(self, media: str, job_id: str, clips: list[dict[str, Any]] | None = None) -> TaskResult:
+        with temp_workdir(self.settings.temp_dir, f"{job_id}_clips") as work:
+            workdir = Path(work)
+            source = self.ingest.resolve(media, workdir / "inputs", "media")
+            metadata = self.assets.probe(source)
+            clip_specs = clips or _highlight_windows(metadata.duration)
+            outputs: list[Path] = []
+            for index, clip in enumerate(clip_specs):
+                start = max(0.0, float(clip.get("start", 0)))
+                end = float(clip.get("end", start + clip.get("duration", 8)))
+                duration = max(0.2, end - start)
+                target = workdir / f"clip_{index + 1:02d}.mp4"
+                command = (
+                    FFmpegCommand()
+                    .add("-hide_banner", "-ss", start)
+                    .input(source)
+                    .add("-t", duration, "-c", "copy")
+                    .overwrite()
+                    .add(target)
+                    .build()
+                )
+                self._run(command)
+                outputs.append(target)
+            if len(outputs) == 1:
+                final = self._export(outputs[0], job_id, outputs[0].name)
+            else:
+                final = self.settings.exports_dir / f"{job_id}_clips.zip"
+                with zipfile.ZipFile(final, "w", zipfile.ZIP_DEFLATED) as archive:
+                    for path in outputs:
+                        archive.write(path, path.name)
+        return self._result(final, {"task": "clips", "clip_count": len(outputs)})
+
+    def thumbnail(self, media: str, job_id: str, *, text: str = "", timestamp: float | None = None, template: str = "bold") -> TaskResult:
+        with temp_workdir(self.settings.temp_dir, f"{job_id}_thumb") as work:
+            workdir = Path(work)
+            source = self.ingest.resolve(media, workdir / "inputs", "media")
+            metadata = self.assets.probe(source)
+            target = workdir / "thumbnail.jpg"
+            seek = timestamp if timestamp is not None else max(0.0, min(metadata.duration * 0.2, 8.0))
+            vf = "scale=1280:720:force_original_aspect_ratio=increase,crop=1280:720"
+            if text:
+                vf += "," + _drawtext_filter(text, template)
+            command = (
+                FFmpegCommand()
+                .add("-hide_banner", "-ss", seek)
+                .input(source)
+                .add("-frames:v", 1, "-vf", vf, "-q:v", 2)
+                .overwrite()
+                .add(target)
+                .build()
+            )
+            self._run(command)
+            final = self._export(target, job_id, "thumbnail.jpg")
+        return self._result(final, {"task": "thumbnail", "timestamp": seek})
+
+    def toolkit(self, payload: dict[str, Any], job_id: str) -> TaskResult:
+        task = str(payload.get("task") or payload.get("operation") or "").strip()
+        if task not in TOOLKIT_TASKS:
+            raise ValueError(f"Unsupported toolkit task: {task}")
+        if task == "thumbnail":
+            return self.thumbnail(str(payload["input"]), job_id, text=str(payload.get("text") or ""), timestamp=payload.get("timestamp"))
+        if task == "split":
+            clips = payload.get("clips") if isinstance(payload.get("clips"), list) else payload.get("params", {}).get("clips")
+            return self.clips(str(payload.get("input") or payload.get("media")), job_id, clips)
+
+        with temp_workdir(self.settings.temp_dir, f"{job_id}_{task}") as work:
+            workdir = Path(work)
+            source_value = payload.get("input") or payload.get("media")
+            source = self.ingest.resolve(str(source_value), workdir / "inputs", "media") if source_value else workdir / "concat_placeholder.mp4"
+            params = payload.get("params") if isinstance(payload.get("params"), dict) else payload
+            output_name = safe_filename(str(payload.get("output_name") or _default_output_name(task)))
+            output = workdir / output_name
+            if task == "extract_audio" and output.suffix.lower() != ".mp3":
+                output = output.with_suffix(".mp3")
+            if task == "gif" and output.suffix.lower() != ".gif":
+                output = output.with_suffix(".gif")
+            command = self._toolkit_command(task, source, output, params, workdir)
+            self._run(command)
+            if task == "frames":
+                final = self.settings.exports_dir / f"{job_id}_frames.zip"
+                with zipfile.ZipFile(final, "w", zipfile.ZIP_DEFLATED) as archive:
+                    for frame in sorted(workdir.glob("frame_*.jpg")):
+                        archive.write(frame, frame.name)
+            else:
+                final = self._export(output, job_id, output.name)
+        return self._result(final, {"task": task})
+
+    def _toolkit_command(self, task: str, source: Path, output: Path, params: dict[str, Any], workdir: Path) -> list[str]:
+        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:
+            cmd.add("-ss", float(params.get("start", 0)))
+        cmd.input(source)
+
+        if task == "merge_audio":
+            audio = self.ingest.resolve(str(params.get("audio")), workdir / "inputs", "audio")
+            cmd.input(audio)
+            return cmd.add("-map", "0:v", "-map", "1:a", "-c:v", "copy", "-c:a", "aac", "-shortest").overwrite().add(output).build()
+        if task == "watermark":
+            image = self.ingest.resolve(str(params.get("watermark") or params.get("image")), workdir / "inputs", "watermark")
+            cmd.input(image)
+            return cmd.add("-filter_complex", "[1:v]scale=iw*0.18:-1[wm];[0:v][wm]overlay=W-w-24:H-h-24", "-c:a", "copy").overwrite().add(output).build()
+        if task in {"concat", "merge"}:
+            inputs = params.get("inputs")
+            if not isinstance(inputs, list) or not inputs:
+                raise ValueError("Concat requires params.inputs")
+            concat_file = workdir / "concat.txt"
+            lines: list[str] = []
+            for index, item in enumerate(inputs):
+                media = self.ingest.resolve(str(item), workdir / "inputs", f"concat_{index:03d}")
+                lines.append(f"file '{str(media).replace(chr(39), chr(39) + chr(92) + chr(39) + chr(39))}'")
+            concat_file.write_text("\n".join(lines), encoding="utf-8")
+            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:
+            cmd.add("-t", float(duration))
+
+        vf = _video_filter(task, params)
+        af = _audio_filter(task, params)
+        if vf:
+            cmd.add("-vf", vf)
+        if af:
+            cmd.add("-af", af)
+
+        if task == "extract_audio":
+            return cmd.add("-vn", "-c:a", "mp3", "-b:a", "192k").overwrite().add(output).build()
+        if task == "frames":
+            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"}:
+            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()
+
+    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)
+        return output
+
+    def _export(self, source: Path, job_id: str, output_name: str) -> Path:
+        target = self.settings.exports_dir / f"{job_id}_{safe_filename(output_name)}"
+        shutil.copy2(source, target)
+        return target
+
+    def _run(self, command: list[str]) -> None:
+        result = self.runner.run(command)
+        if result.stderr:
+            self._logs.append(result.stderr[-4000:])
+
+    def _record_command(self, command: list[str]) -> None:
+        self._commands.append(command)
+
+    def _result(self, output: Path | None, metrics: dict[str, Any]) -> TaskResult:
+        return TaskResult(output_path=output, commands=list(self._commands), metrics=metrics, logs=list(self._logs))
+
+
+def supported_toolkit_tasks() -> list[str]:
+    return sorted(TOOLKIT_TASKS)
+
+
+def _source_type(url: str) -> str:
+    lowered = url.lower()
+    if "youtube.com" in lowered or "youtu.be" in lowered:
+        return "youtube"
+    if "drive.google.com" in lowered:
+        return "google_drive"
+    if "s3" in lowered or "amazonaws.com" in lowered:
+        return "s3"
+    return "direct_url"
+
+
+def _highlight_windows(duration: float) -> list[dict[str, Any]]:
+    if duration <= 0:
+        return [{"start": 0, "end": 8, "reason": "default opener"}]
+    windows = [{"start": 0, "end": min(duration, 8), "reason": "opening hook"}]
+    if duration > 18:
+        middle = max(0.0, duration * 0.42)
+        windows.append({"start": round(middle, 2), "end": round(min(duration, middle + 10), 2), "reason": "midpoint payoff"})
+    if duration > 35:
+        end = max(0.0, duration - 12)
+        windows.append({"start": round(end, 2), "end": round(duration, 2), "reason": "closing CTA"})
+    return windows
+
+
+def _viral_score(duration: float, has_words: bool, width: int | None, height: int | None) -> int:
+    score = 48
+    if 7 <= duration <= 60:
+        score += 20
+    elif duration <= 180:
+        score += 8
+    if width and height and height >= width:
+        score += 14
+    if has_words:
+        score += 10
+    return max(1, min(100, score))
+
+
+def _hook_quality(transcript: str) -> dict[str, Any]:
+    opener = " ".join(transcript.split()[:18])
+    signals = sum(1 for token in ("how", "why", "secret", "mistake", "stop", "watch", "you") if token in opener.lower())
+    return {"score": min(100, 45 + signals * 12), "opening_text": opener}
+
+
+def _retention_estimate(duration: float, viral_score: int) -> dict[str, Any]:
+    first_3s = min(96, 55 + viral_score * 0.35)
+    completion = max(18, min(88, first_3s - math.log(max(duration, 1), 1.8)))
+    return {"first_3_seconds_percent": round(first_3s, 1), "completion_percent": round(completion, 1)}
+
+
+def _engagement_prediction(score: int) -> str:
+    if score >= 80:
+        return "high"
+    if score >= 62:
+        return "medium"
+    return "needs_work"
+
+
+def _persona(text: str) -> str:
+    lowered = text.lower()
+    if any(word in lowered for word in ("founder", "startup", "product", "launch")):
+        return "builders and product-led founders"
+    if any(word in lowered for word in ("money", "sales", "growth", "marketing")):
+        return "growth-minded operators"
+    if any(word in lowered for word in ("learn", "tutorial", "how")):
+        return "learners seeking practical instruction"
+    return "general short-form viewers"
+
+
+def _platform_recommendations(duration: float, width: int | None, height: int | None, platform: str | None) -> list[dict[str, Any]]:
+    vertical = bool(width and height and height >= width)
+    candidates = ["tiktok", "instagram_reels", "youtube_shorts"] if vertical else ["youtube_1080p", "linkedin_video"]
+    if platform and platform not in candidates:
+        candidates.insert(0, platform)
+    return [{"platform": item, "fit": "strong" if duration <= 90 else "medium"} for item in candidates]
+
+
+def _pacing_label(wpm: float | None) -> str:
+    if not wpm:
+        return "unknown"
+    if wpm < 125:
+        return "slow"
+    if wpm > 185:
+        return "fast"
+    return "clear"
+
+
+def _title_from_text(text: str, platform: str | None) -> str:
+    words = [word.strip(".,:;!?") for word in text.split() if word.strip(".,:;!?")]
+    title = " ".join(words[:9]) or "Untitled Video"
+    suffix = " #Shorts" if platform in {"youtube_shorts", "tiktok", "instagram_reels"} else ""
+    return f"{title.title()}{suffix}"
+
+
+def _description(text: str, tags: list[str]) -> str:
+    summary = " ".join(text.split()[:42])
+    return f"{summary}\n\n{' '.join(tags)}".strip()
+
+
+def _hashtags(text: str, platform: str | None) -> list[str]:
+    base = ["#video", "#content"]
+    if platform:
+        base.append(f"#{platform.replace('_', '')}")
+    for keyword in _keywords(text)[:5]:
+        tag = "#" + "".join(ch for ch in keyword.title() if ch.isalnum())
+        if tag not in base:
+            base.append(tag)
+    return base[:8]
+
+
+def _keywords(text: str) -> list[str]:
+    stop = {"the", "and", "for", "with", "that", "this", "your", "you", "are", "from", "into", "video"}
+    words = [word.strip(".,:;!?").lower() for word in text.split()]
+    unique: list[str] = []
+    for word in words:
+        if len(word) < 4 or word in stop or word in unique:
+            continue
+        unique.append(word)
+    return unique[:12]
+
+
+def _chapters(text: str) -> list[dict[str, Any]]:
+    sentences = [part.strip() for part in text.replace("?", ".").replace("!", ".").split(".") if part.strip()]
+    return [{"time": f"0:{index * 15:02d}", "title": sentence[:60]} for index, sentence in enumerate(sentences[:6])]
+
+
+def _schedule(platform: str | None) -> dict[str, str]:
+    if platform in {"linkedin_video", "youtube_1080p"}:
+        return {"day": "Tuesday", "time": "09:00 local"}
+    return {"day": "Thursday", "time": "18:00 local"}
+
+
+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":
+        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 == "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":
+        return f"fps={float(params.get('fps', 1))}"
+    if task == "overlay_text":
+        return _drawtext_filter(str(params.get("text") or "Text"), "bold")
+    if task == "blur_background":
+        return "gblur=sigma=18"
+    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))))
+        return f"atempo={factor}"
+    if task == "reverse":
+        return "areverse"
+    if task == "noise_reduction":
+        return "afftdn=nf=-25"
+    return ""
+
+
+def _drawtext_filter(text: str, template: str) -> str:
+    escaped = text.replace("\\", "\\\\").replace(":", r"\:").replace("'", r"\'")
+    color = "yellow" if template == "bold" else "white"
+    return (
+        "drawtext="
+        f"text='{escaped}':fontcolor={color}:fontsize=58:"
+        "box=1:boxcolor=black@0.55:boxborderw=24:"
+        "x=(w-text_w)/2:y=h-(text_h*3)"
+    )
+
+
+def _default_output_name(task: str) -> str:
+    if task == "extract_audio":
+        return "audio.mp3"
+    if task == "gif":
+        return "clip.gif"
+    if task == "thumbnail":
+        return "thumbnail.jpg"
+    return f"{task}.mp4"

renderer/scenes/timeline.py

@@ -19,6 +19,7 @@ class Timeline:
             scenes=scenes,
             template=payload.get("template", "tiktok_classic"),
             preset=payload.get("preset"),
+            creative_style=payload.get("creative_style"),
             platform=payload.get("platform"),
             output_name=payload.get("output_name", "render.mp4"),
             voiceover=payload.get("voiceover"),
@@ -34,6 +35,16 @@ class Timeline:
             auto_subtitles=payload.get("auto_subtitles", False),
             subtitle_language=payload.get("subtitle_language"),
             whisper_model_size=payload.get("whisper_model_size"),
+            preview=payload.get("preview", False),
+            audio_normalize=payload.get("audio_normalize", False),
+            watermark=payload.get("watermark"),
+            watermark_position=payload.get("watermark_position", "bottom-right"),
+            intro=payload.get("intro"),
+            outro=payload.get("outro"),
+            callback_url=payload.get("callback_url"),
+            export_target=payload.get("export_target"),
+            priority=payload.get("priority", 0),
+            scheduled_at=payload.get("scheduled_at"),
             normalize=payload.get("normalize", True),
             metadata=payload.get("metadata", {}),
         )

renderer/templates/__init__.py

@@ -1,15 +1,31 @@
 from renderer.templates.caption_templates import CaptionTemplate, get_template, list_templates
+from renderer.templates.creative import (
+    apply_creative_style,
+    creative_style_metadata,
+    get_creative_style,
+    list_creative_styles,
+    list_scene_effects,
+    scene_effect_filter,
+    scene_effect_metadata,
+)
 from renderer.templates.platforms import PlatformProfile, get_platform_profile, list_platform_profiles, platform_profile_metadata
 from renderer.templates.presets import apply_preset, list_presets
 
 __all__ = [
     "CaptionTemplate",
     "PlatformProfile",
+    "apply_creative_style",
     "apply_preset",
+    "creative_style_metadata",
+    "get_creative_style",
     "get_platform_profile",
     "get_template",
+    "list_creative_styles",
     "list_platform_profiles",
+    "list_scene_effects",
     "list_presets",
     "list_templates",
     "platform_profile_metadata",
+    "scene_effect_filter",
+    "scene_effect_metadata",
 ]

renderer/templates/caption_templates.py

@@ -35,6 +35,10 @@ TEMPLATES: dict[str, CaptionTemplate] = {
     "youtube_shorts": CaptionTemplate("youtube_shorts", "YouTube Shorts", 62, "&H00FFFFFF", "&H000000FF", effect="karaoke"),
     "podcast_style": CaptionTemplate("podcast_style", "Podcast Style", 48, "&H00F5F5F5", "&H0099CCFF", margin_v=120),
     "news_style": CaptionTemplate("news_style", "News Style", 46, "&H00FFFFFF", "&H0000FFFF", alignment=2, margin_v=100),
+    "neon_pop": CaptionTemplate("neon_pop", "Neon Pop", 76, "&H00FFFFFF", "&H0000E5FF", outline_color="&H00FF2BD6", effect="karaoke"),
+    "product_demo": CaptionTemplate("product_demo", "Product Demo", 54, "&H00FFFFFF", "&H00C7F9CC", margin_v=210, effect="zoom"),
+    "cinematic_gold": CaptionTemplate("cinematic_gold", "Cinematic Gold", 50, "&H00F4E7B2", "&H00FFFFFF", outline_color="&H00111111", margin_v=180),
+    "creator_clean": CaptionTemplate("creator_clean", "Creator Clean", 58, "&H00FFFFFF", "&H00BCE7FD", margin_v=220, effect="bounce"),
 }
 
 

renderer/templates/creative.py

@@ -0,0 +1,276 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(frozen=True)
+class CreativeStyle:
+    key: str
+    label: str
+    description: str
+    platform: str
+    template: str
+    scene_duration: float
+    transition_sequence: tuple[str, ...]
+    scene_effect_sequence: tuple[str, ...]
+    render_defaults: dict[str, Any] = field(default_factory=dict)
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    def metadata_payload(self) -> dict[str, Any]:
+        return {
+            "key": self.key,
+            "label": self.label,
+            "description": self.description,
+            "platform": self.platform,
+            "template": self.template,
+            "scene_duration": self.scene_duration,
+            "transition_sequence": list(self.transition_sequence),
+            "scene_effect_sequence": list(self.scene_effect_sequence),
+            "render_defaults": deepcopy(self.render_defaults),
+            "metadata": deepcopy(self.metadata),
+        }
+
+
+SCENE_EFFECTS: dict[str, dict[str, str]] = {
+    "none": {"label": "None", "filter": ""},
+    "sharp_pop": {
+        "label": "Sharp Pop",
+        "filter": "eq=contrast=1.08:saturation=1.20:brightness=0.01,unsharp=5:5:0.8:3:3:0.4",
+    },
+    "clean_beauty": {
+        "label": "Clean Beauty",
+        "filter": "hqdn3d=1.5:1.5:6:6,eq=saturation=1.08:contrast=1.03",
+    },
+    "warm_glow": {
+        "label": "Warm Glow",
+        "filter": "eq=contrast=1.04:saturation=1.18:gamma_r=1.04:gamma_b=0.96,gblur=sigma=0.25",
+    },
+    "cinematic": {
+        "label": "Cinematic",
+        "filter": "eq=contrast=1.14:saturation=0.95:brightness=-0.015,vignette=PI/6",
+    },
+    "dreamy": {
+        "label": "Dreamy",
+        "filter": "gblur=sigma=0.6,eq=contrast=1.04:saturation=1.18:brightness=0.02",
+    },
+    "flash_pop": {
+        "label": "Flash Pop",
+        "filter": "eq=contrast=1.16:saturation=1.25:brightness=0.035",
+    },
+    "grain": {
+        "label": "Fine Grain",
+        "filter": "noise=alls=8:allf=t+u,eq=contrast=1.07:saturation=1.02",
+    },
+    "motion_blur": {
+        "label": "Motion Blur",
+        "filter": "tmix=frames=3:weights='1 2 1',eq=contrast=1.05:saturation=1.08",
+    },
+    "noir": {
+        "label": "Noir",
+        "filter": "hue=s=0,eq=contrast=1.18:brightness=-0.02",
+    },
+}
+
+
+CREATIVE_STYLES: dict[str, CreativeStyle] = {
+    "viral_shorts": CreativeStyle(
+        key="viral_shorts",
+        label="Viral Shorts",
+        description="Fast vertical pacing, punchy captions, bright contrast, and whip-style movement.",
+        platform="tiktok",
+        template="tiktok_zoom",
+        scene_duration=2.4,
+        transition_sequence=("whip", "flash", "zoom", "glitch"),
+        scene_effect_sequence=("sharp_pop", "flash_pop", "clean_beauty"),
+        render_defaults={
+            "subtitle_format": "ass",
+            "auto_subtitles": True,
+            "audio_normalize": True,
+            "music_volume": 0.24,
+            "music_fade_in": 0.25,
+            "music_fade_out": 0.8,
+            "music_ducking": True,
+            "normalize": True,
+        },
+        metadata={"energy": "high", "best_for": "hooks, offers, memes, short promos"},
+    ),
+    "product_demo": CreativeStyle(
+        key="product_demo",
+        label="Product Demo",
+        description="Clean cuts, readable captions, and polished color for launches and tutorials.",
+        platform="instagram_reels",
+        template="modern_minimal",
+        scene_duration=3.2,
+        transition_sequence=("slide", "wipe_left", "push", "dissolve"),
+        scene_effect_sequence=("clean_beauty", "sharp_pop"),
+        render_defaults={
+            "subtitle_format": "ass",
+            "auto_subtitles": True,
+            "audio_normalize": True,
+            "music_volume": 0.18,
+            "music_fade_in": 0.3,
+            "music_fade_out": 0.7,
+            "music_ducking": True,
+            "normalize": True,
+        },
+        metadata={"energy": "medium", "best_for": "software demos, ecommerce, tutorials"},
+    ),
+    "story_vlog": CreativeStyle(
+        key="story_vlog",
+        label="Story Vlog",
+        description="Warm color, softer movement, and natural pacing for personality-led edits.",
+        platform="instagram_reels",
+        template="tiktok_classic",
+        scene_duration=3.8,
+        transition_sequence=("fade", "smooth_right", "dissolve"),
+        scene_effect_sequence=("warm_glow", "dreamy", "clean_beauty"),
+        render_defaults={
+            "subtitle_format": "ass",
+            "auto_subtitles": True,
+            "audio_normalize": True,
+            "music_volume": 0.22,
+            "music_fade_in": 0.5,
+            "music_fade_out": 1.0,
+            "music_ducking": True,
+            "normalize": True,
+        },
+        metadata={"energy": "medium", "best_for": "founder updates, day-in-life edits, testimonials"},
+    ),
+    "podcast_clip": CreativeStyle(
+        key="podcast_clip",
+        label="Podcast Clip",
+        description="Square-safe framing, calmer captions, and narration-first audio treatment.",
+        platform="instagram_feed_square",
+        template="podcast_style",
+        scene_duration=5.0,
+        transition_sequence=("fade", "dissolve"),
+        scene_effect_sequence=("clean_beauty", "sharp_pop"),
+        render_defaults={
+            "subtitle_format": "ass",
+            "auto_subtitles": True,
+            "audio_normalize": True,
+            "music_volume": 0.12,
+            "music_fade_in": 0.6,
+            "music_fade_out": 1.2,
+            "music_ducking": True,
+            "normalize": True,
+        },
+        metadata={"energy": "low", "best_for": "interviews, audiograms, education"},
+    ),
+    "cinematic_story": CreativeStyle(
+        key="cinematic_story",
+        label="Cinematic Story",
+        description="Deeper contrast, film grain, and slower transitions for mini-documentary edits.",
+        platform="youtube_shorts",
+        template="modern_minimal",
+        scene_duration=4.2,
+        transition_sequence=("dissolve", "fadeblack", "smooth_left"),
+        scene_effect_sequence=("cinematic", "grain"),
+        render_defaults={
+            "subtitle_format": "ass",
+            "auto_subtitles": True,
+            "audio_normalize": True,
+            "music_volume": 0.26,
+            "music_fade_in": 0.8,
+            "music_fade_out": 1.4,
+            "music_ducking": True,
+            "normalize": True,
+        },
+        metadata={"energy": "low", "best_for": "brand films, travel, documentary shorts"},
+    ),
+    "news_explainer": CreativeStyle(
+        key="news_explainer",
+        label="News Explainer",
+        description="Readable lower-third style captions with stable landscape or vertical exports.",
+        platform="youtube_1080p",
+        template="news_style",
+        scene_duration=4.0,
+        transition_sequence=("wipe_left", "slide", "fade"),
+        scene_effect_sequence=("sharp_pop", "clean_beauty"),
+        render_defaults={
+            "subtitle_format": "ass",
+            "auto_subtitles": False,
+            "audio_normalize": True,
+            "music_volume": 0.1,
+            "music_fade_in": 0.5,
+            "music_fade_out": 1.0,
+            "music_ducking": True,
+            "normalize": True,
+        },
+        metadata={"energy": "medium", "best_for": "explainers, news, thought leadership"},
+    ),
+}
+
+
+def apply_creative_style(payload: dict[str, Any]) -> dict[str, Any]:
+    style_key = payload.get("creative_style") or payload.get("metadata", {}).get("creative_style")
+    if not style_key:
+        return payload
+
+    style = get_creative_style(str(style_key))
+    output = deepcopy(payload)
+    output["creative_style"] = style.key
+    _set_default(output, "platform", style.platform)
+    _set_default(output, "template", style.template)
+    for key, value in style.render_defaults.items():
+        _set_default(output, key, deepcopy(value))
+
+    metadata = deepcopy(style.metadata)
+    metadata.update(output.get("metadata", {}))
+    metadata["creative_style"] = style.key
+    metadata["creative_style_label"] = style.label
+    output["metadata"] = metadata
+
+    scenes = output.get("scenes")
+    if isinstance(scenes, list):
+        output["scenes"] = [_style_scene(scene, style, index) for index, scene in enumerate(scenes)]
+    return output
+
+
+def get_creative_style(key: str | None) -> CreativeStyle:
+    if not key:
+        return CREATIVE_STYLES["viral_shorts"]
+    return CREATIVE_STYLES.get(key, CREATIVE_STYLES["viral_shorts"])
+
+
+def list_creative_styles() -> list[str]:
+    return list(CREATIVE_STYLES.keys())
+
+
+def creative_style_metadata() -> dict[str, dict[str, Any]]:
+    return {key: style.metadata_payload() for key, style in CREATIVE_STYLES.items()}
+
+
+def list_scene_effects() -> list[str]:
+    return list(SCENE_EFFECTS.keys())
+
+
+def scene_effect_metadata() -> dict[str, dict[str, str]]:
+    return {key: {"label": value["label"]} for key, value in SCENE_EFFECTS.items()}
+
+
+def scene_effect_filter(key: str | None) -> str:
+    if not key:
+        return ""
+    return SCENE_EFFECTS.get(key, SCENE_EFFECTS["none"])["filter"]
+
+
+def _set_default(payload: dict[str, Any], key: str, value: Any) -> None:
+    if key not in payload or payload[key] in (None, ""):
+        payload[key] = value
+
+
+def _style_scene(scene: Any, style: CreativeStyle, index: int) -> Any:
+    if not isinstance(scene, dict):
+        return scene
+    styled = deepcopy(scene)
+    transition = styled.get("transition")
+    if transition in (None, "", "fade"):
+        styled["transition"] = style.transition_sequence[index % len(style.transition_sequence)]
+    if styled.get("effect") in (None, ""):
+        styled["effect"] = style.scene_effect_sequence[index % len(style.scene_effect_sequence)]
+    _set_default(styled, "background", "blur")
+    _set_default(styled, "layout", "fill")
+    return styled

renderer/templates/platforms.py

@@ -151,6 +151,46 @@ PLATFORM_PROFILES: dict[str, PlatformProfile] = {
         recommended_duration_seconds=(5, 60),
         safe_zones={"top_px": 80, "bottom_px": 140, "left_px": 80, "right_px": 80},
     ),
+    "snapchat_spotlight": PlatformProfile(
+        key="snapchat_spotlight",
+        label="Snapchat Spotlight",
+        width=1080,
+        height=1920,
+        fps=30,
+        maxrate="8M",
+        bufsize="16M",
+        max_duration_seconds=60,
+        recommended_duration_seconds=(5, 30),
+        safe_zones=COMMON_VERTICAL_SAFE_ZONES,
+        notes=("Vertical, fast-paced edits perform best in Spotlight.",),
+    ),
+    "pinterest_idea_pins": PlatformProfile(
+        key="pinterest_idea_pins",
+        label="Pinterest Idea Pins",
+        width=1080,
+        height=1920,
+        fps=30,
+        maxrate="8M",
+        bufsize="16M",
+        max_duration_seconds=300,
+        recommended_duration_seconds=(6, 45),
+        safe_zones={"top_px": 160, "bottom_px": 240, "left_px": 80, "right_px": 80},
+        notes=("Use clear text overlays and evergreen discovery keywords.",),
+    ),
+    "linkedin_video": PlatformProfile(
+        key="linkedin_video",
+        label="LinkedIn video",
+        width=1920,
+        height=1080,
+        fps=30,
+        audio_bitrate="192k",
+        maxrate="10M",
+        bufsize="20M",
+        max_duration_seconds=600,
+        recommended_duration_seconds=(30, 180),
+        safe_zones={"top_px": 80, "bottom_px": 100, "left_px": 80, "right_px": 80},
+        notes=("Landscape explainers and square clips both work; captions are strongly recommended.",),
+    ),
 }
 
 

renderer/templates/presets.py

@@ -6,6 +6,7 @@ from typing import Any
 
 PRESETS: dict[str, dict[str, Any]] = {
     "tiktok_9_16_fast": {
+        "creative_style": "viral_shorts",
         "platform": "tiktok",
         "template": "tiktok_classic",
         "subtitle_format": "ass",
@@ -14,6 +15,7 @@ PRESETS: dict[str, dict[str, Any]] = {
         "normalize": True,
     },
     "youtube_shorts_hd": {
+        "creative_style": "viral_shorts",
         "platform": "youtube_shorts",
         "template": "youtube_shorts",
         "subtitle_format": "ass",
@@ -21,6 +23,7 @@ PRESETS: dict[str, dict[str, Any]] = {
         "normalize": True,
     },
     "podcast_square": {
+        "creative_style": "podcast_clip",
         "platform": "instagram_feed_square",
         "template": "podcast_style",
         "subtitle_format": "ass",
@@ -29,6 +32,7 @@ PRESETS: dict[str, dict[str, Any]] = {
         "metadata": {"target_aspect": "1:1"},
     },
     "reels_with_subtitles": {
+        "creative_style": "story_vlog",
         "platform": "instagram_reels",
         "template": "modern_minimal",
         "subtitle_format": "ass",
@@ -36,6 +40,7 @@ PRESETS: dict[str, dict[str, Any]] = {
         "normalize": True,
     },
     "draft_preview": {
+        "creative_style": "product_demo",
         "platform": "tiktok",
         "template": "modern_minimal",
         "subtitle_format": "ass",
@@ -43,6 +48,7 @@ PRESETS: dict[str, dict[str, Any]] = {
         "normalize": True,
     },
     "tiktok_music_ducked": {
+        "creative_style": "viral_shorts",
         "platform": "tiktok",
         "template": "tiktok_classic",
         "subtitle_format": "ass",
@@ -56,6 +62,7 @@ PRESETS: dict[str, dict[str, Any]] = {
         "normalize": True,
     },
     "instagram_reels_music": {
+        "creative_style": "story_vlog",
         "platform": "instagram_reels",
         "template": "modern_minimal",
         "subtitle_format": "ass",
@@ -69,6 +76,7 @@ PRESETS: dict[str, dict[str, Any]] = {
         "normalize": True,
     },
     "youtube_landscape_1080p": {
+        "creative_style": "news_explainer",
         "platform": "youtube_1080p",
         "template": "news_style",
         "subtitle_format": "ass",
@@ -76,6 +84,48 @@ PRESETS: dict[str, dict[str, Any]] = {
         "audio_normalize": True,
         "normalize": True,
     },
+    "capcut_viral_auto": {
+        "creative_style": "viral_shorts",
+        "platform": "tiktok",
+        "template": "neon_pop",
+        "subtitle_format": "ass",
+        "auto_subtitles": True,
+        "audio_normalize": True,
+        "music_volume": 0.24,
+        "music_fade_in": 0.2,
+        "music_fade_out": 0.8,
+        "music_loop": True,
+        "music_ducking": True,
+        "normalize": True,
+    },
+    "capcut_product_launch": {
+        "creative_style": "product_demo",
+        "platform": "instagram_reels",
+        "template": "product_demo",
+        "subtitle_format": "ass",
+        "auto_subtitles": True,
+        "audio_normalize": True,
+        "music_volume": 0.18,
+        "music_fade_in": 0.3,
+        "music_fade_out": 0.7,
+        "music_loop": True,
+        "music_ducking": True,
+        "normalize": True,
+    },
+    "capcut_cinematic_story": {
+        "creative_style": "cinematic_story",
+        "platform": "youtube_shorts",
+        "template": "cinematic_gold",
+        "subtitle_format": "ass",
+        "auto_subtitles": True,
+        "audio_normalize": True,
+        "music_volume": 0.26,
+        "music_fade_in": 0.8,
+        "music_fade_out": 1.4,
+        "music_loop": True,
+        "music_ducking": True,
+        "normalize": True,
+    },
 }
 
 

renderer/transitions/builder.py

@@ -12,11 +12,23 @@ class TransitionBuilder:
         "blur": "fade",
         "whip": "smoothleft",
         "dissolve": "dissolve",
+        "flash": "fadewhite",
+        "glitch": "hlslice",
+        "wipe": "wipeleft",
+        "wipe_left": "wipeleft",
+        "wipe_right": "wiperight",
+        "smooth_left": "smoothleft",
+        "smooth_right": "smoothright",
+        "fadeblack": "fadeblack",
+        "pixel": "pixelize",
     }
 
     def map_transition(self, name: str) -> str:
         return self.TRANSITIONS.get(name, "fade")
 
+    def list_transitions(self) -> list[str]:
+        return list(self.TRANSITIONS.keys())
+
     def xfade_chain(self, stream_count: int, durations: list[float], transitions: list[str], transition_duration: float = 0.45) -> tuple[str, str]:
         if stream_count <= 1:
             return "", "[0:v]"