@lightcone-ai/daemon 0.15.46 → 0.15.48

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightcone-ai/daemon",
-  "version": "0.15.46",
+  "version": "0.15.48",
   "type": "module",
   "main": "src/index.js",
   "bin": {

package/src/_vendor/video/composer-v2/index.js

@@ -9,6 +9,53 @@ const DEFAULT_WIDTH = 1080;
 const DEFAULT_HEIGHT = 1920;
 const DEFAULT_FPS = 30;
 const TRANSITION_DURATION = 0.5;
+const SUBTITLE_FONT = 'PingFang SC,Microsoft YaHei,Arial';
+const SUBTITLE_FONT_SIZE = 72;
+const SUBTITLE_MARGIN_V = 120;
+
+function msToAssTimestamp(ms) {
+  const totalCs = Math.round(Math.max(0, ms) / 10);
+  const cs = totalCs % 100;
+  const totalSec = Math.floor(totalCs / 100);
+  const sec = totalSec % 60;
+  const min = Math.floor(totalSec / 60) % 60;
+  const hr = Math.floor(totalSec / 3600);
+  return `${hr}:${String(min).padStart(2, '0')}:${String(sec).padStart(2, '0')}.${String(cs).padStart(2, '0')}`;
+}
+
+function wrapSubtitleText(text, maxChars = 14) {
+  const chars = Array.from(String(text ?? ''));
+  if (chars.length <= maxChars) return chars.join('');
+  const lines = [];
+  for (let i = 0; i < chars.length; i += maxChars) {
+    lines.push(chars.slice(i, i + maxChars).join(''));
+  }
+  return lines.join('\\N');
+}
+
+function buildAssContent(subtitles, { playResX = DEFAULT_WIDTH, playResY = DEFAULT_HEIGHT } = {}) {
+  const maxChars = Math.floor((playResX - 60) / SUBTITLE_FONT_SIZE);
+  const header = [
+    '[Script Info]',
+    'ScriptType: v4.00+',
+    `PlayResX: ${playResX}`,
+    `PlayResY: ${playResY}`,
+    'WrapStyle: 2',
+    '',
+    '[V4+ Styles]',
+    'Format: Name, Fontname, Fontsize, PrimaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding',
+    `Style: Default,${SUBTITLE_FONT},${SUBTITLE_FONT_SIZE},&H00FFFFFF,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,4,0,2,30,30,${SUBTITLE_MARGIN_V},1`,
+    '',
+    '[Events]',
+    'Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text',
+  ].join('\n');
+  const events = subtitles.map(({ text, start_ms, end_ms }) => {
+    const wrapped = wrapSubtitleText(text, maxChars);
+    const safe = wrapped.replace(/\r?\n/g, '\\N').replace(/,/g, '{\\,}');
+    return `Dialogue: 0,${msToAssTimestamp(start_ms)},${msToAssTimestamp(end_ms)},Default,,0,0,0,,${safe}`;
+  });
+  return `${header}\n${events.join('\n')}\n`;
+}
 
 async function fileExists(p) {
   try { await access(p, fsConstants.R_OK); return true; } catch { return false; }
@@ -245,7 +292,8 @@ export async function composeVideoV2({
         finalClip = await silentClip({ videoPath: visualClip.path, duration: visualClip.duration, tmpDir });
       }
 
-      readyClips.push({ path: finalClip, duration: visualClip.duration, transition });
+      const subtitleText = typeof seg.subtitle_text === 'string' ? seg.subtitle_text.trim() : '';
+      readyClips.push({ path: finalClip, duration: visualClip.duration, transition, subtitleText });
     }
 
     const outroClips = [];
@@ -256,6 +304,20 @@ export async function composeVideoV2({
       }
     }
 
+    // Build subtitle entries with cumulative timeline timestamps
+    let cursorMs = 0;
+    const subtitleEntries = [];
+    for (const clip of readyClips) {
+      if (clip.subtitleText) {
+        subtitleEntries.push({
+          text: clip.subtitleText,
+          start_ms: cursorMs,
+          end_ms: cursorMs + Math.round(clip.duration * 1000),
+        });
+      }
+      cursorMs += Math.round(clip.duration * 1000);
+    }
+
     const allClips = [];
     let accumulated = readyClips[0].path;
     for (let i = 1; i < readyClips.length; i++) {
@@ -271,10 +333,29 @@ export async function composeVideoV2({
 
     const finalSequence = [...allClips, ...outroClips];
 
+    // Compose without subtitles first (subtitles are burned in a separate pass)
+    const preSubPath = subtitleEntries.length > 0
+      ? path.join(tmpDir, `pre-sub-${randomUUID().slice(0, 8)}.mp4`)
+      : outPath;
+
     if (finalSequence.length === 1) {
-      await runFfmpeg(['-i', finalSequence[0], '-c', 'copy', '-movflags', '+faststart', outPath], 'ffmpeg copy');
+      await runFfmpeg(['-i', finalSequence[0], '-c', 'copy', '-movflags', '+faststart', preSubPath], 'ffmpeg copy');
     } else {
-      await concatWithCuts({ clips: finalSequence, outputPath: outPath });
+      await concatWithCuts({ clips: finalSequence, outputPath: preSubPath });
+    }
+
+    // Burn subtitles into final output
+    if (subtitleEntries.length > 0) {
+      const assPath = path.join(tmpDir, `subs-${randomUUID().slice(0, 8)}.ass`);
+      await writeFile(assPath, buildAssContent(subtitleEntries, { playResX: width, playResY: height }));
+      const escapedAssPath = assPath.replace(/\\/g, '/').replace(/:/g, '\\:').replace(/'/g, "\\'");
+      await runFfmpeg([
+        '-i', preSubPath,
+        '-vf', `subtitles='${escapedAssPath}'`,
+        '-c:a', 'copy',
+        '-movflags', '+faststart',
+        outPath,
+      ], 'ffmpeg burn-subtitles');
     }
 
     const totalDuration = await probeDurationSec(outPath);

package/src/chat-bridge.js

@@ -2,17 +2,9 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
-import { createReadStream, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'fs';
+import { createReadStream, existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { createHash, randomUUID } from 'crypto';
 import path, { extname } from 'path';
-import { homedir } from 'os';
-import {
-  buildAssContent,
-  concatVideos,
-  muxAudioToVideo,
-  probeDurationMs,
-  transcodeForPlatform,
-} from './_vendor/video/composer/index.js';
 import { recordUrlNarration } from './_vendor/video/recorder/index.js';
 import {
   VIDEO_EXT,
@@ -24,6 +16,7 @@ import { runSubmitToLibraryTool } from './submit-to-library-tool.js';
 import { runRenderTextToImageTool } from './tools/render-text-to-image.js';
 import { runRenderHtmlToImageTool } from './tools/render-html-to-image.js';
 import { runSynthesisTtsTool } from './tools/synthesize-tts.js';
+import { runPlanVideoSegmentsTool } from './tools/plan-video-segments.js';
 import { runComposeVideoV2Tool } from './tools/compose-video-v2.js';
 import { runTakePageScreenshotTool } from './tools/take-page-screenshot.js';
 import { runGetLibraryFileTool } from './tools/get-library-file.js';
@@ -75,18 +68,13 @@ function redactTokenPrefix(token) {
 // Current active workspaceId for memory isolation (defaults to spawn-time WORKSPACE_ID)
 let currentWorkspaceId = WORKSPACE_ID;
 
-const VOICEOVER_LOCAL_DIR = path.join(WORKSPACE_DIR, 'artifacts', 'audio');
-const VIDEO_COMPOSE_LOCAL_DIR = path.join(WORKSPACE_DIR, 'artifacts', 'video');
-const DEFAULT_OUTRO_PATH = path.join(homedir(), '.lightcone', 'assets', 'outros', 'default.mp4');
 // Temporary: block legacy video pipeline tools for a specific editor_in_chief agent.
 // Set via env so this doesn't need a code change when workspace/agent IDs rotate.
 // Remove entirely once the new atomic tool framework is stable and the legacy pipeline retires.
 const CVMAX_WORKSPACE_ID = process.env.BLOCKED_EDITOR_WORKSPACE_ID ?? '';
 const CVMAX_EDITOR_IN_CHIEF_AGENT_ID = process.env.BLOCKED_EDITOR_AGENT_ID ?? '';
 const CVMAX_EDITOR_BLOCKED_VIDEO_TOOLS = new Set([
-  'generate_voiceover',
   'record_url_narration',
-  'compose_video',
   'submit_to_library',
 ]);
 
@@ -132,27 +120,6 @@ function cvmaxEditorVideoToolError(toolName) {
   };
 }
 
-function normalizeVoiceFormat(value) {
-  const normalized = String(value ?? '').trim().toLowerCase();
-  if (!normalized) return 'mp3';
-  if (['mp3', 'wav', 'flac'].includes(normalized)) return normalized;
-  return 'mp3';
-}
-
-function inferAudioExtension(url, format = 'mp3') {
-  const normalizedFormat = normalizeVoiceFormat(format);
-  if (typeof url === 'string' && url.trim()) {
-    try {
-      const pathname = new URL(url).pathname;
-      const ext = extname(pathname).toLowerCase();
-      if (ext && ['.mp3', '.wav', '.flac'].includes(ext)) return ext;
-    } catch {
-      // noop
-    }
-  }
-  return `.${normalizedFormat}`;
-}
-
 function isInsideDir(filePath, dir) {
   const rel = path.relative(dir, filePath);
   return rel === '' || (!!rel && !rel.startsWith('..') && !path.isAbsolute(rel));
@@ -168,58 +135,6 @@ function resolveLocalWorkspaceFile(filePath) {
   throw new Error(`Local file must be inside the agent workspace or workspace shared artifacts/notes/tmp directories. Got: ${filePath}`);
 }
 
-function normalizeComposePath(filePath, label) {
-  const normalized = String(filePath ?? '').trim();
-  if (!normalized) throw new Error(`${label} is required.`);
-  return path.resolve(WORKSPACE_DIR, normalized);
-}
-
-function normalizeComposeTarget(value) {
-  const normalized = String(value ?? '').trim().toLowerCase();
-  if (!normalized) return 'short_video_cn';
-  if (['short_video_cn', 'douyin', 'xhs'].includes(normalized)) return normalized;
-  throw new Error(`Unsupported compose target: ${value}`);
-}
-
-function normalizeComposeAudioSegments(audioSegments) {
-  if (!Array.isArray(audioSegments) || audioSegments.length === 0) {
-    throw new Error('audio_segments must be a non-empty array.');
-  }
-
-  return audioSegments.map((segment, index) => {
-    if (!segment || typeof segment !== 'object' || Array.isArray(segment)) {
-      throw new Error(`audio_segments[${index}] must be an object.`);
-    }
-    const audioPath = normalizeComposePath(
-      segment.audio_path ?? segment.audioPath,
-      `audio_segments[${index}].audio_path`
-    );
-    const startMsRaw = segment.start_ms ?? segment.startMs;
-    const startMs = startMsRaw == null ? null : Number(startMsRaw);
-    if (startMsRaw != null && (!Number.isFinite(startMs) || startMs < 0)) {
-      throw new Error(`audio_segments[${index}].start_ms must be a non-negative number.`);
-    }
-    const phase = String(segment.phase ?? segment.phase_id ?? segment.phaseId ?? '').trim();
-    if (startMs == null && !phase) {
-      throw new Error(`audio_segments[${index}] requires start_ms, or provide phase with events_log.`);
-    }
-
-    const normalized = { audio_path: audioPath };
-    if (startMs != null) normalized.start_ms = Math.floor(startMs);
-    if (phase) normalized.phase = phase;
-    return {
-      ...normalized,
-    };
-  });
-}
-
-function cleanupLocalFiles(paths = []) {
-  for (const filePath of paths) {
-    if (!filePath) continue;
-    try { rmSync(filePath, { force: true }); } catch { /* noop */ }
-  }
-}
-
 const DEFAULT_TOOL_CLASSIFICATION = {
   check_messages: 'local',
   list_memory: 'local',
@@ -247,9 +162,7 @@ const DEFAULT_TOOL_CLASSIFICATION = {
   update_goal_field: 'mandatory',
   supersede_goal_field: 'mandatory',
   request_credential_auth: 'mandatory',
-  generate_voiceover: 'mandatory',
   record_url_narration: 'mandatory',
-  compose_video: 'mandatory',
   submit_to_library: 'mandatory',
   register_data_source: 'mandatory',
   bind_workspace_scenario: 'mandatory',
@@ -385,7 +298,6 @@ function inferToolForApi(method, apiPath, body) {
   if (method === 'POST' && cleanPath === '/goal-fields/update') return 'update_goal_field';
   if (method === 'POST' && cleanPath === '/goal-fields/supersede') return 'supersede_goal_field';
   if (method === 'POST' && cleanPath === '/credential-auth/request') return 'request_credential_auth';
-  if (method === 'POST' && cleanPath === '/tts/voiceover') return 'generate_voiceover';
   if (method === 'POST' && cleanPath === '/content-library/submit') return 'submit_to_library';
   if (method === 'POST' && cleanPath === '/api/data-sources') return 'register_data_source';
   if (method === 'POST' && cleanPath === '/orchestrate/decision') return 'write_governance_decision';
@@ -1446,24 +1358,44 @@ server.tool('synthesize_tts',
   async (args) => runSynthesisTtsTool({ ...args, currentWorkspaceId, api })
 );
 
+// ── plan_video_segments ────────────────────────────────────────────────────────
+server.tool('plan_video_segments',
+  'Universal audio-video sync planning step. For each segment, call TTS to get the real audio duration, then compute the visual duration with a safety buffer. Returns a planned segments array ready to pass directly to compose_video_v2 (with audio_path, presentation.duration/per_card_duration, and subtitle_text pre-filled). Always call this before compose_video_v2 when you have narration text.',
+  {
+    segments: z.array(z.object({
+      text: z.string().describe('Narration text for this segment. TTS will be generated from this.'),
+      visual_kind: z.enum(['image', 'video', 'gif', 'carousel']).describe('Type of visual.'),
+      visual_path: z.string().optional().describe('Absolute path to a single image, video, or gif file.'),
+      visual_paths: z.array(z.string()).optional().describe('For carousel: array of image paths, one per card.'),
+      transition: z.enum(['cut', 'fade', 'crossfade']).optional().describe('Transition to next segment. Default cut.'),
+      presentation: z.object({
+        style: z.enum(['static', 'scroll']).optional(),
+      }).optional().describe('Partial presentation hints (style only). duration/per_card_duration are computed from TTS.'),
+    })).describe('Segments to plan. Each must have narration text and visual info.'),
+    voice_id: z.string().optional().describe('TTS voice ID. Omit to use workspace default.'),
+    workspace_id: z.string().optional().describe('Target workspace. Defaults to current workspace context.'),
+  },
+  async (args) => runPlanVideoSegmentsTool({ ...args, currentWorkspaceId, api })
+);
+
 // ── compose_video_v2 ───────────────────────────────────────────────────────────
 server.tool('compose_video_v2',
-  'Compose a video from a list of segments using ffmpeg. Each segment has a visual source (image/scroll/carousel/video/gif) and optional audio. Segments are concatenated in order; an outro clip is appended at the end. Returns a local mp4 path.',
+  'Compose a video from a list of segments using ffmpeg. Each segment has a visual source (image/scroll/carousel/video/gif), optional audio, and optional subtitle text. Subtitles are burned into the video by default when subtitle_text is provided. Segments are concatenated in order; outro clips are appended at the end. Returns a local mp4 path.\n\nTypical flow: plan_video_segments → compose_video_v2 (segments output fed directly in).',
   {
     segments: z.array(z.object({
       visual_path: z.string().optional().describe('Absolute path to a single image, video, or gif file.'),
       visual_paths: z.array(z.string()).optional().describe('For carousel: array of image paths, one per card.'),
-      visual_kind: z.enum(['image', 'video', 'gif', 'carousel']).describe('Type of visual. image: static image frame. video: video clip. gif: animated GIF. carousel: sequence of images (use visual_paths).'),
+      visual_kind: z.enum(['image', 'video', 'gif', 'carousel']).describe('Type of visual.'),
       presentation: z.object({
-        style: z.enum(['static', 'scroll']).optional().describe('For image: static (default) or scroll (pan upward). Ignored for video/gif/carousel.'),
-        duration: z.number().optional().describe('Segment duration in seconds. Required for image/scroll. For gif, omit to use natural GIF duration.'),
+        style: z.enum(['static', 'scroll']).optional().describe('For image: static (default) or scroll (pan upward).'),
+        duration: z.number().optional().describe('Segment duration in seconds. Required for image/scroll.'),
         per_card_duration: z.number().optional().describe('Seconds per card for carousel.'),
       }).optional(),
-      audio_path: z.string().nullable().optional().describe('Absolute path to an audio file (mp3) for this segment. null or omit for silence.'),
+      audio_path: z.string().nullable().optional().describe('Absolute path to audio (mp3). null or omit for silence.'),
+      subtitle_text: z.string().optional().describe('Narration text to burn as subtitle for this segment. Displayed for the full segment duration.'),
       transition: z.enum(['cut', 'fade', 'crossfade']).optional().describe('Transition to next segment. Default cut.'),
     })).describe('Ordered list of video segments.'),
     outro_paths: z.array(z.string()).optional().describe('Absolute paths to outro video clips appended after all segments.'),
-    format: z.string().optional().describe('Aspect ratio. Default "9:16".'),
     resolution: z.string().optional().describe('Output resolution WxH. Default "1080x1920".'),
     output_path: z.string().optional().describe('Absolute output path for the mp4. Auto-generated if omitted.'),
   },
@@ -1495,89 +1427,9 @@ server.tool('get_library_file',
   async (args) => runGetLibraryFileTool({ ...args, currentWorkspaceId, api, SERVER_URL, MACHINE_API_KEY, workspaceDir: WORKSPACE_DIR })
 );
 
-// ── generate_voiceover ─────────────────────────────────────────────────────────
-server.tool('generate_voiceover',
-  'Generate a TTS voiceover using an authorized tts_provider credential and return a local audio file path.',
-  {
-    workspace_id: z.string().optional().describe('Target workspace id. Defaults to current workspace context.'),
-    text: z.string().describe('Text content to synthesize.'),
-    voice_preset: z.string().optional().describe('Platform-neutral voice preset id, e.g. "warm_female_zh_01".'),
-    speed: z.number().optional().describe('Speech speed. Typical range is 0.5 to 2.0.'),
-    format: z.enum(['mp3', 'wav', 'flac']).optional().describe('Audio format. Defaults to mp3.'),
-    credential_id: z.string().optional().describe('Optional explicit credential id. If omitted, uses latest granted tts_provider credential.'),
-  },
-  async ({ workspace_id, text, voice_preset, speed, format, credential_id }) => {
-    if (isBlockedCvmaxEditorVideoTool('generate_voiceover')) {
-      return cvmaxEditorVideoToolError('generate_voiceover');
-    }
-    const targetWorkspaceId = (workspace_id ?? currentWorkspaceId ?? WORKSPACE_ID ?? '').trim();
-    if (!targetWorkspaceId) {
-      return { isError: true, content: [{ type: 'text', text: 'workspace_id is required (no current workspace context).' }] };
-    }
-
-    const normalizedText = String(text ?? '').trim();
-    if (!normalizedText) {
-      return { isError: true, content: [{ type: 'text', text: 'text is required for generate_voiceover.' }] };
-    }
-
-    const normalizedSpeed = speed == null ? 1 : Number(speed);
-    if (!Number.isFinite(normalizedSpeed)) {
-      return { isError: true, content: [{ type: 'text', text: 'speed must be numeric.' }] };
-    }
-
-    const normalizedFormat = normalizeVoiceFormat(format);
-    const payload = {
-      workspace_id: targetWorkspaceId,
-      text: normalizedText,
-      speed: normalizedSpeed,
-      format: normalizedFormat,
-    };
-    if (voice_preset) payload.voice_preset = String(voice_preset).trim();
-    if (credential_id) payload.credential_id = String(credential_id).trim();
-
-    const data = await api('POST', '/tts/voiceover', payload);
-    const remoteAudioUrl = String(data.audio_url ?? '').trim();
-    if (!remoteAudioUrl) {
-      return { isError: true, content: [{ type: 'text', text: 'Voiceover API did not return audio_url.' }] };
-    }
-
-    const downloadRes = await fetch(remoteAudioUrl, {
-      method: 'GET',
-      headers: { 'Authorization': `Bearer ${MACHINE_API_KEY}` },
-    });
-    if (!downloadRes.ok) {
-      return {
-        isError: true,
-        content: [{ type: 'text', text: `Failed to download synthesized audio (${downloadRes.status})` }],
-      };
-    }
-
-    const fileBuffer = Buffer.from(await downloadRes.arrayBuffer());
-    mkdirSync(VOICEOVER_LOCAL_DIR, { recursive: true });
-    const audioExt = inferAudioExtension(remoteAudioUrl, data.format ?? normalizedFormat);
-    const localFileName = `voiceover-${Date.now()}-${randomUUID().slice(0, 8)}${audioExt}`;
-    const localAudioPath = path.join(VOICEOVER_LOCAL_DIR, localFileName);
-    writeFileSync(localAudioPath, fileBuffer);
-
-    return {
-      content: [{
-        type: 'text',
-        text:
-          `Voiceover generated.\n` +
-          `workspace_id=${data.workspace_id ?? targetWorkspaceId}\n` +
-          `local_audio_path=${localAudioPath}\n` +
-          `duration_ms=${data.duration_ms ?? 'unknown'}\n` +
-          `sample_rate=${data.sample_rate ?? 'unknown'}\n` +
-          `format=${data.format ?? normalizedFormat}\n` +
-          `size=${formatBytes(fileBuffer.length)}`,
-      }],
-    };
-  }
-);
-
 // ── record_url_narration ────────────────────────────────────────────────────────
 server.tool('record_url_narration',
-  'Record a silent video of a URL by orchestrating Xvfb + Chromium + ffmpeg, driven by a video plan. Outputs a silent mp4 plus an events.json timestamp log that compose_video can use to align audio segments.\n\nUse this as the canonical recording step for URL-narration videos. Falls back: if the page needs interactions outside the visual_action vocabulary (clicks, waits, OCR loops), use Monitor (Bash) with custom Playwright instead.\n\nRuntime requirements: this tool only works on a Linux daemon machine with Xvfb + ffmpeg (x11grab) + Chromium installed. macOS / Windows daemons will fail at startup.',
+  'Record a silent video of a URL by orchestrating Xvfb + Chromium + ffmpeg, driven by a video plan. Outputs a silent mp4 that can be passed to compose_video_v2 as a video-kind segment with an audio_path for narration.\n\nUse this as the canonical recording step for URL-narration videos. Falls back: if the page needs interactions outside the visual_action vocabulary (clicks, waits, OCR loops), use Monitor (Bash) with custom Playwright instead.\n\nRuntime requirements: this tool only works on a Linux daemon machine with Xvfb + ffmpeg (x11grab) + Chromium installed. macOS / Windows daemons will fail at startup.',
   {
     url: z.string().describe('Page URL to record'),
     plan: z.record(z.any()).describe('Must be the full output from detail_sections (not plan_video). detail_sections output includes detail_sections_version, sections[], audio metadata, and dwell_ms per phase.'),
@@ -1604,126 +1456,6 @@ server.tool('record_url_narration',
   }
 );
 
-// ── compose_video ───────────────────────────────────────────────────────────────
-server.tool('compose_video',
-  'Compose a final short video by muxing audio onto a base video, optionally burning subtitles, concatenating an outro, and transcoding to platform spec.',
-  {
-    video_path: z.string().describe('Base silent video path. Relative paths resolve from the current workspace.'),
-    audio_segments: z.array(z.object({
-      audio_path: z.string().describe('Audio file path for one narration segment.'),
-      start_ms: z.union([z.number(), z.string()]).optional().describe('Segment start offset in milliseconds.'),
-      phase: z.string().optional().describe('Optional phase id. Used with events_log to derive start time.'),
-    })).describe('Ordered or unordered narration audio segments.'),
-    events_log: z.array(z.any()).optional().describe('Optional recorder event log. Used to resolve segment start time by phase.'),
-    subtitles: z.array(z.object({
-      text: z.string().describe('Subtitle text for this segment (the narration sentence).'),
-      start_ms: z.number().describe('Subtitle start time in milliseconds.'),
-      end_ms: z.number().describe('Subtitle end time in milliseconds.'),
-    })).optional().describe('Subtitle segments to burn into the video. Pass each phase sentence text (from detail_sections sections[].sentence) with cumulative start/end time derived from dwell_ms. Omit to produce no subtitles.'),
-    outro_path: z.string().optional().describe('Optional outro mp4 path. If omitted, uses ~/.lightcone/assets/outros/default.mp4 when present.'),
-    target: z.enum(['short_video_cn', 'douyin', 'xhs']).optional().describe('Transcode target profile. Defaults to short_video_cn.'),
-  },
-  async ({ video_path, audio_segments, events_log, subtitles, outro_path, target }) => {
-    if (isBlockedCvmaxEditorVideoTool('compose_video')) {
-      return cvmaxEditorVideoToolError('compose_video');
-    }
-    const composeInput = { video_path, audio_segments, events_log, subtitles, outro_path, target };
-    try {
-      const result = await runMandatoryLocalTool({
-        toolName: 'compose_video',
-        toolInput: composeInput,
-        executor: async (checkedInput) => {
-          const videoPath = normalizeComposePath(checkedInput.video_path, 'video_path');
-          const audioSegments = normalizeComposeAudioSegments(checkedInput.audio_segments);
-          const eventsLog = Array.isArray(checkedInput.events_log) ? checkedInput.events_log : [];
-          const targetProfile = normalizeComposeTarget(checkedInput.target);
-          const requestedOutroPath = String(checkedInput.outro_path ?? '').trim();
-
-          let resolvedOutroPath = null;
-          if (requestedOutroPath) {
-            resolvedOutroPath = path.resolve(WORKSPACE_DIR, requestedOutroPath);
-            if (!existsSync(resolvedOutroPath)) {
-              throw new Error(`outro_path not found: ${resolvedOutroPath}`);
-            }
-          } else if (existsSync(DEFAULT_OUTRO_PATH)) {
-            resolvedOutroPath = DEFAULT_OUTRO_PATH;
-          }
-
-          mkdirSync(VIDEO_COMPOSE_LOCAL_DIR, { recursive: true });
-          const runId = `${Date.now()}-${randomUUID().slice(0, 8)}`;
-          const muxedPath = path.join(VIDEO_COMPOSE_LOCAL_DIR, `compose-${runId}.muxed.mp4`);
-          const concatPath = path.join(VIDEO_COMPOSE_LOCAL_DIR, `compose-${runId}.concat.mp4`);
-          const finalPath = path.join(VIDEO_COMPOSE_LOCAL_DIR, `compose-${runId}.final.mp4`);
-          const assPath = path.join(VIDEO_COMPOSE_LOCAL_DIR, `compose-${runId}.ass`);
-          const intermediates = [muxedPath, concatPath, assPath];
-
-          const subtitleSegments = Array.isArray(checkedInput.subtitles) ? checkedInput.subtitles : [];
-          let subtitlesAssPath = null;
-          if (subtitleSegments.length > 0) {
-            const assContent = buildAssContent(subtitleSegments);
-            writeFileSync(assPath, assContent, 'utf8');
-            subtitlesAssPath = assPath;
-          }
-
-          try {
-            await muxAudioToVideo({
-              video_path: videoPath,
-              audio_segments: audioSegments,
-              events_log: eventsLog,
-              output: muxedPath,
-            });
-
-            let composedPath = muxedPath;
-            if (resolvedOutroPath) {
-              await concatVideos({
-                inputs: [muxedPath, resolvedOutroPath],
-                output: concatPath,
-              });
-              composedPath = concatPath;
-            }
-
-            await transcodeForPlatform({
-              input: composedPath,
-              output: finalPath,
-              target: targetProfile,
-              subtitlesAssPath,
-            });
-
-            const durationMs = await probeDurationMs(finalPath);
-            cleanupLocalFiles(intermediates);
-            return {
-              finalVideoPath: finalPath,
-              durationMs,
-              outroPath: resolvedOutroPath,
-              target: targetProfile,
-              subtitles: subtitleSegments.length > 0,
-            };
-          } catch (error) {
-            cleanupLocalFiles([...intermediates, finalPath]);
-            throw error;
-          }
-        },
-      });
-
-      const outroText = result.outroPath ? result.outroPath : 'skipped';
-      return {
-        content: [{
-          type: 'text',
-          text:
-            `Video composed.\n` +
-            `final_video_path=${result.finalVideoPath}\n` +
-            `duration_ms=${result.durationMs}\n` +
-            `target=${result.target}\n` +
-            `subtitles=${result.subtitles ? 'burned' : 'none'}\n` +
-            `outro=${outroText}`,
-        }],
-      };
-    } catch (error) {
-      return { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] };
-    }
-  }
-);
-
 // ── submit_to_library ──────────────────────────────────────────────────────────
 server.tool('submit_to_library',
   '把已生成的视频成片归档进内容库（content_video_draft entry）。调用前 mp4 必须已经通过 write_workspace_file 落到 workspace 的 artifacts/ 路径。归档后内容库会出现一张新卡片，含视频预览 + 元数据 + 后续支持发布/回采链路。',

package/src/tools/plan-video-segments.js

@@ -0,0 +1,115 @@
+import { mkdirSync, writeFileSync } from 'fs';
+import { randomUUID } from 'crypto';
+import path from 'path';
+import os from 'os';
+
+function toolText(text) {
+  return { content: [{ type: 'text', text }] };
+}
+
+function toolError(text) {
+  return { isError: true, content: [{ type: 'text', text }] };
+}
+
+function inferAudioExt(url) {
+  const clean = String(url ?? '').split('?')[0];
+  const ext = path.extname(clean).toLowerCase();
+  return ['.mp3', '.wav', '.flac', '.aac', '.ogg'].includes(ext) ? ext : '.mp3';
+}
+
+async function synthesizeSegmentTts(text, { workspace_id, voice_id, api }) {
+  const payload = { workspace_id, text, speed: 1, format: 'mp3' };
+  if (voice_id) payload.voice_preset = String(voice_id).trim();
+
+  const data = await api('POST', '/tts/voiceover', payload);
+  const remoteAudioUrl = String(data.audio_url ?? '').trim();
+  if (!remoteAudioUrl) throw new Error('TTS API did not return audio_url');
+
+  const downloadRes = await fetch(remoteAudioUrl);
+  if (!downloadRes.ok) throw new Error(`Failed to download audio (${downloadRes.status})`);
+
+  const fileBuffer = Buffer.from(await downloadRes.arrayBuffer());
+  const outDir = path.join(os.tmpdir(), 'lightcone-tts');
+  mkdirSync(outDir, { recursive: true });
+  const ext = inferAudioExt(remoteAudioUrl);
+  const outPath = path.join(outDir, `tts-${Date.now()}-${randomUUID().slice(0, 8)}${ext}`);
+  writeFileSync(outPath, fileBuffer);
+
+  const durationMs = Number(data.duration_ms ?? 0);
+  return { audio_path: outPath, audio_duration_ms: durationMs };
+}
+
+// Compute segment duration from audio duration: audio + 0.5s buffer, rounded up to nearest 0.5s.
+function planDurationSec(audioDurationMs, bufferSec = 0.5) {
+  const raw = audioDurationMs / 1000 + bufferSec;
+  return Math.ceil(raw * 2) / 2; // round up to nearest 0.5s
+}
+
+export async function runPlanVideoSegmentsTool({ segments, workspace_id, voice_id, currentWorkspaceId, api }) {
+  if (!Array.isArray(segments) || segments.length === 0) {
+    return toolError('segments must be a non-empty array.');
+  }
+
+  const targetWorkspaceId = String(workspace_id ?? currentWorkspaceId ?? '').trim();
+  if (!targetWorkspaceId) {
+    return toolError('workspace_id is required (no current workspace context).');
+  }
+
+  const planned = [];
+  const errors = [];
+
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    const text = String(seg.text ?? '').trim();
+    const kind = String(seg.visual_kind ?? 'image');
+
+    let audioResult = null;
+    if (text) {
+      try {
+        audioResult = await synthesizeSegmentTts(text, { workspace_id: targetWorkspaceId, voice_id, api });
+      } catch (err) {
+        errors.push(`segments[${i}]: TTS failed — ${err.message}`);
+        audioResult = { audio_path: null, audio_duration_ms: 3000 }; // fallback estimate
+      }
+    }
+
+    const audioDurationMs = audioResult?.audio_duration_ms ?? 0;
+    let presentation;
+
+    if (kind === 'carousel') {
+      const numCards = Array.isArray(seg.visual_paths) ? seg.visual_paths.length : 1;
+      const totalDuration = audioDurationMs > 0 ? planDurationSec(audioDurationMs) : numCards * 4;
+      const perCard = Math.max(2, Math.ceil((totalDuration / numCards) * 2) / 2);
+      presentation = { per_card_duration: perCard };
+    } else {
+      // image, scroll, video, gif
+      const duration = audioDurationMs > 0 ? planDurationSec(audioDurationMs, kind === 'scroll' ? 1.0 : 0.5) : 4;
+      presentation = { duration, ...(kind === 'scroll' ? { style: 'scroll' } : {}) };
+    }
+
+    const planned_seg = {
+      ...seg,
+      ...(audioResult?.audio_path ? { audio_path: audioResult.audio_path } : {}),
+      ...(text ? { subtitle_text: text } : {}),
+      presentation: { ...presentation, ...(seg.presentation ?? {}) },
+    };
+    if (audioResult?.audio_duration_ms) {
+      planned_seg.audio_duration_ms = audioResult.audio_duration_ms;
+    }
+    planned.push(planned_seg);
+  }
+
+  const result = {
+    segments: planned,
+    total_segments: planned.length,
+    total_duration_ms: planned.reduce((sum, s) => {
+      const d = s.presentation?.per_card_duration
+        ? s.presentation.per_card_duration * (Array.isArray(s.visual_paths) ? s.visual_paths.length : 1)
+        : (s.presentation?.duration ?? 4);
+      return sum + Math.round(d * 1000);
+    }, 0),
+    ...(errors.length > 0 ? { warnings: errors } : {}),
+  };
+
+  return toolText(JSON.stringify(result, null, 2));
+}

package/src/_vendor/video/composer/index.js

@@ -1,440 +0,0 @@
-import { spawn } from 'node:child_process';
-import path from 'node:path';
-import { access, mkdir, mkdtemp, rm, stat, writeFile } from 'node:fs/promises';
-import { constants as fsConstants } from 'node:fs';
-import os from 'node:os';
-
-const SUBTITLE_FONT = 'WenQuanYi Micro Hei';
-const SUBTITLE_FONT_SIZE = 72;
-const SUBTITLE_MARGIN_V = 80;
-
-const MAX_STDERR_LENGTH = 4000;
-
-const TRANSCODE_TARGETS = Object.freeze({
-  short_video_cn: {
-    width: 1080,
-    height: 1920,
-    fps: 30,
-    videoCodec: 'libx264',
-    profile: 'baseline',
-    pixelFormat: 'yuv420p',
-    crf: 23,
-    preset: 'veryfast',
-    level: '4.0',
-    audioCodec: 'aac',
-    audioBitrate: '128k',
-    audioSampleRate: 48000,
-    audioChannels: 2,
-  },
-});
-
-function normalizeText(value) {
-  if (typeof value !== 'string') return '';
-  return value.trim();
-}
-
-function normalizePath(value, label) {
-  const raw = normalizeText(value);
-  if (!raw) throw new Error(`${label} required`);
-  return path.resolve(raw);
-}
-
-async function ensureReadableFile(filePath, label) {
-  try {
-    await access(filePath, fsConstants.R_OK);
-  } catch {
-    throw new Error(`${label} not found or unreadable: ${filePath}`);
-  }
-
-  const st = await stat(filePath);
-  if (!st.isFile()) throw new Error(`${label} is not a file: ${filePath}`);
-}
-
-async function ensureParentDir(filePath) {
-  await mkdir(path.dirname(filePath), { recursive: true });
-}
-
-function sanitizeStderr(stderr) {
-  const text = String(stderr ?? '').trim();
-  if (!text) return '';
-  if (text.length <= MAX_STDERR_LENGTH) return text;
-  return text.slice(text.length - MAX_STDERR_LENGTH);
-}
-
-function toolError(prefix, error, stderr = '') {
-  const details = [];
-  const message = normalizeText(error?.message);
-  if (message) details.push(message);
-  const cleanedStderr = sanitizeStderr(stderr);
-  if (cleanedStderr) details.push(cleanedStderr);
-  const suffix = details.length > 0 ? `: ${details.join(' | ')}` : '';
-  return new Error(`${prefix}${suffix}`);
-}
-
-function runProcess(binary, args, { name = binary } = {}) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(binary, args, { stdio: ['ignore', 'pipe', 'pipe'] });
-    let stdout = '';
-    let stderr = '';
-
-    child.stdout.on('data', (chunk) => {
-      stdout += chunk.toString();
-    });
-    child.stderr.on('data', (chunk) => {
-      stderr += chunk.toString();
-    });
-
-    child.on('error', (error) => {
-      reject(toolError(`${name} failed`, error, stderr));
-    });
-
-    child.on('close', (code) => {
-      if (code === 0) {
-        resolve({ stdout, stderr });
-        return;
-      }
-      reject(toolError(`${name} exited with code ${code}`, null, stderr));
-    });
-  });
-}
-
-function normalizeStartMs(value) {
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed) || parsed < 0) return null;
-  return Math.floor(parsed);
-}
-
-function resolveStartMsFromEvents(segment, eventsLog = []) {
-  const phase = normalizeText(segment?.phase ?? segment?.phase_id ?? segment?.phaseId);
-  if (!phase) return null;
-
-  let candidate = null;
-  for (const event of eventsLog) {
-    const eventPhase = normalizeText(event?.phase ?? event?.phase_id ?? event?.phaseId);
-    if (!eventPhase || eventPhase !== phase) continue;
-
-    const eventStart = normalizeStartMs(
-      event?.t_ms_start
-      ?? event?.tMsStart
-      ?? event?.t_ms
-      ?? event?.tMs
-    );
-    if (eventStart == null) continue;
-    if (candidate == null || eventStart < candidate) candidate = eventStart;
-  }
-
-  return candidate;
-}
-
-function normalizeAudioSegments(audioSegments = [], eventsLog = []) {
-  if (!Array.isArray(audioSegments)) {
-    throw new Error('audio_segments must be an array');
-  }
-
-  return audioSegments.map((segment, index) => {
-    if (!segment || typeof segment !== 'object' || Array.isArray(segment)) {
-      throw new Error(`audio_segments[${index}] must be an object`);
-    }
-
-    const audioPath = normalizePath(segment.audio_path ?? segment.audioPath, `audio_segments[${index}].audio_path`);
-    const startMs = normalizeStartMs(segment.start_ms ?? segment.startMs)
-      ?? resolveStartMsFromEvents(segment, eventsLog);
-    if (startMs == null) {
-      throw new Error(`audio_segments[${index}].start_ms missing (and no matching events_log entry found)`);
-    }
-
-    return {
-      audioPath,
-      startMs,
-    };
-  });
-}
-
-function defaultOutputPath(inputPath, suffix) {
-  const ext = path.extname(inputPath) || '.mp4';
-  const base = path.basename(inputPath, ext);
-  return path.join(path.dirname(inputPath), `${base}.${suffix}${ext}`);
-}
-
-function escapeConcatPath(filePath) {
-  return filePath.replace(/'/g, `'\\''`);
-}
-
-export async function muxAudioToVideo({
-  video_path,
-  audio_segments = [],
-  events_log = [],
-  output = null,
-} = {}) {
-  const videoPath = normalizePath(video_path, 'video_path');
-  await ensureReadableFile(videoPath, 'video_path');
-
-  const segments = normalizeAudioSegments(audio_segments, events_log).sort((a, b) => a.startMs - b.startMs);
-  for (const segment of segments) {
-    await ensureReadableFile(segment.audioPath, `audio segment (${segment.audioPath})`);
-  }
-
-  const outputPath = output
-    ? normalizePath(output, 'output')
-    : defaultOutputPath(videoPath, 'muxed');
-  if (outputPath === videoPath) throw new Error('output must not equal video_path');
-  await ensureParentDir(outputPath);
-
-  if (segments.length === 0) {
-    await runProcess('ffmpeg', [
-      '-y',
-      '-i', videoPath,
-      '-map', '0:v:0',
-      '-c:v', 'copy',
-      '-an',
-      outputPath,
-    ], { name: 'ffmpeg mux(no-audio)' });
-    return outputPath;
-  }
-
-  const filterChunks = [];
-  const mixInputs = [];
-  for (let i = 0; i < segments.length; i += 1) {
-    const delay = segments[i].startMs;
-    const label = `a${i}`;
-    filterChunks.push(`[${i + 1}:a]adelay=${delay}|${delay},aresample=async=1:first_pts=0[${label}]`);
-    mixInputs.push(`[${label}]`);
-  }
-  filterChunks.push(`${mixInputs.join('')}amix=inputs=${segments.length}:duration=longest:dropout_transition=0,apad[a]`);
-
-  const args = [
-    '-y',
-    '-i', videoPath,
-  ];
-
-  for (const segment of segments) {
-    args.push('-i', segment.audioPath);
-  }
-
-  args.push(
-    '-filter_complex', filterChunks.join(';'),
-    '-map', '0:v:0',
-    '-map', '[a]',
-    '-c:v', 'copy',
-    '-c:a', 'aac',
-    '-shortest',
-    '-movflags', '+faststart',
-    outputPath
-  );
-
-  await runProcess('ffmpeg', args, { name: 'ffmpeg mux' });
-  return outputPath;
-}
-
-export async function concatVideos({
-  inputs = [],
-  output,
-} = {}) {
-  if (!Array.isArray(inputs) || inputs.length === 0) {
-    throw new Error('inputs must be a non-empty array');
-  }
-
-  const normalizedInputs = inputs.map((input, index) => normalizePath(input, `inputs[${index}]`));
-  for (const inputPath of normalizedInputs) {
-    await ensureReadableFile(inputPath, `concat input (${inputPath})`);
-  }
-
-  const outputPath = output
-    ? normalizePath(output, 'output')
-    : defaultOutputPath(normalizedInputs[0], 'concat');
-  await ensureParentDir(outputPath);
-
-  if (normalizedInputs.length === 1) {
-    await runProcess('ffmpeg', [
-      '-y',
-      '-i', normalizedInputs[0],
-      '-c', 'copy',
-      outputPath,
-    ], { name: 'ffmpeg concat(single-input)' });
-    return outputPath;
-  }
-
-  const tempDir = await mkdtemp(path.join(os.tmpdir(), 'lightcone-concat-'));
-  const listPath = path.join(tempDir, 'inputs.txt');
-
-  try {
-    const content = normalizedInputs
-      .map(inputPath => `file '${escapeConcatPath(inputPath)}'`)
-      .join('\n');
-    await writeFile(listPath, `${content}\n`, 'utf8');
-
-    await runProcess('ffmpeg', [
-      '-y',
-      '-f', 'concat',
-      '-safe', '0',
-      '-i', listPath,
-      '-c', 'copy',
-      '-movflags', '+faststart',
-      outputPath,
-    ], { name: 'ffmpeg concat' });
-  } finally {
-    await rm(tempDir, { recursive: true, force: true }).catch(() => {});
-  }
-
-  return outputPath;
-}
-
-function resolveTranscodeTarget(target) {
-  const normalized = normalizeText(target).toLowerCase();
-  if (!normalized) return TRANSCODE_TARGETS.short_video_cn;
-
-  if (normalized === 'short_video_cn' || normalized === 'douyin' || normalized === 'xhs') {
-    return TRANSCODE_TARGETS.short_video_cn;
-  }
-
-  throw new Error(`unsupported transcode target: ${target}`);
-}
-
-function msToAssTimestamp(ms) {
-  const totalCs = Math.round(Math.max(0, ms) / 10);
-  const cs = totalCs % 100;
-  const totalSec = Math.floor(totalCs / 100);
-  const sec = totalSec % 60;
-  const totalMin = Math.floor(totalSec / 60);
-  const min = totalMin % 60;
-  const hr = Math.floor(totalMin / 60);
-  return `${hr}:${String(min).padStart(2, '0')}:${String(sec).padStart(2, '0')}.${String(cs).padStart(2, '0')}`;
-}
-
-// Hard-wrap CJK subtitle text so it never overflows the video frame.
-// libass WrapStyle:0 doesn't handle Chinese text reliably (no word boundaries),
-// so we insert explicit \N breaks every maxChars characters.
-function wrapSubtitleText(text, maxChars = 14) {
-  const chars = Array.from(String(text ?? ''));
-  if (chars.length <= maxChars) return chars.join('');
-  const lines = [];
-  for (let i = 0; i < chars.length; i += maxChars) {
-    lines.push(chars.slice(i, i + maxChars).join(''));
-  }
-  return lines.join('\\N');
-}
-
-export function buildAssContent(subtitles = [], { playResX = 1080, playResY = 1920 } = {}) {
-  // Max chars per line: (playResX - marginL - marginR) / fontSizePx
-  // 1080 - 30 - 30 = 1020px, fontsize 72 ≈ 72px/char → 14 chars
-  const maxCharsPerLine = Math.floor((playResX - 60) / SUBTITLE_FONT_SIZE);
-
-  const header = [
-    '[Script Info]',
-    'ScriptType: v4.00+',
-    `PlayResX: ${playResX}`,
-    `PlayResY: ${playResY}`,
-    'WrapStyle: 2',
-    '',
-    '[V4+ Styles]',
-    'Format: Name, Fontname, Fontsize, PrimaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding',
-    `Style: Default,${SUBTITLE_FONT},${SUBTITLE_FONT_SIZE},&H00FFFFFF,&H00000000,&H00000000,-1,0,0,0,100,100,0,0,1,4,0,2,30,30,${SUBTITLE_MARGIN_V},1`,
-    '',
-    '[Events]',
-    'Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text',
-  ].join('\n');
-
-  const events = subtitles.map(({ text, start_ms, end_ms }) => {
-    const wrapped = wrapSubtitleText(text, maxCharsPerLine);
-    const safeText = wrapped.replace(/\r?\n/g, '\\N').replace(/,/g, '{\\,}');
-    return `Dialogue: 0,${msToAssTimestamp(start_ms)},${msToAssTimestamp(end_ms)},Default,,0,0,0,,${safeText}`;
-  });
-
-  return `${header}\n${events.join('\n')}\n`;
-}
-
-export async function transcodeForPlatform({
-  input,
-  output,
-  target = 'short_video_cn',
-  subtitlesAssPath = null,
-} = {}) {
-  const inputPath = normalizePath(input, 'input');
-  await ensureReadableFile(inputPath, 'input');
-
-  const outputPath = output
-    ? normalizePath(output, 'output')
-    : defaultOutputPath(inputPath, 'platform');
-  if (outputPath === inputPath) throw new Error('output must not equal input');
-  await ensureParentDir(outputPath);
-
-  const preset = resolveTranscodeTarget(target);
-  const vfParts = [
-    `scale=${preset.width}:${preset.height}:force_original_aspect_ratio=decrease`,
-    `pad=${preset.width}:${preset.height}:(ow-iw)/2:(oh-ih)/2:black`,
-    'setsar=1',
-  ];
-  if (subtitlesAssPath) {
-    const escapedPath = subtitlesAssPath.replace(/\\/g, '/').replace(/:/g, '\\:').replace(/'/g, "\\'");
-    vfParts.push(`subtitles='${escapedPath}'`);
-  }
-  const vf = vfParts.join(',');
-
-  await runProcess('ffmpeg', [
-    '-y',
-    '-i', inputPath,
-    '-vf', vf,
-    '-r', String(preset.fps),
-    '-c:v', preset.videoCodec,
-    '-profile:v', preset.profile,
-    '-level', preset.level,
-    '-pix_fmt', preset.pixelFormat,
-    '-preset', preset.preset,
-    '-crf', String(preset.crf),
-    '-c:a', preset.audioCodec,
-    '-b:a', preset.audioBitrate,
-    '-ar', String(preset.audioSampleRate),
-    '-ac', String(preset.audioChannels),
-    '-movflags', '+faststart',
-    outputPath,
-  ], { name: 'ffmpeg transcode' });
-
-  return outputPath;
-}
-
-export async function probeDurationMs(inputPath) {
-  const resolved = normalizePath(inputPath, 'input');
-  await ensureReadableFile(resolved, 'input');
-
-  const { stdout } = await runProcess('ffprobe', [
-    '-v', 'error',
-    '-show_entries', 'format=duration',
-    '-of', 'default=noprint_wrappers=1:nokey=1',
-    resolved,
-  ], { name: 'ffprobe duration' });
-
-  const seconds = Number.parseFloat(String(stdout ?? '').trim());
-  if (!Number.isFinite(seconds) || seconds <= 0) {
-    throw new Error(`ffprobe returned invalid duration for ${resolved}`);
-  }
-  return Math.floor(seconds * 1000);
-}
-
-export async function readMediaSpec(inputPath) {
-  const resolved = normalizePath(inputPath, 'input');
-  await ensureReadableFile(resolved, 'input');
-
-  const { stdout } = await runProcess('ffprobe', [
-    '-v', 'error',
-    '-select_streams', 'v:0',
-    '-show_entries', 'stream=width,height,r_frame_rate,pix_fmt,codec_name',
-    '-of', 'json',
-    resolved,
-  ], { name: 'ffprobe spec' });
-
-  let parsed;
-  try {
-    parsed = JSON.parse(stdout);
-  } catch {
-    throw new Error(`Failed to parse ffprobe spec output for ${resolved}`);
-  }
-
-  const stream = parsed?.streams?.[0] ?? {};
-  return {
-    width: Number(stream.width) || null,
-    height: Number(stream.height) || null,
-    frame_rate: String(stream.r_frame_rate ?? ''),
-    pixel_format: String(stream.pix_fmt ?? ''),
-    video_codec: String(stream.codec_name ?? ''),
-  };
-}