Upload 9 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+asset/TR[[:space:]]Impact.TTF filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,41 @@
+# TrendClip Video Composer Server
+# FastAPI server for scene selection and video composition
+
+FROM python:3.13-slim
+
+# Set working directory
+WORKDIR /app/composer
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements
+COPY requirements_server.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements_server.txt
+
+# Copy application files
+COPY server.py .
+COPY composer_v2.py .
+
+# Copy assets (fonts, etc.)
+COPY asset/ asset/
+
+# Create necessary directories
+RUN mkdir -p selected candidates renders upload_candidates
+
+# Expose port
+EXPOSE 7860
+
+# Environment variables
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONIOENCODING=utf-8
+
+# Run server with uvicorn
+CMD ["uvicorn", "server:app", "--host", "0.0.0.0", "--port", "7860"]

asset/TR Impact.TTF

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fd911ac4105fcd6f8d3cdc71ccd1eea6d456c228e5be58a40900a6676c21cc88
+size 119088

compose_scenes.py

@@ -0,0 +1,923 @@
+"""
+Scene Composer — Hardcoded Edit Engine
+Follows the exact structure and logic from sunset_reel_edit_plan.md
+
+Global architecture:
+  - Resolution: 1080x1920 (9:16 vertical)
+  - FPS: 30
+  - Colour: global warm grade (+8 temp, -5 tint), vignette 35%
+  - Typography: Montserrat Bold (title 100px), medium weight (body 64px)
+  - Motion language: Ken Burns default (1.0→1.06), text slide-up 14px @ 18f
+  - 7 scenes + end card
+"""
+
+import os
+import json
+import math
+from pathlib import Path
+from PIL import Image, ImageDraw, ImageFont, ImageFilter, ImageEnhance
+
+
+# ---------------------------------------------------------------------------
+# GLOBAL CONSTANTS — from edit plan
+# ---------------------------------------------------------------------------
+
+RESOLUTION       = (1080, 1920)
+FPS              = 30
+VIGNETTE_OPACITY = 0.35          # 35% vignette on all scenes
+
+# Global warm grade values (applied as multipliers/shifts in _apply_global_grade)
+GLOBAL_TEMP_SHIFT   = +8         # warm shift (boosts reds/yellows)
+GLOBAL_TINT_SHIFT   = -5         # tint (slight green pull-back)
+
+# Typography — sizes map to Montserrat Bold TTF
+FONT_SIZE_TITLE     = 100        # Title / hook (SF Pro Display equiv)
+FONT_SIZE_BODY      = 64         # Body tip text
+FONT_SIZE_ACCENT    = 140        # Number accent (Bebas equiv — still Montserrat here)
+FONT_SIZE_CAPTION   = 48         # Hashtag / caption
+
+TEXT_COLOR          = (255, 255, 255, 255)   # White
+TEXT_SHADOW         = (0, 0, 0, 80)          # 10% drop shadow
+STROKE_COLOR        = (0, 0, 0, 200)
+STROKE_WIDTH        = 9
+
+
+# ---------------------------------------------------------------------------
+# SCENE CONFIG — hardcoded from edit plan, one dict per scene
+# ---------------------------------------------------------------------------
+
+SCENE_CONFIG = [
+    # ------------------------------------------------------------------
+    # Scene 00 — Chase the Golden Hour
+    # Motion: Ken Burns push-up, scale 1.0→1.06
+    # Text:   Title lower-third, slides up at f8, holds 2.2s, fades f96
+    # Grade:  Boost oranges/reds +15, reduce highlights -20
+    # Trans:  Cross dissolve 12f
+    # ------------------------------------------------------------------
+    {
+        "idx":           0,
+        "label":         "Chase The Golden Hour",
+        "duration_s":    3.5,
+        "motion": {
+            "type":          "ken_burns",
+            "direction":     "up",
+            "scale_start":   1.0,
+            "scale_end":     1.06,
+        },
+        "text": {
+            "type":          "lower_third",     # positioned lower third
+            "entry":         "slide_up",
+            "entry_frame":   8,
+            "hold_s":        2.2,
+            "fade_frame":    96,
+            "font_size":     FONT_SIZE_TITLE,
+            "align":         "left",
+        },
+        "grade": {
+            "boost_reds":    +15,               # orange/red channel boost
+            "highlights":    -20,               # pull back highlights
+            "temp":          GLOBAL_TEMP_SHIFT,
+            "tint":          GLOBAL_TINT_SHIFT,
+        },
+        "transition_out": {
+            "type":          "cross_dissolve",
+            "frames":        12,
+        },
+    },
+
+    # ------------------------------------------------------------------
+    # Scene 01 — Scout Your Spot
+    # Motion: Horizontal slow pan right, +30px offset over 3s
+    # Text:   Typewriter reveal, 20 chars/s, starts f12
+    # Grade:  Crush blacks, push purples into shadows
+    # Trans:  Hard cut (intentional rhythm break)
+    # ------------------------------------------------------------------
+    {
+        "idx":           1,
+        "label":         "Scout Your Spot First",
+        "duration_s":    3.0,
+        "motion": {
+            "type":          "pan",
+            "direction":     "right",
+            "offset_px":     30,               # +30px rightward drift
+        },
+        "text": {
+            "type":          "typewriter",
+            "chars_per_sec": 20,
+            "entry_frame":   12,
+            "font_size":     FONT_SIZE_BODY,
+            "align":         "left",
+        },
+        "grade": {
+            "crush_blacks":  True,             # deeper black crush
+            "push_purples":  True,             # purple shadow tint
+            "temp":          GLOBAL_TEMP_SHIFT,
+            "tint":          GLOBAL_TINT_SHIFT,
+        },
+        "transition_out": {
+            "type":          "hard_cut",
+            "frames":        1,
+        },
+    },
+
+    # ------------------------------------------------------------------
+    # Scene 02 — Balance the Bright Sky
+    # Motion: Static + horizon split parallax (-8px sky drift)
+    # Text:   Two-line stagger, line1 f6, line2 f14, hold 2.5s
+    # Grade:  Dual-tone — sky cooler +4, ground warmer +12
+    # Trans:  Zoom-out wipe 16f
+    # ------------------------------------------------------------------
+    {
+        "idx":           2,
+        "label":         "Balance The Bright Sky",
+        "duration_s":    3.5,
+        "motion": {
+            "type":           "horizon_parallax",
+            "sky_offset_px":  -8,              # sky shifts left subtly
+            "horizon_ratio":  0.42,            # horizon at 42% from top
+        },
+        "text": {
+            "type":           "stagger_two_line",
+            "line1_frame":    6,
+            "line2_frame":    14,
+            "hold_s":         2.5,
+            "font_size":      FONT_SIZE_BODY,
+            "align":          "left",
+        },
+        "grade": {
+            "sky_temp":       +4,              # sky cooler
+            "ground_temp":    +12,             # ground warmer
+            "temp":           GLOBAL_TEMP_SHIFT,
+            "tint":           GLOBAL_TINT_SHIFT,
+        },
+        "transition_out": {
+            "type":           "zoom_out_wipe",
+            "frames":         16,
+        },
+    },
+
+    # ------------------------------------------------------------------
+    # Scene 03 — Rule of Thirds Grid  ⚠️ AE Required
+    # Motion: Static lock — all motion is overlay animation
+    # Text:   Grid draw-on f0-f12 → annotations pop f14-f20 → tip f24
+    # Grade:  Preserve existing grid colour (white ~40% opacity)
+    # Trans:  Cross dissolve 10f
+    # Note:   Image already has baked grid — mask it, animate draw-on
+    # ------------------------------------------------------------------
+    {
+        "idx":           3,
+        "label":         "Rule Of Thirds Grid",
+        "duration_s":    4.0,
+        "motion": {
+            "type":           "static",
+        },
+        "text": {
+            "type":           "grid_sequence",
+            "grid_draw_frames": (0, 12),       # draw-on window
+            "annotations": [
+                # label, pop_frame, (x_ratio, y_ratio)
+                ("Silhouettes",       14, (0.68, 0.30)),
+                ("Horizon Placement", 15, (0.12, 0.64)),
+                ("Leading Lines",     16, (0.60, 0.75)),
+                ("S-Curve",           17, (0.65, 0.82)),
+                ("Reflections",       18, (0.12, 0.82)),
+            ],
+            "annotation_scale_punch": (0.8, 1.0),
+            "tip_frame":      24,
+            "font_size":      FONT_SIZE_BODY,
+        },
+        "grade": {
+            "grid_opacity":   0.40,            # white grid lines ~40%
+            "temp":           GLOBAL_TEMP_SHIFT,
+            "tint":           GLOBAL_TINT_SHIFT,
+        },
+        "transition_out": {
+            "type":           "cross_dissolve",
+            "frames":         10,
+        },
+        "ae_required":    True,
+        "ae_note":        "Grid draw-on via trim path. Mask baked grid at comp start.",
+    },
+
+    # ------------------------------------------------------------------
+    # Scene 04 — Layer the Foreground Depth  ⚠️ AE Required
+    # Motion: 3-layer parallax — FG 18px, MG 6px, BG static
+    # Text:   Right-edge entry at f10, hold 2.8s
+    # Grade:  Saturate magentas/pinks in FG, preserve sunburst
+    # Trans:  Ink-bleed / dissolve 14f
+    # ------------------------------------------------------------------
+    {
+        "idx":           4,
+        "label":         "Layer The Foreground Depth",
+        "duration_s":    4.0,
+        "motion": {
+            "type":           "parallax_3layer",
+            "layers": {
+                "fg": {"drift_px": 18, "direction": "up"},   # wildflowers
+                "mg": {"drift_px":  6, "direction": "up"},   # pine trees
+                "bg": {"drift_px":  0, "direction": None},   # sky / static
+            },
+        },
+        "text": {
+            "type":           "right_slide",
+            "entry_frame":    10,
+            "hold_s":         2.8,
+            "font_size":      FONT_SIZE_BODY,
+            "align":          "right",
+        },
+        "grade": {
+            "saturate_magentas": +20,          # boost pinks/magentas in FG
+            "preserve_highlights": True,       # don't clip sunburst
+            "temp":           GLOBAL_TEMP_SHIFT,
+            "tint":           GLOBAL_TINT_SHIFT,
+        },
+        "transition_out": {
+            "type":           "dissolve",
+            "frames":         14,
+        },
+        "ae_required":    True,
+        "ae_note":        "Roto Brush / manual mask for 3-layer extraction.",
+    },
+
+    # ------------------------------------------------------------------
+    # Scene 05 — Add a Silhouette Subject
+    # Motion: Push-in toward subjects, scale 1.0→1.04
+    # Text:   Centered fade-up at f12, single line, minimal
+    # Grade:  Deep amber, crush blacks to pure silhouette
+    # Trans:  Fade to black 20f
+    # ------------------------------------------------------------------
+    {
+        "idx":           5,
+        "label":         "Add A Silhouette Subject",
+        "duration_s":    3.5,
+        "motion": {
+            "type":           "ken_burns",
+            "direction":      "in",            # push-in (no directional drift)
+            "scale_start":    1.0,
+            "scale_end":      1.04,
+        },
+        "text": {
+            "type":           "center_fade",
+            "entry_frame":    12,
+            "font_size":      FONT_SIZE_BODY,
+            "align":          "center",
+            "single_line":    True,            # minimal — image speaks
+        },
+        "grade": {
+            "deep_amber":     True,            # amber tone throughout
+            "crush_blacks":   True,            # subjects to pure silhouette
+            "protect_reflection": True,        # water reflection stays bright
+            "temp":           GLOBAL_TEMP_SHIFT,
+            "tint":           GLOBAL_TINT_SHIFT,
+        },
+        "transition_out": {
+            "type":           "fade_to_black",
+            "frames":         20,
+        },
+    },
+
+    # ------------------------------------------------------------------
+    # Scene 06 — Edit the Warmth Gently  ⚠️ AE Required (CTA anchor)
+    # Motion: Scroll-up pan, top→bottom of infographic over 3.5s
+    # Text:   Count-up per param (0.4s each) as it scrolls into frame
+    # Grade:  Match reel warm grade, don't over-process the infographic
+    # Trans:  Slide-left 16f to end card
+    # ------------------------------------------------------------------
+    {
+        "idx":           6,
+        "label":         "Edit The Warmth Gently",
+        "duration_s":    4.5,
+        "motion": {
+            "type":           "scroll_pan",
+            "direction":      "down",          # reveal top→bottom
+            "pan_duration_s": 3.5,
+        },
+        "text": {
+            "type":           "countup_params",
+            "countup_duration_s": 0.4,
+            "params": [
+                ("Exposure",    -39),
+                ("Highlights",  -30),
+                ("Shadows",     +59),
+                ("Contrast",    +7),
+                ("Brightness",  -28),
+                ("Saturation",  -11),
+                ("Vibrance",    +63),
+                ("Warmth",      +60),
+                ("Tint",        +29),
+            ],
+        },
+        "grade": {
+            "match_reel_grade": True,          # light warm pass only
+            "temp":            GLOBAL_TEMP_SHIFT,
+            "tint":            GLOBAL_TINT_SHIFT,
+        },
+        "transition_out": {
+            "type":            "slide_left",
+            "frames":          16,
+        },
+        "ae_required":    True,
+        "ae_note":        "Slider control expressions for count-up. linear(time, startT, endT, 0, targetValue).",
+    },
+]
+
+
+# ------------------------------------------------------------------
+# End card config
+# ------------------------------------------------------------------
+END_CARD_CONFIG = {
+    "duration_s":    2.0,
+    "background":    (10, 10, 10),             # near-black
+    "fade_in_frames": 12,
+    "lines": [
+        ("Stop guessing and start shooting", FONT_SIZE_TITLE),
+        ("Which of these do you already do?",  FONT_SIZE_BODY),
+        ("Drop a 🌅 if you're running out tonight!", FONT_SIZE_BODY),
+        ("Save this before you forget",         FONT_SIZE_CAPTION),
+    ],
+    "hashtags": [
+        "#SunsetPhotography", "#GoldenHour",
+        "#PhotographyTips", "#PhotoHack", "#ContentCreator",
+    ],
+}
+
+
+# ---------------------------------------------------------------------------
+# COMPOSER CLASS
+# ---------------------------------------------------------------------------
+
+class SceneComposer:
+
+    def __init__(
+        self,
+        manifest_path: str,
+        selected_dir: str,
+        output_dir: str = "output",
+        font_path: str = "../trendclip/assets/fonts/Montserrat-Bold.ttf",
+    ):
+        self.manifest_path = manifest_path
+        self.selected_dir  = selected_dir
+        self.output_dir    = output_dir
+        self.font_path     = font_path
+
+        Path(self.output_dir).mkdir(parents=True, exist_ok=True)
+
+        with open(manifest_path, "r") as f:
+            self.manifest = json.load(f)
+
+        print(f"[Composer] Loaded manifest  : {len(self.manifest.get('scenes', []))} scenes")
+        print(f"[Composer] Selected dir     : {selected_dir}")
+        print(f"[Composer] Output dir       : {output_dir}\n")
+
+    # ------------------------------------------------------------------
+    # Public entry point
+    # ------------------------------------------------------------------
+
+    def compose_all_scenes(self):
+        """Compose all 7 scenes + end card using hardcoded edit plan."""
+        print(f"[Composer] Processing {len(SCENE_CONFIG)} scenes + end card...\n")
+
+        for cfg in SCENE_CONFIG:
+            self._compose_scene(cfg)
+
+        self._compose_end_card()
+
+        print(f"\n[Composer] ✓ All scenes composed.")
+        print(f"[Composer] Output → {self.output_dir}/\n")
+
+    # ------------------------------------------------------------------
+    # Scene composition
+    # ------------------------------------------------------------------
+
+    def _compose_scene(self, cfg: dict):
+        idx   = cfg["idx"]
+        label = cfg["label"]
+
+        src = os.path.join(self.selected_dir, f"scene_{idx:02d}.jpg")
+        if not os.path.exists(src):
+            print(f"[Scene {idx}] ✗ Missing: {src}")
+            return
+
+        ae_flag = " ⚠️  AE_REQUIRED" if cfg.get("ae_required") else ""
+        print(f"[Scene {idx}] {label}{ae_flag}")
+        if cfg.get("ae_note"):
+            print(f"  AE note: {cfg['ae_note']}")
+
+        try:
+            img = self._load_and_resize(src)
+            img = self._apply_global_grade(img, cfg["grade"])
+            img = self._apply_scene_grade(img, cfg["grade"])
+            img = self._apply_motion_preview(img, cfg["motion"], cfg["duration_s"])
+            img = self._apply_vignette(img)
+            img = self._render_text(img, cfg)
+            img = self._apply_transition_overlay(img, cfg["transition_out"])
+
+            out = os.path.join(self.output_dir, f"scene_{idx:02d}_composed.jpg")
+            img.save(out, quality=95)
+            print(f"  ✓ Saved → {out}\n")
+
+        except Exception as e:
+            print(f"  ✗ Error: {e}\n")
+            raise
+
+    # ------------------------------------------------------------------
+    # Image helpers
+    # ------------------------------------------------------------------
+
+    def _load_and_resize(self, path: str) -> Image.Image:
+        img = Image.open(path).convert("RGB")
+        if img.size != RESOLUTION:
+            img = img.resize(RESOLUTION, Image.Resampling.LANCZOS)
+        return img
+
+    def _apply_global_grade(self, img: Image.Image, grade: dict) -> Image.Image:
+        """
+        Global warm grade applied to every scene:
+          +8 temperature  → boost reds and yellows, pull down blues
+          -5 tint         → slight pull toward magenta (pull green back)
+          Exposure normalise pass (mild)
+        """
+        r, g, b = img.split()
+
+        # Temperature: +8 → warm shift
+        # Boost R channel, slight boost G, pull B down
+        temp = grade.get("temp", GLOBAL_TEMP_SHIFT)
+        if temp != 0:
+            r = r.point(lambda p: min(255, p + int(temp * 1.2)))
+            g = g.point(lambda p: min(255, p + int(temp * 0.4)))
+            b = b.point(lambda p: max(0,   p - int(temp * 0.8)))
+
+        # Tint: -5 → pull back green slightly
+        tint = grade.get("tint", GLOBAL_TINT_SHIFT)
+        if tint != 0:
+            g = g.point(lambda p: max(0, min(255, p + int(tint * 0.6))))
+
+        img = Image.merge("RGB", (r, g, b))
+
+        # Mild exposure normalise — bring slightly flat images to ~0.5 mean
+        enhancer = ImageEnhance.Brightness(img)
+        img = enhancer.enhance(1.02)
+
+        return img
+
+    def _apply_scene_grade(self, img: Image.Image, grade: dict) -> Image.Image:
+        """Per-scene colour grade from edit plan."""
+        r, g, b = img.split()
+
+        # --- Scene 00: boost reds/oranges, reduce highlights
+        if grade.get("boost_reds"):
+            boost = grade["boost_reds"]
+            r = r.point(lambda p: min(255, p + boost))
+            g = g.point(lambda p: min(255, p + int(boost * 0.3)))
+        if grade.get("highlights") and grade["highlights"] < 0:
+            pull = abs(grade["highlights"])
+            # Pull back highlights — only affect bright pixels
+            r = r.point(lambda p: p - int((p / 255) ** 2 * pull))
+            g = g.point(lambda p: p - int((p / 255) ** 2 * pull))
+            b = b.point(lambda p: p - int((p / 255) ** 2 * pull))
+
+        # --- Scene 01 / 05: crush blacks
+        if grade.get("crush_blacks"):
+            r = r.point(lambda p: max(0, p - 15) if p < 60 else p)
+            g = g.point(lambda p: max(0, p - 15) if p < 60 else p)
+            b = b.point(lambda p: max(0, p - 15) if p < 60 else p)
+
+        # --- Scene 01: push purples into shadows
+        if grade.get("push_purples"):
+            r = r.point(lambda p: min(255, p + 8)  if p < 80 else p)
+            b = b.point(lambda p: min(255, p + 12) if p < 80 else p)
+
+        # --- Scene 04: saturate magentas / pinks in FG
+        if grade.get("saturate_magentas"):
+            boost = grade["saturate_magentas"]
+            enhancer = ImageEnhance.Color(Image.merge("RGB", (r, g, b)))
+            merged = enhancer.enhance(1.0 + boost / 100.0)
+            r, g, b = merged.split()
+
+        # --- Scene 05: deep amber tone
+        if grade.get("deep_amber"):
+            r = r.point(lambda p: min(255, p + 10))
+            b = b.point(lambda p: max(0,   p - 8))
+
+        # --- Scene 02: dual-tone (crude approximation — full impl needs mask)
+        # sky_temp and ground_temp applied as global shift here
+        # (full dual-tone requires AE horizon mask)
+        sky_temp = grade.get("sky_temp", 0)
+        if sky_temp != 0:
+            # approximation: slight cool pull on the whole image
+            b = b.point(lambda p: min(255, p + int(sky_temp * 0.5)))
+
+        img = Image.merge("RGB", (r, g, b))
+        return img
+
+    def _apply_motion_preview(
+        self, img: Image.Image, motion: dict, duration_s: float
+    ) -> Image.Image:
+        """
+        Simulate the motion at the midpoint frame for the static preview.
+        Ken Burns: crop to midpoint scale/position.
+        Pan: shift to 50% of offset.
+        Parallax / scroll: show mid-scroll state.
+        Static: no change.
+        """
+        w, h = RESOLUTION
+        mtype = motion["type"]
+
+        if mtype == "ken_burns":
+            scale_start = motion.get("scale_start", 1.0)
+            scale_end   = motion.get("scale_end",   1.06)
+            mid_scale   = (scale_start + scale_end) / 2
+            direction   = motion.get("direction", "up")
+
+            new_w = int(w * mid_scale)
+            new_h = int(h * mid_scale)
+            img_scaled = img.resize((new_w, new_h), Image.Resampling.LANCZOS)
+
+            # Crop anchor based on direction
+            if direction == "up":
+                left = (new_w - w) // 2
+                top  = new_h - h          # anchor bottom, reveals top
+            elif direction == "in":
+                left = (new_w - w) // 2
+                top  = (new_h - h) // 2
+            else:
+                left = (new_w - w) // 2
+                top  = (new_h - h) // 2
+
+            img = img_scaled.crop((left, top, left + w, top + h))
+
+        elif mtype == "pan":
+            direction  = motion.get("direction", "right")
+            offset_px  = motion.get("offset_px", 30)
+            mid_offset = offset_px // 2
+
+            # Scale slightly wider to allow pan headroom
+            img_wide = img.resize((w + offset_px * 2, h), Image.Resampling.LANCZOS)
+            if direction == "right":
+                left = offset_px - mid_offset
+            else:
+                left = offset_px + mid_offset
+            img = img_wide.crop((left, 0, left + w, h))
+
+        elif mtype == "scroll_pan":
+            # Show mid-scroll: pan downward to reveal bottom half
+            pan_s   = motion.get("pan_duration_s", 3.5)
+            # Scroll ~20% down at midpoint preview
+            pan_px  = int(h * 0.20)
+            img_tall = img.resize((w, h + pan_px * 2), Image.Resampling.LANCZOS)
+            top     = pan_px  # midpoint position
+            img     = img_tall.crop((0, top, w, top + h))
+
+        elif mtype == "parallax_3layer":
+            # Simulate slight upward drift at midpoint
+            drift_px = motion["layers"]["fg"]["drift_px"] // 2
+            img_tall  = img.resize((w, h + drift_px * 2), Image.Resampling.LANCZOS)
+            img       = img_tall.crop((0, drift_px, w, drift_px + h))
+
+        elif mtype == "horizon_parallax":
+            # Shift sky layer left by half offset (approximation on flat image)
+            sky_offset = abs(motion.get("sky_offset_px", 8)) // 2
+            img_wide   = img.resize((w + sky_offset * 2, h), Image.Resampling.LANCZOS)
+            img        = img_wide.crop((sky_offset, 0, sky_offset + w, h))
+
+        # "static" and "grid_sequence" — no transform
+        return img
+
+    def _apply_vignette(self, img: Image.Image) -> Image.Image:
+        """35% opacity vignette — applied to all scenes per global architecture."""
+        w, h = RESOLUTION
+        vignette = Image.new("L", (w, h), 0)
+        draw = ImageDraw.Draw(vignette)
+
+        # Radial vignette: black ellipse with feathered edge
+        for i in range(60, 0, -1):
+            alpha = int((60 - i) / 60 * 255 * VIGNETTE_OPACITY)
+            margin_x = int(w * 0.01 * i)
+            margin_y = int(h * 0.01 * i)
+            draw.ellipse(
+                [margin_x, margin_y, w - margin_x, h - margin_y],
+                fill=alpha,
+            )
+
+        vignette_layer = Image.new("RGB", (w, h), (0, 0, 0))
+        img_rgba = img.convert("RGBA")
+        vig_rgba = vignette_layer.convert("RGBA")
+        vig_rgba.putalpha(vignette)
+        img_rgba = Image.alpha_composite(img_rgba, vig_rgba)
+        return img_rgba.convert("RGB")
+
+    def _apply_transition_overlay(self, img: Image.Image, transition: dict) -> Image.Image:
+        """
+        Apply a visual hint of the transition type as a subtle edge overlay
+        on the static preview frame.
+        """
+        ttype  = transition["type"]
+        frames = transition.get("frames", 12)
+        w, h   = RESOLUTION
+
+        # Represent the transition as a thin coloured edge band
+        # (colour-codes the transition type for reference)
+        TRANS_COLORS = {
+            "cross_dissolve": (255, 255, 255, 30),
+            "hard_cut":       (255,  80,  80, 40),
+            "zoom_out_wipe":  (255, 200,  80, 30),
+            "dissolve":       (200, 200, 255, 25),
+            "fade_to_black":  (  0,   0,   0, 60),
+            "slide_left":     ( 80, 180, 255, 30),
+        }
+        color = TRANS_COLORS.get(ttype, (255, 255, 255, 20))
+
+        overlay = Image.new("RGBA", (w, h), (0, 0, 0, 0))
+        draw    = ImageDraw.Draw(overlay)
+        band_h  = max(4, int(frames * 2))  # band height proportional to frame count
+        draw.rectangle([(0, h - band_h), (w, h)], fill=color)
+
+        img_rgba = img.convert("RGBA")
+        img_rgba = Image.alpha_composite(img_rgba, overlay)
+        return img_rgba.convert("RGB")
+
+    # ------------------------------------------------------------------
+    # Text rendering
+    # ------------------------------------------------------------------
+
+    def _render_text(self, img: Image.Image, cfg: dict) -> Image.Image:
+        """
+        Render text onto the composed image according to each scene's text config.
+        This represents the static/midpoint frame of the animation.
+        """
+        text_cfg = cfg["text"]
+        ttype    = text_cfg["type"]
+        label    = cfg["label"]
+
+        txt_layer = Image.new("RGBA", RESOLUTION, (0, 0, 0, 0))
+        draw      = ImageDraw.Draw(txt_layer)
+        font      = self._load_font(text_cfg.get("font_size", FONT_SIZE_BODY))
+
+        w, h = RESOLUTION
+
+        if ttype == "lower_third":
+            # Slide up from lower third — position at 75% height
+            y_pos = int(h * 0.75)
+            x_pos = int(w * 0.08)
+            self._draw_text_with_stroke(draw, label, (x_pos, y_pos), font, align="left")
+
+        elif ttype == "typewriter":
+            # Show partially revealed text (mid-animation)
+            chars_shown = int(len(label) * 0.6)  # 60% revealed at midpoint
+            partial     = label[:chars_shown] + "▌"
+            y_pos = int(h * 0.15)
+            x_pos = int(w * 0.08)
+            self._draw_text_with_stroke(draw, partial, (x_pos, y_pos), font, align="left")
+
+        elif ttype == "stagger_two_line":
+            # Show both lines visible (line 2 has entered by midframe)
+            parts = label.split(" ", 2)
+            line1 = parts[0] if len(parts) > 0 else label
+            line2 = " ".join(parts[1:]) if len(parts) > 1 else ""
+            y_pos  = int(h * 0.12)
+            x_pos  = int(w * 0.08)
+            line_h = text_cfg.get("font_size", FONT_SIZE_BODY) + 20
+            self._draw_text_with_stroke(draw, line1, (x_pos, y_pos),          font, align="left")
+            self._draw_text_with_stroke(draw, line2, (x_pos, y_pos + line_h), font, align="left")
+
+        elif ttype == "grid_sequence":
+            # Draw the rule-of-thirds grid overlay + annotation labels
+            self._draw_grid_overlay(draw, text_cfg, w, h)
+            # Main label at top
+            y_pos = int(h * 0.08)
+            x_pos = w // 2
+            self._draw_text_with_stroke(draw, label, (x_pos, y_pos), font, align="center")
+
+        elif ttype == "right_slide":
+            # Text enters from right — show fully on screen at midpoint
+            y_pos = int(h * 0.20)
+            x_pos = int(w * 0.92)
+            self._draw_text_with_stroke(draw, label, (x_pos, y_pos), font, align="right")
+
+        elif ttype == "center_fade":
+            # Centered text over subjects
+            y_pos = int(h * 0.50)
+            x_pos = w // 2
+            self._draw_text_with_stroke(draw, label, (x_pos, y_pos), font, align="center")
+
+        elif ttype == "countup_params":
+            # Show param labels with their final values (static render of count-up end state)
+            self._draw_countup_params(draw, text_cfg, w, h)
+
+        else:
+            # Fallback: centered label
+            y_pos = int(h * 0.50)
+            x_pos = w // 2
+            self._draw_text_with_stroke(draw, label, (x_pos, y_pos), font, align="center")
+
+        # Composite text layer onto image
+        img_rgba = img.convert("RGBA")
+        img_rgba = Image.alpha_composite(img_rgba, txt_layer)
+        return img_rgba.convert("RGB")
+
+    def _draw_text_with_stroke(
+        self,
+        draw: ImageDraw.Draw,
+        text: str,
+        pos: tuple,
+        font: ImageFont.FreeTypeFont,
+        align: str = "left",
+    ):
+        """Draw text with 9px stroke + drop shadow as per typography system."""
+        x, y = pos
+        w, h = RESOLUTION
+
+        # Wrap text to 85% of canvas width
+        wrapped = self._wrap_text(text, draw, font, w * 0.85)
+
+        # Resolve x anchor for alignment
+        if align == "center":
+            bbox    = draw.textbbox((0, 0), wrapped, font=font)
+            text_w  = bbox[2] - bbox[0]
+            x       = x - text_w // 2
+        elif align == "right":
+            bbox    = draw.textbbox((0, 0), wrapped, font=font)
+            text_w  = bbox[2] - bbox[0]
+            x       = x - text_w
+
+        # Drop shadow (10% opacity black, offset +4,+4)
+        draw.text((x + 4, y + 4), wrapped, font=font, fill=(0, 0, 0, 26))
+
+        # Stroke layers (9px)
+        for sw in [9, 7, 5, 3, 1]:
+            for ax in range(-sw, sw + 1):
+                for ay in range(-sw, sw + 1):
+                    if ax * ax + ay * ay <= sw * sw:
+                        draw.text((x + ax, y + ay), wrapped, font=font, fill=STROKE_COLOR)
+
+        # White text
+        draw.text((x, y), wrapped, font=font, fill=TEXT_COLOR)
+
+    def _draw_grid_overlay(self, draw: ImageDraw.Draw, text_cfg: dict, w: int, h: int):
+        """
+        Render the rule-of-thirds grid overlay for scene 03.
+        Grid lines: white at 40% opacity.
+        Annotation labels at their specified positions.
+        """
+        grid_color = (255, 255, 255, int(255 * 0.40))
+
+        # Vertical lines at 1/3 and 2/3
+        draw.line([(w // 3, 0), (w // 3, h)],     fill=grid_color, width=3)
+        draw.line([(w * 2 // 3, 0), (w * 2 // 3, h)], fill=grid_color, width=3)
+        # Horizontal lines at 1/3 and 2/3
+        draw.line([(0, h // 3), (w, h // 3)],     fill=grid_color, width=3)
+        draw.line([(0, h * 2 // 3), (w, h * 2 // 3)], fill=grid_color, width=3)
+
+        # Annotation labels
+        ann_font = self._load_font(FONT_SIZE_BODY - 20)
+        for label, _, (xr, yr) in text_cfg.get("annotations", []):
+            ax = int(w * xr)
+            ay = int(h * yr)
+            self._draw_text_with_stroke(draw, label, (ax, ay), ann_font, align="left")
+
+    def _draw_countup_params(self, draw: ImageDraw.Draw, text_cfg: dict, w: int, h: int):
+        """
+        Render the edit params for scene 06 at their final count-up values.
+        Laid out as a vertical list centered on screen.
+        """
+        params     = text_cfg.get("params", [])
+        font       = self._load_font(FONT_SIZE_BODY)
+        label_font = self._load_font(FONT_SIZE_BODY - 16)
+        num_font   = self._load_font(FONT_SIZE_ACCENT)
+
+        total_params = len(params)
+        block_h      = int(h * 0.72)            # usable vertical space
+        step         = block_h // total_params
+        start_y      = int(h * 0.14)
+
+        for i, (param_name, value) in enumerate(params):
+            y = start_y + i * step
+            cx = w // 2
+
+            val_str = (f"+{value}" if value > 0 else str(value))
+
+            # Param name (left of center)
+            self._draw_text_with_stroke(
+                draw, param_name, (cx - 20, y), label_font, align="right"
+            )
+            # Value (right of center, accent size)
+            self._draw_text_with_stroke(
+                draw, val_str, (cx + 20, y - 20), num_font, align="left"
+            )
+
+    # ------------------------------------------------------------------
+    # End card
+    # ------------------------------------------------------------------
+
+    def _compose_end_card(self):
+        """Render the end card — black bg, stacked caption text."""
+        cfg  = END_CARD_CONFIG
+        w, h = RESOLUTION
+
+        img  = Image.new("RGB", (w, h), cfg["background"])
+        txt  = Image.new("RGBA", (w, h), (0, 0, 0, 0))
+        draw = ImageDraw.Draw(txt)
+
+        total_lines = len(cfg["lines"])
+        usable_h    = int(h * 0.80)
+        start_y     = int(h * 0.10)
+        # Distribute lines evenly
+        step        = usable_h // total_lines
+
+        for i, (line_text, font_size) in enumerate(cfg["lines"]):
+            y    = start_y + i * step
+            font = self._load_font(font_size)
+            self._draw_text_with_stroke(draw, line_text, (w // 2, y), font, align="center")
+
+        # Hashtags at bottom
+        tag_font  = self._load_font(FONT_SIZE_CAPTION - 12)
+        tags_text = "  ".join(cfg["hashtags"])
+        self._draw_text_with_stroke(
+            draw, tags_text, (w // 2, int(h * 0.92)), tag_font, align="center"
+        )
+
+        img_rgba = img.convert("RGBA")
+        img_rgba = Image.alpha_composite(img_rgba, txt)
+        img_out  = img_rgba.convert("RGB")
+
+        out = os.path.join(self.output_dir, "scene_end_card.jpg")
+        img_out.save(out, quality=95)
+        print(f"[End Card] ✓ Saved → {out}\n")
+
+    # ------------------------------------------------------------------
+    # Utilities
+    # ------------------------------------------------------------------
+
+    def _load_font(self, size: int) -> ImageFont.FreeTypeFont:
+        try:
+            return ImageFont.truetype(self.font_path, size)
+        except Exception:
+            # Fallback: try system fonts
+            fallbacks = [
+                "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
+                "/System/Library/Fonts/Helvetica.ttc",
+                "/usr/share/fonts/truetype/liberation/LiberationSans-Bold.ttf",
+            ]
+            for fb in fallbacks:
+                if os.path.exists(fb):
+                    return ImageFont.truetype(fb, size)
+            return ImageFont.load_default()
+
+    def _wrap_text(
+        self,
+        text: str,
+        draw: ImageDraw.Draw,
+        font: ImageFont.FreeTypeFont,
+        max_width: float,
+    ) -> str:
+        words    = text.split()
+        lines    = []
+        cur_line = []
+
+        for word in words:
+            test  = " ".join(cur_line + [word])
+            bbox  = draw.textbbox((0, 0), test, font=font)
+            if bbox[2] - bbox[0] <= max_width:
+                cur_line.append(word)
+            else:
+                if cur_line:
+                    lines.append(" ".join(cur_line))
+                cur_line = [word]
+
+        if cur_line:
+            lines.append(" ".join(cur_line))
+
+        return "\n".join(lines)
+
+    def print_scene_summary(self):
+        """Print a full summary of all scene configs — useful for handoff to AE."""
+        print("\n" + "=" * 60)
+        print("SCENE SUMMARY — Sunset Reel Edit Plan")
+        print("=" * 60)
+        for cfg in SCENE_CONFIG:
+            ae = " [AE REQUIRED]" if cfg.get("ae_required") else ""
+            print(f"\nScene {cfg['idx']:02d} — {cfg['label']}{ae}")
+            print(f"  Duration    : {cfg['duration_s']} s  ({int(cfg['duration_s'] * FPS)} frames)")
+            print(f"  Motion      : {cfg['motion']['type']}")
+            print(f"  Text type   : {cfg['text']['type']}")
+            print(f"  Transition  : {cfg['transition_out']['type']} ({cfg['transition_out']['frames']}f)")
+            if cfg.get("ae_note"):
+                print(f"  AE note     : {cfg['ae_note']}")
+        print(f"\nEnd Card      : {END_CARD_CONFIG['duration_s']} s — black bg, stacked captions")
+        total = sum(c["duration_s"] for c in SCENE_CONFIG) + END_CARD_CONFIG["duration_s"]
+        print(f"\nTotal runtime : ~{total:.1f} s  ({int(total * FPS)} frames @ {FPS}fps)")
+        print("=" * 60 + "\n")
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    manifest_file = "../content_gen_server/manifest_response.json"
+    selected_dir  = "selected"
+    output_dir    = "output"
+
+    composer = SceneComposer(manifest_file, selected_dir, output_dir)
+    composer.print_scene_summary()
+    composer.compose_all_scenes()

composer_dynamic.py

@@ -0,0 +1,600 @@
+"""
+Dynamic Video Composer - Generates SCENE_CONFIG from Manifest
+Converts manifest labels to uppercase and creates video without hardcoded config
+"""
+
+import os
+import numpy as np
+import cv2
+from pathlib import Path
+from PIL import Image, ImageDraw, ImageFont, ImageEnhance, ImageOps
+from typing import Dict, List, Any
+
+# ---------------------------------------------------------------------------
+# GLOBALS
+# ---------------------------------------------------------------------------
+
+RESOLUTION      = (1080, 1920)   # W x H
+FPS             = 30
+SELECTED_DIR    = "selected"
+FONT_PATH       = "asset/TR Impact.TTF"
+FONT_PATH_REG   = "asset/TR Impact.TTF"
+
+GLOBAL_TEMP      = +8
+GLOBAL_TINT      = -5
+
+TEXT_WHITE  = (255, 255, 255, 255)
+TEXT_STROKE = (0,   0,   0,   210)
+TEXT_SHADOW = (0,   0,   0,   60)
+STROKE_W    = 8
+
+# Easing
+def ease_out(t):      return 1 - (1 - t) ** 3
+def ease_in_out(t):   return t * t * (3 - 2 * t)
+def ease_in(t):       return t * t * t
+def lerp(a, b, t):    return a + (b - a) * t
+
+# ---------------------------------------------------------------------------
+# DYNAMIC SCENE CONFIG GENERATION
+# ---------------------------------------------------------------------------
+
+# Default motion, text, grade, transition configs per scene type
+DEFAULT_SCENE_TEMPLATES = {
+    "intro": {
+        "motion":     {"type": "slow_push_in", "scale_start": 1.0, "scale_end": 1.08},
+        "text":       {"type": "center_stroke_pop", "entry_frame": 2, "font_size": 95},
+        "grade":      {"crush_blacks": 15, "contrast": 1.15},
+        "transition": {"type": "hard_cut", "frames": 1},
+        "duration_s": 4.7,
+    },
+    "default": {
+        "motion":     {"type": "snap_zoom", "scale_start": 1.0, "scale_end": 1.12},
+        "text":       {"type": "center_pop", "entry_frame": 0, "font_size": 110},
+        "grade":      {"warm_tint": True, "lift_mids": 10},
+        "transition": {"type": "whip_pan_right", "frames": 4},
+        "duration_s": 2.3,
+    },
+    "final": {
+        "motion":     {"type": "static"},
+        "text":       {"type": "center_fade_pop", "entry_frame": 2, "font_size": 110},
+        "grade":      {"warm_indoor": True, "soft_glow": True, "lift_mids": 12},
+        "transition": {"type": "end_fade_black", "frames": 30},
+        "duration_s": 2.3,
+    }
+}
+
+# Grade variations for different scenes
+GRADE_VARIATIONS = [
+    {"warm_tint": True, "lift_mids": 10},           # Scene 1: Warm
+    {"desaturate": True, "lift_blacks": 5},         # Scene 2: Desaturated
+    {"cool_tint": True, "highlights": -15},         # Scene 3: Cool
+    {"soft_pink": True, "lift_mids": 15},           # Scene 4: Pink
+    {"indoor_warm": True, "lift_shadows": 8},       # Scene 5: Warm indoor
+    {"teal_orange": True, "crush_blacks": 10},      # Scene 6: Teal/orange
+    {"dark_moody": True, "crush_blacks": 20, "desaturate": 15},  # Scene 7: Moody
+]
+
+
+def generate_scene_config(manifest: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """
+    Generate SCENE_CONFIG dynamically from manifest.
+    
+    Converts labels to uppercase and assigns motion/grade/transition configs.
+    """
+    scenes = manifest.get("scenes", [])
+    config = []
+    
+    for idx, scene_data in enumerate(scenes):
+        # Extract label and convert to uppercase
+        label = scene_data.get("label", f"SCENE {idx}").upper()
+        
+        # Determine scene type
+        if idx == 0:
+            template = DEFAULT_SCENE_TEMPLATES["intro"]
+        elif idx == len(scenes) - 1:
+            template = DEFAULT_SCENE_TEMPLATES["final"]
+        else:
+            template = DEFAULT_SCENE_TEMPLATES["default"]
+        
+        # Calculate hold_frames based on duration
+        duration_s = template.get("duration_s", 2.3)
+        total_frames = int(duration_s * FPS)
+        
+        # Build scene config
+        scene_cfg = {
+            "idx": idx,
+            "label": label,
+            "duration_s": duration_s,
+            "motion": template["motion"].copy(),
+            "text": {
+                **template["text"],
+                "hold_frames": total_frames - template["text"].get("entry_frame", 2) - 6,
+                "align": "center"
+            },
+            "grade": GRADE_VARIATIONS[idx % len(GRADE_VARIATIONS)].copy() if idx > 0 else template["grade"].copy(),
+            "transition": template["transition"].copy(),
+        }
+        
+        config.append(scene_cfg)
+    
+    return config
+
+
+# ---------------------------------------------------------------------------
+# COLOUR GRADE
+# ---------------------------------------------------------------------------
+
+def grade_image(img: Image.Image, grade: dict) -> Image.Image:
+    r, g, b = img.split()
+
+    # Global warm grade
+    r = r.point(lambda p: min(255, p + int(GLOBAL_TEMP * 1.2)))
+    g = g.point(lambda p: min(255, p + int(GLOBAL_TEMP * 0.35)))
+    b = b.point(lambda p: max(0,   p - int(GLOBAL_TEMP * 0.8)))
+    g = g.point(lambda p: max(0, min(255, p + int(GLOBAL_TINT * 0.5))))
+
+    # Scene-specific
+    if grade.get("boost_reds"):
+        v = grade["boost_reds"]
+        r = r.point(lambda p: min(255, p + v))
+        g = g.point(lambda p: min(255, p + int(v * 0.25)))
+
+    if grade.get("crush_blacks"):
+        v = grade.get("crush_blacks", 10)
+        r = r.point(lambda p: max(0, p - v) if p < 55 else p)
+        g = g.point(lambda p: max(0, p - v) if p < 55 else p)
+        b = b.point(lambda p: max(0, p - v) if p < 55 else p)
+
+    if grade.get("contrast"):
+        v = grade["contrast"]
+        r = r.point(lambda p: int((p - 128) * v + 128))
+        g = g.point(lambda p: int((p - 128) * v + 128))
+        b = b.point(lambda p: int((p - 128) * v + 128))
+
+    if grade.get("lift_shadows"):
+        v = grade.get("lift_shadows", 0)
+        r = r.point(lambda p: min(255, p + v))
+        g = g.point(lambda p: min(255, p + v))
+        b = b.point(lambda p: min(255, p + v))
+
+    if grade.get("warm_tint"):
+        r = r.point(lambda p: min(255, p + 8))
+        g = g.point(lambda p: min(255, p + 3))
+
+    if grade.get("cool_tint"):
+        b = b.point(lambda p: min(255, p + 8))
+        r = r.point(lambda p: max(0, p - 5))
+
+    if grade.get("desaturate"):
+        v = grade.get("desaturate", 10)
+        merged = Image.merge("RGB", (r, g, b))
+        merged = ImageEnhance.Color(merged).enhance(max(0, 1.0 - v/100.0))
+        r, g, b = merged.split()
+
+    if grade.get("lift_blacks"):
+        v = grade["lift_blacks"]
+        r = r.point(lambda p: min(255, p + v))
+        g = g.point(lambda p: min(255, p + v))
+        b = b.point(lambda p: min(255, p + v))
+
+    if grade.get("lift_mids"):
+        v = grade["lift_mids"]
+        r = r.point(lambda p: int(p + v * (1 - abs(p - 128) / 128)))
+        g = g.point(lambda p: int(p + v * (1 - abs(p - 128) / 128)))
+        b = b.point(lambda p: int(p + v * (1 - abs(p - 128) / 128)))
+
+    if grade.get("highlights"):
+        v = abs(grade["highlights"])
+        r = r.point(lambda p: p - int((p / 255) ** 2.2 * v))
+        g = g.point(lambda p: p - int((p / 255) ** 2.2 * v))
+        b = b.point(lambda p: p - int((p / 255) ** 2.2 * v))
+
+    if grade.get("teal_orange"):
+        r = r.point(lambda p: min(255, p + 5))
+        b = b.point(lambda p: max(0, p - 8))
+
+    if grade.get("soft_pink"):
+        r = r.point(lambda p: min(255, p + 10))
+        b = b.point(lambda p: min(255, p + 5))
+
+    if grade.get("indoor_warm"):
+        r = r.point(lambda p: min(255, p + 12))
+        g = g.point(lambda p: min(255, p + 5))
+
+    if grade.get("soft_glow"):
+        merged = Image.merge("RGB", (r, g, b))
+        merged = ImageEnhance.Brightness(merged).enhance(1.05)
+        r, g, b = merged.split()
+
+    if grade.get("dark_moody"):
+        r = r.point(lambda p: max(0, p - 15))
+        g = g.point(lambda p: max(0, p - 15))
+        b = b.point(lambda p: max(0, p - 10))
+
+    img = Image.merge("RGB", (r, g, b))
+    img = ImageEnhance.Brightness(img).enhance(1.02)
+    return img
+
+# ---------------------------------------------------------------------------
+# IMAGE LOAD + CROP-TO-FILL
+# ---------------------------------------------------------------------------
+
+def load_scene_image(idx: int, selected_dir: str) -> Image.Image:
+    path = os.path.join(selected_dir, f"scene_{idx:02d}.jpg")
+    img  = Image.open(path).convert("RGB")
+    return crop_to_fill(img, *RESOLUTION)
+
+def crop_to_fill(img: Image.Image, target_w: int, target_h: int) -> Image.Image:
+    iw, ih  = img.size
+    scale   = max(target_w / iw, target_h / ih)
+    new_w   = int(iw * scale)
+    new_h   = int(ih * scale)
+    img     = img.resize((new_w, new_h), Image.Resampling.LANCZOS)
+    left    = (new_w - target_w) // 2
+    top     = (new_h - target_h) // 2
+    return img.crop((left, top, left + target_w, top + target_h))
+
+# ---------------------------------------------------------------------------
+# MOTION
+# ---------------------------------------------------------------------------
+
+def get_motion_frame(base: Image.Image, motion: dict, t: float) -> Image.Image:
+    mtype = motion["type"]
+    w, h  = RESOLUTION
+
+    if mtype == "snap_zoom":
+        s_start = motion["scale_start"]
+        s_end   = motion["scale_end"]
+        scale   = lerp(s_start, s_end, ease_out(t))
+
+        nw = int(w * scale)
+        nh = int(h * scale)
+        scaled = base.resize((nw, nh), Image.Resampling.BILINEAR)
+
+        left = (nw - w) // 2
+        top  = (nh - h) // 2
+        left = max(0, min(left, nw - w))
+        top  = max(0, min(top,  nh - h))
+        return scaled.crop((left, top, left + w, top + h))
+
+    elif mtype == "slow_push_in":
+        s_start = motion.get("scale_start", 1.0)
+        s_end   = motion.get("scale_end", 1.08)
+        scale   = lerp(s_start, s_end, ease_in_out(t))
+
+        nw = int(w * scale)
+        nh = int(h * scale)
+        scaled = base.resize((nw, nh), Image.Resampling.BILINEAR)
+
+        left = (nw - w) // 2
+        top  = (nh - h) // 2
+        left = max(0, min(left, nw - w))
+        top  = max(0, min(top,  nh - h))
+        return scaled.crop((left, top, left + w, top + h))
+
+    else:  # static or others
+        return base
+
+# ---------------------------------------------------------------------------
+# FONT CACHE
+# ---------------------------------------------------------------------------
+
+_font_cache = {}
+
+def get_font(size: int) -> ImageFont.FreeTypeFont:
+    if size not in _font_cache:
+        try:
+            _font_cache[size] = ImageFont.truetype(FONT_PATH, size)
+        except Exception:
+            try:
+                _font_cache[size] = ImageFont.truetype(FONT_PATH_REG, size)
+            except Exception:
+                _font_cache[size] = ImageFont.load_default()
+    return _font_cache[size]
+
+# ---------------------------------------------------------------------------
+# TEXT DRAWING
+# ---------------------------------------------------------------------------
+
+def draw_text_stroked(draw, text, pos, font, align="left", opacity=1.0):
+    """White text with stroke, drop shadow, and opacity."""
+    x, y = pos
+    w, _  = RESOLUTION
+
+    lines = text.split("\n")
+    line_heights = []
+    line_widths  = []
+    for line in lines:
+        bb = draw.textbbox((0, 0), line, font=font)
+        line_widths.append(bb[2] - bb[0])
+        line_heights.append(bb[3] - bb[1])
+
+    line_spacing = int(font.size * 1.25)
+
+    for i, line in enumerate(lines):
+        lw  = line_widths[i]
+        ly  = y + i * line_spacing
+
+        if align == "center":
+            lx = x - lw // 2
+        elif align == "right":
+            lx = x - lw
+        else:
+            lx = x
+
+        alpha_stroke = int(TEXT_STROKE[3] * opacity)
+        alpha_white  = int(TEXT_WHITE[3]  * opacity)
+        alpha_shadow = int(TEXT_SHADOW[3] * opacity)
+
+        stroke_col = TEXT_STROKE[:3] + (alpha_stroke,)
+        white_col  = TEXT_WHITE[:3]  + (alpha_white,)
+        shadow_col = TEXT_SHADOW[:3] + (alpha_shadow,)
+
+        # Drop shadow
+        draw.text((lx + 4, ly + 4), line, font=font, fill=shadow_col)
+
+        # Stroke layers
+        for sw in [STROKE_W, STROKE_W - 2, STROKE_W - 4, 2]:
+            for ax in range(-sw, sw + 1, max(1, sw // 3)):
+                for ay in range(-sw, sw + 1, max(1, sw // 3)):
+                    if ax * ax + ay * ay <= sw * sw:
+                        draw.text((lx + ax, ly + ay), line, font=font, fill=stroke_col)
+
+        # White fill
+        draw.text((lx, ly), line, font=font, fill=white_col)
+
+# ---------------------------------------------------------------------------
+# TEXT ANIMATIONS
+# ---------------------------------------------------------------------------
+
+def render_text_frame(cfg: dict, frame: int, total_frames: int) -> Image.Image:
+    tcfg  = cfg["text"]
+    ttype = tcfg["type"]
+    label = cfg["label"]
+    w, h  = RESOLUTION
+
+    layer = Image.new("RGBA", (w, h), (0, 0, 0, 0))
+    draw  = ImageDraw.Draw(layer)
+    font  = get_font(tcfg["font_size"])
+
+    if ttype == "quick_center_pop" or ttype == "center_stroke_pop":
+        entry_f = tcfg["entry_frame"]
+        hold_f  = tcfg["hold_frames"]
+        fade_start = entry_f + hold_f
+
+        if frame < entry_f:
+            pass
+        elif frame < entry_f + 6:  # 0.2s pop-in
+            progress = ease_out((frame - entry_f) / 6)
+            opacity  = min(1.0, progress * 1.5)
+            x = w // 2
+            y = h // 2
+            draw_text_stroked(draw, label, (x, y), font, align="center", opacity=opacity)
+        elif frame < fade_start:
+            x = w // 2
+            y = h // 2
+            draw_text_stroked(draw, label, (x, y), font, align="center", opacity=1.0)
+        else:
+            fade_progress = min(1.0, (frame - fade_start) / 4)
+            opacity = 1.0 - fade_progress
+            x = w // 2
+            y = h // 2
+            draw_text_stroked(draw, label, (x, y), font, align="center", opacity=opacity)
+
+    elif ttype == "center_pop" or ttype == "center_fade_pop":
+        entry_f = tcfg["entry_frame"]
+        hold_f  = tcfg["hold_frames"]
+        fade_start = entry_f + hold_f
+
+        if frame < entry_f:
+            pass
+        elif frame < entry_f + 6:
+            progress = ease_out((frame - entry_f) / 6)
+            opacity  = min(1.0, progress * 1.5)
+            x = w // 2
+            y = h // 2
+            draw_text_stroked(draw, label, (x, y), font, align="center", opacity=opacity)
+        elif frame < fade_start:
+            x = w // 2
+            y = h // 2
+            draw_text_stroked(draw, label, (x, y), font, align="center", opacity=1.0)
+        else:
+            fade_progress = min(1.0, (frame - fade_start) / 4)
+            opacity = 1.0 - fade_progress
+            x = w // 2
+            y = h // 2
+            draw_text_stroked(draw, label, (x, y), font, align="center", opacity=opacity)
+
+    return layer
+
+# ---------------------------------------------------------------------------
+# TRANSITION
+# ---------------------------------------------------------------------------
+
+def apply_transition(frame_a: Image.Image, frame_b: Image.Image, ttype: str, progress: float) -> Image.Image:
+    """Apply dynamic transition between frames."""
+    w, h = RESOLUTION
+    
+    if ttype == "whip_pan_right":
+        offset = int(w * (1 - ease_out(progress)))
+        result = Image.new("RGB", (w, h))
+        result.paste(frame_a, (0, 0))
+        result.paste(frame_b, (offset, 0))
+        return result
+    
+    elif ttype == "flash":
+        if progress < 0.3:
+            flash_intensity = (progress / 0.3) * 0.5
+            brightened = ImageEnhance.Brightness(frame_a).enhance(1.0 + flash_intensity)
+            alpha = min(0.5, progress / 0.3 * 0.5)
+            return Image.blend(brightened, frame_b, alpha)
+        else:
+            blend_t = (progress - 0.3) / 0.7
+            return Image.blend(frame_a, frame_b, blend_t)
+    
+    elif ttype == "end_fade_black":
+        black = Image.new("RGB", (w, h), (0, 0, 0))
+        return Image.blend(frame_a, black, progress)
+    
+    else:  # Default to hard cut
+        return frame_b if progress >= 0.5 else frame_a
+
+# ---------------------------------------------------------------------------
+# MAIN RENDER FROM MANIFEST
+# ---------------------------------------------------------------------------
+
+def render_video_from_manifest(manifest_dict: Dict[str, Any], selected_dir: str, output_path: str) -> Dict[str, Any]:
+    """
+    Render video from manifest without hardcoded SCENE_CONFIG.
+    
+    Args:
+        manifest_dict: Dictionary with 'scenes' key containing scene data
+        selected_dir: Path to directory with selected scene images
+        output_path: Path to output video file
+    
+    Returns:
+        Dictionary with success status, duration, and metadata
+    """
+    w, h = RESOLUTION
+    Path(os.path.dirname(output_path) or ".").mkdir(parents=True, exist_ok=True)
+
+    # Generate dynamic SCENE_CONFIG from manifest
+    SCENE_CONFIG = generate_scene_config(manifest_dict)
+    
+    if not SCENE_CONFIG:
+        return {
+            "success": False,
+            "error": "No scenes in manifest",
+            "duration_s": 0
+        }
+
+    tmp_path = output_path.replace(".mp4", "_raw.mp4")
+    writer   = cv2.VideoWriter(
+        tmp_path,
+        cv2.VideoWriter_fourcc(*"mp4v"),
+        FPS,
+        (w, h),
+    )
+
+    print(f"\n{'='*55}")
+    print(f"  Dynamic Video Composition")
+    print(f"  {len(SCENE_CONFIG)} scenes | {FPS}fps | {w}x{h}")
+    print(f"{'='*55}\n")
+
+    # Preload and grade all base images
+    print("[1/3] Loading + grading images...")
+    base_images = []
+    for cfg in SCENE_CONFIG:
+        try:
+            raw = load_scene_image(cfg["idx"], selected_dir)
+            graded = grade_image(raw, cfg["grade"])
+            base_images.append(graded)
+        except Exception as e:
+            print(f"  [ERROR] Failed to load scene {cfg['idx']}: {e}")
+            return {"success": False, "error": str(e), "duration_s": 0}
+    
+    print("    [OK] Done\n")
+
+    # Render scenes
+    print("[2/3] Rendering frames...")
+    total_scenes   = len(SCENE_CONFIG)
+    frames_written = 0
+
+    for scene_i, cfg in enumerate(SCENE_CONFIG):
+        total_frames = int(cfg["duration_s"] * FPS)
+        trans_cfg    = cfg["transition"]
+        trans_frames = trans_cfg["frames"]
+        base         = base_images[scene_i]
+
+        # Preload next scene base for transitions
+        if scene_i + 1 < total_scenes:
+            next_cfg   = SCENE_CONFIG[scene_i + 1]
+            next_base  = base_images[scene_i + 1]
+        else:
+            next_cfg   = None
+            next_base  = None
+
+        print(f"  Scene {cfg['idx']:02d} -- {cfg['label'][:40]} ({total_frames}f, {cfg['duration_s']}s)")
+
+        for frame in range(total_frames):
+            # Motion frame
+            t_motion = frame / max(total_frames - 1, 1)
+            img      = get_motion_frame(base, cfg["motion"], t_motion)
+
+            # Text layer
+            text_layer = render_text_frame(cfg, frame, total_frames)
+            img_rgba   = img.convert("RGBA")
+            img_rgba   = Image.alpha_composite(img_rgba, text_layer)
+            img        = img_rgba.convert("RGB")
+
+            # Transition blend at end of scene
+            frames_into_trans = frame - (total_frames - trans_frames)
+            if frames_into_trans >= 0 and next_base is not None:
+                trans_t     = frames_into_trans / max(trans_frames - 1, 1)
+                t_next      = 0.0
+                next_motion = get_motion_frame(next_base, next_cfg["motion"], t_next)
+                img = apply_transition(img, next_motion, trans_cfg["type"], trans_t)
+
+            # Write frame (cv2 expects BGR)
+            arr = np.array(img)
+            writer.write(cv2.cvtColor(arr, cv2.COLOR_RGB2BGR))
+            frames_written += 1
+
+        print(f"    [OK] {total_frames} frames")
+
+    # Hard cut to black at end
+    print(f"\n  Hard cut to black")
+    black_frame = np.zeros((h, w, 3), dtype=np.uint8)
+    for _ in range(2):
+        writer.write(black_frame)
+        frames_written += 1
+    print(f"    [OK] 2 frames")
+
+    writer.release()
+    duration_s = frames_written / FPS
+    print(f"\n  Total frames written: {frames_written} (~{duration_s:.1f}s)\n")
+
+    # Re-encode with ffmpeg
+    print("[3/3] Encoding H.264 MP4 via ffmpeg...")
+    cmd = (
+        f"ffmpeg -y -i {tmp_path} "
+        f"-vcodec libx264 -crf 20 -preset fast "
+        f"-pix_fmt yuv420p "
+        f"-movflags +faststart "
+        f"{output_path} 2>&1"
+    )
+    ret = os.system(cmd)
+    if ret == 0:
+        os.remove(tmp_path)
+        size_mb = os.path.getsize(output_path) / (1024 * 1024)
+        print(f"\n  [OK] Output: {output_path}")
+        print(f"  [OK] Size  : {size_mb:.1f} MB")
+        print(f"\n{'='*55}\n")
+        
+        return {
+            "success": True,
+            "output_path": output_path,
+            "duration_s": duration_s,
+            "size_mb": size_mb
+        }
+    else:
+        print(f"  [ERROR] ffmpeg failed (code {ret}). Raw file kept: {tmp_path}")
+        return {
+            "success": False,
+            "error": f"ffmpeg failed with code {ret}",
+            "duration_s": duration_s
+        }
+
+
+if __name__ == "__main__":
+    # Example usage
+    manifest = {
+        "scenes": [
+            {"label": "which type of anger do you have?"},
+            {"label": "shouting"},
+            {"label": "revenge"},
+        ]
+    }
+    
+    result = render_video_from_manifest(manifest, "selected", "renders/test_dynamic.mp4")
+    print(f"Result: {result}")

composer_simple.py

@@ -0,0 +1,263 @@
+"""
+Sunset Reel — Simplified Frame-by-Frame Renderer
+Renders static frame with text overlay from each scene image (no complex motions)
+Uses PIL only, exports via ffmpeg
+"""
+
+import os
+import json
+from pathlib import Path
+from PIL import Image, ImageDraw, ImageFont, ImageEnhance
+
+# ---------------------------------------------------------------------------
+# GLOBALS
+# ---------------------------------------------------------------------------
+
+RESOLUTION      = (1080, 1920)   # W x H
+FPS             = 30
+OUTPUT_PATH     = "renders/sunset_reel.mp4"
+SELECTED_DIR    = "selected"
+FONT_PATH       = "../trendclip/assets/fonts/Montserrat-Bold.ttf"
+
+TEXT_WHITE  = (255, 255, 255)
+TEXT_STROKE = (0,   0,   0)
+STROKE_W    = 8
+
+# Easing
+def ease_out(t):      return 1 - (1 - t) ** 3
+def ease_in_out(t):   return t * t * (3 - 2 * t)
+def ease_in(t):       return t * t * t
+def lerp(a, b, t):    return a + (b - a) * t
+
+# ---------------------------------------------------------------------------
+# SCENE CONFIG
+# ---------------------------------------------------------------------------
+
+SCENE_CONFIG = [
+    {"idx": 0, "label": "Chase The\nGolden Hour", "duration_s": 3.5, "boost_reds": 15},
+    {"idx": 1, "label": "Scout Your\nSpot First", "duration_s": 3.0, "push_purples": True},
+    {"idx": 2, "label": "Balance The\nBright Sky", "duration_s": 3.5, "sky_cool": True},
+    {"idx": 3, "label": "Rule Of\nThirds Grid", "duration_s": 4.0},
+    {"idx": 4, "label": "Layer The\nForeground Depth", "duration_s": 4.0, "saturate": True},
+    {"idx": 5, "label": "Add A\nSilhouette Subject", "duration_s": 3.5, "deep_amber": True},
+    {"idx": 6, "label": "Edit The\nWarmth Gently", "duration_s": 4.5, "match_reel": True},
+]
+
+END_CARD = {
+    "duration_s": 2.5,
+    "lines": [
+        ("Stop guessing.", 96),
+        ("Start shooting.", 96),
+        ("Which of these do you already do?", 52),
+        ("Save this before you forget", 46),
+    ],
+}
+
+# ---------------------------------------------------------------------------
+# COLOUR GRADE
+# ---------------------------------------------------------------------------
+
+def grade_image(img: Image.Image, grade_cfg: dict) -> Image.Image:
+    """Apply colour grading to image"""
+    enhancer = ImageEnhance.Brightness(img)
+    img = enhancer.enhance(1.02)
+    
+    if grade_cfg.get("boost_reds"):
+        enhancer = ImageEnhance.Color(img)
+        img = enhancer.enhance(1.1)
+    
+    if grade_cfg.get("saturate"):
+        enhancer = ImageEnhance.Color(img)
+        img = enhancer.enhance(1.22)
+    
+    if grade_cfg.get("deep_amber"):
+        enhancer = ImageEnhance.Color(img)
+        img = enhancer.enhance(1.15)
+    
+    return img
+
+
+# ---------------------------------------------------------------------------
+# IMAGE LOAD + CROP
+# ---------------------------------------------------------------------------
+
+def load_scene_image(idx: int) -> Image.Image:
+    path = os.path.join(SELECTED_DIR, f"scene_{idx:02d}.jpg")
+    img = Image.open(path).convert("RGB")
+    return crop_to_fill(img, *RESOLUTION)
+
+
+def crop_to_fill(img: Image.Image, target_w: int, target_h: int) -> Image.Image:
+    iw, ih = img.size
+    scale = max(target_w / iw, target_h / ih)
+    new_w = int(iw * scale)
+    new_h = int(ih * scale)
+    img = img.resize((new_w, new_h), Image.Resampling.LANCZOS)
+    left = (new_w - target_w) // 2
+    top = (new_h - target_h) // 2
+    return img.crop((left, top, left + target_w, top + target_h))
+
+
+# ---------------------------------------------------------------------------
+# TEXT DRAWING
+# ---------------------------------------------------------------------------
+
+def get_font(size: int) -> ImageFont.FreeTypeFont:
+    try:
+        return ImageFont.truetype(FONT_PATH, size)
+    except Exception:
+        return ImageFont.load_default()
+
+
+def draw_text_stroked(draw, text, pos, font, align="left"):
+    """White text with stroke"""
+    x, y = pos
+    w, _ = RESOLUTION
+    
+    # Multi-line
+    lines = text.split("\n")
+    line_spacing = int(font.size * 1.25)
+    
+    for i, line in enumerate(lines):
+        bbox = draw.textbbox((0, 0), line, font=font)
+        line_w = bbox[2] - bbox[0]
+        ly = y + i * line_spacing
+        
+        if align == "center":
+            lx = x - line_w // 2
+        elif align == "right":
+            lx = x - line_w
+        else:
+            lx = x
+        
+        # Stroke layers
+        for sw in [STROKE_W, STROKE_W - 2, STROKE_W - 4, 2]:
+            for ax in range(-sw, sw + 1, max(1, sw // 3)):
+                for ay in range(-sw, sw + 1, max(1, sw // 3)):
+                    if ax * ax + ay * ay <= sw * sw:
+                        draw.text((lx + ax, ly + ay), line, font=font, fill=TEXT_STROKE)
+        
+        # White fill
+        draw.text((lx, ly), line, font=font, fill=TEXT_WHITE)
+
+
+def render_text_frame(cfg: dict, frame: int, total_frames: int) -> Image.Image:
+    """Render text layer for frame"""
+    w, h = RESOLUTION
+    layer = Image.new("RGBA", (w, h), (0, 0, 0, 0))
+    draw = ImageDraw.Draw(layer)
+    font = get_font(90)
+    
+    label = cfg["label"]
+    
+    # Simple fade-in at frame 8
+    if frame >= 8:
+        progress = min(1.0, (frame - 8) / 18)
+        opacity_int = int(255 * progress)
+        
+        # Draw stroked text
+        draw_text_stroked(draw, label, (int(w * 0.08), int(h * 0.76)), font, align="left")
+    
+    return layer
+
+
+# ---------------------------------------------------------------------------
+# MAIN RENDER
+# ---------------------------------------------------------------------------
+
+def render():
+    w, h = RESOLUTION
+    Path(os.path.dirname(OUTPUT_PATH)).mkdir(parents=True, exist_ok=True)
+    
+    # Temp frame folder
+    frames_dir = "renders/frames_tmp"
+    Path(frames_dir).mkdir(parents=True, exist_ok=True)
+    
+    print(f"\n{'='*55}")
+    print(f"  Sunset Reel Renderer (Simplified)")
+    print(f"  {len(SCENE_CONFIG)} scenes + end card  |  {FPS}fps  |  {w}x{h}")
+    print(f"{'='*55}\n")
+    
+    # Render scenes
+    print("[1/2] Rendering frames...")
+    total_frames_written = 0
+    
+    for scene_i, cfg in enumerate(SCENE_CONFIG):
+        total_frames = int(cfg["duration_s"] * FPS)
+        base = load_scene_image(cfg["idx"])
+        base = grade_image(base, cfg)
+        
+        print(f"  Scene {cfg['idx']:02d} — {cfg['label'].replace(chr(10),' ')} ({total_frames}f)")
+        
+        for frame in range(total_frames):
+            # Create base image
+            img = base.copy()
+            
+            # Add text overlay
+            text_layer = render_text_frame(cfg, frame, total_frames)
+            img_rgba = img.convert("RGBA")
+            img_rgba = Image.alpha_composite(img_rgba, text_layer)
+            img = img_rgba.convert("RGB")
+            
+            # Save frame
+            frame_path = os.path.join(frames_dir, f"frame_{total_frames_written:06d}.jpg")
+            img.save(frame_path, quality=92)
+            total_frames_written += 1
+        
+        print(f"    ✓ {total_frames} frames")
+    
+    # Render end card
+    end_frames = int(END_CARD["duration_s"] * FPS)
+    print(f"\n  End card ({end_frames}f)")
+    
+    for frame in range(end_frames):
+        img = Image.new("RGB", (w, h), (8, 8, 8))
+        layer = Image.new("RGBA", (w, h), (0, 0, 0, 0))
+        draw = ImageDraw.Draw(layer)
+        
+        start_y = int(h * 0.14)
+        step = int((h * 0.72) / len(END_CARD["lines"]))
+        
+        for i, (line_text, fsize) in enumerate(END_CARD["lines"]):
+            entry_f = 14 + i * 10
+            if frame >= entry_f:
+                progress = min(1.0, (frame - entry_f) / 18)
+                font = get_font(fsize)
+                y = start_y + i * step
+                slide_y = int(lerp(20, 0, ease_out(progress)))
+                draw_text_stroked(draw, line_text, (w // 2, y + slide_y), font, align="center")
+        
+        img_rgba = img.convert("RGBA")
+        img_rgba = Image.alpha_composite(img_rgba, layer)
+        img = img_rgba.convert("RGB")
+        
+        frame_path = os.path.join(frames_dir, f"frame_{total_frames_written:06d}.jpg")
+        img.save(frame_path, quality=92)
+        total_frames_written += 1
+    
+    print(f"    ✓ {end_frames} frames")
+    
+    print(f"\n  Total frames: {total_frames_written} (~{total_frames_written/FPS:.1f}s)\n")
+    
+    # Encode with ffmpeg
+    print("[2/2] Encoding MP4 via ffmpeg...")
+    cmd = (
+        f"ffmpeg -y -framerate {FPS} -i {frames_dir}/frame_%06d.jpg "
+        f"-c:v libx264 -crf 20 -preset fast -pix_fmt yuv420p -movflags +faststart "
+        f"{OUTPUT_PATH} 2>&1"
+    )
+    ret = os.system(cmd)
+    
+    if ret == 0:
+        import shutil
+        shutil.rmtree(frames_dir, ignore_errors=True)
+        size_mb = os.path.getsize(OUTPUT_PATH) / (1024 * 1024)
+        print(f"\n  ✓ Output: {OUTPUT_PATH}")
+        print(f"  ✓ Size  : {size_mb:.1f} MB\n")
+        print(f"{'='*55}\n")
+    else:
+        print(f"  ✗ ffmpeg failed (code {ret})")
+
+
+if __name__ == "__main__":
+    render()

composer_v2.py

@@ -0,0 +1,574 @@
+"""
+Sunset Reel — Fast-Paced TikTok/Reels Renderer
+7 scenes × ~1s each = ~7s total video
+Snap zoom, quick center-pop text, hard cuts
+Pure code rendering with PIL + cv2
+"""
+
+import os
+import numpy as np
+import cv2
+from pathlib import Path
+from PIL import Image, ImageDraw, ImageFont, ImageEnhance, ImageOps
+import random
+import json
+
+# ---------------------------------------------------------------------------
+# GLOBALS
+# ---------------------------------------------------------------------------
+
+RESOLUTION      = (1080, 1920)   # W x H
+FPS             = 30
+OUTPUT_PATH     = "renders/sunset_reel.mp4"
+SELECTED_DIR    = "selected"
+FONT_PATH       = "asset/TR Impact.TTF"
+FONT_PATH_REG   = "asset/TR Impact.TTF"
+
+GLOBAL_TEMP      = +8
+GLOBAL_TINT      = -5
+
+TEXT_WHITE  = (255, 255, 255, 255)
+TEXT_STROKE = (0,   0,   0,   210)
+TEXT_SHADOW = (0,   0,   0,   60)
+STROKE_W    = 8
+
+# Easing
+def ease_out(t):      return 1 - (1 - t) ** 3
+def ease_in_out(t):   return t * t * (3 - 2 * t)
+def ease_in(t):       return t * t * t
+def lerp(a, b, t):    return a + (b - a) * t
+
+# ---------------------------------------------------------------------------
+# FAST-PACED SCENE CONFIG - Types of Anger
+# ---------------------------------------------------------------------------
+
+SCENE_CONFIG = [
+    # ── INTRO / HOOK ─────────────────────────────────────────────
+    {
+        "idx": 0, "label": "WHICH TYPE OF\nANGER DO YOU HAVE?",
+        "duration_s": 4.7,
+        "motion":     {"type": "slow_push_in", "scale_start": 1.0, "scale_end": 1.08},
+        "text":       {"type": "center_stroke_pop", "entry_frame": 2, "hold_frames": 125, "font_size": 95, "align": "center"},
+        "grade":      {"crush_blacks": 15, "contrast": 1.15},
+        "transition": {"type": "hard_cut", "frames": 1},
+    },
+    # ── TYPE 1: SHOUTING ─────────────────────────────────────────
+    {
+        "idx": 1, "label": "~SHOUTING",
+        "duration_s": 2.3,
+        "motion":     {"type": "snap_zoom", "scale_start": 1.0, "scale_end": 1.12},
+        "text":       {"type": "center_pop", "entry_frame": 0, "hold_frames": 69, "font_size": 110, "align": "center"},
+        "grade":      {"warm_tint": True, "lift_mids": 10},
+        "transition": {"type": "whip_pan_right", "frames": 4},
+    },
+    # ── TYPE 2: REVENGE ──────────────────────────────────────────
+    {
+        "idx": 2, "label": "~REVENGE",
+        "duration_s": 2.3,
+        "motion":     {"type": "static"},
+        "text":       {"type": "center_fade_pop", "entry_frame": 2, "hold_frames": 66, "font_size": 110, "align": "center"},
+        "grade":      {"desaturate": True, "lift_blacks": 5},
+        "transition": {"type": "whip_pan_right", "frames": 4},
+    },
+    # ── TYPE 3: IGNORING ─────────────────────────────────────────
+    {
+        "idx": 3, "label": "~IGNORING",
+        "duration_s": 2.3,
+        "motion":     {"type": "static"},
+        "text":       {"type": "center_fade_pop", "entry_frame": 2, "hold_frames": 66, "font_size": 110, "align": "center"},
+        "grade":      {"cool_tint": True, "highlights": -15},
+        "transition": {"type": "whip_pan_right", "frames": 4},
+    },
+    # ── TYPE 4: SLAMMING ─────────────────────────────────────────
+    {
+        "idx": 4, "label": "~SLAMMING",
+        "duration_s": 2.3,
+        "motion":     {"type": "static"},
+        "text":       {"type": "center_fade_pop", "entry_frame": 2, "hold_frames": 66, "font_size": 110, "align": "center"},
+        "grade":      {"soft_pink": True, "lift_mids": 15},
+        "transition": {"type": "whip_pan_right", "frames": 4},
+    },
+    # ── TYPE 5: CURSING ──────────────────────────────────────────
+    {
+        "idx": 5, "label": "~CURSING",
+        "duration_s": 2.3,
+        "motion":     {"type": "static"},
+        "text":       {"type": "center_fade_pop", "entry_frame": 2, "hold_frames": 66, "font_size": 110, "align": "center"},
+        "grade":      {"indoor_warm": True, "lift_shadows": 8},
+        "transition": {"type": "whip_pan_right", "frames": 4},
+    },
+    # ── TYPE 6: WALKING AWAY ─────────────────────────────────────
+    {
+        "idx": 6, "label": "~WALKING AWAY",
+        "duration_s": 2.3,
+        "motion":     {"type": "static"},
+        "text":       {"type": "center_fade_pop", "entry_frame": 2, "hold_frames": 66, "font_size": 110, "align": "center"},
+        "grade":      {"teal_orange": True, "crush_blacks": 10},
+        "transition": {"type": "whip_pan_right", "frames": 4},
+    },
+    # ── TYPE 7: FIGHTING ─────────────────────────────────────────
+    {
+        "idx": 7, "label": "~FIGHTING",
+        "duration_s": 2.3,
+        "motion":     {"type": "static"},
+        "text":       {"type": "center_fade_pop", "entry_frame": 2, "hold_frames": 66, "font_size": 110, "align": "center"},
+        "grade":      {"dark_moody": True, "crush_blacks": 20, "desaturate": 15},
+        "transition": {"type": "whip_pan_right", "frames": 4},
+    },
+    # ── TYPE 8: CRYING ───────────────────────────────────────────
+    {
+        "idx": 8, "label": "~CRYING",
+        "duration_s": 2.3,
+        "motion":     {"type": "static"},
+        "text":       {"type": "center_fade_pop", "entry_frame": 2, "hold_frames": 66, "font_size": 110, "align": "center"},
+        "grade":      {"warm_indoor": True, "soft_glow": True, "lift_mids": 12},
+        "transition": {"type": "end_fade_black", "frames": 30},
+    },
+]
+
+
+# ---------------------------------------------------------------------------
+# COLOUR GRADE
+# ---------------------------------------------------------------------------
+
+def grade_image(img: Image.Image, grade: dict) -> Image.Image:
+    r, g, b = img.split()
+
+    # Global warm grade
+    r = r.point(lambda p: min(255, p + int(GLOBAL_TEMP * 1.2)))
+    g = g.point(lambda p: min(255, p + int(GLOBAL_TEMP * 0.35)))
+    b = b.point(lambda p: max(0,   p - int(GLOBAL_TEMP * 0.8)))
+    g = g.point(lambda p: max(0, min(255, p + int(GLOBAL_TINT * 0.5))))
+
+    # Scene-specific
+    if grade.get("boost_reds"):
+        v = grade["boost_reds"]
+        r = r.point(lambda p: min(255, p + v))
+        g = g.point(lambda p: min(255, p + int(v * 0.25)))
+
+    if grade.get("crush_blacks"):
+        v = grade.get("crush_blacks", 10)
+        r = r.point(lambda p: max(0, p - v) if p < 55 else p)
+        g = g.point(lambda p: max(0, p - v) if p < 55 else p)
+        b = b.point(lambda p: max(0, p - v) if p < 55 else p)
+
+    if grade.get("contrast"):
+        v = grade["contrast"]
+        r = r.point(lambda p: int((p - 128) * v + 128))
+        g = g.point(lambda p: int((p - 128) * v + 128))
+        b = b.point(lambda p: int((p - 128) * v + 128))
+
+    if grade.get("lift_shadows"):
+        v = grade.get("lift_shadows", 0)
+        r = r.point(lambda p: min(255, p + v))
+        g = g.point(lambda p: min(255, p + v))
+        b = b.point(lambda p: min(255, p + v))
+
+    if grade.get("warm_tint"):
+        r = r.point(lambda p: min(255, p + 8))
+        g = g.point(lambda p: min(255, p + 3))
+
+    if grade.get("cool_tint"):
+        b = b.point(lambda p: min(255, p + 8))
+        r = r.point(lambda p: max(0, p - 5))
+
+    if grade.get("desaturate"):
+        v = grade.get("desaturate", 10)
+        merged = Image.merge("RGB", (r, g, b))
+        merged = ImageEnhance.Color(merged).enhance(max(0, 1.0 - v/100.0))
+        r, g, b = merged.split()
+
+    if grade.get("lift_blacks"):
+        v = grade["lift_blacks"]
+        r = r.point(lambda p: min(255, p + v))
+        g = g.point(lambda p: min(255, p + v))
+        b = b.point(lambda p: min(255, p + v))
+
+    if grade.get("lift_mids"):
+        v = grade["lift_mids"]
+        r = r.point(lambda p: int(p + v * (1 - abs(p - 128) / 128)))
+        g = g.point(lambda p: int(p + v * (1 - abs(p - 128) / 128)))
+        b = b.point(lambda p: int(p + v * (1 - abs(p - 128) / 128)))
+
+    if grade.get("highlights"):
+        v = abs(grade["highlights"])
+        r = r.point(lambda p: p - int((p / 255) ** 2.2 * v))
+        g = g.point(lambda p: p - int((p / 255) ** 2.2 * v))
+        b = b.point(lambda p: p - int((p / 255) ** 2.2 * v))
+
+    if grade.get("teal_orange"):
+        r = r.point(lambda p: min(255, p + 5))
+        b = b.point(lambda p: max(0, p - 8))
+
+    if grade.get("soft_pink"):
+        r = r.point(lambda p: min(255, p + 10))
+        b = b.point(lambda p: min(255, p + 5))
+
+    if grade.get("indoor_warm"):
+        r = r.point(lambda p: min(255, p + 12))
+        g = g.point(lambda p: min(255, p + 5))
+
+    if grade.get("soft_glow"):
+        merged = Image.merge("RGB", (r, g, b))
+        merged = ImageEnhance.Brightness(merged).enhance(1.05)
+        r, g, b = merged.split()
+
+    if grade.get("dark_moody"):
+        r = r.point(lambda p: max(0, p - 15))
+        g = g.point(lambda p: max(0, p - 15))
+        b = b.point(lambda p: max(0, p - 10))
+
+    img = Image.merge("RGB", (r, g, b))
+    img = ImageEnhance.Brightness(img).enhance(1.02)
+    return img
+
+# ---------------------------------------------------------------------------
+# IMAGE LOAD + CROP-TO-FILL
+# ---------------------------------------------------------------------------
+
+def load_scene_image(idx: int) -> Image.Image:
+    path = os.path.join(SELECTED_DIR, f"scene_{idx:02d}.jpg")
+    img  = Image.open(path).convert("RGB")
+    return crop_to_fill(img, *RESOLUTION)
+
+def crop_to_fill(img: Image.Image, target_w: int, target_h: int) -> Image.Image:
+    iw, ih  = img.size
+    scale   = max(target_w / iw, target_h / ih)
+    new_w   = int(iw * scale)
+    new_h   = int(ih * scale)
+    img     = img.resize((new_w, new_h), Image.Resampling.LANCZOS)
+    left    = (new_w - target_w) // 2
+    top     = (new_h - target_h) // 2
+    return img.crop((left, top, left + target_w, top + target_h))
+
+# ---------------------------------------------------------------------------
+# MOTION - snap_zoom (sharp, punchy zoom effect)
+# ---------------------------------------------------------------------------
+
+def get_motion_frame(base: Image.Image, motion: dict, t: float) -> Image.Image:
+    mtype = motion["type"]
+    w, h  = RESOLUTION
+
+    if mtype == "snap_zoom":
+        s_start = motion["scale_start"]
+        s_end   = motion["scale_end"]
+        scale   = lerp(s_start, s_end, ease_out(t))
+
+        nw = int(w * scale)
+        nh = int(h * scale)
+        scaled = base.resize((nw, nh), Image.Resampling.BILINEAR)
+
+        left = (nw - w) // 2
+        top  = (nh - h) // 2
+        left = max(0, min(left, nw - w))
+        top  = max(0, min(top,  nh - h))
+        return scaled.crop((left, top, left + w, top + h))
+
+    elif mtype == "slow_push_in":
+        s_start = motion.get("scale_start", 1.0)
+        s_end   = motion.get("scale_end", 1.08)
+        scale   = lerp(s_start, s_end, ease_in_out(t))
+
+        nw = int(w * scale)
+        nh = int(h * scale)
+        scaled = base.resize((nw, nh), Image.Resampling.BILINEAR)
+
+        left = (nw - w) // 2
+        top  = (nh - h) // 2
+        left = max(0, min(left, nw - w))
+        top  = max(0, min(top,  nh - h))
+        return scaled.crop((left, top, left + w, top + h))
+
+    else:  # static or others
+        return base
+
+# ---------------------------------------------------------------------------
+# FONT CACHE
+# ---------------------------------------------------------------------------
+
+_font_cache = {}
+
+def get_font(size: int) -> ImageFont.FreeTypeFont:
+    if size not in _font_cache:
+        try:
+            _font_cache[size] = ImageFont.truetype(FONT_PATH, size)
+        except Exception:
+            try:
+                _font_cache[size] = ImageFont.truetype(FONT_PATH_REG, size)
+            except Exception:
+                _font_cache[size] = ImageFont.load_default()
+    return _font_cache[size]
+
+# ---------------------------------------------------------------------------
+# TEXT DRAWING
+# ---------------------------------------------------------------------------
+
+def draw_text_stroked(draw, text, pos, font, align="left", opacity=1.0):
+    """White text with stroke, drop shadow, and opacity."""
+    x, y = pos
+    w, _  = RESOLUTION
+
+    lines = text.split("\n")
+    line_heights = []
+    line_widths  = []
+    for line in lines:
+        bb = draw.textbbox((0, 0), line, font=font)
+        line_widths.append(bb[2] - bb[0])
+        line_heights.append(bb[3] - bb[1])
+
+    line_spacing = int(font.size * 1.25)
+
+    for i, line in enumerate(lines):
+        lw  = line_widths[i]
+        ly  = y + i * line_spacing
+
+        if align == "center":
+            lx = x - lw // 2
+        elif align == "right":
+            lx = x - lw
+        else:
+            lx = x
+
+        alpha_stroke = int(TEXT_STROKE[3] * opacity)
+        alpha_white  = int(TEXT_WHITE[3]  * opacity)
+        alpha_shadow = int(TEXT_SHADOW[3] * opacity)
+
+        stroke_col = TEXT_STROKE[:3] + (alpha_stroke,)
+        white_col  = TEXT_WHITE[:3]  + (alpha_white,)
+        shadow_col = TEXT_SHADOW[:3] + (alpha_shadow,)
+
+        # Drop shadow
+        draw.text((lx + 4, ly + 4), line, font=font, fill=shadow_col)
+
+        # Stroke layers
+        for sw in [STROKE_W, STROKE_W - 2, STROKE_W - 4, 2]:
+            for ax in range(-sw, sw + 1, max(1, sw // 3)):
+                for ay in range(-sw, sw + 1, max(1, sw // 3)):
+                    if ax * ax + ay * ay <= sw * sw:
+                        draw.text((lx + ax, ly + ay), line, font=font, fill=stroke_col)
+
+        # White fill
+        draw.text((lx, ly), line, font=font, fill=white_col)
+
+# ---------------------------------------------------------------------------
+# TEXT ANIMATIONS - quick_center_pop
+# ---------------------------------------------------------------------------
+
+def render_text_frame(cfg: dict, frame: int, total_frames: int) -> Image.Image:
+    tcfg  = cfg["text"]
+    ttype = tcfg["type"]
+    label = cfg["label"]
+    w, h  = RESOLUTION
+
+    layer = Image.new("RGBA", (w, h), (0, 0, 0, 0))
+    draw  = ImageDraw.Draw(layer)
+    font  = get_font(tcfg["font_size"])
+
+    if ttype == "quick_center_pop" or ttype == "center_stroke_pop":
+        entry_f = tcfg["entry_frame"]
+        hold_f  = tcfg["hold_frames"]
+        fade_start = entry_f + hold_f
+
+        if frame < entry_f:
+            pass
+        elif frame < entry_f + 6:  # 0.2s pop-in
+            progress = ease_out((frame - entry_f) / 6)
+            opacity  = min(1.0, progress * 1.5)
+            x = w // 2
+            y = h // 2
+            draw_text_stroked(draw, label, (x, y), font, align="center", opacity=opacity)
+        elif frame < fade_start:
+            # Hold full opacity
+            x = w // 2
+            y = h // 2
+            draw_text_stroked(draw, label, (x, y), font, align="center", opacity=1.0)
+        else:
+            # Fade out quickly
+            fade_progress = min(1.0, (frame - fade_start) / 4)
+            opacity = 1.0 - fade_progress
+            x = w // 2
+            y = h // 2
+            draw_text_stroked(draw, label, (x, y), font, align="center", opacity=opacity)
+
+    elif ttype == "center_pop" or ttype == "center_fade_pop":
+        entry_f = tcfg["entry_frame"]
+        hold_f  = tcfg["hold_frames"]
+        fade_start = entry_f + hold_f
+
+        if frame < entry_f:
+            pass
+        elif frame < entry_f + 6:
+            progress = ease_out((frame - entry_f) / 6)
+            opacity  = min(1.0, progress * 1.5)
+            x = w // 2
+            y = h // 2
+            draw_text_stroked(draw, label, (x, y), font, align="center", opacity=opacity)
+        elif frame < fade_start:
+            x = w // 2
+            y = h // 2
+            draw_text_stroked(draw, label, (x, y), font, align="center", opacity=1.0)
+        else:
+            fade_progress = min(1.0, (frame - fade_start) / 4)
+            opacity = 1.0 - fade_progress
+            x = w // 2
+            y = h // 2
+            draw_text_stroked(draw, label, (x, y), font, align="center", opacity=opacity)
+
+    return layer
+
+# ---------------------------------------------------------------------------
+# TRANSITION - hard_cut only
+# ---------------------------------------------------------------------------
+
+def apply_transition(frame_a: Image.Image, frame_b: Image.Image, ttype: str, progress: float) -> Image.Image:
+    """Apply dynamic transition between frames."""
+    w, h = RESOLUTION
+    
+    if ttype == "whip_pan_right":
+        # Slide frame_b in from left with motion blur effect
+        offset = int(w * (1 - ease_out(progress)))
+        result = Image.new("RGB", (w, h))
+        result.paste(frame_a, (0, 0))
+        result.paste(frame_b, (offset, 0))
+        return result
+    
+    elif ttype == "flash":
+        if progress < 0.3:
+            flash_intensity = (progress / 0.3) * 0.5
+            brightened = ImageEnhance.Brightness(frame_a).enhance(1.0 + flash_intensity)
+            alpha = min(0.5, progress / 0.3 * 0.5)
+            return Image.blend(brightened, frame_b, alpha)
+        else:
+            blend_t = (progress - 0.3) / 0.7
+            return Image.blend(frame_a, frame_b, blend_t)
+    
+    elif ttype == "end_fade_black":
+        # Fade to black
+        black = Image.new("RGB", (w, h), (0, 0, 0))
+        return Image.blend(frame_a, black, progress)
+    
+    else:  # Default to hard cut
+        return frame_b if progress >= 0.5 else frame_a
+
+# ---------------------------------------------------------------------------
+# MAIN RENDER
+# ---------------------------------------------------------------------------
+
+def render():
+    global SCENE_CONFIG
+    
+    # Load SCENE_CONFIG from JSON if provided via environment variable
+    config_path = os.environ.get("COMPOSER_MANIFEST_CONFIG")
+    if config_path and os.path.exists(config_path):
+        print(f"\n[INFO] Loading config from: {config_path}")
+        with open(config_path, "r") as f:
+            manifest_data = json.load(f)
+            SCENE_CONFIG = manifest_data.get("scenes", SCENE_CONFIG)
+        print(f"[INFO] Loaded {len(SCENE_CONFIG)} scenes from manifest")
+    
+    w, h = RESOLUTION
+    Path(os.path.dirname(OUTPUT_PATH)).mkdir(parents=True, exist_ok=True)
+
+    tmp_path = OUTPUT_PATH.replace(".mp4", "_raw.mp4")
+    writer   = cv2.VideoWriter(
+        tmp_path,
+        cv2.VideoWriter_fourcc(*"mp4v"),
+        FPS,
+        (w, h),
+    )
+
+    print(f"\n{'='*55}")
+    print(f"  Sunset Reel (Fast-Paced)")
+    print(f"  {len(SCENE_CONFIG)} scenes | {FPS}fps | {w}x{h}")
+    print(f"{'='*55}\n")
+
+    # Preload and grade all base images
+    print("[1/3] Loading + grading images...")
+    base_images = []
+    for cfg in SCENE_CONFIG:
+        raw  = load_scene_image(cfg["idx"])
+        graded = grade_image(raw, cfg["grade"])
+        base_images.append(graded)
+    print("    [OK] Done\n")
+
+    # Render scenes
+    print("[2/3] Rendering frames...")
+    total_scenes   = len(SCENE_CONFIG)
+    frames_written = 0
+
+    for scene_i, cfg in enumerate(SCENE_CONFIG):
+        total_frames = int(cfg["duration_s"] * FPS)
+        trans_cfg    = cfg["transition"]
+        trans_frames = trans_cfg["frames"]
+        base         = base_images[scene_i]
+
+        # Preload next scene base for transitions
+        if scene_i + 1 < total_scenes:
+            next_cfg   = SCENE_CONFIG[scene_i + 1]
+            next_base  = base_images[scene_i + 1]
+        else:
+            next_cfg   = None
+            next_base  = None
+
+        print(f"  Scene {cfg['idx']:02d} -- {cfg['label'].replace(chr(10),' ')} ({total_frames}f, {cfg['duration_s']}s)")
+
+        for frame in range(total_frames):
+            # Motion frame
+            t_motion = frame / max(total_frames - 1, 1)
+            img      = get_motion_frame(base, cfg["motion"], t_motion)
+
+            # Text layer
+            text_layer = render_text_frame(cfg, frame, total_frames)
+            img_rgba   = img.convert("RGBA")
+            img_rgba   = Image.alpha_composite(img_rgba, text_layer)
+            img        = img_rgba.convert("RGB")
+
+            # Transition blend at end of scene
+            frames_into_trans = frame - (total_frames - trans_frames)
+            if frames_into_trans >= 0 and next_base is not None:
+                trans_t     = frames_into_trans / max(trans_frames - 1, 1)
+                t_next      = 0.0
+                next_motion = get_motion_frame(next_base, next_cfg["motion"], t_next)
+                img = apply_transition(img, next_motion, trans_cfg["type"], trans_t)
+
+            # Write frame (cv2 expects BGR)
+            arr = np.array(img)
+            writer.write(cv2.cvtColor(arr, cv2.COLOR_RGB2BGR))
+            frames_written += 1
+
+        print(f"    [OK] {total_frames} frames")
+
+    # Hard cut to black at end
+    print(f"\n  Hard cut to black")
+    black_frame = np.zeros((h, w, 3), dtype=np.uint8)
+    for _ in range(2):  # 2 frames of black
+        writer.write(black_frame)
+        frames_written += 1
+    print(f"    [OK] 2 frames")
+
+    writer.release()
+    print(f"\n  Total frames written: {frames_written} (~{frames_written/FPS:.1f}s)\n")
+
+    # Re-encode with ffmpeg
+    print("[3/3] Encoding H.264 MP4 via ffmpeg...")
+    cmd = (
+        f"ffmpeg -y -i {tmp_path} "
+        f"-vcodec libx264 -crf 20 -preset fast "
+        f"-pix_fmt yuv420p "
+        f"-movflags +faststart "
+        f"{OUTPUT_PATH} 2>&1"
+    )
+    ret = os.system(cmd)
+    if ret == 0:
+        os.remove(tmp_path)
+        size_mb = os.path.getsize(OUTPUT_PATH) / (1024 * 1024)
+        print(f"\n  [OK] Output: {OUTPUT_PATH}")
+        print(f"  [OK] Size  : {size_mb:.1f} MB")
+    else:
+        print(f"  [ERROR] ffmpeg failed (code {ret}). Raw file kept: {tmp_path}")
+
+    print(f"\n{'='*55}\n")
+
+
+if __name__ == "__main__":
+    render()

requirements_server.txt

@@ -0,0 +1,8 @@
+fastapi==0.104.1
+uvicorn==0.24.0
+pydantic==2.5.0
+requests==2.31.0
+python-multipart==0.0.6
+pillow==10.1.0
+opencv-python==4.8.1.78
+numpy==1.24.3

select_scenes.py

@@ -0,0 +1,107 @@
+"""
+Scene Image Selector - Randomly selects candidate images for each scene
+Saves selections to a folder before composition
+"""
+import os
+import json
+import random
+import shutil
+from pathlib import Path
+
+
+class SceneSelector:
+    def __init__(self, manifest_path, candidates_dir, output_dir="selected"):
+        """
+        Initialize the scene selector.
+        
+        Args:
+            manifest_path: Path to manifest_response.json
+            candidates_dir: Path to candidates folder with scene_0-6 subfolders
+            output_dir: Where to save selected images
+        """
+        self.manifest_path = manifest_path
+        self.candidates_dir = candidates_dir
+        self.output_dir = output_dir
+        self.selections = {}
+        
+        # Create output directory
+        Path(self.output_dir).mkdir(parents=True, exist_ok=True)
+        
+        # Load manifest
+        with open(manifest_path, 'r') as f:
+            self.manifest = json.load(f)
+        
+        print(f"[Selector] Initialized with {len(self.manifest.get('scenes', []))} scenes")
+        print(f"[Selector] Candidates dir: {candidates_dir}")
+        print(f"[Selector] Output dir: {output_dir}\n")
+
+    def select_all_scenes(self):
+        """Randomly select one image per scene."""
+        scenes = self.manifest.get("scenes", [])
+        print(f"[Selector] Selecting images for {len(scenes)} scenes...\n")
+        
+        for scene_idx, scene in enumerate(scenes):
+            self._select_scene(scene_idx, scene)
+        
+        # Save selections metadata
+        self._save_selections_metadata()
+        
+        print(f"\n[Selector] ✓ Selected {len(scenes)} images!")
+        print(f"[Selector] Check {self.output_dir}/ for selected images")
+        print(f"[Selector] Check {self.output_dir}/selections.json for metadata")
+
+    def _select_scene(self, scene_idx, scene):
+        """Randomly select one image for a scene."""
+        scene_label = scene.get("label", f"Scene {scene_idx}")
+        candidates_folder = os.path.join(self.candidates_dir, f"scene_{scene_idx}")
+        
+        # Get list of candidate images
+        if not os.path.exists(candidates_folder):
+            print(f"[Scene {scene_idx}] ✗ Folder not found: {candidates_folder}")
+            return
+        
+        candidates = [f for f in os.listdir(candidates_folder) if f.endswith(('.jpg', '.png'))]
+        if not candidates:
+            print(f"[Scene {scene_idx}] ✗ No images found in {candidates_folder}")
+            return
+        
+        # Randomly select one image
+        selected_image = random.choice(candidates)
+        source_path = os.path.join(candidates_folder, selected_image)
+        
+        # Copy to output folder
+        output_filename = f"scene_{scene_idx:02d}.jpg"
+        dest_path = os.path.join(self.output_dir, output_filename)
+        shutil.copy2(source_path, dest_path)
+        
+        # Store selection metadata
+        self.selections[scene_idx] = {
+            "scene_label": scene_label,
+            "original_file": selected_image,
+            "source_folder": candidates_folder,
+            "total_candidates": len(candidates),
+            "output_file": output_filename
+        }
+        
+        print(f"[Scene {scene_idx}] {scene_label}")
+        print(f"  Available: {len(candidates)} candidates")
+        print(f"  Selected: {selected_image}")
+        print(f"  Copied to: {output_filename}\n")
+
+    def _save_selections_metadata(self):
+        """Save metadata about which images were selected."""
+        metadata_path = os.path.join(self.output_dir, "selections.json")
+        with open(metadata_path, 'w') as f:
+            json.dump(self.selections, f, indent=2)
+        print(f"[Selector] Saved selections metadata to {metadata_path}")
+
+
+if __name__ == "__main__":
+    # Load manifest from content_gen_server
+    manifest_file = "../content_gen_server/manifest_response.json"
+    candidates_dir = "../workspace/renders/candidates"
+    output_dir = "selected"
+    
+    # Create and run selector
+    selector = SceneSelector(manifest_file, candidates_dir, output_dir)
+    selector.select_all_scenes()

server.py

@@ -0,0 +1,425 @@
+"""
+FastAPI Server for Scene Selection and Video Composition
+Dynamically generates video from manifest without hardcoded labels
+"""
+
+from fastapi import FastAPI, HTTPException, File, UploadFile, Form
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+from typing import List, Dict, Any, Optional
+import os
+import json
+import shutil
+from pathlib import Path
+import subprocess
+import sys
+
+# ─────────────────────────────────────────────────────────────────────────
+# Pydantic Models
+# ─────────────────────────────────────────────────────────────────────────
+
+class SceneRequest(BaseModel):
+    """Scene metadata from manifest"""
+    label: str
+    image_query: str
+
+
+class ManifestRequest(BaseModel):
+    """Manifest JSON format from client"""
+    title: str
+    scenes: List[SceneRequest]
+
+
+class VideoResponse(BaseModel):
+    """Response after video generation"""
+    status: str
+    message: str
+    output_path: Optional[str] = None
+    size_mb: Optional[float] = None
+    duration_s: Optional[float] = None
+
+
+# ─────────────────────────────────────────────────────────────────────────
+# FastAPI App
+# ─────────────────────────────────────────────────────────────────────────
+
+app = FastAPI(
+    title="TrendClip Video Composer",
+    description="Dynamic video composition from manifest without hardcoded configs",
+    version="2.0"
+)
+
+BASE_DIR = Path(__file__).parent
+CANDIDATES_DIR = BASE_DIR / "candidates"
+SELECTED_DIR = BASE_DIR / "selected"
+RENDERS_DIR = BASE_DIR / "renders"
+
+# Ensure directories exist
+CANDIDATES_DIR.mkdir(exist_ok=True)
+SELECTED_DIR.mkdir(exist_ok=True)
+RENDERS_DIR.mkdir(exist_ok=True)
+
+
+# ─────────────────────────────────────────────────────────────────────────
+# Scene Configuration Generation
+# ─────────────────────────────────────────────────────────────────────────
+
+# Intro scene config (4.7s, 95pt font)
+INTRO_CONFIG = {
+    "duration_s": 4.7,
+    "motion": {"type": "slow_push_in", "scale_start": 1.0, "scale_end": 1.08},
+    "text": {"type": "center_stroke_pop", "entry_frame": 2, "hold_frames": 125, "font_size": 95, "align": "center"},
+    "grade": {"crush_blacks": 15, "contrast": 1.15},
+    "transition": {"type": "hard_cut", "frames": 1},
+}
+
+# Scene templates for subsequent scenes (2.3s, 110pt font)
+SCENES_TEMPLATES = [
+    {
+        "duration_s": 2.3,
+        "motion": {"type": "snap_zoom", "scale_start": 1.0, "scale_end": 1.12},
+        "text": {"type": "center_pop", "entry_frame": 0, "hold_frames": 69, "font_size": 110, "align": "center"},
+        "grade": {"warm_tint": True, "lift_mids": 10},
+        "transition": {"type": "whip_pan_right", "frames": 4},
+    },
+    {
+        "duration_s": 2.3,
+        "motion": {"type": "static"},
+        "text": {"type": "center_fade_pop", "entry_frame": 2, "hold_frames": 66, "font_size": 110, "align": "center"},
+        "grade": {"desaturate": True, "lift_blacks": 5},
+        "transition": {"type": "whip_pan_right", "frames": 4},
+    },
+    {
+        "duration_s": 2.3,
+        "motion": {"type": "static"},
+        "text": {"type": "center_fade_pop", "entry_frame": 2, "hold_frames": 66, "font_size": 110, "align": "center"},
+        "grade": {"cool_tint": True, "highlights": -15},
+        "transition": {"type": "whip_pan_right", "frames": 4},
+    },
+    {
+        "duration_s": 2.3,
+        "motion": {"type": "static"},
+        "text": {"type": "center_fade_pop", "entry_frame": 2, "hold_frames": 66, "font_size": 110, "align": "center"},
+        "grade": {"soft_pink": True, "lift_mids": 15},
+        "transition": {"type": "whip_pan_right", "frames": 4},
+    },
+    {
+        "duration_s": 2.3,
+        "motion": {"type": "static"},
+        "text": {"type": "center_fade_pop", "entry_frame": 2, "hold_frames": 66, "font_size": 110, "align": "center"},
+        "grade": {"indoor_warm": True, "lift_shadows": 8},
+        "transition": {"type": "whip_pan_right", "frames": 4},
+    },
+    {
+        "duration_s": 2.3,
+        "motion": {"type": "static"},
+        "text": {"type": "center_fade_pop", "entry_frame": 2, "hold_frames": 66, "font_size": 110, "align": "center"},
+        "grade": {"teal_orange": True, "crush_blacks": 10},
+        "transition": {"type": "whip_pan_right", "frames": 4},
+    },
+    {
+        "duration_s": 2.3,
+        "motion": {"type": "static"},
+        "text": {"type": "center_fade_pop", "entry_frame": 2, "hold_frames": 66, "font_size": 110, "align": "center"},
+        "grade": {"dark_moody": True, "crush_blacks": 20, "desaturate": 15},
+        "transition": {"type": "whip_pan_right", "frames": 4},
+    },
+    {
+        "duration_s": 2.3,
+        "motion": {"type": "static"},
+        "text": {"type": "center_fade_pop", "entry_frame": 2, "hold_frames": 66, "font_size": 110, "align": "center"},
+        "grade": {"warm_indoor": True, "soft_glow": True, "lift_mids": 12},
+        "transition": {"type": "end_fade_black", "frames": 30},
+    },
+]
+
+
+def generate_scene_config(manifest: ManifestRequest) -> list:
+    """Generate SCENE_CONFIG from manifest, extracting and uppercasing labels."""
+    config = []
+    
+    for idx, scene in enumerate(manifest.scenes):
+        # Extract label and convert to UPPERCASE for captions
+        label = scene.label.upper()
+        
+        scene_cfg = {
+            "idx": idx,
+            "label": label,
+        }
+        
+        if idx == 0:
+            # First scene is intro
+            scene_cfg.update(INTRO_CONFIG)
+        else:
+            # Use templated config for subsequent scenes
+            template_idx = min(idx - 1, len(SCENES_TEMPLATES) - 1)
+            scene_cfg.update(SCENES_TEMPLATES[template_idx])
+        
+        config.append(scene_cfg)
+    
+    return config
+# ─────────────────────────────────────────────────────────────────────────
+# Endpoints
+# ─────────────────────────────────────────────────────────────────────────
+
+# ─────────────────────────────────────────────────────────────────────────
+# Endpoints
+# ─────────────────────────────────────────────────────────────────────────
+
+@app.post("/generate-video")
+async def generate_video(
+    manifest: str = Form(...),
+    files: List[UploadFile] = File(...)
+):
+    """
+    Full pipeline: Upload candidates + manifest, get MP4 back.
+    
+    Form parameters:
+    - manifest: JSON string with title and scenes
+    - files: Uploaded image files for each scene
+    
+    Returns: MP4 video file
+    """
+    try:
+        # Parse manifest
+        manifest_data = json.loads(manifest)
+        manifest_req = ManifestRequest(**manifest_data)
+        
+        # Step 1: Clean and prepare upload directory
+        upload_dir = BASE_DIR / "upload_candidates"
+        if upload_dir.exists():
+            shutil.rmtree(upload_dir)
+        upload_dir.mkdir(exist_ok=True)
+        
+        # Step 2: Save uploaded files organized by scene index
+        uploaded_count = 0
+        for file in files:
+            if file.filename:
+                # Save to upload_candidates folder
+                file_path = upload_dir / file.filename
+                with open(file_path, "wb") as f:
+                    f.write(await file.read())
+                uploaded_count += 1
+        
+        if uploaded_count != len(manifest_req.scenes):
+            raise Exception(
+                f"Expected {len(manifest_req.scenes)} files, received {uploaded_count}"
+            )
+        
+        # Step 3: Select scenes (evaluate and copy to selected/)
+        select_result = await _select_scenes(manifest_req, upload_dir)
+        if select_result["status"] != "success":
+            raise Exception(select_result.get("message", "Scene selection failed"))
+        
+        # Step 4: Compose video with manifest data
+        compose_result = await _compose(manifest_req)
+        if compose_result["status"] != "success":
+            raise Exception(compose_result.get("message", "Composition failed"))
+        
+        # Step 5: Return the MP4 file
+        output_file = Path(compose_result["output_path"])
+        if not output_file.exists():
+            raise Exception("Output file not found")
+        
+        return FileResponse(
+            path=output_file,
+            media_type="video/mp4",
+            filename="video.mp4"
+        )
+    
+    except json.JSONDecodeError as e:
+        raise HTTPException(status_code=400, detail=f"Invalid manifest JSON: {str(e)}")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/select-scenes")
+async def select_scenes(manifest: ManifestRequest):
+    """
+    Endpoint for just scene selection (without upload).
+    Assumes candidates are already in candidates/ folder.
+    """
+    try:
+        result = await _select_scenes(manifest, CANDIDATES_DIR)
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/compose")
+async def compose(manifest: ManifestRequest):
+    """
+    Endpoint for just composition.
+    Assumes selected images are already in selected/ folder.
+    """
+    try:
+        result = await _compose(manifest)
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+async def _select_scenes(manifest: ManifestRequest, source_dir: Path):
+    """
+    Internal: Select scenes from source directory.
+    Copies best image from each scene folder to selected/ folder.
+    """
+    try:
+        # Clean and recreate selected directory
+        if SELECTED_DIR.exists():
+            shutil.rmtree(SELECTED_DIR)
+        SELECTED_DIR.mkdir(exist_ok=True)
+        
+        selected_count = 0
+        
+        # For each scene, find and copy its image
+        for i, scene in enumerate(manifest.scenes):
+            # Try multiple naming conventions
+            scene_folder = None
+            for pattern in [f"scene_{i}", f"scene_{i:02d}", f"{i}", f"scene{i}"]:
+                potential = source_dir / pattern
+                if potential.exists():
+                    scene_folder = potential
+                    break
+            
+            # If no folder, look for files named with scene index
+            if scene_folder is None:
+                images = list(source_dir.glob(f"*scene*{i}*")) + list(
+                    source_dir.glob(f"{i:02d}*")
+                )
+                if images:
+                    dest = SELECTED_DIR / f"scene_{i:02d}.jpg"
+                    shutil.copy2(images[0], dest)
+                    selected_count += 1
+                    continue
+            
+            # If folder found, get best image
+            if scene_folder and scene_folder.is_dir():
+                images = sorted(
+                    list(scene_folder.glob("*.jpg")) + list(scene_folder.glob("*.png")),
+                    key=lambda p: p.stat().st_size,
+                    reverse=True
+                )
+                if images:
+                    dest = SELECTED_DIR / f"scene_{i:02d}.jpg"
+                    shutil.copy2(images[0], dest)
+                    selected_count += 1
+        
+        if selected_count == 0:
+            raise Exception(
+                f"No images found in {source_dir}. "
+                "Expected scene_0/, scene_1/, etc. folders or numbered files."
+            )
+        
+        return {
+            "status": "success",
+            "message": f"Selected {selected_count}/{len(manifest.scenes)} scenes",
+            "selected_count": selected_count,
+            "selected_dir": str(SELECTED_DIR),
+        }
+    except Exception as e:
+        return {
+            "status": "error",
+            "message": str(e),
+        }
+
+
+async def _compose(manifest: ManifestRequest):
+    """
+    Internal: Compose video from manifest and selected images.
+    """
+    try:
+        # Verify selected directory has images
+        selected_images = sorted(SELECTED_DIR.glob("scene_*.jpg"))
+        if len(selected_images) != len(manifest.scenes):
+            raise Exception(
+                f"Expected {len(manifest.scenes)} selected images, found {len(selected_images)}"
+            )
+        
+        # Generate dynamic SCENE_CONFIG from manifest
+        scene_config = generate_scene_config(manifest)
+        
+        # Save config as JSON for composer to use
+        config_json = {
+            "title": manifest.title,
+            "scenes": scene_config,
+        }
+        config_path = BASE_DIR / "manifest_config.json"
+        with open(config_path, "w") as f:
+            json.dump(config_json, f, indent=2)
+        
+        # Call composer_v2.py with the config
+        env = os.environ.copy()
+        env["COMPOSER_MANIFEST_CONFIG"] = str(config_path)
+        env["PYTHONIOENCODING"] = "utf-8"
+        
+        result = subprocess.run(
+            [sys.executable, str(BASE_DIR / "composer_v2.py")],
+            cwd=str(BASE_DIR),
+            env=env,
+            capture_output=True,
+            text=True,
+        )
+        
+        # Filter out numpy warnings from stderr
+        error_msg = result.stderr or result.stdout
+        if error_msg:
+            lines = error_msg.split("\n")
+            # Filter out numpy and importlib warnings
+            errors = [
+                line for line in lines
+                if line.strip() and not any(
+                    skip in line for skip in [
+                        "numpy",
+                        "Numpy",
+                        "MINGW-W64",
+                        "CRASHES ARE TO BE EXPECTED",
+                        "RuntimeWarning",
+                        "importlib",
+                        "getlimits",
+                        "nextafter",
+                        "ld(",
+                        "exp2",
+                        "log10",
+                    ]
+                )
+            ]
+            if errors and result.returncode != 0:
+                error_summary = "\n".join(errors[-5:])  # Last 5 meaningful lines
+                raise Exception(f"Composer failed: {error_summary}")
+        
+        # Verify output file exists
+        output_file = RENDERS_DIR / "sunset_reel.mp4"
+        if not output_file.exists():
+            raise Exception("Output video file not created")
+        
+        size_mb = output_file.stat().st_size / (1024 * 1024)
+        duration_s = len(scene_config) * 2.3 + 2.4  # Approximate
+        
+        return {
+            "status": "success",
+            "message": "Video composed successfully",
+            "output_path": str(output_file),
+            "size_mb": round(size_mb, 1),
+            "duration_s": round(duration_s, 1),
+        }
+    except Exception as e:
+        return {
+            "status": "error",
+            "message": str(e),
+        }
+
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "service": "TrendClip Video Composer",
+        "version": "2.0",
+    }
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)