@remixmate/cli 0.13.8 → 0.13.10

package/skills/gen-voice/skill.json

@@ -3,8 +3,8 @@
   "toolName": "gen_voice",
   "tier": "atomic",
   "category": "asset",
-  "title": "Text-to-Speech (Minimax)",
-  "description": "Text-to-speech (TTS): synthesize narration audio from text via the Minimax TTS model. Returns the persisted audio URL — no download needed.",
+  "title": "Text-to-Speech",
+  "description": "Text-to-speech (TTS): synthesize narration audio from text. The voice catalog spans several providers (MiniMax, 豆包/Volcengine, HeyGen, and the caller's own cloned voices); the provider is picked from the voice id automatically. Returns the persisted audio URL — no download needed.",
   "auth": "required",
   "joinsTake": true,
   "envVars": [
@@ -25,15 +25,57 @@
       },
       "voice_id": {
         "type": "string",
-        "description": "Voice id. Default 'Chinese (Mandarin)_Male_Announcer'. When unsure, call with list_voices=true first to see what's available — do not invent ids, and do not declare a voice unavailable unless it is missing from that list."
+        "description": "Voice id from list_voices (any provider; synthesis routes to the voice's own provider). Default 'Chinese (Mandarin)_Male_Announcer'. When unsure, call with list_voices=true first — do not invent ids, and do not declare a voice unavailable unless it is missing from the filtered list."
       },
       "speed": {
         "type": "number",
-        "description": "Speech rate, 0.5-2.0"
+        "description": "Speech rate, 0.5-2.0. Some HeyGen cloned voices ignore it."
       },
       "list_voices": {
         "type": "boolean",
-        "description": "List the available voices and exit. This queries the live voice service and is the authoritative catalog — one call is enough, and its absence from this list is the only evidence that a voice id is invalid."
+        "description": "List voices and exit (one page of up to 100, with provider / type / gender / language columns and the total). This queries the live voice service and is the authoritative catalog. The public catalog has a few hundred voices, so narrow it with provider / gender / language / name, or page through with page; mine=true lists the caller's own cloned voices instead."
+      },
+      "mine": {
+        "type": "boolean",
+        "description": "With list_voices=true: list the caller's own cloned voices instead of the public catalog (provider / voice_type do not apply)."
+      },
+      "provider": {
+        "type": "string",
+        "enum": [
+          "minimax",
+          "volcengine",
+          "heygen"
+        ],
+        "description": "With list_voices=true: only voices from this provider (volcengine = 豆包). Not needed for synthesis."
+      },
+      "voice_type": {
+        "type": "string",
+        "enum": [
+          "system",
+          "clone"
+        ],
+        "description": "With list_voices=true: system (stock) or clone voices."
+      },
+      "gender": {
+        "type": "string",
+        "enum": [
+          "male",
+          "female"
+        ],
+        "description": "With list_voices=true: filter by gender."
+      },
+      "language": {
+        "type": "string",
+        "description": "With list_voices=true: filter by language tag, exact tag as shown in the Language column (e.g. 中文-普通话, 中文-粤语, 英语, 日语)."
+      },
+      "name": {
+        "type": "string",
+        "description": "With list_voices=true: fuzzy-filter by voice name."
+      },
+      "page": {
+        "type": "integer",
+        "minimum": 1,
+        "description": "With list_voices=true: page number (100 per page). Default 1."
       },
       "json_output": {
         "type": "boolean",
@@ -52,7 +94,14 @@
     ],
     "hidden": [
       "json_output",
-      "list_voices"
+      "list_voices",
+      "mine",
+      "provider",
+      "voice_type",
+      "gender",
+      "language",
+      "name",
+      "page"
     ]
   }
 }

package/skills/render-video/scripts/render_video.py

@@ -61,6 +61,7 @@ _SHARED_LIB_DIR = os.path.join(os.path.dirname(__file__), "..", "..", "template-
 
 sys.path.insert(0, _SHARED_LIB_DIR)
 sys.path.insert(0, os.path.join(_SHARED_LIB_DIR, "scripts"))
+from video_dsl.runtime.presenter_speech import subtitles_between
 from video_dsl.runtime.timeline_compiler import (
     split_subtitle,
     split_subtitle_from_lines,
@@ -919,6 +920,13 @@ def build_render_plan(dsl: dict, binding: dict) -> dict:
                 if probed:
                     asset["duration"] = probed
 
+    presenter = (dsl.get("global") or {}).get("presenter") or {}
+    presenter_transcript = presenter.get("transcript") or []
+
+    presenter_props = (
+        {"presenter": {k: v for k, v in presenter.items() if k != "transcript"}} if presenter.get("segments") else {}
+    )
+
     timeline = []
     current_frame = 0
 
@@ -927,6 +935,10 @@ def build_render_plan(dsl: dict, binding: dict) -> dict:
         duration = scene.get("duration", 5)
         duration_frames = math.floor(duration * fps + 0.5)
 
+        speech = scene.get("speech") if presenter_transcript else None
+        if speech:
+            duration_frames = speech["endFrame"] - speech["startFrame"]
+
         scene_binding = binding_map.get(scene_id, {})
 
 
@@ -959,6 +971,8 @@ def build_render_plan(dsl: dict, binding: dict) -> dict:
             }
             for s in local_subs
         ]
+        if speech:
+            subtitle_segments = subtitles_between(presenter_transcript, speech["startFrame"], speech["endFrame"], fps)
 
         transition_config = dsl.get("transitions", {})
         trans_type = transition_config.get("default", "fade")
@@ -998,7 +1012,7 @@ def build_render_plan(dsl: dict, binding: dict) -> dict:
             "startTime": round(current_frame / fps, 2),
             "endTime": round((current_frame + duration_frames) / fps, 2),
             "compositionId": scene_binding.get("compositionId", "GenericScene"),
-            "props": scene_binding.get("props", {}),
+            "props": {**scene_binding.get("props", {}), **presenter_props},
             "subtitleSegments": subtitle_segments,
             "subtitleAtSec": subtitle_at_sec,
             "transition": {"type": scene_trans_type, "durationFrames": scene_trans_dur},
@@ -1046,6 +1060,7 @@ def build_render_plan(dsl: dict, binding: dict) -> dict:
                 "motionPreset": binding.get("globalOverrides", {}).get("motionPreset", "smooth"),
                 "colorScheme": binding.get("globalOverrides", {}).get("colorScheme", []),
                 **({"variantId": binding["variantId"]} if binding.get("variantId") else {}),
+                **({"templateConfig": binding["templateConfig"]} if binding.get("templateConfig") else {}),
                 **(_build_bgm_props(dsl)),
             },
         },
@@ -1237,6 +1252,9 @@ def resolve_asset_digital_human(asset: dict, private_token: str, timeout: int) -
 
     if payload.get("avatarId"):
         cmd.extend(["--avatar-id", str(payload["avatarId"])])
+    if payload.get("videoUrl"):
+        cmd.extend(["--video-url", payload["videoUrl"]])
+        cmd.extend(["--lipsync-mode", payload.get("mode", "speed")])
     if payload.get("text"):
         cmd.extend(["--text", payload["text"]])
     if payload.get("voiceId"):
@@ -2935,6 +2953,70 @@ def _poll_vod_playback_url(
     return poll_vod_playback_url(file_id, private_token, max_wait=max_wait, interval=interval)
 
 
+def _select_style(config: dict, style_id) -> tuple[dict, dict]:
+
+    styles = config.get("styles")
+    if not isinstance(styles, list):
+        return config, {}
+    default = config.get("defaultStyle")
+    wanted = style_id or default
+    style = next((s for s in styles if s.get("id") == wanted), None)
+    if style is None:
+        options = ", ".join(s.get("id", "") for s in styles)
+        raise ValueError(f"unknown template style {wanted!r}; options: {options}")
+    snapshot = {k: v for k, v in config.items() if k not in ("styles", "defaultStyle")}
+    snapshot["style"] = style
+    return snapshot, ({} if wanted == default else dict(style.get("tokens") or {}))
+
+
+def _restyle_plan(render_plan: dict, style_id: str) -> dict:
+
+    from registry_loader import declares_sources, get_template, load_contract
+
+    template = get_template(render_plan.get("templateId") or "", include_all_statuses=True)
+    if not declares_sources(template):
+        raise ValueError(f"template {render_plan.get('templateId')!r} has no visual styles to switch")
+    contract = load_contract(template, None)
+    config = {**(contract.get("templateConfig") or {}), "releaseId": contract.get("releaseId")}
+    snapshot, _ = _select_style(config, style_id)
+    props = render_plan["remotionProps"]["inputProps"]
+    props["templateConfig"] = snapshot
+    props["globalTypography"] = {**(props.get("globalTypography") or {}), **(snapshot["style"].get("tokens") or {})}
+    return render_plan
+
+
+def _bind_template_config(binding: dict, template: dict, dsl: dict) -> None:
+
+
+
+
+    from registry_loader import declares_sources, load_contract
+
+    if not declares_sources(template):
+        return
+    global_cfg = dsl.get("global") or {}
+    presenter = global_cfg.get("presenter")
+    source = presenter.get("source") if isinstance(presenter, dict) else None
+    try:
+        contract = load_contract(template, source)
+        release = contract.get("releaseId")
+        if contract.get("templateConfig"):
+            binding["templateConfig"], tokens = _select_style(
+                {**contract["templateConfig"], "releaseId": release}, global_cfg.get("templateStyle")
+            )
+            if tokens:
+
+                overrides = binding.setdefault("globalOverrides", {})
+                overrides["typography"] = {**(overrides.get("typography") or {}), **tokens}
+    except Exception as exc:
+        LogPrint(f"❌ cannot load template contract: {exc}", file=sys.stderr)
+        sys.exit(1)
+    lock = global_cfg.get("configLock")
+    if lock and release and lock != release:
+
+        LogPrint(f"⚠️  configLock {lock} is not the current release {release}; using the current config", file=sys.stderr)
+
+
 def auto_bind_template(dsl: dict, template_id: str) -> dict:
 
 
@@ -2985,6 +3067,7 @@ def auto_bind_template(dsl: dict, template_id: str) -> dict:
     selected = match_template.load_full_template(selected)
     LogPrint(f"📋 auto-bound template: {selected.get('name', '')} ({template_id})", file=sys.stderr)
     binding = match_template.build_binding(selected, dsl)
+    _bind_template_config(binding, selected, dsl)
     from required_props import validate_required_props
     try:
         validate_required_props(selected, binding.get("bindings", []))
@@ -3049,6 +3132,11 @@ Examples:
     parser.add_argument("--skip-asset-resolve", action="store_true", help="Skip asset resolution")
     parser.add_argument("--save-render-plan", action="store_true", help="Save the RenderPlan to a file")
     parser.add_argument("--render-plan-output", default=None, help="RenderPlan output path")
+    parser.add_argument(
+        "--restyle", default=None,
+        help="With --job-id: render that job's plan again in this visual style as a new job. "
+        "Nothing is regenerated, so only the render is billed.",
+    )
     parser.add_argument("--job-id", type=int, default=None, help="Render job id (replaces --render-plan; loads the RenderPlan from the database)")
     parser.add_argument(
         "--save-job",
@@ -3699,6 +3787,17 @@ def main():
     dsl = binding = None
     if args.job_id is not None and args.job_id > 0:
         render_plan = _load_plan_from_job(args.job_id, private_token)
+        if args.restyle:
+            try:
+                render_plan = _restyle_plan(render_plan, args.restyle)
+            except ValueError as exc:
+                LogPrint(f"❌ {exc}", file=sys.stderr)
+                sys.exit(1)
+            _validate_saved_plan(render_plan)
+
+            args.job_id = None
+            args.save_job = True
+            args.skip_asset_resolve = True
     elif args.render_plan:
         render_plan = _load_plan_from_file(args.render_plan, args.dsl)
     else:

package/skills/render-video/skill.json

@@ -27,6 +27,10 @@
         "minimum": 1,
         "description": "Render job id (positive integer, e.g. 8). This is the integer N parsed from prepare_video_assets's stdout line '📦 render job jobId: N' (also tolerated: legacy zh '📦 渲染任务 jobId: N'). Never pass 0, a placeholder string, or descriptive text."
       },
+      "restyle": {
+        "type": "string",
+        "description": "Render the same video again in another visual style (a template_style id). Reuses the script, assets and timing, so nothing is regenerated. Only for templates with visual styles such as talking-head-studio."
+      },
       "save_job": {
         "type": "boolean",
         "description": "Persist the render Manifest back to the database under the same jobId (default true). Auto-degrades to false when PRIV_TOKEN is missing. Pass false to opt out explicitly."

package/skills/template-registry/scripts/registry_loader.py

@@ -471,6 +471,104 @@ def list_templates(*, include_all_statuses: bool = False) -> list[dict]:
     return list(load_registry_indexed(include_all_statuses=include_all_statuses).values())
 
 
+
+
+
+
+
+def declares_sources(tpl: Optional[dict]) -> bool:
+    caps = (tpl or {}).get("capabilities")
+    return isinstance(caps, dict) and isinstance(caps.get("sources"), dict) and bool(caps["sources"])
+
+
+def _contract_url() -> str:
+    if override := os.environ.get("VIDEO_TEMPLATE_CONTRACT_URL"):
+        return override
+    url = os.environ.get("VIDEO_TEMPLATE_REGISTRY_URL") or _default_registry_url()
+    return url.rsplit("/", 1)[0] + "/contract"
+
+
+def _local_contract(tpl: dict, source: Optional[str]) -> dict:
+
+    caps = tpl["capabilities"]
+    sources = caps["sources"]
+    default = caps.get("defaultSource")
+    source = source or default
+    if source not in sources:
+        raise ValueError(f"template {tpl.get('templateId')} has no source {source!r}; options: {sorted(sources)}")
+    resolved = {k: v for k, v in caps.items() if k not in ("sources", "defaultSource")}
+    for key in sources.get(default) or {}:
+        resolved.pop(key, None)
+    resolved.update(sources[source])
+    return {
+        "templateId": tpl.get("templateId"),
+        "source": source,
+        "sources": sorted(sources),
+        "releaseId": f"builtin:{tpl.get('templateId')}@{tpl.get('version')}",
+        "capabilities": resolved,
+        "llmHint": tpl.get("llmHint"),
+        "customPayloadSchema": tpl.get("customPayloadSchema"),
+        "templateConfig": tpl.get("templateConfig"),
+    }
+
+
+def _fetch_contract(template_id: str, source: Optional[str]) -> dict:
+    url = _contract_url()
+    body = json.dumps({"templateId": template_id, **({"source": source} if source else {})}).encode("utf-8")
+    headers = {"Accept": "application/json", "Content-Type": "application/json"}
+    if token := _resolve_priv_token(url):
+        headers["X-Priv-Token"] = token
+    req = urllib.request.Request(url, data=body, headers=headers, method="POST")
+    try:
+        with urllib.request.urlopen(req, timeout=_DEFAULT_HTTP_TIMEOUT) as resp:
+            parsed = json.loads(resp.read().decode("utf-8"))
+    except urllib.error.HTTPError as e:
+        if e.code in (401, 403):
+            raise RegistryAuthError(f"HTTP {e.code}") from e
+        raise RegistryUnreachableError(f"template contract HTTP {e.code}: {url}") from e
+    except (urllib.error.URLError, TimeoutError, json.JSONDecodeError) as e:
+        raise RegistryUnreachableError(f"template contract unreachable: {url} ({e})") from e
+    code = parsed.get("code") if isinstance(parsed, dict) else None
+    if str(code) in ("401", "403"):
+        raise RegistryAuthError(str(parsed.get("msg") or f"code={code}"))
+    if code not in (0, "0") or not isinstance(parsed.get("data"), dict):
+
+        raise ValueError(str(parsed.get("msg") if isinstance(parsed, dict) else parsed))
+    return parsed["data"]
+
+
+_contract_cache: dict[tuple[str, Optional[str]], dict] = {}
+
+
+def load_contract(tpl: dict, source: Optional[str] = None) -> dict:
+
+    template_id = str(tpl.get("templateId"))
+    key = (template_id, source)
+    if key not in _contract_cache:
+        registry_url = os.environ.get("VIDEO_TEMPLATE_REGISTRY_URL", "")
+        local = registry_url.startswith("file:") and not os.environ.get("VIDEO_TEMPLATE_CONTRACT_URL")
+        _contract_cache[key] = _local_contract(tpl, source) if local else _fetch_contract(template_id, source)
+    return _contract_cache[key]
+
+
+def template_for_source(tpl: Optional[dict], source: Optional[str] = None) -> Optional[dict]:
+
+
+
+
+    if not declares_sources(tpl):
+        if source:
+            raise ValueError(f"template {(tpl or {}).get('templateId')} does not declare presenter sources")
+        return tpl
+    contract = load_contract(tpl, source)
+    view = dict(tpl)
+    view["capabilities"] = contract.get("capabilities") or {}
+    for key in ("llmHint", "customPayloadSchema"):
+        if contract.get(key) is not None:
+            view[key] = contract[key]
+    return view
+
+
 def invalidate_cache() -> None:
 
 
@@ -478,3 +576,4 @@ def invalidate_cache() -> None:
 
 
     _indexed_view.cache_clear()
+    _contract_cache.clear()

package/skills/template-registry/video_dsl/runtime/dsl_validator.py

@@ -168,6 +168,32 @@ def step_alignment_field(tpl: Optional[dict]) -> Optional[str]:
     return field if isinstance(field, str) and field else None
 
 
+def _dsl_source(dsl: dict) -> Optional[str]:
+    presenter = (dsl.get("global") or {}).get("presenter")
+    source = presenter.get("source") if isinstance(presenter, dict) else None
+    return source if isinstance(source, str) and source else None
+
+
+def _template_for_dsl(dsl: dict) -> Optional[dict]:
+
+
+
+
+
+    tpl = _get_template_cfg(_pick_template_id(dsl))
+    source = _dsl_source(dsl)
+    if not tpl or not source:
+        return tpl
+    caps = tpl.get("capabilities")
+    if not isinstance(caps, dict) or source == caps.get("defaultSource"):
+        return tpl
+    try:
+        from registry_loader import template_for_source
+        return template_for_source(tpl, source)
+    except Exception:
+        return tpl
+
+
 def _get_template_cfg(template_id: Optional[str]) -> Optional[dict]:
 
 
@@ -538,7 +564,7 @@ def _check_slide_id_chosen(dsl: dict) -> list[ValidationError]:
 
 
 
-    tpl = _get_template_cfg(_pick_template_id(dsl))
+    tpl = _template_for_dsl(dsl)
     if not tpl:
         return []
     schema = tpl.get("customPayloadSchema")
@@ -611,7 +637,7 @@ def _check_slide_cross_field(dsl: dict) -> list[ValidationError]:
 
 
 
-    tpl = _get_template_cfg(_pick_template_id(dsl))
+    tpl = _template_for_dsl(dsl)
     if not tpl:
         return []
     schemas = tpl.get("slideSchemas")
@@ -712,7 +738,7 @@ def _check_line_sync_narration(dsl: dict) -> list[ValidationError]:
 
 
 
-    tpl = _get_template_cfg(_pick_template_id(dsl))
+    tpl = _template_for_dsl(dsl)
     if not tpl:
         return []
     line_sync = line_sync_slides(tpl)
@@ -789,7 +815,7 @@ def _check_step_narration_alignment(dsl: dict) -> list[ValidationError]:
 
 
 
-    tpl = _get_template_cfg(_pick_template_id(dsl))
+    tpl = _template_for_dsl(dsl)
     if not tpl:
         return []
     field = step_alignment_field(tpl)
@@ -871,7 +897,7 @@ def _check_duration_estimate(dsl: dict) -> list[ValidationError]:
     narration_cfg = ((dsl.get("global") or {}).get("narration") or {})
     speed = narration_cfg.get("speed")
     speed = float(speed) if isinstance(speed, (int, float)) and not isinstance(speed, bool) and speed > 0 else 1.0
-    tail = nb.template_tail_pad_sec(_get_template_cfg(_pick_template_id(dsl)))
+    tail = nb.template_tail_pad_sec(_template_for_dsl(dsl))
 
     total = 0.0
     narrated = 0
@@ -925,7 +951,7 @@ def _check_slide_payload_fields(dsl: dict) -> list[ValidationError]:
 
 
 
-    tpl = _get_template_cfg(_pick_template_id(dsl))
+    tpl = _template_for_dsl(dsl)
     if not tpl:
         return []
     schemas = tpl.get("slideSchemas")
@@ -988,7 +1014,7 @@ def _check_custom_payload_fields(dsl: dict) -> list[ValidationError]:
 
 
 
-    tpl = _get_template_cfg(_pick_template_id(dsl))
+    tpl = _template_for_dsl(dsl)
     if not tpl:
         return []
     from .payload_contract import required_payload_errors
@@ -1240,7 +1266,7 @@ def _check_narration_language_strict(dsl: dict) -> list[ValidationError]:
 
 
 
-    tpl = _get_template_cfg(_pick_template_id(dsl))
+    tpl = _template_for_dsl(dsl)
     if not tpl:
         return []
     strict = (tpl.get("capabilities") or {}).get("narrationLanguageStrict")
@@ -1273,12 +1299,31 @@ def _check_narration_language_strict(dsl: dict) -> list[ValidationError]:
 _TEXT_LAYER_SKELETON_PREFIXES = ("[骨架待填充]", "[skeleton placeholder]")
 
 
+def _check_presenter_source(dsl: dict) -> list[ValidationError]:
+
+    source = _dsl_source(dsl)
+    if not source:
+        return []
+    tpl = _get_template_cfg(_pick_template_id(dsl))
+    if tpl is None:
+        return []
+    caps = tpl.get("capabilities")
+    sources = caps.get("sources") if isinstance(caps, dict) else None
+    if not isinstance(sources, dict) or source not in sources:
+        options = ", ".join(sorted(sources)) if isinstance(sources, dict) else "none"
+        return [ValidationError(
+            "global.presenter.source",
+            f"unknown presenter source {source!r} for this template; options: {options}",
+        )]
+    return []
+
+
 def _check_presenter_visibility(dsl: dict) -> list[ValidationError]:
 
 
 
 
-    tpl = _get_template_cfg(_pick_template_id(dsl)) or {}
+    tpl = _template_for_dsl(dsl) or {}
     caps = tpl.get("capabilities")
     caps = caps if isinstance(caps, dict) else {}
     spec = caps.get("digitalHuman") or {}
@@ -1325,7 +1370,7 @@ def _check_text_layer_rules(dsl: dict) -> list[ValidationError]:
 
 
 
-    tpl = _get_template_cfg(_pick_template_id(dsl))
+    tpl = _template_for_dsl(dsl)
     if not tpl:
         return []
     rules = (tpl.get("capabilities") or {}).get("textLayerRules")
@@ -1436,6 +1481,7 @@ def validate_integrity(dsl: dict) -> list[ValidationError]:
     errors += _check_step_narration_alignment(dsl)
     errors += _check_slide_cross_field(dsl)
     errors += _check_text_layer_rules(dsl)
+    errors += _check_presenter_source(dsl)
     errors += _check_presenter_visibility(dsl)
 
     errors += _check_duration_estimate(dsl)
@@ -1474,6 +1520,7 @@ def validate_dsl(dsl: dict) -> list[ValidationError]:
     errors += _check_step_narration_alignment(dsl)
     errors += _check_slide_cross_field(dsl)
     errors += _check_text_layer_rules(dsl)
+    errors += _check_presenter_source(dsl)
     errors += _check_presenter_visibility(dsl)
 
     errors += _check_duration_estimate(dsl)

package/skills/template-registry/video_dsl/runtime/presenter_speech.py

@@ -0,0 +1,104 @@
+
+
+
+
+
+
+
+from __future__ import annotations
+
+import re
+
+_SENTENCE_END = re.compile(r"(?<=[。！？!?；;])")
+
+
+def _spread_sentences(text: str, start_ms: int, end_ms: int) -> list[dict]:
+
+    pieces = [p.strip() for p in _SENTENCE_END.split(text) if p.strip()]
+    total = sum(len(p) for p in pieces) or 1
+    out = []
+    cursor = float(start_ms)
+    for piece in pieces:
+        span = (end_ms - start_ms) * len(piece) / total
+        out.append({"text": piece, "startMs": round(cursor), "endMs": round(cursor + span), "words": []})
+        cursor += span
+    return out
+
+
+def _split_by_words(utterance: dict) -> list[dict]:
+
+    out: list[dict] = []
+    current: list[dict] = []
+    for word in utterance["words"]:
+        current.append({"text": word["text"], "startMs": word["startTime"], "endMs": word["endTime"]})
+        if _SENTENCE_END.search(word["text"] + " ") or word["text"][-1:] in "。！？!?；;":
+            out.append(current)
+            current = []
+    if current:
+        out.append(current)
+    return [
+        {"text": "".join(w["text"] for w in s), "startMs": s[0]["startMs"], "endMs": s[-1]["endMs"], "words": s}
+        for s in out
+    ]
+
+
+def transcript_from_asr(asr: dict) -> list[dict]:
+
+    sentences: list[dict] = []
+    for utterance in asr.get("utterances") or []:
+        if utterance.get("words"):
+            sentences += _split_by_words(utterance)
+        elif utterance.get("text"):
+            sentences += _spread_sentences(utterance["text"], utterance.get("startTime", 0), utterance.get("endTime", 0))
+    return sentences
+
+
+def plan_speech_scenes(sentences: list[dict], video_sec: float, count: int, fps: int) -> list[dict]:
+
+
+
+
+    if not sentences:
+        return []
+    count = max(1, min(count, len(sentences)))
+    total = sum(len(s["text"]) for s in sentences)
+    groups: list[list[dict]] = [[]]
+    seen = 0
+    for i, sentence in enumerate(sentences):
+        remaining_sentences = len(sentences) - i
+        remaining_groups = count - len(groups)
+        boundary = total * len(groups) / count
+        if groups[-1] and remaining_groups > 0 and (seen >= boundary or remaining_sentences <= remaining_groups):
+            groups.append([])
+        groups[-1].append(sentence)
+        seen += len(sentence["text"])
+    total_frames = max(round(video_sec * fps), round(sentences[-1]["endMs"] / 1000 * fps))
+    scenes = []
+    for i, group in enumerate(groups):
+        start = 0 if i == 0 else round(group[0]["startMs"] / 1000 * fps)
+        end = total_frames if i == len(groups) - 1 else round(groups[i + 1][0]["startMs"] / 1000 * fps)
+        scenes.append({"startFrame": start, "endFrame": end, "text": "".join(s["text"] for s in group)})
+    return scenes
+
+
+def subtitles_between(sentences: list[dict], start_frame: int, end_frame: int, fps: int) -> list[dict]:
+
+    to_frame = lambda ms: round(ms / 1000 * fps)
+    segments = []
+    for index, sentence in enumerate(sentences):
+        start = to_frame(sentence["startMs"])
+        if not start_frame <= start < end_frame:
+            continue
+        segment = {
+            "text": sentence["text"],
+            "startFrame": start,
+            "endFrame": min(max(to_frame(sentence["endMs"]), start + 1), end_frame),
+            "sentenceIndex": index,
+        }
+        if sentence.get("words"):
+            segment["words"] = [
+                {"text": w["text"], "startFrame": to_frame(w["startMs"]), "endFrame": to_frame(w["endMs"])}
+                for w in sentence["words"]
+            ]
+        segments.append(segment)
+    return segments

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

@@ -442,6 +442,7 @@ def compile_timeline(dsl: dict, binding: dict) -> dict:
                 "colorScheme": binding.get("globalOverrides", {}).get("colorScheme", []),
                 **({"themeConfig": binding["themeConfig"]} if binding.get("themeConfig") else {}),
                 **({"variantId": binding["variantId"]} if binding.get("variantId") else {}),
+                **({"templateConfig": binding["templateConfig"]} if binding.get("templateConfig") else {}),
             },
         },
         "errors": [],