@vibeframe/cli 0.27.0

package/src/commands/export.ts

@@ -0,0 +1,918 @@
+import { Command } from "commander";
+import { readFile, access, stat } from "node:fs/promises";
+import { resolve, basename } from "node:path";
+import { spawn } from "node:child_process";
+import chalk from "chalk";
+import ora from "ora";
+import { Project, type ProjectFile } from "../engine/index.js";
+import { execSafe, ffprobeDuration } from "../utils/exec-safe.js";
+
+/**
+ * Resolve project file path - handles both file paths and directory paths
+ * If path is a directory, looks for project.vibe.json inside
+ */
+async function resolveProjectPath(inputPath: string): Promise<string> {
+  const filePath = resolve(process.cwd(), inputPath);
+
+  try {
+    const stats = await stat(filePath);
+    if (stats.isDirectory()) {
+      return resolve(filePath, "project.vibe.json");
+    }
+  } catch {
+    // Path doesn't exist or other error - let readFile handle it
+  }
+
+  return filePath;
+}
+
+/**
+ * Get the duration of a media file using ffprobe
+ * For images, returns a default duration since they have no inherent time
+ */
+export async function getMediaDuration(
+  filePath: string,
+  mediaType: "video" | "audio" | "image",
+  defaultImageDuration: number = 5
+): Promise<number> {
+  if (mediaType === "image") {
+    return defaultImageDuration;
+  }
+
+  try {
+    return await ffprobeDuration(filePath);
+  } catch {
+    return defaultImageDuration;
+  }
+}
+
+/**
+ * Check if a media file has an audio stream
+ */
+export async function checkHasAudio(filePath: string): Promise<boolean> {
+  try {
+    const { stdout } = await execSafe("ffprobe", [
+      "-v", "error", "-select_streams", "a", "-show_entries", "stream=codec_type", "-of", "default=noprint_wrappers=1:nokey=1", filePath,
+    ]);
+    return stdout.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Export result for programmatic usage
+ */
+export interface ExportResult {
+  success: boolean;
+  message: string;
+  outputPath?: string;
+}
+
+/**
+ * Gap filling strategy for timeline gaps
+ * - "black": Fill gaps with black frames (fallback)
+ * - "extend": Extend adjacent clips using source media if available
+ */
+export type GapFillStrategy = "black" | "extend";
+
+/**
+ * Export options
+ */
+export interface ExportOptions {
+  preset?: "draft" | "standard" | "high" | "ultra";
+  format?: "mp4" | "webm" | "mov";
+  overwrite?: boolean;
+  gapFill?: GapFillStrategy;
+}
+
+/**
+ * Reusable export function for programmatic usage
+ */
+export async function runExport(
+  projectPath: string,
+  outputPath: string,
+  options: ExportOptions = {}
+): Promise<ExportResult> {
+  const { preset = "standard", format = "mp4", overwrite = false, gapFill = "extend" } = options;
+
+  try {
+    // Check if FFmpeg is installed
+    const ffmpegPath = await findFFmpeg();
+    if (!ffmpegPath) {
+      return {
+        success: false,
+        message: "FFmpeg not found. Install with: brew install ffmpeg (macOS) or apt install ffmpeg (Linux)",
+      };
+    }
+
+    // Load project
+    const filePath = await resolveProjectPath(projectPath);
+    const content = await readFile(filePath, "utf-8");
+    const data: ProjectFile = JSON.parse(content);
+    const project = Project.fromJSON(data);
+
+    const summary = project.getSummary();
+
+    if (summary.clipCount === 0) {
+      return {
+        success: false,
+        message: "Project has no clips to export",
+      };
+    }
+
+    // Determine output path
+    const finalOutputPath = resolve(process.cwd(), outputPath);
+
+    // Get preset settings
+    const presetSettings = getPresetSettings(preset, summary.aspectRatio);
+
+    // Get clips sorted by start time
+    const clips = project.getClips().sort((a, b) => a.startTime - b.startTime);
+    const sources = project.getSources();
+
+    // Verify source files exist and check for audio streams
+    const sourceAudioMap = new Map<string, boolean>();
+    for (const clip of clips) {
+      const source = sources.find((s) => s.id === clip.sourceId);
+      if (source) {
+        try {
+          await access(source.url);
+          // Check if video source has audio
+          if (source.type === "video" && !sourceAudioMap.has(source.id)) {
+            sourceAudioMap.set(source.id, await checkHasAudio(source.url));
+          }
+        } catch {
+          return {
+            success: false,
+            message: `Source file not found: ${source.url}`,
+          };
+        }
+      }
+    }
+
+    // Build FFmpeg command
+    const ffmpegArgs = buildFFmpegArgs(clips, sources, presetSettings, finalOutputPath, { overwrite, format, gapFill }, sourceAudioMap);
+
+    // Run FFmpeg
+    await runFFmpegProcess(ffmpegPath, ffmpegArgs, () => {});
+
+    return {
+      success: true,
+      message: `Exported: ${outputPath}`,
+      outputPath: finalOutputPath,
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      message: `Export failed: ${errorMessage}`,
+    };
+  }
+}
+
+export const exportCommand = new Command("export")
+  .description("Export project to video file")
+  .argument("<project>", "Project file path")
+  .option("-o, --output <path>", "Output file path")
+  .option("-f, --format <format>", "Output format (mp4, webm, mov)", "mp4")
+  .option(
+    "-p, --preset <preset>",
+    "Quality preset (draft, standard, high, ultra)",
+    "standard"
+  )
+  .option("-y, --overwrite", "Overwrite output file if exists", false)
+  .option("-g, --gap-fill <strategy>", "Gap filling strategy (black, extend)", "extend")
+  .action(async (projectPath: string, options) => {
+    const spinner = ora("Checking FFmpeg...").start();
+
+    try {
+      // Check if FFmpeg is installed
+      const ffmpegPath = await findFFmpeg();
+      if (!ffmpegPath) {
+        spinner.fail(chalk.red("FFmpeg not found"));
+        console.error();
+        console.error(chalk.yellow("Please install FFmpeg:"));
+        console.error(chalk.dim("  macOS:   brew install ffmpeg"));
+        console.error(chalk.dim("  Ubuntu:  sudo apt install ffmpeg"));
+        console.error(chalk.dim("  Windows: winget install ffmpeg"));
+        process.exit(1);
+      }
+
+      // Load project
+      spinner.text = "Loading project...";
+      const filePath = await resolveProjectPath(projectPath);
+      const content = await readFile(filePath, "utf-8");
+      const data: ProjectFile = JSON.parse(content);
+      const project = Project.fromJSON(data);
+
+      const summary = project.getSummary();
+
+      if (summary.clipCount === 0) {
+        spinner.fail(chalk.red("Project has no clips to export"));
+        process.exit(1);
+      }
+
+      // Determine output path
+      const outputPath = options.output
+        ? resolve(process.cwd(), options.output)
+        : resolve(
+            process.cwd(),
+            `${basename(projectPath, ".vibe.json")}.${options.format}`
+          );
+
+      // Get preset settings
+      const presetSettings = getPresetSettings(options.preset, summary.aspectRatio);
+
+      // Get clips sorted by start time
+      const clips = project.getClips().sort((a, b) => a.startTime - b.startTime);
+      const sources = project.getSources();
+
+      // Verify source files exist and check for audio streams
+      spinner.text = "Verifying source files...";
+      const sourceAudioMap = new Map<string, boolean>();
+      for (const clip of clips) {
+        const source = sources.find((s) => s.id === clip.sourceId);
+        if (source) {
+          try {
+            await access(source.url);
+            // Check if video source has audio
+            if (source.type === "video" && !sourceAudioMap.has(source.id)) {
+              sourceAudioMap.set(source.id, await checkHasAudio(source.url));
+            }
+          } catch {
+            spinner.fail(chalk.red(`Source file not found: ${source.url}`));
+            process.exit(1);
+          }
+        }
+      }
+
+      // Build FFmpeg command
+      spinner.text = "Building export command...";
+      const gapFillStrategy = (options.gapFill === "black" ? "black" : "extend") as GapFillStrategy;
+      const ffmpegArgs = buildFFmpegArgs(clips, sources, presetSettings, outputPath, { ...options, gapFill: gapFillStrategy }, sourceAudioMap);
+
+      if (process.env.DEBUG) {
+        console.log("\nFFmpeg command:");
+        console.log("ffmpeg", ffmpegArgs.join(" "));
+        console.log();
+      }
+
+      // Run FFmpeg
+      spinner.text = "Encoding...";
+
+      await runFFmpegProcess(ffmpegPath, ffmpegArgs, (progress) => {
+        spinner.text = `Encoding... ${progress}%`;
+      });
+
+      spinner.succeed(chalk.green(`Exported: ${outputPath}`));
+
+      console.log();
+      console.log(chalk.dim("  Duration:"), `${summary.duration.toFixed(1)}s`);
+      console.log(chalk.dim("  Clips:"), summary.clipCount);
+      console.log(chalk.dim("  Format:"), options.format);
+      console.log(chalk.dim("  Preset:"), options.preset);
+      console.log(chalk.dim("  Resolution:"), presetSettings.resolution);
+      console.log();
+    } catch (error) {
+      spinner.fail(chalk.red("Export failed"));
+      if (error instanceof Error) {
+        console.error(chalk.red(error.message));
+        if (process.env.DEBUG) {
+          console.error(error.stack);
+        }
+      }
+      process.exit(1);
+    }
+  });
+
+/**
+ * Find FFmpeg executable
+ */
+async function findFFmpeg(): Promise<string | null> {
+  try {
+    const { stdout } = await execSafe("which", ["ffmpeg"]);
+    return stdout.trim().split("\n")[0];
+  } catch {
+    try {
+      const { stdout } = await execSafe("where", ["ffmpeg"]);
+      return stdout.trim().split("\n")[0];
+    } catch {
+      return null;
+    }
+  }
+}
+
+/**
+ * Detect gaps in timeline between clips
+ * Returns array of gaps with start and end times
+ */
+function detectTimelineGaps(
+  clips: Array<{ startTime: number; duration: number }>,
+  totalDuration?: number
+): Array<{ start: number; end: number }> {
+  if (clips.length === 0) return [];
+
+  const gaps: Array<{ start: number; end: number }> = [];
+  const sortedClips = [...clips].sort((a, b) => a.startTime - b.startTime);
+
+  // Check for gap at the start (first clip doesn't start at 0)
+  if (sortedClips[0].startTime > 0.001) {
+    gaps.push({ start: 0, end: sortedClips[0].startTime });
+  }
+
+  // Check for gaps between clips
+  for (let i = 0; i < sortedClips.length - 1; i++) {
+    const clipEnd = sortedClips[i].startTime + sortedClips[i].duration;
+    const nextStart = sortedClips[i + 1].startTime;
+    // Allow small tolerance for floating point errors
+    if (nextStart > clipEnd + 0.001) {
+      gaps.push({ start: clipEnd, end: nextStart });
+    }
+  }
+
+  // Check for gap at the end if totalDuration is provided
+  if (totalDuration !== undefined) {
+    const lastClip = sortedClips[sortedClips.length - 1];
+    const lastClipEnd = lastClip.startTime + lastClip.duration;
+    if (totalDuration > lastClipEnd + 0.001) {
+      gaps.push({ start: lastClipEnd, end: totalDuration });
+    }
+  }
+
+  return gaps;
+}
+
+/**
+ * Gap fill plan for a single gap
+ */
+interface GapFillPlan {
+  gap: { start: number; end: number };
+  fills: Array<{
+    type: "extend-before" | "extend-after" | "black";
+    sourceId?: string;
+    sourceUrl?: string;
+    start: number;
+    end: number;
+    sourceStart?: number;
+    sourceEnd?: number;
+  }>;
+}
+
+/**
+ * Create gap fill plans by extending adjacent clips
+ * Priority:
+ * 1. Extend clip AFTER the gap backwards (if sourceStartOffset > 0)
+ * 2. Extend clip BEFORE the gap forwards (if source has unused duration)
+ * 3. Fallback to black frames
+ */
+function createGapFillPlans(
+  gaps: Array<{ start: number; end: number }>,
+  clips: Array<{ startTime: number; duration: number; sourceId: string; sourceStartOffset: number; sourceEndOffset: number }>,
+  sources: Array<{ id: string; url: string; type: string; duration: number }>
+): GapFillPlan[] {
+  const sortedClips = [...clips].sort((a, b) => a.startTime - b.startTime);
+
+  return gaps.map((gap) => {
+    const fills: GapFillPlan["fills"] = [];
+    let remainingStart = gap.start;
+    let remainingEnd = gap.end;
+
+    // Find clip AFTER the gap (for extending backwards)
+    const clipAfter = sortedClips.find((c) => Math.abs(c.startTime - gap.end) < 0.01);
+
+    // Find clip BEFORE the gap (for extending forwards)
+    const clipBefore = sortedClips.find((c) => Math.abs((c.startTime + c.duration) - gap.start) < 0.01);
+
+    // Try extending clip after the gap backwards first
+    if (clipAfter && clipAfter.sourceStartOffset > 0.01) {
+      const source = sources.find((s) => s.id === clipAfter.sourceId);
+      if (source && source.type === "video") {
+        const availableExtension = clipAfter.sourceStartOffset;
+        const extensionDuration = Math.min(availableExtension, remainingEnd - remainingStart);
+
+        if (extensionDuration > 0.01) {
+          // Extend from the gap end backwards
+          const fillStart = remainingEnd - extensionDuration;
+          const sourceStart = clipAfter.sourceStartOffset - extensionDuration;
+          const sourceEnd = clipAfter.sourceStartOffset;
+
+          fills.push({
+            type: "extend-after",
+            sourceId: source.id,
+            sourceUrl: source.url,
+            start: fillStart,
+            end: remainingEnd,
+            sourceStart,
+            sourceEnd,
+          });
+
+          remainingEnd = fillStart;
+        }
+      }
+    }
+
+    // If there's still a gap, try extending clip before the gap forwards
+    if (remainingEnd - remainingStart > 0.01 && clipBefore) {
+      const source = sources.find((s) => s.id === clipBefore.sourceId);
+      if (source && source.type === "video") {
+        const usedEndInSource = clipBefore.sourceEndOffset;
+        const availableExtension = source.duration - usedEndInSource;
+
+        if (availableExtension > 0.01) {
+          const extensionDuration = Math.min(availableExtension, remainingEnd - remainingStart);
+
+          if (extensionDuration > 0.01) {
+            const sourceStart = usedEndInSource;
+            const sourceEnd = usedEndInSource + extensionDuration;
+
+            fills.push({
+              type: "extend-before",
+              sourceId: source.id,
+              sourceUrl: source.url,
+              start: remainingStart,
+              end: remainingStart + extensionDuration,
+              sourceStart,
+              sourceEnd,
+            });
+
+            remainingStart = remainingStart + extensionDuration;
+          }
+        }
+      }
+    }
+
+    // Fill any remaining gap with black
+    if (remainingEnd - remainingStart > 0.01) {
+      fills.push({
+        type: "black",
+        start: remainingStart,
+        end: remainingEnd,
+      });
+    }
+
+    return { gap, fills };
+  });
+}
+
+/**
+ * Build FFmpeg arguments for export
+ */
+function buildFFmpegArgs(
+  clips: ReturnType<Project["getClips"]>,
+  sources: ReturnType<Project["getSources"]>,
+  presetSettings: PresetSettings,
+  outputPath: string,
+  options: { overwrite?: boolean; format?: string; gapFill?: GapFillStrategy },
+  sourceAudioMap: Map<string, boolean> = new Map()
+): string[] {
+  const args: string[] = [];
+
+  // Overwrite flag first
+  if (options.overwrite) {
+    args.push("-y");
+  }
+
+  // Add input files
+  const sourceMap = new Map<string, number>();
+  let inputIndex = 0;
+
+  for (const clip of clips) {
+    const source = sources.find((s) => s.id === clip.sourceId);
+    if (source && !sourceMap.has(source.id)) {
+      // Add -loop 1 before image inputs to create a continuous video stream
+      if (source.type === "image") {
+        args.push("-loop", "1");
+      }
+      args.push("-i", source.url);
+      sourceMap.set(source.id, inputIndex);
+      inputIndex++;
+    }
+  }
+
+  // Build filter complex
+  const filterParts: string[] = [];
+
+  // Separate clips by track type for proper timeline-based export
+  // Get track info to determine clip types
+  const videoClips = clips.filter((clip) => {
+    const source = sources.find((s) => s.id === clip.sourceId);
+    return source && (source.type === "image" || source.type === "video");
+  }).sort((a, b) => a.startTime - b.startTime);
+
+  // Include audio clips from:
+  // 1. Explicit audio sources (narration, music)
+  // 2. Video sources when there are NO separate audio clips (e.g., highlight reels)
+  const explicitAudioClips = clips.filter((clip) => {
+    const source = sources.find((s) => s.id === clip.sourceId);
+    return source && source.type === "audio";
+  }).sort((a, b) => a.startTime - b.startTime);
+
+  // If no explicit audio clips, extract audio from video clips
+  const audioClips = explicitAudioClips.length > 0
+    ? explicitAudioClips
+    : clips.filter((clip) => {
+        const source = sources.find((s) => s.id === clip.sourceId);
+        return source && source.type === "video";
+      }).sort((a, b) => a.startTime - b.startTime);
+
+  // Get target resolution for scaling (all clips must match for concat)
+  const [targetWidth, targetHeight] = presetSettings.resolution.split("x").map(Number);
+
+  // Detect gaps in video timeline
+  // For totalDuration, use the longest audio clip end time if explicit audio exists
+  // (audio is usually the reference for timing in b-roll scenarios)
+  let totalDuration: number | undefined;
+  if (explicitAudioClips.length > 0) {
+    const audioEnd = Math.max(...explicitAudioClips.map(c => c.startTime + c.duration));
+    totalDuration = audioEnd;
+  }
+  const videoGaps = detectTimelineGaps(videoClips, totalDuration);
+
+  // Create gap fill plans based on strategy
+  const gapFillStrategy = options.gapFill || "extend";
+  const gapFillPlans = gapFillStrategy === "extend"
+    ? createGapFillPlans(videoGaps, videoClips, sources)
+    : videoGaps.map((gap) => ({
+        gap,
+        fills: [{ type: "black" as const, start: gap.start, end: gap.end }],
+      }));
+
+  // Build ordered list of video segments (clips and gap fills interleaved)
+  interface VideoSegment {
+    type: 'clip' | 'extended' | 'black';
+    clip?: typeof videoClips[0];
+    sourceId?: string;
+    sourceUrl?: string;
+    startTime: number;
+    duration?: number;
+    sourceStart?: number;
+    sourceEnd?: number;
+  }
+  const videoSegments: VideoSegment[] = [];
+
+  // Add video clips as segments
+  for (const clip of videoClips) {
+    videoSegments.push({ type: 'clip', clip, startTime: clip.startTime });
+  }
+
+  // Add gap fills as segments (from gap fill plans)
+  for (const plan of gapFillPlans) {
+    for (const fill of plan.fills) {
+      if (fill.type === "black") {
+        videoSegments.push({
+          type: 'black',
+          startTime: fill.start,
+          duration: fill.end - fill.start,
+        });
+      } else {
+        // extend-before or extend-after
+        videoSegments.push({
+          type: 'extended',
+          sourceId: fill.sourceId,
+          sourceUrl: fill.sourceUrl,
+          startTime: fill.start,
+          duration: fill.end - fill.start,
+          sourceStart: fill.sourceStart,
+          sourceEnd: fill.sourceEnd,
+        });
+      }
+    }
+  }
+
+  // Sort by start time
+  videoSegments.sort((a, b) => a.startTime - b.startTime);
+
+  // Process video segments (clips, extended clips, and black frames)
+  const videoStreams: string[] = [];
+  let videoStreamIdx = 0;
+
+  for (const segment of videoSegments) {
+    if (segment.type === 'clip' && segment.clip) {
+      const clip = segment.clip;
+      const source = sources.find((s) => s.id === clip.sourceId);
+      if (!source) continue;
+
+      const srcIdx = sourceMap.get(source.id);
+      if (srcIdx === undefined) continue;
+
+      // Video filter chain - images need different handling than video
+      let videoFilter: string;
+      if (source.type === "image") {
+        // Images: trim from 0 to clip duration (no source offset since images are looped)
+        videoFilter = `[${srcIdx}:v]trim=start=0:end=${clip.duration},setpts=PTS-STARTPTS`;
+      } else {
+        // Video: use source offsets
+        const trimStart = clip.sourceStartOffset;
+        const trimEnd = clip.sourceStartOffset + clip.duration;
+        videoFilter = `[${srcIdx}:v]trim=start=${trimStart}:end=${trimEnd},setpts=PTS-STARTPTS`;
+      }
+
+      // Scale to target resolution for concat compatibility (force same size, pad if needed)
+      videoFilter += `,scale=${targetWidth}:${targetHeight}:force_original_aspect_ratio=decrease,pad=${targetWidth}:${targetHeight}:(ow-iw)/2:(oh-ih)/2,setsar=1`;
+
+      // Apply effects
+      for (const effect of clip.effects || []) {
+        if (effect.type === "fadeIn") {
+          videoFilter += `,fade=t=in:st=0:d=${effect.duration}`;
+        } else if (effect.type === "fadeOut") {
+          const fadeStart = clip.duration - effect.duration;
+          videoFilter += `,fade=t=out:st=${fadeStart}:d=${effect.duration}`;
+        }
+      }
+
+      videoFilter += `[v${videoStreamIdx}]`;
+      filterParts.push(videoFilter);
+      videoStreams.push(`[v${videoStreamIdx}]`);
+      videoStreamIdx++;
+    } else if (segment.type === 'extended' && segment.sourceId) {
+      // Extended segment - use source video to fill gap
+      const srcIdx = sourceMap.get(segment.sourceId);
+      if (srcIdx === undefined) {
+        // Fallback to black if source not found in input map
+        const gapFilter = `color=c=black:s=${targetWidth}x${targetHeight}:d=${segment.duration}:r=30,format=yuv420p[v${videoStreamIdx}]`;
+        filterParts.push(gapFilter);
+        videoStreams.push(`[v${videoStreamIdx}]`);
+        videoStreamIdx++;
+        continue;
+      }
+
+      const videoFilter = `[${srcIdx}:v]trim=start=${segment.sourceStart}:end=${segment.sourceEnd},setpts=PTS-STARTPTS,scale=${targetWidth}:${targetHeight}:force_original_aspect_ratio=decrease,pad=${targetWidth}:${targetHeight}:(ow-iw)/2:(oh-ih)/2,setsar=1[v${videoStreamIdx}]`;
+      filterParts.push(videoFilter);
+      videoStreams.push(`[v${videoStreamIdx}]`);
+      videoStreamIdx++;
+    } else if (segment.type === 'black') {
+      // Generate black frame for the gap duration
+      const gapFilter = `color=c=black:s=${targetWidth}x${targetHeight}:d=${segment.duration}:r=30,format=yuv420p[v${videoStreamIdx}]`;
+      filterParts.push(gapFilter);
+      videoStreams.push(`[v${videoStreamIdx}]`);
+      videoStreamIdx++;
+    }
+  }
+
+  // Detect gaps in audio timeline (use same totalDuration for consistency)
+  const audioGaps = detectTimelineGaps(audioClips, totalDuration);
+
+  // Build ordered list of audio segments
+  interface AudioSegment {
+    type: 'clip' | 'gap';
+    clip?: typeof audioClips[0];
+    gap?: { start: number; end: number };
+    startTime: number;
+  }
+  const audioSegments: AudioSegment[] = [];
+
+  // Add audio clips as segments
+  for (const clip of audioClips) {
+    audioSegments.push({ type: 'clip', clip, startTime: clip.startTime });
+  }
+
+  // Add gaps as segments
+  for (const gap of audioGaps) {
+    audioSegments.push({ type: 'gap', gap, startTime: gap.start });
+  }
+
+  // Sort by start time
+  audioSegments.sort((a, b) => a.startTime - b.startTime);
+
+  // Process audio segments (clips and gaps)
+  const audioStreams: string[] = [];
+  let audioStreamIdx = 0;
+
+  for (const segment of audioSegments) {
+    if (segment.type === 'clip' && segment.clip) {
+      const clip = segment.clip;
+      const source = sources.find((s) => s.id === clip.sourceId);
+      if (!source) continue;
+
+      const srcIdx = sourceMap.get(source.id);
+      if (srcIdx === undefined) continue;
+
+      // Check if source has audio (audio sources always have audio, video sources need to be checked)
+      const hasAudio = source.type === "audio" || sourceAudioMap.get(source.id) === true;
+
+      let audioFilter: string;
+      if (hasAudio) {
+        const audioTrimStart = clip.sourceStartOffset;
+        const audioTrimEnd = clip.sourceStartOffset + clip.duration;
+        const sourceDuration = source.duration || 0;
+        const clipDuration = clip.duration;
+
+        if (source.type === "audio" && sourceDuration > clipDuration && audioTrimStart === 0) {
+          // Audio source is longer than clip slot — speed up to fit instead of truncating
+          const tempo = sourceDuration / clipDuration;
+          if (tempo <= 2.0) {
+            // atempo sounds natural up to ~1.3x, acceptable up to 2x
+            audioFilter = `[${srcIdx}:a]atempo=${tempo.toFixed(4)},asetpts=PTS-STARTPTS`;
+          } else {
+            // Too fast would sound bad — fall back to trim
+            audioFilter = `[${srcIdx}:a]atrim=start=${audioTrimStart}:end=${audioTrimEnd},asetpts=PTS-STARTPTS`;
+          }
+        } else {
+          // Normal trim for video-embedded audio, audio that fits, or offset clips
+          audioFilter = `[${srcIdx}:a]atrim=start=${audioTrimStart}:end=${audioTrimEnd},asetpts=PTS-STARTPTS`;
+        }
+      } else {
+        // Source has no audio - generate silence for the clip duration
+        audioFilter = `anullsrc=r=48000:cl=stereo,atrim=0:${clip.duration},asetpts=PTS-STARTPTS`;
+      }
+
+      // Apply audio effects
+      for (const effect of clip.effects || []) {
+        if (effect.type === "fadeIn") {
+          audioFilter += `,afade=t=in:st=0:d=${effect.duration}`;
+        } else if (effect.type === "fadeOut") {
+          const fadeStart = clip.duration - effect.duration;
+          audioFilter += `,afade=t=out:st=${fadeStart}:d=${effect.duration}`;
+        }
+      }
+
+      audioFilter += `[a${audioStreamIdx}]`;
+      filterParts.push(audioFilter);
+      audioStreams.push(`[a${audioStreamIdx}]`);
+      audioStreamIdx++;
+    } else if (segment.type === 'gap' && segment.gap) {
+      // Generate silence for the gap duration
+      const gapDuration = segment.gap.end - segment.gap.start;
+      const audioGapFilter = `anullsrc=r=48000:cl=stereo,atrim=0:${gapDuration},asetpts=PTS-STARTPTS[a${audioStreamIdx}]`;
+      filterParts.push(audioGapFilter);
+      audioStreams.push(`[a${audioStreamIdx}]`);
+      audioStreamIdx++;
+    }
+  }
+
+  // Concatenate video clips
+  if (videoStreams.length > 1) {
+    filterParts.push(
+      `${videoStreams.join("")}concat=n=${videoStreams.length}:v=1:a=0[outv]`
+    );
+  } else if (videoStreams.length === 1) {
+    // Single video clip - just copy
+    filterParts.push(`${videoStreams[0]}copy[outv]`);
+  }
+
+  // Concatenate or mix audio clips
+  if (audioStreams.length > 1) {
+    filterParts.push(
+      `${audioStreams.join("")}concat=n=${audioStreams.length}:v=0:a=1[outa]`
+    );
+  } else if (audioStreams.length === 1) {
+    // Single audio clip - just copy
+    filterParts.push(`${audioStreams[0]}acopy[outa]`);
+  }
+
+  // Add filter complex
+  args.push("-filter_complex", filterParts.join(";"));
+
+  // Map outputs
+  args.push("-map", "[outv]");
+  if (audioStreams.length > 0) {
+    args.push("-map", "[outa]");
+  }
+
+  // Add encoding settings
+  args.push(...presetSettings.ffmpegArgs);
+
+  // Output file
+  args.push(outputPath);
+
+  return args;
+}
+
+/**
+ * Run FFmpeg with progress reporting
+ */
+function runFFmpegProcess(
+  ffmpegPath: string,
+  args: string[],
+  onProgress: (percent: number) => void
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const ffmpeg = spawn(ffmpegPath, args, {
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    let duration = 0;
+    let stderr = "";
+
+    ffmpeg.stderr?.on("data", (data: Buffer) => {
+      const output = data.toString();
+      stderr += output;
+
+      // Parse duration
+      const durationMatch = output.match(/Duration: (\d+):(\d+):(\d+\.\d+)/);
+      if (durationMatch) {
+        const [, hours, minutes, seconds] = durationMatch;
+        duration =
+          parseInt(hours) * 3600 +
+          parseInt(minutes) * 60 +
+          parseFloat(seconds);
+      }
+
+      // Parse progress
+      const timeMatch = output.match(/time=(\d+):(\d+):(\d+\.\d+)/);
+      if (timeMatch && duration > 0) {
+        const [, hours, minutes, seconds] = timeMatch;
+        const currentTime =
+          parseInt(hours) * 3600 +
+          parseInt(minutes) * 60 +
+          parseFloat(seconds);
+        const percent = Math.min(100, Math.round((currentTime / duration) * 100));
+        onProgress(percent);
+      }
+    });
+
+    ffmpeg.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        // Extract error message
+        const errorMatch = stderr.match(/Error.*$/m);
+        const errorMsg = errorMatch ? errorMatch[0] : `FFmpeg exited with code ${code}`;
+        reject(new Error(errorMsg));
+      }
+    });
+
+    ffmpeg.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+
+interface PresetSettings {
+  resolution: string;
+  videoBitrate: string;
+  audioBitrate: string;
+  ffmpegArgs: string[];
+}
+
+function getPresetSettings(
+  preset: string,
+  aspectRatio: string
+): PresetSettings {
+  const presets: Record<string, PresetSettings> = {
+    draft: {
+      resolution: "640x360",
+      videoBitrate: "1M",
+      audioBitrate: "128k",
+      ffmpegArgs: [
+        "-c:v", "libx264",
+        "-preset", "ultrafast",
+        "-crf", "28",
+        "-c:a", "aac",
+        "-b:a", "128k",
+      ],
+    },
+    standard: {
+      resolution: "1280x720",
+      videoBitrate: "4M",
+      audioBitrate: "192k",
+      ffmpegArgs: [
+        "-c:v", "libx264",
+        "-preset", "medium",
+        "-crf", "23",
+        "-c:a", "aac",
+        "-b:a", "192k",
+      ],
+    },
+    high: {
+      resolution: "1920x1080",
+      videoBitrate: "8M",
+      audioBitrate: "256k",
+      ffmpegArgs: [
+        "-c:v", "libx264",
+        "-preset", "slow",
+        "-crf", "18",
+        "-c:a", "aac",
+        "-b:a", "256k",
+      ],
+    },
+    ultra: {
+      resolution: "3840x2160",
+      videoBitrate: "20M",
+      audioBitrate: "320k",
+      ffmpegArgs: [
+        "-c:v", "libx264",
+        "-preset", "slow",
+        "-crf", "15",
+        "-c:a", "aac",
+        "-b:a", "320k",
+      ],
+    },
+  };
+
+  // Adjust resolution for aspect ratio
+  const settings = { ...presets[preset] || presets.standard };
+
+  if (aspectRatio === "9:16") {
+    // Vertical video
+    const [w, h] = settings.resolution.split("x");
+    settings.resolution = `${h}x${w}`;
+  } else if (aspectRatio === "1:1") {
+    // Square video
+    const h = settings.resolution.split("x")[1];
+    settings.resolution = `${h}x${h}`;
+  }
+
+  return settings;
+}