From 879af0a0c2497d10da1cc43510de889c5e713b94 Mon Sep 17 00:00:00 2001
From: CK <86251706+altCK129@users.noreply.github.com>
Date: Thu, 5 Mar 2026 13:43:08 +0530
Subject: [PATCH 01/35] Create build.yml

---
 .github/workflows/build.yml | 95 +++++++++++++++++++++++++++++++++++++
 1 file changed, 95 insertions(+)
 create mode 100644 .github/workflows/build.yml

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
new file mode 100644
index 00000000..6dac6fda
--- /dev/null
+++ b/.github/workflows/build.yml
@@ -0,0 +1,95 @@
+name: Build Android APK
+
+on:
+  workflow_dispatch:
+    inputs:
+      build_type:
+        description: 'Build type'
+        required: true
+        default: 'release'
+        type: choice
+        options:
+          - release
+          - debug
+      commit_sha:
+        description: 'Commit SHA to build from (leave empty for latest)'
+        required: false
+        type: string
+      notes:
+        description: 'Notes (optional)'
+        required: false
+        type: string
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.commit_sha || github.sha }}
+
+      - name: Print build info
+        run: |
+          echo "Building commit: $(git rev-parse HEAD)"
+          echo "Commit message: $(git log -1 --pretty=%B)"
+          echo "Build type: ${{ inputs.build_type }}"
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '18'
+          cache: 'npm'
+
+      - name: Setup Java 17
+        uses: actions/setup-java@v4
+        with:
+          java-version: '17'
+          distribution: 'temurin'
+
+      - name: Setup Android SDK
+        uses: android-actions/setup-android@v3
+
+      - name: Install NDK r29
+        run: |
+          echo "y" | sdkmanager "ndk;29.0.14206865"
+
+      - name: Create .env file (debug defaults)
+        run: |
+          cp .env.example .env
+          sed -i 's/your_[^ ]*/debug_placeholder/g' .env
+
+      - name: Install dependencies
+        run: npm install --legacy-peer-deps
+
+      - name: Apply patches
+        run: npx patch-package
+
+
+      - name: Make gradlew executable
+        run: chmod +x android/gradlew
+
+      - name: Build ${{ inputs.build_type }} APK
+        env:
+          NODE_ENV: production
+          SENTRY_DISABLE_AUTO_UPLOAD: true
+        run: |
+          cd android
+          ./gradlew clean
+          if [ "${{ inputs.build_type }}" = "release" ]; then
+            ./gradlew assembleRelease --no-daemon --stacktrace --rerun-tasks
+          else
+           ./gradlew assembleDebug --no-daemon --stacktrace --rerun-tasks
+          fi
+
+      - name: List APK outputs
+        run: find android/app/build/outputs/apk -name "*.apk" | sort
+
+      - name: Upload APK as artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: nuvio-${{ inputs.build_type }}-${{ inputs.commit_sha != '' && inputs.commit_sha || github.sha }}-run${{ github.run_number }}
+          path: android/app/build/outputs/apk/${{ inputs.build_type }}/*.apk
+          retention-days: 30
+          

From 601194b93fd78863c01f45cf0efab62d11abf66b Mon Sep 17 00:00:00 2001
From: CK <86251706+altCK129@users.noreply.github.com>
Date: Thu, 5 Mar 2026 13:46:02 +0530
Subject: [PATCH 02/35] Update youtubeExtractor.ts 1

---
 src/services/youtubeExtractor.ts | 98 +++++++++++++++++++-------------
 1 file changed, 60 insertions(+), 38 deletions(-)

diff --git a/src/services/youtubeExtractor.ts b/src/services/youtubeExtractor.ts
index c01aeda3..b109cc0c 100644
--- a/src/services/youtubeExtractor.ts
+++ b/src/services/youtubeExtractor.ts
@@ -68,52 +68,67 @@ export interface YouTubeExtractionResult {
 // Constants
 // ---------------------------------------------------------------------------
 
-// Innertube client configs — we use Android (no cipher, direct URLs)
-// and web as fallback (may need cipher decode)
-const INNERTUBE_API_KEY = 'AIzaSyA8ggJvXiQHQFN-YMEoM30s0s3RlxEYJuA';
+// Innertube client configs.
+// Note: ?key= param was deprecated by YouTube in mid-2023 and is no longer sent.
+//
+// IMPORTANT: As of late 2024, YouTube requires Proof of Origin (PO) tokens for
+// most clients (ANDROID, IOS, WEB). Without a PO token, the player API returns
+// format URLs but segment fetches get HTTP 403. The ANDROID_VR client is currently
+// the only client that bypasses PO token requirements and gives full format access
+// without authentication. Keep it first in the client list.
+//
+// Reference: https://github.com/yt-dlp/yt-dlp/wiki/PO-Token-Guide
 const INNERTUBE_URL = 'https://www.youtube.com/youtubei/v1/player';
 
-// Android client gives direct URLs without cipher obfuscation
+// ANDROID_VR (Oculus Quest) — bypasses PO token requirement, full format access.
+// This is the primary client. clientVersion from yt-dlp as of 2025.
+const ANDROID_VR_CLIENT_CONTEXT = {
+  client: {
+    clientName: 'ANDROID_VR',
+    clientVersion: '1.60.19',
+    deviceMake: 'Oculus',
+    deviceModel: 'Quest 3',
+    androidSdkVersion: 32,
+    userAgent:
+      'com.google.android.apps.youtube.vr.oculus/1.60.19 (Linux; U; Android 12L; eureka-user Build/SQ3A.220605.009.A1) gzip',
+    hl: 'en',
+    gl: 'US',
+  },
+};
+
+// ANDROID_SDKLESS — secondary fallback, no PO token needed, updated version.
+// Works for most non-age-restricted content.
 const ANDROID_CLIENT_CONTEXT = {
   client: {
     clientName: 'ANDROID',
-    clientVersion: '19.09.37',
+    clientVersion: '20.10.38',
     androidSdkVersion: 30,
+    osName: 'Android',
+    osVersion: '11',
     userAgent:
-      'com.google.android.youtube/19.09.37 (Linux; U; Android 11) gzip',
+      'com.google.android.youtube/20.10.38 (Linux; U; Android 11) gzip',
     hl: 'en',
     gl: 'US',
   },
 };
 
-// iOS client as secondary fallback
-const IOS_CLIENT_CONTEXT = {
+// TV client — no PO token needed, good format availability.
+const TV_CLIENT_CONTEXT = {
   client: {
-    clientName: 'IOS',
-    clientVersion: '19.09.3',
-    deviceModel: 'iPhone14,3',
+    clientName: 'TVHTML5',
+    clientVersion: '7.20250422.19.00',
     userAgent:
-      'com.google.ios.youtube/19.09.3 (iPhone14,3; U; CPU iPhone OS 15_6 like Mac OS X)',
+      'Mozilla/5.0 (SMART-TV; Linux; Tizen 6.0) AppleWebKit/538.1 (KHTML, like Gecko) Version/6.0 TV Safari/538.1',
     hl: 'en',
     gl: 'US',
   },
 };
 
-// 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',
-  },
-};
-
-// Web Embedded client — good fallback for content that rejects app clients
+// Web Embedded — fallback for embeddable content, may need PO token for segments.
 const WEB_EMBEDDED_CONTEXT = {
   client: {
     clientName: 'WEB_EMBEDDED_PLAYER',
-    clientVersion: '2.20240726.00.00',
+    clientVersion: '2.20250422.01.00',
     hl: 'en',
     gl: 'US',
   },
@@ -359,7 +374,8 @@ async function writeDashManifestToFile(
 async function fetchPlayerResponse(
   videoId: string,
   context: object,
-  userAgent: string
+  userAgent: string,
+  clientNameId: string = '3'
 ): Promise<InnertubePlayerResponse | null> {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
@@ -373,13 +389,13 @@ async function fetchPlayerResponse(
     };
 
     const response = await fetch(
-      `${INNERTUBE_URL}?key=${INNERTUBE_API_KEY}&prettyPrint=false`,
+      `${INNERTUBE_URL}?prettyPrint=false`,
       {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json',
           'User-Agent': userAgent,
-          'X-YouTube-Client-Name': '3',
+          'X-YouTube-Client-Name': clientNameId,
           'Origin': 'https://www.youtube.com',
           'Referer': `https://www.youtube.com/watch?v=${videoId}`,
         },
@@ -500,24 +516,30 @@ export class YouTubeExtractor {
 
     logger.info('YouTubeExtractor', `Extracting for videoId=${videoId} platform=${platform ?? 'unknown'}`);
 
-    const clients: Array<{ context: object; userAgent: string; name: string }> = [
+    // Client order matters: ANDROID_VR first because it bypasses PO token requirements.
+    // Other clients may return 403 on segment fetch even if player API succeeds.
+    const clients: Array<{ context: object; userAgent: string; name: string; clientNameId: string }> = [
+      {
+        name: 'ANDROID_VR',
+        clientNameId: '28',
+        context: ANDROID_VR_CLIENT_CONTEXT,
+        userAgent: 'com.google.android.apps.youtube.vr.oculus/1.60.19 (Linux; U; Android 12L; eureka-user Build/SQ3A.220605.009.A1) gzip',
+      },
       {
         name: 'ANDROID',
+        clientNameId: '3',
         context: ANDROID_CLIENT_CONTEXT,
-        userAgent: 'com.google.android.youtube/19.09.37 (Linux; U; Android 11) gzip',
+        userAgent: 'com.google.android.youtube/20.10.38 (Linux; U; Android 11) gzip',
       },
       {
-        name: 'IOS',
-        context: IOS_CLIENT_CONTEXT,
-        userAgent: 'com.google.ios.youtube/19.09.3 (iPhone14,3; U; CPU iPhone OS 15_6 like Mac OS X)',
-      },
-      {
-        name: 'TVHTML5_EMBEDDED',
-        context: TVHTML5_EMBEDDED_CONTEXT,
-        userAgent: 'Mozilla/5.0 (SMART-TV; Linux; Tizen 6.0)',
+        name: 'TV',
+        clientNameId: '7',
+        context: TV_CLIENT_CONTEXT,
+        userAgent: 'Mozilla/5.0 (SMART-TV; Linux; Tizen 6.0) AppleWebKit/538.1 (KHTML, like Gecko) Version/6.0 TV Safari/538.1',
       },
       {
         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',
       },
@@ -529,7 +551,7 @@ export class YouTubeExtractor {
 
     for (const client of clients) {
       logger.info('YouTubeExtractor', `Trying ${client.name} client...`);
-      const resp = await fetchPlayerResponse(videoId, client.context, client.userAgent);
+      const resp = await fetchPlayerResponse(videoId, client.context, client.userAgent, client.clientNameId);
       if (!resp) continue;
 
       const status = resp.playabilityStatus?.status;

From 02e9aef9f29bac0c3844d313cd1d46fd5d69ec1c Mon Sep 17 00:00:00 2001
From: CK <86251706+altCK129@users.noreply.github.com>
Date: Thu, 5 Mar 2026 13:47:47 +0530
Subject: [PATCH 03/35] Update AppleTVHero.tsx 2

---
 src/components/home/AppleTVHero.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/components/home/AppleTVHero.tsx b/src/components/home/AppleTVHero.tsx
index 18a1e0a1..578c9362 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;

From 274d2f7d0a9d936bb5f5c12637dceca5c26dfa19 Mon Sep 17 00:00:00 2001
From: CK <86251706+altCK129@users.noreply.github.com>
Date: Thu, 5 Mar 2026 13:49:06 +0530
Subject: [PATCH 04/35] Update HeroSection.tsx 3

---
 src/components/metadata/HeroSection.tsx | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/components/metadata/HeroSection.tsx b/src/components/metadata/HeroSection.tsx
index 67f6221c..b3f79705 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;

From b2cce9484153f5fd7e56346e12a024a0d4179ef4 Mon Sep 17 00:00:00 2001
From: CK <86251706+altCK129@users.noreply.github.com>
Date: Thu, 5 Mar 2026 13:50:11 +0530
Subject: [PATCH 05/35] Update TrailersSection.tsx 4

---
 src/components/metadata/TrailersSection.tsx | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

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,

From 2019230dfd5378aa50e164c9b9fe6cf2b4e4034b Mon Sep 17 00:00:00 2001
From: CK <86251706+altCK129@users.noreply.github.com>
Date: Thu, 5 Mar 2026 13:54:56 +0530
Subject: [PATCH 06/35] Update TrailerPlayer.tsx

---
 src/components/video/TrailerPlayer.tsx | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/components/video/TrailerPlayer.tsx b/src/components/video/TrailerPlayer.tsx
index cd5d9e75..7734aad8 100644
--- a/src/components/video/TrailerPlayer.tsx
+++ b/src/components/video/TrailerPlayer.tsx
@@ -374,12 +374,20 @@ 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') {
+            // For DASH streams from YouTube (googlevideo.com CDN), use the same
+            // User-Agent as the ANDROID_VR Innertube client used during extraction.
+            // For all other URLs (HLS, MP4 from server fallback) use a generic UA.
+            const isYouTubeCdn = lower.includes('googlevideo.com') || lower.includes('youtube.com');
+            const androidHeaders = {
+              'User-Agent': (looksLikeDash && isYouTubeCdn)
+                ? 'com.google.android.apps.youtube.vr.oculus/1.60.19 (Linux; U; Android 12L; eureka-user Build/SQ3A.220605.009.A1) gzip'
+                : 'Nuvio/1.0 (Android)',
+            };
             if (looksLikeHls) {
               return { uri: trailerUrl, type: 'm3u8', headers: androidHeaders } as any;
             }

From 639d53263d25d6ce05b5df00cd839936e9c5cbb2 Mon Sep 17 00:00:00 2001
From: CK <86251706+altCK129@users.noreply.github.com>
Date: Thu, 5 Mar 2026 13:57:41 +0530
Subject: [PATCH 07/35] Update TrailerContext.tsx

---
 src/contexts/TrailerContext.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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);

From ffe94607d239d17c1d0e789cffc9f36846af662d Mon Sep 17 00:00:00 2001
From: CK <86251706+altCK129@users.noreply.github.com>
Date: Thu, 5 Mar 2026 13:58:52 +0530
Subject: [PATCH 08/35] Update TrailerModal.tsx

---
 src/components/metadata/TrailerModal.tsx | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/src/components/metadata/TrailerModal.tsx b/src/components/metadata/TrailerModal.tsx
index 452a4a4f..4adc0712 100644
--- a/src/components/metadata/TrailerModal.tsx
+++ b/src/components/metadata/TrailerModal.tsx
@@ -270,7 +270,23 @@ const TrailerModal: React.FC<TrailerModalProps> = memo(({
               <View style={styles.playerWrapper}>
                 <Video
                   ref={videoRef}
-                  source={{ uri: trailerUrl }}
+                  source={(() => {
+                    const lower = (trailerUrl || '').toLowerCase();
+                    const looksLikeDash = /\.mpd(\b|$)/.test(lower) || /dash|manifest/.test(lower);
+                    const isYouTubeCdn = lower.includes('googlevideo.com') || lower.includes('youtube.com');
+                    if (Platform.OS === 'android') {
+                      const headers = {
+                        'User-Agent': (looksLikeDash && isYouTubeCdn)
+                          ? 'com.google.android.apps.youtube.vr.oculus/1.60.19 (Linux; U; Android 12L; eureka-user Build/SQ3A.220605.009.A1) gzip'
+                          : 'Nuvio/1.0 (Android)',
+                      };
+                      if (looksLikeDash) {
+                        return { uri: trailerUrl, type: 'mpd', headers } as any;
+                      }
+                      return { uri: trailerUrl, headers } as any;
+                    }
+                    return { uri: trailerUrl } as any;
+                  })()}
                   style={styles.player}
                   controls={true}
                   paused={!isPlaying}

From 80eb45e775de21bfe4181cf0345af1bfd2bdf825 Mon Sep 17 00:00:00 2001
From: CK <86251706+altCK129@users.noreply.github.com>
Date: Thu, 5 Mar 2026 13:59:45 +0530
Subject: [PATCH 09/35] Rename build.yml to buillld.yml

---
 .github/workflows/{build.yml => buillld.yml} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename .github/workflows/{build.yml => buillld.yml} (100%)

diff --git a/.github/workflows/build.yml b/.github/workflows/buillld.yml
similarity index 100%
rename from .github/workflows/build.yml
rename to .github/workflows/buillld.yml

From 8d50959abdcba9f8ea538e34e6aada5b85d346eb Mon Sep 17 00:00:00 2001
From: CK <86251706+altCK129@users.noreply.github.com>
Date: Thu, 5 Mar 2026 14:50:25 +0530
Subject: [PATCH 10/35] Update HeroSection.tsx

---
 src/components/metadata/HeroSection.tsx | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/components/metadata/HeroSection.tsx b/src/components/metadata/HeroSection.tsx
index b3f79705..218016c5 100644
--- a/src/components/metadata/HeroSection.tsx
+++ b/src/components/metadata/HeroSection.tsx
@@ -1155,9 +1155,8 @@ 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=${tmdbApiKey}`
+            `https://api.themoviedb.org/3/${contentType}/${resolvedTmdbId}/videos?api_key=d131017ccc6e5462a81c9304d21476de&language=en-US`
           );
 
           if (!alive) return;
@@ -1171,9 +1170,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');

From c6c27bf86a9d3f195d37e545af22ffc3f5e8238f Mon Sep 17 00:00:00 2001
From: CK <86251706+altCK129@users.noreply.github.com>
Date: Thu, 5 Mar 2026 14:51:17 +0530
Subject: [PATCH 11/35] Update AppleTVHero.tsx

---
 src/components/home/AppleTVHero.tsx | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/components/home/AppleTVHero.tsx b/src/components/home/AppleTVHero.tsx
index 578c9362..5a849aca 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}`
+          `https://api.themoviedb.org/3/${contentType}/${tmdbId}/videos?api_key=${tmdbApiKey}&language=en-US`
         );
 
         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');

From 02cecaf1ac48d7510f8a60691741df300c1a5e91 Mon Sep 17 00:00:00 2001
From: CK <86251706+altCK129@users.noreply.github.com>
Date: Thu, 5 Mar 2026 14:54:29 +0530
Subject: [PATCH 12/35] Update HeroSection.tsx

---
 src/components/metadata/HeroSection.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/components/metadata/HeroSection.tsx b/src/components/metadata/HeroSection.tsx
index 218016c5..224c737e 100644
--- a/src/components/metadata/HeroSection.tsx
+++ b/src/components/metadata/HeroSection.tsx
@@ -1156,7 +1156,7 @@ const HeroSection: React.FC<HeroSectionProps> = memo(({
 
           // Fetch video list from TMDB to get the YouTube video ID
           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;

From 54173cd704d20b61ba6e6c1b6bc02392b77f604d Mon Sep 17 00:00:00 2001
From: CK <86251706+altCK129@users.noreply.github.com>
Date: Thu, 5 Mar 2026 14:56:33 +0530
Subject: [PATCH 13/35] Update AppleTVHero.tsx

---
 src/components/home/AppleTVHero.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/components/home/AppleTVHero.tsx b/src/components/home/AppleTVHero.tsx
index 5a849aca..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;

From c75f6ae9d074fad907a921fa70ee9224018ad910 Mon Sep 17 00:00:00 2001
From: CK <86251706+altCK129@users.noreply.github.com>
Date: Thu, 5 Mar 2026 09:43:48 +0000
Subject: [PATCH 14/35] Update youtubeExtractor.ts

---
 src/services/youtubeExtractor.ts | 22 ----------------------
 1 file changed, 22 deletions(-)

diff --git a/src/services/youtubeExtractor.ts b/src/services/youtubeExtractor.ts
index b109cc0c..c967f123 100644
--- a/src/services/youtubeExtractor.ts
+++ b/src/services/youtubeExtractor.ts
@@ -96,22 +96,6 @@ const ANDROID_VR_CLIENT_CONTEXT = {
   },
 };
 
-// ANDROID_SDKLESS — secondary fallback, no PO token needed, updated version.
-// Works for most non-age-restricted content.
-const ANDROID_CLIENT_CONTEXT = {
-  client: {
-    clientName: 'ANDROID',
-    clientVersion: '20.10.38',
-    androidSdkVersion: 30,
-    osName: 'Android',
-    osVersion: '11',
-    userAgent:
-      'com.google.android.youtube/20.10.38 (Linux; U; Android 11) gzip',
-    hl: 'en',
-    gl: 'US',
-  },
-};
-
 // TV client — no PO token needed, good format availability.
 const TV_CLIENT_CONTEXT = {
   client: {
@@ -525,12 +509,6 @@ export class YouTubeExtractor {
         context: ANDROID_VR_CLIENT_CONTEXT,
         userAgent: 'com.google.android.apps.youtube.vr.oculus/1.60.19 (Linux; U; Android 12L; eureka-user Build/SQ3A.220605.009.A1) gzip',
       },
-      {
-        name: 'ANDROID',
-        clientNameId: '3',
-        context: ANDROID_CLIENT_CONTEXT,
-        userAgent: 'com.google.android.youtube/20.10.38 (Linux; U; Android 11) gzip',
-      },
       {
         name: 'TV',
         clientNameId: '7',

From e9d549cebb414b36b776febe26106d482a1bba1a Mon Sep 17 00:00:00 2001
From: CK <86251706+altCK129@users.noreply.github.com>
Date: Thu, 5 Mar 2026 15:44:38 +0530
Subject: [PATCH 15/35] Update HeroSection.tsx

---
 src/components/metadata/HeroSection.tsx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/components/metadata/HeroSection.tsx b/src/components/metadata/HeroSection.tsx
index 224c737e..6da5a40d 100644
--- a/src/components/metadata/HeroSection.tsx
+++ b/src/components/metadata/HeroSection.tsx
@@ -1155,6 +1155,7 @@ 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=${tmdbApiKey}`
           );

From 25de499931f5ddc31b658be414dcd7fbefca9872 Mon Sep 17 00:00:00 2001
From: CK <86251706+altCK129@users.noreply.github.com>
Date: Thu, 5 Mar 2026 20:12:35 +0530
Subject: [PATCH 16/35] Update youtubeExtractor.ts

---
 src/services/youtubeExtractor.ts | 1093 ++++++++++++++++--------------
 1 file changed, 603 insertions(+), 490 deletions(-)

diff --git a/src/services/youtubeExtractor.ts b/src/services/youtubeExtractor.ts
index c967f123..7d34ee37 100644
--- a/src/services/youtubeExtractor.ts
+++ b/src/services/youtubeExtractor.ts
@@ -1,640 +1,753 @@
 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[];
+interface StreamingData {
+  formats?: InnertubeFormat[];
+  adaptiveFormats?: InnertubeFormat[];
+  hlsManifestUrl?: string;
   expiresInSeconds?: string;
 }
 
-interface InnertubePlayerResponse {
-  streamingData?: InnertubeStreamingData;
+interface PlayerResponse {
+  streamingData?: StreamingData;
   videoDetails?: {
-    videoId: string;
-    title: string;
-    lengthSeconds: string;
+    videoId?: string;
+    title?: string;
+    lengthSeconds?: string;
     isLive?: boolean;
-    isLiveDvr?: boolean;
   };
   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';
+  initRange?: { start: string; end: string };
+  indexRange?: { start: string; end: string };
   bitrate: number;
+  audioSampleRate?: string;
+  mimeType: string;
+  itag?: number;
+}
+
+interface HlsVariant {
+  url: string;
+  width: number;
+  height: number;
+  bandwidth: number;
+}
+
+export interface TrailerPlaybackSource {
+  videoUrl: string;         // best video (may be muxed, DASH video-only, HLS, or progressive)
+  audioUrl: string | null;  // separate audio URL if adaptive, null if muxed/HLS
+  quality: string;
+  isMuxed: boolean;         // true if videoUrl already contains audio
+  isDash: boolean;          // true if we should build a DASH manifest
+  durationSeconds: number;
 }
 
 export interface YouTubeExtractionResult {
-  streams: ExtractedStream[];
-  bestStream: ExtractedStream | null;
+  source: TrailerPlaybackSource;
   videoId: string;
   title?: string;
-  durationSeconds?: number;
 }
 
 // ---------------------------------------------------------------------------
-// Constants
+// Client definitions
 // ---------------------------------------------------------------------------
 
-// Innertube client configs.
-// Note: ?key= param was deprecated by YouTube in mid-2023 and is no longer sent.
-//
-// IMPORTANT: As of late 2024, YouTube requires Proof of Origin (PO) tokens for
-// most clients (ANDROID, IOS, WEB). Without a PO token, the player API returns
-// format URLs but segment fetches get HTTP 403. The ANDROID_VR client is currently
-// the only client that bypasses PO token requirements and gives full format access
-// without authentication. Keep it first in the client list.
-//
-// Reference: https://github.com/yt-dlp/yt-dlp/wiki/PO-Token-Guide
-const INNERTUBE_URL = 'https://www.youtube.com/youtubei/v1/player';
+interface ClientDef {
+  key: string;
+  id: string;
+  version: string;
+  userAgent: string;
+  context: Record<string, any>;
+  priority: number;
+}
 
-// ANDROID_VR (Oculus Quest) — bypasses PO token requirement, full format access.
-// This is the primary client. clientVersion from yt-dlp as of 2025.
-const ANDROID_VR_CLIENT_CONTEXT = {
-  client: {
-    clientName: 'ANDROID_VR',
-    clientVersion: '1.60.19',
-    deviceMake: 'Oculus',
-    deviceModel: 'Quest 3',
-    androidSdkVersion: 32,
-    userAgent:
-      'com.google.android.apps.youtube.vr.oculus/1.60.19 (Linux; U; Android 12L; eureka-user Build/SQ3A.220605.009.A1) gzip',
-    hl: 'en',
-    gl: 'US',
+const PREFERRED_ADAPTIVE_CLIENT = 'android_vr';
+
+const CLIENTS: ClientDef[] = [
+  {
+    key: 'android_vr',
+    id: '28',
+    version: '1.62.27',
+    userAgent: 'com.google.android.apps.youtube.vr.oculus/1.62.27 (Linux; U; Android 12L; eureka-user Build/SQ3A.220605.009.A1) gzip',
+    context: {
+      clientName: 'ANDROID_VR',
+      clientVersion: '1.62.27',
+      deviceMake: 'Oculus',
+      deviceModel: 'Quest 3',
+      osName: 'Android',
+      osVersion: '12L',
+      platform: 'MOBILE',
+      androidSdkVersion: 32,
+      hl: 'en',
+      gl: 'US',
+    },
+    priority: 0,
   },
-};
-
-// TV client — no PO token needed, good format availability.
-const TV_CLIENT_CONTEXT = {
-  client: {
-    clientName: 'TVHTML5',
-    clientVersion: '7.20250422.19.00',
-    userAgent:
-      'Mozilla/5.0 (SMART-TV; Linux; Tizen 6.0) AppleWebKit/538.1 (KHTML, like Gecko) Version/6.0 TV Safari/538.1',
-    hl: 'en',
-    gl: 'US',
+  {
+    key: 'android',
+    id: '3',
+    version: '20.10.38',
+    userAgent: '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,
   },
-};
-
-// Web Embedded — fallback for embeddable content, may need PO token for segments.
-const WEB_EMBEDDED_CONTEXT = {
-  client: {
-    clientName: 'WEB_EMBEDDED_PLAYER',
-    clientVersion: '2.20250422.01.00',
-    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,
   },
-  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;
+const REQUEST_TIMEOUT_MS = 20000;
+const DEFAULT_UA = 'Mozilla/5.0 (Linux; Android 12; Android TV) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36';
+const DEFAULT_HEADERS: Record<string, string> = {
+  'accept-language': 'en-US,en;q=0.9',
+  'user-agent': DEFAULT_UA,
+};
 
 // ---------------------------------------------------------------------------
 // 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 getCodecs(mimeType?: string): string {
+  const m = (mimeType ?? '').match(/codecs="?([^"]+)"?/i);
+  return m ? m[1].trim() : '';
 }
 
-function isVideoMp4(format: InnertubeFormat): boolean {
-  return format.mimeType.startsWith('video/mp4');
+function getExt(mimeType?: string): 'mp4' | 'webm' | 'm4a' | 'other' {
+  const base = getMimeBase(mimeType);
+  if (base.includes('mp4') || base === 'audio/mp4') return 'mp4';
+  if (base.includes('webm')) return 'webm';
+  if (base === 'audio/mp4' || base.includes('m4a')) return 'm4a';
+  return 'other';
 }
 
-function formatQualityLabel(format: InnertubeFormat): string {
-  return format.qualityLabel || format.quality || 'unknown';
+function containerScore(ext: string): number {
+  switch (ext) {
+    case 'mp4':
+    case 'm4a': return 0;
+    case 'webm': return 1;
+    default: return 2;
+  }
 }
 
-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 videoScore(height: number, fps: number, bitrate: number): number {
+  return height * 1_000_000_000 + fps * 1_000_000 + bitrate;
+}
+
+function audioScore(bitrate: number, sampleRate: number): number {
+  return bitrate * 1_000_000 + sampleRate;
+}
+
+function parseQualityLabel(label?: string): number {
+  if (!label) return 0;
+  const m = label.match(/(\d{2,4})p/);
+  return m ? parseInt(m[1], 10) : 0;
+}
+
+function isMuxedFormat(f: InnertubeFormat): boolean {
+  const codecs = getCodecs(f.mimeType);
+  return (!!f.qualityLabel && !!f.audioQuality) || codecs.includes(',');
+}
+
+function isVideoOnly(f: InnertubeFormat): boolean {
+  return !!(f.qualityLabel && !f.audioQuality && f.mimeType?.startsWith('video/'));
+}
+
+function isAudioOnly(f: InnertubeFormat): boolean {
+  return !!(f.audioQuality && !f.qualityLabel && f.mimeType?.startsWith('audio/'));
+}
+
+function summarizeUrl(url: string): string {
+  try {
+    const u = new URL(url);
+    return `${u.hostname}${u.pathname.substring(0, 40)}`;
+  } catch {
+    return url.substring(0, 80);
+  }
 }
 
 // ---------------------------------------------------------------------------
-// Adaptive stream helpers (Android/DASH only)
+// Watch page — extract API key + visitor data dynamically
 // ---------------------------------------------------------------------------
 
-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;
+interface WatchConfig {
+  apiKey: string | null;
+  visitorData: string | null;
 }
 
-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;
+async function fetchWatchConfig(videoId: string): Promise<WatchConfig> {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), REQUEST_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 fetch failed: ${res.status}`);
+      return { apiKey: null, visitorData: null };
+    }
+    const html = await res.text();
+    const apiKeyMatch = html.match(/"INNERTUBE_API_KEY":"([^"]+)"/);
+    const visitorMatch = html.match(/"VISITOR_DATA":"([^"]+)"/);
+    return {
+      apiKey: apiKeyMatch?.[1] ?? null,
+      visitorData: visitorMatch?.[1] ?? null,
+    };
+  } catch (err) {
+    clearTimeout(timer);
+    logger.warn('YouTubeExtractor', 'Watch page fetch error:', err);
+    return { apiKey: null, visitorData: null };
   }
-  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,
+// ---------------------------------------------------------------------------
+// Player API request
+// ---------------------------------------------------------------------------
+
+async function fetchPlayerResponse(
   videoId: string,
-  durationSeconds?: number
+  client: ClientDef,
+  apiKey: string | null,
+  visitorData: string | null,
+): Promise<PlayerResponse | null> {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+
+  // Use dynamic API key if available, otherwise omit (deprecated but harmless)
+  const url = 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,
+    context: { client: client.context },
+    contentCheckOk: true,
+    racyCheckOk: true,
+    playbackContext: {
+      contentPlaybackContext: { html5Preference: 'HTML5_PREF_WANTS' },
+    },
+  });
+
+  try {
+    const res = await fetch(url, { method: 'POST', headers, body, signal: controller.signal });
+    clearTimeout(timer);
+    if (!res.ok) {
+      logger.warn('YouTubeExtractor', `[${client.key}] player API HTTP ${res.status}`);
+      return null;
+    }
+    return await res.json() as PlayerResponse;
+  } catch (err) {
+    clearTimeout(timer);
+    if (err instanceof Error && err.name === 'AbortError') {
+      logger.warn('YouTubeExtractor', `[${client.key}] Timed out`);
+    } else {
+      logger.warn('YouTubeExtractor', `[${client.key}] Error:`, err);
+    }
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// HLS manifest parsing — pick best variant by height then bandwidth
+// ---------------------------------------------------------------------------
+
+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);
+
+    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;
+
+      // Parse attributes
+      const attrs: Record<string, string> = {};
+      const attrStr = line.substring(line.indexOf(':') + 1);
+      let key = '', val = '', inKey = true, inQuote = false;
+      for (const ch of attrStr) {
+        if (inKey) { if (ch === '=') inKey = false; else key += ch; continue; }
+        if (ch === '"') { inQuote = !inQuote; continue; }
+        if (ch === ',' && !inQuote) { 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;
+
+      // Absolutize URL
+      let variantUrl = nextLine;
+      if (!variantUrl.startsWith('http')) {
+        try { variantUrl = new URL(variantUrl, manifestUrl).toString(); } catch { /* keep as-is */ }
+      }
+
+      const candidate: HlsVariant = { url: variantUrl, width, height, bandwidth };
+      if (!best || height > best.height || (height === best.height && 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
+// ---------------------------------------------------------------------------
+
+interface CollectedFormats {
+  progressive: StreamCandidate[];   // muxed video+audio
+  adaptiveVideo: StreamCandidate[]; // video-only adaptive
+  adaptiveAudio: StreamCandidate[]; // audio-only adaptive
+  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 }> = [];
+
+  for (const client of CLIENTS) {
+    try {
+      const resp = await fetchPlayerResponse(videoId, client, apiKey, visitorData);
+      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;
+
+      // Collect HLS manifest URL if present
+      if (sd.hlsManifestUrl) {
+        hlsManifests.push({ clientKey: client.key, priority: client.priority, url: sd.hlsManifestUrl });
+      }
+
+      let clientProgressive = 0, clientVideo = 0, clientAudio = 0;
+
+      // Progressive (muxed) formats
+      for (const f of (sd.formats ?? [])) {
+        if (!f.url || !f.mimeType?.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),
+          initRange: f.initRange,
+          indexRange: f.indexRange,
+          bitrate,
+          mimeType: f.mimeType,
+          itag: f.itag,
+        });
+        clientProgressive++;
+      }
+
+      // 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),
+            initRange: f.initRange,
+            indexRange: f.indexRange,
+            bitrate,
+            mimeType: f.mimeType,
+            itag: f.itag,
+          });
+          clientVideo++;
+        } 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),
+            initRange: f.initRange,
+            indexRange: f.indexRange,
+            bitrate,
+            audioSampleRate: f.audioSampleRate,
+            mimeType: f.mimeType,
+            itag: f.itag,
+          });
+          clientAudio++;
+        }
+      }
+
+      logger.info('YouTubeExtractor', `[${client.key}] progressive=${clientProgressive} video=${clientVideo} audio=${clientAudio} hls=${sd.hlsManifestUrl ? 1 : 0}`);
+    } catch (err) {
+      logger.warn('YouTubeExtractor', `[${client.key}] Failed:`, err);
+    }
+  }
+
+  return { progressive, adaptiveVideo, adaptiveAudio, hlsManifests };
+}
+
+// ---------------------------------------------------------------------------
+// Sorting and selection
+// ---------------------------------------------------------------------------
+
+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;
+}
+
+// ---------------------------------------------------------------------------
+// DASH manifest builder
+// ---------------------------------------------------------------------------
+
+async function buildDashManifest(
+  video: StreamCandidate,
+  audio: StreamCandidate,
+  videoId: string,
+  durationSeconds: number,
 ): Promise<string | null> {
   try {
     const FileSystem = await import('expo-file-system/legacy');
-    const cacheDir = FileSystem.cacheDirectory;
-    if (!cacheDir) return null;
+    if (!FileSystem.cacheDirectory) 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) =>
+    const esc = (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 dur = `PT${durationSeconds}S`;
+    const vMime = getMimeBase(video.mimeType);
+    const aMime = getMimeBase(audio.mimeType);
+    const vCodec = getCodecs(video.mimeType);
+    const aCodec = getCodecs(audio.mimeType);
+    const vInit = video.initRange ? `${video.initRange.start}-${video.initRange.end}` : '0-0';
+    const vIdx  = video.indexRange ? `${video.indexRange.start}-${video.indexRange.end}` : '0-0';
+    const aInit = audio.initRange ? `${audio.initRange.start}-${audio.initRange.end}` : '0-0';
+    const aIdx  = audio.indexRange ? `${audio.indexRange.start}-${audio.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>
+<MPD xmlns="urn:mpeg:dash:schema:mpd:2011" type="static" mediaPresentationDuration="${dur}" minBufferTime="PT2S" profiles="urn:mpeg:dash:profile:isoff-on-demand:2011">
+  <Period duration="${dur}">
+    <AdaptationSet id="1" mimeType="${vMime}" codecs="${vCodec}" subsegmentAlignment="true" subsegmentStartsWithSAP="1">
+      <Representation id="v1" bandwidth="${video.bitrate}" height="${video.height}">
+        <BaseURL>${esc(video.url)}</BaseURL>
+        <SegmentBase indexRange="${vIdx}"><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>
+    <AdaptationSet id="2" mimeType="${aMime}" codecs="${aCodec}" lang="en" subsegmentAlignment="true" subsegmentStartsWithSAP="1">
+      <Representation id="a1" bandwidth="${audio.bitrate}" audioSamplingRate="${audio.audioSampleRate ?? '44100'}">
+        <BaseURL>${esc(audio.url)}</BaseURL>
+        <SegmentBase indexRange="${aIdx}"><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;
+    const path = `${FileSystem.cacheDirectory}trailer_${videoId}.mpd`;
+    await FileSystem.writeAsStringAsync(path, mpd, { encoding: FileSystem.EncodingType.UTF8 });
+    logger.info('YouTubeExtractor', `DASH manifest: ${path} (video=${video.itag} ${video.height}p, audio=${audio.itag})`);
+    return path;
   } catch (err) {
-    logger.warn('YouTubeExtractor', 'writeDashManifestToFile failed:', err);
+    logger.warn('YouTubeExtractor', 'DASH manifest write failed:', err);
     return null;
   }
 }
 
-// ---------------------------------------------------------------------------
-// Core extractor
-// ---------------------------------------------------------------------------
-
-async function fetchPlayerResponse(
-  videoId: string,
-  context: object,
-  userAgent: string,
-  clientNameId: string = '3'
-): Promise<InnertubePlayerResponse | null> {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
-
-  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,
-      }
-    );
-
-    clearTimeout(timer);
-
-    if (!response.ok) {
-      logger.warn('YouTubeExtractor', `Innertube HTTP ${response.status} for videoId=${videoId}`);
-      return null;
-    }
-
-    const data: InnertubePlayerResponse = await response.json();
-    return data;
-  } catch (err) {
-    clearTimeout(timer);
-    if (err instanceof Error && err.name === 'AbortError') {
-      logger.warn('YouTubeExtractor', `Request timed out for videoId=${videoId}`);
-    } else {
-      logger.warn('YouTubeExtractor', `Fetch error for videoId=${videoId}:`, 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;
-}
-
-function parseAdaptiveFormats(playerResponse: InnertubePlayerResponse): InnertubeFormat[] {
-  const sd = playerResponse.streamingData;
-  if (!sd) return [];
-  return (sd.adaptiveFormats ?? []).filter((f) => !!f.url);
-}
-
-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,
-    };
-  }
-
-  // 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,
-      };
-    }
-  }
-
-  return null;
-}
-
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
 
 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.
-   *
-   * On iOS: always returns the best muxed stream. AVPlayer has no DASH support.
+   * Strategy:
+   * 1. Fetch watch page to get dynamic API key + visitor data
+   * 2. Try ALL clients in parallel — collect formats from all that succeed
+   * 3. On Android: prefer DASH (adaptive video from android_vr + best audio)
+   *    falling back to best HLS manifest, then best progressive
+   * 4. On iOS: prefer HLS manifest (AVPlayer native), then progressive (muxed)
    */
   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');
+    logger.info('YouTubeExtractor', `Extracting videoId=${videoId} platform=${effectivePlatform}`);
 
-    // Client order matters: ANDROID_VR first because it bypasses PO token requirements.
-    // Other clients may return 403 on segment fetch even if player API succeeds.
-    const clients: Array<{ context: object; userAgent: string; name: string; clientNameId: string }> = [
-      {
-        name: 'ANDROID_VR',
-        clientNameId: '28',
-        context: ANDROID_VR_CLIENT_CONTEXT,
-        userAgent: 'com.google.android.apps.youtube.vr.oculus/1.60.19 (Linux; U; Android 12L; eureka-user Build/SQ3A.220605.009.A1) gzip',
-      },
-      {
-        name: 'TV',
-        clientNameId: '7',
-        context: TV_CLIENT_CONTEXT,
-        userAgent: 'Mozilla/5.0 (SMART-TV; Linux; Tizen 6.0) AppleWebKit/538.1 (KHTML, like Gecko) Version/6.0 TV Safari/538.1',
-      },
-      {
-        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;
-      }
-
-      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`);
+    // Step 1: fetch watch page for dynamic API key + visitor data
+    const watchConfig = await fetchWatchConfig(videoId);
+    if (watchConfig.apiKey) {
+      logger.info('YouTubeExtractor', `Got apiKey and visitorData from watch page`);
+    } else {
+      logger.warn('YouTubeExtractor', `Could not get apiKey from watch page — proceeding without`);
     }
 
-    if (muxedFormats.length === 0 && adaptiveFormats.length === 0) {
-      logger.warn('YouTubeExtractor', `All clients failed for videoId=${videoId}`);
+    // Step 2: collect formats from all clients
+    const { progressive, adaptiveVideo, adaptiveAudio, hlsManifests } =
+      await collectAllFormats(videoId, watchConfig.apiKey, watchConfig.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;
     }
 
-    const details = playerResponse?.videoDetails;
-    const durationSeconds = details?.lengthSeconds ? parseInt(details.lengthSeconds, 10) : undefined;
+    // Step 3: pick best HLS variant (by resolution/bandwidth)
+    let bestHls: (HlsVariant & { manifestUrl: string }) | null = null;
+    for (const { url, priority } 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 };
+      }
+    }
 
-    let bestStream: ExtractedStream | null = null;
+    const bestProgressive = sortCandidates(progressive)[0] ?? null;
+    const bestAdaptiveVideo = pickBestForClient(adaptiveVideo, PREFERRED_ADAPTIVE_CLIENT);
+    const bestAdaptiveAudio = pickBestForClient(adaptiveAudio, PREFERRED_ADAPTIVE_CLIENT);
 
-    // 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 (bestHls) logger.info('YouTubeExtractor', `Best HLS: ${bestHls.height}p ${bestHls.bandwidth}bps`);
+    if (bestProgressive) logger.info('YouTubeExtractor', `Best progressive: ${bestProgressive.height}p score=${bestProgressive.score}`);
+    if (bestAdaptiveVideo) logger.info('YouTubeExtractor', `Best adaptive video: ${bestAdaptiveVideo.height}p client=${bestAdaptiveVideo.client}`);
+    if (bestAdaptiveAudio) logger.info('YouTubeExtractor', `Best adaptive audio: bitrate=${bestAdaptiveAudio.bitrate} client=${bestAdaptiveAudio.client}`);
 
-      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),
+    // Placeholder duration (refined below)
+    const durationSeconds = 300;
+
+    let source: TrailerPlaybackSource | null = null;
+
+    if (effectivePlatform === 'android') {
+      // Android priority: DASH adaptive > HLS > progressive
+      if (bestAdaptiveVideo && bestAdaptiveAudio) {
+        const mpdPath = await buildDashManifest(bestAdaptiveVideo, bestAdaptiveAudio, videoId, durationSeconds);
+        if (mpdPath) {
+          source = {
+            videoUrl: mpdPath,
+            audioUrl: null,
+            quality: `${bestAdaptiveVideo.height}p`,
+            isMuxed: true, // MPD contains both tracks
+            isDash: true,
+            durationSeconds,
           };
-        } 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`
-        );
+      }
+      if (!source && bestHls) {
+        source = {
+          videoUrl: bestHls.manifestUrl,
+          audioUrl: null,
+          quality: `${bestHls.height}p`,
+          isMuxed: true,
+          isDash: false,
+          durationSeconds,
+        };
+      }
+      if (!source && bestProgressive) {
+        source = {
+          videoUrl: bestProgressive.url,
+          audioUrl: null,
+          quality: `${bestProgressive.height}p`,
+          isMuxed: true,
+          isDash: false,
+          durationSeconds,
+        };
+      }
+    } else {
+      // iOS priority: HLS (native AVPlayer support) > progressive
+      if (bestHls) {
+        source = {
+          videoUrl: bestHls.manifestUrl,
+          audioUrl: null,
+          quality: `${bestHls.height}p`,
+          isMuxed: true,
+          isDash: false,
+          durationSeconds,
+        };
+      }
+      if (!source && bestProgressive) {
+        source = {
+          videoUrl: bestProgressive.url,
+          audioUrl: null,
+          quality: `${bestProgressive.height}p`,
+          isMuxed: true,
+          isDash: false,
+          durationSeconds,
+        };
       }
     }
 
-    // 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}`);
-      }
+    if (!source) {
+      logger.warn('YouTubeExtractor', `Could not build a playable source for videoId=${videoId}`);
+      return null;
     }
 
-    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,
-    }));
+    logger.info('YouTubeExtractor', `Final source: ${summarizeUrl(source.videoUrl)} quality=${source.quality} dash=${source.isDash}`);
 
     return {
-      streams,
-      bestStream,
+      source,
       videoId,
-      title: details?.title,
-      durationSeconds,
+      title: undefined,
     };
   }
 
-  /**
-   * Returns just the best playable URL or null.
-   * Pass platform so the extractor can choose DASH vs muxed.
-   */
+  /** Convenience: returns just the best playable URL or null. */
   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?.source.videoUrl ?? null;
   }
 
   static parseVideoId(input: string): string | null {
-    return extractVideoId(input);
+    return parseVideoId(input);
   }
 }
 

From da39ca47bce8760f9773a0a1979417efedf551a2 Mon Sep 17 00:00:00 2001
From: CK <86251706+altCK129@users.noreply.github.com>
Date: Thu, 5 Mar 2026 20:20:44 +0530
Subject: [PATCH 17/35] Update youtubeExtractor.ts

---
 src/services/youtubeExtractor.ts | 454 +++++++++++--------------------
 1 file changed, 165 insertions(+), 289 deletions(-)

diff --git a/src/services/youtubeExtractor.ts b/src/services/youtubeExtractor.ts
index 7d34ee37..b1103f6b 100644
--- a/src/services/youtubeExtractor.ts
+++ b/src/services/youtubeExtractor.ts
@@ -18,26 +18,15 @@ interface InnertubeFormat {
   qualityLabel?: string;
   audioQuality?: string;
   audioSampleRate?: string;
-  audioChannels?: number;
-  approxDurationMs?: string;
   initRange?: { start: string; end: string };
   indexRange?: { start: string; end: string };
 }
 
-interface StreamingData {
-  formats?: InnertubeFormat[];
-  adaptiveFormats?: InnertubeFormat[];
-  hlsManifestUrl?: string;
-  expiresInSeconds?: string;
-}
-
 interface PlayerResponse {
-  streamingData?: StreamingData;
-  videoDetails?: {
-    videoId?: string;
-    title?: string;
-    lengthSeconds?: string;
-    isLive?: boolean;
+  streamingData?: {
+    formats?: InnertubeFormat[];
+    adaptiveFormats?: InnertubeFormat[];
+    hlsManifestUrl?: string;
   };
   playabilityStatus?: {
     status?: string;
@@ -53,12 +42,9 @@ interface StreamCandidate {
   height: number;
   fps: number;
   ext: 'mp4' | 'webm' | 'm4a' | 'other';
-  initRange?: { start: string; end: string };
-  indexRange?: { start: string; end: string };
   bitrate: number;
   audioSampleRate?: string;
   mimeType: string;
-  itag?: number;
 }
 
 interface HlsVariant {
@@ -68,25 +54,32 @@ interface HlsVariant {
   bandwidth: number;
 }
 
-export interface TrailerPlaybackSource {
-  videoUrl: string;         // best video (may be muxed, DASH video-only, HLS, or progressive)
-  audioUrl: string | null;  // separate audio URL if adaptive, null if muxed/HLS
-  quality: string;
-  isMuxed: boolean;         // true if videoUrl already contains audio
-  isDash: boolean;          // true if we should build a DASH manifest
-  durationSeconds: number;
-}
-
 export interface YouTubeExtractionResult {
-  source: TrailerPlaybackSource;
+  /** 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;
 }
 
 // ---------------------------------------------------------------------------
-// Client definitions
+// Constants — matching the Kotlin extractor exactly
 // ---------------------------------------------------------------------------
 
+// 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';
+
+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 = 20000;
+
 interface ClientDef {
   key: string;
   id: string;
@@ -96,21 +89,22 @@ interface ClientDef {
   priority: number;
 }
 
-const PREFERRED_ADAPTIVE_CLIENT = 'android_vr';
-
+// 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.apps.youtube.vr.oculus/1.62.27 (Linux; U; Android 12L; eureka-user Build/SQ3A.220605.009.A1) gzip',
+    userAgent:
+      '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: '12L',
+      osVersion: '12',
       platform: 'MOBILE',
       androidSdkVersion: 32,
       hl: 'en',
@@ -122,7 +116,8 @@ const CLIENTS: ClientDef[] = [
     key: 'android',
     id: '3',
     version: '20.10.38',
-    userAgent: 'com.google.android.youtube/20.10.38 (Linux; U; Android 14; en_US) gzip',
+    userAgent:
+      'com.google.android.youtube/20.10.38 (Linux; U; Android 14; en_US) gzip',
     context: {
       clientName: 'ANDROID',
       clientVersion: '20.10.38',
@@ -139,7 +134,8 @@ const CLIENTS: ClientDef[] = [
     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)',
+    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',
@@ -154,13 +150,6 @@ const CLIENTS: ClientDef[] = [
   },
 ];
 
-const REQUEST_TIMEOUT_MS = 20000;
-const DEFAULT_UA = 'Mozilla/5.0 (Linux; Android 12; Android TV) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36';
-const DEFAULT_HEADERS: Record<string, string> = {
-  'accept-language': 'en-US,en;q=0.9',
-  'user-agent': DEFAULT_UA,
-};
-
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -191,26 +180,16 @@ function getMimeBase(mimeType?: string): string {
   return (mimeType ?? '').split(';')[0].trim();
 }
 
-function getCodecs(mimeType?: string): string {
-  const m = (mimeType ?? '').match(/codecs="?([^"]+)"?/i);
-  return m ? m[1].trim() : '';
-}
-
 function getExt(mimeType?: string): 'mp4' | 'webm' | 'm4a' | 'other' {
   const base = getMimeBase(mimeType);
-  if (base.includes('mp4') || base === 'audio/mp4') return 'mp4';
+  if (base === 'video/mp4' || base === 'audio/mp4') return 'mp4';
   if (base.includes('webm')) return 'webm';
-  if (base === 'audio/mp4' || base.includes('m4a')) return 'm4a';
+  if (base.includes('m4a')) return 'm4a';
   return 'other';
 }
 
 function containerScore(ext: string): number {
-  switch (ext) {
-    case 'mp4':
-    case 'm4a': return 0;
-    case 'webm': return 1;
-    default: return 2;
-  }
+  return ext === 'mp4' || ext === 'm4a' ? 0 : ext === 'webm' ? 1 : 2;
 }
 
 function videoScore(height: number, fps: number, bitrate: number): number {
@@ -222,24 +201,10 @@ function audioScore(bitrate: number, sampleRate: number): number {
 }
 
 function parseQualityLabel(label?: string): number {
-  if (!label) return 0;
-  const m = label.match(/(\d{2,4})p/);
+  const m = (label ?? '').match(/(\d{2,4})p/);
   return m ? parseInt(m[1], 10) : 0;
 }
 
-function isMuxedFormat(f: InnertubeFormat): boolean {
-  const codecs = getCodecs(f.mimeType);
-  return (!!f.qualityLabel && !!f.audioQuality) || codecs.includes(',');
-}
-
-function isVideoOnly(f: InnertubeFormat): boolean {
-  return !!(f.qualityLabel && !f.audioQuality && f.mimeType?.startsWith('video/'));
-}
-
-function isAudioOnly(f: InnertubeFormat): boolean {
-  return !!(f.audioQuality && !f.qualityLabel && f.mimeType?.startsWith('audio/'));
-}
-
 function summarizeUrl(url: string): string {
   try {
     const u = new URL(url);
@@ -249,6 +214,24 @@ function summarizeUrl(url: string): string {
   }
 }
 
+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
 // ---------------------------------------------------------------------------
@@ -262,31 +245,29 @@ async function fetchWatchConfig(videoId: string): Promise<WatchConfig> {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
   try {
-    const res = await fetch(`https://www.youtube.com/watch?v=${videoId}&hl=en`, {
-      headers: DEFAULT_HEADERS,
-      signal: controller.signal,
-    });
+    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 fetch failed: ${res.status}`);
+      logger.warn('YouTubeExtractor', `Watch page ${res.status}`);
       return { apiKey: null, visitorData: null };
     }
     const html = await res.text();
-    const apiKeyMatch = html.match(/"INNERTUBE_API_KEY":"([^"]+)"/);
-    const visitorMatch = html.match(/"VISITOR_DATA":"([^"]+)"/);
-    return {
-      apiKey: apiKeyMatch?.[1] ?? null,
-      visitorData: visitorMatch?.[1] ?? null,
-    };
+    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 fetch error:', err);
+    logger.warn('YouTubeExtractor', 'Watch page error:', err);
     return { apiKey: null, visitorData: null };
   }
 }
 
 // ---------------------------------------------------------------------------
-// Player API request
+// Player API
 // ---------------------------------------------------------------------------
 
 async function fetchPlayerResponse(
@@ -298,8 +279,7 @@ async function fetchPlayerResponse(
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
 
-  // Use dynamic API key if available, otherwise omit (deprecated but harmless)
-  const url = apiKey
+  const endpoint = apiKey
     ? `https://www.youtube.com/youtubei/v1/player?key=${encodeURIComponent(apiKey)}&prettyPrint=false`
     : `https://www.youtube.com/youtubei/v1/player?prettyPrint=false`;
 
@@ -316,19 +296,24 @@ async function fetchPlayerResponse(
 
   const body = JSON.stringify({
     videoId,
-    context: { client: client.context },
     contentCheckOk: true,
     racyCheckOk: true,
+    context: { client: client.context },
     playbackContext: {
       contentPlaybackContext: { html5Preference: 'HTML5_PREF_WANTS' },
     },
   });
 
   try {
-    const res = await fetch(url, { method: 'POST', headers, body, signal: controller.signal });
+    const res = await fetch(endpoint, {
+      method: 'POST',
+      headers,
+      body,
+      signal: controller.signal,
+    });
     clearTimeout(timer);
     if (!res.ok) {
-      logger.warn('YouTubeExtractor', `[${client.key}] player API HTTP ${res.status}`);
+      logger.warn('YouTubeExtractor', `[${client.key}] HTTP ${res.status}`);
       return null;
     }
     return await res.json() as PlayerResponse;
@@ -344,14 +329,17 @@ async function fetchPlayerResponse(
 }
 
 // ---------------------------------------------------------------------------
-// HLS manifest parsing — pick best variant by height then bandwidth
+// HLS manifest parsing
 // ---------------------------------------------------------------------------
 
 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 });
+    const res = await fetch(manifestUrl, {
+      headers: DEFAULT_HEADERS,
+      signal: controller.signal,
+    });
     clearTimeout(timer);
     if (!res.ok) return null;
     const text = await res.text();
@@ -364,14 +352,16 @@ async function parseBestHlsVariant(manifestUrl: string): Promise<HlsVariant | nu
       const nextLine = lines[i + 1];
       if (!nextLine || nextLine.startsWith('#')) continue;
 
-      // Parse attributes
+      // Parse attribute list
       const attrs: Record<string, string> = {};
-      const attrStr = line.substring(line.indexOf(':') + 1);
       let key = '', val = '', inKey = true, inQuote = false;
-      for (const ch of attrStr) {
+      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) { attrs[key.trim()] = val.trim(); key = ''; val = ''; inKey = true; 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();
@@ -381,14 +371,17 @@ async function parseBestHlsVariant(manifestUrl: string): Promise<HlsVariant | nu
       const height = parseInt(res2[1] ?? '0', 10) || 0;
       const bandwidth = parseInt(attrs['BANDWIDTH'] ?? '0', 10) || 0;
 
-      // Absolutize URL
       let variantUrl = nextLine;
       if (!variantUrl.startsWith('http')) {
-        try { variantUrl = new URL(variantUrl, manifestUrl).toString(); } catch { /* keep as-is */ }
+        try { variantUrl = new URL(variantUrl, manifestUrl).toString(); } catch { /* keep */ }
       }
 
       const candidate: HlsVariant = { url: variantUrl, width, height, bandwidth };
-      if (!best || height > best.height || (height === best.height && bandwidth > best.bandwidth)) {
+      if (
+        !best ||
+        candidate.height > best.height ||
+        (candidate.height === best.height && candidate.bandwidth > best.bandwidth)
+      ) {
         best = candidate;
       }
     }
@@ -401,13 +394,13 @@ async function parseBestHlsVariant(manifestUrl: string): Promise<HlsVariant | nu
 }
 
 // ---------------------------------------------------------------------------
-// Format collection — tries ALL clients, collects from all
+// Format collection — tries ALL clients, collects from all (matching Kotlin)
 // ---------------------------------------------------------------------------
 
 interface CollectedFormats {
-  progressive: StreamCandidate[];   // muxed video+audio
-  adaptiveVideo: StreamCandidate[]; // video-only adaptive
-  adaptiveAudio: StreamCandidate[]; // audio-only adaptive
+  progressive: StreamCandidate[];
+  adaptiveVideo: StreamCandidate[];
+  adaptiveAudio: StreamCandidate[];
   hlsManifests: Array<{ clientKey: string; priority: number; url: string }>;
 }
 
@@ -435,16 +428,17 @@ async function collectAllFormats(
       const sd = resp.streamingData;
       if (!sd) continue;
 
-      // Collect HLS manifest URL if present
       if (sd.hlsManifestUrl) {
         hlsManifests.push({ clientKey: client.key, priority: client.priority, url: sd.hlsManifestUrl });
       }
 
-      let clientProgressive = 0, clientVideo = 0, clientAudio = 0;
+      let nProg = 0, nVid = 0, nAud = 0;
 
-      // Progressive (muxed) formats
+      // Progressive (muxed) formats — matching Kotlin: skip non-video mimeTypes
       for (const f of (sd.formats ?? [])) {
-        if (!f.url || !f.mimeType?.startsWith('video/')) continue;
+        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;
@@ -456,13 +450,10 @@ async function collectAllFormats(
           height,
           fps,
           ext: getExt(f.mimeType),
-          initRange: f.initRange,
-          indexRange: f.indexRange,
           bitrate,
-          mimeType: f.mimeType,
-          itag: f.itag,
+          mimeType: f.mimeType ?? '',
         });
-        clientProgressive++;
+        nProg++;
       }
 
       // Adaptive formats
@@ -482,13 +473,10 @@ async function collectAllFormats(
             height,
             fps,
             ext: getExt(f.mimeType),
-            initRange: f.initRange,
-            indexRange: f.indexRange,
             bitrate,
-            mimeType: f.mimeType,
-            itag: f.itag,
+            mimeType: f.mimeType ?? '',
           });
-          clientVideo++;
+          nVid++;
         } else if (mimeBase.startsWith('audio/')) {
           const bitrate = f.bitrate ?? f.averageBitrate ?? 0;
           const sampleRate = parseFloat(f.audioSampleRate ?? '0') || 0;
@@ -500,18 +488,15 @@ async function collectAllFormats(
             height: 0,
             fps: 0,
             ext: getExt(f.mimeType),
-            initRange: f.initRange,
-            indexRange: f.indexRange,
             bitrate,
             audioSampleRate: f.audioSampleRate,
-            mimeType: f.mimeType,
-            itag: f.itag,
+            mimeType: f.mimeType ?? '',
           });
-          clientAudio++;
+          nAud++;
         }
       }
 
-      logger.info('YouTubeExtractor', `[${client.key}] progressive=${clientProgressive} video=${clientVideo} audio=${clientAudio} hls=${sd.hlsManifestUrl ? 1 : 0}`);
+      logger.info('YouTubeExtractor', `[${client.key}] progressive=${nProg} video=${nVid} audio=${nAud} hls=${sd.hlsManifestUrl ? 1 : 0}`);
     } catch (err) {
       logger.warn('YouTubeExtractor', `[${client.key}] Failed:`, err);
     }
@@ -520,80 +505,6 @@ async function collectAllFormats(
   return { progressive, adaptiveVideo, adaptiveAudio, hlsManifests };
 }
 
-// ---------------------------------------------------------------------------
-// Sorting and selection
-// ---------------------------------------------------------------------------
-
-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;
-}
-
-// ---------------------------------------------------------------------------
-// DASH manifest builder
-// ---------------------------------------------------------------------------
-
-async function buildDashManifest(
-  video: StreamCandidate,
-  audio: StreamCandidate,
-  videoId: string,
-  durationSeconds: number,
-): Promise<string | null> {
-  try {
-    const FileSystem = await import('expo-file-system/legacy');
-    if (!FileSystem.cacheDirectory) return null;
-
-    const esc = (s: string) =>
-      s.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-
-    const dur = `PT${durationSeconds}S`;
-    const vMime = getMimeBase(video.mimeType);
-    const aMime = getMimeBase(audio.mimeType);
-    const vCodec = getCodecs(video.mimeType);
-    const aCodec = getCodecs(audio.mimeType);
-    const vInit = video.initRange ? `${video.initRange.start}-${video.initRange.end}` : '0-0';
-    const vIdx  = video.indexRange ? `${video.indexRange.start}-${video.indexRange.end}` : '0-0';
-    const aInit = audio.initRange ? `${audio.initRange.start}-${audio.initRange.end}` : '0-0';
-    const aIdx  = audio.indexRange ? `${audio.indexRange.start}-${audio.indexRange.end}` : '0-0';
-
-    const mpd = `<?xml version="1.0" encoding="UTF-8"?>
-<MPD xmlns="urn:mpeg:dash:schema:mpd:2011" type="static" mediaPresentationDuration="${dur}" minBufferTime="PT2S" profiles="urn:mpeg:dash:profile:isoff-on-demand:2011">
-  <Period duration="${dur}">
-    <AdaptationSet id="1" mimeType="${vMime}" codecs="${vCodec}" subsegmentAlignment="true" subsegmentStartsWithSAP="1">
-      <Representation id="v1" bandwidth="${video.bitrate}" height="${video.height}">
-        <BaseURL>${esc(video.url)}</BaseURL>
-        <SegmentBase indexRange="${vIdx}"><Initialization range="${vInit}"/></SegmentBase>
-      </Representation>
-    </AdaptationSet>
-    <AdaptationSet id="2" mimeType="${aMime}" codecs="${aCodec}" lang="en" subsegmentAlignment="true" subsegmentStartsWithSAP="1">
-      <Representation id="a1" bandwidth="${audio.bitrate}" audioSamplingRate="${audio.audioSampleRate ?? '44100'}">
-        <BaseURL>${esc(audio.url)}</BaseURL>
-        <SegmentBase indexRange="${aIdx}"><Initialization range="${aInit}"/></SegmentBase>
-      </Representation>
-    </AdaptationSet>
-  </Period>
-</MPD>`;
-
-    const path = `${FileSystem.cacheDirectory}trailer_${videoId}.mpd`;
-    await FileSystem.writeAsStringAsync(path, mpd, { encoding: FileSystem.EncodingType.UTF8 });
-    logger.info('YouTubeExtractor', `DASH manifest: ${path} (video=${video.itag} ${video.height}p, audio=${audio.itag})`);
-    return path;
-  } catch (err) {
-    logger.warn('YouTubeExtractor', 'DASH manifest write failed:', err);
-    return null;
-  }
-}
-
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -602,12 +513,15 @@ export class YouTubeExtractor {
   /**
    * Extract a playable source from a YouTube video ID or URL.
    *
-   * Strategy:
-   * 1. Fetch watch page to get dynamic API key + visitor data
-   * 2. Try ALL clients in parallel — collect formats from all that succeed
-   * 3. On Android: prefer DASH (adaptive video from android_vr + best audio)
-   *    falling back to best HLS manifest, then best progressive
-   * 4. On iOS: prefer HLS manifest (AVPlayer native), then progressive (muxed)
+   * 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
+   *
+   * 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,
@@ -622,30 +536,33 @@ export class YouTubeExtractor {
     const effectivePlatform = platform ?? (Platform.OS === 'android' ? 'android' : 'ios');
     logger.info('YouTubeExtractor', `Extracting videoId=${videoId} platform=${effectivePlatform}`);
 
-    // Step 1: fetch watch page for dynamic API key + visitor data
-    const watchConfig = await fetchWatchConfig(videoId);
-    if (watchConfig.apiKey) {
-      logger.info('YouTubeExtractor', `Got apiKey and visitorData from watch page`);
-    } else {
-      logger.warn('YouTubeExtractor', `Could not get apiKey from watch page — proceeding without`);
-    }
+    // Step 1: watch page for dynamic API key + visitor data
+    const { apiKey, visitorData } = await fetchWatchConfig(videoId);
 
     // Step 2: collect formats from all clients
     const { progressive, adaptiveVideo, adaptiveAudio, hlsManifests } =
-      await collectAllFormats(videoId, watchConfig.apiKey, watchConfig.visitorData);
+      await collectAllFormats(videoId, apiKey, visitorData);
 
-    logger.info('YouTubeExtractor', `Totals: progressive=${progressive.length} adaptiveVideo=${adaptiveVideo.length} adaptiveAudio=${adaptiveAudio.length} hls=${hlsManifests.length}`);
+    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 (by resolution/bandwidth)
+    // Step 3: pick best HLS variant across all manifests
     let bestHls: (HlsVariant & { manifestUrl: string }) | null = null;
-    for (const { url, priority } of hlsManifests.sort((a, b) => a.priority - b.priority)) {
+    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))) {
+      if (
+        variant &&
+        (!bestHls ||
+          variant.height > bestHls.height ||
+          (variant.height === bestHls.height && variant.bandwidth > bestHls.bandwidth))
+      ) {
         bestHls = { ...variant, manifestUrl: url };
       }
     }
@@ -655,95 +572,54 @@ export class YouTubeExtractor {
     const bestAdaptiveAudio = pickBestForClient(adaptiveAudio, PREFERRED_ADAPTIVE_CLIENT);
 
     if (bestHls) logger.info('YouTubeExtractor', `Best HLS: ${bestHls.height}p ${bestHls.bandwidth}bps`);
-    if (bestProgressive) logger.info('YouTubeExtractor', `Best progressive: ${bestProgressive.height}p score=${bestProgressive.score}`);
+    if (bestProgressive) logger.info('YouTubeExtractor', `Best progressive: ${bestProgressive.height}p`);
     if (bestAdaptiveVideo) logger.info('YouTubeExtractor', `Best adaptive video: ${bestAdaptiveVideo.height}p client=${bestAdaptiveVideo.client}`);
-    if (bestAdaptiveAudio) logger.info('YouTubeExtractor', `Best adaptive audio: bitrate=${bestAdaptiveAudio.bitrate} client=${bestAdaptiveAudio.client}`);
+    if (bestAdaptiveAudio) logger.info('YouTubeExtractor', `Best adaptive audio: ${bestAdaptiveAudio.bitrate}bps client=${bestAdaptiveAudio.client}`);
 
-    // Placeholder duration (refined below)
-    const durationSeconds = 300;
-
-    let source: TrailerPlaybackSource | null = null;
-
-    if (effectivePlatform === 'android') {
-      // Android priority: DASH adaptive > HLS > progressive
-      if (bestAdaptiveVideo && bestAdaptiveAudio) {
-        const mpdPath = await buildDashManifest(bestAdaptiveVideo, bestAdaptiveAudio, videoId, durationSeconds);
-        if (mpdPath) {
-          source = {
-            videoUrl: mpdPath,
-            audioUrl: null,
-            quality: `${bestAdaptiveVideo.height}p`,
-            isMuxed: true, // MPD contains both tracks
-            isDash: true,
-            durationSeconds,
-          };
-        }
-      }
-      if (!source && bestHls) {
-        source = {
-          videoUrl: bestHls.manifestUrl,
-          audioUrl: null,
-          quality: `${bestHls.height}p`,
-          isMuxed: true,
-          isDash: false,
-          durationSeconds,
-        };
-      }
-      if (!source && bestProgressive) {
-        source = {
-          videoUrl: bestProgressive.url,
-          audioUrl: null,
-          quality: `${bestProgressive.height}p`,
-          isMuxed: true,
-          isDash: false,
-          durationSeconds,
-        };
-      }
-    } else {
-      // iOS priority: HLS (native AVPlayer support) > progressive
-      if (bestHls) {
-        source = {
-          videoUrl: bestHls.manifestUrl,
-          audioUrl: null,
-          quality: `${bestHls.height}p`,
-          isMuxed: true,
-          isDash: false,
-          durationSeconds,
-        };
-      }
-      if (!source && bestProgressive) {
-        source = {
-          videoUrl: bestProgressive.url,
-          audioUrl: null,
-          quality: `${bestProgressive.height}p`,
-          isMuxed: true,
-          isDash: false,
-          durationSeconds,
-        };
-      }
+    // Step 4: select final source
+    // Priority: HLS > progressive muxed
+    // (No DASH/MPD — react-native-video cannot merge separate video+audio streams)
+    if (bestHls) {
+      logger.info('YouTubeExtractor', `Using HLS: ${summarizeUrl(bestHls.manifestUrl)}`);
+      return {
+        videoUrl: bestHls.manifestUrl,
+        audioUrl: null,
+        quality: `${bestHls.height}p`,
+        videoId,
+      };
     }
 
-    if (!source) {
-      logger.warn('YouTubeExtractor', `Could not build a playable source for videoId=${videoId}`);
-      return null;
+    if (bestProgressive) {
+      logger.info('YouTubeExtractor', `Using progressive: ${summarizeUrl(bestProgressive.url)}`);
+      return {
+        videoUrl: bestProgressive.url,
+        audioUrl: null,
+        quality: `${bestProgressive.height}p`,
+        videoId,
+      };
     }
 
-    logger.info('YouTubeExtractor', `Final source: ${summarizeUrl(source.videoUrl)} quality=${source.quality} dash=${source.isDash}`);
+    // Last resort: video-only adaptive (no audio, but beats nothing)
+    if (bestAdaptiveVideo) {
+      logger.warn('YouTubeExtractor', `Using video-only adaptive (no audio): ${bestAdaptiveVideo.height}p`);
+      return {
+        videoUrl: bestAdaptiveVideo.url,
+        audioUrl: null,
+        quality: `${bestAdaptiveVideo.height}p`,
+        videoId,
+      };
+    }
 
-    return {
-      source,
-      videoId,
-      title: undefined,
-    };
+    logger.warn('YouTubeExtractor', `No playable source for videoId=${videoId}`);
+    return null;
   }
 
-  /** Convenience: returns just the best playable URL or null. */
   static async getBestStreamUrl(
     videoIdOrUrl: string,
     platform?: 'android' | 'ios',
   ): Promise<string | null> {
     const result = await this.extract(videoIdOrUrl, platform);
-    return result?.source.videoUrl ?? null;
+    return result?.videoUrl ?? null;
   }
 
   static parseVideoId(input: string): string | null {

From 16ab2461d9379ac3c1e07844b25bb50984229def Mon Sep 17 00:00:00 2001
From: CK <86251706+altCK129@users.noreply.github.com>
Date: Thu, 5 Mar 2026 20:21:37 +0530
Subject: [PATCH 18/35] Update trailerService.ts

---
 src/services/trailerService.ts | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/src/services/trailerService.ts b/src/services/trailerService.ts
index 000f6b1b..8de90955 100644
--- a/src/services/trailerService.ts
+++ b/src/services/trailerService.ts
@@ -251,12 +251,6 @@ 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;
-    }
     return entry.url;
   }
 

From 6f8515f94346f98bbf18c166bffd79904a22b8f4 Mon Sep 17 00:00:00 2001
From: CK <86251706+altCK129@users.noreply.github.com>
Date: Thu, 5 Mar 2026 20:22:29 +0530
Subject: [PATCH 19/35] Update TrailerPlayer.tsx

---
 src/components/video/TrailerPlayer.tsx | 15 +--------------
 1 file changed, 1 insertion(+), 14 deletions(-)

diff --git a/src/components/video/TrailerPlayer.tsx b/src/components/video/TrailerPlayer.tsx
index 7734aad8..ba4a992e 100644
--- a/src/components/video/TrailerPlayer.tsx
+++ b/src/components/video/TrailerPlayer.tsx
@@ -376,24 +376,11 @@ const TrailerPlayer = React.forwardRef<any, TrailerPlayerProps>(({
         source={(() => {
           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') {
-            // For DASH streams from YouTube (googlevideo.com CDN), use the same
-            // User-Agent as the ANDROID_VR Innertube client used during extraction.
-            // For all other URLs (HLS, MP4 from server fallback) use a generic UA.
-            const isYouTubeCdn = lower.includes('googlevideo.com') || lower.includes('youtube.com');
-            const androidHeaders = {
-              'User-Agent': (looksLikeDash && isYouTubeCdn)
-                ? 'com.google.android.apps.youtube.vr.oculus/1.60.19 (Linux; U; Android 12L; eureka-user Build/SQ3A.220605.009.A1) gzip'
-                : 'Nuvio/1.0 (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;

From 83d19f466c41b8b7a5a3c63d7123df60c36ae4fc Mon Sep 17 00:00:00 2001
From: CK <86251706+altCK129@users.noreply.github.com>
Date: Thu, 5 Mar 2026 20:23:28 +0530
Subject: [PATCH 20/35] Update TrailerModal.tsx

---
 src/components/metadata/TrailerModal.tsx | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

diff --git a/src/components/metadata/TrailerModal.tsx b/src/components/metadata/TrailerModal.tsx
index 4adc0712..09c9f7bc 100644
--- a/src/components/metadata/TrailerModal.tsx
+++ b/src/components/metadata/TrailerModal.tsx
@@ -272,16 +272,11 @@ const TrailerModal: React.FC<TrailerModalProps> = memo(({
                   ref={videoRef}
                   source={(() => {
                     const lower = (trailerUrl || '').toLowerCase();
-                    const looksLikeDash = /\.mpd(\b|$)/.test(lower) || /dash|manifest/.test(lower);
-                    const isYouTubeCdn = lower.includes('googlevideo.com') || lower.includes('youtube.com');
+                    const looksLikeHls = /\.m3u8(\b|$)/.test(lower) || /hls|playlist|m3u/.test(lower);
                     if (Platform.OS === 'android') {
-                      const headers = {
-                        'User-Agent': (looksLikeDash && isYouTubeCdn)
-                          ? 'com.google.android.apps.youtube.vr.oculus/1.60.19 (Linux; U; Android 12L; eureka-user Build/SQ3A.220605.009.A1) gzip'
-                          : 'Nuvio/1.0 (Android)',
-                      };
-                      if (looksLikeDash) {
-                        return { uri: trailerUrl, type: 'mpd', headers } as any;
+                      const headers = { 'User-Agent': 'Nuvio/1.0 (Android)' };
+                      if (looksLikeHls) {
+                        return { uri: trailerUrl, type: 'm3u8', headers } as any;
                       }
                       return { uri: trailerUrl, headers } as any;
                     }

From 23984bdfa6c1741896e36da986c00f48f1c9a94e Mon Sep 17 00:00:00 2001
From: CK <86251706+altCK129@users.noreply.github.com>
Date: Thu, 5 Mar 2026 21:26:54 +0530
Subject: [PATCH 21/35] Update trailerService.ts

---
 src/services/trailerService.ts | 164 +++------------------------------
 1 file changed, 15 insertions(+), 149 deletions(-)

diff --git a/src/services/trailerService.ts b/src/services/trailerService.ts
index 8de90955..7f5238da 100644
--- a/src/services/trailerService.ts
+++ b/src/services/trailerService.ts
@@ -14,18 +14,6 @@ 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;
   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
   // ---------------------------------------------------------------------------
@@ -261,26 +147,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;

From 09707af661bba7a14d0b4600695f621892911e19 Mon Sep 17 00:00:00 2001
From: CK <86251706+altCK129@users.noreply.github.com>
Date: Thu, 5 Mar 2026 21:27:34 +0530
Subject: [PATCH 22/35] Update youtubeExtractor.ts

---
 src/services/youtubeExtractor.ts | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/services/youtubeExtractor.ts b/src/services/youtubeExtractor.ts
index b1103f6b..d4a645b4 100644
--- a/src/services/youtubeExtractor.ts
+++ b/src/services/youtubeExtractor.ts
@@ -78,7 +78,8 @@ const DEFAULT_HEADERS: Record<string, string> = {
 };
 
 const PREFERRED_ADAPTIVE_CLIENT = 'android_vr';
-const REQUEST_TIMEOUT_MS = 20000;
+const REQUEST_TIMEOUT_MS = 12000;       // player API + HLS manifest requests
+const WATCH_PAGE_TIMEOUT_MS = 5000;    // watch page scrape — best-effort only
 
 interface ClientDef {
   key: string;
@@ -243,7 +244,7 @@ interface WatchConfig {
 
 async function fetchWatchConfig(videoId: string): Promise<WatchConfig> {
   const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  const timer = setTimeout(() => controller.abort(), WATCH_PAGE_TIMEOUT_MS);
   try {
     const res = await fetch(
       `https://www.youtube.com/watch?v=${videoId}&hl=en`,
@@ -536,7 +537,8 @@ export class YouTubeExtractor {
     const effectivePlatform = platform ?? (Platform.OS === 'android' ? 'android' : 'ios');
     logger.info('YouTubeExtractor', `Extracting videoId=${videoId} platform=${effectivePlatform}`);
 
-    // Step 1: watch page for dynamic API key + visitor data
+    // Step 1: watch page for dynamic API key + visitor data (5s timeout, best-effort)
+    // Player API works without these — don't let a slow/blocked watch page stall everything
     const { apiKey, visitorData } = await fetchWatchConfig(videoId);
 
     // Step 2: collect formats from all clients

From 5fa02d7c535e1b10c097cd22c1a872ad44974859 Mon Sep 17 00:00:00 2001
From: CK <86251706+altCK129@users.noreply.github.com>
Date: Thu, 5 Mar 2026 21:35:41 +0530
Subject: [PATCH 23/35] Update youtubeExtractor.ts

---
 src/services/youtubeExtractor.ts | 27 +++++++++++++++++++++++----
 1 file changed, 23 insertions(+), 4 deletions(-)

diff --git a/src/services/youtubeExtractor.ts b/src/services/youtubeExtractor.ts
index d4a645b4..4772429d 100644
--- a/src/services/youtubeExtractor.ts
+++ b/src/services/youtubeExtractor.ts
@@ -78,8 +78,9 @@ const DEFAULT_HEADERS: Record<string, string> = {
 };
 
 const PREFERRED_ADAPTIVE_CLIENT = 'android_vr';
-const REQUEST_TIMEOUT_MS = 12000;       // player API + HLS manifest requests
-const WATCH_PAGE_TIMEOUT_MS = 5000;    // watch page scrape — best-effort only
+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;
@@ -535,10 +536,28 @@ export class YouTubeExtractor {
     }
 
     const effectivePlatform = platform ?? (Platform.OS === 'android' ? 'android' : 'ios');
+
+    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 result = await this.extractOnce(videoId, effectivePlatform);
+      if (result) return result;
+      logger.warn('YouTubeExtractor', `Attempt ${attempt} failed for videoId=${videoId}`);
+    }
+
+    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}`);
 
-    // Step 1: watch page for dynamic API key + visitor data (5s timeout, best-effort)
-    // Player API works without these — don't let a slow/blocked watch page stall everything
     const { apiKey, visitorData } = await fetchWatchConfig(videoId);
 
     // Step 2: collect formats from all clients

From a2a801d68a852255ff4c5fc19ec52f359cd9c8f8 Mon Sep 17 00:00:00 2001
From: CK <86251706+altCK129@users.noreply.github.com>
Date: Thu, 5 Mar 2026 21:39:26 +0530
Subject: [PATCH 24/35] Update youtubeExtractor.ts

---
 src/services/youtubeExtractor.ts | 140 ++++++++++++++++---------------
 1 file changed, 74 insertions(+), 66 deletions(-)

diff --git a/src/services/youtubeExtractor.ts b/src/services/youtubeExtractor.ts
index 4772429d..9f26db96 100644
--- a/src/services/youtubeExtractor.ts
+++ b/src/services/youtubeExtractor.ts
@@ -416,35 +416,69 @@ async function collectAllFormats(
   const adaptiveAudio: StreamCandidate[] = [];
   const hlsManifests: Array<{ clientKey: string; priority: number; url: string }> = [];
 
-  for (const client of CLIENTS) {
-    try {
-      const resp = await fetchPlayerResponse(videoId, client, apiKey, visitorData);
-      if (!resp) continue;
+  // 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 }))
+    )
+  );
 
-      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;
-      }
+  for (const result of results) {
+    if (result.status === 'rejected') {
+      logger.warn('YouTubeExtractor', `Client request rejected:`, result.reason);
+      continue;
+    }
 
-      const sd = resp.streamingData;
-      if (!sd) continue;
+    const { client, resp } = result.value;
+    if (!resp) continue;
 
-      if (sd.hlsManifestUrl) {
-        hlsManifests.push({ clientKey: client.key, priority: client.priority, url: sd.hlsManifestUrl });
-      }
+    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;
+    }
 
-      let nProg = 0, nVid = 0, nAud = 0;
+    const sd = resp.streamingData;
+    if (!sd) continue;
 
-      // 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;
+    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;
-        progressive.push({
+        adaptiveVideo.push({
           client: client.key,
           priority: client.priority,
           url: f.url,
@@ -455,53 +489,27 @@ async function collectAllFormats(
           bitrate,
           mimeType: f.mimeType ?? '',
         });
-        nProg++;
+        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++;
       }
-
-      // 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}`);
-    } catch (err) {
-      logger.warn('YouTubeExtractor', `[${client.key}] Failed:`, err);
     }
+
+    logger.info('YouTubeExtractor', `[${client.key}] progressive=${nProg} video=${nVid} audio=${nAud} hls=${sd.hlsManifestUrl ? 1 : 0}`);
   }
 
   return { progressive, adaptiveVideo, adaptiveAudio, hlsManifests };

From 16a9c5c41d7534e55cc7183b29b4e8693521f0d0 Mon Sep 17 00:00:00 2001
From: CK <86251706+altCK129@users.noreply.github.com>
Date: Thu, 5 Mar 2026 21:55:44 +0530
Subject: [PATCH 25/35] Update HeroSection.tsx

---
 src/components/metadata/HeroSection.tsx | 22 +++-------------------
 1 file changed, 3 insertions(+), 19 deletions(-)

diff --git a/src/components/metadata/HeroSection.tsx b/src/components/metadata/HeroSection.tsx
index 6da5a40d..32743cc9 100644
--- a/src/components/metadata/HeroSection.tsx
+++ b/src/components/metadata/HeroSection.tsx
@@ -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}

From 86477b594a6852b6b920bd1a3f7599ba28c2977c Mon Sep 17 00:00:00 2001
From: CK <86251706+altCK129@users.noreply.github.com>
Date: Thu, 5 Mar 2026 16:34:00 +0000
Subject: [PATCH 26/35] Update TrailerModal.tsx

---
 src/components/metadata/TrailerModal.tsx | 25 +++++++++---------------
 1 file changed, 9 insertions(+), 16 deletions(-)

diff --git a/src/components/metadata/TrailerModal.tsx b/src/components/metadata/TrailerModal.tsx
index 09c9f7bc..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);

From ea4218840c69a163734ae939f654dfdf23dc5ba2 Mon Sep 17 00:00:00 2001
From: CK <86251706+altCK129@users.noreply.github.com>
Date: Thu, 5 Mar 2026 16:45:59 +0000
Subject: [PATCH 27/35] Update youtubeExtractor.ts

---
 src/services/youtubeExtractor.ts | 105 +++++++++++++++++++++++++------
 1 file changed, 86 insertions(+), 19 deletions(-)

diff --git a/src/services/youtubeExtractor.ts b/src/services/youtubeExtractor.ts
index 9f26db96..2c58fa4c 100644
--- a/src/services/youtubeExtractor.ts
+++ b/src/services/youtubeExtractor.ts
@@ -216,6 +216,60 @@ function summarizeUrl(url: string): string {
   }
 }
 
+// ---------------------------------------------------------------------------
+// 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;
@@ -596,18 +650,23 @@ export class YouTubeExtractor {
       }
     }
 
-    const bestProgressive = sortCandidates(progressive)[0] ?? null;
+    // 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 (bestProgressive) logger.info('YouTubeExtractor', `Best progressive: ${bestProgressive.height}p`);
+    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}`);
 
-    // Step 4: select final source
+    // 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
-    // (No DASH/MPD — react-native-video cannot merge separate video+audio streams)
+    // HLS manifests don't need validation — they're not CDN segment URLs
     if (bestHls) {
       logger.info('YouTubeExtractor', `Using HLS: ${summarizeUrl(bestHls.manifestUrl)}`);
       return {
@@ -618,25 +677,33 @@ export class YouTubeExtractor {
       };
     }
 
-    if (bestProgressive) {
-      logger.info('YouTubeExtractor', `Using progressive: ${summarizeUrl(bestProgressive.url)}`);
-      return {
-        videoUrl: bestProgressive.url,
-        audioUrl: null,
-        quality: `${bestProgressive.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) {
-      logger.warn('YouTubeExtractor', `Using video-only adaptive (no audio): ${bestAdaptiveVideo.height}p`);
-      return {
-        videoUrl: bestAdaptiveVideo.url,
-        audioUrl: null,
-        quality: `${bestAdaptiveVideo.height}p`,
-        videoId,
-      };
+      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}`);

From dbd5b42b864c9611760779e182a3f33e61e06edb Mon Sep 17 00:00:00 2001
From: CK <86251706+altCK129@users.noreply.github.com>
Date: Thu, 5 Mar 2026 23:54:37 +0530
Subject: [PATCH 28/35] Delete .github/workflows/buillld.yml

---
 .github/workflows/buillld.yml | 95 -----------------------------------
 1 file changed, 95 deletions(-)
 delete mode 100644 .github/workflows/buillld.yml

diff --git a/.github/workflows/buillld.yml b/.github/workflows/buillld.yml
deleted file mode 100644
index 6dac6fda..00000000
--- a/.github/workflows/buillld.yml
+++ /dev/null
@@ -1,95 +0,0 @@
-name: Build Android APK
-
-on:
-  workflow_dispatch:
-    inputs:
-      build_type:
-        description: 'Build type'
-        required: true
-        default: 'release'
-        type: choice
-        options:
-          - release
-          - debug
-      commit_sha:
-        description: 'Commit SHA to build from (leave empty for latest)'
-        required: false
-        type: string
-      notes:
-        description: 'Notes (optional)'
-        required: false
-        type: string
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          ref: ${{ inputs.commit_sha || github.sha }}
-
-      - name: Print build info
-        run: |
-          echo "Building commit: $(git rev-parse HEAD)"
-          echo "Commit message: $(git log -1 --pretty=%B)"
-          echo "Build type: ${{ inputs.build_type }}"
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '18'
-          cache: 'npm'
-
-      - name: Setup Java 17
-        uses: actions/setup-java@v4
-        with:
-          java-version: '17'
-          distribution: 'temurin'
-
-      - name: Setup Android SDK
-        uses: android-actions/setup-android@v3
-
-      - name: Install NDK r29
-        run: |
-          echo "y" | sdkmanager "ndk;29.0.14206865"
-
-      - name: Create .env file (debug defaults)
-        run: |
-          cp .env.example .env
-          sed -i 's/your_[^ ]*/debug_placeholder/g' .env
-
-      - name: Install dependencies
-        run: npm install --legacy-peer-deps
-
-      - name: Apply patches
-        run: npx patch-package
-
-
-      - name: Make gradlew executable
-        run: chmod +x android/gradlew
-
-      - name: Build ${{ inputs.build_type }} APK
-        env:
-          NODE_ENV: production
-          SENTRY_DISABLE_AUTO_UPLOAD: true
-        run: |
-          cd android
-          ./gradlew clean
-          if [ "${{ inputs.build_type }}" = "release" ]; then
-            ./gradlew assembleRelease --no-daemon --stacktrace --rerun-tasks
-          else
-           ./gradlew assembleDebug --no-daemon --stacktrace --rerun-tasks
-          fi
-
-      - name: List APK outputs
-        run: find android/app/build/outputs/apk -name "*.apk" | sort
-
-      - name: Upload APK as artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: nuvio-${{ inputs.build_type }}-${{ inputs.commit_sha != '' && inputs.commit_sha || github.sha }}-run${{ github.run_number }}
-          path: android/app/build/outputs/apk/${{ inputs.build_type }}/*.apk
-          retention-days: 30
-          

From ec9c0db867bedc28ea3a684e10d2a93f18719686 Mon Sep 17 00:00:00 2001
From: chrisk325 <singaracemas@gmail.com>
Date: Fri, 6 Mar 2026 01:25:51 +0530
Subject: [PATCH 29/35] fix logic for cdn caching

---
 src/services/trailerService.ts | 20 ++++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/src/services/trailerService.ts b/src/services/trailerService.ts
index 7f5238da..86762505 100644
--- a/src/services/trailerService.ts
+++ b/src/services/trailerService.ts
@@ -14,8 +14,8 @@ interface CacheEntry {
 }
 
 export class TrailerService {
-  // 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 = 3 * 60 * 1000;
   private static urlCache = new Map<string, CacheEntry>();
 
   // ---------------------------------------------------------------------------
@@ -137,6 +137,22 @@ export class TrailerService {
       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;
   }
 

From 33fa8a08260ee1c66ca4abeb3666e67d59c00f8e Mon Sep 17 00:00:00 2001
From: chrisk325 <singaracemas@gmail.com>
Date: Fri, 6 Mar 2026 02:13:06 +0530
Subject: [PATCH 30/35] fix movie trailers quality in hero section remove
 scaling

---
 src/components/video/TrailerPlayer.tsx | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/src/components/video/TrailerPlayer.tsx b/src/components/video/TrailerPlayer.tsx
index ba4a992e..80da8ce3 100644
--- a/src/components/video/TrailerPlayer.tsx
+++ b/src/components/video/TrailerPlayer.tsx
@@ -385,11 +385,8 @@ const TrailerPlayer = React.forwardRef<any, TrailerPlayerProps>(({
           }
           return { uri: trailerUrl } as any;
         })()}
-        style={[
-          styles.video,
-          contentType === 'movie' && styles.movieVideoScale,
-        ]}
-        resizeMode="cover"
+        style={styles.video}
+        resizeMode="contain"
         paused={!isPlaying}
         repeat={false}
         muted={isMuted}
@@ -519,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,

From 7bd4779745173f712749b4d35f59b1ff0e8792a9 Mon Sep 17 00:00:00 2001
From: chrisk325 <singaracemas@gmail.com>
Date: Fri, 6 Mar 2026 04:15:27 +0530
Subject: [PATCH 31/35] fix merge issues

---
 src/services/youtubeExtractor.ts | 137 +++++++++----------------------
 1 file changed, 41 insertions(+), 96 deletions(-)

diff --git a/src/services/youtubeExtractor.ts b/src/services/youtubeExtractor.ts
index 7f91d2c3..66e028e5 100644
--- a/src/services/youtubeExtractor.ts
+++ b/src/services/youtubeExtractor.ts
@@ -67,35 +67,14 @@ export interface YouTubeExtractionResult {
 // 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,
-    userAgent:
-      'com.google.android.youtube/19.44.41 (Linux; U; Android 11) gzip',
-    hl: 'en',
-    gl: 'US',
-  },
-};
-
-// iOS client as secondary fallback
-const IOS_CLIENT_CONTEXT = {
-  client: {
-    clientName: 'IOS',
-    clientVersion: '19.45.4',
-    deviceModel: 'iPhone16,2',
-    userAgent:
-      'com.google.ios.youtube/19.45.4 (iPhone16,2; U; CPU iOS 17_5_1 like Mac OS X)',
-    hl: 'en',
-    gl: 'US',
-  },
+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';
@@ -349,36 +328,37 @@ async function fetchWatchConfig(videoId: string): Promise<WatchConfig> {
 
 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);
 
-  try {
-    const body = {
-      videoId,
-      context,
-      contentCheckOk: true,
-      racyCheckOk: true,
-    };
+  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 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 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 res = await fetch(endpoint, {
@@ -617,48 +597,13 @@ export class YouTubeExtractor {
       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 result = await this.extractOnce(videoId, effectivePlatform);
       if (result) return result;
@@ -723,7 +668,7 @@ export class YouTubeExtractor {
     // Priority: HLS > progressive muxed
     // HLS manifests don't need validation — they're not CDN segment URLs
     if (bestHls) {
-      logger.info('YouTubeExtractor', `Using HLS: ${summarizeUrl(bestHls.manifestUrl)}`);
+      logger.info('YouTubeExtractor', `Using HLS manifest: ${summarizeUrl(bestHls.manifestUrl)} ${bestHls.height}p`);
       return {
         videoUrl: bestHls.manifestUrl,
         audioUrl: null,

From 1f64ee453aeeb3c87e40350fb63d8457f7a5b3c1 Mon Sep 17 00:00:00 2001
From: chrisk325 <singaracemas@gmail.com>
Date: Fri, 6 Mar 2026 04:19:24 +0530
Subject: [PATCH 32/35] fix previous merge issues

---
 src/services/youtubeExtractor.ts | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/services/youtubeExtractor.ts b/src/services/youtubeExtractor.ts
index 66e028e5..d1d0985d 100644
--- a/src/services/youtubeExtractor.ts
+++ b/src/services/youtubeExtractor.ts
@@ -668,9 +668,12 @@ export class YouTubeExtractor {
     // Priority: HLS > progressive muxed
     // HLS manifests don't need validation — they're not CDN segment URLs
     if (bestHls) {
-      logger.info('YouTubeExtractor', `Using HLS manifest: ${summarizeUrl(bestHls.manifestUrl)} ${bestHls.height}p`);
+      // 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.manifestUrl,
+        videoUrl: bestHls.url,
         audioUrl: null,
         quality: `${bestHls.height}p`,
         videoId,

From 4c6aa39ccfd4c4693f5eda8ef9e58d2e8913c6d1 Mon Sep 17 00:00:00 2001
From: chrisk325 <singaracemas@gmail.com>
Date: Fri, 6 Mar 2026 04:30:52 +0530
Subject: [PATCH 33/35] reduce cache ttl

---
 src/services/trailerService.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/services/trailerService.ts b/src/services/trailerService.ts
index 86762505..0bb11cae 100644
--- a/src/services/trailerService.ts
+++ b/src/services/trailerService.ts
@@ -15,7 +15,7 @@ interface CacheEntry {
 
 export class TrailerService {
   // Cache for 3 minutes — just enough to avoid re-extracting on quick re-renders
-  private static readonly CACHE_TTL_MS = 3 * 60 * 1000;
+  private static readonly CACHE_TTL_MS = 30 * 1000;
   private static urlCache = new Map<string, CacheEntry>();
 
   // ---------------------------------------------------------------------------

From 0dc207cc85ef1b84adc9ba730d9d9b6c24ea5026 Mon Sep 17 00:00:00 2001
From: chrisk325 <singaracemas@gmail.com>
Date: Fri, 6 Mar 2026 05:37:33 +0530
Subject: [PATCH 34/35] trailer aspect ratio from contain to cover

---
 src/components/video/TrailerPlayer.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/components/video/TrailerPlayer.tsx b/src/components/video/TrailerPlayer.tsx
index 80da8ce3..b7aa6162 100644
--- a/src/components/video/TrailerPlayer.tsx
+++ b/src/components/video/TrailerPlayer.tsx
@@ -386,7 +386,7 @@ const TrailerPlayer = React.forwardRef<any, TrailerPlayerProps>(({
           return { uri: trailerUrl } as any;
         })()}
         style={styles.video}
-        resizeMode="contain"
+        resizeMode="cover"
         paused={!isPlaying}
         repeat={false}
         muted={isMuted}

From b89c5b7b4f30bce681ac78088ff07c7dab8462fb Mon Sep 17 00:00:00 2001
From: tapframe <85391825+tapframe@users.noreply.github.com>
Date: Fri, 6 Mar 2026 09:10:09 +0530
Subject: [PATCH 35/35] change in ipa bundleID

---
 nuvio-source.json                  | 4 ++--
 src/screens/ContributorsScreen.tsx | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

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/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)}