style: auto-format with black + isort + prettier [skip ci-format-check]

Co-authored-by: xiaoxia <dev@xiaoxiajianji.com>
Co-committed-by: xiaoxia <dev@xiaoxiajianji.com>

apps/web/src/pages/editing-planner/components/SubtitleStylePanel.tsx

@@ -1,18 +1,16 @@
-/**
- * 字幕样式配置面板 — Drawer 形式
- * 字幕开关（手动 / ASR 自动识别）、字体大小、颜色、描边/阴影、位置、ASR 语言
- */
 import React from "react"
 import { Drawer, Slider, ColorPicker, Select } from "antd"
 import type { Color } from "antd/es/color-picker"
 import type { SubtitleStyleConfig } from "@/pages/editing-planner/types/subtitle"
 import {
-  POSITION_OPTIONS,
   FONT_OPTIONS,
   ANIMATION_OPTIONS,
   ASR_LANGUAGE_OPTIONS,
 } from "@/pages/editing-planner/constants/subtitleStyle"
 import SubtitlePreview from "./subtitle-style/SubtitlePreview"
+import { SubtitleModeSwitch } from "./subtitle-style/SubtitleModeSwitch"
+import { SubtitlePositionSelector } from "./subtitle-style/SubtitlePositionSelector"
+import { SubtitleEffectButtons } from "./subtitle-style/SubtitleEffectButtons"
 
 interface SubtitleStylePanelProps {
   open: boolean
@@ -40,7 +38,6 @@ const SubtitleStylePanel: React.FC<SubtitleStylePanelProps> = ({
       onClose={onClose}
       className="subtitle-style-drawer"
     >
-      {/* ── 字幕开关 ── */}
       <div className="sub-field">
         <div className="sub-toggle-row">
           <span className="sub-label">启用字幕</span>
@@ -55,26 +52,11 @@ const SubtitleStylePanel: React.FC<SubtitleStylePanelProps> = ({
 
       {config.enabled && (
         <>
-          {/* ── 模式切换 ── */}
           <div className="sub-field">
             <label className="sub-label">字幕来源</label>
-            <div className="sub-mode-switch">
-              <button
-                className={`sub-mode-btn${config.mode === "manual" ? " active" : ""}`}
-                onClick={() => update({ mode: "manual" })}
-              >
-                ✏️ 手动输入
-              </button>
-              <button
-                className={`sub-mode-btn${config.mode === "asr" ? " active" : ""}`}
-                onClick={() => update({ mode: "asr" })}
-              >
-                🤖 ASR 识别
-              </button>
-            </div>
+            <SubtitleModeSwitch mode={config.mode} onModeChange={(mode) => update({ mode })} />
           </div>
 
-          {/* ── ASR 语言（仅 ASR 模式） ── */}
           {config.mode === "asr" && (
             <div className="sub-field">
               <label className="sub-label">识别语言</label>
@@ -88,7 +70,6 @@ const SubtitleStylePanel: React.FC<SubtitleStylePanelProps> = ({
             </div>
           )}
 
-          {/* ── 字体大小 ── */}
           <div className="sub-field">
             <label className="sub-label">
               字体大小 <span className="sub-value">{config.fontSize}px</span>
@@ -101,7 +82,6 @@ const SubtitleStylePanel: React.FC<SubtitleStylePanelProps> = ({
             />
           </div>
 
-          {/* ── 字体颜色 ── */}
           <div className="sub-field">
             <label className="sub-label">字体颜色</label>
             <div className="sub-color-row">
@@ -113,7 +93,6 @@ const SubtitleStylePanel: React.FC<SubtitleStylePanelProps> = ({
             </div>
           </div>
 
-          {/* ── 字体 ── */}
           <div className="sub-field">
             <label className="sub-label">字体</label>
             <Select
@@ -125,46 +104,24 @@ const SubtitleStylePanel: React.FC<SubtitleStylePanelProps> = ({
             />
           </div>
 
-          {/* ── 字幕位置 ── */}
           <div className="sub-field">
             <label className="sub-label">位置</label>
-            <div className="sub-position-group">
-              {POSITION_OPTIONS.map((opt) => (
-                <button
-                  key={opt.value}
-                  className={`sub-position-btn${config.position === opt.value ? " active" : ""}`}
-                  onClick={() =>
-                    update({
-                      position: opt.value as SubtitleStyleConfig["position"],
-                    })
-                  }
-                >
-                  {opt.label}
-                </button>
-              ))}
-            </div>
+            <SubtitlePositionSelector
+              position={config.position}
+              onPositionChange={(position) => update({ position })}
+            />
           </div>
 
-          {/* ── 描边 / 阴影 ── */}
           <div className="sub-field">
             <label className="sub-label">效果</label>
-            <div className="sub-effect-btns">
-              <button
-                className={`sub-effect-btn${config.stroke ? " active" : ""}`}
-                onClick={() => update({ stroke: !config.stroke })}
-              >
-                S 描边
-              </button>
-              <button
-                className={`sub-effect-btn${config.shadow ? " active" : ""}`}
-                onClick={() => update({ shadow: !config.shadow })}
-              >
-                ☁ 阴影
-              </button>
-            </div>
+            <SubtitleEffectButtons
+              stroke={config.stroke}
+              shadow={config.shadow}
+              onStrokeChange={(stroke) => update({ stroke })}
+              onShadowChange={(shadow) => update({ shadow })}
+            />
           </div>
 
-          {/* ── 动画 ── */}
           <div className="sub-field">
             <label className="sub-label">动画效果</label>
             <Select
@@ -179,7 +136,6 @@ const SubtitleStylePanel: React.FC<SubtitleStylePanelProps> = ({
             />
           </div>
 
-          {/* ── 预览 ── */}
           <SubtitlePreview config={config} />
         </>
       )}

apps/web/src/pages/editing-planner/components/subtitle-style/SubtitleEffectButtons.tsx

@@ -0,0 +1,32 @@
+import React from "react"
+
+interface SubtitleEffectButtonsProps {
+  stroke: boolean
+  shadow: boolean
+  onStrokeChange: (enabled: boolean) => void
+  onShadowChange: (enabled: boolean) => void
+}
+
+export const SubtitleEffectButtons: React.FC<SubtitleEffectButtonsProps> = ({
+  stroke,
+  shadow,
+  onStrokeChange,
+  onShadowChange,
+}) => {
+  return (
+    <div className="sub-effect-btns">
+      <button
+        className={`sub-effect-btn${stroke ? " active" : ""}`}
+        onClick={() => onStrokeChange(!stroke)}
+      >
+        S 描边
+      </button>
+      <button
+        className={`sub-effect-btn${shadow ? " active" : ""}`}
+        onClick={() => onShadowChange(!shadow)}
+      >
+        ☁ 阴影
+      </button>
+    </div>
+  )
+}

apps/web/src/pages/editing-planner/components/subtitle-style/SubtitleModeSwitch.tsx

@@ -0,0 +1,25 @@
+import React from "react"
+
+interface SubtitleModeSwitchProps {
+  mode: "manual" | "asr"
+  onModeChange: (mode: "manual" | "asr") => void
+}
+
+export const SubtitleModeSwitch: React.FC<SubtitleModeSwitchProps> = ({ mode, onModeChange }) => {
+  return (
+    <div className="sub-mode-switch">
+      <button
+        className={`sub-mode-btn${mode === "manual" ? " active" : ""}`}
+        onClick={() => onModeChange("manual")}
+      >
+        ✏️ 手动输入
+      </button>
+      <button
+        className={`sub-mode-btn${mode === "asr" ? " active" : ""}`}
+        onClick={() => onModeChange("asr")}
+      >
+        🤖 ASR 识别
+      </button>
+    </div>
+  )
+}

apps/web/src/pages/editing-planner/components/subtitle-style/SubtitlePositionSelector.tsx

@@ -0,0 +1,27 @@
+import React from "react"
+import type { SubtitleStyleConfig } from "@/pages/editing-planner/types/subtitle"
+import { POSITION_OPTIONS } from "@/pages/editing-planner/constants/subtitleStyle"
+
+interface SubtitlePositionSelectorProps {
+  position: SubtitleStyleConfig["position"]
+  onPositionChange: (position: SubtitleStyleConfig["position"]) => void
+}
+
+export const SubtitlePositionSelector: React.FC<SubtitlePositionSelectorProps> = ({
+  position,
+  onPositionChange,
+}) => {
+  return (
+    <div className="sub-position-group">
+      {POSITION_OPTIONS.map((opt) => (
+        <button
+          key={opt.value}
+          className={`sub-position-btn${position === opt.value ? " active" : ""}`}
+          onClick={() => onPositionChange(opt.value as SubtitleStyleConfig["position"])}
+        >
+          {opt.label}
+        </button>
+      ))}
+    </div>
+  )
+}

apps/web/src/pages/voice-materials/components/voice-material-row/useRowProgress.ts

@@ -1,4 +1,4 @@
-import { useRef, useCallback } from "react"
+import { useRef, useCallback, useEffect } from "react"
 
 interface UseRowProgressOptions {
   duration: number
@@ -7,6 +7,22 @@ interface UseRowProgressOptions {
 
 export function useRowProgress({ duration, onSeek }: UseRowProgressOptions) {
   const progressRef = useRef<HTMLDivElement>(null)
+  const listenersRef = useRef<{ move: ((e: MouseEvent) => void) | null; up: (() => void) | null }>({
+    move: null,
+    up: null,
+  })
+
+  const cleanupListeners = useCallback(() => {
+    const { move, up } = listenersRef.current
+    if (move) {
+      document.removeEventListener("mousemove", move)
+      listenersRef.current.move = null
+    }
+    if (up) {
+      document.removeEventListener("mouseup", up)
+      listenersRef.current.up = null
+    }
+  }, [])
 
   const handleMouseDown = useCallback(
     (e: React.MouseEvent<HTMLDivElement>) => {
@@ -16,6 +32,7 @@ export function useRowProgress({ duration, onSeek }: UseRowProgressOptions) {
       const doSeek = (ev: MouseEvent) => {
         if (!progressRef.current) return
         const rect = progressRef.current.getBoundingClientRect()
+        if (rect.width <= 0) return
         const percent = Math.max(0, Math.min(1, (ev.clientX - rect.left) / rect.width))
         onSeek(percent * duration)
       }
@@ -24,15 +41,26 @@ export function useRowProgress({ duration, onSeek }: UseRowProgressOptions) {
 
       const handleMove = (ev: MouseEvent) => doSeek(ev)
       const handleUp = () => {
-        document.removeEventListener("mousemove", handleMove)
-        document.removeEventListener("mouseup", handleUp)
+        cleanupListeners()
       }
 
+      // 先清理旧的，再添加新的
+      cleanupListeners()
+      listenersRef.current.move = handleMove
+      listenersRef.current.up = handleUp
+
       document.addEventListener("mousemove", handleMove)
       document.addEventListener("mouseup", handleUp)
     },
-    [duration, onSeek],
+    [duration, onSeek, cleanupListeners],
   )
 
+  // 组件卸载时清理事件监听器
+  useEffect(() => {
+    return () => {
+      cleanupListeners()
+    }
+  }, [cleanupListeners])
+
   return { progressRef, handleMouseDown }
 }

apps/web/src/test/pages/editing-planner/smoke.test.tsx

@@ -65,6 +65,9 @@ import "@/pages/editing-planner/components/filter/FilterPresetGrid"
 import "@/pages/editing-planner/components/filter/FilterManualAdjust"
 import "@/pages/editing-planner/components/intro-outro/IntroOutroBlock"
 import "@/pages/editing-planner/components/subtitle-style/SubtitlePreview"
+import "@/pages/editing-planner/components/subtitle-style/SubtitleModeSwitch"
+import "@/pages/editing-planner/components/subtitle-style/SubtitlePositionSelector"
+import "@/pages/editing-planner/components/subtitle-style/SubtitleEffectButtons"
 import "@/pages/editing-planner/components/tts/VoiceSelector"
 import "@/pages/editing-planner/components/tts/TtsSlider"
 import "@/pages/editing-planner/components/watermark/WatermarkTypeTabs"

apps/web/src/test/pages/voice-materials/smoke.test.tsx

@@ -20,6 +20,8 @@ import "@/pages/voice-materials/components/voice-material-card/CardActions"
 import "@/pages/voice-materials/components/voice-material-card/BatchCheckbox"
 import "@/pages/voice-materials/components/voice-material-card/types"
 import "@/pages/voice-materials/components/VoiceMaterialRow"
+import "@/pages/voice-materials/components/voice-material-row/useRowProgress"
+import "@/pages/voice-materials/components/voice-material-row/TagDisplay"
 import "@/pages/voice-materials/components/Toolbar"
 import "@/pages/voice-materials/components/TagFilterBar"
 import "@/pages/voice-materials/components/BatchBar"

packages/application/cosyvoice_service.py

@@ -569,7 +569,9 @@ class CosyVoiceService:
             清洗后的 prefix
         """
         # 只保留字母和数字
-        cleaned = "".join(c for c in name if c.isalnum())
+        import re
+
+        cleaned = re.sub(r"[^a-zA-Z0-9]", "", name)
         # 最多10字符
         cleaned = cleaned[:10]
         # 如果清洗后为空，用默认值

tests/unit/domain/test_template_clip_converter.py

@@ -0,0 +1,496 @@
+"""模板片段转换器单测.
+
+纯函数模块，覆盖：枚举安全解析、config过滤、
+clip→template转换、snapshot双向转换、名称校验。
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from packages.domain.template_clip_config import (
+    ClipType,
+    TemplateClipConfig,
+    TransitionEffect,
+)
+from packages.domain.template_clip_converter import (
+    clip_config_to_snapshot,
+    clip_configs_to_snapshots,
+    clip_to_template_clip_config,
+    clips_to_template_clip_configs,
+    filter_clip_config,
+    filter_plan_config_to_template,
+    safe_parse_clip_type,
+    safe_parse_transition_effect,
+    snapshot_to_template_clip_config,
+    snapshots_to_template_clip_configs,
+    validate_template_name,
+)
+
+
+class TestSafeParseTransitionEffect:
+    def test_enum_passthrough(self):
+        result = safe_parse_transition_effect(TransitionEffect.FADE)
+        assert result == TransitionEffect.FADE
+        assert isinstance(result, TransitionEffect)
+
+    def test_valid_string(self):
+        result = safe_parse_transition_effect("fade")
+        assert result == TransitionEffect.FADE
+
+    def test_cut_string(self):
+        result = safe_parse_transition_effect("cut")
+        assert result == TransitionEffect.CUT
+
+    def test_invalid_string_returns_default(self):
+        result = safe_parse_transition_effect("invalid_effect")
+        assert result == TransitionEffect.CUT  # 默认
+
+    def test_invalid_string_custom_default(self):
+        result = safe_parse_transition_effect("bad", default=TransitionEffect.DISSOLVE)
+        assert result == TransitionEffect.DISSOLVE
+
+    def test_none_returns_default(self):
+        result = safe_parse_transition_effect(None)
+        assert result == TransitionEffect.CUT
+
+    def test_int_value_returns_default(self):
+        result = safe_parse_transition_effect(123)
+        assert result == TransitionEffect.CUT
+
+    def test_empty_string_returns_default(self):
+        result = safe_parse_transition_effect("")
+        assert result == TransitionEffect.CUT
+
+
+class TestSafeParseClipType:
+    def test_enum_passthrough(self):
+        result = safe_parse_clip_type(ClipType.SUBTITLE)
+        assert result == ClipType.SUBTITLE
+        assert isinstance(result, ClipType)
+
+    def test_valid_string_main(self):
+        result = safe_parse_clip_type("main")
+        assert result == ClipType.MAIN
+
+    def test_valid_string_text(self):
+        result = safe_parse_clip_type("subtitle")
+        assert result == ClipType.SUBTITLE
+
+    def test_invalid_string_returns_default(self):
+        result = safe_parse_clip_type("unknown_type")
+        assert result == ClipType.MAIN
+
+    def test_invalid_string_custom_default(self):
+        result = safe_parse_clip_type("bad", default=ClipType.TITLE)
+        assert result == ClipType.TITLE
+
+    def test_none_returns_default(self):
+        result = safe_parse_clip_type(None)
+        assert result == ClipType.MAIN
+
+    def test_dict_returns_default(self):
+        result = safe_parse_clip_type({"key": "val"})
+        assert result == ClipType.MAIN
+
+
+class TestFilterClipConfig:
+    def test_none_config(self):
+        result = filter_clip_config(None)
+        assert result == {}
+
+    def test_empty_dict(self):
+        result = filter_clip_config({})
+        assert result == {}
+
+    def test_basic_config_passthrough(self):
+        cfg = {"font_size": 24, "color": "red"}
+        result = filter_clip_config(cfg)
+        assert result == {"font_size": 24, "color": "red"}
+
+    def test_filters_asset_info(self):
+        cfg = {"font_size": 24, "asset_info": {"id": "123"}}
+        result = filter_clip_config(cfg)
+        assert "asset_info" not in result
+        assert result["font_size"] == 24
+
+    def test_filters_source_asset_id(self):
+        cfg = {"source_asset_id": "asset_1", "text_key": "hi"}
+        result = filter_clip_config(cfg)
+        assert "source_asset_id" not in result
+        assert result["text_key"] == "hi"
+
+    def test_playback_speed_added_when_not_one(self):
+        result = filter_clip_config({}, playback_speed=1.5)
+        assert result["playback_speed"] == 1.5
+
+    def test_playback_speed_one_not_added(self):
+        result = filter_clip_config({}, playback_speed=1.0)
+        assert "playback_speed" not in result
+
+    def test_playback_speed_none_not_added(self):
+        result = filter_clip_config({}, playback_speed=None)
+        assert "playback_speed" not in result
+
+    def test_playback_speed_config_takes_priority(self):
+        """clip_config中的playback_speed会覆盖参数传入的（因为update在后面）."""
+        cfg = {"playback_speed": 0.5, "other": "val"}
+        result = filter_clip_config(cfg, playback_speed=2.0)
+        assert result["playback_speed"] == 0.5  # config里的覆盖参数的
+        assert result["other"] == "val"
+
+    def test_custom_skip_keys(self):
+        cfg = {"keep_me": 1, "drop_me": 2, "also_drop": 3}
+        skip = frozenset({"drop_me", "also_drop"})
+        result = filter_clip_config(cfg, skip_keys=skip)
+        assert result == {"keep_me": 1}
+
+    def test_does_not_mutate_input(self):
+        cfg = {"a": 1, "asset_info": "x"}
+        original = dict(cfg)
+        filter_clip_config(cfg)
+        assert cfg == original  # 原dict不变
+
+
+class TestFilterPlanConfigToTemplate:
+    def test_none_config(self):
+        result = filter_plan_config_to_template(None)
+        assert result == {}
+
+    def test_empty_dict(self):
+        result = filter_plan_config_to_template({})
+        assert result == {}
+
+    def test_keeps_template_fields(self):
+        cfg = {"title": "My Template", "aspect_ratio": "9:16"}
+        result = filter_plan_config_to_template(cfg)
+        assert result == cfg
+
+    def test_filters_runtime_fields(self):
+        cfg = {
+            "title": "T",
+            "is_template_draft": True,
+            "asset_ids": ["a1"],
+            "source_edit_plan_id": "ep1",
+            "generation_task_id": "gt1",
+        }
+        result = filter_plan_config_to_template(cfg)
+        assert "is_template_draft" not in result
+        assert "asset_ids" not in result
+        assert "source_edit_plan_id" not in result
+        assert "generation_task_id" not in result
+        assert result["title"] == "T"
+
+    def test_custom_skip_keys(self):
+        cfg = {"keep": 1, "skip_a": 2, "skip_b": 3}
+        skip = frozenset({"skip_a", "skip_b"})
+        result = filter_plan_config_to_template(cfg, skip_keys=skip)
+        assert result == {"keep": 1}
+
+
+class TestClipToTemplateClipConfig:
+    @dataclass
+    class FakeClip:
+        clip_type: str = "main"
+        order: int = 0
+        duration: float = 5.0
+        text_content: str = ""
+        transition_effect: str = "cut"
+        playback_speed: float | None = None
+        config: dict | None = None
+
+    def test_basic_conversion(self):
+        clip = self.FakeClip(
+            clip_type="subtitle",
+            order=2,
+            duration=3.5,
+            text_content="Hello",
+            transition_effect="fade",
+        )
+        result = clip_to_template_clip_config("tpl_1", clip)
+        assert isinstance(result, TemplateClipConfig)
+        assert result.template_id == "tpl_1"
+        assert result.clip_type == ClipType.SUBTITLE
+        assert result.order == 2
+        assert result.min_duration == 3.5
+        assert result.max_duration == 3.5
+        assert result.text_template == "Hello"
+        assert result.transition_effect == TransitionEffect.FADE
+
+    def test_duration_fixed_min_max_equal(self):
+        """转换后 min_duration == max_duration == clip.duration."""
+        clip = self.FakeClip(duration=7.2)
+        result = clip_to_template_clip_config("t1", clip)
+        assert result.min_duration == 7.2
+        assert result.max_duration == 7.2
+
+    def test_zero_duration(self):
+        clip = self.FakeClip(duration=0.0)
+        result = clip_to_template_clip_config("t1", clip)
+        assert result.min_duration == 0.0
+        assert result.max_duration == 0.0
+
+    def test_none_duration_defaults_to_zero(self):
+        clip = self.FakeClip()
+        clip.duration = None  # type: ignore
+        result = clip_to_template_clip_config("t1", clip)
+        assert result.min_duration == 0.0
+        assert result.max_duration == 0.0
+
+    def test_empty_text_content_becomes_empty_string(self):
+        clip = self.FakeClip(text_content="")
+        result = clip_to_template_clip_config("t1", clip)
+        assert result.text_template == ""
+
+    def test_none_text_content_becomes_empty_string(self):
+        clip = self.FakeClip()
+        clip.text_content = None  # type: ignore
+        result = clip_to_template_clip_config("t1", clip)
+        assert result.text_template == ""
+
+    def test_playback_speed_in_config(self):
+        clip = self.FakeClip(playback_speed=1.5, config={"font": "bold"})
+        result = clip_to_template_clip_config("t1", clip)
+        assert result.config["playback_speed"] == 1.5
+        assert result.config["font"] == "bold"
+
+    def test_playback_speed_one_not_in_config(self):
+        clip = self.FakeClip(playback_speed=1.0)
+        result = clip_to_template_clip_config("t1", clip)
+        assert "playback_speed" not in result.config
+
+    def test_config_asset_info_filtered(self):
+        clip = self.FakeClip(config={"text_key": "hi", "asset_info": {"id": "a"}})
+        result = clip_to_template_clip_config("t1", clip)
+        assert "asset_info" not in result.config
+        assert result.config["text_key"] == "hi"
+
+    def test_invalid_clip_type_falls_back(self):
+        clip = self.FakeClip(clip_type="invalid_type")
+        result = clip_to_template_clip_config("t1", clip)
+        assert result.clip_type == ClipType.MAIN
+
+    def test_missing_attributes(self):
+        """对象没有某些属性时使用默认值."""
+
+        class MinimalClip:
+            pass
+
+        result = clip_to_template_clip_config("t1", MinimalClip())
+        assert result.clip_type == ClipType.MAIN
+        assert result.order == 0
+        assert result.min_duration == 0.0
+        assert result.text_template == ""
+        assert result.transition_effect == TransitionEffect.CUT
+
+
+class TestClipsToTemplateClipConfigs:
+    def test_empty_list(self):
+        result = clips_to_template_clip_configs("t1", [])
+        assert result == []
+
+    def test_multiple_clips(self):
+        clip_a = TestClipToTemplateClipConfig.FakeClip(clip_type="subtitle", order=0, duration=3.0, text_content="A")
+        clip_b = TestClipToTemplateClipConfig.FakeClip(clip_type="title", order=1, duration=5.0, text_content="")
+        result = clips_to_template_clip_configs("t1", [clip_a, clip_b])
+        assert len(result) == 2
+        assert result[0].clip_type == ClipType.SUBTITLE
+        assert result[0].order == 0
+        assert result[1].clip_type == ClipType.TITLE
+        assert result[1].order == 1
+        assert all(isinstance(r, TemplateClipConfig) for r in result)
+
+
+class TestClipConfigToSnapshot:
+    def test_basic_snapshot(self):
+        cfg = TemplateClipConfig.create(
+            template_id="t1",
+            clip_type=ClipType.SUBTITLE,
+            order=2,
+            min_duration=3.0,
+            max_duration=5.0,
+            text_template="Hello",
+            transition_effect=TransitionEffect.FADE,
+            config={"font_size": 20},
+        )
+        snap = clip_config_to_snapshot(cfg)
+        assert snap["clip_type"] == "subtitle"
+        assert snap["order"] == 2
+        assert snap["min_duration"] == 3.0
+        assert snap["max_duration"] == 5.0
+        assert snap["text_template"] == "Hello"
+        assert snap["transition_effect"] == "fade"
+        assert snap["config"] == {"font_size": 20}
+
+    def test_enum_values_are_strings(self):
+        cfg = TemplateClipConfig.create(template_id="t1", clip_type=ClipType.MAIN, order=0)
+        snap = clip_config_to_snapshot(cfg)
+        assert snap["clip_type"] == "main"
+        assert isinstance(snap["clip_type"], str)
+        assert snap["transition_effect"] == "cut"
+        assert isinstance(snap["transition_effect"], str)
+
+    def test_config_is_copy_not_reference(self):
+        config = {"key": "val"}
+        cfg = TemplateClipConfig.create(template_id="t1", clip_type=ClipType.MAIN, order=0, config=config)
+        snap = clip_config_to_snapshot(cfg)
+        snap["config"]["key"] = "changed"
+        assert config["key"] == "val"  # 原config不变
+
+    def test_empty_config(self):
+        cfg = TemplateClipConfig.create(template_id="t1", clip_type=ClipType.MAIN, order=0, config={})
+        snap = clip_config_to_snapshot(cfg)
+        assert snap["config"] == {}
+
+    def test_none_text_becomes_empty(self):
+        cfg = TemplateClipConfig.create(template_id="t1", clip_type=ClipType.MAIN, order=0)
+        cfg.text_template = None  # type: ignore
+        snap = clip_config_to_snapshot(cfg)
+        assert snap["text_template"] == ""
+
+
+class TestClipConfigsToSnapshots:
+    def test_empty_list(self):
+        assert clip_configs_to_snapshots([]) == []
+
+    def test_multiple_configs(self):
+        cfg1 = TemplateClipConfig.create(
+            template_id="t1",
+            clip_type=ClipType.SUBTITLE,
+            order=0,
+            min_duration=2.0,
+            max_duration=2.0,
+        )
+        cfg2 = TemplateClipConfig.create(
+            template_id="t1",
+            clip_type=ClipType.TITLE,
+            order=1,
+            min_duration=3.0,
+            max_duration=3.0,
+        )
+        snaps = clip_configs_to_snapshots([cfg1, cfg2])
+        assert len(snaps) == 2
+        assert snaps[0]["clip_type"] == "subtitle"
+        assert snaps[1]["clip_type"] == "title"
+
+
+class TestSnapshotToTemplateClipConfig:
+    def test_basic_conversion(self):
+        snap = {
+            "clip_type": "subtitle",
+            "order": 3,
+            "min_duration": 2.5,
+            "max_duration": 4.5,
+            "text_template": "World",
+            "transition_effect": "dissolve",
+            "config": {"color": "blue"},
+        }
+        result = snapshot_to_template_clip_config("tpl_2", snap)
+        assert isinstance(result, TemplateClipConfig)
+        assert result.template_id == "tpl_2"
+        assert result.clip_type == ClipType.SUBTITLE
+        assert result.order == 3
+        assert result.min_duration == 2.5
+        assert result.max_duration == 4.5
+        assert result.text_template == "World"
+        assert result.transition_effect == TransitionEffect.DISSOLVE
+        assert result.config == {"color": "blue"}
+
+    def test_empty_snapshot_uses_defaults(self):
+        result = snapshot_to_template_clip_config("t1", {})
+        assert result.clip_type == ClipType.MAIN
+        assert result.order == 0
+        assert result.min_duration == 0.0
+        assert result.max_duration == 0.0
+        assert result.text_template == ""
+        assert result.transition_effect == TransitionEffect.CUT
+        assert result.config == {}
+
+    def test_invalid_clip_type_defaults(self):
+        snap = {"clip_type": "unknown"}
+        result = snapshot_to_template_clip_config("t1", snap)
+        assert result.clip_type == ClipType.MAIN
+
+    def test_invalid_transition_defaults(self):
+        snap = {"transition_effect": "bad_effect"}
+        result = snapshot_to_template_clip_config("t1", snap)
+        assert result.transition_effect == TransitionEffect.CUT
+
+    def test_none_config_becomes_empty(self):
+        snap = {"config": None}
+        result = snapshot_to_template_clip_config("t1", snap)
+        assert result.config == {}
+
+
+class TestSnapshotsToTemplateClipConfigs:
+    def test_empty_list(self):
+        result = snapshots_to_template_clip_configs("t1", [])
+        assert result == []
+
+    def test_multiple_snapshots(self):
+        snaps = [
+            {"clip_type": "subtitle", "order": 0, "text_template": "A"},
+            {"clip_type": "title", "order": 1},
+        ]
+        result = snapshots_to_template_clip_configs("t1", snaps)
+        assert len(result) == 2
+        assert result[0].clip_type == ClipType.SUBTITLE
+        assert result[0].text_template == "A"
+        assert result[1].clip_type == ClipType.TITLE
+
+
+class TestRoundTrip:
+    """clip → config → snapshot → config 双向转换一致性."""
+
+    def test_snapshot_config_round_trip(self):
+        original = TemplateClipConfig.create(
+            template_id="t1",
+            clip_type=ClipType.SUBTITLE,
+            order=5,
+            min_duration=3.0,
+            max_duration=6.0,
+            text_template="Round trip",
+            transition_effect=TransitionEffect.FADE,
+            config={"key": "value"},
+        )
+        snap = clip_config_to_snapshot(original)
+        restored = snapshot_to_template_clip_config("t1", snap)
+        assert restored.clip_type == original.clip_type
+        assert restored.order == original.order
+        assert restored.min_duration == original.min_duration
+        assert restored.max_duration == original.max_duration
+        assert restored.text_template == original.text_template
+        assert restored.transition_effect == original.transition_effect
+        assert restored.config == original.config
+
+
+class TestValidateTemplateName:
+    def test_valid_name(self):
+        assert validate_template_name("我的模板") == "我的模板"
+
+    def test_strips_whitespace(self):
+        assert validate_template_name("  Hello  ") == "Hello"
+
+    def test_empty_string_raises(self):
+        try:
+            validate_template_name("")
+        except ValueError as e:
+            assert "不能为空" in str(e)
+        else:
+            raise AssertionError("expected ValueError")
+
+    def test_whitespace_only_raises(self):
+        try:
+            validate_template_name("   ")
+        except ValueError as e:
+            assert "不能为空" in str(e)
+        else:
+            raise AssertionError("expected ValueError")
+
+    def test_none_raises(self):
+        try:
+            validate_template_name(None)
+        except ValueError as e:
+            assert "不能为空" in str(e)
+        else:
+            raise AssertionError("expected ValueError")

tests/unit/domain/test_video_concat.py

@@ -0,0 +1,392 @@
+"""video_concat 视频拼接配置单测."""
+
+import pytest
+from domain.video_concat import (
+    ALLOWED_VIDEO_EXTENSIONS,
+    CONCAT_DEMUXER_REQUIRED_PARAMS,
+    MAX_CONCAT_SEGMENTS,
+    ConcatConfig,
+    ConcatSegment,
+)
+
+# ── 常量测试 ─────────────────────────────────────────────────────────────────
+
+
+class TestConstants:
+    """模块常量"""
+
+    def test_max_concat_segments(self):
+        assert MAX_CONCAT_SEGMENTS == 50
+
+    def test_allowed_extensions(self):
+        assert ".mp4" in ALLOWED_VIDEO_EXTENSIONS
+        assert ".mov" in ALLOWED_VIDEO_EXTENSIONS
+        assert ".avi" in ALLOWED_VIDEO_EXTENSIONS
+        assert ".mkv" in ALLOWED_VIDEO_EXTENSIONS
+        assert ".webm" in ALLOWED_VIDEO_EXTENSIONS
+        assert ".flv" in ALLOWED_VIDEO_EXTENSIONS
+        assert ".wmv" in ALLOWED_VIDEO_EXTENSIONS
+
+    def test_concat_demuxer_params(self):
+        params = CONCAT_DEMUXER_REQUIRED_PARAMS
+        assert "codec_name" in params
+        assert "width" in params
+        assert "height" in params
+        assert "r_frame_rate" in params
+        assert "pix_fmt" in params
+        assert "sample_rate" in params
+        assert "channels" in params
+        assert "audio_codec" in params
+        assert len(params) == 8
+
+
+# ── ConcatSegment ────────────────────────────────────────────────────────────
+
+
+class TestConcatSegmentDefaults:
+    """ConcatSegment 默认值"""
+
+    def test_required_path(self):
+        s = ConcatSegment(video_path="/video.mp4")
+        assert s.video_path == "/video.mp4"
+        assert s.start_time == 0.0
+        assert s.duration == 0.0
+        assert s.has_audio is True
+
+    def test_all_custom(self):
+        s = ConcatSegment(
+            video_path="/clip.mp4",
+            start_time=5.0,
+            duration=10.0,
+            has_audio=False,
+        )
+        assert s.video_path == "/clip.mp4"
+        assert s.start_time == 5.0
+        assert s.duration == 10.0
+        assert s.has_audio is False
+
+
+class TestConcatSegmentFromDict:
+    """ConcatSegment.from_dict"""
+
+    def test_none_returns_empty_path(self):
+        s = ConcatSegment.from_dict(None)
+        assert s.video_path == ""
+        assert s.is_valid is False
+
+    def test_empty_dict(self):
+        s = ConcatSegment.from_dict({})
+        assert s.video_path == ""
+
+    def test_not_dict(self):
+        s = ConcatSegment.from_dict("not a dict")
+        assert s.video_path == ""
+
+    def test_full_dict(self):
+        s = ConcatSegment.from_dict(
+            {
+                "video_path": "/clip.mp4",
+                "start_time": 2.5,
+                "duration": 15.0,
+                "has_audio": False,
+            }
+        )
+        assert s.video_path == "/clip.mp4"
+        assert s.start_time == 2.5
+        assert s.duration == 15.0
+        assert s.has_audio is False
+
+    def test_invalid_start_time_falls_back(self):
+        s = ConcatSegment.from_dict({"video_path": "/a.mp4", "start_time": "bad"})
+        assert s.start_time == 0.0
+
+    def test_negative_start_time_clamped(self):
+        s = ConcatSegment.from_dict({"video_path": "/a.mp4", "start_time": -5.0})
+        assert s.start_time == 0.0
+
+    def test_invalid_duration_falls_back(self):
+        s = ConcatSegment.from_dict({"video_path": "/a.mp4", "duration": None})
+        assert s.duration == 0.0
+
+    def test_negative_duration_clamped(self):
+        s = ConcatSegment.from_dict({"video_path": "/a.mp4", "duration": -10.0})
+        assert s.duration == 0.0
+
+    def test_has_audio_default_true(self):
+        s = ConcatSegment.from_dict({"video_path": "/a.mp4"})
+        assert s.has_audio is True
+
+    def test_has_audio_false(self):
+        s = ConcatSegment.from_dict({"video_path": "/a.mp4", "has_audio": False})
+        assert s.has_audio is False
+
+    def test_path_is_string(self):
+        s = ConcatSegment.from_dict({"video_path": 123})
+        assert s.video_path == "123"
+
+
+class TestConcatSegmentProperties:
+    """ConcatSegment 属性方法"""
+
+    def test_is_valid_true(self):
+        s = ConcatSegment(video_path="/a.mp4")
+        assert s.is_valid is True
+
+    def test_is_valid_false_empty(self):
+        s = ConcatSegment(video_path="")
+        assert s.is_valid is False
+
+    def test_effective_duration_positive(self):
+        s = ConcatSegment(video_path="/a.mp4", duration=10.0)
+        assert s.effective_duration == 10.0
+
+    def test_effective_duration_zero(self):
+        s = ConcatSegment(video_path="/a.mp4", duration=0.0)
+        assert s.effective_duration == 0.0
+
+    def test_effective_duration_negative(self):
+        s = ConcatSegment(video_path="/a.mp4", duration=-5.0)
+        assert s.effective_duration == 0.0
+
+
+# ── ConcatConfig ─────────────────────────────────────────────────────────────
+
+
+class TestConcatConfigDefaults:
+    """ConcatConfig 默认值"""
+
+    def test_default_values(self):
+        c = ConcatConfig()
+        assert c.segments == []
+        assert c.output_width == 0
+        assert c.output_height == 0
+        assert c.output_fps == 0.0
+        assert c.force_reencode is False
+        assert c.transition == "none"
+        assert c.transition_duration == 0.3
+
+
+class TestConcatConfigFromDict:
+    """ConcatConfig.from_config_dict"""
+
+    def test_none_returns_default(self):
+        c = ConcatConfig.from_config_dict(None)
+        assert c.segments == []
+
+    def test_empty_dict_returns_default(self):
+        c = ConcatConfig.from_config_dict({})
+        assert c.segments == []
+
+    def test_not_dict_returns_default(self):
+        c = ConcatConfig.from_config_dict("config")
+        assert c.segments == []
+
+    def test_single_segment(self):
+        c = ConcatConfig.from_config_dict(
+            {
+                "segments": [
+                    {"video_path": "/a.mp4", "duration": 10.0},
+                ],
+            }
+        )
+        assert len(c.segments) == 1
+        assert c.segments[0].video_path == "/a.mp4"
+
+    def test_multiple_segments(self):
+        c = ConcatConfig.from_config_dict(
+            {
+                "segments": [
+                    {"video_path": "/a.mp4", "duration": 10.0},
+                    {"video_path": "/b.mp4", "duration": 20.0},
+                    {"video_path": "/c.mp4", "duration": 15.0},
+                ],
+            }
+        )
+        assert len(c.segments) == 3
+
+    def test_skip_no_path_segments(self):
+        c = ConcatConfig.from_config_dict(
+            {
+                "segments": [
+                    {"video_path": "/a.mp4"},
+                    {"video_path": ""},
+                    {"duration": 5.0},  # 没有 video_path
+                    {"video_path": "/b.mp4"},
+                ],
+            }
+        )
+        assert len(c.segments) == 2
+
+    def test_skip_non_dict_segments(self):
+        c = ConcatConfig.from_config_dict(
+            {
+                "segments": [
+                    {"video_path": "/a.mp4"},
+                    "not a dict",
+                    123,
+                    None,
+                    {"video_path": "/b.mp4"},
+                ],
+            }
+        )
+        assert len(c.segments) == 2
+
+    def test_output_resolution(self):
+        c = ConcatConfig.from_config_dict(
+            {
+                "segments": [{"video_path": "/a.mp4"}],
+                "output_width": 1920,
+                "output_height": 1080,
+            }
+        )
+        assert c.output_width == 1920
+        assert c.output_height == 1080
+
+    def test_output_width_clamped(self):
+        c = ConcatConfig.from_config_dict({"output_width": -100})
+        assert c.output_width == 0
+
+    def test_invalid_output_width_falls_back(self):
+        c = ConcatConfig.from_config_dict({"output_width": "wide"})
+        assert c.output_width == 0
+
+    def test_output_fps(self):
+        c = ConcatConfig.from_config_dict({"output_fps": 30.0})
+        assert c.output_fps == 30.0
+
+    def test_output_fps_clamped(self):
+        c = ConcatConfig.from_config_dict({"output_fps": -1.0})
+        assert c.output_fps == 0.0
+
+    def test_invalid_output_fps_falls_back(self):
+        c = ConcatConfig.from_config_dict({"output_fps": "fast"})
+        assert c.output_fps == 0.0
+
+    def test_force_reencode_true(self):
+        c = ConcatConfig.from_config_dict({"force_reencode": True})
+        assert c.force_reencode is True
+
+    def test_transition_crossfade(self):
+        c = ConcatConfig.from_config_dict({"transition": "crossfade"})
+        assert c.transition == "crossfade"
+
+    def test_transition_duration(self):
+        c = ConcatConfig.from_config_dict({"transition_duration": 1.0})
+        assert c.transition_duration == 1.0
+
+    def test_transition_duration_min_clamped(self):
+        c = ConcatConfig.from_config_dict({"transition_duration": 0.01})
+        # max(0.1, 0.01) = 0.1
+        assert c.transition_duration == 0.1
+        # 代码里 transition_duration = max(0.1, ...)，默认 0.3
+        # 0.01 < 0.1 ，所以被钳制到 0.1
+
+    def test_invalid_transition_duration_falls_back(self):
+        c = ConcatConfig.from_config_dict({"transition_duration": "long"})
+        assert c.transition_duration == 0.3
+
+    def test_segments_not_list_ignored(self):
+        c = ConcatConfig.from_config_dict({"segments": "not a list"})
+        assert c.segments == []
+
+
+class TestConcatConfigProperties:
+    """ConcatConfig 属性方法"""
+
+    def _make_config(self, n=3):
+        return ConcatConfig.from_config_dict(
+            {
+                "segments": [{"video_path": f"/s{i}.mp4", "duration": 10.0 + i} for i in range(n)],
+            }
+        )
+
+    def test_has_effect_true(self):
+        c = self._make_config(3)
+        assert c.has_effect is True
+
+    def test_has_effect_false_one_segment(self):
+        c = self._make_config(1)
+        assert c.has_effect is False
+
+    def test_has_effect_false_empty(self):
+        c = ConcatConfig()
+        assert c.has_effect is False
+
+    def test_valid_segment_count(self):
+        c = self._make_config(5)
+        assert c.valid_segment_count == 5
+
+    def test_total_segments_alias(self):
+        c = self._make_config(4)
+        assert c.total_segments == 4
+        assert c.total_segments == c.valid_segment_count
+
+    def test_first_valid_segment(self):
+        c = self._make_config(3)
+        first = c.first_valid_segment
+        assert first is not None
+        assert first.video_path == "/s0.mp4"
+
+    def test_first_valid_segment_empty(self):
+        c = ConcatConfig()
+        assert c.first_valid_segment is None
+
+    def test_estimated_total_duration(self):
+        c = ConcatConfig(
+            segments=[
+                ConcatSegment("/a.mp4", duration=10.0),
+                ConcatSegment("/b.mp4", duration=20.0),
+                ConcatSegment("/c.mp4", duration=0.0),  # 不计入
+            ]
+        )
+        assert c.estimated_total_duration == 30.0
+
+    def test_estimated_total_duration_empty(self):
+        c = ConcatConfig()
+        assert c.estimated_total_duration == 0.0
+
+    def test_clamp_segments_within_limit(self):
+        c = self._make_config(10)
+        original = len(c.segments)
+        c.clamp_segments(max_segments=50)
+        assert len(c.segments) == original
+
+    def test_clamp_segments_over_limit(self):
+        c = self._make_config(10)
+        c.clamp_segments(max_segments=3)
+        assert len(c.segments) == 3
+        assert c.segments[0].video_path == "/s0.mp4"
+        assert c.segments[2].video_path == "/s2.mp4"
+
+    def test_clamp_segments_default_max(self):
+        # 默认应该是 MAX_CONCAT_SEGMENTS
+        c = ConcatConfig(segments=[ConcatSegment(f"/s{i}.mp4") for i in range(100)])
+        c.clamp_segments()
+        assert len(c.segments) == MAX_CONCAT_SEGMENTS
+
+
+class TestTransitionDurationClamp:
+    """transition_duration 钳制边界"""
+
+    def test_min_boundary_01(self):
+        c = ConcatConfig.from_config_dict({"transition_duration": 0.1})
+        assert c.transition_duration == 0.1
+
+    def test_below_min_clamped(self):
+        c = ConcatConfig.from_config_dict({"transition_duration": 0.05})
+        # max(0.1, 0.05) = 0.1
+        assert c.transition_duration == 0.1
+
+    def test_large_duration_ok(self):
+        c = ConcatConfig.from_config_dict({"transition_duration": 5.0})
+        assert c.transition_duration == 5.0
+
+    def test_zero_clamped(self):
+        c = ConcatConfig.from_config_dict({"transition_duration": 0.0})
+        # max(0.1, 0.0) = 0.1
+        assert c.transition_duration == 0.1
+
+    def test_negative_clamped(self):
+        c = ConcatConfig.from_config_dict({"transition_duration": -1.0})
+        # max(0.1, -1.0) = 0.1
+        assert c.transition_duration == 0.1