manim-mcp 0.1.0

package/dist/server.js

@@ -0,0 +1,1492 @@
+// server.ts
+import {
+  registerAppResource,
+  registerAppTool,
+  RESOURCE_MIME_TYPE
+} from "@modelcontextprotocol/ext-apps/server";
+import {
+  McpServer,
+  ResourceTemplate
+} from "@modelcontextprotocol/sdk/server/mcp.js";
+import { execSync, execFile, spawn } from "node:child_process";
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import readline from "node:readline";
+import { z } from "zod";
+var DIST_DIR = import.meta.filename.endsWith(".ts") ? path.join(import.meta.dirname, "dist") : import.meta.dirname;
+var REFERENCES_DIR = import.meta.filename.endsWith(".ts") ? path.join(import.meta.dirname, "references") : path.join(import.meta.dirname, "..", "references");
+var VIEW_URI = "ui://manim-player/mcp-app.html";
+var OUTPUT_DIR = path.join(os.tmpdir(), "manim_mcp_output");
+fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+var TTS_CACHE_DIR = path.join(os.homedir(), ".manim-mcp", "tts_cache");
+fs.mkdirSync(TTS_CACHE_DIR, { recursive: true });
+var SCENE_CACHE_DIR = path.join(os.homedir(), ".manim-mcp", "scene_cache");
+fs.mkdirSync(SCENE_CACHE_DIR, { recursive: true });
+var MAX_PARALLEL_RENDERS = 2;
+var RENDER_WORKER_PY = `
+import sys, os, json, traceback, importlib, importlib.util
+
+# Save real stdout for JSON protocol, redirect stdout to stderr so manim logging doesn't corrupt it
+_real_stdout = os.fdopen(os.dup(1), "w")
+os.dup2(2, 1)  # stdout -> stderr
+
+# Pre-import manim once \u2014 this is the expensive part (~700ms)
+from manim import *
+from manim.scene.scene import Scene
+from manim._config import config as manim_config
+
+def _send(msg):
+    _real_stdout.write(json.dumps(msg) + "\\n")
+    _real_stdout.flush()
+
+def render_scene(scene_file, class_name, media_dir, quality_flag):
+    quality_map = {
+        "-ql": "low_quality",
+        "-qm": "medium_quality",
+        "-qh": "high_quality",
+        "-qp": "production_quality",
+    }
+    # Reset config state that may be mutated by previous renders
+    manim_config.quality = quality_map.get(quality_flag, "low_quality")
+    manim_config.media_dir = media_dir
+    manim_config.write_to_movie = True
+    manim_config.save_last_frame = False
+    manim_config.disable_caching = True
+    manim_config.input_file = scene_file
+
+    spec = importlib.util.spec_from_file_location("scene_module", scene_file)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+
+    scene_cls = getattr(mod, class_name)
+    scene = scene_cls()
+    scene.render()
+
+    # Find the final combined mp4, not partial movie clips
+    candidates = []
+    for root, dirs, files in os.walk(media_dir):
+        for f in sorted(files):
+            if f.endswith(".mp4"):
+                full = os.path.join(root, f)
+                is_partial = "partial_movie_files" in full
+                matches_class = class_name in f
+                size = os.path.getsize(full)
+                candidates.append((not is_partial, matches_class, size, full))
+    if candidates:
+        candidates.sort(reverse=True)  # non-partial + class match + largest first
+        return candidates[0][3]
+    return None
+
+_send({"ready": True})
+
+while True:
+    line = sys.stdin.readline()
+    if not line:
+        break
+    line = line.strip()
+    if not line:
+        continue
+    try:
+        cmd = json.loads(line)
+        video_path = render_scene(
+            cmd["scene_file"],
+            cmd["class_name"],
+            cmd["media_dir"],
+            cmd["quality_flag"],
+        )
+        if video_path:
+            _send({"success": True, "videoPath": video_path})
+        else:
+            _send({"success": False, "error": "Render succeeded but no .mp4 found"})
+    except Exception as e:
+        tb = traceback.format_exc()
+        _send({"success": False, "error": tb[-2000:]})
+`;
+var renderWorkers = [];
+function spawnRenderWorker() {
+  const pythonBin = path.join(MANAGED_VENV, "bin", "python");
+  const servicesDir = path.join(MANAGED_VENV_DIR, "services");
+  const espeakLib = process.platform === "darwin" ? "/opt/homebrew/lib/libespeak-ng.dylib" : "/usr/lib/x86_64-linux-gnu/libespeak-ng.so.1";
+  const envPath = [TINYTEX_BIN, "/Library/TeX/texbin", process.env.PATH].filter(Boolean).join(":");
+  const proc = spawn(pythonBin, ["-u", "-c", RENDER_WORKER_PY], {
+    stdio: ["pipe", "pipe", "pipe"],
+    env: {
+      ...process.env,
+      PATH: envPath,
+      PYTHONPATH: [servicesDir, process.env.PYTHONPATH].filter(Boolean).join(":"),
+      PHONEMIZER_ESPEAK_LIBRARY: espeakLib
+    }
+  });
+  const rl = readline.createInterface({ input: proc.stdout });
+  const worker = { process: proc, rl, busy: false, ready: false, pendingReady: null };
+  proc.stderr?.on("data", (_chunk) => {
+  });
+  proc.on("exit", () => {
+    worker.ready = false;
+    renderWorkers = renderWorkers.filter((w) => w !== worker);
+  });
+  return worker;
+}
+function waitForWorkerReady(worker) {
+  if (worker.ready) return Promise.resolve();
+  return new Promise((resolve) => {
+    worker.pendingReady = resolve;
+    const onLine = (line) => {
+      try {
+        const msg = JSON.parse(line);
+        if (msg.ready) {
+          worker.ready = true;
+          worker.rl.removeListener("line", onLine);
+          if (worker.pendingReady) {
+            worker.pendingReady();
+            worker.pendingReady = null;
+          }
+        }
+      } catch {
+      }
+    };
+    worker.rl.on("line", onLine);
+  });
+}
+async function getAvailableWorker() {
+  let worker = renderWorkers.find((w) => w.ready && !w.busy);
+  if (worker) return worker;
+  if (renderWorkers.length < MAX_PARALLEL_RENDERS) {
+    worker = spawnRenderWorker();
+    renderWorkers.push(worker);
+    await waitForWorkerReady(worker);
+    return worker;
+  }
+  return new Promise((resolve) => {
+    const interval = setInterval(() => {
+      const free = renderWorkers.find((w) => w.ready && !w.busy);
+      if (free) {
+        clearInterval(interval);
+        resolve(free);
+      }
+    }, 50);
+  });
+}
+function preWarmWorkers() {
+  const needed = MAX_PARALLEL_RENDERS - renderWorkers.length;
+  for (let i = 0; i < needed; i++) {
+    const worker = spawnRenderWorker();
+    renderWorkers.push(worker);
+    waitForWorkerReady(worker).catch(() => {
+    });
+  }
+}
+function renderViaWorker(worker, cmd) {
+  return new Promise((resolve) => {
+    worker.busy = true;
+    const timeout = setTimeout(() => {
+      worker.busy = false;
+      resolve({ success: false, error: "Worker render timed out (300s)" });
+    }, 3e5);
+    const onLine = (line) => {
+      try {
+        const msg = JSON.parse(line);
+        if ("success" in msg) {
+          clearTimeout(timeout);
+          worker.rl.removeListener("line", onLine);
+          worker.busy = false;
+          resolve(msg);
+        }
+      } catch {
+      }
+    };
+    worker.rl.on("line", onLine);
+    worker.process.stdin.write(JSON.stringify(cmd) + "\n");
+  });
+}
+var MANAGED_VENV_DIR = path.join(os.homedir(), ".manim-mcp");
+var MANAGED_VENV = path.join(MANAGED_VENV_DIR, ".venv");
+var BASE_DEPS = ["manim", "manim-voiceover", "kokoro-onnx", "soundfile", "'setuptools<75'"];
+var MLX_DEPS = ["mlx-audio[kokoro]", "misaki", "num2words", "spacy"];
+var PIPER_DEPS = ["piper-tts"];
+var ELEVENLABS_DEPS = ["elevenlabs"];
+var KOKORO_MODEL_URL = "https://github.com/thewh1teagle/kokoro-onnx/releases/download/model-files-v1.0/kokoro-v1.0.fp16.onnx";
+var KOKORO_VOICES_URL = "https://github.com/thewh1teagle/kokoro-onnx/releases/download/model-files-v1.0/voices-v1.0.bin";
+var KOKORO_SERVICE_PY = `from manim_voiceover.services.base import SpeechService
+import numpy as np
+import soundfile as sf
+from pathlib import Path
+from pydub import AudioSegment
+import tempfile, platform, sys
+
+KOKORO_VOICES = {
+    "en-us": "af_heart", "en-gb": "bf_emma", "ja": "jf_alpha",
+    "cmn": "zf_xiaobei", "es": "ef_dora", "fr": "ff_siwis", "fr-fr": "ff_siwis",
+    "hi": "hf_alpha", "it": "if_sara", "pt-br": "pf_dora",
+}
+
+# Map manim-voiceover lang codes to mlx-audio lang_code (single char)
+MLX_LANG_CODES = {
+    "en-us": "a", "en-gb": "b", "ja": "j", "cmn": "z",
+    "es": "e", "fr": "f", "fr-fr": "f", "hi": "h", "it": "i", "pt-br": "p",
+}
+
+def _use_mlx():
+    """Use MLX backend on Apple Silicon Macs."""
+    return platform.system() == "Darwin" and platform.machine() == "arm64"
+
+# Lazy-loaded singleton for MLX model (heavy to init, reuse across calls)
+_mlx_model = None
+
+def _get_mlx_model():
+    global _mlx_model
+    if _mlx_model is None:
+        from mlx_audio.tts import load
+        _mlx_model = load("mlx-community/Kokoro-82M-bf16")
+    return _mlx_model
+
+class KokoroService(SpeechService):
+    def __init__(self, lang="en-us", cache_dir=None, **kwargs):
+        self.lang = lang
+        self.voice = KOKORO_VOICES.get(lang, "af_heart")
+        self.use_mlx = _use_mlx()
+        if not self.use_mlx:
+            from kokoro_onnx import Kokoro
+            model_dir = Path.home() / ".manim-mcp" / "models" / "kokoro"
+            self.kokoro = Kokoro(
+                str(model_dir / "kokoro-v1.0.fp16.onnx"),
+                str(model_dir / "voices-v1.0.bin"),
+            )
+        SpeechService.__init__(self, cache_dir=cache_dir, transcription_model=None, **kwargs)
+
+    def generate_from_text(self, text, cache_dir=None, path=None, **kwargs):
+        if cache_dir is None:
+            cache_dir = self.cache_dir
+        cache_dir = Path(cache_dir)
+        input_data = {"input_text": text, "service": "kokoro", "lang": self.lang}
+        cached = self.get_cached_result(input_data, cache_dir)
+        if cached is not None:
+            return cached
+        audio_basename = (path or self.get_audio_basename(input_data))
+        mp3_path = audio_basename + ".mp3"
+        if self.use_mlx:
+            model = _get_mlx_model()
+            lang_code = MLX_LANG_CODES.get(self.lang, "a")
+            chunks = list(model.generate(text, voice=self.voice, lang_code=lang_code, speed=1.0))
+            samples = np.concatenate([np.array(c.audio).flatten() for c in chunks])
+            sr = chunks[0].sample_rate if chunks else 24000
+        else:
+            samples, sr = self.kokoro.create(text, voice=self.voice, lang=self.lang, speed=1.0)
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=True) as tmp:
+            sf.write(tmp.name, samples, sr)
+            audio = AudioSegment.from_wav(tmp.name)
+            audio.export(str(Path(cache_dir) / mp3_path), format="mp3")
+        return {
+            "input_text": text,
+            "input_data": input_data,
+            "original_audio": mp3_path,
+        }
+`;
+var PIPER_SERVICE_PY = `from manim_voiceover.services.base import SpeechService
+from piper.voice import PiperVoice
+import wave
+import tempfile
+from pathlib import Path
+from pydub import AudioSegment
+
+class PiperService(SpeechService):
+    def __init__(self, lang="en_US", model_name="lessac", quality="medium", speed=1.0, cache_dir=None, **kwargs):
+        model_dir = Path.home() / ".manim-mcp" / "models" / "piper"
+        model_path = model_dir / f"{lang}-{model_name}-{quality}.onnx"
+        config_path = model_dir / f"{lang}-{model_name}-{quality}.onnx.json"
+        self.voice = PiperVoice.load(str(model_path), config_path=str(config_path))
+        self.lang = lang
+        self.speed = speed
+        SpeechService.__init__(self, cache_dir=cache_dir, transcription_model=None, **kwargs)
+
+    def generate_from_text(self, text, cache_dir=None, path=None, **kwargs):
+        if cache_dir is None:
+            cache_dir = self.cache_dir
+        cache_dir = Path(cache_dir)
+        input_data = {"input_text": text, "service": "piper", "lang": self.lang}
+        cached = self.get_cached_result(input_data, cache_dir)
+        if cached is not None:
+            return cached
+        audio_basename = (path or self.get_audio_basename(input_data))
+        mp3_path = audio_basename + ".mp3"
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=True) as tmp:
+            with wave.open(tmp.name, "wb") as wav_file:
+                self.voice.synthesize_wav(text, wav_file)
+            audio = AudioSegment.from_wav(tmp.name)
+            if self.speed != 1.0:
+                new_rate = int(audio.frame_rate * self.speed)
+                audio = audio._spawn(audio.raw_data, overrides={"frame_rate": new_rate})
+                audio = audio.set_frame_rate(44100)
+            audio.export(str(Path(cache_dir) / mp3_path), format="mp3")
+        return {
+            "input_text": text,
+            "input_data": input_data,
+            "original_audio": mp3_path,
+        }
+`;
+var KOKORO_LANGS = {
+  en: "en-us",
+  "en-us": "en-us",
+  "en-gb": "en-gb",
+  ja: "ja",
+  zh: "cmn",
+  "zh-cn": "cmn",
+  cmn: "cmn",
+  es: "es",
+  fr: "fr-fr",
+  hi: "hi",
+  it: "it",
+  pt: "pt-br"
+};
+var PIPER_LANG_MODELS = {
+  de: { locale: "de_DE", model: "thorsten" },
+  pt: { locale: "pt_BR", model: "faber" },
+  ru: { locale: "ru_RU", model: "denis" },
+  nl: { locale: "nl_NL", model: "mls" },
+  pl: { locale: "pl_PL", model: "gosia" },
+  cs: { locale: "cs_CZ", model: "jirka" },
+  tr: { locale: "tr_TR", model: "dfki" },
+  ar: { locale: "ar_JO", model: "kareem", speed: 1.5 },
+  hu: { locale: "hu_HU", model: "anna" }
+};
+function getTtsConfig(lang) {
+  if (process.env.PREFER_ELEVENLABS && process.env.ELEVEN_API_KEY) return { service: "elevenlabs" };
+  const kokoroLang = KOKORO_LANGS[lang];
+  if (kokoroLang) return { service: "kokoro", lang: kokoroLang };
+  const piper = PIPER_LANG_MODELS[lang];
+  if (piper) return { service: "piper", locale: piper.locale, model: piper.model, speed: piper.speed ?? 1 };
+  if (process.env.ELEVEN_API_KEY) return { service: "elevenlabs" };
+  return { service: "kokoro", lang: "en-us" };
+}
+var TINYTEX_BIN = process.platform === "darwin" ? path.join(os.homedir(), "Library", "TinyTeX", "bin", "universal-darwin") : path.join(os.homedir(), ".TinyTeX", "bin", "x86_64-linux");
+var LATEX_AVAILABLE = false;
+try {
+  execSync("which latex", { timeout: 5e3, stdio: "pipe" });
+  LATEX_AVAILABLE = true;
+} catch {
+  if (fs.existsSync(path.join(TINYTEX_BIN, "latex"))) {
+    LATEX_AVAILABLE = true;
+  }
+}
+console.error(`[manim] LaTeX available: ${LATEX_AVAILABLE}`);
+if (!LATEX_AVAILABLE && fs.existsSync("/Library/TeX/texbin/latex")) {
+  LATEX_AVAILABLE = true;
+}
+var PROJECT_ROOT = import.meta.filename.endsWith(".ts") ? import.meta.dirname : path.join(import.meta.dirname, "..");
+function findManimBin() {
+  const localVenv = path.join(PROJECT_ROOT, ".venv", "bin", "manim");
+  if (fs.existsSync(localVenv)) {
+    console.error("[manim] Using local venv:", localVenv);
+    return localVenv;
+  }
+  const managedBin = path.join(MANAGED_VENV, "bin", "manim");
+  if (fs.existsSync(managedBin)) {
+    console.error("[manim] Using managed venv:", managedBin);
+    return managedBin;
+  }
+  try {
+    const pathBin = execSync("which manim", { encoding: "utf-8", timeout: 5e3 }).trim();
+    if (pathBin) {
+      console.error("[manim] Using system manim:", pathBin);
+      return pathBin;
+    }
+  } catch {
+  }
+  return installManagedVenv();
+}
+function findPython() {
+  for (const cmd of ["python3.13", "python3.12", "python3", "python"]) {
+    try {
+      const version = execSync(`${cmd} --version`, { encoding: "utf-8", timeout: 5e3 }).trim();
+      console.error(`[manim] Found ${version}`);
+      return cmd;
+    } catch {
+    }
+  }
+  throw new Error(
+    "Python 3 not found. Install Python 3.9+ from https://python.org and try again."
+  );
+}
+function installManagedVenv() {
+  console.error("[manim] First run \u2014 installing manim + voiceover + local TTS deps...");
+  const python = findPython();
+  fs.mkdirSync(MANAGED_VENV_DIR, { recursive: true });
+  console.error("[manim] Creating virtual environment...");
+  execSync(`${python} -m venv "${MANAGED_VENV}"`, {
+    timeout: 3e4,
+    stdio: "pipe"
+  });
+  const pip = path.join(MANAGED_VENV, "bin", "pip");
+  console.error(`[manim] Installing ${BASE_DEPS.join(", ")}...`);
+  execSync(`"${pip}" install ${BASE_DEPS.join(" ")}`, {
+    timeout: 3e5,
+    stdio: "pipe"
+  });
+  if (process.env.ELEVEN_API_KEY) {
+    console.error("[manim] ELEVEN_API_KEY detected \u2014 installing elevenlabs...");
+    try {
+      execSync(`"${pip}" install ${ELEVENLABS_DEPS.join(" ")}`, {
+        timeout: 12e4,
+        stdio: "pipe"
+      });
+    } catch (e) {
+      console.error("[manim] Warning: failed to install elevenlabs:", e);
+    }
+  }
+  if (process.platform === "darwin" && process.arch === "arm64") {
+    console.error("[manim] Apple Silicon detected \u2014 installing MLX for faster TTS...");
+    try {
+      execSync(`"${pip}" install ${MLX_DEPS.join(" ")}`, {
+        timeout: 3e5,
+        stdio: "pipe"
+      });
+    } catch (e) {
+      console.error("[manim] Warning: MLX install failed (falling back to ONNX):", e);
+    }
+  }
+  downloadKokoroModels();
+  writeServiceFiles();
+  installTinyTeX();
+  const manimBin = path.join(MANAGED_VENV, "bin", "manim");
+  if (!fs.existsSync(manimBin)) {
+    throw new Error("Installation completed but manim binary not found. Check Python installation.");
+  }
+  console.error("[manim] Setup complete!");
+  return manimBin;
+}
+function downloadKokoroModels() {
+  const modelDir = path.join(MANAGED_VENV_DIR, "models", "kokoro");
+  const modelPath = path.join(modelDir, "kokoro-v1.0.fp16.onnx");
+  const voicesPath = path.join(modelDir, "voices-v1.0.bin");
+  if (fs.existsSync(modelPath) && fs.existsSync(voicesPath)) {
+    console.error("[manim] Kokoro models already downloaded.");
+    return;
+  }
+  fs.mkdirSync(modelDir, { recursive: true });
+  if (!fs.existsSync(modelPath)) {
+    console.error("[manim] Downloading Kokoro model (~300MB)...");
+    execSync(`curl -L -o "${modelPath}" "${KOKORO_MODEL_URL}"`, {
+      timeout: 6e5,
+      stdio: "pipe"
+    });
+  }
+  if (!fs.existsSync(voicesPath)) {
+    console.error("[manim] Downloading Kokoro voices...");
+    execSync(`curl -L -o "${voicesPath}" "${KOKORO_VOICES_URL}"`, {
+      timeout: 12e4,
+      stdio: "pipe"
+    });
+  }
+  console.error("[manim] Kokoro models downloaded.");
+}
+function writeServiceFiles() {
+  const servicesDir = path.join(MANAGED_VENV_DIR, "services");
+  fs.mkdirSync(servicesDir, { recursive: true });
+  fs.writeFileSync(path.join(servicesDir, "kokoro_service.py"), KOKORO_SERVICE_PY);
+  fs.writeFileSync(path.join(servicesDir, "piper_service.py"), PIPER_SERVICE_PY);
+  console.error("[manim] Custom TTS service files written.");
+}
+function installTinyTeX() {
+  try {
+    execSync("which latex", { timeout: 5e3, stdio: "pipe" });
+    console.error("[manim] LaTeX already installed.");
+    return;
+  } catch {
+  }
+  if (fs.existsSync(TINYTEX_BIN)) {
+    console.error("[manim] TinyTeX already installed at", TINYTEX_BIN);
+    return;
+  }
+  if (process.platform === "darwin" || process.platform === "linux") {
+    console.error("[manim] Installing TinyTeX for LaTeX rendering...");
+    try {
+      execSync('curl -sL "https://yihui.org/tinytex/install-bin-unix.sh" | sh', {
+        timeout: 3e5,
+        stdio: "pipe"
+      });
+      const tlmgr = path.join(TINYTEX_BIN, "tlmgr");
+      if (fs.existsSync(tlmgr)) {
+        console.error("[manim] Installing LaTeX packages for manim...");
+        execSync(`"${tlmgr}" install amsmath amssymb amsfonts standalone preview doublestroke setspace rsfs relsize mathtools physics dvisvgm dvipng jknapltx calligra etoolbox l3packages l3kernel pgf xcolor xkeyval`, {
+          timeout: 12e4,
+          stdio: "pipe"
+        });
+      }
+      console.error("[manim] TinyTeX installed.");
+    } catch (e) {
+      console.error("[manim] Warning: TinyTeX install failed (LaTeX rendering won't work):", e);
+    }
+  }
+}
+function ensurePiperDeps(locale, model) {
+  const pip = path.join(MANAGED_VENV, "bin", "pip");
+  try {
+    execSync(`"${pip}" show piper-tts`, { timeout: 1e4, stdio: "pipe" });
+  } catch {
+    console.error("[manim] Installing piper-tts for extended language support...");
+    execSync(`"${pip}" install ${PIPER_DEPS.join(" ")}`, {
+      timeout: 12e4,
+      stdio: "pipe"
+    });
+  }
+  const modelDir = path.join(MANAGED_VENV_DIR, "models", "piper");
+  const modelFile = `${locale}-${model}-medium.onnx`;
+  const modelPath = path.join(modelDir, modelFile);
+  if (!fs.existsSync(modelPath)) {
+    fs.mkdirSync(modelDir, { recursive: true });
+    const langPrefix = locale.split("_")[0];
+    const baseUrl = `https://huggingface.co/rhasspy/piper-voices/resolve/v1.0.0/${langPrefix}/${locale}/${model}/medium`;
+    console.error(`[manim] Downloading Piper voice model: ${modelFile}...`);
+    execSync(`curl -L -o "${modelPath}" "${baseUrl}/${modelFile}"`, {
+      timeout: 12e4,
+      stdio: "pipe"
+    });
+    const configFile = `${modelFile}.json`;
+    const configPath = path.join(modelDir, configFile);
+    execSync(`curl -L -o "${configPath}" "${baseUrl}/${configFile}"`, {
+      timeout: 3e4,
+      stdio: "pipe"
+    });
+    console.error(`[manim] Piper voice model downloaded: ${modelFile}`);
+  }
+}
+var MANIM_BIN;
+function getManimBin() {
+  if (!MANIM_BIN) MANIM_BIN = findManimBin();
+  return MANIM_BIN;
+}
+var videoStore = /* @__PURE__ */ new Map();
+function getVoiceoverImport(ttsConfig) {
+  switch (ttsConfig.service) {
+    case "elevenlabs":
+      return `import sys, os
+sys.path.insert(0, os.path.expanduser("~/.manim-mcp/services"))
+from manim_voiceover import VoiceoverScene
+from manim_voiceover.services.elevenlabs import ElevenLabsService`;
+    case "kokoro":
+      return `import sys, os
+sys.path.insert(0, os.path.expanduser("~/.manim-mcp/services"))
+from manim_voiceover import VoiceoverScene
+from kokoro_service import KokoroService`;
+    case "piper":
+      return `import sys, os
+sys.path.insert(0, os.path.expanduser("~/.manim-mcp/services"))
+from manim_voiceover import VoiceoverScene
+from piper_service import PiperService`;
+  }
+}
+function getVoiceoverInit(ttsConfig) {
+  const cacheDir = TTS_CACHE_DIR.replace(/"/g, '\\"');
+  switch (ttsConfig.service) {
+    case "elevenlabs":
+      return `self.set_speech_service(
+            ElevenLabsService(
+                voice_id="nPczCjzI2devNBz1zQrb",
+                voice_settings={"stability": 0.5, "similarity_boost": 0.75},
+                transcription_model=None,
+                cache_dir="${cacheDir}",
+            )
+        )`;
+    case "kokoro":
+      return `self.set_speech_service(KokoroService(lang="${ttsConfig.lang}", cache_dir="${cacheDir}"))`;
+    case "piper":
+      return `self.set_speech_service(PiperService(lang="${ttsConfig.locale}", model_name="${ttsConfig.model}", speed=${ttsConfig.speed}, cache_dir="${cacheDir}"))`;
+  }
+}
+function fixGeneratedCode(code, language = "en") {
+  let fixed = code;
+  const ttsConfig = getTtsConfig(language);
+  const voiceoverImport = getVoiceoverImport(ttsConfig);
+  const voiceoverInit = getVoiceoverInit(ttsConfig);
+  fixed = fixed.replace(
+    /from manim_voiceover\.services\.\w+ import \w+/g,
+    ""
+  );
+  fixed = fixed.replace(
+    /import sys, os\nsys\.path\.insert\(0, os\.path\.expanduser\("~\/\.manim-mcp\/services"\)\)\n/g,
+    ""
+  );
+  fixed = fixed.replace(/from (?:kokoro_service|piper_service) import \w+\n?/g, "");
+  if (/VoiceoverScene/.test(fixed)) {
+    if (/from manim_voiceover import/.test(fixed)) {
+      fixed = fixed.replace(
+        /from manim_voiceover import VoiceoverScene/,
+        voiceoverImport
+      );
+    } else {
+      fixed = fixed.replace(
+        /from manim import \*/,
+        `from manim import *
+${voiceoverImport}`
+      );
+    }
+  }
+  const svcPattern = /self\.set_(?:speech_service|speech_synthesizer|tts_service|voice_service|tts)\(/g;
+  let svcMatch;
+  while ((svcMatch = svcPattern.exec(fixed)) !== null) {
+    const start = svcMatch.index;
+    let depth = 1;
+    let i = start + svcMatch[0].length;
+    while (i < fixed.length && depth > 0) {
+      if (fixed[i] === "(") depth++;
+      else if (fixed[i] === ")") depth--;
+      i++;
+    }
+    fixed = fixed.slice(0, start) + voiceoverInit + fixed.slice(i);
+    svcPattern.lastIndex = start + voiceoverInit.length;
+  }
+  if (/class \w+\(VoiceoverScene\)/.test(fixed) && !/set_speech_service/.test(fixed)) {
+    fixed = fixed.replace(
+      /(def construct\(self\):)/,
+      `$1
+        ${voiceoverInit}
+`
+    );
+  }
+  fixed = fixed.replace(
+    /\.get_te(?:x|xt)\(([^)]*?)(?:,\s*font_size\s*=\s*\d+)/g,
+    ".get_text($1"
+  );
+  fixed = fixed.replace(/self\.(?:safe_wait|wait)\(tracker\.get_remaining\(\)\)/g, "self.wait()");
+  fixed = fixed.replace(/tracker\.get_remaining\(\)/g, "tracker.duration");
+  fixed = fixed.replace(/\bCYAN\b/g, "TEAL");
+  fixed = fixed.replace(/(?:color\s*=\s*|ManimColor\s*\(\s*)["']#[0-9A-Fa-f]{3,8}["']/g, (match) => {
+    return match.replace(/["']#[0-9A-Fa-f]{3,8}["']/, "BLUE");
+  });
+  if (!LATEX_AVAILABLE) {
+    fixed = fixed.replace(
+      /\b(MathTex|Tex)\(\s*r?"((?:[^"\\]|\\.)*)"/g,
+      (_match, _cls, latex) => {
+        const unicode = latexToUnicode(latex);
+        return `Text("${unicode}"`;
+      }
+    );
+    fixed = fixed.replace(
+      /\b(MathTex|Tex)\(\s*r?"""((?:[^"\\]|\\.|"(?!""))*?)"""/g,
+      (_match, _cls, latex) => {
+        const unicode = latexToUnicode(latex);
+        return `Text("${unicode}"`;
+      }
+    );
+  }
+  fixed = fixed.replace(/\n{3,}/g, "\n\n");
+  return fixed;
+}
+function latexToUnicode(latex) {
+  let s = latex;
+  s = s.replace(/\\(?:left|right|,|;|!|quad|qquad|text\s*\{([^}]*)\})/g, "$1");
+  s = s.replace(/\\frac\s*\{([^}]*)\}\s*\{([^}]*)\}/g, "($1)/($2)");
+  const greek = {
+    alpha: "\u03B1",
+    beta: "\u03B2",
+    gamma: "\u03B3",
+    delta: "\u03B4",
+    epsilon: "\u03B5",
+    zeta: "\u03B6",
+    eta: "\u03B7",
+    theta: "\u03B8",
+    iota: "\u03B9",
+    kappa: "\u03BA",
+    lambda: "\u03BB",
+    mu: "\u03BC",
+    nu: "\u03BD",
+    xi: "\u03BE",
+    pi: "\u03C0",
+    rho: "\u03C1",
+    sigma: "\u03C3",
+    tau: "\u03C4",
+    upsilon: "\u03C5",
+    phi: "\u03C6",
+    chi: "\u03C7",
+    psi: "\u03C8",
+    omega: "\u03C9",
+    Gamma: "\u0393",
+    Delta: "\u0394",
+    Theta: "\u0398",
+    Lambda: "\u039B",
+    Xi: "\u039E",
+    Pi: "\u03A0",
+    Sigma: "\u03A3",
+    Phi: "\u03A6",
+    Psi: "\u03A8",
+    Omega: "\u03A9"
+  };
+  for (const [name, sym] of Object.entries(greek)) {
+    s = s.replace(new RegExp(`\\\\${name}\\b`, "g"), sym);
+  }
+  const symbols = {
+    "\\\\cdot": "\xB7",
+    "\\\\times": "\xD7",
+    "\\\\div": "\xF7",
+    "\\\\pm": "\xB1",
+    "\\\\leq": "\u2264",
+    "\\\\geq": "\u2265",
+    "\\\\neq": "\u2260",
+    "\\\\approx": "\u2248",
+    "\\\\infty": "\u221E",
+    "\\\\sqrt": "\u221A",
+    "\\\\sum": "\u03A3",
+    "\\\\prod": "\u220F",
+    "\\\\int": "\u222B",
+    "\\\\partial": "\u2202",
+    "\\\\nabla": "\u2207",
+    "\\\\forall": "\u2200",
+    "\\\\exists": "\u2203",
+    "\\\\in": "\u2208",
+    "\\\\notin": "\u2209",
+    "\\\\subset": "\u2282",
+    "\\\\rightarrow": "\u2192",
+    "\\\\leftarrow": "\u2190",
+    "\\\\Rightarrow": "\u21D2",
+    "\\\\neg": "\xAC",
+    "\\\\lnot": "\xAC"
+  };
+  for (const [pat, sym] of Object.entries(symbols)) {
+    s = s.replace(new RegExp(pat, "g"), sym);
+  }
+  s = s.replace(/\^{([^}]*)}/g, (_m, inner) => {
+    const sup = {
+      "0": "\u2070",
+      "1": "\xB9",
+      "2": "\xB2",
+      "3": "\xB3",
+      "4": "\u2074",
+      "5": "\u2075",
+      "6": "\u2076",
+      "7": "\u2077",
+      "8": "\u2078",
+      "9": "\u2079",
+      "+": "\u207A",
+      "-": "\u207B",
+      "n": "\u207F",
+      "i": "\u2071",
+      "T": "\u1D40"
+    };
+    return inner.split("").map((c) => sup[c] ?? c).join("");
+  });
+  s = s.replace(/\^([0-9nTi])/g, (_m, c) => {
+    const sup = { "0": "\u2070", "1": "\xB9", "2": "\xB2", "3": "\xB3", "4": "\u2074", "5": "\u2075", "6": "\u2076", "7": "\u2077", "8": "\u2078", "9": "\u2079", "n": "\u207F", "T": "\u1D40", "i": "\u2071" };
+    return sup[c] ?? c;
+  });
+  s = s.replace(/_{([^}]*)}/g, (_m, inner) => {
+    const sub = {
+      "0": "\u2080",
+      "1": "\u2081",
+      "2": "\u2082",
+      "3": "\u2083",
+      "4": "\u2084",
+      "5": "\u2085",
+      "6": "\u2086",
+      "7": "\u2087",
+      "8": "\u2088",
+      "9": "\u2089",
+      "+": "\u208A",
+      "-": "\u208B",
+      "k": "\u2096",
+      "i": "\u1D62",
+      "j": "\u2C7C",
+      "n": "\u2099"
+    };
+    return inner.split("").map((c) => sub[c] ?? c).join("");
+  });
+  s = s.replace(/_([0-9kijn])/g, (_m, c) => {
+    const sub = { "0": "\u2080", "1": "\u2081", "2": "\u2082", "3": "\u2083", "4": "\u2084", "5": "\u2085", "6": "\u2086", "7": "\u2087", "8": "\u2088", "9": "\u2089", "k": "\u2096", "i": "\u1D62", "j": "\u2C7C", "n": "\u2099" };
+    return sub[c] ?? c;
+  });
+  s = s.replace(/\\([a-zA-Z]+)/g, "$1");
+  s = s.replace(/[{}]/g, "");
+  s = s.replace(/\$/g, "");
+  return s;
+}
+async function runWithConcurrency(tasks, limit) {
+  const results = new Array(tasks.length);
+  let nextIndex = 0;
+  async function worker() {
+    while (nextIndex < tasks.length) {
+      const i = nextIndex++;
+      results[i] = await tasks[i]();
+    }
+  }
+  const workers = Array.from({ length: Math.min(limit, tasks.length) }, () => worker());
+  await Promise.all(workers);
+  return results;
+}
+function extractVoiceoverTexts(code) {
+  const texts = [];
+  const patterns = [
+    // Triple-quoted strings: text="""...""" or text='''...'''
+    /self\.voiceover\s*\(\s*text\s*=\s*"""([\s\S]*?)"""/g,
+    /self\.voiceover\s*\(\s*text\s*=\s*'''([\s\S]*?)'''/g,
+    // Single-line strings: text="..." or text='...'
+    /self\.voiceover\s*\(\s*text\s*=\s*"([^"]*?)"/g,
+    /self\.voiceover\s*\(\s*text\s*=\s*'([^']*?)'/g
+  ];
+  for (const pattern of patterns) {
+    let match;
+    while ((match = pattern.exec(code)) !== null) {
+      const text = match[1].trim();
+      if (text.length > 0) texts.push(text);
+    }
+  }
+  return texts;
+}
+var TTS_PRESYNC_PY = `
+import sys, os, json
+
+# Redirect stdout to stderr so only our JSON protocol goes to real stdout
+_real_stdout = os.fdopen(os.dup(1), "w")
+os.dup2(2, 1)
+
+from pathlib import Path
+cache_dir = Path(sys.argv[1])
+lang = sys.argv[2]
+
+# Read texts from stdin (JSON array)
+texts = json.loads(sys.stdin.readline())
+
+if not texts:
+    _real_stdout.write(json.dumps({"done": True, "count": 0}) + "\\n")
+    _real_stdout.flush()
+    sys.exit(0)
+
+sys.stderr.write(f"[tts-presync] Pre-synthesizing {len(texts)} voiceover(s) for lang={lang}\\n")
+sys.stderr.flush()
+
+# Import and init the service (loads model once)
+sys.path.insert(0, os.path.join(os.path.expanduser("~"), ".manim-mcp", "services"))
+from kokoro_service import KokoroService
+svc = KokoroService(lang=lang, cache_dir=cache_dir)
+
+count = 0
+for i, text in enumerate(texts):
+    # Normalize whitespace like _wrap_generate_from_text does
+    normalized = " ".join(text.split())
+    input_data = {"input_text": normalized, "service": "kokoro", "lang": lang}
+    cached = svc.get_cached_result(input_data, cache_dir)
+    if cached is not None:
+        sys.stderr.write(f"[tts-presync] ({i+1}/{len(texts)}) cached\\n")
+        sys.stderr.flush()
+        continue
+    try:
+        svc._wrap_generate_from_text(text)
+        count += 1
+        sys.stderr.write(f"[tts-presync] ({i+1}/{len(texts)}) synthesized\\n")
+        sys.stderr.flush()
+    except Exception as e:
+        sys.stderr.write(f"[tts-presync] ({i+1}/{len(texts)}) error: {e}\\n")
+        sys.stderr.flush()
+
+_real_stdout.write(json.dumps({"done": True, "count": count}) + "\\n")
+_real_stdout.flush()
+`;
+function startTtsPreSynthesis(allTexts, lang) {
+  if (allTexts.length === 0) return Promise.resolve();
+  const ttsConfig = getTtsConfig(lang);
+  if (ttsConfig.service !== "kokoro") return Promise.resolve();
+  const kokoroLang = ttsConfig.lang;
+  console.error(`[manim] Starting speculative TTS pre-synthesis: ${allTexts.length} text(s), lang=${kokoroLang}`);
+  return new Promise((resolve) => {
+    const pythonBin = path.join(MANAGED_VENV, "bin", "python");
+    const envPath = [path.dirname(pythonBin), process.env.PATH].filter(Boolean).join(":");
+    const espeakLib = process.platform === "darwin" ? "/opt/homebrew/lib/libespeak-ng.dylib" : "/usr/lib/x86_64-linux-gnu/libespeak-ng.so.1";
+    const servicesDir = path.join(MANAGED_VENV_DIR, "services");
+    const pythonPath = [servicesDir, process.env.PYTHONPATH].filter(Boolean).join(":");
+    const child = spawn(pythonBin, ["-c", TTS_PRESYNC_PY, TTS_CACHE_DIR, kokoroLang], {
+      stdio: ["pipe", "pipe", "inherit"],
+      env: {
+        ...process.env,
+        PATH: envPath,
+        PYTHONPATH: pythonPath,
+        PHONEMIZER_ESPEAK_LIBRARY: espeakLib
+      },
+      timeout: 12e4
+    });
+    child.stdin.write(JSON.stringify(allTexts) + "\n");
+    child.stdin.end();
+    const rl = readline.createInterface({ input: child.stdout });
+    rl.on("line", (line) => {
+      try {
+        const msg = JSON.parse(line);
+        if (msg.done) {
+          console.error(`[manim] TTS pre-synthesis done: ${msg.count} new, ${allTexts.length - msg.count} cached`);
+        }
+      } catch {
+      }
+    });
+    child.on("close", () => resolve());
+    child.on("error", (err) => {
+      console.error(`[manim] TTS pre-synthesis error: ${err.message}`);
+      resolve();
+    });
+  });
+}
+function sceneHash(fixedCode, qualityFlag) {
+  return crypto.createHash("sha256").update(`${qualityFlag}
+${fixedCode}`).digest("hex").slice(0, 16);
+}
+function getSceneCacheHit(hash) {
+  const cached = path.join(SCENE_CACHE_DIR, `${hash}.mp4`);
+  if (fs.existsSync(cached)) {
+    const stat = fs.statSync(cached);
+    if (stat.size > 1024) return cached;
+  }
+  return void 0;
+}
+function storeSceneCache(hash, videoPath) {
+  const cached = path.join(SCENE_CACHE_DIR, `${hash}.mp4`);
+  try {
+    fs.copyFileSync(videoPath, cached);
+  } catch {
+  }
+}
+async function renderManimScene(code, className, quality = "l", language = "en") {
+  const fixedCode = fixGeneratedCode(code, language);
+  const qualityFlag = { l: "-ql", m: "-qm", h: "-qh" }[quality] ?? "-ql";
+  const hash = sceneHash(fixedCode, qualityFlag);
+  const cached = getSceneCacheHit(hash);
+  if (cached) {
+    console.error(`[manim] Scene cache HIT for ${className} (${hash})`);
+    return { success: true, videoPath: cached };
+  }
+  const sceneDir = path.join(OUTPUT_DIR, `${className}_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`);
+  fs.mkdirSync(sceneDir, { recursive: true });
+  const sceneFile = path.join(sceneDir, `${className}.py`);
+  fs.writeFileSync(sceneFile, fixedCode);
+  let result;
+  try {
+    const worker = await getAvailableWorker();
+    result = await renderViaWorker(worker, {
+      scene_file: sceneFile,
+      class_name: className,
+      media_dir: sceneDir,
+      quality_flag: qualityFlag
+    });
+  } catch (workerError) {
+    result = await renderManimSceneFallback(sceneFile, className, sceneDir, qualityFlag);
+  }
+  if (result.success && result.videoPath) {
+    storeSceneCache(hash, result.videoPath);
+  }
+  return result;
+}
+function renderManimSceneFallback(sceneFile, className, sceneDir, qualityFlag) {
+  return new Promise((resolve) => {
+    const envPath = [TINYTEX_BIN, "/Library/TeX/texbin", process.env.PATH].filter(Boolean).join(":");
+    const servicesDir = path.join(MANAGED_VENV_DIR, "services");
+    const pythonPath = [servicesDir, process.env.PYTHONPATH].filter(Boolean).join(":");
+    const espeakLib = process.platform === "darwin" ? "/opt/homebrew/lib/libespeak-ng.dylib" : "/usr/lib/x86_64-linux-gnu/libespeak-ng.so.1";
+    execFile(getManimBin(), [
+      "render",
+      qualityFlag,
+      "--media_dir",
+      sceneDir,
+      sceneFile,
+      className
+    ], {
+      timeout: 3e5,
+      cwd: sceneDir,
+      env: {
+        ...process.env,
+        PATH: envPath,
+        PYTHONPATH: pythonPath,
+        PHONEMIZER_ESPEAK_LIBRARY: espeakLib
+      }
+    }, (error, _stdout, stderr) => {
+      if (error) {
+        resolve({
+          success: false,
+          error: (stderr ?? String(error)).slice(-2e3)
+        });
+        return;
+      }
+      const videoPath = findVideo(sceneDir, className);
+      if (!videoPath) {
+        resolve({ success: false, error: "Render succeeded but no .mp4 found" });
+        return;
+      }
+      resolve({ success: true, videoPath });
+    });
+  });
+}
+function findVideo(dir, className) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true, recursive: true });
+  const mp4s = [];
+  for (const e of entries) {
+    if (e.isFile() && e.name.endsWith(".mp4")) {
+      const fullPath = path.join(e.parentPath ?? e.path, e.name);
+      const isPartial = fullPath.includes("partial_movie_files");
+      const matchesClass = e.name.includes(className);
+      const size = fs.statSync(fullPath).size;
+      mp4s.push({ path: fullPath, isPartial, matchesClass, size });
+    }
+  }
+  mp4s.sort((a, b) => {
+    if (!a.isPartial && b.isPartial) return -1;
+    if (a.isPartial && !b.isPartial) return 1;
+    if (a.matchesClass && !b.matchesClass) return -1;
+    if (!a.matchesClass && b.matchesClass) return 1;
+    return b.size - a.size;
+  });
+  return mp4s[0]?.path;
+}
+function concatVideos(videoPaths, outputPath) {
+  if (videoPaths.length === 0) return false;
+  if (videoPaths.length === 1) {
+    fs.copyFileSync(videoPaths[0], outputPath);
+    return true;
+  }
+  const listFile = path.join(OUTPUT_DIR, `concat_${Date.now()}.txt`);
+  fs.writeFileSync(listFile, videoPaths.map((p) => `file '${p}'`).join("\n"));
+  try {
+    execSync(`ffmpeg -y -f concat -safe 0 -i "${listFile}" -c copy "${outputPath}"`, {
+      timeout: 12e4,
+      stdio: "pipe"
+    });
+    return true;
+  } catch {
+    return false;
+  } finally {
+    try {
+      fs.unlinkSync(listFile);
+    } catch {
+    }
+  }
+}
+function listRefFiles(subdir, ext) {
+  const dir = path.join(REFERENCES_DIR, subdir);
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir).filter((f) => f.endsWith(ext)).sort();
+}
+function readRef(subpath) {
+  return fs.readFileSync(path.join(REFERENCES_DIR, subpath), "utf-8");
+}
+function createServer() {
+  const server = new McpServer(
+    { name: "Manim Video Generator", version: "1.0.0" },
+    {
+      instructions: `You are driving a 3Blue1Brown-style math animation server with comprehensive Manim reference materials.
+
+WORKFLOW:
+1. FIRST: Call get_manim_reference to load the best practices and style guide for the topic
+2. Plan 2-4 scenes (titles, descriptions, narration scripts) following 3b1b storytelling principles
+3. Write Manim code for each scene following the loaded reference guidelines
+4. Call render_video with ALL scenes at once \u2014 they render in parallel, get concatenated, and show as one video
+
+For simple topics, 2 scenes is enough. For complex topics, use 3-4.
+Default quality is "l" (480p) for fast iteration. Only use "m" or "h" if the user asks.
+
+SCENE COMPOSITION \u2014 CRITICAL:
+Each scene renders independently with NO shared state. This means each scene starts from a blank canvas.
+DO NOT rebuild the same visual in every scene. Each scene MUST have a DISTINCT visual focus:
+- BAD: Scene 1 draws triangle + labels \u2192 Scene 2 draws same triangle + labels + squares \u2192 Scene 3 draws same triangle + labels + equation
+- GOOD: Scene 1 draws triangle, introduces the question \u2192 Scene 2 shows geometric proof with rearrangement (NO triangle rebuild) \u2192 Scene 3 shows equation + numerical verification
+Think of each scene as a different CAMERA ANGLE on the topic \u2014 different layout, different focal objects, different stage of the argument.
+If Scene N needs a visual from Scene N-1, use a BRIEF recap (1-2 seconds) with a simplified/smaller version, not a full rebuild.
+
+LANGUAGE SUPPORT:
+Pass the \`language\` parameter to render_video. Write ALL narration in the requested language.
+Kokoro (best, local): en, zh, ja, ko, es, fr, hi, it | Piper (extended): de, pt, ru, nl, cs, ar, hu, pl, tr | ElevenLabs (premium, needs ELEVEN_API_KEY): all
+
+VOICEOVER (MANDATORY):
+Use VoiceoverScene base class. The server auto-injects the correct TTS service \u2014 just write:
+  with self.voiceover(text="...") as tracker:
+      self.play(Create(obj), run_time=tracker.duration)
+KEY: Always use tracker.duration to sync animation with speech!
+GOTCHA: tracker.get_remaining() does NOT exist. The voiceover context manager auto-waits when the block exits. Just use self.wait() if you need a pause, never tracker.get_remaining().
+
+The server auto-fixes common issues: wrong TTS service, CYAN\u2192TEAL, tracker.get_remaining()\u2192self.wait().
+LaTeX: If LaTeX is installed, use MathTex/Tex. If not, the server auto-converts to Text() with Unicode (\u03C0, \xB2, \u221A, \u222B, etc.).
+TTS defaults to local models (Kokoro/Piper). Set PREFER_ELEVENLABS=1 + ELEVEN_API_KEY to use ElevenLabs instead.
+
+IF A RENDER FAILS: Read the error, fix the code, call render_video again.`
+    }
+  );
+  server.registerResource(
+    "video",
+    new ResourceTemplate("videos://{id}", { list: void 0 }),
+    {
+      description: "Rendered Manim video (base64 blob)",
+      mimeType: "video/mp4"
+    },
+    async (uri, { id }) => {
+      const idStr = Array.isArray(id) ? id[0] : id;
+      const buffer = videoStore.get(idStr);
+      if (!buffer) {
+        throw new Error(`Video not found: ${idStr}`);
+      }
+      console.error(`[manim] Serving video ${idStr}: ${buffer.byteLength} bytes`);
+      return {
+        contents: [{
+          uri: uri.href,
+          mimeType: "video/mp4",
+          blob: buffer.toString("base64")
+        }]
+      };
+    }
+  );
+  const manimceRulesDir = path.join(REFERENCES_DIR, "manimce", "rules");
+  if (fs.existsSync(manimceRulesDir)) {
+    server.registerResource(
+      "manimce-rules",
+      new ResourceTemplate("skills://manimce/rules/{name}", {
+        list: async () => ({
+          resources: listRefFiles("manimce/rules", ".md").map((f) => ({
+            uri: `skills://manimce/rules/${f.replace(".md", "")}`,
+            name: `ManimCE: ${f.replace(".md", "").replace(/-/g, " ")}`,
+            mimeType: "text/markdown"
+          }))
+        })
+      }),
+      { description: "ManimCE best practices rule files (animations, positioning, LaTeX, 3D, colors, timing, etc.)", mimeType: "text/markdown" },
+      async (uri, { name }) => {
+        const fileName = (Array.isArray(name) ? name[0] : name) + ".md";
+        return { contents: [{ uri: uri.href, mimeType: "text/markdown", text: readRef(`manimce/rules/${fileName}`) }] };
+      }
+    );
+  }
+  const manimceExamplesDir = path.join(REFERENCES_DIR, "manimce", "examples");
+  if (fs.existsSync(manimceExamplesDir)) {
+    server.registerResource(
+      "manimce-examples",
+      new ResourceTemplate("skills://manimce/examples/{name}", {
+        list: async () => ({
+          resources: listRefFiles("manimce/examples", ".py").map((f) => ({
+            uri: `skills://manimce/examples/${f.replace(".py", "")}`,
+            name: `Example: ${f.replace(".py", "").replace(/_/g, " ")}`,
+            mimeType: "text/x-python"
+          }))
+        })
+      }),
+      { description: "Working ManimCE code examples", mimeType: "text/x-python" },
+      async (uri, { name }) => {
+        const fileName = (Array.isArray(name) ? name[0] : name) + ".py";
+        return { contents: [{ uri: uri.href, mimeType: "text/x-python", text: readRef(`manimce/examples/${fileName}`) }] };
+      }
+    );
+  }
+  const composerRefsDir = path.join(REFERENCES_DIR, "composer", "references");
+  if (fs.existsSync(composerRefsDir)) {
+    server.registerResource(
+      "composer-references",
+      new ResourceTemplate("skills://composer/{name}", {
+        list: async () => ({
+          resources: listRefFiles("composer/references", ".md").map((f) => ({
+            uri: `skills://composer/${f.replace(".md", "")}`,
+            name: `Composer: ${f.replace(".md", "").replace(/-/g, " ")}`,
+            mimeType: "text/markdown"
+          }))
+        })
+      }),
+      { description: "3Blue1Brown video composition guides: narrative patterns, scene archetypes, pacing, storytelling", mimeType: "text/markdown" },
+      async (uri, { name }) => {
+        const fileName = (Array.isArray(name) ? name[0] : name) + ".md";
+        return { contents: [{ uri: uri.href, mimeType: "text/markdown", text: readRef(`composer/references/${fileName}`) }] };
+      }
+    );
+  }
+  const referenceTopics = [
+    "animations",
+    "positioning",
+    "latex",
+    "colors",
+    "timing",
+    "axes",
+    "3d",
+    "camera",
+    "creation-animations",
+    "transform-animations",
+    "animation-groups",
+    "text",
+    "styling",
+    "grouping",
+    "graphing",
+    "updaters",
+    "shapes",
+    "lines",
+    "scenes",
+    "mobjects",
+    "pedagogy",
+    "advanced-animations",
+    "mathematical-domains",
+    "color-conventions",
+    "physics-simulations",
+    "3b1b-translation",
+    "long-form-video",
+    "text-animations",
+    "multi-scene-composition",
+    "config",
+    "cli",
+    "api-pitfalls"
+  ];
+  server.tool(
+    "get_manim_reference",
+    `Load Manim best practices and reference material. Call this BEFORE writing scene code.
+Topics: ${referenceTopics.join(", ")}
+Use "all-core" to get the most important rules (animations, positioning, colors, timing, axes, 3d, latex, pedagogy) in one call.
+Use "composer" to get the 3b1b video planning and storytelling guide.`,
+    {
+      topics: z.array(z.string()).min(1).describe('Topics to load. Use specific names or "all-core" for essential rules, "composer" for storytelling guide.')
+    },
+    async ({ topics }) => {
+      preWarmWorkers();
+      const sections = [];
+      const resolvedTopics = /* @__PURE__ */ new Set();
+      for (const t of topics) {
+        if (t === "all-core") {
+          ["animations", "positioning", "colors", "timing", "axes", "3d", "latex", "pedagogy", "creation-animations", "transform-animations", "multi-scene-composition", "api-pitfalls"].forEach((r) => resolvedTopics.add(r));
+        } else if (t === "composer") {
+          try {
+            sections.push(readRef("composer/SKILL.md"));
+          } catch {
+          }
+          for (const ref of ["narrative-patterns", "scene-archetypes", "pacing-guide", "visual-techniques"]) {
+            try {
+              sections.push(readRef(`composer/references/${ref}.md`));
+            } catch {
+            }
+          }
+        } else {
+          resolvedTopics.add(t);
+        }
+      }
+      if (resolvedTopics.size > 0) {
+        try {
+          sections.unshift(readRef("manimce/SKILL.md"));
+        } catch {
+        }
+      }
+      for (const topic of resolvedTopics) {
+        try {
+          sections.push(readRef(`manimce/rules/${topic}.md`));
+        } catch {
+          sections.push(`[Topic "${topic}" not found]`);
+        }
+      }
+      const reference = sections.join("\n\n---\n\n");
+      return {
+        content: [{ type: "text", text: reference }]
+      };
+    }
+  );
+  const sceneSchema = z.object({
+    code: z.string().describe("Complete Manim Python code for this scene. Must contain a class extending VoiceoverScene, Scene, MovingCameraScene, or ThreeDScene."),
+    title: z.string().optional().describe("Short title for this scene")
+  });
+  registerAppTool(
+    server,
+    "render_video",
+    {
+      title: "Render Manim Video",
+      description: `Render one or more Manim scenes in parallel, concatenate them, and return one combined video inline.
+Each scene has complete Python code with voiceover baked in via manim-voiceover.
+Scenes render concurrently \u2014 voice is generated and synced during rendering automatically.
+The server auto-fixes TTS service injection based on language, and fixes common issues like CYAN \u2192 TEAL.`,
+      inputSchema: {
+        scenes: z.array(sceneSchema).min(1).max(6).describe("Array of scenes to render in parallel. Order matters for final video."),
+        quality: z.enum(["l", "m", "h"]).default("l").describe("Video quality: l=480p (default), m=720p, h=1080p"),
+        language: z.enum([
+          "en",
+          "en-us",
+          "en-gb",
+          "es",
+          "fr",
+          "de",
+          "it",
+          "pt",
+          "pl",
+          "tr",
+          "ru",
+          "nl",
+          "cs",
+          "ar",
+          "zh",
+          "zh-cn",
+          "ja",
+          "hu",
+          "ko",
+          "hi"
+        ]).default("en").describe("Language for voiceover narration. Kokoro (best): en,zh,ja,ko,es,fr,hi,it. Piper (extended): de,pt,ru,nl,cs,ar,hu,pl,tr.")
+      },
+      outputSchema: z.object({
+        videoUri: z.string(),
+        overview: z.string(),
+        scenes: z.array(z.string()),
+        durationSeconds: z.number()
+      }),
+      _meta: { ui: { resourceUri: VIEW_URI } }
+    },
+    async ({ scenes, quality, language }) => {
+      const lang = language ?? "en";
+      const id = crypto.randomUUID().slice(0, 8);
+      const jobStart = Date.now();
+      console.error(`[manim] [${id}] Starting ${scenes.length} scene(s), max ${MAX_PARALLEL_RENDERS} parallel (lang=${lang})...`);
+      const ttsConfig = getTtsConfig(lang);
+      if (ttsConfig.service === "piper") {
+        try {
+          ensurePiperDeps(ttsConfig.locale, ttsConfig.model);
+        } catch (e) {
+          return {
+            content: [{ type: "text", text: `Failed to install Piper TTS for language "${lang}": ${e}` }],
+            isError: true
+          };
+        }
+      }
+      writeServiceFiles();
+      const sceneMeta = [];
+      for (let i = 0; i < scenes.length; i++) {
+        const s = scenes[i];
+        const classMatch = s.code.match(/class\s+(\w+)\s*\(\s*(?:Scene|VoiceoverScene|MovingCameraScene|ThreeDScene)\s*\)/);
+        if (!classMatch) {
+          return {
+            content: [{ type: "text", text: `Scene ${i}: code must contain a class extending Scene or VoiceoverScene.` }],
+            isError: true
+          };
+        }
+        sceneMeta.push({ className: classMatch[1], code: s.code, title: s.title });
+      }
+      const allVoiceoverTexts = [...new Set(sceneMeta.flatMap((s) => extractVoiceoverTexts(s.code)))];
+      if (allVoiceoverTexts.length > 0) {
+        console.error(`[manim] [${id}] Pre-synthesizing ${allVoiceoverTexts.length} voiceover(s) before rendering...`);
+        await startTtsPreSynthesis(allVoiceoverTexts, lang);
+        console.error(`[manim] [${id}] TTS pre-synthesis complete, starting renders...`);
+      }
+      const renderResults = await runWithConcurrency(
+        sceneMeta.map((s, i) => async () => {
+          console.error(`[manim] [${id}] Rendering scene ${i + 1}/${sceneMeta.length}: ${s.className}`);
+          const startTime = Date.now();
+          const result = await renderManimScene(s.code, s.className, quality, lang);
+          const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
+          console.error(`[manim] [${id}] Scene ${i + 1} ${result.success ? "rendered" : "errored"} in ${elapsed}s`);
+          return result;
+        }),
+        MAX_PARALLEL_RENDERS
+      );
+      const videoPaths = [];
+      const sceneNames = [];
+      const errors = [];
+      for (let i = 0; i < renderResults.length; i++) {
+        const r = renderResults[i];
+        const name = sceneMeta[i].title ?? sceneMeta[i].className;
+        if (r.success && r.videoPath) {
+          videoPaths.push(r.videoPath);
+          sceneNames.push(name);
+          console.error(`[manim] [${id}] Scene ${i + 1} OK: ${name}`);
+        } else {
+          errors.push(`Scene ${i + 1} (${name}): ${r.error}`);
+          console.error(`[manim] [${id}] Scene ${i + 1} FAILED: ${r.error?.slice(0, 200)}`);
+        }
+      }
+      if (videoPaths.length === 0) {
+        return {
+          content: [{ type: "text", text: `All scenes failed to render:
+
+${errors.join("\n\n")}` }],
+          isError: true
+        };
+      }
+      const finalPath = path.join(OUTPUT_DIR, `final_${id}.mp4`);
+      if (!concatVideos(videoPaths, finalPath)) {
+        return {
+          content: [{ type: "text", text: "Failed to concatenate scene videos" }],
+          isError: true
+        };
+      }
+      let durationSeconds = 0;
+      try {
+        const probe = execSync(`ffprobe -v quiet -print_format json -show_format "${finalPath}"`, { timeout: 1e4 });
+        durationSeconds = parseFloat(JSON.parse(probe.toString()).format?.duration ?? "0");
+      } catch {
+      }
+      durationSeconds = Math.round(durationSeconds * 10) / 10;
+      const videoId = `manim-${id}`;
+      videoStore.set(videoId, fs.readFileSync(finalPath));
+      const overview = sceneMeta[0].title ?? sceneNames.join(" \u2192 ");
+      const data = {
+        videoUri: `videos://${videoId}`,
+        overview,
+        scenes: sceneNames,
+        durationSeconds
+      };
+      const summary = [
+        `Video rendered: "${overview}" (${durationSeconds}s)`,
+        `${sceneNames.length}/${scenes.length} scenes succeeded`
+      ];
+      if (errors.length > 0) {
+        summary.push(`
+Failed scenes:
+${errors.join("\n")}`);
+      }
+      const jobElapsed = ((Date.now() - jobStart) / 1e3).toFixed(1);
+      console.error(`[manim] [${id}] Done: ${sceneNames.length} scenes, ${durationSeconds}s video, ${jobElapsed}s wall time`);
+      return {
+        content: [{ type: "text", text: summary.join("\n") }],
+        structuredContent: data
+      };
+    }
+  );
+  const DEMO_VIDEO_PATH = path.join(DIST_DIR, "demo.mp4");
+  registerAppTool(
+    server,
+    "show_demo_video",
+    {
+      title: "Show Demo Video",
+      description: "Show a pre-rendered demo video inline to test the MCP video player. No generation needed.",
+      inputSchema: {},
+      outputSchema: z.object({
+        videoUri: z.string(),
+        overview: z.string(),
+        scenes: z.array(z.string()),
+        durationSeconds: z.number()
+      }),
+      _meta: { ui: { resourceUri: VIEW_URI } }
+    },
+    async () => {
+      if (!fs.existsSync(DEMO_VIDEO_PATH)) {
+        return {
+          content: [{ type: "text", text: "Demo video not found at " + DEMO_VIDEO_PATH }],
+          isError: true
+        };
+      }
+      const videoId = "demo-pythagorean";
+      if (!videoStore.has(videoId)) {
+        videoStore.set(videoId, fs.readFileSync(DEMO_VIDEO_PATH));
+      }
+      const data = {
+        videoUri: `videos://${videoId}`,
+        overview: "Pythagorean Theorem \u2014 visual proof with squares on triangle sides",
+        scenes: ["The Hook", "Building the Proof"],
+        durationSeconds: 41
+      };
+      return {
+        content: [{
+          type: "text",
+          text: `Demo video: "${data.overview}" (${data.durationSeconds}s)`
+        }],
+        structuredContent: data
+      };
+    }
+  );
+  registerAppResource(
+    server,
+    "Manim Video Player",
+    VIEW_URI,
+    { mimeType: RESOURCE_MIME_TYPE },
+    async () => {
+      const html = await fs.promises.readFile(
+        path.join(DIST_DIR, "mcp-app.html"),
+        "utf-8"
+      );
+      return {
+        contents: [
+          { uri: VIEW_URI, mimeType: RESOURCE_MIME_TYPE, text: html }
+        ]
+      };
+    }
+  );
+  return server;
+}
+export {
+  createServer
+};