egatari 0.0.0-stage → 0.6.4

package/tts/core.py

@@ -0,0 +1,237 @@
+"""Irodori-TTS の呼び出しと音声の後処理（ffmpeg）。
+
+marp2mp4（main_irodori.py）の関数を移したもの。ffmpeg のフィルタ・音量の目標・行間・無音除去の
+設定は同じにしてある（同じ文字列と声なら同じ処理の音声になる）。
+
+設定（環境変数）:
+  IRODORI_URL       Irodori-TTS のサーバー（既定 http://localhost:8882）
+  IRODORI_REF_DIR   参照音声（<名前>.wav）のフォルダ。サーバーから見えるパスで渡す（既定 tts/voices）
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import subprocess
+import time
+from pathlib import Path
+from urllib.parse import urlparse
+
+import requests
+
+IRODORI_URL = os.environ.get("IRODORI_URL", "http://localhost:8882").rstrip("/")
+TTS_MODEL = "mlx-community/Irodori-TTS-v4.1-Small-fp16"
+# 使えるエンジン（同じ mlx-audio のサーバーで、モデル名だけが違う）。日本語は Irodori、英語などは VoxCPM2
+ENGINES = {"irodori": TTS_MODEL, "voxcpm2": "mlx-community/VoxCPM2-8bit"}
+DEFAULT_REF_DIR = Path(__file__).resolve().parent / "voices"
+
+PAUSE_MS = 350          # 同じ段階の中の行間に挟む無音
+TRIM_SILENCE = True     # TTS が各行の前後に付ける 0.5〜0.9 秒の無音を削るか
+TRIM_THRESHOLD = "-45dB"
+TRIM_KEEP_S = 0.05      # 削った後に残す無音
+
+# 話者ごとの音量差をならす目標（EBU R128 の loudnorm を 2 パス）。参照音声の音量が揃って
+# いないと合成結果もその差を引きずり、Irodori はピークを 0dB に正規化して返すので
+# 単純なゲインでは揃わない
+TARGET_LUFS = -20.0       # 各行のラウドネスの目標（I）
+TARGET_TP_DB = -1.5       # トゥルーピークの上限
+TARGET_LRA = 11.0         # ラウドネスレンジ
+
+
+def ref_dir(cli: str | None = None) -> Path:
+    """参照音声のフォルダ：--ref-dir > IRODORI_REF_DIR > tts/voices。"""
+    d = cli or os.environ.get("IRODORI_REF_DIR")
+    return Path(d).expanduser() if d else DEFAULT_REF_DIR
+
+
+def server_is_local() -> bool:
+    return urlparse(IRODORI_URL).hostname in ("localhost", "127.0.0.1", "::1")
+
+
+def resolve_voice(voice: str, refs: Path, base: Path | None = None) -> Path:
+    """声の指定 → 参照音声のパス。名前（bob）なら <refs>/<名前>.wav、
+    パス（/ を含むか .wav で終わる）ならそのファイル（相対なら base から）。
+
+    サーバーが別のマシンのときはパスはサーバー側のものなので、有無を確かめない。
+    """
+    if "/" in voice or voice.endswith(".wav"):
+        p = Path(voice).expanduser()
+        if not p.is_absolute() and base is not None:
+            p = base / p
+    else:
+        p = refs / f"{voice}.wav"
+    if server_is_local() and not p.exists():
+        raise FileNotFoundError(f"参照音声が見つかりません: {p}"
+                                "（IRODORI_REF_DIR か --ref-dir、または voice.json にパスで書く）")
+    return p
+
+
+REF_RATE = 48000  # TTS のモデル（Irodori・VoxCPM2）が前提にする参照音声のサンプリング周波数
+
+
+def ref_at_model_rate(path: Path, cache_dir: Path) -> Path:
+    """参照音声が 48 kHz・モノラルでなければ、変換したものを cache_dir に作ってそのパスを返す。
+
+    16 kHz のまま渡すと、mlx のサーバーでは読む速さが変わった（ブラウザ版より 2〜4 割速い）。
+    サーバーが別のマシンのときはパスが向こうのものなので、何もしない。
+    """
+    if not server_is_local() or not path.exists():
+        return path
+    info = subprocess.run(
+        ["ffprobe", "-v", "error", "-select_streams", "a:0", "-show_entries", "stream=sample_rate,channels",
+         "-of", "csv=p=0", str(path)], capture_output=True, text=True, encoding="utf-8").stdout.strip()
+    if info == f"{REF_RATE},1":
+        return path
+    digest = hashlib.sha1(path.read_bytes()).hexdigest()[:12]
+    out = cache_dir / f"{path.stem}-{digest}-48k.wav"
+    # 原稿のフォルダの .cache に置かれたリンクを通して外に書かない（途中のフォルダは呼び出す側が確かめる。SECURITY.md）
+    if cache_dir.is_symlink() or out.is_symlink():
+        raise PermissionError(f"シンボリックリンクを通しては書きません / refusing to write through a symbolic link: {out}")
+    if not out.exists():
+        cache_dir.mkdir(parents=True, exist_ok=True)
+        subprocess.run(["ffmpeg", "-y", "-loglevel", "error", "-i", str(path), "-ac", "1", "-ar", str(REF_RATE), str(out)],
+                       check=True)
+    return out
+
+
+def ping(timeout: float = 5):
+    requests.get(f"{IRODORI_URL}/v1/models", timeout=timeout).raise_for_status()
+
+
+def synthesize_line(text: str, ref: Path, out_path: Path, retries: int = 2, model: str = TTS_MODEL):
+    """1 行を合成して WAV に保存する。
+
+    response_format="wav" の明示は必須（省略すると mp3 が返り、拡張子と中身が食い違う）。
+    """
+    payload = {
+        "model": model,
+        "input": text,
+        "ref_audio": str(ref),
+        "response_format": "wav",
+    }
+    last_err = None
+    for attempt in range(retries + 1):
+        try:
+            resp = requests.post(f"{IRODORI_URL}/v1/audio/speech", json=payload, timeout=600)
+            resp.raise_for_status()
+            out_path.write_bytes(resp.content)
+            return
+        except Exception as e:
+            last_err = e
+            if attempt < retries:
+                time.sleep(2 * (attempt + 1))
+    raise RuntimeError(f"TTS合成に失敗しました: {last_err}")
+
+
+def trim_silence(path: Path):
+    """先頭・末尾の無音を削る（インプレース）。発話の途中の間は削らない。
+
+    残すと「TTS 由来の無音 + 意図した無音」が二重に乗り、段階の切り替わりが間延びする。
+    """
+    trim = (f"silenceremove=start_periods=1:start_silence={TRIM_KEEP_S}:"
+            f"start_threshold={TRIM_THRESHOLD}")
+    af = f"{trim},areverse,{trim},areverse"
+
+    tmp_out = path.with_suffix(".trim.wav")
+    result = subprocess.run(
+        ["ffmpeg", "-y", "-i", str(path), "-af", af, str(tmp_out)],
+        capture_output=True,
+    )
+    if result.returncode != 0:
+        print(f"  ⚠ 無音除去に失敗（元の音声を使用）: {result.stderr.decode()[-500:]}")
+        tmp_out.unlink(missing_ok=True)
+        return
+    tmp_out.replace(path)
+
+
+def normalize_level(path: Path):
+    """1 行の音声を TARGET_LUFS に揃える（インプレース）。
+
+    1 パス目で測り、2 パス目は linear=true の一律のゲインで当てる（行の中の抑揚は保つ）。
+    測定に失敗した行は元のまま（音が消えるよりはレベルが揃わないほうがよい）。
+    """
+    probe = subprocess.run(
+        ["ffmpeg", "-v", "info", "-i", str(path), "-af",
+         f"loudnorm=I={TARGET_LUFS}:TP={TARGET_TP_DB}:LRA={TARGET_LRA}:print_format=json",
+         "-f", "null", "-"], capture_output=True, text=True, encoding="utf-8", errors="replace").stderr
+    m = re.search(r"\{[^{}]*input_i[^{}]*\}", probe, re.DOTALL)
+    if not m:
+        return
+    try:
+        s = json.loads(m.group(0))
+    except json.JSONDecodeError:
+        return
+    if s.get("input_i") in (None, "-inf", "inf"):
+        return
+
+    af = (f"loudnorm=I={TARGET_LUFS}:TP={TARGET_TP_DB}:LRA={TARGET_LRA}"
+          f":measured_I={s['input_i']}:measured_TP={s['input_tp']}"
+          f":measured_LRA={s['input_lra']}:measured_thresh={s['input_thresh']}"
+          f":offset={s['target_offset']}:linear=true:print_format=summary")
+    tmp_out = path.with_suffix(".norm.wav")
+    result = subprocess.run(
+        ["ffmpeg", "-y", "-i", str(path), "-af", af, "-ar", "44100", str(tmp_out)],
+        capture_output=True)
+    if result.returncode != 0:
+        print(f"  ⚠ 音量調整に失敗（元の音声を使用）: {result.stderr.decode()[-300:]}")
+        tmp_out.unlink(missing_ok=True)
+        return
+    tmp_out.replace(path)
+
+
+def concat_audio_with_pauses(seg_paths: list[Path], out_path: Path, pause_ms: int = PAUSE_MS):
+    """複数の WAV を、行間に無音を挟んで 1 本に結合する。
+
+    サンプルレートが違っても繋がるよう、concat demuxer ではなく concat フィルタを使う。
+    """
+    n = len(seg_paths)
+    pause_s = pause_ms / 1000.0
+    insert_silence = pause_s > 0 and n > 1
+    fmt = "aresample=44100,aformat=sample_fmts=s16:channel_layouts=mono"
+
+    inputs = []
+    for p in seg_paths:
+        inputs += ["-i", str(p)]
+
+    stages = [f"[{i}:a]{fmt}[a{i}];" for i in range(n)]
+
+    if insert_silence:
+        # 無音を 1 本用意して asplit で n-1 個に分け、[a0][s0][a1]… の順に繋ぐ
+        inputs += ["-f", "lavfi", "-t", str(pause_s), "-i", "anullsrc=r=44100:cl=mono"]
+        sil_labels = "".join(f"[s{i}]" for i in range(n - 1))
+        split = f",asplit={n-1}" if n - 1 > 1 else ""
+        stages.append(f"[{n}:a]{fmt}{split}{sil_labels};")
+
+        order = ""
+        for i in range(n):
+            order += f"[a{i}]"
+            if i < n - 1:
+                order += f"[s{i}]"
+        count = 2 * n - 1
+    else:
+        order = "".join(f"[a{i}]" for i in range(n))
+        count = n
+
+    filter_complex = "".join(stages) + order + f"concat=n={count}:v=0:a=1[outa]"
+
+    cmd = ["ffmpeg", "-y"] + inputs + [
+        "-filter_complex", filter_complex,
+        "-map", "[outa]",
+        str(out_path),
+    ]
+    result = subprocess.run(cmd, capture_output=True)
+    if result.returncode != 0:
+        print(f"  ⚠ 音声結合エラー:\n{result.stderr.decode()[-2000:]}")
+        result.check_returncode()
+
+
+def media_duration(path: Path) -> float:
+    """メディアの長さ（秒）。"""
+    result = subprocess.run(
+        ["ffprobe", "-v", "error", "-show_entries", "format=duration",
+         "-of", "csv=p=0", str(path)],
+        capture_output=True, text=True, encoding="utf-8", check=True,
+    )
+    return float(result.stdout.strip())

package/tts/pyproject.toml

@@ -0,0 +1,12 @@
+[project]
+name = "motion-slides-tts"
+version = "0.1.0"
+description = "motion-academic-slides の口述原稿を Irodori-TTS で段階ごとの音声にする"
+requires-python = ">=3.13"
+dependencies = [
+    "requests>=2.32,<3",
+    "pyyaml>=6.0,<7",   # yomi.py が yomi.yaml を読む
+]
+
+[tool.uv]
+package = false

package/tts/synth.py

@@ -0,0 +1,401 @@
+#!/usr/bin/env python3
+"""口述原稿（narration.md）→ 段階ごとの音声（audio/seg_<digest>.wav）と audio/manifest.json。
+
+    uv run --project tts python tts/synth.py <deckdir> \
+        [--voices expert=bob,novice=alice] [--ref-dir DIR] [--yomi FILE] [--only key,...] [--dry-run]
+
+- 原稿の解析は node（tools/narration-json.mjs → kit/narration.mjs）に任せる。parser を二重に持たない
+- 合成・無音除去・音量の正規化・結合は core.py、読み辞書は yomi.py。行間の無音は PAUSE_MS。
+  段階の末尾の間（pad_after）はタイムライン（deck.js）が足すので、wav には付けない
+- {cue} で区切られた部分は別々に合成し、各区切りの時刻（段階の音声の先頭からの秒）を cues に記録する
+- キャッシュ：seg_<digest>.wav が既にあれば作らない。digest は segDigest(seg, voice) で、
+  voice には声・モデル・正規化の目標・行間・読み辞書と適用規則の版が入る（どれかが変われば作り直し）
+- --dry-run：TTS を呼ばず、推定の長さ（日本語 7.5 字/秒）の無音を作る。digest は別になる
+- 声の設定：--voices > <deckdir>/voice.json > 既定（Expert = bob、Novice = alice）。
+  名前は <参照音声のフォルダ>/<名前>.wav（--ref-dir > IRODORI_REF_DIR > tts/voices）、パスも書ける
+- 読み辞書：--yomi > MOTION_YOMI > tts/yomi.yaml
+- サーバー：IRODORI_URL（既定 http://localhost:8882）
+- 録音・取り込みの音声（manifest の kind が recorded か imported。編集アプリの音声の板が書く）は作り直さず、そのまま残す
+  （--replace-recorded で TTS に替える）。manifest の各段階には kind と inputHash（その段階の口述原稿の hash。format spec §5.4）も書く
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import wave
+from pathlib import Path
+
+TTS_DIR = Path(__file__).resolve().parent
+sys.path.insert(0, str(TTS_DIR))
+
+import core as M  # noqa: E402  （synthesize_line, trim_silence, normalize_level, …）
+import yomi as Y  # noqa: E402
+
+REPO = TTS_DIR.parent
+CHARS_PER_SEC = 7.5
+MODEL = M.TTS_MODEL   # main() でエンジンに合わせて決める
+SR = 44100
+ROLE_LABEL = {"expert": "Expert", "novice": "Novice"}
+
+
+def parse_args():
+    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("deckdir")
+    p.add_argument("--voices", default=None, help="expert=bob,novice=alice")
+    p.add_argument("--ref-dir", default=None, help="参照音声（<名前>.wav）のフォルダ（既定 IRODORI_REF_DIR か tts/voices）")
+    p.add_argument("--engine", default=None, choices=sorted(M.ENGINES), help="TTS のエンジン（既定：英語のデッキは voxcpm2、それ以外は irodori）")
+    p.add_argument("--yomi", default=None, help="読み辞書（既定 MOTION_YOMI か tts/yomi.yaml）")
+    p.add_argument("--only", default=None, help="この鍵（slideKey:stepKey）の段階だけ作る。カンマ区切り")
+    p.add_argument("--dry-run", action="store_true", help="TTS を呼ばず、推定の長さの無音を作る")
+    p.add_argument("--force", action="store_true", help="キャッシュを無視して作り直す")
+    p.add_argument("--replace-recorded", action="store_true", help="録音・取り込みの音声（kind が recorded か imported）も TTS で作り直す")
+    return p.parse_args()
+
+
+DEFAULT_VOICES = {"expert": "bob", "novice": "alice"}
+
+
+def resolve_voices(deckdir: Path, cli: str | None) -> tuple[dict[str, str], list[str], dict[str, str]]:
+    """{role: 声の名前}, 既定を使った role, どこから来たか。"""
+    src: dict[str, str] = {}
+    voices: dict[str, str] = {}
+    vj = deckdir / "voice.json"
+    if vj.exists():
+        for k, v in json.loads(vj.read_text(encoding="utf-8")).items():
+            if k.lower() in ROLE_LABEL and v:
+                voices[k.lower()] = v
+                src[k.lower()] = "voice.json"
+    if cli:
+        for item in cli.split(","):
+            if not item.strip():
+                continue
+            k, _, v = item.partition("=")
+            k = k.strip().lower()
+            if k not in ROLE_LABEL or not v.strip():
+                sys.exit(f"--voices の書式が不正です: {item!r}（例: expert=bob,novice=alice）")
+            if k in voices and voices[k] != v.strip():
+                print(f"  --voices が voice.json を上書き: {k} {voices[k]} → {v.strip()}")
+            voices[k] = v.strip()
+            src[k] = "--voices"
+    # 既定の声：1 人モードは bob、掛け合いは bob（Expert）× alice（Novice）。
+    # 既定を使っても警告はしない（既定は決まった声で、尺が黙ってずれることはない）
+    defaulted = []
+    for role in ROLE_LABEL:
+        if role not in voices:
+            voices[role] = DEFAULT_VOICES[role]
+            src[role] = "既定"
+    return voices, defaulted, src
+
+
+def voice_file(v: str) -> str:
+    """digest と表示に使う参照音声のファイル名（名前なら <名前>.wav、パスならファイル名）。"""
+    return Path(v).name if ("/" in v or v.endswith(".wav")) else v + ".wav"
+
+
+def file_hash(*paths: Path) -> str:
+    h = hashlib.sha1()
+    for p in paths:
+        h.update(p.read_bytes() if p.exists() else b"")
+        h.update(b"\x1f")
+    return h.hexdigest()[:12]
+
+
+def narration_json(narr: Path, voice: dict) -> list[dict]:
+    node = shutil.which("node")
+    if not node:
+        sys.exit("node が見つかりません（tools/narration-json.mjs を動かすのに要ります）")
+    out = subprocess.run(
+        [node, str(REPO / "tools/narration-json.mjs"), str(narr), "--voice", json.dumps(voice, ensure_ascii=False)],
+        capture_output=True, text=True, encoding="utf-8")
+    if out.returncode != 0:
+        sys.exit(f"narration-json.mjs が失敗しました:\n{out.stderr}")
+    data = json.loads(out.stdout)
+    for w in data.get("warnings", []):
+        print(f"  ⚠ {w}")
+    return data["segments"]
+
+
+def no_link(deckdir: Path, p: Path) -> Path:
+    """deckdir から p までの途中のフォルダと p 自身のどれかがシンボリックリンクなら止める（壊れたリンクも）。
+    原稿のフォルダに置かれたリンクを通して外のファイルに書かない（SECURITY.md）。deckdir 自身は呼び出した人が選んだもの。"""
+    q = deckdir
+    for part in p.relative_to(deckdir).parts:
+        q = q / part
+        if q.is_symlink():
+            sys.exit(f"⚠ シンボリックリンクを通しては書きません / refusing to write through a symbolic link: {q}")
+    return p
+
+
+def write_text_safe(deckdir: Path, p: Path, text: str):
+    """p に書く（no_link で確かめ、同じフォルダに排他的に作った一時ファイルに書いて rename で入れ替える）。"""
+    no_link(deckdir, p)
+    tmp = p.with_name(f".{p.name}.{os.urandom(8).hex()}.tmp")
+    fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, "O_NOFOLLOW", 0), 0o666)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            f.write(text)
+        os.replace(tmp, p)
+    except BaseException:
+        tmp.unlink(missing_ok=True)
+        raise
+
+
+def est_dur(text: str) -> float:
+    if re.search(r"[A-Za-z]{3}", text) and not re.search(r"[\u3040-\u30ff\u4e00-\u9fff]", text):
+        n = len(text.split())                       # 英語：1 秒 ≒ 2.5 語
+        return round(n / 2.5, 3) if n else 0.0
+    n = len(re.sub(r"\s", "", text))
+    return round(n / CHARS_PER_SEC, 3) if n else 0.0
+
+
+def write_silence(path: Path, dur: float):
+    with wave.open(str(path), "wb") as w:
+        w.setnchannels(1)
+        w.setsampwidth(2)
+        w.setframerate(SR)
+        w.writeframes(b"\x00\x00" * int(round(dur * SR)))
+
+
+def plan(seg: dict, terms, watch_kanji, watch, stats) -> list[list[str]]:
+    """段階の各ターン → 読み辞書を適用した部分（{cue} 区切り）のリスト。terms が None（日本語以外）なら辞書を掛けない。"""
+    if terms is None:
+        return [list(t["ttsParts"]) for t in seg["turns"]]
+    turns = []
+    for t in seg["turns"]:
+        parts = []
+        for p in t["ttsParts"]:
+            txt, used, warns = Y.apply_yomi(p, terms, watch_kanji)
+            for u in used:
+                stats["replaced"][u] = stats["replaced"].get(u, 0) + 1
+            stats["warns"].update(warns)
+            stats["watched"].update(Y.check_watch(txt, watch))
+            parts.append(txt)
+        turns.append(parts)
+    return turns
+
+
+def synth_segment(seg: dict, turns: list[list[str]], out: Path, dry: bool, refs: dict[str, Path]) -> tuple[float, list[float]]:
+    """1 段階分を合成して out に書く。(長さ, cues) を返す。"""
+    pause_s = M.PAUSE_MS / 1000.0
+    if dry:
+        t, cues = 0.0, []
+        for ti, parts in enumerate(turns):
+            if ti > 0:
+                t += pause_s
+            for pi, p in enumerate(parts):
+                if pi > 0:
+                    cues.append(round(t, 3))
+                t += est_dur(p)
+        write_silence(out, t)
+        return round(t, 3), cues
+
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp = Path(tmp)
+        sil = tmp / "pause.wav"
+        write_silence(sil, pause_s)
+        pieces: list[Path] = []
+        cues: list[float] = []
+        t = 0.0
+        for ti, parts in enumerate(turns):
+            ref = refs.get(seg["turns"][ti]["role"])
+            if ti > 0 and pause_s > 0:
+                pieces.append(sil)
+                t += pause_s
+            for pi, p in enumerate(parts):
+                if pi > 0:
+                    cues.append(round(t, 3))
+                if not p.strip():
+                    continue
+                f = tmp / f"t{ti:02d}_p{pi:02d}.wav"
+                M.synthesize_line(p, ref, f, model=MODEL)
+                if M.TRIM_SILENCE:
+                    M.trim_silence(f)
+                M.normalize_level(f)
+                pieces.append(f)
+                t += M.media_duration(f)
+        if not pieces:
+            write_silence(out, 0.0)
+            return 0.0, cues
+        # 行間の無音は pieces に入れてあるので、ここでは間を足さない
+        M.concat_audio_with_pauses(pieces, out, pause_ms=0)
+    dur = M.media_duration(out)
+    return round(dur, 3), cues
+
+
+def main():
+    args = parse_args()
+    deckdir = Path(args.deckdir).resolve()
+    deck_html = None
+    if deckdir.is_file():                     # <deck>/foo.html を渡してもよい
+        deck_html, deckdir = deckdir, deckdir.parent
+    elif (deckdir / "deck.html").exists():
+        deck_html = deckdir / "deck.html"
+    else:
+        cands = sorted(p for p in deckdir.glob("*.html"))
+        deck_html = cands[0] if len(cands) == 1 else None
+    narr = deckdir / "narration.md"
+    if not narr.exists():
+        sys.exit(f"narration.md がありません: {narr}")
+    audio_dir = no_link(deckdir, deckdir / "audio")
+    audio_dir.mkdir(exist_ok=True)
+
+    voices, _, src = resolve_voices(deckdir, args.voices)
+    # 言語とエンジン：--engine > voice.json の "engine" > デッキの <html lang>（en なら voxcpm2）
+    global MODEL
+    vjson = json.loads((deckdir / "voice.json").read_text(encoding="utf-8")) if (deckdir / "voice.json").exists() else {}
+    m_lang = re.search(r'<html[^>]*\blang="([^"]+)"', deck_html.read_text(encoding="utf-8")) if deck_html else None
+    lang = (vjson.get("lang") or (m_lang.group(1) if m_lang else "ja")).lower()
+    engine = args.engine or vjson.get("engine") or ("irodori" if lang.startswith("ja") else "voxcpm2")
+    MODEL = M.ENGINES[engine]
+    use_yomi = lang.startswith("ja")
+    ref_dir = M.ref_dir(args.ref_dir)
+    yomi_src = args.yomi or os.environ.get("MOTION_YOMI")
+    yomi_path = Path(yomi_src).expanduser().resolve() if yomi_src else TTS_DIR / "yomi.yaml"
+    if yomi_src and not yomi_path.exists():
+        sys.exit(f"読み辞書がありません: {yomi_path}")
+    # 日本語以外のデッキでは、名前で指定した声に <名前>_<言語>.wav（例：alice_en.wav）があればそちらを使う
+    # （日本語の参照音声で英語を読ませると訛りが出るため。ファイルの有無はこの PC の参照音声のフォルダで見る）
+    if not lang.startswith("ja"):
+        suffix = "_" + lang.split("-")[0]
+        for r, v in list(voices.items()):
+            if not ("/" in v or v.endswith(".wav")) and (ref_dir / f"{v}{suffix}.wav").exists():
+                voices[r] = v + suffix
+    voice = {
+        "engine": "dry-run" if args.dry_run else engine,
+        "model": MODEL,
+        "expert": voice_file(voices["expert"]),
+        "novice": voice_file(voices["novice"]),
+        "norm": f"{M.TARGET_LUFS}/{M.TARGET_TP_DB}/{M.TARGET_LRA}",
+        "pause_ms": M.PAUSE_MS,
+        "trim": f"{M.TRIM_SILENCE}/{M.TRIM_THRESHOLD}/{M.TRIM_KEEP_S}",
+        # 実際に使う読み辞書と適用規則（yomi.py）が変われば作り直す
+        "yomi": file_hash(yomi_path, TTS_DIR / "yomi.py") if use_yomi else None,
+    }
+    segs = narration_json(narr, voice)
+    used_roles = sorted({t["role"] for s in segs for t in s["turns"]})
+    print(f"口述原稿: {len(segs)} 段階 / {sum(len(s['turns']) for s in segs)} ターン"
+          f"（{'dry-run' if args.dry_run else engine}・言語 {lang}）")
+    for r in used_roles:
+        print(f"  {ROLE_LABEL[r]} → {voice_file(voices[r])}（{src[r]}）")
+    print(f"  読み辞書の場所: {yomi_path}" if use_yomi else "  読み辞書：使わない（日本語以外）")
+
+    refs: dict[str, Path] = {}
+    if not args.dry_run:
+        try:
+            M.ping()
+        except Exception as e:
+            sys.exit(f"⚠ TTS のサーバーに接続できません: {M.IRODORI_URL} ({e})\n"
+                     "  サーバーを起動するか IRODORI_URL を確かめてください（オフラインで流れを試すなら --dry-run）")
+        for r in used_roles:
+            try:
+                refs[r] = M.resolve_voice(voices[r], ref_dir, deckdir)   # 参照音声が無ければここで止める
+                refs[r] = M.ref_at_model_rate(refs[r], no_link(deckdir, deckdir / ".cache" / "voices"))   # 48 kHz・モノラルにそろえる
+            except (FileNotFoundError, PermissionError) as e:
+                sys.exit(f"⚠ {e}")
+
+    only = set(k.strip() for k in args.only.split(",")) if args.only else None
+    if only:
+        unknown = only - {s["key"] for s in segs}
+        if unknown:
+            print(f"  ⚠ --only の鍵が原稿にありません: {', '.join(sorted(unknown))}")
+
+    terms, watch = Y.load_yomi(yomi_path) if use_yomi else (None, [])
+    watch_kanji = Y.load_watch_kanji(yomi_path) if use_yomi else None
+    stats = {"replaced": {}, "warns": set(), "watched": set()}
+
+    man_path = no_link(deckdir, audio_dir / "manifest.json")
+    manifest = {"segments": {}}
+    if man_path.exists():
+        try:
+            manifest = json.loads(man_path.read_text(encoding="utf-8"))
+            manifest.setdefault("segments", {})
+        except json.JSONDecodeError:
+            pass
+    # 原稿から消えた段階は manifest からも消す（音声ファイルは残す：戻したときに再利用できる）
+    keys = {s["key"] for s in segs}
+    for k in list(manifest["segments"]):
+        if k not in keys:
+            del manifest["segments"][k]
+
+    made = cached = kept = 0
+    failed: list[tuple[str, str]] = []
+    for n, seg in enumerate(segs):
+        key = seg["key"]
+        if only and key not in only:
+            continue
+        prev = manifest["segments"].get(key)
+        if isinstance(prev, dict) and prev.get("kind") in ("recorded", "imported") and not args.replace_recorded:
+            kept += 1
+            print(f"  [{n+1}/{len(segs)}] {key}: {'録音' if prev['kind'] == 'recorded' else '取り込み'}の音声を残す（--replace-recorded で TTS に替える）")
+            continue
+        turns = plan(seg, terms, watch_kanji, watch, stats)
+        fname = f"seg_{seg['digest']}.wav"
+        out = no_link(deckdir, audio_dir / fname)
+        meta = no_link(deckdir, audio_dir / f"seg_{seg['digest']}.json")   # 長さと cues の控え（キャッシュ時に測り直さない）
+        if out.exists() and meta.exists() and not args.force:
+            info = json.loads(meta.read_text(encoding="utf-8"))
+            cached += 1
+            print(f"  [{n+1}/{len(segs)}] {key}: キャッシュ使用 ({fname}, {info['dur']:.2f}s)")
+        else:
+            print(f"  [{n+1}/{len(segs)}] {key}: {len(turns)} ターン合成中…", end="")
+            tmp_out = no_link(deckdir, out.with_suffix(".tmp.wav"))
+            try:
+                dur, cues = synth_segment(seg, turns, tmp_out, args.dry_run, refs)
+            except Exception as e:
+                tmp_out.unlink(missing_ok=True)
+                print(f"\n    ✗ 合成に失敗: {e}")
+                failed.append((key, str(e)))
+                # 前の版の音声（違う原稿・声のもの）を使い続けないよう、manifest から外す
+                manifest["segments"].pop(key, None)
+                continue
+            tmp_out.replace(out)
+            info = {"dur": dur, "cues": cues, "voice": voice, "tts": turns}
+            write_text_safe(deckdir, meta, json.dumps(info, ensure_ascii=False, indent=1))
+            made += 1
+            print(f" {dur:.2f}s" + (f", cues {cues}" if cues else ""))
+        manifest["segments"][key] = {"file": fname, "dur": info["dur"], "cues": info["cues"], "digest": seg["digest"],
+                                     "engine": info.get("voice", {}).get("engine", voice["engine"]),
+                                     "kind": "tts", "inputHash": seg.get("inputHash")}
+
+    # 原稿の順に並べ直して書く
+    order = {s["key"]: i for i, s in enumerate(segs)}
+    manifest["segments"] = dict(sorted(manifest["segments"].items(), key=lambda kv: order.get(kv[0], 1e9)))
+    write_text_safe(deckdir, man_path, json.dumps(manifest, ensure_ascii=False, indent=1))
+
+    dry = [k for k, v in manifest["segments"].items() if v.get("engine") == "dry-run"]
+    if dry and not args.dry_run:
+        print(f"  ⚠ manifest に dry-run（無音）の段階が {len(dry)} 個残っています: {', '.join(dry[:5])}{' …' if len(dry) > 5 else ''}")
+    if terms:
+        print(f"  読み辞書: {sum(stats['replaced'].values())} 箇所を置換"
+              + "".join(f"\n     {k} ×{c}" for k, c in sorted(stats["replaced"].items(), key=lambda kv: -kv[1])))
+    for w in sorted(stats["warns"]):
+        print(f"  ⚠ {w}")
+    for w in sorted(stats["watched"]):
+        print(f"  ? 文脈依存の語: {w} — 読みが正しいか確認してください")
+    if failed:
+        print(f"✗ 失敗 {len(failed)} 段階（新規 {made} / キャッシュ {cached} / 録音を残した {kept}）→ {man_path}", file=sys.stderr)
+        for k, e in failed:
+            print(f"    {k}: {e}", file=sys.stderr)
+        print("  失敗した段階は manifest から外した（音声なしになる）。サーバーを確かめて、"
+              f"--only {','.join(k for k, _ in failed)} でやり直すこと", file=sys.stderr)
+        sys.exit(1)
+    print(f"完了: 新規 {made} / キャッシュ {cached}" + (f" / 録音を残した {kept}" if kept else "") + f" → {man_path}")
+    # egatari コマンドから呼ばれたら（EGATARI_CLI）そのコマンドの形で
+    cli = os.environ.get("EGATARI_CLI")
+    print(f"  音声を反映するには build をやり直す（{cli + ' build' if cli else 'node kit/build.mjs'} <deck.html>）")
+
+
+if __name__ == "__main__":
+    # Windows の端末やパイプでも日本語の表示で落ちないように
+    for _s in (sys.stdout, sys.stderr):
+        if hasattr(_s, "reconfigure"):
+            _s.reconfigure(encoding="utf-8", errors="replace")
+    main()