fix: setExtractionOptions 改为 nbSamples: Infinity，提取全部样本

alembic/versions/057_add_title_config_to_generation_tasks.py

@@ -1,26 +0,0 @@
-"""Add title_config to generation_tasks
-
-Revision ID: 057_title_config
-Revises: 056_fix_cover_templates_config
-Create Date: 2026-08-23
-"""
-
-import sqlalchemy as sa
-
-from alembic import op
-
-revision = "057_title_config"
-down_revision = "056_fix_cover_templates_config"
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    op.add_column(
-        "generation_tasks",
-        sa.Column("title_config", sa.JSON(), nullable=False, server_default="{}"),
-    )
-
-
-def downgrade() -> None:
-    op.drop_column("generation_tasks", "title_config")

apps/api/app/api/routes/assets.py

@@ -18,6 +18,7 @@ from app.schemas.asset import (
     BatchMarkRequest,
     BatchOperationResponse,
     BatchTagRequest,
+    CreateAssetRequest,
     ListAssetsResponse,
     SmartMatchItem,
     SmartMatchRequest,
@@ -28,6 +29,11 @@ from app.schemas.asset import (
 from app.schemas.tag import TagAssetsRequest
 from fastapi import APIRouter, Depends, HTTPException, Query, Response
 
+from packages.application import (
+    CreateAssetCommand,
+    CreateAssetUseCase,
+)
+from packages.domain import AssetStatus, ClassificationStatus
 from packages.domain.smart_match import smart_select_assets
 
 logger = logging.getLogger(__name__)
@@ -671,12 +677,51 @@ def untag_asset(
 
 
 @router.post("", response_model=AssetResponse)
-def create_asset() -> None:
-    """
-    已废弃接口。
-    所有素材上传统一走 uploadAssetDirect → completeDirectUpload → ingest-jobs 流程。
-    """
-    raise HTTPException(
-        status_code=410,
-        detail="此接口已废弃。请使用 uploadAssetDirect 接口上传素材，Worker 会自动处理（视频转码、图片/音频元数据提取）并创建 Asset 记录。",
+def create_asset(
+    request: CreateAssetRequest,
+    authenticated_user: AuthenticatedUser = Depends(get_current_user),
+    asset_repository: Any = Depends(get_asset_repository),
+    asset_library_repository: Any = Depends(get_asset_library_repository),
+    project_repository: Any = Depends(get_project_repository),
+) -> AssetResponse:
+    # 先获取素材库，用于推导 project_id（前端可能不传）
+    library = asset_library_repository.get(request.library_id)
+    if library is None:
+        raise HTTPException(status_code=404, detail=f"AssetLibrary {request.library_id} not found")
+
+    # project_id 自动推导：优先用请求值，否则从 library 关联的项目获取
+    project_id = request.project_id or library.project_id
+
+    project = project_repository.find_by_id(project_id)
+    if project is None:
+        raise HTTPException(status_code=404, detail=f"Project {project_id} not found")
+    if not project.can_access(authenticated_user.user.id):
+        raise HTTPException(status_code=403, detail="Access denied to project")
+
+    # 确保 library 和 project 归属一致
+    if library.project_id != project_id:
+        raise HTTPException(status_code=400, detail="AssetLibrary does not belong to the specified project")
+
+    use_case = CreateAssetUseCase(asset_repository)
+    item = use_case.execute(
+        CreateAssetCommand(
+            project_id=project_id,
+            library_id=request.library_id,
+            name=request.name,
+            storage_key=request.storage_key,
+            mime_type=request.mime_type,
+            metadata=request.metadata,
+            file_size=request.file_size,
+            thumbnail_url=request.thumbnail_url,
+            duration=request.duration,
+            width=request.width,
+            height=request.height,
+            fps=request.fps,
+            codec=request.codec,
+            status=AssetStatus(request.status),
+            classification_status=ClassificationStatus(request.classification_status),
+            quality_score=request.quality_score,
+            uploaded_by_user_id=authenticated_user.user.id,
+        )
     )
+    return _to_asset_response(item)

apps/api/app/api/routes/generation_cover.py

@@ -31,6 +31,8 @@ logger = logging.getLogger(__name__)
 router = APIRouter(tags=["Generation"])
 
 
+
+
 # ── Schemas ──────────────────────────────────────────────────────────────
 
 
@@ -63,83 +65,6 @@ class GenerateCoverResponse(BaseModel):
 # ── Route ────────────────────────────────────────────────────────────────
 
 
-def _persist_cover_frame(
-    frame_url: str,
-    plan_id: str,
-    title_text: str = "",
-    *,
-    title_color: str = "#ffffff",
-    title_position: str = "bottom",
-    title_font_size: int | None = None,
-) -> str:
-    """下载 MediaKit 返回的临时帧图，可选叠加标题后转存到 OSS covers/ 路径。
-
-    Args:
-        frame_url: MediaKit 返回的临时帧图 URL
-        plan_id: 剪辑计划 ID（生成 OSS key）
-        title_text: 非空时用 Pillow 在帧上叠加标题（用于 E2 从源素材抽帧，
-            因为源素材本身没有烧录标题）
-        title_color: 标题字体颜色（#RRGGBB）
-        title_position: 标题位置 top/center/bottom
-        title_font_size: 标题字号，None 时自动计算
-    """
-    import tempfile
-    import uuid
-    from pathlib import Path
-
-    tmp_path: str | None = None
-    try:
-        import httpx
-
-        resp = httpx.get(frame_url, timeout=30, follow_redirects=True)
-        resp.raise_for_status()
-        if not resp.content:
-            return frame_url
-
-        with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tmp:
-            tmp.write(resp.content)
-            tmp_path = tmp.name
-
-        # E2 从源素材抽帧时，源素材无标题，叠加标题文字
-        if title_text and title_text.strip():
-            try:
-                from packages.shared.title_overlay import apply_title_to_image
-
-                applied = apply_title_to_image(
-                    tmp_path,
-                    title_text,
-                    color=title_color,
-                    position=title_position,
-                    font_size=title_font_size,
-                )
-                if applied:
-                    logger.info("[封面生成] E2 帧图已叠加标题: plan_id=%s", plan_id)
-            except Exception:
-                logger.warning(
-                    "[封面生成] E2 标题叠加失败（返回无标题帧）: plan_id=%s",
-                    plan_id,
-                    exc_info=True,
-                )
-
-        from packages.shared.storage import get_shared_storage_service
-
-        storage = get_shared_storage_service()
-        cover_key = f"covers/{plan_id}/cover_{uuid.uuid4().hex[:8]}.jpg"
-        storage.upload_file(
-            file_or_path=tmp_path,
-            storage_key=cover_key,
-            content_type="image/jpeg",
-        )
-        public_url = storage.get_url(cover_key)
-        return public_url or frame_url
-    except Exception:
-        logger.warning("封面帧转存失败，返回原始 URL: plan_id=%s", plan_id, exc_info=True)
-        return frame_url
-    finally:
-        if tmp_path:
-            Path(tmp_path).unlink(missing_ok=True)
-
-
 @router.post("/generate-cover", response_model=GenerateCoverResponse)
 def generate_cover(
     body: GenerateCoverRequest,
@@ -273,31 +198,44 @@ def generate_cover(
                 exc_info=True,
             )
 
-    # 使用裸 URL（rendered/* 已配置公开读）；找不到渲染视频时不立即报错，
-    # 因为步骤 E 可以直接从源素材抽帧（历史数据或 Worker 抽帧失败时的兜底）
+    # 仍然找不到才报 400
+    if not rendered_storage_key:
+        logger.error("[封面生成] ❌ 找不到预览视频: plan_id=%s", plan_id)
+        raise HTTPException(
+            status_code=400,
+            detail="请先生成预览视频，再生成封面",
+        )
+
+    # 回写到 plan.config
+    plan_svc.update_plan_config(plan_id, {"rendered_storage_key": rendered_storage_key})
+
+    # 使用裸 URL（rendered/* 已配置公开读）
     primary_video_url = None
-    if rendered_storage_key:
-        plan_svc.update_plan_config(plan_id, {"rendered_storage_key": rendered_storage_key})
-        try:
-            if rendered_storage_key.startswith("http"):
-                primary_video_url = rendered_storage_key
-            else:
-                from packages.shared.storage import get_shared_storage_service
+    try:
+        if rendered_storage_key.startswith("http"):
+            primary_video_url = rendered_storage_key
+        else:
+            from packages.shared.storage import get_shared_storage_service
 
-                storage_svc = get_shared_storage_service()
-                primary_video_url = storage_svc.get_url(rendered_storage_key)
-            if primary_video_url:
-                import re as _re
+            storage_svc = get_shared_storage_service()
+            primary_video_url = storage_svc.get_url(rendered_storage_key)
+        # 防御性规范化：合并路径中的双斜杠（// -> /），但保留协议头的 ://
+        # 历史数据中 project_id 为空时会产生 projects//tasks/ 路径，
+        # MediaKit 的 HTTP 客户端会规范化 URL 导致 404
+        if primary_video_url:
+            import re as _re
 
-                primary_video_url = _re.sub(r"(?<!:)//", "/", primary_video_url)
-            logger.info(
-                "获取预览视频URL用于封面生成: plan_id=%s url=%s",
-                plan_id,
-                primary_video_url[:80] if primary_video_url else "",
-            )
-        except Exception as e:
-            logger.warning("获取预览视频URL失败: plan_id=%s err=%s", plan_id, e)
-            primary_video_url = None
+            primary_video_url = _re.sub(r"(?<!:)//", "/", primary_video_url)
+        logger.info(
+            "获取预览视频URL用于封面生成: plan_id=%s url=%s",
+            plan_id,
+            primary_video_url[:80] if primary_video_url else "",
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"获取预览视频URL失败: {e}",
+        ) from e
 
     # 统一封面管道：优先从 GenerationTask.cover_url 读取渲染后视频抽帧的封面
     # 多步查找 cover_url，和查找视频 URL 一样的 fallback 逻辑
@@ -372,129 +310,6 @@ def generate_cover(
                     exc_info=True,
                 )
 
-        # 步骤 D：从 plan.config.cover_candidates 读取（Worker 渲染时写入）
-        if not cover_url_from_task:
-            _candidates = (plan.config or {}).get("cover_candidates") or []
-            if isinstance(_candidates, list) and _candidates:
-                _first = _candidates[0]
-                if isinstance(_first, dict):
-                    cover_url_from_task = _first.get("image_url") or _first.get("url") or ""
-                    if cover_url_from_task:
-                        logger.info(
-                            "[封面生成] 统一管道封面(步骤D-cover_candidates): plan_id=%s url=%s",
-                            plan_id,
-                            cover_url_from_task[:80],
-                        )
-
-        # 步骤 E1：如果有已渲染的预览视频 URL 但 cover_url 未持久化（历史数据），
-        # 直接从渲染视频抽帧
-        if not cover_url_from_task and primary_video_url:
-            try:
-                from packages.shared.mediakit_client import get_mediakit_client
-
-                mk_client = get_mediakit_client()
-                if mk_client.is_available:
-                    logger.info(
-                        "[封面生成] 步骤E1-从渲染视频抽帧: plan_id=%s url=%s",
-                        plan_id,
-                        primary_video_url[:80],
-                    )
-                    snapshots = mk_client.extract_frames(
-                        video_url=primary_video_url,
-                        strategy="SpecifiedFrames",
-                        max_frames=1,
-                        poll_interval=2.0,
-                        max_poll_attempts=5,
-                        max_retries=0,
-                    )
-                    if snapshots:
-                        raw = snapshots[0].get("image_url") or snapshots[0].get("url") or ""
-                        if raw:
-                            cover_url_from_task = _persist_cover_frame(raw, plan_id)
-                            logger.info(
-                                "[封面生成] 统一管道封面(步骤E1-rendered-video): plan_id=%s url=%s",
-                                plan_id,
-                                cover_url_from_task[:80],
-                            )
-            except Exception:
-                logger.warning(
-                    "[封面生成] 步骤E1从渲染视频抽帧失败: plan_id=%s",
-                    plan_id,
-                    exc_info=True,
-                )
-
-        # 步骤 E2：当 A/B/C/D/E1 均未命中（如历史预览任务无 cover_url）时，
-        # 直接从用户选择的第一个视频素材中抽取封面帧作为兜底。API 请求内短超时，不阻塞。
-        if not cover_url_from_task and body.asset_ids:
-            from packages.adapters.sqlalchemy_impl.asset_repository import (
-                SQLAlchemyAssetRepository,
-            )
-            from packages.shared.mediakit_client import get_mediakit_client
-            from packages.shared.storage import get_shared_storage_service
-
-            asset_repo = SQLAlchemyAssetRepository(db)
-            storage_svc = get_shared_storage_service()
-            mk_client = get_mediakit_client()
-            # 从 plan.config 读取完整标题样式，E2 从源素材抽帧时叠加（源素材本身无标题）
-            _e2_title_cfg = (plan.config or {}).get("title", {}) or {}
-            if not isinstance(_e2_title_cfg, dict):
-                _e2_title_cfg = {}
-            _e2_title_text = (_e2_title_cfg.get("text", "") or "").strip() if _e2_title_cfg.get("enabled", True) else ""
-            # 读取标题样式：前端可能传 color 或 font_color，都兼容
-            _e2_title_color = _e2_title_cfg.get("color") or _e2_title_cfg.get("font_color") or "#ffffff"
-            _e2_title_position = _e2_title_cfg.get("position", "bottom") or "bottom"
-            _e2_title_font_size = _e2_title_cfg.get("font_size") or _e2_title_cfg.get("size")
-            if mk_client.is_available:
-                for aid in body.asset_ids:
-                    try:
-                        asset = asset_repo.get(aid)
-                        if not asset or asset.file_type != "video":
-                            continue
-                        sk = asset.storage_key or ""
-                        if not sk:
-                            continue
-                        src_url = sk if sk.startswith("http") else storage_svc.get_url(sk)
-                        if not src_url:
-                            continue
-                        logger.info(
-                            "[封面生成] 步骤E-从素材抽帧: plan_id=%s asset_id=%s url=%s",
-                            plan_id,
-                            aid,
-                            src_url[:80],
-                        )
-                        snapshots = mk_client.extract_frames(
-                            video_url=src_url,
-                            strategy="SpecifiedFrames",
-                            max_frames=1,
-                            poll_interval=2.0,
-                            max_poll_attempts=5,
-                            max_retries=0,
-                        )
-                        if snapshots:
-                            raw = snapshots[0].get("image_url") or snapshots[0].get("url") or ""
-                            if raw:
-                                cover_url_from_task = _persist_cover_frame(
-                                    raw,
-                                    plan_id,
-                                    title_text=_e2_title_text,
-                                    title_color=_e2_title_color,
-                                    title_position=_e2_title_position,
-                                    title_font_size=_e2_title_font_size,
-                                )
-                                logger.info(
-                                    "[封面生成] 统一管道封面(步骤E-source-asset): plan_id=%s url=%s",
-                                    plan_id,
-                                    cover_url_from_task[:80],
-                                )
-                                break
-                    except Exception:
-                        logger.warning(
-                            "[封面生成] 步骤E从素材抽帧失败: plan_id=%s asset_id=%s",
-                            plan_id,
-                            aid,
-                            exc_info=True,
-                        )
-
         if cover_url_from_task:
             # 标题已在预览视频渲染时烧录（ASS字幕），封面帧自然包含标题
             cover_data = {
@@ -510,13 +325,13 @@ def generate_cover(
             return GenerateCoverResponse(plan_id=plan_id, cover=cover_data)
 
         logger.warning(
-            "[封面生成] 统一管道未找到 cover_url (A/B/C/D均未命中): plan_id=%s",
+            "[封面生成] 统一管道未找到 cover_url: plan_id=%s",
             plan_id,
         )
         # ai_frame/ai_regenerate 类型必须从渲染管道获取，不再回退到 AI 服务
         raise HTTPException(
             status_code=400,
-            detail="封面生成失败：未找到可抽帧的视频素材，请确认已上传视频素材后重试",
+            detail="封面尚未生成，请先重新生成预览视频以触发封面自动提取",
         )
 
     from packages.shared.ai_service import run_generate_cover

apps/api/app/api/routes/generation_preview.py

@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 
+import json
 import logging
 
 from app.auth import AuthenticatedUser, get_current_user
@@ -267,7 +268,19 @@ def create_preview_generation_task(
     # 从模板读取 editing_mode / mode 作为 strategy_id（渲染 pipeline 的 mode 参数）
     strategy_id = _resolve_strategy_id_from_template(request.template_id, db, user_id)
 
+    # 处理标题配置：如果有标题文本，序列化到 custom_title 字段传递给 worker
     title_config = request.title_config or {}
+    title_text = (title_config.get("text") or "").strip()
+    custom_title_value = ""
+    if title_text:
+        # 将标题文本和样式配置序列化为 JSON 存入 custom_title
+        # Worker 端会解析 JSON 获取完整标题配置
+        custom_title_value = json.dumps(title_config, ensure_ascii=False)
+        logger.info(
+            "[预览生成] 标题配置: text=%s, config_keys=%s",
+            title_text[:30],
+            list(title_config.keys()),
+        )
 
     use_case = CreateGenerationTaskUseCase(generation_task_repository)
 
@@ -292,7 +305,7 @@ def create_preview_generation_task(
                 auto_retry_enabled=False,
                 auto_retry_max=0,
                 is_preview=True,
-                title_config=title_config,
+                custom_title=custom_title_value,
             )
         )
     except ValueError as e:

apps/api/app/api/routes/generation_tasks.py

@@ -16,7 +16,6 @@ from app.core.task_enqueue import (
 from app.dependencies import (
     get_asset_library_repository,
     get_asset_repository,
-    get_db_session,
     get_generated_video_repository,
     get_generation_task_repository,
     get_project_repository,
@@ -33,7 +32,6 @@ from app.schemas.generation_task import (
     ListGenerationTasksResponse,
 )
 from fastapi import APIRouter, Depends, HTTPException
-from sqlalchemy.orm import Session
 
 from packages.application import (
     CreateGenerationTaskCommand,
@@ -70,7 +68,7 @@ def _to_generation_task_response(task) -> GenerationTaskResponse:
         output_width=getattr(task, "output_width", 1280),
         output_height=getattr(task, "output_height", 720),
         cover_url=getattr(task, "cover_url", ""),
-        title_config=getattr(task, "title_config", {}) or {},
+        custom_title=getattr(task, "custom_title", ""),
         logs=getattr(task, "logs", "[]"),
         status=task.status,
         progress=task.progress,
@@ -144,54 +142,6 @@ def _select_assets_from_library(
     return [a.id for a in ready_video_assets]
 
 
-
-def _writeback_edit_plan_config(
-    plan_id: str,
-    task_id: str,
-    title_config: dict | None,
-    db: Session,
-) -> None:
-    """任务入队成功后，回写 EditPlan.config：generation_task_id + title_config。
-
-    用 merge 方式更新，不整体覆盖 config，避免丢失其他字段。
-    失败只记日志，不影响任务创建。
-    """
-    if not plan_id:
-        return
-    try:
-        from packages.adapters.sqlalchemy_impl.models import EditPlanModel
-
-        plan_model = db.query(EditPlanModel).filter(EditPlanModel.id == plan_id).first()
-        if plan_model is None:
-            logger.warning("[生成任务] 回写plan.config失败: plan不存在 plan_id=%s", plan_id)
-            return
-
-        current_config = plan_model.config if isinstance(plan_model.config, dict) else {}
-        merged = dict(current_config)
-        merged["generation_task_id"] = task_id
-        if title_config:
-            merged["title_config"] = title_config
-        plan_model.config = merged
-        db.commit()
-        logger.info(
-            "[生成任务] 回写plan.config成功: plan_id=%s task_id=%s keys=%s",
-            plan_id,
-            task_id,
-            list(merged.keys()),
-        )
-    except Exception as e:
-        logger.warning(
-            "[生成任务] 回写plan.config异常（不影响任务创建）: plan_id=%s error=%s",
-            plan_id,
-            e,
-            exc_info=True,
-        )
-        try:
-            db.rollback()
-        except Exception:
-            pass
-
-
 def _resolve_project_and_library(
     request: CreateGenerationTaskRequest,
     project_repository: Any,
@@ -237,7 +187,6 @@ def create_generation_task(
     project_repository: Any = Depends(get_project_repository),
     asset_library_repository: Any = Depends(get_asset_library_repository),
     asset_repository: Any = Depends(get_asset_repository),
-    db: Session = Depends(get_db_session),
 ) -> BatchGenerationTaskResponse:
     logger.info(
         "[生成任务] 接收请求: user_id=%s, template_id=%s, asset_count=%d, mode=%s, count=%d",
@@ -293,89 +242,6 @@ def create_generation_task(
                     detail="当前项目没有符合条件的视频素材，请先上传并等待导入完成后再生成。",
                 )
 
-    # ── 兜底复用预览产物 ──
-    # 前端刷新后 previewTaskId 丢失，降级调 create 接口时，
-    # 如果同一 edit_plan 有已完成的预览任务，直接复用（秒出）。
-    if request.source_edit_plan_id and not request.is_preview:
-        try:
-            from packages.adapters.sqlalchemy_impl.models import (
-                GenerationTaskModel,
-            )
-
-            _preview_model = (
-                db.query(GenerationTaskModel)
-                .filter(
-                    GenerationTaskModel.source_edit_plan_id == request.source_edit_plan_id,
-                    GenerationTaskModel.is_preview.is_(True),
-                    GenerationTaskModel.status == "completed",
-                    GenerationTaskModel.created_by_user_id == authenticated_user.user.id,
-                )
-                .order_by(GenerationTaskModel.created_at.desc())
-                .first()
-            )
-            if _preview_model is not None:
-                # 校验分辨率一致性（与 confirm 端点逻辑相同）
-                req_w = request.output_width or 0
-                req_h = request.output_height or 0
-                src_w = getattr(_preview_model, "output_width", 0) or 0
-                src_h = getattr(_preview_model, "output_height", 0) or 0
-                resolution_match = (req_w == 0 or req_w == src_w) and (req_h == 0 or req_h == src_h)
-
-                if resolution_match:
-                    from packages.adapters.sqlalchemy_impl.generation_task_repository import (
-                        _to_domain,
-                    )
-
-                    preview_task = _to_domain(_preview_model)
-
-                    # 如果传了标题，更新 title_config
-                    fallback_title_config = None
-                    if request.title_config and request.title_config.get("text", "").strip():
-                        fallback_title_config = dict(preview_task.title_config or {})
-                        fallback_title_config.update(request.title_config)
-
-                    preview_task.mark_confirmed(
-                        cover_url=request.cover_url or preview_task.cover_url,
-                        output_width=request.output_width or preview_task.output_width,
-                        output_height=request.output_height or preview_task.output_height,
-                        title_config=fallback_title_config,
-                    )
-                    generation_task_repository.update(preview_task)
-
-                    # 同步标题到 EditPlan.config
-                    if fallback_title_config:
-                        _writeback_edit_plan_config(
-                            plan_id=request.source_edit_plan_id,
-                            task_id=preview_task.id,
-                            title_config=fallback_title_config,
-                            db=db,
-                        )
-
-                    logger.info(
-                        "[生成任务] 兜底复用预览产物: preview_task_id=%s, plan_id=%s",
-                        preview_task.id,
-                        request.source_edit_plan_id,
-                    )
-                    return BatchGenerationTaskResponse(
-                        items=[_to_generation_task_response(preview_task)],
-                        total=1,
-                    )
-                else:
-                    logger.info(
-                        "[生成任务] 兜底复用跳过（分辨率不一致）: plan_id=%s, src=%sx%s, req=%sx%s",
-                        request.source_edit_plan_id,
-                        src_w,
-                        src_h,
-                        req_w,
-                        req_h,
-                    )
-        except Exception:
-            logger.warning(
-                "[生成任务] 兜底复用预览产物异常（不影响主流程）: plan_id=%s",
-                request.source_edit_plan_id,
-                exc_info=True,
-            )
-
     use_case = CreateGenerationTaskUseCase(generation_task_repository)
     count = request.count
     created_tasks = []
@@ -437,53 +303,10 @@ def create_generation_task(
                     output_width=request.output_width,
                     output_height=request.output_height,
                     cover_url=request.cover_url,
-                    title_config=request.title_config or {},
+                    custom_title=request.custom_title,
                 )
             )
             try:
-                # 兜底关联编辑计划：前端未传 source_edit_plan_id 时，
-                # 通过 template_id + user_id 在 DB 层直接查找最新的 plan。
-                # 必须在 enqueue 之前执行，避免 worker 读取时 source_edit_plan_id 为空（竞态条件）
-                if not task.source_edit_plan_id and request.template_id:
-                    try:
-                        from packages.adapters.sqlalchemy_impl.models import EditPlanModel
-
-                        _plan_model = (
-                            db.query(EditPlanModel)
-                            .filter(
-                                EditPlanModel.template_id == request.template_id,
-                                EditPlanModel.created_by_user_id == user_id,
-                            )
-                            .order_by(EditPlanModel.created_at.desc())
-                            .first()
-                        )
-                        if _plan_model:
-                            task.source_edit_plan_id = _plan_model.id
-                            generation_task_repository.update(task)
-                            logger.info(
-                                "[生成任务] 自动关联编辑计划: task_id=%s plan_id=%s",
-                                task.id,
-                                _plan_model.id,
-                            )
-                    except Exception:
-                        logger.warning(
-                            "[生成任务] 查找关联编辑计划失败（不影响主流程）: task_id=%s",
-                            task.id,
-                            exc_info=True,
-                        )
-
-                # 回写 plan.config：必须在 enqueue 之前执行，
-                # 确保 worker 读取 plan 时 config 中已包含 generation_task_id。
-                # 只在首个任务时回写一次，避免批量生成时循环覆盖。
-                _effective_plan_id = task.source_edit_plan_id
-                if _effective_plan_id and len(created_tasks) == 0:
-                    _writeback_edit_plan_config(
-                        plan_id=_effective_plan_id,
-                        task_id=task.id,
-                        title_config=request.title_config,
-                        db=db,
-                    )
-
                 if safe_enqueue_generation_task(
                     task,
                     generation_task_repository,
@@ -528,7 +351,6 @@ def confirm_generation(
     authenticated_user: AuthenticatedUser = Depends(get_current_user),
     generation_task_repository: Any = Depends(get_generation_task_repository),
     project_repository: Any = Depends(get_project_repository),
-    db: Session = Depends(get_db_session),
 ) -> BatchGenerationTaskResponse:
     """确认生成 -- 复用预览渲染产物（预览与正式品质一致）。
 
@@ -557,29 +379,13 @@ def confirm_generation(
         resolution_match = (req_w == 0 or req_w == src_w) and (req_h == 0 or req_h == src_h)
 
         if resolution_match:
-            # 如果用户传了 custom_title，同步更新 title_config
-            confirmed_title_config = None
-            if request.custom_title and request.custom_title.strip():
-                confirmed_title_config = dict(getattr(source_task, "title_config", {}) or {})
-                confirmed_title_config["text"] = request.custom_title.strip()
-
             source_task.mark_confirmed(
                 cover_url=request.cover_url,
+                custom_title=request.custom_title,
                 output_width=request.output_width,
                 output_height=request.output_height,
-                title_config=confirmed_title_config,
             )
             generation_task_repository.update(source_task)
-
-            # 同步标题到 EditPlan.config
-            if confirmed_title_config and source_task.source_edit_plan_id:
-                _writeback_edit_plan_config(
-                    plan_id=source_task.source_edit_plan_id,
-                    task_id=source_task.id,
-                    title_config=confirmed_title_config,
-                    db=db,
-                )
-
             logger.info(
                 "[确认生成] 复用预览产物: task_id=%s, user_id=%s",
                 task_id,
@@ -621,6 +427,7 @@ def confirm_generation(
             output_width=request.output_width,
             output_height=request.output_height,
             cover_url=request.cover_url,
+            custom_title=request.custom_title,
         )
     )
 
@@ -753,6 +560,7 @@ def retry_generation_task(
             output_width=getattr(task, "output_width", 1280),
             output_height=getattr(task, "output_height", 720),
             cover_url=getattr(task, "cover_url", ""),
+            custom_title=getattr(task, "custom_title", ""),
         )
     )
     try:

apps/api/app/api/routes/templates_editor/__init__.py

@@ -1,9 +1,10 @@
 """模板编辑器 API 路由包.
 
-模块拆分：
+将原来 2560 行的 templates_editor.py 巨无霸拆分为 12 个模块：
 - schemas.py:        所有 Pydantic model
 - dependencies.py:   依赖注入
 - _utils.py:         工具函数
+- _fallback.py:      自动兜底逻辑
 - draft.py:          草稿管理（详情/更新/发布/版本/回滚）
 - clips.py:          片段管理（CRUD/分割/合并/重排/批量删除/从素材创建）
 - adjustments.py:    片段调整（速度/音量/裁剪/批量调速）
@@ -12,6 +13,7 @@
 - export.py:         导出配置
 - subtitles.py:      字幕管理
 - ai_features.py:    AI 推荐
+- generation.py:     生成（触发/进度/记录）
 - timeline.py:       时间线
 
 挂载路径: /api/v1/templates/{template_id}/editor/
@@ -32,6 +34,7 @@ from .dependencies import get_draft_plan_id, get_editor_services  # noqa: F401
 from .draft import router as draft_router
 from .effects import router as effects_router
 from .export import router as export_router
+from .generation import router as generation_router
 from .subtitles import router as subtitles_router
 from .timeline import router as timeline_router
 
@@ -48,6 +51,7 @@ _sub_routers = [
     export_router,
     subtitles_router,
     ai_features_router,
+    generation_router,
     timeline_router,
 ]
 

apps/api/app/api/routes/templates_editor/_fallback.py

@@ -0,0 +1,227 @@
+"""模板编辑器自动兜底逻辑.
+
+generate_editor_draft 触发生成前的自动修复流程：
+1. draft → editing 状态迁移
+2. 无片段时从模板复制片段配置
+3. 为无素材片段分配指定素材
+4. 项目有素材库时自动选素材
+"""
+
+from __future__ import annotations
+
+import logging
+import random
+from typing import Any
+
+from app.services.edit_plan_service import EditPlanService
+from sqlalchemy.orm import Session
+
+from packages.adapters.sqlalchemy_impl.template_clip_config_repository import (
+    SQLAlchemyTemplateClipConfigRepository,
+)
+from packages.adapters.sqlalchemy_impl.template_repository import (
+    SQLAlchemyTemplateRepository,
+)
+from packages.domain.edit_plan import EditPlanStatus
+
+logger = logging.getLogger(__name__)
+
+
+def _auto_fallback_draft_to_editing(svc: EditPlanService, plan_id: str, plan_check) -> None:
+    """自动兜底 1: draft → editing"""
+    if plan_check.status == EditPlanStatus.DRAFT:
+        logger.info("模板编辑器自动兜底: plan=%s draft→editing", plan_id)
+        svc.transition_status(plan_id, EditPlanStatus.EDITING)
+
+
+def _auto_fallback_copy_template_clips(svc: EditPlanService, plan_id: str, plan_check, db: Session) -> None:
+    """自动兜底 2: 无片段 + 有 template_id → 从模板复制片段配置"""
+    existing_clips = svc.count_clips(plan_id)
+    if existing_clips == 0 and plan_check.template_id:
+        logger.info(
+            "模板编辑器自动兜底: plan=%s 无片段，从模板 %s 复制片段配置",
+            plan_id,
+            plan_check.template_id,
+        )
+        clip_config_repo = SQLAlchemyTemplateClipConfigRepository(db)
+        configs = clip_config_repo.list_by_template(plan_check.template_id)
+        if configs:
+            for cfg in configs:
+                svc.create_clip(
+                    plan_id=plan_id,
+                    clip_type=cfg.clip_type.value if hasattr(cfg.clip_type, "value") else cfg.clip_type,
+                    order=cfg.order,
+                    template_clip_config_id=cfg.id,
+                    duration=cfg.default_duration,
+                    transition_effect=(
+                        cfg.transition_effect.value
+                        if hasattr(cfg.transition_effect, "value")
+                        else cfg.transition_effect
+                    ),
+                )
+            logger.info(
+                "模板编辑器自动兜底: plan=%s 从 template_clip_configs 复制了 %d 个片段",
+                plan_id,
+                len(configs),
+            )
+        else:
+            tpl_repo = SQLAlchemyTemplateRepository(db)
+            segments = tpl_repo.list_segments(plan_check.template_id)
+            for seg in segments:
+                avg_duration = (seg.duration_min + seg.duration_max) / 2
+                svc.create_clip(
+                    plan_id=plan_id,
+                    clip_type="main",
+                    order=seg.segment_order,
+                    duration=avg_duration,
+                    config={
+                        "material_type": seg.material_type or "",
+                        "template_segment_id": seg.id,
+                    },
+                )
+            logger.info(
+                "模板编辑器自动兜底: plan=%s 从旧模板 segments 复制了 %d 个片段",
+                plan_id,
+                len(segments),
+            )
+
+
+def _auto_fallback_assign_assets(svc: EditPlanService, plan_id: str, plan_check) -> list:
+    """自动兜底 3: 为没有素材的片段分配素材。返回剩余无素材片段列表。"""
+    all_clips = svc.list_clips(plan_id)
+    clips_without_asset = [c for c in all_clips if not c.asset_id]
+    config_asset_ids = (plan_check.config or {}).get("asset_ids", [])
+
+    logger.info(
+        "模板编辑器自动兜底3 诊断: plan=%s total_clips=%d " "clips_without_asset=%d config_asset_ids=%r",
+        plan_id,
+        len(all_clips),
+        len(clips_without_asset),
+        config_asset_ids[:5] if config_asset_ids else [],
+    )
+
+    if clips_without_asset and config_asset_ids:
+        logger.info(
+            "模板编辑器自动兜底3: plan=%s 为 %d 个无素材片段分配 %d 个指定素材",
+            plan_id,
+            len(clips_without_asset),
+            len(config_asset_ids),
+        )
+        assigned = 0
+        for i, clip in enumerate(clips_without_asset):
+            asset_idx = i % len(config_asset_ids)
+            try:
+                svc.assign_asset(clip.id, config_asset_ids[asset_idx])
+                assigned += 1
+            except Exception as exc:
+                logger.error(
+                    "模板编辑器自动兜底3: plan=%s clip=%s 分配素材 %s 失败: %s",
+                    plan_id,
+                    clip.id,
+                    config_asset_ids[asset_idx],
+                    exc,
+                )
+        logger.info(
+            "模板编辑器自动兜底3: plan=%s 素材分配完成 assigned=%d/%d",
+            plan_id,
+            assigned,
+            len(clips_without_asset),
+        )
+        # 重新检查剩余无素材片段
+        all_clips_after = svc.list_clips(plan_id)
+        clips_without_asset = [c for c in all_clips_after if not c.asset_id]
+        if clips_without_asset:
+            logger.warning(
+                "模板编辑器自动兜底3: plan=%s 仍有 %d 个片段无素材",
+                plan_id,
+                len(clips_without_asset),
+            )
+    elif not clips_without_asset:
+        logger.info("模板编辑器自动兜底3: plan=%s 所有片段已有素材，跳过", plan_id)
+    elif not config_asset_ids:
+        logger.info(
+            "模板编辑器自动兜底3: plan=%s config.asset_ids 为空，跳过分配",
+            plan_id,
+        )
+
+    return clips_without_asset
+
+
+def _auto_fallback_auto_material_mode(
+    svc: EditPlanService,
+    plan_id: str,
+    plan_check,
+    clips_without_asset: list,
+    asset_library_repo: Any,
+    asset_repo: Any,
+    user_id: str = "",
+) -> None:
+    """自动兜底 4: 自动选素材分配给无素材片段
+
+    查找策略（按优先级）：
+    1. plan 有 project_id → 从项目素材库查找
+    2. plan 无 project_id 但有 user_id → 从用户上传的素材中查找
+    """
+    if not clips_without_asset:
+        return
+
+    ready_videos: list = []
+    source_desc = ""
+
+    # 策略 1: 通过 project_id 查找项目素材库
+    if plan_check.project_id:
+        libs = asset_library_repo.find_by_project(plan_check.project_id)
+        video_lib = None
+        for lib in libs:
+            lib_kind = lib.kind.value if hasattr(lib.kind, "value") else lib.kind
+            if lib_kind == "video":
+                video_lib = lib
+                break
+        if video_lib:
+            assets = asset_repo.find_by_library(video_lib.id)
+            ready_videos = [
+                a
+                for a in assets
+                if (a.status.value if hasattr(a.status, "value") else a.status) == "ready"
+                and a.mime_type
+                and a.mime_type.startswith("video")
+            ]
+            source_desc = f"素材库 {video_lib.name}"
+
+    # 策略 2: 通过 user_id 查找用户上传的素材
+    if not ready_videos and user_id and hasattr(asset_repo, "find_ready_videos_by_user"):
+        logger.info(
+            "模板编辑器自动兜底4: plan=%s project_id 为空，尝试通过 user_id=%s 查找素材",
+            plan_id,
+            user_id,
+        )
+        ready_videos = asset_repo.find_ready_videos_by_user(user_id)
+        source_desc = f"用户上传 (user_id={user_id[:8]}...)"
+
+    if not ready_videos:
+        logger.warning(
+            "模板编辑器自动兜底4: plan=%s 未找到可用素材 (project_id=%s, user_id=%s)",
+            plan_id,
+            plan_check.project_id or "(empty)",
+            user_id[:8] + "..." if user_id else "(empty)",
+        )
+        return
+
+    logger.info(
+        "模板编辑器自动兜底4: plan=%s 自动选素材分配给 %d 个无素材片段 (来源: %s, 共 %d 个)",
+        plan_id,
+        len(clips_without_asset),
+        source_desc,
+        len(ready_videos),
+    )
+    random.shuffle(ready_videos)
+    for i, clip in enumerate(clips_without_asset):
+        asset = ready_videos[i % len(ready_videos)]
+        svc.assign_asset(clip.id, asset.id)
+    logger.info(
+        "模板编辑器自动兜底4: plan=%s 从 %s 分配了 %d 个素材给 %d 个片段",
+        plan_id,
+        source_desc,
+        len(ready_videos),
+        len(clips_without_asset),
+    )

apps/api/app/api/routes/templates_editor/dependencies.py

@@ -3,6 +3,7 @@
 核心依赖：
 - get_editor_services: 获取模板+计划服务
 - get_draft_plan_id: 根据 template_id 获取或创建草稿，返回 plan_id
+- _check_queue_limits: 生成队列限流检查
 """
 
 from __future__ import annotations
@@ -10,6 +11,7 @@ from __future__ import annotations
 import logging
 
 from app.auth import AuthenticatedUser, get_current_user
+from app.core.task_enqueue import GLOBAL_PENDING_LIMIT, USER_PENDING_LIMIT
 from app.dependencies import get_db_session
 from app.services.edit_plan_service import EditPlanService
 from app.services.edit_template_service import EditTemplateService
@@ -111,3 +113,29 @@ def get_draft_plan_id(
         user_id,
     )
     return plan.id
+
+
+def _check_queue_limits(gen_task_repo, user_id: str) -> None:
+    """队列限流预检查"""
+    try:
+        has_count = (
+            hasattr(gen_task_repo, "count_pending_by_user")
+            and hasattr(gen_task_repo, "count_pending_total")
+        )
+        if has_count:
+            user_pending = gen_task_repo.count_pending_by_user(user_id)
+            global_pending = gen_task_repo.count_pending_total()
+            if user_pending >= USER_PENDING_LIMIT:
+                raise HTTPException(
+                    status_code=429,
+                    detail=f"您的待处理任务过多（当前 {user_pending}/{USER_PENDING_LIMIT}），请等待完成后再提交",
+                )
+            if global_pending >= GLOBAL_PENDING_LIMIT:
+                raise HTTPException(
+                    status_code=503,
+                    detail="系统繁忙，请稍后再试",
+                )
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.warning("[模板编辑器队列限流] 检查失败，跳过: %s", e)

apps/api/app/api/routes/templates_editor/draft.py

@@ -17,8 +17,6 @@ from fastapi import APIRouter, Depends, HTTPException, Query, status
 
 from .dependencies import get_draft_plan_id, get_editor_services
 from .schemas import (
-    EditorClipBatchUpdateRequest,
-    EditorClipBatchUpdateResponse,
     EditorDraftResponse,
     EditorPublishResponse,
     EditorRollbackRequest,
@@ -128,7 +126,11 @@ def list_template_versions(
             clip_count=len(v.clip_configs),
             change_note=v.change_note,
             published_by=v.published_by,
-            created_at=(v.created_at.isoformat() if hasattr(v.created_at, "isoformat") else str(v.created_at)),
+            created_at=(
+                v.created_at.isoformat()
+                if hasattr(v.created_at, "isoformat")
+                else str(v.created_at)
+            ),
         )
         for v in versions
     ]
@@ -160,35 +162,3 @@ def rollback_template(
         new_version=tpl.version,
         clip_count=len(clip_configs),
     )
-
-
-@router.put("/clips", response_model=EditorClipBatchUpdateResponse)
-def batch_update_clips(
-    template_id: str,
-    req: EditorClipBatchUpdateRequest,
-    plan_id: str = Depends(get_draft_plan_id),
-    services: tuple[EditTemplateService, EditPlanService] = Depends(get_editor_services),
-    _: AuthenticatedUser = Depends(get_current_user),
-):
-    """批量替换草稿clips（全量覆盖，用于前端选择素材后同步片段）
-
-    事务保证：清空→创建→标记ready 在同一数据库事务内完成，
-    任何步骤失败时自动回滚，避免数据不一致。
-    """
-    _, plan_svc = services
-    plan_svc.get_plan_or_raise(plan_id)
-
-    clips_data = []
-    for clip_item in req.clips:
-        item = {
-            "asset_id": clip_item.asset_id,
-            "start_time": clip_item.start_time,
-            "duration": clip_item.duration,
-        }
-        if clip_item.order is not None:
-            item["order"] = clip_item.order
-        clips_data.append(item)
-
-    plan_svc.replace_all_clips_transactional(plan_id, clips_data)
-
-    return EditorClipBatchUpdateResponse(plan_id=plan_id, clip_count=len(req.clips))

apps/api/app/api/routes/templates_editor/generation.py

@@ -0,0 +1,383 @@
+"""草稿生成路由.
+
+端点：
+- POST /generate              触发生成
+- GET  /generation-status     生成进度
+- GET  /generations           生成记录列表
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any, Optional
+
+from app.auth import AuthenticatedUser, get_current_user
+from app.core.celery_app import celery_app
+from app.core.storage import OSSStorageService, get_storage_service
+from app.dependencies import (
+    get_asset_library_repository,
+    get_asset_repository,
+    get_db_session,
+    get_generated_video_repository,
+)
+from app.schemas.generation_task import GenerationTaskResponse
+from app.services.edit_plan_service import EditPlanService
+from app.services.edit_template_service import EditTemplateService
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+
+from packages.adapters.sqlalchemy_impl.generation_task_repository import (
+    SQLAlchemyGenerationTaskRepository,
+)
+from packages.application.generated_videos import ListGeneratedVideosByTaskUseCase
+from packages.application.generation_tasks import (
+    CreateGenerationTaskCommand,
+    CreateGenerationTaskUseCase,
+)
+from packages.domain.edit_plan import EditPlanStatus
+
+from ._fallback import (
+    _auto_fallback_assign_assets,
+    _auto_fallback_auto_material_mode,
+    _auto_fallback_copy_template_clips,
+    _auto_fallback_draft_to_editing,
+)
+from .dependencies import _check_queue_limits, get_draft_plan_id, get_editor_services
+from .schemas import (
+    ClipStatusItem,
+    EditPlanGenerateRequest,
+    EditPlanGenerateResponse,
+    EditPlanGenerationsResponse,
+    EditPlanGenerationStatusResponse,
+)
+
+logger = logging.getLogger(__name__)
+router = APIRouter(tags=["Template Editor"])
+
+
+@router.post("/generate", response_model=EditPlanGenerateResponse)
+def generate_editor_draft(
+    template_id: str,
+    request: Optional[EditPlanGenerateRequest] = None,
+    plan_id: str = Depends(get_draft_plan_id),
+    services: tuple[EditTemplateService, EditPlanService] = Depends(get_editor_services),
+    db: Session = Depends(get_db_session),
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    asset_library_repo: Any = Depends(get_asset_library_repository),
+    asset_repo: Any = Depends(get_asset_repository),
+) -> EditPlanGenerateResponse:
+    """触发模板草稿渲染生成"""
+    req = request or EditPlanGenerateRequest()
+    _, plan_svc = services
+    plan_check = plan_svc.get_plan_or_raise(plan_id)
+
+    # 自动兜底流程
+    _auto_fallback_draft_to_editing(plan_svc, plan_id, plan_check)
+    _auto_fallback_copy_template_clips(plan_svc, plan_id, plan_check, db)
+    clips_without_asset = _auto_fallback_assign_assets(plan_svc, plan_id, plan_check)
+    _auto_fallback_auto_material_mode(
+        plan_svc,
+        plan_id,
+        plan_check,
+        clips_without_asset,
+        asset_library_repo,
+        asset_repo,
+        user_id=str(current_user.user.id),
+    )
+
+    # 检查是否可复用已完成的预览产物（预览品质已与正式一致）
+    gen_task_repo = SQLAlchemyGenerationTaskRepository(db)
+    reusable_task = _find_reusable_preview_task(gen_task_repo, plan_id, plan_check)
+    if reusable_task:
+        # 复用预览产物：标记为正式产出，跳过渲染
+        # 如果前端传了 title_config，需要创建新任务（因为预览任务的 custom_title 可能不同）
+        title_config_reuse = req.title_config or {}
+        title_text_reuse = (title_config_reuse.get("text") or "").strip()
+        existing_custom_title = getattr(reusable_task, "custom_title", "") or ""
+        if title_text_reuse and existing_custom_title:
+            # 如果新标题和已有标题不同，不能复用，走新建任务流程
+            new_title_json = json.dumps(title_config_reuse, ensure_ascii=False)
+            if new_title_json != existing_custom_title:
+                logger.info(
+                    "[模板生成] 标题已变更，跳过复用: task_id=%s",
+                    reusable_task.id,
+                )
+                reusable_task = None
+        elif title_text_reuse and not existing_custom_title:
+            # 原来没标题，现在有标题，不能复用
+            logger.info(
+                "[模板生成] 新增标题，跳过复用: task_id=%s",
+                reusable_task.id,
+            )
+            reusable_task = None
+        elif not title_text_reuse and existing_custom_title:
+            # 原来有标题，现在移除了，不能复用
+            logger.info(
+                "[模板生成] 移除标题，跳过复用: task_id=%s",
+                reusable_task.id,
+            )
+            reusable_task = None
+
+    if reusable_task:
+        # 复用预览产物：标记为正式产出，跳过渲染
+        reusable_task.mark_confirmed()
+        gen_task_repo.update(reusable_task)
+
+        # 将产物 URL 写入 plan config
+        rendered_url = _get_task_output_url(reusable_task, gen_task_repo, db)
+        plan_svc.update_plan_config(
+            plan_id,
+            {
+                "generation_task_id": reusable_task.id,
+                "rendered_storage_key": rendered_url,  # 统一用 rendered_storage_key
+            },
+        )
+        plan_svc.transition_status(plan_id, EditPlanStatus.COMPLETED)
+
+        updated_plan = plan_svc.get_plan_or_raise(plan_id)
+        logger.info(
+            "模板编辑器复用预览产物: template_id=%s plan_id=%s task_id=%s by user=%s",
+            template_id,
+            plan_id,
+            reusable_task.id,
+            current_user.user.id,
+        )
+        return EditPlanGenerateResponse(
+            plan_id=plan_id,
+            plan_status=updated_plan.status.value if hasattr(updated_plan.status, "value") else updated_plan.status,
+            generation_task_id=reusable_task.id,
+            clip_count=len((plan_check.config or {}).get("clips", [])),
+        )
+
+    # 检查是否可生成（含最后防线自动修复 + 诊断日志）
+    try:
+        can_gen, reason = plan_svc.can_generate(plan_id)
+    except ValueError as exc:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc
+    if not can_gen:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=reason)
+
+    try:
+        clip_count = plan_svc.mark_clips_ready(plan_id)
+
+        user_id = current_user.user.id
+        _check_queue_limits(gen_task_repo, user_id)
+
+        gen_task_use_case = CreateGenerationTaskUseCase(gen_task_repo)
+        plan = plan_svc.get_plan_or_raise(plan_id)
+        config_asset_ids = (plan.config or {}).get("asset_ids", [])
+        # 从 plan config 读取封面 URL（由 generate-cover 保存）
+        cover_url_from_config = (plan.config or {}).get("cover", {}).get("image_url", "")
+
+        # 处理标题配置：序列化 title_config 为 JSON 存入 custom_title
+        title_config = req.title_config or {}
+        title_text = (title_config.get("text") or "").strip()
+        custom_title_value = ""
+        if title_text:
+            custom_title_value = json.dumps(title_config, ensure_ascii=False)
+            logger.info(
+                "[模板生成] 标题配置: text=%s, config_keys=%s",
+                title_text[:30],
+                list(title_config.keys()),
+            )
+
+        gen_task = gen_task_use_case.execute(
+            CreateGenerationTaskCommand(
+                project_id=plan.project_id or "",
+                template_id=plan.template_id,
+                created_by_user_id=current_user.user.id,
+                source_edit_plan_id=plan_id,
+                asset_ids=list(config_asset_ids) if config_asset_ids else [],
+                cover_url=cover_url_from_config,
+                custom_title=custom_title_value,
+            ),
+        )
+
+        plan_svc.update_plan_config(plan_id, {"generation_task_id": gen_task.id})
+        plan_svc.transition_status(plan_id, EditPlanStatus.RENDERING)
+        celery_app.send_task("worker.render_edit_plan", args=[plan_id])
+
+        updated_plan = plan_svc.get_plan_or_raise(plan_id)
+
+        logger.info(
+            "模板编辑器触发生成: template_id=%s plan_id=%s gen_task_id=%s clips=%d by user=%s",
+            template_id,
+            plan_id,
+            gen_task.id,
+            clip_count,
+            current_user.user.id,
+        )
+
+        return EditPlanGenerateResponse(
+            plan_id=plan_id,
+            plan_status=updated_plan.status.value if hasattr(updated_plan.status, "value") else updated_plan.status,
+            generation_task_id=gen_task.id,
+            clip_count=clip_count,
+        )
+    except HTTPException:
+        raise
+    except Exception as _e:
+        logger.exception(
+            "模板编辑器触发生成失败: template_id=%s plan_id=%s",
+            template_id,
+            plan_id,
+        )
+        try:
+            plan_svc.transition_status(plan_id, EditPlanStatus.FAILED)
+        except Exception:
+            pass
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="生成失败，请稍后重试",
+        ) from _e
+
+
+def _find_reusable_preview_task(gen_task_repo, plan_id: str, plan) -> "object | None":
+    """查找该 plan 关联的已完成预览任务，判断是否可复用。
+
+    复用条件：
+    1. 存在 source_edit_plan_id == plan_id 的已完成预览任务
+    2. plan 在预览完成后未被修改（updated_at <= 预览完成时间）
+
+    Returns:
+        可复用的 GenerationTask，或 None
+    """
+    try:
+        tasks = gen_task_repo.list_by_source_edit_plan(plan_id)
+    except Exception:
+        return None
+
+    for task in tasks:
+        if not getattr(task, "is_preview", False):
+            continue
+        if not task.is_completed:
+            continue
+        # 检查 plan 是否在预览完成后被修改
+        completed_at = getattr(task, "completed_at", None)
+        if completed_at and hasattr(plan, "updated_at"):
+            plan_updated = plan.updated_at
+            # 如果 plan.updated_at 为空，无法判断是否修改过，跳过
+            if plan_updated is None:
+                continue
+            # 如果 plan 在预览完成后又被修改了，不能复用
+            if plan_updated > completed_at:
+                continue
+        return task
+    return None
+
+
+def _get_task_output_url(task, gen_task_repo, db) -> str:
+    """获取任务的输出视频 URL。"""
+    try:
+        video_repo = get_generated_video_repository(db)
+        use_case = ListGeneratedVideosByTaskUseCase(video_repo)
+        videos = use_case.execute(task.id)
+        if videos:
+            url = getattr(videos[0], "file_url", "") or ""
+            # 规范化：合并路径中的双斜杠（保留协议头 ://）
+            if url:
+                import re as _re
+                url = _re.sub(r"(?<!:)//", "/", url)
+            return url
+    except Exception:
+        pass
+    return ""
+
+
+@router.get("/generation-status", response_model=EditPlanGenerationStatusResponse)
+def get_editor_generation_status(
+    template_id: str,
+    plan_id: str = Depends(get_draft_plan_id),
+    services: tuple[EditTemplateService, EditPlanService] = Depends(get_editor_services),
+    storage_service: OSSStorageService = Depends(get_storage_service),
+    _: AuthenticatedUser = Depends(get_current_user),
+) -> EditPlanGenerationStatusResponse:
+    """查询草稿生成进度"""
+    _, plan_svc = services
+    try:
+        gen_status = plan_svc.get_generation_status(plan_id)
+    except ValueError as exc:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc
+
+    plan = gen_status["plan"]
+    clips = gen_status["clips"]
+
+    clip_items = [
+        ClipStatusItem(
+            clip_id=c.id,
+            clip_type=c.clip_type,
+            order=c.order,
+            status=c.status.value if hasattr(c.status, "value") else c.status,
+            asset_id=c.asset_id or "",
+            text_content=c.text_content or "",
+            duration=c.duration,
+        )
+        for c in clips
+    ]
+
+    raw_video_url = (plan.config or {}).get("rendered_storage_key", "") or (plan.config or {}).get("rendered_url", "")
+    video_url = ""
+    if raw_video_url:
+        if raw_video_url.startswith("http"):
+            video_url = raw_video_url  # 已经是完整 URL
+        else:
+            try:
+                video_url = storage_service.get_url(raw_video_url)  # storage_key -> 完整 URL
+            except Exception as e:
+                logger.warning("生成视频URL获取失败: template_id=%s error=%s", template_id, e)
+                video_url = raw_video_url
+
+    progress = gen_status.get("progress", 0.0)
+    error_message = gen_status.get("error_message", "")
+    gen_task_status = gen_status.get("generation_task_status")
+    plan_status_val = plan.status.value if hasattr(plan.status, "value") else plan.status
+    if plan_status_val == "completed" and progress < 100:
+        progress = 100.0
+
+    return EditPlanGenerationStatusResponse(
+        plan_id=plan_id,
+        plan_status=plan_status_val,
+        generation_task_id=gen_status["generation_task_id"],
+        generation_task_status=gen_task_status,
+        progress=progress,
+        video_url=video_url,
+        error_message=error_message,
+        clips=clip_items,
+    )
+
+
+@router.get("/generations", response_model=EditPlanGenerationsResponse)
+def list_editor_generations(
+    template_id: str,
+    plan_id: str = Depends(get_draft_plan_id),
+    services: tuple[EditTemplateService, EditPlanService] = Depends(get_editor_services),
+    db: Session = Depends(get_db_session),
+    _: AuthenticatedUser = Depends(get_current_user),
+) -> EditPlanGenerationsResponse:
+    """查询草稿关联的生成记录列表"""
+    _, plan_svc = services
+    plan_svc.get_plan_or_raise(plan_id)
+
+    gen_task_repo = SQLAlchemyGenerationTaskRepository(db)
+    tasks = gen_task_repo.list_by_source_edit_plan(plan_id)
+    items = [
+        GenerationTaskResponse(
+            id=t.id,
+            project_id=t.project_id,
+            asset_library_id=t.asset_library_id,
+            strategy_id=t.strategy_id,
+            voice_library_id=t.voice_library_id,
+            template_id=t.template_id,
+            asset_ids=t.asset_ids,
+            title_ids=t.title_ids,
+            voice_ids=t.voice_ids,
+            source_edit_plan_id=t.source_edit_plan_id or "",
+            status=t.status.value if hasattr(t.status, "value") else t.status,
+            progress=t.progress,
+            result_count=t.result_count,
+            error_message=t.error_message,
+        )
+        for t in tasks
+    ]
+    return EditPlanGenerationsResponse(items=items, total=len(items))

apps/api/app/api/routes/templates_editor/schemas.py

@@ -6,8 +6,9 @@
 from __future__ import annotations
 
 import re as _re
-from typing import Any, List, Optional
+from typing import Any, Dict, List, Optional
 
+from app.schemas.generation_task import GenerationTaskResponse
 from pydantic import BaseModel, Field, validator
 
 _EXPORT_RESOLUTION_PATTERN = _re.compile(r"^\d+x\d+$")
@@ -15,6 +16,58 @@ _EXPORT_VALID_QUALITY_PRESETS = {"ultra_fast", "fast", "balanced", "high", "best
 _EXPORT_VALID_FORMATS = {"mp4", "mov"}
 
 
+# ── 生成状态相关 ────────────────────────────────────────────────────────────
+
+
+class ClipStatusItem(BaseModel):
+    """片段生成状态"""
+
+    clip_id: str
+    clip_type: str
+    order: int
+    status: str
+    asset_id: str
+    text_content: str
+    duration: float
+
+
+class EditPlanGenerationStatusResponse(BaseModel):
+    """剪辑计划生成进度响应体"""
+
+    plan_id: str
+    plan_status: str
+    generation_task_id: Optional[str] = None
+    generation_task_status: Optional[str] = None
+    progress: float = 0.0
+    video_url: str = ""
+    error_message: str = ""
+    clips: List[ClipStatusItem]
+
+
+class EditPlanGenerateRequest(BaseModel):
+    """模板编辑器触发生成请求体"""
+    title_config: Optional[Dict[str, Any]] = Field(
+        default_factory=dict,
+        description="标题配置（可选），渲染时烧录到视频中。支持字段: text/font/font_size/font_color/position/bold/stroke/shadow",
+    )
+
+
+class EditPlanGenerateResponse(BaseModel):
+    """剪辑计划触发生成响应体"""
+
+    plan_id: str
+    plan_status: str
+    generation_task_id: str
+    clip_count: int
+
+
+class EditPlanGenerationsResponse(BaseModel):
+    """剪辑计划关联的生成记录列表响应体"""
+
+    items: List[GenerationTaskResponse]
+    total: int
+
+
 # ── AI 推荐 ────────────────────────────────────────────────────────────────
 
 
@@ -22,8 +75,12 @@ class AIRecommendRequest(BaseModel):
     """AI 推荐片段方案请求体"""
 
     asset_ids: List[str] = Field(default_factory=list, description="素材 ID 列表")
-    editing_mode: str = Field(default="one_take", description="剪辑模式: one_take / pip / voice_over / voice_pip")
-    target_duration: float = Field(default=30.0, ge=1.0, le=600.0, description="目标时长（秒）")
+    editing_mode: str = Field(
+        default="one_take", description="剪辑模式: one_take / pip / voice_over / voice_pip"
+    )
+    target_duration: float = Field(
+        default=30.0, ge=1.0, le=600.0, description="目标时长（秒）"
+    )
 
 
 class AIRecommendClipItem(BaseModel):
@@ -50,6 +107,8 @@ class AIRecommendResponse(BaseModel):
     confidence: float = Field(..., ge=0.0, le=1.0, description="AI 推荐置信度 (0~1)")
 
 
+
+
 # ── BGM ────────────────────────────────────────────────────────────────────
 
 
@@ -165,7 +224,9 @@ class ClipBatchDeleteResponse(BaseModel):
 class ClipsFromAssetsRequest(BaseModel):
     """从素材批量创建片段请求"""
 
-    asset_ids: List[str] = Field(..., min_length=1, max_length=200, description="素材 ID 列表，按顺序追加到时间线末尾")
+    asset_ids: List[str] = Field(
+        ..., min_length=1, max_length=200, description="素材 ID 列表，按顺序追加到时间线末尾"
+    )
     clip_type: str = Field(default="main", description="片段类型，默认 main")
 
 
@@ -440,28 +501,6 @@ class EditorClipUpdateRequest(BaseModel):
     config: Optional[dict[str, Any]] = None
 
 
-class EditorClipBatchItem(BaseModel):
-    """批量更新clips的单个片段"""
-
-    asset_id: str = Field(default="", max_length=100, description="关联素材ID，可为空（占位片段）")
-    start_time: float = Field(default=0.0, ge=0.0)
-    duration: float = Field(default=0.0, ge=0.0)
-    order: Optional[int] = Field(default=None, ge=0, description="排序，None表示按数组顺序")
-
-
-class EditorClipBatchUpdateRequest(BaseModel):
-    """批量替换clips请求（全量覆盖）"""
-
-    clips: List[EditorClipBatchItem] = Field(default_factory=list)
-
-
-class EditorClipBatchUpdateResponse(BaseModel):
-    """批量更新clips响应"""
-
-    plan_id: str
-    clip_count: int
-
-
 class EditorPublishResponse(BaseModel):
     """发布草稿响应"""
 

apps/api/app/api/routes/upload.py

@@ -206,7 +206,6 @@ async def complete_direct_upload(
                 ingest_job_id="",
                 duplicated=True,
                 asset_id=existing.id,
-                url=storage_service.get_url(normalized_key),
             )
 
     job = _submit_ingest_job(
@@ -216,7 +215,7 @@ async def complete_direct_upload(
         ingest_job_repository=ingest_job_repository,
         file_hash=request.file_hash,
     )
-    return DirectUploadCompleteResponse(storage_key=normalized_key, ingest_job_id=job.id, url=storage_service.get_url(normalized_key))
+    return DirectUploadCompleteResponse(storage_key=normalized_key, ingest_job_id=job.id)
 
 
 @router.post(

apps/api/app/schemas/generation_task.py

@@ -10,7 +10,7 @@ class ConfirmGenerationRequest(BaseModel):
     output_width: int = Field(default=1080, ge=100, description="输出视频宽度")
     output_height: int = Field(default=1920, ge=100, description="输出视频高度")
     cover_url: str = Field(default="", description="自定义封面图片 URL")
-    custom_title: str = Field(default="", description="用户自定义标题文本，非空时同步到任务和编辑计划")
+    custom_title: str = Field(default="", description="自定义视频标题")
 
 
 class CreateGenerationTaskRequest(BaseModel):
@@ -33,11 +33,6 @@ class CreateGenerationTaskRequest(BaseModel):
     voice_ids: list[str] = Field(default_factory=list)
     # ── 来源剪辑计划 ──
     source_edit_plan_id: str = ""
-    # ── 标题配置（结构化）──
-    title_config: dict | None = Field(
-        default=None,
-        description="标题样式对象，包含 text/font/font_size/font_color/position/bold/stroke/shadow 等。为空时不影响现有行为。",
-    )
     # ── 视频标题 ──
     video_title: str = Field(default="", description="生成视频的标题/名称，为空则使用默认命名")
     # ── 批量生成 ──
@@ -77,6 +72,7 @@ class CreateGenerationTaskRequest(BaseModel):
     output_width: int = Field(default=1280, description="输出视频宽度")
     output_height: int = Field(default=720, description="输出视频高度")
     cover_url: str = Field(default="", description="封面图片 URL")
+    custom_title: str = Field(default="", description="自定义视频标题")
 
     @model_validator(mode="after")
     def _check_at_least_one_mode(self) -> "CreateGenerationTaskRequest":
@@ -112,7 +108,7 @@ class GenerationTaskResponse(BaseModel):
     output_width: int = 1280
     output_height: int = 720
     cover_url: str = ""
-    title_config: dict = Field(default_factory=dict)
+    custom_title: str = ""
     status: str
     progress: float
     result_count: int

apps/api/app/schemas/upload.py

@@ -39,7 +39,6 @@ class DirectUploadCompleteResponse(BaseModel):
     ingest_job_id: str
     duplicated: bool = Field(default=False, description="是否为重复素材（命中去重）")
     asset_id: str = Field(default="", description="重复素材的 asset_id（duplicated=true 时返回）")
-    url: str = Field(default="", description="Public URL of uploaded file")
 
 
 class UploadAssetResponse(BaseModel):

apps/api/app/services/edit_plan_service.py

@@ -371,88 +371,6 @@ class EditPlanService:
         logger.info("删除所有片段: plan_id=%s count=%d", plan_id, count)
         return count
 
-    def replace_all_clips_transactional(
-        self,
-        plan_id: str,
-        clips_data: list[dict],
-    ) -> int:
-        """事务性地替换所有片段：清空→创建→标记ready，单事务保证原子性。
-
-        Args:
-            plan_id: 计划 ID
-            clips_data: 片段数据列表，每项包含 asset_id/start_time/duration/order
-
-        Returns:
-            int: 创建的片段数量
-
-        Raises:
-            Exception: 任何步骤失败时自动回滚
-        """
-        from packages.adapters.sqlalchemy_impl.models import EditPlanClipModel
-
-        db = self._clip_repo.session
-        try:
-            # 1. 清空现有 clips（不 commit）
-            deleted_count = db.query(EditPlanClipModel).filter(EditPlanClipModel.plan_id == plan_id).delete()
-
-            # 2. 批量创建新 clips（不 commit）
-            for i, clip_item in enumerate(clips_data):
-                order = clip_item.get("order") or i
-                clip = EditPlanClip.create(
-                    plan_id=plan_id,
-                    clip_type="main",
-                    order=order,
-                    asset_id=clip_item.get("asset_id", ""),
-                    start_time=clip_item.get("start_time", 0.0),
-                    duration=clip_item.get("duration", 0.0),
-                )
-                model = EditPlanClipModel(
-                    id=clip.id,
-                    plan_id=clip.plan_id,
-                    clip_type=clip.clip_type,
-                    order=clip.order,
-                    asset_id=clip.asset_id,
-                    text_content=clip.text_content,
-                    start_time=clip.start_time,
-                    duration=clip.duration,
-                    transition_effect=clip.transition_effect,
-                    transition_duration=clip.transition_duration,
-                    playback_speed=clip.playback_speed,
-                    status=clip.status.value,
-                    config=clip.config,
-                )
-                db.add(model)
-
-            # flush 让新建 clip 写入当前事务（未 commit），后续查询才能找到它们
-            db.flush()
-
-            # 3. 标记有 asset_id 的 clips 为 ready（不 commit）
-            pending_with_asset = (
-                db.query(EditPlanClipModel)
-                .filter(
-                    EditPlanClipModel.plan_id == plan_id,
-                    EditPlanClipModel.status == "pending",
-                    EditPlanClipModel.asset_id != "",
-                )
-                .all()
-            )
-            for m in pending_with_asset:
-                m.status = "ready"
-
-            # 4. 一次性提交
-            db.commit()
-            logger.info(
-                "事务性替换片段: plan_id=%s deleted=%d created=%d",
-                plan_id,
-                deleted_count,
-                len(clips_data),
-            )
-            return len(clips_data)
-        except Exception:
-            db.rollback()
-            logger.exception("事务性替换片段失败: plan_id=%s", plan_id)
-            raise
-
     # ── 片段分割与合并 ──────────────────────────────────────────────────────
 
     def split_clip(self, clip_id: str, split_time: float) -> Dict[str, Any]:

apps/web/e2e/core-generation.spec.ts

@@ -226,12 +226,16 @@ test.describe("Core generation flow", () => {
     await expect(page.getByRole("heading", { name: /确认生成/ })).toBeVisible()
 
     // Wait for generation API to be called
-    // 前端直接创建生成任务：POST /generation/tasks
+    // 确认生成走新流程：POST /tasks/{taskId}/confirm（复用预览产物）
+    // 或旧流程：POST /editor/generate（向后兼容）
     const generatePromise = page.waitForResponse(
       (response) => {
         const url = response.url()
         const path = new URL(url).pathname
-        return response.request().method() === "POST" && path.endsWith("/generation/tasks")
+        return (
+          response.request().method() === "POST" &&
+          (path.endsWith("/confirm") || path.endsWith("/editor/generate"))
+        )
       },
       { timeout: 30_000 },
     )

apps/web/e2e/test_asset.spec.ts

@@ -178,7 +178,7 @@ test.describe("素材库流程", () => {
     expect(kinds).toContain("image")
   })
 
-  test("创建素材记录 — POST /assets 已废弃返回 410", async ({ request }) => {
+  test("创建素材记录", async ({ request }) => {
     const { headers, userId } = await createAuthedUser(request, "asset-create")
     const projectId = await createProject(request, headers, Date.now().toString())
 
@@ -194,7 +194,7 @@ test.describe("素材库流程", () => {
     expect(lib.ok()).toBeTruthy()
     const libData = await lib.json()
 
-    // POST /assets 已废弃，应返回 410 Gone
+    // 创建素材记录
     const response = await request.post(`${apiBase}/assets`, {
       headers,
       data: {
@@ -210,9 +210,16 @@ test.describe("素材库流程", () => {
       },
     })
 
-    expect(response.status()).toBe(410)
+    expect(
+      response.ok(),
+      `创建素材应返回 2xx，实际: ${response.status()} ${await response.text()}`,
+    ).toBeTruthy()
+
     const data = await response.json()
-    expect(data.error?.code).toBe("HTTP_410")
+    expect(data.id, "应返回素材 ID").toBeTruthy()
+    expect(data.name).toContain("test_video")
+    expect(data.mime_type).toBe("video/mp4")
+    expect(data.library_id).toBe(libData.id)
   })
 
   test("列出素材", async ({ request }) => {
@@ -225,50 +232,51 @@ test.describe("素材库流程", () => {
       data: {
         project_id: projectId,
         name: `List Lib ${Date.now()}`,
-        kind: "image",
+        kind: "video",
       },
     })
     expect(lib.ok(), `创建素材库应成功: ${await lib.text()}`).toBeTruthy()
     const libData = await lib.json()
 
-    // 通过 multipart upload 上传 2 个小图片作为测试素材
-    // 创建一个 1x1 的 PNG buffer
-    const tinyPng = Buffer.from(
-      "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
-      "base64",
-    )
-
-    await request.post(`${apiBase}/upload`, {
+    // 创建 2 个素材
+    await request.post(`${apiBase}/assets`, {
       headers,
-      multipart: {
+      data: {
         project_id: projectId,
         library_id: libData.id,
-        file: { name: "clip_a.png", mimeType: "image/png", buffer: tinyPng },
+        name: `clip_a_${Date.now()}.mp4`,
+        storage_key: `uploads/e2e/clip_a.mp4`,
+        mime_type: "video/mp4",
+        status: "ready",
+        uploaded_by_user_id: userId,
       },
     })
-    await request.post(`${apiBase}/upload`, {
+    await request.post(`${apiBase}/assets`, {
       headers,
-      multipart: {
+      data: {
         project_id: projectId,
         library_id: libData.id,
-        file: { name: "clip_b.png", mimeType: "image/png", buffer: tinyPng },
+        name: `clip_b_${Date.now()}.mp4`,
+        storage_key: `uploads/e2e/clip_b.mp4`,
+        mime_type: "video/mp4",
+        status: "ready",
+        uploaded_by_user_id: userId,
       },
     })
 
-    // 列出素材（可能需要等待 ingest job 完成）
-    let items: any[] = []
-    for (let i = 0; i < 10; i++) {
-      const response = await request.get(`${apiBase}/assets`, {
-        headers,
-        params: { library_id: libData.id },
-      })
-      expect(response.ok(), `列出素材应返回 2xx`).toBeTruthy()
-      const data = await response.json()
-      items = data.items || []
-      if (items.length >= 2) break
-      await new Promise((r) => setTimeout(r, 2000))
-    }
+    // 列出素材
+    const response = await request.get(`${apiBase}/assets`, {
+      headers,
+      params: { library_id: libData.id },
+    })
 
+    expect(
+      response.ok(),
+      `列出素材应返回 2xx，实际: ${response.status()} ${await response.text()}`,
+    ).toBeTruthy()
+
+    const data = await response.json()
+    const items = data.items || []
     expect(items.length, "应至少有 2 个素材").toBeGreaterThanOrEqual(2)
   })
 

apps/web/src/api/assets/assets.ts

@@ -60,6 +60,18 @@ export const smartMatchAssets = async (libraryId: string): Promise<{ items: Asse
   return response.data
 }
 
+/** 创建素材（上传文件后调用，附带 metadata） */
+export const createAsset = async (data: {
+  library_id: string
+  name: string
+  storage_key: string
+  mime_type: string
+  metadata?: AssetMetadata
+}): Promise<AssetItem> => {
+  const response = await apiClient.post("/assets", data)
+  return response.data
+}
+
 /** 更新素材（名称、metadata 等） */
 export const updateAsset = async (
   assetId: string,

apps/web/src/api/assets/index.ts

@@ -13,6 +13,7 @@ export type {
   ClassificationJob,
   AssetDiagnosis,
   BatchOperationResult,
+  UploadResult,
   DirectUploadPrepareResult,
   DirectUploadCompleteResult,
 } from "./types"
@@ -33,13 +34,14 @@ export {
   getAssets,
   getAssetsByKind,
   smartMatchAssets,
+  createAsset,
   updateAsset,
   updateAssetReviewStatus,
   deleteAsset,
 } from "./assets"
 
 // 上传
-export { prepareDirectUpload, completeDirectUpload, uploadAssetDirect } from "./upload"
+export { uploadAsset, prepareDirectUpload, completeDirectUpload, uploadAssetDirect } from "./upload"
 
 // 任务
 export { getIngestJob, submitClassificationJob, getClassificationJob } from "./jobs"

apps/web/src/api/assets/types.ts

@@ -135,5 +135,4 @@ export interface DirectUploadPrepareResult {
 export interface DirectUploadCompleteResult {
   storage_key: string
   ingest_job_id: string
-  url: string
 }

apps/web/src/api/assets/upload.ts

@@ -3,7 +3,16 @@
  */
 import apiClient from "../client"
 import { getOrCreateDefaultProject } from "../projects"
-import type { DirectUploadPrepareResult, DirectUploadCompleteResult } from "./types"
+import type { UploadResult, DirectUploadPrepareResult, DirectUploadCompleteResult } from "./types"
+
+/** 表单上传素材（小文件） */
+export const uploadAsset = async (formData: FormData): Promise<UploadResult> => {
+  const response = await apiClient.post("/upload", formData, {
+    headers: { "Content-Type": "multipart/form-data" },
+    timeout: 30 * 60 * 1000,
+  })
+  return response.data
+}
 
 /** 预签名直传准备 */
 export const prepareDirectUpload = async (data: {

apps/web/src/api/bgm/bgm.ts

@@ -4,20 +4,11 @@
 import apiClient from "../client"
 import type { BgmPreset, BgmPresetsQuery } from "./types"
 
-/**
- * 获取 BGM 预设列表
- * @param templateId 模板/草稿 ID
- * @param params 分类/关键词筛选
- */
-export const getBgmPresets = async (
-  templateId: string,
-  params?: BgmPresetsQuery,
-): Promise<BgmPreset[]> => {
+/** 获取 BGM 预设列表 */
+export const getBgmPresets = async (params?: BgmPresetsQuery): Promise<BgmPreset[]> => {
   const searchParams: Record<string, string> = {}
   if (params?.category) searchParams.category = params.category
   if (params?.keyword) searchParams.keyword = params.keyword
-  const res = await apiClient.get(`/templates/${templateId}/editor/bgm/presets`, {
-    params: searchParams,
-  })
+  const res = await apiClient.get("/bgm/presets", { params: searchParams })
   return res.data?.data ?? res.data ?? []
 }

apps/web/src/api/generation/cover.ts

@@ -1,22 +1,9 @@
 import apiClient from "../client"
 
-export interface GenerateCoverTitleConfig {
-  text?: string
-  font?: string
-  font_size?: number
-  font_color?: string
-  position?: string
-  bold?: boolean
-  stroke?: boolean
-  shadow?: boolean
-}
-
 export interface GenerateCoverRequest {
   asset_ids: string[]
   cover_type?: "ai_frame" | "manual" | "upload" | "ai_regenerate"
   frame_time?: number
-  /** 标题样式，用于在封面上叠加标题文字 */
-  title_config?: GenerateCoverTitleConfig
 }
 
 export interface GenerateCoverResponse {

apps/web/src/api/generation/index.ts

@@ -3,9 +3,13 @@ export type {
   CreatePreviewRequest,
   CreatePreviewResponse,
   PreviewTaskResponse,
+  ConfirmGenerationRequest,
+  ConfirmGenerationResponse,
+  ConfirmGenerationTaskItem,
 } from "./types"
 
 export { createPreview, getPreviewStatus } from "./preview"
+export { confirmGeneration } from "./confirm"
 
 export { generateCover } from "./cover"
 export type { GenerateCoverRequest, GenerateCoverResponse } from "./cover"

apps/web/src/api/generation/types.ts

@@ -38,8 +38,6 @@ export interface CreatePreviewResponse {
   is_preview: boolean
   resolution: string
   created_at: string
-  /** 后端自动关联的编辑计划 ID（用于 fallback 路径传递 source_edit_plan_id） */
-  source_edit_plan_id?: string
 }
 
 /** 预览任务详情响应 */

apps/web/src/api/tasks/tasks.ts

@@ -6,7 +6,6 @@ import apiClient from "../client"
 import type {
   CreateGenerationTaskRequest,
   CreateGenerationTaskResponse,
-  GenerationTaskDetail,
   TaskItem,
   TaskListParams,
   TaskListResponse,
@@ -20,12 +19,6 @@ export const createGenerationTask = async (
   return data
 }
 
-/** 获取单个生成任务详情（轮询用） */
-export const getGenerationTask = async (taskId: string): Promise<GenerationTaskDetail> => {
-  const { data } = await apiClient.get<GenerationTaskDetail>(`/generation/tasks/${taskId}`)
-  return data
-}
-
 /** 获取任务列表（支持分页和筛选） */
 export const getTasks = async (params?: TaskListParams): Promise<TaskListResponse> => {
   const { data } = await apiClient.get<TaskListResponse>("/tasks", {

apps/web/src/api/tasks/types.ts

@@ -57,45 +57,12 @@ export interface TaskListResponse {
 export interface CreateGenerationTaskRequest {
   template_id: string
   asset_ids: string[]
-  title_ids?: string[]
-  voice_ids?: string[]
-  /** 输出视频宽度 */
-  output_width?: number
-  /** 输出视频高度 */
-  output_height?: number
-  /** 自定义封面图片 URL */
-  cover_url?: string
-  /** 自定义视频标题 */
-  custom_title?: string
-  /** 视频时长（秒） */
-  duration?: number
-  /** 视频宽高比，如 "9:16" */
-  video_ratio?: string
-  /** 标题烧录配置 */
-  title_config?: {
-    text?: string
-    font?: string
-    font_size?: number
-    font_color?: string
-    position?: string
-    bold?: boolean
-    stroke?: boolean
-    shadow?: boolean
-  }
-  /** 关联的草稿 ID（编辑流程数据链路用） */
-  source_edit_plan_id?: string
-  /** 配音素材库 ID（用户上传的音频或 AI 配音素材） */
-  voice_library_id?: string
-  /** 自定义 BGM 配置，覆盖模板 BGM 设置 */
-  bgm_config?: {
-    enabled: boolean
-    preset_id?: string
-    volume?: number
-  }
+  title_ids: string[]
+  voice_ids: string[]
 }
 
-/** 单个生成任务详情（对齐后端 GenerationTaskResponse） */
-export interface GenerationTaskDetail {
+/** 创建生成任务响应（对齐后端 GenerationTaskResponse） */
+export interface CreateGenerationTaskResponse {
   id: string
   project_id: string
   asset_library_id: string
@@ -105,18 +72,8 @@ export interface GenerationTaskDetail {
   asset_ids: string[]
   title_ids: string[]
   voice_ids: string[]
-  source_edit_plan_id?: string
   status: string
   progress: number
   result_count: number
   error_message: string
-  error_info?: TaskErrorInfo
-  created_at?: string | null
-  updated_at?: string | null
-}
-
-/** 创建生成任务响应（后端返回批量结构 {items, total}） */
-export interface CreateGenerationTaskResponse {
-  items: GenerationTaskDetail[]
-  total: number
 }

apps/web/src/api/template-editor/editPlans.ts

@@ -1,8 +1,27 @@
 /**
- * 模板草稿 CRUD API
+ * 模板草稿 CRUD + 生成相关 API
  */
 import apiClient from "../client"
-import type { EditPlan, UpdateEditPlanRequest, GeneratedVideo } from "./types"
+import type {
+  EditPlan,
+  EditPlanListParams,
+  EditPlanListResponse,
+  CreateEditPlanRequest,
+  UpdateEditPlanRequest,
+  GenerateResponse,
+  GenerationStatusResponse,
+  EditPlanGeneration,
+  GeneratedVideo,
+  CopyEditPlanRequest,
+} from "./types"
+
+/** 获取模板草稿列表（支持分页和筛选） */
+export async function getEditPlans(params?: EditPlanListParams): Promise<EditPlanListResponse> {
+  const response = await apiClient.get<EditPlanListResponse>("/templates/drafts", {
+    params,
+  })
+  return response.data
+}
 
 /** 获取单个模板草稿 */
 export async function getEditPlan(templateId: string): Promise<EditPlan> {
@@ -10,44 +29,63 @@ export async function getEditPlan(templateId: string): Promise<EditPlan> {
   return response.data
 }
 
-/** 更新模板草稿（支持传入 AbortSignal 用于自动保存竞态取消） */
+/** 创建模板草稿 */
+export async function createEditPlan(data: CreateEditPlanRequest): Promise<EditPlan> {
+  const response = await apiClient.post("/templates/drafts", data)
+  return response.data
+}
+
+/** 更新模板草稿 */
 export async function updateEditPlan(
   templateId: string,
   data: UpdateEditPlanRequest,
-  signal?: AbortSignal,
 ): Promise<EditPlan> {
-  const response = await apiClient.put(`/templates/${templateId}/editor`, data, { signal })
+  const response = await apiClient.put(`/templates/${templateId}/editor`, data)
   return response.data
 }
 
+/** 删除模板草稿 */
+export async function deleteEditPlan(templateId: string): Promise<void> {
+  await apiClient.delete(`/templates/${templateId}/editor`)
+}
+
+/** 触发生成 */
+export async function generateEditPlan(templateId: string): Promise<GenerateResponse> {
+  const response = await apiClient.post(`/templates/${templateId}/editor/generate`)
+  return response.data
+}
+
+/** 获取生成状态（轮询用） */
+export async function getGenerationStatus(templateId: string): Promise<GenerationStatusResponse> {
+  const response = await apiClient.get(`/templates/${templateId}/editor/generation-status`)
+  return response.data
+}
+
+/** 获取模板草稿关联的生成记录 */
+export async function getEditPlanGenerations(templateId: string): Promise<EditPlanGeneration[]> {
+  const response = await apiClient.get(`/templates/${templateId}/editor/generations`)
+  return response.data.items || []
+}
+
 /** 获取生成任务的视频结果列表 */
 export async function getGenerationTaskResults(taskId: string): Promise<GeneratedVideo[]> {
   const response = await apiClient.get(`/generation/tasks/${taskId}/results`)
   return response.data.items || response.data || []
 }
 
-/** ── 草稿 clips 批量更新 ── */
-
-export interface EditPlanClipInput {
-  asset_id: string
-  start_time: number
-  duration: number
-  order: number
+/** 取消生成任务 */
+export async function cancelGeneration(templateId: string): Promise<void> {
+  await apiClient.post(`/templates/${templateId}/editor/cancel`)
 }
 
-/**
- * 批量替换草稿的 clips（先全删再批量插入）
- * 后端路由：PUT /templates/{template_id}/editor/clips
- */
-export async function updateEditPlanClips(
+/** 复制模板草稿（含所有片段配置） */
+export async function copyEditPlan(
   templateId: string,
-  clips: EditPlanClipInput[],
-  signal?: AbortSignal,
-): Promise<{ count: number }> {
-  const response = await apiClient.put(
-    `/templates/${templateId}/editor/clips`,
-    { clips },
-    { signal },
+  data?: CopyEditPlanRequest,
+): Promise<EditPlan> {
+  const response = await apiClient.post<EditPlan>(
+    `/templates/${templateId}/editor/copy`,
+    data || {},
   )
   return response.data
 }

apps/web/src/api/template-editor/index.ts

@@ -15,8 +15,14 @@ export type {
   EditPlanSegment,
   EditPlanConfig,
   EditPlan,
+  CreateEditPlanRequest,
   UpdateEditPlanRequest,
+  EditPlanListParams,
+  EditPlanListResponse,
+  GenerateResponse,
+  EditPlanGeneration,
   ClipStatusItem,
+  GenerationStatusResponse,
   GeneratedVideo,
   AIRecommendRequest,
   AIRecommendClipItem,
@@ -31,6 +37,7 @@ export type {
   ClipReorderResponse,
   ClipBatchDeleteResponse,
   ClipsFromAssetsResponse,
+  CopyEditPlanRequest,
   TransitionEffect,
   MediaAsset,
 } from "./types"
@@ -46,12 +53,18 @@ export {
 
 // 模板草稿 CRUD + 生成
 export {
+  getEditPlans,
   getEditPlan,
+  createEditPlan,
   updateEditPlan,
-  updateEditPlanClips,
+  deleteEditPlan,
+  generateEditPlan,
+  getGenerationStatus,
+  getEditPlanGenerations,
   getGenerationTaskResults,
+  cancelGeneration,
+  copyEditPlan,
 } from "./editPlans"
-export type { EditPlanClipInput } from "./editPlans"
 
 // 片段 CRUD + 批量操作
 export {

apps/web/src/api/template-editor/types.ts

@@ -118,17 +118,6 @@ export interface EditPlanConfig {
   generate_count?: number
   /** 素材模式 */
   material_mode?: string
-  /** 前端标题设置（Step4 自动保存，与 title_config 字段分离，不影响后端渲染） */
-  title?: {
-    text?: string
-    font?: string
-    font_size?: number
-    color?: string
-    position?: string
-    bold?: boolean
-    stroke?: boolean
-    shadow?: boolean
-  }
   /** 预览视频 URL（封面生成用） */
   rendered_storage_key?: string
   /** 生成任务 ID */
@@ -187,6 +176,31 @@ export interface EditPlanListResponse {
 
 /* ── 生成相关 ── */
 
+/** 生成响应 */
+export interface GenerateResponse {
+  plan_id: string
+  plan_status: EditPlanStatus
+  generation_task_id: string
+  clip_count: number
+}
+
+/** 模板草稿关联的生成记录 */
+export interface EditPlanGeneration {
+  id: string
+  source_edit_plan_id: string
+  template_id: string
+  asset_ids: string[]
+  status: EditPlanStatus
+  progress: number
+  result_count: number
+  error_message: string
+  error_info: Record<string, unknown>
+  logs: Array<Record<string, unknown>>
+  retry_count: number
+  created_at?: string
+  updated_at?: string
+}
+
 /** 片段生成状态 */
 export interface ClipStatusItem {
   clip_id: string
@@ -199,6 +213,17 @@ export interface ClipStatusItem {
   error_message?: string
 }
 
+/** 生成状态轮询响应 */
+export interface GenerationStatusResponse {
+  plan_id: string
+  plan_status: EditPlanStatus
+  generation_task_id?: string
+  error_message?: string
+  clips: ClipStatusItem[]
+  error?: string
+  message?: string
+}
+
 /** 生成视频详情 */
 export interface GeneratedVideo {
   id: string

apps/web/src/api/templates/index.ts

@@ -9,6 +9,8 @@ export type {
   TemplateSegment,
   TemplateListParams,
   TemplateListResponse,
+  GenerateFromTemplateRequest,
+  GenerateFromTemplateResponse,
   CopyTemplateResponse,
 } from "./types"
 
@@ -22,4 +24,5 @@ export {
   getTemplate,
   toggleFavoriteTemplate,
   copyTemplate,
+  generateFromTemplate,
 } from "./templates"

apps/web/src/api/templates/templates.ts

@@ -5,6 +5,8 @@
 import apiClient from "../client"
 import type {
   CopyTemplateResponse,
+  GenerateFromTemplateRequest,
+  GenerateFromTemplateResponse,
   TemplateItem,
   TemplateListParams,
   TemplateListResponse,
@@ -43,3 +45,15 @@ export const copyTemplate = async (templateId: string): Promise<CopyTemplateResp
   const response = await apiClient.post<CopyTemplateResponse>(`/templates/${templateId}/copy`)
   return response.data
 }
+
+/** 从模板生成 */
+export const generateFromTemplate = async (
+  templateId: string,
+  data?: GenerateFromTemplateRequest,
+): Promise<GenerateFromTemplateResponse> => {
+  const response = await apiClient.post<GenerateFromTemplateResponse>(
+    `/templates/${templateId}/generate`,
+    data,
+  )
+  return response.data
+}

apps/web/src/components/voice/CloneModal/index.tsx

@@ -1,8 +1,7 @@
 import React, { useState, useCallback, useRef, useEffect } from "react"
 import { Modal, Button } from "@/components/ui"
 import { createVoiceClone, toVoiceClone } from "@/api/voice-clone"
-import { uploadAssetDirect, ensureDefaultLibrary } from "@/api/assets"
-import { getOrCreateDefaultProject } from "@/api/projects"
+import { uploadAsset } from "@/api/assets"
 import { PROGRESS_STEPS, ACCEPTED_MIME } from "./constants"
 import { validateFile } from "./utils"
 import { useAudioRecorder } from "./hooks/useAudioRecorder"
@@ -182,15 +181,9 @@ const CloneModal: React.FC<CloneModalProps> = ({ open, onClose, onSuccess }) =>
         })
       }
 
-      // 获取默认项目和素材库
-      const project = await getOrCreateDefaultProject()
-      const library = await ensureDefaultLibrary({ project_id: project.id, kind: "voice" })
-
-      // 直传到 OSS
-      const uploadResult = await uploadAssetDirect({
-        file: fileToUpload,
-        library_id: library.id,
-      })
+      const formData = new FormData()
+      formData.append("file", fileToUpload)
+      const uploadResult = await uploadAsset(formData)
 
       // 组件已卸载则中止后续操作
       if (!isMountedRef.current) return

apps/web/src/components/voice/hooks/useCloneSubmit.ts

@@ -1,6 +1,6 @@
 import { useRef, useCallback, useEffect } from "react"
 import { createVoiceClone, toVoiceClone } from "@/api/voice-clone"
-import { uploadAssetDirect, ensureDefaultLibrary } from "@/api/assets"
+import { uploadAsset, ensureDefaultLibrary } from "@/api/assets"
 import { getOrCreateDefaultProject } from "@/api/projects"
 import type { VoiceClone } from "@/api/voice-clone"
 
@@ -62,15 +62,15 @@ export function useCloneSubmit({
         })
       }
 
-      // 获取默认项目和素材库
+      // 获取默认项目和素材库（后端 /upload 接口必填）
       const project = await getOrCreateDefaultProject()
       const library = await ensureDefaultLibrary({ project_id: project.id, kind: "voice" })
 
-      // 直传到 OSS
-      const uploadResult = await uploadAssetDirect({
-        file: fileToUpload,
-        library_id: library.id,
-      })
+      const formData = new FormData()
+      formData.append("file", fileToUpload)
+      formData.append("project_id", project.id)
+      formData.append("library_id", library.id)
+      const uploadResult = await uploadAsset(formData)
 
       // 阶段 2：克隆
       setPhase("cloning")

apps/web/src/config/navigation.ts

@@ -71,7 +71,7 @@ export const NAV_ITEMS: NavItem[] = [
   },
   {
     key: "editing-planner",
-    label: "剪辑模板",
+    label: "剪辑编辑器",
     path: "/app/editing-planner",
     icon: React.createElement(EditOutlined),
   },
@@ -133,7 +133,7 @@ export const NAV_GROUPS: NavGroup[] = [
       },
       {
         key: "editing-planner",
-        label: "剪辑模板",
+        label: "剪辑编辑器",
         path: "/app/editing-planner",
         icon: React.createElement(EditOutlined),
       },

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

@@ -0,0 +1,116 @@
+/**
+ * 生成历史弹窗 — 展示当前模板草稿的生成任务记录
+ * 从 EditingPlanner 拆分，避免主文件过大
+ */
+import React from "react"
+import { CloseOutlined, InboxOutlined } from "@ant-design/icons"
+import type { EditPlanGeneration } from "@/api/template-editor"
+import { PLAN_STATUS_LABELS } from "@/api/template-editor"
+
+interface GenerationHistoryModalProps {
+  open: boolean
+  loading: boolean
+  history: EditPlanGeneration[]
+  onClose: () => void
+  onCancel?: (taskId: string) => void
+  cancelLoading?: boolean
+}
+
+const GenerationHistoryModal: React.FC<GenerationHistoryModalProps> = ({
+  open,
+  loading,
+  history,
+  onClose,
+  onCancel,
+  cancelLoading,
+}) => {
+  if (!open) return null
+
+  return (
+    <div className="ep-modal-overlay" onClick={onClose}>
+      <div className="ep-modal ep-gh-modal" onClick={(e) => e.stopPropagation()}>
+        <div className="ep-modal-header">
+          <h3>生成历史</h3>
+          <button className="ep-modal-close" onClick={onClose}>
+            <CloseOutlined />
+          </button>
+        </div>
+        <div className="ep-modal-body ep-gh-body">
+          {loading ? (
+            <div className="ep-gh-empty">
+              <div className="ep-skeleton">
+                <div className="ep-skeleton-item ep-skeleton-item--header" />
+                <div className="ep-skeleton-item" />
+                <div className="ep-skeleton-item" />
+                <div className="ep-skeleton-item" />
+              </div>
+            </div>
+          ) : history.length === 0 ? (
+            <div className="ep-gh-empty">
+              <InboxOutlined style={{ fontSize: 32, opacity: 0.4 }} />
+              <span>暂无生成记录</span>
+            </div>
+          ) : (
+            <table className="ep-gh-table">
+              <thead>
+                <tr className="ep-gh-table-header-row">
+                  <th className="ep-gh-th">任务ID</th>
+                  <th className="ep-gh-th">状态</th>
+                  <th className="ep-gh-th">创建时间</th>
+                  <th className="ep-gh-th">更新时间</th>
+                  {onCancel && <th className="ep-gh-th">操作</th>}
+                </tr>
+              </thead>
+              <tbody>
+                {history.map((gen) => {
+                  const statusClass = `ep-gh-status-tag--${gen.status}`
+                  const canCancel = gen.status === "rendering" || gen.status === "editing"
+                  return (
+                    <tr key={gen.id} className="ep-gh-table-row">
+                      <td className="ep-gh-td ep-gh-td-id">
+                        {gen.id ? `${gen.id.slice(0, 8)}...` : "—"}
+                      </td>
+                      <td className="ep-gh-td">
+                        <span className={`ep-gh-status-tag ${statusClass}`}>
+                          {PLAN_STATUS_LABELS[gen.status] || gen.status}
+                        </span>
+                      </td>
+                      <td className="ep-gh-td ep-gh-td-time">
+                        {gen.created_at ? new Date(gen.created_at).toLocaleString("zh-CN") : "—"}
+                      </td>
+                      <td className="ep-gh-td ep-gh-td-time">
+                        {gen.updated_at ? new Date(gen.updated_at).toLocaleString("zh-CN") : "—"}
+                      </td>
+                      {onCancel && (
+                        <td className="ep-gh-td ep-gh-td-action">
+                          {canCancel ? (
+                            <button
+                              className="ep-gh-cancel-btn"
+                              onClick={() => onCancel(gen.id)}
+                              disabled={cancelLoading}
+                            >
+                              取消
+                            </button>
+                          ) : (
+                            <span className="ep-gh-action-placeholder">—</span>
+                          )}
+                        </td>
+                      )}
+                    </tr>
+                  )
+                })}
+              </tbody>
+            </table>
+          )}
+        </div>
+        <div className="ep-modal-footer">
+          <button className="ep-btn ep-btn-secondary" onClick={onClose}>
+            关闭
+          </button>
+        </div>
+      </div>
+    </div>
+  )
+}
+
+export default GenerationHistoryModal

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

@@ -0,0 +1,6 @@
+/**
+ * 生成进度弹窗 — 入口文件（向后兼容）
+ * 实际实现已移至 ./generation-progress-modal/ 目录
+ */
+export { default } from "./generation-progress-modal"
+export type { GenPhase, GenerationProgressModalProps } from "./generation-progress-modal"

apps/web/src/pages/editing-planner/components/bgm-selector/index.tsx

@@ -16,17 +16,9 @@ interface BgmSelectorProps {
   onClose: () => void
   config: BgmMixConfig
   onChange: (config: BgmMixConfig) => void
-  /** 模板/草稿 ID，用于请求 BGM 预设 */
-  templateId?: string
 }
 
-const BgmSelector: React.FC<BgmSelectorProps> = ({
-  open,
-  onClose,
-  config,
-  onChange,
-  templateId,
-}) => {
+const BgmSelector: React.FC<BgmSelectorProps> = ({ open, onClose, config, onChange }) => {
   const {
     presets,
     loading,
@@ -38,7 +30,7 @@ const BgmSelector: React.FC<BgmSelectorProps> = ({
     loadPresets,
     handlePreview,
     stopPreview,
-  } = useBgmSelector(open, templateId)
+  } = useBgmSelector(open)
 
   /* ── 选中 BGM ── */
   const handleSelect = useCallback(

apps/web/src/pages/editing-planner/components/bgm-selector/useBgmSelector.ts

@@ -19,7 +19,7 @@ export const CATEGORY_LIST: {
  * BGM 选择器数据与交互 Hook
  * 封装列表加载、搜索、分类筛选、试听播放逻辑
  */
-export function useBgmSelector(open: boolean, templateId?: string) {
+export function useBgmSelector(open: boolean) {
   const [presets, setPresets] = useState<BgmPreset[]>([])
   const [loading, setLoading] = useState(false)
   const [activeCategory, setActiveCategory] = useState<BgmCategory | "all">("all")
@@ -30,23 +30,19 @@ export function useBgmSelector(open: boolean, templateId?: string) {
 
   /* ── 加载 BGM 列表 ── */
   const loadPresets = useCallback(async () => {
-    if (!templateId) {
-      setPresets([])
-      return
-    }
     setLoading(true)
     try {
       const params: { category?: string; keyword?: string } = {}
       if (activeCategory !== "all") params.category = activeCategory
       if (keyword.trim()) params.keyword = keyword.trim()
-      const data = await getBgmPresets(templateId, params)
+      const data = await getBgmPresets(params)
       setPresets(data)
     } catch {
       message.error("加载 BGM 列表失败")
     } finally {
       setLoading(false)
     }
-  }, [activeCategory, keyword, templateId])
+  }, [activeCategory, keyword])
 
   useEffect(() => {
     if (open) loadPresets()

apps/web/src/pages/editing-planner/components/generation-progress-modal/ProgressPhase.tsx

@@ -0,0 +1,65 @@
+import React from "react"
+import { Modal } from "@/components/ui"
+import type { TaskItem } from "@/api/tasks"
+import { getStepLabel, getStatusColor } from "./constants"
+
+interface ProgressPhaseProps {
+  open: boolean
+  task: TaskItem | null
+  onCancel: () => void
+}
+
+/** progress（进度轮询）阶段弹窗 */
+export const ProgressPhase: React.FC<ProgressPhaseProps> = ({ open, task, onCancel }) => {
+  const progress = task?.progress ?? 0
+  const status = task?.status ?? ""
+  const currentStep = task?.current_step ?? ""
+  const userMessage = task?.user_message ?? ""
+  const stepColor = getStatusColor(status, currentStep)
+
+  return (
+    <Modal open={open} title="视频生成中" footer={null} onCancel={onCancel} closable width={480}>
+      <div className="ep-gen-progress">
+        {/* 进度环 */}
+        <div className="ep-gen-progress-ring-wrap">
+          <svg className="ep-gen-progress-ring" viewBox="0 0 120 120">
+            <circle className="ep-gen-progress-ring-bg" cx="60" cy="60" r="52" />
+            <circle
+              className="ep-gen-progress-ring-fill"
+              cx="60"
+              cy="60"
+              r="52"
+              style={{
+                strokeDasharray: `${2 * Math.PI * 52}`,
+                strokeDashoffset: `${2 * Math.PI * 52 * (1 - progress / 100)}`,
+                stroke: stepColor,
+              }}
+            />
+          </svg>
+          <span className="ep-gen-progress-pct" style={{ color: stepColor }}>
+            {progress}%
+          </span>
+        </div>
+
+        {/* 当前步骤 */}
+        <div className="ep-gen-step-text">
+          {userMessage || getStepLabel(currentStep) || "处理中…"}
+        </div>
+
+        {/* 进度条 */}
+        <div className="ep-gen-progress-bar">
+          <div
+            className="ep-gen-progress-bar-fill"
+            style={{
+              width: `${progress}%`,
+              backgroundColor: stepColor,
+            }}
+          />
+        </div>
+
+        {/* 任务 ID */}
+        {task?.id && <div className="ep-gen-task-id">任务 ID: {task.id}</div>}
+      </div>
+    </Modal>
+  )
+}

apps/web/src/pages/editing-planner/components/generation-progress-modal/ResultPhase.tsx

@@ -0,0 +1,82 @@
+import React from "react"
+import { Modal, Button } from "@/components/ui"
+import type { TaskItem } from "@/api/tasks"
+
+interface ResultPhaseProps {
+  open: boolean
+  phase: "completed" | "failed"
+  task: TaskItem | null
+  onCancel: () => void
+  onRetry?: () => void
+  onClose?: () => void
+}
+
+/** completed / failed（结果）阶段弹窗 */
+export const ResultPhase: React.FC<ResultPhaseProps> = ({
+  open,
+  phase,
+  task,
+  onCancel,
+  onRetry,
+  onClose,
+}) => {
+  const userMessage = task?.user_message ?? ""
+  const errorMessage = task?.error_message ?? ""
+  const retryable = task?.retryable ?? false
+  const handleClose = onClose || onCancel
+
+  if (phase === "completed") {
+    return (
+      <Modal
+        open={open}
+        title="✅ 生成完成"
+        footer={null}
+        onCancel={handleClose}
+        closable
+        width={440}
+      >
+        <div className="ep-gen-result">
+          <div className="ep-gen-result-icon">🎉</div>
+          <div className="ep-gen-result-title">视频生成完成！</div>
+          {userMessage && <div className="ep-gen-result-msg">{userMessage}</div>}
+          <div className="ep-gen-result-actions">
+            <Button buttonType="primary" onClick={handleClose}>
+              查看结果
+            </Button>
+          </div>
+        </div>
+      </Modal>
+    )
+  }
+
+  return (
+    <Modal
+      open={open}
+      title="❌ 生成失败"
+      footer={null}
+      onCancel={handleClose}
+      closable
+      width={440}
+    >
+      <div className="ep-gen-result ep-gen-result--error">
+        <div className="ep-gen-result-icon">😥</div>
+        <div className="ep-gen-result-title">视频生成失败</div>
+        {(errorMessage || userMessage) && (
+          <div className="ep-gen-result-msg ep-gen-result-msg--error">
+            {errorMessage || userMessage}
+          </div>
+        )}
+        <div className="ep-gen-result-actions">
+          {retryable && onRetry && (
+            <Button buttonType="primary" onClick={onRetry}>
+              🔄 重试
+            </Button>
+          )}
+          <Button buttonType="secondary" onClick={handleClose}>
+            关闭
+          </Button>
+        </div>
+      </div>
+    </Modal>
+  )
+}

apps/web/src/pages/editing-planner/components/generation-progress-modal/SetupPhase.tsx

@@ -0,0 +1,53 @@
+import React from "react"
+import { Modal } from "@/components/ui"
+
+interface SetupPhaseProps {
+  open: boolean
+  voiceoverDuration: number | null
+  estimatedDuration: number
+  submitting: boolean
+  onDurationChange: (v: number | null) => void
+  onGenerate: () => void
+  onCancel: () => void
+}
+
+/** setup（配置）阶段弹窗 */
+export const SetupPhase: React.FC<SetupPhaseProps> = ({
+  open,
+  voiceoverDuration,
+  estimatedDuration,
+  submitting,
+  onDurationChange,
+  onGenerate,
+  onCancel,
+}) => (
+  <Modal
+    open={open}
+    title="使用模板生成视频"
+    confirmLoading={submitting}
+    onOk={onGenerate}
+    onCancel={onCancel}
+    okText="开始生成"
+    cancelText="取消"
+    width={440}
+  >
+    <div className="ep-gen-setup">
+      <label className="ep-gen-field-label">配音时长（秒）</label>
+      <input
+        type="number"
+        className="ep-gen-duration-input"
+        placeholder="请输入配音时长"
+        value={voiceoverDuration ?? ""}
+        onChange={(e) => {
+          const v = e.target.value ? Number(e.target.value) : null
+          onDurationChange(v)
+        }}
+        min={1}
+        max={600}
+      />
+      <div className="ep-gen-estimate">
+        预估总时长：<strong>{estimatedDuration}s</strong>
+      </div>
+    </div>
+  </Modal>
+)

apps/web/src/pages/editing-planner/components/generation-progress-modal/constants.ts

@@ -0,0 +1,31 @@
+/* ──────────── 步骤文案映射 ──────────── */
+
+export const STEP_LABELS: Record<string, string> = {
+  queued: "排队中…",
+  preparing: "准备素材…",
+  generating_video: "渲染视频中…",
+  adding_effects: "添加特效…",
+  composing: "合成中…",
+  encoding: "编码输出中…",
+  completed: "生成完成！",
+  failed: "生成失败",
+}
+
+export const getStepLabel = (step: string) => STEP_LABELS[step] || step.replace(/_/g, " ")
+
+/* ──────────── 状态徽标颜色 ──────────── */
+
+export const STATUS_COLOR: Record<string, string> = {
+  queued: "#6b7280",
+  pending: "#6b7280",
+  preparing: "#f59e0b",
+  generating_video: "#4f46e5",
+  adding_effects: "#7c3aed",
+  composing: "#2563eb",
+  encoding: "#0891b2",
+  completed: "#10b981",
+  failed: "#ef4444",
+}
+
+export const getStatusColor = (status: string, currentStep: string) =>
+  STATUS_COLOR[status] || STATUS_COLOR[currentStep] || "#4f46e5"

apps/web/src/pages/editing-planner/components/generation-progress-modal/index.tsx

@@ -0,0 +1,70 @@
+/**
+ * 生成进度弹窗 — 任务 2.17
+ * 三阶段 UI：setup（配置）→ progress（进度轮询）→ completed / failed（结果）
+ * V21 设计系统，CSS 类名前缀 ep-gen-
+ */
+import React, { useEffect, useRef } from "react"
+import type { GenPhase, GenerationProgressModalProps } from "./types"
+import { SetupPhase } from "./SetupPhase"
+import { ProgressPhase } from "./ProgressPhase"
+import { ResultPhase } from "./ResultPhase"
+
+/* 重新导出类型，保持向后兼容 */
+export type { GenPhase, GenerationProgressModalProps }
+
+const GenerationProgressModal: React.FC<GenerationProgressModalProps> = ({
+  open,
+  phase,
+  voiceoverDuration,
+  estimatedDuration,
+  onDurationChange,
+  onGenerate,
+  task,
+  submitting,
+  onCancel,
+  onRetry,
+  onClose,
+}) => {
+  /* 关闭弹窗时重置（避免下次打开残留旧状态） */
+  const prevOpen = useRef(false)
+  useEffect(() => {
+    if (prevOpen.current && !open) {
+      /* modal just closed — parent handles reset */
+    }
+    prevOpen.current = open
+  }, [open])
+
+  /* setup 阶段 */
+  if (phase === "setup") {
+    return (
+      <SetupPhase
+        open={open}
+        voiceoverDuration={voiceoverDuration}
+        estimatedDuration={estimatedDuration}
+        submitting={submitting}
+        onDurationChange={onDurationChange}
+        onGenerate={onGenerate}
+        onCancel={onCancel}
+      />
+    )
+  }
+
+  /* progress 阶段 */
+  if (phase === "progress") {
+    return <ProgressPhase open={open} task={task} onCancel={onCancel} />
+  }
+
+  /* completed / failed 阶段 */
+  return (
+    <ResultPhase
+      open={open}
+      phase={phase as "completed" | "failed"}
+      task={task}
+      onCancel={onCancel}
+      onRetry={onRetry}
+      onClose={onClose}
+    />
+  )
+}
+
+export default GenerationProgressModal

apps/web/src/pages/editing-planner/components/generation-progress-modal/types.ts

@@ -0,0 +1,23 @@
+import type { TaskItem } from "@/api/tasks"
+
+export type GenPhase = "setup" | "progress" | "completed" | "failed"
+
+export interface GenerationProgressModalProps {
+  open: boolean
+  phase: GenPhase
+
+  /* setup 阶段 */
+  voiceoverDuration: number | null
+  estimatedDuration: number
+  onDurationChange: (v: number | null) => void
+  onGenerate: () => void
+
+  /* progress / 结果阶段 */
+  task: TaskItem | null
+
+  /* 通用 */
+  submitting: boolean
+  onCancel: () => void
+  onRetry?: () => void
+  onClose?: () => void
+}

apps/web/src/pages/generate/GeneratePage.tsx

@@ -1,20 +1,21 @@
 /**
- * 智能剪辑页面 — 服务器渲染预览架构
+ * 智能剪辑页面 — V24 前端预览播放器架构改造
  * 7 步向导：选择模板 → 素材 → 配音 → 标题 → 预览 → 封面 → 确认生成
  * 左右布局：左侧 generate-form + 右侧 generate-preview
  *
- * 架构：
- * - Step4+ 右侧预览面板自动创建服务器预览渲染任务（POST /generation/preview）
- * - 轮询完成后播放服务器渲染的真实视频（<video> 标签）
- * - 标题样式编辑时 CSS 层实时叠加预览
- * - 素材/配音/BGM 变更自动重新渲染；标题变更标记 stale
- * - 点"确认生成"时走 confirm 路径，成品就是预览视频本身，100% 一致
+ * 架构改造：
+ * - Step5 预览改为前端素材切片播放（FrontendPreviewPlayer）
+ * - 完全去除后端 FFmpeg 预览依赖
+ * - 标题样式通过 CSS 层实时叠加，所见即所得
+ * - 最终成片仍走后端 FFmpeg 渲染（Step7 确认生成）
  */
-import React, { useMemo, useCallback } from "react"
+import React, { useMemo } from "react"
 import { Modal, message } from "antd"
 import { useNavigate } from "react-router-dom"
 import type { VoiceClone } from "@/api/voice-clone"
+import { useQuery } from "@tanstack/react-query"
 import { useCloneProgress } from "@/hooks/useCloneProgress"
+import { getAssetsByKind } from "@/api/assets"
 import CloneModal from "@/components/voice/CloneModal"
 import GenerateHeader from "./components/GenerateHeader"
 import {
@@ -30,7 +31,6 @@ import { useGenerateFormState } from "./hooks/useGenerateFormState"
 import { useStepNavigation } from "./hooks/useStepNavigation"
 import { useGenerateVideo } from "./hooks/useGenerateVideo"
 import { usePreviewAssets } from "./hooks/usePreviewAssets"
-import { useServerPreview } from "./hooks/useServerPreview"
 import { useTitleStyleUpdaters } from "./hooks/useStep4Title/useTitleStyleUpdaters"
 import "./generate.css"
 
@@ -72,18 +72,13 @@ const GeneratePage: React.FC = () => {
     autoSubtitles,
     bgm,
     editPlanId,
-    sourceEditPlanId,
     previewVideo,
     setPreviewVideo,
     previewModalOpen,
     setPreviewModalOpen,
-    previewTaskId,
-    setPreviewTaskId,
-    storedSourceEditPlanId,
-    setStoredSourceEditPlanId,
   } = formState
 
-  /* ── 标题样式回调 ── */
+  /* ── 标题样式回调（Step5 样式面板 + 右侧预览 CSS 层共用） ── */
   const styleUpdaters = useTitleStyleUpdaters({
     titleSettings,
     onTitleSettingsChange: setTitleSettings,
@@ -98,103 +93,45 @@ const GeneratePage: React.FC = () => {
     message.success("音色克隆成功！")
   }
 
-  /* ── 素材 ID 列表 ── */
+  /* ── 前端预览：加载选中素材的视频文件信息 ── */
   const previewAssetIds = useMemo(
     () => (materialMode === "auto" ? smartSelectedIds : selectedMaterials),
     [materialMode, smartSelectedIds, selectedMaterials],
   )
+  const previewAssetsEnabled = currentStep >= 4 && previewAssetIds.length > 0
+  const {
+    assets: previewAssets,
+    loading: previewAssetsLoading,
+    ready: previewAssetsReady,
+  } = usePreviewAssets(previewAssetIds, previewAssetsEnabled)
 
-  /* ── 当前模板对象 ── */
+  /* ── 当前模板对象（传给前端预览播放器） ── */
   const currentTemplate = useMemo(
     () => userTemplates.find((t) => t.id === selectedTemplate) || null,
     [userTemplates, selectedTemplate],
   )
 
-  /* ── BGM 配置 ── */
-  const bgmConfig = useMemo(
-    () => ({
-      enabled: bgm,
-      music_id: currentTemplate?.bgm_config?.music_id || "",
-    }),
-    [bgm, currentTemplate],
-  )
-
-  /* ── 加载素材详情（仅用于配音时长校验，不用于播放） ── */
-  const previewAssetsEnabled = previewAssetIds.length > 0
-  const { assets: previewAssets } = usePreviewAssets(previewAssetIds, previewAssetsEnabled)
-
-  /* ── 视频总时长计算 ── */
+  /* ── 视频总时长计算（用于配音时长校验） ── */
   const totalVideoDuration = useMemo(() => {
+    // 优先用素材精确时长；素材未加载时用模板 segments 的 duration_max 之和估算
     const exact = calculateTotalVideoDuration(previewAssets, currentTemplate ?? undefined)
     if (exact > 0) return exact
     return estimateTotalVideoDuration(currentTemplate ?? undefined)
   }, [previewAssets, currentTemplate])
 
-  /* ── 解析配音 ID ── */
-  const voiceLibraryId = useMemo(
-    () => (voiceMode === "clone" ? selectedClonedVoice || "" : selectedVoice || ""),
-    [voiceMode, selectedClonedVoice, selectedVoice],
-  )
-
-  /* ── 构建服务器预览请求参数 ── */
-  const buildPreviewRequest = useCallback(() => {
-    return {
-      template_id: selectedTemplate,
-      asset_ids: previewAssetIds,
-      duration: duration || 30,
-      video_ratio: videoRatio,
-      ...(voiceLibraryId ? { voice_library_id: voiceLibraryId } : {}),
-      bgm_config: {
-        enabled: bgm !== false,
-        ...(bgmConfig.music_id ? { preset_id: bgmConfig.music_id } : {}),
-      },
-      ...(titleSettings.title
-        ? {
-            title_config: {
-              text: titleSettings.title,
-              font: titleSettings.font,
-              font_size: titleSettings.size,
-              font_color: titleSettings.color,
-              position: titleSettings.position,
-              bold: titleSettings.bold,
-              stroke: titleSettings.stroke,
-              shadow: titleSettings.shadow,
-            },
-          }
-        : {}),
-    }
-  }, [
-    selectedTemplate,
-    previewAssetIds,
-    duration,
-    videoRatio,
-    voiceLibraryId,
-    bgm,
-    bgmConfig,
-    titleSettings,
-  ])
-
-  /* ── 服务器预览 ── */
-  const serverPreviewEnabled = currentStep >= 4 && !!selectedTemplate && previewAssetIds.length > 0
-
-  const {
-    status: previewStatus,
-    videoUrl: previewVideoUrl,
-    progress: previewProgress,
-    error: previewError,
-    triggerPreview,
-  } = useServerPreview({
-    enabled: serverPreviewEnabled,
-    buildRequest: buildPreviewRequest,
-    onPreviewTaskCreated: (taskId, planId) => {
-      setPreviewTaskId(taskId)
-      if (planId) setStoredSourceEditPlanId(planId)
-    },
+  /* ── 配音音频 URL ── */
+  const { data: voiceMaterials = [] } = useQuery({
+    queryKey: ["assets", "voice"],
+    queryFn: () => getAssetsByKind("voice", { limit: 50 }),
   })
 
+  const voiceAudioUrl = useMemo(() => {
+    if (!selectedVoice) return undefined
+    const asset = voiceMaterials.find((v) => v.id === selectedVoice)
+    return asset?.file_url || undefined
+  }, [selectedVoice, voiceMaterials])
+
   /* ── 步骤导航 ── */
-  // Step5 需要服务器预览完成才能前进
-  const previewReady = previewStatus === "ready"
   const { goNext, goPrev } = useStepNavigation({
     currentStep,
     setCurrentStep,
@@ -203,7 +140,7 @@ const GeneratePage: React.FC = () => {
     selectedMaterials,
     smartSelectedIds,
     titleSettings,
-    previewReady,
+    previewReady: previewAssetsReady,
   })
 
   /* ── 视频生成核心逻辑 ── */
@@ -234,30 +171,22 @@ const GeneratePage: React.FC = () => {
     autoSubtitles,
     bgm,
     generateCount,
-    sourceEditPlanId: storedSourceEditPlanId || sourceEditPlanId,
-    previewTaskId,
-    bgmConfig,
-    onGenerationSuccess: () => {
-      setPreviewTaskId(null)
-      setStoredSourceEditPlanId(null)
-    },
+    previewTaskId: "",
   })
 
-  /* ── 手动重新预览（标题变更后或失败重试） ── */
-  const handleRetryPreview = useCallback(() => {
-    triggerPreview()
-  }, [triggerPreview])
-
   /* ================================================================
-     渲染
+     渲染 — 主页面
      ================================================================ */
 
   return (
     <div className="xx-generate-page">
+      {/* ── 页头 ── */}
       <GenerateHeader fromEditPlan={!!editPlanId} />
 
+      {/* ── 步骤条 ── */}
       <GenerateStepsBar currentStep={currentStep} onStepClick={setCurrentStep} />
 
+      {/* ── 主布局 ── */}
       <div className="xx-generate-layout">
         {/* ════ 左侧：表单区 ════ */}
         <div className="xx-generate-form">
@@ -274,6 +203,7 @@ const GeneratePage: React.FC = () => {
             onSmartSelectedIdsChange={setSmartSelectedIds}
             titleSettings={titleSettings}
             onTitleSettingsChange={setTitleSettings}
+            /* 标题样式回调 */
             onUpdatePosition={styleUpdaters.updatePosition}
             onUpdateFont={styleUpdaters.updateFont}
             onUpdateSize={styleUpdaters.updateSize}
@@ -284,10 +214,6 @@ const GeneratePage: React.FC = () => {
             onApplyPreset={styleUpdaters.applyPreset}
             activePreset={styleUpdaters.activePreset}
             titlePresets={styleUpdaters.titlePresets}
-            onPreviewTaskCreated={setPreviewTaskId}
-            onSourceEditPlanIdExtracted={setStoredSourceEditPlanId}
-            bgm={bgm}
-            bgmConfig={bgmConfig}
             coverSettings={coverSettings}
             onCoverSettingsChange={setCoverSettings}
             duration={duration}
@@ -313,8 +239,6 @@ const GeneratePage: React.FC = () => {
             onRetry={handleRetryGenerate}
             onDismissError={handleDismissError}
             presetVoices={presetVoices}
-            previewStatus={previewStatus}
-            onRetryPreview={handleRetryPreview}
           />
 
           <GenerateStepActions
@@ -328,18 +252,18 @@ const GeneratePage: React.FC = () => {
           />
         </div>
 
-        {/* ════ 右侧：预览 + 结果 ════ */}
+        {/* ════ 右侧：预览 + 生成结果 ════ */}
         <div className="xx-generate-right-col">
+          {/* 预览视频面板（Step4+ 显示，含 CSS 标题实时预览层） */}
           {currentStep >= 4 && (
             <PreviewVideoPanel
-              previewStatus={previewStatus}
-              videoUrl={previewVideoUrl}
-              progress={previewProgress}
-              error={previewError}
-              onRetry={handleRetryPreview}
+              assets={previewAssets}
+              template={currentTemplate}
               videoRatio={videoRatio}
+              assetsReady={previewAssetsReady}
+              assetsLoading={previewAssetsLoading}
               titleSettings={titleSettings}
-              assetCount={previewAssetIds.length}
+              voiceAudioUrl={voiceAudioUrl}
             />
           )}
           {currentStep >= 6 && (
@@ -361,7 +285,7 @@ const GeneratePage: React.FC = () => {
         </div>
       </div>
 
-      {/* 视频预览弹窗 */}
+      {/* ── 视频预览弹窗 ── */}
       <Modal
         className="xx-preview-modal"
         open={previewModalOpen}
@@ -384,7 +308,7 @@ const GeneratePage: React.FC = () => {
         )}
       </Modal>
 
-      {/* 音色克隆弹窗 */}
+      {/* ── 音色克隆弹窗 ── */}
       <CloneModal
         open={cloneModalOpen}
         onClose={() => setCloneModalOpen(false)}

apps/web/src/pages/generate/components/FrontendPreviewPlayer.tsx

@@ -17,7 +17,7 @@ import {
 import type { AssetItem } from "@/api/assets"
 import type { EditingTemplate } from "@/api/editing-planner"
 import { useSegmentScheduler, type PlaybackSegment } from "../hooks/useSegmentScheduler"
-import { useCanvasPlayer } from "../hooks/useCanvasPlayer"
+import { useCanvasPlayer, isWebCodecsSupported } from "../hooks/useCanvasPlayer"
 
 interface FrontendPreviewPlayerProps {
   assets: AssetItem[]
@@ -82,9 +82,7 @@ const FrontendPreviewPlayer: React.FC<FrontendPreviewPlayerProps> = ({
   titleSettings,
 }) => {
   const segments = useMemo(() => buildPlaybackSegments(assets, template), [assets, template])
-  // 默认走原生 video 播放（浏览器硬件解码，独立线程，不阻塞 UI）
-  // WebCodecs 仅在明确需要时启用（保留代码作为兜底）
-  const useWebCodecs = false
+  const useWebCodecs = isWebCodecsSupported()
 
   // ── 两条路径共用同一个 canvas ref（fallback 路径不使用） ──
   const canvasRef = useRef<HTMLCanvasElement>(null)
@@ -114,30 +112,12 @@ const FrontendPreviewPlayer: React.FC<FrontendPreviewPlayerProps> = ({
     [segments],
   )
 
-  // WebCodecs 解码失败后强制走 video fallback
-  const [forceVideoFallback, setForceVideoFallback] = useState(false)
-
-  const handleCanvasError = useCallback((err: Error) => {
-    console.error("[FrontendPreviewPlayer] Canvas decode Error, switching to video fallback:", err)
-    setForceVideoFallback(true)
-  }, [])
-
   const { state: canvasState, controls: canvasControls } = useCanvasPlayer(
     canvasRef,
-    useWebCodecs && !forceVideoFallback ? canvasSegments : [],
-    useWebCodecs && !forceVideoFallback ? canvasTitle : undefined,
-    handleCanvasError,
-    useWebCodecs && !forceVideoFallback,
+    canvasSegments,
+    useWebCodecs ? canvasTitle : undefined,
   )
 
-  // WebCodecs 报告解码失败时自动切换到 video fallback
-  useEffect(() => {
-    if (canvasState.hasDecodeError && !forceVideoFallback) {
-      console.warn("[FrontendPreviewPlayer] hasDecodeError detected, forcing video fallback")
-      setForceVideoFallback(true)
-    }
-  }, [canvasState.hasDecodeError, forceVideoFallback])
-
   // ── Video 播放器（fallback 路径） ──
   const {
     isPlaying: videoIsPlaying,
@@ -150,13 +130,12 @@ const FrontendPreviewPlayer: React.FC<FrontendPreviewPlayerProps> = ({
     videoRefs,
   } = useSegmentScheduler(segments)
 
-  // 选择哪条路径的状态（WebCodecs 解码失败时强制走 video fallback）
-  const effectiveUseWebCodecs = useWebCodecs && !forceVideoFallback
-  const isPlaying = effectiveUseWebCodecs ? canvasState.isPlaying : videoIsPlaying
-  const currentTime = effectiveUseWebCodecs ? canvasState.currentTime : videoCurrentTime
-  const totalDuration = effectiveUseWebCodecs ? canvasState.duration : videoTotalDuration
-  const canPlay = effectiveUseWebCodecs ? canvasState.isReady : videoCanPlay
-  const isBuffering = effectiveUseWebCodecs ? canvasState.isBuffering : false
+  // 选择哪条路径的状态
+  const isPlaying = useWebCodecs ? canvasState.isPlaying : videoIsPlaying
+  const currentTime = useWebCodecs ? canvasState.currentTime : videoCurrentTime
+  const totalDuration = useWebCodecs ? canvasState.duration : videoTotalDuration
+  const canPlay = useWebCodecs ? canvasState.isReady : videoCanPlay
+  const isBuffering = useWebCodecs ? canvasState.isBuffering : false
 
   // ── 配音音频同步 ──
   const audioRef = useRef<HTMLAudioElement | null>(null)
@@ -193,18 +172,16 @@ const FrontendPreviewPlayer: React.FC<FrontendPreviewPlayerProps> = ({
   }, [isPlaying, currentTime])
 
   // 片段切换时同步音频（仅 fallback 路径需要）
-  const segmentSyncKey = effectiveUseWebCodecs ? -1 : videoCurrentSegIdx
+  const segmentSyncKey = useWebCodecs ? -1 : videoCurrentSegIdx
   useEffect(() => {
     const audio = audioRef.current
     if (!audio || !audio.src || !isPlaying) return
     audio.currentTime = currentTime
-    // 注意：不要把 currentTime 放进依赖数组，否则每200ms会重置音频位置导致卡顿
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [segmentSyncKey, isPlaying])
+  }, [segmentSyncKey, isPlaying, currentTime])
 
   const handleSeekTo = useCallback(
     (time: number) => {
-      if (effectiveUseWebCodecs) {
+      if (useWebCodecs) {
         canvasControls.seek(time)
       } else {
         videoSeekTo(time)
@@ -214,11 +191,11 @@ const FrontendPreviewPlayer: React.FC<FrontendPreviewPlayerProps> = ({
         audio.currentTime = time
       }
     },
-    [effectiveUseWebCodecs, canvasControls, videoSeekTo],
+    [useWebCodecs, canvasControls, videoSeekTo],
   )
 
   const handleTogglePlay = useCallback(() => {
-    if (effectiveUseWebCodecs) {
+    if (useWebCodecs) {
       if (canvasState.isPlaying) {
         canvasControls.pause()
       } else {
@@ -227,7 +204,7 @@ const FrontendPreviewPlayer: React.FC<FrontendPreviewPlayerProps> = ({
     } else {
       videoTogglePlayPause()
     }
-  }, [effectiveUseWebCodecs, canvasState.isPlaying, canvasControls, videoTogglePlayPause])
+  }, [useWebCodecs, canvasState.isPlaying, canvasControls, videoTogglePlayPause])
 
   // ── 进度条拖拽 ──
   const [isDragging, setIsDragging] = useState(false)
@@ -270,8 +247,24 @@ const FrontendPreviewPlayer: React.FC<FrontendPreviewPlayerProps> = ({
 
   const progressPercent = totalDuration > 0 ? (currentTime / totalDuration) * 100 : 0
 
-  // ── Canvas 容器 ref（保留声明，WebCodecs 兜底路径仍引用） ──
+  // ── Canvas ResizeObserver ──
   const canvasContainerRef = useRef<HTMLDivElement>(null)
+  useEffect(() => {
+    const container = canvasContainerRef.current
+    const canvas = canvasRef.current
+    if (!container || !canvas) return
+    const ro = new ResizeObserver((entries) => {
+      for (const entry of entries) {
+        const { width, height } = entry.contentRect
+        if (width > 0 && height > 0) {
+          canvas.width = width * window.devicePixelRatio
+          canvas.height = height * window.devicePixelRatio
+        }
+      }
+    })
+    ro.observe(container)
+    return () => ro.disconnect()
+  }, [])
 
   // ── 未就绪 ──
   if (!ready || !assets.length) {
@@ -297,7 +290,6 @@ const FrontendPreviewPlayer: React.FC<FrontendPreviewPlayerProps> = ({
 
   // ── 无播放片段 ──
   if (!canPlay) {
-    const showDecodeError = forceVideoFallback && canvasState.hasDecodeError
     return (
       <div
         className="xx-preview-empty"
@@ -316,19 +308,6 @@ const FrontendPreviewPlayer: React.FC<FrontendPreviewPlayerProps> = ({
             <LoadingOutlined style={{ fontSize: 48, color: "#fff", marginBottom: 12 }} spin />
             <p style={{ color: "rgba(255,255,255,0.8)" }}>加载中...</p>
           </>
-        ) : showDecodeError ? (
-          <>
-            <PlayCircleOutlined style={{ fontSize: 48, color: "#ef4444", marginBottom: 12 }} />
-            <p className="xx-preview-empty-title" style={{ color: "rgba(255,255,255,0.9)" }}>
-              视频解码失败
-            </p>
-            <p
-              className="xx-preview-empty-desc"
-              style={{ color: "rgba(255,255,255,0.6)", maxWidth: 300, textAlign: "center" }}
-            >
-              {canvasState.errorMessage || "当前浏览器不支持该视频编码格式，请刷新重试"}
-            </p>
-          </>
         ) : (
           <>
             <PlayCircleOutlined
@@ -345,7 +324,7 @@ const FrontendPreviewPlayer: React.FC<FrontendPreviewPlayerProps> = ({
   return (
     <>
       {/* ── Canvas 渲染层（WebCodecs 路径） ── */}
-      {effectiveUseWebCodecs && (
+      {useWebCodecs && (
         <div
           ref={canvasContainerRef}
           style={{
@@ -366,8 +345,8 @@ const FrontendPreviewPlayer: React.FC<FrontendPreviewPlayerProps> = ({
         </div>
       )}
 
-      {/* ── Video 渲染层（默认路径，浏览器原生硬件解码） ── */}
-      {!effectiveUseWebCodecs &&
+      {/* ── Video 渲染层（fallback 路径） ── */}
+      {!useWebCodecs &&
         segments.map((seg, i) => (
           <video
             key={seg.assetId}
@@ -375,7 +354,9 @@ const FrontendPreviewPlayer: React.FC<FrontendPreviewPlayerProps> = ({
             ref={(el) => {
               videoRefs.current[i] = el
             }}
-            preload="auto"
+            preload={
+              i === videoCurrentSegIdx ? "auto" : i === videoCurrentSegIdx + 1 ? "metadata" : "none"
+            }
             src={seg.videoUrl}
             style={{
               position: "absolute",
@@ -434,7 +415,7 @@ const FrontendPreviewPlayer: React.FC<FrontendPreviewPlayerProps> = ({
           zIndex: 10,
         }}
       >
-        {`片段 ${videoCurrentSegIdx + 1}/${segments.length}`}
+        {useWebCodecs ? "Canvas" : `片段 ${videoCurrentSegIdx + 1}/${segments.length}`}
       </div>
 
       {/* 控制条 */}

apps/web/src/pages/generate/components/GenerateStepContent.tsx

@@ -76,18 +76,6 @@ export interface GenerateStepContentProps {
   onDismissError: () => void
   /* 其他 */
   presetVoices: PresetVoiceItem[]
-  /** 预览任务创建回调——传递给 Step6CoverSettings */
-  onPreviewTaskCreated?: (taskId: string) => void
-  /** 从预览响应中提取到 source_edit_plan_id 时的回调 */
-  onSourceEditPlanIdExtracted?: (planId: string) => void
-  /** BGM 开关 */
-  bgm: boolean
-  /** BGM 配置（来自模板） */
-  bgmConfig?: { enabled: boolean; music_id?: string }
-  /** 服务器预览状态 */
-  previewStatus?: import("../hooks/useServerPreview").ServerPreviewStatus
-  /** 重新预览回调 */
-  onRetryPreview?: () => void
 }
 
 export const GenerateStepContent: React.FC<GenerateStepContentProps> = (props) => {
@@ -133,18 +121,8 @@ export const GenerateStepContent: React.FC<GenerateStepContentProps> = (props) =
     onRetry,
     onDismissError,
     presetVoices,
-    onPreviewTaskCreated,
-    onSourceEditPlanIdExtracted,
-    bgm,
-    bgmConfig,
-    previewStatus,
-    onRetryPreview,
   } = props
 
-  /* 当前模板的 segments，传给 Step2 构建 clips */
-  const currentTemplate = userTemplates.find((t) => t.id === selectedTemplate)
-  const templateSegments = currentTemplate?.segments
-
   switch (currentStep) {
     case 1:
       return (
@@ -163,8 +141,6 @@ export const GenerateStepContent: React.FC<GenerateStepContentProps> = (props) =
           onSelectedMaterialsChange={onSelectedMaterialsChange}
           smartSelectedIds={smartSelectedIds}
           onSmartSelectedIdsChange={onSmartSelectedIdsChange}
-          selectedTemplate={selectedTemplate}
-          templateSegments={templateSegments}
         />
       )
     case 3:
@@ -180,7 +156,6 @@ export const GenerateStepContent: React.FC<GenerateStepContentProps> = (props) =
         <Step4TitleSettings
           titleSettings={titleSettings}
           onTitleSettingsChange={onTitleSettingsChange}
-          selectedTemplate={selectedTemplate}
         />
       )
     case 5:
@@ -197,8 +172,6 @@ export const GenerateStepContent: React.FC<GenerateStepContentProps> = (props) =
           onApplyPreset={onApplyPreset}
           activePreset={activePreset}
           titlePresets={titlePresets}
-          previewStatus={previewStatus || "idle"}
-          onRetryPreview={onRetryPreview || (() => {})}
         />
       )
     case 6:
@@ -209,14 +182,6 @@ export const GenerateStepContent: React.FC<GenerateStepContentProps> = (props) =
           duration={duration}
           assetIds={materialMode === "auto" ? smartSelectedIds : selectedMaterials}
           selectedTemplate={selectedTemplate}
-          titleSettings={titleSettings}
-          onPreviewTaskCreated={onPreviewTaskCreated}
-          onSourceEditPlanIdExtracted={onSourceEditPlanIdExtracted}
-          voiceMode={voiceMode}
-          selectedVoice={selectedVoice}
-          selectedClonedVoice={selectedClonedVoice}
-          bgm={bgm}
-          bgmConfig={bgmConfig}
         />
       )
     case 7:

apps/web/src/pages/generate/components/PreviewVideoPanel.tsx

@@ -1,42 +1,38 @@
 /**
- * 右侧预览视频面板 — 服务器渲染预览架构
+ * 右侧预览视频面板
+ * Step4+: 显示预览视频面板
+ * Step5: 前端实时预览 — 用原生 video 播放素材片段 + CSS 标题叠加
  *
- * Step4+: 显示预览面板
- * Step5: 播放服务器渲染的真实视频（POST /generation/preview）
+ * 架构改造：完全去除后端 FFmpeg 预览依赖
+ * - 使用 FrontendPreviewPlayer 直接播放素材片段
+ * - TitleOverlay CSS 层实时响应标题样式变化
  *
- * 架构：
- * - 进入 Step4/5 时自动创建服务器预览渲染任务
- * - 轮询完成后用 <video> 标签播放返回的 video_url
- * - 标题样式编辑时 CSS TitleOverlay 实时叠加预览
- * - 素材/配音/BGM 变更自动重新渲染
- * - 标题文字/样式变更标记 stale，保留旧视频 + 显示"重新预览"按钮
- *
- * 点"确认生成"时走 confirm 路径，成品就是预览视频本身，100% 一致。
+ * 布局：本组件提供 .xx-preview-video 容器（position: relative + overflow: hidden）
+ * FrontendPreviewPlayer 的内容通过 absolute 定位填充容器
+ * TitleOverlay 通过 absolute 定位 + z-index: 30 覆盖在最上层
  */
 import React, { useMemo, useRef, useState, useEffect } from "react"
-import { LoadingOutlined, ReloadOutlined, ExclamationCircleOutlined } from "@ant-design/icons"
-import { Button } from "antd"
+import { LoadingOutlined } from "@ant-design/icons"
+import type { AssetItem } from "@/api/assets"
+import type { EditingTemplate } from "@/api/editing-planner"
 import type { TitleSettings } from "../types"
-import { getFontFamily } from "../constants"
-import type { ServerPreviewStatus } from "../hooks/useServerPreview"
+import FrontendPreviewPlayer from "./FrontendPreviewPlayer"
 
 interface PreviewVideoPanelProps {
-  /** 服务器预览状态 */
-  previewStatus: ServerPreviewStatus
-  /** 服务器渲染视频 URL */
-  videoUrl: string | null
-  /** 渲染进度 0-100 */
-  progress: number
-  /** 错误信息 */
-  error: string | null
-  /** 重新预览回调 */
-  onRetry: () => void
+  /** 已加载的素材列表 */
+  assets: AssetItem[]
+  /** 当前模板 */
+  template: EditingTemplate | null
   /** 视频比例 */
   videoRatio: string
-  /** 标题设置 — CSS 实时预览层 */
+  /** 素材是否已加载就绪 */
+  assetsReady: boolean
+  /** 素材是否正在加载 */
+  assetsLoading: boolean
+  /** 标题设置 — 用于 CSS 实时预览层 */
   titleSettings?: TitleSettings
-  /** 素材数量 */
-  assetCount?: number
+  /** 配音音频 URL */
+  voiceAudioUrl?: string
 }
 
 /* ── ASS 坐标系参数（与后端 ass_subtitle_builder.py 一致） ── */
@@ -45,8 +41,13 @@ const ASS_TITLE_MARGIN_TOP = 60
 const ASS_TITLE_MARGIN_BOTTOM = 60
 const ASS_TITLE_MARGIN_SIDE = 40
 
+/**
+ * 根据 position 计算 CSS 垂直定位
+ * 与后端 position_to_ass_alignment() 对齐：top→8, center→5, bottom→2
+ */
 function getPositionStyle(position: string): React.CSSProperties {
   const sidePercent = (ASS_TITLE_MARGIN_SIDE / 1280) * 100
+
   switch (position) {
     case "bottom":
       return {
@@ -74,14 +75,19 @@ function getPositionStyle(position: string): React.CSSProperties {
   }
 }
 
+/**
+ * 构建 CSS 标题层的样式
+ * 所有渲染参数与后端 FFmpeg ASS 字幕一致
+ */
 function buildTitleStyle(settings: TitleSettings, containerHeight: number): React.CSSProperties {
+  // 用 px 计算 fontSize，不再依赖父元素 font-size 的百分比
   const fontSizePx =
     containerHeight > 0
       ? (Math.min(settings.size, 96) / ASS_VIDEO_HEIGHT) * containerHeight
-      : (Math.min(settings.size, 96) / ASS_VIDEO_HEIGHT) * 400
+      : (Math.min(settings.size, 96) / ASS_VIDEO_HEIGHT) * 400 // fallback
 
   const base: React.CSSProperties = {
-    fontFamily: getFontFamily(settings.font),
+    fontFamily: settings.font || "思源黑体",
     fontSize: `${fontSizePx}px`,
     color: settings.color || "#ffffff",
     fontWeight: settings.bold ? 700 : 400,
@@ -93,16 +99,28 @@ function buildTitleStyle(settings: TitleSettings, containerHeight: number): Reac
     paddingLeft: `${(ASS_TITLE_MARGIN_SIDE / 1280) * 100}%`,
     paddingRight: `${(ASS_TITLE_MARGIN_SIDE / 1280) * 100}%`,
   }
-  if (settings.stroke) base.WebkitTextStroke = "1px #000000"
-  if (settings.shadow) base.textShadow = "2px 2px 4px rgba(0,0,0,0.8)"
+
+  if (settings.stroke) {
+    base.WebkitTextStroke = "1px #000000"
+  }
+
+  if (settings.shadow) {
+    base.textShadow = "2px 2px 4px rgba(0,0,0,0.8)"
+  }
+
   return base
 }
 
-/** CSS 标题实时预览覆盖层 */
+/**
+ * CSS 标题预览覆盖层
+ * 始终渲染：有标题显示标题，无标题显示占位文本"标题预览"
+ * z-index: 20（在视频 z-index:1 和控制条 z-index:10 之上）
+ */
 const TitleOverlay: React.FC<{ titleSettings: TitleSettings }> = ({ titleSettings }) => {
   const containerRef = useRef<HTMLDivElement>(null)
-  const [containerHeight, setContainerHeight] = useState(400)
+  const [containerHeight, setContainerHeight] = useState(400) // fallback
 
+  // ResizeObserver 获取容器实际高度
   useEffect(() => {
     const el = containerRef.current
     if (!el) return
@@ -113,6 +131,7 @@ const TitleOverlay: React.FC<{ titleSettings: TitleSettings }> = ({ titleSetting
       }
     })
     ro.observe(el)
+    // 初始化也读一次
     const rect = el.getBoundingClientRect()
     if (rect.height > 0) setContainerHeight(rect.height)
     return () => ro.disconnect()
@@ -124,7 +143,7 @@ const TitleOverlay: React.FC<{ titleSettings: TitleSettings }> = ({ titleSetting
   )
   const titleStyle = useMemo(
     () => buildTitleStyle(titleSettings, containerHeight),
-    // eslint-disable-next-line react-hooks/exhaustive-deps
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- 已逐字段列出 titleSettings 依赖
     [
       containerHeight,
       titleSettings.font,
@@ -150,13 +169,14 @@ const TitleOverlay: React.FC<{ titleSettings: TitleSettings }> = ({ titleSetting
         overflow: "hidden",
       }}
     >
-      <div style={{ ...positionStyle, ...titleStyle, position: "absolute" }}>
-        {displayTitle.split("/").map((part, i) => (
-          <span key={i}>
-            {i > 0 && <br />}
-            {part}
-          </span>
-        ))}
+      <div
+        style={{
+          ...positionStyle,
+          ...titleStyle,
+          position: "absolute",
+        }}
+      >
+        {displayTitle}
       </div>
     </div>
   )
@@ -165,47 +185,30 @@ const TitleOverlay: React.FC<{ titleSettings: TitleSettings }> = ({ titleSetting
 /* ── 主组件 ── */
 
 export const PreviewVideoPanel: React.FC<PreviewVideoPanelProps> = ({
-  previewStatus,
-  videoUrl,
-  progress,
-  error,
-  onRetry,
+  assets,
+  template,
   videoRatio,
+  assetsReady,
+  assetsLoading,
   titleSettings,
-  assetCount,
+  voiceAudioUrl,
 }) => {
-  const videoAspectStyle = { aspectRatio: (videoRatio || "9:16").replace(":", "/") }
-  const isLoading = previewStatus === "loading"
-  const isReady = previewStatus === "ready" || previewStatus === "stale"
-  const isFailed = previewStatus === "failed"
-  const isIdle = previewStatus === "idle"
-  const isStale = previewStatus === "stale"
+  const videoAspectStyle = { aspectRatio: (videoRatio || "16:9").replace(":", "/") }
 
   return (
     <div className="xx-generate-preview">
       <div className="xx-preview-header">
         <h3>预览视频</h3>
-        {isReady && !isStale && <span className="xx-preview-badge">服务器渲染</span>}
-        {isStale && (
-          <span
-            style={{
-              fontSize: 12,
-              color: "#faad14",
-              display: "flex",
-              alignItems: "center",
-              gap: 4,
-            }}
-          >
-            <ExclamationCircleOutlined /> 配置已变更
-          </span>
-        )}
-        {isLoading && <span className="xx-preview-badge">渲染中</span>}
+        {assetsReady && assets.length > 0 && <span className="xx-preview-badge">实时预览</span>}
       </div>
 
+      {/* ✅ 预览容器 — 唯一的 .xx-preview-video 容器
+          内部所有内容（视频、控制条、标题叠加层）通过 absolute 定位填充 */}
       <div className="xx-preview-video" style={{ ...videoAspectStyle, position: "relative" }}>
-        {/* 加载中 */}
-        {isLoading && (
+        {/* 加载中状态 */}
+        {assetsLoading && (
           <div
+            className="xx-preview-loading-center"
             style={{
               position: "absolute",
               inset: 0,
@@ -214,130 +217,34 @@ export const PreviewVideoPanel: React.FC<PreviewVideoPanelProps> = ({
               alignItems: "center",
               justifyContent: "center",
               zIndex: 5,
-              background: "rgba(0,0,0,0.6)",
             }}
           >
             <LoadingOutlined style={{ fontSize: 36, color: "#fff" }} spin />
-            <p style={{ marginTop: 12, color: "rgba(255,255,255,0.9)", fontSize: 14 }}>
-              正在渲染预览视频{progress > 0 ? `...${progress}%` : "..."}
-            </p>
-            <p style={{ marginTop: 4, color: "rgba(255,255,255,0.5)", fontSize: 12 }}>
-              首次渲染约需 30-60 秒
+            <p style={{ marginTop: 12, color: "rgba(255,255,255,0.8)", fontSize: 14 }}>
+              加载素材中...
             </p>
           </div>
         )}
 
-        {/* 空闲状态（尚未触发预览） */}
-        {isIdle && (
-          <div
-            style={{
-              position: "absolute",
-              inset: 0,
-              display: "flex",
-              flexDirection: "column",
-              alignItems: "center",
-              justifyContent: "center",
-              background: "rgba(0,0,0,0.3)",
-              zIndex: 5,
-            }}
-          >
-            <p style={{ color: "rgba(255,255,255,0.7)", fontSize: 14 }}>等待素材选择...</p>
-          </div>
-        )}
+        {/* 前端播放器（视频 + 控制条 + 播放按钮）*/}
+        <FrontendPreviewPlayer
+          assets={assets}
+          template={template}
+          videoRatio={videoRatio}
+          ready={assetsReady}
+          voiceAudioUrl={voiceAudioUrl}
+        />
 
-        {/* 服务器渲染的真实视频 */}
-        {isReady && videoUrl && (
-          <video
-            key={videoUrl}
-            src={videoUrl}
-            controls
-            autoPlay
-            loop
-            playsInline
-            style={{
-              width: "100%",
-              height: "100%",
-              objectFit: "contain",
-              position: "absolute",
-              inset: 0,
-              zIndex: 1,
-            }}
-          />
-        )}
-
-        {/* 标题样式实时预览层（仅在有视频时叠加） */}
-        {isReady && titleSettings && <TitleOverlay titleSettings={titleSettings} />}
-
-        {/* stale 遮罩：配置变更提示 */}
-        {isStale && (
-          <div
-            style={{
-              position: "absolute",
-              bottom: 0,
-              left: 0,
-              right: 0,
-              padding: "10px 16px",
-              background: "linear-gradient(transparent, rgba(0,0,0,0.85))",
-              display: "flex",
-              alignItems: "center",
-              justifyContent: "space-between",
-              gap: 8,
-              zIndex: 30,
-            }}
-          >
-            <span style={{ color: "rgba(255,255,255,0.9)", fontSize: 12 }}>
-              配置已变更，预览内容可能不是最新
-            </span>
-            <Button size="small" type="primary" icon={<ReloadOutlined />} onClick={onRetry}>
-              重新预览
-            </Button>
-          </div>
-        )}
-
-        {/* 错误状态 */}
-        {isFailed && (
-          <div
-            style={{
-              position: "absolute",
-              inset: 0,
-              display: "flex",
-              flexDirection: "column",
-              alignItems: "center",
-              justifyContent: "center",
-              background: "rgba(0,0,0,0.7)",
-              zIndex: 10,
-              padding: 24,
-            }}
-          >
-            <ExclamationCircleOutlined style={{ fontSize: 40, color: "#ff4d4f" }} />
-            <p
-              style={{
-                marginTop: 12,
-                color: "rgba(255,255,255,0.9)",
-                fontSize: 14,
-                textAlign: "center",
-              }}
-            >
-              {error || "预览渲染失败"}
-            </p>
-            <Button
-              type="primary"
-              icon={<ReloadOutlined />}
-              onClick={onRetry}
-              style={{ marginTop: 12 }}
-            >
-              重新预览
-            </Button>
-          </div>
-        )}
+        {/* CSS 标题实时预览层 — z-index: 20，始终渲染在内容层之上 */}
+        {titleSettings && <TitleOverlay titleSettings={titleSettings} />}
       </div>
 
       {/* 素材信息 */}
-      {assetCount !== undefined && assetCount > 0 && (
+      {assetsReady && assets.length > 0 && (
         <div className="xx-preview-info">
           <div className="xx-preview-info-row">
             <span>素材数</span>
-            <span>{assetCount} 个</span>
+            <span>{assets.length} 个</span>
           </div>
           <div className="xx-preview-info-row">
             <span>比例</span>

apps/web/src/pages/generate/components/Step2MaterialSelect.tsx

@@ -2,7 +2,6 @@
  * Step 2 素材选择组件
  */
 import React from "react"
-import type { TemplateSegment } from "@/api/templates/types"
 import { useStep2Materials } from "../hooks/useStep2Materials"
 import MaterialModeTabs from "./material/MaterialModeTabs"
 import ManualMaterialList from "./material/ManualMaterialList"
@@ -16,10 +15,6 @@ interface Step2MaterialSelectProps {
   onSelectedMaterialsChange: (ids: string[]) => void
   smartSelectedIds: string[]
   onSmartSelectedIdsChange: (ids: string[]) => void
-  /** 当前选中的模板/草稿 ID，用于自动保存 */
-  selectedTemplate?: string
-  /** 当前模板的 segments（用于构建 clips duration） */
-  templateSegments?: TemplateSegment[]
 }
 
 const Step2MaterialSelect: React.FC<Step2MaterialSelectProps> = (props) => {

apps/web/src/pages/generate/components/Step4TitleSettings.tsx

@@ -12,8 +12,6 @@ import AiTitleGenerator from "./title/AiTitleGenerator"
 interface Step4TitleSettingsProps {
   titleSettings: TitleSettings
   onTitleSettingsChange: (settings: TitleSettings) => void
-  /** 当前选中的模板/草稿 ID，用于自动保存 */
-  selectedTemplate?: string
 }
 
 const Step4TitleSettings: React.FC<Step4TitleSettingsProps> = (props) => {

apps/web/src/pages/generate/components/Step5GeneratePreview.tsx

@@ -1,21 +1,16 @@
 /**
- * Step 5 预览设置组件
- *
- * 服务器渲染预览架构：
- * - 进入此步骤时右侧面板自动播放服务器渲染的真实视频
- * - 标题样式可实时调整（CSS 层叠加预览）
- * - 调整标题后点击"重新预览"可刷新服务器渲染结果
- * - 素材/配音/BGM 变更会自动重新渲染
+ * Step 5 生成预览组件
+ * 架构改造：移除后端预览生成，改为前端实时预览
+ * 左侧仅保留标题样式面板，视频在右侧 PreviewVideoPanel 实时播放
  */
 import React from "react"
-import { PlayCircleOutlined, ReloadOutlined } from "@ant-design/icons"
-import { Button } from "antd"
+import { PlayCircleOutlined } from "@ant-design/icons"
 import { POSITION_OPTIONS, FONT_OPTIONS } from "../constants"
 import type { TitleSettings } from "../types"
-import type { ServerPreviewStatus } from "../hooks/useServerPreview"
 import TitleStylePanel from "./title/TitleStylePanel"
 
 interface Step5GeneratePreviewProps {
+  /* 标题样式 */
   titleSettings: TitleSettings
   onUpdatePosition: (position: string) => void
   onUpdateFont: (font: string) => void
@@ -27,10 +22,6 @@ interface Step5GeneratePreviewProps {
   onApplyPreset: (presetKey: string) => void
   activePreset: string | null
   titlePresets: { key: string; label: string; previewStyle: React.CSSProperties }[]
-  /** 服务器预览状态 */
-  previewStatus: ServerPreviewStatus
-  /** 重新预览回调 */
-  onRetryPreview: () => void
 }
 
 const Step5GeneratePreview: React.FC<Step5GeneratePreviewProps> = ({
@@ -45,18 +36,14 @@ const Step5GeneratePreview: React.FC<Step5GeneratePreviewProps> = ({
   onApplyPreset,
   activePreset,
   titlePresets,
-  previewStatus,
-  onRetryPreview,
 }) => {
-  const isLoading = previewStatus === "loading"
-  const isStale = previewStatus === "stale"
-  const isFailed = previewStatus === "failed"
-
   return (
     <div className="xx-form-section">
       <h3>🎬 预览设置</h3>
 
+      {/* 前端实时预览提示 */}
       <div
+        className="xx-preview-tip"
         style={{
           display: "flex",
           alignItems: "center",
@@ -70,71 +57,11 @@ const Step5GeneratePreview: React.FC<Step5GeneratePreviewProps> = ({
       >
         <PlayCircleOutlined style={{ fontSize: 18, color: "#3b82f6" }} />
         <span style={{ fontSize: 13, color: "var(--text-secondary, #666)" }}>
-          右侧为服务器渲染的真实预览视频，最终成片与预览完全一致
+          右侧面板直接播放素材片段，调整标题样式可实时预览效果
         </span>
       </div>
 
-      {/* 配置变更提示条 */}
-      {isStale && (
-        <div
-          style={{
-            display: "flex",
-            alignItems: "center",
-            justifyContent: "space-between",
-            gap: 8,
-            padding: "10px 16px",
-            background: "rgba(250, 173, 20, 0.1)",
-            borderRadius: 8,
-            marginBottom: 16,
-            border: "1px solid rgba(250, 173, 20, 0.2)",
-          }}
-        >
-          <span style={{ fontSize: 13, color: "#d48806" }}>
-            标题已修改，点击重新预览刷新服务器渲染
-          </span>
-          <Button size="small" type="primary" icon={<ReloadOutlined />} onClick={onRetryPreview}>
-            重新预览
-          </Button>
-        </div>
-      )}
-
-      {isFailed && (
-        <div
-          style={{
-            display: "flex",
-            alignItems: "center",
-            justifyContent: "space-between",
-            gap: 8,
-            padding: "10px 16px",
-            background: "rgba(255, 77, 79, 0.1)",
-            borderRadius: 8,
-            marginBottom: 16,
-            border: "1px solid rgba(255, 77, 79, 0.2)",
-          }}
-        >
-          <span style={{ fontSize: 13, color: "#ff4d4f" }}>预览渲染失败</span>
-          <Button size="small" danger icon={<ReloadOutlined />} onClick={onRetryPreview}>
-            重新预览
-          </Button>
-        </div>
-      )}
-
-      {isLoading && (
-        <div
-          style={{
-            padding: "10px 16px",
-            background: "rgba(82, 196, 26, 0.08)",
-            borderRadius: 8,
-            marginBottom: 16,
-            border: "1px solid rgba(82, 196, 26, 0.15)",
-          }}
-        >
-          <span style={{ fontSize: 13, color: "#389e0d" }}>
-            ⏳ 正在服务器渲染预览视频，请稍候...
-          </span>
-        </div>
-      )}
-
+      {/* 标题样式面板 */}
       <TitleStylePanel
         settings={titleSettings}
         onUpdatePosition={onUpdatePosition}

apps/web/src/pages/generate/components/Step5VoiceSelect.tsx

@@ -17,16 +17,6 @@ interface Step5VoiceSelectProps {
 }
 
 /** 格式化时长 mm:ss */
-/** 获取素材实际时长（优先顶层 duration，fallback 到 metadata.duration） */
-const getDuration = (item: AssetItem): number => {
-  return item.duration ?? (item.metadata?.duration as number) ?? 0
-}
-
-/** 获取素材实际文件大小 */
-const getFileSize = (item: AssetItem): number => {
-  return item.file_size ?? (item.metadata?.file_size as number) ?? 0
-}
-
 const formatDuration = (seconds?: number): string => {
   if (!seconds || seconds <= 0) return "00:00"
   const m = Math.floor(seconds / 60)
@@ -99,7 +89,7 @@ const Step5VoiceSelect: React.FC<Step5VoiceSelectProps> = ({
       // 如果启用了时长校验，且配音时长不足
       if (totalVideoDuration > 0) {
         const material = materials.find((m) => m.id === id)
-        if (material && getDuration(material) < totalVideoDuration) {
+        if (material && (material.duration || 0) < totalVideoDuration) {
           setPendingVoiceId(id)
           setDurationWarningOpen(true)
           return
@@ -281,24 +271,25 @@ const Step5VoiceSelect: React.FC<Step5VoiceSelectProps> = ({
                 }}
               >
                 <span style={{ display: "flex", alignItems: "center", gap: 4 }}>
-                  {formatDuration(getDuration(item))}
-                  {totalVideoDuration > 0 && getDuration(item) < Number(totalVideoDuration) && (
-                    <span
-                      style={{
-                        color: "#ff4d4f",
-                        fontSize: 11,
-                        fontWeight: 500,
-                        display: "inline-flex",
-                        alignItems: "center",
-                        gap: 2,
-                      }}
-                    >
-                      <WarningOutlined />
-                      时长不足
-                    </span>
-                  )}
+                  {formatDuration(item.duration)}
+                  {totalVideoDuration > 0 &&
+                    (Number(item.duration) || 0) < Number(totalVideoDuration) && (
+                      <span
+                        style={{
+                          color: "#ff4d4f",
+                          fontSize: 11,
+                          fontWeight: 500,
+                          display: "inline-flex",
+                          alignItems: "center",
+                          gap: 2,
+                        }}
+                      >
+                        <WarningOutlined />
+                        时长不足
+                      </span>
+                    )}
                 </span>
-                <span>{formatFileSize(getFileSize(item))}</span>
+                <span>{formatFileSize(item.file_size)}</span>
               </div>
             </div>
           )
@@ -327,9 +318,7 @@ const Step5VoiceSelect: React.FC<Step5VoiceSelectProps> = ({
           return (
             <p>
               该配音时长（
-              <strong>
-                {pendingMaterial ? formatDuration(getDuration(pendingMaterial)) : "--"}
-              </strong>
+              <strong>{pendingMaterial ? formatDuration(pendingMaterial.duration) : "--"}</strong>
               ）短于视频总时长（
               <strong>{formatDuration(totalVideoDuration)}</strong>
               ），播放时配音可能提前结束，建议选择更长的配音素材。

apps/web/src/pages/generate/components/Step6CoverSettings.tsx

@@ -14,22 +14,6 @@ interface Step6CoverSettingsProps {
   assetIds?: string[]
   /** 当前选中的模板 ID */
   selectedTemplate?: string
-  /** Step4 标题设置，用于预览视频烧录标题 & 封面叠加标题 */
-  titleSettings?: import("../types").TitleSettings
-  /** 预览任务创建回调——将 task_id 暴露给父组件供 confirmGeneration 复用 */
-  onPreviewTaskCreated?: (taskId: string) => void
-  /** 从预览响应中提取到 source_edit_plan_id 时的回调 */
-  onSourceEditPlanIdExtracted?: (planId: string) => void
-  /** 配音模式 */
-  voiceMode?: "preset" | "custom" | "clone"
-  /** 选中的配音素材 ID */
-  selectedVoice?: string
-  /** 选中的克隆音色 ID */
-  selectedClonedVoice?: string
-  /** BGM 开关 */
-  bgm?: boolean
-  /** BGM 配置 */
-  bgmConfig?: { enabled: boolean; music_id?: string }
 }
 
 const Step6CoverSettings: React.FC<Step6CoverSettingsProps> = (props) => {
@@ -56,14 +40,6 @@ const Step6CoverSettings: React.FC<Step6CoverSettingsProps> = (props) => {
     duration: props.duration,
     assetIds: props.assetIds,
     selectedTemplate: props.selectedTemplate,
-    titleSettings: props.titleSettings,
-    onPreviewTaskCreated: props.onPreviewTaskCreated,
-    onSourceEditPlanIdExtracted: props.onSourceEditPlanIdExtracted,
-    voiceMode: props.voiceMode,
-    selectedVoice: props.selectedVoice,
-    selectedClonedVoice: props.selectedClonedVoice,
-    bgm: props.bgm,
-    bgmConfig: props.bgmConfig,
   })
 
   const handleAutoGenerate = () => {

apps/web/src/pages/generate/components/cover-settings/UploadCoverPicker.tsx

@@ -30,7 +30,7 @@ export const UploadCoverPicker: React.FC<UploadCoverPickerProps> = ({ uploadUrl,
           <div className="xx-cover-upload-placeholder">
             <span style={{ fontSize: 32 }}>📤</span>
             <span className="xx-cover-upload-text">点击上传封面图片</span>
-            <span className="xx-cover-upload-hint">支持 JPG / PNG，建议 9:16 比例</span>
+            <span className="xx-cover-upload-hint">支持 JPG / PNG，建议 16:9 比例</span>
           </div>
         )}
         <input

apps/web/src/pages/generate/components/title/TitlePresetsGrid.tsx

@@ -2,7 +2,6 @@
  * 标题预设样式网格
  */
 import React from "react"
-import { getFontFamily } from "../../constants"
 
 interface TitlePresetItem {
   key: string
@@ -36,7 +35,7 @@ const TitlePresetsGrid: React.FC<TitlePresetsGridProps> = ({
           >
             <span
               className="xx-title-preset-preview-text"
-              style={{ ...p.previewStyle, fontFamily: getFontFamily(fontFamily || "思源黑体") }}
+              style={{ ...p.previewStyle, ...(fontFamily ? { fontFamily } : {}) }}
             >
               标题
             </span>

apps/web/src/pages/generate/constants.ts

@@ -56,21 +56,6 @@ export const FONT_OPTIONS = [
   "华康俪金黑",
 ]
 
-/* ── 标题字体 CSS font-family 映射（中文显示名 → 浏览器可识别的字体栈） ── */
-export const FONT_FAMILY_MAP: Record<string, string> = {
-  思源黑体: '"Source Han Sans SC", "Noto Sans SC", "PingFang SC", "Microsoft YaHei", sans-serif',
-  思源宋体: '"Source Han Serif SC", "Noto Serif SC", "Songti SC", "SimSun", serif',
-  苹方: '"PingFang SC", -apple-system, "Helvetica Neue", sans-serif',
-  PingFang: '"PingFang SC", -apple-system, "Helvetica Neue", sans-serif',
-  微软雅黑: '"Microsoft YaHei", "PingFang SC", sans-serif',
-  楷体: '"KaiTi", "STKaiti", "DFKai-SB", serif',
-  华康俪金黑: '"华康俪金黑", "DFLiJinHei-W8", "Source Han Sans SC", "Microsoft YaHei", sans-serif',
-}
-
-export function getFontFamily(font: string): string {
-  return FONT_FAMILY_MAP[font] || FONT_FAMILY_MAP["思源黑体"]
-}
-
 /* ── 标题样式预设 ── */
 export const TITLE_PRESETS = [
   {

apps/web/src/pages/generate/generate.css

@@ -891,7 +891,7 @@
 
 /* ── 视频预览 ── */
 .xx-preview-video {
-  aspect-ratio: 9 / 16;
+  aspect-ratio: 16 / 9;
   max-height: 400px;
   border-radius: var(--radius-md);
   background: linear-gradient(135deg, var(--color-gray-900), var(--color-primary-900));
@@ -1516,7 +1516,7 @@
 .xx-smart-match-thumb {
   position: relative;
   width: 100%;
-  aspect-ratio: 9 / 16;
+  aspect-ratio: 16 / 9;
   background: #f1f5f9;
   overflow: hidden;
 }
@@ -2144,7 +2144,7 @@
 }
 
 .xx-cover-frame-placeholder {
-  aspect-ratio: 9 / 16;
+  aspect-ratio: 16 / 9;
   background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
   border-radius: var(--radius-md);
   display: flex;
@@ -2247,7 +2247,7 @@
 }
 
 .xx-cover-upload-area {
-  aspect-ratio: 9 / 16;
+  aspect-ratio: 16 / 9;
   border: 2px dashed var(--border-color);
   border-radius: var(--radius-md);
   display: flex;
@@ -2308,9 +2308,7 @@
 
 .xx-cover-preview-box {
   position: relative;
-  aspect-ratio: 9 / 16;
-  max-width: 180px;
-  margin: 0 auto;
+  aspect-ratio: 16 / 9;
   background: var(--bg-tertiary);
   border-radius: var(--radius-md);
   overflow: hidden;
@@ -2668,7 +2666,7 @@
 .xx-preview-video-wrapper .xx-preview-video {
   max-width: 300px;
   width: 100%;
-  aspect-ratio: 9 / 16;
+  aspect-ratio: 16 / 9;
   margin-bottom: 0;
 }
 
@@ -2774,7 +2772,7 @@
 
 .xx-video-thumb {
   position: relative;
-  aspect-ratio: 9 / 16;
+  aspect-ratio: 16 / 9;
   background: var(--bg-tertiary);
   overflow: hidden;
 }

apps/web/src/pages/generate/hooks/generate-video/types.ts

@@ -19,17 +19,8 @@ export interface UseGenerateVideoProps {
   autoSubtitles: boolean
   bgm: boolean
   generateCount: number
-  /** 当前草稿 ID（URL 参数 edit_plan_id，用于后端回写任务关联） */
-  sourceEditPlanId?: string | null
-  /** 预览任务 ID（由 useStep6Cover 创建后写入，供 confirmGeneration 复用预览产物） */
-  previewTaskId?: string | null
-  /** BGM 配置（来自模板 bgm_config，受 bgm 开关控制） */
-  bgmConfig?: {
-    enabled: boolean
-    music_id?: string
-  }
-  /** 生成成功后的回调（用于清除持久化的 previewTaskId 等状态） */
-  onGenerationSuccess?: () => void
+  /** 预览任务的 task_id（用于新确认生成 API） */
+  previewTaskId: string
 }
 
 /** 生成阶段 */

apps/web/src/pages/generate/hooks/generate-video/useGenerationPolling.ts

@@ -1,146 +1,87 @@
 import { useRef, useCallback } from "react"
 import { message } from "antd"
-import axios from "axios"
-import { getGenerationTask } from "@/api/tasks/tasks"
-import { getGenerationTaskResults } from "@/api/template-editor"
+import { getGenerationStatus, getGenerationTaskResults } from "@/api/template-editor"
 import { safeExtractError } from "./errorUtils"
 
 interface UseGenerationPollingOptions {
+  templateId: string
   onProgress: (progress: number) => void
   onComplete: (videos: unknown[]) => void
   onFailed: (errorMsg: string) => void
 }
 
-/** 最大连续错误次数（仅对可重试错误），超过后终止轮询 */
-const MAX_RETRYABLE_ERRORS = 10
-/** 获取结果的最大重试次数 */
-const MAX_RESULTS_RETRIES = 3
-
 /**
- * 生成状态轮询 Hook（v2 — 改用 /generation/tasks/{task_id}）
- *
- * 旧版轮询 GET /templates/{id}/editor/generation-status 依赖 plan 维度状态，
- * 在编辑流程数据链路断裂时拿不到 task_id。新版直接使用 POST /generation/tasks
- * 返回的 task_id 轮询任务详情，不再依赖 plan。
- *
- * 错误处理：
- * - 4xx（尤其 404）视为不可恢复，立即 onFailed，不再重试
- * - 5xx / 网络错误重试，最多连续 MAX_RETRYABLE_ERRORS 次
- * - 任务完成后获取结果失败会重试 MAX_RESULTS_RETRIES 次，仍失败则 onFailed
+ * 生成状态轮询 Hook
+ * 轮询生成状态，更新进度，处理完成/失败
  */
 export const useGenerationPolling = ({
+  templateId,
   onProgress,
   onComplete,
   onFailed,
 }: UseGenerationPollingOptions) => {
   const progressTimer = useRef<ReturnType<typeof setTimeout>>()
-  const cancelledRef = useRef(false)
 
   const clearTimer = useCallback(() => {
-    cancelledRef.current = true
     if (progressTimer.current) {
       clearTimeout(progressTimer.current)
       progressTimer.current = undefined
     }
   }, [])
 
-  /** 任务完成后拉取结果列表，带重试 */
-  const fetchResultsWithRetry = useCallback(
-    async (taskId: string, attempt = 0): Promise<unknown[] | null> => {
+  const startPolling = useCallback(() => {
+    const poll = async () => {
       try {
-        return await getGenerationTaskResults(taskId)
-      } catch (err) {
-        if (cancelledRef.current) return null
-        console.error(`[获取生成结果失败] 第 ${attempt + 1} 次`, err)
-        if (attempt < MAX_RESULTS_RETRIES - 1) {
-          await new Promise((resolve) => setTimeout(resolve, 1000 * (attempt + 1)))
-          return fetchResultsWithRetry(taskId, attempt + 1)
-        }
-        return null
-      }
-    },
-    [],
-  )
+        const data = await getGenerationStatus(templateId)
 
-  const startPolling = useCallback(
-    (taskId: string) => {
-      cancelledRef.current = false
-      let consecutiveErrors = 0
-
-      const poll = async () => {
-        if (cancelledRef.current) return
-        try {
-          const task = await getGenerationTask(taskId)
-          consecutiveErrors = 0
-
-          if (task.status === "completed") {
-            onProgress(100)
-            const videos = await fetchResultsWithRetry(taskId)
-            if (cancelledRef.current) return
-            if (videos === null) {
-              const errorMsg = "视频已生成，但获取结果列表失败，请稍后在任务列表查看"
-              console.error("[生成结果获取失败] taskId:", taskId)
-              onFailed(errorMsg)
-              message.error(errorMsg)
-              return
+        if (data.plan_status === "completed") {
+          onProgress(100)
+          // 获取生成的视频结果
+          let videos: unknown[] = []
+          if (data.generation_task_id) {
+            try {
+              videos = await getGenerationTaskResults(data.generation_task_id)
+            } catch (err) {
+              console.error("[获取生成结果失败]", err)
             }
-            onComplete(videos)
-            message.success("视频生成完成！")
-            return
           }
-
-          if (task.status === "failed" || task.status === "cancelled") {
-            const rawMsg =
-              task.error_info?.error_message ||
-              task.error_message ||
-              (task.status === "cancelled" ? "任务已取消" : "视频生成失败，请联系管理员或重试")
-            const errorMsg = safeExtractError(rawMsg)
-            console.error("[生成失败] taskId:", taskId, "响应:", task)
-            onFailed(errorMsg)
-            message.error(errorMsg)
-            return
-          }
-
-          // pending / waiting / running — 继续轮询
-          const pct = Math.max(0, Math.min(99, Math.round(Number(task.progress) || 0)))
-          onProgress(pct)
-          progressTimer.current = setTimeout(poll, 2000)
-        } catch (pollErr) {
-          if (cancelledRef.current) return
-          console.error("[轮询出错] taskId:", taskId, pollErr)
-
-          // 4xx 不可恢复，立即失败
-          const status = axios.isAxiosError(pollErr) ? pollErr.response?.status : undefined
-          if (status && status >= 400 && status < 500) {
-            const msg =
-              (axios.isAxiosError(pollErr) &&
-                (pollErr.response?.data as { detail?: string; message?: string } | undefined)
-                  ?.detail) ||
-              (axios.isAxiosError(pollErr) &&
-                (pollErr.response?.data as { detail?: string; message?: string } | undefined)
-                  ?.message) ||
-              `查询任务失败 (${status})`
-            const errorMsg = safeExtractError(msg)
-            onFailed(errorMsg)
-            message.error(errorMsg)
-            return
-          }
-
-          consecutiveErrors += 1
-          if (consecutiveErrors >= MAX_RETRYABLE_ERRORS) {
-            const errorMsg = "任务状态查询连续失败，请稍后在任务列表查看结果"
-            onFailed(errorMsg)
-            message.error(errorMsg)
-            return
-          }
-          progressTimer.current = setTimeout(poll, 3000)
+          onComplete(videos)
+          message.success("视频生成完成！")
+          return
+        }
+        if (data.plan_status === "failed") {
+          const dataAny = data as unknown as Record<string, unknown>
+          const rawMsg =
+            dataAny.error_message ||
+            dataAny.error ||
+            dataAny.message ||
+            (Array.isArray(data.clips)
+              ? (data.clips as { status: string; error_message?: string }[]).find(
+                  (c) => c.status === "failed",
+                )?.error_message
+              : undefined) ||
+            "视频生成失败，请联系管理员或重试"
+          const errorMsg = safeExtractError(rawMsg)
+          console.error("[生成失败] templateId:", templateId, "响应:", data)
+          onFailed(errorMsg)
+          message.error(errorMsg)
+          return
         }
-      }
 
-      progressTimer.current = setTimeout(poll, 1500)
-    },
-    [onProgress, onComplete, onFailed, fetchResultsWithRetry],
-  )
+        const clips = data.clips || []
+        const total = clips.length || 1
+        const done = (clips as { status: string }[]).filter((c) => c.status === "completed").length
+        onProgress(Math.round((done / total) * 100))
+
+        progressTimer.current = setTimeout(poll, 2000)
+      } catch (pollErr) {
+        console.error("[轮询出错] templateId:", templateId, pollErr)
+        progressTimer.current = setTimeout(poll, 3000)
+      }
+    }
+
+    progressTimer.current = setTimeout(poll, 2000)
+  }, [templateId, onProgress, onComplete, onFailed])
 
   return { startPolling, clearTimer }
 }

apps/web/src/pages/generate/hooks/useCanvasPlayer.ts

@@ -8,62 +8,16 @@ import { useRef, useCallback, useEffect, useState } from "react"
 import { createFile } from "mp4box"
 import type { Movie, Sample } from "mp4box"
 
-// ── 常量 ──
-
-/**
- * 规范化 mp4box 提取的 codec 字符串为 WebCodecs 兼容格式
- * mp4box 返回的 codec 可能包含 mp4box 特有后缀（如 avc1.640028），
- * WebCodecs 要求标准 ISO BMFF codec string（如 avc1.640028）
- * 大部分情况下格式一致，但需要做防御性处理
- */
-function normalizeCodecString(codec: string): string {
-  // mp4box 有时返回带空格的 codec，去掉
-  const trimmed = codec.trim()
-  // HEVC: mp4box 可能返回 hev1.1.6.L93.B0 或 hvc1.1.6.L93.B0
-  // WebCodecs 接受 hev1.x.x 或 hvc1.x.x，两者都可
-  // H.264: mp4box 返回 avc1.640028，WebCodecs 也接受
-  return trimmed
-}
-
 // ── MP4 Box 解析辅助函数 ──
 
-// MP4 标准容器 box 列表（递归时会进入这些 box 内部搜索子 box）
-const MP4_CONTAINER_TYPES = [
-  "moov",
-  "trak",
-  "mdia",
-  "minf",
-  "stbl",
-  "stsd",
-  "dinf",
-  "edts",
-  "udta",
-  "meta",
-  "tref",
-]
-
-const VISUAL_SAMPLE_ENTRY_TYPES = ["avc1", "avc3", "hvc1", "hev1"]
-
-/**
- * 递归搜索 box 树，找到 hvcC 或 avcC box 并返回其配置数据（不含 8 字节 box header）
- *
- * MP4 box 嵌套结构：moov → trak → mdia → minf → stbl → stsd → hev1 → hvcC
- * - 普通容器 box 从 offset+8 开始递归
- * - stsd 有额外 8 字节头（version/flags 4B + entry_count 4B），从 offset+16 开始
- * - VisualSampleEntry (avc1/avc3/hvc1/hev1) 前 78 字节是固定字段，子 box 从 offset+8+78 开始
- */
-function findCodecConfigRecursive(
-  buffer: ArrayBuffer,
-  start: number,
-  end: number,
-): ArrayBuffer | undefined {
+/** 在指定范围内查找 avcC / hvcC box，返回其数据 */
+function findCodecConfig(buffer: ArrayBuffer, start: number, end: number): ArrayBuffer | undefined {
   const view = new DataView(buffer)
   let offset = start
 
   while (offset < end - 8) {
     const size = view.getUint32(offset)
-    if (size < 8 || offset + size > end) break
-
+    if (size < 8) break
     const type = String.fromCharCode(
       view.getUint8(offset + 4),
       view.getUint8(offset + 5),
@@ -71,28 +25,37 @@ function findCodecConfigRecursive(
       view.getUint8(offset + 7),
     )
 
-    // 找到目标 codec 配置 box，返回内容（不含 8 字节 header）
-    if (type === "avcC" || type === "hvcC") {
-      console.log("[findCodecConfig] Found", type, "at offset", offset, "size", size)
-      return buffer.slice(offset + 8, offset + size)
-    }
-
-    // VisualSampleEntry：前 78 字节是固定字段，子 box 在 78 字节之后
-    if (VISUAL_SAMPLE_ENTRY_TYPES.includes(type)) {
-      const childResult = findCodecConfigRecursive(buffer, offset + 8 + 78, offset + size)
-      if (childResult) return childResult
-    }
-    // stsd：额外 8 字节头（version/flags 4B + entry_count 4B），子 box 在 offset+16
-    else if (type === "stsd") {
-      const childResult = findCodecConfigRecursive(buffer, offset + 8 + 8, offset + size)
-      if (childResult) return childResult
-    }
-    // 标准容器 box：从 offset+8 开始递归
-    else if (MP4_CONTAINER_TYPES.includes(type)) {
-      const childResult = findCodecConfigRecursive(buffer, offset + 8, offset + size)
-      if (childResult) return childResult
+    // 容器 box（fullbox 多 4 字节）
+    const containerBoxes = ["trak", "mdia", "minf", "stbl"]
+    if (containerBoxes.includes(type)) {
+      // fullbox: size(4) + type(4) + version(1) + flags(3) = 12 bytes header
+      const contentStart = offset + 12
+      const result = findCodecConfig(buffer, contentStart, offset + size)
+      if (result) return result
+    } else if (type === "stsd") {
+      // SampleDescriptionBox 是 fullbox: 8 header + 4 version/flags + 4 entry_count
+      const entryCount = view.getUint32(offset + 12)
+      let entryOffset = offset + 16
+      for (let i = 0; i < entryCount && entryOffset < offset + size; i++) {
+        const entrySize = view.getUint32(entryOffset)
+        // 视觉样本条目: 8 header + 6 reserved + 2 data_ref_index + remaining
+        // 子 box 从 entryOffset + 16 + 62 开始 (skip reserved + data_ref_index + predefined)
+        // 实际结构: 8(header) + 6(reserved) + 2(data_ref_index) + 16(predefined+reserved) + 2(width) + 2(height) + ...
+        // 子 box 从 entryOffset + 8 + 6 + 2 + 16 + 2 + 2 + 2 + 2 + 4 + 2 + 2 + 2 + 2 = entryOffset + 78
+        // 更简单的做法：扫描 entry 内的子 box
+        const entryEnd = entryOffset + entrySize
+        const subBoxStart = entryOffset + 8 + 70 // VisualSampleEntry 固定字段共 70 字节
+        const result = findCodecConfig(buffer, subBoxStart, entryEnd)
+        if (result) return result
+        entryOffset += entrySize
+      }
+    } else if (type === "avcC" || type === "hvcC") {
+      // 找到目标 box，返回完整 box（含 header）
+      // 返回完整 box（含 size + type header），WebCodecs HEVC decoder 需要
+      return buffer.slice(offset, offset + size)
     }
 
+    if (size === 0) break
     offset += size
   }
   return undefined
@@ -109,7 +72,7 @@ class FrameQueue {
   private frames: FrameEntry[] = []
   private maxSize: number
 
-  constructor(maxSize = 200) {
+  constructor(maxSize = 5) {
     this.maxSize = maxSize
   }
 
@@ -121,36 +84,24 @@ class FrameQueue {
     this.frames.push(entry)
   }
 
-  /** 获取当前时间戳应显示的帧（二分查找，O(log n)） */
+  /** 获取当前时间戳应显示的帧 */
   getCurrentFrame(timestamp: number): VideoFrame | null {
-    if (this.frames.length === 0) return null
-
-    const target = timestamp + 0.01
-
-    // 找到最后一个 pts <= target 的帧（右边界）
-    let lo = 0,
-      hi = this.frames.length - 1,
-      bestIdx = -1
-    while (lo <= hi) {
-      const mid = (lo + hi) >> 1
-      if (this.frames[mid].pts <= target) {
-        bestIdx = mid
-        lo = mid + 1
-      } else {
-        hi = mid - 1
+    let best: FrameEntry | null = null
+    let bestIdx = -1
+    for (let i = 0; i < this.frames.length; i++) {
+      const f = this.frames[i]
+      if (f.pts <= timestamp + 0.01) {
+        best = f
+        bestIdx = i
       }
     }
-
-    if (bestIdx < 0) return null
-
-    // 关闭并移除 bestIdx 之前的所有已播放帧
     for (let i = 0; i < bestIdx; i++) {
       this.frames[i].frame.close()
     }
-    this.frames.splice(0, bestIdx)
-
-    // 此时 bestIdx 对应帧已在索引 0
-    return this.frames[0]?.frame ?? null
+    if (bestIdx >= 0) {
+      this.frames = this.frames.slice(bestIdx)
+    }
+    return best?.frame ?? null
   }
 
   clear() {
@@ -197,10 +148,6 @@ export interface CanvasPlayerState {
   duration: number
   isReady: boolean
   isBuffering: boolean
-  /** WebCodecs 解码失败时为 true，调用方应 fallback 到原生 video 播放 */
-  hasDecodeError: boolean
-  /** 解码错误信息（用于 UI 展示） */
-  errorMessage: string
 }
 
 export interface CanvasPlayerControls {
@@ -238,31 +185,19 @@ export function useCanvasPlayer(
     stroke?: boolean
     shadow?: boolean
   },
-  onError?: (error: Error) => void,
-  enabled: boolean = true,
 ) {
   const [state, setState] = useState<CanvasPlayerState>({
-    hasSupport: enabled && isWebCodecsSupported(),
+    hasSupport: isWebCodecsSupported(),
     isPlaying: false,
     currentTime: 0,
     duration: 0,
     isReady: false,
     isBuffering: false,
-    hasDecodeError: false,
-    errorMessage: "",
   })
 
   // ── 内部引用 ──
   const decoderRef = useRef<VideoDecoder | null>(null)
-  const frameQueueRef = useRef(new FrameQueue(200))
-  /** 每个片段持久化解码器，避免每次新建导致关键帧错误 */
-  const segmentDecodersRef = useRef(new Map<number, VideoDecoder>())
-  /** 每个片段已送入解码器的 sample 游标（用于续解码） */
-  const segmentSampleCursorRef = useRef(new Map<number, number>())
-  /** 后台补充解码是否正在运行（防重入） */
-  const isFeedingRef = useRef(false)
-  /** 解码代数计数器，seek 时递增以作废正在进行的异步解码 */
-  const decodeGenerationRef = useRef(0)
+  const frameQueueRef = useRef(new FrameQueue(10))
   const rafRef = useRef<number>(0)
   const playStartRef = useRef<number>(0)
   const playStartOffsetRef = useRef<number>(0)
@@ -271,8 +206,7 @@ export function useCanvasPlayer(
   const videoDimRef = useRef<{ width: number; height: number }>({ width: 0, height: 0 })
   const isDestroyedRef = useRef(false)
   const lastProgressUpdateRef = useRef<number>(0)
-  const onErrorRef = useRef(onError)
-  onErrorRef.current = onError
+  const descriptionCache = useRef<Map<string, ArrayBuffer>>(new Map())
 
   // 计算总时长
   const totalDuration = segments.reduce((sum, seg) => sum + (seg.endTime - seg.startTime), 0)
@@ -312,15 +246,7 @@ export function useCanvasPlayer(
           view.getUint8(offset + 7),
         )
         if (type === "moov") {
-          const result = findCodecConfigRecursive(buffer, offset + 8, offset + size)
-          console.log("[useCanvasPlayer] extractCodecDescription:", {
-            moovOffset: offset,
-            moovSize: size,
-            searchRange: [offset + 8, offset + size],
-            found: !!result,
-            resultByteLength: result?.byteLength,
-          })
-          return result
+          return findCodecConfig(buffer, offset + 8, offset + size)
         }
         if (size === 0) break
         offset += size
@@ -386,7 +312,15 @@ export function useCanvasPlayer(
           }
 
           // 提取编解码器配置数据（HEVC 必需，H.264 也需要）
-          const description = extractCodecDescription(buffer)
+          let description = extractCodecDescription(buffer)
+
+          // 如果当前分片没有 description，尝试从缓存获取
+          if (!description) {
+            for (const cached of descriptionCache.current.values()) {
+              description = cached
+              break
+            }
+          }
 
           // ✅ 如果 description 缺失，无法解码 HEVC
           if (!description) {
@@ -399,6 +333,9 @@ export function useCanvasPlayer(
             return
           }
 
+          // 缓存 description 供后续分片使用
+          descriptionCache.current.set(segment.assetId, description)
+
           meta = {
             assetId: segment.assetId,
             videoUrl: segment.videoUrl,
@@ -406,7 +343,7 @@ export function useCanvasPlayer(
             globalEndTime: globalStart + (segment.endTime - segment.startTime),
             trackId: videoTrack.id ?? 1,
             timescale: videoTrack.timescale ?? 90000,
-            codec: normalizeCodecString(videoTrack.codec ?? "avc1.42E01E"),
+            codec: videoTrack.codec ?? "avc1.42E01E",
             videoWidth: videoTrack.track_width || 1280,
             videoHeight: videoTrack.track_height || 720,
             description,
@@ -490,92 +427,71 @@ export function useCanvasPlayer(
     [segments, extractCodecDescription],
   )
 
-  // ── 解码片段的一批帧（使用持久化解码器，支持从断点续解码） ──
-  /**
-   * @param segIdx 片段索引
-   * @param maxFrames 本次最多解码多少帧
-   */
-  const decodeSegmentBatch = useCallback(
-    async (segIdx: number, maxFrames: number = 60): Promise<number> => {
-      if (isDestroyedRef.current) return 0
-      const metas = segmentMetaRef.current
-      const meta = metas[segIdx]
-      if (!meta) return 0
-      const buffer = segmentDataRef.current.get(meta.assetId)
-      if (!buffer) return 0
+  // ── 初始化 VideoDecoder 并解码指定片段 ──
+  const decodeSegment = useCallback(
+    async (_buffer: ArrayBuffer, meta: SegmentMeta): Promise<void> => {
+      if (isDestroyedRef.current) return
 
-      const gen = decodeGenerationRef.current
-      let decoder = segmentDecodersRef.current.get(segIdx)
-      let cursor = segmentSampleCursorRef.current.get(segIdx) ?? 0
-      const samples = meta.samples
+      let decoderReady = false
 
-      // 如果还没有解码器，新建一个（从关键帧开始，不会报 key frame 错误）
-      if (!decoder || decoder.state === "closed") {
-        decoder = new VideoDecoder({
-          output: (frame: VideoFrame) => {
-            if (videoDimRef.current.width === 0 || videoDimRef.current.height === 0) {
-              videoDimRef.current = { width: frame.codedWidth, height: frame.codedHeight }
-            }
-            const localTime = frame.timestamp / 1_000_000
-            const globalTime = localTime + meta.globalStartTime
-            frameQueueRef.current.push({
-              frame,
-              pts: globalTime,
-              duration: (frame.duration ?? 0) / 1_000_000,
-            })
-          },
-          error: (e: DOMException) => {
-            console.error(`[useCanvasPlayer] Segment ${segIdx} decoder error:`, e)
-            // 重置该片段的解码器和游标，允许重试
-            segmentDecodersRef.current.delete(segIdx)
-            segmentSampleCursorRef.current.set(segIdx, 0)
-          },
-        })
-
-        try {
-          await decoder.configure({
-            codec: meta.codec,
-            ...(meta.description ? { description: meta.description } : {}),
+      // 配置解码器（每个片段可能需要不同的 codec/分辨率）
+      const decoder = new VideoDecoder({
+        output: (frame: VideoFrame) => {
+          const localTime = frame.timestamp / 1_000_000
+          const globalTime = localTime + meta.globalStartTime
+          frameQueueRef.current.push({
+            frame,
+            pts: globalTime,
+            duration: (frame.duration ?? 0) / 1_000_000,
           })
-        } catch (err) {
-          console.error(`[useCanvasPlayer] Segment ${segIdx} configure failed:`, err)
-          const error = err instanceof Error ? err : new Error(String(err))
-          setState((s) => ({
-            ...s,
-            isBuffering: false,
-            hasDecodeError: true,
-            errorMessage: `视频解码失败: ${error.message || "不支持的编解码器"}`,
-          }))
-          onErrorRef.current?.(error)
-          return 0
-        }
+        },
+        error: (e: DOMException) => {
+          console.error("[useCanvasPlayer] Decoder error:", e)
+        },
+      })
 
-        segmentDecodersRef.current.set(segIdx, decoder)
-        cursor = 0
-        // 标记缓冲结束
-        setState((s) => ({ ...s, isBuffering: false }))
+      console.log("[useCanvasPlayer] configure:", {
+        codec: meta.codec,
+        description: meta.description,
+        descriptionByteLength: meta.description?.byteLength,
+        videoWidth: meta.videoWidth,
+        videoHeight: meta.videoHeight,
+      })
+
+      try {
+        await decoder.configure({
+          codec: meta.codec,
+          codedWidth: meta.videoWidth,
+          codedHeight: meta.videoHeight,
+          ...(meta.description ? { description: meta.description } : {}),
+        })
+        decoderRef.current = decoder
+        decoderReady = true
+
+        // 更新视频尺寸（用于 aspect ratio）
+        if (meta.videoWidth > 0 && meta.videoHeight > 0) {
+          videoDimRef.current = { width: meta.videoWidth, height: meta.videoHeight }
+        }
+      } catch (err) {
+        console.error("[useCanvasPlayer] Decoder configure failed for segment:", err)
+        return
       }
 
-      if (decoder.state !== "configured") return 0
+      if (!decoderReady) return
 
-      // 从 cursor 继续喂 sample（流水线批量提交，不 await 单个 decode）
-      let decoded = 0
-      let si = cursor
-      while (si < samples.length && decoded < maxFrames) {
-        if (decodeGenerationRef.current !== gen || isDestroyedRef.current) break
-        if ((decoder.state as string) === "closed") break
-        // 帧队列快满时停止提交（这才是真正的背压）
-        if (frameQueueRef.current.size >= 180) break
-        // 解码器内部队列积压过多时短暂让出线程（阈值64，给硬件足够流水线深度）
-        if (decoder.decodeQueueSize > 64) {
-          await new Promise((r) => setTimeout(r, 5))
-          continue
-        }
+      // 使用 demuxSegment 中已提取并过滤的 samples（前端切片）
+      const samplesCollected = meta.samples
+      if (samplesCollected.length === 0) {
+        console.warn("[useCanvasPlayer] No samples to decode for segment", meta.assetId)
+        return
+      }
+
+      // 送入解码器
+      for (const sample of samplesCollected) {
+        if (!sample.data || isDestroyedRef.current) continue
+        if (decoder.state === "closed") break
 
-        const sample = samples[si]
-        si++
         if (!sample.data) continue
-
         const chunk = new EncodedVideoChunk({
           type: sample.is_sync ? "key" : "delta",
           timestamp: ((sample.cts ?? 0) / (meta.timescale || 90000)) * 1_000_000,
@@ -585,74 +501,21 @@ export function useCanvasPlayer(
 
         try {
           decoder.decode(chunk)
-          decoded++
         } catch (e) {
-          console.warn(`[useCanvasPlayer] Segment ${segIdx} decode error:`, e)
-          break
+          console.warn("[useCanvasPlayer] Decode chunk error:", e)
         }
       }
 
-      cursor = si
-      segmentSampleCursorRef.current.set(segIdx, cursor)
-      // 等待解码器输出帧（最多500ms）
-      if (decoded > 0 && (decoder.state as string) === "configured") {
-        let waited = 0
-        while (frameQueueRef.current.size < Math.min(decoded, 10) && waited < 500) {
-          await new Promise((r) => setTimeout(r, 20))
-          waited += 20
-          if (isDestroyedRef.current) break
-        }
+      // flush 确保所有帧输出
+      try {
+        await decoder.flush()
+      } catch (e) {
+        console.warn("[useCanvasPlayer] Decoder flush error:", e)
       }
-      console.log(
-        `[useCanvasPlayer] Segment ${segIdx} decoded ${decoded} frames, queue size: ${frameQueueRef.current.size}`,
-      )
-      return decoded
     },
     [],
   )
 
-  // ── 后台持续补充帧 ──
-  /**
-   * 根据当前播放时间，确保队列中有足够缓冲
-   * 播放循环每 200ms 调用一次
-   */
-  const feedFrames = useCallback(
-    async (currentTime: number) => {
-      if (isFeedingRef.current) return
-      isFeedingRef.current = true
-      try {
-        const metas = segmentMetaRef.current
-        if (!metas || metas.length === 0) return
-
-        // 队列帧数充足时不解码（目标：保持 >= 80 帧缓冲）
-        if (frameQueueRef.current.size >= 80) return
-
-        // 找到当前播放的片段
-        let targetIdx = 0
-        let acc = 0
-        for (let i = 0; i < metas.length; i++) {
-          const dur = metas[i].globalEndTime - metas[i].globalStartTime
-          if (currentTime < acc + dur) {
-            targetIdx = i
-            break
-          }
-          acc += dur
-        }
-
-        // 依次补充：当前片段 → 下一个片段 → 再下一个
-        for (let offset = 0; offset <= 2; offset++) {
-          const idx = targetIdx + offset
-          if (idx >= metas.length) break
-          if (frameQueueRef.current.size >= 180) break
-          await decodeSegmentBatch(idx, 60)
-        }
-      } finally {
-        isFeedingRef.current = false
-      }
-    },
-    [decodeSegmentBatch],
-  )
-
   // ── 标题绘制 ──
   const drawTitle = useCallback(
     (
@@ -667,6 +530,7 @@ export function useCanvasPlayer(
 
       // 按 "/" 分割为多行（"/" 作为手动换行符）
       const lines = title.text.split(/[/／⁄∕]/)
+      console.log("[drawTitle] 原始标题:", JSON.stringify(title.text), "分割后:", lines)
       const lineHeight = fontSize * 1.3
       const totalHeight = lines.length * lineHeight
 
@@ -753,8 +617,6 @@ export function useCanvasPlayer(
     const elapsed = (performance.now() - playStartRef.current) / 1000
     const currentTime = Math.min(playStartOffsetRef.current + elapsed, totalDuration)
 
-    // getCurrentFrame 返回 FrameQueue 内部引用，帧生命周期由 FrameQueue 管理
-    // （push 淘汰旧帧时 close、clear 时全部 close），渲染层不应 close
     const frame = frameQueueRef.current.getCurrentFrame(currentTime)
 
     ctx.clearRect(0, 0, canvas.width, canvas.height)
@@ -778,10 +640,6 @@ export function useCanvasPlayer(
         }
         return s
       })
-      // 后台补充帧：队列不足时自动续解码
-      if (frameQueueRef.current.size < 80) {
-        void feedFrames(currentTime)
-      }
     }
 
     if (currentTime >= totalDuration) {
@@ -790,46 +648,18 @@ export function useCanvasPlayer(
     }
 
     rafRef.current = requestAnimationFrame(renderFrame)
-  }, [canvasRef, totalDuration, titleSettings, drawTitle, computeDrawRect, feedFrames])
+  }, [canvasRef, totalDuration, titleSettings, drawTitle, computeDrawRect])
 
   // ── 播放控制 ──
   const play = useCallback(async () => {
     if (!state.hasSupport || isDestroyedRef.current) return
 
-    // 重播：必须关闭旧解码器、清空队列、重置游标，从头重新解码
-    if (state.currentTime >= totalDuration - 0.1 || state.currentTime <= 0.1) {
-      decodeGenerationRef.current++
-      // 关闭所有持久化解码器
-      for (const d of segmentDecodersRef.current.values()) {
-        try {
-          if (d.state !== "closed") d.close()
-        } catch {
-          /* noop */
-        }
-      }
-      segmentDecodersRef.current.clear()
-      segmentSampleCursorRef.current.clear()
-      frameQueueRef.current.clear()
-      playStartOffsetRef.current = 0
-      setState((s) => ({ ...s, currentTime: 0 }))
-      // 重新初始化解码
-      const metas = segmentMetaRef.current
-      const initialDecodeCount = Math.min(metas.length, 2)
-      for (let i = 0; i < initialDecodeCount; i++) {
-        await decodeSegmentBatch(i, 60)
-      }
-    }
-
     setState((s) => ({ ...s, isPlaying: true }))
     playStartRef.current = performance.now()
-    if (state.currentTime < 0.1) {
-      playStartOffsetRef.current = 0
-    } else {
-      playStartOffsetRef.current = state.currentTime
-    }
+    playStartOffsetRef.current = state.currentTime
     lastProgressUpdateRef.current = 0
     rafRef.current = requestAnimationFrame(renderFrame)
-  }, [state.hasSupport, state.currentTime, totalDuration, renderFrame, decodeSegmentBatch])
+  }, [state.hasSupport, state.currentTime, renderFrame])
 
   const pause = useCallback(() => {
     setState((s) => ({ ...s, isPlaying: false }))
@@ -837,56 +667,21 @@ export function useCanvasPlayer(
   }, [])
 
   const seek = useCallback(
-    async (time: number) => {
+    (time: number) => {
       const clampedTime = Math.max(0, Math.min(time, totalDuration))
-      decodeGenerationRef.current++
-      // 关闭所有解码器、清空队列、重置游标
-      for (const d of segmentDecodersRef.current.values()) {
-        try {
-          if (d.state !== "closed") d.close()
-        } catch {
-          /* noop */
-        }
-      }
-      segmentDecodersRef.current.clear()
-      segmentSampleCursorRef.current.clear()
-      frameQueueRef.current.clear()
       setState((s) => ({ ...s, currentTime: clampedTime }))
       playStartOffsetRef.current = clampedTime
       playStartRef.current = performance.now()
-      // 找到 seek 目标片段，从该片段开始解码
-      const metas = segmentMetaRef.current
-      let targetIdx = 0,
-        acc = 0
-      for (let i = 0; i < metas.length; i++) {
-        const dur = metas[i].globalEndTime - metas[i].globalStartTime
-        if (clampedTime < acc + dur) {
-          targetIdx = i
-          break
-        }
-        acc += dur
-      }
-      await decodeSegmentBatch(targetIdx, 60)
-      await decodeSegmentBatch(Math.min(targetIdx + 1, metas.length - 1), 60)
+      // seek 后清空帧队列，等待新帧解码
+      frameQueueRef.current.clear()
     },
-    [totalDuration, decodeSegmentBatch],
+    [totalDuration],
   )
 
   const destroy = useCallback(() => {
     isDestroyedRef.current = true
     cancelAnimationFrame(rafRef.current)
 
-    // 关闭所有持久化解码器
-    for (const d of segmentDecodersRef.current.values()) {
-      try {
-        if (d.state !== "closed") d.close()
-      } catch {
-        /* noop */
-      }
-    }
-    segmentDecodersRef.current.clear()
-    segmentSampleCursorRef.current.clear()
-
     if (decoderRef.current && decoderRef.current.state !== "closed") {
       decoderRef.current.close()
     }
@@ -894,6 +689,7 @@ export function useCanvasPlayer(
     frameQueueRef.current.clear()
     segmentDataRef.current.clear()
     segmentMetaRef.current = []
+    descriptionCache.current.clear()
   }, [])
 
   // ── 预加载下一个片段的数据 ──
@@ -910,120 +706,53 @@ export function useCanvasPlayer(
 
   // ── 初始化：加载并解码所有片段 ──
   useEffect(() => {
-    if (!enabled) return
-    if (!state.hasSupport || segments.length === 0) {
-      console.log("[useCanvasPlayer] Skip init:", {
-        hasSupport: state.hasSupport,
-        segmentCount: segments.length,
-      })
-      return
-    }
-
-    let cancelled = false
+    if (!state.hasSupport || segments.length === 0) return
 
     const init = async () => {
-      // ✅ 关键修复：重置销毁标记，允许新的 init 周期正常工作
-      // destroy() 在 useEffect cleanup 中被调用，将 isDestroyedRef 设为 true
-      // 如果不重置，后续的 loadSegment / decodeSegment 会立即 return
-      isDestroyedRef.current = false
-      // ✅ Strict Mode 修复：init 不再递增 generation
-      // seek() 和 play() 仍保留 generation 递增用于中止异步解码
-      // 重置错误状态，避免上一轮的解码错误影响新的 init 周期
-      setState((s) => ({
-        ...s,
-        isBuffering: true,
-        hasDecodeError: false,
-        errorMessage: "",
-        isReady: false,
-      }))
-
-      console.log("[useCanvasPlayer] Init start v2_DIAG, segments:", segments.length)
+      setState((s) => ({ ...s, isBuffering: true }))
 
       // 1. 加载所有片段数据
       for (const seg of segments) {
         await loadSegment(seg)
-        if (cancelled) {
-          console.log("[useCanvasPlayer] Cancelled during loadSegment")
-          return
-        }
       }
 
-      // 验证 buffer 是否都已存入
-      const bufferCheck = segments.map((s) => ({
-        assetId: s.assetId,
-        hasBuffer: segmentDataRef.current.has(s.assetId),
-      }))
-      console.log("[useCanvasPlayer] Buffers loaded:", bufferCheck)
+      if (isDestroyedRef.current) return
 
       // 2. 解析每个片段的轨道元数据（await 等待 onSamples 回调完成）
       const metas: SegmentMeta[] = []
       for (let i = 0; i < segments.length; i++) {
         const buffer = segmentDataRef.current.get(segments[i].assetId)
-        if (!buffer) {
-          console.warn("[useCanvasPlayer] No buffer for segment", i, segments[i].assetId)
-          continue
-        }
+        if (!buffer) continue
         const meta = await demuxSegment(buffer, i)
-        if (cancelled) {
-          console.log("[useCanvasPlayer] Cancelled during demuxSegment")
-          return
-        }
         if (meta) metas.push(meta)
       }
 
-      if (cancelled || metas.length === 0) {
-        console.warn("[useCanvasPlayer] Init failed:", { cancelled, metasCount: metas.length })
+      if (isDestroyedRef.current || metas.length === 0) {
         setState((s) => ({ ...s, isBuffering: false }))
         return
       }
 
       segmentMetaRef.current = metas
 
-      // 3. 初始化解码：关闭旧解码器，前 2 个片段各解 60 帧
-      //    后续由 feedFrames 后台补充
-      for (const d of segmentDecodersRef.current.values()) {
-        try {
-          if (d.state !== "closed") d.close()
-        } catch {
-          /* noop */
-        }
-      }
-      segmentDecodersRef.current.clear()
-      segmentSampleCursorRef.current.clear()
-      frameQueueRef.current.clear()
-
-      const initGen = decodeGenerationRef.current
-      const initialDecodeCount = Math.min(metas.length, 2)
-      console.log(
-        `[useCanvasPlayer] Starting init decode: ${initialDecodeCount} segments, metas: ${metas.length}`,
-      )
-      for (let i = 0; i < initialDecodeCount; i++) {
-        if (cancelled) break
-        if (decodeGenerationRef.current !== initGen) break
-        console.log(`[DIAG_v2] Init decode segment ${i}...`)
-        try {
-          await decodeSegmentBatch(i, 60)
-          console.log(`[DIAG_v2] Init decode segment ${i} done`)
-        } catch (e) {
-          console.warn(`[useCanvasPlayer] 初始化解码片段 ${i} 失败:`, e)
-        }
-        if (cancelled) break
+      // 3. 设置视频尺寸（用第一个片段的尺寸）
+      if (metas[0].videoWidth > 0 && metas[0].videoHeight > 0) {
+        videoDimRef.current = { width: metas[0].videoWidth, height: metas[0].videoHeight }
       }
 
-      console.log(`[useCanvasPlayer] Init decode finished, cancelled:`, cancelled)
-
-      if (!cancelled) {
-        console.log("[useCanvasPlayer] Init complete, isReady = true, duration:", totalDuration)
-        setState((s) => ({ ...s, duration: totalDuration, isReady: true, isBuffering: false }))
-      } else {
-        console.warn("[useCanvasPlayer] Init was cancelled before completion")
+      // 4. 依次解码每个片段
+      for (const meta of metas) {
+        const buffer = segmentDataRef.current.get(meta.assetId)
+        if (!buffer) continue
+        await decodeSegment(buffer, meta)
+        if (isDestroyedRef.current) break
       }
+
+      setState((s) => ({ ...s, duration: totalDuration, isReady: true, isBuffering: false }))
     }
 
     init()
 
     return () => {
-      cancelled = true
       destroy()
     }
     // eslint-disable-next-line react-hooks/exhaustive-deps

apps/web/src/pages/generate/hooks/useDraftAutoSave.ts

@@ -1,124 +0,0 @@
-/**
- * 草稿自动保存工具 Hook
- *
- * 背景：后端 PUT /templates/{id}/editor 的 config 是「整体替换」语义，
- * 直接发送 { config: { asset_ids } } 会把 title 等其他字段覆盖掉。
- * 本 Hook 统一执行「GET 当前 config → 浅合并新字段 → PUT 回去」，
- * 并用串行队列 + AbortController 保证：
- *   - 同一时刻只有一个保存请求在飞
- *   - 快速连续变化时只提交最后一次
- *   - 组件卸载时取消未完成请求
- *   - 保存失败时保留补丁，自动重试（指数退避，最多 5 次）
- *
- * 保存失败只 console.warn，不弹窗、不阻塞。
- */
-import { useCallback, useEffect, useRef } from "react"
-import { getEditPlan, updateEditPlan } from "@/api/template-editor"
-
-type ConfigPatch = Record<string, unknown>
-
-/** 最大自动重试次数 */
-const MAX_RETRIES = 5
-/** 初始重试延迟（ms），每次翻倍 */
-const BASE_RETRY_DELAY = 1000
-
-export function useDraftAutoSave(templateId?: string) {
-  const timerRef = useRef<ReturnType<typeof setTimeout>>()
-  const abortRef = useRef<AbortController | null>(null)
-  // 待合并的补丁队列（解决「保存进行中又来了新变化」）
-  const pendingPatchRef = useRef<ConfigPatch | null>(null)
-  const savingRef = useRef(false)
-  const templateIdRef = useRef(templateId)
-  templateIdRef.current = templateId
-
-  const flush = useCallback(async (retryCount = 0) => {
-    const tid = templateIdRef.current
-    if (!tid) return
-    // 已有保存在飞：把新补丁暂存，等当前请求结束后再合并一次
-    if (savingRef.current) return
-
-    // 快照当前补丁，但先不清空 —— 成功后才清除，失败时保留以便重试
-    const patchToSave = pendingPatchRef.current
-    if (!patchToSave) {
-      savingRef.current = false
-      return
-    }
-    savingRef.current = true
-
-    const controller = new AbortController()
-    abortRef.current = controller
-    try {
-      // 1. 读当前 config（拿最新，避免覆盖别人/别的步骤写入的字段）
-      const current = await getEditPlan(tid)
-      if (controller.signal.aborted) return
-      const merged = { ...(current.config || {}), ...patchToSave }
-      // 2. 写回完整合并后的 config
-      await updateEditPlan(tid, { config: merged }, controller.signal)
-      // 3. 保存成功才清除已保存的补丁
-      //    （保存期间可能有新补丁进来，只清除我们已经保存的部分）
-      pendingPatchRef.current = null
-    } catch (err) {
-      const name = (err as { name?: string })?.name
-      if (name === "CanceledError" || name === "AbortError") {
-        // 组件卸载或新请求取消，不重试
-        return
-      }
-      console.warn("[useDraftAutoSave] 自动保存草稿失败:", err)
-
-      // 保存失败：把本次尝试保存的补丁合并回 pendingPatchRef
-      // （保存期间可能有新补丁，新补丁优先）
-      pendingPatchRef.current = {
-        ...patchToSave,
-        ...(pendingPatchRef.current || {}),
-      }
-
-      // 指数退避重试
-      if (retryCount < MAX_RETRIES && !controller.signal.aborted) {
-        const delay = BASE_RETRY_DELAY * Math.pow(2, retryCount)
-        timerRef.current = setTimeout(() => {
-          void flush(retryCount + 1)
-        }, delay)
-      }
-      // 超过最大重试次数后，补丁仍保留在 pendingPatchRef 中，
-      // 下次 scheduleSave 触发时会一起带上
-    } finally {
-      savingRef.current = false
-      // 保存期间又积累了新变化（且不是在重试路径中），再触发一次
-      if (pendingPatchRef.current && !controller.signal.aborted && retryCount === 0) {
-        timerRef.current = setTimeout(() => {
-          void flush()
-        }, 50)
-      }
-    }
-  }, [])
-
-  /**
-   * 调度一次自动保存（防抖）
-   * @param patch 要合并进 config 的局部字段
-   * @param delay 防抖毫秒数
-   */
-  const scheduleSave = useCallback(
-    (patch: ConfigPatch, delay = 500) => {
-      const tid = templateIdRef.current
-      if (!tid) return
-      if (timerRef.current) clearTimeout(timerRef.current)
-      // 累计补丁（同一周期内多次变化合并成一次写入）
-      pendingPatchRef.current = { ...(pendingPatchRef.current || {}), ...patch }
-      timerRef.current = setTimeout(() => {
-        void flush()
-      }, delay)
-    },
-    [flush],
-  )
-
-  useEffect(() => {
-    return () => {
-      if (timerRef.current) clearTimeout(timerRef.current)
-      if (abortRef.current) abortRef.current.abort()
-    }
-  }, [])
-
-  return { scheduleSave }
-}
-
-export default useDraftAutoSave

apps/web/src/pages/generate/hooks/useGenerateFormState/index.ts

@@ -14,7 +14,6 @@ import { useTemplateSelection } from "./useTemplateSelection"
 import { useTitleCoverSync } from "./useTitleCoverSync"
 import { useVoiceState } from "./useVoiceState"
 import { usePlanConfigLoader } from "./usePlanConfigLoader"
-import { usePersistedState } from "../usePersistedState"
 
 const DEFAULT_TITLE_SETTINGS: TitleSettings = {
   aiAutoSelect: false,
@@ -83,27 +82,11 @@ export interface GenerateFormState {
   editPlanId: string | null
   planConfigStr: string | null
 
-  /**
-   * 传给 Worker 的 source_edit_plan_id。
-   * 仅使用 URL 中的 edit_plan_id（从剪辑模板编辑器跳转时携带）。
-   * URL 没有时传 null，后端正式生成 API 会通过 template_id+user_id 兜底查找正确的 plan。
-   * 注意：selectedTemplate 是模板 ID，不是 edit_plan_id，不能作为此值传递。
-   */
-  sourceEditPlanId: string | null
-
   /* 预览弹窗 */
   previewVideo: GeneratedVideo | null
   setPreviewVideo: (v: GeneratedVideo | null) => void
   previewModalOpen: boolean
   setPreviewModalOpen: (open: boolean) => void
-
-  /** 预览任务 ID（由 useStep6Cover 创建后写入，供 useGenerateVideo 复用） */
-  previewTaskId: string | null
-  setPreviewTaskId: (id: string | null) => void
-
-  /** 从预览响应中提取的 source_edit_plan_id（供 fallback 路径使用） */
-  storedSourceEditPlanId: string | null
-  setStoredSourceEditPlanId: (planId: string | null) => void
 }
 
 export const useGenerateFormState = (): GenerateFormState => {
@@ -117,11 +100,6 @@ export const useGenerateFormState = (): GenerateFormState => {
   /* ── 模板选择 ── */
   const { selectedTemplate, setSelectedTemplate, userTemplates } = useTemplateSelection()
 
-  /* ── source_edit_plan_id：仅取 URL 参数，无则 null 让后端兜底 ── */
-  // selectedTemplate 是模板 ID 而非 edit_plan_id，不能混淆；
-  // 后端正式生成 API 会在 source_edit_plan_id 为空时通过 template_id+user_id 自动关联。
-  const sourceEditPlanId = editPlanId || null
-
   /* ── 素材 ── */
   const [selectedMaterials, setSelectedMaterials] = useState<string[]>([])
   const [materialMode, setMaterialMode] = useState<"manual" | "auto">("manual")
@@ -169,30 +147,6 @@ export const useGenerateFormState = (): GenerateFormState => {
   const [previewVideo, setPreviewVideo] = useState<GeneratedVideo | null>(null)
   const [previewModalOpen, setPreviewModalOpen] = useState(false)
 
-  /* ── 预览任务 ID（useStep6Cover 创建预览时写入，useGenerateVideo 复用） ── */
-  // 持久化到 localStorage，key 按 editPlanId/templateId 区分，刷新页面后可恢复
-  const previewStorageKey = editPlanId
-    ? `preview_task_id_${editPlanId}`
-    : selectedTemplate
-      ? `preview_task_id_tpl_${selectedTemplate}`
-      : null
-  const [previewTaskId, setPreviewTaskId] = usePersistedState<string | null>(
-    previewStorageKey,
-    null,
-  )
-
-  /* ── 从预览响应中提取的 source_edit_plan_id（供 fallback 路径使用） ── */
-  // 持久化到 localStorage，刷新页面后 fallback 路径仍能正确传递 source_edit_plan_id
-  const planIdStorageKey = editPlanId
-    ? `source_edit_plan_id_${editPlanId}`
-    : selectedTemplate
-      ? `source_edit_plan_id_tpl_${selectedTemplate}`
-      : null
-  const [storedSourceEditPlanId, setStoredSourceEditPlanId] = usePersistedState<string | null>(
-    planIdStorageKey,
-    null,
-  )
-
   /* ── 从 URL / 编辑计划加载配置 ── */
   usePlanConfigLoader({
     editPlanId,
@@ -235,15 +189,10 @@ export const useGenerateFormState = (): GenerateFormState => {
     autoSubtitles,
     bgm,
     editPlanId,
-    sourceEditPlanId,
     planConfigStr,
     previewVideo,
     setPreviewVideo,
     previewModalOpen,
     setPreviewModalOpen,
-    previewTaskId,
-    setPreviewTaskId,
-    storedSourceEditPlanId,
-    setStoredSourceEditPlanId,
   }
 }

apps/web/src/pages/generate/hooks/useGenerateVideo.ts

@@ -5,8 +5,7 @@
 import { useState, useCallback } from "react"
 import { message } from "antd"
 import type { GeneratedVideo } from "@/api/template-editor"
-import { createGenerationTask } from "@/api/tasks/tasks"
-import { confirmGeneration } from "@/api/generation/confirm"
+import { confirmGeneration, createPreview } from "@/api/generation"
 import type { UseGenerateVideoProps } from "./generate-video/types"
 import { getGenerationPhase } from "./generate-video/phase"
 import { useGenerationPolling } from "./generate-video/useGenerationPolling"
@@ -14,7 +13,7 @@ import { validateGenerateInputs } from "./generate-video/buildPayload"
 import { extractBackendError, translateError } from "./generate-video/errorUtils"
 
 export function useGenerateVideo(props: UseGenerateVideoProps) {
-  const { selectedTemplate, onGenerationSuccess } = props
+  const { selectedTemplate } = props
 
   /* ── 生成状态 ── */
   const [generating, setGenerating] = useState(false)
@@ -24,22 +23,18 @@ export function useGenerateVideo(props: UseGenerateVideoProps) {
   const [generatedVideos, setGeneratedVideos] = useState<GeneratedVideo[]>([])
 
   const handleProgress = useCallback((p: number) => setProgress(p), [])
-  const handleComplete = useCallback(
-    (videos: unknown[]) => {
-      setGenerating(false)
-      setGenerated(true)
-      setGeneratedVideos(videos as GeneratedVideo[])
-      // 生成成功后清除持久化的预览状态，避免下次进入复用旧任务
-      onGenerationSuccess?.()
-    },
-    [onGenerationSuccess],
-  )
+  const handleComplete = useCallback((videos: unknown[]) => {
+    setGenerating(false)
+    setGenerated(true)
+    setGeneratedVideos(videos as GeneratedVideo[])
+  }, [])
   const handleFailed = useCallback((errorMsg: string) => {
     setGenerating(false)
     setGenerateError(errorMsg)
   }, [])
 
   const { startPolling, clearTimer } = useGenerationPolling({
+    templateId: selectedTemplate,
     onProgress: handleProgress,
     onComplete: handleComplete,
     onFailed: handleFailed,
@@ -60,7 +55,7 @@ export function useGenerateVideo(props: UseGenerateVideoProps) {
     clearTimer()
 
     try {
-      // 解析分辨率
+      // 解析分辨率：videoRatio 可能是 "9:16"（宽高比）或 "1080x1920"（分辨率）
       const ratio = props.videoRatio || "9:16"
       let outputWidth: number
       let outputHeight: number
@@ -92,89 +87,42 @@ export function useGenerateVideo(props: UseGenerateVideoProps) {
         outputHeight = 1920
       }
 
-      const assetIds =
-        props.materialMode === "auto" ? props.smartSelectedIds : props.selectedMaterials
-
-      // 封面 URL：优先 AI 生成缩略图，兜底用户上传
-      const coverUrl = props.coverSettings?.thumbnail_url || props.coverSettings?.upload_url || ""
-
-      // ── Step7 确认生成：优先复用预览产物（秒出），fallback 到全量渲染 ──
-      let taskId: string | undefined
-
-      // 主路径：如果有预览任务 ID 且只生成 1 个视频，调用 confirmGeneration 复用预览产物
-      // generateCount > 1 时需要走 createGenerationTask 支持批量生成
-      const isSingleGenerate = !props.generateCount || props.generateCount === 1
-      if (props.previewTaskId && isSingleGenerate) {
-        try {
-          console.log(
-            "[handleGenerate] 尝试 confirmGeneration 复用预览产物, previewTaskId:",
-            props.previewTaskId,
-          )
-          const confirmResp = await confirmGeneration(props.previewTaskId, {
-            output_width: outputWidth,
-            output_height: outputHeight,
-            cover_url: coverUrl,
-            custom_title: props.titleSettings?.title || "",
-          })
-          taskId = confirmResp.items?.[0]?.id
-          if (taskId) {
-            console.log("[handleGenerate] confirmGeneration 成功, taskId:", taskId)
-          }
-        } catch (confirmErr) {
-          console.warn(
-            "[handleGenerate] confirmGeneration 失败, fallback 到 createGenerationTask:",
-            confirmErr,
-          )
-          // 继续走 fallback 路径
-        }
-      }
-
-      // 解析配音参数：voiceMode=clone 时用 selectedClonedVoice，否则用 selectedVoice（配音素材库 asset ID）
-      const voiceLibraryId =
-        props.voiceMode === "clone" ? props.selectedClonedVoice || "" : props.selectedVoice || ""
-
-      // Fallback 路径：没有预览任务或 confirmGeneration 失败，创建新的生成任务
+      // 获取或创建后端任务 ID
+      // 预览改为前端播放后，不再有预览任务，需要在此处创建
+      let taskId = props.previewTaskId
       if (!taskId) {
-        const taskResp = await createGenerationTask({
+        const assetIds =
+          props.materialMode === "auto" ? props.smartSelectedIds : props.selectedMaterials
+        const previewResp = await createPreview({
           template_id: selectedTemplate,
           asset_ids: assetIds,
-          output_width: outputWidth,
-          output_height: outputHeight,
-          cover_url: coverUrl,
-          custom_title: props.titleSettings?.title || "",
           duration: props.duration || undefined,
           video_ratio: props.videoRatio,
-          // 配音：优先用 voice_library_id（配音素材库 asset），兜底 voice_ids
-          ...(voiceLibraryId ? { voice_library_id: voiceLibraryId } : {}),
-          ...(props.selectedVoice && !voiceLibraryId ? { voice_ids: [props.selectedVoice] } : {}),
-          // BGM 配置：受 bgm 开关控制，enabled=false 时也显式传覆盖模板 BGM
-          bgm_config: {
-            enabled: props.bgm !== false,
-            ...(props.bgmConfig?.music_id ? { preset_id: props.bgmConfig.music_id } : {}),
-          },
-          ...(props.sourceEditPlanId ? { source_edit_plan_id: props.sourceEditPlanId } : {}),
-          ...(props.titleSettings?.title
+          voice_ids: undefined,
+          title_config: props.titleSettings?.title
             ? {
-                title_config: {
-                  text: props.titleSettings.title,
-                  font: props.titleSettings.font,
-                  font_size: props.titleSettings.size,
-                  font_color: props.titleSettings.color,
-                  position: props.titleSettings.position,
-                  bold: props.titleSettings.bold,
-                  stroke: props.titleSettings.stroke,
-                  shadow: props.titleSettings.shadow,
-                },
+                text: props.titleSettings.title,
+                font: props.titleSettings.font,
+                font_size: props.titleSettings.size,
+                font_color: props.titleSettings.color,
+                position: props.titleSettings.position,
+                bold: props.titleSettings.bold,
+                stroke: props.titleSettings.stroke,
+                shadow: props.titleSettings.shadow,
               }
-            : {}),
+            : undefined,
         })
-        taskId = taskResp.items?.[0]?.id
+        taskId = previewResp.task_id
       }
 
-      if (!taskId) {
-        throw new Error("创建任务成功但未返回任务 ID，请稍后在任务列表查看")
-      }
-      startPolling(taskId)
+      await confirmGeneration(taskId, {
+        output_width: outputWidth,
+        output_height: outputHeight,
+        cover_url: props.coverSettings.upload_url || "",
+        custom_title: props.titleSettings.title || "",
+      })
+
+      startPolling()
     } catch (err: unknown) {
       console.error("[handleGenerate] 生成失败:", err)
       setGenerating(false)

apps/web/src/pages/generate/hooks/usePersistedState.ts

@@ -1,63 +0,0 @@
-import { useState, useEffect, useCallback, useRef } from "react"
-
-/**
- * 持久化到 localStorage 的 state hook
- *
- * 用于在页面刷新后恢复 previewTaskId / sourceEditPlanId 等关键状态。
- * 当 localStorage 不可用（SSR、隐私模式等）时自动降级为普通 useState。
- * 当 key 变化时（例如切换模板），自动从新 key 重新读取并更新 state。
- */
-export function usePersistedState<T>(
-  key: string | null | undefined,
-  defaultValue: T,
-): [T, (value: T | ((prev: T) => T)) => void] {
-  const storageKey = key ? `xiaoxia_${key}` : null
-  // defaultValue 用 ref 持有，避免作为 useEffect 依赖导致频繁重跑
-  const defaultValueRef = useRef(defaultValue)
-  defaultValueRef.current = defaultValue
-
-  const readFromStorage = useCallback((k: string | null): T => {
-    if (!k) return defaultValueRef.current
-    try {
-      const stored = localStorage.getItem(k)
-      if (stored !== null) {
-        return JSON.parse(stored) as T
-      }
-    } catch (e) {
-      // localStorage 不可用或 JSON 解析失败，使用默认值
-      console.warn("[usePersistedState] 读取 localStorage 失败:", e)
-    }
-    return defaultValueRef.current
-  }, [])
-
-  const [state, setState] = useState<T>(() => readFromStorage(storageKey))
-
-  // key 变化时（如切换模板/草稿），从新 key 重新读取，避免状态与存储不同步
-  useEffect(() => {
-    setState(readFromStorage(storageKey))
-  }, [storageKey, readFromStorage])
-
-  const setPersistedState = useCallback(
-    (value: T | ((prev: T) => T)) => {
-      setState((prev) => {
-        const nextValue = typeof value === "function" ? (value as (prev: T) => T)(prev) : value
-        if (storageKey) {
-          try {
-            if (nextValue === null || nextValue === undefined || nextValue === "") {
-              localStorage.removeItem(storageKey)
-            } else {
-              localStorage.setItem(storageKey, JSON.stringify(nextValue))
-            }
-          } catch (e) {
-            // localStorage 写入失败（存储空间满/隐私模式），静默忽略
-            console.warn("[usePersistedState] 写入 localStorage 失败:", e)
-          }
-        }
-        return nextValue
-      })
-    },
-    [storageKey],
-  )
-
-  return [state, setPersistedState]
-}

apps/web/src/pages/generate/hooks/useSegmentScheduler.ts

@@ -1,37 +1,55 @@
 /**
- * 素材片段调度器 Hook（多 video 元素方案 v3）
- *
- * v3 修复：
- * - 所有动态状态存入 ref，tick 为稳定函数，彻底消除 RAF 闭包陷阱
- * - 片段切换时先启动下一个 video 再切可见性，消除冻屏间隔
- * - 进度更新 200ms 节流
+ * 素材片段调度器 Hook（多 video 元素方案 v2）
+ * 每个片段对应一个独立 <video> 元素，全部预加载，通过 display 切换实现无缝播放
+ * 替代单 video + 切 src 方案，消除片段切换延迟
  */
-
 import { useState, useRef, useCallback, useEffect, useMemo } from "react"
 
+/** 单个播放片段 */
 export interface PlaybackSegment {
+  /** 素材 ID */
   assetId: string
+  /** 素材视频 URL */
   videoUrl: string
+  /** 片段在素材中的入点（秒） */
   startTime: number
+  /** 片段在素材中的出点（秒） */
   endTime: number
+  /** 片段在时间线中的顺序 */
   order: number
 }
 
+/** 调度器返回 */
 export interface SegmentSchedulerState {
+  /** 是否正在播放 */
   isPlaying: boolean
+  /** 当前播放的全局时间（秒） */
   currentTime: number
+  /** 总时长（秒） */
   totalDuration: number
+  /** 当前片段索引 */
   currentSegmentIndex: number
+  /** 当前片段的本地播放时间 */
   segmentLocalTime: number
+  /** 是否已播完 */
   isEnded: boolean
+  /** 是否可以播放（至少有 1 个片段） */
   canPlay: boolean
+  /** 播放 */
   play: () => void
+  /** 暂停 */
   pause: () => void
+  /** 切换播放/暂停 */
   togglePlayPause: () => void
+  /** 跳转到全局时间 */
   seekTo: (time: number) => void
+  /** 每个片段对应的 video 元素 ref 数组 */
   videoRefs: React.MutableRefObject<(HTMLVideoElement | null)[]>
 }
 
+/**
+ * 根据全局时间定位对应的片段和本地时间
+ */
 function findSegmentAtTime(
   segments: PlaybackSegment[],
   globalTime: number,
@@ -48,6 +66,9 @@ function findSegmentAtTime(
   return { index: segments.length - 1, localTime: segments[segments.length - 1].endTime }
 }
 
+/**
+ * 计算每个片段的全局起始时间
+ */
 function buildTimeline(segments: PlaybackSegment[]): number[] {
   const starts: number[] = []
   let acc = 0
@@ -58,242 +79,224 @@ function buildTimeline(segments: PlaybackSegment[]): number[] {
   return starts
 }
 
+/**
+ * useSegmentScheduler — 多 video 元素版素材片段调度器
+ *
+ * 核心改变：
+ * - 每个片段对应一个独立 <video> 元素（由组件渲染，ref 传入）
+ * - 所有 video 在挂载时即设置 src + preload="auto"，浏览器自动预加载
+ * - 切换片段仅改 currentSegmentIndex + display，无需重新 load
+ * - 实现无缝切换，无加载延迟
+ */
 export function useSegmentScheduler(segments: PlaybackSegment[]): SegmentSchedulerState {
+  /** 每个片段对应的 video 元素 ref（由组件 JSX 渲染并绑定） */
   const videoRefs = useRef<(HTMLVideoElement | null)[]>([])
   const [isPlaying, setIsPlaying] = useState(false)
   const [currentTime, setCurrentTime] = useState(0)
   const [currentSegmentIndex, setCurrentSegmentIndex] = useState(0)
   const [isEnded, setIsEnded] = useState(false)
-  const rafRef = useRef(0)
+  const rafRef = useRef<number>(0)
   const isSeekingRef = useRef(false)
-  const lastTimeUpdateRef = useRef(0)
 
-  // 所有动态值存入 ref，tick 始终读取最新值，不依赖闭包
-  const segIdxRef = useRef(0)
-  const segmentsRef = useRef(segments)
-  const timelineStartsData = useMemo(() => buildTimeline(segments), [segments])
-  const totalDurationData = useMemo(
+  // 计算时间线
+  const timelineStarts = useMemo(() => buildTimeline(segments), [segments])
+  const totalDuration = useMemo(
     () => segments.reduce((sum, seg) => sum + (seg.endTime - seg.startTime), 0),
     [segments],
   )
-  const timelineStartsRef = useRef(timelineStartsData)
-  const totalDurationRef = useRef(totalDurationData)
-  const isPlayingRef = useRef(false)
-
-  segmentsRef.current = segments
-  timelineStartsRef.current = timelineStartsData
-  totalDurationRef.current = totalDurationData
 
   const canPlay = segments.length > 0
 
-  useEffect(() => {
-    segIdxRef.current = currentSegmentIndex
-  }, [currentSegmentIndex])
-
-  useEffect(() => {
-    isPlayingRef.current = isPlaying
-  }, [isPlaying])
-
-  const waitForReady = useCallback((video: HTMLVideoElement, timeout = 3000): Promise<void> => {
-    if (video.readyState >= 3) return Promise.resolve()
-    return new Promise((resolve) => {
-      const onCanPlay = () => {
-        video.removeEventListener("canplay", onCanPlay)
-        clearTimeout(timer)
-        resolve()
-      }
-      const timer = setTimeout(() => {
-        video.removeEventListener("canplay", onCanPlay)
-        resolve()
-      }, timeout)
-      video.addEventListener("canplay", onCanPlay)
-    })
-  }, [])
+  // 当前片段信息
+  const currentSegment = segments[currentSegmentIndex] || null
+  const segmentLocalTime = currentSegment
+    ? currentTime - (timelineStarts[currentSegmentIndex] || 0) + currentSegment.startTime
+    : 0
 
+  /**
+   * 切换到指定片段
+   * 不改变 src（video 已在 JSX 中设置），仅 seek + 等待可播
+   */
   const switchToSegment = useCallback(
-    async (index: number, seekToLocalTime?: number) => {
-      const segs = segmentsRef.current
-      const video = videoRefs.current[index]
-      if (!video || index >= segs.length) return
+    (index: number, seekToLocalTime?: number): Promise<void> => {
+      return new Promise((resolve) => {
+        // 暂停当前视频
+        const prevVideo = videoRefs.current[currentSegmentIndex]
+        if (prevVideo) prevVideo.pause()
 
-      const seg = segs[index]
-      const localTime = seekToLocalTime ?? seg.startTime
-      const oldIdx = segIdxRef.current
-      const oldVideo = videoRefs.current[oldIdx]
+        const video = videoRefs.current[index]
+        if (!video || index >= segments.length) {
+          resolve()
+          return
+        }
 
-      if (oldVideo && oldVideo !== video) oldVideo.pause()
+        const seg = segments[index]
+        const localTime = seekToLocalTime ?? seg.startTime
 
-      if (!video.src && seg.videoUrl) {
-        video.src = seg.videoUrl
-        video.load()
-      }
-
-      if (Math.abs(video.currentTime - localTime) > 0.05) {
+        // 设置播放位置
         video.currentTime = localTime
-      }
 
-      segIdxRef.current = index
-      setCurrentSegmentIndex(index)
+        // 如果已有足够帧数据，直接 resolve
+        if (video.readyState >= 2) {
+          setCurrentSegmentIndex(index)
+          resolve()
+          return
+        }
 
-      await waitForReady(video)
+        // 等待 canplay 事件
+        const onCanPlay = () => {
+          video.removeEventListener("canplay", onCanPlay)
+          clearTimeout(timeoutId)
+          setCurrentSegmentIndex(index)
+          resolve()
+        }
+
+        // 10 秒超时保护
+        const timeoutId = setTimeout(() => {
+          video.removeEventListener("canplay", onCanPlay)
+          console.warn(
+            `[useSegmentScheduler] 片段 ${index} 预加载超时 (10s), readyState=${video.readyState}`,
+          )
+          setCurrentSegmentIndex(index)
+          resolve()
+        }, 10000)
+
+        video.addEventListener("canplay", onCanPlay)
+      })
     },
-    [waitForReady],
+    [segments, currentSegmentIndex],
   )
 
-  // 稳定的 tick 函数，空依赖，所有值从 ref 读取
+  /** 播放循环 — 检测片段边界并切换 */
   const tick = useCallback(() => {
-    const segs = segmentsRef.current
-    const idx = segIdxRef.current
-    const video = videoRefs.current[idx]
-
+    const video = videoRefs.current[currentSegmentIndex]
     if (!video || isSeekingRef.current) {
       rafRef.current = requestAnimationFrame(tick)
       return
     }
 
-    const seg = segs[idx]
+    const seg = segments[currentSegmentIndex]
     if (!seg) return
 
-    // 预加载下一个片段
-    const nextIndex = idx + 1
-    if (nextIndex < segs.length) {
-      const nextVideo = videoRefs.current[nextIndex]
-      if (nextVideo) {
-        const timeToEnd = seg.endTime - video.currentTime
-        if (timeToEnd <= 2 && nextVideo.readyState < 3) {
-          const nextSeg = segs[nextIndex]
-          if (Math.abs(nextVideo.currentTime - nextSeg.startTime) > 0.5) {
-            nextVideo.currentTime = nextSeg.startTime
+    // 检查是否到达出点（容差 0.15s）
+    if (video.currentTime >= seg.endTime - 0.15) {
+      video.pause()
+      const nextIndex = currentSegmentIndex + 1
+      if (nextIndex < segments.length) {
+        switchToSegment(nextIndex).then(() => {
+          setIsPlaying(true)
+          rafRef.current = requestAnimationFrame(tick)
+          const nextVideo = videoRefs.current[nextIndex]
+          if (nextVideo) {
+            const canPlay = () => {
+              nextVideo
+                .play()
+                .catch((e) =>
+                  console.warn("[useSegmentScheduler] auto-play next segment failed:", e),
+                )
+            }
+            if (nextVideo.readyState >= 3) {
+              canPlay()
+            } else {
+              const timeout = setTimeout(canPlay, 300)
+              nextVideo.addEventListener(
+                "canplay",
+                () => {
+                  clearTimeout(timeout)
+                  canPlay()
+                },
+                { once: true },
+              )
+            }
           }
-        }
-      }
-    }
-
-    // 检测片段边界
-    if (video.currentTime >= seg.endTime - 0.1) {
-      if (nextIndex < segs.length) {
-        const nextVideo = videoRefs.current[nextIndex]
-        const nextSeg = segs[nextIndex]
-        const accumulatedTime =
-          (timelineStartsRef.current[idx] || 0) + (seg.endTime - seg.startTime)
-
-        if (nextVideo) {
-          if (Math.abs(nextVideo.currentTime - nextSeg.startTime) > 0.1) {
-            nextVideo.currentTime = nextSeg.startTime
-          }
-          // 先启动下一个视频（muted，可安全同时播放）
-          nextVideo
-            .play()
-            .catch((e) => console.warn("[useSegmentScheduler] next segment play failed:", e))
-        }
-
-        // 立即切换可见性
-        segIdxRef.current = nextIndex
-        setCurrentSegmentIndex(nextIndex)
-        setCurrentTime(accumulatedTime)
-        lastTimeUpdateRef.current = 0
-        setIsPlaying(true)
-
-        // 下一帧暂停旧视频（让新视频先渲染，避免冻屏）
-        const oldVideo = video
-        requestAnimationFrame(() => {
-          oldVideo.pause()
         })
-
-        rafRef.current = requestAnimationFrame(tick)
-        return
+        const accumulatedTime =
+          (timelineStarts[currentSegmentIndex] || 0) + (seg.endTime - seg.startTime)
+        setCurrentTime(accumulatedTime)
       } else {
-        video.pause()
         setIsPlaying(false)
         setIsEnded(true)
-        setCurrentTime(totalDurationRef.current)
+        setCurrentTime(totalDuration)
         return
       }
-    }
-
-    const globalTime = (timelineStartsRef.current[idx] || 0) + (video.currentTime - seg.startTime)
-    const now = performance.now()
-    if (now - lastTimeUpdateRef.current >= 200) {
-      lastTimeUpdateRef.current = now
-      setCurrentTime(Math.max(0, Math.min(globalTime, totalDurationRef.current)))
+    } else {
+      const globalTime =
+        (timelineStarts[currentSegmentIndex] || 0) + (video.currentTime - seg.startTime)
+      setCurrentTime(Math.max(0, Math.min(globalTime, totalDuration)))
     }
 
     rafRef.current = requestAnimationFrame(tick)
-  }, [])
+  }, [segments, currentSegmentIndex, timelineStarts, totalDuration, switchToSegment])
 
+  /** 播放 */
   const play = useCallback(async () => {
     if (!canPlay) return
-    setIsEnded(false)
-    const idx = segIdxRef.current
-    const video = videoRefs.current[idx]
-    if (!video) return
 
-    if (idx === 0 && video.readyState < 2) {
-      if (!video.src && segmentsRef.current[0]?.videoUrl) {
-        video.src = segmentsRef.current[0].videoUrl
-        video.load()
-      }
-      await waitForReady(video)
+    setIsEnded(false)
+
+    // 确保第一段可播放
+    const firstVideo = videoRefs.current[0]
+    if (firstVideo && currentSegmentIndex === 0 && firstVideo.readyState < 2) {
+      await switchToSegment(0)
     }
 
+    const video = videoRefs.current[currentSegmentIndex]
+    if (!video) return
+
     try {
-      await video.play()
+      const playPromise = video.play()
+      if (playPromise !== undefined) {
+        await playPromise
+      }
       setIsPlaying(true)
-      cancelAnimationFrame(rafRef.current)
       rafRef.current = requestAnimationFrame(tick)
     } catch (err) {
       console.warn("[useSegmentScheduler] 播放失败:", err)
     }
-  }, [canPlay, waitForReady, tick])
+  }, [canPlay, switchToSegment, tick, currentSegmentIndex])
 
+  /** 暂停 */
   const pause = useCallback(() => {
-    const video = videoRefs.current[segIdxRef.current]
+    const video = videoRefs.current[currentSegmentIndex]
     if (video) video.pause()
     setIsPlaying(false)
     cancelAnimationFrame(rafRef.current)
-  }, [])
+  }, [currentSegmentIndex])
 
+  /** 切换播放/暂停 */
   const togglePlayPause = useCallback(() => {
-    if (isPlayingRef.current) {
+    if (isPlaying) {
       pause()
     } else {
       if (isEnded) {
+        // 播放结束后再次播放，从头开始
         setIsEnded(false)
-        lastTimeUpdateRef.current = 0
-        const firstVideo = videoRefs.current[0]
-        if (firstVideo) {
-          videoRefs.current.forEach((v, i) => {
-            if (v && i !== 0) v.pause()
-          })
-          firstVideo.currentTime = segmentsRef.current[0]?.startTime || 0
-          segIdxRef.current = 0
-          setCurrentSegmentIndex(0)
-          setCurrentTime(0)
-          firstVideo
-            .play()
-            .then(() => {
-              setIsPlaying(true)
-              cancelAnimationFrame(rafRef.current)
-              rafRef.current = requestAnimationFrame(tick)
-            })
-            .catch((e) => console.warn("[useSegmentScheduler] restart failed:", e))
-        }
+        switchToSegment(0, segments[0]?.startTime).then(() => {
+          const video = videoRefs.current[0]
+          if (video) {
+            video.play().catch((e) => console.warn("[useSegmentScheduler] restart play failed:", e))
+            setIsPlaying(true)
+            setCurrentTime(0)
+            rafRef.current = requestAnimationFrame(tick)
+          }
+        })
       } else {
         play()
       }
     }
-  }, [isEnded, pause, play, tick])
+  }, [isPlaying, isEnded, pause, play, switchToSegment, segments, tick])
 
+  /** 跳转到指定全局时间 */
   const seekTo = useCallback(
     async (time: number) => {
       if (!canPlay) return
-      const clampedTime = Math.max(0, Math.min(time, totalDurationRef.current))
-      const { index, localTime } = findSegmentAtTime(segmentsRef.current, clampedTime)
+
+      const clampedTime = Math.max(0, Math.min(time, totalDuration))
+      const { index, localTime } = findSegmentAtTime(segments, clampedTime)
 
       isSeekingRef.current = true
-      cancelAnimationFrame(rafRef.current)
 
-      if (index !== segIdxRef.current) {
+      if (index !== currentSegmentIndex) {
         await switchToSegment(index, localTime)
       } else {
         const video = videoRefs.current[index]
@@ -302,54 +305,48 @@ export function useSegmentScheduler(segments: PlaybackSegment[]): SegmentSchedul
 
       setCurrentTime(clampedTime)
       setIsEnded(false)
-      lastTimeUpdateRef.current = 0
-
-      if (isPlayingRef.current) {
-        const video = videoRefs.current[index]
-        if (video) {
-          video.play().catch(() => {})
-        }
-        rafRef.current = requestAnimationFrame(tick)
-      }
 
       setTimeout(() => {
         isSeekingRef.current = false
       }, 200)
     },
-    [canPlay, switchToSegment, tick],
+    [canPlay, totalDuration, segments, currentSegmentIndex, switchToSegment],
   )
 
+  // 确保 videoRefs 数组长度与 segments 一致 + 强制预加载
   useEffect(() => {
     videoRefs.current = videoRefs.current.slice(0, segments.length)
     while (videoRefs.current.length < segments.length) {
       videoRefs.current.push(null)
     }
+    // 强制预加载：所有 video 元素挂载后，调用 load() 确保浏览器真正开始加载数据
+    videoRefs.current.forEach((video) => {
+      if (video) {
+        video.load()
+      }
+    })
   }, [segments])
 
+  // 组件卸载时清理
   useEffect(() => {
     return () => {
       cancelAnimationFrame(rafRef.current)
     }
   }, [])
 
+  // 片段列表变化时重置
   useEffect(() => {
     cancelAnimationFrame(rafRef.current)
-    segIdxRef.current = 0
     setIsPlaying(false)
     setCurrentTime(0)
     setCurrentSegmentIndex(0)
     setIsEnded(false)
   }, [segments])
 
-  const currentSegment = segments[currentSegmentIndex] || null
-  const segmentLocalTime = currentSegment
-    ? currentTime - (timelineStartsRef.current[currentSegmentIndex] || 0) + currentSegment.startTime
-    : 0
-
   return {
     isPlaying,
     currentTime,
-    totalDuration: totalDurationData,
+    totalDuration,
     currentSegmentIndex,
     segmentLocalTime,
     isEnded,

apps/web/src/pages/generate/hooks/useServerPreview.ts

@@ -1,294 +0,0 @@
-/**
- * 服务器渲染预览 Hook
- *
- * 核心职责：
- * 1. 调用 POST /generation/preview 创建服务器预览渲染任务
- * 2. 轮询 GET /generation/preview/{task_id} 直到完成
- * 3. 返回服务器渲染的真实视频 URL（供 <video> 标签播放）
- * 4. 检测配置变更，标记预览失效（stale）或自动重新渲染
- * 5. 网络错误自动重试 2 次
- *
- * 状态机：
- *   idle → loading → ready → stale (config changed)
- *                   ↘ failed → idle (retry)
- */
-import { useState, useCallback, useRef, useEffect } from "react"
-import { createPreview, getPreviewStatus } from "@/api/generation/preview"
-import type { CreatePreviewRequest } from "@/api/generation/types"
-
-export type ServerPreviewStatus = "idle" | "loading" | "ready" | "stale" | "failed"
-
-interface UseServerPreviewOptions {
-  /** 是否启用预览（Step4+ 且有素材和模板时） */
-  enabled: boolean
-  /** 构建预览请求参数（每次 render 调用，获取最新配置） */
-  buildRequest: () => CreatePreviewRequest
-  /** 预览任务创建成功回调 */
-  onPreviewTaskCreated?: (taskId: string, sourceEditPlanId?: string) => void
-}
-
-interface UseServerPreviewReturn {
-  status: ServerPreviewStatus
-  videoUrl: string | null
-  error: string | null
-  /** 进度 0-100 */
-  progress: number
-  /** 手动触发预览创建（"重新预览"按钮或标题变更后手动刷新） */
-  triggerPreview: () => void
-  /** 当前预览任务 ID */
-  taskId: string | null
-}
-
-const POLL_INTERVAL = 2000
-const POLL_TIMEOUT = 120_000
-const MAX_NETWORK_RETRIES = 2
-
-/**
- * 对配置参数做指纹，用于检测配置是否变化
- */
-function buildFingerprint(req: CreatePreviewRequest): string {
-  return JSON.stringify({
-    t: req.template_id,
-    a: [...req.asset_ids].sort(),
-    d: req.duration,
-    r: req.video_ratio,
-    v: req.voice_library_id,
-    b: req.bgm_config,
-    title: req.title_config,
-  })
-}
-
-export function useServerPreview({
-  enabled,
-  buildRequest,
-  onPreviewTaskCreated,
-}: UseServerPreviewOptions): UseServerPreviewReturn {
-  const [status, setStatus] = useState<ServerPreviewStatus>("idle")
-  const [videoUrl, setVideoUrl] = useState<string | null>(null)
-  const [error, setError] = useState<string | null>(null)
-  const [progress, setProgress] = useState(0)
-  const [taskId, setTaskId] = useState<string | null>(null)
-
-  const pollTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
-  const timeoutTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
-  const requestSeqRef = useRef(0)
-  const renderedFingerprintRef = useRef<string>("")
-  const mountedRef = useRef(true)
-  const networkRetriesRef = useRef(0)
-
-  // 始终持有最新的 buildRequest 和回调
-  const buildRequestRef = useRef(buildRequest)
-  buildRequestRef.current = buildRequest
-  const onCreatedRef = useRef(onPreviewTaskCreated)
-  onCreatedRef.current = onPreviewTaskCreated
-
-  /* ── 清理 ── */
-  const clearTimers = useCallback(() => {
-    if (pollTimerRef.current) {
-      clearTimeout(pollTimerRef.current)
-      pollTimerRef.current = null
-    }
-    if (timeoutTimerRef.current) {
-      clearTimeout(timeoutTimerRef.current)
-      timeoutTimerRef.current = null
-    }
-  }, [])
-
-  useEffect(() => {
-    mountedRef.current = true
-    return () => {
-      mountedRef.current = false
-      clearTimers()
-    }
-  }, [clearTimers])
-
-  /* ── 创建预览 + 轮询 ── */
-  const createAndPoll = useCallback(
-    async (request: CreatePreviewRequest, seq: number) => {
-      setStatus("loading")
-      setProgress(0)
-      setError(null)
-      networkRetriesRef.current = 0
-
-      try {
-        const resp = await createPreview(request)
-        if (seq !== requestSeqRef.current || !mountedRef.current) return
-
-        setTaskId(resp.task_id)
-        onCreatedRef.current?.(resp.task_id, resp.source_edit_plan_id)
-
-        let completed = false
-
-        // 超时保护
-        timeoutTimerRef.current = setTimeout(() => {
-          if (completed || seq !== requestSeqRef.current || !mountedRef.current) return
-          completed = true
-          clearTimers()
-          setStatus("failed")
-          setError("预览渲染超时（120秒），请重试")
-        }, POLL_TIMEOUT)
-
-        const poll = async () => {
-          if (completed || seq !== requestSeqRef.current || !mountedRef.current) return
-
-          try {
-            const st = await getPreviewStatus(resp.task_id)
-            if (completed || seq !== requestSeqRef.current || !mountedRef.current) return
-
-            if (st.status === "completed" && st.video_url) {
-              completed = true
-              clearTimers()
-              renderedFingerprintRef.current = buildFingerprint(request)
-              setVideoUrl(st.video_url)
-              setProgress(100)
-              setStatus("ready")
-              setError(null)
-              return
-            }
-
-            if (st.status === "failed" || st.status === "cancelled") {
-              completed = true
-              clearTimers()
-              setStatus("failed")
-              setError(
-                st.status === "cancelled"
-                  ? "预览任务已取消"
-                  : st.error_message || "预览渲染失败，请重试",
-              )
-              return
-            }
-
-            // pending / generating
-            if (typeof st.progress === "number") setProgress(st.progress)
-            pollTimerRef.current = setTimeout(poll, POLL_INTERVAL)
-          } catch (pollErr) {
-            if (completed || seq !== requestSeqRef.current || !mountedRef.current) return
-            if (networkRetriesRef.current < MAX_NETWORK_RETRIES) {
-              networkRetriesRef.current += 1
-              console.warn(
-                `[ServerPreview] 轮询网络错误，第 ${networkRetriesRef.current} 次重试`,
-                pollErr,
-              )
-              pollTimerRef.current = setTimeout(poll, POLL_INTERVAL * 2)
-            } else {
-              completed = true
-              clearTimers()
-              setStatus("failed")
-              setError("网络错误，无法获取预览状态，请重试")
-            }
-          }
-        }
-
-        poll()
-      } catch (createErr) {
-        if (seq !== requestSeqRef.current || !mountedRef.current) return
-        console.error("[ServerPreview] 创建预览任务失败:", createErr)
-
-        const isNetworkError =
-          !!(createErr as { request?: unknown })?.request ||
-          (createErr as { code?: string })?.code === "ERR_NETWORK"
-
-        if (isNetworkError && networkRetriesRef.current < MAX_NETWORK_RETRIES) {
-          networkRetriesRef.current += 1
-          console.warn(`[ServerPreview] 创建任务网络错误，第 ${networkRetriesRef.current} 次重试`)
-          setTimeout(() => {
-            if (seq === requestSeqRef.current && mountedRef.current) {
-              createAndPoll(request, seq)
-            }
-          }, POLL_INTERVAL * 2)
-          return
-        }
-
-        const errData = (
-          createErr as { response?: { data?: { detail?: string; message?: string } } }
-        )?.response?.data
-        setStatus("failed")
-        setError(errData?.detail || errData?.message || "预览任务创建失败，请重试")
-      }
-    },
-    [clearTimers],
-  )
-
-  /* ── 手动触发预览 ── */
-  const triggerPreview = useCallback(() => {
-    if (!enabled) return
-    const request = buildRequestRef.current()
-    if (!request.template_id || request.asset_ids.length === 0) return
-
-    clearTimers()
-    const seq = ++requestSeqRef.current
-    setVideoUrl(null)
-    setTaskId(null)
-    createAndPoll(request, seq)
-  }, [enabled, clearTimers, createAndPoll])
-
-  /* ── 自动触发 + 配置变更检测 ── */
-  // 每次 render 都检查最新配置 fingerprint，与已渲染的 fingerprint 比较
-  const request = enabled ? buildRequest() : null
-  const currentFingerprint = request
-    ? request.template_id && request.asset_ids.length > 0
-      ? buildFingerprint(request)
-      : ""
-    : ""
-
-  // 首次进入自动触发
-  const didInitRef = useRef(false)
-  useEffect(() => {
-    if (!enabled || !currentFingerprint) {
-      didInitRef.current = false
-      // 禁用时取消进行中的轮询，避免回到前序步骤后仍在后台轮询
-      requestSeqRef.current += 1
-      clearTimers()
-      return
-    }
-    if (!didInitRef.current) {
-      didInitRef.current = true
-      renderedFingerprintRef.current = currentFingerprint
-      triggerPreview()
-    }
-  }, [enabled, currentFingerprint, triggerPreview, clearTimers])
-
-  // 配置变更检测：素材/配音/BGM 等变化 → 自动重渲染；标题样式变化 → 标记 stale
-  const prevFingerprintRef = useRef(currentFingerprint)
-  useEffect(() => {
-    if (!enabled || !currentFingerprint) return
-    const prev = prevFingerprintRef.current
-    prevFingerprintRef.current = currentFingerprint
-
-    if (!prev || prev === currentFingerprint) return
-    if (currentFingerprint === renderedFingerprintRef.current) return
-
-    // 配置已变更
-    // 判断是标题样式变更还是素材/配音/BGM 变更
-    const prevParsed = JSON.parse(prev) as Record<string, unknown>
-    const currParsed = JSON.parse(currentFingerprint) as Record<string, unknown>
-    const nonTitleChanged =
-      prevParsed.t !== currParsed.t ||
-      prevParsed.a !== currParsed.a ||
-      prevParsed.d !== currParsed.d ||
-      prevParsed.r !== currParsed.r ||
-      prevParsed.v !== currParsed.v ||
-      JSON.stringify(prevParsed.b) !== JSON.stringify(currParsed.b)
-
-    if (nonTitleChanged) {
-      // 素材/配音/BGM/模板等变化 → 自动重新渲染
-      renderedFingerprintRef.current = currentFingerprint
-      triggerPreview()
-    } else {
-      // 仅标题文字/样式变化 → 标记 stale，不自动重渲染（避免频繁请求）
-      // 实时预览由 CSS TitleOverlay 提供
-      setStatus((s) => (s === "ready" ? "stale" : s))
-    }
-  }, [enabled, currentFingerprint, triggerPreview])
-
-  return {
-    status,
-    videoUrl,
-    error,
-    progress,
-    triggerPreview,
-    taskId,
-  }
-}
-
-export default useServerPreview

apps/web/src/pages/generate/hooks/useStep2Materials.ts

@@ -3,14 +3,9 @@
  * 组合素材库加载 + 智能匹配两个子 Hook
  */
 import { useCallback, useEffect, useRef } from "react"
-import type { AssetItem } from "@/api/assets"
-import type { TemplateSegment } from "@/api/templates/types"
-import { updateEditPlanClips } from "@/api/template-editor"
 import { formatDuration } from "../utils/formatDuration"
-import { buildClipsFromAssets } from "../utils/buildClipsFromAssets"
 import { useMaterialLibrary } from "./step2-materials/useMaterialLibrary"
 import { useSmartMatch } from "./step2-materials/useSmartMatch"
-import { useDraftAutoSave } from "./useDraftAutoSave"
 
 interface UseStep2MaterialsProps {
   materialMode: "manual" | "auto"
@@ -19,10 +14,6 @@ interface UseStep2MaterialsProps {
   onSelectedMaterialsChange: (ids: string[]) => void
   smartSelectedIds: string[]
   onSmartSelectedIdsChange: (ids: string[]) => void
-  /** 当前选中的模板/草稿 ID，用于自动保存 */
-  selectedTemplate?: string
-  /** 当前模板的 segments（用于构建 clips duration） */
-  templateSegments?: TemplateSegment[]
 }
 
 export function useStep2Materials({
@@ -32,8 +23,6 @@ export function useStep2Materials({
   onSelectedMaterialsChange,
   smartSelectedIds,
   onSmartSelectedIdsChange,
-  selectedTemplate,
-  templateSegments,
 }: UseStep2MaterialsProps) {
   const { libraries, selectedLibraryId, setSelectedLibraryId, materials, materialsLoading } =
     useMaterialLibrary()
@@ -64,69 +53,6 @@ export function useStep2Materials({
     handleSmartMatch()
   }, [selectedLibraryId, materialMode, materialsLoading, materials.items, handleSmartMatch])
 
-  /* ── Step2 选择素材后自动保存草稿 asset_ids（防抖 500ms，失败静默） ── */
-  const { scheduleSave } = useDraftAutoSave(selectedTemplate)
-  useEffect(() => {
-    if (!selectedTemplate) return
-    const ids = materialMode === "auto" ? smartSelectedIds : selectedMaterials
-    scheduleSave({ asset_ids: ids }, 500)
-  }, [selectedTemplate, materialMode, selectedMaterials, smartSelectedIds, scheduleSave])
-
-  /* ── Step2 选择素材后同步写入 edit_plan_clips（防抖 800ms，失败静默） ── */
-  const clipsTimerRef = useRef<ReturnType<typeof setTimeout>>()
-  const clipsAbortRef = useRef<AbortController | null>(null)
-  const templateSegmentsRef = useRef(templateSegments)
-  templateSegmentsRef.current = templateSegments
-  const selectedTemplateRef = useRef(selectedTemplate)
-  selectedTemplateRef.current = selectedTemplate
-  const materialsRef = useRef(materials)
-  materialsRef.current = materials
-  const smartMatchedRef = useRef<AssetItem[]>(smartMatch.smartMatchedResults)
-  smartMatchedRef.current = smartMatch.smartMatchedResults
-
-  useEffect(() => {
-    const tid = selectedTemplateRef.current
-    if (!tid) return
-    const ids = materialMode === "auto" ? smartSelectedIds : selectedMaterials
-    if (!ids.length) return
-
-    if (clipsTimerRef.current) clearTimeout(clipsTimerRef.current)
-    clipsTimerRef.current = setTimeout(async () => {
-      // 取消上一次未完成的请求
-      if (clipsAbortRef.current) clipsAbortRef.current.abort()
-      const controller = new AbortController()
-      clipsAbortRef.current = controller
-
-      const clips = buildClipsFromAssets({
-        selectedIds: ids,
-        materials: materialsRef.current.items,
-        smartMatchedAssets: smartMatchedRef.current,
-        templateSegments: templateSegmentsRef.current || [],
-      })
-
-      try {
-        await updateEditPlanClips(tid, clips, controller.signal)
-      } catch (err) {
-        const name = (err as { name?: string })?.name
-        if (name !== "CanceledError" && name !== "AbortError") {
-          console.warn("[useStep2Materials] 写入 clips 失败:", err)
-        }
-      }
-    }, 800)
-
-    return () => {
-      if (clipsTimerRef.current) clearTimeout(clipsTimerRef.current)
-    }
-  }, [selectedTemplate, materialMode, selectedMaterials, smartSelectedIds, templateSegments])
-
-  // 组件卸载时取消未完成请求
-  useEffect(() => {
-    return () => {
-      if (clipsTimerRef.current) clearTimeout(clipsTimerRef.current)
-      if (clipsAbortRef.current) clipsAbortRef.current.abort()
-    }
-  }, [])
-
   /* ── 手动选择素材 ── */
   const handleToggleMaterial = useCallback(
     (materialId: string) => {

apps/web/src/pages/generate/hooks/useStep4Title/index.ts

@@ -4,24 +4,17 @@ import { getTitles } from "@/api/titles"
 import type { TitleSettings } from "../../types"
 import { useAiTitleGenerator } from "./useAiTitleGenerator"
 import { useTitleStyleUpdaters } from "./useTitleStyleUpdaters"
-import { useDraftAutoSave } from "../useDraftAutoSave"
 
 interface UseStep4TitleProps {
   titleSettings: TitleSettings
   onTitleSettingsChange: (settings: TitleSettings) => void
-  /** 当前选中的模板/草稿 ID，用于自动保存 */
-  selectedTemplate?: string
 }
 
 /**
  * Step 4 标题设置 Hook
  * 封装 AI 标题生成、标题样式设置等逻辑
  */
-export function useStep4Title({
-  titleSettings,
-  onTitleSettingsChange,
-  selectedTemplate,
-}: UseStep4TitleProps) {
+export function useStep4Title({ titleSettings, onTitleSettingsChange }: UseStep4TitleProps) {
   // 标题库数据
   const { data: userTitles = [] } = useQuery({
     queryKey: ["titles"],
@@ -49,38 +42,6 @@ export function useStep4Title({
   const prevAiAutoSelect = useRef(titleSettings.aiAutoSelect)
   const isFirstMount = useRef(true)
 
-  /* ── Step4 标题内容/样式变化后自动保存草稿（防抖 800ms，失败静默） ── */
-  const { scheduleSave: scheduleTitleSave } = useDraftAutoSave(selectedTemplate)
-  useEffect(() => {
-    if (!selectedTemplate) return
-    scheduleTitleSave(
-      {
-        title: {
-          text: titleSettings.title,
-          font: titleSettings.font,
-          font_size: titleSettings.size,
-          color: titleSettings.color,
-          position: titleSettings.position,
-          bold: titleSettings.bold,
-          stroke: titleSettings.stroke,
-          shadow: titleSettings.shadow,
-        },
-      },
-      800,
-    )
-  }, [
-    selectedTemplate,
-    titleSettings.title,
-    titleSettings.font,
-    titleSettings.size,
-    titleSettings.color,
-    titleSettings.position,
-    titleSettings.bold,
-    titleSettings.stroke,
-    titleSettings.shadow,
-    scheduleTitleSave,
-  ])
-
   // 当 AI 自动选择开关打开时，自动生成/选择一个标题填入
   // 首次挂载时如果开关已经是 true 且无标题，也需要触发
   useEffect(() => {

apps/web/src/pages/generate/hooks/useStep6Cover.ts

@@ -2,13 +2,11 @@
  * Step 6 封面设置 Hook
  * 封装封面设置的交互逻辑，对接后端封面模板 CRUD API
  */
-import { useCallback, useEffect, useRef, useState } from "react"
+import { useCallback, useEffect, useState } from "react"
 import { message } from "antd"
 import type { CoverConfig, CoverTemplate } from "../types/cover"
 import { generateCover } from "@/api/generation"
 import { createPreview, getPreviewStatus } from "@/api/generation/preview"
-import { updateEditPlan } from "@/api/template-editor"
-import type { TitleSettings } from "../types"
 import {
   fetchCoverTemplates,
   createCoverTemplate,
@@ -24,22 +22,6 @@ interface UseStep6CoverProps {
   assetIds?: string[]
   /** 当前选中的模板 ID */
   selectedTemplate?: string
-  /** Step4 标题设置，用于预览视频烧录标题 & 封面叠加标题 */
-  titleSettings?: TitleSettings
-  /** 预览任务创建回调——将 task_id 暴露给父组件供 confirmGeneration 复用 */
-  onPreviewTaskCreated?: (taskId: string) => void
-  /** 从预览响应中提取到 source_edit_plan_id 时的回调 */
-  onSourceEditPlanIdExtracted?: (planId: string) => void
-  /** 配音模式 */
-  voiceMode?: "preset" | "custom" | "clone"
-  /** 选中的配音素材 ID（配音素材库 asset ID） */
-  selectedVoice?: string
-  /** 选中的克隆音色 ID */
-  selectedClonedVoice?: string
-  /** BGM 开关 */
-  bgm?: boolean
-  /** BGM 配置（来自模板） */
-  bgmConfig?: { enabled: boolean; music_id?: string }
 }
 
 export function useStep6Cover({
@@ -48,18 +30,8 @@ export function useStep6Cover({
   duration,
   assetIds = [],
   selectedTemplate = "",
-  titleSettings,
-  onPreviewTaskCreated,
-  onSourceEditPlanIdExtracted,
-  voiceMode,
-  selectedVoice,
-  selectedClonedVoice,
-  bgm,
-  bgmConfig,
 }: UseStep6CoverProps) {
   const [generating, setGenerating] = useState(false)
-  // 防竞态：记录当前预览生成的参数指纹，任务完成时校验一致性
-  const previewParamsRef = useRef<string>("")
 
   // ── 封面设置弹窗状态 ──
   const [showCoverSettings, setShowCoverSettings] = useState(false)
@@ -120,20 +92,6 @@ export function useStep6Cover({
       const response = await generateCover(selectedTemplate, {
         asset_ids: assetIds,
         cover_type: "ai_frame",
-        ...(titleSettings?.title
-          ? {
-              title_config: {
-                text: titleSettings.title,
-                font: titleSettings.font,
-                font_size: titleSettings.size,
-                font_color: titleSettings.color,
-                position: titleSettings.position,
-                bold: titleSettings.bold,
-                stroke: titleSettings.stroke,
-                shadow: titleSettings.shadow,
-              },
-            }
-          : {}),
       })
       clearTimeout(timeoutId)
       const thumbnailUrl = response.cover?.image_url || ""
@@ -156,127 +114,39 @@ export function useStep6Cover({
       const anyErr = err as any
       const statusCode = anyErr?.response?.status
 
-      // 400 错误：精确判断是否为"预览缺失"，避免误判其他 400 错误
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const errCode = anyErr?.response?.data?.code as string | undefined
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const errMsg = (anyErr?.response?.data?.message ||
-        anyErr?.response?.data?.detail ||
-        "") as string
-      const isPreviewMissing =
-        statusCode === 400 &&
-        (errCode?.includes("PREVIEW") ||
-          /预览.*(?:缺失|不存在|未找到)|(?:missing|not found|does not exist).*preview/i.test(
-            errMsg,
-          ))
-
-      if (isPreviewMissing) {
-        console.log("[Step6] 检测到预览缺失，尝试自动创建预览渲染任务...")
+      // 400 错误：后端缺少预览视频，自动创建后重试
+      if (statusCode === 400) {
+        console.log("[Step6] 后端返回 400，尝试自动创建预览渲染任务...")
         message.info("正在准备预览视频，请稍候...")
         try {
-          // 记录当前参数指纹，用于任务完成时校验一致性（防竞态）
-          previewParamsRef.current = JSON.stringify({ selectedTemplate, assetIds, titleSettings })
-          // 解析配音参数：voiceMode=clone 时用 selectedClonedVoice，否则用 selectedVoice
-          const previewVoiceLibraryId =
-            voiceMode === "clone" ? selectedClonedVoice || "" : selectedVoice || ""
           const previewResp = await createPreview({
             template_id: selectedTemplate,
             asset_ids: assetIds,
             duration: duration || 30,
-            // 配音：voice_library_id 是配音素材库 asset ID（用户上传的音频或 AI 配音）
-            ...(previewVoiceLibraryId ? { voice_library_id: previewVoiceLibraryId } : {}),
-            // BGM 配置：受 bgm 开关控制
-            bgm_config: {
-              enabled: bgm !== false,
-              ...(bgmConfig?.music_id ? { preset_id: bgmConfig.music_id } : {}),
-            },
-            ...(titleSettings?.title
-              ? {
-                  title_config: {
-                    text: titleSettings.title,
-                    font: titleSettings.font,
-                    font_size: titleSettings.size,
-                    font_color: titleSettings.color,
-                    position: titleSettings.position,
-                    bold: titleSettings.bold,
-                    stroke: titleSettings.stroke,
-                    shadow: titleSettings.shadow,
-                  },
-                }
-              : {}),
           })
-          // 将预览任务 ID 暴露给父组件，供 Step7 确认生成时复用（confirmGeneration）
-          const currentFingerprint = JSON.stringify({ selectedTemplate, assetIds, titleSettings })
-          if (previewResp.task_id && previewParamsRef.current === currentFingerprint) {
-            onPreviewTaskCreated?.(previewResp.task_id)
-            // 提取后端自动关联的 source_edit_plan_id，供 fallback 路径使用
-            if (previewResp.source_edit_plan_id) {
-              onSourceEditPlanIdExtracted?.(previewResp.source_edit_plan_id)
-            }
-          }
-          // 轮询等待预览渲染完成：递归 setTimeout 避免请求重叠 + 120s 超时兜底
+          // 轮询等待预览渲染完成
           await new Promise<void>((resolve, reject) => {
-            let finished = false
-            const done = (fn: () => void) => {
-              if (finished) return
-              finished = true
-              clearTimeout(timeoutId)
-              fn()
-            }
-            const timeoutId = setTimeout(() => {
-              done(() => reject(new Error("预览生成超时，请稍后重试")))
-            }, 120_000)
-            const poll = async () => {
-              if (finished) return
+            const poll = setInterval(async () => {
               try {
                 const status = await getPreviewStatus(previewResp.task_id)
                 if (status.status === "completed") {
-                  // 保存预览视频地址到 plan.config.rendered_storage_key，
-                  // 供封面 API 的 E1 兜底路径定位渲染后的视频（含标题烧录）。
-                  // video_url 可能是完整 http(s) URL 或 OSS storage_key，两种格式后端都能处理。
-                  if (status.video_url) {
-                    try {
-                      await updateEditPlan(selectedTemplate, {
-                        config: { rendered_storage_key: status.video_url },
-                      })
-                    } catch (saveErr) {
-                      console.warn(
-                        "[Step6] 保存 rendered_storage_key 失败（不阻塞封面重试）:",
-                        saveErr,
-                      )
-                    }
-                  }
-                  done(() => resolve())
+                  clearInterval(poll)
+                  resolve()
                 } else if (status.status === "failed") {
-                  done(() => reject(new Error(status.error_message || "预览渲染失败")))
-                } else {
-                  setTimeout(poll, 2000)
+                  clearInterval(poll)
+                  reject(new Error(status.error_message || "预览渲染失败"))
                 }
               } catch (e) {
-                done(() => reject(e))
+                clearInterval(poll)
+                reject(e)
               }
-            }
-            poll()
+            }, 3000)
           })
           message.success("预览视频就绪，重新生成封面...")
           // 重试封面生成
           const retryResp = await generateCover(selectedTemplate, {
             asset_ids: assetIds,
             cover_type: "ai_frame",
-            ...(titleSettings?.title
-              ? {
-                  title_config: {
-                    text: titleSettings.title,
-                    font: titleSettings.font,
-                    font_size: titleSettings.size,
-                    font_color: titleSettings.color,
-                    position: titleSettings.position,
-                    bold: titleSettings.bold,
-                    stroke: titleSettings.stroke,
-                    shadow: titleSettings.shadow,
-                  },
-                }
-              : {}),
           })
           const retryUrl = retryResp.cover?.image_url || ""
           if (retryUrl) {
@@ -318,22 +188,7 @@ export function useStep6Cover({
       clearTimeout(timeoutId)
       setGenerating(false)
     }
-  }, [
-    selectedTemplate,
-    assetIds,
-    coverSettings,
-    onCoverSettingsChange,
-    generating,
-    duration,
-    titleSettings,
-    onPreviewTaskCreated,
-    onSourceEditPlanIdExtracted,
-    voiceMode,
-    selectedVoice,
-    selectedClonedVoice,
-    bgm,
-    bgmConfig,
-  ])
+  }, [selectedTemplate, assetIds, coverSettings, onCoverSettingsChange, generating, duration])
 
   // ── 模板操作方法 ──
   const handleSelectTemplate = useCallback((id: string) => {

apps/web/src/pages/generate/hooks/useStepNavigation.ts

@@ -3,7 +3,7 @@
  * 管理步骤切换与各步骤的前置校验
  * 步骤顺序：模板(1) → 素材(2) → 配音(3) → 标题(4) → 预览(5) → 封面(6) → 确认(7)
  *
- * 服务器预览架构：Step5 需要服务器渲染预览完成才能前进
+ * V24: previewReady 改为前端素材加载状态
  */
 import { message } from "antd"
 import type { TitleSettings } from "../types"
@@ -16,7 +16,7 @@ export interface UseStepNavigationOptions {
   selectedMaterials: string[]
   smartSelectedIds: string[]
   titleSettings: TitleSettings
-  /** 服务器预览是否已完成（ready 状态） */
+  /** 预览是否就绪（前端素材已加载） */
   previewReady: boolean
 }
 
@@ -50,12 +50,13 @@ export const useStepNavigation = (options: UseStepNavigationOptions): UseStepNav
       message.warning("请先进行智能匹配并选择素材")
       return
     }
+    // Step3 配音：配音为可选项，不强制校验，用户可跳过
     if (currentStep === 4 && !titleSettings.title.trim()) {
       message.warning("请选择或输入标题")
       return
     }
     if (currentStep === 5 && !previewReady) {
-      message.warning("请等待预览视频渲染完成后再继续")
+      message.warning("请先选择素材以预览效果")
       return
     }
     if (currentStep < 7) {

apps/web/src/pages/generate/utils/buildClipsFromAssets.ts

@@ -1,69 +0,0 @@
-/**
- * 将选中素材 + 模板 segments 构建为 edit_plan_clips 写入数据。
- *
- * 逻辑必须与 FrontendPreviewPlayer.tsx 中 buildPlaybackSegments 完全一致：
- *   assetDuration = asset.duration || asset.metadata?.duration || 30
- *   tplSeg = templateSegments[i] || lastSegment
- *   segDuration = clamp(assetDuration, tplSeg.duration_min, tplSeg.duration_max)
- *   start_time = 0
- *   // 关键：预览播放器中 endTime = min(startTime + segDuration, assetDuration)
- *   // 因此 clips.duration 也必须用 min(segDuration, assetDuration) 截断，
- *   // 避免素材实际时长比 clamp 后的 segDuration 短时，Worker 尝试读取不存在的片段
- *   duration = min(segDuration, assetDuration)
- *
- * 预览播放器（Canvas 实时预览）直接在内存中构建 segments 播放，不读 edit_plan_clips；
- * 本函数产出的 clips 写入 DB 后由 Worker 渲染。两边用完全相同的时长计算，
- * 保证用户在编辑过程中看到的预览与最终生成视频一致。
- */
-import type { AssetItem } from "@/api/assets"
-import type { TemplateSegment } from "@/api/templates/types"
-import type { EditPlanClipInput } from "@/api/template-editor"
-
-interface BuildClipsOptions {
-  /** 选中的素材 ID 列表（按选择顺序） */
-  selectedIds: string[]
-  /** 已加载的素材列表（用于查 duration） */
-  materials: AssetItem[]
-  /** 智能匹配返回的素材（auto 模式下可能不在 materials 列表中） */
-  smartMatchedAssets?: AssetItem[]
-  /** 模板 segments */
-  templateSegments?: TemplateSegment[]
-}
-
-export function buildClipsFromAssets({
-  selectedIds,
-  materials,
-  smartMatchedAssets = [],
-  templateSegments = [],
-}: BuildClipsOptions): EditPlanClipInput[] {
-  if (!selectedIds.length) return []
-
-  // 合并两个素材来源，建立 id → asset 索引
-  const assetMap = new Map<string, AssetItem>()
-  for (const a of materials) assetMap.set(a.id, a)
-  for (const a of smartMatchedAssets) assetMap.set(a.id, a)
-
-  const lastSeg = templateSegments[templateSegments.length - 1]
-
-  return selectedIds.map((assetId, i) => {
-    const asset = assetMap.get(assetId)
-    const assetDuration = asset?.duration || asset?.metadata?.duration || 30
-
-    const tplSeg = templateSegments[i] || lastSeg
-    const segDuration = tplSeg
-      ? Math.min(tplSeg.duration_max, Math.max(tplSeg.duration_min, assetDuration))
-      : Math.min(assetDuration, 10)
-
-    // 与 FrontendPreviewPlayer.buildPlaybackSegments 中
-    //   endTime = Math.min(startTime + segDuration, assetDuration)
-    // 保持一致：duration 不能超过素材实际时长
-    const duration = Math.min(segDuration, assetDuration)
-
-    return {
-      asset_id: assetId,
-      start_time: 0,
-      duration,
-      order: i,
-    }
-  })
-}

apps/web/src/pages/templates/hooks/useTemplateLibrary.ts

@@ -87,7 +87,7 @@ export const useTemplateLibrary = () => {
     [copyMutation],
   )
 
-  /* 操作：使用模板 → 跳转剪辑模板 */
+  /* 操作：使用模板 → 跳转剪辑编辑器 */
   const handleUse = useCallback(
     (template: TemplateItem) => {
       navigate(`/app/editing-planner?templateId=${template.id}`)

apps/web/src/pages/voice-materials/hooks/useVoiceMaterials/actions/useVoiceUpload.ts

@@ -2,13 +2,14 @@ import { useState, useCallback } from "react"
 import { useMutation, useQueryClient } from "@tanstack/react-query"
 import { message } from "antd"
 import {
+  createAsset,
   uploadAssetDirect,
   getAssetLibraries,
-  getIngestJob,
   type AssetLibraryItem,
 } from "@/api/assets"
 import { tagAsset } from "@/api/tags"
-import { type VoiceGender, type VoiceMaterial } from "../../../types"
+import { type VoiceGender, type VoiceMaterial, buildMetadata } from "../../../types"
+import { getAudioDuration } from "../../../utils/audio"
 
 interface UseVoiceUploadOptions {
   voiceLibrary?: { id: string; kind: string }
@@ -47,34 +48,32 @@ export function useVoiceUpload({ voiceLibrary, createLibMutation }: UseVoiceUplo
           if (!lib) throw new Error("无法创建配音库")
         }
 
-        // 2. 上传文件（带进度，后端自动创建 ingest job）
-        const { ingest_job_id } = await uploadAssetDirect({
+        // 2. 上传文件（带进度）
+        const { storage_key } = await uploadAssetDirect({
           file: data.file,
           library_id: lib.id,
           onProgress: (p) => setUploadProgress(p),
         })
 
-        // 3. 轮询 ingest job 状态
-        let job: Awaited<ReturnType<typeof getIngestJob>> | null = null
-        let retries = 0
-        const maxRetries = 60 // 最多等待 5 分钟
-        while (retries < maxRetries) {
-          await new Promise((r) => setTimeout(r, 5000))
-          job = await getIngestJob(ingest_job_id)
-          if (job.status === "completed" || job.status === "failed") break
-          retries++
-        }
+        // 3. 获取音频时长
+        const duration = await getAudioDuration(data.file)
 
-        if (!job || job.status === "failed") {
-          throw new Error("音频处理失败，请重试")
-        }
-        if (retries >= maxRetries) {
-          throw new Error("音频处理超时，请稍后在素材库查看")
-        }
+        // 4. 创建素材记录
+        const asset = await createAsset({
+          library_id: lib.id,
+          name: data.name,
+          storage_key,
+          mime_type: data.file.type || "audio/mpeg",
+          metadata: buildMetadata({
+            gender: data.gender,
+            description: data.description,
+            duration,
+          }),
+        })
 
-        // 4. 打标签（标签走独立 API）
-        if (data.tagIds.length > 0 && job.result_asset_id) {
-          await tagAsset(job.result_asset_id, data.tagIds)
+        // 5. 打标签（标签走独立 API）
+        if (data.tagIds.length > 0) {
+          await tagAsset(asset.id, data.tagIds)
         }
       } finally {
         setUploadProgress(null)

apps/web/src/pages/voice-materials/types.ts

@@ -21,7 +21,7 @@ export interface VoiceMaterial {
   fileUrl?: string
 }
 
-/** 配音素材上传元数据（上传素材的 metadata） */
+/** 配音素材上传元数据（传递给 createAsset 的 metadata） */
 export interface VoiceAssetMetadata {
   gender: VoiceGender
   description: string

apps/web/src/pages/voices/hooks/useVoiceUpload.ts

@@ -1,6 +1,8 @@
 import { useState, useCallback } from "react"
 import { useMutation, useQueryClient } from "@tanstack/react-query"
-import { uploadAssetDirect, getAssetLibraries, getIngestJob } from "@/api/assets"
+import { uploadAssetDirect, getAssetLibraries, createAsset } from "@/api/assets"
+import { getAudioDuration } from "../utils/audio"
+import { buildVoiceMetadata } from "../types"
 
 /**
  * 配音上传 Hook
@@ -31,30 +33,27 @@ export function useVoiceUpload({ showToast }: UseVoiceUploadProps) {
         const lib = libs.find((l) => l.kind === "voice")
         if (!lib) throw new Error("配音库不存在，请先在配音库页面创建")
 
-        /* 直传文件（后端会自动创建 ingest job） */
-        const { ingest_job_id } = await uploadAssetDirect({
+        /* 直传文件 */
+        const { storage_key } = await uploadAssetDirect({
           file: data.file,
           library_id: lib.id,
           onProgress: (p) => setUploadProgress(p),
         })
 
-        /* 轮询 ingest job 状态，等待 Worker 处理完成 */
-        let jobStatus = ""
-        let retries = 0
-        const maxRetries = 60 // 最多等待 5 分钟（60 * 5秒）
-        while (jobStatus !== "ready" && jobStatus !== "failed" && retries < maxRetries) {
-          await new Promise((r) => setTimeout(r, 5000))
-          const job = await getIngestJob(ingest_job_id)
-          jobStatus = job.status
-          retries++
-        }
+        /* 获取音频时长 */
+        const duration = await getAudioDuration(data.file)
 
-        if (jobStatus === "failed") {
-          throw new Error("音频处理失败，请重试")
-        }
-        if (retries >= maxRetries) {
-          throw new Error("音频处理超时，请稍后在素材库查看")
-        }
+        /* 创建素材记录 */
+        await createAsset({
+          library_id: lib.id,
+          name: data.name,
+          storage_key,
+          mime_type: data.file.type || "audio/mpeg",
+          metadata: buildVoiceMetadata({
+            description: data.description,
+            duration,
+          }),
+        })
       } finally {
         setUploadProgress(null)
       }

apps/web/src/pages/voices/types.ts

@@ -39,7 +39,7 @@ export interface ClonedVoiceDisplay {
   sampleUrl?: string
 }
 
-/** 音色上传元数据（上传素材的 metadata） */
+/** 音色上传元数据（传递给 createAsset 的 metadata） */
 export interface VoiceUploadMetadata {
   gender?: string
   description?: string

apps/web/src/test/api/assets.test.ts

@@ -7,9 +7,11 @@ import {
   deleteAssetLibrary,
   getAssets,
   getAssetsByKind,
+  createAsset,
   updateAsset,
   updateAssetReviewStatus,
   deleteAsset,
+  uploadAsset,
   prepareDirectUpload,
   completeDirectUpload,
   uploadAssetDirect,
@@ -173,6 +175,22 @@ describe("assets API", () => {
     })
   })
 
+  describe("createAsset", () => {
+    it("should resolve successfully", async () => {
+      await expect(createAsset({ name: "test-item" })).resolves.not.toThrow()
+    })
+
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
+
+      await expect(createAsset({ name: "test-item" })).rejects.toThrow()
+    })
+  })
+
   describe("updateAsset", () => {
     it("should resolve successfully", async () => {
       await expect(updateAsset("test-assetId")).resolves.not.toThrow()
@@ -221,6 +239,22 @@ describe("assets API", () => {
     })
   })
 
+  describe("uploadAsset", () => {
+    it("should resolve successfully", async () => {
+      await expect(uploadAsset(new FormData())).resolves.not.toThrow()
+    })
+
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
+
+      await expect(uploadAsset(new FormData())).rejects.toThrow()
+    })
+  })
+
   describe("prepareDirectUpload", () => {
     it("should resolve successfully", async () => {
       await expect(prepareDirectUpload({ name: "test-item" })).resolves.not.toThrow()

apps/web/src/test/api/bgm.test.ts

@@ -32,7 +32,7 @@ describe("bgm API", () => {
 
   describe("getBgmPresets", () => {
     it("should resolve successfully", async () => {
-      await expect(getBgmPresets("test-template", { category: "test" })).resolves.not.toThrow()
+      await expect(getBgmPresets("test-params?")).resolves.not.toThrow()
     })
 
     it("should reject on API error", async () => {
@@ -42,7 +42,7 @@ describe("bgm API", () => {
       mockDelete.mockRejectedValue(new Error("Network error"))
       mockPatch.mockRejectedValue(new Error("Network error"))
 
-      await expect(getBgmPresets("test-template", { category: "test" })).rejects.toThrow()
+      await expect(getBgmPresets("test-params?")).rejects.toThrow()
     })
   })
 })

apps/web/src/test/api/edit-plans.test.ts

@@ -1,9 +1,16 @@
 import { describe, expect, it, vi, beforeEach } from "vitest"
 import {
+  getEditPlans,
   getEditPlan,
+  createEditPlan,
   updateEditPlan,
+  deleteEditPlan,
+  generateEditPlan,
+  getGenerationStatus,
   aiRecommendClips,
+  getEditPlanGenerations,
   getGenerationTaskResults,
+  cancelGeneration,
   getEditPlanClips,
   getEditPlanClip,
   createEditPlanClip,
@@ -12,6 +19,7 @@ import {
   reorderEditPlanClips,
   batchDeleteEditPlanClips,
   createClipsFromAssets,
+  copyEditPlan,
   getMediaAssets,
   getMediaAsset,
 } from "@/api/template-editor"
@@ -45,6 +53,22 @@ describe("editPlans API", () => {
     mockPatch.mockResolvedValue({ data: { success: true, items: [] } })
   })
 
+  describe("getEditPlans", () => {
+    it("should resolve successfully", async () => {
+      await expect(getEditPlans("test-params?")).resolves.not.toThrow()
+    })
+
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
+
+      await expect(getEditPlans("test-params?")).rejects.toThrow()
+    })
+  })
+
   describe("getEditPlan", () => {
     it("should resolve successfully", async () => {
       await expect(getEditPlan("test-planId")).resolves.not.toThrow()
@@ -61,6 +85,22 @@ describe("editPlans API", () => {
     })
   })
 
+  describe("createEditPlan", () => {
+    it("should resolve successfully", async () => {
+      await expect(createEditPlan({ name: "test-item" })).resolves.not.toThrow()
+    })
+
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
+
+      await expect(createEditPlan({ name: "test-item" })).rejects.toThrow()
+    })
+  })
+
   describe("updateEditPlan", () => {
     it("should resolve successfully", async () => {
       await expect(updateEditPlan("test-planId")).resolves.not.toThrow()
@@ -77,6 +117,54 @@ describe("editPlans API", () => {
     })
   })
 
+  describe("deleteEditPlan", () => {
+    it("should resolve successfully", async () => {
+      await expect(deleteEditPlan("test-planId")).resolves.not.toThrow()
+    })
+
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
+
+      await expect(deleteEditPlan("test-planId")).rejects.toThrow()
+    })
+  })
+
+  describe("generateEditPlan", () => {
+    it("should resolve successfully", async () => {
+      await expect(generateEditPlan("test-planId")).resolves.not.toThrow()
+    })
+
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
+
+      await expect(generateEditPlan("test-planId")).rejects.toThrow()
+    })
+  })
+
+  describe("getGenerationStatus", () => {
+    it("should resolve successfully", async () => {
+      await expect(getGenerationStatus("test-planId")).resolves.not.toThrow()
+    })
+
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
+
+      await expect(getGenerationStatus("test-planId")).rejects.toThrow()
+    })
+  })
+
   describe("aiRecommendClips", () => {
     it("should resolve successfully", async () => {
       await expect(aiRecommendClips("test-planId")).resolves.not.toThrow()
@@ -93,6 +181,22 @@ describe("editPlans API", () => {
     })
   })
 
+  describe("getEditPlanGenerations", () => {
+    it("should resolve successfully", async () => {
+      await expect(getEditPlanGenerations("test-planId")).resolves.not.toThrow()
+    })
+
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
+
+      await expect(getEditPlanGenerations("test-planId")).rejects.toThrow()
+    })
+  })
+
   describe("getGenerationTaskResults", () => {
     it("should resolve successfully", async () => {
       await expect(getGenerationTaskResults("test-taskId")).resolves.not.toThrow()
@@ -109,6 +213,22 @@ describe("editPlans API", () => {
     })
   })
 
+  describe("cancelGeneration", () => {
+    it("should resolve successfully", async () => {
+      await expect(cancelGeneration("test-planId")).resolves.not.toThrow()
+    })
+
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
+
+      await expect(cancelGeneration("test-planId")).rejects.toThrow()
+    })
+  })
+
   describe("getEditPlanClips", () => {
     it("should resolve successfully", async () => {
       await expect(getEditPlanClips("test-planId")).resolves.not.toThrow()
@@ -237,6 +357,22 @@ describe("editPlans API", () => {
     })
   })
 
+  describe("copyEditPlan", () => {
+    it("should resolve successfully", async () => {
+      await expect(copyEditPlan("test-planId")).resolves.not.toThrow()
+    })
+
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
+
+      await expect(copyEditPlan("test-planId")).rejects.toThrow()
+    })
+  })
+
   describe("getMediaAssets", () => {
     it("should resolve successfully", async () => {
       await expect(getMediaAssets("test-libraryId?")).resolves.not.toThrow()

apps/web/src/test/api/templates.test.ts

@@ -5,6 +5,7 @@ import {
   getTemplate,
   toggleFavoriteTemplate,
   copyTemplate,
+  generateFromTemplate,
 } from "@/api/templates"
 
 const mockGet = vi.fn()
@@ -115,4 +116,20 @@ describe("templates API", () => {
       await expect(copyTemplate("test-templateId")).rejects.toThrow()
     })
   })
+
+  describe("generateFromTemplate", () => {
+    it("should resolve successfully", async () => {
+      await expect(generateFromTemplate("test-templateId")).resolves.not.toThrow()
+    })
+
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
+
+      await expect(generateFromTemplate("test-templateId")).rejects.toThrow()
+    })
+  })
 })

apps/web/src/test/components/voice/CloneModal.test.tsx

@@ -10,9 +10,7 @@ vi.mock("@/api/voice-clone", () => ({
 }))
 
 vi.mock("@/api/assets", () => ({
-  uploadAssetDirect: vi
-    .fn()
-    .mockResolvedValue({ storage_key: "test", ingest_job_id: "test", url: "http://test" }),
+  uploadAsset: vi.fn(),
 }))
 
 vi.mock("@/components/ui", () => ({

apps/web/src/test/pages/EditingPlanner.test.tsx

@@ -148,9 +148,14 @@ vi.mock("@/api/editing-planner", () => ({
 
 vi.mock("@/api/template-editor", () => ({
   getMediaAssets: vi.fn().mockResolvedValue({ items: [] }),
+  getEditPlanGenerations: vi.fn().mockResolvedValue({ items: [] }),
   getEditPlan: vi.fn().mockResolvedValue({}),
+  createEditPlan: vi.fn().mockResolvedValue({ id: "test-plan" }),
   updateEditPlan: vi.fn().mockResolvedValue({}),
+  generateEditPlan: vi.fn().mockResolvedValue({ task_id: "test-task" }),
+  getGenerationStatus: vi.fn().mockResolvedValue({ status: "completed" }),
   getGenerationTaskResults: vi.fn().mockResolvedValue({ items: [] }),
+  cancelGeneration: vi.fn().mockResolvedValue({}),
   getEditPlanClips: vi.fn().mockResolvedValue({ items: [] }),
   createEditPlanClip: vi.fn().mockResolvedValue({}),
   batchDeleteEditPlanClips: vi.fn().mockResolvedValue({}),
@@ -220,6 +225,12 @@ vi.mock("@/pages/editing-planner/components/StickerPanel", () => ({
 vi.mock("@/pages/editing-planner/components/SaveModal", () => ({
   default: () => React.createElement("div", { "data-testid": "SaveModal" }),
 }))
+vi.mock("@/pages/editing-planner/components/GenerationHistoryModal", () => ({
+  default: () => React.createElement("div", { "data-testid": "GenerationHistoryModal" }),
+}))
+vi.mock("@/pages/editing-planner/components/GenerationProgressModal", () => ({
+  default: () => React.createElement("div", { "data-testid": "GenerationProgressModal" }),
+}))
 
 // === useUndoRedo hook mock ===
 vi.mock("@/pages/editing-planner/hooks/useUndoRedo", () => ({

apps/web/src/test/pages/GeneratePage.test.tsx

@@ -180,6 +180,7 @@ vi.mock("@/api/assets", () => ({
   getAssets: vi.fn().mockResolvedValue({ items: [], total: 0 }),
   getAssetsByKind: vi.fn().mockResolvedValue({ items: [], total: 0 }),
   smartMatchAssets: vi.fn().mockResolvedValue({ items: [] }),
+  createAsset: vi.fn().mockResolvedValue({}),
   updateAsset: vi.fn().mockResolvedValue({}),
   deleteAsset: vi.fn().mockResolvedValue({}),
   uploadAssetDirect: vi.fn().mockResolvedValue({}),
@@ -214,6 +215,12 @@ vi.mock("@/api/titles", () => ({
 }))
 
 vi.mock("@/api/template-editor", () => ({
+  generateEditPlan: vi.fn().mockResolvedValue({
+    plan_id: "test-plan",
+    generation_task_id: "test-task",
+    plan_status: "processing",
+    clip_count: 5,
+  }),
   updateEditPlan: vi.fn().mockResolvedValue({ plan_id: "test-plan", template_id: "test-template" }),
   getEditPlan: vi.fn().mockResolvedValue({
     plan_id: "test-plan",
@@ -222,6 +229,9 @@ vi.mock("@/api/template-editor", () => ({
     config: {},
     status: "draft",
   }),
+  getGenerationStatus: vi
+    .fn()
+    .mockResolvedValue({ plan_status: "completed", generation_task_id: "test-task", clips: [] }),
   getGenerationTaskResults: vi.fn().mockResolvedValue({ items: [] }),
 }))
 

apps/web/src/test/pages/TemplateLibrary.test.tsx

@@ -109,6 +109,7 @@ vi.mock("@/api/templates", () => ({
   getTemplate: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
   toggleFavoriteTemplate: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
   copyTemplate: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
+  generateFromTemplate: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
 }))
 
 vi.mock("@/pages/templates/TemplateLibrary.css", () => ({}))

apps/web/src/test/pages/VoiceMaterialLibrary.test.tsx

@@ -165,6 +165,7 @@ vi.mock("@/api/assets", () => ({
   deleteAssetLibrary: vi.fn().mockResolvedValue({}),
   getAssetsByKind: vi.fn().mockResolvedValue({ items: [], total: 0 }),
   getAssets: vi.fn().mockResolvedValue({ items: [], total: 0 }),
+  createAsset: vi.fn().mockResolvedValue({}),
   updateAsset: vi.fn().mockResolvedValue({}),
   deleteAsset: vi.fn().mockResolvedValue({}),
   uploadAssetDirect: vi.fn().mockResolvedValue({}),

apps/web/src/test/pages/editing-planner/components/GenerationHistoryModal.test.tsx

@@ -0,0 +1,39 @@
+import { describe, expect, it, vi } from "vitest"
+import { render } from "@testing-library/react"
+import GenerationHistoryModal from "@/pages/editing-planner/components/GenerationHistoryModal"
+
+const defaultProps = {
+  open: true,
+  loading: false,
+  history: [],
+  onClose: vi.fn(),
+  onCancel: vi.fn(),
+  cancelLoading: false,
+}
+
+describe("GenerationHistoryModal", () => {
+  it("should render without crashing", () => {
+    const { container } = render(<GenerationHistoryModal {...defaultProps} />)
+    expect(container).toBeTruthy()
+  })
+
+  it("should not render when open is false", () => {
+    const { container } = render(<GenerationHistoryModal {...defaultProps} open={false} />)
+    expect(container.firstChild).toBeNull()
+  })
+
+  it("should render with history items", () => {
+    const history = [
+      {
+        id: "1",
+        status: "completed",
+        created_at: "2024-01-01T00:00:00Z",
+        duration: 60,
+      },
+    ]
+    const { container } = render(
+      <GenerationHistoryModal {...defaultProps} history={history as any} />,
+    )
+    expect(container).toBeTruthy()
+  })
+})

apps/web/src/test/pages/editing-planner/components/GenerationProgressModal.test.tsx

@@ -0,0 +1,102 @@
+import { describe, expect, it, vi } from "vitest"
+import { render } from "@testing-library/react"
+import GenerationProgressModal from "@/pages/editing-planner/components/GenerationProgressModal"
+
+const baseProps = {
+  open: true,
+  voiceoverDuration: null,
+  estimatedDuration: 60,
+  onDurationChange: vi.fn(),
+  onGenerate: vi.fn(),
+  task: null,
+  submitting: false,
+  onCancel: vi.fn(),
+  onRetry: vi.fn(),
+  onClose: vi.fn(),
+}
+
+describe("GenerationProgressModal", () => {
+  it("should render setup phase", () => {
+    const { container } = render(<GenerationProgressModal {...baseProps} phase="setup" />)
+    expect(container).toBeTruthy()
+  })
+
+  it("should render progress phase without task", () => {
+    const { container } = render(<GenerationProgressModal {...baseProps} phase="progress" />)
+    expect(container).toBeTruthy()
+  })
+
+  it("should render progress phase with task data", () => {
+    const { container } = render(
+      <GenerationProgressModal
+        {...baseProps}
+        phase="progress"
+        task={
+          {
+            id: "task-123",
+            status: "generating_video",
+            progress: 50,
+            current_step: "generating_video",
+            user_message: "正在生成视频",
+          } as any
+        }
+      />,
+    )
+    expect(container).toBeTruthy()
+  })
+
+  it("should render completed phase", () => {
+    const { container } = render(
+      <GenerationProgressModal
+        {...baseProps}
+        phase="completed"
+        task={{ id: "task-1", status: "completed", progress: 100 } as any}
+      />,
+    )
+    expect(container).toBeTruthy()
+  })
+
+  it("should render failed phase with retry", () => {
+    const { container } = render(
+      <GenerationProgressModal
+        {...baseProps}
+        phase="failed"
+        task={
+          {
+            id: "task-1",
+            status: "failed",
+            progress: 30,
+            error_message: "生成失败",
+            retryable: true,
+          } as any
+        }
+      />,
+    )
+    expect(container).toBeTruthy()
+  })
+
+  it("should render failed phase without retry", () => {
+    const { container } = render(
+      <GenerationProgressModal
+        {...baseProps}
+        phase="failed"
+        task={
+          {
+            id: "task-1",
+            status: "failed",
+            progress: 30,
+            retryable: false,
+          } as any
+        }
+      />,
+    )
+    expect(container).toBeTruthy()
+  })
+
+  it("should not render when closed", () => {
+    const { container } = render(
+      <GenerationProgressModal {...baseProps} phase="setup" open={false} />,
+    )
+    expect(container).toBeTruthy()
+  })
+})

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

@@ -31,6 +31,8 @@ import "@/pages/editing-planner/components/ClipPropertiesPanel"
 import "@/pages/editing-planner/components/EditorClipList"
 import "@/pages/editing-planner/components/EditingDrawers"
 import "@/pages/editing-planner/components/FilterPanel"
+import "@/pages/editing-planner/components/GenerationHistoryModal"
+import "@/pages/editing-planner/components/GenerationProgressModal"
 import "@/pages/editing-planner/components/GreenScreenPanel"
 import "@/pages/editing-planner/components/IntroOutroPanel"
 import "@/pages/editing-planner/components/MediaPanel"

apps/web/src/test/pages/generate/useStep5Voice.test.tsx

@@ -93,5 +93,5 @@ describe("useStep5Voice smoke test", () => {
     )
     expect(result.current).toBeDefined()
     expect(typeof result.current.handlePlayCloneSample).toBe("function")
-  }, 15_000)
+  })
 })

apps/web/vite.config.ts

@@ -13,7 +13,6 @@ export default defineConfig({
     environment: "jsdom",
     globals: true,
     setupFiles: ["./src/test/setup.ts"],
-    testTimeout: 15_000, // 全局 15 秒，防止 CI 高负载时偶发超时
   },
   plugins: [
     react({

apps/worker/video_processing/__init__.py

@@ -7,7 +7,7 @@ VideoProcessor 等）按需从子模块导入，避免 __init__ 阶段引入
 packages / DB 等重依赖。
 """
 
-# 共享工具模块（零外部依赖，供 editing_modes / generation 等复用）
+# 共享工具模块（零外部依赖，供 editing_modes / generation / edit_plan_generation 等复用）
 from . import dedup_helpers, ffmpeg_utils, oss_helpers, url_security
 
 __all__ = [

apps/worker/video_processing/dedup_helpers.py

@@ -1,6 +1,6 @@
 """查重辅助函数 — 从 generation.py 提取的 GeneratedVideo 记录 + 查重逻辑.
 
-供 generate_video 共同复用，
+供 render_edit_plan 和 generate_video 共同复用，
 创建 GeneratedVideo 记录后计算指纹并执行项目级 + 批次内查重。
 """
 

apps/worker/video_processing/oss_helpers.py

@@ -1,4 +1,4 @@
-"""OSS 工具函数 — 从 generation.py 提取的共享 OSS 操作.
+"""OSS 工具函数 — 从 generation.py / edit_plan_generation.py 提取的共享 OSS 操作.
 
 提供 OSS 配置读取、Bucket 创建、素材上传/下载、asset_id → 本地路径解析
 等能力，供 render_edit_plan 和 generate_video 共同复用。
@@ -22,7 +22,7 @@ logger = logging.getLogger(__name__)
 
 # OSS 上传配置
 OSS_CONNECT_TIMEOUT = 10  # 连接超时（秒），防止 TCP 握手挂死
-OSS_UPLOAD_TOTAL_TIMEOUT = 900  # 单文件上传总超时（秒），防止网络慢时无限卡住
+OSS_UPLOAD_TOTAL_TIMEOUT = 300  # 单文件上传总超时（秒），防止网络慢时无限卡住
 OSS_MULTIPART_THRESHOLD = 100 * 1024 * 1024  # 分片上传阈值：100MB 以上走分片
 OSS_PART_SIZE = 8 * 1024 * 1024  # 分片大小：8MB
 OSS_MULTIPART_NUM_THREADS = 3  # 分片上传并发数
@@ -127,10 +127,10 @@ def download_asset(asset_storage_key: str, local_path: Path) -> bool:
 def _download_via_http(url: str, local_path: Path) -> bool:
     """通过 HTTP 下载文件（支持预签名 URL）。
 
-    使用流式下载避免大文件内存溢出，超时 900s。
+    使用流式下载避免大文件内存溢出，超时 300s。
     """
     try:
-        resp = requests.get(url, stream=True, timeout=900)
+        resp = requests.get(url, stream=True, timeout=300)
         resp.raise_for_status()
         with open(local_path, "wb") as f:
             for chunk in resp.iter_content(chunk_size=8 * 1024 * 1024):
@@ -146,7 +146,7 @@ def upload_to_oss(local_path: Path | str, storage_key: str) -> str | None:
     """上传文件到 OSS，返回公开 URL。
 
     大文件（>100MB）自动走分片上传，降低内存峰值，减少 OOM 风险。
-    上传加总超时保护（默认 900s），防止网络异常时无限挂死。
+    上传加总超时保护（默认 300s），防止网络异常时无限挂死。
 
     Args:
         local_path: 本地文件路径（Path 或 str 均可）

apps/worker/video_processing/render_adapter.py

@@ -84,7 +84,6 @@ class RenderAdapterResult:
     cover_candidates: list[dict] | None = (
         None  # 封面候选帧 [{"image_url": "...", "frame_time": 5.0, "storage_key": "..."}]
     )
-    temp_dir: str | None = None  # 渲染临时目录，成功时由调用方清理，失败时由 finally 清理
 
     def __post_init__(self):
         if self.rendered_clip_ids is None:
@@ -129,7 +128,6 @@ class RenderAdapter:
         job_id: str = "",
         work_dir: Path | None = None,
         progress_cb: ProgressCallback | None = None,
-        voiceover_audio_path: str | None = None,
     ) -> RenderAdapterResult:
         """渲染一个 EditPlan。
 
@@ -144,7 +142,6 @@ class RenderAdapter:
             job_id: 关联的 Job ID（用于结果存储路径）
             work_dir: 工作目录，不传则使用临时目录
             progress_cb: 进度回调函数
-            voiceover_audio_path: 配音音频本地路径（一键生成场景使用）
 
         Returns:
             RenderAdapterResult
@@ -201,7 +198,7 @@ class RenderAdapter:
             self._report_progress(progress_cb, 35.0, "准备 BGM 音频")
 
             # 3~6. 统一渲染核心流程（BGM + ASR + 渲染 + 缩略图 + 上传）
-            result = self._do_render(
+            return self._do_render(
                 plan=plan,
                 clips=ready_clips,
                 asset_path_map=asset_path_map,
@@ -211,13 +208,7 @@ class RenderAdapter:
                 progress_cb=progress_cb,
                 rendered_clip_ids=rendered_clip_ids,
                 failed_clip_ids=failed_clip_ids,
-                voiceover_audio_path=voiceover_audio_path,
             )
-            # 成功时将临时目录所有权转移给调用方，阻止 finally 清理
-            if result.success and temp_dir:
-                result.temp_dir = temp_dir
-                temp_dir = None  # 阻止 finally 块清理
-            return result
 
         except subprocess.CalledProcessError as exc:
             stderr_text = (exc.stderr or "").strip()
@@ -594,11 +585,14 @@ class RenderAdapter:
         try:
             from video_processing.thumbnail_generator import extract_and_upload_cover_frames
 
-            # 已渲染视频在统一渲染阶段已通过 ASS 字幕把标题烧录进画面，
-            # 抽帧天然带标题，因此这里传空字符串，避免 Pillow 二次叠加导致重影。
-            # Pillow 叠加仅用于 API 从源素材抽帧（源素材本身无标题）的兜底场景。
+            # 从 plan config 提取标题文字，叠加到封面候选帧上
+            _title_cfg = (plan_config or {}).get("title", {}) or {}
+            if not isinstance(_title_cfg, dict):
+                _title_cfg = {}
+            _title_text = (_title_cfg.get("text", "") or "").strip() if _title_cfg.get("enabled", True) else ""
+
             cover_candidates = extract_and_upload_cover_frames(
-                str(result.output_path), plan_id, num_frames=3, title_text=""
+                str(result.output_path), plan_id, num_frames=3, title_text=_title_text
             )
             if cover_candidates:
                 logger.info(

apps/worker/video_processing/render_audio.py

@@ -67,16 +67,6 @@ def clip_has_audio(ctx: RenderContext, clip: ResolvedClip) -> bool:
     return ctx._audio_cache[key]
 
 
-def _clip_volume(clip: ResolvedClip) -> float:
-    """读取 clip 的音量配置（0.0~1.0，>1 放大）。缺省 1.0 原声。"""
-    cfg = getattr(clip, "config", None) or {}
-    try:
-        vol = float(cfg.get("volume", 1.0))
-    except (TypeError, ValueError):
-        return 1.0
-    return max(0.0, vol)
-
-
 # ── 音频混音 ──────────────────────────────────────────────────────────────────
 
 
@@ -92,13 +82,12 @@ def mix_audio(
     """音频后处理混音.
 
     处理逻辑：
-    1. 保留主图层（main/broll/overlay/corner_voice）视频素材的原声，按顺序 concat 拼接
-    2. 每个 clip 按 config.volume 应用音量（volume=0 静音，=1 原声）
-    3. 独立音频轨（audio role，TTS/配音）通过 amix 混入
-    4. 如果提供了 bgm_path，则额外混入 BGM（支持淡入淡出、循环、人声闪避）
-    5. 如果配置了 audio_tracks，则混入多轨道音频（配音、音效等）
-    6. 输出时长截断到 video_duration
-    7. 如果配置了降噪，最后应用降噪
+    1. 丢弃主图层（main/broll/overlay/corner_voice）的原始音频，避免录入源视频杂音
+    2. 仅使用独立音频轨（audio role，TTS/配音）作为主音频
+    3. 如果提供了 bgm_path，则额外混入 BGM（支持淡入淡出、循环、人声闪避）
+    4. 如果配置了 audio_tracks，则混入多轨道音频（配音、音效等）
+    5. 输出时长截断到 video_duration
+    6. 如果配置了降噪，最后应用降噪
 
     Args:
         ctx: 渲染上下文
@@ -134,12 +123,10 @@ def mix_audio(
     if "audio" in layer_map:
         audio_clips = layer_map["audio"].clips
 
-    # ── 保留源视频原声：过滤掉无音频流的 main clip（图片/无声素材） ──
-    # 注意：volume=0 的 clip 不能移除——移除会导致后续 clip 音频时间轴前移、音画不同步。
-    # volume=0 通过滤镜链生成静音流，保持时间轴对齐。
-    main_clips = [c for c in main_clips if clip_has_audio(ctx, c)]
+    # ── 丢弃源视频的原始音频（避免录入杂音），成片仅保留 TTS 配音 + BGM ──
+    main_clips = []
 
-    # ── 防御：过滤掉无音频流的独立音频轨 ──
+    # ── 防御：过滤掉无音频流的 clip ──
     audio_clips = [c for c in audio_clips if clip_has_audio(ctx, c)]
 
     if not main_clips and not audio_clips:
@@ -157,7 +144,7 @@ def mix_audio(
     # 构建音频处理命令
     output_path = ctx.work_dir / f"audio_{ctx.plan_id}.aac"
 
-    # 主音频为视频素材原声 concat；独立音频轨（TTS/配音）通过 amix 混入。
+    # 源视频原始音频已被丢弃（main_clips = []），最终音频完全由独立音频轨 + BGM + 多轨配置组成。
     # 当无 main_clips 时，将独立音频轨作为主音频走 concat 拼接；当二者均有则走 amix 混音。
     if main_clips:
         effective_main = main_clips
@@ -279,67 +266,28 @@ def concat_main_audio(
         has_speed = abs(speed - 1.0) >= 1e-6
 
         if not has_speed and not has_reverse:
-            # 无调速无倒放：根据是否需要裁剪/音量选择最高效的路径。
-            vol = _clip_volume(clip)
-            need_trim = trim_start > 0 or (effective_duration > 0 and final_duration < adjusted_duration)
-            need_volume = abs(vol - 1.0) >= 1e-6
-
-            if need_trim:
-                # 需要裁剪：用 atrim 滤镜在滤镜链中精确裁剪（采样点级精度，不浪费解码）。
-                # 滤镜顺序：atrim → asetpts → volume（先裁剪再调音量，避免处理被丢弃的数据）。
-                af_parts: list[str] = []
-                if trim_start > 0 and effective_duration > 0:
-                    af_parts.append(f"atrim=start={trim_start:.3f}:duration={final_duration:.3f}")
-                elif trim_start > 0:
-                    af_parts.append(f"atrim=start={trim_start:.3f}")
-                elif final_duration > 0:
-                    af_parts.append(f"atrim=duration={final_duration:.3f}")
-                af_parts.append("asetpts=PTS-STARTPTS")
-                if need_volume:
-                    af_parts.append(f"volume={vol:.4f}")
-                command = [
-                    FFMPEG_BIN,
-                    "-y",
-                    "-i",
-                    str(clip.local_path),
-                    "-vn",
-                    "-af",
-                    ",".join(af_parts),
-                    "-acodec",
-                    "aac",
-                    "-b:a",
-                    "128k",
-                    "-ar",
-                    "48000",
-                    "-ac",
-                    "2",
-                ]
-                # atrim 已精确控制时长，无需额外 -t
-                command.append(str(output_path))
-                run_ffmpeg(command)
-            else:
-                # 无需裁剪：直接提取，最高效。音量用单个 -af（如有）。
-                command = [
-                    FFMPEG_BIN,
-                    "-y",
-                    "-i",
-                    str(clip.local_path),
-                    "-vn",
-                    "-acodec",
-                    "aac",
-                    "-b:a",
-                    "128k",
-                    "-ar",
-                    "48000",
-                    "-ac",
-                    "2",
-                ]
-                if need_volume:
-                    command.extend(["-af", f"volume={vol:.4f}"])
-                if final_duration > 0:
-                    command.extend(["-t", f"{final_duration:.3f}"])
-                command.append(str(output_path))
-                run_ffmpeg(command)
+            # 无调速无倒放：简单命令行，-ss 裁剪更高效
+            command = [
+                FFMPEG_BIN,
+                "-y",
+                "-i",
+                str(clip.local_path),
+                "-vn",
+                "-acodec",
+                "aac",
+                "-b:a",
+                "128k",
+                "-ar",
+                "48000",
+                "-ac",
+                "2",
+            ]
+            if trim_start > 0:
+                command.extend(["-ss", f"{trim_start:.3f}"])
+            if final_duration > 0:
+                command.extend(["-t", f"{final_duration:.3f}"])
+            command.append(str(output_path))
+            run_ffmpeg(command)
         else:
             # 有调速或倒放：用 filter_complex
             speed_engine = SpeedEngine()
@@ -364,11 +312,6 @@ def concat_main_audio(
                 if reverse_filter:
                     audio_filters.append(reverse_filter)
 
-            # 音量
-            vol = _clip_volume(clip)
-            if abs(vol - 1.0) >= 1e-6:
-                audio_filters.append(f"volume={vol:.4f}")
-
             # aformat 归一化：统一输出格式为 48000Hz + stereo + fltp
             audio_filters.append("aformat=sample_rates=48000:channel_layouts=stereo:sample_fmts=fltp")
 
@@ -435,11 +378,6 @@ def concat_main_audio(
             if reverse_filter:
                 audio_filters.append(reverse_filter)
 
-        # 音量（0=静音，1=原声）
-        vol = _clip_volume(clip)
-        if abs(vol - 1.0) >= 1e-6:
-            audio_filters.append(f"volume={vol:.4f}")
-
         # aformat 归一化：统一采样率48000Hz + 双声道stereo + fltp采样格式
         # concat filter 要求所有输入音频参数完全一致，否则 exit=234 失败
         audio_filters.append("aformat=sample_rates=48000:channel_layouts=stereo:sample_fmts=fltp")

apps/worker/video_processing/thumbnail_generator.py

@@ -1,8 +1,7 @@
-"""视频封面抽帧工具 — 从视频中抽取帧作为封面，支持标题文字叠加。
+"""视频封面抽帧工具 — 从已渲染视频中抽取帧作为封面。
 
-统一封面管道：
-- 从已渲染视频抽帧：标题已通过 ASS 字幕烧进视频，帧天然带标题，无需再叠加。
-- 从源素材抽帧（API E2 兜底）：源素材无标题，通过 Pillow 在帧上绘制标题文字。
+统一封面管道：视频渲染时标题已通过 ASS 字幕烧进视频，
+渲染完成后直接从此视频抽帧，封面天然带标题，无需额外叠加逻辑。
 """
 
 from __future__ import annotations
@@ -13,40 +12,6 @@ from pathlib import Path
 
 logger = logging.getLogger(__name__)
 
-# ── 标题叠加（Pillow）──────────────────────────────────────────────────────
-# 实现统一放在 packages/shared/title_overlay.py，API 和 Worker 共用。
-
-
-def apply_title_overlay(
-    image_path: str,
-    title_text: str,
-    *,
-    color: str = "#ffffff",
-    position: str = "bottom",
-    font_size: int | None = None,
-    margin_ratio: float = 0.06,
-    stroke_width_ratio: float = 0.04,
-) -> str:
-    """在图片上绘制标题文字（指定颜色 + 黑色描边/阴影）。
-
-    委托给 packages.shared.title_overlay.apply_title_to_image，
-    保持 Worker 内调用方式不变。title_text 为空时直接返回原路径。
-    """
-    from packages.shared.title_overlay import apply_title_to_image
-
-    if not title_text or not title_text.strip():
-        return image_path
-    result = apply_title_to_image(
-        image_path,
-        title_text,
-        color=color,
-        position=position,
-        font_size=font_size,
-        margin_ratio=margin_ratio,
-        stroke_width_ratio=stroke_width_ratio,
-    )
-    return result or image_path
-
 
 def extract_first_frame(
     video_path: str,
@@ -169,104 +134,3 @@ def _format_seek_time(seconds: float) -> str:
     m = int((seconds % 3600) // 60)
     s = seconds % 60
     return f"{h:02d}:{m:02d}:{s:05.2f}"
-
-
-def generate_and_upload_thumbnail(
-    video_path: str,
-    storage_key: str,
-    *,
-    seek_ratio: float = 0.15,
-) -> str:
-    """从视频中提取一帧缩略图并上传到 OSS。
-
-    Args:
-        video_path: 视频文件路径
-        storage_key: OSS 存储 key
-        seek_ratio: 抽帧位置比例（默认 0.15）
-
-    Returns:
-        上传后的 URL 字符串
-
-    Raises:
-        RuntimeError: 抽帧或上传失败
-    """
-    from video_processing.oss_helpers import upload_to_oss
-
-    tmp = tempfile.NamedTemporaryFile(suffix=".jpg", delete=False)
-    tmp.close()
-    try:
-        frame_path = extract_first_frame(video_path, output_path=tmp.name, seek_ratio=seek_ratio)
-        url = upload_to_oss(frame_path, storage_key)
-        if not url:
-            raise RuntimeError(f"上传缩略图到 OSS 失败: {storage_key}")
-        return url
-    finally:
-        Path(tmp.name).unlink(missing_ok=True)
-
-
-def extract_and_upload_cover_frames(
-    video_path: str,
-    plan_id: str,
-    *,
-    num_frames: int = 3,
-    title_text: str = "",
-    title_color: str = "#ffffff",
-    title_position: str = "bottom",
-    title_font_size: int | None = None,
-) -> list[dict]:
-    """从视频中抽取多帧作为封面候选，上传到 OSS。
-
-    Args:
-        video_path: 视频文件路径
-        plan_id: 编辑计划 ID（用于生成 storage key）
-        num_frames: 抽取帧数（默认 3）
-        title_text: 标题文字；非空时用 Pillow 叠加到每帧。
-            从已渲染视频抽帧时通常传空（标题已烧录）；从源素材抽帧时传标题。
-        title_color: 标题字体颜色（#RRGGBB）
-        title_position: 标题位置 top/center/bottom
-        title_font_size: 标题字号，None 时自动计算
-
-    Returns:
-        封面候选列表，每项包含 {"url": str, "position": float}
-    """
-    from video_processing.ffmpeg_utils import probe_duration
-    from video_processing.oss_helpers import upload_to_oss
-
-    try:
-        duration = probe_duration(video_path)
-    except Exception:
-        duration = 0.0
-
-    candidates: list[dict] = []
-    # 均匀分布抽帧点：从 10% 到 90%
-    for i in range(num_frames):
-        ratio = 0.1 + 0.8 * i / max(num_frames - 1, 1)
-        tmp = tempfile.NamedTemporaryFile(suffix=".jpg", delete=False)
-        tmp.close()
-        try:
-            frame_path = extract_first_frame(
-                video_path,
-                output_path=tmp.name,
-                seek_ratio=ratio,
-                min_seek_seconds=0.5,
-            )
-            # 从源素材抽帧时叠加标题文字；已渲染视频标题已烧录时传空字符串跳过
-            if title_text and title_text.strip():
-                apply_title_overlay(
-                    frame_path,
-                    title_text,
-                    color=title_color,
-                    position=title_position,
-                    font_size=title_font_size,
-                )
-            storage_key = f"covers/{plan_id}/frame_{i}.jpg"
-            url = upload_to_oss(frame_path, storage_key)
-            if url:
-                seek_time = max(0.5, duration * ratio) if duration > 0 else 0.0
-                candidates.append({"url": url, "position": round(seek_time, 2)})
-        except Exception as e:
-            logger.warning("[thumbnail] 封面候选帧 %d 提取失败: %s", i, e)
-        finally:
-            Path(tmp.name).unlink(missing_ok=True)
-
-    return candidates

apps/worker/video_processing/unified_render_service.py

@@ -36,7 +36,6 @@ from video_processing.ffmpeg_utils import (
     DEFAULT_TRANSITION_DURATION,
     FFMPEG_BIN,
     probe_duration,
-    probe_has_audio,
     probe_video_info,
     run_ffmpeg,
 )
@@ -1001,11 +1000,6 @@ class UnifiedRenderService:
         if abs(speed - 1.0) >= 1e-6:
             return False, f"有调速: speed={speed:.2f}x"
 
-        # 音量非默认（静音/放大）→ 需要音频滤镜重编码 → 不能 copy
-        vol = UnifiedRenderService._clip_volume(clip)
-        if abs(vol - 1.0) >= 1e-6:
-            return False, f"音量非默认: volume={vol:.2f}"
-
         # 有倒放 → 需要重编码 → 不能 copy
         reverse_config = ReverseConfig.from_dict(clip.config.get("reverse"))
         if reverse_config.enabled and (reverse_config.reverse_video or reverse_config.reverse_audio):
@@ -1276,23 +1270,13 @@ class UnifiedRenderService:
             "+faststart",
         ]
 
-        # 音频处理：background 通常是图片无音频，跳过；其他角色先探测是否真有音频流。
-        # volume=0 不丢弃音频流，而是保留后通过 volume=0 滤镜静音，保持时间轴对齐。
-        clip_volume = UnifiedRenderService._clip_volume(clip)
-        if role != "background":
-            try:
-                has_audio = probe_has_audio(clip.local_path)
-            except Exception as e:
-                # probe_has_audio 内部已保守返回 True；只有极端错误才会到这里。
-                # 此时不静默丢音频，记录 error 并向上抛出，让任务失败而不是产出无声视频。
-                logger.error("[unified-render] 探测音频流发生致命错误，终止渲染: %s: %s", clip.local_path, e)
-                raise
-        else:
-            has_audio = False
+        # 音频处理：background 通常是图片无音频，跳过；其他编码为 aac
+        # background 以外的视频素材，默认带音频
+        has_audio = role != "background"
         if has_audio:
             af_parts: list[str] = []
 
-            # 音频降噪（最先处理：在原始信号上降噪效果最好）
+            # 音频降噪
             try:
                 from video_processing.noise_reduction_engine import NoiseReductionConfig, NoiseReductionEngine
 
@@ -1306,16 +1290,13 @@ class UnifiedRenderService:
             except Exception as e:
                 logger.warning("[unified-render] 直通模式音频降噪应用失败，跳过: %s", e)
 
-            # 音频调速（在降噪之后、音量之前，与 render_audio.py concat 路径保持一致）
-            # SpeedEngine.build_audio_filter 内部已实现多级 atempo 串联，
-            # 自动处理超出 [0.5, 2.0] 范围的速度（如 0.25x → atempo=0.5,atempo=0.5）。
+            # 音频调速（与视频setpts对应，保持音画同步）
             speed = UnifiedRenderService._clip_speed(clip)
             if abs(speed - 1.0) >= 1e-6:
                 try:
                     from video_processing.speed_engine import SpeedConfig, SpeedEngine
 
                     speed_cfg = SpeedConfig(speed=speed)
-                    speed_cfg.clamp()
                     speed_engine = SpeedEngine()
                     af_parts.append(speed_engine.build_audio_filter(speed_cfg))
                 except Exception as e:
@@ -1328,10 +1309,6 @@ class UnifiedRenderService:
                 if af_filter:
                     af_parts.append(af_filter)
 
-            # 片段音量（最后应用：确保调速/倒放后的最终输出音量准确，与 concat 路径一致）
-            if abs(clip_volume - 1.0) >= 1e-6:
-                af_parts.append(f"volume={clip_volume:.4f}")
-
             if af_parts:
                 command.extend(["-af", ",".join(af_parts)])
 
@@ -1999,16 +1976,6 @@ class UnifiedRenderService:
         """
         return _clip_playback_speed_pure(getattr(clip, "playback_speed", 1.0))
 
-    @staticmethod
-    def _clip_volume(clip: ResolvedClip) -> float:
-        """获取 clip 的音量（config.volume）。缺省 1.0 原声，0.0 静音。"""
-        cfg = getattr(clip, "config", None) or {}
-        try:
-            vol = float(cfg.get("volume", 1.0))
-        except (TypeError, ValueError):
-            return 1.0
-        return max(0.0, vol)
-
     @staticmethod
     def _clip_adjusted_duration(clip: ResolvedClip) -> float:
         """计算调速后的 clip 实际时长（用于拼接计算）。

apps/worker/worker_app/celery_app.py

@@ -14,17 +14,9 @@ celery_app.conf.imports = (
     "worker_app.tasks.voice_extraction",
     "worker_app.tasks.voice_clone",
     "worker_app.tasks.tts_synthesis",
+    "worker_app.tasks.edit_plan_generation",
+    "worker_app.tasks.compose_video",
     "worker_app.tasks.batch_download",
     "worker_app.tasks._startup",
     "apps.worker.video_processing.dedup",
-    "worker_app.tasks.cleanup",
 )
-
-# Celery Beat 定时任务调度
-celery_app.conf.beat_schedule = {
-    "cleanup-stale-pending-tasks": {
-        "task": "worker.cleanup_stale_pending_tasks",
-        "schedule": 600.0,  # 每 10 分钟（秒）
-        "options": {"expires": 300},  # 5 分钟过期，避免堆积
-    },
-}

apps/worker/worker_app/tasks/__init__.py

@@ -25,6 +25,10 @@ def __getattr__(name: str):
         from .voice_extraction import extract_voice_task
 
         return extract_voice_task
+    elif name == "compose_video":
+        from .compose_video import compose_video
+
+        return compose_video
     elif name == "extract_background_task":
         from .voice_extraction import extract_background_task
 
@@ -54,6 +58,7 @@ def __getattr__(name: str):
 
 __all__ = [
     "classify_asset",
+    "compose_video",
     "generate_video",
     "healthcheck",
     "ingest_asset",