@oh-story/dsh 0.1.7 → 0.1.9

package/lib/video-recap/skills/video-assemble/scripts/subtitle_core.py

@@ -44,26 +44,25 @@ def _subtitle_style_config(canvas=None):
     16:9 source (or the 1280x720 default) reproduces the legacy values exactly.
     """
     style = {
-        "font_name": CONFIG.get("subtitle_font_name", "Arial"),
-        "font_size": CONFIG.get("subtitle_font_size", 42),
-        "primary_color": CONFIG.get("subtitle_primary_color", "&H00FFFFFF"),
-        "outline_color": CONFIG.get("subtitle_outline_color", "&H00000000"),
-        "outline": CONFIG.get("subtitle_outline", 2),
-        "shadow": CONFIG.get("subtitle_shadow", 1),
-        "alignment": CONFIG.get("subtitle_alignment", 2),
-        "margin_l": CONFIG.get("subtitle_margin_l", 40),
-        "margin_r": CONFIG.get("subtitle_margin_r", 40),
-        "margin_v": CONFIG.get("subtitle_margin_v", 30),
-        "max_chars": CONFIG.get("subtitle_max_chars", 20),
-        "play_res_x": CONFIG.get("subtitle_play_res_x", 1280),
-        "play_res_y": CONFIG.get("subtitle_play_res_y", 720),
+        "font_name": CONFIG["subtitle_font_name"],
+        "font_size": CONFIG["subtitle_font_size"],
+        "primary_color": CONFIG["subtitle_primary_color"],
+        "outline_color": CONFIG["subtitle_outline_color"],
+        "outline": CONFIG["subtitle_outline"],
+        "shadow": CONFIG["subtitle_shadow"],
+        "alignment": CONFIG["subtitle_alignment"],
+        "margin_l": CONFIG["subtitle_margin_l"],
+        "margin_r": CONFIG["subtitle_margin_r"],
+        "margin_v": CONFIG["subtitle_margin_v"],
+        "max_chars": CONFIG["subtitle_max_chars"],
+        "play_res_x": CONFIG["subtitle_play_res_x"],
+        "play_res_y": CONFIG["subtitle_play_res_y"],
     }
     pinned = "SUBTITLE_PLAY_RES_X" in os.environ or "SUBTITLE_PLAY_RES_Y" in os.environ
-    cw = int((canvas or {}).get("width", 0) or 0)
-    ch = int((canvas or {}).get("height", 0) or 0)
-    if canvas is None or pinned or cw <= 0 or ch <= 0:
+    if canvas is None or pinned:
         return style  # legacy / manually-pinned: unchanged
 
+    cw, ch = canvas["width"], canvas["height"]
     base_font = float(style["font_size"])
     kx = cw / float(SUBTITLE_STYLE_REF_W)  # horizontal metrics ∝ width
     ky = ch / float(SUBTITLE_STYLE_REF_H)  # vertical metrics ∝ height
@@ -73,9 +72,9 @@ def _subtitle_style_config(canvas=None):
     # height-proportional size, then cap so a full line of CJK glyphs (≈1em wide) fits the
     # usable width — this is what keeps portrait text on-screen instead of overflowing.
     usable_w = max(1.0, cw - margin_l - margin_r)
-    width_cap = usable_w / max(1, int(style["max_chars"]))
+    width_cap = usable_w / int(style["max_chars"])
     font_size = max(1, int(min(base_font * ky, width_cap)))  # floor so a full line never overflows
-    font_scale = font_size / base_font if base_font else 1.0
+    font_scale = font_size / base_font
     style.update({
         "font_size": font_size,
         "outline": max(0, round(float(style["outline"]) * font_scale)),
@@ -89,48 +88,45 @@ def _subtitle_style_config(canvas=None):
     return style
 
 
-def _validate_measured_subtitle_coordinate_domain(canvas=None):
-    y_top = int(CONFIG.get("subtitle_y_top", -1))
-    y_bot = int(CONFIG.get("subtitle_y_bot", -1))
+def _measured_subtitle_band(canvas):
+    """Explicit (y_top, y_bot) display-frame subtitle band validated against the canvas, or None."""
+    y_top = CONFIG["subtitle_y_top"]
+    y_bot = CONFIG["subtitle_y_bot"]
     if y_top < 0 and y_bot < 0:
-        return
-    sar_text = str((canvas or {}).get("sample_aspect_ratio") or "1:1")
+        return None
+    sar_text = canvas["sample_aspect_ratio"]
     if abs(_ratio_to_float(sar_text, 0.0) - 1.0) >= 1e-9:
         raise ValueError(
             f"字幕带坐标仅支持方形像素画布 (SAR 1:1)；当前 SAR={sar_text}"
         )
-
-
-def _style_for_measured_subtitle_band(style, canvas=None):
-    """Fit the ASS baseline and font into explicit auto-rotated display-frame Y coordinates."""
-    style = dict(style)
-    y_top = int(CONFIG.get("subtitle_y_top", -1))
-    y_bot = int(CONFIG.get("subtitle_y_bot", -1))
-    canvas_h = int((canvas or {}).get("height", 0) or 0)
-    if y_top < 0 and y_bot < 0:
-        return style
-    _validate_measured_subtitle_coordinate_domain(canvas)
-    if canvas_h <= 0:
-        return style
+    canvas_h = canvas["height"]
     if not 0 <= y_top < y_bot <= canvas_h:
         raise ValueError(
             f"字幕带坐标无效: top={y_top}, bot={y_bot}, 画布高度={canvas_h}；"
             "必须满足 0 <= top < bot <= height"
         )
-    alignment = int(style.get("alignment", 2))
+    return y_top, y_bot
+
+
+def _style_for_measured_subtitle_band(style, canvas):
+    """Fit the ASS baseline and font into explicit auto-rotated display-frame Y coordinates."""
+    style = dict(style)
+    safe_area = _measured_subtitle_safe_area(style, canvas)
+    if safe_area is None:
+        return style
+    alignment = style["alignment"]
     if alignment not in {1, 2, 3}:
         raise ValueError(
             "measured subtitle coordinates require a bottom-aligned ASS style "
             f"(SUBTITLE_ALIGNMENT 1/2/3); got {alignment}"
         )
+    canvas_h = canvas["height"]
     scale_y = float(style["play_res_y"]) / canvas_h
-    style["margin_v"] = max(0, round((canvas_h - y_bot) * scale_y))
-    current_font = max(1, int(style["font_size"]))
-    current_outline = float(style.get("outline", 0) or 0)
-    current_shadow = float(style.get("shadow", 0) or 0)
-    safe_area = _measured_subtitle_safe_area(style, canvas)
-    available_height = int((safe_area or {}).get("height", 0) or 0)
-    fitted_font = current_font
+    style["margin_v"] = max(0, round((canvas_h - CONFIG["subtitle_y_bot"]) * scale_y))
+    current_font = int(style["font_size"])
+    current_outline = float(style["outline"])
+    current_shadow = float(style["shadow"])
+    available_height = safe_area["height"]
     for candidate in range(current_font, 7, -1):
         scale = candidate / current_font
         outline = max(1 if current_outline > 0 else 0, round(current_outline * scale))
@@ -151,39 +147,27 @@ def _style_for_measured_subtitle_band(style, canvas=None):
     return style
 
 
-def _measured_subtitle_safe_area(style, canvas=None):
+def _measured_subtitle_safe_area(style, canvas):
     """Return the padded measured band in ASS PlayRes coordinates, or None."""
-    y_top = int(CONFIG.get("subtitle_y_top", -1))
-    y_bot = int(CONFIG.get("subtitle_y_bot", -1))
-    canvas_w = int((canvas or {}).get("width", 0) or 0)
-    canvas_h = int((canvas or {}).get("height", 0) or 0)
-    if y_top < 0 and y_bot < 0:
+    band = _measured_subtitle_band(canvas)
+    if band is None:
         return None
-    _validate_measured_subtitle_coordinate_domain(canvas)
-    if canvas_w <= 0 or canvas_h <= 0:
-        return None
-    if not 0 <= y_top < y_bot <= canvas_h:
-        raise ValueError(
-            f"字幕带坐标无效: top={y_top}, bot={y_bot}, 画布高度={canvas_h}；"
-            "必须满足 0 <= top < bot <= height"
-        )
-    padding = max(0, int(CONFIG.get("subtitle_mask_padding", 4) or 0))
-    safe_top = max(0, y_top - padding)
+    y_top, y_bot = band
+    canvas_h = canvas["height"]
+    safe_top = max(0, y_top - CONFIG["subtitle_mask_padding"])
     # The ASS style remains bottom-anchored at the measured y_bot. Bottom mask padding hides
     # source glyph edges but is not usable subtitle layout space; only top padding can extend
     # the line box without moving its baseline below the measured band.
-    safe_bot = y_bot
-    play_x = int(style.get("play_res_x") or canvas_w)
-    play_y = int(style.get("play_res_y") or canvas_h)
-    scale_y = play_y / canvas_h
-    margin_l = int(style.get("margin_l") or 0)
-    margin_r = int(style.get("margin_r") or 0)
+    play_x = int(style["play_res_x"])
+    scale_y = int(style["play_res_y"]) / canvas_h
+    margin_l = int(style["margin_l"])
+    margin_r = int(style["margin_r"])
     return {
         "x": margin_l,
         "y": round(safe_top * scale_y),
         "width": max(1, play_x - margin_l - margin_r),
-        "height": max(1, round((safe_bot - safe_top) * scale_y)),
-        "bottom_margin": max(0, round((canvas_h - safe_bot) * scale_y)),
+        "height": max(1, round((y_bot - safe_top) * scale_y)),
+        "bottom_margin": max(0, round((canvas_h - y_bot) * scale_y)),
     }
 
 
@@ -193,9 +177,7 @@ def _subtitle_display_text(text):
     Narration/TTS source text stays untouched; this is applied only to SRT/ASS cue text.
     Closing quotes/brackets are preserved, so 「原声台词。」 renders as 「原声台词」.
     """
-    text = str(text or "").strip()
-    if not text:
-        return ""
+    text = text.strip()
     suffix = ""
     while text and text[-1] in _SUBTITLE_CLOSING_QUOTES:
         suffix = text[-1] + suffix
@@ -206,8 +188,7 @@ def _subtitle_display_text(text):
 
 def _subtitle_chunk_weight(text):
     """Weight raw subtitle chunks for timing, independent of display punctuation cleanup."""
-    core = re.sub(r"\s+", "", str(text or ""))
-    return max(1, len(core))
+    return max(1, len(re.sub(r"\s+", "", text)))
 
 
 def _subtitle_entry_chunks(raw_chunks):
@@ -217,9 +198,8 @@ def _subtitle_entry_chunks(raw_chunks):
     on the emitted text, while quote-only suffix chunks are folded into the previous cue
     so a closing bracket never renders alone.
     """
-    chunks = [str(c).strip() for c in (raw_chunks or []) if str(c).strip()]
     out = []
-    for i, chunk in enumerate(chunks):
+    for chunk in raw_chunks:
         display = _subtitle_display_text(chunk)
         if not display:
             continue
@@ -231,16 +211,11 @@ def _subtitle_entry_chunks(raw_chunks):
     return out
 
 
-def _normalize_subtitle_text(s):
+def _normalize_subtitle_text(text):
     """Normalize Chinese em-dashes in burned subtitle text: a run of one-or-more "—" (incl. "——")
     collapses to a single "，". Then collapse any resulting double commas ("，，"→"，") so the dash
-    swap never leaves a doubled comma. Empty/None passes through as "" unchanged."""
-    text = str(s or "")
-    if not text:
-        return text
-    text = re.sub(r"—+", "，", text)
-    text = re.sub(r"，{2,}", "，", text)
-    return text
+    swap never leaves a doubled comma."""
+    return re.sub(r"，{2,}", "，", re.sub(r"—+", "，", text))
 
 
 def _split_subtitle_chunks(text, max_chars):
@@ -252,7 +227,7 @@ def _split_subtitle_chunks(text, max_chars):
     chunks of at most `max_chars` — each chunk renders as ONE readable line synced to its slice of
     the block's audio. Punctuation stays attached here for lossless splitting; the display layer
     strips terminal sentence marks per subtitle-cue style."""
-    text = str(text).strip()
+    text = text.strip()
     if not text:
         return []
     breakers = "，。！？、；：…—,.!?;:"
@@ -298,42 +273,14 @@ def _subtitle_entries(narration):
     Each placed segment is split into short one-line chunks and its played window
     [actual_place_start, actual_place_end] is distributed across them in proportion to character
     count — karaoke-style timing that keeps each line on screen only while it is roughly being
-    spoken, instead of holding a whole paragraph for the segment's full duration."""
-    max_chars = int(CONFIG.get("subtitle_max_chars", 20))
+    spoken, instead of holding a whole paragraph for the segment's full duration. Segments that
+    were not placed have a zero-width window and therefore produce no cue."""
+    max_chars = CONFIG["subtitle_max_chars"]
     entries = []
     for seg in narration:
-        if not isinstance(seg, dict):
-            continue
-        text = str(seg.get("spoken_text") or seg.get("narration", "")).strip()
-        if not text:
-            continue
-        try:
-            start = float(seg.get("actual_place_start", seg["start"]))
-            end = float(seg.get("actual_place_end", seg["end"]))
-        except (KeyError, TypeError, ValueError):
-            continue
-        if end - start < 0.1:
-            continue
-        chunks = _subtitle_entry_chunks(_split_subtitle_chunks(text, max_chars))
-        if not chunks:
-            continue
-        if len(chunks) == 1:
-            entries.append({"start": start, "end": end, "text": chunks[0]["text"]})
-            continue
-        total_chars = sum(_subtitle_chunk_weight(c["raw"]) for c in chunks) or 1
-        span = end - start
-        cursor = start
-        for i, chunk in enumerate(chunks):
-            weight = _subtitle_chunk_weight(chunk["raw"])
-            chunk_end = end if i == len(chunks) - 1 else cursor + span * (weight / total_chars)
-            if i > 0 and chunk_end - cursor < 0.05:
-                # slice too short to show on its own — fold the text into the previous line of THIS
-                # block (i>0) and extend its end, so no chunk is ever silently dropped.
-                entries[-1]["text"] += chunk["text"]
-                entries[-1]["end"] = chunk_end
-            else:
-                entries.append({"start": cursor, "end": chunk_end, "text": chunk["text"]})
-            cursor = chunk_end
+        text = seg.get("spoken_text", seg["narration"])
+        start, end = float(seg["actual_place_start"]), float(seg["actual_place_end"])
+        entries.extend(_distribute_chunks(_split_subtitle_chunks(text, max_chars), start, end))
     return entries
 
 
@@ -341,14 +288,15 @@ def _distribute_chunks(chunks, start, end):
     """Distribute [start,end] across raw chunks while emitting display-clean text.
 
     Terminal subtitle punctuation is visual-only: it is stripped from final cue text,
-    but the raw split chunks remain the timing topology.
+    but the raw split chunks remain the timing topology. A slice too short to show on its
+    own is folded into the previous line of the same block, so no chunk is ever dropped.
     """
     chunks = _subtitle_entry_chunks(chunks)
     if not chunks or end - start < 0.1:
         return []
     if len(chunks) == 1:
         return [{"start": start, "end": end, "text": chunks[0]["text"]}]
-    total_chars = sum(_subtitle_chunk_weight(c["raw"]) for c in chunks) or 1
+    total_chars = sum(_subtitle_chunk_weight(c["raw"]) for c in chunks)
     span = end - start
     out, cursor = [], start
     for i, chunk in enumerate(chunks):
@@ -365,12 +313,11 @@ def _distribute_chunks(chunks, start, end):
 
 def _bracketed_original_chunks(text, start, end, max_chars):
     """Split original dialogue into timed chunks wrapped in 「」 for visual distinction."""
-    raw = str(text).strip()
+    raw = text.strip()
     if raw.startswith("「") and raw.endswith("」"):
         raw = raw[1:-1].strip()
     chunks = _split_subtitle_chunks(raw, max_chars)
     if chunks:
-        chunks = list(chunks)
         chunks[0] = "「" + chunks[0]
         chunks[-1] = chunks[-1] + "」"
     return _distribute_chunks(chunks, start, end)

package/lib/video-recap/skills/video-assemble/scripts/subtitle_render.py

@@ -6,21 +6,16 @@ from subtitle_core import (
     _seconds_to_ass_time,
     _seconds_to_srt_time,
     _style_for_measured_subtitle_band,
-    _subtitle_entries,
     _subtitle_style_config,
 )
 
-def _generate_srt(narration, work_dir, video_duration=None):
-    """将解说脚本转为 SRT 字幕文件，使用实际音频放置时间。video_duration 给定时，原声留白处补烧原声字幕。"""
+def _generate_srt(narration, work_dir, video_duration):
+    """将解说脚本转为 SRT 字幕文件，使用实际音频放置时间；原声留白处补烧原声字幕。"""
     srt_lines = []
-    entries = (_subtitle_entries(narration) if video_duration is None
-               else _combined_subtitle_entries(narration, work_dir, video_duration))
     # entries are already split into short one-line chunks, so no wrapping here.
-    for idx, entry in enumerate(entries, start=1):
-        start_ts = _seconds_to_srt_time(entry["start"])
-        end_ts = _seconds_to_srt_time(entry["end"])
+    for idx, entry in enumerate(_combined_subtitle_entries(narration, work_dir, video_duration), start=1):
         srt_lines.append(str(idx))
-        srt_lines.append(f"{start_ts} --> {end_ts}")
+        srt_lines.append(f"{_seconds_to_srt_time(entry['start'])} --> {_seconds_to_srt_time(entry['end'])}")
         srt_lines.append(_normalize_subtitle_text(entry["text"]))
         srt_lines.append("")
     srt_path = work_dir / "subtitles.srt"
@@ -31,7 +26,7 @@ def _generate_srt(narration, work_dir, video_duration=None):
 def _escape_ass_text(text):
     """Escape user text for an ASS dialogue Text field."""
     return (
-        str(text)
+        text
         .replace("\\", "\\\\")
         .replace("{", "\\{")
         .replace("}", "\\}")
@@ -41,10 +36,10 @@ def _escape_ass_text(text):
     )
 
 
-def _generate_ass(narration, work_dir, video_duration=None, canvas=None):
-    """Generate an ASS subtitle file for readable hard-sub rendering. video_duration given ⇒ also
-    burn the original dialogue (from ASR) during the original-audio gaps. canvas ({"width","height"})
-    scales the style to the real frame so portrait/竖屏 subtitles are not stretched."""
+def _generate_ass(narration, work_dir, video_duration, canvas):
+    """Generate an ASS subtitle file for readable hard-sub rendering, including the original
+    dialogue during the original-audio gaps. canvas ({"width","height"}) scales the style to the
+    real frame so portrait/竖屏 subtitles are not stretched."""
     style = _style_for_measured_subtitle_band(_subtitle_style_config(canvas), canvas)
     ass_lines = [
         "[Script Info]",
@@ -72,10 +67,8 @@ def _generate_ass(narration, work_dir, video_duration=None, canvas=None):
         "[Events]",
         "Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text",
     ]
-    entries = (_subtitle_entries(narration) if video_duration is None
-               else _combined_subtitle_entries(narration, work_dir, video_duration))
     # entries are already split into short one-line chunks, so no wrapping here.
-    for entry in entries:
+    for entry in _combined_subtitle_entries(narration, work_dir, video_duration):
         text = _escape_ass_text(_normalize_subtitle_text(entry["text"]))
         ass_lines.append(
             "Dialogue: 0,"

package/lib/video-recap/skills/video-assemble/scripts/timeline.py

@@ -38,8 +38,8 @@ def _ceil_time(value, digits=4):
 
 def build_timeline(canvas, duration_s, video_clips, narration_segments,
                    bgm=None, ducking=None, subtitle_segments=None,
-                   image_segments=None, resource_packages=None,
-                   style_presets=None, extra_tracks=None):
+                   image_segments=(), resource_packages=None,
+                   style_presets=None, extra_tracks=()):
     """Assemble a Timeline dict from resolved placement data.
 
     canvas: {"width", "height", "fps"}
@@ -48,7 +48,8 @@ def build_timeline(canvas, duration_s, video_clips, narration_segments,
                  "timeline_start", "timeline_end"}] (cut mode: one per clip;
                  full mode: a single clip spanning the whole video).
     narration_segments: placed beats [{"source_path", "timeline_start",
-                 "timeline_end", "text", "overlaps_speech", "gain"?}].
+                 "timeline_end", "text", "overlaps_speech", "gain"?}]; a zero-width
+                 beat (an unplaced segment) is skipped.
     subtitle_segments: optional display-ready text cues [{"text", "timeline_start",
                  "timeline_end"}]. When present, this is authoritative for the
                  subtitle/text track; narration segment text remains raw editor metadata.
@@ -57,27 +58,21 @@ def build_timeline(canvas, duration_s, video_clips, narration_segments,
              automation; None disables original ducking (flat original). `bridge` holds
              the duck across inter-beat gaps shorter than it (defaults to 2*fade).
     """
-    windows = [(float(s["timeline_start"]), float(s["timeline_end"]))
-               for s in narration_segments
-               if s.get("timeline_end", 0) > s.get("timeline_start", 0)]
-    duck_windows = [
-        (
-            float(s["timeline_start"]),
-            max(float(s["timeline_end"]), float(s.get("source_duck_end", s["timeline_end"]))),
-            float((ducking or {}).get("speech" if s.get("overlaps_speech", True) else "quiet", 1.0)),
-            max(
-                float(s["timeline_end"]),
-                float(s.get("source_duck_end", s["timeline_end"])),
-                float(s.get(
-                    "source_restore_at",
-                    max(float(s["timeline_end"]), float(s.get("source_duck_end", s["timeline_end"])))
-                    + float((ducking or {}).get("fade", 0.0)),
-                )),
-            ),
-        )
-        for s in narration_segments
-        if s.get("timeline_end", 0) > s.get("timeline_start", 0)
+    placed = [
+        s for s in narration_segments
+        if float(s["timeline_end"]) > float(s["timeline_start"])
     ]
+    windows = [(float(s["timeline_start"]), float(s["timeline_end"])) for s in placed]
+    duck_windows = []
+    if ducking is not None:
+        for s in placed:
+            end = float(s["timeline_end"])
+            hold_end = max(end, float(s.get("source_duck_end", end)))
+            restore_at = max(
+                hold_end, float(s.get("source_restore_at", hold_end + float(ducking["fade"])))
+            )
+            level = float(ducking["speech" if s.get("overlaps_speech", True) else "quiet"])
+            duck_windows.append((float(s["timeline_start"]), hold_end, level, restore_at))
 
     # --- video track: each clip carries its original audio + ducking automation
     video_clip_objs = []
@@ -112,14 +107,11 @@ def build_timeline(canvas, duration_s, video_clips, narration_segments,
 
     # --- narration track
     narr_segs = []
-    for s in narration_segments:
-        ts, te = float(s["timeline_start"]), float(s["timeline_end"])
-        if te <= ts:
-            continue
+    for s in placed:
         narration = {
             "source_path": s["source_path"],
-            "timeline_start": round(ts, 4),
-            "timeline_end": _ceil_time(te, 4),
+            "timeline_start": round(float(s["timeline_start"]), 4),
+            "timeline_end": _ceil_time(s["timeline_end"], 4),
             "gain": round(float(s.get("gain", 1.0)), 4),
             "text": s.get("text", ""),
             "overlaps_speech": bool(s.get("overlaps_speech", True)),
@@ -138,7 +130,7 @@ def build_timeline(canvas, duration_s, video_clips, narration_segments,
     if bgm and bgm.get("source_path"):
         base = float(bgm.get("volume", 0.18))
         duck = float(bgm.get("ducking_volume", 0.10))
-        fade = float(bgm.get("fade") or (ducking or {}).get("fade", 0.25))
+        fade = float(bgm.get("fade", (ducking or {}).get("fade", 0.25)))
         kfs = ducking_keyframes(windows, base, duck, fade, 0.0, duration_s,
                                 bridge=(ducking or {}).get("bridge"))
         tracks.append({
@@ -152,21 +144,17 @@ def build_timeline(canvas, duration_s, video_clips, narration_segments,
             }],
         })
 
-    # --- subtitle (text) track
+    # --- subtitle (text) track: empty cues carry nothing to display
     text_source = subtitle_segments if subtitle_segments is not None else narration_segments
     text_segs = []
-    for s in text_source or []:
-        if not isinstance(s, dict) or not s.get("text"):
-            continue
-        try:
-            ts = float(s["timeline_start"])
-            te = float(s["timeline_end"])
-        except (KeyError, TypeError, ValueError):
+    for s in text_source:
+        if not s.get("text"):
             continue
+        ts, te = float(s["timeline_start"]), float(s["timeline_end"])
         if te <= ts:
             continue
         text_segment = {
-            "text": s.get("text", ""),
+            "text": s["text"],
             "timeline_start": round(ts, 4),
             "timeline_end": round(te, 4),
         }
@@ -179,15 +167,15 @@ def build_timeline(canvas, duration_s, video_clips, narration_segments,
 
     # --- local image overlays (optional, timeline schema v2)
     images = []
-    for segment in image_segments or []:
+    for segment in image_segments:
         if not isinstance(segment, dict) or not segment.get("source_path"):
             continue
         try:
-            ts = float(segment["timeline_start"])
-            te = float(segment["timeline_end"])
+            ts = max(0.0, float(segment["timeline_start"]))
+            te = min(float(duration_s), float(segment["timeline_end"]))
         except (KeyError, TypeError, ValueError):
             continue
-        if te <= ts:
+        if not math.isfinite(ts) or not math.isfinite(te) or te <= ts:
             continue
         scale = segment.get("scale") if isinstance(segment.get("scale"), dict) else {}
         position = segment.get("position") if isinstance(segment.get("position"), dict) else {}
@@ -218,15 +206,12 @@ def build_timeline(canvas, duration_s, video_clips, narration_segments,
     if images:
         tracks.append({"kind": "image", "name": "image", "segments": images})
 
-    for track in extra_tracks or []:
-        if not isinstance(track, dict):
-            raise TypeError("extra_tracks entries must be objects")
-        tracks.append(deepcopy(track))
+    tracks.extend(deepcopy(track) for track in extra_tracks)
 
     timeline = {
         "schema_version": SCHEMA_VERSION,
         "canvas": {"width": int(canvas["width"]), "height": int(canvas["height"]),
-                   "fps": float(canvas.get("fps", 30))},
+                   "fps": float(canvas["fps"])},
         "duration": round(float(duration_s), 4),
         "tracks": tracks,
     }

package/lib/video-recap/skills/video-assemble/scripts/timeline_emit.py

@@ -4,7 +4,7 @@ from pathlib import Path
 
 from audio_mix import _seg_place_window
 from lib import CONFIG, log
-from media import _build_video_clips, _probe_canvas
+from media import _build_video_clips
 from source_subtitles import _combined_subtitle_entries
 from timeline import build_timeline, save_timeline
 
@@ -25,14 +25,11 @@ def _timeline_subtitle_segments(tts_segments, work_dir, duration_s):
     ]
 
 
-def _emit_timeline(input_video, tts_segments, work_dir, duration_s, has_bgm):
+def _emit_timeline(input_video, tts_segments, work_dir, duration_s, canvas, has_bgm):
     """Build and persist the backend-neutral multi-track timeline.json."""
-    canvas = _probe_canvas(input_video)
     video_clips = _build_video_clips(input_video, work_dir, duration_s)
     narration_segments = []
     for seg in tts_segments:
-        if not isinstance(seg, dict):
-            continue
         s, e = _seg_place_window(seg)
         if e <= s:
             continue
@@ -40,9 +37,9 @@ def _emit_timeline(input_video, tts_segments, work_dir, duration_s, has_bgm):
             # JianYing must consume the exact WAV written into narration.wav. In
             # particular, a tempo-adjusted beat cannot reference its longer pre-fit
             # source or the editor will trim its final words at timeline_end.
-            "source_path": seg.get("placed_audio_path") or seg.get("audio_path", ""),
+            "source_path": seg["placed_audio_path"],
             "timeline_start": s, "timeline_end": e,
-            "text": seg.get("narration", ""),
+            "text": seg["narration"],
             "overlaps_speech": seg.get("overlaps_speech", True),
             "gain": 1.0,
         }
@@ -50,31 +47,28 @@ def _emit_timeline(input_video, tts_segments, work_dir, duration_s, has_bgm):
             if key in seg:
                 narration_item[key] = seg[key]
         narration_segments.append(narration_item)
-    fade = CONFIG.get("duck_fade_seconds", 0.3)
+    fade = CONFIG["duck_fade_seconds"]
     bgm = None
     if has_bgm:
-        bgm = {"source_path": CONFIG.get("bgm_path", ""),
-               "volume": CONFIG.get("bgm_volume", 0.18),
-               "ducking_volume": CONFIG.get("bgm_ducking_volume", 0.10),
+        bgm = {"source_path": CONFIG["bgm_path"],
+               "volume": CONFIG["bgm_volume"],
+               "ducking_volume": CONFIG["bgm_ducking_volume"],
                "fade": fade}
     # carry ducking automation whenever ducking is on at all; even under sidechain
     # mode the draft gets editable volume keyframes (ffmpeg stays the canonical mix)
     ducking = None
-    if CONFIG.get("ducking_mode", "fixed") != "none":
-        ducking = {"idle": CONFIG.get("idle_orig_volume", 1.0),
-                   "speech": CONFIG.get("speech_ducking_volume", 0.2),
-                   "quiet": CONFIG.get("zone_ducking_volume", 0.12),
+    if CONFIG["ducking_mode"] != "none":
+        ducking = {"idle": CONFIG["idle_orig_volume"],
+                   "speech": CONFIG["speech_ducking_volume"],
+                   "quiet": CONFIG["zone_ducking_volume"],
                    "fade": fade,
-                   "bridge": CONFIG.get("duck_bridge_seconds", 1.5)}
+                   "bridge": CONFIG["duck_bridge_seconds"]}
     subtitle_segments = _timeline_subtitle_segments(tts_segments, work_dir, duration_s)
     timeline = build_timeline(canvas, duration_s, video_clips,
                               narration_segments, bgm=bgm, ducking=ducking,
                               subtitle_segments=subtitle_segments)
     degraded = [
-        {
-            "source_path": clip.get("source_path"),
-            "reason": clip.get("provenance_reason") or "unknown",
-        }
+        {"source_path": clip["source_path"], "reason": clip["provenance_reason"]}
         for clip in video_clips
         if clip.get("provenance_degraded")
     ]