diff --git a/nuvio-source.json b/nuvio-source.json
index 06059a82..0ac08b83 100644
--- a/nuvio-source.json
+++ b/nuvio-source.json
@@ -11,7 +11,7 @@
   "apps": [
     {
       "name": "Nuvio",
-      "bundleIdentifier": "com.nuvio.app",
+      "bundleIdentifier": "com.nuvio.hub",
       "developerName": "Tapframe",
       "subtitle": "Media player and discovery app",
       "localizedDescription": "Nuvio is a media player and metadata discovery application for user-provided and user-installed sources.",
@@ -272,4 +272,4 @@
     }
   ],
   "news": []
-}
+}
\ No newline at end of file
diff --git a/src/components/home/AppleTVHero.tsx b/src/components/home/AppleTVHero.tsx
index 18a1e0a1..35976293 100644
--- a/src/components/home/AppleTVHero.tsx
+++ b/src/components/home/AppleTVHero.tsx
@@ -460,7 +460,7 @@ const AppleTVHero: React.FC<AppleTVHeroProps> = ({
         // Fetch video list from TMDB to get the YouTube video ID
         const tmdbApiKey = await TMDBService.getInstance().getApiKey();
         const videosRes = await fetch(
-          `https://api.themoviedb.org/3/${contentType}/${tmdbId}/videos?api_key=${tmdbApiKey}&language=en-US`
+          `https://api.themoviedb.org/3/${contentType}/${tmdbId}/videos?api_key=${tmdbApiKey}`
         );
 
         if (!alive) return;
@@ -475,9 +475,8 @@ const AppleTVHero: React.FC<AppleTVHeroProps> = ({
         const videosData = await videosRes.json();
         const results: any[] = videosData.results ?? [];
 
-        // Pick best YouTube trailer: official trailer > any trailer > teaser > any YouTube video
+        // Pick best YouTube trailer: any trailer > teaser > any YouTube video
         const pick =
-          results.find((v) => v.site === 'YouTube' && v.type === 'Trailer' && v.official) ??
           results.find((v) => v.site === 'YouTube' && v.type === 'Trailer') ??
           results.find((v) => v.site === 'YouTube' && v.type === 'Teaser') ??
           results.find((v) => v.site === 'YouTube');
diff --git a/src/components/metadata/HeroSection.tsx b/src/components/metadata/HeroSection.tsx
index 67f6221c..32743cc9 100644
--- a/src/components/metadata/HeroSection.tsx
+++ b/src/components/metadata/HeroSection.tsx
@@ -1155,8 +1155,9 @@ const HeroSection: React.FC<HeroSectionProps> = memo(({
           logger.info('HeroSection', `Fetching TMDB videos for ${metadata.name} (tmdbId: ${resolvedTmdbId})`);
 
           // Fetch video list from TMDB to get the YouTube video ID
+          const tmdbApiKey = await TMDBService.getInstance().getApiKey();
           const videosRes = await fetch(
-            `https://api.themoviedb.org/3/${contentType}/${resolvedTmdbId}/videos?api_key=d131017ccc6e5462a81c9304d21476de&language=en-US`
+            `https://api.themoviedb.org/3/${contentType}/${resolvedTmdbId}/videos?api_key=${tmdbApiKey}`
           );
 
           if (!alive) return;
@@ -1170,9 +1171,8 @@ const HeroSection: React.FC<HeroSectionProps> = memo(({
           const videosData = await videosRes.json();
           const results: any[] = videosData.results ?? [];
 
-          // Pick best YouTube trailer: official trailer > any trailer > teaser > any YouTube video
+          // Pick best YouTube trailer: any trailer > teaser > any YouTube video
           const pick =
-            results.find((v) => v.site === 'YouTube' && v.type === 'Trailer' && v.official) ??
             results.find((v) => v.site === 'YouTube' && v.type === 'Trailer') ??
             results.find((v) => v.site === 'YouTube' && v.type === 'Teaser') ??
             results.find((v) => v.site === 'YouTube');
@@ -1612,29 +1612,13 @@ const HeroSection: React.FC<HeroSectionProps> = memo(({
           </Animated.View>
         )}
 
-        {/* Hidden preload trailer player - loads in background */}
-        {shouldLoadSecondaryData && settings?.showTrailers && trailerUrl && !trailerLoading && !trailerError && !trailerPreloaded && (
-          <View style={[staticStyles.absoluteFill, { opacity: 0, pointerEvents: 'none' }]}>
-            <TrailerPlayer
-              key={`preload-${trailerUrl}`}
-              trailerUrl={trailerUrl}
-              autoPlay={false}
-              muted={true}
-              style={staticStyles.absoluteFill}
-              hideLoadingSpinner={true}
-              onLoad={handleTrailerPreloaded}
-              onError={handleTrailerError}
-            />
-          </View>
-        )}
-
-        {/* Visible trailer player - rendered on top with fade transition and parallax */}
-        {shouldLoadSecondaryData && settings?.showTrailers && trailerUrl && !trailerLoading && !trailerError && trailerPreloaded && (
+        {/* Single trailer player - starts hidden (opacity 0), fades in when ready */}
+        {shouldLoadSecondaryData && settings?.showTrailers && trailerUrl && !trailerLoading && !trailerError && (
           <Animated.View style={[staticStyles.absoluteFill, {
             opacity: trailerOpacity
           }, trailerParallaxStyle]}>
             <TrailerPlayer
-              key={`visible-${trailerUrl}`}
+              key={`trailer-${trailerUrl}`}
               ref={trailerVideoRef}
               trailerUrl={trailerUrl}
               autoPlay={globalTrailerPlaying}
diff --git a/src/components/metadata/TrailerModal.tsx b/src/components/metadata/TrailerModal.tsx
index 452a4a4f..b49428e4 100644
--- a/src/components/metadata/TrailerModal.tsx
+++ b/src/components/metadata/TrailerModal.tsx
@@ -159,35 +159,28 @@ const TrailerModal: React.FC<TrailerModalProps> = memo(({
   const handleVideoError = useCallback((error: any) => {
     logger.error('TrailerModal', 'Video error:', error);
 
-    // Check if this is a permission/network error that might benefit from retry
     const errorCode = error?.error?.code;
     const isRetryableError = errorCode === -1102 || errorCode === -1009 || errorCode === -1005;
 
     if (isRetryableError && retryCount < 2) {
-      // Silent retry - increment count and try again
       logger.info('TrailerModal', `Retrying video load (attempt ${retryCount + 1}/2)`);
       setRetryCount(prev => prev + 1);
 
-      // Small delay before retry to avoid rapid-fire attempts
-      setTimeout(() => {
-        if (videoRef.current) {
-          // Force video to reload by changing the source briefly
-          setTrailerUrl(null);
-          setTimeout(() => {
-            if (trailerUrl) {
-              setTrailerUrl(trailerUrl);
-            }
-          }, 100);
-        }
-      }, 1000);
+      // Capture current URL before clearing it
+      setTrailerUrl(current => {
+        const urlToRestore = current;
+        setTimeout(() => {
+          setTrailerUrl(urlToRestore);
+        }, 500);
+        return null; // Clear first to force remount
+      });
       return;
     }
 
-    // After 2 retries or for non-retryable errors, show the error
     logger.error('TrailerModal', 'Video error after retries or non-retryable:', error);
     setError('Unable to play trailer. Please try again.');
     setLoading(false);
-  }, [retryCount, trailerUrl]);
+  }, [retryCount]);
 
   const handleTrailerEnd = useCallback(() => {
     setIsPlaying(false);
@@ -270,7 +263,18 @@ const TrailerModal: React.FC<TrailerModalProps> = memo(({
               <View style={styles.playerWrapper}>
                 <Video
                   ref={videoRef}
-                  source={{ uri: trailerUrl }}
+                  source={(() => {
+                    const lower = (trailerUrl || '').toLowerCase();
+                    const looksLikeHls = /\.m3u8(\b|$)/.test(lower) || /hls|playlist|m3u/.test(lower);
+                    if (Platform.OS === 'android') {
+                      const headers = { 'User-Agent': 'Nuvio/1.0 (Android)' };
+                      if (looksLikeHls) {
+                        return { uri: trailerUrl, type: 'm3u8', headers } as any;
+                      }
+                      return { uri: trailerUrl, headers } as any;
+                    }
+                    return { uri: trailerUrl } as any;
+                  })()}
                   style={styles.player}
                   controls={true}
                   paused={!isPlaying}
diff --git a/src/components/metadata/TrailersSection.tsx b/src/components/metadata/TrailersSection.tsx
index 7bc86baa..579a51cc 100644
--- a/src/components/metadata/TrailersSection.tsx
+++ b/src/components/metadata/TrailersSection.tsx
@@ -201,7 +201,7 @@ const TrailersSection: React.FC<TrailersSectionProps> = memo(({
 
         if (type === 'movie') {
           // For movies, just fetch the main videos endpoint
-          const videosEndpoint = `https://api.themoviedb.org/3/movie/${tmdbId}/videos?api_key=${tmdbApiKey}&language=en-US`;
+          const videosEndpoint = `https://api.themoviedb.org/3/movie/${tmdbId}/videos?api_key=${tmdbApiKey}`;
 
           logger.info('TrailersSection', `Fetching movie videos from: ${videosEndpoint}`);
 
@@ -232,7 +232,7 @@ const TrailersSection: React.FC<TrailersSectionProps> = memo(({
           logger.info('TrailersSection', `TV show has ${numberOfSeasons} seasons`);
 
           // Fetch main TV show videos
-          const tvVideosEndpoint = `https://api.themoviedb.org/3/tv/${tmdbId}/videos?api_key=${tmdbApiKey}&language=en-US`;
+          const tvVideosEndpoint = `https://api.themoviedb.org/3/tv/${tmdbId}/videos?api_key=${tmdbApiKey}`;
           const tvResponse = await fetch(tvVideosEndpoint);
 
           if (tvResponse.ok) {
@@ -251,7 +251,7 @@ const TrailersSection: React.FC<TrailersSectionProps> = memo(({
           const seasonPromises = [];
           for (let seasonNum = 1; seasonNum <= numberOfSeasons; seasonNum++) {
             seasonPromises.push(
-              fetch(`https://api.themoviedb.org/3/tv/${tmdbId}/season/${seasonNum}/videos?api_key=${tmdbApiKey}&language=en-US`)
+              fetch(`https://api.themoviedb.org/3/tv/${tmdbId}/season/${seasonNum}/videos?api_key=${tmdbApiKey}`)
                 .then(res => res.json())
                 .then(data => ({
                   seasonNumber: seasonNum,
diff --git a/src/components/video/TrailerPlayer.tsx b/src/components/video/TrailerPlayer.tsx
index cd5d9e75..b7aa6162 100644
--- a/src/components/video/TrailerPlayer.tsx
+++ b/src/components/video/TrailerPlayer.tsx
@@ -374,26 +374,18 @@ const TrailerPlayer = React.forwardRef<any, TrailerPlayerProps>(({
       <Video
         ref={videoRef}
         source={(() => {
-          const androidHeaders = Platform.OS === 'android' ? { 'User-Agent': 'Nuvio/1.0 (Android)' } : {} as any;
           const lower = (trailerUrl || '').toLowerCase();
           const looksLikeHls = /\.m3u8(\b|$)/.test(lower) || /hls|applehlsencryption|playlist|m3u/.test(lower);
-          // Detect both .mpd URLs and inline data: DASH manifests
-          const looksLikeDash = /\.mpd(\b|$)/.test(lower) || /dash|manifest/.test(lower) || lower.startsWith('data:application/dash');
           if (Platform.OS === 'android') {
+            const androidHeaders = { 'User-Agent': 'Nuvio/1.0 (Android)' };
             if (looksLikeHls) {
               return { uri: trailerUrl, type: 'm3u8', headers: androidHeaders } as any;
             }
-            if (looksLikeDash) {
-              return { uri: trailerUrl, type: 'mpd', headers: androidHeaders } as any;
-            }
             return { uri: trailerUrl, headers: androidHeaders } as any;
           }
           return { uri: trailerUrl } as any;
         })()}
-        style={[
-          styles.video,
-          contentType === 'movie' && styles.movieVideoScale,
-        ]}
+        style={styles.video}
         resizeMode="cover"
         paused={!isPlaying}
         repeat={false}
@@ -524,9 +516,7 @@ const styles = StyleSheet.create({
     width: '100%',
     height: '100%',
   },
-  movieVideoScale: {
-    transform: [{ scale: 1.30 }], // Custom scale for movies to crop black bars
-  },
+
   videoOverlay: {
     position: 'absolute',
     top: 0,
diff --git a/src/contexts/TrailerContext.tsx b/src/contexts/TrailerContext.tsx
index 53c1438d..10f9573a 100644
--- a/src/contexts/TrailerContext.tsx
+++ b/src/contexts/TrailerContext.tsx
@@ -10,7 +10,7 @@ interface TrailerContextValue {
 const TrailerContext = createContext<TrailerContextValue | undefined>(undefined);
 
 export const TrailerProvider: React.FC<{ children: ReactNode }> = ({ children }) => {
-  const [isTrailerPlaying, setIsTrailerPlaying] = useState(true);
+  const [isTrailerPlaying, setIsTrailerPlaying] = useState(false);
 
   const pauseTrailer = useCallback(() => {
     setIsTrailerPlaying(false);
diff --git a/src/screens/ContributorsScreen.tsx b/src/screens/ContributorsScreen.tsx
index 75dfe841..581d6b16 100644
--- a/src/screens/ContributorsScreen.tsx
+++ b/src/screens/ContributorsScreen.tsx
@@ -289,7 +289,7 @@ const DonorCard: React.FC<DonorCardProps> = ({ donor, currentTheme, isTablet })
           { color: currentTheme.colors.mediumEmphasis },
           isTablet && styles.tabletContributions
         ]}>
-          {donor.amount.toFixed(2)} {donor.currency} · {formatDonationDate(donor.date)}
+          {formatDonationDate(donor.date)}
         </Text>
         {donor.message ? (
           <Text style={[styles.donorMessage, { color: currentTheme.colors.mediumEmphasis }]}>
@@ -876,7 +876,7 @@ const ContributorsScreen: React.FC = () => {
                           { color: currentTheme.colors.mediumEmphasis },
                           isTablet && styles.tabletContributions
                         ]}>
-                          {entry.total.toFixed(2)} {entry.currency} · {entry.count} {entry.count === 1 ? 'donation' : 'donations'}
+                          {entry.count} {entry.count === 1 ? 'donation' : 'donations'}
                         </Text>
                         <Text style={[styles.donorMessage, { color: currentTheme.colors.mediumEmphasis }]}>
                           Rank #{entry.rank} · Last: {formatDonationDate(entry.lastDate)}
diff --git a/src/services/trailerService.ts b/src/services/trailerService.ts
index 000f6b1b..0bb11cae 100644
--- a/src/services/trailerService.ts
+++ b/src/services/trailerService.ts
@@ -14,20 +14,8 @@ interface CacheEntry {
 }
 
 export class TrailerService {
-  // ---- Remote server (fallback only) ----
-  private static readonly ENV_LOCAL_BASE =
-    process.env.EXPO_PUBLIC_TRAILER_LOCAL_BASE || 'http://46.62.173.157:3001';
-  private static readonly ENV_LOCAL_TRAILER_PATH =
-    process.env.EXPO_PUBLIC_TRAILER_LOCAL_TRAILER_PATH || '/trailer';
-  private static readonly ENV_LOCAL_SEARCH_PATH =
-    process.env.EXPO_PUBLIC_TRAILER_LOCAL_SEARCH_PATH || '/search-trailer';
-
-  private static readonly LOCAL_SERVER_URL = `${TrailerService.ENV_LOCAL_BASE}${TrailerService.ENV_LOCAL_TRAILER_PATH}`;
-  private static readonly AUTO_SEARCH_URL = `${TrailerService.ENV_LOCAL_BASE}${TrailerService.ENV_LOCAL_SEARCH_PATH}`;
-  private static readonly SERVER_TIMEOUT = 20000;
-
-  // YouTube CDN URLs expire ~6h; cache for 5h
-  private static readonly CACHE_TTL_MS = 5 * 60 * 60 * 1000;
+  // Cache for 3 minutes — just enough to avoid re-extracting on quick re-renders
+  private static readonly CACHE_TTL_MS = 30 * 1000;
   private static urlCache = new Map<string, CacheEntry>();
 
   // ---------------------------------------------------------------------------
@@ -36,7 +24,7 @@ export class TrailerService {
 
   /**
    * Get a playable stream URL from a raw YouTube video ID (e.g. from TMDB).
-   * Tries on-device extraction first, falls back to remote server.
+   * Uses on-device extraction only.
    */
   static async getTrailerFromVideoId(
     youtubeVideoId: string,
@@ -53,30 +41,19 @@ export class TrailerService {
       return cached;
     }
 
-    // 1. On-device extraction via Innertube
     try {
       const platform = Platform.OS === 'android' ? 'android' : 'ios';
       const url = await YouTubeExtractor.getBestStreamUrl(youtubeVideoId, platform);
       if (url) {
-        logger.info('TrailerService', `On-device extraction succeeded for ${youtubeVideoId}`);
+        logger.info('TrailerService', `Extraction succeeded for ${youtubeVideoId}`);
         this.setCache(youtubeVideoId, url);
         return url;
       }
-      logger.warn('TrailerService', `On-device extraction returned null for ${youtubeVideoId}`);
+      logger.warn('TrailerService', `Extraction returned null for ${youtubeVideoId}`);
     } catch (err) {
-      logger.warn('TrailerService', `On-device extraction threw for ${youtubeVideoId}:`, err);
+      logger.warn('TrailerService', `Extraction threw for ${youtubeVideoId}:`, err);
     }
 
-    // 2. Server fallback
-    logger.info('TrailerService', `Falling back to server for ${youtubeVideoId}`);
-    const youtubeUrl = `https://www.youtube.com/watch?v=${youtubeVideoId}`;
-    const serverUrl = await this.fetchFromServer(youtubeUrl, title, year?.toString());
-    if (serverUrl) {
-      this.setCache(youtubeVideoId, serverUrl);
-      return serverUrl;
-    }
-
-    logger.warn('TrailerService', `Both on-device and server failed for ${youtubeVideoId}`);
     return null;
   }
 
@@ -94,8 +71,7 @@ export class TrailerService {
     const videoId = YouTubeExtractor.parseVideoId(youtubeUrl);
     if (!videoId) {
       logger.warn('TrailerService', `Could not parse video ID from: ${youtubeUrl}`);
-      // No video ID — try server directly with the raw URL
-      return this.fetchFromServer(youtubeUrl, title, year);
+      return null;
     }
 
     return this.getTrailerFromVideoId(
@@ -107,43 +83,24 @@ export class TrailerService {
 
   /**
    * Called by AppleTVHero and HeroSection which only have title/year/tmdbId.
-   * No YouTube video ID available — goes straight to server search.
+   * Without a YouTube video ID there is nothing to extract — returns null.
+   * Callers should ensure they pass a video ID via getTrailerFromVideoId instead.
    */
   static async getTrailerUrl(
     title: string,
     year: number,
-    tmdbId?: string,
-    type?: 'movie' | 'tv'
+    _tmdbId?: string,
+    _type?: 'movie' | 'tv'
   ): Promise<string | null> {
-    logger.warn(
-      'TrailerService',
-      `getTrailerUrl called for "${title}" — no YouTube video ID, using server search`
-    );
-
-    const cacheKey = `search:${title}:${year}:${tmdbId ?? ''}`;
-    const cached = this.getCached(cacheKey);
-    if (cached) return cached;
-
-    const serverResult = await this.getTrailerFromServer(title, year, tmdbId, type);
-    if (serverResult) {
-      this.setCache(cacheKey, serverResult);
-    }
-    return serverResult;
+    logger.warn('TrailerService', `getTrailerUrl called for "${title}" but no YouTube video ID available — cannot extract`);
+    return null;
   }
 
   // ---------------------------------------------------------------------------
-  // Unchanged public helpers (API compatibility)
+  // Public helpers (API compatibility)
   // ---------------------------------------------------------------------------
 
   static getBestFormatUrl(url: string): string {
-    if (url.includes('formats=')) {
-      if (url.includes('M3U')) {
-        return `${url.split('?')[0]}?formats=M3U+none,M3U+appleHlsEncryption`;
-      }
-      if (url.includes('MPEG4')) {
-        return `${url.split('?')[0]}?formats=MPEG4`;
-      }
-    }
     return url;
   }
 
@@ -154,92 +111,21 @@ export class TrailerService {
   static async getTrailerData(title: string, year: number): Promise<TrailerData | null> {
     const url = await this.getTrailerUrl(title, year);
     if (!url) return null;
-    return { url: this.getBestFormatUrl(url), title, year };
+    return { url, title, year };
   }
 
-  static setUseLocalServer(_useLocal: boolean): void {
-    logger.info('TrailerService', 'setUseLocalServer: server used as fallback only');
-  }
+  static setUseLocalServer(_useLocal: boolean): void {}
 
   static getServerStatus(): { usingLocal: boolean; localUrl: string } {
-    return { usingLocal: true, localUrl: this.LOCAL_SERVER_URL };
+    return { usingLocal: false, localUrl: '' };
   }
 
   static async testServers(): Promise<{
     localServer: { status: 'online' | 'offline'; responseTime?: number };
   }> {
-    try {
-      const t = Date.now();
-      const r = await fetch(`${this.AUTO_SEARCH_URL}?title=test&year=2023`, {
-        signal: AbortSignal.timeout(5000),
-      });
-      if (r.ok || r.status === 404) {
-        return { localServer: { status: 'online', responseTime: Date.now() - t } };
-      }
-    } catch { /* offline */ }
     return { localServer: { status: 'offline' } };
   }
 
-  // ---------------------------------------------------------------------------
-  // Private — server requests
-  // ---------------------------------------------------------------------------
-
-  private static async getTrailerFromServer(
-    title: string,
-    year: number,
-    tmdbId?: string,
-    type?: 'movie' | 'tv'
-  ): Promise<string | null> {
-    const params = new URLSearchParams({ title, year: year.toString() });
-    if (tmdbId) {
-      params.append('tmdbId', tmdbId);
-      params.append('type', type ?? 'movie');
-    }
-    return this.doServerFetch(`${this.AUTO_SEARCH_URL}?${params}`);
-  }
-
-  private static async fetchFromServer(
-    youtubeUrl: string,
-    title?: string,
-    year?: string
-  ): Promise<string | null> {
-    const params = new URLSearchParams({ youtube_url: youtubeUrl });
-    if (title) params.append('title', title);
-    if (year) params.append('year', year);
-    return this.doServerFetch(`${this.LOCAL_SERVER_URL}?${params}`);
-  }
-
-  private static async doServerFetch(url: string): Promise<string | null> {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), this.SERVER_TIMEOUT);
-    try {
-      const res = await fetch(url, {
-        headers: { Accept: 'application/json', 'User-Agent': 'Nuvio/1.0' },
-        signal: controller.signal,
-      });
-      clearTimeout(timer);
-      if (!res.ok) {
-        logger.warn('TrailerService', `Server ${res.status} for ${url}`);
-        return null;
-      }
-      const data = await res.json();
-      if (!data.url || !this.isValidTrailerUrl(data.url)) {
-        logger.warn('TrailerService', `Server returned invalid URL: ${data.url}`);
-        return null;
-      }
-      logger.info('TrailerService', `Server fallback succeeded: ${String(data.url).substring(0, 80)}`);
-      return data.url as string;
-    } catch (err) {
-      clearTimeout(timer);
-      if (err instanceof Error && err.name === 'AbortError') {
-        logger.warn('TrailerService', `Server timed out: ${url}`);
-      } else {
-        logger.warn('TrailerService', `Server fetch error:`, err);
-      }
-      return null;
-    }
-  }
-
   // ---------------------------------------------------------------------------
   // Private — cache
   // ---------------------------------------------------------------------------
@@ -251,11 +137,21 @@ export class TrailerService {
       this.urlCache.delete(key);
       return null;
     }
-    // Don't return cached .mpd file paths — the temp file may no longer exist
-    // after an app restart, and we'd rather re-extract than serve a dead file URI
-    if (entry.url.endsWith('.mpd')) {
-      this.urlCache.delete(key);
-      return null;
+    // Check the URL's own CDN expiry — googlevideo.com URLs carry an `expire`
+    // param (Unix timestamp). Treat as stale if it expires within 2 minutes.
+    if (entry.url.includes('googlevideo.com')) {
+      try {
+        const u = new URL(entry.url);
+        const expire = u.searchParams.get('expire');
+        if (expire) {
+          const expiresAt = parseInt(expire, 10) * 1000;
+          if (Date.now() > expiresAt - 2 * 60 * 1000) {
+            logger.info('TrailerService', `Cached URL expired or expiring soon — re-extracting`);
+            this.urlCache.delete(key);
+            return null;
+          }
+        }
+      } catch { /* ignore */ }
     }
     return entry.url;
   }
@@ -267,26 +163,6 @@ export class TrailerService {
       if (oldest) this.urlCache.delete(oldest);
     }
   }
-
-  // ---------------------------------------------------------------------------
-  // Private — URL validation
-  // ---------------------------------------------------------------------------
-
-  private static isValidTrailerUrl(url: string): boolean {
-    try {
-      const u = new URL(url);
-      if (!['http:', 'https:'].includes(u.protocol)) return false;
-      const host = u.hostname.toLowerCase();
-      return (
-        ['theplatform.com', 'youtube.com', 'youtu.be', 'vimeo.com',
-          'dailymotion.com', 'twitch.tv', 'amazonaws.com',
-          'cloudfront.net', 'googlevideo.com'].some(d => host.includes(d)) ||
-        /\.(mp4|m3u8|mpd|webm|mov)(\?|$)/i.test(u.pathname)
-      );
-    } catch {
-      return false;
-    }
-  }
 }
 
 export default TrailerService;
diff --git a/src/services/youtubeExtractor.ts b/src/services/youtubeExtractor.ts
index 0a1f27e7..d1d0985d 100644
--- a/src/services/youtubeExtractor.ts
+++ b/src/services/youtubeExtractor.ts
@@ -1,478 +1,572 @@
 import { logger } from '../utils/logger';
+import { Platform } from 'react-native';
 
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
 
 interface InnertubeFormat {
-  itag: number;
+  itag?: number;
   url?: string;
-  signatureCipher?: string;
-  mimeType: string;
-  bitrate: number;
+  mimeType?: string;
+  bitrate?: number;
+  averageBitrate?: number;
   width?: number;
   height?: number;
-  contentLength?: string;
-  quality: string;
+  fps?: number;
+  quality?: string;
   qualityLabel?: string;
   audioQuality?: string;
   audioSampleRate?: string;
-  audioChannels?: number;
-  approxDurationMs?: string;
-  lastModified?: string;
-  projectionType?: string;
   initRange?: { start: string; end: string };
   indexRange?: { start: string; end: string };
 }
 
-interface InnertubeStreamingData {
-  formats: InnertubeFormat[];
-  adaptiveFormats: InnertubeFormat[];
-  expiresInSeconds?: string;
-}
-
-interface InnertubePlayerResponse {
-  streamingData?: InnertubeStreamingData;
-  videoDetails?: {
-    videoId: string;
-    title: string;
-    lengthSeconds: string;
-    isLive?: boolean;
-    isLiveDvr?: boolean;
+interface PlayerResponse {
+  streamingData?: {
+    formats?: InnertubeFormat[];
+    adaptiveFormats?: InnertubeFormat[];
+    hlsManifestUrl?: string;
   };
   playabilityStatus?: {
-    status: string;
+    status?: string;
     reason?: string;
   };
 }
 
-export interface ExtractedStream {
+interface StreamCandidate {
+  client: string;
+  priority: number;
   url: string;
-  quality: string;        // e.g. "720p", "480p"
-  mimeType: string;       // e.g. "video/mp4"
-  itag: number;
-  hasAudio: boolean;
-  hasVideo: boolean;
+  score: number;
+  height: number;
+  fps: number;
+  ext: 'mp4' | 'webm' | 'm4a' | 'other';
   bitrate: number;
+  audioSampleRate?: string;
+  mimeType: string;
+}
+
+interface HlsVariant {
+  url: string;
+  width: number;
+  height: number;
+  bandwidth: number;
 }
 
 export interface YouTubeExtractionResult {
-  streams: ExtractedStream[];
-  bestStream: ExtractedStream | null;
+  /** Primary playable URL — HLS manifest, progressive muxed, or video-only adaptive */
+  videoUrl: string;
+  /** Separate audio URL when adaptive video-only is used. null for HLS/progressive. */
+  audioUrl: string | null;
+  quality: string;
   videoId: string;
-  title?: string;
-  durationSeconds?: number;
 }
 
 // ---------------------------------------------------------------------------
-// Constants
+// Constants — matching the Kotlin extractor exactly
 // ---------------------------------------------------------------------------
 
-// Innertube client configs — we use Android (no cipher, direct URLs)
-// and web as fallback (may need cipher decode)
-// Note: ?key= param was deprecated by YouTube in mid-2023 and is no longer sent.
-const INNERTUBE_URL = 'https://www.youtube.com/youtubei/v1/player';
+// Used for all GET requests (watch page, HLS manifest fetch)
+const DEFAULT_USER_AGENT =
+  'Mozilla/5.0 (Linux; Android 12; Android TV) AppleWebKit/537.36 ' +
+  '(KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36';
 
-// Android client gives direct URLs without cipher obfuscation
-const ANDROID_CLIENT_CONTEXT = {
-  client: {
-    clientName: 'ANDROID',
-    clientVersion: '19.44.41',
-    androidSdkVersion: 30,
+const DEFAULT_HEADERS: Record<string, string> = {
+  'accept-language': 'en-US,en;q=0.9',
+  'user-agent': DEFAULT_USER_AGENT,
+};
+
+const PREFERRED_ADAPTIVE_CLIENT = 'android_vr';
+const REQUEST_TIMEOUT_MS = 6000;        // player API + HLS manifest requests
+const WATCH_PAGE_TIMEOUT_MS = 3000;    // watch page scrape — best-effort only
+const MAX_RETRIES = 2;                  // retry extraction up to 2 times on total failure
+
+interface ClientDef {
+  key: string;
+  id: string;
+  version: string;
+  userAgent: string;
+  context: Record<string, any>;
+  priority: number;
+}
+
+// Matching the Kotlin extractor client list exactly (versions updated to current)
+const CLIENTS: ClientDef[] = [
+  {
+    key: 'android_vr',
+    id: '28',
+    version: '1.62.27',
     userAgent:
-      'com.google.android.youtube/19.44.41 (Linux; U; Android 11) gzip',
-    hl: 'en',
-    gl: 'US',
+      'com.google.android.apps.youtube.vr.oculus/1.62.27 ' +
+      '(Linux; U; Android 12; en_US; Quest 3; Build/SQ3A.220605.009.A1) gzip',
+    context: {
+      clientName: 'ANDROID_VR',
+      clientVersion: '1.62.27',
+      deviceMake: 'Oculus',
+      deviceModel: 'Quest 3',
+      osName: 'Android',
+      osVersion: '12',
+      platform: 'MOBILE',
+      androidSdkVersion: 32,
+      hl: 'en',
+      gl: 'US',
+    },
+    priority: 0,
   },
-};
-
-// iOS client as secondary fallback
-const IOS_CLIENT_CONTEXT = {
-  client: {
-    clientName: 'IOS',
-    clientVersion: '19.45.4',
-    deviceModel: 'iPhone16,2',
+  {
+    key: 'android',
+    id: '3',
+    version: '20.10.38',
     userAgent:
-      'com.google.ios.youtube/19.45.4 (iPhone16,2; U; CPU iOS 17_5_1 like Mac OS X)',
-    hl: 'en',
-    gl: 'US',
+      'com.google.android.youtube/20.10.38 (Linux; U; Android 14; en_US) gzip',
+    context: {
+      clientName: 'ANDROID',
+      clientVersion: '20.10.38',
+      osName: 'Android',
+      osVersion: '14',
+      platform: 'MOBILE',
+      androidSdkVersion: 34,
+      hl: 'en',
+      gl: 'US',
+    },
+    priority: 1,
   },
-};
-
-// TV Embedded client — works for age-restricted / embed-allowed content
-const TVHTML5_EMBEDDED_CONTEXT = {
-  client: {
-    clientName: 'TVHTML5_SIMPLY_EMBEDDED_PLAYER',
-    clientVersion: '2.0',
-    hl: 'en',
-    gl: 'US',
+  {
+    key: 'ios',
+    id: '5',
+    version: '20.10.1',
+    userAgent:
+      'com.google.ios.youtube/20.10.1 (iPhone16,2; U; CPU iOS 17_4 like Mac OS X)',
+    context: {
+      clientName: 'IOS',
+      clientVersion: '20.10.1',
+      deviceModel: 'iPhone16,2',
+      osName: 'iPhone',
+      osVersion: '17.4.0.21E219',
+      platform: 'MOBILE',
+      hl: 'en',
+      gl: 'US',
+    },
+    priority: 2,
   },
-};
-
-// Web Embedded client — good fallback for content that rejects app clients
-const WEB_EMBEDDED_CONTEXT = {
-  client: {
-    clientName: 'WEB_EMBEDDED_PLAYER',
-    clientVersion: '2.20240726.00.00',
-    hl: 'en',
-    gl: 'US',
-  },
-  thirdParty: {
-    embedUrl: 'https://www.youtube.com',
-  },
-};
-
-// ---------------------------------------------------------------------------
-// Itag reference tables
-// ---------------------------------------------------------------------------
-
-// Muxed (video+audio in one file).
-// iOS AVPlayer can ONLY use these. Max quality YouTube provides is 720p (itag 22),
-// but it is often absent on modern videos, leaving 360p (itag 18) as the fallback.
-const PREFERRED_MUXED_ITAGS = [
-  22,   // 720p MP4 (video+audio)
-  18,   // 360p MP4 (video+audio)
-  59,   // 480p MP4 (video+audio) — rare
-  78,   // 480p MP4 (video+audio) — rare
 ];
 
-// Adaptive video-only itags, best quality first (MP4 preferred over WebM).
-// Used for DASH on Android only.
-const ADAPTIVE_VIDEO_ITAGS_RANKED = [
-  137,  // 1080p MP4 video-only
-  248,  // 1080p WebM video-only
-  136,  // 720p MP4 video-only
-  247,  // 720p WebM video-only
-  135,  // 480p MP4 video-only
-  244,  // 480p WebM video-only
-  134,  // 360p MP4 video-only
-  243,  // 360p WebM video-only
-];
-
-// Adaptive audio-only itags, best quality first (AAC preferred over Opus).
-// Used for DASH on Android only.
-const ADAPTIVE_AUDIO_ITAGS_RANKED = [
-  141,  // 256kbps AAC
-  140,  // 128kbps AAC  ← most common
-  251,  // 160kbps Opus
-  250,  // 70kbps Opus
-  249,  // 50kbps Opus
-];
-
-const REQUEST_TIMEOUT_MS = 12000;
-
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 
-function extractVideoId(input: string): string | null {
+function parseVideoId(input: string): string | null {
   if (!input) return null;
-
-  // Already a bare video ID (11 chars, alphanumeric + _ -)
-  if (/^[A-Za-z0-9_-]{11}$/.test(input.trim())) {
-    return input.trim();
-  }
-
+  const trimmed = input.trim();
+  if (/^[A-Za-z0-9_-]{11}$/.test(trimmed)) return trimmed;
   try {
-    const url = new URL(input);
-
-    // youtu.be/VIDEO_ID
-    if (url.hostname === 'youtu.be') {
+    const url = new URL(trimmed.startsWith('http') ? trimmed : `https://${trimmed}`);
+    const host = url.hostname.toLowerCase();
+    if (host.endsWith('youtu.be')) {
       const id = url.pathname.slice(1).split('/')[0];
-      if (id && /^[A-Za-z0-9_-]{11}$/.test(id)) return id;
+      if (/^[A-Za-z0-9_-]{11}$/.test(id)) return id;
     }
-
-    // youtube.com/watch?v=VIDEO_ID
     const v = url.searchParams.get('v');
     if (v && /^[A-Za-z0-9_-]{11}$/.test(v)) return v;
-
-    // youtube.com/embed/VIDEO_ID or /shorts/VIDEO_ID
-    const pathMatch = url.pathname.match(/\/(embed|shorts|v)\/([A-Za-z0-9_-]{11})/);
-    if (pathMatch) return pathMatch[2];
+    const m = url.pathname.match(/\/(embed|shorts|live|v)\/([A-Za-z0-9_-]{11})/);
+    if (m) return m[2];
   } catch {
-    // Not a valid URL — try regex fallback
-    const match = input.match(/[?&]v=([A-Za-z0-9_-]{11})/);
-    if (match) return match[1];
+    const m = trimmed.match(/[?&]v=([A-Za-z0-9_-]{11})/);
+    if (m) return m[1];
   }
-
   return null;
 }
 
-function parseMimeType(mimeType: string): { container: string; codecs: string } {
-  // e.g. 'video/mp4; codecs="avc1.64001F, mp4a.40.2"'
-  const [base, codecsPart] = mimeType.split(';');
-  const container = base.trim();
-  const codecs = codecsPart ? codecsPart.replace(/codecs=["']?/i, '').replace(/["']$/, '').trim() : '';
-  return { container, codecs };
+function getMimeBase(mimeType?: string): string {
+  return (mimeType ?? '').split(';')[0].trim();
 }
 
-function isMuxedFormat(format: InnertubeFormat): boolean {
-  // A muxed format has both video and audio codecs in its mimeType
-  const { codecs } = parseMimeType(format.mimeType);
-  // MP4 muxed: "avc1.xxx, mp4a.xxx"
-  // WebM muxed: "vp8, vorbis" etc.
-  return codecs.includes(',') || (!!format.audioQuality && !!format.qualityLabel);
+function getExt(mimeType?: string): 'mp4' | 'webm' | 'm4a' | 'other' {
+  const base = getMimeBase(mimeType);
+  if (base === 'video/mp4' || base === 'audio/mp4') return 'mp4';
+  if (base.includes('webm')) return 'webm';
+  if (base.includes('m4a')) return 'm4a';
+  return 'other';
 }
 
-function isVideoMp4(format: InnertubeFormat): boolean {
-  return format.mimeType.startsWith('video/mp4');
+function containerScore(ext: string): number {
+  return ext === 'mp4' || ext === 'm4a' ? 0 : ext === 'webm' ? 1 : 2;
 }
 
-function formatQualityLabel(format: InnertubeFormat): string {
-  return format.qualityLabel || format.quality || 'unknown';
+function videoScore(height: number, fps: number, bitrate: number): number {
+  return height * 1_000_000_000 + fps * 1_000_000 + bitrate;
 }
 
-function scoreFormat(format: InnertubeFormat): number {
-  const preferredIndex = PREFERRED_MUXED_ITAGS.indexOf(format.itag);
-  const itagBonus = preferredIndex !== -1 ? (PREFERRED_MUXED_ITAGS.length - preferredIndex) * 10000 : 0;
-  const height = format.height ?? 0;
-  const heightScore = Math.min(height, 720) * 10;
-  const bitrateScore = Math.min(format.bitrate ?? 0, 3_000_000) / 1000;
-  return itagBonus + heightScore + bitrateScore;
+function audioScore(bitrate: number, sampleRate: number): number {
+  return bitrate * 1_000_000 + sampleRate;
 }
 
-// ---------------------------------------------------------------------------
-// Adaptive stream helpers (Android/DASH only)
-// ---------------------------------------------------------------------------
-
-function pickBestAdaptiveVideo(adaptiveFormats: InnertubeFormat[]): InnertubeFormat | null {
-  // Video-only: has qualityLabel, no audioQuality, has direct URL
-  const videoOnly = adaptiveFormats.filter(
-    (f) => f.url && f.qualityLabel && !f.audioQuality && f.mimeType.startsWith('video/')
-  );
-  if (videoOnly.length === 0) return null;
-  for (const itag of ADAPTIVE_VIDEO_ITAGS_RANKED) {
-    const match = videoOnly.find((f) => f.itag === itag);
-    if (match) return match;
-  }
-  return videoOnly.sort((a, b) => (b.bitrate ?? 0) - (a.bitrate ?? 0))[0] ?? null;
+function parseQualityLabel(label?: string): number {
+  const m = (label ?? '').match(/(\d{2,4})p/);
+  return m ? parseInt(m[1], 10) : 0;
 }
 
-function pickBestAdaptiveAudio(adaptiveFormats: InnertubeFormat[]): InnertubeFormat | null {
-  // Audio-only: has audioQuality, no qualityLabel, has direct URL
-  const audioOnly = adaptiveFormats.filter(
-    (f) => f.url && f.audioQuality && !f.qualityLabel && f.mimeType.startsWith('audio/')
-  );
-  if (audioOnly.length === 0) return null;
-  for (const itag of ADAPTIVE_AUDIO_ITAGS_RANKED) {
-    const match = audioOnly.find((f) => f.itag === itag);
-    if (match) return match;
-  }
-  return audioOnly.sort((a, b) => (b.bitrate ?? 0) - (a.bitrate ?? 0))[0] ?? null;
-}
-
-/**
- * Write a DASH MPD manifest to a temp file and return its file:// URI.
- *
- * We use a file URI rather than a data: URI because:
- * - ExoPlayer's DefaultDataSource handles file:// URIs natively via FileDataSource.
- * - The .mpd file extension lets ExoPlayer auto-detect the type even without an
- *   explicit 'type' hint — meaning TrailerModal's bare <Video> also works correctly.
- * - Avoids the need for a Buffer/btoa polyfill (not guaranteed in Hermes).
- *
- * Uses expo-file-system which is already in the project's dependencies.
- * Returns null if writing fails.
- */
-async function writeDashManifestToFile(
-  videoFormat: InnertubeFormat,
-  audioFormat: InnertubeFormat,
-  videoId: string,
-  durationSeconds?: number
-): Promise<string | null> {
+function summarizeUrl(url: string): string {
   try {
-    const FileSystem = await import('expo-file-system/legacy');
-    const cacheDir = FileSystem.cacheDirectory;
-    if (!cacheDir) return null;
-
-    const duration = durationSeconds ?? 300;
-    const mediaDurationISO = `PT${duration}S`;
-
-    const videoCodec = parseMimeType(videoFormat.mimeType).codecs.replace(/"/g, '').trim();
-    const audioCodec = parseMimeType(audioFormat.mimeType).codecs.replace(/"/g, '').trim();
-    const videoMime = videoFormat.mimeType.split(';')[0].trim();
-    const audioMime = audioFormat.mimeType.split(';')[0].trim();
-
-    const width = videoFormat.width ?? 1920;
-    const height = videoFormat.height ?? 1080;
-    const videoBandwidth = videoFormat.bitrate ?? 2_000_000;
-    const audioBandwidth = audioFormat.bitrate ?? 128_000;
-    const audioSampleRate = audioFormat.audioSampleRate ?? '44100';
-
-    const escapeXml = (s: string) =>
-      s.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-
-    const videoUrl = escapeXml(videoFormat.url!);
-    const audioUrl = escapeXml(audioFormat.url!);
-
-    // Use proper initRange/indexRange if available (YouTube adaptive streams have these)
-    // Without correct ranges ExoPlayer's DashMediaSource cannot parse the segment index.
-    // Fall back to range "0-0" only as last resort — ExoPlayer will attempt a range request.
-    const vInit = videoFormat.initRange
-      ? `${videoFormat.initRange.start}-${videoFormat.initRange.end}`
-      : '0-0';
-    const vIndex = videoFormat.indexRange
-      ? `${videoFormat.indexRange.start}-${videoFormat.indexRange.end}`
-      : '0-0';
-    const aInit = audioFormat.initRange
-      ? `${audioFormat.initRange.start}-${audioFormat.initRange.end}`
-      : '0-0';
-    const aIndex = audioFormat.indexRange
-      ? `${audioFormat.indexRange.start}-${audioFormat.indexRange.end}`
-      : '0-0';
-
-    const mpd = `<?xml version="1.0" encoding="UTF-8"?>
-<MPD xmlns="urn:mpeg:dash:schema:mpd:2011" type="static" mediaPresentationDuration="${mediaDurationISO}" minBufferTime="PT2S" profiles="urn:mpeg:dash:profile:isoff-on-demand:2011">
-  <Period duration="${mediaDurationISO}">
-    <AdaptationSet id="1" mimeType="${videoMime}" codecs="${videoCodec}" width="${width}" height="${height}" subsegmentAlignment="true" subsegmentStartsWithSAP="1">
-      <Representation id="v1" bandwidth="${videoBandwidth}" width="${width}" height="${height}">
-        <BaseURL>${videoUrl}</BaseURL>
-        <SegmentBase indexRange="${vIndex}">
-          <Initialization range="${vInit}"/>
-        </SegmentBase>
-      </Representation>
-    </AdaptationSet>
-    <AdaptationSet id="2" mimeType="${audioMime}" codecs="${audioCodec}" lang="en" subsegmentAlignment="true" subsegmentStartsWithSAP="1">
-      <Representation id="a1" bandwidth="${audioBandwidth}" audioSamplingRate="${audioSampleRate}">
-        <BaseURL>${audioUrl}</BaseURL>
-        <SegmentBase indexRange="${aIndex}">
-          <Initialization range="${aInit}"/>
-        </SegmentBase>
-      </Representation>
-    </AdaptationSet>
-  </Period>
-</MPD>`;
-
-    const filePath = `${cacheDir}trailer_${videoId}.mpd`;
-    await FileSystem.writeAsStringAsync(filePath, mpd, { encoding: FileSystem.EncodingType.UTF8 });
-    logger.info('YouTubeExtractor', `DASH manifest written: ${filePath}`);
-    return filePath;
-  } catch (err) {
-    logger.warn('YouTubeExtractor', 'writeDashManifestToFile failed:', err);
-    return null;
+    const u = new URL(url);
+    return `${u.hostname}${u.pathname.substring(0, 40)}`;
+  } catch {
+    return url.substring(0, 80);
   }
 }
 
 // ---------------------------------------------------------------------------
-// Core extractor
+// URL validation — HEAD request to check if URL is actually accessible
+// ---------------------------------------------------------------------------
+
+async function validateUrl(url: string, userAgent: string): Promise<boolean> {
+  // Only validate googlevideo.com CDN URLs — other URLs (HLS manifests) are fine
+  if (!url.includes('googlevideo.com')) return true;
+
+  // Check expiry param before making a network request
+  try {
+    const u = new URL(url);
+    const expire = u.searchParams.get('expire');
+    if (expire) {
+      const expiresAt = parseInt(expire, 10) * 1000;
+      if (Date.now() > expiresAt - 30000) {
+        logger.warn('YouTubeExtractor', `URL expired or expiring in <30s: expire=${expire}`);
+        return false;
+      }
+    }
+  } catch { /* ignore URL parse errors */ }
+
+  // Quick HEAD request to confirm URL is accessible
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 4000);
+  try {
+    const res = await fetch(url, {
+      method: 'HEAD',
+      headers: { 'User-Agent': userAgent },
+      signal: controller.signal,
+    });
+    clearTimeout(timer);
+    if (res.status === 403 || res.status === 401) {
+      logger.warn('YouTubeExtractor', `URL validation failed: HTTP ${res.status}`);
+      return false;
+    }
+    return true;
+  } catch (err) {
+    clearTimeout(timer);
+    // Network error or timeout — assume valid and let the player try
+    logger.warn('YouTubeExtractor', `URL validation request failed (assuming valid):`, err);
+    return true;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// android_vr preferred selection — only fall back to other clients if
+// android_vr returned zero formats (likely PO token required for others)
+// ---------------------------------------------------------------------------
+
+function filterPreferAndroidVr(items: StreamCandidate[]): StreamCandidate[] {
+  const fromVr = items.filter(c => c.client === 'android_vr');
+  return fromVr.length > 0 ? fromVr : items;
+}
+
+function sortCandidates(items: StreamCandidate[]): StreamCandidate[] {
+  return [...items].sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    const ca = containerScore(a.ext), cb = containerScore(b.ext);
+    if (ca !== cb) return ca - cb;
+    return a.priority - b.priority;
+  });
+}
+
+function pickBestForClient(
+  items: StreamCandidate[],
+  preferredClient: string,
+): StreamCandidate | null {
+  const fromPreferred = items.filter(c => c.client === preferredClient);
+  const pool = fromPreferred.length > 0 ? fromPreferred : items;
+  return sortCandidates(pool)[0] ?? null;
+}
+
+// ---------------------------------------------------------------------------
+// Watch page — extract API key + visitor data dynamically
+// ---------------------------------------------------------------------------
+
+interface WatchConfig {
+  apiKey: string | null;
+  visitorData: string | null;
+}
+
+async function fetchWatchConfig(videoId: string): Promise<WatchConfig> {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), WATCH_PAGE_TIMEOUT_MS);
+  try {
+    const res = await fetch(
+      `https://www.youtube.com/watch?v=${videoId}&hl=en`,
+      { headers: DEFAULT_HEADERS, signal: controller.signal },
+    );
+    clearTimeout(timer);
+    if (!res.ok) {
+      logger.warn('YouTubeExtractor', `Watch page ${res.status}`);
+      return { apiKey: null, visitorData: null };
+    }
+    const html = await res.text();
+    const apiKey = html.match(/"INNERTUBE_API_KEY":"([^"]+)"/)?.[1] ?? null;
+    const visitorData = html.match(/"VISITOR_DATA":"([^"]+)"/)?.[1] ?? null;
+    logger.info('YouTubeExtractor', `Watch page: apiKey=${apiKey ? 'found' : 'missing'} visitorData=${visitorData ? 'found' : 'missing'}`);
+    return { apiKey, visitorData };
+  } catch (err) {
+    clearTimeout(timer);
+    logger.warn('YouTubeExtractor', 'Watch page error:', err);
+    return { apiKey: null, visitorData: null };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Player API
 // ---------------------------------------------------------------------------
 
 async function fetchPlayerResponse(
   videoId: string,
-  context: object,
-  userAgent: string,
-  clientNameId: string = '3'
-): Promise<InnertubePlayerResponse | null> {
+  client: ClientDef,
+  apiKey: string | null,
+  visitorData: string | null,
+): Promise<PlayerResponse | null> {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
 
+  const endpoint = apiKey
+    ? `https://www.youtube.com/youtubei/v1/player?key=${encodeURIComponent(apiKey)}&prettyPrint=false`
+    : `https://www.youtube.com/youtubei/v1/player?prettyPrint=false`;
+
+  const headers: Record<string, string> = {
+    ...DEFAULT_HEADERS,
+    'content-type': 'application/json',
+    'origin': 'https://www.youtube.com',
+    'referer': `https://www.youtube.com/watch?v=${videoId}`,
+    'x-youtube-client-name': client.id,
+    'x-youtube-client-version': client.version,
+    'user-agent': client.userAgent,
+  };
+  if (visitorData) headers['x-goog-visitor-id'] = visitorData;
+
+  const body = JSON.stringify({
+    videoId,
+    contentCheckOk: true,
+    racyCheckOk: true,
+    context: { client: client.context },
+    playbackContext: {
+      contentPlaybackContext: { html5Preference: 'HTML5_PREF_WANTS' },
+    },
+  });
+
   try {
-    const body = {
-      videoId,
-      context,
-      contentCheckOk: true,
-      racyCheckOk: true,
-    };
-
-    const response = await fetch(
-      `${INNERTUBE_URL}?prettyPrint=false`,
-      {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'User-Agent': userAgent,
-          'X-YouTube-Client-Name': clientNameId,
-          'Origin': 'https://www.youtube.com',
-          'Referer': `https://www.youtube.com/watch?v=${videoId}`,
-        },
-        body: JSON.stringify(body),
-        signal: controller.signal,
-      }
-    );
-
+    const res = await fetch(endpoint, {
+      method: 'POST',
+      headers,
+      body,
+      signal: controller.signal,
+    });
     clearTimeout(timer);
-
-    if (!response.ok) {
-      logger.warn('YouTubeExtractor', `Innertube HTTP ${response.status} for videoId=${videoId}`);
+    if (!res.ok) {
+      logger.warn('YouTubeExtractor', `[${client.key}] HTTP ${res.status}`);
       return null;
     }
-
-    const data: InnertubePlayerResponse = await response.json();
-    return data;
+    return await res.json() as PlayerResponse;
   } catch (err) {
     clearTimeout(timer);
     if (err instanceof Error && err.name === 'AbortError') {
-      logger.warn('YouTubeExtractor', `Request timed out for videoId=${videoId}`);
+      logger.warn('YouTubeExtractor', `[${client.key}] Timed out`);
     } else {
-      logger.warn('YouTubeExtractor', `Fetch error for videoId=${videoId}:`, err);
+      logger.warn('YouTubeExtractor', `[${client.key}] Error:`, err);
     }
     return null;
   }
 }
 
-function parseMuxedFormats(playerResponse: InnertubePlayerResponse): InnertubeFormat[] {
-  const sd = playerResponse.streamingData;
-  if (!sd) return [];
-  const formats: InnertubeFormat[] = [];
-  for (const f of sd.formats ?? []) {
-    if (f.url) formats.push(f);
-  }
-  // Edge case: some adaptive formats are muxed
-  for (const f of sd.adaptiveFormats ?? []) {
-    if (f.url && isMuxedFormat(f)) formats.push(f);
-  }
-  return formats;
-}
+// ---------------------------------------------------------------------------
+// HLS manifest parsing
+// ---------------------------------------------------------------------------
 
-function parseAdaptiveFormats(playerResponse: InnertubePlayerResponse): InnertubeFormat[] {
-  const sd = playerResponse.streamingData;
-  if (!sd) return [];
-  return (sd.adaptiveFormats ?? []).filter((f) => !!f.url);
-}
+async function parseBestHlsVariant(manifestUrl: string): Promise<HlsVariant | null> {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  try {
+    const res = await fetch(manifestUrl, {
+      headers: DEFAULT_HEADERS,
+      signal: controller.signal,
+    });
+    clearTimeout(timer);
+    if (!res.ok) return null;
+    const text = await res.text();
+    const lines = text.split('\n').map(l => l.trim()).filter(Boolean);
 
-function pickBestMuxedStream(
-  muxedFormats: InnertubeFormat[],
-  adaptiveFormats: InnertubeFormat[] = []
-): ExtractedStream | null {
-  // Prefer proper muxed streams (have both video and audio)
-  if (muxedFormats.length > 0) {
-    const mp4Formats = muxedFormats.filter(isVideoMp4);
-    const pool = mp4Formats.length > 0 ? mp4Formats : muxedFormats;
-    const sorted = [...pool].sort((a, b) => scoreFormat(b) - scoreFormat(a));
-    const best = sorted[0];
-    return {
-      url: best.url!,
-      quality: formatQualityLabel(best),
-      mimeType: best.mimeType,
-      itag: best.itag,
-      hasAudio: !!best.audioQuality || isMuxedFormat(best),
-      hasVideo: !!best.qualityLabel || best.mimeType.startsWith('video/'),
-      bitrate: best.bitrate ?? 0,
-    };
-  }
+    let best: HlsVariant | null = null;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (!line.startsWith('#EXT-X-STREAM-INF:')) continue;
+      const nextLine = lines[i + 1];
+      if (!nextLine || nextLine.startsWith('#')) continue;
 
-  // Last resort: if there are no muxed formats at all, use the best video-only
-  // adaptive stream (will have no audio, but at least something plays vs nothing)
-  if (adaptiveFormats.length > 0) {
-    const videoAdaptive = adaptiveFormats.filter(
-      (f) => f.url && f.qualityLabel && f.mimeType.startsWith('video/')
-    );
-    if (videoAdaptive.length > 0) {
-      const sorted = [...videoAdaptive].sort((a, b) => (b.bitrate ?? 0) - (a.bitrate ?? 0));
-      const best = sorted[0];
-      logger.warn('YouTubeExtractor', `No muxed streams — using video-only adaptive itag=${best.itag} (no audio)`);
-      return {
-        url: best.url!,
-        quality: formatQualityLabel(best),
-        mimeType: best.mimeType,
-        itag: best.itag,
-        hasAudio: false,
-        hasVideo: true,
-        bitrate: best.bitrate ?? 0,
-      };
+      // Parse attribute list
+      const attrs: Record<string, string> = {};
+      let key = '', val = '', inKey = true, inQuote = false;
+      for (const ch of line.substring(line.indexOf(':') + 1)) {
+        if (inKey) { if (ch === '=') inKey = false; else key += ch; continue; }
+        if (ch === '"') { inQuote = !inQuote; continue; }
+        if (ch === ',' && !inQuote) {
+          if (key.trim()) attrs[key.trim()] = val.trim();
+          key = ''; val = ''; inKey = true; continue;
+        }
+        val += ch;
+      }
+      if (key.trim()) attrs[key.trim()] = val.trim();
+
+      const res2 = (attrs['RESOLUTION'] ?? '').split('x');
+      const width = parseInt(res2[0] ?? '0', 10) || 0;
+      const height = parseInt(res2[1] ?? '0', 10) || 0;
+      const bandwidth = parseInt(attrs['BANDWIDTH'] ?? '0', 10) || 0;
+
+      let variantUrl = nextLine;
+      if (!variantUrl.startsWith('http')) {
+        try { variantUrl = new URL(variantUrl, manifestUrl).toString(); } catch { /* keep */ }
+      }
+
+      const candidate: HlsVariant = { url: variantUrl, width, height, bandwidth };
+      if (
+        !best ||
+        candidate.height > best.height ||
+        (candidate.height === best.height && candidate.bandwidth > best.bandwidth)
+      ) {
+        best = candidate;
+      }
     }
+    return best;
+  } catch (err) {
+    clearTimeout(timer);
+    logger.warn('YouTubeExtractor', 'HLS manifest parse error:', err);
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Format collection — tries ALL clients, collects from all (matching Kotlin)
+// ---------------------------------------------------------------------------
+
+interface CollectedFormats {
+  progressive: StreamCandidate[];
+  adaptiveVideo: StreamCandidate[];
+  adaptiveAudio: StreamCandidate[];
+  hlsManifests: Array<{ clientKey: string; priority: number; url: string }>;
+}
+
+async function collectAllFormats(
+  videoId: string,
+  apiKey: string | null,
+  visitorData: string | null,
+): Promise<CollectedFormats> {
+  const progressive: StreamCandidate[] = [];
+  const adaptiveVideo: StreamCandidate[] = [];
+  const adaptiveAudio: StreamCandidate[] = [];
+  const hlsManifests: Array<{ clientKey: string; priority: number; url: string }> = [];
+
+  // Fire all client requests in parallel — same approach as Kotlin coroutines
+  const results = await Promise.allSettled(
+    CLIENTS.map(client => fetchPlayerResponse(videoId, client, apiKey, visitorData)
+      .then(resp => ({ client, resp }))
+    )
+  );
+
+  for (const result of results) {
+    if (result.status === 'rejected') {
+      logger.warn('YouTubeExtractor', `Client request rejected:`, result.reason);
+      continue;
+    }
+
+    const { client, resp } = result.value;
+    if (!resp) continue;
+
+    const status = resp.playabilityStatus?.status;
+    if (status && status !== 'OK' && status !== 'CONTENT_CHECK_REQUIRED') {
+      logger.warn('YouTubeExtractor', `[${client.key}] status=${status} reason=${resp.playabilityStatus?.reason ?? ''}`);
+      continue;
+    }
+
+    const sd = resp.streamingData;
+    if (!sd) continue;
+
+    if (sd.hlsManifestUrl) {
+      hlsManifests.push({ clientKey: client.key, priority: client.priority, url: sd.hlsManifestUrl });
+    }
+
+    let nProg = 0, nVid = 0, nAud = 0;
+
+    // Progressive (muxed) formats — matching Kotlin: skip non-video mimeTypes
+    for (const f of (sd.formats ?? [])) {
+      if (!f.url) continue;
+      const mimeBase = getMimeBase(f.mimeType);
+      if (f.mimeType && !mimeBase.startsWith('video/')) continue;
+      const height = f.height ?? parseQualityLabel(f.qualityLabel);
+      const fps = f.fps ?? 0;
+      const bitrate = f.bitrate ?? f.averageBitrate ?? 0;
+      progressive.push({
+        client: client.key,
+        priority: client.priority,
+        url: f.url,
+        score: videoScore(height, fps, bitrate),
+        height,
+        fps,
+        ext: getExt(f.mimeType),
+        bitrate,
+        mimeType: f.mimeType ?? '',
+      });
+      nProg++;
+    }
+
+    // Adaptive formats
+    for (const f of (sd.adaptiveFormats ?? [])) {
+      if (!f.url) continue;
+      const mimeBase = getMimeBase(f.mimeType);
+
+      if (mimeBase.startsWith('video/')) {
+        const height = f.height ?? parseQualityLabel(f.qualityLabel);
+        const fps = f.fps ?? 0;
+        const bitrate = f.bitrate ?? f.averageBitrate ?? 0;
+        adaptiveVideo.push({
+          client: client.key,
+          priority: client.priority,
+          url: f.url,
+          score: videoScore(height, fps, bitrate),
+          height,
+          fps,
+          ext: getExt(f.mimeType),
+          bitrate,
+          mimeType: f.mimeType ?? '',
+        });
+        nVid++;
+      } else if (mimeBase.startsWith('audio/')) {
+        const bitrate = f.bitrate ?? f.averageBitrate ?? 0;
+        const sampleRate = parseFloat(f.audioSampleRate ?? '0') || 0;
+        adaptiveAudio.push({
+          client: client.key,
+          priority: client.priority,
+          url: f.url,
+          score: audioScore(bitrate, sampleRate),
+          height: 0,
+          fps: 0,
+          ext: getExt(f.mimeType),
+          bitrate,
+          audioSampleRate: f.audioSampleRate,
+          mimeType: f.mimeType ?? '',
+        });
+        nAud++;
+      }
+    }
+
+    logger.info('YouTubeExtractor', `[${client.key}] progressive=${nProg} video=${nVid} audio=${nAud} hls=${sd.hlsManifestUrl ? 1 : 0}`);
   }
 
-  return null;
+  return { progressive, adaptiveVideo, adaptiveAudio, hlsManifests };
 }
 
 // ---------------------------------------------------------------------------
@@ -481,165 +575,154 @@ function pickBestMuxedStream(
 
 export class YouTubeExtractor {
   /**
-   * Extract a playable stream URL from a YouTube video ID or URL.
+   * Extract a playable source from a YouTube video ID or URL.
    *
-   * On Android: attempts to build a DASH manifest from high-quality adaptive
-   * streams (up to 1080p) written to a temp .mpd file. Falls back to best
-   * muxed stream (max 720p) if adaptive streams are unavailable or file write fails.
+   * Matches the Kotlin InAppYouTubeExtractor approach:
+   * 1. Fetch watch page for dynamic API key + visitor data
+   * 2. Try ALL clients, collect formats from all that succeed
+   * 3. Pick best HLS variant (by resolution/bandwidth) as primary
+   * 4. Fall back to best progressive (muxed) if no HLS
    *
-   * On iOS: always returns the best muxed stream. AVPlayer has no DASH support.
+   * Note: Unlike the Kotlin version, we do not return separate videoUrl/audioUrl
+   * for adaptive streams — react-native-video cannot merge two sources. HLS
+   * provides the best quality without needing a separate audio track.
    */
   static async extract(
     videoIdOrUrl: string,
-    platform?: 'android' | 'ios'
+    platform?: 'android' | 'ios',
   ): Promise<YouTubeExtractionResult | null> {
-    const videoId = extractVideoId(videoIdOrUrl);
+    const videoId = parseVideoId(videoIdOrUrl);
     if (!videoId) {
-      logger.warn('YouTubeExtractor', `Could not parse video ID from: ${videoIdOrUrl}`);
+      logger.warn('YouTubeExtractor', `Could not parse video ID: ${videoIdOrUrl}`);
       return null;
     }
 
-    logger.info('YouTubeExtractor', `Extracting for videoId=${videoId} platform=${platform ?? 'unknown'}`);
+    const effectivePlatform = platform ?? (Platform.OS === 'android' ? 'android' : 'ios');
 
-    const clients: Array<{ context: object; userAgent: string; name: string; clientNameId: string }> = [
-      {
-        name: 'ANDROID',
-        clientNameId: '3',
-        context: ANDROID_CLIENT_CONTEXT,
-        userAgent: 'com.google.android.youtube/19.44.41 (Linux; U; Android 11) gzip',
-      },
-      {
-        name: 'IOS',
-        clientNameId: '5',
-        context: IOS_CLIENT_CONTEXT,
-        userAgent: 'com.google.ios.youtube/19.45.4 (iPhone16,2; U; CPU iOS 17_5_1 like Mac OS X)',
-      },
-      {
-        name: 'TVHTML5_EMBEDDED',
-        clientNameId: '85',
-        context: TVHTML5_EMBEDDED_CONTEXT,
-        userAgent: 'Mozilla/5.0 (SMART-TV; Linux; Tizen 6.0)',
-      },
-      {
-        name: 'WEB_EMBEDDED',
-        clientNameId: '56',
-        context: WEB_EMBEDDED_CONTEXT,
-        userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36',
-      },
-    ];
-
-    let muxedFormats: InnertubeFormat[] = [];
-    let adaptiveFormats: InnertubeFormat[] = [];
-    let playerResponse: InnertubePlayerResponse | null = null;
-
-    for (const client of clients) {
-      logger.info('YouTubeExtractor', `Trying ${client.name} client...`);
-      const resp = await fetchPlayerResponse(videoId, client.context, client.userAgent, client.clientNameId);
-      if (!resp) continue;
-
-      const status = resp.playabilityStatus?.status;
-      if (status === 'UNPLAYABLE' || status === 'LOGIN_REQUIRED') {
-        logger.warn('YouTubeExtractor', `${client.name}: playabilityStatus=${status}`);
-        continue;
+    for (let attempt = 1; attempt <= MAX_RETRIES + 1; attempt++) {
+      if (attempt > 1) {
+        const delay = attempt * 300;
+        logger.info('YouTubeExtractor', `Retry attempt ${attempt}/${MAX_RETRIES + 1} after ${delay}ms`);
+        await new Promise(resolve => setTimeout(resolve, delay));
       }
-
-      const muxed = parseMuxedFormats(resp);
-      const adaptive = parseAdaptiveFormats(resp);
-
-      if (muxed.length > 0 || adaptive.length > 0) {
-        logger.info('YouTubeExtractor', `${client.name}: ${muxed.length} muxed, ${adaptive.length} adaptive`);
-        muxedFormats = muxed;
-        adaptiveFormats = adaptive;
-        playerResponse = resp;
-        break;
-      }
-
-      logger.warn('YouTubeExtractor', `${client.name} returned no usable formats`);
+      const result = await this.extractOnce(videoId, effectivePlatform);
+      if (result) return result;
+      logger.warn('YouTubeExtractor', `Attempt ${attempt} failed for videoId=${videoId}`);
     }
 
-    if (muxedFormats.length === 0 && adaptiveFormats.length === 0) {
-      logger.warn('YouTubeExtractor', `All clients failed for videoId=${videoId}`);
-      return null;
-    }
-
-    const details = playerResponse?.videoDetails;
-    const durationSeconds = details?.lengthSeconds ? parseInt(details.lengthSeconds, 10) : undefined;
-
-    let bestStream: ExtractedStream | null = null;
-
-    // Android: try DASH via temp .mpd file (works in TrailerPlayer AND TrailerModal)
-    if (platform === 'android' && adaptiveFormats.length > 0) {
-      const bestVideo = pickBestAdaptiveVideo(adaptiveFormats);
-      const bestAudio = pickBestAdaptiveAudio(adaptiveFormats);
-
-      if (bestVideo && bestAudio) {
-        const mpdFilePath = await writeDashManifestToFile(bestVideo, bestAudio, videoId, durationSeconds);
-        if (mpdFilePath) {
-          logger.info(
-            'YouTubeExtractor',
-            `DASH: video=${bestVideo.itag} (${formatQualityLabel(bestVideo)}), audio=${bestAudio.itag}`
-          );
-          bestStream = {
-            url: mpdFilePath,        // file:// path, .mpd extension → ExoPlayer auto-detects DASH
-            quality: formatQualityLabel(bestVideo),
-            mimeType: 'application/dash+xml',
-            itag: bestVideo.itag,
-            hasAudio: true,
-            hasVideo: true,
-            bitrate: (bestVideo.bitrate ?? 0) + (bestAudio.bitrate ?? 0),
-          };
-        } else {
-          logger.warn('YouTubeExtractor', 'DASH file write failed — falling back to muxed');
-        }
-      } else {
-        logger.info(
-          'YouTubeExtractor',
-          `No adaptive pair: video=${bestVideo?.itag ?? 'none'}, audio=${bestAudio?.itag ?? 'none'} — falling back to muxed`
-        );
-      }
-    }
-
-    // iOS or DASH fallback: use best muxed stream (or video-only adaptive as last resort)
-    if (!bestStream) {
-      bestStream = pickBestMuxedStream(muxedFormats, adaptiveFormats);
-      if (bestStream) {
-        logger.info('YouTubeExtractor', `Muxed: itag=${bestStream.itag} quality=${bestStream.quality}`);
-      }
-    }
-
-    const streams: ExtractedStream[] = muxedFormats.map((f) => ({
-      url: f.url!,
-      quality: formatQualityLabel(f),
-      mimeType: f.mimeType,
-      itag: f.itag,
-      hasAudio: !!f.audioQuality || isMuxedFormat(f),
-      hasVideo: !!f.qualityLabel || f.mimeType.startsWith('video/'),
-      bitrate: f.bitrate ?? 0,
-    }));
-
-    return {
-      streams,
-      bestStream,
-      videoId,
-      title: details?.title,
-      durationSeconds,
-    };
+    logger.warn('YouTubeExtractor', `All ${MAX_RETRIES + 1} attempts failed for videoId=${videoId}`);
+    return null;
+  }
+
+  private static async extractOnce(
+    videoId: string,
+    effectivePlatform: 'android' | 'ios',
+  ): Promise<YouTubeExtractionResult | null> {
+    logger.info('YouTubeExtractor', `Extracting videoId=${videoId} platform=${effectivePlatform}`);
+
+    const { apiKey, visitorData } = await fetchWatchConfig(videoId);
+
+    // Step 2: collect formats from all clients
+    const { progressive, adaptiveVideo, adaptiveAudio, hlsManifests } =
+      await collectAllFormats(videoId, apiKey, visitorData);
+
+    logger.info('YouTubeExtractor',
+      `Totals: progressive=${progressive.length} adaptiveVideo=${adaptiveVideo.length} ` +
+      `adaptiveAudio=${adaptiveAudio.length} hls=${hlsManifests.length}`
+    );
+
+    if (progressive.length === 0 && adaptiveVideo.length === 0 && hlsManifests.length === 0) {
+      logger.warn('YouTubeExtractor', `No usable formats for videoId=${videoId}`);
+      return null;
+    }
+
+    // Step 3: pick best HLS variant across all manifests
+    let bestHls: (HlsVariant & { manifestUrl: string }) | null = null;
+    for (const { url } of hlsManifests.sort((a, b) => a.priority - b.priority)) {
+      const variant = await parseBestHlsVariant(url);
+      if (
+        variant &&
+        (!bestHls ||
+          variant.height > bestHls.height ||
+          (variant.height === bestHls.height && variant.bandwidth > bestHls.bandwidth))
+      ) {
+        bestHls = { ...variant, manifestUrl: url };
+      }
+    }
+
+    // Prefer android_vr formats exclusively — other clients may require PO tokens
+    // and return URLs that 403 at the CDN level during playback
+    const preferredProgressive = sortCandidates(filterPreferAndroidVr(progressive));
+    const bestAdaptiveVideo = pickBestForClient(adaptiveVideo, PREFERRED_ADAPTIVE_CLIENT);
+    const bestAdaptiveAudio = pickBestForClient(adaptiveAudio, PREFERRED_ADAPTIVE_CLIENT);
+
+    if (bestHls) logger.info('YouTubeExtractor', `Best HLS: ${bestHls.height}p ${bestHls.bandwidth}bps`);
+    if (preferredProgressive[0]) logger.info('YouTubeExtractor', `Best progressive: ${preferredProgressive[0].height}p client=${preferredProgressive[0].client}`);
+    if (bestAdaptiveVideo) logger.info('YouTubeExtractor', `Best adaptive video: ${bestAdaptiveVideo.height}p client=${bestAdaptiveVideo.client}`);
+    if (bestAdaptiveAudio) logger.info('YouTubeExtractor', `Best adaptive audio: ${bestAdaptiveAudio.bitrate}bps client=${bestAdaptiveAudio.client}`);
+
+    // VR client user agent used for CDN URL validation
+    const vrUserAgent = CLIENTS.find(c => c.key === 'android_vr')!.userAgent;
+
+    // Step 4: select final source with URL validation
+    // Priority: HLS > progressive muxed
+    // HLS manifests don't need validation — they're not CDN segment URLs
+    if (bestHls) {
+      // Return the specific best variant URL, not the master playlist.
+      // Master playlist lets the player pick quality adaptively (often starts low).
+      // Pinning to the best variant ensures consistent high quality playback.
+      logger.info('YouTubeExtractor', `Using HLS variant: ${summarizeUrl(bestHls.url)} ${bestHls.height}p`);
+      return {
+        videoUrl: bestHls.url,
+        audioUrl: null,
+        quality: `${bestHls.height}p`,
+        videoId,
+      };
+    }
+
+    // Validate progressive candidates in order, return first valid one
+    for (const candidate of preferredProgressive) {
+      const valid = await validateUrl(candidate.url, vrUserAgent);
+      if (valid) {
+        logger.info('YouTubeExtractor', `Using progressive: ${summarizeUrl(candidate.url)} ${candidate.height}p`);
+        return {
+          videoUrl: candidate.url,
+          audioUrl: null,
+          quality: `${candidate.height}p`,
+          videoId,
+        };
+      }
+      logger.warn('YouTubeExtractor', `Progressive URL invalid, trying next candidate`);
+    }
+
+    // Last resort: video-only adaptive (no audio, but beats nothing)
+    if (bestAdaptiveVideo) {
+      const valid = await validateUrl(bestAdaptiveVideo.url, vrUserAgent);
+      if (valid) {
+        logger.warn('YouTubeExtractor', `Using video-only adaptive (no audio): ${bestAdaptiveVideo.height}p`);
+        return {
+          videoUrl: bestAdaptiveVideo.url,
+          audioUrl: null,
+          quality: `${bestAdaptiveVideo.height}p`,
+          videoId,
+        };
+      }
+    }
+
+    logger.warn('YouTubeExtractor', `No playable source for videoId=${videoId}`);
+    return null;
   }
 
-  /**
-   * Returns just the best playable URL or null.
-   * Pass platform so the extractor can choose DASH vs muxed.
-   */
   static async getBestStreamUrl(
     videoIdOrUrl: string,
-    platform?: 'android' | 'ios'
+    platform?: 'android' | 'ios',
   ): Promise<string | null> {
     const result = await this.extract(videoIdOrUrl, platform);
-    return result?.bestStream?.url ?? null;
+    return result?.videoUrl ?? null;
   }
 
   static parseVideoId(input: string): string | null {
-    return extractVideoId(input);
+    return parseVideoId(input);
   }
 }