diff --git a/builds/android/1.4.4/app-release.apk b/builds/android/1.4.4/app-release.apk
new file mode 100644
index 0000000..58b05f5
Binary files /dev/null and b/builds/android/1.4.4/app-release.apk differ
diff --git a/package.json b/package.json
index e414a5d..b5285b5 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "Flickv4",
-  "version": "1.4.3",
+  "version": "1.4.4",
   "private": true,
   "scripts": {
     "clean:android": "cd android && ./gradlew clean",
diff --git a/src/components/MediaPlayer/NetflixMediaPlayer.tsx b/src/components/MediaPlayer/NetflixMediaPlayer.tsx
index ef8f8b5..6279690 100644
--- a/src/components/MediaPlayer/NetflixMediaPlayer.tsx
+++ b/src/components/MediaPlayer/NetflixMediaPlayer.tsx
@@ -145,6 +145,7 @@ const NetflixMediaPlayer: React.FC<NetflixMediaPlayerProps> = ({
   const [showSeasonDropdown, setShowSeasonDropdown] = useState(false);
   const [isSeeking, setIsSeeking] = useState(false);
   const [seekBarWidth, setSeekBarWidth] = useState(0);
+  const [bufferedPosition, setBufferedPosition] = useState(0);
 
   const videoRef = useRef<any>(null);
   const seekBarRef = useRef<View>(null);
@@ -305,8 +306,11 @@ const NetflixMediaPlayer: React.FC<NetflixMediaPlayerProps> = ({
     showControls();
   }, [showControls]);
 
-  const handleProgress = useCallback(({ currentTime: t }: { currentTime: number }) => {
+  const handleProgress = useCallback(({ currentTime: t, playableDuration }: { currentTime: number; playableDuration?: number }) => {
     if (!isSeeking) setCurrentTime(t);
+    if (typeof playableDuration === 'number' && Number.isFinite(playableDuration)) {
+      setBufferedPosition(playableDuration);
+    }
     onPlaybackProgress(t);
   }, [isSeeking, onPlaybackProgress]);
 
@@ -321,11 +325,14 @@ const NetflixMediaPlayer: React.FC<NetflixMediaPlayerProps> = ({
   }, [onEnd, onPlaybackEnd]);
 
   const videoSource = useMemo(() => {
-    const isCached = playbackUrl.startsWith('file://');
-    return {
+    const useStreamHeaders =
+      playbackUrl.includes('.m3u8') ||
+      (!playbackUrl.startsWith('file://') && !playbackUrl.startsWith('/'));
+    const base = {
       uri: playbackUrl,
-      ...(isCached ? {} : { headers: VIDEO_STREAM_HEADERS }),
+      ...(useStreamHeaders ? { headers: VIDEO_STREAM_HEADERS } : {}),
     };
+    return playbackUrl.includes('.m3u8') ? { ...base, type: 'm3u8' as const } : base;
   }, [playbackUrl]);
 
   const handleError = useCallback(() => {
@@ -346,8 +353,9 @@ const NetflixMediaPlayer: React.FC<NetflixMediaPlayerProps> = ({
     const next = Math.max(0, Math.min(currentTime + offset, duration));
     videoRef.current.seek(next);
     setCurrentTime(next);
+    onPlaybackProgress(next);
     showControls();
-  }, [currentTime, duration, showControls]);
+  }, [currentTime, duration, onPlaybackProgress, showControls]);
 
   // ── seekbar pan responder ──────────────────────────────────────────────────
   const seekPanResponder = useMemo(() =>
@@ -374,16 +382,25 @@ const NetflixMediaPlayer: React.FC<NetflixMediaPlayerProps> = ({
           const t = pct * duration;
           videoRef.current?.seek(t);
           setCurrentTime(t);
+          onPlaybackProgress(t);
         });
         setIsSeeking(false);
         showControls();
       },
       onPanResponderTerminate: () => setIsSeeking(false),
     }),
-  [duration, showControls]);
+  [duration, onPlaybackProgress, showControls]);
 
   // ── computed ───────────────────────────────────────────────────────────────
   const progressPct = duration > 0 ? currentTime / duration : 0;
+  const bufferLinePct = useMemo(() => {
+    if (duration <= 0) return 0;
+    const bufferedPct = bufferedPosition / duration;
+    const cachedPct = cacheStatus.isActive
+      ? Math.min((currentTime + cacheStatus.cachedSecondsAhead) / duration, 1)
+      : 0;
+    return Math.max(bufferedPct, cachedPct);
+  }, [bufferedPosition, cacheStatus.cachedSecondsAhead, cacheStatus.isActive, currentTime, duration]);
   const thumbLeft = Math.max(0, progressPct * seekBarWidth - 8);
   const hasTV = contentType === 'tv' && seasons.length > 0 && episodes.length > 0;
   const currentEpisodeInfo = episodes.find(e => e.episode_number === selectedEpisode);
@@ -434,24 +451,26 @@ const NetflixMediaPlayer: React.FC<NetflixMediaPlayerProps> = ({
   return (
     <View style={styles.root}>
       {/* ── Video ── */}
-      <Video
-        ref={videoRef}
-        source={videoSource}
-        style={StyleSheet.absoluteFill}
-        resizeMode="contain"
-        paused={!isPlaying}
-        controls={false}
-        bufferingStrategy={BufferingStrategyType.DEPENDING_ON_MEMORY}
-        onLoad={handleLoad}
-        onProgress={handleProgress}
-        onBuffer={handleBuffer}
-        onEnd={handleEnd}
-        onError={handleError}
-        progressUpdateInterval={250}
-        repeat={false}
-        muted={false}
-        hideShutterView
-      />
+      {!isCacheLoading && playbackUrl ? (
+        <Video
+          ref={videoRef}
+          source={videoSource}
+          style={StyleSheet.absoluteFill}
+          resizeMode="contain"
+          paused={!isPlaying}
+          controls={false}
+          bufferingStrategy={BufferingStrategyType.DEPENDING_ON_MEMORY}
+          onLoad={handleLoad}
+          onProgress={handleProgress}
+          onBuffer={handleBuffer}
+          onEnd={handleEnd}
+          onError={handleError}
+          progressUpdateInterval={250}
+          repeat={false}
+          muted={false}
+          hideShutterView
+        />
+      ) : null}
 
       {/* ── Buffering ── */}
       {(isBuffering || isCacheLoading) && (
@@ -463,14 +482,6 @@ const NetflixMediaPlayer: React.FC<NetflixMediaPlayerProps> = ({
         </View>
       )}
 
-      {cacheStatus.isActive && cacheStatus.cachedSecondsAhead > 0 && (
-        <View style={styles.cacheBadge}>
-          <Text style={styles.cacheBadgeText}>
-            {Math.round(cacheStatus.cachedSecondsAhead)}s cached ahead
-          </Text>
-        </View>
-      )}
-
       {/* ── Tap to toggle controls ── */}
       <TouchableWithoutFeedback onPress={toggleControls}>
         <View style={StyleSheet.absoluteFill} />
@@ -555,6 +566,9 @@ const NetflixMediaPlayer: React.FC<NetflixMediaPlayerProps> = ({
               {...seekPanResponder.panHandlers}
             >
               <View style={styles.seekBackground} />
+              {bufferLinePct > 0 && (
+                <View style={[styles.seekBuffered, { width: bufferLinePct * seekBarWidth }]} />
+              )}
               <View style={[styles.seekFill, { width: progressPct * seekBarWidth }]} />
               {seekBarWidth > 0 && (
                 <View
@@ -706,25 +720,10 @@ const styles = StyleSheet.create({
     marginTop: 12,
     fontSize: 14,
   },
-  cacheBadge: {
-    position: 'absolute',
-    top: 16,
-    right: 16,
-    backgroundColor: 'rgba(0,0,0,0.65)',
-    paddingHorizontal: 8,
-    paddingVertical: 4,
-    borderRadius: 4,
-    zIndex: 5,
-  },
   subtitleLayer: {
     ...StyleSheet.absoluteFillObject,
     zIndex: 3,
   },
-  cacheBadgeText: {
-    color: '#fff',
-    fontSize: 11,
-    fontWeight: '600',
-  },
   controlsOverlay: {
     ...StyleSheet.absoluteFillObject,
     backgroundColor: 'rgba(0,0,0,0.35)',
@@ -843,6 +842,13 @@ const styles = StyleSheet.create({
     borderRadius: 2,
     backgroundColor: 'rgba(255,255,255,0.3)',
   },
+  seekBuffered: {
+    position: 'absolute',
+    left: 0,
+    height: 4,
+    borderRadius: 2,
+    backgroundColor: 'rgba(255,255,255,0.55)',
+  },
   seekFill: {
     position: 'absolute',
     left: 0,
diff --git a/src/components/MediaPlayer/SubtitleOverlay.tsx b/src/components/MediaPlayer/SubtitleOverlay.tsx
index 4e1452d..7098824 100644
--- a/src/components/MediaPlayer/SubtitleOverlay.tsx
+++ b/src/components/MediaPlayer/SubtitleOverlay.tsx
@@ -1,12 +1,7 @@
 import React, { useState, useEffect, useMemo } from 'react';
 import { View, Text, ViewStyle, TextStyle, Platform } from 'react-native';
 import { SubtitleStyle, DEFAULT_SUBTITLE_STYLE } from '../../types';
-
-interface SubtitleCue {
-  start: number;
-  end: number;
-  text: string;
-}
+import { findActiveCue, parseSrtCues } from '../../utils/subtitleUtils';
 
 interface SubtitleOverlayProps {
   subtitleContent: string | null;
@@ -17,47 +12,6 @@ interface SubtitleOverlayProps {
   style?: SubtitleStyle;
 }
 
-const parseSRT = (srtContent: string): SubtitleCue[] => {
-  const cues: SubtitleCue[] = [];
-  
-  const blocks = srtContent.trim().split(/\r?\n\r?\n/);
-  
-  for (const block of blocks) {
-    const lines = block.trim().split(/\r?\n/);
-    if (lines.length < 3) continue;
-    
-    const timestampIndex = lines.findIndex(line => line.includes('-->'));
-    if (timestampIndex === -1) continue;
-    
-    const timestampLine = lines[timestampIndex];
-    const textLines = lines.slice(timestampIndex + 1);
-    
-    const match = timestampLine.match(/(\d{2}):(\d{2}):(\d{2}),(\d{3})\s*-->\s*(\d{2}):(\d{2}):(\d{2}),(\d{3})/);
-    if (!match) continue;
-    
-    const startHours = parseInt(match[1], 10);
-    const startMinutes = parseInt(match[2], 10);
-    const startSeconds = parseFloat(`${match[3]}.${match[4]}`);
-    const endHours = parseInt(match[5], 10);
-    const endMinutes = parseInt(match[6], 10);
-    const endSeconds = parseFloat(`${match[7]}.${match[8]}`);
-    
-    const start = startHours * 3600 + startMinutes * 60 + startSeconds;
-    const end = endHours * 3600 + endMinutes * 60 + endSeconds;
-    
-    const text = textLines
-      .join('\n')
-      .replace(/<[^>]*>/g, '')
-      .trim();
-    
-    if (text) {
-      cues.push({ start, end, text });
-    }
-  }
-  
-  return cues;
-};
-
 export const SubtitleOverlay: React.FC<SubtitleOverlayProps> = ({
   subtitleContent,
   currentTime,
@@ -66,8 +20,9 @@ export const SubtitleOverlay: React.FC<SubtitleOverlayProps> = ({
   delay = 0,
   style = DEFAULT_SUBTITLE_STYLE,
 }) => {
-  const [cues, setCues] = useState<SubtitleCue[]>([]);
-  const [currentCue, setCurrentCue] = useState<string | null>(null);
+  const [cues, setCues] = useState(() =>
+    subtitleContent ? parseSrtCues(subtitleContent) : [],
+  );
 
   const computedFontSize = useMemo(() => {
     const baseSizes = {
@@ -124,28 +79,19 @@ export const SubtitleOverlay: React.FC<SubtitleOverlayProps> = ({
   useEffect(() => {
     if (subtitleContent) {
       try {
-        const parsedCues = parseSRT(subtitleContent);
-        setCues(parsedCues);
+        setCues(parseSrtCues(subtitleContent));
       } catch {
+        setCues([]);
       }
     } else {
       setCues([]);
-      setCurrentCue(null);
     }
   }, [subtitleContent]);
 
-  useEffect(() => {
-    if (cues.length === 0) {
-      setCurrentCue(null);
-      return;
-    }
-
-    const adjustedTime = currentTime - delay + 0.5;
-    const activeCue = cues.find(
-      cue => adjustedTime >= cue.start && adjustedTime <= cue.end
-    );
-
-    setCurrentCue(activeCue ? activeCue.text : null);
+  const currentCue = useMemo(() => {
+    if (cues.length === 0) return null;
+    const adjustedTime = currentTime - delay;
+    return findActiveCue(cues, adjustedTime)?.text ?? null;
   }, [currentTime, cues, delay]);
 
   if (!currentCue) {
diff --git a/src/components/MediaPlayer/controls/BottomBar.tsx b/src/components/MediaPlayer/controls/BottomBar.tsx
index 7f32d87..f56713b 100644
--- a/src/components/MediaPlayer/controls/BottomBar.tsx
+++ b/src/components/MediaPlayer/controls/BottomBar.tsx
@@ -27,6 +27,7 @@ export const BottomBar: React.FC<BottomBarProps> = ({
   subtitleDelay = 0,
   onSubtitleDelayChange,
   onResetSubtitleDelay,
+  cachedAheadSeconds = 0,
 }) => {
   const [showDelayControls, setShowDelayControls] = useState(false);
 
@@ -61,6 +62,7 @@ export const BottomBar: React.FC<BottomBarProps> = ({
         currentPosition={currentPosition}
         duration={duration}
         bufferedPosition={bufferedPosition}
+        cachedAheadSeconds={cachedAheadSeconds}
         hidden={hidden}
         onSeek={onSeek}
         onTimePreview={onTimePreview}
diff --git a/src/components/MediaPlayer/controls/Controls.tsx b/src/components/MediaPlayer/controls/Controls.tsx
index 5d9a61e..99f8254 100644
--- a/src/components/MediaPlayer/controls/Controls.tsx
+++ b/src/components/MediaPlayer/controls/Controls.tsx
@@ -49,7 +49,7 @@ const ControlsComponent: React.FC<ControlsProps> = ({
   subtitleDelay = 0,
   onSubtitleDelayChange,
   onResetSubtitleDelay,
-  cacheAheadSeconds,
+  cachedAheadSeconds = 0,
 }) => {
   const navigation = useNavigation();
   const [timeLabel, setTimeLabel] = useState<string>(formatTime(0));
@@ -178,14 +178,9 @@ const ControlsComponent: React.FC<ControlsProps> = ({
         subtitleDelay={subtitleDelay}
         onSubtitleDelayChange={onSubtitleDelayChange}
         onResetSubtitleDelay={onResetSubtitleDelay}
+        cachedAheadSeconds={cachedAheadSeconds}
       />
 
-      {cacheAheadSeconds !== undefined && cacheAheadSeconds > 0 && !isControlsHidden && (
-        <View style={styles.cacheBadge}>
-          <Text style={styles.cacheBadgeText}>{cacheAheadSeconds}s cached ahead</Text>
-        </View>
-      )}
-
       {readyNext && fullscreen && onNext && (
         <View
           style={[
diff --git a/src/components/MediaPlayer/controls/ProgressBar.tsx b/src/components/MediaPlayer/controls/ProgressBar.tsx
index d5910c7..f82d871 100644
--- a/src/components/MediaPlayer/controls/ProgressBar.tsx
+++ b/src/components/MediaPlayer/controls/ProgressBar.tsx
@@ -9,6 +9,7 @@ const ProgressBarComponent: React.FC<ProgressBarProps> = ({
   currentPosition,
   duration,
   bufferedPosition = 0,
+  cachedAheadSeconds = 0,
   hidden,
   onSeek,
   onTimePreview,
@@ -30,6 +31,17 @@ const ProgressBarComponent: React.FC<ProgressBarProps> = ({
     return clamp(bufferedPosition / duration, 0, 1);
   }, [bufferedPosition, duration]);
 
+  const cachedPercentage = useMemo(() => {
+    if (!duration || duration === 0 || cachedAheadSeconds <= 0) return 0;
+    const cachedEnd = currentPosition + cachedAheadSeconds;
+    return clamp(cachedEnd / duration, 0, 1);
+  }, [cachedAheadSeconds, currentPosition, duration]);
+
+  const bufferLinePercentage = useMemo(
+    () => Math.max(bufferedPercentage, cachedPercentage),
+    [bufferedPercentage, cachedPercentage],
+  );
+
   useEffect(() => {
     if (!isDragging) {
       dragPercentageRef.current = progressPercentage;
@@ -91,8 +103,8 @@ const ProgressBarComponent: React.FC<ProgressBarProps> = ({
   const displayPercentage = isDragging ? dragPercentage : progressPercentage;
 
   const bufferedStyle = useMemo(() => ({
-    width: bufferedPercentage * trackWidth,
-  }), [bufferedPercentage, trackWidth]);
+    width: bufferLinePercentage * trackWidth,
+  }), [bufferLinePercentage, trackWidth]);
 
   const progressStyle = useMemo(() => ({
     width: displayPercentage * trackWidth,
@@ -113,7 +125,7 @@ const ProgressBarComponent: React.FC<ProgressBarProps> = ({
       <View style={styles.progressTouchArea} {...panResponder.panHandlers}>
         <View ref={trackRef} style={styles.progressTrack}>
           <View style={styles.progressBackground} />
-          {bufferedPercentage > 0 && <View style={[styles.progressBuffered, bufferedStyle]} />}
+          {bufferLinePercentage > 0 && <View style={[styles.progressBuffered, bufferedStyle]} />}
           <View style={[styles.progressForeground, progressStyle]} />
           <Animated.View style={[styles.progressThumb, thumbStyle]} />
         </View>
diff --git a/src/components/MediaPlayer/controls/styles.ts b/src/components/MediaPlayer/controls/styles.ts
index fb56838..129a81a 100644
--- a/src/components/MediaPlayer/controls/styles.ts
+++ b/src/components/MediaPlayer/controls/styles.ts
@@ -227,7 +227,7 @@ export const styles = StyleSheet.create({
     top: 0,
     left: 0,
     bottom: 0,
-    backgroundColor: 'rgba(255, 255, 255, 0.4)',
+    backgroundColor: 'rgba(255, 255, 255, 0.55)',
     borderRadius: 2,
   },
   progressForeground: {
@@ -284,18 +284,4 @@ export const styles = StyleSheet.create({
     fontSize: 11,
     fontWeight: '600',
   },
-  cacheBadge: {
-    position: 'absolute',
-    top: 48,
-    right: 12,
-    backgroundColor: 'rgba(0,0,0,0.65)',
-    paddingHorizontal: 8,
-    paddingVertical: 4,
-    borderRadius: 4,
-  },
-  cacheBadgeText: {
-    color: colors.white,
-    fontSize: 11,
-    fontWeight: '600',
-  },
 });
diff --git a/src/components/MediaPlayer/controls/types.ts b/src/components/MediaPlayer/controls/types.ts
index 8f386fa..e6c8974 100644
--- a/src/components/MediaPlayer/controls/types.ts
+++ b/src/components/MediaPlayer/controls/types.ts
@@ -34,7 +34,7 @@ export interface ControlsProps {
   subtitleDelay?: number;
   onSubtitleDelayChange?: (delta: number) => void;
   onResetSubtitleDelay?: () => void;
-  cacheAheadSeconds?: number;
+  cachedAheadSeconds?: number;
 }
 
 export interface DoubleTapSeekAreaProps {
@@ -86,12 +86,14 @@ export interface BottomBarProps {
   subtitleDelay?: number;
   onSubtitleDelayChange?: (delta: number) => void;
   onResetSubtitleDelay?: () => void;
+  cachedAheadSeconds?: number;
 }
 
 export interface ProgressBarProps {
   currentPosition: number;
   duration: number;
   bufferedPosition?: number;
+  cachedAheadSeconds?: number;
   hidden: boolean;
   onSeek: (time: number) => void;
   onTimePreview: (time: number) => void;
diff --git a/src/components/MediaPlayer/index.tsx b/src/components/MediaPlayer/index.tsx
index 56f5b1c..529e60f 100644
--- a/src/components/MediaPlayer/index.tsx
+++ b/src/components/MediaPlayer/index.tsx
@@ -8,6 +8,7 @@ import { useAppState } from '../../hooks/useAppState';
 import { usePlaybackCache } from '../../hooks/usePlaybackCache';
 import { SubtitleTrack, DEFAULT_SUBTITLE_STYLE } from '../../types';
 import { VIDEO_STREAM_HEADERS } from '../../utils/streamHeaders';
+import { convertSrtToVtt } from '../../utils/subtitleUtils';
 import { SubtitleSelector } from '../';
 import { SubtitleOverlay } from './SubtitleOverlay';
 import Controls from './controls';
@@ -23,33 +24,6 @@ const { width: screenWidth, height: screenHeight } = Dimensions.get('window');
 const RESIZE_MODES = ['contain', 'cover', 'stretch', 'none'] as const;
 const NEXT_EPISODE_THRESHOLD = 150;
 
-const convertSrtToVtt = (srtContent: string): string => {
-  // Add VTT header
-  let vttContent = 'WEBVTT\n\n';
-  
-  // Split by double newline to get subtitle blocks
-  const blocks = srtContent.trim().split(/\r?\n\r?\n/);
-  
-  for (const block of blocks) {
-    const lines = block.trim().split(/\r?\n/);
-    if (lines.length < 2) continue;
-    
-    // Find the timestamp line (contains -->)
-    const timestampIndex = lines.findIndex(line => line.includes('-->'));
-    if (timestampIndex === -1) continue;
-    
-    // Convert SRT timestamps (00:00:01,000) to VTT format (00:00:01.000)
-    const timestampLine = lines[timestampIndex].replace(/,/g, '.');
-    const textLines = lines.slice(timestampIndex + 1);
-    
-    if (textLines.length > 0) {
-      vttContent += `${timestampLine}\n${textLines.join('\n')}\n\n`;
-    }
-  }
-  
-  return vttContent;
-};
-
 interface MediaPlayerProps {
   videoUrl: string;
   title: string;
@@ -96,6 +70,7 @@ const MediaPlayer: React.FC<MediaPlayerProps> = ({
   const [hasStartedFromProgress, setHasStartedFromProgress] = useState(false);
   const [showSubtitleSelector, setShowSubtitleSelector] = useState(false);
   const [isSeeking, setIsSeeking] = useState(false);
+  const [bufferedPosition, setBufferedPosition] = useState(0);
 
   const [subtitleContent, setSubtitleContent] = useState<string | null>(null);
   const [subtitleVttPath, setSubtitleVttPath] = useState<string | null>(null);
@@ -221,8 +196,11 @@ const MediaPlayer: React.FC<MediaPlayerProps> = ({
     }
   }, [currentTime, hasStartedFromProgress]);
 
-  const handleProgress = useCallback(({ currentTime: time }: { currentTime: number }) => {
+  const handleProgress = useCallback(({ currentTime: time, playableDuration }: { currentTime: number; playableDuration?: number }) => {
     setCurrentTime(time);
+    if (typeof playableDuration === 'number' && Number.isFinite(playableDuration)) {
+      setBufferedPosition(playableDuration);
+    }
     onPlaybackProgress(time);
   }, [onPlaybackProgress]);
 
@@ -250,9 +228,10 @@ const MediaPlayer: React.FC<MediaPlayerProps> = ({
       const clampedTime = Math.max(0, Math.min(time, duration));
       videoRef.current.seek(clampedTime);
       setCurrentTime(clampedTime);
+      onPlaybackProgress(clampedTime);
       showControls();
     }
-  }, [duration, showControls]);
+  }, [duration, onPlaybackProgress, showControls]);
 
   const handleResizeModeToggle = useCallback(() => {
     setResizeMode(prev => (prev + 1) % RESIZE_MODES.length);
@@ -295,7 +274,8 @@ const MediaPlayer: React.FC<MediaPlayerProps> = ({
 
         const sanitizedTitle = selectedSubtitle.title.replace(/[^a-z0-9]/gi, '_').toLowerCase() + `_${contentId}` + (season && episode ? `_s${season}e${episode}` : '');
         const srtFilename = `${sanitizedTitle}_${selectedSubtitle.language}.srt`;
-        const vttFilename = `${sanitizedTitle}_${selectedSubtitle.language}.vtt`;
+        const delayKey = subtitleDelay.toFixed(1).replace('.', 'p');
+        const vttFilename = `${sanitizedTitle}_${selectedSubtitle.language}_d${delayKey}.vtt`;
         const srtPath = `${subtitlesDir}/${srtFilename}`;
         const vttPath = `${subtitlesDir}/${vttFilename}`;
 
@@ -316,13 +296,9 @@ const MediaPlayer: React.FC<MediaPlayerProps> = ({
         }
         
         setSubtitleContent(srtContent);
-        
-        const vttExists = await RNFS.exists(vttPath);
-        if (!vttExists) {
-          const vttContent = convertSrtToVtt(srtContent);
-          await RNFS.writeFile(vttPath, vttContent, 'utf8');
-        }
-        
+
+        const vttContent = convertSrtToVtt(srtContent, subtitleDelay);
+        await RNFS.writeFile(vttPath, vttContent, 'utf8');
         setSubtitleVttPath(`file://${vttPath}`);
         
       } catch {
@@ -332,7 +308,7 @@ const MediaPlayer: React.FC<MediaPlayerProps> = ({
     };
 
     downloadAndSaveSubtitle();
-  }, [selectedSubtitle, contentId, season, episode]);
+  }, [selectedSubtitle, contentId, season, episode, subtitleDelay]);
 
 
   const videoContainerStyle = useMemo(() => ({
@@ -390,12 +366,15 @@ const MediaPlayer: React.FC<MediaPlayerProps> = ({
 
   const videoSource = useMemo(() => {
     const uri = playbackUrl;
-    const isCached = uri.startsWith('file://');
-    return {
+    const useStreamHeaders =
+      uri.includes('.m3u8') ||
+      (!uri.startsWith('file://') && !uri.startsWith('/'));
+    const base = {
       uri,
       textTracks,
-      ...(isCached ? {} : { headers: VIDEO_STREAM_HEADERS }),
+      ...(useStreamHeaders ? { headers: VIDEO_STREAM_HEADERS } : {}),
     };
+    return uri.includes('.m3u8') ? { ...base, type: 'm3u8' as const } : base;
   }, [playbackUrl, textTracks]);
 
   if (!videoUrl) {
@@ -416,7 +395,7 @@ const MediaPlayer: React.FC<MediaPlayerProps> = ({
           <Text style={styles.cacheLoadingText}>Buffering ahead…</Text>
         </View>
       )}
-      {playbackUrl && typeof playbackUrl === 'string' && playbackUrl.trim() !== '' ? (
+      {!isCacheLoading && playbackUrl && typeof playbackUrl === 'string' && playbackUrl.trim() !== '' ? (
         <Video
           ref={videoRef}
           source={videoSource}
@@ -447,11 +426,11 @@ const MediaPlayer: React.FC<MediaPlayerProps> = ({
             opacity: 1,
           }}
         />
-      ) : (
+      ) : !isCacheLoading ? (
         <View style={styles.errorContainer}>
           <Text style={styles.errorText}>No valid video URL provided.</Text>
         </View>
-      )}
+      ) : null}
 
       <Controls
         title={title}
@@ -462,6 +441,8 @@ const MediaPlayer: React.FC<MediaPlayerProps> = ({
         playing={isPlaying}
         currentPosition={currentTime}
         duration={duration}
+        bufferedPosition={bufferedPosition}
+        cachedAheadSeconds={cacheStatus.isActive ? cacheStatus.cachedSecondsAhead : 0}
         onSeek={handleSeek}
         fullscreen={isFullscreen}
         onFullscreen={toggleFullscreen}
@@ -481,7 +462,6 @@ const MediaPlayer: React.FC<MediaPlayerProps> = ({
         subtitleDelay={subtitleDelay}
         onSubtitleDelayChange={handleSubtitleDelayChange}
         onResetSubtitleDelay={handleResetSubtitleDelay}
-        cacheAheadSeconds={cacheStatus.isActive ? Math.round(cacheStatus.cachedSecondsAhead) : undefined}
         upperRightComponent={
           <View style={styles.castButtonContainer}>
             <CastButton style={styles.castButton} />
@@ -501,6 +481,7 @@ const MediaPlayer: React.FC<MediaPlayerProps> = ({
 
       <SubtitleSelector
         visible={showSubtitleSelector}
+        variant={isFullscreen ? 'landscape' : 'portrait'}
         onClose={handleCloseSubtitleSelector}
         onSelectSubtitle={handleSubtitleSelect}
         selectedSubtitle={selectedSubtitle}
diff --git a/src/components/tv/TVMediaPlayer.tsx b/src/components/tv/TVMediaPlayer.tsx
index e8beb60..3f682f1 100644
--- a/src/components/tv/TVMediaPlayer.tsx
+++ b/src/components/tv/TVMediaPlayer.tsx
@@ -25,6 +25,7 @@ import Animated, {
 import { useAppState } from '../../hooks/useAppState';
 import { usePlaybackCache } from '../../hooks/usePlaybackCache';
 import { VIDEO_STREAM_HEADERS } from '../../utils/streamHeaders';
+import { convertSrtToVtt } from '../../utils/subtitleUtils';
 import { SubtitleTrack, DEFAULT_SUBTITLE_STYLE } from '../../types';
 import { SubtitleOverlay } from '../MediaPlayer/SubtitleOverlay';
 import { TVSubtitleSelector } from './TVSubtitleSelector';
@@ -50,29 +51,6 @@ interface TVMediaPlayerProps {
   navigation?: any;
 }
 
-// Convert SRT to VTT format
-const convertSrtToVtt = (srtContent: string): string => {
-  let vttContent = 'WEBVTT\n\n';
-  const blocks = srtContent.trim().split(/\r?\n\r?\n/);
-  
-  for (const block of blocks) {
-    const lines = block.trim().split(/\r?\n/);
-    if (lines.length < 2) continue;
-    
-    const timestampIndex = lines.findIndex(line => line.includes('-->'));
-    if (timestampIndex === -1) continue;
-    
-    const timestampLine = lines[timestampIndex].replace(/,/g, '.');
-    const textLines = lines.slice(timestampIndex + 1);
-    
-    if (textLines.length > 0) {
-      vttContent += `${timestampLine}\n${textLines.join('\n')}\n\n`;
-    }
-  }
-  
-  return vttContent;
-};
-
 // Format time helper
 const formatTime = (seconds: number): string => {
   if (!seconds || isNaN(seconds)) return '0:00';
@@ -118,6 +96,7 @@ export const TVMediaPlayer: React.FC<TVMediaPlayerProps> = ({
   // Seekbar drag state
   const [isSeeking, setIsSeeking] = useState(false);
   const [seekBarWidth, setSeekBarWidth] = useState(0);
+  const [bufferedPosition, setBufferedPosition] = useState(0);
   const seekBarRef = useRef<View>(null);
 
   const videoRef = useRef<any>(null);
@@ -246,6 +225,7 @@ export const TVMediaPlayer: React.FC<TVMediaPlayerProps> = ({
           const newTime = percent * duration;
           videoRef.current?.seek(newTime);
           setCurrentTime(newTime);
+          onPlaybackProgress(newTime);
         });
       }
     },
@@ -267,6 +247,7 @@ export const TVMediaPlayer: React.FC<TVMediaPlayerProps> = ({
           const newTime = percent * duration;
           videoRef.current?.seek(newTime);
           setCurrentTime(newTime);
+          onPlaybackProgress(newTime);
         });
       }
       setIsSeeking(false);
@@ -275,7 +256,7 @@ export const TVMediaPlayer: React.FC<TVMediaPlayerProps> = ({
     onPanResponderTerminate: () => {
       setIsSeeking(false);
     },
-  }), [duration, resetControlsTimer]);
+  }), [duration, onPlaybackProgress, resetControlsTimer]);
 
   // Initial progress seek
   useEffect(() => {
@@ -335,8 +316,11 @@ export const TVMediaPlayer: React.FC<TVMediaPlayerProps> = ({
     resetControlsTimer();
   }, [isPlaying, resetControlsTimer]);
 
-  const handleProgress = useCallback(({ currentTime: time }: { currentTime: number }) => {
+  const handleProgress = useCallback(({ currentTime: time, playableDuration }: { currentTime: number; playableDuration?: number }) => {
     setCurrentTime(time);
+    if (typeof playableDuration === 'number' && Number.isFinite(playableDuration)) {
+      setBufferedPosition(playableDuration);
+    }
     onPlaybackProgress(time);
   }, [onPlaybackProgress]);
 
@@ -374,9 +358,10 @@ export const TVMediaPlayer: React.FC<TVMediaPlayerProps> = ({
       const newTime = Math.max(0, Math.min(currentTime + offset, duration));
       videoRef.current.seek(newTime);
       setCurrentTime(newTime);
+      onPlaybackProgress(newTime);
       resetControlsTimer();
     }
-  }, [currentTime, duration, resetControlsTimer]);
+  }, [currentTime, duration, onPlaybackProgress, resetControlsTimer]);
 
   // TV Remote Control Support
   useTVRemote(
@@ -394,33 +379,37 @@ export const TVMediaPlayer: React.FC<TVMediaPlayerProps> = ({
           const newTime = Math.max(0, currentTime - SEEK_AMOUNT);
           videoRef.current.seek(newTime);
           setCurrentTime(newTime);
+          onPlaybackProgress(newTime);
           resetControlsTimer();
         }
-      }, [currentTime, duration, resetControlsTimer]),
+      }, [currentTime, duration, onPlaybackProgress, resetControlsTimer]),
       onRight: useCallback(() => {
         if (videoRef.current && duration > 0) {
           const newTime = Math.min(duration, currentTime + SEEK_AMOUNT);
           videoRef.current.seek(newTime);
           setCurrentTime(newTime);
+          onPlaybackProgress(newTime);
           resetControlsTimer();
         }
-      }, [currentTime, duration, resetControlsTimer]),
+      }, [currentTime, duration, onPlaybackProgress, resetControlsTimer]),
       onRewind: useCallback(() => {
         if (videoRef.current && duration > 0) {
           const newTime = Math.max(0, currentTime - SEEK_AMOUNT_LARGE);
           videoRef.current.seek(newTime);
           setCurrentTime(newTime);
+          onPlaybackProgress(newTime);
           resetControlsTimer();
         }
-      }, [currentTime, duration, resetControlsTimer]),
+      }, [currentTime, duration, onPlaybackProgress, resetControlsTimer]),
       onFastForward: useCallback(() => {
         if (videoRef.current && duration > 0) {
           const newTime = Math.min(duration, currentTime + SEEK_AMOUNT_LARGE);
           videoRef.current.seek(newTime);
           setCurrentTime(newTime);
+          onPlaybackProgress(newTime);
           resetControlsTimer();
         }
-      }, [currentTime, duration, resetControlsTimer]),
+      }, [currentTime, duration, onPlaybackProgress, resetControlsTimer]),
       onBack: useCallback(() => {
         setIsPlaying(false);
         if (onBack) {
@@ -542,6 +531,15 @@ export const TVMediaPlayer: React.FC<TVMediaPlayerProps> = ({
     width: `${progressWidth.value}%`,
   }));
 
+  const bufferLinePct = useMemo(() => {
+    if (duration <= 0) return 0;
+    const bufferedPct = bufferedPosition / duration;
+    const cachedPct = cacheStatus.isActive
+      ? Math.min((currentTime + cacheStatus.cachedSecondsAhead) / duration, 1)
+      : 0;
+    return Math.max(bufferedPct, cachedPct);
+  }, [bufferedPosition, cacheStatus.cachedSecondsAhead, cacheStatus.isActive, currentTime, duration]);
+
   // Control buttons for TV
   const controlButtons = [
     { key: 'back', icon: 'arrow-left', label: 'Back', onPress: handleGoBack },
@@ -574,12 +572,21 @@ export const TVMediaPlayer: React.FC<TVMediaPlayerProps> = ({
   return (
     <View style={styles.container}>
       {/* Video Player - only render when URL is valid and player is ready */}
-      {isPlayerReady && isValidUrl ? (
+      {isPlayerReady && isValidUrl && !isCacheLoading && playbackUrl ? (
         <Video
           ref={videoRef}
           source={playbackUrl.includes('.m3u8')
-            ? { uri: playbackUrl, headers: playbackUrl.startsWith('file://') ? undefined : VIDEO_STREAM_HEADERS, type: 'm3u8' }
-            : { uri: playbackUrl, headers: playbackUrl.startsWith('file://') ? undefined : VIDEO_STREAM_HEADERS }
+            ? {
+                uri: playbackUrl,
+                headers: VIDEO_STREAM_HEADERS,
+                type: 'm3u8',
+              }
+            : {
+                uri: playbackUrl,
+                headers: playbackUrl.startsWith('file://') || playbackUrl.startsWith('/')
+                  ? undefined
+                  : VIDEO_STREAM_HEADERS,
+              }
           }
           style={styles.video}
           onLoad={handleLoad}
@@ -621,14 +628,6 @@ export const TVMediaPlayer: React.FC<TVMediaPlayerProps> = ({
         </View>
       )}
 
-      {cacheStatus.isActive && cacheStatus.cachedSecondsAhead > 0 && (
-        <View style={styles.cacheBadge}>
-          <Text style={styles.cacheBadgeText}>
-            {Math.round(cacheStatus.cachedSecondsAhead)}s cached
-          </Text>
-        </View>
-      )}
-
       {/* Controls overlay */}
       <Animated.View style={[styles.controlsOverlay, controlsAnimatedStyle]} pointerEvents={showControls ? 'auto' : 'none'}>
         {/* Top bar - Title */}
@@ -676,6 +675,9 @@ export const TVMediaPlayer: React.FC<TVMediaPlayerProps> = ({
               style={styles.progressBackground}
               {...tvSeekPanResponder.panHandlers}
             >
+              {bufferLinePct > 0 && (
+                <View style={[styles.progressBuffered, { width: `${bufferLinePct * 100}%` }]} />
+              )}
               <Animated.View style={[styles.progressFill, progressAnimatedStyle]} />
               {/* Seek thumb */}
               {seekBarWidth > 0 && (
@@ -754,19 +756,6 @@ const styles = StyleSheet.create({
     marginTop: 12,
     fontSize: 16,
   },
-  cacheBadge: {
-    position: 'absolute',
-    top: 20,
-    right: 20,
-    backgroundColor: 'rgba(0,0,0,0.65)',
-    paddingHorizontal: 10,
-    paddingVertical: 6,
-    borderRadius: 4,
-  },
-  cacheBadgeText: {
-    color: '#fff',
-    fontSize: 12,
-  },
   controlsOverlay: {
     ...StyleSheet.absoluteFillObject,
     backgroundColor: 'rgba(0, 0, 0, 0.4)',
@@ -836,10 +825,19 @@ const styles = StyleSheet.create({
     borderRadius: 3,
     overflow: 'visible',
   },
+  progressBuffered: {
+    position: 'absolute',
+    left: 0,
+    top: 0,
+    height: '100%',
+    backgroundColor: 'rgba(255, 255, 255, 0.55)',
+    borderRadius: 3,
+  },
   progressFill: {
     height: '100%',
     backgroundColor: TV_FOCUS_COLOR,
     borderRadius: 3,
+    zIndex: 1,
   },
   progressThumb: {
     position: 'absolute',
diff --git a/src/hooks/usePlaybackCache.ts b/src/hooks/usePlaybackCache.ts
index 669fda1..39074fa 100644
--- a/src/hooks/usePlaybackCache.ts
+++ b/src/hooks/usePlaybackCache.ts
@@ -30,7 +30,7 @@ export function usePlaybackCache({
   const preferences = state.user.preferences.playbackCache ?? DEFAULT_PLAYBACK_CACHE;
   const cacheEnabled = enabled && preferences.enabled && isM3U8Url(videoUrl);
 
-  const [playbackUrl, setPlaybackUrl] = useState(videoUrl);
+  const [playbackUrl, setPlaybackUrl] = useState(() => (cacheEnabled ? '' : videoUrl));
   const [isCacheLoading, setIsCacheLoading] = useState(cacheEnabled);
   const [cacheStatus, setCacheStatus] = useState<PlaybackCacheStatus>(
     playbackCacheService.getCacheStatus(),
@@ -52,6 +52,7 @@ export function usePlaybackCache({
       }
 
       sessionVideoUrlRef.current = videoUrl;
+      setPlaybackUrl('');
       setIsCacheLoading(true);
 
       try {
diff --git a/src/screens/NetflixDetailScreen.tsx b/src/screens/NetflixDetailScreen.tsx
index d338de6..f0f2ba9 100644
--- a/src/screens/NetflixDetailScreen.tsx
+++ b/src/screens/NetflixDetailScreen.tsx
@@ -424,6 +424,7 @@ const NetflixDetailScreen: React.FC<Props> = ({ route, navigation }) => {
   if (showFullPlayer && currentVideoUrl) {
     return (
       <NetflixMediaPlayer
+        key={`${validContent?.id}-${tvState.selectedSeason}-${tvState.selectedEpisode}`}
         videoUrl={currentVideoUrl}
         title={contentTitle}
         contentId={validContent?.id ?? 0}
diff --git a/src/services/PlaybackCacheService.ts b/src/services/PlaybackCacheService.ts
index 1f0354a..0d82923 100644
--- a/src/services/PlaybackCacheService.ts
+++ b/src/services/PlaybackCacheService.ts
@@ -123,7 +123,7 @@ class PlaybackCacheService {
   updatePlayhead(timeSec: number): void {
     if (!this.sessionId) return;
     this.playheadSec = timeSec;
-    this.evictBehindPlayhead();
+    void this.evictBehindPlayhead();
     this.notifyStatus();
   }
 
@@ -264,11 +264,17 @@ class PlaybackCacheService {
     if (cutoffTime < 0) cutoffTime = 0;
     const cutoffIndex = findSegmentIndexAtTime(this.playlist.segments, cutoffTime);
 
+    let evicted = false;
     for (const index of [...this.downloadedIndices]) {
       if (index < cutoffIndex && index < currentIndex - 1) {
         await this.removeSegment(index);
+        evicted = true;
       }
     }
+
+    if (evicted) {
+      await this.writePlaylist(false);
+    }
   }
 
   private async evictOldestOutsideWindow(): Promise<void> {
@@ -316,14 +322,16 @@ class PlaybackCacheService {
       `#EXT-X-MEDIA-SEQUENCE:${this.playlist.mediaSequence}`,
     ];
 
-    const sortedIndices = [...this.downloadedIndices].sort((a, b) => a - b);
-    for (const index of sortedIndices) {
+    // Full timeline: cached segments use local files, the rest keep remote URIs so
+    // the player can continue past the pre-buffer window without reloading the playlist.
+    for (let index = 0; index < this.playlist.segments.length; index++) {
       const segment = this.playlist.segments[index];
-      if (!segment) continue;
-
-      const segmentPath = getSegmentPath(this.sessionDir, index);
       lines.push(`#EXTINF:${segment.duration.toFixed(3)},`);
-      lines.push(`file://${segmentPath}`);
+      if (this.downloadedIndices.has(index)) {
+        lines.push(`file://${getSegmentPath(this.sessionDir, index)}`);
+      } else {
+        lines.push(segment.uri);
+      }
     }
 
     if (finalize || this.playlist.endList) {
diff --git a/src/utils/subtitleUtils.ts b/src/utils/subtitleUtils.ts
index 6d852c0..1493001 100644
--- a/src/utils/subtitleUtils.ts
+++ b/src/utils/subtitleUtils.ts
@@ -1,20 +1,149 @@
 /**
- * Utility functions for subtitle manipulation
+ * Utility functions for subtitle parsing, timing, and format conversion.
  */
 
+export interface SubtitleCue {
+  start: number;
+  end: number;
+  text: string;
+}
+
+const SRT_TIMESTAMP_REGEX =
+  /(\d{2}):(\d{2}):(\d{2})[,.](\d{3})\s*-->\s*(\d{2}):(\d{2}):(\d{2})[,.](\d{3})/;
+
+function parseTimestamp(
+  hours: string,
+  minutes: string,
+  seconds: string,
+  millis: string,
+): number {
+  return (
+    parseInt(hours, 10) * 3600 +
+    parseInt(minutes, 10) * 60 +
+    parseFloat(`${seconds}.${millis}`)
+  );
+}
+
+function formatSrtTimestamp(seconds: number): string {
+  const clamped = Math.max(0, seconds);
+  const hours = Math.floor(clamped / 3600);
+  const minutes = Math.floor((clamped % 3600) / 60);
+  const secs = Math.floor(clamped % 60);
+  const millis = Math.round((clamped % 1) * 1000);
+  return `${hours.toString().padStart(2, '0')}:${minutes
+    .toString()
+    .padStart(2, '0')}:${secs.toString().padStart(2, '0')},${millis
+    .toString()
+    .padStart(3, '0')}`;
+}
+
+function formatVttTimestamp(seconds: number): string {
+  return formatSrtTimestamp(seconds).replace(',', '.');
+}
+
+export function parseSrtCues(srtContent: string): SubtitleCue[] {
+  const cues: SubtitleCue[] = [];
+  const blocks = srtContent.trim().split(/\r?\n\r?\n/);
+
+  for (const block of blocks) {
+    const lines = block.trim().split(/\r?\n/);
+    if (lines.length < 2) continue;
+
+    const timestampIndex = lines.findIndex((line) => line.includes('-->'));
+    if (timestampIndex === -1) continue;
+
+    const match = lines[timestampIndex].match(SRT_TIMESTAMP_REGEX);
+    if (!match) continue;
+
+    const start = parseTimestamp(match[1], match[2], match[3], match[4]);
+    const end = parseTimestamp(match[5], match[6], match[7], match[8]);
+    const text = lines
+      .slice(timestampIndex + 1)
+      .join('\n')
+      .replace(/<[^>]*>/g, '')
+      .trim();
+
+    if (text && end > start) {
+      cues.push({ start, end, text });
+    }
+  }
+
+  return cues.sort((a, b) => a.start - b.start);
+}
+
+export function findActiveCue(
+  cues: SubtitleCue[],
+  timeSec: number,
+): SubtitleCue | null {
+  if (cues.length === 0) return null;
+
+  let left = 0;
+  let right = cues.length - 1;
+  let candidate = -1;
+
+  while (left <= right) {
+    const mid = Math.floor((left + right) / 2);
+    if (cues[mid].start <= timeSec) {
+      candidate = mid;
+      left = mid + 1;
+    } else {
+      right = mid - 1;
+    }
+  }
+
+  if (candidate === -1) return null;
+
+  const cue = cues[candidate];
+  if (timeSec >= cue.start && timeSec < cue.end) {
+    return cue;
+  }
+
+  return null;
+}
+
+export function applyDelayToSrt(srtContent: string, delaySec: number): string {
+  if (!delaySec) return srtContent;
+
+  const cues = parseSrtCues(srtContent);
+  if (cues.length === 0) return srtContent;
+
+  return cues
+    .map((cue, index) => {
+      const start = formatSrtTimestamp(Math.max(0, cue.start + delaySec));
+      const end = formatSrtTimestamp(Math.max(0, cue.end + delaySec));
+      if (cue.end + delaySec <= 0) return '';
+      return `${index + 1}\n${start} --> ${end}\n${cue.text}`;
+    })
+    .filter(Boolean)
+    .join('\n\n');
+}
+
+export function convertSrtToVtt(srtContent: string, delaySec = 0): string {
+  const source = delaySec ? applyDelayToSrt(srtContent, delaySec) : srtContent;
+  const cues = parseSrtCues(source);
+  let vttContent = 'WEBVTT\n\n';
+
+  for (const cue of cues) {
+    if (cue.end <= 0) continue;
+    const start = formatVttTimestamp(Math.max(0, cue.start));
+    const end = formatVttTimestamp(Math.max(0, cue.end));
+    vttContent += `${start} --> ${end}\n${cue.text}\n\n`;
+  }
+
+  return vttContent;
+}
+
 /**
  * Extracts metadata from VTT content
- * @param vttContent - VTT subtitle content
- * @returns Metadata object with timing info and subtitle count
  */
 export function extractVttMetadata(vttContent: string) {
   const lines = vttContent.split('\n');
   const timingRegex = /(\d{2}:\d{2}:\d{2}\.\d{3})\s*-->\s*(\d{2}:\d{2}:\d{2}\.\d{3})/;
-  
+
   let subtitleCount = 0;
   let firstTimestamp = '';
   let lastTimestamp = '';
-  
+
   for (const line of lines) {
     const match = line.match(timingRegex);
     if (match) {
@@ -25,12 +154,14 @@ export function extractVttMetadata(vttContent: string) {
       lastTimestamp = match[2];
     }
   }
-  
+
   return {
     subtitleCount,
     firstTimestamp,
     lastTimestamp,
-    duration: firstTimestamp && lastTimestamp ? 
-      `${firstTimestamp} to ${lastTimestamp}` : 'Unknown',
+    duration:
+      firstTimestamp && lastTimestamp
+        ? `${firstTimestamp} to ${lastTimestamp}`
+        : 'Unknown',
   };
-}
\ No newline at end of file
+}