@openvidstudio/mcp-server 0.1.0

package/dist/tools/renderVideo.js

@@ -0,0 +1,120 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRenderCommand = buildRenderCommand;
+exports.runRenderVideo = runRenderVideo;
+exports.registerRenderVideo = registerRenderVideo;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const zod_1 = require("zod");
+const util_1 = require("../util");
+const mcp_1 = require("./mcp");
+const COMPOSITION_ID_RE = /^[A-Za-z0-9_-]+$/;
+/**
+ * Pure argv builder, unit-testable without spawning a real process. On Windows, npx is
+ * a .cmd shim -- Node's spawn() can only execute that via an internal cmd.exe hop even
+ * with shell:false, which is why compositionId/outPath both get sanitized against
+ * cmd.exe metacharacters before ever reaching this function (see util.ts).
+ */
+function buildRenderCommand(compositionId, outPath, opts = {}) {
+    const args = ["remotion", "render", compositionId, outPath];
+    if (opts.draft) {
+        // Half resolution and a fast x264 preset. Enough to judge framing, motion and
+        // timing; not enough to judge final text crispness.
+        args.push("--scale=0.5", "--crf=32", "--x264-preset=veryfast");
+    }
+    if (opts.concurrency && opts.concurrency > 0) {
+        args.push(`--concurrency=${Math.floor(opts.concurrency)}`);
+    }
+    // Remotion suppresses its progress bar when stdout is not a TTY, which is always
+    // the case here, so a piped render writes an empty log for its whole run and an
+    // agent watching it cannot tell progress from a hang.
+    args.push("--log=verbose");
+    return {
+        command: process.platform === "win32" ? "npx.cmd" : "npx",
+        args,
+    };
+}
+async function runRenderVideo(input) {
+    const videoName = (0, util_1.sanitizeSegment)(input.videoName, "videoName");
+    const projectRoot = (0, util_1.resolveProjectRoot)(input.projectRoot);
+    const compositionId = input.compositionId ?? `${(0, util_1.pascalCase)(videoName)}Demo`;
+    if (!COMPOSITION_ID_RE.test(compositionId)) {
+        throw new Error(`compositionId "${compositionId}" is not safe (letters, numbers, "-", "_" only).`);
+    }
+    const outPathRel = input.outPath ?? path.join("out", `${videoName}.mp4`);
+    (0, util_1.sanitizeRelativeOutPath)(projectRoot, outPathRel, "outPath");
+    fs.mkdirSync(path.dirname(path.join(projectRoot, outPathRel)), { recursive: true });
+    const started = Date.now();
+    const { command, args } = buildRenderCommand(compositionId, outPathRel, {
+        draft: input.draft,
+        concurrency: input.concurrency,
+    });
+    const result = await (0, util_1.spawnCapture)(command, args, projectRoot);
+    const elapsedSeconds = Math.round((Date.now() - started) / 1000);
+    return {
+        success: result.code === 0,
+        outPath: path.join(projectRoot, outPathRel),
+        draft: Boolean(input.draft),
+        elapsedSeconds,
+        stdout: result.stdout,
+        stderr: result.stderr,
+    };
+}
+function registerRenderVideo(server) {
+    server.registerTool("render_video", {
+        title: "Render a composition with the Remotion CLI",
+        description: "Thin wrapper around `npx remotion render <compositionId> <outPath>`, run in projectRoot via " +
+            "child_process.spawn with an argv array (never exec/execSync with a shell string), so a " +
+            "user-controlled videoName/outPath can't inject shell syntax. Default compositionId is the video's " +
+            "PascalCase name + \"Demo\" (matching stitch_composition's naming), default outPath is " +
+            "out/<videoName>.mp4. Pass draft for a half resolution, fast encode pass: a five minute video is " +
+            "9000 frames and tens of minutes at full quality, which is far too slow a loop for checking whether " +
+            "the video is right, and draft is usually enough to judge framing, motion and timing. Pass " +
+            "concurrency to cap the worker count; left unset Remotion takes as much of the machine as it can, " +
+            "and one render here spawned 25 Chrome workers and starved a second pipeline step running " +
+            "alongside it. Renders with verbose logging, because Remotion hides its progress bar when stdout " +
+            "is not a TTY and a piped render otherwise writes an empty log for its entire run, leaving no way " +
+            "to tell progress from a hang. Returns the render's captured stdout/stderr and how long it took.",
+        inputSchema: {
+            projectRoot: zod_1.z.string().optional(),
+            videoName: zod_1.z.string().min(1),
+            compositionId: zod_1.z.string().optional(),
+            outPath: zod_1.z.string().optional(),
+            draft: zod_1.z.boolean().optional(),
+            concurrency: zod_1.z.number().positive().optional(),
+        },
+    }, async (input) => (0, mcp_1.runTool)("render_video", () => runRenderVideo(input)));
+}

package/dist/tools/scaffoldScene.d.ts

@@ -0,0 +1,23 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type SceneKind, type TemplateName } from "../scenes/templates";
+export type { SceneKind };
+export interface ScaffoldSceneInput {
+    projectRoot?: string;
+    videoName: string;
+    beatId: string;
+    kind: SceneKind;
+    overwrite?: boolean;
+    /** Override the automatic template choice. */
+    template?: TemplateName;
+}
+export interface ScaffoldSceneResult {
+    written: true;
+    path: string;
+    componentName: string;
+    template: TemplateName;
+    /** True when the beat was found in beats.json and its content was used. */
+    usedBeat: boolean;
+    notes: string[];
+}
+export declare function runScaffoldScene(input: ScaffoldSceneInput): ScaffoldSceneResult;
+export declare function registerScaffoldScene(server: McpServer): void;

package/dist/tools/scaffoldScene.js

@@ -0,0 +1,147 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runScaffoldScene = runScaffoldScene;
+exports.registerScaffoldScene = registerScaffoldScene;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const zod_1 = require("zod");
+const util_1 = require("../util");
+const mcp_1 = require("./mcp");
+const templates_1 = require("../scenes/templates");
+const pngSize_1 = require("../scenes/pngSize");
+/**
+ * Read the beat out of the project's beats.json so the scaffolded scene can carry
+ * that beat's own copy and duration. Without this the template has nothing real to
+ * put on screen and the first render says nothing.
+ */
+function readBeat(projectRoot, videoName, beatId) {
+    const file = path.join(projectRoot, "src", "videos", videoName, "beats.json");
+    try {
+        const doc = JSON.parse(fs.readFileSync(file, "utf8"));
+        return doc.beats?.find((b) => b.id === beatId) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function runScaffoldScene(input) {
+    const videoName = (0, util_1.sanitizeSegment)(input.videoName, "videoName");
+    const beatId = (0, util_1.sanitizeSegment)(input.beatId, "beatId");
+    const projectRoot = (0, util_1.resolveProjectRoot)(input.projectRoot);
+    const componentName = (0, util_1.pascalCase)(beatId);
+    const scenesDir = path.join(projectRoot, "src", "videos", videoName, "scenes");
+    const filePath = path.join(scenesDir, `${componentName}.tsx`);
+    const notes = [];
+    if (fs.existsSync(filePath) && !input.overwrite) {
+        throw new Error(`${filePath} already exists. Pass overwrite: true to replace a scene the calling agent or dev has ` +
+            `already started editing.`);
+    }
+    const beat = readBeat(projectRoot, videoName, beatId);
+    if (!beat) {
+        notes.push(`No beat "${beatId}" found in beats.json, so the scene was scaffolded with placeholder copy. ` +
+            `Run write_beats_file first to get a scene that carries this beat's own content.`);
+    }
+    const description = beat?.visual?.description ?? "";
+    const ctx = {
+        beatId,
+        componentName,
+        description,
+        vo: beat?.vo ?? "",
+        durationFrames: beat?.duration ?? 300,
+        url: beat?.visual?.url,
+    };
+    if (input.kind === "real-screenshot") {
+        const png = path.join(projectRoot, "public", "images", `${beatId}.png`);
+        const size = (0, pngSize_1.pngSize)(png);
+        if (size) {
+            ctx.captureWidth = size.width;
+            ctx.captureHeight = size.height;
+            notes.push(`Frame sized from the real capture: ${size.width}x${size.height}.`);
+        }
+        else {
+            notes.push(`No capture found at public/images/${beatId}.png, so the frame uses a 1440x900 default. ` +
+                `Re-run scaffold_scene after capture_screenshot to size the frame from the real file.`);
+        }
+    }
+    const template = input.template ?? (0, templates_1.pickTemplate)(input.kind, description);
+    const source = (0, templates_1.renderTemplate)(template, ctx, input.kind);
+    fs.mkdirSync(scenesDir, { recursive: true });
+    fs.writeFileSync(filePath, source, "utf8");
+    return {
+        written: true,
+        path: filePath,
+        componentName,
+        template,
+        usedBeat: Boolean(beat),
+        notes,
+    };
+}
+function registerScaffoldScene(server) {
+    server.registerTool("scaffold_scene", {
+        title: "Scaffold a working scene for one beat",
+        description: "Writes src/videos/<videoName>/scenes/<BeatId>.tsx as a scene that renders immediately, with no " +
+            "TODOs to fill in. It reads the beat out of beats.json and uses that beat's own description, " +
+            "narration and duration for the on-screen copy and timings, so the first render already says " +
+            "something. Pick the shape with `template`, or let it choose from the capture method and what the " +
+            "beat's description talks about. Templates: browser-capture and recording (for real captures), " +
+            "terminal, split-panel, checklist, stat, code, comparison, cta, title. For real-screenshot beats " +
+            "the frame is sized from the actual PNG on disk rather than guessed, so the page is not letterboxed. " +
+            "Constructed scenes use a gentle camera push and a safe content width, because the visible area is " +
+            "the stage divided by the camera scale and content built at full stage size gets cropped at the " +
+            "frame edge. Refuses to overwrite an existing scene unless overwrite: true.",
+        inputSchema: {
+            projectRoot: zod_1.z.string().optional(),
+            videoName: zod_1.z.string().min(1),
+            beatId: zod_1.z.string().min(1),
+            kind: zod_1.z.enum(["real-screenshot", "real-recording", "dom-demo", "higgsfield-clip"]),
+            overwrite: zod_1.z.boolean().optional(),
+            template: zod_1.z
+                .enum([
+                "browser-capture",
+                "recording",
+                "terminal",
+                "split-panel",
+                "checklist",
+                "stat",
+                "code",
+                "comparison",
+                "cta",
+                "title",
+            ])
+                .optional(),
+        },
+    }, async (input) => (0, mcp_1.runTool)("scaffold_scene", () => runScaffoldScene(input)));
+}

package/dist/tools/stitchComposition.d.ts

@@ -0,0 +1,24 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export interface StitchCompositionInput {
+    projectRoot?: string;
+    videoName: string;
+}
+export interface StitchCompositionResult {
+    written: true;
+    compositionId: string;
+    demoPath: string;
+    rootPath: string;
+    durationInFrames: number;
+    voBeatsFound: string[];
+    musicBedFound: boolean;
+}
+/**
+ * Reads src/videos/<videoName>/beats.json and writes the composition + updates
+ * src/Root.tsx (via the registry above). VO convention: public/audio/vo/<beatId>.mp3,
+ * included only if the file actually exists on disk (mirrors PepirosDemo.tsx, where
+ * the cta beat has no VO entry because none was recorded). Music bed convention:
+ * public/audio/music-bed.mp3, included as a full-duration looping layer only if it
+ * exists.
+ */
+export declare function runStitchComposition(input: StitchCompositionInput): StitchCompositionResult;
+export declare function registerStitchComposition(server: McpServer): void;

package/dist/tools/stitchComposition.js

@@ -0,0 +1,230 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runStitchComposition = runStitchComposition;
+exports.registerStitchComposition = registerStitchComposition;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const zod_1 = require("zod");
+const config_1 = require("../config");
+const util_1 = require("../util");
+const mcp_1 = require("./mcp");
+/**
+ * Registry of every video this project has stitched, one entry per stitch_composition
+ * call, at src/videos/.registry.json. Root.tsx is fully regenerated from this file on
+ * every call rather than round-tripped via regex/JSX parsing, which is what makes it
+ * safe to never clobber a composition a prior call registered for a different video:
+ * the registry (not Root.tsx itself) is the actual source of truth. Deliberately not
+ * part of openvidstudio.config.json: that shape is pinned for Task 5 to depend on,
+ * this is internal bookkeeping local to this one tool.
+ */
+function registryPath(projectRoot) {
+    return path.join(projectRoot, "src", "videos", ".registry.json");
+}
+function readRegistry(projectRoot) {
+    const p = registryPath(projectRoot);
+    if (!fs.existsSync(p))
+        return [];
+    return JSON.parse(fs.readFileSync(p, "utf8"));
+}
+function writeRegistry(projectRoot, entries) {
+    const p = registryPath(projectRoot);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify(entries, null, 2) + "\n", "utf8");
+}
+function renderRootTsx(entries) {
+    const imports = entries.map((e) => `import { ${e.componentName} } from "${e.importPath}";`).join("\n");
+    const comps = entries
+        .map((e) => `      <Composition\n        id="${e.id}"\n        component={${e.componentName}}\n` +
+        `        durationInFrames={${e.durationInFrames}}\n        fps={${e.fps}}\n` +
+        `        width={${e.width}}\n        height={${e.height}}\n      />`)
+        .join("\n");
+    return `// AUTO-GENERATED by openvidstudio's stitch_composition MCP tool.
+// Source of truth is src/videos/.registry.json -- hand edits to this file are lost the
+// next time stitch_composition runs for ANY video in this project, not just the one you
+// edited. Add a video by calling stitch_composition, not by editing this directly.
+
+import React from "react";
+import { Composition } from "remotion";
+${imports}
+
+export const RemotionRoot: React.FC = () => {
+  return (
+    <>
+${comps}
+    </>
+  );
+};
+`;
+}
+function renderDemoTsx(opts) {
+    const { componentName, beats, voMap, musicBedFound } = opts;
+    const sceneImports = beats
+        .map((b) => `import { ${(0, util_1.pascalCase)(b.id)} } from "./scenes/${(0, util_1.pascalCase)(b.id)}";`)
+        .join("\n");
+    const sceneMapLines = beats.map((b) => `  ${JSON.stringify(b.id)}: ${(0, util_1.pascalCase)(b.id)},`).join("\n");
+    const voLines = Object.entries(voMap)
+        .map(([id, rel]) => `  ${JSON.stringify(id)}: ${JSON.stringify(rel)},`)
+        .join("\n");
+    const musicBedBlock = musicBedFound
+        ? `      <Sequence from={0} durationInFrames={DURATION_IN_FRAMES} layout="none">
+        <Audio src={staticFile("audio/music-bed.mp3")} volume={0.18} loop />
+      </Sequence>
+`
+        : "";
+    return `// AUTO-GENERATED by openvidstudio's stitch_composition MCP tool from beats.json.
+// Re-run stitch_composition after editing beats.json rather than hand-editing this file;
+// it will be overwritten.
+
+import React from "react";
+import { AbsoluteFill, Audio, Sequence, Series, staticFile } from "remotion";
+import beats from "./beats.json";
+${sceneImports}
+
+const SCENES: Record<string, React.FC> = {
+${sceneMapLines}
+};
+
+const VO_FILES: Record<string, string> = {
+${voLines}
+};
+
+const last = beats.beats[beats.beats.length - 1];
+export const DURATION_IN_FRAMES = last.start + last.duration;
+
+export const ${componentName}: React.FC = () => {
+  return (
+    <AbsoluteFill>
+      <Series>
+        {beats.beats.map((b) => {
+          const Scene = SCENES[b.id];
+          return (
+            <Series.Sequence key={b.id} durationInFrames={b.duration} name={b.id}>
+              <Scene />
+            </Series.Sequence>
+          );
+        })}
+      </Series>
+      {beats.beats
+        .filter((b) => VO_FILES[b.id])
+        .map((b) => (
+          <Sequence key={\`vo-\${b.id}\`} from={b.start} durationInFrames={b.duration} layout="none">
+            <Audio src={staticFile(VO_FILES[b.id])} volume={0.9} />
+          </Sequence>
+        ))}
+${musicBedBlock}    </AbsoluteFill>
+  );
+};
+`;
+}
+/**
+ * Reads src/videos/<videoName>/beats.json and writes the composition + updates
+ * src/Root.tsx (via the registry above). VO convention: public/audio/vo/<beatId>.mp3,
+ * included only if the file actually exists on disk (mirrors PepirosDemo.tsx, where
+ * the cta beat has no VO entry because none was recorded). Music bed convention:
+ * public/audio/music-bed.mp3, included as a full-duration looping layer only if it
+ * exists.
+ */
+function runStitchComposition(input) {
+    const videoName = (0, util_1.sanitizeSegment)(input.videoName, "videoName");
+    const projectRoot = (0, util_1.resolveProjectRoot)(input.projectRoot);
+    const videoDir = path.join(projectRoot, "src", "videos", videoName);
+    const beatsPath = path.join(videoDir, "beats.json");
+    if (!fs.existsSync(beatsPath)) {
+        throw new Error(`${beatsPath} does not exist. Call write_beats_file for "${videoName}" first.`);
+    }
+    const beatsData = JSON.parse(fs.readFileSync(beatsPath, "utf8"));
+    const beats = beatsData.beats;
+    if (!Array.isArray(beats) || beats.length === 0) {
+        throw new Error(`${beatsPath} has no beats.`);
+    }
+    const config = (0, config_1.loadConfig)(projectRoot);
+    const fps = beatsData.fps ?? config.videoConfig.fps;
+    const last = beats[beats.length - 1];
+    const durationInFrames = last.start + last.duration;
+    const voMap = {};
+    for (const b of beats) {
+        const voFile = path.join(projectRoot, "public", "audio", "vo", `${b.id}.mp3`);
+        if (fs.existsSync(voFile)) {
+            voMap[b.id] = `audio/vo/${b.id}.mp3`;
+        }
+    }
+    const musicBedFound = fs.existsSync(path.join(projectRoot, "public", "audio", "music-bed.mp3"));
+    const componentName = `${(0, util_1.pascalCase)(videoName)}Demo`;
+    const demoTsx = renderDemoTsx({ componentName, beats, voMap, musicBedFound });
+    const demoPath = path.join(videoDir, `${componentName}.tsx`);
+    fs.writeFileSync(demoPath, demoTsx, "utf8");
+    const entries = readRegistry(projectRoot).filter((e) => e.videoName !== videoName);
+    entries.push({
+        id: componentName,
+        videoName,
+        componentName,
+        importPath: `./videos/${videoName}/${componentName}`,
+        durationInFrames,
+        fps,
+        width: config.videoConfig.width,
+        height: config.videoConfig.height,
+    });
+    writeRegistry(projectRoot, entries);
+    const rootPath = path.join(projectRoot, "src", "Root.tsx");
+    fs.writeFileSync(rootPath, renderRootTsx(entries), "utf8");
+    return {
+        written: true,
+        compositionId: componentName,
+        demoPath,
+        rootPath,
+        durationInFrames,
+        voBeatsFound: Object.keys(voMap),
+        musicBedFound,
+    };
+}
+function registerStitchComposition(server) {
+    server.registerTool("stitch_composition", {
+        title: "Stitch a video's beats into a composition",
+        description: "Reads src/videos/<videoName>/beats.json and writes src/videos/<videoName>/<PascalName>Demo.tsx: a " +
+            "SCENES map from beat id to its scaffold_scene component (imported from ./scenes/<BeatId>, the same " +
+            "PascalCase convention scaffold_scene uses -- beats without a scaffolded scene file will fail to " +
+            "type-check, scaffold every beat first), a <Series> of <Series.Sequence> per beat, a VO Audio layer " +
+            "per beat only where public/audio/vo/<beatId>.mp3 actually exists on disk, and a looping " +
+            "full-duration music bed layer if public/audio/music-bed.mp3 exists. Also (re)registers the " +
+            "composition in src/Root.tsx (via an internal src/videos/.registry.json this tool owns), without " +
+            "clobbering compositions a prior stitch_composition call registered for a different video in the " +
+            "same project.",
+        inputSchema: {
+            projectRoot: zod_1.z.string().optional(),
+            videoName: zod_1.z.string().min(1),
+        },
+    }, async (input) => (0, mcp_1.runTool)("stitch_composition", () => runStitchComposition(input)));
+}

package/dist/tools/validateBeats.d.ts

@@ -0,0 +1,14 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export interface ValidateBeatsResult {
+    valid: boolean;
+    errors: string[];
+}
+/**
+ * Mechanically enforces packages/docs/PLANNING.md §4 (captureMethod field spec) and
+ * packages/docs/SCRIPT.md (VO pacing, no em dashes). Takes the drafted beats.json
+ * content directly (not yet written to disk, not assumed to already be valid), and
+ * returns every failure found rather than stopping at the first -- this is the tool's
+ * normal "no" answer, never a thrown exception.
+ */
+export declare function validateBeatsLogic(beatsJson: unknown): ValidateBeatsResult;
+export declare function registerValidateBeats(server: McpServer): void;