@openvidstudio/mcp-server 0.1.0 → 1.3.1

package/dist/tools/generateNarration.js

@@ -33,6 +33,8 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeLanguage = sanitizeLanguage;
+exports.lineFor = lineFor;
 exports.runGenerateNarration = runGenerateNarration;
 exports.registerGenerateNarration = registerGenerateNarration;
 const node_child_process_1 = require("node:child_process");
@@ -40,6 +42,7 @@ const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const zod_1 = require("zod");
 const util_1 = require("../util");
+const paths_1 = require("../paths");
 const mcp_1 = require("./mcp");
 /** Beyond this, a pitch-preserving stretch starts to sound processed. */
 const TEMPO_FLOOR = 0.9;
@@ -48,16 +51,78 @@ const DEFAULT_VOICE = {
     "edge-tts": "en-US-AndrewNeural",
     say: "Alex",
     espeak: "en-us",
+    // omnivoice is zero-shot: the voice comes from a reference clip or a description, not
+    // from a catalogue of named voices, which is exactly why it can cover 600 languages.
+    omnivoice: "k2-fsa/OmniVoice",
 };
+const LANGUAGE_TAG = /^[A-Za-z]{2,8}(-[A-Za-z0-9]{2,8})*$/;
+/** A language tag becomes a directory name, so it is checked before it is joined into a path. */
+function sanitizeLanguage(tag) {
+    if (!LANGUAGE_TAG.test(tag)) {
+        throw new Error(`"${tag}" is not a language tag. Use a BCP-47 tag such as "en", "hi", "pt-BR", which is also what ` +
+            `becomes the directory name under public/audio/vo/.`);
+    }
+    return tag;
+}
+/** The line for one language: the original for the base, a translation for anything else. */
+function lineFor(beat, language, baseLanguage) {
+    if (language === baseLanguage)
+        return beat.vo;
+    return beat.voTranslations?.[language];
+}
 function probeDuration(file) {
     const r = (0, node_child_process_1.spawnSync)("ffprobe", ["-v", "error", "-show_entries", "format=duration", "-of", "default=nw=1:nk=1", file], { encoding: "utf8" });
     const v = Number.parseFloat((r.stdout ?? "").trim());
     return Number.isFinite(v) ? v : 0;
 }
-function synthesize(engine, voice, text, out) {
+let edgePython;
+/**
+ * The interpreter that can import edge_tts: the one the `edge-tts` command was installed into (its
+ * shebang, which is how pipx and a venv install it), then python3, then python. null when none can,
+ * in which case audio still comes from the command line and no word timings are written.
+ */
+function edgePythonInterpreter() {
+    if (edgePython !== undefined)
+        return edgePython;
+    const candidates = [];
+    const which = (0, node_child_process_1.spawnSync)(process.platform === "win32" ? "where" : "which", ["edge-tts"], { encoding: "utf8" });
+    const binary = which.status === 0 ? (which.stdout ?? "").split(/\r?\n/)[0]?.trim() : "";
+    if (binary) {
+        try {
+            const head = fs.readFileSync(binary, "utf8").slice(0, 200).split("\n")[0] ?? "";
+            const m = /^#!\s*(\S+)/.exec(head);
+            if (m && !m[1].endsWith("/env"))
+                candidates.push(m[1]);
+        }
+        catch {
+            // a binary launcher (Windows .exe) has no shebang to read
+        }
+    }
+    candidates.push("python3", "python");
+    edgePython = candidates.find((py) => (0, node_child_process_1.spawnSync)(py, ["-c", "import edge_tts"], { encoding: "utf8" }).status === 0) ?? null;
+    return edgePython;
+}
+function readWords(file) {
+    try {
+        const words = JSON.parse(fs.readFileSync(file, "utf8"));
+        return Array.isArray(words) && words.length > 0 ? words : null;
+    }
+    catch {
+        return null;
+    }
+}
+function synthesize(engine, voice, text, out, omni = {}, wordsOut) {
     for (let attempt = 0; attempt < 3; attempt++) {
         fs.rmSync(out, { force: true });
         let r;
+        if (engine === "edge-tts" && wordsOut !== undefined && edgePythonInterpreter() !== null) {
+            fs.rmSync(wordsOut, { force: true });
+            r = (0, node_child_process_1.spawnSync)(edgePythonInterpreter(), [path.join(paths_1.PY_DIR, "edge-words.py"), "--voice", voice, "--text", text, "--out", out, "--words", wordsOut], { encoding: "utf8" });
+            if (!r.error && r.status === 0 && fs.existsSync(out) && probeDuration(out) > 0.3) {
+                return { ok: true, words: readWords(wordsOut) ?? undefined };
+            }
+            // fall through to the plain command line, which gives audio and no timings
+        }
         if (engine === "edge-tts") {
             r = (0, node_child_process_1.spawnSync)("edge-tts", ["--voice", voice, "--text", text, "--write-media", out], {
                 encoding: "utf8",
@@ -67,6 +132,22 @@ function synthesize(engine, voice, text, out) {
                 r = (0, node_child_process_1.spawnSync)("python", ["-m", "edge_tts", "--voice", voice, "--text", text, "--write-media", out], { encoding: "utf8" });
             }
         }
+        else if (engine === "omnivoice") {
+            // Zero-shot across 600+ languages, so the same call synthesizes every language with
+            // no per-language voice to pick. With ref_audio it is the same cloned voice in all
+            // of them, which is what makes a set of translations read as one narrator.
+            const args = ["--model", voice, "--text", text, "--output", out];
+            if (omni.refAudio)
+                args.push("--ref_audio", omni.refAudio);
+            if (omni.refText)
+                args.push("--ref_text", omni.refText);
+            if (omni.instruct)
+                args.push("--instruct", omni.instruct);
+            r = (0, node_child_process_1.spawnSync)("omnivoice-infer", args, { encoding: "utf8" });
+            if (r.error) {
+                r = (0, node_child_process_1.spawnSync)("python", ["-m", "omnivoice.cli.infer", ...args], { encoding: "utf8" });
+            }
+        }
         else if (engine === "say") {
             r = (0, node_child_process_1.spawnSync)("say", ["-v", voice, "-o", out, "--data-format=LEF32@22050", text], {
                 encoding: "utf8",
@@ -86,79 +167,156 @@ function runGenerateNarration(input) {
     const videoName = (0, util_1.sanitizeSegment)(input.videoName, "videoName");
     const projectRoot = (0, util_1.resolveProjectRoot)(input.projectRoot);
     const engine = input.engine ?? "edge-tts";
-    const voice = input.voice ?? DEFAULT_VOICE[engine];
     const pad = input.padSeconds ?? 0.45;
+    const baseLanguage = sanitizeLanguage(input.baseLanguage ?? "en");
+    const languages = (input.languages?.length ? input.languages : [baseLanguage]).map(sanitizeLanguage);
+    if (!languages.includes(baseLanguage))
+        languages.unshift(baseLanguage);
     const beatsFile = path.join(projectRoot, "src", "videos", videoName, "beats.json");
     if (!fs.existsSync(beatsFile)) {
         throw new Error(`No beats.json at ${beatsFile}. Run write_beats_file first.`);
     }
     const doc = JSON.parse(fs.readFileSync(beatsFile, "utf8"));
     const fps = doc.fps || 30;
-    const outDir = path.join(projectRoot, "public", "audio", "vo");
-    fs.mkdirSync(outDir, { recursive: true });
     const workDir = path.join(projectRoot, ".openvidstudio", "narration");
     fs.mkdirSync(workDir, { recursive: true });
-    const written = [];
-    const skipped = [];
-    const missing = [];
-    const warnings = [];
-    for (const beat of doc.beats) {
-        if (input.beatIds && !input.beatIds.includes(beat.id))
-            continue;
-        const finalPath = path.join(outDir, `${beat.id}.mp3`);
-        if (!beat.vo || !beat.vo.trim()) {
-            missing.push(beat.id);
-            continue;
-        }
-        if (fs.existsSync(finalPath) && !input.overwrite) {
-            skipped.push(beat.id);
-            continue;
-        }
-        const raw = path.join(workDir, `${beat.id}.raw`);
-        const res = synthesize(engine, voice, beat.vo, raw);
-        if (!res.ok) {
-            missing.push(beat.id);
-            warnings.push(`${beat.id}: ${res.error}`);
-            continue;
-        }
-        const spoken = probeDuration(raw);
-        const beatSeconds = beat.duration / fps;
-        const target = beatSeconds - pad;
-        const wanted = spoken / target;
-        const tempo = Math.min(TEMPO_CEIL, Math.max(TEMPO_FLOOR, wanted));
-        const r = (0, node_child_process_1.spawnSync)("ffmpeg", ["-v", "error", "-i", raw, "-filter:a", `atempo=${tempo.toFixed(4)}`,
-            "-c:a", "libmp3lame", "-q:a", "3", finalPath, "-y"], { encoding: "utf8" });
-        if (r.status !== 0) {
-            missing.push(beat.id);
-            warnings.push(`${beat.id}: ffmpeg failed writing the fitted clip`);
-            continue;
+    const omni = { refAudio: input.refAudio, refText: input.refText, instruct: input.instruct };
+    // Checked before anything is synthesized. Finding out that Hindi is missing three lines
+    // after twenty minutes of TTS is worse than finding out immediately, and the fix (write
+    // the lines) is the same either way.
+    if (input.requireTranslations === true) {
+        const gaps = [];
+        for (const language of languages) {
+            for (const beat of doc.beats) {
+                if (input.beatIds && !input.beatIds.includes(beat.id))
+                    continue;
+                const line = lineFor(beat, language, baseLanguage);
+                if (!line || !line.trim())
+                    gaps.push(`${language}/${beat.id}`);
+            }
         }
-        const finalSeconds = probeDuration(finalPath);
-        const overruns = finalSeconds > beatSeconds;
-        const clip = {
-            beatId: beat.id,
-            path: finalPath,
-            beatSeconds: Number(beatSeconds.toFixed(2)),
-            spokenSeconds: Number(spoken.toFixed(2)),
-            finalSeconds: Number(finalSeconds.toFixed(2)),
-            tempo: Number(tempo.toFixed(3)),
-            needsAttention: overruns || Math.abs(wanted - tempo) > 0.001,
-        };
-        if (overruns) {
-            clip.note =
-                `Runs ${(finalSeconds - beatSeconds).toFixed(2)}s past the beat. Shorten the line or ` +
-                    `lengthen the beat; stretching further would sound processed.`;
-            warnings.push(`${beat.id}: narration overruns its beat by ${(finalSeconds - beatSeconds).toFixed(2)}s`);
+        if (gaps.length > 0) {
+            throw new Error(`Missing narration lines for: ${gaps.join(", ")}. requireTranslations is on, so this fails rather ` +
+                `than shipping a video narrated in one language and silent in another, which looks broken to ` +
+                `exactly the audience it was made for.`);
         }
-        else if (clip.needsAttention) {
-            const slack = (target - finalSeconds).toFixed(2);
-            clip.note =
-                `Fits with ${slack}s of silence left over. Stretching was clamped to keep the voice ` +
-                    `natural; add a few words to the line if the gap is noticeable.`;
+    }
+    const reports = [];
+    const wordTimings = { supported: engine === "edge-tts", written: [] };
+    if (engine !== "edge-tts") {
+        wordTimings.note = `${engine} gives no word boundaries, so no .words.json files were written and none were invented. Only edge-tts does.`;
+    }
+    else if (edgePythonInterpreter() === null) {
+        wordTimings.supported = false;
+        wordTimings.note =
+            "No Python interpreter that can import edge_tts was found, so the audio came from the edge-tts command line and no word timings " +
+                "were written. Install it with pip (pip install edge-tts) into the interpreter python3 points at, or into the one the edge-tts command uses.";
+    }
+    for (const language of languages) {
+        const isBase = language === baseLanguage;
+        // The base language keeps its original path. Moving it into an "en" subdirectory would
+        // break every project that already has narration, for no gain.
+        const outDirRel = isBase
+            ? path.join("public", "audio", "vo")
+            : path.join("public", "audio", "vo", language);
+        const outDir = path.join(projectRoot, outDirRel);
+        fs.mkdirSync(outDir, { recursive: true });
+        const voice = input.voices?.[language] ?? input.voice ?? DEFAULT_VOICE[engine];
+        const written = [];
+        const skipped = [];
+        const missing = [];
+        const warnings = [];
+        for (const beat of doc.beats) {
+            if (input.beatIds && !input.beatIds.includes(beat.id))
+                continue;
+            const finalPath = path.join(outDir, `${beat.id}.mp3`);
+            const line = lineFor(beat, language, baseLanguage);
+            if (!line || !line.trim()) {
+                missing.push(beat.id);
+                if (!isBase) {
+                    warnings.push(`${beat.id}: no ${language} line in voTranslations, so this beat would play silent in the ` +
+                        `${language} cut.`);
+                }
+                continue;
+            }
+            if (fs.existsSync(finalPath) && !input.overwrite) {
+                skipped.push(beat.id);
+                continue;
+            }
+            const raw = path.join(workDir, isBase ? `${beat.id}.raw` : `${language}-${beat.id}.raw`);
+            const res = synthesize(engine, voice, line, raw, omni, `${raw}.words.json`);
+            if (!res.ok) {
+                missing.push(beat.id);
+                warnings.push(`${beat.id}: ${res.error}`);
+                continue;
+            }
+            const spoken = probeDuration(raw);
+            const beatSeconds = beat.duration / fps;
+            const target = beatSeconds - pad;
+            const wanted = spoken / target;
+            const tempo = Math.min(TEMPO_CEIL, Math.max(TEMPO_FLOOR, wanted));
+            const r = (0, node_child_process_1.spawnSync)("ffmpeg", ["-v", "error", "-i", raw, "-filter:a", `atempo=${tempo.toFixed(4)}`,
+                "-c:a", "libmp3lame", "-q:a", "3", finalPath, "-y"], { encoding: "utf8" });
+            if (r.status !== 0) {
+                missing.push(beat.id);
+                warnings.push(`${beat.id}: ffmpeg failed writing the fitted clip`);
+                continue;
+            }
+            const finalSeconds = probeDuration(finalPath);
+            const overruns = finalSeconds > beatSeconds;
+            const clip = {
+                beatId: beat.id,
+                language,
+                path: finalPath,
+                beatSeconds: Number(beatSeconds.toFixed(2)),
+                spokenSeconds: Number(spoken.toFixed(2)),
+                finalSeconds: Number(finalSeconds.toFixed(2)),
+                tempo: Number(tempo.toFixed(3)),
+                needsAttention: overruns || Math.abs(wanted - tempo) > 0.001,
+            };
+            if (overruns) {
+                // Translations overrun far more often than the original does: the same sentence is
+                // routinely 20 to 30 percent longer in German or Hindi than in English, and the fix
+                // is a shorter translation, not a faster one.
+                clip.note =
+                    `Runs ${(finalSeconds - beatSeconds).toFixed(2)}s past the beat. Shorten the line or ` +
+                        `lengthen the beat; stretching further would sound processed.`;
+                warnings.push(`${beat.id}: narration overruns its beat by ${(finalSeconds - beatSeconds).toFixed(2)}s`);
+            }
+            else if (clip.needsAttention) {
+                const slack = (target - finalSeconds).toFixed(2);
+                clip.note =
+                    `Fits with ${slack}s of silence left over. Stretching was clamped to keep the voice ` +
+                        `natural; add a few words to the line if the gap is noticeable.`;
+            }
+            // Word timings, in the clip as written: the stretch speeds the audio up by `tempo`, so every time
+            // is divided by it. The words file sits beside the clip so stitch_composition can find it.
+            if (res.words) {
+                const wordsPath = path.join(outDir, `${beat.id}.words.json`);
+                const scaled = res.words.map((w) => ({ word: w.word, startMs: Math.round(w.startMs / tempo), endMs: Math.round(w.endMs / tempo) }));
+                fs.writeFileSync(wordsPath, JSON.stringify(scaled, null, 2) + "\n", "utf8");
+                clip.wordsPath = wordsPath;
+                clip.wordCount = scaled.length;
+                wordTimings.written.push(wordsPath);
+            }
+            else if (engine === "edge-tts" && wordTimings.supported) {
+                warnings.push(`${beat.id}: the service sent no word boundaries for this line, so no .words.json was written.`);
+            }
+            written.push(clip);
         }
-        written.push(clip);
+        reports.push({ language, voice, dir: outDirRel, written, skipped, missing, warnings });
     }
-    return { engine, voice, written, skipped, missing, warnings };
+    const base = reports.find((r) => r.language === baseLanguage);
+    return {
+        engine,
+        voice: base.voice,
+        written: base.written,
+        skipped: base.skipped,
+        missing: base.missing,
+        warnings: base.warnings,
+        languages: reports,
+        wordTimings,
+    };
 }
 function registerGenerateNarration(server) {
     server.registerTool("generate_narration", {
@@ -171,15 +329,22 @@ function registerGenerateNarration(server) {
             "rather than stretching it into something processed, because the real fix is the script or the beat " +
             "duration. Reports which beats got audio, which were skipped as already present, and which are still " +
             "missing, so a partially generated narration cannot slip through and render silent. Resumable: pass " +
-            "overwrite to redo clips that already exist.",
+            "overwrite to redo clips that already exist. With edge-tts it also writes public/audio/vo/<beatId>.words.json, [{ word, startMs, endMs }] per beat, timed to the clip as written (scaled by the same stretch), which stitch_composition copies next to the composition for useNarrationWords(beatId); other engines write no timings and the result says so (wordTimings). Pass languages to ship the same manifest in several at once: the base language keeps writing to public/audio/vo/<beatId>.mp3 and every other language gets public/audio/vo/<lang>/<beatId>.mp3, read from each beat's voTranslations. Translated lines live in the manifest rather than being produced here, because a translation is content and goes through the same approval the original script did. The omnivoice engine covers 600+ languages zero-shot and, given a reference clip, uses one cloned voice across all of them, which is the difference between a translated video and a dubbed one. requireTranslations fails up front on a missing line rather than shipping a cut that is narrated in one language and silent in another.",
         inputSchema: {
             projectRoot: zod_1.z.string().optional(),
             videoName: zod_1.z.string().min(1),
-            engine: zod_1.z.enum(["edge-tts", "say", "espeak"]).optional(),
+            engine: zod_1.z.enum(["edge-tts", "say", "espeak", "omnivoice"]).optional(),
             voice: zod_1.z.string().optional(),
             padSeconds: zod_1.z.number().positive().optional(),
             overwrite: zod_1.z.boolean().optional(),
             beatIds: zod_1.z.array(zod_1.z.string()).optional(),
+            languages: zod_1.z.array(zod_1.z.string()).optional().describe("BCP-47 tags. Defaults to the base language alone."),
+            baseLanguage: zod_1.z.string().optional().describe("The language `vo` is written in. Defaults to en."),
+            voices: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).optional(),
+            requireTranslations: zod_1.z.boolean().optional(),
+            refAudio: zod_1.z.string().optional().describe("omnivoice only: a clip to clone, so every language is one voice."),
+            refText: zod_1.z.string().optional(),
+            instruct: zod_1.z.string().optional().describe("omnivoice only: voice design, when there is no clip to clone."),
         },
     }, async (input) => (0, mcp_1.runTool)("generate_narration", () => runGenerateNarration(input)));
 }

package/dist/tools/importHiggsfieldClip.js

@@ -40,6 +40,7 @@ const path = __importStar(require("node:path"));
 const zod_1 = require("zod");
 const util_1 = require("../util");
 const mcp_1 = require("./mcp");
+const facts_1 = require("../facts");
 async function fetchToBuffer(url, fetchImpl) {
     let response;
     try {
@@ -71,6 +72,21 @@ function readLocalFile(sourcePath) {
  * are trusted as-is from whichever source the calling agent already produced.
  */
 async function runImportHiggsfieldClip(input, deps = {}) {
+    const result = await importHiggsfieldClip(input, deps);
+    const projectRoot = (0, util_1.resolveProjectRoot)(input.projectRoot);
+    (0, facts_1.writeFactRecord)(projectRoot, {
+        tool: "import_higgsfield_clip",
+        beatId: (0, util_1.sanitizeSegment)(input.beatId, "beatId"),
+        facts: {
+            kind: "generated-clip",
+            outPath: (0, facts_1.relToProject)(projectRoot, result.outPath),
+            bytes: (0, facts_1.fileBytes)(result.outPath),
+            sourceType: input.source.type,
+        },
+    });
+    return result;
+}
+async function importHiggsfieldClip(input, deps = {}) {
     const beatId = (0, util_1.sanitizeSegment)(input.beatId, "beatId");
     const projectRoot = (0, util_1.resolveProjectRoot)(input.projectRoot);
     const outPathRel = input.outPath ?? path.join("public", "video", `${beatId}.mp4`);

package/dist/tools/index.js

@@ -4,18 +4,43 @@ exports.registerTools = registerTools;
 const initProject_1 = require("./initProject");
 const validateBeats_1 = require("./validateBeats");
 const writeBeatsFile_1 = require("./writeBeatsFile");
+const writeBrief_1 = require("./writeBrief");
 const scaffoldScene_1 = require("./scaffoldScene");
 const stitchComposition_1 = require("./stitchComposition");
 const renderVideo_1 = require("./renderVideo");
+const jobStatus_1 = require("./jobStatus");
 const qcExtractFrames_1 = require("./qcExtractFrames");
 const captureScreenshot_1 = require("./captureScreenshot");
 const captureScreenRecording_1 = require("./captureScreenRecording");
 const importHiggsfieldClip_1 = require("./importHiggsfieldClip");
 const generateNarration_1 = require("./generateNarration");
 const preflight_1 = require("./preflight");
+const planProduction_1 = require("./planProduction");
 const planBeats_1 = require("./planBeats");
 const validateScenes_1 = require("./validateScenes");
+const qcCapture_1 = require("./qcCapture");
 const contactSheet_1 = require("./contactSheet");
+const soundEffects_1 = require("./soundEffects");
+const extractBrand_1 = require("./extractBrand");
+const diffBeats_1 = require("./diffBeats");
+const captureDesktop_1 = require("./captureDesktop");
+const captureMobile_1 = require("./captureMobile");
+const captureTerminal_1 = require("./captureTerminal");
+const reformatVertical_1 = require("./reformatVertical");
+const exportRendition_1 = require("./exportRendition");
+const visualRegression_1 = require("./visualRegression");
+const docsDrift_1 = require("./docsDrift");
+const planShots_1 = require("./planShots");
+const releaseDiff_1 = require("./releaseDiff");
+const musicCues_1 = require("./musicCues");
+const musicLibrary_1 = require("./musicLibrary");
+const composeScore_1 = require("./composeScore");
+const motionPrimitives_1 = require("./motionPrimitives");
+const writeDescription_1 = require("./writeDescription");
+const renderStills_1 = require("./renderStills");
+const collectFacts_1 = require("./collectFacts");
+const finalizeVideo_1 = require("./finalizeVideo");
+const checkScript_1 = require("./checkScript");
 /**
  * Registers all of this package's tools. All but one need no server-startup config: each
  * resolves a project's own openvidstudio.config.json itself, per call, off projectRoot.
@@ -30,17 +55,43 @@ function registerTools(server, config) {
     (0, initProject_1.registerInitProject)(server);
     (0, validateBeats_1.registerValidateBeats)(server);
     (0, writeBeatsFile_1.registerWriteBeatsFile)(server);
+    (0, writeBrief_1.registerWriteBrief)(server);
     (0, scaffoldScene_1.registerScaffoldScene)(server);
     (0, stitchComposition_1.registerStitchComposition)(server);
     (0, renderVideo_1.registerRenderVideo)(server);
+    (0, jobStatus_1.registerJobStatus)(server);
     (0, qcExtractFrames_1.registerQcExtractFrames)(server);
     (0, captureScreenshot_1.registerCaptureScreenshot)(server);
     (0, captureScreenRecording_1.registerCaptureScreenRecording)(server);
     (0, generateNarration_1.registerGenerateNarration)(server);
     (0, preflight_1.registerPreflight)(server);
+    (0, planProduction_1.registerPlanProduction)(server);
     (0, planBeats_1.registerPlanBeats)(server);
     (0, validateScenes_1.registerValidateScenes)(server);
+    (0, qcCapture_1.registerQcCapture)(server);
     (0, contactSheet_1.registerContactSheet)(server);
+    (0, soundEffects_1.registerSoundEffects)(server);
+    (0, extractBrand_1.registerExtractBrand)(server);
+    (0, diffBeats_1.registerDiffBeats)(server);
+    (0, captureDesktop_1.registerCaptureDesktop)(server);
+    (0, captureMobile_1.registerCaptureMobile)(server);
+    (0, captureTerminal_1.registerCaptureTerminal)(server);
+    (0, reformatVertical_1.registerReformatVertical)(server);
+    (0, exportRendition_1.registerExportRendition)(server);
+    (0, visualRegression_1.registerVisualRegression)(server);
+    (0, docsDrift_1.registerDocsDrift)(server);
+    (0, planShots_1.registerPlanShots)(server);
+    (0, releaseDiff_1.registerReleaseDiff)(server);
+    (0, musicCues_1.registerMusicCues)(server);
+    (0, musicLibrary_1.registerMusicLibrary)(server);
+    (0, composeScore_1.registerComposeScore)(server);
+    (0, motionPrimitives_1.registerCatalogMotionPrimitives)(server);
+    (0, motionPrimitives_1.registerAddMotionPrimitive)(server);
+    (0, writeDescription_1.registerWriteDescription)(server);
+    (0, renderStills_1.registerRenderStills)(server);
+    (0, collectFacts_1.registerCollectFacts)(server);
+    (0, finalizeVideo_1.registerFinalizeVideo)(server);
+    (0, checkScript_1.registerCheckScript)(server);
     if (config?.hasHiggsfield === true) {
         (0, importHiggsfieldClip_1.registerImportHiggsfieldClip)(server);
     }

package/dist/tools/initProject.d.ts

@@ -1,5 +1,5 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { type OpenvidstudioConfig, type VideoConfig } from "../config";
+import { type OpenvidstudioConfig, type ProductionMode, type VideoConfig } from "../config";
 export interface InitProjectInput {
     name: string;
     projectRoot?: string;
@@ -8,6 +8,12 @@ export interface InitProjectInput {
     videoConfig?: Partial<VideoConfig>;
     appUrl?: string;
     demo?: boolean;
+    /**
+     * "standard" (the default) or "supernova", a STEM lesson. A supernova project also gets
+     * @openvidstudio/stem (vendored, with its display font), is stored as production.mode, and
+     * defaults to a 1080x1920 frame. A standard project's files and config do not change at all.
+     */
+    mode?: ProductionMode;
 }
 export interface InitProjectResult {
     projectRoot: string;
@@ -18,6 +24,11 @@ export interface InitProjectResult {
     config: OpenvidstudioConfig;
     demo: boolean;
     nextSteps: string[];
+    runtime: {
+        node: string;
+        pnpm: string | null;
+        warnings: string[];
+    };
 }
 /**
  * Scaffolds `src/videos/<name>/` in `projectRoot`, copying the bundled project shell

package/dist/tools/initProject.js

@@ -41,7 +41,41 @@ const zod_1 = require("zod");
 const paths_1 = require("../paths");
 const config_1 = require("../config");
 const util_1 = require("../util");
+const stitchComposition_1 = require("./stitchComposition");
 const mcp_1 = require("./mcp");
+const STEM_DIR = "openvidstudio-stem";
+const STEM_DEPENDENCY = "@openvidstudio/stem";
+const SUPERNOVA_VIDEO_CONFIG = { fps: 30, width: 1080, height: 1920 };
+/** Adds or removes the stem dependency in the project's package.json, leaving the rest as it is. */
+function setStemDependency(projectRoot, present) {
+    const file = path.join(projectRoot, "package.json");
+    if (!fs.existsSync(file))
+        return;
+    const pkg = JSON.parse(fs.readFileSync(file, "utf8"));
+    const has = pkg.dependencies !== undefined && STEM_DEPENDENCY in pkg.dependencies;
+    if (present === has)
+        return;
+    pkg.dependencies = pkg.dependencies ?? {};
+    if (present)
+        pkg.dependencies[STEM_DEPENDENCY] = `file:./${STEM_DIR}`;
+    else
+        delete pkg.dependencies[STEM_DEPENDENCY];
+    fs.writeFileSync(file, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+}
+/**
+ * Makes @openvidstudio/stem importable from a supernova project: the vendored package, the
+ * dependency on it, its display font in public/fonts/ (where the project's local font loader looks)
+ * and the maths renderer's runtime in public/mathjax/. Safe on a project that already has any of them.
+ */
+function installStem(projectRoot) {
+    (0, util_1.copyTemplateTree)(path.join(paths_1.TEMPLATE_DIR, STEM_DIR), path.join(projectRoot, STEM_DIR));
+    setStemDependency(projectRoot, true);
+    const stemPublic = path.join(projectRoot, STEM_DIR, "public");
+    for (const dir of ["fonts", "mathjax"]) {
+        if (fs.existsSync(path.join(stemPublic, dir)))
+            (0, util_1.copyTemplateTree)(path.join(stemPublic, dir), path.join(projectRoot, "public", dir));
+    }
+}
 /**
  * Scaffolds `src/videos/<name>/` in `projectRoot`, copying the bundled project shell
  * (package.json, tsconfig, remotion.config.ts, Root.tsx, public/sfx/, the vendored
@@ -63,16 +97,45 @@ function runInitProject(input) {
     // copyTemplateTree never overwrites a file that's already there, so this is safe to
     // call again for a second video in an already-scaffolded project.
     const alreadyScaffolded = fs.existsSync(path.join(projectRoot, "package.json"));
-    (0, util_1.copyTemplateTree)(paths_1.TEMPLATE_DIR, projectRoot);
+    const supernova = input.mode === "supernova";
+    const configExisted = fs.existsSync((0, config_1.configPath)(projectRoot));
+    // The vendored stem package is part of the bundled shell but belongs only to supernova projects.
+    (0, util_1.copyTemplateTree)(paths_1.TEMPLATE_DIR, projectRoot, supernova ? undefined : (rel) => rel === STEM_DIR);
+    if (supernova)
+        installStem(projectRoot);
+    else if (!alreadyScaffolded)
+        setStemDependency(projectRoot, false);
     const docsDir = path.join(projectRoot, "docs");
     (0, util_1.copyTemplateTree)(paths_1.DOCS_DIR, docsDir);
     const videoDir = path.join(projectRoot, "src", "videos", name);
     fs.mkdirSync(path.join(videoDir, "scenes"), { recursive: true });
+    // Seeds preflight's render-benchmark composition into the registry (idempotent: a
+    // second init_project call, or one against an already-scaffolded project, just finds
+    // the entry already there and does nothing). This is what lets preflight time a real
+    // render before any real video has been planned or stitched -- Root.tsx otherwise stays
+    // `return null;` (the bare template) until the first stitch_composition call.
+    const registry = (0, stitchComposition_1.readRegistry)(projectRoot);
+    if (!registry.some((e) => e.videoName === stitchComposition_1.PREFLIGHT_BENCHMARK_VIDEO_NAME)) {
+        registry.push({
+            id: stitchComposition_1.PREFLIGHT_BENCHMARK_COMPOSITION_ID,
+            videoName: stitchComposition_1.PREFLIGHT_BENCHMARK_VIDEO_NAME,
+            componentName: "PreflightBenchmark",
+            importPath: "./PreflightBenchmark",
+            durationInFrames: 150,
+            fps: 30,
+            width: 1920,
+            height: 1080,
+        });
+        (0, stitchComposition_1.writeRegistry)(projectRoot, registry);
+        fs.writeFileSync(path.join(projectRoot, "src", "Root.tsx"), (0, stitchComposition_1.renderRootTsx)(registry, fs.existsSync(path.join(projectRoot, "src", "brand.ts"))), "utf8");
+    }
     const config = (0, config_1.writeConfig)(projectRoot, {
         hasHiggsfield: input.hasHiggsfield,
         targetDurationSeconds: input.targetDurationSeconds,
-        videoConfig: input.videoConfig,
+        // A lesson is a vertical video unless the caller (or an existing config) says otherwise.
+        videoConfig: input.videoConfig ?? (supernova && !configExisted ? { ...SUPERNOVA_VIDEO_CONFIG } : undefined),
         capture: input.appUrl ? { appUrl: input.appUrl } : undefined,
+        production: supernova ? { mode: "supernova" } : undefined,
     });
     // A demo project ships a ready beats.json so the very next call can be
     // scaffold_scene. Without it a new user has nothing to run and no worked example
@@ -118,6 +181,11 @@ function runInitProject(input) {
         config,
         demo: Boolean(input.demo),
         nextSteps,
+        runtime: {
+            node: process.version,
+            pnpm: process.env.npm_config_user_agent?.match(/pnpm\/(\S+)/)?.[1] ?? null,
+            warnings: Number.parseInt(process.versions.node, 10) < 20 ? ["Node 20 or newer is supported."] : [],
+        },
     };
 }
 function registerInitProject(server) {
@@ -154,6 +222,11 @@ function registerInitProject(server) {
                 .boolean()
                 .optional()
                 .describe("Also write a ready two beat beats.json, as a two minute end to end smoke test."),
+            mode: zod_1.z
+                .enum(["standard", "supernova"])
+                .optional()
+                .describe("\"standard\" (default) or \"supernova\", a STEM lesson: also installs @openvidstudio/stem and its " +
+                "display font, records production.mode, and defaults the frame to 1080x1920."),
             videoConfig: zod_1.z
                 .object({
                 fps: zod_1.z.number().positive().optional(),

package/dist/tools/jobStatus.d.ts

@@ -0,0 +1,14 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type JobRecord } from "../jobs";
+export interface JobStatusInput {
+    jobId: string;
+}
+/**
+ * Poll target for a job started with { async: true } on a tool that supports it
+ * (render_video today). Returns the job record as-is: status, progress (frames rendered,
+ * current beat, a log tail), and result once status is "done" or error once "error".
+ * Jobs live only in this server process's memory, so a job from before a server restart is
+ * simply gone -- the error message says so rather than pretending the jobId never existed.
+ */
+export declare function runJobStatus(input: JobStatusInput): JobRecord;
+export declare function registerJobStatus(server: McpServer): void;