@remixmate/cli 0.9.72 → 0.9.73

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

@@ -1,17 +1,17 @@
-"""
-时间线编译器 - 将 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
@@ -19,51 +19,51 @@ from typing import Optional
 
 CHARS_PER_SECOND = 5.0
 
-# 英文句末：`.!?`（可跟一个收尾引号/括号）且后面是空白。以前只认中文标点，英文旁白
-# 从来不在句号处断，只能落到逗号 / 30 字空格硬切，切出 `went home. A few days later,`
-# 这种跨句的行，所有段的 sentenceIndex 也全是 0。常见缩写后的句点不算句末。
+
+
+
 _EN_SENTENCE_END = (
     r"(?:(?<=[.!?])|(?<=[.!?][\"'\u201d\u2019)]))"
     r"(?<!\bMr\.)(?<!\bMs\.)(?<!\bDr\.)(?<!\bSt\.)(?<!\bMrs\.)(?<!\be\.g\.)(?<!\bi\.e\.)(?<!\bvs\.)"
     r"(?=\s)"
 )
 _PRIMARY_BREAK = re.compile(r"(?<=[。！？；\n])|" + _EN_SENTENCE_END)
-# 次级断点**不含顿号 `、`**。顿号是并列项之间的分隔，在它上面下刀就是把一串并列
-# 拦腰切开（`调研、策划、` ／ `开发、分析，…`）。这一层只数字符、分不出标点的语义
-# 强度，所以干脆不碰它 —— 真需要再切时交给渲染端，那边是分级的（句末 > 冒号 >
-# 逗号 > 顿号 > 空格），只有前面几级都切不动才会降到顿号。
+
+
+
+
 _SECONDARY_BREAK = re.compile(r"(?<=[，,：:])")
 _PRIMARY_TAIL = re.compile(
     r"(?:[。！？；\n]|(?<!\bMr)(?<!\bMs)(?<!\bDr)(?<!\bSt)(?<!\bMrs)(?<!\bvs)[.!?][\"'\u201d\u2019)]?)\s*$"
 )
 
-# ─── 这两个上限管的是「喂给 TTS 的行」，不再是「一屏字幕」 ────────────────
-#
-# 曾经是 16 / 6，那是渲染端还不会分屏时的产物：谁都不会再切，所以必须在这里
-# 就把旁白预切成一屏放得下的大小。现在渲染端（core 的 `chunkSubtitleSegments`）
-# 会按**实际字号与实际可用宽度**算容量、按**标点语义强度分级**切分，这件事它
-# 做得比这里好得多：
-#   · 这里只能数字符数，数不出 `HNSW` 比 4 个中文字窄一半；
-#   · 这里的 `_SECONDARY_BREAK` 是平的，冒号和顿号同权，会把并列项拦腰切开；
-#   · 这里一个全局 16 要同时服务 16:9（一行放 44 字）和 9:16（一行放 22 字）。
-#
-# 于是 16 的唯一效果变成了**抢在渲染端之前把句子剁碎**。2026-09-21 线上成片实测：
-# 121.5s 里 57 屏、中位 2.10s 一屏、33% 短于 1.5s，「AI Agent」独占一屏 —— 全都是
-# 这个 16 的产物，渲染端的分屏阈值（20）一次都没被触发。
-#
-# 现在这里只负责一件事：**在真实语音停顿处断行**，让 Minimax 按停顿返回时间戳。
-# 句末（`_PRIMARY_BREAK`）永远断；逗号那一级只在句子长到一行 TTS 太长时才用。
-# 30 是「一个中文长句」的量级 —— 越过它说明这句本来就该有个呼吸点。
-#
-# ⚠️ 别再把它当字幕宽度调：想改一屏显示多少字，改 core 的
-# `DEFAULT_SPLIT_MAX_UNITS` / `LINE_FILL_LIMIT`，那边才看得见字号和画幅。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 MAX_SEGMENT_CHARS = 30
-# 合并下限保持 6：TTS 行太短会让合成的语气断掉（和字幕闪烁是两回事）。
+
 MIN_SEGMENT_CHARS = 6
 
-# 字幕显示时需要去掉的末尾标点（中英文句末 + 逗号等）
+
 _TRAILING_PUNCT = re.compile(r"[。！？；，,、：:．.…]+$")
-# **...** 强调标记（用于计算纯文本长度）
+
 _EMPHASIS_MARKS = re.compile(r"\*\*")
 
 RESOLUTION_MAP = {
@@ -90,54 +90,54 @@ def _is_latin_word_char(ch: str) -> bool:
 
 
 def _breakable(prev_token: str, next_token: str) -> bool:
-    """两个 token 之间断开是否安全 —— 拉丁↔拉丁即同一词组内部，不安全。
 
-    拆与并共用这一个判据：断的时候躲开的边界，并的时候就得把空格补回去。
-    """
+
+
+
     if not prev_token or not next_token:
         return True
     return not (_is_latin_word_char(prev_token[-1]) and _is_latin_word_char(next_token[0]))
 
 
 def _concat_segments(left: str, right: str) -> str:
-    """拼接两个字幕段，必要时补回被切分吃掉的那个空格。
 
-    ``_split_at_spaces`` 在空格处断开，空格本身不属于任何一段；直接 ``+`` 拼回去
-    会把 ``capabilities and`` + ``more`` 粘成 ``capabilities andmore`` —— 这串同样会
-    原样进 TTS，读出来就是一个不存在的词。中文两侧不补空格（中文本来就不分词）。
-    """
+
+
+
+
+
     if _breakable(left, right):
         return left + right
     return left + " " + right
 
 
 def _split_at_spaces(text: str, max_len: int) -> list[str]:
-    """Split long text at space boundaries, keeping multi-word Latin terms whole.
-
-    These boundaries are not only subtitle cuts: ``segment_narration`` joins the
-    result with ``\\n`` and that is what goes to TTS, where each line is a hard
-    segment boundary. Cutting between two Latin words therefore breaks the term
-    apart in the *audio* — Minimax loses both the liaison and the context that
-    told it this was English at all.
-
-    实测(2026-09-20): ``最近刷爆科技圈的 AI Agent，`` 是 18 字、超过 16 的上限，而这
-    段里仅有的两个空格都在 "AI Agent" 中间,于是旧实现只能从词组中间下刀,切成
-    ``最近刷爆科技圈的 AI`` + ``Agent，`` —— 合成出来 "AI" 收在上一段末尾、"Agent"
-    孤零零起一段,那个词就读不准了。同句末尾的 "Agent Loop。" 因为没超上限反而完好,
-    用户听到的正是"中间那个 Agent 不对"。
-
-    所以断点优先选**中文↔拉丁**边界(回退到词组之前),找不到再退回"就近断开"。
-    纯英文旁白里根本不存在中文↔拉丁边界,每个断点都会走回退分支,行为与旧实现逐字
-    相同 —— picture-book-en 这类全英文模板不受影响。
-    """
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     if len(text) <= max_len:
         return [text]
 
     parts: list[str] = []
-    buf: list[str] = []  # 当前段已收的 token
+    buf: list[str] = []
     for word in text.split(" "):
         if buf and len(" ".join(buf + [word])) > max_len:
-            # 从最靠后的边界往回找第一个安全断点;整段都没有就按旧行为就近断开。
+
             cut = len(buf)
             for i in range(len(buf), 0, -1):
                 following = word if i == len(buf) else buf[i]
@@ -153,28 +153,28 @@ def _split_at_spaces(text: str, max_len: int) -> list[str]:
 
 
 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] = _concat_segments(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] = _concat_segments(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] = _concat_segments(merged[-2], merged.pop())
@@ -182,28 +182,28 @@ def _merge_short(segments: list[str], min_len: int) -> list[str]:
 
 
 def assign_sentence_indices(raw_texts: list[str]) -> list[int]:
-    """给每个字幕/TTS 段标注它属于原旁白的第几**句**（0-based）。
 
-    为什么必须单独标：一段 **不等于** 一句。``segment_narration`` 在句末断行之后，
-    还会把超过 ``MAX_SEGMENT_CHARS`` 的长句在逗号处继续切 —— 那是为了让 TTS 按真实
-    停顿返回时间戳，跟"句"没关系。于是 35 字的一句话会变成 3 段。
 
-    靠下标把「第 i 个动作」对齐到「第 i 段字幕」的模板（math-principles-expl 的
-    ``steps``、ppt-to-video 的 ``beats``）因此会整体错位，而且是**静默**的：
-    2026-09-23 线上一条鸡兔同笼成片里 10 句旁白被切成约 19 段，板面 10 步在音频
-    播到一半就走完，之后画面冻结、旁白继续，全程零报错、终态 completed。
 
-    判据：一段是某句的**末段**，当且仅当它以句末标点（``。！？；`` 或换行）结尾。
-    这与 ``_PRIMARY_BREAK`` 是同一个集合 —— 切的时候用它断，标的时候用它认，
-    所以两边不会漂移。
 
-    ⚠️ 必须传**未去尾标点**的原文。``_strip_trailing_punct`` 之后句末标点就没了，
-    那时所有段都会被认成同一句。
 
-    极少数情况下一段会跨句：``_merge_short`` 为了不让 TTS 行短到丢语气，会把一个
-    过短的段向后并（比如整句只有「对吗？」三个字）。这时该段归**它起始的那一句**，
-    因为调用方要的是「这句话从哪一帧开始被说出来」。
-    """
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     indices: list[int] = []
     sentence = 0
     for text in raw_texts:
@@ -214,10 +214,10 @@ def assign_sentence_indices(raw_texts: list[str]) -> list[int]:
 
 
 def count_narration_sentences(text: str) -> int:
-    """数一段旁白有多少句。与 ``assign_sentence_indices`` 同一判据。
 
-    给校验层用：模板声明「steps 与旁白一一对应」时，用它和 steps 条数比对。
-    """
+
+
+
     if not text or not text.strip():
         return 0
     chunks = [s for s in _PRIMARY_BREAK.split(text.strip()) if s.strip()]
@@ -225,26 +225,26 @@ def count_narration_sentences(text: str) -> int:
 
 
 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 into **TTS lines**, cutting at speech pauses.
 
-    Use before TTS: ``"\\n".join(segment_narration(text))`` sends to Minimax
-    so it returns per-line timestamps.
 
-    ⚠️ 这里切的**不是字幕屏**。字幕分屏归渲染端（core 的
-    ``chunkSubtitleSegments``），它知道字号、画幅和标点的语义强度；这里只知道
-    字符数。这一层切得越细，留给渲染端的余地越小 —— 见 ``MAX_SEGMENT_CHARS``
-    的注释。
-    """
+
+
+
+
+
+
+
+
     if not text:
         return []
     raw = _PRIMARY_BREAK.split(text.strip())
@@ -267,14 +267,14 @@ def segment_narration(text: str) -> list[str]:
 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 []
@@ -285,7 +285,7 @@ def split_subtitle_from_lines(
         max(duration_frames - 2 * padding_frames, fps),
         max(estimated_audio_frames, fps),
     )
-    # 句归属必须在去尾标点**之前**算 —— 去掉「。」之后就认不出句末了。
+
     sentence_indices = assign_sentence_indices(segments)
     result: list[dict] = []
     current_frame = padding_frames
@@ -303,11 +303,11 @@ def split_subtitle_from_lines(
 
 
 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 []
@@ -318,7 +318,7 @@ def split_subtitle(text: str, duration_frames: int, fps: int, padding_frames: in
         max(duration_frames - 2 * padding_frames, fps),
         max(estimated_audio_frames, fps),
     )
-    # 句归属必须在去尾标点**之前**算（见 assign_sentence_indices）。
+
     sentence_indices = assign_sentence_indices(segments)
     result: list[dict] = []
     current_frame = padding_frames
@@ -337,7 +337,7 @@ def split_subtitle(text: str, duration_frames: int, fps: int, padding_frames: in
 
 
 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"))
@@ -345,7 +345,7 @@ def _resolve_root_composition(binding: dict, ratio: str) -> str:
 
 
 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")
@@ -389,9 +389,9 @@ def compile_timeline(dsl: dict, binding: dict) -> dict:
 
         scene_bind = binding_map.get(scene_id, {})
 
-        # P2.3: 不再产出 entry.layers——背景视觉资产、旁白音频、文本图层全部
-        # 通过 propExtractors 写入 binding.props（backgroundAssetId / narrationAssetId
-        # / titleText 等），渲染端用 props 直接消费。
+
+
+
 
         narration = scene.get("audio", {}).get("narration", {})
 

package/skills/template-registry/video_dsl/schema/video-dsl-v1alpha1.json

@@ -54,7 +54,20 @@
           "description": "整体风格标签，如 科技感、清新、商务、卡通"
         },
         "audience": { "type": "string" },
-        "description": { "type": "string" }
+        "description": { "type": "string" },
+        "templateSelection": {
+          "type": "object",
+          "description": "模板是怎么定下来的（gen_script --template-source / --template-candidates 写入）。user-explicit = 用户点名；user-confirmed = agent 推荐、用户确认。未经确认的 auto 选择不会出现在这里：gen_script 直接拒绝生成。",
+          "required": ["source"],
+          "properties": {
+            "source": { "type": "string", "enum": ["user-explicit", "user-confirmed"] },
+            "candidates": {
+              "type": "array",
+              "items": { "type": "string" },
+              "description": "给用户看过的候选 templateId，推荐的排第一"
+            }
+          }
+        }
       }
     },
     "GlobalConfig": {