Prevent visual looping in Classic render

src/lib/server/serverClipRenderer.ts

@@ -25,7 +25,6 @@ const WORK_DIR = path.join(process.cwd(), '.local-review-data', 'server-renders'
 const VIDEO_WIDTH = 1080;
 const VIDEO_HEIGHT = 1920;
 const VIDEO_FPS = 24;
-const MIN_VIDEO_CLIP_SECONDS = 5;
 const MAX_VIDEO_CLIP_SECONDS = 5;
 const MAX_AUDIO_CLIP_SECONDS = 5;
 const FINAL_VIDEO_MIN_SECONDS = 12;
@@ -213,6 +212,12 @@ function maxSecondsForStep(step: number) {
   return STEP_VIDEO_MAX_SECONDS[step] ?? MAX_VIDEO_CLIP_SECONDS;
 }
 
+function usableClipDuration(source: PreparedClip) {
+  const stepMax = maxSecondsForStep(source.step);
+  if (source.duration > 0) return Math.min(source.duration, stepMax);
+  return stepMax;
+}
+
 function addSegment(segments: VideoSegment[], source: PreparedClip | null, duration: number) {
   if (!source || duration < 0.25) return;
   segments.push({
@@ -221,16 +226,38 @@ function addSegment(segments: VideoSegment[], source: PreparedClip | null, durat
   });
 }
 
+function createClipBudgets(videoClips: PreparedClip[]) {
+  const budgets = new Map<string, number>();
+  for (const clip of videoClips) {
+    budgets.set(clip.path, Math.max(budgets.get(clip.path) ?? 0, usableClipDuration(clip)));
+  }
+  return budgets;
+}
+
+function addSegmentWithBudget(
+  segments: VideoSegment[],
+  budgets: Map<string, number>,
+  source: PreparedClip | null,
+  duration: number,
+) {
+  if (!source || duration < 0.25) return 0;
+
+  const remaining = budgets.get(source.path) ?? usableClipDuration(source);
+  const actualDuration = Math.min(duration, remaining);
+  if (actualDuration < 0.25) return 0;
+
+  budgets.set(source.path, Math.max(0, remaining - actualDuration));
+  addSegment(segments, source, actualDuration);
+  return actualDuration;
+}
+
 function buildLinearSegments(videoClips: PreparedClip[]) {
   const segments: VideoSegment[] = [];
   let remaining = FINAL_VIDEO_MAX_SECONDS;
 
   for (const source of videoClips) {
     if (remaining <= 0.25) break;
-    const stepMax = maxSecondsForStep(source.step);
-    const fallbackDuration = Math.min(MIN_VIDEO_CLIP_SECONDS, stepMax);
-    const sourceDuration =
-      source.duration > 0 ? Math.min(source.duration, stepMax) : fallbackDuration;
+    const sourceDuration = usableClipDuration(source);
     const duration = Math.min(sourceDuration, remaining);
     addSegment(segments, source, duration);
     remaining -= duration;
@@ -255,11 +282,13 @@ function buildVoiceAwareSegments({
   const actionShot = clipByStep(videoClips, 3) ?? videoClips[2] ?? wideShot;
   const reactionShot =
     clipByStep(videoClips, 4) ??
+    videoClips.find((clip) => clip.step >= 6) ??
     (videoClips.length > 3 ? videoClips[videoClips.length - 1]! : null);
 
-  const orderAudio = clipByStep(audioClips, 5) ?? audioClips[0] ?? null;
+  const orderAudio = clipByStep(audioClips, 5) ?? clipByStep(audioClips, 4) ?? audioClips[0] ?? null;
   const likedAudio =
     clipByStep(audioClips, 6) ??
+    clipByStep(audioClips, 5) ??
     audioClips.find((clip) => clip !== orderAudio) ??
     null;
   const recommendationAudio =
@@ -292,20 +321,34 @@ function buildVoiceAwareSegments({
   const likedSeconds = Math.max(0, mainVoiceSeconds - orderSeconds);
 
   const segments: VideoSegment[] = [];
+  const budgets = createClipBudgets(videoClips);
 
   if (closeShot === wideShot || orderSeconds < 2.5) {
-    addSegment(segments, closeShot, orderSeconds);
+    addSegmentWithBudget(segments, budgets, closeShot, orderSeconds);
   } else {
     const closeSeconds = clamp(orderSeconds * 0.58, 1.25, orderSeconds - 0.75);
-    addSegment(segments, closeShot, closeSeconds);
-    addSegment(segments, wideShot, orderSeconds - closeSeconds);
+    addSegmentWithBudget(segments, budgets, closeShot, closeSeconds);
+    addSegmentWithBudget(segments, budgets, wideShot, orderSeconds - closeSeconds);
   }
 
-  addSegment(segments, actionShot, likedSeconds);
-
-  addSegment(segments, wideShot, recommendationSeconds);
-
-  addSegment(segments, reactionShot, reactionSeconds);
+  addSegmentWithBudget(segments, budgets, actionShot, likedSeconds);
+
+  let remainingRecommendationSeconds = recommendationSeconds;
+  remainingRecommendationSeconds -= addSegmentWithBudget(
+    segments,
+    budgets,
+    wideShot,
+    remainingRecommendationSeconds,
+  );
+  remainingRecommendationSeconds -= addSegmentWithBudget(
+    segments,
+    budgets,
+    actionShot,
+    remainingRecommendationSeconds,
+  );
+  addSegmentWithBudget(segments, budgets, closeShot, remainingRecommendationSeconds);
+
+  addSegmentWithBudget(segments, budgets, reactionShot, reactionSeconds);
 
   return segments.length > 0 ? segments : buildLinearSegments(videoClips);
 }
@@ -379,14 +422,15 @@ export async function renderClipsOnServer(input: ServerRenderInput): Promise<Ser
           renderTargetSeconds: voiceoverTargetSeconds,
         })
       : buildLinearSegments(preparedVideoClips);
+    const visualDurationSeconds = videoSegments.reduce(
+      (total, segment) => total + segment.duration,
+      0,
+    );
     const renderTargetSeconds = hasVoiceover
-      ? voiceoverTargetSeconds
+      ? Math.max(1, Math.min(voiceoverTargetSeconds, visualDurationSeconds))
       : Math.max(
           1,
-          Math.min(
-            FINAL_VIDEO_MAX_SECONDS,
-            videoSegments.reduce((total, segment) => total + segment.duration, 0),
-          ),
+          Math.min(FINAL_VIDEO_MAX_SECONDS, visualDurationSeconds),
         );
 
     if (videoSegments.length === 0) {
@@ -395,8 +439,6 @@ export async function renderClipsOnServer(input: ServerRenderInput): Promise<Ser
 
     const inputArgs = [
       ...videoSegments.flatMap((segment) => [
-        '-stream_loop',
-        '-1',
         '-t',
         formatDuration(segment.duration),
         '-i',