dsh-deepmoyu 2.3.0 → 2.4.2

package/lib/pv_editorial.py

@@ -0,0 +1,336 @@
+"""Deterministic 1080p motion editorial: kinetic short-form studio direction.
+
+No network, external media, or generated code is accepted by this renderer.
+Speech remains the source of timing; all visual text is separately authored.
+"""
+from __future__ import annotations
+
+import math
+import os
+import random
+from functools import lru_cache
+from pathlib import Path
+
+from PIL import Image, ImageDraw, ImageFont
+
+try:
+    # pv imports this module lazily during build, so the shared portrait driver
+    # is available without creating a second character implementation.
+    from pv import Portrait, Fish, DialoguePortrait
+except ImportError:  # pragma: no cover - standalone renderer smoke tests
+    Portrait = Fish = DialoguePortrait = None
+
+WIDTH, HEIGHT = 1920, 1080
+# Keep the three persisted names, but make them bright editorial directions rather
+# than three flat color swatches. Each palette has a light canvas, a strong ink
+# color and a warm/cool accent pair so a frame stays inviting on a phone screen.
+THEMES = {
+    "paper": {"bg": "#fff8f3", "ink": "#17243b", "muted": "#6d7482", "accent": "#ed6a57", "accent2": "#4f69b5", "panel": "#fffdfb", "panel2": "#ffe4db", "contrast": "#fff0e9"},
+    "midnight": {"bg": "#f2f5ff", "ink": "#192440", "muted": "#68748d", "accent": "#5b63d4", "accent2": "#ed7a6d", "panel": "#ffffff", "panel2": "#e5eaff", "contrast": "#ffefeb"},
+    "signal": {"bg": "#fff8e8", "ink": "#2b2230", "muted": "#776d73", "accent": "#de584c", "accent2": "#e1a044", "panel": "#fffdf8", "panel2": "#ffe2c8", "contrast": "#fff0d9"},
+}
+
+
+@lru_cache(maxsize=128)
+def font(size, serif=False):
+    directory = Path(os.environ.get("WINDIR", r"C:\Windows")) / "Fonts"
+    names = ("NotoSerifSC-VF.ttf", "simhei.ttf", "msyhbd.ttc") if serif else ("NotoSansSC-VF.ttf", "msyhbd.ttc", "simhei.ttf")
+    candidates = [directory / name for name in names]
+    candidates += [Path("/usr/share/fonts/opentype/noto/NotoSansCJK-Bold.ttc")]
+    for candidate in candidates:
+        try:
+            return ImageFont.truetype(str(candidate), size)
+        except OSError:
+            pass
+    return ImageFont.load_default()
+
+
+def ease(value):
+    return 1 - (1 - max(0, min(1, value))) ** 3
+
+
+def wrap(draw, text, face, width):
+    lines, line = [], ""
+    for character in str(text):
+        if character == "\n":
+            lines.append(line)
+            line = ""
+        elif line and draw.textlength(line + character, font=face) > width:
+            lines.append(line)
+            line = character
+        else:
+            line += character
+    if line:
+        lines.append(line)
+    return lines
+
+
+def typeset(draw, text, box, color, size=96, minimum=30, serif=False, align="left"):
+    """Fit the complete text by measured pixels, without truncation."""
+    if not text:
+        return
+    x, y, width, height = box
+    for point in range(size, minimum - 1, -2):
+        face = font(point, serif)
+        lines = wrap(draw, text, face, width)
+        # Include the glyph bearing (CJK fonts have a nonzero top bearing).
+        advance = int(point * 1.34)
+        if len(lines) * advance <= height and all(draw.textlength(line, font=face) <= width for line in lines):
+            break
+    else:
+        raise ValueError(f"屏幕文字无法完整排入画面，请精简：{text}")
+    for index, line in enumerate(lines):
+        left = x + (width - draw.textlength(line, font=face)) / 2 if align == "center" else x
+        draw.text((int(left), int(y + index * advance)), line, font=face, fill=color, anchor="lt")
+
+
+def _gradient(top, bottom, width=WIDTH, height=HEIGHT):
+    image = Image.new("RGB", (width, height))
+    pixels = image.load()
+    for y in range(height):
+        ratio = y / max(1, height - 1)
+        color = tuple(int(top[i] * (1 - ratio) + bottom[i] * ratio) for i in range(3))
+        for x in range(width):
+            pixels[x, y] = color
+    return image
+
+
+@lru_cache(maxsize=6)
+def backdrop(theme):
+    colors = THEMES[theme]
+    base = tuple(int(colors["bg"][index:index + 2], 16) for index in (1, 3, 5))
+    panel = tuple(int(colors["panel"][index:index + 2], 16) for index in (1, 3, 5))
+    image = _gradient(tuple(min(255, value + 10) for value in base), base)
+    draw = ImageDraw.Draw(image)
+    # A fine grid and offset bands create depth without decorative blobs.
+    for x in range(0, WIDTH, 80):
+        draw.line((x, 0, x, HEIGHT), fill=tuple(min(255, c + 8) for c in panel), width=1)
+    for y in range(0, HEIGHT, 80):
+        draw.line((0, y, WIDTH, y), fill=tuple(min(255, c + 8) for c in panel), width=1)
+    draw.polygon([(0, 760), (560, 430), (1220, 770), (680, 1080), (0, 1080)], fill=colors["panel"])
+    draw.polygon([(1510, 0), (1920, 0), (1920, 420), (1730, 300)], fill=colors["panel2"])
+    draw.line((112, 136, 1808, 136), fill=colors["muted"], width=2)
+    # Sparse print grain, deterministic and low contrast.
+    rng = random.Random(187)
+    for _ in range(2600):
+        x, y = rng.randrange(WIDTH), rng.randrange(HEIGHT)
+        draw.point((x, y), fill=colors["panel2"])
+    return image
+
+
+def fish_cameo(canvas, state, x, y, size=380, alpha=255):
+    """Let the established fish character appear as a speaker or reaction beat."""
+    fish = state.get("fish")
+    if fish is None:
+        return
+    try:
+        layer = fish.render(mouth=float(state.get("mouth", 0)), sway=0.18, bounce=0.12)
+        layer = layer.resize((size, size), Image.Resampling.LANCZOS)
+        if alpha < 255:
+            layer.putalpha(layer.getchannel("A").point(lambda value: int(value * alpha / 255)))
+        canvas.alpha_composite(layer, (int(x), int(y)))
+    except (AttributeError, OSError, ValueError):
+        # A missing optional portrait must never stop a text-led production.
+        return
+
+
+def reaction_card(draw, text, colors, x=1260, y=715, width=520):
+    """A compact editorial reaction card, separate from the full subtitle lane."""
+    draw.rounded_rectangle((x, y, x + width, y + 108), radius=18, fill=colors["contrast"])
+    draw.ellipse((x + 24, y + 34, x + 42, y + 52), fill=colors["accent"])
+    typeset(draw, text, (x + 68, y + 27, width - 92, 60), colors["bg"], 27, minimum=18)
+
+
+def motif(draw, center, radius, colors, t, variant="orbit"):
+    x, y = center
+    for index, factor in enumerate((.48, .74, 1.0)):
+        r = radius * factor
+        draw.ellipse((x-r, y-r, x+r, y+r), outline=colors["accent"] if index == 1 else colors["muted"], width=2 if index != 1 else 3)
+        angle = t * (.22 + index * .06) + index * 2.1
+        px, py = x + math.cos(angle)*r, y + math.sin(angle)*r
+        dot = 8 if index == 1 else 5
+        draw.ellipse((px-dot, py-dot, px+dot, py+dot), fill=colors["accent"])
+    if variant == "spark":
+        points = []
+        for index in range(16):
+            angle = index * math.pi / 8 + t * .05
+            r = radius * (.43 if index % 2 == 0 else .14)
+            points.append((x + math.cos(angle)*r, y + math.sin(angle)*r))
+        draw.polygon(points, fill=colors["accent"])
+    else:
+        typeset(draw, "?", (x-radius*.25, y-radius*.40, radius*.5, radius*.9), colors["accent"], int(radius*.7), align="center", serif=True)
+
+
+def caption_parts(text, limit=23):
+    parts, current = [], ""
+    for character in text:
+        current += character
+        if len(current) >= limit or (character in "，。！？；：!?;" and len(current) >= 7):
+            parts.append(current)
+            current = ""
+    if current:
+        parts.append(current)
+    return parts
+
+
+def active_caption(text, t, duration):
+    """Phrase timing is proportional within the measured utterance, not ASR."""
+    if not text or not 0 <= t < duration:
+        return ""
+    parts = caption_parts(text)
+    position = t / max(.01, duration) * sum(len(part) for part in parts)
+    for part in parts:
+        position -= len(part)
+        if position < 0:
+            return part
+    return parts[-1]
+
+
+def contrast_ink(colors):
+    """Pick text that stays readable inside the warm caption card."""
+    raw = colors.get("contrast", "#ffffff").lstrip("#")
+    try:
+        luminance = .2126 * int(raw[0:2], 16) + .7152 * int(raw[2:4], 16) + .0722 * int(raw[4:6], 16)
+    except (ValueError, IndexError):
+        luminance = 255
+    # Light editorial caption lanes need the dark ink; the old dark-theme rule
+    # selected the canvas color here and made captions nearly disappear.
+    return colors["ink"] if luminance > 150 else colors["bg"]
+
+
+@lru_cache(maxsize=1)
+def host_avatar():
+    """Load the reviewed rigged portrait so the presenter keeps the mouth animation."""
+    if DialoguePortrait is not None:
+        return DialoguePortrait()
+    if Portrait is not None:
+        portrait = Portrait(520)
+        if portrait.ok:
+            return portrait
+    return Fish(520) if Fish is not None else None
+
+
+def place_host(image, draw, state, t, colors, compact=False):
+    """A restrained presenter cameo; mouth follows the measured voice envelope."""
+    avatar = state.get("dialogue_portrait") or host_avatar()
+    if avatar is None:
+        return
+    target = 390 if compact else 520
+    driven = avatar.render(mouth=state.get("mouth", 0.0), expression="happy" if state.get("mouth", 0) > .45 else "neutral")
+    ratio = target / max(1, driven.height)
+    driven = driven.resize((max(1, int(driven.width * ratio)), target), Image.Resampling.LANCZOS)
+    width, height = driven.size
+    x = WIDTH - width - 86
+    y = 290 if not compact else 205
+    # A quiet stage gives the transparent portrait a deliberate home in the frame.
+    draw.rounded_rectangle((x - 34, y + 44, x + width + 34, y + height + 22), radius=28,
+                           fill=colors["panel"], outline=colors["muted"], width=2)
+    draw.ellipse((x + 28, y + 20, x + 62, y + 54), fill=colors["accent"])
+    draw.text((x + 78, y + 17), "大肥鱼在说", font=font(22), fill=colors["muted"])
+    image.alpha_composite(driven, (x, y))
+
+
+def render(shot, t, duration, state):
+    theme = state.get("theme", "paper")
+    colors = THEMES[theme]
+    image = backdrop(theme).copy().convert("RGBA")
+    draw = ImageDraw.Draw(image)
+    index, count = state.get("shot_index", 0), max(1, state.get("shot_count", 1))
+    draw.ellipse((112, 69, 128, 85), fill=colors["accent"])
+    draw.text((145, 58), "DeepMoYu / 浪里有料", font=font(26), fill=colors["ink"])
+    scene = shot.get("scene", "headline")
+    label = {"hook": "先看一个问题", "headline": "换个角度", "compare": "放在一起看", "steps": "拆开来看", "quote": "记住这一句", "spotlight": "值得放大", "outro": "把问题留给你"}.get(scene, "继续看")
+    label = shot.get("kicker") or label
+    draw.text((112, 174), label, font=font(26), fill=colors["accent"])
+    folio = f"{index+1:02d} / {count:02d}"
+    draw.text((1808-draw.textlength(folio, font=font(26)), 58), folio, font=font(26), fill=colors["muted"])
+    energy = shot.get("energy", "warm")
+    energy_amp = {"quiet": 12, "warm": 24, "punchy": 42, "surprise": 58}.get(energy, 24)
+    rise = int((1 - ease(t / (.32 if energy in {"punchy", "surprise"} else .48))) * energy_amp)
+    headline, body = shot.get("headline", ""), shot.get("body", "")
+
+    if scene in ("hook", "headline", "outro"):
+        typeset(draw, headline, (112, 267+rise, 1120, 340), colors["ink"], 118 if scene == "hook" else 106, serif=True)
+        typeset(draw, body, (118, 667+rise, 1080, 130), colors["muted"], 34)
+        draw.rectangle((114, 623+rise, 294+int(ease(t/.7)*160), 631+rise), fill=colors["accent"])
+        motif(draw, (1515, 493), 222 + 5*math.sin(t*.6), colors, t, "orbit" if scene == "hook" else "spark")
+        if shot.get("speaker") == "fish":
+            place_host(image, draw, state, t, colors)
+        if scene == "outro":
+            draw.line((1420, 779, 1630, 779), fill=colors["accent"], width=4)
+            draw.line((1600, 751, 1630, 779, 1600, 807), fill=colors["accent"], width=4)
+
+    elif scene == "compare":
+        typeset(draw, headline, (112, 245+rise, 1650, 130), colors["ink"], 82, serif=True)
+        for slot, item in enumerate(shot.get("items", [])):
+            x = 112 + slot*876
+            y = 405 + int((1-ease((t-slot*.13)/.5))*35)
+            draw.rounded_rectangle((x, y, x+820, y+378), radius=14, fill=colors["panel"] if slot == 0 else colors["panel2"])
+            ink = colors["ink"]
+            accent = colors["accent"] if slot == 0 else colors["accent2"]
+            draw.text((x+40, y+28), f"0{slot+1}", font=font(25), fill=accent)
+            typeset(draw, item["label"], (x+40, y+108, 740, 150), ink, 66)
+            typeset(draw, item.get("detail", ""), (x+40, y+275, 740, 82), ink, 32)
+        if shot.get("speaker") == "fish":
+            place_host(image, draw, state, t, colors, compact=True)
+
+    elif scene == "steps":
+        typeset(draw, headline, (112, 245+rise, 1650, 130), colors["ink"], 82, serif=True)
+        items = shot.get("items", [])
+        width = (1696 - max(0, len(items)-1)*28) / max(1, len(items))
+        for slot, item in enumerate(items):
+            x = int(112 + slot*(width+28))
+            y = 410 + int((1-ease((t-slot*.16)/.5))*40)
+            draw.rectangle((x, y, int(x+width), y+385), fill=colors["panel"])
+            draw.rectangle((x, y, int(x+width*ease((t-slot*.16)/.8)), y+5), fill=colors["accent"])
+            draw.text((x+28, y+24), f"{slot+1:02d}", font=font(67, True), fill=colors["accent"])
+            typeset(draw, item["label"], (x+28, y+140, width-56, 116), colors["ink"], 48)
+            typeset(draw, item.get("detail", ""), (x+28, y+273, width-56, 96), colors["muted"], 29, minimum=23)
+        if shot.get("speaker") == "fish":
+            place_host(image, draw, state, t, colors, compact=True)
+
+    elif scene == "quote":
+        draw.text((96, 210+rise), "“", font=font(235, True), fill=colors["accent"], anchor="lt")
+        typeset(draw, headline, (270, 325+rise, 1390, 300), colors["ink"], 110, serif=True)
+        draw.rectangle((278, 692, 350, 696), fill=colors["accent"])
+        typeset(draw, body, (385, 670, 1260, 120), colors["muted"], 32)
+        if shot.get("speaker") == "fish":
+            place_host(image, draw, state, t, colors, compact=True)
+
+    elif scene == "spotlight":
+        draw.ellipse((1190, 245, 1780, 835), fill=colors["panel"])
+        motif(draw, (1485, 540), 228, colors, t, "spark")
+        typeset(draw, headline, (112, 282+rise, 1030, 300), colors["ink"], 114, serif=True)
+        typeset(draw, body, (118, 660, 1010, 130), colors["muted"], 34)
+        if shot.get("speaker") == "fish":
+            place_host(image, draw, state, t, colors, compact=True)
+
+    # Dedicated caption and source lanes never share the content field.
+    caption = active_caption(shot.get("text", ""), t, duration)
+    if caption:
+        draw.rounded_rectangle((112, 863, 1808, 975), radius=8, fill=colors["contrast"])
+        typeset(draw, caption, (145, 891, 1630, 70), contrast_ink(colors), 43, align="center")
+    source_ids = shot.get("source_ids", [])
+    source = state.get("source_map", {}).get(source_ids[0], {}) if source_ids else {}
+    provenance = "逐字引用" if shot.get("provenance") == "source-quote" else "公开来源改编"
+    source_text = f"{provenance} / {source.get('title', '')}" if source else ("虚构演绎 / 原创评论" if state.get("mode") == "custom" else "原创评论")
+    typeset(draw, source_text, (112, 1000, 1450, 38), colors["muted"], 22, minimum=12)
+    draw.rectangle((0, 1068, WIDTH, 1079), fill=colors["panel"])
+    progress = (index + max(0, min(1, t/max(.01, duration)))) / count
+    draw.rectangle((0, 1068, int(WIDTH*progress), 1079), fill=colors["accent"])
+    return image
+
+
+def cover(title, ratio, theme="paper"):
+    """Full-bleed editorial cover, sharing the film's typography and palette."""
+    colors = THEMES[theme]
+    width = 1920 if ratio == "16x9" else 1440
+    image = Image.new("RGB", (width, HEIGHT), colors["bg"])
+    draw = ImageDraw.Draw(image)
+    draw.rectangle((0, 0, 28, HEIGHT), fill=colors["accent"])
+    # Decorative geometry contains no extra claims or cover copy.
+    motif(draw, (width-150, 720), 340, colors, 1.5, "spark")
+    draw.rectangle((90, 170, width-90, 785), fill=colors["bg"])
+    typeset(draw, title, (100, 265, width-215, 485), colors["ink"], 150, minimum=38, serif=True)
+    draw.rectangle((104, 830, 410, 844), fill=colors["accent"])
+    return image.convert("RGBA")

package/lib/pv_verify.py

@@ -0,0 +1,267 @@
+"""Validate a locally rendered PV package without ASR or human-listening claims.
+
+Usage: python pv_verify.py --video movie.mp4 --timeline timeline.json --outdir package [--max-duration 300] [--target-duration 90]
+Writes outdir/verification.json and exits nonzero for a failed check.
+"""
+from __future__ import annotations
+
+import argparse
+import array
+import json
+import math
+import subprocess
+import sys
+from pathlib import Path
+
+import imageio_ffmpeg
+from PIL import Image
+
+
+def _probe(video: Path) -> tuple[dict, int]:
+    # imageio-ffmpeg bundles ffmpeg, not ffprobe. Decode without frame duplication
+    # so nb_frames is an observed count rather than fps * container duration.
+    frame_count = 0
+    reader = imageio_ffmpeg.read_frames(
+        str(video), pix_fmt="rgb24", input_params=["-xerror"], output_params=["-vsync", "0"]
+    )
+    try:
+        metadata = next(reader)
+        for _ in reader:
+            frame_count += 1
+    except Exception as exc:
+        raise ValueError(f"视频无法完整解码：{str(exc)[-300:]}") from exc
+    finally:
+        reader.close()
+    if not metadata or frame_count <= 0:
+        raise ValueError("视频没有可解码画面")
+    fps = _duration(metadata.get("fps"))
+    width, height = metadata.get("size", (0, 0))
+    duration = _duration(metadata.get("duration"))
+    audio_codec = str(metadata.get("audio_codec") or "")
+    streams = [{"codec_type": "video", "width": int(width), "height": int(height),
+                "r_frame_rate": str(fps), "nb_frames": str(frame_count)}]
+    if audio_codec:
+        streams.append({"codec_type": "audio", "codec_name": audio_codec})
+    return {"streams": streams, "format": {"duration": str(duration)}}, frame_count
+
+
+def _stream(streams: list[dict], kind: str) -> dict | None:
+    return next((row for row in streams if row.get("codec_type") == kind), None)
+
+
+def _duration(value: object) -> float:
+    try:
+        number = float(value)
+    except (TypeError, ValueError, OverflowError):
+        return 0.0
+    return number if math.isfinite(number) and number >= 0 else 0.0
+
+
+def _number(value: object, field: str) -> float:
+    # Do not silently turn negative/NaN/missing cue times into zero, or accept
+    # JSON booleans and numeric strings as measured timeline values.
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise ValueError(f"{field} 必须是有限数值")
+    try:
+        number = float(value)
+    except OverflowError as exc:
+        raise ValueError(f"{field} 必须是有限数值") from exc
+    if not math.isfinite(number):
+        raise ValueError(f"{field} 必须是有限数值")
+    return number
+
+
+def _decode_frames(video: Path, outdir: Path, width: int, height: int, frame_count: int) -> dict:
+    # Select by actual decoded indices, including the final frame at low fps.
+    # Raw RGB bytes never pass through text-mode subprocess capture.
+    indices = {"first": 0, "middle": frame_count // 2, "last": frame_count - 1}
+    selected = sorted(set(indices.values()))
+    expression = "+".join(f"eq(n\\,{index})" for index in selected)
+    try:
+        result = subprocess.run(
+            [imageio_ffmpeg.get_ffmpeg_exe(), "-nostdin", "-v", "error", "-xerror",
+             "-i", str(video), "-map", "0:v:0", "-vf", f"select={expression}",
+             "-vsync", "0", "-pix_fmt", "rgb24", "-vcodec", "rawvideo", "-f", "rawvideo", "pipe:1"],
+            capture_output=True, check=False, timeout=120,
+        )
+    except subprocess.TimeoutExpired as exc:
+        raise ValueError("视频抽帧超时") from exc
+    if result.returncode != 0:
+        error = result.stderr.decode("utf-8", errors="replace").strip()[-300:]
+        raise ValueError("视频抽帧失败：" + (error or f"exit {result.returncode}"))
+    frame_bytes = width * height * 3
+    if len(result.stdout) != frame_bytes * len(selected):
+        raise ValueError("视频缺少可解码的首帧、中帧或末帧")
+    for offset, source_index in enumerate(selected):
+        pixels = result.stdout[offset * frame_bytes:(offset + 1) * frame_bytes]
+        image = Image.frombytes("RGB", (width, height), pixels)
+        for label, index in indices.items():
+            if index == source_index:
+                image.save(outdir / f"verify_{label}.png")
+    return indices
+
+
+def _timeline_check(timeline: dict, duration: float) -> dict:
+    if not isinstance(timeline, dict) or timeline.get("schema") != "dafeiyu-timeline-v1":
+        raise ValueError("timeline schema 不匹配")
+    fps = _number(timeline.get("fps"), "timeline.fps")
+    planned = _number(timeline.get("duration"), "timeline.duration")
+    if not 1 <= fps <= 60 or planned <= 0:
+        raise ValueError("timeline 的 fps 或 duration 无效")
+    cues = timeline.get("cues")
+    if not isinstance(cues, list) or not cues:
+        raise ValueError("timeline 缺少有效 cues")
+    previous = 0.0
+    for index, cue in enumerate(cues):
+        field = f"timeline.cues[{index}]"
+        if not isinstance(cue, dict):
+            raise ValueError(f"{field} 无效")
+        for key in ("shot", "speaker", "text", "start", "end", "audio_duration", "engine", "mouth_frames"):
+            if key not in cue:
+                raise ValueError(f"{field} 缺少 {key}")
+        start = _number(cue["start"], f"{field}.start")
+        end = _number(cue["end"], f"{field}.end")
+        audio = _number(cue["audio_duration"], f"{field}.audio_duration")
+        if start < 0 or end > planned + 1e-6 or end <= start or audio <= 0:
+            raise ValueError(f"{field} 时间超出 timeline 范围或为空")
+        if abs((end - start) - audio) > 0.15 or start + 1e-6 < previous:
+            raise ValueError(f"{field} 时间重叠或与音频时长不一致")
+        mouth = cue["mouth_frames"]
+        if (not isinstance(cue["text"], str) or not cue["text"].strip()
+                or isinstance(mouth, bool) or not isinstance(mouth, int) or mouth <= 0):
+            raise ValueError(f"{field} 缺少有效对白或口型帧")
+        previous = end
+    if abs(planned - duration) > max(0.35, 2 / fps):
+        raise ValueError(f"视频时长 {duration:.3f}s 与 timeline {planned:.3f}s 不一致")
+    return {"timeline_fps": fps, "timeline_duration": planned,
+            "cue_count": len(cues), "last_cue_end": previous}
+
+
+def _decode_audio(video: Path, duration: float) -> dict:
+    # Decode to mono signed 16-bit PCM. Capture bytes, not locale-decoded text;
+    # this is an acoustic sanity check, not speech recognition or a listening test.
+    rate = 16000
+    try:
+        result = subprocess.run(
+            [imageio_ffmpeg.get_ffmpeg_exe(), "-nostdin", "-v", "error", "-xerror",
+             "-i", str(video), "-map", "0:a:0", "-vn", "-ac", "1", "-ar", str(rate),
+             "-acodec", "pcm_s16le", "-f", "s16le", "pipe:1"],
+            capture_output=True, check=False, timeout=60,
+        )
+    except subprocess.TimeoutExpired as exc:
+        raise ValueError("音轨解码超时") from exc
+    if result.returncode != 0:
+        error = result.stderr.decode("utf-8", errors="replace").strip()[-300:]
+        raise ValueError("音轨解码失败：" + (error or f"exit {result.returncode}"))
+    if not result.stdout or len(result.stdout) % 2:
+        raise ValueError("音轨没有可解码的 PCM 样本")
+    samples = array.array("h")
+    samples.frombytes(result.stdout)
+    if sys.byteorder != "little":
+        samples.byteswap()
+    audio_duration = len(samples) / rate
+    # AAC padding at the renderer's 24 kHz is under 0.1s and is independent
+    # of video fps; a low-fps movie must not permit seconds of missing audio.
+    if abs(audio_duration - duration) > 0.15:
+        raise ValueError(f"音轨时长 {audio_duration:.3f}s 与 timeline {duration:.3f}s 不一致")
+    peak = max(abs(value) for value in samples)
+    rms = math.sqrt(sum(value * value for value in samples) / len(samples))
+    # One PCM least-significant bit tolerates codec noise without accepting an
+    # otherwise silent AAC stream. Normalized levels are recorded for inspection.
+    if peak <= 1 or rms <= 1:
+        raise ValueError("音轨为空或静音")
+    return {"audio_duration": round(audio_duration, 6), "audio_sample_count": len(samples),
+            "audio_peak": round(peak / 32768, 8), "audio_rms": round(rms / 32768, 8)}
+
+
+def verify(video: Path, timeline_file: Path, outdir: Path, max_duration: float = 300.0,
+           target_duration: float | None = None) -> dict:
+    max_duration = _number(max_duration, "max-duration")
+    if max_duration <= 0:
+        raise ValueError("max-duration 必须大于零")
+    if target_duration is not None:
+        target_duration = _number(target_duration, "target-duration")
+        if target_duration <= 0:
+            raise ValueError("target-duration 必须大于零")
+    if not video.is_file() or video.stat().st_size <= 1024:
+        raise ValueError("视频文件不存在或为空")
+    outdir.mkdir(parents=True, exist_ok=True)
+    try:
+        timeline = json.loads(timeline_file.read_text(encoding="utf-8"))
+    except Exception as exc:
+        raise ValueError("timeline.json 不是有效 JSON") from exc
+    streams_info, frame_count = _probe(video)
+    streams = streams_info.get("streams") or []
+    video_stream = _stream(streams, "video")
+    audio_stream = _stream(streams, "audio")
+    if not video_stream or not audio_stream:
+        raise ValueError("成片必须同时包含视频和非空音轨")
+    width, height = int(video_stream.get("width") or 0), int(video_stream.get("height") or 0)
+    if width < 320 or height < 180 or width > 4096 or height > 4096:
+        raise ValueError("视频尺寸不在允许范围")
+    duration = _duration((streams_info.get("format") or {}).get("duration"))
+    if not duration or duration > max_duration + 0.35:
+        raise ValueError(f"视频时长 {duration:.3f}s 超过 {max_duration:g}s 预算")
+    minimum_duration = target_duration * 0.60 if target_duration is not None else None
+    if minimum_duration is not None and duration + 1e-9 < minimum_duration:
+        raise ValueError(
+            f"视频实测时长 {duration:.3f}s 低于目标 {target_duration:g}s 的60%"
+            f"（至少 {minimum_duration:.3f}s）"
+        )
+    timeline_info = _timeline_check(timeline, duration)
+    fps = _duration(video_stream.get("r_frame_rate"))
+    if not 1 <= fps <= 60:
+        raise ValueError("视频帧率不在允许范围")
+    if abs(fps - timeline_info["timeline_fps"]) > 0.001:
+        raise ValueError(f"视频帧率 {fps:g} 与 timeline {timeline_info['timeline_fps']:g} 不一致")
+    expected_frames = round(timeline_info["timeline_duration"] * timeline_info["timeline_fps"])
+    # The renderer uses int(total * fps); a floating-point frame-boundary roundoff
+    # can remove one frame. Larger differences indicate truncated/extra footage.
+    if abs(frame_count - expected_frames) > 1:
+        raise ValueError(f"视频实际帧数 {frame_count} 与 timeline {expected_frames} 不一致")
+    sample_indices = _decode_frames(video, outdir, width, height, frame_count)
+    audio_info = _decode_audio(video, timeline_info["timeline_duration"])
+    receipt = {
+        "ok": True,
+        "video": str(video),
+        "timeline": str(timeline_file),
+        "width": width,
+        "height": height,
+        "fps": round(fps, 6),
+        "duration": round(duration, 6),
+        "frame_count": frame_count,
+        "expected_frame_count": expected_frames,
+        "sample_frame_indices": sample_indices,
+        "audio_codec": audio_stream.get("codec_name", ""),
+        **audio_info,
+        **timeline_info,
+        "limitations": ["仅验证画面解码、音轨解码与非静音、时长及时间轴一致；不进行 ASR，也不声称有人听过音频。"],
+    }
+    if target_duration is not None:
+        receipt["target_duration"] = round(target_duration, 6)
+        receipt["minimum_target_duration"] = round(minimum_duration, 6)
+    (outdir / "verification.json").write_text(json.dumps(receipt, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    return receipt
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--video", required=True, type=Path)
+    parser.add_argument("--timeline", required=True, type=Path)
+    parser.add_argument("--outdir", required=True, type=Path)
+    parser.add_argument("--max-duration", type=float, default=300.0)
+    parser.add_argument("--target-duration", type=float)
+    args = parser.parse_args()
+    try:
+        result = verify(args.video, args.timeline, args.outdir, args.max_duration, args.target_duration)
+    except Exception as exc:
+        args.outdir.mkdir(parents=True, exist_ok=True)
+        (args.outdir / "verification.json").write_text(json.dumps({"ok": False, "error": str(exc)}, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+        print(json.dumps({"ok": False, "error": str(exc)}, ensure_ascii=False))
+        return 1
+    print(json.dumps(result, ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/lib/python-env.mjs

@@ -0,0 +1,61 @@
+/** Cheap, read-only environment metadata checks. Never spawn Python during status polling. */
+import { existsSync, readFileSync, readdirSync } from 'node:fs'
+import { join } from 'node:path'
+
+export const MAIN_PYTHON_RANGE = '>=3.11,<3.14'
+export const MAIN_ENV_PACKAGES = Object.freeze(['bilibili_api', 'mcp', 'qrcode', 'PIL', 'edge_tts', 'imageio_ffmpeg'])
+export const PYTHON_COMPATIBILITY_CHECK = 'import sys;sys.exit(0 if (3,11)<=sys.version_info[:2]<(3,14) else 2)'
+export const MAIN_RUNTIME_CHECK = 'import sys,PIL,bilibili_api,mcp,qrcode,edge_tts,imageio_ffmpeg;sys.exit(0 if (3,11)<=sys.version_info[:2]<(3,14) and int(PIL.__version__.split(".")[0])>=13 else 2)'
+export const ASR_ENV_PACKAGES = Object.freeze(['faster_whisper', 'yt_dlp', 'ctranslate2', 'av'])
+export const ASR_RUNTIME_CHECK = 'import faster_whisper,yt_dlp,ctranslate2,av;print("DeepMoYu ASR runtime imports OK")'
+
+const read = file => { try { return readFileSync(file, 'utf8') } catch { return '' } }
+const list = folder => { try { return readdirSync(folder) } catch { return [] } }
+export const environmentPython = (root, platform = process.platform) => join(root, platform === 'win32' ? 'Scripts' : 'bin', platform === 'win32' ? 'python.exe' : 'python')
+
+export function inspectMainEnvironment(root, { platform = process.platform, ignoreRuntimeFailure = false } = {}) {
+  const python = environmentPython(root, platform), exists = existsSync(python)
+  const config = read(join(root, 'pyvenv.cfg'))
+  const pythonVersion = /^(?:version|version_info)\s*=\s*(\d+\.\d+(?:\.\d+)?)/mi.exec(config)?.[1] || ''
+  const version = pythonVersion.split('.').map(Number)
+  const pythonCompatible = exists && version[0] === 3 && version[1] >= 11 && version[1] < 14
+  const roots = [join(root, 'Lib', 'site-packages'), ...list(join(root, 'lib')).filter(name => /^python\d+\.\d+$/.test(name)).map(name => join(root, 'lib', name, 'site-packages'))]
+  const site = roots.find(folder => existsSync(folder)) || roots[0]
+  const names = list(site)
+  const missing = MAIN_ENV_PACKAGES.filter(name => !names.includes(name) && !names.includes(name + '.py'))
+  let pillowVersion = /__version__\s*=\s*["'](\d+\.\d+(?:\.\d+)?)["']/.exec(read(join(site, 'PIL', '_version.py')))?.[1] || ''
+  if (!pillowVersion) {
+    const candidates = names.filter(name => /^pillow-.+\.dist-info$/i.test(name))
+      .map(name => /^Version:\s*(\d+\.\d+(?:\.\d+)?)\s*$/mi.exec(read(join(site, name, 'METADATA')))?.[1]).filter(Boolean)
+    if (new Set(candidates).size === 1) pillowVersion = candidates[0]
+  }
+  const pillowCompatible = /^\d+\.\d+(?:\.\d+)?$/.test(pillowVersion) && Number(pillowVersion.split('.')[0]) >= 13 && !missing.includes('PIL')
+  const reasons = []
+  if (!exists) reasons.push('尚未创建插件 Python 环境')
+  else if (!pythonCompatible) reasons.push(`需要 Python 3.11–3.13（当前 ${pythonVersion || '版本无法确认'}）`)
+  if (!pillowCompatible) reasons.push(`需要 Pillow 13.0+（当前 ${pillowVersion || '未安装或版本无法确认'}）`)
+  if (missing.length) reasons.push('缺少依赖：' + missing.join(' / '))
+  let runtimeFailed = false
+  if (!ignoreRuntimeFailure && existsSync(join(root, 'deepmoyu-health.json'))) {
+    try { runtimeFailed = JSON.parse(read(join(root, 'deepmoyu-health.json')))?.ok !== true } catch { runtimeFailed = true }
+    if (runtimeFailed) reasons.push('上次实际运行校验未通过，请重新安装主依赖以复核')
+  }
+  return { ready: exists && pythonCompatible && pillowCompatible && missing.length === 0 && !runtimeFailed, exists, python,
+    pythonVersion, pythonCompatible, pillowVersion, pillowCompatible, missing, reasons,
+    runtimeFailed, upgradeRequired: exists && (!pythonCompatible || !pillowCompatible), upgradeHint: reasons.join('；') }
+}
+
+/** Optional ASR remains independent from main Python/Pillow constraints and supports complete legacy envs. */
+export function inspectAsrEnvironment(root, { platform = process.platform, installState = null } = {}) {
+  const python = environmentPython(root, platform), exists = existsSync(python)
+  const roots = [join(root, 'Lib', 'site-packages'), ...list(join(root, 'lib')).filter(name => /^python\d+\.\d+$/.test(name)).map(name => join(root, 'lib', name, 'site-packages'))]
+  const site = roots.find(folder => existsSync(folder)) || roots[0], names = list(site)
+  const missing = ASR_ENV_PACKAGES.filter(name => !names.includes(name) && !names.includes(name + '.py'))
+  const blocked = Boolean(installState && (installState.ok === false || installState.running || ['running', 'failed', 'interrupted'].includes(installState.state)))
+  const reasons = []
+  if (!exists) reasons.push('尚未创建转写 Python 环境')
+  if (missing.length) reasons.push('缺少转写运行依赖：' + missing.join(' / '))
+  if (blocked) reasons.push(installState.running ? '转写依赖仍在安装或校验' : String(installState.error || '上次转写安装或校验未通过，请重试'))
+  return { ready: exists && missing.length === 0 && !blocked, python, exists, missing, reasons,
+    install: installState || { state: 'unknown', ok: null, running: false }, installFailed: blocked && !installState?.running }
+}