Update app.py

app.py

@@ -1,5 +1,4 @@
 
-
 from kokoro import KPipeline
 
 import soundfile as sf
@@ -15,7 +14,7 @@ import cv2
 import math
 import os, requests, io, time, re, random
 from moviepy.editor import (
-    VideoFileClip, concatenate_videoclips, AudioFileClip, ImageClip,
+    VideoFileFileClip, concatenate_videoclips, AudioFileClip, ImageClip,
     CompositeVideoClip, TextClip, CompositeAudioClip
 )
 import moviepy.video.fx.all as vfx
@@ -33,12 +32,17 @@ from urllib.parse import quote
 from gtts import gTTS
 import gradio as gr  # Import Gradio
 import shutil # Needed for temp folder cleanup
+import subprocess # Needed for sudo commands in fix_imagemagick_policy
+
 
 # Initialize Kokoro TTS pipeline (using American English)
 # Ensure you have the required voice models downloaded for Kokoro if needed,
 # or it will fall back to gTTS. 'a' for American English uses voice 'af_heart'.
+# Add a flag to check if Kokoro initialized successfully
+kokoro_initialized = False
 try:
     pipeline = KPipeline(lang_code='a')
+    kokoro_initialized = True
     print("Kokoro TTS pipeline initialized.")
 except Exception as e:
     print(f"Warning: Could not initialize Kokoro TTS pipeline: {e}. Will rely on gTTS.")
@@ -51,11 +55,30 @@ except Exception as e:
 # Common paths: "/usr/bin/convert", "/usr/local/bin/convert", "C:\\Program Files\\ImageMagick-X.Y.Z-Q16\\convert.exe"
 # You might need to adjust this based on your OS and installation
 IMAGEMAGICK_BINARY_PATH = "/usr/bin/convert" # Default path, check your system
-if not os.path.exists(IMAGEMAGICK_BINARY_PATH):
-     print(f"Warning: ImageMagick binary not found at {IMAGEMAGICK_BINARY_PATH}. TextClip may not work.")
-     print("Please install ImageMagick or update the IMAGEMAGICK_BINARY_PATH.")
-
-mpy_config.change_settings({"IMAGEMAGICK_BINARY": IMAGEMAGICK_BINARY_PATH})
+# Add more common paths to check
+common_imagemagick_paths = [
+    "/usr/bin/convert",
+    "/usr/local/bin/convert",
+    "/opt/homebrew/bin/convert", # Homebrew on macOS ARM
+    "/usr/local/opt/imagemagick/bin/convert", # Older Homebrew
+    "C:\\Program Files\\ImageMagick-X.Y.Z-Q16\\convert.exe", # Windows example, adjust version
+    # Add other paths as needed for your environment
+]
+
+found_imagemagick_binary = None
+for path in common_imagemagick_paths:
+    if os.path.exists(path):
+        found_imagemagick_binary = path
+        break
+
+if found_imagemagick_binary:
+     print(f"Found ImageMagick binary at: {found_imagemagick_binary}")
+     mpy_config.change_settings({"IMAGEMAGICK_BINARY": found_imagemagick_binary})
+else:
+     print("Warning: ImageMagick binary 'convert' not found in common locations.")
+     print("TextClip may fail. Please install ImageMagick or update the IMAGICK_BINARY setting if it's installed elsewhere.")
+     # Still try to set a default path, though it might be wrong
+     mpy_config.change_settings({"IMAGEMAGICK_BINARY": IMAGEMAGICK_BINARY_PATH})
 
 
 # ---------------- Global Configuration ---------------- #
@@ -67,7 +90,7 @@ OUTPUT_VIDEO_FILENAME = "final_video.mp4"
 USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
 
 # Maximum number of script segments to display for editing
-MAX_SEGMENTS_FOR_EDITING = 15
+MAX_SEGMENTS_FOR_EDITING = 15 # Limit for UI manageability
 
 # Global placeholder for the temporary folder, will be created per run
 TEMP_FOLDER = None
@@ -259,7 +282,7 @@ def search_pexels_videos(query):
     for page in range(1, num_pages + 1):
         for attempt in range(max_retries):
             try:
-                params = {"query": search_query, "per_page": videos_per_page, "page": page}
+                params = {"query": search_query, "per_page": videos_per_page, "page": page, "orientation": "landscape"} # Added orientation
                 response = requests.get(base_url, headers=headers, params=params, timeout=10)
 
                 if response.status_code == 200:
@@ -271,16 +294,22 @@ def search_pexels_videos(query):
                     other_videos_on_page = []
                     for video in videos:
                         video_files = video.get("video_files", [])
-                        for file in video_files:
-                            if file.get("quality") == "hd":
-                                hd_videos_on_page.append(file.get("link"))
-                                break # Found HD, move to next video file for this video entry
-                            # Collect other qualities just in case no HD is found on this page or in total
-                            other_videos_on_page.append(file.get("link"))
-
+                        # Sort video files by quality preference if possible
+                        video_files_sorted = sorted(video_files, key=lambda x: {'hd': 0, 'sd': 1}.get(x.get('quality'), 2))
+
+                        for file in video_files_sorted:
+                             link = file.get("link")
+                             quality = file.get("quality")
+                             if link:
+                                 if quality == "hd":
+                                     hd_videos_on_page.append(link)
+                                     break # Found the best quality for this video entry
+                                 else:
+                                     other_videos_on_page.append(link)
+                                     # Don't break, keep looking for HD for this video entry
 
                     all_videos.extend(hd_videos_on_page) # Add HD videos found
-                    if not hd_videos_on_page: # If no HD found on this page, add other videos
+                    if not hd_videos_on_page: # If no HD found on this page, add other videos found on this page
                          all_videos.extend(other_videos_on_page)
 
                     if not videos:
@@ -424,7 +453,7 @@ def download_image(image_url, filename):
 
     try:
         headers = {"User-Agent": USER_AGENT}
-        print(f"Attempting to download image from: {image_url}")
+        # print(f"Attempting to download image from: {image_url}") # Keep less noisy
         response = requests.get(image_url, headers=headers, stream=True, timeout=20) # Increased timeout
         response.raise_for_status()
 
@@ -619,6 +648,12 @@ def generate_silent_audio(duration, sample_rate=24000):
     num_samples = int(duration * sample_rate)
     silence = np.zeros(num_samples, dtype=np.float32)
     # Use unique filename to avoid conflicts
+    # Ensure TEMP_FOLDER exists before generating path
+    if not TEMP_FOLDER:
+         print("Error: TEMP_FOLDER not set for generate_silent_audio.")
+         return None
+    os.makedirs(TEMP_FOLDER, exist_ok=True)
+
     silent_path = os.path.join(TEMP_FOLDER, f"silent_{abs(hash(duration)) % (10**8)}_{int(time.time())}.wav")
     try:
         sf.write(silent_path, silence, sample_rate)
@@ -638,6 +673,10 @@ def generate_tts(text, voice='en'):
         print("TTS text is empty. Generating silent audio.")
         return generate_silent_audio(duration=2.0) # Default silence for empty text
 
+    if not TEMP_FOLDER:
+        print("Error: TEMP_FOLDER not set for generate_tts.")
+        return generate_silent_audio(duration=max(2.0, len(text.split()) * 0.4))
+
     os.makedirs(TEMP_FOLDER, exist_ok=True) # Ensure temp folder exists
     safe_text_hash = str(abs(hash(text)) % (10**10)) # Use a hash for potentially long text
     file_path = os.path.join(TEMP_FOLDER, f"tts_{safe_text_hash}.wav")
@@ -649,7 +688,8 @@ def generate_tts(text, voice='en'):
     # Estimate duration based on word count (adjust factor as needed), used if TTS fails
     target_duration_fallback = max(2.0, len(text.split()) * 0.4)
 
-    if pipeline:
+    # Use the global kokoro_initialized flag
+    if kokoro_initialized and pipeline:
         try:
             print(f"Attempting Kokoro TTS for text: '{text[:50]}...'")
             kokoro_voice = 'af_heart' if voice == 'en' else voice # Kokoro default American English voice
@@ -657,9 +697,16 @@ def generate_tts(text, voice='en'):
             generator = pipeline(text, voice=kokoro_voice, speed=1.0, split_pattern=r'\n+') # Use speed 1.0
             audio_segments = []
             total_duration = 0
+            # Iterate through the generator, but add a timeout to prevent infinite loops
+            start_time = time.time()
+            timeout = 30 # seconds per segment generation attempt
             for i, (gs, ps, audio) in enumerate(generator):
+                if time.time() - start_time > timeout:
+                    print(f"Kokoro TTS timed out after {timeout}s for text segment {i}.")
+                    break # Exit loop on timeout
                 audio_segments.append(audio)
                 total_duration += len(audio) / 24000.0 # Assuming 24000 Hz sample rate
+            
             if audio_segments:
                 full_audio = np.concatenate(audio_segments) if len(audio_segments) > 1 else audio_segments[0]
                 sf.write(file_path, full_audio, 24000) # Use 24000Hz standard
@@ -721,84 +768,31 @@ def apply_kenburns_effect(clip, target_resolution, effect_type=None):
     # Define start and end positions of the top-left corner of the target_resolution window
     start_x, start_y = 0, 0
     end_x, end_y = 0, 0
-    start_zoom_factor = 1.0 # Relative to the scaled image size
-    end_zoom_factor = 1.0
+    start_zoom_relative = 1.0 # Relative to target_resolution size
+    end_zoom_relative = 1.0
 
-    # Set start/end positions based on effect type. Positions are top-left corner of the target frame within the scaled image.
+    # Set start/end positions and zoom based on effect type.
+    # Positions are top-left corner of the target frame within the scaled image coordinates (new_width, new_height).
     if effect_type == "zoom-in":
-        start_zoom_factor = 1.0 # Starts covering the entire scaled image
-        end_zoom_factor = scale_factor # Zooms to cover the original image size within the scaled frame
-        # Stay centered
-        start_x = max_offset_x / 2 # Top-left of the original image center
+        start_zoom_relative = 1.0 # Start covering target_resolution size
+        end_zoom_relative = scale_factor # End covering target_resolution / scale_factor size (zoomed in)
+        # Stay centered in the *scaled* image
+        start_x = max_offset_x / 2
         start_y = max_offset_y / 2
         end_x = max_offset_x / 2
         end_y = max_offset_y / 2
-        # Note: The zoom factor here is relative to the FINAL frame size during the effect,
-        # which is `target_resolution`. A zoom factor of 1 means crop size is `target_resolution`.
-        # A zoom factor of `scale_factor` means crop size is `target_resolution / scale_factor`.
-        # Let's redefine zoom factors to be relative to target_resolution for clarity
-        start_zoom_relative = 1.0 # Start at target size
-        end_zoom_relative = scale_factor # End zoomed in by scale factor
-
-        def get_crop_size(zoom_relative):
-             return int(target_w / zoom_relative), int(target_h / zoom_relative)
-
-        # Adjust start/end positions to match the changing crop size to keep the center aligned
-        def get_current_center(t):
-             progress = t / clip.duration if clip.duration > 0 else 0
-             eased_progress = 0.5 - 0.5 * math.cos(math.pi * progress)
-             current_zoom_relative = start_zoom_relative + (end_zoom_relative - start_zoom_relative) * eased_progress
-             current_crop_w, current_crop_h = get_crop_size(current_zoom_relative)
-             # Center position in the scaled image coordinates
-             center_x = new_width / 2
-             center_y = new_height / 2
-             return center_x, center_y, current_crop_w, current_crop_h
-
-        def transform_frame_zoom(get_frame, t):
-            frame = get_frame(t)
-            center_x, center_y, crop_w, crop_h = get_current_center(t)
-            # Ensure center stays within bounds
-            center_x = max(crop_w / 2, min(center_x, new_width - crop_w / 2))
-            center_y = max(crop_h / 2, min(center_y, new_height - crop_h / 2))
-            cropped_frame = cv2.getRectSubPix(frame, (crop_w, crop_h), (center_x, center_y))
-            resized_frame = cv2.resize(cropped_frame, (target_w, target_h), interpolation=cv2.INTER_LANCZOS4)
-            return resized_frame
-
-        return clip.fl(transform_frame_zoom)
-
 
     elif effect_type == "zoom-out":
         start_zoom_relative = scale_factor # Start zoomed in
-        end_zoom_relative = 1.0 # End at target size
-
-        def get_crop_size(zoom_relative):
-             return int(target_w / zoom_relative), int(target_h / zoom_relative)
-
-        def get_current_center(t):
-             progress = t / clip.duration if clip.duration > 0 else 0
-             eased_progress = 0.5 - 0.5 * math.cos(math.pi * progress)
-             current_zoom_relative = start_zoom_relative + (end_zoom_relative - start_zoom_relative) * eased_progress
-             current_crop_w, current_crop_h = get_crop_size(current_zoom_relative)
-             center_x = new_width / 2
-             center_y = new_height / 2
-             return center_x, center_y, current_crop_w, current_crop_h
-
-        def transform_frame_zoom(get_frame, t):
-            frame = get_frame(t)
-            center_x, center_y, crop_w, crop_h = get_current_center(t)
-            center_x = max(crop_w / 2, min(center_x, new_width - crop_w / 2))
-            center_y = max(crop_h / 2, min(center_y, new_height - crop_h / 2))
-            cropped_frame = cv2.getRectSubPix(frame, (crop_w, crop_h), (center_x, center_y))
-            resized_frame = cv2.resize(cropped_frame, (target_w, target_h), interpolation=cv2.INTER_LANCZOS4)
-            return resized_frame
-
-        return clip.fl(transform_frame_zoom)
-
-    # For pan effects, the crop size is constant (target_resolution)
-    # We just interpolate the top-left corner position
-    crop_w, crop_h = target_w, target_h
+        end_zoom_relative = 1.0 # End at target_resolution size
+        # Stay centered in the *scaled* image
+        start_x = max_offset_x / 2
+        start_y = max_offset_y / 2
+        end_x = max_offset_x / 2
+        end_y = max_offset_y / 2
 
-    if effect_type == "pan-left":
+    # For pan effects, the crop size is constant (target_resolution, which corresponds to zoom_relative=1.0)
+    elif effect_type == "pan-left":
         start_x = max_offset_x
         start_y = max_offset_y / 2
         end_x = 0
@@ -838,13 +832,21 @@ def apply_kenburns_effect(clip, target_resolution, effect_type=None):
          print(f"Warning: Unexpected effect type '{effect_type}'. Defaulting to 'pan-right'.")
 
 
-    def transform_frame_pan(get_frame, t):
+    def transform_frame(get_frame, t):
         frame = get_frame(t)
         # Use a smooth ease-in/ease-out function
         progress = t / clip.duration if clip.duration > 0 else 0
         eased_progress = 0.5 - 0.5 * math.cos(math.pi * progress) # Cosine easing
 
-        # Interpolate position (top-left corner of the target frame)
+        # Interpolate zoom relative to target_resolution
+        current_zoom_relative = start_zoom_relative + (end_zoom_relative - start_zoom_relative) * eased_progress
+
+        # Calculate crop size based on current zoom relative to target resolution
+        # If zoom_relative is 1, crop size is target_resolution. If zoom_relative is scale_factor, crop size is target_resolution/scale_factor
+        crop_w = int(target_w / current_zoom_relative)
+        crop_h = int(target_h / current_zoom_relative)
+
+        # Interpolate position (top-left corner of the target frame within the scaled image)
         current_x = start_x + (end_x - start_x) * eased_progress
         current_y = start_y + (end_y - start_y) * eased_progress
 
@@ -852,27 +854,24 @@ def apply_kenburns_effect(clip, target_resolution, effect_type=None):
         center_x = current_x + crop_w / 2
         center_y = current_y + crop_h / 2
 
-        # Ensure center stays within the bounds of the scaled image
+        # Ensure center stays within the bounds of the scaled image (new_width, new_height)
         center_x = max(crop_w / 2, min(center_x, new_width - crop_w / 2))
         center_y = max(crop_h / 2, min(center_y, new_height - crop_h / 2))
 
-
         try:
             # Perform the crop using cv2.getRectSubPix (expects floating point center)
             # Ensure frame is a numpy array (moviepy returns numpy arrays)
-            # Clamp coordinates to avoid errors on edges
-            # Note: cv2.getRectSubPix handles bounds clipping internally, but explicit checks can prevent NaNs
+            # Clamp center coordinates just in case, although max/min should handle it
             center_x = np.clip(center_x, 0, new_width)
             center_y = np.clip(center_y, 0, new_height)
 
+            # Ensure crop dimensions are positive integers
+            crop_w = max(1, crop_w)
+            crop_h = max(1, crop_h)
+
+
             cropped_frame = cv2.getRectSubPix(frame, (crop_w, crop_h), (center_x, center_y))
-            # Resize the cropped frame back to the target resolution (should already be target_resolution size)
-            # This resize is actually redundant if crop_w, crop_h == target_w, target_h
-            # but might be needed if bounds clipping changed effective size slightly?
-            # Let's remove the resize if crop size == target size for efficiency
-            # if (crop_w, crop_h) == (target_w, target_h):
-            #     resized_frame = cropped_frame # No need to resize
-            # else:
+            # Resize the cropped frame back to the target resolution
             resized_frame = cv2.resize(cropped_frame, (target_w, target_h), interpolation=cv2.INTER_LANCZOS4)
 
             return resized_frame
@@ -882,8 +881,8 @@ def apply_kenburns_effect(clip, target_resolution, effect_type=None):
              return np.zeros((target_h, target_w, 3), dtype=np.uint8)
 
 
-    # Apply the panning transform
-    return clip.fl(transform_frame_pan)
+    # Apply the transformation function
+    return clip.fl(transform_frame)
 
 
 def resize_to_fill(clip, target_resolution):
@@ -901,6 +900,8 @@ def resize_to_fill(clip, target_resolution):
         # Ensure crop coordinates are integers
         x1 = int(crop_amount_x)
         x2 = int(clip.w - crop_amount_x)
+        # Handle potential edge cases with integer rounding
+        x2 = max(x1 + 1, x2) # Ensure at least 1 pixel width if needed
         clip = clip.crop(x1=x1, x2=x2, y1=0, y2=clip.h)
     else: # Clip is taller than target or same aspect
         clip = clip.resize(width=target_w)
@@ -909,6 +910,8 @@ def resize_to_fill(clip, target_resolution):
         # Ensure crop coordinates are integers
         y1 = int(crop_amount_y)
         y2 = int(clip.h - crop_amount_y)
+         # Handle potential edge cases with integer rounding
+        y2 = max(y1 + 1, y2) # Ensure at least 1 pixel height if needed
         clip = clip.crop(x1=0, x2=clip.w, y1=y1, y2=y2)
 
     # Final check and resize if dimensions are slightly off due to rounding
@@ -928,13 +931,15 @@ def find_mp3_files():
         for file in files:
             if file.lower().endswith('.mp3'):
                 mp3_path = os.path.join(root, file)
-                mp3_files.append(mp3_path)
-                print(f"Found MP3 file: {mp3_path}")
+                # Exclude files that are likely temporary or part of internal libraries
+                if not any(keyword in mp3_path for keyword in ['temp', '.gradio', 'site-packages', 'dist-packages', 'venv']):
+                    mp3_files.append(mp3_path)
+                    print(f"Found MP3 file: {mp3_path}")
 
     if mp3_files:
-        return mp3_files[0] # Return the first one found
+        return mp3_files[0] # Return the first one found that isn't excluded
     else:
-        # print("No MP3 files found in the current directory or subdirectories.") # Keep less noisy
+        # print("No user-provided MP3 files found in the current directory or subdirectories.") # Keep less noisy
         return None
 
 
@@ -945,7 +950,7 @@ def add_background_music(final_video, bg_music_path, bg_music_volume=0.08):
         return final_video
 
     try:
-        print(f"Adding background music from: {bg_music_path}")
+        print(f"Adding background music from: {bg_music_path} with volume {bg_music_volume}")
         bg_music = AudioFileClip(bg_music_path)
 
         # Loop background music if shorter than video
@@ -968,8 +973,12 @@ def add_background_music(final_video, bg_music_path, bg_music_volume=0.08):
         if video_audio:
             # Ensure video audio matches video duration before compositing
             if abs(video_audio.duration - final_video.duration) > 0.1:
-                 print(f"Adjusting video audio duration ({video_audio.duration:.2f}s) to match video duration ({final_video.duration:.2f}s)")
-                 video_audio = video_audio.fx(vfx.speedx, factor=video_audio.duration / final_video.duration)
+                 print(f"Adjusting video audio duration ({video_audio.duration:.2f}s) to match video duration ({final_video.duration:.2f}s) for final mix")
+                 try:
+                    video_audio = video_audio.fx(vfx.speedx, factor=video_audio.duration / final_video.duration)
+                 except Exception as e:
+                      print(f"Error adjusting final video audio speed: {e}. Using original audio.")
+                      pass # Proceed with original audio if speedx fails
 
             mixed_audio = CompositeAudioClip([video_audio, bg_music])
             # print("Composited video audio and background music") # Keep less noisy
@@ -1015,9 +1024,9 @@ def create_clip(media_asset, tts_path, estimated_duration, target_resolution,
                  target_clip_duration = estimated_duration # Fallback to estimated duration
 
 
-        # Handle missing media first
+        # Handle missing or invalid media first
         if not media_path or not os.path.exists(media_path):
-            print(f"Skipping clip {segment_index}: Missing media file {media_path}")
+            print(f"Skipping clip {segment_index}: Missing or invalid media file {media_path}")
             # Create a black clip with silent audio for the target duration
             clip = ColorClip(size=target_resolution, color=(0,0,0), duration=target_clip_duration)
             print(f"Created placeholder black clip for segment {segment_index}")
@@ -1047,8 +1056,8 @@ def create_clip(media_asset, tts_path, estimated_duration, target_resolution,
                          silent_audio_clip = silent_audio_clip.fx(vfx.speedx, factor=silent_audio_clip.duration / clip.duration)
                     clip = clip.set_audio(silent_audio_clip)
                 except Exception as e:
-                     print(f"Error adding silent audio to placeholder clip {segment_index}: {e}")
-                     clip = clip.set_audio(None) # Set audio to None if silent audio fails
+                     print(f"Error setting silent audio to placeholder clip {segment_index}: {e}")
+                     clip = clip.set_audio(None) # Set audio to None if silent audio fails loading
             else:
                  clip = clip.set_audio(None) # Set audio to None if silent audio generation fails
 
@@ -1170,62 +1179,79 @@ def create_clip(media_asset, tts_path, estimated_duration, target_resolution,
         if caption_enabled and narration_text and caption_color.lower() != "transparent" and narration_text.strip():
             try:
                 # Determine total audio duration (using actual if available, else estimated)
-                actual_audio_duration_for_subtitles = audio_duration if audio_clip else target_clip_duration
-
-                # Simple word-based chunking for subtitles
-                words = narration_text.split()
-                # Calculate average word duration based on total audio duration and word count
-                # This is a simple approach; for better sync, use a forced aligner (more complex)
-                total_words = len(words)
-                average_word_duration = actual_audio_duration_for_subtitles / total_words if total_words > 0 else 0.5 # Default if no words
-
-                subtitle_clips = []
-                current_time = 0
-                chunk_size = 6 # Words per caption chunk (adjust as needed for readability)
-
-                for i in range(0, total_words, chunk_size):
-                    chunk_words = words[i:i+chunk_size]
-                    chunk_text = ' '.join(chunk_words)
-                    # Estimate chunk duration based on word count * average word duration
-                    estimated_chunk_duration = len(chunk_words) * average_word_duration
-
-                    start_time = current_time
-                    # Ensure end time doesn't exceed the *clip* duration
-                    end_time = min(current_time + estimated_chunk_duration, clip.duration)
-                    if start_time >= end_time: break # Avoid 0 or negative duration clips
-
-                    # Determine vertical position
-                    if caption_position == "Top":
-                         subtitle_y_position = int(target_resolution[1] * 0.05) # Slightly lower than top edge
-                    elif caption_position == "Middle":
-                         subtitle_y_position = int(target_resolution[1] * 0.5) - int(caption_size * 1.2 / 2) # Center adjusted for text height
-                    else: # Default to Bottom
-                         subtitle_y_position = int(target_resolution[1] * 0.9) - int(caption_size * 1.2) # Slightly higher than bottom edge, accounting for multiple lines
-
-
-                    txt_clip = TextClip(
-                        chunk_text,
-                        fontsize=caption_size,
-                        font='Arial-Bold', # Ensure this font is available or use a common system font
-                        color=caption_color,
-                        bg_color=caption_bg_color, # Use background color
-                        method='caption', # Enables text wrapping
-                        align='center',
-                        stroke_width=caption_stroke_width, # Use stroke
-                        stroke_color=caption_stroke_color, # Use stroke color
-                        size=(target_resolution[0] * 0.9, None) # Caption width max 90% of video width
-                    ).set_start(start_time).set_end(end_time)
-
-                    # Position is tuple ('center', y_position)
-                    txt_clip = txt_clip.set_position(('center', subtitle_y_position))
-                    subtitle_clips.append(txt_clip)
-                    current_time = end_time # Move to the end of the current chunk
-
-                if subtitle_clips:
-                    clip = CompositeVideoClip([clip] + subtitle_clips)
-                    # print(f"Added {len(subtitle_clips)} subtitle chunks to clip {segment_index}.") # Keep less noisy
-                # else:
-                     # print(f"No subtitle clips generated for segment {segment_index} (might be due to text/duration issues).") # Keep less noisy
+                # Use clip.duration for subtitle timing as the clip's duration is final
+                actual_clip_duration_for_subtitles = clip.duration
+                if actual_clip_duration_for_subtitles <= 0:
+                     print(f"Clip duration is zero or negative for segment {segment_index}, cannot add subtitles.")
+                else:
+                    # Simple word-based chunking for subtitles
+                    words = narration_text.split()
+                    # Calculate average word duration based on clip duration and word count
+                    total_words = len(words)
+                    average_word_duration = actual_clip_duration_for_subtitles / total_words if total_words > 0 else 0.5 # Default if no words
+
+                    subtitle_clips = []
+                    current_time = 0
+                    chunk_size = 6 # Words per caption chunk (adjust as needed for readability)
+
+                    for i in range(0, total_words, chunk_size):
+                        chunk_words = words[i:i+chunk_size]
+                        chunk_text = ' '.join(chunk_words)
+                        # Estimate chunk duration based on word count * average word duration
+                        estimated_chunk_duration = len(chunk_words) * average_word_duration
+
+                        start_time = current_time
+                        # Ensure end time doesn't exceed the *clip* duration
+                        end_time = min(current_time + estimated_chunk_duration, clip.duration)
+                        if start_time >= end_time: break # Avoid 0 or negative duration clips
+
+                        # Determine vertical position
+                        if caption_position == "Top":
+                             subtitle_y_position = int(target_resolution[1] * 0.05) # Slightly lower than top edge
+                        elif caption_position == "Middle":
+                             # Calculate vertical center, then subtract half the estimated text height
+                             # Estimate text height based on font size and number of lines (adjust factor as needed)
+                             estimated_text_lines = math.ceil(len(chunk_words) / chunk_size) # Crude estimate
+                             estimated_total_text_height = estimated_text_lines * caption_size * 1.2 # 1.2 is line spacing approx
+                             subtitle_y_position = int(target_resolution[1] * 0.5) - int(estimated_total_text_height / 2)
+                             # Ensure position is not off-screen
+                             subtitle_y_position = max(0, subtitle_y_position)
+                        else: # Default to Bottom
+                             # Position from the bottom edge
+                             subtitle_y_position = int(target_resolution[1] * 0.9) # Start near bottom
+                             # Note: moviepy positions text relative to the top-left of the *text box*.
+                             # To place the bottom of the text at a certain point, this requires more complex calculation
+                             # based on actual text height, which is hard to get before rendering.
+                             # The current 'bottom' positioning puts the *top* of the text box at ~90% down.
+                             # A simpler approach for "Bottom" is positioning the text box bottom at a fixed Y.
+                             # Let's stick to positioning the top-left of the text box for simplicity with moviepy's TextClip position.
+                             # positioning the top-left of the text box at 85% of height often looks good for bottom captions.
+                             subtitle_y_position = int(target_resolution[1] * 0.85) # Top-left of text box is at 85% height
+
+
+                        txt_clip = TextClip(
+                            chunk_text,
+                            fontsize=caption_size,
+                            font='Arial-Bold', # Ensure this font is available or use a common system font
+                            color=caption_color,
+                            bg_color=caption_bg_color, # Use background color
+                            method='caption', # Enables text wrapping
+                            align='center',
+                            stroke_width=caption_stroke_width, # Use stroke
+                            stroke_color=caption_stroke_color, # Use stroke color
+                            size=(target_resolution[0] * 0.9, None) # Caption width max 90% of video width
+                        ).set_start(start_time).set_end(end_time)
+
+                        # Position is tuple ('center', y_position)
+                        txt_clip = txt_clip.set_position(('center', subtitle_y_position))
+                        subtitle_clips.append(txt_clip)
+                        current_time = end_time # Move to the end of the current chunk
+
+                    if subtitle_clips:
+                        clip = CompositeVideoClip([clip] + subtitle_clips)
+                        # print(f"Added {len(subtitle_clips)} subtitle chunks to clip {segment_index}.") # Keep less noisy
+                    # else:
+                         # print(f"No subtitle clips generated for segment {segment_index} (might be due to text/duration issues).") # Keep less noisy
 
 
             except Exception as sub_error:
@@ -1243,22 +1269,23 @@ def create_clip(media_asset, tts_path, estimated_duration, target_resolution,
                         stroke_width=caption_stroke_width,
                         stroke_color=caption_stroke_color,
                         size=(target_resolution[0] * 0.8, None)
-                    ).set_position(('center', int(target_resolution[1] * 0.75))).set_duration(clip.duration)
+                    ).set_position(('center', int(target_resolution[1] * 0.75))).set_duration(clip.duration) # Position slightly above bottom
                     clip = CompositeVideoClip([clip, txt_clip])
                     print(f"Added simple fallback subtitle for segment {segment_index}.")
                 except Exception as fallback_sub_error:
                     print(f"Simple fallback subtitle failed for segment {segment_index}: {fallback_sub_error}")
 
 
-        # Ensure final clip duration is explicitly set
-        clip = clip.set_duration(clip.duration)
+        # Ensure final clip duration is explicitly set (already done earlier based on audio)
+        # clip = clip.set_duration(clip.duration)
 
         # print(f"Clip {segment_index} created successfully: {clip.duration:.2f}s") # Keep less noisy
         return clip
     except Exception as e:
         print(f"Critical error in create_clip for segment {segment_index}: {str(e)}")
         # Create a black clip with error message if anything goes wrong during the main process
-        error_duration = target_clip_duration if 'target_clip_duration' in locals() else (estimated_duration if estimated_duration else 3.0)
+        # Use a safe duration if previous duration calculation also failed
+        error_duration = target_clip_duration if 'target_clip_duration' in locals() and target_clip_duration > 0 else (estimated_duration if estimated_duration > 0 else 3.0)
         print(f"Creating error placeholder black clip for segment {segment_index} with duration {error_duration:.2f}s.")
         black_clip = ColorClip(size=target_resolution, color=(0,0,0), duration=error_duration)
         error_text = f"Error in segment {segment_index}"
@@ -1286,23 +1313,52 @@ def create_clip(media_asset, tts_path, estimated_duration, target_resolution,
 def fix_imagemagick_policy():
     """Attempt to fix ImageMagick security policies required by TextClip."""
     print("Attempting to fix ImageMagick security policies...")
-    policy_paths = [
-        "/etc/ImageMagick-6/policy.xml",
-        "/etc/ImageMagick-7/policy.xml",
-        "/etc/ImageMagick/policy.xml", # Common symlink path
-        "/usr/local/etc/ImageMagick-7/policy.xml", # macports/homebrew path
-        "/usr/share/ImageMagick/policy.xml", # Another common path
-        "/usr/share/ImageMagick-6/policy.xml",
-        "/usr/share/ImageMagick-7/policy.xml",
-        os.path.join(os.environ.get('MAGICK_HOME', ''), 'policy.xml') if os.environ.get('MAGICK_HOME') else '', # Check MAGICK_HOME
-        # Add more paths if needed based on typical installations
-    ]
-    # Filter out empty paths
-    policy_paths = [path for path in policy_paths if path and os.path.exists(path)]
+
+    # Use the found binary path if available, otherwise use default list
+    if found_imagemagick_binary:
+         # Assuming policy.xml is relative to the binary path or in a standard location
+         # This is a heuristic, may need manual path depending on installation
+         policy_paths_to_check = [
+             os.path.join(os.path.dirname(found_imagemagick_binary), '..', 'etc', 'ImageMagick-7', 'policy.xml'),
+             os.path.join(os.path.dirname(found_imagemagick_binary), '..', 'etc', 'ImageMagick-6', 'policy.xml'),
+             os.path.join(os.path.dirname(found_imagemagick_binary), '..', 'etc', 'ImageMagick', 'policy.xml'),
+             os.path.join(os.path.dirname(found_imagemagick_binary), '..', 'share', 'ImageMagick-7', 'policy.xml'),
+             os.path.join(os.path.dirname(found_imagemagick_binary), '..', 'share', 'ImageMagick-6', 'policy.xml'),
+             os.path.join(os.path.dirname(found_imagemagick_binary), '..', 'share', 'ImageMagick', 'policy.xml'),
+             # Add more paths relative to binary if needed
+         ]
+         # Add standard system paths as fallbacks
+         policy_paths_to_check.extend([
+            "/etc/ImageMagick-6/policy.xml",
+            "/etc/ImageMagick-7/policy.xml",
+            "/etc/ImageMagick/policy.xml",
+            "/usr/local/etc/ImageMagick-7/policy.xml", # macports/homebrew path
+            "/usr/share/ImageMagick/policy.xml",
+            "/usr/share/ImageMagick-6/policy.xml",
+            "/usr/share/ImageMagick-7/policy.xml",
+            os.path.join(os.environ.get('MAGICK_HOME', ''), 'policy.xml') if os.environ.get('MAGICK_HOME') else '', # Check MAGICK_HOME
+         ])
+    else:
+         # Only check standard system paths if binary wasn't found
+         policy_paths_to_check = [
+            "/etc/ImageMagick-6/policy.xml",
+            "/etc/ImageMagick-7/policy.xml",
+            "/etc/ImageMagick/policy.xml",
+            "/usr/local/etc/ImageMagick-7/policy.xml", # macports/homebrew path
+            "/usr/share/ImageMagick/policy.xml",
+            "/usr/share/ImageMagick-6/policy.xml",
+            "/usr/share/ImageMagick-7/policy.xml",
+            os.path.join(os.environ.get('MAGICK_HOME', ''), 'policy.xml') if os.environ.get('MAGICK_HOME') else '', # Check MAGICK_HOME
+         ]
+
+
+    # Filter out empty paths and check existence
+    existing_policy_paths = [path for path in policy_paths_to_check if path and os.path.exists(path)]
+
 
     found_policy = None
-    if policy_paths:
-        found_policy = policy_paths[0] # Use the first one found
+    if existing_policy_paths:
+        found_policy = existing_policy_paths[0] # Use the first one found
 
     if not found_policy:
         print("No policy.xml found in common locations. TextClip may fail.")
@@ -1321,6 +1377,7 @@ def fix_imagemagick_policy():
 
 
         # Read the original policy file (handle potential permission issues)
+        policy_content = None
         try:
              with open(found_policy, 'r') as f:
                  policy_content = f.read()
@@ -1337,11 +1394,17 @@ def fix_imagemagick_policy():
                      print(f"Failed to read policy file using sudo cat. Error: {stderr.decode('utf-8')}")
                      print("Manual intervention may be required.")
                      return False
+             except FileNotFoundError:
+                  print(f"sudo command not found. Cannot read policy file with sudo.")
+                  return False
              except Exception as e_sudo_read:
                   print(f"Error executing sudo cat: {e_sudo_read}")
                   print("Manual intervention may be required.")
                   return False
 
+        if policy_content is None:
+             print("Failed to read policy file content.")
+             return False
 
         # Use regex to find and replace the specific policy lines
         # Allow read and write rights for PDF, EPS, PS, etc. potentially restricted formats
@@ -1359,9 +1422,10 @@ def fix_imagemagick_policy():
             modified_content
         )
          # Catch any other "rights=none" for coder or path domains, but be cautious
+        # Use non-greedy match .*?
         modified_content = re.sub(
-             r'<policy domain="(coder|path)" rights="none"(.*?)/>',
-             r'<policy domain="\1" rights="read|write"\2/>',
+             r'<policy domain="(coder|path)" rights="none"(.*?)/?>', # Added /? for self-closing tag
+             r'<policy domain="\1" rights="read|write"\2/>', # Ensure it ends with self-closing tag
              modified_content
          )
 
@@ -1377,21 +1441,28 @@ def fix_imagemagick_policy():
             # Fallback to using os.system with sudo tee if direct write fails
             # This requires the user to be able to run sudo commands without a password prompt for the script's execution
             # and tee needs to be available.
-            # Using tee is safer than sudo cp for writing potentially large content.
+            # Using subprocess is safer than os.system for piping
             try:
                 # Write modified content to a temporary file first
+                # Ensure TEMP_FOLDER is set before creating a temp file path
+                if not TEMP_FOLDER:
+                     print("Error: TEMP_FOLDER not set for sudo write fallback.")
+                     return False
+                os.makedirs(TEMP_FOLDER, exist_ok=True) # Ensure temp folder exists
+
                 temp_policy_file = os.path.join(TEMP_FOLDER, "temp_policy_modified.xml")
                 with open(temp_policy_file, 'w') as f:
                     f.write(modified_content)
 
                 # Use sudo tee to overwrite the original file
-                # echo <content> | sudo tee <file> > /dev/null
-                cmd = f'sudo tee {found_policy} > /dev/null'
-                print(f"Executing: echo ... | {cmd}")
+                # sudo tee <file> < temp_file
+                cmd = ['sudo', 'tee', found_policy]
+                print(f"Executing: {' '.join(cmd)} < {temp_policy_file}")
 
-                # Using subprocess is safer than os.system for piping
-                process = subprocess.Popen(['sudo', 'tee', found_policy], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-                stdout, stderr = process.communicate(input=modified_content.encode('utf-8'))
+                # Using subprocess with stdin redirection
+                with open(temp_policy_file, 'rb') as f_in: # Open in binary mode for input
+                     process = subprocess.Popen(cmd, stdin=f_in, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                     stdout, stderr = process.communicate()
 
                 if process.returncode == 0:
                      print("ImageMagick policies updated successfully using sudo tee.")
@@ -1401,6 +1472,9 @@ def fix_imagemagick_policy():
                      print("Please manually edit your policy.xml to grant read/write rights for coder and path domains.")
                      print("Example: Change <policy domain='coder' rights='none' pattern='PDF'> to <policy domain='coder' rights='read|write' pattern='PDF'>")
                      return False
+            except FileNotFoundError:
+                 print(f"sudo or tee command not found. Cannot write policy file with sudo.")
+                 return False
             except Exception as e_sudo_write:
                  print(f"Error executing sudo tee process: {e_sudo_write}")
                  print("Manual intervention may be required.")
@@ -1417,10 +1491,6 @@ def fix_imagemagick_policy():
         return False
 
 
-# Import subprocess for sudo commands in fix_imagemagick_policy
-import subprocess
-
-
 # ---------------- Gradio Interface Functions ---------------- #
 
 def generate_script_and_show_editor(user_input, resolution_choice,
@@ -1445,6 +1515,7 @@ def generate_script_and_show_editor(user_input, resolution_choice,
             print(f"Error starting cleanup of temp folder {TEMP_FOLDER}: {e}")
 
     # Create a new unique temporary folder for this run
+    # Add a suffix based on time to minimize collision risk if cleanup fails
     TEMP_FOLDER = tempfile.mkdtemp(prefix="aivgen_")
     print(f"Created new temp folder: {TEMP_FOLDER}")
 
@@ -1463,10 +1534,12 @@ def generate_script_and_show_editor(user_input, resolution_choice,
     }
 
     # Initial status update and hide editing/video areas
+    # Yielding multiple updates in a list/tuple works for simultaneous updates
     yield (run_config,
            gr.update(value="Generating script...", visible=True),
            gr.update(visible=False), # Hide editing area
            gr.update(value=None, visible=False), # Hide video output and clear value
+           gr.update(visible=False, value="### Generated Script Preview\n\nGenerating script..."), # Hide and update raw script preview
            # Updates for dynamic components (initially hide/clear all)
            [gr.update(visible=False, value="") for _ in range(MAX_SEGMENTS_FOR_EDITING)], # Hide textboxes
            [gr.update(visible=False, value=None) for _ in range(MAX_SEGMENTS_FOR_EDITING)], # Hide file uploads
@@ -1476,9 +1549,8 @@ def generate_script_and_show_editor(user_input, resolution_choice,
 
     script_text = generate_script(user_input, OPENROUTER_API_KEY, OPENROUTER_MODEL)
 
-    # Update raw script preview
-    raw_script_preview = f"### Generated Script Preview\n\n```\n{script_text}\n```" if script_text else "### Generated Script Preview\n\nFailed to generate script."
-
+    # Determine raw script preview content
+    raw_script_preview_content = f"### Generated Script Preview\n\n```\n{script_text}\n```" if script_text and not script_text.startswith("[Error]") else f"### Generated Script Preview\n\n{script_text}"
 
     if not script_text or script_text.startswith("[Error]"):
         # Update status and keep editing/video areas hidden
@@ -1486,12 +1558,13 @@ def generate_script_and_show_editor(user_input, resolution_choice,
                gr.update(value=f"Script generation failed: {script_text}", visible=True),
                gr.update(visible=False),
                gr.update(value=None, visible=False),
+                gr.update(visible=True, value=raw_script_preview_content), # Show raw script preview on error
                # Updates for dynamic components (all hidden)
                [gr.update(visible=False, value="") for _ in range(MAX_SEGMENTS_FOR_EDITING)],
                [gr.update(visible=False, value=None) for _ in range(MAX_SEGMENTS_FOR_EDITING)],
                [gr.update(visible=False) for _ in range(MAX_SEGMENTS_FOR_EDITING)],
                [], # segments_state remains empty
-               raw_script_preview) # Update raw script preview
+              )
         return # Stop execution
 
 
@@ -1499,11 +1572,12 @@ def generate_script_and_show_editor(user_input, resolution_choice,
            gr.update(value="Parsing script...", visible=True),
            gr.update(visible=False),
            gr.update(value=None, visible=False),
+           gr.update(visible=True, value=raw_script_preview_content), # Show raw script preview
            [gr.update(visible=False, value="") for _ in range(MAX_SEGMENTS_FOR_EDITING)],
            [gr.update(visible=False, value=None) for _ in range(MAX_SEGMENTS_FOR_EDITING)],
            [gr.update(visible=False) for _ in range(MAX_SEGMENTS_FOR_EDITING)],
            [], # segments_state will be updated next
-           raw_script_preview)
+          )
 
 
     segments = parse_script(script_text)
@@ -1513,12 +1587,13 @@ def generate_script_and_show_editor(user_input, resolution_choice,
                gr.update(value="Failed to parse script or script is empty after parsing.", visible=True),
                gr.update(visible=False),
                gr.update(value=None, visible=False),
+               gr.update(visible=True, value=raw_script_preview_content), # Show raw script preview
                # Updates for dynamic components (all hidden)
                [gr.update(visible=False, value="") for _ in range(MAX_SEGMENTS_FOR_EDITING)],
                [gr.update(visible=False, value=None) for _ in range(MAX_SEGMENTS_FOR_EDITING)],
                [gr.update(visible=False) for _ in range(MAX_SEGMENTS_FOR_EDITING)],
                [], # segments_state remains empty
-               raw_script_preview) # Update raw script preview
+              )
         return # Stop execution
 
 
@@ -1545,11 +1620,12 @@ def generate_script_and_show_editor(user_input, resolution_choice,
            gr.update(value=f"Script generated with {len(segments)} segments. Edit segments below.", visible=True),
            gr.update(visible=True), # Show Editing area
            gr.update(value=None, visible=False), # Ensure video output is hidden and cleared
+           gr.update(visible=True, value=raw_script_preview_content), # Show raw script preview
            textbox_updates, # Update textboxes (visibility and value)
            file_updates, # Update file uploads (visibility and value)
            group_visibility_updates, # Update visibility of groups
            segments, # Update the state with parsed segments
-           raw_script_preview) # Update raw script preview
+          )
 
 
 def generate_video_from_edited(run_config, segments_data, segment_texts, segment_uploads, bg_music_volume):
@@ -1590,34 +1666,37 @@ def generate_video_from_edited(run_config, segments_data, segment_texts, segment
     # Update segments_data with potentially edited text and uploaded file paths
     # segment_texts and segment_uploads are lists of values from the Gradio components
     processed_segments = []
-    for i, segment in enumerate(segments_data):
-        if i < len(segment_texts) and i < len(segment_uploads): # Ensure we have corresponding input values
-            processed_segment = segment.copy() # Make a copy
-            # Use edited text, strip whitespace
-            processed_segment['text'] = segment_texts[i].strip() if segment_texts[i] is not None else segment.get('text', '').strip()
-            # Use uploaded media path (will be None if nothing uploaded)
-            processed_segment['uploaded_media'] = segment_uploads[i]
-            processed_segments.append(processed_segment)
-        else:
-            # This shouldn't happen if state and UI updates are in sync, but as a safeguard
-            print(f"Warning: Missing input value(s) for segment index {i}. Using original segment data.")
-            processed_segments.append(segment) # Append original if inputs are missing
+    # Iterate up to the minimum of state segments and provided inputs
+    num_segments_to_process = min(len(segments_data), len(segment_texts), len(segment_uploads), MAX_SEGMENTS_FOR_EDITING)
 
-    if not processed_segments:
-        yield "No valid segments to process after editing.", None
-        # Clean up
-        if TEMP_FOLDER and os.path.exists(TEMP_FOLDER):
+    if num_segments_to_process == 0:
+         yield "No segments to process after reading editor inputs.", None
+         # Clean up
+         if TEMP_FOLDER and os.path.exists(TEMP_FOLDER):
              try:
                  shutil.rmtree(TEMP_FOLDER)
                  print(f"Cleaned up temp folder: {TEMP_FOLDER}")
              except Exception as e:
                  print(f"Error cleaning up temp folder {TEMP_FOLDER}: {e}")
-        TEMP_FOLDER = None # Reset global
-        return
+         TEMP_FOLDER = None # Reset global
+         return
+
+
+    for i in range(num_segments_to_process):
+        segment = segments_data[i] # Get original segment data
+        processed_segment = segment.copy() # Make a copy
+        # Use edited text, strip whitespace
+        processed_segment['text'] = segment_texts[i].strip() if segment_texts[i] is not None else segment.get('text', '').strip()
+        # Use uploaded media path (will be None if nothing uploaded)
+        processed_segment['uploaded_media'] = segment_uploads[i]
+        processed_segments.append(processed_segment)
 
 
     yield "Fixing ImageMagick policy...", None
-    fix_imagemagick_policy() # Attempt policy fix before creating clips
+    # Call fix_imagemagick_policy again just before video generation as a safeguard
+    # This might require the user to enter a password if sudo is needed.
+    # It's better to handle permissions manually or configure sudoers.
+    fix_imagemagick_policy()
 
     clips = []
     yield "Generating media and audio for clips...", None
@@ -1633,7 +1712,6 @@ def generate_video_from_edited(run_config, segments_data, segment_texts, segment
             segment.get('uploaded_media') # Pass uploaded media path
         )
 
-
         # Generate TTS audio
         tts_path = generate_tts(segment.get('text', '')) # Use edited text, default to empty string if None/missing
 
@@ -1724,6 +1802,9 @@ def generate_video_from_edited(run_config, segments_data, segment_texts, segment
             shutil.move(temp_output_filename, final_output_path)
             print(f"Final video saved as {final_output_path}")
             output_path = final_output_path
+        except shutil.SameFileError:
+             print(f"Output path is the same as temp path, no move needed: {temp_output_filename}")
+             output_path = temp_output_filename
         except Exception as e:
              print(f"Error moving temporary file {temp_output_filename} to final destination {final_output_path}: {e}")
              # If move fails, return the temp file path or None
@@ -1756,6 +1837,7 @@ def generate_video_from_edited(run_config, segments_data, segment_texts, segment
 
 # Need lists to hold the dynamic UI components for segments
 segment_editing_groups = []
+segment_prompt_labels = [] # List to hold the prompt Labels
 segment_text_inputs = []
 segment_file_inputs = []
 
@@ -1802,12 +1884,14 @@ with gr.Blocks() as demo:
         gr.Markdown("### Edit Script Segments")
         gr.Markdown("Review the AI-generated text and media suggestions below. Edit the text and/or upload your own image/video for any segment. If no file is uploaded, AI will fetch media based on the original prompt.")
         for i in range(MAX_SEGMENTS_FOR_EDITING):
-            # Use gr.Box for better visual grouping
-            with gr.Box(visible=False) as segment_group: # Each group represents one segment
+            # Use gr.Group instead of gr.Box for compatibility
+            with gr.Group(visible=False) as segment_group: # Each group represents one segment
                 segment_editing_groups.append(segment_group)
                 # Use a Label to display the original prompt - it's non-interactive text
-                segment_prompt_label = gr.Label(f"Segment {i+1} Prompt:", show_label=False) # Label will be set by JS
-                # We'll update the value of this label using JS/state change
+                # The value will be updated by JS
+                segment_prompt_label = gr.Label(f"Segment {i+1} Prompt:", show_label=False)
+                segment_prompt_labels.append(segment_prompt_label)
+
 
                 segment_text = gr.Textbox(label="Narration Text", lines=2, interactive=True)
                 segment_text_inputs.append(segment_text)
@@ -1842,12 +1926,12 @@ with gr.Blocks() as demo:
             status_output, # Update status label
             editing_area, # Show/hide editing area column
             final_video_output, # Hide and clear video output
+            script_preview_markdown, # Update raw script preview
             # Outputs for dynamic components (visibility and value updates)
             *segment_text_inputs,
             *segment_file_inputs,
             *segment_editing_groups,
             segments_state, # Update segments state
-            script_preview_markdown # Update raw script preview
         ]
     )
 
@@ -1864,8 +1948,7 @@ with gr.Blocks() as demo:
         outputs=[status_output, final_video_output] # Yield status updates and final video
     )
 
-    # Add JS to update segment prompt Labels after script generation
-    # This JS function reads the segments_state and updates the Labels
+    # Add JS to update segment prompt Labels when segments_state changes
     demo.load(
         None,
         None,
@@ -1875,69 +1958,158 @@ with gr.Blocks() as demo:
         function updateSegmentPromptLabels(segments_data) {{
             console.log("updateSegmentPromptLabels called", segments_data);
             // Gradio stores dynamic component outputs in a flat list.
-            // The prompt labels are the first Label component in each segment group.
-            // Assuming the order is consistent: [Label_0, Textbox_0, File_0, Label_1, Textbox_1, File_1, ...]
-            // We need to find the correct Label element for each segment index.
+            // The prompt labels are specific Label components we've identified.
+            // We need to map the segment index to the correct Label component index.
+            // Since segment_prompt_labels is a list of Gradio components,
+            // its corresponding elements in the _js scope arguments list are ordered similarly.
 
-            // Find all elements that are potentially segment prompt labels
-            const all_segment_labels = document.querySelectorAll('.segment_group_box > label.svelte-q5b6g8'); // Find Label elements within segment boxes
+            const segmentPromptLabelOutputs = arguments[0]; // This argument corresponds to segment_prompt_labels in the outputs list of segments_state.change
+            const segmentsData = arguments[1]; // This argument corresponds to segments_state in the inputs list
 
-            if (!segments_data || segments_data.length === 0) {{
+            if (!segmentsData || segmentsData.length === 0) {{
                  // Clear any existing labels if script generation failed or empty
-                 all_segment_labels.forEach(label => label.textContent = '');
-                 return;
+                 for(let i = 0; i < {MAX_SEGMENTS_FOR_EDITING}; i++) {{
+                      // The Gradio JS output object for a Label has a 'value' property
+                      if (segmentPromptLabelOutputs && segmentPromptLabelOutputs[i]) {{
+                          segmentPromptLabelOutputs[i].update(''); // Or promptLabel.value = ''; depending on version
+                      }}
+                 }}
+                 return segmentPromptLabelOutputs; // Return the output object unchanged
             }}
 
             for (let i = 0; i < {MAX_SEGMENTS_FOR_EDITING}; i++) {{
-                // Assuming the labels correspond directly to the group index
-                const promptLabel = all_segment_labels[i]; // Get the i-th potential label
+                 const gradioLabelOutput = segmentPromptLabelOutputs[i]; // Get the Gradio JS output object for this label
 
-                if (promptLabel) {{
-                    if (i < segments_data.length) {{
+                if (gradioLabelOutput) {{
+                    if (i < segmentsData.length) {{
                         // Update label text with the original prompt
-                        promptLabel.textContent = `Segment ${i+1} (Prompt: ${segments_data[i].original_prompt})`;
-                        promptLabel.parentElement.style.display = 'block'; // Ensure parent box is visible (redundant if group visibility is set, but safe)
+                        const promptText = `Segment ${i+1} (Prompt: ${segmentsData[i].original_prompt})`;
+                        gradioLabelOutput.update(promptText); // Update the label's value
+                        // Need to ensure the parent container (gr.Group) is visible.
+                        // Assuming the gr.Group visibility update happens elsewhere (in generate_script_and_show_editor)
                     }} else {{
-                        // Hide label for unused segments
-                        promptLabel.textContent = '';
-                        promptLabel.parentElement.style.display = 'none'; // Hide parent box
+                        // Clear label for unused segments
+                        gradioLabelOutput.update('');
+                        // Hiding the gr.Group should handle hiding the label, but clear value anyway
                     }}
                 }} else {{
-                     console.warn(`Prompt label element not found for segment index ${i}`);
+                     console.warn(`Prompt label JS output object not found for segment index ${i}`);
                 }}
             }}
+             return segmentPromptLabelOutputs; // Return the output object unchanged
         }}
         """
     )
 
     # Trigger the JS function whenever segments_state changes
     segments_state.change(
-        None, # No Python function to call
-        segments_state, # The state variable that changed
-        None, # No output components to update via Python
-        _js="""
+        fn=None, # No Python function to call
+        inputs=[segments_state], # The state variable that changed
+        outputs=[*segment_prompt_labels], # Explicitly list the labels to be updated by JS
+        js="""
         (segments_data) => {
-            // Call the JS function defined in demo.load
-            updateSegmentPromptLabels(segments_data);
-            // Return the segments_data itself if needed for chaining, but here it's not.
-            // This function just updates the UI client-side.
-            return arguments[0]; // Return original arguments to avoid state getting cleared
-        }
-        """
-    )
+            // The arguments passed to this JS function will match the inputs list.
+            // So segments_data is arguments[0].
+            // The outputs list elements are available via arguments[1] onwards.
+            // This structure seems inconsistent with the doc examples sometimes.
+            // Let's pass the labels back as inputs and have the JS function handle it.
+            // Re-structuring the JS call:
+            // Let's make the JS function *only* take the segments_data
+            // and rely on the Gradio JS environment to access/update the elements.
+            // This is harder. The standard way is to list outputs.
+
+            // Let's pass segments_state and the labels list to the JS function.
+            // The JS function then finds the correct label outputs.
+
+            // Let's use the standard Gradio approach: list inputs and outputs.
+            // The JS function receives inputs as arguments[0...n] and expects
+            // return values corresponding to outputs.
+
+            // Let's modify the JS function to take segments_data directly and
+            // return an array of updates for the labels.
+            // This requires the JS function to live outside the _js call, as it does.
+            // The _js call then just invokes that function.
+
+            // The inputs to this _js are the *outputs* of the upstream function (generate_script_and_show_editor).
+            // So, segments_data is arguments[8] (index 8 because there are 8 outputs before segments_state)
+            // This is complicated! Let's simplify.
+
+            // Alternative: Use a single JS function that takes segments_data and the total number of segments.
+            // It finds the elements by some other means (e.g., data attributes or a known structure).
+
+            // Let's go back to the original plan, JS function defined in demo.load,
+            // triggered by state.change, inputs=[state], outputs=[elements_to_update].
+            // The arguments to the JS function will be [state_value, output1_value, output2_value, ...]
+            // In segments_state.change(inputs=[segments_state], outputs=[*segment_prompt_labels]):
+            // arguments[0] = segments_state value
+            // arguments[1...n] = current values of segment_prompt_labels components (less useful)
+            // The return value of the JS function should be an array matching the shape of outputs.
+
+            // Let's pass segments_data as the input and the labels as outputs.
+            // The JS function will receive segments_data and needs to return updates for the labels.
+            // The JS function needs access to the list of segments_data and the indices of the output labels.
+
+            // Let's try this simplified JS structure in the segments_state.change _js:
+             // arguments[0] is the new value of segments_state
+            const newSegmentsData = arguments[0];
+            const updates = [];
+            // We need to generate updates for each segment_prompt_label
+            // This requires knowing how many labels there are and their order in the outputs list.
+            // This is where the complexity lies in dynamically addressing components in JS.
+
+            // Revert to the simpler approach: the JS function is defined in demo.load
+            // and segments_state.change simply calls it with the segments_data.
+            // The JS function needs to find the elements itself.
+            // Let's use data attributes or a known structure to find the labels.
+
+            // Let's give each segment group and label a predictable ID or class.
+            // Update Python code to add data attributes or IDs.
+            // Update JS selector.
+
+            // *** Re-implementing JS selector using a more robust method ***
+
+             // arguments[0] is the new value of segments_state
+            const segmentsData = arguments[0];
+            // Find the main editing area container
+            const editingArea = document.querySelector('#editing_area_id'); // Need to add id in Python
+
+            if (!editingArea) {{
+                 console.error("Editing area container not found.");
+                 return arguments[0]; // Return state unchanged
+            }}
 
-# Launch the interface
-if __name__ == "__main__":
-    # Attempt ImageMagick policy fix on script startup
-    # This helps but might still require manual sudo depending on system config
-    fix_imagemagick_policy()
+            // Find all segment group containers within the editing area
+            const segmentGroups = editingArea.querySelectorAll('.gradio-group'); // Using generic Gradio group class
+
+            if (!segmentGroups || segmentGroups.length === 0) {{
+                 console.warn("No segment groups found.");
+                 return arguments[0]; // Return state unchanged
+            }}
 
-    print("Launching Gradio interface...")
+            segmentGroups.forEach((group, index) => {{
+                // Find the first Label component within this group
+                const promptLabel = group.querySelector('label.svelte-q5b6g8'); // Assuming Label uses 'label' tag and this class
 
-    # Check if API keys are still placeholders (unlikely with hardcoded keys, but good practice)
-    if PEXELS_API_KEY.startswith('YOUR_PEXELS_API_KEY'):
-        print("Warning: PEXELS_API_KEY is not configured. Media search may fail.")
-    if OPENROUTER_API_KEY.startswith('YOUR_OPENROUTER_API_KEY'):
-        print("Warning: OPENROUTER_API_KEY is not configured. Script generation will fail.")
+                if (promptLabel) {{
+                    if (index < segmentsData.length) {{
+                        // Update label text
+                        promptLabel.textContent = `Segment ${index+1} (Prompt: ${segmentsData[index].original_prompt})`;
+                        group.style.display = 'block'; // Ensure the group is visible (should be handled by Python outputs too)
+                    }} else {{
+                        // Hide label and group for unused segments
+                        promptLabel.textContent = '';
+                        group.style.display = 'none';
+                    }}
+                }} else {{
+                     console.warn(`Prompt label element not found within group index ${index}.`);
+                     // Still hide the group if it's unused
+                     if (index >= segmentsData.length) {{
+                         group.style.display = 'none';
+                     }}
+                }}
+            }});
 
-    demo.launch(share=True) # Set share=True to get a public link
+            return arguments[0]; // Return segments_data unchanged
+        }
+        """
+    )