@oh-story/dsh 0.1.7 → 0.1.9

package/lib/video-recap/skills/video-cut/scripts/cut_cli.py

@@ -111,9 +111,7 @@ def main():
     # implements padding — and it used to read the CLI flag alone, so setting the env var did
     # nothing at all while `clip_padding_source: "env"` reported otherwise. CLI still wins.
     clip_padding = (
-        args.clip_padding
-        if args.clip_padding is not None
-        else float(CONFIG.get("clip_padding", 0.0) or 0.0)
+        args.clip_padding if args.clip_padding is not None else CONFIG["clip_padding"]
     )
 
     work_dir = Path(args.work_dir)
@@ -153,34 +151,32 @@ def main():
     # Keep boundaries off the original footage's hard cuts (avoids 闪烁 at the edit point).
     # This visual-only pass runs FIRST. The sentence/quiet pass below is the final authority:
     # a prettier edit point must never move the final boundary back inside a spoken sentence.
-    if sources_manifest is None and CONFIG.get("scene_cut_snap", True):
+    if sources_manifest is None and CONFIG["scene_cut_snap"]:
         validated_plan = snap_clips_off_shot_changes(
             validated_plan,
             args.video,
-            video_duration=video_duration,
-            margin=CONFIG.get("scene_cut_snap_margin", 0.5),
-            threshold=CONFIG.get("scene_cut_detect_threshold", 0.4),
+            margin=CONFIG["scene_cut_snap_margin"],
+            threshold=CONFIG["scene_cut_detect_threshold"],
         )
 
     if sources_manifest is None:
-        silence_periods = _load_silence_for_source(work_dir, None)
-        sentence_boundaries = _load_sentence_boundary_windows(work_dir)
         safe_boundaries = _combine_boundary_windows(
-            silence_periods, sentence_boundaries
+            _load_silence_for_source(work_dir, None),
+            _load_sentence_boundary_windows(work_dir),
         )
-        if CONFIG.get("snap_clip_line_end", True):
+        if CONFIG["snap_clip_line_end"]:
             validated_plan = snap_clip_starts_to_lines(
                 validated_plan,
                 safe_boundaries,
                 video_duration,
-                CONFIG.get("clip_start_snap_max_prepend", 1.8),
-                max_trim=CONFIG.get("clip_start_snap_max_trim", 0.35),
+                CONFIG["clip_start_snap_max_prepend"],
+                max_trim=CONFIG["clip_start_snap_max_trim"],
             )
             validated_plan = snap_clip_ends_to_lines(
                 validated_plan,
                 safe_boundaries,
                 video_duration,
-                CONFIG.get("clip_snap_max_extend", 2.0),
+                CONFIG["clip_snap_max_extend"],
             )
         validated_plan = enforce_clip_sentence_boundaries(
             validated_plan,
@@ -194,54 +190,50 @@ def main():
     if sources_manifest is not None:
         validated_plan = snap_multi_source_clips(
             validated_plan,
-            validated_plan.get("sources", {}),
+            validated_plan["sources"],
             work_dir,
-            line_max_extend=CONFIG.get("clip_snap_max_extend", 2.0),
-            scene_margin=CONFIG.get("scene_cut_snap_margin", 0.5),
-            scene_threshold=CONFIG.get("scene_cut_detect_threshold", 0.4),
-            do_line_snap=CONFIG.get("snap_clip_line_end", True),
-            do_scene_snap=CONFIG.get("scene_cut_snap", True),
-            start_max_prepend=CONFIG.get("clip_start_snap_max_prepend", 1.8),
-            start_max_trim=CONFIG.get("clip_start_snap_max_trim", 0.35),
+            line_max_extend=CONFIG["clip_snap_max_extend"],
+            scene_margin=CONFIG["scene_cut_snap_margin"],
+            scene_threshold=CONFIG["scene_cut_detect_threshold"],
+            do_line_snap=CONFIG["snap_clip_line_end"],
+            do_scene_snap=CONFIG["scene_cut_snap"],
+            start_max_prepend=CONFIG["clip_start_snap_max_prepend"],
+            start_max_trim=CONFIG["clip_start_snap_max_trim"],
         )
 
-    if isinstance(validated_plan, dict):
-        validated_plan["raw_plan_fingerprint"] = value_fingerprint(raw_plan)
-        validated_plan.setdefault("qc", {})["join_fade_ms"] = round(
-            max(0.0, float(CONFIG.get("clip_join_audio_fade_ms", 30.0) or 0.0)), 3
-        )
-        source_paths = []
-        for clip in validated_plan.get("clips", []):
-            source_path = str(clip.get("source_path") or "")
-            if source_path and source_path not in source_paths:
-                source_paths.append(source_path)
-        if not source_paths:
-            source_paths = [str(args.video)]
-        _, _, _, geometry_qc = _select_output_geometry(
-            source_paths, validated_plan.get("clips", [])
-        )
-        validated_plan["qc"]["output_geometry"] = geometry_qc
-        validated_plan["qc"]["output_geometry_reason"] = geometry_qc.get("reason")
-        allow_duration_drift = bool(args.allow_duration_drift or args.allow_sparse_cut)
-        drift_source = (
-            "--allow-duration-drift"
-            if args.allow_duration_drift
-            else ("--allow-sparse-cut" if args.allow_sparse_cut else None)
-        )
-        update_cut_qc(
-            validated_plan,
-            allow_duration_drift=allow_duration_drift,
-            duration_drift_allowed_by=drift_source,
-        )
-        update_delivery_qc(
-            validated_plan,
-            source_paths=source_paths,
-            output_path=work_dir / "edited_source.mp4",
+    validated_plan["raw_plan_fingerprint"] = value_fingerprint(raw_plan)
+    validated_plan.setdefault("qc", {})["join_fade_ms"] = round(
+        CONFIG["clip_join_audio_fade_ms"], 3
+    )
+    # Single-source clips carry no source_path; the CLI video is the only input.
+    source_paths = list(
+        dict.fromkeys(
+            clip["source_path"] for clip in validated_plan["clips"] if "source_path" in clip
         )
+    ) or [str(args.video)]
+    _, _, _, geometry_qc = _select_output_geometry(source_paths, validated_plan["clips"])
+    validated_plan["qc"]["output_geometry"] = geometry_qc
+    validated_plan["qc"]["output_geometry_reason"] = geometry_qc["reason"]
+    allow_duration_drift = bool(args.allow_duration_drift or args.allow_sparse_cut)
+    drift_source = (
+        "--allow-duration-drift"
+        if args.allow_duration_drift
+        else ("--allow-sparse-cut" if args.allow_sparse_cut else None)
+    )
+    update_cut_qc(
+        validated_plan,
+        allow_duration_drift=allow_duration_drift,
+        duration_drift_allowed_by=drift_source,
+    )
+    update_delivery_qc(
+        validated_plan,
+        source_paths=source_paths,
+        output_path=work_dir / "edited_source.mp4",
+    )
     (work_dir / "clip_plan_validated.json").write_text(
         json.dumps(validated_plan, ensure_ascii=False, indent=2), encoding="utf-8"
     )
-    if (validated_plan.get("qc") or {}).get("blocking"):
+    if validated_plan["qc"].get("blocking"):
         raise SystemExit(
             "clip_plan QC blocking: fix unsafe sentence boundaries or target-duration drift. "
             "Only duration drift can be explicitly accepted with --allow-duration-drift; "
@@ -305,12 +297,12 @@ def main():
         )
         for w in report["warnings"]:
             log(f"  ⚠️ 剪后解说同步: {w['message']} [{w['code']}]")
-        if report.get("clamped_count"):
+        if report["clamped_count"]:
             raise SystemExit(
                 "剪后解说有句子被 clip 边界裁断。移动 clip_plan 边界或重写整句后重跑；"
                 "--allow-sparse-cut 不能跳过语句完整性门禁。详见 narration_mapped_lint.json"
             )
-        if report.get("blocking") and not args.allow_sparse_cut:
+        if report["blocking"] and not args.allow_sparse_cut:
             raise SystemExit(
                 "剪后解说与保留片段对不上：丢弃过多或成片过稀疏。改 narration.json / clip_plan.json "
                 "让解说落在保留片段内后重跑，或加 --allow-sparse-cut 接受当前映射。详见 narration_mapped_lint.json"

package/lib/video-recap/skills/video-cut/scripts/cut_contract.py

@@ -114,14 +114,11 @@ def value_fingerprint(value):
 
 def cut_plan_fingerprint(validated_plan):
     """Hash the exact normalized clip plan that determines edited_source.mp4 bytes."""
-    if isinstance(validated_plan, dict):
-        payload = dict(validated_plan)
-        # Provenance for raw-plan freshness is not part of the edited media bytes.
-        payload.pop("raw_plan_fingerprint", None)
-        # QC is observability derived from the media plan, not an input range decision.
-        payload.pop("qc", None)
-    else:
-        payload = validated_plan
+    payload = dict(validated_plan)
+    # Provenance for raw-plan freshness is not part of the edited media bytes.
+    payload.pop("raw_plan_fingerprint", None)
+    # QC is observability derived from the media plan, not an input range decision.
+    payload.pop("qc", None)
     return value_fingerprint(payload)
 
 
@@ -169,26 +166,19 @@ def _load_edited_source_meta(output_path):
     if not meta_path.exists():
         return None
     try:
-        data = json.loads(meta_path.read_text(encoding="utf-8"))
+        meta = json.loads(meta_path.read_text(encoding="utf-8"))
     except (OSError, ValueError):
         return None
-    return data if isinstance(data, dict) else None
+    return meta if isinstance(meta, dict) else None
 
 
 def _source_fingerprints_for_plan(validated_plan, input_video=None):
     """Fingerprint every media file that can affect edited_source.mp4 bytes."""
-    paths = []
-    for clip in (
-        validated_plan.get("clips", []) if isinstance(validated_plan, dict) else []
-    ):
-        if clip.get("source_path"):
-            paths.append(str(clip["source_path"]))
+    # Single-source plans carry no per-clip source_path; the CLI video is the only input.
+    paths = {clip["source_path"] for clip in validated_plan["clips"] if "source_path" in clip}
     if not paths and input_video is not None:
-        paths.append(str(input_video))
-    fingerprints = {}
-    for path in sorted(set(paths)):
-        fingerprints[str(Path(path))] = file_fingerprint(path)
-    return fingerprints
+        paths.add(str(input_video))
+    return {str(Path(path)): file_fingerprint(path) for path in sorted(paths)}
 
 
 def edited_source_render_cache_payload():
@@ -200,9 +190,7 @@ def edited_source_render_cache_payload():
     return {
         "render_algorithm_version": EDITED_SOURCE_RENDER_ALGORITHM_VERSION,
         "geometry_render_algorithm_version": GEOMETRY_RENDER_ALGORITHM_VERSION,
-        "clip_join_audio_fade_ms": round(
-            max(0.0, float(CONFIG.get("clip_join_audio_fade_ms", 30.0) or 0.0)), 3
-        ),
+        "clip_join_audio_fade_ms": round(CONFIG["clip_join_audio_fade_ms"], 3),
     }
 
 
@@ -211,38 +199,17 @@ def edited_source_render_fingerprint():
 
 
 def _write_edited_source_meta(output_path, validated_plan, input_video=None):
-    meta_path = _edited_source_meta_path(output_path)
-    source_fingerprints = _source_fingerprints_for_plan(validated_plan, input_video)
-    has_plan_sources = any(
-        clip.get("source_path")
-        for clip in (
-            validated_plan.get("clips", []) if isinstance(validated_plan, dict) else []
-        )
-    )
-    legacy_source_fp = (
-        file_fingerprint(input_video)
-        if input_video is not None
-        and not has_plan_sources
-        and len(source_fingerprints) == 1
-        else None
-    )
     meta = {
         "schema_version": 2,
         "clip_plan_fingerprint": cut_plan_fingerprint(validated_plan),
         "render_fingerprint": edited_source_render_fingerprint(),
         "render_cache": edited_source_render_cache_payload(),
-        "source_fingerprints": source_fingerprints,
+        "source_fingerprints": _source_fingerprints_for_plan(validated_plan, input_video),
         "edited_source_fingerprint": file_fingerprint(output_path),
-        "total_duration": validated_plan.get("total_duration"),
-        "clip_count": len(validated_plan.get("clips", [])),
+        "total_duration": validated_plan["total_duration"],
+        "clip_count": len(validated_plan["clips"]),
     }
-    delivery_qc = (validated_plan.get("qc") or {}).get("delivery_qc")
-    if delivery_qc:
-        meta["delivery_qc"] = delivery_qc
-    # Preserve the legacy key for existing single-source callers/tests/metadata readers.
-    if legacy_source_fp is not None:
-        meta["source_video_fingerprint"] = legacy_source_fp
-    meta_path.write_text(
+    _edited_source_meta_path(output_path).write_text(
         json.dumps(meta, ensure_ascii=False, indent=2), encoding="utf-8"
     )
 
@@ -253,20 +220,20 @@ def should_reuse_edited_source(output_path, validated_plan, input_video=None):
     if not output_path.exists():
         return False
     meta = _load_edited_source_meta(output_path)
-    if not meta or meta.get("clip_plan_fingerprint") != cut_plan_fingerprint(
-        validated_plan
+    if meta is None:
+        return False
+    if (
+        meta.get("clip_plan_fingerprint") != cut_plan_fingerprint(validated_plan)
+        or meta.get("render_fingerprint") != edited_source_render_fingerprint()
+        or meta.get("source_fingerprints")
+        != _source_fingerprints_for_plan(validated_plan, input_video)
     ):
         return False
-    if meta.get("render_fingerprint") != edited_source_render_fingerprint():
+    try:
+        output_fingerprint = file_fingerprint(output_path)
+    except OSError:
         return False
-    expected_sources = _source_fingerprints_for_plan(validated_plan, input_video)
-    meta_sources = meta.get("source_fingerprints")
-    if meta_sources is None and input_video is not None:
-        meta_sources = {str(Path(input_video)): meta.get("source_video_fingerprint")}
-    return bool(
-        meta_sources == expected_sources
-        and meta.get("edited_source_fingerprint") == file_fingerprint(output_path)
-    )
+    return meta.get("edited_source_fingerprint") == output_fingerprint
 
 
 def _manifest_source_entries(sources_manifest):
@@ -313,9 +280,11 @@ def normalize_sources_manifest(sources_manifest):
         if duration in (None, ""):
             duration = get_video_duration(source_path)
         try:
-            duration = max(0.0, float(duration or 0.0))
+            duration = float(duration)
         except (TypeError, ValueError) as exc:
             raise ValueError(f"source {source_id} has invalid duration") from exc
+        if duration <= 0:
+            raise ValueError(f"source {source_id} has invalid duration")
         sources[source_id] = {
             "source_id": source_id,
             "source_path": str(source_path),
@@ -358,8 +327,8 @@ def normalize_multi_source_clip_plan(
     if not isinstance(raw_clips, list):
         raise ValueError("clip_plan.json field `clips` must be an array")
 
-    padding = max(0.0, float(clip_padding or 0.0))
-    min_duration = max(0.05, float(min_clip_duration or 0.05))
+    padding = max(0.0, clip_padding)
+    min_duration = max(0.05, min_clip_duration)
     clips = []
     source_ranges = {}
     cursor = 0.0
@@ -422,9 +391,7 @@ def normalize_multi_source_clip_plan(
     plan = {
         "clips": clips,
         "total_duration": total_duration,
-        "target_duration": round(float(target_duration), 3)
-        if target_duration
-        else None,
+        "target_duration": round(target_duration, 3) if target_duration else None,
         "sources": {
             sid: {
                 "source_path": s["source_path"],
@@ -442,7 +409,7 @@ def normalize_multi_source_clip_plan(
     if target_duration and total_duration > target_duration * 1.15:
         plan["warning"] = (
             f"validated clips total {total_duration:.1f}s exceeds target "
-            f"{float(target_duration):.1f}s by more than 15%"
+            f"{target_duration:.1f}s by more than 15%"
         )
         log(f"警告: {plan['warning']}")
     return plan
@@ -478,9 +445,8 @@ def normalize_clip_plan(
     if not isinstance(raw_clips, list):
         raise ValueError("clip_plan.json field `clips` must be an array")
 
-    video_duration = max(0.0, float(video_duration or 0.0))
-    padding = max(0.0, float(clip_padding or 0.0))
-    min_duration = max(0.05, float(min_clip_duration or 0.05))
+    padding = max(0.0, clip_padding)
+    min_duration = max(0.05, min_clip_duration)
     clips = []
     source_ranges = []
     cursor = 0.0
@@ -530,16 +496,14 @@ def normalize_clip_plan(
     plan = {
         "clips": clips,
         "total_duration": total_duration,
-        "target_duration": round(float(target_duration), 3)
-        if target_duration
-        else None,
+        "target_duration": round(target_duration, 3) if target_duration else None,
         "source_duration": round(video_duration, 3),
         "allow_overlap": bool(allow_overlap),
     }
     if target_duration and total_duration > target_duration * 1.15:
         plan["warning"] = (
             f"validated clips total {total_duration:.1f}s exceeds target "
-            f"{float(target_duration):.1f}s by more than 15%"
+            f"{target_duration:.1f}s by more than 15%"
         )
         log(f"警告: {plan['warning']}")
     return plan

package/lib/video-recap/skills/video-cut/scripts/cut_render.py

@@ -13,25 +13,11 @@ from sentence_boundaries import _continuous_source_join
 
 
 def _audio_segment_filter(
-    label_in,
-    label_out,
-    start,
-    end,
-    duration,
-    fade_ms,
-    extra_filters="",
-    fade_in_ms=None,
-    fade_out_ms=None,
+    label_in, label_out, start, end, duration, fade_in_ms, fade_out_ms, extra_filters=""
 ):
-    max_fade = max(0.0, float(duration or 0.0)) / 2
-    fade_in = max(
-        0.0,
-        min(float(fade_ms if fade_in_ms is None else fade_in_ms) / 1000.0, max_fade),
-    )
-    fade_out = max(
-        0.0,
-        min(float(fade_ms if fade_out_ms is None else fade_out_ms) / 1000.0, max_fade),
-    )
+    max_fade = duration / 2
+    fade_in = max(0.0, min(fade_in_ms / 1000.0, max_fade))
+    fade_out = max(0.0, min(fade_out_ms / 1000.0, max_fade))
     base = f"{label_in}atrim=start={start:.3f}:end={end:.3f},asetpts=PTS-STARTPTS"
     if fade_in > 0:
         base += f",afade=t=in:st=0:d={fade_in:.3f}"
@@ -57,13 +43,12 @@ def _clip_audio_edge_fades(clips, idx, fade_ms):
     return fade_in, fade_out
 
 
-def _write_filter_script(filter_complex, work_dir):
-    script_path = Path(work_dir) / "edit_filter_complex.txt"
-    script_path.write_text(filter_complex, encoding="utf-8")
-    return script_path
-
-
 def _probe_audio_sample_rate(video_path):
+    """Sample rate of the first audio stream, or None when it cannot be observed.
+
+    Delivery QC is observational and runs even on a plan that was never rendered, so an
+    ffprobe that is absent (OSError) reads the same as one that reports no audio stream.
+    """
     cmd = [
         "ffprobe",
         "-v",
@@ -78,46 +63,33 @@ def _probe_audio_sample_rate(video_path):
     ]
     try:
         result = run_cmd(cmd)
-    except Exception:  # noqa: BLE001 - delivery QC is observational
+    except OSError:
         return None
-    if result.returncode != 0:
-        return None
-    try:
-        return int(float((result.stdout or "").strip().splitlines()[0]))
-    except (IndexError, TypeError, ValueError):
+    text = result.stdout.strip()
+    if result.returncode != 0 or not text:
         return None
+    return int(float(text))
 
 
 def _delivery_reencode_reason(source_paths, clips):
     reasons = ["trim_concat_filter_requires_reencode"]
-    if len(source_paths or []) > 1:
+    if len(source_paths) > 1:
         reasons.append("multi_source_geometry_audio_normalization")
-    if any(not clip.get("source_path") for clip in clips or []):
+    if any("source_path" not in clip for clip in clips):
         reasons.append("single_source_filter_concat_no_stream_copy")
     return "+".join(reasons)
 
 
-def update_delivery_qc(
-    validated_plan, *, source_paths=None, output_path=None, rendered=False
-):
+def update_delivery_qc(validated_plan, *, source_paths, output_path=None, rendered=False):
     """Attach cut delivery facts to qc.delivery_qc without writing visual_qc."""
-    qc = validated_plan.setdefault("qc", {})
-    clips = validated_plan.get("clips") or []
-    if source_paths is None:
-        source_paths = sorted(
-            {
-                str(clip.get("source_path") or "")
-                for clip in clips
-                if str(clip.get("source_path") or "")
-            }
-        )
+    qc = validated_plan["qc"]
+    clips = validated_plan["clips"]
     target_sample_rate = 48000
     probed_sample_rate = (
         _probe_audio_sample_rate(output_path)
         if output_path and Path(output_path).exists()
         else None
     )
-    output_geometry = qc.get("output_geometry")
     delivery_qc = {
         "schema_version": 1,
         "video_encode_passes": 1,
@@ -135,9 +107,9 @@ def update_delivery_qc(
             "audio encoded as AAC with 48000 Hz target for delivery compatibility",
             "edited_source.mp4 is an intermediate; downstream assembly may perform another intentional encode",
         ],
-        "output_geometry": output_geometry,
-        "rendered": bool(rendered),
-        "planned": not bool(rendered),
+        "output_geometry": qc["output_geometry"],
+        "rendered": rendered,
+        "planned": not rendered,
     }
     if probed_sample_rate and probed_sample_rate != target_sample_rate:
         delivery_qc["final_compat_notes"].append(
@@ -148,12 +120,10 @@ def update_delivery_qc(
 
 
 def write_cut_delivery_qc(work_dir, validated_plan):
-    delivery_qc = (validated_plan.get("qc") or {}).get("delivery_qc")
-    if not delivery_qc or not delivery_qc.get("rendered"):
-        return None
     path = Path(work_dir) / "cut_delivery_qc.json"
     path.write_text(
-        json.dumps(delivery_qc, ensure_ascii=False, indent=2), encoding="utf-8"
+        json.dumps(validated_plan["qc"]["delivery_qc"], ensure_ascii=False, indent=2),
+        encoding="utf-8",
     )
     return path
 
@@ -163,23 +133,21 @@ def build_edited_source_video(input_video, validated_plan, work_dir, output_path
     work_dir = Path(work_dir)
     output_path = Path(output_path or work_dir / "edited_source.mp4")
     clips = validated_plan["clips"]
-    if not clips:
-        raise ValueError("validated clip plan has no clips")
 
     source_paths = []
     for clip in clips:
-        source_path = str(clip.get("source_path") or input_video)
+        source_path = clip.get("source_path", str(input_video))
         if source_path not in source_paths:
             source_paths.append(source_path)
     source_index = {path: idx for idx, path in enumerate(source_paths)}
     audio_by_input = {path: _has_audio_stream(path) for path in source_paths}
-    join_fade_ms = max(0.0, float(CONFIG.get("clip_join_audio_fade_ms", 30.0) or 0.0))
+    join_fade_ms = CONFIG["clip_join_audio_fade_ms"]
     qc = validated_plan.setdefault("qc", {})
     qc["join_fade_ms"] = round(join_fade_ms, 3)
-    if not qc.get("output_geometry"):
+    if "output_geometry" not in qc:
         _, _, _, geometry_qc = _select_output_geometry(source_paths, clips)
         qc["output_geometry"] = geometry_qc
-        qc["output_geometry_reason"] = geometry_qc.get("reason")
+        qc["output_geometry_reason"] = geometry_qc["reason"]
 
     parts = []
     concat_inputs = []
@@ -190,23 +158,12 @@ def build_edited_source_video(input_video, validated_plan, work_dir, output_path
         # segment to one canvas and give every clip an audio segment (real or synthesized
         # silence) so concat always succeeds with a continuous track and no source's audio
         # is dropped just because a sibling source is silent.
-        # Reuse the geometry already probed+stored above (guard) or by main() — the
-        # selection is deterministic, so re-probing every source here is wasted ffprobe work.
-        geometry_qc = qc.get("output_geometry")
-        if isinstance(geometry_qc, dict) and all(
-            geometry_qc.get(k) for k in ("width", "height", "fps")
-        ):
-            canvas_w, canvas_h, canvas_fps = (
-                int(geometry_qc["width"]),
-                int(geometry_qc["height"]),
-                geometry_qc["fps"],
-            )
-        else:
-            canvas_w, canvas_h, canvas_fps, geometry_qc = _select_output_geometry(
-                source_paths, clips
-            )
-            qc["output_geometry"] = geometry_qc
-            qc["output_geometry_reason"] = geometry_qc.get("reason")
+        geometry_qc = qc["output_geometry"]
+        canvas_w, canvas_h, canvas_fps = (
+            geometry_qc["width"],
+            geometry_qc["height"],
+            geometry_qc["fps"],
+        )
         vnorm = (
             f"scale={canvas_w}:{canvas_h}:force_original_aspect_ratio=decrease,"
             f"pad={canvas_w}:{canvas_h}:(ow-iw)/2:(oh-ih)/2,setsar=1,"
@@ -214,18 +171,16 @@ def build_edited_source_video(input_video, validated_plan, work_dir, output_path
         )
         for clip_pos, clip in enumerate(clips):
             idx = clip["clip_id"]
-            clip_source = str(clip.get("source_path") or input_video)
+            clip_source = clip.get("source_path", str(input_video))
             input_idx = source_index[clip_source]
             start = clip["source_start"]
             end = clip["source_end"]
-            dur = max(0.0, float(end) - float(start))
-            fade_in_ms, fade_out_ms = _clip_audio_edge_fades(
-                clips, clip_pos, join_fade_ms
-            )
+            dur = end - start
+            fade_in_ms, fade_out_ms = _clip_audio_edge_fades(clips, clip_pos, join_fade_ms)
             parts.append(
                 f"[{input_idx}:v]trim=start={start:.3f}:end={end:.3f},setpts=PTS-STARTPTS,{vnorm}[v{idx}]"
             )
-            if audio_by_input.get(clip_source):
+            if audio_by_input[clip_source]:
                 parts.append(
                     _audio_segment_filter(
                         f"[{input_idx}:a]",
@@ -233,10 +188,9 @@ def build_edited_source_video(input_video, validated_plan, work_dir, output_path
                         start,
                         end,
                         dur,
-                        join_fade_ms,
+                        fade_in_ms,
+                        fade_out_ms,
                         extra_filters="aresample=48000,aformat=sample_rates=48000:channel_layouts=stereo",
-                        fade_in_ms=fade_in_ms,
-                        fade_out_ms=fade_out_ms,
                     )
                 )
             else:
@@ -251,7 +205,7 @@ def build_edited_source_video(input_video, validated_plan, work_dir, output_path
         has_audio = all(audio_by_input.values())
         for clip_pos, clip in enumerate(clips):
             idx = clip["clip_id"]
-            input_idx = source_index[str(clip.get("source_path") or input_video)]
+            input_idx = source_index[clip.get("source_path", str(input_video))]
             start = clip["source_start"]
             end = clip["source_end"]
             parts.append(
@@ -268,10 +222,9 @@ def build_edited_source_video(input_video, validated_plan, work_dir, output_path
                         f"[a{idx}]",
                         start,
                         end,
-                        max(0.0, float(end) - float(start)),
-                        join_fade_ms,
-                        fade_in_ms=fade_in_ms,
-                        fade_out_ms=fade_out_ms,
+                        end - start,
+                        fade_in_ms,
+                        fade_out_ms,
                     )
                 )
                 concat_inputs.append(f"[a{idx}]")
@@ -282,23 +235,21 @@ def build_edited_source_video(input_video, validated_plan, work_dir, output_path
             )
             maps = ["-map", "[v]", "-map", "[a]"]
         else:
-            total = validated_plan.get("total_duration") or sum(
-                c["duration"] for c in clips
-            )
             parts.append("".join(concat_inputs) + f"concat=n={len(clips)}:v=1:a=0[v]")
             maps = ["-map", "[v]", "-map", f"{len(source_paths)}:a", "-shortest"]
             extra_inputs = [
                 "-f",
                 "lavfi",
                 "-t",
-                f"{float(total):.3f}",
+                f"{validated_plan['total_duration']:.3f}",
                 "-i",
                 "anullsrc=channel_layout=stereo:sample_rate=48000",
             ]
 
     filter_complex = ";".join(parts)
     if len(filter_complex.encode("utf-8")) > 7000:
-        filter_script = _write_filter_script(filter_complex, work_dir)
+        filter_script = work_dir / "edit_filter_complex.txt"
+        filter_script.write_text(filter_complex, encoding="utf-8")
         filter_args = ["-filter_complex_script", str(filter_script)]
     else:
         filter_args = ["-filter_complex", filter_complex]