@remixmate/cli 0.1.0

package/skills/template-bind/video_dsl/runtime/prompt_enhancer.py

@@ -0,0 +1,274 @@
+"""
+图片 Prompt 增强模块 — 利用旁白语义 + 模版视觉指南生成高质量图片提示词。
+
+纯函数模块，无外部依赖。主要入口:
+  - build_enhanced_prompt()  : 根据 purpose/topic/style/narration/styleGuide 构建增强 prompt
+  - enrich_asset_payload()   : 一站式入口，自动判断并增强 asset payload
+"""
+
+import re
+from typing import Optional
+
+# ---------------------------------------------------------------------------
+# 常量
+# ---------------------------------------------------------------------------
+
+# 口语化填充词 / 无视觉意义的片段
+_FILLER_PATTERNS = re.compile(
+    r"(那么|其实|所以说|然后呢|接下来|大家好|你好|对吧|对不对|是不是|"
+    r"嗯|啊|呢|吧|哦|哈|了|的话|来说|而言|就是说|换句话说|"
+    r"如果觉得有用就|点个关注|下期见|别忘了)"
+)
+
+# 标点符号归一化
+_PUNCT = re.compile("[，。！？、；：\u201c\u201d\u2018\u2019《》【】（）\\s]+")
+
+# 默认按 purpose 的 prompt 模板（无模版 styleGuide 时的兜底）
+DEFAULT_PURPOSE_PATTERNS: dict[str, str] = {
+    "opening": "{narration_summary}，{topic}主题概念图，视觉冲击力强，{style_suffix}，高清大图",
+    "intro": "{narration_summary}，{topic}主题引入场景，{style_suffix}，清晰直观",
+    "point": "{narration_summary}，{style_suffix}，聚焦核心概念的场景插画，清晰直观",
+    "example": "{narration_summary}，{style_suffix}，具体案例示意图，写实与图解结合",
+    "explanation": "{narration_summary}，{style_suffix}，解释性图示，信息图表风格",
+    "highlight": "{narration_summary}，{style_suffix}，重点概念高亮，视觉聚焦",
+    "transition": "{topic}相关过渡画面，{style_suffix}，简洁流畅",
+    "cta": "关注点赞互动图标，{style_suffix}，简洁现代设计，明亮醒目",
+    "ending": "感谢观看结尾画面，{style_suffix}，温馨大气",
+}
+
+# prompt 长度阈值：超过此字符数的 prompt 视为已精心编写
+WELL_CRAFTED_THRESHOLD = 80
+
+# ---------------------------------------------------------------------------
+# 工具函数
+# ---------------------------------------------------------------------------
+
+
+def summarize_narration(text: str, max_chars: int = 60) -> str:
+    """从旁白文本提取视觉关键信息，去除口语化填充词。
+
+    >>> summarize_narration("那么接下来我们来看一下AI如何帮你高效背单词")
+    'AI如何帮你高效背单词'
+    """
+    if not text:
+        return ""
+    # 去除填充词
+    cleaned = _FILLER_PATTERNS.sub("", text)
+    # 归一化标点 → 空格
+    cleaned = _PUNCT.sub(" ", cleaned).strip()
+    # 去除开头尾部空白
+    if not cleaned:
+        return text[:max_chars]
+    # 截断到 max_chars
+    if len(cleaned) > max_chars:
+        cleaned = cleaned[:max_chars]
+    return cleaned
+
+
+def extract_scene_context(scene: dict) -> dict:
+    """从 DSL scene 提取视觉相关上下文。
+
+    Returns:
+        dict with keys: narration_text, title, badge, purpose
+    """
+    purpose = scene.get("purpose", "default")
+    narration_text = ""
+    audio = scene.get("audio", {})
+    narration = audio.get("narration", {})
+    if isinstance(narration, dict):
+        narration_text = narration.get("text", "")
+
+    title = ""
+    badge = ""
+    for layer in scene.get("textLayers", []):
+        role = layer.get("role", "")
+        if role == "title" and not title:
+            title = layer.get("content", "")
+        elif role == "badge" and not badge:
+            badge = layer.get("content", "")
+
+    return {
+        "narration_text": narration_text,
+        "title": title,
+        "badge": badge,
+        "purpose": purpose,
+    }
+
+
+def resolve_style_guide(template: Optional[dict], variant_id: str = "") -> dict:
+    """合并模版根级 + 变体级的 imageStyleGuide。
+
+    变体级字段覆盖根级同名字段，purposeOverrides 做 merge。
+    """
+    if not template:
+        return {}
+
+    base = dict(template.get("imageStyleGuide", {}) or {})
+    if not variant_id:
+        return base
+
+    variant = (template.get("variants", {}) or {}).get(variant_id, {})
+    variant_guide = dict(variant.get("imageStyleGuide", {}) or {})
+    if not variant_guide:
+        return base
+
+    # 合并 purposeOverrides
+    base_overrides = dict(base.get("purposeOverrides", {}) or {})
+    variant_overrides = dict(variant_guide.get("purposeOverrides", {}) or {})
+
+    merged = {**base, **variant_guide}
+    if base_overrides or variant_overrides:
+        merged_po = {**base_overrides, **variant_overrides}
+        merged["purposeOverrides"] = merged_po
+
+    return merged
+
+
+# ---------------------------------------------------------------------------
+# 核心构建函数
+# ---------------------------------------------------------------------------
+
+
+def build_enhanced_prompt(
+    purpose: str,
+    topic: str,
+    style: str = "",
+    narration_text: str = "",
+    scene_title: str = "",
+    style_guide: Optional[dict] = None,
+) -> dict:
+    """构建增强 prompt，返回 {prompt, negative_prompt, guidance_scale}。
+
+    优先使用 style_guide 中的模板和修饰符；无 style_guide 时使用内置默认模板。
+    """
+    style_guide = style_guide or {}
+    style_suffix = f"{style}风格" if style else ""
+
+    # 提取旁白摘要
+    narration_summary = summarize_narration(narration_text)
+    if not narration_summary and scene_title:
+        narration_summary = scene_title
+    if not narration_summary:
+        narration_summary = topic or ""
+
+    # 基础变量
+    vars_ = {
+        "narration_summary": narration_summary,
+        "topic": topic or "",
+        "style_suffix": style_suffix,
+        "scene_title": scene_title or "",
+    }
+
+    # 决定 prompt 模板
+    purpose_overrides = style_guide.get("purposeOverrides", {}) or {}
+    override = purpose_overrides.get(purpose, {})
+
+    prompt_template = override.get("promptTemplate", "")
+    if not prompt_template:
+        prompt_template = DEFAULT_PURPOSE_PATTERNS.get(
+            purpose, DEFAULT_PURPOSE_PATTERNS.get("point", "")
+        )
+
+    # 格式化模板（安全替换）
+    prompt = _safe_format(prompt_template, vars_)
+
+    # 追加 styleModifier
+    style_modifier = override.get("styleModifier", "")
+    if style_modifier:
+        prompt = f"{prompt}，{style_modifier}"
+
+    # 追加 baseStyle
+    base_style = style_guide.get("baseStyle", "")
+    if base_style:
+        prompt = f"{prompt}，{base_style}"
+
+    # 追加 colorDirective
+    color_directive = style_guide.get("colorDirective", "")
+    if color_directive:
+        prompt = f"{prompt}，{color_directive}"
+
+    # negative prompt
+    negative_prompt = override.get("negativePrompt", "") or style_guide.get("negativePrompt", "")
+
+    # guidance scale
+    guidance_scale = style_guide.get("guidanceScale")
+
+    result = {"prompt": prompt}
+    if negative_prompt:
+        result["negativePrompt"] = negative_prompt
+    if guidance_scale is not None:
+        result["guidanceScale"] = guidance_scale
+
+    return result
+
+
+def _safe_format(template: str, vars_: dict) -> str:
+    """安全的字符串格式化，缺失变量保留占位符原文。"""
+    try:
+        return template.format(**vars_)
+    except (KeyError, IndexError):
+        result = template
+        for k, v in vars_.items():
+            result = result.replace("{" + k + "}", v)
+        return result
+
+
+# ---------------------------------------------------------------------------
+# 一站式入口
+# ---------------------------------------------------------------------------
+
+
+def enrich_asset_payload(
+    payload: dict,
+    scene: Optional[dict] = None,
+    template: Optional[dict] = None,
+    dsl_meta: Optional[dict] = None,
+    variant_id: str = "",
+) -> dict:
+    """增强 asset payload 中的图片 prompt。
+
+    - prompt 已超过 WELL_CRAFTED_THRESHOLD 字符的，仅补充 negativePrompt（如缺失）
+    - 否则用 build_enhanced_prompt 重新构建
+
+    Returns:
+        新的 payload dict（不修改原始对象）
+    """
+    payload = dict(payload)
+    current_prompt = payload.get("prompt", "")
+
+    meta = dsl_meta or {}
+    topic = meta.get("topic", meta.get("title", ""))
+    style = meta.get("style", "")
+
+    style_guide = resolve_style_guide(template, variant_id)
+
+    # 已精心编写的 prompt → 仅补充 negativePrompt
+    if len(current_prompt) > WELL_CRAFTED_THRESHOLD:
+        if "negativePrompt" not in payload and style_guide.get("negativePrompt"):
+            payload["negativePrompt"] = style_guide["negativePrompt"]
+        if "guidanceScale" not in payload and style_guide.get("guidanceScale") is not None:
+            payload["guidanceScale"] = style_guide["guidanceScale"]
+        return payload
+
+    # 从 scene 提取上下文
+    scene_ctx = extract_scene_context(scene) if scene else {}
+    purpose = scene_ctx.get("purpose", "point")
+    narration_text = scene_ctx.get("narration_text", "")
+    scene_title = scene_ctx.get("title", "") or scene_ctx.get("badge", "")
+
+    enhanced = build_enhanced_prompt(
+        purpose=purpose,
+        topic=topic,
+        style=style,
+        narration_text=narration_text,
+        scene_title=scene_title,
+        style_guide=style_guide,
+    )
+
+    payload["prompt"] = enhanced["prompt"]
+    if "negativePrompt" in enhanced:
+        payload["negativePrompt"] = enhanced["negativePrompt"]
+    if "guidanceScale" in enhanced:
+        payload["guidanceScale"] = enhanced["guidanceScale"]
+
+    return payload

package/skills/template-bind/video_dsl/runtime/template_binder.py

@@ -0,0 +1,87 @@
+"""
+模板 registry 摘要导出器 - 把 ``@ab-templates/metadata`` 的 registry.json
+浓缩为 LLM prompt / 离线脚本使用的精简版本并写盘。
+
+历史：本模块之前还托管了 ``bind_template`` / ``load_template`` / ``extract_props``
+等 DSL→TemplateBinding 接口；那条路径已被 ``scripts/match_template.py`` 接管
+(由 render-video 直接 import)，留在这里的副本无任何外部调用方且与
+match_template 的算法已经漂移。删除这些死接口后，本文件只保留 ``sync_registry``
+所需的最小依赖链 (``_load_registry`` → ``load_all_templates`` → ``build_registry``)。
+
+monorepo 路径解析统一走 ``scripts/template_paths``，避免本文件再自己数 ``..``。
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from typing import Optional
+
+# template_paths 住在 ../../scripts/，把它挂上 sys.path 后才能 import。
+_SCRIPTS_DIR = os.path.abspath(
+    os.path.join(os.path.dirname(__file__), "..", "..", "scripts")
+)
+if _SCRIPTS_DIR not in sys.path:
+    sys.path.insert(0, _SCRIPTS_DIR)
+
+from template_paths import monorepo_registry_path  # noqa: E402
+
+_registry_cache: Optional[dict] = None
+
+
+def _load_registry(registry_path: Optional[str] = None) -> dict:
+    """Load and cache the template registry from ``@ab-templates/metadata``.
+
+    File-only: this helper never goes to HTTP (that's ``registry_loader`` 的
+    职责)；``sync_registry`` 的输出只是给 LLM prompt 用，对一致性要求弱，所以
+    本地读盘即可。
+    """
+    global _registry_cache
+    if _registry_cache is not None:
+        return _registry_cache
+
+    path = registry_path or monorepo_registry_path()
+    if not os.path.isfile(path):
+        return {"templates": []}
+
+    with open(path, "r", encoding="utf-8") as f:
+        _registry_cache = json.load(f)
+    return _registry_cache
+
+
+def load_all_templates(registry_path: Optional[str] = None) -> list[dict]:
+    """Return every template definition from the metadata registry."""
+    registry = _load_registry(registry_path)
+    return registry.get("templates", [])
+
+
+def build_registry(registry_path: Optional[str] = None) -> dict:
+    """Return the registry in the legacy summary format (for LLM prompts etc.)."""
+    templates = load_all_templates(registry_path)
+    matching_fields = [
+        "templateId", "name", "description", "supportedAspectRatios",
+        "supportedDurations", "styleTags", "scenePatterns", "assetRequirements",
+    ]
+    summary = []
+    for tpl in templates:
+        summary.append({k: tpl[k] for k in matching_fields if k in tpl})
+    return {
+        "version": "v1alpha1",
+        "description": "视频模板注册表 - 来自 @ab-templates/metadata",
+        "templates": summary,
+    }
+
+
+def sync_registry(output_path: Optional[str] = None, registry_path: Optional[str] = None) -> str:
+    """Write a local registry-cache.json from ``@ab-templates/metadata``.
+
+    Returns the absolute path of the written file.
+    """
+    registry = build_registry(registry_path)
+    out = output_path or os.path.join(os.path.dirname(__file__), "..", "registry-cache.json")
+    out = os.path.abspath(out)
+    with open(out, "w", encoding="utf-8") as f:
+        json.dump(registry, f, ensure_ascii=False, indent=2)
+        f.write("\n")
+    return out

package/skills/template-bind/video_dsl/runtime/timeline_compiler.py

@@ -0,0 +1,312 @@
+"""
+时间线编译器 - 将 DSL + TemplateBinding 编译为 Remotion 可消费的 RenderPlan。
+
+负责: 帧号计算、字幕切片、转场注入、层级分配。
+
+⚠️ 跨 skill 契约：
+    `skills/render-video/scripts/render_video.py` 通过 sys.path 注入后直接
+    `from video_dsl.runtime.timeline_compiler import (split_subtitle,
+     split_subtitle_from_lines, segment_narration)`。
+    改动以下公共函数的签名 / 返回结构前，请同步核对 render_video.py 的调用点：
+      - split_subtitle
+      - split_subtitle_from_lines
+      - segment_narration
+"""
+
+import re
+from datetime import datetime, timezone
+from typing import Optional
+
+CHARS_PER_SECOND = 5.0
+
+_PRIMARY_BREAK = re.compile(r"(?<=[。！？；\n])")
+_SECONDARY_BREAK = re.compile(r"(?<=[，,、：:])")
+_PRIMARY_TAIL = re.compile(r"[。！？；\n]\s*$")
+
+MAX_SEGMENT_CHARS = 16
+MIN_SEGMENT_CHARS = 6
+
+# 字幕显示时需要去掉的末尾标点（中英文句末 + 逗号等）
+_TRAILING_PUNCT = re.compile(r"[。！？；，,、：:．.…]+$")
+# **...** 强调标记（用于计算纯文本长度）
+_EMPHASIS_MARKS = re.compile(r"\*\*")
+
+RESOLUTION_MAP = {
+    "16:9": {"480p": (854, 480), "720p": (1280, 720), "1080p": (1920, 1080), "4k": (3840, 2160)},
+    "9:16": {"480p": (480, 854), "720p": (720, 1280), "1080p": (1080, 1920), "4k": (2160, 3840)},
+    "1:1": {"480p": (480, 480), "720p": (720, 720), "1080p": (1080, 1080), "4k": (2160, 2160)},
+    "4:3": {"480p": (640, 480), "720p": (960, 720), "1080p": (1440, 1080), "4k": (2880, 2160)},
+    "3:4": {"480p": (480, 640), "720p": (720, 960), "1080p": (1080, 1440), "4k": (2160, 2880)},
+    "21:9": {"720p": (1720, 720), "1080p": (2560, 1080), "4k": (5120, 2160)},
+}
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def resolve_dimensions(ratio: str, resolution: str) -> tuple[int, int]:
+    dims = RESOLUTION_MAP.get(ratio, RESOLUTION_MAP["16:9"])
+    return dims.get(resolution, dims.get("1080p", (1920, 1080)))
+
+
+def _split_at_spaces(text: str, max_len: int) -> list[str]:
+    """Split long text at space boundaries to protect English words."""
+    if len(text) <= max_len:
+        return [text]
+    parts: list[str] = []
+    current = ""
+    for word in text.split(" "):
+        candidate = f"{current} {word}" if current else word
+        if len(candidate) > max_len and current:
+            parts.append(current)
+            current = word
+        else:
+            current = candidate
+    if current:
+        parts.append(current)
+    return parts
+
+
+def _merge_short(segments: list[str], min_len: int) -> list[str]:
+    """Merge fragments shorter than *min_len* into a neighbour.
+
+    Never merge a short segment backward into a sentence-ending segment
+    (ending with 。！？；\\n) to avoid cross-sentence subtitle lines like
+    "可复用技能。第三，".  Instead, keep it as a new entry so it merges
+    forward with the next segment.
+    """
+    if len(segments) <= 1:
+        return segments
+    merged: list[str] = [segments[0]]
+    for seg in segments[1:]:
+        prev_is_sentence_end = bool(_PRIMARY_TAIL.search(merged[-1]))
+        if len(merged[-1]) < min_len:
+            # Previous fragment is short — always merge forward into it
+            merged[-1] += seg
+        elif len(seg) < min_len and not prev_is_sentence_end:
+            # Current fragment is short and prev is NOT a sentence end — merge backward
+            merged[-1] += seg
+        else:
+            # Either both are long enough, or seg is short but prev ends a sentence
+            merged.append(seg)
+    # Handle trailing short segment (avoid merging across sentence boundary)
+    if len(merged) > 1 and len(merged[-1]) < min_len:
+        if not _PRIMARY_TAIL.search(merged[-2]):
+            merged[-2] += merged.pop()
+    return merged
+
+
+def _plain_len(text: str) -> int:
+    """计算去掉 **...** 标记后的纯文本字符数，用于更准确的时间分配。"""
+    return len(_EMPHASIS_MARKS.sub("", text))
+
+
+def _strip_trailing_punct(text: str) -> str:
+    """去掉字幕段末尾的标点符号（中英文句末 + 逗号等），让画面更干净。"""
+    return _TRAILING_PUNCT.sub("", text)
+
+
+def segment_narration(text: str) -> list[str]:
+    """Split narration text into subtitle-display-sized segments (text only).
+
+    Use before TTS: ``"\\n".join(segment_narration(text))`` sends to Minimax
+    so it returns per-segment timestamps.
+    """
+    if not text:
+        return []
+    raw = _PRIMARY_BREAK.split(text.strip())
+    raw = [s for s in raw if s.strip()]
+    segments: list[str] = []
+    for chunk in raw:
+        if len(chunk) <= MAX_SEGMENT_CHARS:
+            segments.append(chunk)
+            continue
+        sub = _SECONDARY_BREAK.split(chunk)
+        sub = [s for s in sub if s.strip()]
+        for part in sub:
+            if len(part) <= MAX_SEGMENT_CHARS:
+                segments.append(part)
+            else:
+                segments.extend(_split_at_spaces(part, MAX_SEGMENT_CHARS))
+    return _merge_short(segments, MIN_SEGMENT_CHARS)
+
+
+def split_subtitle_from_lines(
+    lines: list[str], duration_frames: int, fps: int, padding_frames: int = 10
+) -> list[dict]:
+    """Fallback subtitle timing for pre-split narration lines.
+
+    Preserves exactly ``len(lines)`` segments (no secondary comma-split,
+    no short-fragment merging). Used when narration was authored as
+    ``{intro, items, outro}`` and TTS timestamps are unavailable.
+
+    末尾标点会被去掉（画面更干净），时间分配按纯文本长度（去掉 ** 标记）。
+    """
+    segments = [s.strip() for s in lines if s and s.strip()]
+    if not segments:
+        return []
+
+    total_chars = max(sum(_plain_len(s) for s in segments), 1)
+    estimated_audio_frames = int(total_chars / CHARS_PER_SECOND * fps)
+    usable_frames = min(
+        max(duration_frames - 2 * padding_frames, fps),
+        max(estimated_audio_frames, fps),
+    )
+    result: list[dict] = []
+    current_frame = padding_frames
+    for seg in segments:
+        ratio = _plain_len(seg) / total_chars
+        frames = max(int(usable_frames * ratio), fps // 2)
+        result.append({
+            "text": _strip_trailing_punct(seg.strip()),
+            "startFrame": current_frame,
+            "endFrame": current_frame + frames,
+        })
+        current_frame += frames
+    return result
+
+
+def split_subtitle(text: str, duration_frames: int, fps: int, padding_frames: int = 10) -> list[dict]:
+    """Split narration text into subtitle segments aligned to frames.
+
+    Fallback path used when real TTS timestamps are not available.
+    末尾标点会被去掉（画面更干净），时间分配按纯文本长度（去掉 ** 标记）。
+    """
+    segments = segment_narration(text)
+    if not segments:
+        return []
+
+    total_plain = max(sum(_plain_len(s) for s in segments), 1)
+    estimated_audio_frames = int(total_plain / CHARS_PER_SECOND * fps)
+    usable_frames = min(
+        max(duration_frames - 2 * padding_frames, fps),
+        max(estimated_audio_frames, fps),
+    )
+    result: list[dict] = []
+    current_frame = padding_frames
+    for seg in segments:
+        ratio = _plain_len(seg) / total_plain
+        frames = max(int(usable_frames * ratio), fps // 2)
+        result.append({
+            "text": _strip_trailing_punct(seg.strip()),
+            "startFrame": current_frame,
+            "endFrame": current_frame + frames,
+        })
+        current_frame += frames
+
+    return result
+
+
+def _resolve_root_composition(binding: dict, ratio: str) -> str:
+    """Pick Remotion root Composition ID from template's remotionEntry by aspect ratio."""
+    entry_map = binding.get("remotionEntry", {})
+    if entry_map:
+        return entry_map.get(ratio, next(iter(entry_map.values()), "MainVideo"))
+    return binding.get("templateId", "MainVideo")
+
+
+def compile_timeline(dsl: dict, binding: dict) -> dict:
+    """Compile DSL + TemplateBinding into a full RenderPlan."""
+    fps = dsl.get("global", {}).get("fps", 30)
+    ratio = dsl.get("global", {}).get("aspectRatio", "16:9")
+    resolution = dsl.get("global", {}).get("resolution", "1080p")
+    width, height = resolve_dimensions(ratio, resolution)
+
+    binding_map = {}
+    for b in binding.get("bindings", []):
+        binding_map[b["sceneId"]] = b
+
+    assets_pool = {}
+    for a in dsl.get("assets", []):
+        status = a.get("status", "planned")
+        if status in ("planned", "missing"):
+            status = "pending"
+        assets_pool[a["assetId"]] = {
+            "assetId": a["assetId"],
+            "type": a.get("type", ""),
+            "source": a.get("source", "existing"),
+            "status": status,
+            "url": a.get("url", ""),
+            "localPath": a.get("localPath", ""),
+            "duration": None,
+            "width": None,
+            "height": None,
+            "mimeType": "",
+            "generatedBy": {},
+            "retryCount": 0,
+            "maxRetries": 3,
+        }
+
+    timeline = []
+    current_frame = 0
+    trans_cfg = dsl.get("transitions", {})
+    default_trans = trans_cfg.get("default", "fade")
+    default_trans_dur = int(trans_cfg.get("duration", 0.5) * fps)
+
+    for scene in dsl.get("scenes", []):
+        scene_id = scene["id"]
+        duration = scene.get("duration", 5)
+        dur_frames = int(duration * fps)
+
+        scene_bind = binding_map.get(scene_id, {})
+
+        # P2.3: 不再产出 entry.layers——背景视觉资产、旁白音频、文本图层全部
+        # 通过 propExtractors 写入 binding.props（backgroundAssetId / narrationAssetId
+        # / titleText 等），渲染端用 props 直接消费。
+
+        narration = scene.get("audio", {}).get("narration", {})
+
+        narration_text = narration.get("text", "")
+        sub_segs = split_subtitle(narration_text, dur_frames, fps)
+
+        entry = {
+            "sceneId": scene_id,
+            "startFrame": current_frame,
+            "endFrame": current_frame + dur_frames,
+            "durationFrames": dur_frames,
+            "startTime": round(current_frame / fps, 2),
+            "endTime": round((current_frame + dur_frames) / fps, 2),
+            "compositionId": scene_bind.get("compositionId", "GenericScene"),
+            "props": scene_bind.get("props", {}),
+            "subtitleSegments": sub_segs,
+            "transition": {"type": default_trans, "durationFrames": default_trans_dur},
+        }
+        timeline.append(entry)
+        current_frame += dur_frames
+
+    render_plan = {
+        "version": "v1alpha1",
+        "createdAt": _now_iso(),
+        "status": "planning",
+        "templateId": binding.get("templateId", ""),
+        "resolvedAssets": list(assets_pool.values()),
+        "timeline": timeline,
+        "renderConfig": {
+            "width": width,
+            "height": height,
+            "fps": fps,
+            "totalFrames": current_frame,
+            "totalDuration": round(current_frame / fps, 2),
+            "codec": "h264",
+            "crf": 18,
+            "outputFormat": "mp4",
+        },
+        "remotionProps": {
+            "compositionId": _resolve_root_composition(binding, ratio),
+            "inputProps": {
+                "globalTypography": binding.get("globalOverrides", {}).get("typography", {}),
+                "motionPreset": binding.get("globalOverrides", {}).get("motionPreset", "smooth"),
+                "colorScheme": binding.get("globalOverrides", {}).get("colorScheme", []),
+                **({"themeConfig": binding["themeConfig"]} if binding.get("themeConfig") else {}),
+                **({"variantId": binding["variantId"]} if binding.get("variantId") else {}),
+            },
+        },
+        "errors": [],
+        "logs": [
+            {"phase": "validate", "message": "DSL validation passed", "timestamp": _now_iso()},
+            {"phase": "compile", "message": f"Compiled {len(timeline)} scenes, {current_frame} total frames", "timestamp": _now_iso()},
+        ],
+    }
+
+    return render_plan