@oh-story/dsh 0.1.12 → 0.1.13

package/lib/drama/skills/short-drama-edit/scripts/edit_tool.py

@@ -5,8 +5,9 @@ Three subcommands, deliberately separated so a report can never borrow one's
 evidence for another's claim:
 
 ``check``   parse and cross-check ``剪辑单.md`` against the project. No rendering.
-``render``  cut, join, mix sound effects, burn subtitles and screen text, and
-            normalize loudness into 制作成果/成片/.
+``render``  cut video and draw stills, join, mix sound effects and voice lines,
+            burn subtitles and screen text, and normalize loudness into
+            制作成果/成片/.
 ``verify``  measure an already-rendered film and print the numbers.
 
 ``verify`` prints measurements, never verdicts. Whether the film is any good is
@@ -16,6 +17,7 @@ a question for review or for the creator, and no number here answers it.
 from __future__ import annotations
 
 import argparse
+from array import array
 import json
 import operator
 import re
@@ -24,7 +26,7 @@ import subprocess
 import sys
 import tempfile
 from pathlib import Path
-from typing import Any, Callable, NamedTuple, Optional, Sequence, Union
+from typing import Any, Callable, Iterable, NamedTuple, Optional, Sequence, Union
 
 MINIMUM_PYTHON = (3, 9)
 if sys.version_info < MINIMUM_PYTHON:
@@ -81,8 +83,57 @@ FIELD = re.compile(r"^-\s*([^：]+)：\s*(.*)$")
 UNUSED_LINE = re.compile(r"^-\s*未采用镜头：\s*(.*)$")
 # A source line is "MOTION-... · relative/path". The separator is the same
 # middle dot the storyboard uses for reference slots, so the two documents read
-# alike; a plain slash would collide with the path itself.
-SOURCE = re.compile(r"^(MOTION-\S+)\s*·\s*(.+?)\s*$")
+# alike; a plain slash would collide with the path itself. A still cut -- the
+# static 漫剧 route, keyframes and voiceover -- names the storyboard shot or the
+# image prompt its picture answers to instead.
+SOURCE = re.compile(r"^((?:MOTION|SHOT|IMG)-\S+)\s*·\s*(.+?)\s*$")
+IMAGE_DOCUMENT = "图片提示词.md"
+IMAGE_HEADING = re.compile(r"^##\s+(IMG-[^\s·]+)")
+IMAGE_SUFFIXES = {".png", ".jpg", ".jpeg", ".webp"}
+# A still holds the screen for as long as it is written to; shorter than this
+# it reads as a flash frame rather than a shot.
+STILL_MINIMUM = 0.50
+# 「运镜：推近 8%」 moves the frame across a still. Past 30% the picture is
+# being re-framed, not moved, and the upscale starts to show.
+CAMERA_MOVES = ("推近", "拉远", "左移", "右移", "上移", "下移")
+CAMERA_MOVE = re.compile(r"^(" + "|".join(CAMERA_MOVES) + r")\s*([0-9]+)\s*[%％]$")
+# 「推近 2.5%/秒」: a speed rather than a distance, so a scene's cuts can share
+# one and the move runs on through the cut instead of settling at every one.
+CAMERA_RATE = re.compile(
+    r"^(" + "|".join(CAMERA_MOVES) + r")\s*([0-9]+(?:\.[0-9]+)?)\s*[%％]\s*[/／]\s*秒$"
+)
+CAMERA_HOLD = "固定"
+CAMERA_MOVE_LIMITS = (1, 30)
+CAMERA_RATE_LIMITS = (0.1, 10.0)
+# A move that starts or stops from rest ramps its speed over this long.
+CAMERA_EASE = 0.5
+CAMERA_OPPOSITES = {"推近": "拉远", "拉远": "推近", "左移": "右移", "右移": "左移", "上移": "下移", "下移": "上移"}
+# Adjacent moves in one scene whose speeds differ by more than this read as a lurch.
+CAMERA_SPEED_NOTICE = 0.30
+# 「环境声：[<起>] <文件>」 lays a room under the film from this cut on, looping the
+# file, until the next 环境声 line (「无」 stops it).
+BED_FIELD = "环境声"
+BED = re.compile(r"^\s*(?:(-?[0-9]+(?:\.[0-9]+)?)\s+)?(.+?)\s*$")
+BED_FADE = 0.3
+# The silent track under a still when there is no video audio to match.
+STILL_AUDIO = (48000, "stereo")
+# 「配音 N：<起> <文件>」 plays a voice file to its end, from its cut's start plus
+# 起. It may run on over the cuts after it (an L-cut), and 起 may be negative, as
+# far back as the previous cut's start (a J-cut): the line is part of the film's
+# sound, not of one picture.
+VOICE_FIELD = re.compile(r"^配音(?:\s*(\d+))?$")
+VOICE = re.compile(r"^\s*(-?[0-9]+(?:\.[0-9]+)?)\s+(.+?)\s*$")
+VOICE_OVERRUN = 0.05
+# A sound line's trailing 「（起点：<秒>；增益：<dB>）」, either or both, in any order.
+SOUND_OPTIONS = re.compile(r"[（(]\s*((?:起点|增益)[：:][^（）()]*)[）)]\s*$")
+SOUND_OPTION = re.compile(r"^(起点|增益)[：:]\s*([+-]?[0-9]+(?:\.[0-9]+)?)\s*(dB)?$", re.I)
+# What counts as audible in a voice file: a 20 ms window within this many dB of
+# its loudest window. TTS pads each line with a breath of silence at both ends;
+# measured on the files, the checks would keep two lines 0.4 s apart that are
+# not overlapping at all.
+AUDIBLE_RANGE_DB = 40.0
+AUDIBLE_WINDOW = 0.02
+AUDIBLE_RATE = 8000
 SUBTITLE_WINDOW = re.compile(r"^\s*([0-9.]+)\s*[-–~]\s*([0-9.]+)\s*$")
 # One shot can carry several lines: an exchange of three is one shot, not three.
 # Numbered fields keep them ordered and let each one state its own window.
@@ -134,7 +185,6 @@ SCREENPLAY_SCREEN_TEXT = re.compile(r"^\s*\[画面文字\]\s*(.+?)\s*$", re.MULT
 # screen: a chip that persists across five shots must not re-enter five times.
 SCREEN_TEXT_JOIN_GAP = 0.05
 SOUND_EFFECT_FIELD = re.compile(r"^音效(?:\s*(\d+))?$")
-GAIN = re.compile(r"[（(]增益[：:]\s*([+-]?[0-9]+(?:\.[0-9]+)?)\s*(?:dB)?\s*[）)]\s*$", re.I)
 GAIN_LIMITS = (-40.0, 6.0)
 # A shot-match is three numbers and nothing else. Anything richer belongs in a
 # grading tool, and anything implicit belongs nowhere: a correction the cut list
@@ -211,11 +261,61 @@ class SoundEffect(NamedTuple):
     end: float
     path: str
     gain_db: float = 0.0
+    # 「起点」: where in the file playback begins.
+    offset: float = 0.0
+
+
+class CameraMove(NamedTuple):
+    """「运镜」 on a still: 固定, a push, pull or pan of `amount` percent, or at `rate` %/s."""
+
+    kind: str = CAMERA_HOLD
+    amount: float = 0
+    rate: Optional[float] = None
+
+
+class Bed(NamedTuple):
+    """One 「环境声」 line: from `start` seconds into its cut, `path` looping; None is 「无」."""
+
+    start: float
+    path: Optional[str]
+    gain_db: float = 0.0
+    offset: float = 0.0
+
+
+class Placed(NamedTuple):
+    """A sound laid on the film: output start and length, the file, and how it is played."""
+
+    start: float
+    duration: float
+    path: str
+    gain_db: float = 0.0
+    offset: float = 0.0
+    loop: bool = False
+    fade_in: float = 0.0
+    fade_out: float = 0.05
+
+
+class Voice(NamedTuple):
+    """One 「配音」 line: the file from `offset` to its end, `start` seconds into the cut."""
+
+    start: float
+    path: str
+    gain_db: float = 0.0
+    offset: float = 0.0
+
+
+class Audible(NamedTuple):
+    """A sound file's length and the span inside it that is not silence, in seconds."""
+
+    duration: float
+    head: float
+    tail: float
 
 
 class Cut(NamedTuple):
     cut_id: str
     title: str
+    # The source ID: MOTION-... for a video cut, SHOT-... or IMG-... for a still.
     motion: str
     media: str
     start: float
@@ -228,6 +328,14 @@ class Cut(NamedTuple):
     sound_effects: tuple[SoundEffect, ...] = ()
     # 「画面：不校」: neither a stated nor an automatic correction.
     untouched: bool = False
+    # Stills only; None on a video cut.
+    move: Optional[CameraMove] = None
+    voices: tuple[Voice, ...] = ()
+    bed: Optional[Bed] = None
+
+    @property
+    def still(self) -> bool:
+        return not self.motion.startswith("MOTION-")
 
 
 class Delivery(NamedTuple):
@@ -369,6 +477,7 @@ def _repeated_field(name: str, cut_id: str, line: int) -> str:
     where = f"{CUT_LIST_NAME}:{line}: {cut_id} 的「{name}」写了两遍"
     for pattern, label in (
         (SUBTITLE_FIELD, "字幕"), (SCREEN_TEXT_FIELD, "画面文字"), (SOUND_EFFECT_FIELD, "音效"),
+        (VOICE_FIELD, "配音"),
     ):
         if pattern.match(name):
             return f"{where}；一段有多条{label}时全部编号，且编号不重复：「{label} 1」「{label} 2」…"
@@ -390,7 +499,15 @@ def _finish_cut(pending: dict[str, Any]) -> Cut:
     if not source:
         raise EditError(
             f"{CUT_LIST_NAME}:{source_line}: {cut_id} 的来源要写成 "
-            f"「MOTION-... · 项目相对路径」，当前是 {source_raw!r}"
+            f"「MOTION-... · 项目相对路径」，静帧写「SHOT-... · 图片路径」或「IMG-... · 图片路径」，"
+            f"当前是 {source_raw!r}"
+        )
+    still = not source.group(1).startswith("MOTION-")
+    if still != (Path(source.group(2)).suffix.lower() in IMAGE_SUFFIXES):
+        raise EditError(
+            f"{CUT_LIST_NAME}:{source_line}: {cut_id} 的来源 {source.group(1)} 与文件类型不符；"
+            "视频素材写 MOTION-...，静帧（" + "/".join(sorted(IMAGE_SUFFIXES))
+            + "）写 SHOT-... 或 IMG-..."
         )
     start_raw, start_line = required("入点")
     end_raw, end_line = required("出点")
@@ -432,9 +549,64 @@ def _finish_cut(pending: dict[str, Any]) -> Cut:
         screen_texts=_parse_screen_texts(fields, cut_id=cut_id, line=line),
         sound_effects=_parse_sound_effects(fields, cut_id=cut_id, line=line),
         untouched=untouched,
+        move=_parse_move(fields, cut_id=cut_id, still=still),
+        voices=_parse_voices(fields, cut_id=cut_id, line=line),
+        bed=_parse_bed(fields, cut_id=cut_id),
     )
 
 
+def _parse_bed(fields: dict[str, tuple[str, int]], *, cut_id: str) -> Optional[Bed]:
+    """Read 「环境声：[<起>] <文件>（起点：<秒>；增益：<dB>）」 or 「环境声：[<起>] 无」."""
+
+    raw = fields.get(BED_FIELD)
+    if raw is None:
+        return None
+    value, gain, offset = _sound_options(raw[0], BED_FIELD, cut_id=cut_id, where=raw[1])
+    found = BED.match(value)
+    # A bed has a start, not a window: it runs until the next 环境声 line.
+    if not found or SUBTITLE_CUE.match(value):
+        raise EditError(
+            f"{CUT_LIST_NAME}:{raw[1]}: {cut_id} 的「环境声」要写成「[<起>] <项目相对路径>」或「[<起>] 无」"
+        )
+    path = found.group(2)
+    return Bed(float(found.group(1) or 0.0), None if path == "无" else path, gain, offset)
+
+
+def _parse_move(
+    fields: dict[str, tuple[str, int]], *, cut_id: str, still: bool
+) -> Optional[CameraMove]:
+    """Read 「运镜：固定|推近 <n>%|拉远|左移|右移|上移|下移」. Stills only; default 固定."""
+
+    raw = fields.get("运镜")
+    if raw is None:
+        return CameraMove() if still else None
+    value, where = raw[0].strip(), raw[1]
+    if not still:
+        raise EditError(
+            f"{CUT_LIST_NAME}:{where}: {cut_id} 是视频段，「运镜」只写在静帧段上；"
+            "视频的运镜在生成时就定了"
+        )
+    if value == CAMERA_HOLD:
+        return CameraMove()
+    paced = CAMERA_RATE.match(value)
+    if paced:
+        low, high = CAMERA_RATE_LIMITS
+        rate = float(paced.group(2))
+        if not low <= rate <= high:
+            raise EditError(
+                f"{CUT_LIST_NAME}:{where}: {cut_id} 的运镜速度 {rate:g}%/秒 超出 {low:g}–{high:g}"
+            )
+        return CameraMove(paced.group(1), 0, rate)
+    found = CAMERA_MOVE.match(value)
+    low, high = CAMERA_MOVE_LIMITS
+    if not found or not low <= int(found.group(2)) <= high:
+        raise EditError(
+            f"{CUT_LIST_NAME}:{where}: {cut_id} 的运镜要写成「{CAMERA_HOLD}」、"
+            f"「{'/'.join(CAMERA_MOVES)} <{low}–{high}>%」或「… <速度>%/秒」，当前是 {value!r}"
+        )
+    return CameraMove(found.group(1), int(found.group(2)))
+
+
 def _field_entries(
     fields: dict[str, tuple[str, int]],
     pattern: re.Pattern[str],
@@ -544,37 +716,79 @@ def _parse_screen_texts(
     return tuple(texts)
 
 
+def _sound_options(
+    value: str, label: str, *, cut_id: str, where: int
+) -> tuple[str, float, float]:
+    """Split 「（起点：<秒>；增益：<dB>）」 off a sound line: (rest, dB, 起点 seconds)."""
+
+    stated = SOUND_OPTIONS.search(value)
+    if not stated:
+        return value, 0.0, 0.0
+    options: dict[str, float] = {}
+    for part in re.split(r"[；;]", stated.group(1)):
+        found = SOUND_OPTION.match(part.strip())
+        if not found or found.group(1) in options or (found.group(3) and found.group(1) != "增益"):
+            raise EditError(
+                f"{CUT_LIST_NAME}:{where}: {cut_id} 的「{label}」括号里只写「起点：<秒>」"
+                f"和「增益：<dB>」，各至多一次，用「；」分隔，当前是 {part.strip()!r}"
+            )
+        options[found.group(1)] = float(found.group(2))
+    gain, offset = options.get("增益", 0.0), options.get("起点", 0.0)
+    low, high = GAIN_LIMITS
+    if not low <= gain <= high:
+        raise EditError(
+            f"{CUT_LIST_NAME}:{where}: {cut_id} 的「{label}」增益 {gain:g} dB "
+            f"超出 {low:g} 到 {high:g}"
+        )
+    if offset < 0:
+        raise EditError(f"{CUT_LIST_NAME}:{where}: {cut_id} 的「{label}」起点不能为负")
+    return value[: stated.start()], gain, offset
+
+
 def _parse_sound_effects(
     fields: dict[str, tuple[str, int]], *, cut_id: str, line: int
 ) -> tuple[SoundEffect, ...]:
-    """Read 「音效 N：<起>-<止> <文件>（增益：<dB>）」 lines."""
+    """Read 「音效 N：<起>-<止> <文件>（起点：<秒>；增益：<dB>）」 lines."""
 
     _, entries = _field_entries(fields, SOUND_EFFECT_FIELD, "音效", cut_id=cut_id, line=line)
     effects: list[SoundEffect] = []
     for index, value, where in entries:
         if value.strip() == "无":
             continue
-        gain = 0.0
-        stated = GAIN.search(value)
-        if stated:
-            value = value[: stated.start()]
-            gain = float(stated.group(1))
-            low, high = GAIN_LIMITS
-            if not low <= gain <= high:
-                raise EditError(
-                    f"{CUT_LIST_NAME}:{where}: {cut_id} 的「音效 {index}」增益 {gain:g} dB "
-                    f"超出 {low:g} 到 {high:g}"
-                )
+        value, gain, offset = _sound_options(value, f"音效 {index}", cut_id=cut_id, where=where)
         found = SUBTITLE_CUE.match(value)
         if not found:
             raise EditError(
                 f"{CUT_LIST_NAME}:{where}: {cut_id} 的「音效 {index}」要写成"
                 "「<起>-<止> <项目相对路径>」"
             )
-        effects.append(SoundEffect(float(found.group(1)), float(found.group(2)), found.group(3), gain))
+        effects.append(SoundEffect(
+            float(found.group(1)), float(found.group(2)), found.group(3), gain, offset
+        ))
     return tuple(effects)
 
 
+def _parse_voices(
+    fields: dict[str, tuple[str, int]], *, cut_id: str, line: int
+) -> tuple[Voice, ...]:
+    """Read 「配音 N：<起> <文件>（起点：<秒>；增益：<dB>）」 lines. The file plays to its end."""
+
+    _, entries = _field_entries(fields, VOICE_FIELD, "配音", cut_id=cut_id, line=line)
+    voices: list[Voice] = []
+    for index, value, where in entries:
+        if value.strip() == "无":
+            continue
+        value, gain, offset = _sound_options(value, f"配音 {index}", cut_id=cut_id, where=where)
+        found = VOICE.match(value)
+        if not found:
+            raise EditError(
+                f"{CUT_LIST_NAME}:{where}: {cut_id} 的「配音 {index}」要写成"
+                "「<起> <项目相对路径>」，从起点放到文件结束"
+            )
+        voices.append(Voice(float(found.group(1)), found.group(2), gain, offset))
+    return tuple(voices)
+
+
 def _parse_subtitles(
     fields: dict[str, tuple[str, int]], *, cut_id: str, line: int
 ) -> tuple[Subtitle, ...]:
@@ -688,16 +902,47 @@ def probe_stream(media: Path) -> dict[str, Any]:
     }
 
 
-def _unaccounted_shots(known: set[str], cuts: Sequence[Cut], unused: Sequence[str]) -> list[str]:
-    """Require each source to be used or explicitly omitted with a reason."""
+def _excused(unused: Sequence[str]) -> set[str]:
+    """IDs listed under 「未采用镜头」 with a non-empty reason."""
 
-    used = {cut.motion for cut in cuts}
     excused = set()
     for note in unused:
-        match = re.fullmatch(r"(MOTION-[\w-]+)\s*[（(]理由[：:]\s*(.+?)[）)]", note.strip())
+        match = re.fullmatch(
+            r"((?:MOTION|SHOT|IMG)-[\w-]+)\s*[（(]理由[：:]\s*(.+?)[）)]", note.strip()
+        )
         if match and match.group(2).strip():
             excused.add(match.group(1))
-    missing = sorted(known - used - excused)
+    return excused
+
+
+def probe_audio(media: Path) -> Optional[tuple[int, str]]:
+    """(sample rate, channel layout) of the first audio stream; None when it has none."""
+
+    probe = _require("ffprobe")
+    result = subprocess.run(
+        [probe, "-v", "error", "-select_streams", "a:0", "-show_entries",
+         "stream=sample_rate,channels,channel_layout", "-of", "json", str(media)],
+        capture_output=True, text=True, check=False,
+    )
+    streams = json.loads(result.stdout or "{}").get("streams") if result.returncode == 0 else None
+    if not streams:
+        return None
+    stream = streams[0]
+    layout = stream.get("channel_layout") or ("mono" if stream.get("channels") == 1 else "stereo")
+    return int(stream.get("sample_rate") or STILL_AUDIO[0]), layout
+
+
+def _unaccounted_shots(
+    known: set[str],
+    cuts: Sequence[Cut],
+    unused: Sequence[str],
+    *,
+    accounted: Iterable[str] = (),
+) -> list[str]:
+    """Require each source to be used, accounted for another way, or omitted with a reason."""
+
+    used = {cut.motion for cut in cuts} | set(accounted)
+    missing = sorted(known - used - _excused(unused))
     if not missing:
         return []
     return [
@@ -706,6 +951,196 @@ def _unaccounted_shots(known: set[str], cuts: Sequence[Cut], unused: Sequence[st
     ]
 
 
+def _headings(path: Path, heading: re.Pattern[str]) -> Optional[set[str]]:
+    """The IDs a document declares as `##` headings; None when it does not exist."""
+
+    if not path.is_file():
+        return None
+    return {
+        match.group(1)
+        for match in map(heading.match, path.read_text(encoding="utf-8").splitlines())
+        if match
+    }
+
+
+def _motion_shots(episode: Path) -> dict[str, str]:
+    """`{MOTION-...: SHOT-...}` from each video prompt's 「分镜」 line."""
+
+    fields = _heading_fields(episode / MOTION_DOCUMENT, MOTION_HEADING, "分镜")
+    return {
+        motion: found.group(0)
+        for motion, value in fields.items()
+        for found in [SHOT_REFERENCE.search(value)]
+        if found
+    }
+
+
+def _source_findings(episode: Path, cuts: Sequence[Cut], unused: Sequence[str]) -> list[str]:
+    """Each source ID exists in its document, and each shot is in the film or excused.
+
+    Video prompts are held to coverage when the list has a video cut, storyboard
+    shots when it has a SHOT- still. Across the two, a shot counts once however
+    it reached the film: a MOTION whose storyboard shot went in as a still is
+    accounted for, and so is a SHOT whose MOTION was used or excused.
+    """
+
+    findings: list[str] = []
+    documents = (
+        ("MOTION-", MOTION_DOCUMENT, MOTION_HEADING),
+        ("SHOT-", STORYBOARD_DOCUMENT, SHOT_HEADING),
+        ("IMG-", IMAGE_DOCUMENT, IMAGE_HEADING),
+    )
+    known: dict[str, Optional[set[str]]] = {}
+    for prefix, name, heading in documents:
+        using = [cut for cut in cuts if cut.motion.startswith(prefix)]
+        declared = known[prefix] = _headings(episode / name, heading) if using else None
+        if not using:
+            continue
+        if declared is None:
+            findings.append(f"没有 {episode / name}，来源 {prefix[:-1]} 无法核对")
+            continue
+        findings.extend(
+            f"{CUT_LIST_NAME}:{cut.line_number}: {cut.cut_id} 的来源 "
+            f"{cut.motion} 不在《{name}》中"
+            for cut in using if cut.motion not in declared
+        )
+
+    shot_of = _motion_shots(episode)
+    used = {cut.motion for cut in cuts}
+    motions, shots = known["MOTION-"], known["SHOT-"]
+    if motions is not None:
+        findings.extend(_unaccounted_shots(
+            motions, cuts, unused, accounted={m for m in motions if shot_of.get(m) in used},
+        ))
+    if shots is not None:
+        findings.extend(_unaccounted_shots(
+            shots, cuts, unused,
+            accounted={shot_of[m] for m in used | _excused(unused) if m in shot_of},
+        ))
+    return findings
+
+
+def probe_audible(media: Path) -> Audible:
+    """A sound file's length and where its sound starts and stops, decoded small and mono."""
+
+    ffmpeg = _require("ffmpeg")
+    result = subprocess.run(
+        [ffmpeg, "-v", "error", "-i", str(media), "-ac", "1", "-ar", str(AUDIBLE_RATE),
+         "-f", "s16le", "-"],
+        capture_output=True, check=False,
+    )
+    if result.returncode != 0:
+        raise EditError(f"ffmpeg 读不出声音: {media} ({result.stderr.decode(errors='replace').strip()})")
+    samples = array("h")
+    samples.frombytes(result.stdout[: len(result.stdout) // 2 * 2])
+    if sys.byteorder == "big":
+        samples.byteswap()
+    return _audible_span(samples, AUDIBLE_RATE)
+
+
+def _audible_span(samples: Sequence[int], rate: int) -> Audible:
+    """The first and last 20 ms window within AUDIBLE_RANGE_DB of the loudest one."""
+
+    size = max(1, round(rate * AUDIBLE_WINDOW))
+    energies = [
+        sum(value * value for value in samples[at:at + size]) / len(samples[at:at + size])
+        for at in range(0, len(samples), size)
+    ]
+    duration = len(samples) / rate
+    loudest = max(energies, default=0.0)
+    if loudest <= 0:
+        return Audible(duration, 0.0, 0.0)
+    floor = loudest * 10 ** (-AUDIBLE_RANGE_DB / 10)
+    heard = [index for index, energy in enumerate(energies) if energy >= floor]
+    return Audible(duration, heard[0] * size / rate, min(duration, (heard[-1] + 1) * size / rate))
+
+
+def _voice_sounds(episode: Path, project_root: Path, cuts: Sequence[Cut]) -> dict[str, Audible]:
+    """Every 「配音」 file, measured, keyed as written. Raises when one cannot be read."""
+
+    sounds: dict[str, Audible] = {}
+    for cut in cuts:
+        for voice in cut.voices:
+            if voice.path in sounds:
+                continue
+            media = _resolve_media(episode, project_root, voice.path)
+            if media is None:
+                raise EditError(f"配音文件不存在或不在项目目录内: {voice.path}")
+            sounds[voice.path] = probe_audible(media)
+    return sounds
+
+
+def _voice_spans(
+    cuts: Sequence[Cut], sounds: dict[str, Audible], lengths: Sequence[float]
+) -> list[tuple[float, float, Cut, Voice]]:
+    """Each voice line's audible span in film seconds, cuts laid end to end at `lengths`."""
+
+    spans: list[tuple[float, float, Cut, Voice]] = []
+    for cut, cursor, length in _timeline(cuts, lengths):
+        for voice in cut.voices:
+            sound = sounds[voice.path]
+            # Where the file's own second zero lands on the film.
+            zero = _at(cut, cursor, length, voice.start) - voice.offset
+            spans.append((zero + max(sound.head, voice.offset), zero + sound.tail, cut, voice))
+    return sorted(spans, key=lambda span: span[0])
+
+
+def _voice_findings(
+    cuts: Sequence[Cut], sounds: dict[str, Audible], lengths: Sequence[float]
+) -> list[str]:
+    """A voice line is heard inside the film and never over another line, across cuts too."""
+
+    total = sum(lengths)
+    findings: list[str] = []
+    latest: Optional[tuple[float, float, Cut, Voice]] = None
+    for span in _voice_spans(cuts, sounds, lengths):
+        start, end, cut, voice = span
+        where = f"{CUT_LIST_NAME}:{cut.line_number}: {cut.cut_id}"
+        if end <= start:
+            findings.append(f"{where} 的配音 {voice.path} 起点 {voice.offset:g} 秒之后没有声音")
+            continue
+        if end > total + VOICE_OVERRUN:
+            findings.append(
+                f"{where} 的配音 {voice.path} 在成片 {start:.2f} 秒开口、{end:.2f} 秒才说完，"
+                f"超出成片结尾 {total:.2f}；加长末几段或提前起点"
+            )
+        if latest is not None and start < latest[1] - TOLERANCE:
+            findings.append(
+                f"{where} 的配音 {voice.path}（成片 {start:.2f} 秒开口）压在 {latest[2].cut_id} 的"
+                f"配音 {latest[3].path} 上（说到 {latest[1]:.2f} 秒）"
+            )
+        if latest is None or end > latest[1]:
+            latest = span
+    return findings
+
+
+def _subtitle_findings(cuts: Sequence[Cut], lengths: Sequence[float]) -> list[str]:
+    """A subtitle may run on past its cut, but stays in the film and off every other subtitle."""
+
+    total = sum(lengths)
+    placed: list[tuple[float, float, Cut]] = []
+    findings: list[str] = []
+    for cut, cursor, length in _timeline(cuts, lengths):
+        for window_start, window_end, _, _ in cut.subtitles:
+            start = 0.0 if window_start is None else window_start
+            end = cut.declared if window_end is None else window_end
+            shown = (_at(cut, cursor, length, start), _at(cut, cursor, length, end))
+            if not 0 <= start < min(end, cut.declared) or shown[1] > total + TOLERANCE:
+                findings.append(
+                    f"{CUT_LIST_NAME}:{cut.line_number}: {cut.cut_id} 的字幕时间要从本段内开始、"
+                    f"在成片结尾之前结束: {start:g}-{end:g}"
+                )
+            placed.append((*shown, cut))
+    placed.sort(key=lambda item: item[0])
+    for (_, end, earlier), (start, _, later) in zip(placed, placed[1:]):
+        if earlier is not later and start < end - TOLERANCE:
+            findings.append(
+                f"{CUT_LIST_NAME}:{later.line_number}: {later.cut_id} 的字幕与 {earlier.cut_id} "
+                f"跨过来的字幕同时在屏上（成片 {start:.2f} 秒）"
+            )
+    return findings
+
+
 def check_cuts(
     episode: Path,
     cuts: Sequence[Cut],
@@ -713,8 +1148,17 @@ def check_cuts(
     *,
     probe: bool,
     unused: Sequence[str] = (),
+    delivery: Optional[Delivery] = None,
+    listen: Optional[bool] = None,
 ) -> list[str]:
-    """Every mechanical cross-check the cut list can be held to. Returns findings."""
+    """Every mechanical cross-check the cut list can be held to. Returns findings.
+
+    `probe` reads media with ffprobe; `listen` (default: `probe`) decodes voice
+    files with ffmpeg to find where they are audible.
+    """
+
+    if listen is None:
+        listen = probe
 
     findings: list[str] = []
     if not cuts:
@@ -727,25 +1171,22 @@ def check_cuts(
             findings.append(f"{CUT_LIST_NAME}:{cut.line_number}: CUT ID 重复: {cut.cut_id}")
         seen.add(cut.cut_id)
 
-    motion_path = episode / MOTION_DOCUMENT
-    if motion_path.is_file():
-        known = {
-            match.group(1)
-            for match in (
-                MOTION_HEADING.match(line)
-                for line in motion_path.read_text(encoding="utf-8").splitlines()
+    findings.extend(_source_findings(episode, cuts, unused))
+    # Stills are drawn at the delivery frame; video in the same film must match it.
+    spec: Optional[tuple[Any, Any, float]] = None
+    if any(cut.still for cut in cuts):
+        if delivery is None or delivery.frame_size is None or delivery.fps is None:
+            findings.append(
+                f"{CUT_LIST_NAME}: 有静帧段时，交付规格必须写「画幅与帧率」"
+                "（如 1080×1920 · 24fps）；静帧按它出画"
             )
-            if match
-        }
-        for cut in cuts:
-            if cut.motion not in known:
+        else:
+            spec = (*delivery.frame_size, round(delivery.fps, 3))
+            if any(side % 2 for side in delivery.frame_size):
                 findings.append(
-                    f"{CUT_LIST_NAME}:{cut.line_number}: {cut.cut_id} 的来源 "
-                    f"{cut.motion} 不在《{MOTION_DOCUMENT}》中"
+                    f"{CUT_LIST_NAME}: 交付画幅 {delivery.frame_size[0]}×{delivery.frame_size[1]} "
+                    "有奇数边；静帧按它编码成 4:2:0，宽高都要是偶数"
                 )
-        findings.extend(_unaccounted_shots(known, cuts, unused))
-    else:
-        findings.append(f"没有 {motion_path}，来源 MOTION 无法核对")
 
     screenplay = ""
     screenplay_path = episode / SCREENPLAY_DOCUMENT
@@ -753,6 +1194,7 @@ def check_cuts(
         screenplay = screenplay_path.read_text(encoding="utf-8")
 
     media_format: Optional[tuple[Any, Any, float]] = None
+    voiced = True
     for cut in cuts:
         span = cut.end - cut.start
         if cut.start < 0:
@@ -766,11 +1208,28 @@ def check_cuts(
                 f"{CUT_LIST_NAME}:{cut.line_number}: {cut.cut_id} 出点 - 入点 = "
                 f"{span:.2f}，与「时长：{cut.declared:.2f}」不符"
             )
+        if cut.still and abs(cut.start) > TOLERANCE:
+            findings.append(
+                f"{CUT_LIST_NAME}:{cut.line_number}: {cut.cut_id} 是静帧，入点必须是 0.00，"
+                "出点等于时长"
+            )
+        if cut.still and cut.declared < STILL_MINIMUM - TOLERANCE:
+            findings.append(
+                f"{CUT_LIST_NAME}:{cut.line_number}: {cut.cut_id} 是静帧，时长 "
+                f"{cut.declared:.2f} 短于 {STILL_MINIMUM:.2f} 秒"
+            )
         media = _resolve_media(episode, project_root, cut.media)
         if media is None:
             findings.append(
-                f"{CUT_LIST_NAME}:{cut.line_number}: {cut.cut_id} 的素材不存在: {cut.media}"
+                f"{CUT_LIST_NAME}:{cut.line_number}: {cut.cut_id} 的素材不存在或不在项目目录内: {cut.media}"
             )
+        elif probe and cut.still:
+            try:
+                probe_stream(media)
+            except EditError as error:
+                findings.append(
+                    f"{CUT_LIST_NAME}:{cut.line_number}: {cut.cut_id} 的图片读不出: {error}"
+                )
         elif probe:
             stream = probe_stream(media)
             available = stream["duration"]
@@ -783,35 +1242,87 @@ def check_cuts(
                     f"{current_format} 与首段 {media_format} 不一致；"
                     "先在外部统一素材规格，再更新来源路径与入出点"
                 )
+            if spec is not None and current_format != spec:
+                findings.append(
+                    f"{CUT_LIST_NAME}:{cut.line_number}: {cut.cut_id} 的画幅或帧率 "
+                    f"{current_format} 与交付规格 {spec} 不一致；静帧按交付规格出画，"
+                    "同一条片里的视频段须与之相同"
+                )
             if cut.end > available + TOLERANCE:
                 findings.append(
                     f"{CUT_LIST_NAME}:{cut.line_number}: {cut.cut_id} 出点 {cut.end:.2f} "
                     f"超过素材实际时长 {available:.2f}"
                 )
-        for window_start, window_end, text, _ in cut.subtitles:
+        for _, _, text, _ in cut.subtitles:
             if screenplay and _normalize(text) not in _normalize(screenplay):
                 findings.append(
                     f"{CUT_LIST_NAME}:{cut.line_number}: {cut.cut_id} 的字幕在《"
                     f"{SCREENPLAY_DOCUMENT}》里找不到原文: {text}"
                 )
-            if window_start is None or window_end is None:
-                continue
-            if not 0 <= window_start < window_end <= span + TOLERANCE:
-                findings.append(
-                    f"{CUT_LIST_NAME}:{cut.line_number}: {cut.cut_id} 的字幕时间超出本段区间"
-                    f": {window_start}-{window_end}"
-                )
         for effect in cut.sound_effects:
             if not 0 <= effect.start < effect.end <= span + TOLERANCE:
                 findings.append(
                     f"{CUT_LIST_NAME}:{cut.line_number}: {cut.cut_id} 的音效时间超出本段区间"
                     f": {effect.start:g}-{effect.end:g}"
                 )
-            if _resolve_media(episode, project_root, effect.path) is None:
+            effect_media = _resolve_media(episode, project_root, effect.path)
+            if effect_media is None:
                 findings.append(
-                    f"{CUT_LIST_NAME}:{cut.line_number}: {cut.cut_id} 的音效文件不存在: "
+                    f"{CUT_LIST_NAME}:{cut.line_number}: {cut.cut_id} 的音效文件不存在或不在项目目录内: "
                     f"{effect.path}"
                 )
+            elif probe and effect.offset > 0:
+                try:
+                    available_sound = probe_duration(effect_media)
+                    if effect.offset >= available_sound:
+                        findings.append(
+                            f"{CUT_LIST_NAME}:{cut.line_number}: {cut.cut_id} 的音效起点 "
+                            f"{effect.offset:g} 必须小于 {effect.path} 的实际时长 {available_sound:g}"
+                        )
+                except EditError as error:
+                    findings.append(f"{CUT_LIST_NAME}:{cut.line_number}: {cut.cut_id} 的音效读不出: {error}")
+        for voice in cut.voices:
+            if _resolve_media(episode, project_root, voice.path) is None:
+                voiced = False
+                findings.append(
+                    f"{CUT_LIST_NAME}:{cut.line_number}: {cut.cut_id} 的配音文件不存在或不在项目目录内: "
+                    f"{voice.path}"
+                )
+
+    # The film's rate: the spec's, else the one the probe loop read off the video.
+    fps = delivery.fps if delivery is not None and delivery.fps else (media_format or (0, 0, 0.0))[2]
+    lengths = _film_spans(cuts, fps)
+    for index, cut in enumerate(cuts):
+        where = f"{CUT_LIST_NAME}:{cut.line_number}: {cut.cut_id}"
+        if cut.move is not None and cut.move.rate is not None:
+            reach = cut.move.rate * lengths[index]
+            if reach > CAMERA_MOVE_LIMITS[1]:
+                findings.append(
+                    f"{where} 的运镜 {cut.move.rate:g}%/秒 走完这一段是 {reach:.0f}%，"
+                    f"超过 {CAMERA_MOVE_LIMITS[1]}%；放慢或缩短这一段"
+                )
+        if cut.bed is not None:
+            earliest = -lengths[index - 1] if index else 0.0
+            if not earliest - TOLERANCE <= cut.bed.start < cut.end - cut.start:
+                findings.append(
+                    f"{where} 的环境声起点 {cut.bed.start:g} 要在 {earliest:g}（上一段开头）到本段结尾之间"
+                )
+            if cut.bed.path is not None and _resolve_media(episode, project_root, cut.bed.path) is None:
+                findings.append(f"{where} 的环境声文件不存在或不在项目目录内: {cut.bed.path}")
+        for voice in cut.voices:
+            # A J-cut reaches back at most to the previous cut's start.
+            earliest = -lengths[index - 1] if index else 0.0
+            if not earliest - TOLERANCE <= voice.start < cut.end - cut.start:
+                findings.append(
+                    f"{CUT_LIST_NAME}:{cut.line_number}: {cut.cut_id} 的配音起点 {voice.start:g} "
+                    f"要在 {earliest:g}（上一段开头）到本段结尾之间"
+                )
+    findings.extend(_subtitle_findings(cuts, lengths))
+    if listen and voiced and any(cut.voices for cut in cuts):
+        try:
+            findings.extend(_voice_findings(cuts, _voice_sounds(episode, project_root, cuts), lengths))
+        except EditError as error:
+            findings.append(f"{CUT_LIST_NAME}: {error}")
 
     findings.extend(_screen_text_findings(cuts, screenplay))
     findings.extend(_overlap_findings(cuts))
@@ -876,22 +1387,26 @@ def _stale_window_findings(
             any(subtitle[0] is not None for subtitle in cut.subtitles)
             or cut.screen_texts
             or cut.sound_effects
+            or cut.voices
         )
         if not timed:
             continue
-        media = _resolve_media(episode, project_root, cut.media)
-        if media is None:
-            continue
-        try:
-            changed = media.stat().st_mtime
-        except OSError:
-            continue
-        if changed > authored + 1.0:
-            findings.append(
-                f"{CUT_LIST_NAME}:{cut.line_number}: {cut.cut_id} 的素材比剪辑单新"
-                f"（{cut.media}）；这一段的字幕、画面文字与音效时间是按旧素材反推的，"
-                "重出之后必须重测再改，不能沿用"
-            )
+        # A still's timings were measured on its voice files, not on the picture.
+        written = [voice.path for voice in cut.voices] + ([] if cut.still else [cut.media])
+        for relative in written:
+            media = _resolve_media(episode, project_root, relative)
+            if media is None:
+                continue
+            try:
+                changed = media.stat().st_mtime
+            except OSError:
+                continue
+            if changed > authored + 1.0:
+                findings.append(
+                    f"{CUT_LIST_NAME}:{cut.line_number}: {cut.cut_id} 的素材比剪辑单新"
+                    f"（{relative}）；这一段的字幕、画面文字与音效时间是按旧素材反推的，"
+                    "重出之后必须重测再改，不能沿用"
+                )
     return findings
 
 
@@ -901,7 +1416,9 @@ def _overlap_findings(cuts: Sequence[Cut]) -> list[str]:
     findings: list[str] = []
     by_media: dict[str, list[Cut]] = {}
     for cut in cuts:
-        by_media.setdefault(cut.media, []).append(cut)
+        # A keyframe reused in a shot/reverse-shot is a choice, not repeated footage.
+        if not cut.still:
+            by_media.setdefault(cut.media, []).append(cut)
     for media, group in by_media.items():
         ordered = sorted(group, key=lambda item: item.start)
         for earlier, later in zip(ordered, ordered[1:]):
@@ -920,9 +1437,16 @@ def _normalize(text: str) -> str:
 
 
 def _resolve_media(episode: Path, project_root: Path, relative: str) -> Optional[Path]:
+    """The file a cut list names, against the episode then the project; None if absent.
+
+    A path that leaves the project (`../`, an absolute path, a link out) is
+    treated as absent: the cut list describes this project's material only.
+    """
+
+    root = project_root.resolve()
     for base in (episode, project_root):
         candidate = (base / relative).resolve()
-        if candidate.is_file():
+        if candidate.is_file() and (candidate == root or root in candidate.parents):
             return candidate
     return None
 
@@ -946,31 +1470,62 @@ def render(
 
     def measure(cut: Cut) -> Optional[ChannelStats]:
         media = _resolve_media(episode, project_root, cut.media)
-        return None if media is None else _channel_stats(ffmpeg, media, cut.start, cut.end - cut.start)
+        if media is None:
+            return None
+        if cut.still:
+            return None if delivery.frame_size is None else _still_stats(
+                ffmpeg, media, delivery.frame_size
+            )
+        return _channel_stats(ffmpeg, media, cut.start, cut.end - cut.start)
 
     scenes = _scene_keys(episode, cuts)
     pictures, auto = _picture_plan(cuts, scenes, measure, enabled=delivery.shot_match)
+    silence = _silent_track(episode, project_root, cuts, delivery)
+    sounds = _voice_sounds(episode, project_root, cuts)
+    fps = _film_fps(episode, project_root, cuts, delivery, probe=True)
+    spans = _film_spans(cuts, fps)
 
+    eases = _move_ease(cuts, scenes)
     segments: list[Path] = []
-    spans: list[float] = []
-    for cut, match in zip(cuts, pictures):
+    for cut, match, length, ease in zip(cuts, pictures, spans, eases):
         media = _resolve_media(episode, project_root, cut.media)
         if media is None:
-            raise EditError(f"{cut.cut_id} 的素材不存在: {cut.media}")
+            raise EditError(f"{cut.cut_id} 的素材不存在或不在项目目录内: {cut.media}")
         segment = segments_root / f"{cut.cut_id}.mp4"
-        command = [
-            ffmpeg, "-hide_banner", "-loglevel", "error", "-y",
-            "-ss", f"{cut.start:.3f}", "-t", f"{cut.end - cut.start:.3f}", "-i", str(media),
-        ]
-        if match:
-            command += ["-vf", match]
+        if cut.still:
+            command = _still_command(ffmpeg, media, cut, delivery, silence, match, length, ease)
+        else:
+            # Read enough source for the whole frames the film gives this cut.
+            span = max(cut.end - cut.start, length)
+            command = [
+                ffmpeg, "-hide_banner", "-loglevel", "error", "-y",
+                "-ss", f"{cut.start:.3f}", "-t", f"{span:.3f}", "-i", str(media),
+            ]
+            if probe_audio(media) is None:
+                rate, layout = silence
+                command += [
+                    "-f", "lavfi", "-t", f"{span:.3f}", "-i", f"anullsrc=r={rate}:cl={layout}",
+                    "-map", "0:v", "-map", "1:a",
+                ]
+            if match:
+                command += ["-vf", match]
+            if fps:
+                command += ["-frames:v", str(round(length * fps)), "-t", f"{length:.6f}"]
         command += [
             "-c:v", "libx264", "-preset", "medium", "-crf", "18", "-pix_fmt", "yuv420p",
+            "-ar", str(silence[0]), "-channel_layout", silence[1],
             "-c:a", "aac", "-b:a", "192k", str(segment),
         ]
         _run(command)
         segments.append(segment)
-        spans.append(probe_duration(segment))
+        # Everything after this cut is placed by `spans`; a segment that came
+        # out short (the source ran out of frames) would shift all of it.
+        rendered = probe_duration(segment)
+        if fps and abs(rendered - length) > 1.5 / fps:
+            raise EditError(
+                f"{cut.cut_id} 渲染出 {rendered:.3f} 秒，按 {fps:g} fps 应为 {length:.3f} 秒；"
+                "素材在出点附近可能不够帧，先把出点提前一帧"
+            )
 
     with tempfile.TemporaryDirectory() as scratch:
         listing = Path(scratch) / "segments.txt"
@@ -978,15 +1533,22 @@ def render(
             "".join(f"file '{segment.as_posix()}'\n" for segment in segments), encoding="utf-8"
         )
         joined = output_root / "成片-未混音.mp4"
-        _run([ffmpeg, "-hide_banner", "-loglevel", "error", "-y",
+        # AAC encoder priming starts before zero. Keep that timestamp rather
+        # than shifting the video by one audio packet (and duplicating a frame
+        # when downstream tools decode at the delivery frame rate).
+        _run([ffmpeg, "-hide_banner", "-loglevel", "error", "-y", "-copyts",
               "-f", "concat", "-safe", "0", "-i", str(listing), "-c", "copy", str(joined)])
 
-        effects: list[tuple[float, float, Path, float]] = []
-        for start, duration, written, gain in _placed_sound_effects(cuts, spans):
-            resolved = _resolve_media(episode, project_root, written)
+        effects: list[Placed] = []
+        placed = (
+            _placed_sound_effects(cuts, spans) + _placed_voices(cuts, sounds, spans)
+            + _placed_beds(cuts, spans)
+        )
+        for sound in placed:
+            resolved = _resolve_media(episode, project_root, sound.path)
             if resolved is None:
-                raise EditError(f"音效文件不存在: {written}")
-            effects.append((start, duration, resolved, gain))
+                raise EditError(f"音效、配音或环境声文件不存在或不在项目目录内: {sound.path}")
+            effects.append(sound._replace(path=str(resolved)))
         if effects:
             # Mixed into its own file first, so the loudness pass below measures
             # the film the audience hears rather than the one before the chimes.
@@ -1077,13 +1639,182 @@ def render(
         "叠层": str(overlay_path) if overlay_path else None,
         "字幕渲染": renderer if subtitle_path else None,
         "画面文字": len(layers),
-        "音效": len(effects),
+        "音效": sum(len(cut.sound_effects) for cut in cuts),
+        "配音": sum(len(cut.voices) for cut in cuts),
+        "环境声": len(_placed_beds(cuts, spans)),
+        "静帧段": sum(cut.still for cut in cuts),
         "自动接镜": _shot_match_report(auto, scenes, enabled=delivery.shot_match),
         "段数": len(segments),
         "各段时长之和": round(sum(cut.end - cut.start for cut in cuts), 2),
     }
 
 
+def _silent_track(
+    episode: Path, project_root: Path, cuts: Sequence[Cut], delivery: Delivery
+) -> tuple[int, str]:
+    """Shared (sample rate, layout) for every rendered segment.
+
+    Segments are joined by stream copy, so every segment needs an audio track
+    encoded like the first video audio beside it, including audible clips: a
+    segment without one shifts every sound after it, and a mismatched one
+    decodes wrong. 48 kHz stereo when no clip has sound.
+    """
+
+    if any(cut.still for cut in cuts) and (delivery.frame_size is None or delivery.fps is None):
+        raise EditError("有静帧段时，交付规格必须写「画幅与帧率」；静帧按它出画")
+    for cut in cuts:
+        media = None if cut.still else _resolve_media(episode, project_root, cut.media)
+        heard = probe_audio(media) if media is not None else None
+        if heard is not None:
+            return heard
+    return STILL_AUDIO
+
+
+def _move_ease(
+    cuts: Sequence[Cut], scenes: Sequence[Optional[tuple[str, ...]]]
+) -> list[tuple[bool, bool]]:
+    """(ease in, ease out) per cut: a move ramps only where it starts or stops from rest.
+
+    Two adjacent rate moves (「%/秒」) in the same direction and the same scene
+    run straight through the cut between them: the camera does not stop at the
+    join. A move eases in where the cut before it is in another scene, is 固定,
+    or moves some other way, and eases out likewise. The percentage form always
+    eases at both ends: it states where the move ends, not how fast it goes.
+    """
+
+    def continues(earlier: int, later: int) -> bool:
+        first, second = cuts[earlier].move, cuts[later].move
+        return (
+            first is not None and second is not None
+            and first.rate is not None and second.rate is not None
+            and first.kind == second.kind != CAMERA_HOLD
+            and scenes[earlier] is not None and scenes[earlier] == scenes[later]
+        )
+
+    last = len(cuts) - 1
+    return [
+        (not (index and continues(index - 1, index)), not (index < last and continues(index, index + 1)))
+        for index in range(len(cuts))
+    ]
+
+
+def _move_progress(
+    move: CameraMove, frames: int, fps: float, ease: tuple[bool, bool]
+) -> tuple[str, float]:
+    """How far the move has gone at output frame `on`, in percent, and how far it goes in all.
+
+    A rate move cruises at its speed and ramps (a half cosine, CAMERA_EASE long)
+    only at the ends `ease` names, so where it does not ease its speed at the
+    cut equals the next cut's. The percentage form eases over the whole cut.
+    """
+
+    last = max(frames - 1, 1)
+    if move.rate is None:
+        return f"({move.amount}*(1-cos(PI*on/{last}))/2)", float(move.amount)
+    span = last / fps
+    ramp_in = min(CAMERA_EASE, span / 2) if ease[0] else 0.0
+    ramp_out = min(CAMERA_EASE, span / 2) if ease[1] else 0.0
+    t = f"(on/{fps:g})"
+    terms = [t]
+    # Distance lost to each ramp so far: the integral of (1 - speed / cruise).
+    if ramp_in:
+        a = f"min({t},{ramp_in:.6f})"
+        terms.append(f"-({a}+{ramp_in / 3.141592653589793:.6f}*sin(PI*{a}/{ramp_in:.6f}))/2")
+    if ramp_out:
+        b = f"max(0,{t}-{span - ramp_out:.6f})"
+        terms.append(f"-({b}-{ramp_out / 3.141592653589793:.6f}*sin(PI*{b}/{ramp_out:.6f}))/2")
+    total = move.rate * (span - ramp_in / 2 - ramp_out / 2)
+    return f"({move.rate:g}*({''.join(terms)}))", total
+
+
+def _still_filter(
+    move: CameraMove, width: int, height: int, frames: int,
+    fps: float = 24.0, ease: tuple[bool, bool] = (True, True),
+) -> str:
+    """Cover-fit a still to the frame and move across it on an eased curve.
+
+    The move is a window over the fitted picture, `1/zoom` of it on each side,
+    whose corners `perspective` samples per frame at sub-pixel positions.
+    zoompan and crop place the window on whole pixels, which is what makes a
+    slow push judder. Measured on 1080×1920 renders, the frame-to-frame motion
+    of a push wavered 0.34 px rms with zoompan, 0.14 px with zoompan at 4×
+    internal scale and 0.10 px here; of a pan, 0.84, 0.23 and 0.11 px. This
+    route also renders no slower than the 4× one.
+    """
+
+    fitted = (
+        f"scale={width}:{height}:force_original_aspect_ratio=increase:flags=lanczos,"
+        f"crop={width}:{height},setsar=1"
+    )
+    if move.kind == CAMERA_HOLD:
+        return fitted
+    gone, total = _move_progress(move, frames, fps, ease)
+    reach = total / 100
+    # Share of the move done, 0 to 1.
+    eased = f"({gone}/{total:.6f})" if total > 0 else "0"
+    zoom = {
+        "推近": f"(1+{reach:.6f}*{eased})",
+        "拉远": f"(1+{reach:.6f}*(1-{eased}))",
+    }.get(move.kind, f"{1 + reach:.6f}")
+    across, down = f"(W/{zoom})", f"(H/{zoom})"
+    room_x, room_y = f"(W-{across})", f"(H-{down})"
+    # A camera move: 左移 slides the window left, so the picture drifts right.
+    x = {"左移": f"{room_x}*(1-{eased})", "右移": f"{room_x}*{eased}"}.get(move.kind, f"{room_x}/2")
+    y = {"上移": f"{room_y}*(1-{eased})", "下移": f"{room_y}*{eased}"}.get(move.kind, f"{room_y}/2")
+    corners = ((x, y), (f"{x}+{across}", y), (x, f"{y}+{down}"), (f"{x}+{across}", f"{y}+{down}"))
+    points = ":".join(f"x{i}='{cx}':y{i}='{cy}'" for i, (cx, cy) in enumerate(corners))
+    return f"{fitted},perspective={points}:interpolation=cubic:eval=frame"
+
+
+def _still_command(
+    ffmpeg: str,
+    image: Path,
+    cut: Cut,
+    delivery: Delivery,
+    silence: tuple[int, str],
+    match: str,
+    seconds: float,
+    ease: tuple[bool, bool] = (True, True),
+) -> list[str]:
+    """The input half of a still segment's command: picture, move, correction and silence.
+
+    `seconds` is the cut's span from `_film_spans`, a whole number of frames.
+    """
+
+    assert delivery.frame_size is not None and delivery.fps is not None
+    width, height = delivery.frame_size
+    frames = max(1, round(seconds * delivery.fps))
+    chain = _still_filter(cut.move or CameraMove(), width, height, frames, delivery.fps, ease)
+    rate, layout = silence
+    return [
+        ffmpeg, "-hide_banner", "-loglevel", "error", "-y",
+        "-loop", "1", "-framerate", f"{delivery.fps:g}", "-i", str(image),
+        "-f", "lavfi", "-t", f"{seconds:.3f}", "-i", f"anullsrc=r={rate}:cl={layout}",
+        "-vf", ",".join(filter(None, [chain, match])),
+        "-map", "0:v", "-map", "1:a", "-frames:v", str(frames), "-t", f"{seconds:.3f}",
+    ]
+
+
+def _placed_voices(
+    cuts: Sequence[Cut], sounds: dict[str, Audible], spans: Sequence[float]
+) -> list[Placed]:
+    """Each voice line in the form `_placed_sound_effects` gives, for the same mix.
+
+    Its start follows the rendered cut positions, like an effect's. Its length
+    does not: an effect's window is a stretch of its cut and scales with the
+    frame rounding, but a voice plays its file from 起点 to the end, and
+    scaling that would clip the line. It is laid at its cut's start plus 起
+    however far past the cut it runs, which is what makes an L-cut.
+    """
+
+    return [
+        Placed(max(0.0, _at(cut, cursor, length, voice.start)), sounds[voice.path].duration - voice.offset,
+               voice.path, voice.gain_db, voice.offset)
+        for cut, cursor, length in _timeline(cuts, spans)
+        for voice in cut.voices
+    ]
+
+
 def _shot_match_filter(cut: Cut) -> str:
     """The correction a cut states in 「画面：」. It replaces the automatic match."""
 
@@ -1127,20 +1858,54 @@ def _heading_fields(path: Path, heading: re.Pattern[str], field: str) -> dict[st
 def _scene_keys(episode: Path, cuts: Sequence[Cut]) -> list[Optional[tuple[str, ...]]]:
     """Each cut's scene: MOTION → its 分镜 SHOT → the scene IDs that SHOT's 来源 names.
 
-    A shot drawing on two scenes keys on both, so it matches neither neighbour.
-    None where the chain breaks; such a cut is never matched.
+    A SHOT- still starts at the SHOT. A shot drawing on two scenes keys on both,
+    so it matches neither neighbour. None where the chain breaks (an IMG- still
+    names no shot); such a cut is never matched.
     """
 
-    shots = _heading_fields(episode / MOTION_DOCUMENT, MOTION_HEADING, "分镜")
+    shots = _motion_shots(episode)
     sources = _heading_fields(episode / STORYBOARD_DOCUMENT, SHOT_HEADING, "来源")
     keys: list[Optional[tuple[str, ...]]] = []
     for cut in cuts:
-        shot = SHOT_REFERENCE.search(shots.get(cut.motion, ""))
-        scenes = tuple(SCENE_ID.findall(sources.get(shot.group(0), ""))) if shot else ()
+        shot = cut.motion if cut.motion.startswith("SHOT-") else shots.get(cut.motion)
+        scenes = tuple(SCENE_ID.findall(sources.get(shot, ""))) if shot else ()
         keys.append(scenes or None)
     return keys
 
 
+def move_notices(
+    cuts: Sequence[Cut], scenes: Sequence[Optional[tuple[str, ...]]], lengths: Sequence[float]
+) -> list[str]:
+    """Joins inside one scene that will read as a jolt: a speed jump or a reversed move.
+
+    Not errors: a deliberate change of pace is the creator's to make.
+    """
+
+    def speed(cut: Cut, length: float) -> Optional[float]:
+        move = cut.move
+        if move is None or move.kind == CAMERA_HOLD:
+            return None
+        return move.rate if move.rate is not None else move.amount / length if length else None
+
+    notices: list[str] = []
+    for index in range(1, len(cuts)):
+        before, after = cuts[index - 1], cuts[index]
+        if scenes[index - 1] is None or scenes[index - 1] != scenes[index]:
+            continue
+        first, second = speed(before, lengths[index - 1]), speed(after, lengths[index])
+        if first is None or second is None or before.move is None or after.move is None:
+            continue
+        pair = f"{before.cut_id}（{before.move.kind} 约 {first:.1f}%/秒）→ {after.cut_id}（{after.move.kind} 约 {second:.1f}%/秒）"
+        if CAMERA_OPPOSITES[before.move.kind] == after.move.kind:
+            notices.append(f"{pair}：同一场里镜头来回反向，切过去像晃了一下；改成同向，或让其中一段固定")
+        elif max(first, second) > (1 + CAMERA_SPEED_NOTICE) * min(first, second):
+            notices.append(
+                f"{pair}：同一场里运镜速度差了 {max(first, second) / min(first, second) - 1:.0%}，"
+                "切过去像换了一台机器；同一场用一个速度，写成「%/秒」最省事"
+            )
+    return notices
+
+
 def _scene_runs(scenes: Sequence[Optional[tuple[str, ...]]]) -> list[list[int]]:
     """Indexes of consecutive cuts from one scene. Intercut scenes form separate runs."""
 
@@ -1265,11 +2030,30 @@ def _channel_stats(
 ) -> Optional[ChannelStats]:
     """Per-channel mean and spread of one cut's source range, sampled small."""
 
+    return _sampled_stats([
+        ffmpeg, "-v", "error", "-ss", f"{start:.3f}", "-t", f"{duration:.3f}",
+        "-i", str(media), "-vf", SHOT_MATCH_SAMPLE,
+    ])
+
+
+def _still_stats(ffmpeg: str, image: Path, frame_size: tuple[int, int]) -> Optional[ChannelStats]:
+    """Per-channel mean and spread of a still as the frame shows it, cover-fitted.
+
+    An image has no timeline: `fps` drops its only frame, and a seek on a JPEG
+    returns none, so it is read once, whole.
+    """
+
+    width, height = frame_size
+    return _sampled_stats([
+        ffmpeg, "-v", "error", "-i", str(image), "-vf",
+        f"scale={width}:{height}:force_original_aspect_ratio=increase,"
+        f"crop={width}:{height},scale=64:-2",
+    ])
+
+
+def _sampled_stats(command: list[str]) -> Optional[ChannelStats]:
     result = subprocess.run(
-        [ffmpeg, "-v", "error", "-ss", f"{start:.3f}", "-t", f"{duration:.3f}",
-         "-i", str(media), "-vf", SHOT_MATCH_SAMPLE,
-         "-pix_fmt", "rgb24", "-f", "rawvideo", "-"],
-        capture_output=True, check=False,
+        command + ["-pix_fmt", "rgb24", "-f", "rawvideo", "-"], capture_output=True, check=False
     )
     if result.returncode != 0 or len(result.stdout) < 3:
         return None
@@ -1458,42 +2242,81 @@ def _frame_geometry(media: Path) -> str:
 def _subtitle_cues(
     cuts: Sequence[Cut], spans: Sequence[float]
 ) -> list[tuple[float, float, str, tuple[str, ...]]]:
-    """Place each line in output time, measuring the segments that were written.
+    """Place each line in film seconds, on the frame-rounded spans the segments are rendered at.
 
-    A segment lands on a frame boundary, so it is a few milliseconds longer than
-    the cut list declares. Accumulating the declared numbers instead drifts —
-    a third of a second by the end of eight cuts here — and the subtitle leaves
-    before the actor stops speaking. The rendered files are the timeline.
+    A segment lands on a frame boundary, so it runs a few milliseconds off the
+    length the cut list declares. Accumulating the declared numbers instead
+    drifts -- a third of a second by the end of eight cuts here -- and the
+    subtitle leaves before the actor stops speaking.
     """
 
     cues: list[tuple[float, float, str, tuple[str, ...]]] = []
-    for cut, cursor, scale in _timeline(cuts, spans):
-        declared = cut.end - cut.start
+    for cut, cursor, length in _timeline(cuts, spans):
         for window_start, window_end, text, words in cut.subtitles:
             start = 0.0 if window_start is None else window_start
-            end = declared if window_end is None else window_end
-            cues.append((cursor + start * scale, cursor + end * scale, text, words))
+            end = cut.declared if window_end is None else window_end
+            cues.append((_at(cut, cursor, length, start), _at(cut, cursor, length, end), text, words))
     return cues
 
 
+def _film_spans(cuts: Sequence[Cut], fps: Optional[float]) -> list[float]:
+    """How long each cut runs in the film: its declared length rounded to whole frames.
+
+    render writes every segment as exactly this many frames, and everything
+    that places or checks something on the film -- subtitles, screen text,
+    effects, voices, the film's end -- lays the cuts end to end at these spans.
+    Nothing re-derives timing from the declared lengths, so no path can drift
+    from the picture by the frame rounding. Without a known rate, the declared
+    lengths are all there is.
+    """
+
+    if not fps:
+        return [cut.declared for cut in cuts]
+    return [max(1, round(cut.declared * fps)) / fps for cut in cuts]
+
+
+def _film_fps(
+    episode: Path, project_root: Path, cuts: Sequence[Cut], delivery: Optional[Delivery], *, probe: bool
+) -> Optional[float]:
+    """The film's frame rate: the delivery spec's, else the first video cut's."""
+
+    if delivery is not None and delivery.fps:
+        return delivery.fps
+    if probe:
+        for cut in cuts:
+            media = None if cut.still else _resolve_media(episode, project_root, cut.media)
+            if media is not None:
+                return probe_stream(media)["fps"] or None
+    return None
+
+
 def _timeline(
     cuts: Sequence[Cut], spans: Sequence[float]
 ) -> list[tuple[Cut, float, float]]:
-    """Each cut with its output start and the factor from declared to rendered time.
-
-    Windows were authored against the declared span; scaling holds them in
-    place proportionally rather than letting the tail slip out.
-    """
+    """Each cut with its start in the film and its span there."""
 
     placed: list[tuple[Cut, float, float]] = []
     cursor = 0.0
     for cut, span in zip(cuts, spans):
-        declared = cut.end - cut.start
-        placed.append((cut, cursor, span / declared if declared > 0 else 1.0))
+        placed.append((cut, cursor, span))
         cursor += span
     return placed
 
 
+def _at(cut: Cut, cursor: float, span: float, seconds: float) -> float:
+    """A time written against a cut, in film seconds.
+
+    Inside the cut it keeps its place relative to the cut's rendered length, so
+    a window written to end with the cut still does. Before or past the cut --
+    a J-cut's start, an L-cut subtitle's end -- it is plain seconds from the
+    cut's start, the same clock a voice file plays on.
+    """
+
+    if 0 <= seconds <= cut.declared and cut.declared > 0:
+        return cursor + seconds * span / cut.declared
+    return cursor + seconds
+
+
 class DisplayCue(NamedTuple):
     """One subtitle as burned: output seconds, display text, speaker kind, highlights."""
 
@@ -1639,10 +2462,10 @@ def _screen_text_layers(
 
     layers: list[dict[str, Any]] = []
     latest: Optional[dict[str, Any]] = None
-    for cut, cursor, scale in _timeline(cuts, spans):
+    for cut, cursor, length in _timeline(cuts, spans):
         for text in sorted(cut.screen_texts, key=lambda item: item.start):
-            start = cursor + text.start * scale
-            end = cursor + text.end * scale
+            start = _at(cut, cursor, length, text.start)
+            end = _at(cut, cursor, length, text.end)
             countdown = text.countdown
             if text.resume:
                 if latest is None:
@@ -1680,30 +2503,56 @@ def _screen_text_layers(
     return layers
 
 
-def _placed_sound_effects(
-    cuts: Sequence[Cut], spans: Sequence[float]
-) -> list[tuple[float, float, str, float]]:
-    """Each effect as (output start, duration, path as written, gain dB)."""
+def _placed_sound_effects(cuts: Sequence[Cut], spans: Sequence[float]) -> list[Placed]:
+    """Each effect in output seconds, with its path as written."""
 
     return [
-        (cursor + effect.start * scale, (effect.end - effect.start) * scale,
-         effect.path, effect.gain_db)
-        for cut, cursor, scale in _timeline(cuts, spans)
+        Placed(max(0.0, _at(cut, cursor, length, effect.start)),
+               _at(cut, cursor, length, effect.end) - _at(cut, cursor, length, effect.start),
+               effect.path, effect.gain_db, effect.offset)
+        for cut, cursor, length in _timeline(cuts, spans)
         for effect in cut.sound_effects
     ]
 
 
+def _placed_beds(cuts: Sequence[Cut], spans: Sequence[float]) -> list[Placed]:
+    """Each 「环境声」 run, looping its file with no break at the cuts it spans.
+
+    A run starts at its line's cut plus 起 and lasts until the next 环境声 line:
+    to that line's cut start, or to its 起 when that is later. A negative 起
+    therefore overlaps the two rooms across the cut, a sound bridge. It fades
+    only at its own two ends.
+    """
+
+    lines = [
+        (_at(cut, cursor, length, cut.bed.start), cursor, cut.bed)
+        for cut, cursor, length in _timeline(cuts, spans) if cut.bed is not None
+    ]
+    total = sum(spans)
+    placed: list[Placed] = []
+    for index, (start, _, bed) in enumerate(lines):
+        if bed.path is None:
+            continue
+        end = total if index + 1 == len(lines) else max(lines[index + 1][0], lines[index + 1][1])
+        start = max(0.0, start)
+        if end - start > TOLERANCE:
+            placed.append(Placed(start, end - start, bed.path, bed.gain_db, bed.offset,
+                                 loop=True, fade_in=BED_FADE, fade_out=BED_FADE))
+    return placed
+
+
 def _sound_effect_command(
     ffmpeg: str,
     film: Path,
-    effects: Sequence[tuple[float, float, Path, float]],
+    effects: Sequence[Union[Placed, tuple[Any, ...]]],
     output: Path,
 ) -> list[str]:
-    """Lay each effect into the film's own audio at its output time.
+    """Lay each effect, voice and bed into the film's own audio at its output time.
 
     `normalize=0` keeps the dialogue at its level: amix's default divides every
     input by the input count, and the film would get quieter each time a chime
-    is added. A short fade closes each effect so a trimmed tail does not click.
+    is added. A short fade closes each sound so a trimmed tail does not click;
+    a bed loops its file and fades in and out only at its own ends.
     """
 
     command = [ffmpeg, "-hide_banner", "-loglevel", "error", "-y", "-i", str(film)]
@@ -1711,14 +2560,17 @@ def _sound_effect_command(
     # stereo costs it 3 dB, and the effects are converted to match instead.
     stages = ["[0:a]aformat=sample_rates=48000[a0]"]
     labels = ["[a0]"]
-    for index, (start, duration, media, gain) in enumerate(effects, start=1):
-        command += ["-i", str(media)]
-        fade = min(0.05, duration / 2)
+    for index, raw in enumerate(effects, start=1):
+        sound = Placed(*raw)
+        command += (["-stream_loop", "-1"] if sound.loop else []) + ["-i", str(sound.path)]
+        fade_in = min(sound.fade_in, sound.duration / 2)
+        fade_out = min(sound.fade_out, sound.duration / 2)
         stages.append(
-            f"[{index}:a]atrim=0:{duration:.3f},asetpts=PTS-STARTPTS,"
-            f"afade=t=out:st={duration - fade:.3f}:d={fade:.3f},volume={gain:g}dB,"
+            f"[{index}:a]atrim=start={sound.offset:.3f}:duration={sound.duration:.3f},asetpts=PTS-STARTPTS,"
+            + (f"afade=t=in:st=0:d={fade_in:.3f}," if fade_in else "")
+            + f"afade=t=out:st={sound.duration - fade_out:.3f}:d={fade_out:.3f},volume={sound.gain_db:g}dB,"
             "aformat=sample_rates=48000,"
-            f"adelay={round(start * 1000)}:all=1[s{index}]"
+            f"adelay={round(sound.start * 1000)}:all=1[s{index}]"
         )
         labels.append(f"[s{index}]")
     stages.append(
@@ -1872,7 +2724,9 @@ def _segment_colours(ffmpeg: str, output_root: Path, cuts: Sequence[Cut]) -> lis
     return rows
 
 
-def verify(episode: Path, cuts: Sequence[Cut], delivery: Delivery) -> dict[str, Any]:
+def verify(
+    episode: Path, cuts: Sequence[Cut], delivery: Delivery, project_root: Optional[Path] = None
+) -> dict[str, Any]:
     """Measure the rendered film. Every entry is a number or an honest 未测."""
 
     ffmpeg = _require("ffmpeg")
@@ -1913,14 +2767,20 @@ def verify(episode: Path, cuts: Sequence[Cut], delivery: Delivery) -> dict[str,
     measurements["画内可读文字"] = (
         "未测（抽有画内文字的帧，逐字对《剧本.md》的「画面文字」与提示词声明的内容）"
     )
-    segments = [episode / OUTPUT_DIRECTORY / SEGMENT_DIRECTORY / f"{cut.cut_id}.mp4" for cut in cuts]
-    spans = (
-        [probe_duration(segment) for segment in segments]
-        if all(segment.is_file() for segment in segments)
-        else None
-    )
+    # The same spans render placed everything on; the film's own rate when no spec states one.
+    spans = _film_spans(cuts, delivery.fps or stream["fps"])
     if any(cut.screen_texts or cut.sound_effects for cut in cuts):
         measurements.update(_placements_for_sampling(cuts, spans))
+    beds = _placed_beds(cuts, spans)
+    if beds:
+        measurements["环境声落点"] = [
+            {"起": round(bed.start, 2), "止": round(bed.start + bed.duration, 2), "文件": bed.path}
+            for bed in beds
+        ]
+    if any(cut.voices for cut in cuts):
+        measurements["配音落点"] = _voice_placements(
+            episode, project_root or episode, cuts, spans
+        )
     measurements["台词完整性"] = "未测（本工具不做转写；在成片上转写后逐句对《剧本.md》原文）"
     measurements.update(_frame_report(
         _grey_frames(ffmpeg, final), stream["fps"], cuts, spans, _scene_keys(episode, cuts)
@@ -2073,13 +2933,34 @@ def _placements_for_sampling(cuts: Sequence[Cut], spans: Optional[Sequence[float
             }
             for layer in placed
         ],
-        "音效落点": [
-            {"起": round(start, 2), "止": round(start + duration, 2), "文件": written}
-            for start, duration, written, _ in _placed_sound_effects(cuts, spans)
-        ],
+        "音效落点": _sound_placements(cuts, spans),
     }
 
 
+def _sound_placements(cuts: Sequence[Cut], spans: Sequence[float]) -> list[dict[str, Any]]:
+    return [
+        {"起": round(start, 2), "止": round(start + duration, 2), "文件": written}
+        for start, duration, written, *_ in _placed_sound_effects(cuts, spans)
+    ]
+
+
+def _voice_placements(
+    episode: Path, project_root: Path, cuts: Sequence[Cut], spans: Optional[Sequence[float]]
+) -> Union[list[dict[str, Any]], str]:
+    """Where each 「配音」 line is heard in the film, for listening back."""
+
+    if spans is None:
+        return "未测（分段缺失，无法换算成片时间）"
+    try:
+        sounds = _voice_sounds(episode, project_root, cuts)
+    except EditError as error:
+        return f"未测（{error}）"
+    return [
+        {"起": round(start, 2), "止": round(end, 2), "段": cut.cut_id, "文件": voice.path}
+        for start, end, cut, voice in _voice_spans(cuts, sounds, spans)
+    ]
+
+
 def _matches_frame_size(delivery: Delivery, stream: dict[str, Any]) -> Any:
     if delivery.frame_size is None:
         return "未测（剪辑单没有声明画幅）"
@@ -2149,7 +3030,8 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
         if arguments.command == "check":
             findings = check_cuts(
                 episode, cuts, project_root,
-                probe=_which("ffprobe") is not None, unused=unused,
+                probe=_which("ffprobe") is not None, unused=unused, delivery=delivery,
+                listen=_which("ffmpeg") is not None,
             )
             payload: dict[str, Any] = {
                 "段数": len(cuts),
@@ -2158,13 +3040,21 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
                 "未采用镜头": unused,
                 "findings": findings,
             }
+            notices = move_notices(cuts, _scene_keys(episode, cuts), _film_spans(cuts, delivery.fps))
+            if notices:
+                payload["提醒"] = notices
+            unmeasured = []
             if _which("ffprobe") is None:
-                payload["未测"] = ["区间是否超过素材实际时长（PATH 上没有 ffprobe）"]
+                unmeasured.append("区间是否超过素材实际时长（PATH 上没有 ffprobe）")
+            if _which("ffmpeg") is None and any(cut.voices for cut in cuts):
+                unmeasured.append("配音是否越过成片结尾、是否互相重叠（PATH 上没有 ffmpeg）")
+            if unmeasured:
+                payload["未测"] = unmeasured
             _emit(payload)
             return 1 if findings else 0
         if arguments.command == "render":
             findings = check_cuts(
-                episode, cuts, project_root, probe=True, unused=unused
+                episode, cuts, project_root, probe=True, unused=unused, delivery=delivery
             )
             if findings:
                 _emit({"findings": findings, "已渲染": False})
@@ -2177,7 +3067,7 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
                 remotion_concurrency=arguments.remotion_concurrency,
             ))
             return 0
-        _emit(verify(episode, cuts, delivery))
+        _emit(verify(episode, cuts, delivery, project_root))
         return 0
     except EditError as error:
         print(str(error), file=sys.stderr)