fix(subtitles): guard track-list effect against stale async runs

The track-building effect in VideoContext reruns once api?.basePath and isCurrentSubImageBased settle. An earlier async run could resolve after a rerun and overwrite subtitleTracks/audioTracks with setTrack callbacks bound to a stale `api`, breaking external-subtitle identity matching. Add a cancellation token and route every state commit through guarded committers so all six commit points (offline-transcoded audio/subs, burned-in, and the online audio/subs paths) drop writes from a dead run, plus bail out right after the awaited getAudioTracks when cancelled.
fix(subtitles): rebuild track callbacks when isCurrentSubImageBased changes
2026-06-30 01:22:56 +01:00 · 2026-06-30 01:56:58 +02:00 · 2026-06-30 01:41:21 +02:00 · 2026-06-30 01:32:43 +02:00 · 2026-06-30 01:19:18 +02:00 · 2026-06-30 01:10:59 +02:00
47 changed files with 1548 additions and 786 deletions
--- a/.github/copilot-instructions.md
+++ b/.github/copilot-instructions.md
@@ -42,7 +42,7 @@ and provides seamless media streaming with offline capabilities and Chromecast s

 ## Coding Standards

- Use TypeScript for ALL files (no .js files)
+- Use TypeScript for ALL files (no .js files). Tooling-required exceptions: `babel.config.js`, `metro.config.js`, `react-native.config.js`, `tailwind.config.js` (their loaders cannot parse TypeScript)
 - Use descriptive English names for variables, functions, and components
 - Prefer functional React components with hooks
 - Use Jotai atoms for global state management
--- a/.github/workflows/detect-duplicate.yml
+++ b/.github/workflows/detect-duplicate.yml
@@ -30,7 +30,7 @@ jobs:
          bun-version: "1.3.14"

      - name: 🔍 Detect duplicate issues
-        run: bun scripts/detect-duplicate-issue.mjs
+        run: bun scripts/detect-duplicate-issue.ts
        env:
          GH_TOKEN: ${{ github.token }}
          GITHUB_REPOSITORY: ${{ github.repository }}
--- a/.gitignore
+++ b/.gitignore
@@ -12,10 +12,6 @@ web-build/
 # Platform-specific Build Directories
 /ios
 /android
-/iostv
-/iosmobile
-/androidmobile
-/androidtv

 # Gradle caches (top-level + per-module native projects)
 **/.gradle/
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -152,7 +152,7 @@ import { apiAtom } from "@/providers/JellyfinProvider";

 ## Coding Standards

- Use TypeScript for all files (no .js)
+- Use TypeScript for all files (no .js). Tooling-required exceptions: `babel.config.js`, `metro.config.js`, `react-native.config.js`, `tailwind.config.js` (their loaders cannot parse TypeScript)
 - Use functional React components with hooks
 - Use Jotai atoms for global state, React Query for server state
 - Follow BiomeJS formatting rules (2-space indent, semicolons, LF line endings)
--- a/app/(auth)/player/direct-player.tsx
+++ b/app/(auth)/player/direct-player.tsx
@@ -56,8 +56,8 @@ import { getDefaultPlaySettings } from "@/utils/jellyfin/getDefaultPlaySettings"
 import { getPrimaryImageUrl } from "@/utils/jellyfin/image/getPrimaryImageUrl";
 import { getStreamUrl } from "@/utils/jellyfin/media/getStreamUrl";
 import {
+  applyMpvSubtitleSelection,
  getMpvAudioId,
-  getMpvSubtitleId,
 } from "@/utils/jellyfin/subtitleUtils";
 import { writeToLog } from "@/utils/log";
 import { msToTicks, ticksToSeconds } from "@/utils/time";
@@ -456,10 +456,23 @@ export default function DirectPlayerPage() {
    });
    reportPlaybackStopped();
    setIsPlaybackStopped(true);
-    videoRef.current?.pause();
+    // Synchronously destroy the mpv instance + decoder + surface buffers
+    // BEFORE the screen unmounts. Otherwise the next screen (or the next
+    // episode's player) mounts while the old 4K decoder is still alive,
+    // causing OOM on low-RAM devices. Native stop() is idempotent so the
+    // later React unmount cleanup is still safe.
+    videoRef.current?.destroy().catch(() => {});
+    // Pre-libmpv-1.0 used `stop()`:
+    // videoRef.current?.stop();
    revalidateProgressCache();
    // Resume inactivity timer when leaving player (TV only)
    resumeInactivityTimer();
+    // Release the keep-awake wakelock acquired during playback so it
+    // doesn't follow us back to the home screen and block the TV
+    // screensaver. activateKeepAwakeAsync() is tag-scoped to this module
+    // and only released on the "paused" event; without this, navigating
+    // away mid-play leaves FLAG_KEEP_SCREEN_ON set on the window.
+    deactivateKeepAwake();
  }, [videoRef, reportPlaybackStopped, progress, resumeInactivityTimer]);

  useEffect(() => {
@@ -626,12 +639,9 @@ export default function DirectPlayerPage() {
      ).map((s) => s.DeliveryUrl!);
    }

-    // Calculate track IDs for initial selection
-    const initialSubtitleId = getMpvSubtitleId(
-      mediaSource,
-      subtitleIndex,
-      isTranscoding,
-    );
+    // Audio maps positionally (audio tracks aren't reordered or hidden like
+    // subtitles). The subtitle selection is applied later, once MPV's real track
+    // list is known — see applySubtitleSelection / onTracksReady.
    const initialAudioId = getMpvAudioId(
      mediaSource,
      audioIndex,
@@ -649,7 +659,6 @@ export default function DirectPlayerPage() {
      url: stream.url,
      startPosition: startPos,
      autoplay: true,
-      initialSubtitleId,
      initialAudioId,
      // Pass cache/buffer settings from user preferences
      cacheConfig: {
@@ -697,7 +706,6 @@ export default function DirectPlayerPage() {
    playbackPositionFromUrl,
    api?.basePath,
    api?.accessToken,
-    subtitleIndex,
    audioIndex,
    offline,
    settings.mpvCacheEnabled,
@@ -895,30 +903,41 @@ export default function DirectPlayerPage() {
  );

  // TV subtitle track change handler
+  /**
+   * Resolve a Jellyfin subtitle index against MPV's *real* track list and apply
+   * it. Identity-based (external by filename, embedded by language/title) so it
+   * stays correct across external/embedded reordering and server-hidden embedded
+   * subs — unlike positional mapping. Reused for initial selection (onTracksReady,
+   * fired again after each external sub-add) and runtime changes.
+   */
+  const applySubtitleSelection = useCallback(
+    async (jellyfinSubtitleIndex: number) => {
+      const subtitleStreams = stream?.mediaSource?.MediaStreams?.filter(
+        (s) => s.Type === "Subtitle",
+      );
+      await applyMpvSubtitleSelection(videoRef.current, {
+        subtitleStreams,
+        jellyfinSubtitleIndex,
+        // The exact URL each external sub was loaded into MPV with — mirrors the
+        // externalSubtitles array built in videoSource (online: basePath +
+        // DeliveryUrl, offline: local DeliveryUrl).
+        getExpectedExternalUrl: (s) => {
+          if (!s.DeliveryUrl) return undefined;
+          if (offline) return s.DeliveryUrl;
+          return api?.basePath ? `${api.basePath}${s.DeliveryUrl}` : undefined;
+        },
+      });
+    },
+    [stream?.mediaSource, offline, api?.basePath],
+  );
+
+  // TV/mobile subtitle track change handler
  const handleSubtitleIndexChange = useCallback(
    async (index: number) => {
      setCurrentSubtitleIndex(index);
-
-      // Check if we're transcoding
-      const isTranscoding = Boolean(stream?.mediaSource?.TranscodingUrl);
-
-      if (index === -1) {
-        // Disable subtitles
-        await videoRef.current?.disableSubtitles?.();
-      } else {
-        // Convert Jellyfin index to MPV track ID
-        const mpvTrackId = getMpvSubtitleId(
-          stream?.mediaSource,
-          index,
-          isTranscoding,
-        );
-
-        if (mpvTrackId !== undefined && mpvTrackId !== -1) {
-          await videoRef.current?.setSubtitleTrack?.(mpvTrackId);
-        }
-      }
+      await applySubtitleSelection(index);
    },
-    [stream?.mediaSource],
+    [applySubtitleSelection],
  );

  // Technical info toggle handler
@@ -1105,6 +1124,15 @@ export default function DirectPlayerPage() {
        nextItem.UserData?.PlaybackPositionTicks?.toString() ?? "",
    }).toString();

+    // Destroy the current mpv instance BEFORE navigating so the old 4K
+    // decoder + surface buffers are freed before the new player screen
+    // mounts. Without this, Expo Router briefly holds two simultaneous
+    // mpv instances during the transition (~768 MB of surface buffers
+    // for two 4K HDR10+ decoders) and OOM-kills the app on low-RAM
+    // devices. Native stop() is idempotent so the subsequent React
+    // unmount cleanup is still safe.
+    videoRef.current?.destroy().catch(() => {});
+
    router.replace(`player/direct-player?${queryParams}` as any);
  }, [
    nextItem,
@@ -1115,6 +1143,7 @@ export default function DirectPlayerPage() {
    bitrateValue,
    router,
    isPlaybackStopped,
+    videoRef,
  ]);

  // Apply subtitle settings when video loads
@@ -1273,6 +1302,10 @@ export default function DirectPlayerPage() {
                }}
                onTracksReady={() => {
                  setTracksReady(true);
+                  // Fired after embedded tracks enumerate and again after each
+                  // external sub-add; re-resolve so the final fire (full track
+                  // list) selects the right track by identity.
+                  void applySubtitleSelection(currentSubtitleIndex);
                }}
              />
              {!hasPlaybackStarted && (
--- a/app/_layout.tsx
+++ b/app/_layout.tsx
@@ -7,6 +7,7 @@ import { onlineManager, QueryClient } from "@tanstack/react-query";
 import { PersistQueryClientProvider } from "@tanstack/react-query-persist-client";
 import * as BackgroundTask from "expo-background-task";
 import * as Device from "expo-device";
+import { Image } from "expo-image";
 import { DarkTheme, ThemeProvider } from "expo-router/react-navigation";
 import { Platform } from "react-native";
 import { GlobalModal } from "@/components/GlobalModal";
@@ -100,6 +101,22 @@ SplashScreen.setOptions({
  fade: true,
 });

+// Cap expo-image's in-memory cache. Default is unbounded (maxMemoryCost=0),
+// which on a 2GB Android TV box leads to ~200MB of decoded backdrops/posters
+// pinned in RAM after browsing. Caps are intentionally tighter on TV (which
+// has less RAM and runs alongside libmpv/MediaCodec) than on mobile.
+// Cost is measured in bytes of decoded bitmap (ARGB8888 = 4 bytes/pixel).
+try {
+  Image.configureCache({
+    maxMemoryCost: Platform.isTV
+      ? 8 * 1024 * 1024 // ~8 MB on TV
+      : 128 * 1024 * 1024, // ~128 MB on mobile
+    maxDiskSize: 200 * 1024 * 1024, // 200 MB disk cache on all platforms
+  });
+} catch {
+  // configureCache is a no-op on some platforms/versions; safe to ignore.
+}
+
 function useNotificationObserver() {
  const router = useRouter();

--- a/biome.json
+++ b/biome.json
@@ -1,5 +1,5 @@
 {
-  "$schema": "https://biomejs.dev/schemas/2.5.1/schema.json",
+  "$schema": "https://biomejs.dev/schemas/2.4.16/schema.json",
  "files": {
    "includes": [
      "**/*",
--- a/bun.lock
+++ b/bun.lock
@@ -100,7 +100,7 @@
      },
      "devDependencies": {
        "@babel/core": "7.29.7",
-        "@biomejs/biome": "2.5.1",
+        "@biomejs/biome": "2.4.16",
        "@react-native-community/cli": "20.1.3",
        "@react-native-tvos/config-tv": "0.1.6",
        "@types/jest": "29.5.14",
@@ -266,23 +266,23 @@

    "@babel/types": ["@babel/types@7.29.7", "", { "dependencies": { "@babel/helper-string-parser": "^7.29.7", "@babel/helper-validator-identifier": "^7.29.7" } }, "sha512-4zBIxpPzowiZpusoFkyGVwakdRJUyuH5PxQ/PrqghfdFWWasvnCdPfQXHrenDai+gyLARulZjZowCOj6fjT4pA=="],

-    "@biomejs/biome": ["@biomejs/biome@2.5.1", "", { "optionalDependencies": { "@biomejs/cli-darwin-arm64": "2.5.1", "@biomejs/cli-darwin-x64": "2.5.1", "@biomejs/cli-linux-arm64": "2.5.1", "@biomejs/cli-linux-arm64-musl": "2.5.1", "@biomejs/cli-linux-x64": "2.5.1", "@biomejs/cli-linux-x64-musl": "2.5.1", "@biomejs/cli-win32-arm64": "2.5.1", "@biomejs/cli-win32-x64": "2.5.1" }, "bin": { "biome": "bin/biome" } }, "sha512-IXWLCxKmae+rI7LOHS1B3EbVisQ6GRAWbhN9msa6KjNCyFWrvKZWR4oUdinaNssrV852OrSHuSPa95h1GPJc7Q=="],
+    "@biomejs/biome": ["@biomejs/biome@2.4.16", "", { "optionalDependencies": { "@biomejs/cli-darwin-arm64": "2.4.16", "@biomejs/cli-darwin-x64": "2.4.16", "@biomejs/cli-linux-arm64": "2.4.16", "@biomejs/cli-linux-arm64-musl": "2.4.16", "@biomejs/cli-linux-x64": "2.4.16", "@biomejs/cli-linux-x64-musl": "2.4.16", "@biomejs/cli-win32-arm64": "2.4.16", "@biomejs/cli-win32-x64": "2.4.16" }, "bin": { "biome": "bin/biome" } }, "sha512-x9ajFh1zChVybCiM3TN6OD4phAqLgtPZjFrZF+aTMYCPjwBO+k529TX7PPsAqtGNLeV4UgzwQnowEgS7bGmzcA=="],

-    "@biomejs/cli-darwin-arm64": ["@biomejs/cli-darwin-arm64@2.5.1", "", { "os": "darwin", "cpu": "arm64" }, "sha512-npqDzvqv7vFaWRiNN1Te71siRgPaqS9MpqgYCdP/CrUbkJ7ApezaeaKjueKHRN/JH/6lRjJQAHi8acQDCAz22w=="],
+    "@biomejs/cli-darwin-arm64": ["@biomejs/cli-darwin-arm64@2.4.16", "", { "os": "darwin", "cpu": "arm64" }, "sha512-wxPvu4XOA85YJk9ixSWUmq/QBHbid85BISbOAqqBM/5xQpPk9ayjk5375tOlSC0BeCwNSbPFafQBm+vBumXq0A=="],

-    "@biomejs/cli-darwin-x64": ["@biomejs/cli-darwin-x64@2.5.1", "", { "os": "darwin", "cpu": "x64" }, "sha512-RgwTqPAM8g2tn1j+b5oRjF/DbSBX8a4gwojtuG9XuhfK7GgomvZ9+T+tqjXiVbjLEeGJOoL6VEk8mvRTVeSybw=="],
+    "@biomejs/cli-darwin-x64": ["@biomejs/cli-darwin-x64@2.4.16", "", { "os": "darwin", "cpu": "x64" }, "sha512-xFCqGPwYusQJp4N4NJLi1XJiZqjwFdjhT+KqtNy+Ug3qgfczqnTa6MSDvxJF6TkuDLoYJItMapz6tAf7kCekFw=="],

-    "@biomejs/cli-linux-arm64": ["@biomejs/cli-linux-arm64@2.5.1", "", { "os": "linux", "cpu": "arm64" }, "sha512-yhV35CzZh38VyMvTEXi3JTjxZBs++oCKK9KG8vB6VI5+uvQvZNR3BFWEKKzuOmx9DJJj7sQpZ4LQJcmbGTs3+Q=="],
+    "@biomejs/cli-linux-arm64": ["@biomejs/cli-linux-arm64@2.4.16", "", { "os": "linux", "cpu": "arm64" }, "sha512-2kFb4//jxfZaP6D+Rj5VkHkxgyD9EoRAVBEQb8PKRv+s4NO2zYNJKXFaJmK1CmhufJOWEfpHKaRbOja7qjmdhQ=="],

-    "@biomejs/cli-linux-arm64-musl": ["@biomejs/cli-linux-arm64-musl@2.5.1", "", { "os": "linux", "cpu": "arm64" }, "sha512-WMcvMLgByyTqVxGlq918NBBYliq9FRR9GAQVETHb+VjGVqXCZFfHlZHC1FX4ibuYY/Hg6TJE3rHU0xVrdJXNRw=="],
+    "@biomejs/cli-linux-arm64-musl": ["@biomejs/cli-linux-arm64-musl@2.4.16", "", { "os": "linux", "cpu": "arm64" }, "sha512-oYxnW0ARfJkr72ezzF2OR8N/rtkgLUQeYtF8cFhVswbknHxtTcmzSsanVJP8yQKnGpGpc2ck6c5zLvHahL6Cbg=="],

-    "@biomejs/cli-linux-x64": ["@biomejs/cli-linux-x64@2.5.1", "", { "os": "linux", "cpu": "x64" }, "sha512-J/7uHSX7NfoYDI7HijAkd8lnQIOrRb2W7j3X+tw4R+N5ExvXGsyXFiGdQcfcxfOmNQmZVSQOCDk757fwpzqQcg=="],
+    "@biomejs/cli-linux-x64": ["@biomejs/cli-linux-x64@2.4.16", "", { "os": "linux", "cpu": "x64" }, "sha512-NbcBbi/nJqn5baae6wqRXdS7Gadf2uRpehSh6vMSYpG8OhkXl/Xg8aorWrJ+9VWqAT5ml90alLvorkpMW0nBwQ=="],

-    "@biomejs/cli-linux-x64-musl": ["@biomejs/cli-linux-x64-musl@2.5.1", "", { "os": "linux", "cpu": "x64" }, "sha512-ANTowtlLmPYm5yeMckWY8Xzb9Ix+JJP3tgHR/n6xRj1VWyIzzWtfRfih9hv9VmClwadpBvZduISZIbBsIlYG3A=="],
+    "@biomejs/cli-linux-x64-musl": ["@biomejs/cli-linux-x64-musl@2.4.16", "", { "os": "linux", "cpu": "x64" }, "sha512-iHDS+MCM65DPqWGu+ECC3uoALyj2H7F4nVUPxIPjz/PIl94EUu+EDfGZDzFP+NY1EOPVt9NQvwFqq7HdMmowdg=="],

-    "@biomejs/cli-win32-arm64": ["@biomejs/cli-win32-arm64@2.5.1", "", { "os": "win32", "cpu": "arm64" }, "sha512-zgXnKNgWPC4iPF7Y1lR3STUeCUuZRpD6IiOrC7TZTlh0Lx6FiVUT05myuMQHQ9D+1cc7uyMldi4forE6lp0ivQ=="],
+    "@biomejs/cli-win32-arm64": ["@biomejs/cli-win32-arm64@2.4.16", "", { "os": "win32", "cpu": "arm64" }, "sha512-0rgImMsNb5v/chhkIFe3wu7PEFClS6RBAYUijGL9UsYN3PanSaoK24HSSuSJb1pYbYYVjzAyZTl3gtjJ84BM8A=="],

-    "@biomejs/cli-win32-x64": ["@biomejs/cli-win32-x64@2.5.1", "", { "os": "win32", "cpu": "x64" }, "sha512-6uxpR9hvaglANkZemeSiN/FhYgkGasrEGn267eXIWvjrjJ2LhDlk251IhjVJq6MXzkV2/bcXwLwSroLyPtqRZg=="],
+    "@biomejs/cli-win32-x64": ["@biomejs/cli-win32-x64@2.4.16", "", { "os": "win32", "cpu": "x64" }, "sha512-Kp85jgoBHa05gix6UIRjfCDiUV3w/8VIdZ247VyyO2gEjaw12WEVhdIjlxp/AMzXxqxQwbxNTDVZ3Mwd2RG5rw=="],

    "@bottom-tabs/react-navigation": ["@bottom-tabs/react-navigation@1.2.0", "", { "dependencies": { "color": "^5.0.0" }, "peerDependencies": { "@react-navigation/native": ">=7", "react": "*", "react-native": "*", "react-native-bottom-tabs": "*" } }, "sha512-gEnLP7q9Iai0KlVxHDIdlrDgkvJ5vwPzL2+2ucz5BdPWd++Cf5GO1jPq92R4/85PrioviCZnlAD91Wx8WxPOjA=="],

--- a/components/ItemContent.tv.tsx
+++ b/components/ItemContent.tv.tsx
@@ -56,6 +56,7 @@ import { useSettings } from "@/utils/atoms/settings";
 import type { TVOptionItem } from "@/utils/atoms/tvOptionModal";
 import { getLogoImageUrlById } from "@/utils/jellyfin/image/getLogoImageUrlById";
 import { getPrimaryImageUrlById } from "@/utils/jellyfin/image/getPrimaryImageUrlById";
+import { compareTracksForMenu } from "@/utils/jellyfin/subtitleUtils";
 import { formatDuration, runtimeTicksToMinutes } from "@/utils/time";

 const { width: SCREEN_WIDTH, height: SCREEN_HEIGHT } = Dimensions.get("window");
@@ -232,12 +233,13 @@ export const ItemContentTV: React.FC<ItemContentTVProps> = React.memo(
      return streams ?? [];
    }, [selectedOptions?.mediaSource]);

-    // Get available subtitle tracks (raw MediaStream[] for label lookup)
+    // Get available subtitle tracks (raw MediaStream[] for label lookup),
+    // ordered like jellyfin-web (embedded first, externals last, forced/default up).
    const subtitleStreams = useMemo(() => {
      const streams = selectedOptions?.mediaSource?.MediaStreams?.filter(
        (s) => s.Type === "Subtitle",
      );
-      return streams ?? [];
+      return streams ? [...streams].sort(compareTracksForMenu) : [];
    }, [selectedOptions?.mediaSource]);

    // Store handleSubtitleChange in a ref for stable callback reference
@@ -411,11 +413,13 @@ export const ItemContentTV: React.FC<ItemContentTVProps> = React.memo(
            )
          : freshItem.MediaSources?.[0];

-        // Get subtitle streams from the fresh data
-        const streams =
-          mediaSource?.MediaStreams?.filter(
+        // Get subtitle streams from the fresh data, ordered like jellyfin-web
+        // (embedded first, externals last) — same as the initial list.
+        const streams = [
+          ...(mediaSource?.MediaStreams?.filter(
            (s: MediaStream) => s.Type === "Subtitle",
-          ) ?? [];
+          ) ?? []),
+        ].sort(compareTracksForMenu);

        // Convert to Track[] with setTrack callbacks
        const tracks: Track[] = streams.map((stream) => ({
--- a/components/MediaSourceButton.tsx
+++ b/components/MediaSourceButton.tsx
@@ -7,6 +7,7 @@ import { useCallback, useEffect, useMemo, useState } from "react";
 import { useTranslation } from "react-i18next";
 import { ActivityIndicator, TouchableOpacity, View } from "react-native";
 import type { ThemeColors } from "@/hooks/useImageColorsReturn";
+import { compareTracksForMenu } from "@/utils/jellyfin/subtitleUtils";
 import { BITRATES } from "./BitRateSheet";
 import type { SelectedOptions } from "./ItemContent";
 import { type OptionGroup, PlatformDropdown } from "./PlatformDropdown";
@@ -63,9 +64,12 @@ export const MediaSourceButton: React.FC<Props> = ({

  const subtitleStreams = useMemo(
    () =>
-      selectedOptions.mediaSource?.MediaStreams?.filter(
-        (x) => x.Type === "Subtitle",
-      ) || [],
+      // Order like jellyfin-web (embedded first, externals last, forced/default up).
+      [
+        ...(selectedOptions.mediaSource?.MediaStreams?.filter(
+          (x) => x.Type === "Subtitle",
+        ) || []),
+      ].sort(compareTracksForMenu),
    [selectedOptions.mediaSource],
  );

--- a/components/SubtitleTrackSelector.tsx
+++ b/components/SubtitleTrackSelector.tsx
@@ -2,6 +2,7 @@ import type { MediaSourceInfo } from "@jellyfin/sdk/lib/generated-client/models"
 import { useMemo, useState } from "react";
 import { useTranslation } from "react-i18next";
 import { Platform, TouchableOpacity, View } from "react-native";
+import { compareTracksForMenu } from "@/utils/jellyfin/subtitleUtils";
 import { tc } from "@/utils/textTools";
 import { Text } from "./common/Text";
 import { type OptionGroup, PlatformDropdown } from "./PlatformDropdown";
@@ -22,7 +23,9 @@ export const SubtitleTrackSelector: React.FC<Props> = ({
  const [open, setOpen] = useState(false);

  const subtitleStreams = useMemo(() => {
-    return source?.MediaStreams?.filter((x) => x.Type === "Subtitle");
+    const subs = source?.MediaStreams?.filter((x) => x.Type === "Subtitle");
+    // Order like jellyfin-web (embedded first, externals last, forced/default up).
+    return subs ? [...subs].sort(compareTracksForMenu) : subs;
  }, [source]);

  const selectedSubtitleSteam = useMemo(
--- a/components/home/Home.tv.tsx
+++ b/components/home/Home.tv.tsx
@@ -140,9 +140,11 @@ export const Home = () => {
    let isCancelled = false;

    const performCrossfade = async () => {
-      // Prefetch the image before starting the crossfade
+      // Prefetch to disk only - the full-size 1920x1080 backdrop (~8MB
+      // decoded ARGB) is too large to pin in the memory cache on every
+      // focus change. Disk cache is fast enough for a 500ms crossfade.
      try {
-        await Image.prefetch(backdropUrl);
+        await Image.prefetch(backdropUrl, "disk");
      } catch {
        // Continue even if prefetch fails
      }
--- a/components/home/InfiniteScrollingCollectionList.tv.tsx
+++ b/components/home/InfiniteScrollingCollectionList.tv.tsx
@@ -326,9 +326,9 @@ export const InfiniteScrollingCollectionList: React.FC<Props> = ({
          showsHorizontalScrollIndicator={false}
          onEndReached={handleEndReached}
          onEndReachedThreshold={0.5}
-          initialNumToRender={5}
-          maxToRenderPerBatch={3}
-          windowSize={5}
+          initialNumToRender={4}
+          maxToRenderPerBatch={2}
+          windowSize={3}
          removeClippedSubviews={false}
          maintainVisibleContentPosition={{ minIndexForVisible: 0 }}
          style={{ overflow: "visible" }}
--- a/components/home/TVHeroCarousel.tsx
+++ b/components/home/TVHeroCarousel.tsx
@@ -256,8 +256,11 @@ export const TVHeroCarousel: React.FC<TVHeroCarouselProps> = ({
    let isCancelled = false;

    const performCrossfade = async () => {
+      // Disk-only prefetch: backdrops are ~8MB decoded ARGB; keeping them
+      // out of the memory cache avoids bloat when the user cycles through
+      // hero items quickly.
      try {
-        await Image.prefetch(backdropUrl);
+        await Image.prefetch(backdropUrl, "disk");
      } catch {
        // Continue even if prefetch fails
      }
--- a/components/persons/TVActorPage.tsx
+++ b/components/persons/TVActorPage.tsx
@@ -156,9 +156,9 @@ export const TVActorPage: React.FC<TVActorPageProps> = ({ personId }) => {
    let isCancelled = false;

    const performCrossfade = async () => {
-      // Prefetch the image before starting the crossfade
+      // Disk-only prefetch to avoid pinning large backdrops in memory cache.
      try {
-        await Image.prefetch(backdropUrl);
+        await Image.prefetch(backdropUrl, "disk");
      } catch {
        // Continue even if prefetch fails
      }
--- a/components/tv/TVPosterCard.tsx
+++ b/components/tv/TVPosterCard.tsx
@@ -448,8 +448,8 @@ export const TVPosterCard: React.FC<TVPosterCardProps> = ({
        <Image
          placeholder={{ blurhash }}
          key={item.Id}
-          id={item.Id}
          source={{ uri: imageUrl }}
+          recyclingKey={item.Id}
          cachePolicy='memory-disk'
          contentFit='cover'
          style={{
--- a/components/video-player/controls/Controls.tv.tsx
+++ b/components/video-player/controls/Controls.tv.tsx
@@ -51,6 +51,7 @@ import { useOfflineMode } from "@/providers/OfflineModeProvider";
 import { useSettings } from "@/utils/atoms/settings";
 import type { TVOptionItem } from "@/utils/atoms/tvOptionModal";
 import { getDefaultPlaySettings } from "@/utils/jellyfin/getDefaultPlaySettings";
+import { compareTracksForMenu } from "@/utils/jellyfin/subtitleUtils";
 import { formatTimeString, msToTicks, ticksToMs } from "@/utils/time";
 import { CONTROLS_CONSTANTS } from "./constants";
 import { useVideoContext } from "./contexts/VideoContext";
@@ -317,8 +318,10 @@ export const Controls: FC<Props> = ({
    try {
      const streams = (await onRefreshSubtitleTracks?.()) ?? [];
      // Skip streams without a real index: `?? -1` would alias them to the
-      // "disable subtitles" sentinel and mis-route selection.
-      return streams
+      // "disable subtitles" sentinel and mis-route selection. Order like
+      // jellyfin-web (embedded first, externals last, forced/default up).
+      return [...streams]
+        .sort(compareTracksForMenu)
        .filter((stream) => typeof stream.Index === "number")
        .map((stream) => {
          const index = stream.Index as number;
--- a/components/video-player/controls/TVSubtitleSheet.tsx
+++ b/components/video-player/controls/TVSubtitleSheet.tsx
@@ -33,6 +33,7 @@ import {
  type SubtitleSearchResult,
  useRemoteSubtitles,
 } from "@/hooks/useRemoteSubtitles";
+import { compareTracksForMenu } from "@/utils/jellyfin/subtitleUtils";
 import { COMMON_SUBTITLE_LANGUAGES } from "@/utils/opensubtitles/api";

 interface TVSubtitleSheetProps {
@@ -96,13 +97,19 @@ export const TVSubtitleSheet: React.FC<TVSubtitleSheetProps> = ({
  const overlayOpacity = useRef(new Animated.Value(0)).current;
  const sheetTranslateY = useRef(new Animated.Value(300)).current;

+  // Order like jellyfin-web (embedded first, externals last, forced/default up).
+  const sortedTracks = useMemo(
+    () => [...subtitleTracks].sort(compareTracksForMenu),
+    [subtitleTracks],
+  );
+
  const initialSelectedTrackIndex = useMemo(() => {
    if (currentSubtitleIndex === -1) return 0;
-    const trackIdx = subtitleTracks.findIndex(
+    const trackIdx = sortedTracks.findIndex(
      (t) => t.Index === currentSubtitleIndex,
    );
    return trackIdx >= 0 ? trackIdx + 1 : 0;
-  }, [subtitleTracks, currentSubtitleIndex]);
+  }, [sortedTracks, currentSubtitleIndex]);

  useEffect(() => {
    if (visible) {
@@ -215,7 +222,7 @@ export const TVSubtitleSheet: React.FC<TVSubtitleSheetProps> = ({
      value: -1,
      selected: currentSubtitleIndex === -1,
    };
-    const options = subtitleTracks.map((track) => ({
+    const options = sortedTracks.map((track) => ({
      label:
        track.DisplayTitle || `${track.Language || "Unknown"} (${track.Codec})`,
      sublabel: track.Codec?.toUpperCase(),
@@ -223,7 +230,7 @@ export const TVSubtitleSheet: React.FC<TVSubtitleSheetProps> = ({
      selected: track.Index === currentSubtitleIndex,
    }));
    return [noneOption, ...options];
-  }, [subtitleTracks, currentSubtitleIndex, t]);
+  }, [sortedTracks, currentSubtitleIndex, t]);

  if (!visible) return null;

--- a/components/video-player/controls/TechnicalInfoOverlay.tsx
+++ b/components/video-player/controls/TechnicalInfoOverlay.tsx
@@ -342,6 +342,12 @@ export const TechnicalInfoOverlay: FC<TechnicalInfoOverlayProps> = memo(
          {info?.cacheSeconds !== undefined && (
            <Text style={textStyle}>
              Buffer: {info.cacheSeconds.toFixed(1)}s
+              {info?.demuxerMaxBytes !== undefined
+                ? ` (cap ${info.demuxerMaxBytes}MB` +
+                  `${info.demuxerMaxBackBytes !== undefined ? ` / ${info.demuxerMaxBackBytes}MB back` : ""}` +
+                  `${info?.cacheSecsLimit !== undefined && info.cacheSecsLimit < 3600 ? ` · ${info.cacheSecsLimit.toFixed(0)}s` : ""}` +
+                  ")"
+                : ""}
            </Text>
          )}
          {info?.voDriver && (
@@ -350,6 +356,12 @@ export const TechnicalInfoOverlay: FC<TechnicalInfoOverlayProps> = memo(
              {info.hwdec ? ` / ${info.hwdec}` : ""}
            </Text>
          )}
+          {info?.estimatedVfFps !== undefined && (
+            <Text style={textStyle}>
+              Output FPS: {info.estimatedVfFps.toFixed(2)}
+              {info?.fps ? ` (container ${formatFps(info.fps)})` : ""}
+            </Text>
+          )}
          {info?.droppedFrames !== undefined && info.droppedFrames > 0 && (
            <Text style={[textStyle, styles.warningText]}>
              Dropped: {info.droppedFrames} frames
--- a/components/video-player/controls/contexts/VideoContext.tsx
+++ b/components/video-player/controls/contexts/VideoContext.tsx
@@ -23,32 +23,29 @@
 *    - Used to report playback state to Jellyfin server
 *    - Value of -1 means disabled/none
 *
- * 2. MPV INDEX (track.mpvIndex)
- *    - MPV's internal track ID
- *    - MPV orders tracks as: [all embedded, then all external]
- *    - IDs: 1..embeddedCount for embedded, embeddedCount+1.. for external
- *    - Value of -1 means track needs replacePlayer() (e.g., burned-in sub)
+ * 2. PLAYER TRACK (selected by IDENTITY, not position)
+ *    - Selection resolves the server Index against MPV's REAL track list via
+ *      applyMpvSubtitleSelection: externals matched by external-filename,
+ *      embedded by language/title. `track.mpvIndex` is no longer used to select
+ *      (kept -1) — positional mapping mis-selected when externals/embedded were
+ *      reordered or the server hid embedded subs (#954 et al.).
 *
 * ============================================================================
 * SUBTITLE HANDLING
 * ============================================================================
 *
- * Embedded (DeliveryMethod.Embed):
- *   - Already in MPV's track list
- *   - Select via setSubtitleTrack(mpvId)
- *
- * External (DeliveryMethod.External):
- *   - Loaded into MPV on video start
- *   - Select via setSubtitleTrack(embeddedCount + externalPosition + 1)
+ * Embedded & External:
+ *   - Selected via applyMpvSubtitleSelection (identity match against the live
+ *     track list). Menu order matches jellyfin-web (compareTracksForMenu:
+ *     embedded first, externals last, forced/default float up).
 *
 * Image-based during transcoding:
- *   - Burned into video by Jellyfin, not in MPV
- *   - Requires replacePlayer() to change
+ *   - Burned into video by Jellyfin, not in MPV → replacePlayer() to change.
 */

-import { SubtitleDeliveryMethod } from "@jellyfin/sdk/lib/generated-client";
 import { File } from "expo-file-system";
 import { useLocalSearchParams } from "expo-router";
+import { useAtomValue } from "jotai";
 import type React from "react";
 import {
  createContext,
@@ -61,9 +58,14 @@ import {
 import { Platform } from "react-native";
 import useRouter from "@/hooks/useAppRouter";
 import type { MpvAudioTrack } from "@/modules";
+import { apiAtom } from "@/providers/JellyfinProvider";
 import { useOfflineMode } from "@/providers/OfflineModeProvider";
 import { getSubtitlesForItem } from "@/utils/atoms/downloadedSubtitles";
-import { isImageBasedSubtitle } from "@/utils/jellyfin/subtitleUtils";
+import {
+  applyMpvSubtitleSelection,
+  compareTracksForMenu,
+  isImageBasedSubtitle,
+} from "@/utils/jellyfin/subtitleUtils";
 import type { Track } from "../types";
 import { usePlayerContext, usePlayerControls } from "./PlayerContext";

@@ -87,6 +89,7 @@ export const VideoProvider: React.FC<{ children: ReactNode }> = ({
  const { tracksReady, mediaSource, downloadedItem } = usePlayerContext();
  const playerControls = usePlayerControls();
  const offline = useOfflineMode();
+  const api = useAtomValue(apiAtom);
  const router = useRouter();

  const { itemId, audioIndex, bitrateValue, subtitleIndex, playbackPosition } =
@@ -141,6 +144,19 @@ export const VideoProvider: React.FC<{ children: ReactNode }> = ({
  useEffect(() => {
    if (!tracksReady) return;

+    // Guard every state commit against stale runs: api?.basePath /
+    // isCurrentSubImageBased can flip mid-run and restart this effect, and an
+    // earlier async run (which captured an old `api`) must not finish later and
+    // overwrite the fresh track list with callbacks bound to stale closures.
+    // The cleanup flips `cancelled`, so any late commit from a dead run is dropped.
+    let cancelled = false;
+    const commitSubtitleTracks = (next: Track[]) => {
+      if (!cancelled) setSubtitleTracks(next);
+    };
+    const commitAudioTracks = (next: Track[]) => {
+      if (!cancelled) setAudioTracks(next);
+    };
+
    const fetchTracks = async () => {
      // Check if this is offline transcoded content
      // For transcoded offline content, only ONE audio track exists in the file
@@ -166,10 +182,10 @@ export const VideoProvider: React.FC<{ children: ReactNode }> = ({
              },
            },
          ];
-          setAudioTracks(audio);
+          commitAudioTracks(audio);
        } else {
          // Fallback: show no audio tracks if the stored track wasn't found
-          setAudioTracks([]);
+          commitAudioTracks([]);
        }

        // For subtitles in transcoded offline content:
@@ -179,6 +195,24 @@ export const VideoProvider: React.FC<{ children: ReactNode }> = ({
          downloadedItem.userData.subtitleStreamIndex;
        const subs: Track[] = [];

+        // If an IMAGE subtitle was burned into the transcoded download it's in the
+        // video pixels — it can't be turned off or swapped. Show only that entry
+        // instead of advertising "Disable"/text controls that can't affect it.
+        const burnedInSub = allSubs.find(
+          (s) => s.Index === downloadedSubtitleIndex,
+        );
+        if (burnedInSub && isImageBasedSubtitle(burnedInSub)) {
+          commitSubtitleTracks([
+            {
+              name: `${burnedInSub.DisplayTitle || "Unknown"} (burned in)`,
+              index: burnedInSub.Index ?? -1,
+              mpvIndex: -1,
+              setTrack: () => {},
+            },
+          ]);
+          return;
+        }
+
        // Add "Disable" option
        subs.push({
          name: "Disable",
@@ -190,123 +224,82 @@ export const VideoProvider: React.FC<{ children: ReactNode }> = ({
          },
        });

-        // For text-based subs, they should still be available in the file
-        let subIdx = 1;
-        for (const sub of allSubs) {
-          if (sub.IsTextSubtitleStream) {
+        // Text subs are muxed into the transcoded file and switchable; resolve by
+        // identity against MPV's real track list (same as online). Order matches web.
+        // Image subs aren't in the transcoded file (only the burned one was, handled
+        // above), so skip them here.
+        for (const sub of [...allSubs].sort(compareTracksForMenu)) {
+          if (!isImageBasedSubtitle(sub)) {
            subs.push({
              name: sub.DisplayTitle || "Unknown",
              index: sub.Index ?? -1,
-              mpvIndex: subIdx,
+              mpvIndex: -1,
              setTrack: () => {
-                playerControls.setSubtitleTrack(subIdx);
-                router.setParams({ subtitleIndex: String(sub.Index) });
-              },
-            });
-            subIdx++;
-          } else if (sub.Index === downloadedSubtitleIndex) {
-            // This image-based sub was burned in - show it but indicate it's active
-            subs.push({
-              name: `${sub.DisplayTitle || "Unknown"} (burned in)`,
-              index: sub.Index ?? -1,
-              mpvIndex: -1, // Can't be changed
-              setTrack: () => {
-                // Already burned in, just update params
                router.setParams({ subtitleIndex: String(sub.Index) });
+                void applyMpvSubtitleSelection(playerControls, {
+                  subtitleStreams: allSubs,
+                  jellyfinSubtitleIndex: sub.Index ?? -1,
+                  getExpectedExternalUrl: (s) => {
+                    if (!s.DeliveryUrl) return undefined;
+                    if (offline) return s.DeliveryUrl;
+                    return api?.basePath
+                      ? `${api.basePath}${s.DeliveryUrl}`
+                      : undefined;
+                  },
+                });
              },
            });
          }
        }

-        setSubtitleTracks(subs.sort((a, b) => a.index - b.index));
+        commitSubtitleTracks(subs);
        return;
      }

      // MPV track handling
      const audioData = await playerControls.getAudioTracks().catch(() => null);
+      if (cancelled) return;
      const playerAudio = (audioData as MpvAudioTrack[]) ?? [];

-      // Separate embedded vs external subtitles from Jellyfin's list
-      // MPV orders tracks as: [all embedded, then all external]
-      const embeddedSubs = allSubs.filter(
-        (s) => s.DeliveryMethod === SubtitleDeliveryMethod.Embed,
-      );
-      const externalSubs = allSubs.filter(
-        (s) => s.DeliveryMethod === SubtitleDeliveryMethod.External,
-      );
-
-      // Count embedded subs that will be in MPV
-      // (excludes image-based subs during transcoding as they're burned in)
-      const embeddedInPlayer = embeddedSubs.filter(
-        (s) => !isTranscoding || !isImageBasedSubtitle(s),
-      );
-
      const subs: Track[] = [];

-      // Process all Jellyfin subtitles
-      for (const sub of allSubs) {
-        const isEmbedded = sub.DeliveryMethod === SubtitleDeliveryMethod.Embed;
-        const isExternal =
-          sub.DeliveryMethod === SubtitleDeliveryMethod.External;
-
-        // For image-based subs during transcoding, need to refresh player
-        if (isTranscoding && isImageBasedSubtitle(sub)) {
-          subs.push({
-            name: sub.DisplayTitle || "Unknown",
-            index: sub.Index ?? -1,
-            mpvIndex: -1,
-            setTrack: () => {
-              replacePlayer({ subtitleIndex: String(sub.Index) });
-            },
-          });
-          continue;
-        }
-
-        // Calculate MPV track ID based on type
-        // MPV IDs: [1..embeddedCount] for embedded, [embeddedCount+1..] for external
-        let mpvId = -1;
-
-        if (isEmbedded) {
-          // Find position among embedded subs that are in player
-          const embeddedPosition = embeddedInPlayer.findIndex(
-            (s) => s.Index === sub.Index,
-          );
-          if (embeddedPosition !== -1) {
-            mpvId = embeddedPosition + 1; // 1-based ID
-          }
-        } else if (isExternal) {
-          // Find position among external subs, offset by embedded count
-          const externalPosition = externalSubs.findIndex(
-            (s) => s.Index === sub.Index,
-          );
-          if (externalPosition !== -1) {
-            mpvId = embeddedInPlayer.length + externalPosition + 1;
-          }
-        }
+      // Process all Jellyfin subtitles. Selection resolves against MPV's real
+      // track list by identity (applyMpvSubtitleSelection) — never positional
+      // index math, which mis-selects across external/embedded reordering and
+      // server-hidden embedded subs (#954/#1690/#618/#1467/#976/#1451).
+      // Order matches jellyfin-web (embedded first, externals last, forced/default up).
+      for (const sub of [...allSubs].sort(compareTracksForMenu)) {
+        // Image-based subs during transcoding are burned into the video by the
+        // server; both switching TO one and switching AWAY from a currently
+        // active one require a player refresh (re-transcode), not a track change.
+        const needsReplace =
+          isTranscoding &&
+          (isImageBasedSubtitle(sub) || isCurrentSubImageBased);

        subs.push({
          name: sub.DisplayTitle || "Unknown",
          index: sub.Index ?? -1,
-          mpvIndex: mpvId,
+          mpvIndex: -1,
          setTrack: () => {
-            // Transcoding + switching to/from image-based sub
-            if (
-              isTranscoding &&
-              (isImageBasedSubtitle(sub) || isCurrentSubImageBased)
-            ) {
+            if (needsReplace) {
              replacePlayer({ subtitleIndex: String(sub.Index) });
              return;
            }
-
-            // Direct switch in player
-            if (mpvId !== -1) {
-              playerControls.setSubtitleTrack(mpvId);
-              router.setParams({ subtitleIndex: String(sub.Index) });
-              return;
-            }
-
-            // Fallback - refresh player
-            replacePlayer({ subtitleIndex: String(sub.Index) });
+            router.setParams({ subtitleIndex: String(sub.Index) });
+            void applyMpvSubtitleSelection(playerControls, {
+              subtitleStreams: allSubs,
+              jellyfinSubtitleIndex: sub.Index ?? -1,
+              // Mirror how external subs are loaded into MPV (online: basePath +
+              // DeliveryUrl, offline: local DeliveryUrl) so identity matching by
+              // external-filename lines up.
+              getExpectedExternalUrl: (s) => {
+                if (!s.DeliveryUrl) return undefined;
+                if (offline) return s.DeliveryUrl;
+                return api?.basePath
+                  ? `${api.basePath}${s.DeliveryUrl}`
+                  : undefined;
+              },
+            });
          },
        });
      }
@@ -374,12 +367,29 @@ export const VideoProvider: React.FC<{ children: ReactNode }> = ({
        }
      }

-      setSubtitleTracks(subs.sort((a, b) => a.index - b.index));
-      setAudioTracks(audio);
+      // Already in jellyfin-web order (sorted iteration above); "Disable" stays
+      // at the front (unshifted), local downloaded subs at the end.
+      commitSubtitleTracks(subs);
+      commitAudioTracks(audio);
    };

    fetchTracks();
-  }, [tracksReady, mediaSource, offline, downloadedItem, itemId]);
+    return () => {
+      cancelled = true;
+    };
+    // api?.basePath: setTrack builds external-sub URLs from it — rebuild once the
+    // API is ready so online externals don't resolve with undefined.
+    // isCurrentSubImageBased: setTrack closes over it for the transcode replacePlayer
+    // decision — rebuild when it flips so we refresh the stream when we should.
+  }, [
+    tracksReady,
+    mediaSource,
+    offline,
+    downloadedItem,
+    itemId,
+    api?.basePath,
+    isCurrentSubImageBased,
+  ]);

  return (
    <VideoContext.Provider value={{ subtitleTracks, audioTracks }}>
--- a/constants/MediaTypes.ts
+++ b/constants/MediaTypes.ts
@@ -3,9 +3,13 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
-export default {
+const MediaTypes = {
  Audio: "Audio",
  Video: "Video",
  Photo: "Photo",
  Book: "Book",
-};
+} as const;
+
+export type MediaType = (typeof MediaTypes)[keyof typeof MediaTypes];
+
+export default MediaTypes;
--- a/index.ts
+++ b/index.ts
--- a/modules/mpv-player/android/build.gradle
+++ b/modules/mpv-player/android/build.gradle
@@ -53,5 +53,5 @@ android {

 dependencies {
  // libmpv from Maven Central
-  implementation 'dev.jdtech.mpv:libmpv:0.5.1'
+  implementation 'dev.jdtech.mpv:libmpv:1.0.0'
 }
--- a/modules/mpv-player/android/src/main/assets/subfont.ttf
+++ b/modules/mpv-player/android/src/main/assets/subfont.ttf
--- a/modules/mpv-player/android/src/main/java/expo/modules/mpvplayer/MPVLayerRenderer.kt
+++ b/modules/mpv-player/android/src/main/java/expo/modules/mpvplayer/MPVLayerRenderer.kt
@@ -3,14 +3,14 @@ package expo.modules.mpvplayer
 import android.app.UiModeManager
 import android.content.Context
 import android.content.res.Configuration
-import android.content.res.AssetManager
 import android.os.Build
 import android.os.Handler
 import android.os.Looper
+import android.system.Os
 import android.util.Log
 import android.view.Surface
 import java.io.File
-import java.io.FileOutputStream
+import java.util.Locale

 /**
 * MPV renderer that wraps libmpv for video playback.
@@ -76,8 +76,15 @@ class MPVLayerRenderer(private val context: Context) : MPVLib.EventObserver {
    
    private var surface: Surface? = null
    private var isRunning = false
-    private var isStopping = false
-    
+
+    // This renderer's own mpv handle. Per-instance (not singleton) — each
+    // player screen gets a fresh mpv handle and drops the reference on stop.
+    // We intentionally do NOT call a destroy() equivalent: libmpv 1.0's
+    // nativeDestroy has an internal use-after-free we can't fix from Kotlin,
+    // so we mirror Findroid and let the JVM GC + native finalization path
+    // reclaim resources. Only one player is alive at a time in this app.
+    private var mpv: MPVLib? = null
+
    // Cached state
    private var cachedPosition: Double = 0.0
    private var cachedDuration: Double = 0.0
@@ -137,106 +144,108 @@ class MPVLayerRenderer(private val context: Context) : MPVLib.EventObserver {

    fun start(voDriver: String = "gpu-next") {
        if (isRunning) return
-        
+
        try {
-            MPVLib.create(context)
-            MPVLib.addObserver(this)
-            
-            /**
-             * Create mpv config directory and copy font files to ensure SubRip subtitles load properly on Android.
-             *
-             * Technical Background:
-             * ====================
-             * On Android, mpv requires access to a font file to render text-based subtitles, particularly SubRip (.srt)
-             * format subtitles. Without an available font in the config directory, mpv will fail to display subtitles
-             * even when subtitle tracks are properly detected and loaded.
-             *
-             * Why This Is Necessary:
-             * =====================
-             * 1. Android's font system is isolated from native libraries like mpv. While Android has system fonts,
-             *    mpv cannot access them directly due to sandboxing and library isolation.
-             *
-             * 2. SubRip subtitles require a font to render text overlay on video. When no font is available in the
-             *    configured directory, mpv either:
-             *    - Fails silently (subtitles don't appear)
-             *    - Falls back to a default font that may not support the required character set
-             *    - Crashes or produces rendering errors
-             *
-             * 3. By placing a font file (font.ttf) in mpv's config directory and setting that directory via
-             *    MPVLib.setOptionString("config-dir", ...), we ensure mpv has a known, accessible font source.
-             *
-             * Reference:
-             * =========
-             * This workaround is documented in the mpv-android project:
-             * https://github.com/mpv-android/mpv-android/issues/96
-             *
-             * The issue discusses that without a font in the config directory, SubRip subtitles fail to load
-             * properly on Android, and the solution is to copy a font file to a known location that mpv can access.
-             */
-            // Create mpv config directory and copy font files
+            // Per-instance handle — see class-level comment. Each player gets
+            // its own mpv; we drop the reference in stop().
+            val mpv = MPVLib.create(context)
+            this.mpv = mpv
+            mpv.addObserver(this)
+
+            // Resolved once — TV gets the memory-pressure customizations
+            // (SCUDO_OPTIONS, hwdec/profile, demuxer-seekable-cache, larger
+            // audio-buffer) that would be counterproductive on higher-RAM
+            // mobile devices. Demuxer cache sizes are NOT included here —
+            // those come from user settings via load().
+            val isTV = isTvDevice()
+
+            // mpv config directory — used by the config-dir option below and
+            // as XDG_CONFIG_HOME for fontconfig.
            val mpvDir = File(context.getExternalFilesDir(null) ?: context.filesDir, "mpv")
-            //Log.i(TAG, "mpv config dir: $mpvDir")
            if (!mpvDir.exists()) mpvDir.mkdirs()
-            // This needs to be named `subfont.ttf` else it won't work
-            arrayOf("subfont.ttf").forEach { fileName ->
-                val file = File(mpvDir, fileName)
-                if (file.exists()) return@forEach
-                context.assets
-                    .open(fileName, AssetManager.ACCESS_STREAMING)
-                    .copyTo(FileOutputStream(file))
+
+            // Point fontconfig (new in libmpv 1.0) at writable app dirs so it
+            // persists its font index across runs instead of re-walking
+            // /system/fonts on every subtitle/seek event. Each rebuild costs
+            // ~1-2 s and ~10-30 MB of scudo:primary memory that scudo then
+            // holds onto. Without this we see "No usable fontconfig
+            // configuration file found, using fallback" on every re-init.
+            try {
+                val cacheDir = context.cacheDir.absolutePath
+                val configDir = (context.getExternalFilesDir(null) ?: context.filesDir).absolutePath
+                Os.setenv("XDG_CACHE_HOME", cacheDir, true)
+                Os.setenv("XDG_CONFIG_HOME", configDir, true)
+                Os.setenv("HOME", configDir, true)
+            } catch (e: Exception) {
+                Log.w(TAG, "Could not set XDG/HOME env for fontconfig: ${e.message}")
            }
-            MPVLib.setOptionString("config", "yes")
-            MPVLib.setOptionString("config-dir", mpvDir.path)
+
+            mpv?.setOptionString("config", "yes")
+            mpv?.setOptionString("config-dir", mpvDir.path)
            
            // Configure mpv options before initialization (based on Findroid)
            this.voDriver = voDriver
-            MPVLib.setOptionString("vo", voDriver)
-            MPVLib.setOptionString("gpu-context", "android")
-            MPVLib.setOptionString("opengl-es", "yes")
+            mpv?.setOptionString("vo", voDriver)
+            mpv?.setOptionString("gpu-context", "android")
+            mpv?.setOptionString("opengl-es", "yes")
            
-            // Hardware decode path:
-            //  - Real TV hardware: zero-copy `mediacodec` (fastest on low-power devices).
+            // Hardware decoder codecs (shared)
+            mpv?.setOptionString("hwdec-codecs", "h264,hevc,mpeg4,mpeg2video,vp8,vp9,av1")
+
+            // Pause on initial cache fill (shared default). The actual
+            // cache mode, cache-secs, and demuxer cache sizes come from
+            // user preferences and are applied per-load in load().
+            mpv?.setOptionString("cache-pause-initial", "yes")
+
+            // Hardware decode path + TV-only memory options. Demuxer cache
+            // sizes and cache-secs are NOT set here — they come from user
+            // preferences via load().
+            //  - Emulator: software decode. Its MediaCodec can't bind an
+            //    output surface (surface 0x0); HEVC then fails cleanly and
+            //    mpv auto-falls-back to software, but H.264 "opens"
+            //    deceptively and wedges the core with no fallback (black
+            //    video, then any command — seek/pause — deadlocks the UI
+            //    thread → ANR). hwdec=no makes every codec render via the
+            //    gpu-next VO. Real devices unaffected.
+            //  - Real TV hardware: zero-copy `mediacodec` (fastest on
+            //    low-power devices) + fast profile.
            //  - Real phone: `mediacodec-copy` (broadest compatibility).
-            //  - Emulator: software decode. Its MediaCodec can't bind an output surface
-            //    (surface 0x0); HEVC then fails cleanly and mpv auto-falls-back to software,
-            //    but H.264 "opens" deceptively and wedges the core with no fallback (black
-            //    video, then any command — seek/pause — deadlocks the UI thread → ANR).
-            //    hwdec=no makes every codec render via the gpu-next VO. Real devices unaffected.
            when {
-                isEmulator() -> MPVLib.setOptionString("hwdec", "no")
-                isTvDevice() -> {
-                    MPVLib.setOptionString("hwdec", "mediacodec")
-                    MPVLib.setOptionString("profile", "fast")
+                isEmulator() -> mpv?.setOptionString("hwdec", "no")
+                isTV -> {
+                    mpv?.setOptionString("hwdec", "mediacodec")
+                    mpv?.setOptionString("profile", "fast")
+                    // Don't retain already-played content for backward
+                    // seeking over a network source — Jellyfin can re-fetch
+                    // on demand. Saves up to ~30 MiB on long seeks and
+                    // reduces swap pressure.
+                    mpv?.setOptionString("demuxer-seekable-cache", "no")
+                    // Larger audio buffer to absorb page-fault stalls
+                    // (default ~0.2s). Cheap insurance against the audio
+                    // underruns that happen when the kernel is swap-thrashing.
+                    mpv?.setOptionString("audio-buffer", "0.5")
                }
-                else -> MPVLib.setOptionString("hwdec", "mediacodec-copy")
+                else -> mpv?.setOptionString("hwdec", "mediacodec-copy")
            }
-            MPVLib.setOptionString("hwdec-codecs", "h264,hevc,mpeg4,mpeg2video,vp8,vp9,av1")
-            
-            // Cache settings for better network streaming
-            MPVLib.setOptionString("cache", "yes")
-            MPVLib.setOptionString("cache-pause-initial", "yes")
-            MPVLib.setOptionString("demuxer-max-bytes", "150MiB")
-            MPVLib.setOptionString("demuxer-max-back-bytes", "75MiB")
-            MPVLib.setOptionString("demuxer-readahead-secs", "20")
            
            // Seeking optimization - faster seeking at the cost of less precision
            // Use keyframe seeking by default (much faster for network streams)
-            MPVLib.setOptionString("hr-seek", "no")
+            mpv?.setOptionString("hr-seek", "no")
            // Drop frames during seeking for faster response
-            MPVLib.setOptionString("hr-seek-framedrop", "yes")
+            mpv?.setOptionString("hr-seek-framedrop", "yes")
            
            // Subtitle settings
-            MPVLib.setOptionString("sub-scale-with-window", "no")
-            MPVLib.setOptionString("sub-use-margins", "no")
-            MPVLib.setOptionString("subs-match-os-language", "yes")
-            MPVLib.setOptionString("subs-fallback", "yes")
+            mpv?.setOptionString("sub-scale-with-window", "no")
+            mpv?.setOptionString("sub-use-margins", "no")
+            mpv?.setOptionString("subs-match-os-language", "yes")
+            mpv?.setOptionString("subs-fallback", "yes")
            
            // Important: Start with force-window=no, will be set to yes when surface is attached
-            MPVLib.setOptionString("force-window", "no")
-            MPVLib.setOptionString("keep-open", "always")
-            
-            MPVLib.initialize()
-            
+            mpv?.setOptionString("force-window", "no")
+            mpv?.setOptionString("keep-open", "always")
+
+            mpv.initialize()
+
            // Observe properties
            observeProperties()
            
@@ -249,21 +258,68 @@ class MPVLayerRenderer(private val context: Context) : MPVLib.EventObserver {
    }
    
    fun stop() {
-        if (isStopping) return
        if (!isRunning) return
-        
-        isStopping = true
        isRunning = false
-        
-        try {
-            MPVLib.removeObserver(this)
-            MPVLib.detachSurface()
-            MPVLib.destroy()
-        } catch (e: Exception) {
-            Log.e(TAG, "Error stopping MPV: ${e.message}")
-        }
-        
-        isStopping = false
+
+        val m = mpv
+        mpv = null
+
+        // Clear cached media state on the main thread so the next player
+        // screen doesn't observe stale position/duration values during the
+        // (async) teardown below.
+        currentUrl = null
+        currentHeaders = null
+        pendingExternalSubtitles = emptyList()
+        initialSubtitleId = null
+        initialAudioId = null
+        cachedPosition = 0.0
+        cachedDuration = 0.0
+        cachedCacheSeconds = 0.0
+
+        if (m == null) return
+
+        // Teardown runs on a background daemon thread. mpv's "stop" command
+        // flushes the demuxer queue and releases the MediaCodec hardware
+        // decoder — synchronous JNI work that can block for hundreds of ms
+        // on TV hardware. Running it on the main thread produced a visible
+        // delay/stutter between pressing "exit" and the confirm alert
+        // appearing. The local `m` keeps the MPVLib instance alive for the
+        // lifetime of this thread even though we've already nulled `mpv`.
+        Thread {
+            // Drop force-window BEFORE issuing stop. With keep-open=always +
+            // force-window=yes, mpv tears down the decoder at stop time but
+            // tries to keep the VO alive — which fires an internal
+            // video-reconfig. On libmpv 1.0's gpu-next/android backend that
+            // reconfig path crashes with "Missing surface pointer" because we
+            // detach the Surface below before mpv's worker reaches the
+            // reconfig step (command() is async). Setting force-window=no
+            // first makes mpv tear VO down cleanly instead of attempting a
+            // doomed re-init, eliminating the fatal VO error and the
+            // "playback won't restart" aftermath.
+            try {
+                m.setOptionString("force-window", "no")
+            } catch (e: Exception) {
+                Log.e(TAG, "Error clearing force-window: ${e.message}")
+            }
+            try {
+                // Stop playback — flushes demuxer queue and signals MediaCodec
+                // to release its hardware decoders. This is the bulk of what
+                // we can reclaim without calling destroy().
+                m.command(arrayOf("stop"))
+            } catch (e: Exception) {
+                Log.e(TAG, "Error stopping mpv playback: ${e.message}")
+            }
+            try {
+                m.removeObserver(this)
+            } catch (e: Exception) {
+                Log.e(TAG, "Error removing mpv observer: ${e.message}")
+            }
+            try {
+                m.detachSurface()
+            } catch (e: Exception) {
+                Log.e(TAG, "Error detaching mpv surface: ${e.message}")
+            }
+        }.also { it.isDaemon = true }.start()
    }
    
    /**
@@ -278,10 +334,10 @@ class MPVLayerRenderer(private val context: Context) : MPVLib.EventObserver {
        this.surface = surface
        Log.i(TAG, "[PiP] attachSurface — isRunning=$isRunning, vo=$voDriver, surface=${surface.hashCode()}")
        if (isRunning) {
-            MPVLib.attachSurface(surface)
-            MPVLib.setOptionString("force-window", "yes")
+            mpv?.attachSurface(surface)
+            mpv?.setOptionString("force-window", "yes")
            // Read back vo to confirm it's still active
-            val activeVo = try { MPVLib.getPropertyString("vo") } catch (e: Exception) { null }
+            val activeVo = try { mpv?.getPropertyString("vo") } catch (e: Exception) { null }
            Log.i(TAG, "[PiP] attachSurface — attached, activeVo=$activeVo")
        }
    }
@@ -301,8 +357,8 @@ class MPVLayerRenderer(private val context: Context) : MPVLib.EventObserver {
        this.surface = null
        Log.i(TAG, "[PiP] detachSurface — isRunning=$isRunning, vo=$voDriver")
        if (isRunning) {
-            MPVLib.detachSurface()
-            val activeVo = try { MPVLib.getPropertyString("vo") } catch (e: Exception) { null }
+            mpv?.detachSurface()
+            val activeVo = try { mpv?.getPropertyString("vo") } catch (e: Exception) { null }
            Log.i(TAG, "[PiP] detachSurface — detached, activeVo=$activeVo (should still be $voDriver)")
        }
    }
@@ -313,7 +369,7 @@ class MPVLayerRenderer(private val context: Context) : MPVLib.EventObserver {
     */
    fun updateSurfaceSize(width: Int, height: Int) {
        if (isRunning) {
-            MPVLib.setPropertyString("android-surface-size", "${width}x$height")
+            mpv?.setPropertyString("android-surface-size", "${width}x$height")
            Log.i(TAG, "[PiP] updateSurfaceSize — ${width}x${height}")
        } else {
            Log.w(TAG, "[PiP] updateSurfaceSize — called but renderer not running")
@@ -329,9 +385,9 @@ class MPVLayerRenderer(private val context: Context) : MPVLib.EventObserver {
        if (!isRunning) return
        val pos = cachedPosition
        Log.i(TAG, "[PiP] forceRedraw — stepping frame then seeking to $pos")
-        MPVLib.command(arrayOf("frame-step"))
+        mpv?.command(arrayOf("frame-step"))
        if (pos > 0) {
-            MPVLib.command(arrayOf("seek", pos.toString(), "absolute"))
+            mpv?.command(arrayOf("seek", pos.toString(), "absolute"))
        }
    }
    
@@ -341,29 +397,43 @@ class MPVLayerRenderer(private val context: Context) : MPVLib.EventObserver {
        startPosition: Double? = null,
        externalSubtitles: List<String>? = null,
        initialSubtitleId: Int? = null,
-        initialAudioId: Int? = null
+        initialAudioId: Int? = null,
+        cacheEnabled: String? = null,
+        cacheSeconds: Int? = null,
+        demuxerMaxBytes: Int? = null,
+        demuxerMaxBackBytes: Int? = null
    ) {
        currentUrl = url
        currentHeaders = headers
        pendingExternalSubtitles = externalSubtitles ?: emptyList()
        this.initialSubtitleId = initialSubtitleId
        this.initialAudioId = initialAudioId
-        
+
        _isLoading = true
        isReadyToSeek = false
        mainHandler.post { delegate?.onLoadingChanged(true) }
-        
+
        // Stop previous playback
-        MPVLib.command(arrayOf("stop"))
-        
+        mpv?.command(arrayOf("stop"))
+
        // Set HTTP headers if provided
        updateHttpHeaders(headers)
+
+        // Apply cache/buffer settings from user preferences (mirrors iOS).
+        // These override the conservative defaults applied in start() so the
+        // TV/mobile settings screen actually takes effect on Android.
+        cacheEnabled?.let { mpv?.setOptionString("cache", it) }
+        cacheSeconds?.let { mpv?.setOptionString("cache-secs", it.toString()) }
+        demuxerMaxBytes?.let { mpv?.setOptionString("demuxer-max-bytes", "${it}MiB") }
+        demuxerMaxBackBytes?.let { mpv?.setOptionString("demuxer-max-back-bytes", "${it}MiB") }
        
-        // Set start position
+        // Set start position. mpv's time parser requires '.' as the decimal
+        // separator; use Locale.US so devices with other default locales
+        // (e.g. ',' as decimal separator) don't break resume-from-position.
        if (startPosition != null && startPosition > 0) {
-            MPVLib.setPropertyString("start", String.format("%.2f", startPosition))
+            mpv?.setPropertyString("start", String.format(Locale.US, "%.2f", startPosition))
        } else {
-            MPVLib.setPropertyString("start", "0")
+            mpv?.setPropertyString("start", "0")
        }
        
        // Set initial audio track if specified
@@ -383,7 +453,7 @@ class MPVLayerRenderer(private val context: Context) : MPVLib.EventObserver {
        }
        
        // Load the file
-        MPVLib.command(arrayOf("loadfile", url, "replace"))
+        mpv?.command(arrayOf("loadfile", url, "replace"))
    }
    
    fun reloadCurrentItem() {
@@ -399,29 +469,29 @@ class MPVLayerRenderer(private val context: Context) : MPVLib.EventObserver {
        }
        
        val headerString = headers.entries.joinToString("\r\n") { "${it.key}: ${it.value}" }
-        MPVLib.setPropertyString("http-header-fields", headerString)
+        mpv?.setPropertyString("http-header-fields", headerString)
    }
    
    private fun observeProperties() {
-        MPVLib.observeProperty("duration", MPV_FORMAT_DOUBLE)
-        MPVLib.observeProperty("time-pos", MPV_FORMAT_DOUBLE)
-        MPVLib.observeProperty("pause", MPV_FORMAT_FLAG)
-        MPVLib.observeProperty("track-list/count", MPV_FORMAT_INT64)
-        MPVLib.observeProperty("paused-for-cache", MPV_FORMAT_FLAG)
-        MPVLib.observeProperty("demuxer-cache-duration", MPV_FORMAT_DOUBLE)
+        mpv?.observeProperty("duration", MPV_FORMAT_DOUBLE)
+        mpv?.observeProperty("time-pos", MPV_FORMAT_DOUBLE)
+        mpv?.observeProperty("pause", MPV_FORMAT_FLAG)
+        mpv?.observeProperty("track-list/count", MPV_FORMAT_INT64)
+        mpv?.observeProperty("paused-for-cache", MPV_FORMAT_FLAG)
+        mpv?.observeProperty("demuxer-cache-duration", MPV_FORMAT_DOUBLE)
        // Video dimensions for PiP aspect ratio
-        MPVLib.observeProperty("video-params/w", MPV_FORMAT_INT64)
-        MPVLib.observeProperty("video-params/h", MPV_FORMAT_INT64)
+        mpv?.observeProperty("video-params/w", MPV_FORMAT_INT64)
+        mpv?.observeProperty("video-params/h", MPV_FORMAT_INT64)
    }
-    
+
    // MARK: - Playback Controls
    
    fun play() {
-        MPVLib.setPropertyBoolean("pause", false)
+        mpv?.setPropertyBoolean("pause", false)
    }
    
    fun pause() {
-        MPVLib.setPropertyBoolean("pause", true)
+        mpv?.setPropertyBoolean("pause", true)
    }
    
    fun togglePause() {
@@ -431,22 +501,22 @@ class MPVLayerRenderer(private val context: Context) : MPVLib.EventObserver {
    fun seekTo(seconds: Double) {
        val clamped = maxOf(0.0, seconds)
        cachedPosition = clamped
-        MPVLib.command(arrayOf("seek", clamped.toString(), "absolute"))
+        mpv?.command(arrayOf("seek", clamped.toString(), "absolute"))
    }
    
    fun seekBy(seconds: Double) {
        val newPosition = maxOf(0.0, cachedPosition + seconds)
        cachedPosition = newPosition
-        MPVLib.command(arrayOf("seek", seconds.toString(), "relative"))
+        mpv?.command(arrayOf("seek", seconds.toString(), "relative"))
    }
    
    fun setSpeed(speed: Double) {
        _playbackSpeed = speed
-        MPVLib.setPropertyDouble("speed", speed)
+        mpv?.setPropertyDouble("speed", speed)
    }
    
    fun getSpeed(): Double {
-        return MPVLib.getPropertyDouble("speed") ?: _playbackSpeed
+        return mpv?.getPropertyDouble("speed") ?: _playbackSpeed
    }
    
    // MARK: - Subtitle Controls
@@ -454,85 +524,96 @@ class MPVLayerRenderer(private val context: Context) : MPVLib.EventObserver {
    fun getSubtitleTracks(): List<Map<String, Any>> {
        val tracks = mutableListOf<Map<String, Any>>()
        
-        val trackCount = MPVLib.getPropertyInt("track-list/count") ?: 0
+        val trackCount = mpv?.getPropertyInt("track-list/count") ?: 0
        
        for (i in 0 until trackCount) {
-            val trackType = MPVLib.getPropertyString("track-list/$i/type") ?: continue
+            val trackType = mpv?.getPropertyString("track-list/$i/type") ?: continue
            if (trackType != "sub") continue
            
-            val trackId = MPVLib.getPropertyInt("track-list/$i/id") ?: continue
+            val trackId = mpv?.getPropertyInt("track-list/$i/id") ?: continue
            val track = mutableMapOf<String, Any>("id" to trackId)
-            
-            MPVLib.getPropertyString("track-list/$i/title")?.let { track["title"] = it }
-            MPVLib.getPropertyString("track-list/$i/lang")?.let { track["lang"] = it }
-            
-            val selected = MPVLib.getPropertyBoolean("track-list/$i/selected") ?: false
+
+            mpv?.getPropertyString("track-list/$i/title")?.let { track["title"] = it }
+            mpv?.getPropertyString("track-list/$i/lang")?.let { track["lang"] = it }
+            mpv?.getPropertyString("track-list/$i/codec")?.let { track["codec"] = it }
+
+            // Identity fields used to map a Jellyfin subtitle to the real track
+            // (instead of fragile positional counting). `external` + `external-filename`
+            // uniquely identify a sub-added sidecar; `ff-index` aids embedded matching.
+            val external = mpv?.getPropertyBoolean("track-list/$i/external") ?: false
+            track["external"] = external
+            mpv?.getPropertyString("track-list/$i/external-filename")?.let {
+                track["externalFilename"] = it
+            }
+            mpv?.getPropertyInt("track-list/$i/ff-index")?.let { track["ffIndex"] = it }
+
+            val selected = mpv?.getPropertyBoolean("track-list/$i/selected") ?: false
            track["selected"] = selected
-            
+
            tracks.add(track)
        }
-        
+
        return tracks
    }
    
    fun setSubtitleTrack(trackId: Int) {
        Log.i(TAG, "setSubtitleTrack: setting sid to $trackId")
        if (trackId < 0) {
-            MPVLib.setPropertyString("sid", "no")
+            mpv?.setPropertyString("sid", "no")
        } else {
-            MPVLib.setPropertyInt("sid", trackId)
+            mpv?.setPropertyInt("sid", trackId)
        }
    }
    
    fun disableSubtitles() {
-        MPVLib.setPropertyString("sid", "no")
+        mpv?.setPropertyString("sid", "no")
    }
    
    fun getCurrentSubtitleTrack(): Int {
-        return MPVLib.getPropertyInt("sid") ?: 0
+        return mpv?.getPropertyInt("sid") ?: 0
    }
    
    fun addSubtitleFile(url: String, select: Boolean = true) {
        val flag = if (select) "select" else "cached"
-        MPVLib.command(arrayOf("sub-add", url, flag))
+        mpv?.command(arrayOf("sub-add", url, flag))
    }
    
    // MARK: - Subtitle Positioning
    
    fun setSubtitlePosition(position: Int) {
-        MPVLib.setPropertyInt("sub-pos", position)
+        mpv?.setPropertyInt("sub-pos", position)
    }
    
    fun setSubtitleScale(scale: Double) {
-        MPVLib.setPropertyDouble("sub-scale", scale)
+        mpv?.setPropertyDouble("sub-scale", scale)
    }
    
    fun setSubtitleMarginY(margin: Int) {
-        MPVLib.setPropertyInt("sub-margin-y", margin)
+        mpv?.setPropertyInt("sub-margin-y", margin)
    }
    
    fun setSubtitleAlignX(alignment: String) {
-        MPVLib.setPropertyString("sub-align-x", alignment)
+        mpv?.setPropertyString("sub-align-x", alignment)
    }
    
    fun setSubtitleAlignY(alignment: String) {
-        MPVLib.setPropertyString("sub-align-y", alignment)
+        mpv?.setPropertyString("sub-align-y", alignment)
    }
    
    fun setSubtitleFontSize(size: Int) {
-        MPVLib.setPropertyInt("sub-font-size", size)
+        mpv?.setPropertyInt("sub-font-size", size)
    }

    fun setSubtitleBorderStyle(style: String) {
-        MPVLib.setPropertyString("sub-border-style", style)
+        mpv?.setPropertyString("sub-border-style", style)
    }

    fun setSubtitleBackgroundColor(color: String) {
-        MPVLib.setPropertyString("sub-back-color", color)
+        mpv?.setPropertyString("sub-back-color", color)
    }

    fun setSubtitleAssOverride(mode: String) {
-        MPVLib.setPropertyString("sub-ass-override", mode)
+        mpv?.setPropertyString("sub-ass-override", mode)
    }

    // MARK: - Audio Track Controls
@@ -540,25 +621,25 @@ class MPVLayerRenderer(private val context: Context) : MPVLib.EventObserver {
    fun getAudioTracks(): List<Map<String, Any>> {
        val tracks = mutableListOf<Map<String, Any>>()
        
-        val trackCount = MPVLib.getPropertyInt("track-list/count") ?: 0
+        val trackCount = mpv?.getPropertyInt("track-list/count") ?: 0
        
        for (i in 0 until trackCount) {
-            val trackType = MPVLib.getPropertyString("track-list/$i/type") ?: continue
+            val trackType = mpv?.getPropertyString("track-list/$i/type") ?: continue
            if (trackType != "audio") continue
            
-            val trackId = MPVLib.getPropertyInt("track-list/$i/id") ?: continue
+            val trackId = mpv?.getPropertyInt("track-list/$i/id") ?: continue
            val track = mutableMapOf<String, Any>("id" to trackId)
            
-            MPVLib.getPropertyString("track-list/$i/title")?.let { track["title"] = it }
-            MPVLib.getPropertyString("track-list/$i/lang")?.let { track["lang"] = it }
-            MPVLib.getPropertyString("track-list/$i/codec")?.let { track["codec"] = it }
+            mpv?.getPropertyString("track-list/$i/title")?.let { track["title"] = it }
+            mpv?.getPropertyString("track-list/$i/lang")?.let { track["lang"] = it }
+            mpv?.getPropertyString("track-list/$i/codec")?.let { track["codec"] = it }
            
-            val channels = MPVLib.getPropertyInt("track-list/$i/audio-channels")
+            val channels = mpv?.getPropertyInt("track-list/$i/audio-channels")
            if (channels != null && channels > 0) {
                track["channels"] = channels
            }
            
-            val selected = MPVLib.getPropertyBoolean("track-list/$i/selected") ?: false
+            val selected = mpv?.getPropertyBoolean("track-list/$i/selected") ?: false
            track["selected"] = selected
            
            tracks.add(track)
@@ -569,11 +650,11 @@ class MPVLayerRenderer(private val context: Context) : MPVLib.EventObserver {
    
    fun setAudioTrack(trackId: Int) {
        Log.i(TAG, "setAudioTrack: setting aid to $trackId")
-        MPVLib.setPropertyInt("aid", trackId)
+        mpv?.setPropertyInt("aid", trackId)
    }
    
    fun getCurrentAudioTrack(): Int {
-        return MPVLib.getPropertyInt("aid") ?: 0
+        return mpv?.getPropertyInt("aid") ?: 0
    }

    // MARK: - Video Scaling
@@ -582,7 +663,7 @@ class MPVLayerRenderer(private val context: Context) : MPVLib.EventObserver {
        // panscan: 0.0 = fit (letterbox), 1.0 = fill (crop)
        val panscanValue = if (zoomed) 1.0 else 0.0
        Log.i(TAG, "setZoomedToFill: setting panscan to $panscanValue")
-        MPVLib.setPropertyDouble("panscan", panscanValue)
+        mpv?.setPropertyDouble("panscan", panscanValue)
    }

    // MARK: - Technical Info
@@ -591,58 +672,79 @@ class MPVLayerRenderer(private val context: Context) : MPVLib.EventObserver {
        val info = mutableMapOf<String, Any>()

        // Video dimensions
-        MPVLib.getPropertyInt("video-params/w")?.takeIf { it > 0 }?.let {
+        mpv?.getPropertyInt("video-params/w")?.takeIf { it > 0 }?.let {
            info["videoWidth"] = it
        }
-        MPVLib.getPropertyInt("video-params/h")?.takeIf { it > 0 }?.let {
+        mpv?.getPropertyInt("video-params/h")?.takeIf { it > 0 }?.let {
            info["videoHeight"] = it
        }

        // Video codec
-        MPVLib.getPropertyString("video-format")?.let {
+        mpv?.getPropertyString("video-format")?.let {
            info["videoCodec"] = it
        }

        // Audio codec
-        MPVLib.getPropertyString("audio-codec-name")?.let {
+        mpv?.getPropertyString("audio-codec-name")?.let {
            info["audioCodec"] = it
        }

        // FPS (container fps)
-        MPVLib.getPropertyDouble("container-fps")?.takeIf { it > 0 }?.let {
+        mpv?.getPropertyDouble("container-fps")?.takeIf { it > 0 }?.let {
            info["fps"] = it
        }

        // Video bitrate (bits per second)
-        MPVLib.getPropertyInt("video-bitrate")?.takeIf { it > 0 }?.let {
+        mpv?.getPropertyInt("video-bitrate")?.takeIf { it > 0 }?.let {
            info["videoBitrate"] = it
        }

        // Audio bitrate (bits per second)
-        MPVLib.getPropertyInt("audio-bitrate")?.takeIf { it > 0 }?.let {
+        mpv?.getPropertyInt("audio-bitrate")?.takeIf { it > 0 }?.let {
            info["audioBitrate"] = it
        }

        // Demuxer cache duration (seconds of video buffered)
-        MPVLib.getPropertyDouble("demuxer-cache-duration")?.let {
+        mpv?.getPropertyDouble("demuxer-cache-duration")?.let {
            info["cacheSeconds"] = it
        }

+        // Configured cache limits — read back from mpv to confirm user
+        // settings actually took effect. mpv stores byte sizes as int64
+        // (bytes); convert to MiB for display.
+        mpv?.getPropertyInt("demuxer-max-bytes")?.let { bytes ->
+            info["demuxerMaxBytes"] = bytes / (1024 * 1024)
+        }
+        mpv?.getPropertyInt("demuxer-max-back-bytes")?.let { bytes ->
+            info["demuxerMaxBackBytes"] = bytes / (1024 * 1024)
+        }
+        mpv?.getPropertyDouble("cache-secs")?.let { secs ->
+            info["cacheSecsLimit"] = secs
+        }
+
        // Dropped frames
-        MPVLib.getPropertyInt("frame-drop-count")?.let {
+        mpv?.getPropertyInt("frame-drop-count")?.let {
            info["droppedFrames"] = it
        }

        // Active video output driver (read from MPV to confirm what's actually applied)
-        MPVLib.getPropertyString("vo")?.let {
+        mpv?.getPropertyString("vo")?.let {
            info["voDriver"] = it
        }

-        // Active hardware decoder
-        MPVLib.getPropertyString("hwdec-active")?.let {
+        // Active hardware decoder.
+        // hwdec-current yields e.g. "mediacodec",
+        // "mediacodec-copy", "auto-copy" or empty when SW decoding.
+        mpv?.getPropertyString("hwdec-current")?.let {
            info["hwdec"] = it
        }

+        // Estimated video output fps (renderer-side, after filtering).
+        // Useful for diagnosing display/pipeline drops vs container fps.
+        mpv?.getPropertyDouble("estimated-vf-fps")?.takeIf { it > 0 }?.let {
+            info["estimatedVfFps"] = it
+        }
+
        return info
    }

@@ -735,7 +837,7 @@ class MPVLayerRenderer(private val context: Context) : MPVLib.EventObserver {
                    pendingExternalSubtitles.forEachIndexed { index, subUrl ->
                        android.util.Log.d("MPVRenderer", "Adding external subtitle [$index]: $subUrl")
                        // "auto" flag = add without auto-selecting (order preserved, MPVLib.command is sync)
-                        MPVLib.command(arrayOf("sub-add", subUrl, "auto"))
+                        mpv?.command(arrayOf("sub-add", subUrl, "auto"))
                    }
                    pendingExternalSubtitles = emptyList()
                }
--- a/modules/mpv-player/android/src/main/java/expo/modules/mpvplayer/MPVLib.kt
+++ b/modules/mpv-player/android/src/main/java/expo/modules/mpvplayer/MPVLib.kt
@@ -1,20 +1,29 @@
 package expo.modules.mpvplayer

 import android.content.Context
-import android.util.Log
-import android.view.Surface
 import dev.jdtech.mpv.MPVLib as LibMPV

 /**
- * Wrapper around the dev.jdtech.mpv.MPVLib class.
- * This provides a consistent interface for the rest of the app.
+ * Per-instance wrapper around the dev.jdtech.mpv.MPVLib class.
+ *
+ * libmpv 1.0 exposes an instance-based API: each `LibMPV.create(ctx)` returns
+ * a fresh, independent handle. Each player creates its own MPVLib instance
+ * (Findroid pattern) and on teardown we simply drop the reference. We do NOT
+ * call `LibMPV.destroy()` — its native implementation has an internal
+ * use-after-free on libmpv 1.0 that we cannot fix from Kotlin. Letting the
+ * GC reach the JVM-level finalizer (or never reaching it, since the native
+ * handle lives in process-global state until exit) is strictly safer than
+ * crashing.
+ *
+ * Trade-off: mpv's native footprint (decoder + demuxer cache) for one player
+ * stays allocated until the next player's allocation displaces it in scudo's
+ * arena. On a TV app where the player is the dominant memory consumer and
+ * only one player is alive at a time, this is acceptable.
 */
-object MPVLib {
-    private const val TAG = "MPVLib"
-    
-    private var initialized = false
-    
-    // Event observer interface
+class MPVLib private constructor(private val instance: LibMPV) {
+
+    // Event observer interface — mirrors dev.jdtech.mpv.MPVLib.EventObserver
+    // so MPVLayerRenderer implements a stable, wrapper-owned signature.
    interface EventObserver {
        fun eventProperty(property: String)
        fun eventProperty(property: String, value: Long)
@@ -23,198 +32,144 @@ object MPVLib {
        fun eventProperty(property: String, value: Double)
        fun event(eventId: Int)
    }
-    
+
    private val observers = mutableListOf<EventObserver>()
-    
-    // Library event observer that forwards to our observers
+
+    // Library event observer that forwards LibMPV callbacks to our observers.
    private val libObserver = object : LibMPV.EventObserver {
-        override fun eventProperty(property: String) {
+        override fun eventProperty(property: String) =
+            dispatch { it.eventProperty(property) }
+
+        override fun eventProperty(property: String, value: Long) =
+            dispatch { it.eventProperty(property, value) }
+
+        override fun eventProperty(property: String, value: Boolean) =
+            dispatch { it.eventProperty(property, value) }
+
+        override fun eventProperty(property: String, value: String) =
+            dispatch { it.eventProperty(property, value) }
+
+        override fun eventProperty(property: String, value: Double) =
+            dispatch { it.eventProperty(property, value) }
+
+        override fun event(eventId: Int) =
+            dispatch { it.event(eventId) }
+
+        private inline fun dispatch(block: (EventObserver) -> Unit) {
            synchronized(observers) {
-                for (observer in observers) {
-                    observer.eventProperty(property)
-                }
-            }
-        }
-        
-        override fun eventProperty(property: String, value: Long) {
-            synchronized(observers) {
-                for (observer in observers) {
-                    observer.eventProperty(property, value)
-                }
-            }
-        }
-        
-        override fun eventProperty(property: String, value: Boolean) {
-            synchronized(observers) {
-                for (observer in observers) {
-                    observer.eventProperty(property, value)
-                }
-            }
-        }
-        
-        override fun eventProperty(property: String, value: String) {
-            synchronized(observers) {
-                for (observer in observers) {
-                    observer.eventProperty(property, value)
-                }
-            }
-        }
-        
-        override fun eventProperty(property: String, value: Double) {
-            synchronized(observers) {
-                for (observer in observers) {
-                    observer.eventProperty(property, value)
-                }
-            }
-        }
-        
-        override fun event(eventId: Int) {
-            synchronized(observers) {
-                for (observer in observers) {
-                    observer.event(eventId)
-                }
+                observers.forEach(block)
            }
        }
    }
-    
+
    fun addObserver(observer: EventObserver) {
-        synchronized(observers) {
-            observers.add(observer)
-        }
+        synchronized(observers) { observers.add(observer) }
    }
-    
+
    fun removeObserver(observer: EventObserver) {
-        synchronized(observers) {
-            observers.remove(observer)
-        }
+        synchronized(observers) { observers.remove(observer) }
    }
-    
-    // MPV Event IDs
-    const val MPV_EVENT_NONE = 0
-    const val MPV_EVENT_SHUTDOWN = 1
-    const val MPV_EVENT_LOG_MESSAGE = 2
-    const val MPV_EVENT_GET_PROPERTY_REPLY = 3
-    const val MPV_EVENT_SET_PROPERTY_REPLY = 4
-    const val MPV_EVENT_COMMAND_REPLY = 5
-    const val MPV_EVENT_START_FILE = 6
-    const val MPV_EVENT_END_FILE = 7
-    const val MPV_EVENT_FILE_LOADED = 8
-    const val MPV_EVENT_IDLE = 11
-    const val MPV_EVENT_TICK = 14
-    const val MPV_EVENT_CLIENT_MESSAGE = 16
-    const val MPV_EVENT_VIDEO_RECONFIG = 17
-    const val MPV_EVENT_AUDIO_RECONFIG = 18
-    const val MPV_EVENT_SEEK = 20
-    const val MPV_EVENT_PLAYBACK_RESTART = 21
-    const val MPV_EVENT_PROPERTY_CHANGE = 22
-    const val MPV_EVENT_QUEUE_OVERFLOW = 24
-    
-    // End file reason
-    const val MPV_END_FILE_REASON_EOF = 0
-    const val MPV_END_FILE_REASON_STOP = 2
-    const val MPV_END_FILE_REASON_QUIT = 3
-    const val MPV_END_FILE_REASON_ERROR = 4
-    const val MPV_END_FILE_REASON_REDIRECT = 5
-    
-    /**
-     * Create and initialize the MPV library
-     */
-    fun create(context: Context, configDir: String? = null) {
-        if (initialized) return
-        
-        try {
-            LibMPV.create(context)
-            LibMPV.addObserver(libObserver)
-            initialized = true
-            Log.i(TAG, "libmpv created successfully")
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to create libmpv: ${e.message}")
-            throw e
-        }
-    }
-    
+
    fun initialize() {
-        LibMPV.init()
+        instance.init()
    }
-    
-    fun destroy() {
-        if (!initialized) return
-        try {
-            LibMPV.removeObserver(libObserver)
-            LibMPV.destroy()
-        } catch (e: Exception) {
-            Log.e(TAG, "Error destroying mpv: ${e.message}")
-        }
-        initialized = false
+
+    fun attachSurface(surface: android.view.Surface) {
+        instance.attachSurface(surface)
    }
-    
-    fun isInitialized(): Boolean = initialized
-    
-    fun attachSurface(surface: Surface) {
-        LibMPV.attachSurface(surface)
-    }
-    
+
    fun detachSurface() {
-        LibMPV.detachSurface()
+        instance.detachSurface()
    }
-    
-    fun command(cmd: Array<String?>) {
-        LibMPV.command(cmd)
+
+    fun command(cmd: Array<String>) {
+        instance.command(cmd)
    }
-    
+
    fun setOptionString(name: String, value: String): Int {
-        return LibMPV.setOptionString(name, value)
+        return instance.setOptionString(name, value)
    }
-    
-    fun getPropertyInt(name: String): Int? {
-        return try {
-            LibMPV.getPropertyInt(name)
-        } catch (e: Exception) {
-            null
-        }
-    }
-    
-    fun getPropertyDouble(name: String): Double? {
-        return try {
-            LibMPV.getPropertyDouble(name)
-        } catch (e: Exception) {
-            null
-        }
-    }
-    
-    fun getPropertyBoolean(name: String): Boolean? {
-        return try {
-            LibMPV.getPropertyBoolean(name)
-        } catch (e: Exception) {
-            null
-        }
-    }
-    
-    fun getPropertyString(name: String): String? {
-        return try {
-            LibMPV.getPropertyString(name)
-        } catch (e: Exception) {
-            null
-        }
-    }
-    
+
+    fun getPropertyInt(name: String): Int? = try {
+        instance.getPropertyInt(name)
+    } catch (e: Exception) { null }
+
+    fun getPropertyDouble(name: String): Double? = try {
+        instance.getPropertyDouble(name)
+    } catch (e: Exception) { null }
+
+    fun getPropertyBoolean(name: String): Boolean? = try {
+        instance.getPropertyBoolean(name)
+    } catch (e: Exception) { null }
+
+    fun getPropertyString(name: String): String? = try {
+        instance.getPropertyString(name)
+    } catch (e: Exception) { null }
+
    fun setPropertyInt(name: String, value: Int) {
-        LibMPV.setPropertyInt(name, value)
+        instance.setPropertyInt(name, value)
    }
-    
+
    fun setPropertyDouble(name: String, value: Double) {
-        LibMPV.setPropertyDouble(name, value)
+        instance.setPropertyDouble(name, value)
    }
-    
+
    fun setPropertyBoolean(name: String, value: Boolean) {
-        LibMPV.setPropertyBoolean(name, value)
+        instance.setPropertyBoolean(name, value)
    }
-    
+
    fun setPropertyString(name: String, value: String) {
-        LibMPV.setPropertyString(name, value)
+        instance.setPropertyString(name, value)
    }
-    
+
    fun observeProperty(name: String, format: Int) {
-        LibMPV.observeProperty(name, format)
+        instance.observeProperty(name, format)
+    }
+
+    companion object {
+        /**
+         * Create a fresh mpv handle. Each call returns an independent instance —
+         * do not share across players. Attach exactly one [EventObserver] per
+         * player via [addObserver].
+         */
+        fun create(context: Context): MPVLib {
+            val lib = LibMPV.create(context)
+                ?: throw IllegalStateException("LibMPV.create returned null")
+            val wrapper = MPVLib(lib)
+            // The libObserver is attached for the lifetime of this MPVLib
+            // instance and forwards every LibMPV callback to our observers
+            // list. Player-specific observers are added/removed via
+            // addObserver/removeObserver.
+            lib.addObserver(wrapper.libObserver)
+            return wrapper
+        }
+
+        // MPV Event IDs (kept here so observers can reference them without
+        // holding a reference to an instance).
+        const val MPV_EVENT_NONE = 0
+        const val MPV_EVENT_SHUTDOWN = 1
+        const val MPV_EVENT_LOG_MESSAGE = 2
+        const val MPV_EVENT_GET_PROPERTY_REPLY = 3
+        const val MPV_EVENT_SET_PROPERTY_REPLY = 4
+        const val MPV_EVENT_COMMAND_REPLY = 5
+        const val MPV_EVENT_START_FILE = 6
+        const val MPV_EVENT_END_FILE = 7
+        const val MPV_EVENT_FILE_LOADED = 8
+        const val MPV_EVENT_IDLE = 11
+        const val MPV_EVENT_TICK = 14
+        const val MPV_EVENT_CLIENT_MESSAGE = 16
+        const val MPV_EVENT_VIDEO_RECONFIG = 17
+        const val MPV_EVENT_AUDIO_RECONFIG = 18
+        const val MPV_EVENT_SEEK = 20
+        const val MPV_EVENT_PLAYBACK_RESTART = 21
+        const val MPV_EVENT_PROPERTY_CHANGE = 22
+        const val MPV_EVENT_QUEUE_OVERFLOW = 24
+
+        // End file reason
+        const val MPV_END_FILE_REASON_EOF = 0
+        const val MPV_END_FILE_REASON_STOP = 2
+        const val MPV_END_FILE_REASON_QUIT = 3
+        const val MPV_END_FILE_REASON_ERROR = 4
+        const val MPV_END_FILE_REASON_REDIRECT = 5
    }
 }
--- a/modules/mpv-player/android/src/main/java/expo/modules/mpvplayer/MpvPlayerModule.kt
+++ b/modules/mpv-player/android/src/main/java/expo/modules/mpvplayer/MpvPlayerModule.kt
@@ -28,7 +28,11 @@ class MpvPlayerModule : Module() {
                if (source == null) return@Prop
                
                val urlString = source["url"] as? String ?: return@Prop
-                
+
+                // Parse cache config if provided (mirrors iOS)
+                @Suppress("UNCHECKED_CAST")
+                val cacheConfig = source["cacheConfig"] as? Map<String, Any?>
+
                @Suppress("UNCHECKED_CAST")
                val config = VideoLoadConfig(
                    url = urlString,
@@ -38,7 +42,11 @@ class MpvPlayerModule : Module() {
                    autoplay = (source["autoplay"] as? Boolean) ?: true,
                    initialSubtitleId = (source["initialSubtitleId"] as? Number)?.toInt(),
                    initialAudioId = (source["initialAudioId"] as? Number)?.toInt(),
-                    voDriver = source["voDriver"] as? String
+                    voDriver = source["voDriver"] as? String,
+                    cacheEnabled = cacheConfig?.get("enabled") as? String,
+                    cacheSeconds = (cacheConfig?.get("cacheSeconds") as? Number)?.toInt(),
+                    demuxerMaxBytes = (cacheConfig?.get("maxBytes") as? Number)?.toInt(),
+                    demuxerMaxBackBytes = (cacheConfig?.get("maxBackBytes") as? Number)?.toInt()
                )
                
                view.loadVideo(config)
@@ -60,6 +68,15 @@ class MpvPlayerModule : Module() {
                view.pause()
            }

+            // Stop playback and release the MediaCodec decoder + demuxer.
+            // Does not synchronously tear down the native mpv handle (see
+            // MPVLib / MpvPlayerView.destroy docs). Call before navigating
+            // away from the player screen to avoid OOM during screen
+            // transitions on low-RAM devices.
+            AsyncFunction("destroy") { view: MpvPlayerView ->
+                view.destroy()
+            }
+
            // Async function to seek to position
            AsyncFunction("seekTo") { view: MpvPlayerView, position: Double ->
                view.seekTo(position)
--- a/modules/mpv-player/android/src/main/java/expo/modules/mpvplayer/MpvPlayerView.kt
+++ b/modules/mpv-player/android/src/main/java/expo/modules/mpvplayer/MpvPlayerView.kt
@@ -26,7 +26,11 @@ data class VideoLoadConfig(
    val autoplay: Boolean = true,
    val initialSubtitleId: Int? = null,
    val initialAudioId: Int? = null,
-    val voDriver: String? = null
+    val voDriver: String? = null,
+    val cacheEnabled: String? = null,
+    val cacheSeconds: Int? = null,
+    val demuxerMaxBytes: Int? = null,
+    val demuxerMaxBackBytes: Int? = null
 )

 /**
@@ -60,6 +64,7 @@ class MpvPlayerView(context: Context, appContext: AppContext) : ExpoView(context
    private var pendingConfig: VideoLoadConfig? = null
    private var rendererStarted: Boolean = false
    private var pendingSurface: Surface? = null
+    private var activeSurface: Surface? = null
    private var surfaceTexture: SurfaceTexture? = null

    // PiP state tracking
@@ -131,6 +136,7 @@ class MpvPlayerView(context: Context, appContext: AppContext) : ExpoView(context
            rendererStarted = true

            pendingSurface?.let { surface ->
+                activeSurface = surface
                renderer?.attachSurface(surface)
                pendingSurface = null
            }
@@ -149,6 +155,11 @@ class MpvPlayerView(context: Context, appContext: AppContext) : ExpoView(context
        surfaceReady = true

        if (rendererStarted) {
+            // Release the previous wrapper Surface before losing the only
+            // reference to it. cleanup() only runs on detach, so without this
+            // repeated PiP/background/resize cycles leak native surface objects.
+            activeSurface?.release()
+            activeSurface = surface
            renderer?.attachSurface(surface)
        } else {
            pendingSurface = surface
@@ -207,7 +218,11 @@ class MpvPlayerView(context: Context, appContext: AppContext) : ExpoView(context
            startPosition = config.startPosition,
            externalSubtitles = config.externalSubtitles,
            initialSubtitleId = config.initialSubtitleId,
-            initialAudioId = config.initialAudioId
+            initialAudioId = config.initialAudioId,
+            cacheEnabled = config.cacheEnabled,
+            cacheSeconds = config.cacheSeconds,
+            demuxerMaxBytes = config.demuxerMaxBytes,
+            demuxerMaxBackBytes = config.demuxerMaxBackBytes
        )

        if (config.autoplay) {
@@ -236,6 +251,51 @@ class MpvPlayerView(context: Context, appContext: AppContext) : ExpoView(context
        pipController?.setPlaybackRate(0.0)
    }

+    /**
+     * Stop playback and release decoder resources.
+     *
+     * Delegates to [MPVLayerRenderer.stop], which issues mpv's "stop" command
+     * on a background thread (flushing the demuxer and releasing the
+     * MediaCodec hardware decoder) and drops the per-instance mpv handle.
+     *
+     * NOTE: this does NOT call `LibMPV.destroy()`. libmpv 1.0's
+     * nativeDestroy has an internal use-after-free on the JNI global ref
+     * path, so the native mpv handle is intentionally left for the JVM GC
+     * / native finalizer rather than torn down synchronously. See
+     * [MPVLib] class doc for the full rationale.
+     *
+     * Call this BEFORE navigating away from the player screen so the
+     * decoder is reclaimed before the next screen (or the next episode's
+     * player) mounts. Otherwise Expo Router renders the new screen first
+     * and you briefly have two mpv instances + two 4K decoders alive —
+     * instant OOM on a 2 GB device.
+     */
+    fun destroy() {
+        renderer?.stop()
+
+        // Reset view-level state so a subsequent loadVideo() on the SAME view
+        // instance re-creates the mpv handle and re-attaches the still-live
+        // TextureView surface. Without this, rendererStarted stays true and
+        // ensureRendererStarted() early-returns, so renderer.start() is never
+        // called again — but stop() already nulled the renderer's mpv handle.
+        // The next loadVideo() then runs loadVideoInternal() -> renderer.load()
+        // against mpv == null, where every mpv?.command() (including the
+        // "stop" and load commands) silently no-ops, leaving a black frame.
+        //
+        // This path is hit by direct-player.tsx's goToNextItem()/stop(),
+        // which call destroy() immediately before router.replace() to the
+        // same route — Expo Router reuses the same MpvPlayerView instance,
+        // so the next source load happens on this view without a remount.
+        rendererStarted = false
+        currentUrl = null
+        // Move the active surface back to pending so ensureRendererStarted()
+        // re-attaches it to the freshly created mpv instance on next load.
+        // The Surface itself is still valid — onSurfaceTextureDestroyed has
+        // not fired because the TextureView is not being unmounted.
+        activeSurface?.let { pendingSurface = it }
+        activeSurface = null
+    }
+
    fun seekTo(position: Double) {
        renderer?.seekTo(position)
    }
@@ -479,13 +539,32 @@ class MpvPlayerView(context: Context, appContext: AppContext) : ExpoView(context

    // MARK: - Cleanup

+    /**
+     * Proactively tear down the player. Called from onDetachedFromWindow so
+     * the app releases mpv + decoder buffers when the View detaches from the
+     * window. The JS-facing destroy() is intentionally thinner (just
+     * renderer.stop()) — see this thread for why the full teardown was kept
+     * off the JS path.
+     */
    fun cleanup() {
        isWaitingForPiPTransition = false
        pipHandler.removeCallbacksAndMessages(null)
        pipController?.stopPictureInPicture()
        renderer?.stop()
-        surfaceTexture = null
+        renderer?.delegate = null
+
+        // Release the Surface that wraps the SurfaceTexture. These Surface
+        // objects are created in onSurfaceTextureAvailable and were never
+        // released; each playback session previously leaked one. The
+        // SurfaceTexture itself is owned by TextureView and released by it
+        // via onSurfaceTextureDestroyed, so we leave it alone.
+        pendingSurface?.release()
+        pendingSurface = null
+        activeSurface?.release()
+        activeSurface = null
        surfaceReady = false
+        currentUrl = null
+        rendererStarted = false
    }

    override fun onDetachedFromWindow() {
--- a/modules/mpv-player/ios/MPVLayerRenderer.swift
+++ b/modules/mpv-player/ios/MPVLayerRenderer.swift
@@ -770,12 +770,32 @@ final class MPVLayerRenderer {
            if let lang = getStringProperty(handle: handle, name: "track-list/\(i)/lang") {
                track["lang"] = lang
            }
-            
+
+            if let codec = getStringProperty(handle: handle, name: "track-list/\(i)/codec") {
+                track["codec"] = codec
+            }
+
+            // Identity fields used to map a Jellyfin subtitle to the real track
+            // (instead of fragile positional counting). `external` + `external-filename`
+            // uniquely identify a sub-added sidecar; `ff-index` aids embedded matching.
+            var external: Int32 = 0
+            getProperty(handle: handle, name: "track-list/\(i)/external", format: MPV_FORMAT_FLAG, value: &external)
+            track["external"] = external != 0
+
+            if let extFilename = getStringProperty(handle: handle, name: "track-list/\(i)/external-filename") {
+                track["externalFilename"] = extFilename
+            }
+
+            var ffIndex: Int64 = 0
+            if getProperty(handle: handle, name: "track-list/\(i)/ff-index", format: MPV_FORMAT_INT64, value: &ffIndex) >= 0 {
+                track["ffIndex"] = Int(ffIndex)
+            }
+
            var selected: Int32 = 0
            getProperty(handle: handle, name: "track-list/\(i)/selected", format: MPV_FORMAT_FLAG, value: &selected)
            track["selected"] = selected != 0
-            
-            Logger.shared.log("getSubtitleTracks: found sub track id=\(trackId), title=\(track["title"] ?? "none"), lang=\(track["lang"] ?? "none")", type: "Info")
+
+            Logger.shared.log("getSubtitleTracks: found sub track id=\(trackId), title=\(track["title"] ?? "none"), lang=\(track["lang"] ?? "none"), external=\(external != 0)", type: "Info")
            tracks.append(track)
        }
        
@@ -1020,12 +1040,44 @@ final class MPVLayerRenderer {
            info["cacheSeconds"] = cacheSeconds
        }

+        // Configured cache limits — read back from mpv to confirm user
+        // settings actually took effect. mpv stores byte sizes as int64
+        // (bytes); convert to MiB for display.
+        var demuxerMaxBytes: Int64 = 0
+        if getProperty(handle: handle, name: "demuxer-max-bytes", format: MPV_FORMAT_INT64, value: &demuxerMaxBytes) >= 0 {
+            info["demuxerMaxBytes"] = Int(demuxerMaxBytes / (1024 * 1024))
+        }
+        var demuxerMaxBackBytes: Int64 = 0
+        if getProperty(handle: handle, name: "demuxer-max-back-bytes", format: MPV_FORMAT_INT64, value: &demuxerMaxBackBytes) >= 0 {
+            info["demuxerMaxBackBytes"] = Int(demuxerMaxBackBytes / (1024 * 1024))
+        }
+        var cacheSecsLimit: Double = 0
+        if getProperty(handle: handle, name: "cache-secs", format: MPV_FORMAT_DOUBLE, value: &cacheSecsLimit) >= 0 {
+            info["cacheSecsLimit"] = cacheSecsLimit
+        }
+
        // Dropped frames
        var droppedFrames: Int64 = 0
        if getProperty(handle: handle, name: "frame-drop-count", format: MPV_FORMAT_INT64, value: &droppedFrames) >= 0 {
            info["droppedFrames"] = Int(droppedFrames)
        }

+        // Active video output driver
+        if let voDriver = getStringProperty(handle: handle, name: "vo") {
+            info["voDriver"] = voDriver
+        }
+
+        // Active hardware decoder
+        if let hwdec = getStringProperty(handle: handle, name: "hwdec-current") {
+            info["hwdec"] = hwdec
+        }
+
+        // Estimated video output fps (post-filter)
+        var estimatedVfFps: Double = 0
+        if getProperty(handle: handle, name: "estimated-vf-fps", format: MPV_FORMAT_DOUBLE, value: &estimatedVfFps) >= 0 && estimatedVfFps > 0 {
+            info["estimatedVfFps"] = estimatedVfFps
+        }
+
        return info
    }
 }
--- a/modules/mpv-player/ios/MpvPlayerModule.swift
+++ b/modules/mpv-player/ios/MpvPlayerModule.swift
@@ -74,7 +74,13 @@ public class MpvPlayerModule: Module {
      AsyncFunction("pause") { (view: MpvPlayerView) in
        view.pause()
      }
-      
+
+      // Synchronously destroy mpv instance + decoder before navigating
+      // away from the player screen (cross-platform; matches Android).
+      AsyncFunction("destroy") { (view: MpvPlayerView) in
+        view.destroy()
+      }
+
      // Async function to seek to position
      AsyncFunction("seekTo") { (view: MpvPlayerView, position: Double) in
        view.seekTo(position: position)
--- a/modules/mpv-player/ios/MpvPlayerView.swift
+++ b/modules/mpv-player/ios/MpvPlayerView.swift
@@ -289,6 +289,49 @@ class MpvPlayerView: ExpoView {
 		pipController?.updatePlaybackState()
 	}

+	/**
+	 * Synchronously stop and destroy the mpv instance + decoder so memory is
+	 * freed before the next screen mounts. Safe to call multiple times — the
+	 * underlying renderer.stop() guards against re-entry.
+	 *
+	 * Cross-platform counterpart of MpvPlayerView.destroy() on Android.
+	 */
+	func destroy() {
+		renderer?.stop()
+
+		// Reset view state and re-create the mpv handle so a subsequent
+		// loadVideo() on the SAME view instance can actually load.
+		// Without this, stop() leaves renderer.mpv == nil, and the next
+		// loadVideo(config:) calls renderer.load() which early-returns
+		// at `guard let handle = self.mpv else { return }` — but only
+		// after flipping isLoading = true and dispatching the loading
+		// delegate callback, so the JS layer is stuck in a perpetual
+		// "loading" state with no actual playback.
+		//
+		// This path is hit by direct-player.tsx's goToNextItem()/stop(),
+		// which call destroy() immediately before router.replace() to
+		// the same route — Expo Router reuses the same MpvPlayerView
+		// instance, so the next `source` prop update arrives on this
+		// view without a remount. setupView() is otherwise the only
+		// place start() is called, so without re-starting here the
+		// renderer stays dead until the whole view is unmounted and
+		// recreated.
+		//
+		// start() is idempotent (`guard !isRunning else { return }`)
+		// and stop() has already nulled mpv synchronously before
+		// dispatching the async mpv_terminate_destroy, so creating a
+		// fresh handle here is safe even while the old handle's
+		// teardown is still in flight on a background queue (libmpv
+		// handles are independent).
+		currentURL = nil
+		intendedPlayState = false
+		do {
+			try renderer?.start()
+		} catch {
+			onError(["error": "Failed to restart renderer after destroy: \(error.localizedDescription)"])
+		}
+	}
+
 	func seekTo(position: Double) {
 		// Update cached position and Now Playing immediately for smooth Control Center feedback
 		cachedPosition = position
--- a/modules/mpv-player/src/MpvPlayer.types.ts
+++ b/modules/mpv-player/src/MpvPlayer.types.ts
@@ -89,6 +89,14 @@ export type MpvPlayerViewProps = {
 export interface MpvPlayerViewRef {
  play: () => Promise<void>;
  pause: () => Promise<void>;
+  /**
+   * Synchronously destroy the mpv instance + decoder + surface buffers.
+   * Call before navigating away from the player screen so memory is
+   * freed before the next screen mounts. Safe to call multiple times.
+   */
+  destroy: () => Promise<void>;
+  // Pre-libmpv-1.0 alias (kept for source-history reference):
+  // stop: () => Promise<void>;
  seekTo: (position: number) => Promise<void>;
  seekBy: (offset: number) => Promise<void>;
  setSpeed: (speed: number) => Promise<void>;
@@ -133,6 +141,14 @@ export type SubtitleTrack = {
  id: number;
  title?: string;
  lang?: string;
+  /** Subtitle codec (mpv `codec`), e.g. "subrip", "ass", "hdmv_pgs_subtitle". */
+  codec?: string;
+  /** True if loaded from a separate file via `sub-add` (mpv `external`). */
+  external?: boolean;
+  /** For external tracks: the exact URL/path it was loaded from (mpv `external-filename`). */
+  externalFilename?: string;
+  /** FFmpeg stream index (mpv `ff-index`); not guaranteed for non-lavf demuxers. */
+  ffIndex?: number;
  selected?: boolean;
 };

@@ -154,9 +170,17 @@ export type TechnicalInfo = {
  videoBitrate?: number;
  audioBitrate?: number;
  cacheSeconds?: number;
+  /** Configured demuxer forward cache cap (MiB), read back from mpv */
+  demuxerMaxBytes?: number;
+  /** Configured demuxer backward cache cap (MiB), read back from mpv */
+  demuxerMaxBackBytes?: number;
+  /** Configured cache-secs floor, read back from mpv */
+  cacheSecsLimit?: number;
  droppedFrames?: number;
  /** Active video output driver (read from MPV at runtime) */
  voDriver?: string;
  /** Active hardware decoder (read from MPV at runtime) */
  hwdec?: string;
+  /** Estimated video output fps (mpv "estimated-vf-fps") */
+  estimatedVfFps?: number;
 };
--- a/modules/mpv-player/src/MpvPlayerView.tsx
+++ b/modules/mpv-player/src/MpvPlayerView.tsx
@@ -20,6 +20,9 @@ export default React.forwardRef<MpvPlayerViewRef, MpvPlayerViewProps>(
      pause: async () => {
        await nativeRef.current?.pause();
      },
+      destroy: async () => {
+        await nativeRef.current?.destroy();
+      },
      seekTo: async (position: number) => {
        await nativeRef.current?.seekTo(position);
      },
--- a/package.json
+++ b/package.json
@@ -17,13 +17,13 @@
    "ios:unsigned-build": "cross-env EXPO_TV=0 bun scripts/ios/build-ios.ts --production",
    "ios:unsigned-build:tv": "cross-env EXPO_TV=1 bun scripts/ios/build-ios.ts --production",
    "prepare": "husky",
-    "typecheck": "node scripts/typecheck.js",
+    "typecheck": "bun scripts/typecheck.ts",
    "check": "biome check . --max-diagnostics 1000",
    "lint": "biome check --write --unsafe --max-diagnostics 1000",
    "format": "biome format --write .",
    "doctor": "expo-doctor",
-    "i18n:check": "bun scripts/check-i18n-keys.mjs",
-    "i18n:fix-unused": "bun scripts/check-i18n-keys.mjs --fix-unused",
+    "i18n:check": "bun scripts/check-i18n-keys.ts",
+    "i18n:fix-unused": "bun scripts/check-i18n-keys.ts --fix-unused",
    "test": "bun run typecheck && bun run lint && bun run format && bun run i18n:check && bun run doctor",
    "postinstall": "patch-package"
  },
@@ -123,7 +123,7 @@
  },
  "devDependencies": {
    "@babel/core": "7.29.7",
-    "@biomejs/biome": "2.5.1",
+    "@biomejs/biome": "2.4.16",
    "@react-native-community/cli": "20.1.3",
    "@react-native-tvos/config-tv": "0.1.6",
    "@types/jest": "29.5.14",
--- a/plugins/withGradleProperties.js
+++ b/plugins/withGradleProperties.js
@@ -27,6 +27,9 @@ module.exports = function withCustomPlugin(config) {
  // https://github.com/expo/expo/issues/32558
  config = setGradlePropertiesValue(config, "android.enableJetifier", "true");

+  // NDK version required by libmpv 1.0.0
+  config = setGradlePropertiesValue(config, "ndkVersion", "29.0.14206865");
+
  // Increase memory
  config = setGradlePropertiesValue(
    config,
--- a/scripts/check-i18n-keys.mjs
+++ b/scripts/check-i18n-keys.mjs
@@ -18,11 +18,11 @@
 *   - Edge cases the static scan cannot see can be allow-listed in the config file.
 *
 * Usage:
- *   bun scripts/check-i18n-keys.mjs                # report + exit 1 on missing OR unused
- *   bun scripts/check-i18n-keys.mjs --unused=warn  # exit 1 only on missing; unused = warning
- *   bun scripts/check-i18n-keys.mjs --unused=off   # ignore unused entirely
- *   bun scripts/check-i18n-keys.mjs --json         # machine-readable output
- *   bun scripts/check-i18n-keys.mjs --fix-unused   # remove dead keys from en.json (Crowdin syncs the rest)
+ *   bun scripts/check-i18n-keys.ts                # report + exit 1 on missing OR unused
+ *   bun scripts/check-i18n-keys.ts --unused=warn  # exit 1 only on missing; unused = warning
+ *   bun scripts/check-i18n-keys.ts --unused=off   # ignore unused entirely
+ *   bun scripts/check-i18n-keys.ts --json         # machine-readable output
+ *   bun scripts/check-i18n-keys.ts --fix-unused   # remove dead keys from en.json (Crowdin syncs the rest)
 */

 import {
@@ -34,9 +34,20 @@ import {
 } from "node:fs";
 import { extname, join, relative } from "node:path";

+type LocaleTree = { [key: string]: LocaleTree | string };
+
+interface I18nConfig {
+  localesDir: string;
+  sourceLocale: string;
+  srcDirs: string[];
+  srcExtensions: string[];
+  excludeDirs: string[];
+  ignoreUnused: string[];
+}
+
 const ROOT = process.cwd();
 const args = process.argv.slice(2);
-const flag = (name, def) => {
+const flag = (name: string, def: string | boolean): string | boolean => {
  const a = args.find((x) => x === `--${name}` || x.startsWith(`--${name}=`));
  if (!a) return def;
  const [, v] = a.split("=");
@@ -48,7 +59,7 @@ const FIX_UNUSED = !!flag("fix-unused", false);

 // ---- config ----
 const CONFIG_PATH = join(ROOT, "scripts", "i18n-keys.config.json");
-const DEFAULT_CONFIG = {
+const DEFAULT_CONFIG: I18nConfig = {
  localesDir: "translations",
  sourceLocale: "en",
  // Scan the whole repo by default so keys referenced outside the obvious dirs
@@ -69,29 +80,36 @@ const DEFAULT_CONFIG = {
  // Keys (or glob-ish prefixes ending with .* or *) known to be used dynamically / externally.
  ignoreUnused: [],
 };
-const config = existsSync(CONFIG_PATH)
-  ? { ...DEFAULT_CONFIG, ...JSON.parse(readFileSync(CONFIG_PATH, "utf8")) }
+const config: I18nConfig = existsSync(CONFIG_PATH)
+  ? {
+      ...DEFAULT_CONFIG,
+      ...(JSON.parse(readFileSync(CONFIG_PATH, "utf8")) as Partial<I18nConfig>),
+    }
  : DEFAULT_CONFIG;

 // ---- helpers ----
-const flatten = (obj, prefix = "", out = {}) => {
+const flatten = (
+  obj: LocaleTree,
+  prefix = "",
+  out: Record<string, string> = {},
+): Record<string, string> => {
  for (const [k, v] of Object.entries(obj)) {
    const key = prefix ? `${prefix}.${k}` : k;
    if (v && typeof v === "object" && !Array.isArray(v)) flatten(v, key, out);
-    else out[key] = v;
+    else out[key] = v as string;
  }
  return out;
 };

-const globMatch = (key, pattern) => {
+const globMatch = (key: string, pattern: string): boolean => {
  if (pattern.endsWith(".*"))
    return key === pattern.slice(0, -2) || key.startsWith(pattern.slice(0, -1));
  if (pattern.endsWith("*")) return key.startsWith(pattern.slice(0, -1));
  return key === pattern;
 };

-const walk = (dir, files = []) => {
-  let entries;
+const walk = (dir: string, files: string[] = []): string[] => {
+  let entries: string[];
  try {
    entries = readdirSync(dir);
  } catch {
@@ -99,7 +117,7 @@ const walk = (dir, files = []) => {
  }
  for (const name of entries) {
    const full = join(dir, name);
-    let st;
+    let st: ReturnType<typeof statSync>;
    try {
      st = statSync(full);
    } catch {
@@ -118,7 +136,7 @@ const walk = (dir, files = []) => {
 // ---- load source keys ----
 const sourcePath = join(ROOT, config.localesDir, `${config.sourceLocale}.json`);
 const sourceKeys = Object.keys(
-  flatten(JSON.parse(readFileSync(sourcePath, "utf8"))),
+  flatten(JSON.parse(readFileSync(sourcePath, "utf8")) as LocaleTree),
 );
 const sourceKeySet = new Set(sourceKeys);

@@ -129,16 +147,16 @@ const TPL_DYN_RE = /\bt\(\s*`([^`$]*)\$\{/g; // t(`a.b.${x}`) -> prefix "a.b."
 const I18NKEY_RE = /\bi18nKey\s*=\s*(?:\{\s*)?(['"])((?:\\.|(?!\1).)+?)\1/g; // <Trans i18nKey="a.b">
 const KEY_SHAPE = /^[A-Za-z0-9_]+(\.[A-Za-z0-9_]+)+$/; // dotted key, e.g. home.x.y

-const usedStatic = new Set(); // keys passed to t(...) / i18nKey — used for MISSING detection
-const dynamicPrefixes = new Set();
-const fullyDynamic = []; // { file, line }
+const usedStatic = new Set<string>(); // keys passed to t(...) / i18nKey — used for MISSING detection
+const dynamicPrefixes = new Set<string>();
+const fullyDynamic: Array<{ file: string; line: number }> = [];
 let codeBlob = ""; // all (comment-stripped) source text — searched for delimited key literals

 // Strip comments so keys mentioned in comments (e.g. `// t("old.key")`) are not counted as
 // usage. Block comments and JSX {/* */} are blanked (preserving newlines for line numbers);
 // line comments are only stripped when `//` follows start/whitespace/punctuation, which keeps
 // `://` inside string URLs intact.
-const stripComments = (src) =>
+const stripComments = (src: string): string =>
  src
    .replace(/\/\*[\s\S]*?\*\//g, (m) => m.replace(/[^\n]/g, " "))
    .replace(/(^|[\s;{}()[\],=>])\/\/[^\n]*/g, (_m, p) => p);
@@ -168,11 +186,11 @@ const prefixList = [...dynamicPrefixes];
 // the code (covers t("k"), <Trans i18nKey>, and keys stored as bare string constants in
 // arrays/config then resolved via t(variable)), or it is reached via a dynamic prefix, or
 // explicitly allow-listed. Delimited search avoids substring false-matches (e.g. a.b vs a.b_c).
-const literalUsed = (key) =>
+const literalUsed = (key: string): boolean =>
  codeBlob.includes(`"${key}"`) ||
  codeBlob.includes(`'${key}'`) ||
  codeBlob.includes(`\`${key}\``);
-const isUsed = (key) =>
+const isUsed = (key: string): boolean =>
  literalUsed(key) ||
  prefixList.some((p) => key.startsWith(p)) ||
  config.ignoreUnused.some((g) => globMatch(key, g));
@@ -191,25 +209,22 @@ const missing = [...usedStatic]
 // keys are static literals in practice; revisit if dynamic key constants become common.

 // ---- optional fix: strip dead keys from the source locale (en.json) ----
-const removeKey = (obj, parts) => {
+const removeKey = (obj: LocaleTree, parts: string[]): void => {
  const [head, ...rest] = parts;
  if (!(head in obj)) return;
  if (rest.length === 0) {
    delete obj[head];
    return;
  }
-  removeKey(obj[head], rest);
-  if (
-    obj[head] &&
-    typeof obj[head] === "object" &&
-    Object.keys(obj[head]).length === 0
-  )
-    delete obj[head];
+  const child = obj[head];
+  if (!child || typeof child !== "object") return;
+  removeKey(child, rest);
+  if (Object.keys(child).length === 0) delete obj[head];
 };
 if (FIX_UNUSED && unused.length) {
  // Only edit the SOURCE locale (en.json). Crowdin owns the target locales and removes
  // the keys from them automatically on the next sync once they disappear from the source.
-  const data = JSON.parse(readFileSync(sourcePath, "utf8"));
+  const data = JSON.parse(readFileSync(sourcePath, "utf8")) as LocaleTree;
  for (const key of unused) removeKey(data, key.split("."));
  writeFileSync(sourcePath, `${JSON.stringify(data, null, 2)}\n`);
  console.log(
@@ -259,7 +274,7 @@ if (JSON_OUT) {
      );
      for (const k of unused) console.log(`   - ${k}`);
      console.log(
-        `\n   → remove with: bun scripts/check-i18n-keys.mjs --fix-unused`,
+        `\n   → remove with: bun scripts/check-i18n-keys.ts --fix-unused`,
      );
      console.log(
        `   → or allow-list a dynamic key in scripts/i18n-keys.config.json ("ignoreUnused").`,
--- a/scripts/detect-duplicate-issue.mjs
+++ b/scripts/detect-duplicate-issue.mjs
@@ -21,8 +21,14 @@
 import { execFileSync } from "node:child_process";
 import { readFileSync } from "node:fs";

+interface Issue {
+  number: number;
+  title: string;
+  body: string | null;
+}
+
 // Parse a numeric env var, falling back to `def` only when unset/empty/NaN so an explicit 0 is honoured.
-const numEnv = (name, def) => {
+const numEnv = (name: string, def: number): number => {
  const raw = process.env[name];
  if (raw === undefined || raw === "") return def;
  const n = Number(raw);
@@ -51,9 +57,9 @@ const STOP = new Set(
  ).split(/\s+/),
 );

-const stem = (w) => w.replace(/(ing|ed|es|s)$/, "");
+const stem = (w: string): string => w.replace(/(ing|ed|es|s)$/, "");

-const tokens = (s) =>
+const tokens = (s: string | null): string[] =>
  (s || "")
    .toLowerCase()
    .replace(/```[\s\S]*?```/g, " ") // drop code blocks
@@ -65,7 +71,7 @@ const tokens = (s) =>
    .map(stem)
    .filter((w) => w.length > 2);

-const jaccard = (a, b) => {
+const jaccard = (a: string[], b: string[]): number => {
  const A = new Set(a);
  const B = new Set(b);
  if (!A.size || !B.size) return 0;
@@ -76,14 +82,14 @@ const jaccard = (a, b) => {

 const newTitle = tokens(TITLE);
 const newBody = tokens(BODY);
-const score = (o) =>
+const score = (o: Issue): number =>
  0.6 * jaccard(newTitle, tokens(o.title)) +
  0.4 * jaccard(newBody, tokens(o.body));

 // fetch open issues (excluding PRs and the new issue itself)
-let issues;
+let issues: Issue[];
 if (process.env.DUP_FIXTURE) {
-  issues = JSON.parse(readFileSync(process.env.DUP_FIXTURE, "utf8"));
+  issues = JSON.parse(readFileSync(process.env.DUP_FIXTURE, "utf8")) as Issue[];
 } else {
  const raw = execFileSync(
    "gh",
@@ -105,7 +111,7 @@ if (process.env.DUP_FIXTURE) {
  issues = raw
    .split("\n")
    .filter(Boolean)
-    .map((l) => JSON.parse(l));
+    .map((l) => JSON.parse(l) as Issue);
 }

 const matches = issues
@@ -123,7 +129,7 @@ if (!matches.length) {
 // Neutralise other issues' titles before echoing them back: break @mentions and
 // strip markdown/HTML control chars so a maliciously-named issue can't ping people
 // or inject formatting into our comment. GitHub linkifies "#123" on its own.
-const safeTitle = (t) =>
+const safeTitle = (t: string): string =>
  (t || "")
    .replace(/@/g, "@")
    .replace(/[`<>|*_~[\]]/g, " ")
--- a/scripts/symlink-native-dirs.js
+++ b/scripts/symlink-native-dirs.js
@@ -1,62 +0,0 @@
-#!/usr/bin/env node
-
-const _fs = require("node:fs");
-const path = require("node:path");
-const process = require("node:process");
-const { execSync } = require("node:child_process");
-
-const root = process.cwd();
-// const tvosPath = path.join(root, 'iostv');
-// const iosPath = path.join(root, 'iosmobile');
-// const androidPath = path.join(root, 'androidmobile');
-// const androidTVPath = path.join(root, 'androidtv');
-// const device = process.argv[2];
-// const platform = process.argv[2];
-const isTV = process.env.EXPO_TV || false;
-
-const paths = new Map([
-  ["tvos", path.join(root, "iostv")],
-  ["ios", path.join(root, "iosmobile")],
-  ["android", path.join(root, "androidmobile")],
-  ["androidtv", path.join(root, "androidtv")],
-]);
-
-// const platformPath = paths.get(platform);
-
-if (isTV) {
-  stdout = execSync(
-    `mkdir -p ${paths.get("tvos")}; ln -nsf ${paths.get("tvos")} ios`,
-  );
-  console.log(stdout.toString());
-  stdout = execSync(
-    `mkdir -p ${paths.get("androidtv")}; ln -nsf ${paths.get(
-      "androidtv",
-    )} android`,
-  );
-  console.log(stdout.toString());
-} else {
-  stdout = execSync(
-    `mkdir -p ${paths.get("ios")}; ln -nsf ${paths.get("ios")} ios`,
-  );
-  console.log(stdout.toString());
-  stdout = execSync(
-    `mkdir -p ${paths.get("android")}; ln -nsf ${paths.get("android")} android`,
-  );
-  console.log(stdout.toString());
-}
-
-// target = "";
-// switch (platform) {
-//   case "tvos":
-//     target = "ios";
-//     break;
-//   case "ios":
-//     target = "ios";
-//     break;
-//   case "android":
-//     target = "android";
-//     break;
-//   case "androidtv":
-//     target = "android";
-//     break;
-// }
--- a/scripts/typecheck.ts
+++ b/scripts/typecheck.ts
@@ -1,5 +1,8 @@
-const { execFileSync } = require("node:child_process");
-const process = require("node:process");
+import { execFileSync } from "node:child_process";
+import { createRequire } from "node:module";
+import process from "node:process";
+
+const require = createRequire(import.meta.url);

 // Enhanced ANSI color codes and styles
 const colors = {
@@ -32,7 +35,7 @@ const centeredTitle = " ".repeat(titlePadding) + title;

 const useColor = process.stdout.isTTY && !process.env.NO_COLOR;

-function log(message, color = "") {
+function log(message: string, color = "") {
  if (useColor && color) {
    console.log(`${color}${message}${colors.reset}`);
  } else {
@@ -40,7 +43,7 @@ function log(message, color = "") {
  }
 }

-function formatError(errorLine) {
+function formatError(errorLine: string): string {
  if (!useColor) return errorLine;

  // Color file paths in cyan
@@ -70,12 +73,15 @@ function formatError(errorLine) {
  return formatted;
 }

-function parseErrorsAndCreateSummary(errorOutput) {
+function parseErrorsAndCreateSummary(errorOutput: string): {
+  formattedErrors: string[];
+  errorsByFile: Map<string, number>;
+} {
  const lines = errorOutput.split("\n").filter((line) => line.trim());
-  const errorsByFile = new Map();
-  const formattedErrors = [];
+  const errorsByFile = new Map<string, number>();
+  const formattedErrors: string[] = [];

-  let currentError = [];
+  let currentError: string[] = [];

  for (const line of lines) {
    const trimmedLine = line.trim();
@@ -96,7 +102,7 @@ function parseErrorsAndCreateSummary(errorOutput) {
      if (!errorsByFile.has(filePath)) {
        errorsByFile.set(filePath, 0);
      }
-      errorsByFile.set(filePath, errorsByFile.get(filePath) + 1);
+      errorsByFile.set(filePath, (errorsByFile.get(filePath) ?? 0) + 1);

      // Start new error
      currentError.push(formatError(line));
@@ -119,7 +125,7 @@ function parseErrorsAndCreateSummary(errorOutput) {
  return { formattedErrors, errorsByFile };
 }

-function createErrorSummaryTable(errorsByFile) {
+function createErrorSummaryTable(errorsByFile: Map<string, number>): string {
  if (errorsByFile.size === 0) return "";

  const sortedFiles = Array.from(errorsByFile.entries()).sort(
@@ -136,7 +142,7 @@ function createErrorSummaryTable(errorsByFile) {
  return table;
 }

-function runTypeCheck() {
+function runTypeCheck(): { ok: boolean } {
  const extraArgs = process.argv.slice(2);

  // Prefer local TypeScript binary when available
@@ -150,16 +156,13 @@ function runTypeCheck() {
    "false",
    ...extraArgs,
  ];
-  let execArgs = null;
+  let execArgs: { cmd: string; args: string[] };
  try {
    const tscBin = require.resolve("typescript/bin/tsc");
    execArgs = { cmd: process.execPath, args: [tscBin, ...runnerArgs] };
  } catch {
-    // fallback to PATH tsc
-    execArgs = {
-      cmd: "tsc",
-      args: ["-p", "tsconfig.json", "--noEmit", ...extraArgs],
-    };
+    // fallback to PATH tsc (reuse runnerArgs so --pretty false is preserved)
+    execArgs = { cmd: "tsc", args: runnerArgs };
  }

  try {
@@ -183,7 +186,21 @@ function runTypeCheck() {
    );
    return { ok: true };
  } catch (error) {
-    const errorOutput = (error && (error.stderr || error.stdout)) || "";
+    const execError = error as { stderr?: string; stdout?: string };
+    const errorOutput = [execError.stdout, execError.stderr]
+      .filter((chunk): chunk is string => Boolean(chunk))
+      .join("\n");
+
+    // No compiler output = tsc never ran (e.g. binary missing). Don't let a
+    // launch failure fall through to the "passed" branch and green-light CI.
+    if (!errorOutput) {
+      const message = error instanceof Error ? error.message : String(error);
+      log(
+        `❌ ${colors.bold}TypeScript check failed to start${colors.reset} ${colors.gray}${message}${colors.reset}`,
+        colors.red,
+      );
+      return { ok: false };
+    }

    // Filter out jellyseerr utils errors - this is a third-party git submodule
    // that generates a large volume of known type errors
--- a/utils/atoms/settings.ts
+++ b/utils/atoms/settings.ts
@@ -9,6 +9,7 @@ import {
 import { t } from "i18next";
 import { atom, useAtom, useAtomValue } from "jotai";
 import { useCallback, useEffect, useMemo } from "react";
+import { Platform } from "react-native";
 import { BITRATES, type Bitrate } from "@/components/BitrateSelector";
 import * as ScreenOrientation from "@/packages/expo-screen-orientation";
 import { apiAtom } from "@/providers/JellyfinProvider";
@@ -361,11 +362,16 @@ export const defaultValues: Settings = {
  mpvSubtitleFontSize: undefined,
  mpvSubtitleBackgroundEnabled: false,
  mpvSubtitleBackgroundOpacity: 75,
-  // MPV buffer/cache defaults
+  // MPV buffer/cache defaults.
+  // Android TV gets tighter caps — combined with libmpv 1.0's larger
+  // baseline (fontconfig + libxml2 + libplacebo HDR path + scudo
+  // retention) the larger mobile budget pushes 2 GB Android TV boxes
+  // into swap death during 4K HDR playback. Apple TV has more RAM and
+  // keeps the full budget. Users can override via the settings screen.
  mpvCacheEnabled: "auto",
  mpvCacheSeconds: 10,
-  mpvDemuxerMaxBytes: 150, // MB
-  mpvDemuxerMaxBackBytes: 50, // MB
+  mpvDemuxerMaxBytes: Platform.isTV && Platform.OS === "android" ? 75 : 150, // MB
+  mpvDemuxerMaxBackBytes: Platform.isTV && Platform.OS === "android" ? 30 : 50, // MB
  // MPV video output driver defaults (Android only)
  mpvVoDriver: "gpu-next",
  // Gesture controls
--- a/utils/jellyfin/subtitleUtils.test.ts
+++ b/utils/jellyfin/subtitleUtils.test.ts
@@ -0,0 +1,221 @@
+import { describe, expect, test } from "bun:test";
+import type {
+  MediaStream,
+  SubtitleDeliveryMethod,
+} from "@jellyfin/sdk/lib/generated-client";
+import {
+  compareTracksForMenu,
+  isExternalSubtitle,
+  type PlayerSubtitleTrack,
+  resolveSubtitleTrack,
+} from "@/utils/jellyfin/subtitleUtils";
+
+// String-enum values as typed literals — avoids a runtime SDK import (see subtitleUtils.ts).
+const External = "External" as SubtitleDeliveryMethod;
+const Embed = "Embed" as SubtitleDeliveryMethod;
+
+// --- fixtures --------------------------------------------------------------
+
+const sub = (o: Partial<MediaStream> & { Index: number }): MediaStream =>
+  ({ Type: "Subtitle", ...o }) as MediaStream;
+
+const ext = (Index: number, o: Partial<MediaStream> = {}): MediaStream =>
+  sub({
+    Index,
+    DeliveryMethod: External,
+    IsExternal: true,
+    DeliveryUrl: `/sub/${Index}.srt`,
+    ...o,
+  });
+
+const emb = (Index: number, o: Partial<MediaStream> = {}): MediaStream =>
+  sub({ Index, DeliveryMethod: Embed, ...o });
+
+const track = (o: PlayerSubtitleTrack): PlayerSubtitleTrack => o;
+
+// Mirror direct-player.tsx online URL builder.
+const urlBuilder =
+  (base: string) =>
+  (s: MediaStream): string | undefined =>
+    s.DeliveryUrl ? `${base}${s.DeliveryUrl}` : undefined;
+
+const resolve = (
+  streams: MediaStream[],
+  index: number | undefined,
+  player: PlayerSubtitleTrack[],
+  getExpectedExternalUrl = urlBuilder("http://srv"),
+) =>
+  resolveSubtitleTrack({
+    subtitleStreams: streams,
+    jellyfinSubtitleIndex: index,
+    playerTracks: player,
+    getExpectedExternalUrl,
+  });
+
+// --- tests -----------------------------------------------------------------
+
+describe("isExternalSubtitle", () => {
+  test("true for External delivery or the IsExternal flag, not a bare DeliveryUrl", () => {
+    expect(isExternalSubtitle(ext(0))).toBe(true);
+    expect(isExternalSubtitle(sub({ Index: 1, IsExternal: true }))).toBe(true);
+    expect(isExternalSubtitle(emb(2))).toBe(false);
+    // A DeliveryUrl alone (e.g. an Hls-delivered sub) is NOT a sub-added sidecar.
+    expect(isExternalSubtitle(sub({ Index: 3, DeliveryUrl: "/x.srt" }))).toBe(
+      false,
+    );
+  });
+});
+
+describe("resolveSubtitleTrack — disable / notFound", () => {
+  test("index -1 or undefined disables", () => {
+    expect(resolve([], -1, [])).toEqual({ kind: "disable" });
+    expect(resolve([], undefined, [])).toEqual({ kind: "disable" });
+  });
+
+  test("index not present returns notFound", () => {
+    expect(resolve([emb(0)], 99, [track({ id: 1 })])).toEqual({
+      kind: "notFound",
+    });
+  });
+});
+
+describe("resolveSubtitleTrack — hidden embedded (#954)", () => {
+  // Server hides embedded subs: MediaStreams lists only the 3 externals,
+  // but mpv still demuxes the 3 embedded from the file → externals get ids 4,5,6.
+  const streams = [
+    ext(0, { Language: "por" }),
+    ext(1, { Language: "eng" }),
+    ext(2, { Language: "eng", Title: "SDH" }),
+  ];
+  const player = [
+    track({ id: 1, external: false, language: "eng", title: "CC" }),
+    track({ id: 2, external: false, language: "spa" }),
+    track({ id: 3, external: false, language: "fre" }),
+    track({ id: 4, external: true, externalFilename: "http://srv/sub/0.srt" }),
+    track({ id: 5, external: true, externalFilename: "http://srv/sub/1.srt" }),
+    track({ id: 6, external: true, externalFilename: "http://srv/sub/2.srt" }),
+  ];
+
+  test("each external maps to the right player id by filename (not 1,2,3)", () => {
+    expect(resolve(streams, 0, player)).toEqual({ kind: "select", trackId: 4 });
+    expect(resolve(streams, 1, player)).toEqual({ kind: "select", trackId: 5 });
+    expect(resolve(streams, 2, player)).toEqual({ kind: "select", trackId: 6 });
+  });
+
+  test("falls back to external ordinal when filenames are unavailable", () => {
+    const noNames = player.map((t) =>
+      t.external ? { ...t, externalFilename: undefined } : t,
+    );
+    expect(resolve(streams, 1, noNames)).toEqual({
+      kind: "select",
+      trackId: 5,
+    });
+  });
+});
+
+describe("resolveSubtitleTrack — external/embed reversal (non-hidden)", () => {
+  // Jellyfin lists externals first; mpv lists embedded first then externals.
+  const streams = [
+    ext(0, { Language: "eng" }),
+    emb(1, { Language: "spa" }),
+    emb(2, { Language: "fre" }),
+  ];
+  const player = [
+    track({ id: 1, external: false, language: "spa" }),
+    track({ id: 2, external: false, language: "fre" }),
+    track({ id: 3, external: true, externalFilename: "http://srv/sub/0.srt" }),
+  ];
+
+  test("external resolves by filename, embedded by language", () => {
+    expect(resolve(streams, 0, player)).toEqual({ kind: "select", trackId: 3 });
+    expect(resolve(streams, 1, player)).toEqual({ kind: "select", trackId: 1 });
+    expect(resolve(streams, 2, player)).toEqual({ kind: "select", trackId: 2 });
+  });
+});
+
+describe("resolveSubtitleTrack — external without DeliveryUrl (#1763 CodeRabbit)", () => {
+  // Middle external has no DeliveryUrl → never loaded into the player.
+  const streams = [
+    ext(0, { Language: "eng", DeliveryUrl: "/sub/a.srt" }),
+    sub({ Index: 1, DeliveryMethod: External, IsExternal: true }),
+    ext(2, { Language: "fre", DeliveryUrl: "/sub/c.srt" }),
+  ];
+  const player = [
+    track({ id: 4, external: true, externalFilename: "http://srv/sub/a.srt" }),
+    track({ id: 5, external: true, externalFilename: "http://srv/sub/c.srt" }),
+  ];
+
+  test("loaded externals still map correctly despite the gap", () => {
+    expect(resolve(streams, 0, player)).toEqual({ kind: "select", trackId: 4 });
+    expect(resolve(streams, 2, player)).toEqual({ kind: "select", trackId: 5 });
+  });
+
+  test("selecting the unloaded external returns notFound", () => {
+    expect(resolve(streams, 1, player)).toEqual({ kind: "notFound" });
+  });
+});
+
+describe("resolveSubtitleTrack — embedded matching", () => {
+  test("unique language match wins even when player order differs (not positional)", () => {
+    const streams = [emb(0, { Language: "eng" }), emb(1, { Language: "jpn" })];
+    // Player lists them in the OPPOSITE order — a positional map would mis-pick.
+    const player = [
+      track({ id: 1, external: false, language: "jpn" }),
+      track({ id: 2, external: false, language: "eng" }),
+    ];
+    expect(resolve(streams, 0, player)).toEqual({ kind: "select", trackId: 2 }); // eng
+    expect(resolve(streams, 1, player)).toEqual({ kind: "select", trackId: 1 }); // jpn
+  });
+
+  test("same-language tracks with no distinguishing title fall back to ordinal among matches", () => {
+    const streams = [emb(0, { Language: "eng" }), emb(1, { Language: "eng" })];
+    // Both eng, no title → identity can't disambiguate → ordinal among matches.
+    const player = [
+      track({ id: 5, external: false, language: "eng" }),
+      track({ id: 6, external: false, language: "eng" }),
+    ];
+    expect(resolve(streams, 0, player)).toEqual({ kind: "select", trackId: 5 });
+    expect(resolve(streams, 1, player)).toEqual({ kind: "select", trackId: 6 });
+  });
+
+  test("falls back to embedded ordinal when no language/title info", () => {
+    const streams = [emb(0), emb(1)];
+    const player = [
+      track({ id: 1, external: false }),
+      track({ id: 2, external: false }),
+    ];
+    expect(resolve(streams, 1, player)).toEqual({ kind: "select", trackId: 2 });
+  });
+});
+
+describe("compareTracksForMenu — jellyfin-web order", () => {
+  test("externals sort after embedded despite lower Index", () => {
+    const sorted = [
+      ext(0, { Language: "eng" }),
+      emb(7, { Language: "fra" }),
+    ].sort(compareTracksForMenu);
+    expect(sorted.map((s) => s.Index)).toEqual([7, 0]);
+  });
+
+  test("forced then default float to the top within a group", () => {
+    const sorted = [
+      emb(2, { Language: "eng" }),
+      emb(1, { Language: "eng", IsDefault: true }),
+      emb(0, { Language: "eng", IsForced: true }),
+    ].sort(compareTracksForMenu);
+    expect(sorted.map((s) => s.Index)).toEqual([0, 1, 2]);
+  });
+
+  test("full Okiku order: embedded first, externals last by Index", () => {
+    const streams = [
+      ext(0, { Language: "eng" }),
+      ext(1, { Language: "eng" }),
+      ext(2, { Language: "fra" }),
+      ext(3, { Language: "fra" }),
+      emb(7, { Language: "fra", Title: "French" }),
+    ];
+    expect([...streams].sort(compareTracksForMenu).map((s) => s.Index)).toEqual(
+      [7, 0, 1, 2, 3],
+    );
+  });
+});
--- a/utils/jellyfin/subtitleUtils.ts
+++ b/utils/jellyfin/subtitleUtils.ts
@@ -1,91 +1,287 @@
 /**
- * Subtitle utility functions for mapping between Jellyfin and MPV track indices.
+ * Subtitle utilities: resolve a Jellyfin subtitle stream to the right track in
+ * the *player's real track list* by identity — never by positional counting.
 *
- * Jellyfin uses server-side indices (e.g., 3, 4, 5 for subtitles in MediaStreams).
- * MPV uses its own track IDs starting from 1, only counting tracks loaded into MPV.
+ * Why: Jellyfin renumbers MediaStreams (externals first); the player enumerates
+ * embedded-from-container first and externals (`sub-add`) last; and a library that
+ * hides embedded subs drops them from MediaStreams while the player still demuxes
+ * them from the file. Positional Index→id mapping therefore mis-selects (e.g.
+ * picking Spanish shows English). See {@link resolveSubtitleTrack}.
 *
 * Image-based subtitles (PGS, VOBSUB) during transcoding are burned into the video
- * and NOT available in MPV's track list.
+ * and absent from the player's track list.
 */

-import {
-  type MediaSourceInfo,
-  type MediaStream,
+import type {
+  MediaSourceInfo,
+  MediaStream,
  SubtitleDeliveryMethod,
 } from "@jellyfin/sdk/lib/generated-client";

+// "External" is the value of SubtitleDeliveryMethod.External. Compared as a typed
+// literal so this util needs no *runtime* import of the SDK barrel — which pulls in
+// the axios-dependent `/api` modules and breaks unit tests under `bun test`.
+const EXTERNAL_DELIVERY = "External" as SubtitleDeliveryMethod;
+
 /** Check if subtitle is image-based (PGS, VOBSUB, etc.) */
 export const isImageBasedSubtitle = (sub: MediaStream): boolean =>
  sub.IsTextSubtitleStream === false;

 /**
- * Determine if a subtitle will be available in MPV's track list.
+ * A Jellyfin subtitle stream is "external" when the server delivers it as a
+ * sub-added sidecar — i.e. `DeliveryMethod === External` (or the `IsExternal`
+ * flag before a device-specific delivery method is assigned).
 *
- * A subtitle is in MPV if:
- * - Delivery is Embed/Hls/External AND not an image-based sub during transcode
+ * Deliberately NOT keyed on `DeliveryUrl`: an Hls-delivered sub also carries a
+ * `DeliveryUrl` but lives inside the player's track list (not `sub-add`-ed), so
+ * it must resolve through the embedded path. Keeping this in lockstep with the
+ * load sites (which only `sub-add` `DeliveryMethod === External`) and with the
+ * menu comparator below avoids a sub being sorted as embedded yet resolved as
+ * external (→ `notFound`).
 */
-export const isSubtitleInMpv = (
-  sub: MediaStream,
-  isTranscoding: boolean,
-): boolean => {
-  // During transcoding, image-based subs are burned in, not in MPV
-  if (isTranscoding && isImageBasedSubtitle(sub)) {
-    return false;
-  }
+export const isExternalSubtitle = (sub: MediaStream): boolean =>
+  sub.DeliveryMethod === EXTERNAL_DELIVERY || sub.IsExternal === true;

-  // Embed/Hls/External methods mean the sub is loaded into MPV
-  return (
-    sub.DeliveryMethod === SubtitleDeliveryMethod.Embed ||
-    sub.DeliveryMethod === SubtitleDeliveryMethod.Hls ||
-    sub.DeliveryMethod === SubtitleDeliveryMethod.External
-  );
+/**
+ * Order subtitle MediaStreams for the selection menu exactly like jellyfin-web's
+ * `itemHelper.sortTracks`: in-container tracks first then external, and within
+ * each group forced first, then default, then `Index` ascending. Callers prepend
+ * their own "None/Off" entry separately.
+ *
+ * The Jellyfin server inserts external (sidecar) streams at the FRONT of
+ * `MediaStreams` (low indices), so raw Index order shows externals first — this
+ * comparator flips that to match web (externals last). Uses {@link isExternalSubtitle}
+ * (not the raw `IsExternal` flag) so ordering and resolution agree.
+ */
+export const compareTracksForMenu = (a: MediaStream, b: MediaStream): number =>
+  Number(isExternalSubtitle(a)) - Number(isExternalSubtitle(b)) ||
+  Number(b.IsForced ?? false) - Number(a.IsForced ?? false) ||
+  Number(b.IsDefault ?? false) - Number(a.IsDefault ?? false) ||
+  (a.Index ?? 0) - (b.Index ?? 0);
+
+/**
+ * Identity of a subtitle track as reported by the *player's real track list*
+ * (mpv `track-list`, or a Cast media-track list). Player-agnostic on purpose so
+ * the same resolver can drive the mpv player today and the Chromecast backend later.
+ */
+export type PlayerSubtitleTrack = {
+  /** Player-side id used to actually select the track (mpv `sid`, cast trackId). */
+  id: number;
+  /** True if loaded from a separate file (mpv `external`). */
+  external?: boolean;
+  /** For external tracks: the exact URL/path it was loaded from (mpv `external-filename`). */
+  externalFilename?: string;
+  language?: string;
+  title?: string;
+  codec?: string;
+};
+
+export type SubtitleSelection =
+  | { kind: "select"; trackId: number }
+  | { kind: "disable" }
+  | { kind: "notFound" };
+
+/** Decode percent-encoding and strip a leading `file://` scheme for tolerant comparison. */
+const normalizeUrl = (url: string): string => {
+  let u = url;
+  try {
+    u = decodeURIComponent(u);
+  } catch {
+    // not decodable — compare raw
+  }
+  return u.replace(/^file:\/\//, "");
+};
+
+const externalFilenameMatches = (
+  trackFilename: string | undefined,
+  expectedUrl: string | undefined,
+): boolean => {
+  if (!trackFilename || !expectedUrl) return false;
+  const a = normalizeUrl(trackFilename);
+  const b = normalizeUrl(expectedUrl);
+  return a === b || a.endsWith(b) || b.endsWith(a);
+};
+
+const eq = (a?: string | null, b?: string | null): boolean =>
+  !!a && !!b && a.toLowerCase() === b.toLowerCase();
+
+/** Match an embedded player track to a Jellyfin stream by language/title (codec-agnostic). */
+const embeddedIdentityMatches = (
+  track: PlayerSubtitleTrack,
+  stream: MediaStream,
+): boolean => {
+  if (eq(track.language, stream.Language)) {
+    // When both carry a title it must agree; otherwise language alone is enough.
+    if (track.title && stream.Title) return eq(track.title, stream.Title);
+    return true;
+  }
+  // No language on one side — fall back to a title match.
+  if (!track.language || !stream.Language) return eq(track.title, stream.Title);
+  return false;
 };

 /**
- * Calculate the MPV track ID for a given Jellyfin subtitle index.
+ * Resolve the player track id for a given Jellyfin subtitle index by matching
+ * against the player's REAL track list (identity), never by positional counting.
 *
- * MPV track IDs are 1-based and only count subtitles that are actually in MPV.
- * We iterate through all subtitles, counting only those in MPV, until we find
- * the one matching the Jellyfin index.
+ * Why identity, not position: Jellyfin renumbers `MediaStreams` (externals first)
+ * while the player enumerates embedded-from-container first and externals
+ * (`sub-add`) last; and when a library hides embedded subs they vanish from
+ * `MediaStreams` but still physically exist in the file the player demuxes.
+ * Positional Index→id mapping therefore mis-selects (e.g. picking Spanish shows
+ * English — issues #954/#1690/#618/#1467/#976/#1451).
 *
- * @param mediaSource - The media source containing subtitle streams
- * @param jellyfinSubtitleIndex - The Jellyfin server-side subtitle index (-1 = disabled)
- * @param isTranscoding - Whether the stream is being transcoded
- * @returns MPV track ID (1-based), or -1 if disabled, or undefined if not in MPV
+ * Strategy:
+ *  - disabled (-1/undefined) → `disable`
+ *  - external Jellyfin sub → match the player track by `externalFilename`
+ *    (exact identity, immune to hidden-embedded shifts); fall back to the
+ *    ordinal among *loadable* externals (Swiftfin: externals are the list tail).
+ *  - embedded Jellyfin sub → match by language/title among non-external tracks;
+ *    fall back to the embedded ordinal (container order aligns on both sides).
+ *
+ * Player-agnostic: pass any player's track list + a URL builder, so the mpv
+ * player and (later) the Chromecast backend share one source of truth.
 */
-export const getMpvSubtitleId = (
-  mediaSource: MediaSourceInfo | null | undefined,
-  jellyfinSubtitleIndex: number | undefined,
-  isTranscoding: boolean,
-): number | undefined => {
-  // -1 or undefined means disabled
+export const resolveSubtitleTrack = (params: {
+  subtitleStreams: MediaStream[] | undefined;
+  jellyfinSubtitleIndex: number | undefined;
+  playerTracks: PlayerSubtitleTrack[];
+  /** Build the exact URL/path an external Jellyfin sub was loaded into the player with. */
+  getExpectedExternalUrl?: (sub: MediaStream) => string | undefined;
+}): SubtitleSelection => {
+  const { jellyfinSubtitleIndex, playerTracks, getExpectedExternalUrl } =
+    params;
+  const subtitleStreams = params.subtitleStreams ?? [];
+
  if (jellyfinSubtitleIndex === undefined || jellyfinSubtitleIndex === -1) {
-    return -1;
+    return { kind: "disable" };
  }

-  const allSubs =
-    mediaSource?.MediaStreams?.filter((s) => s.Type === "Subtitle") || [];
+  const target = subtitleStreams.find((s) => s.Index === jellyfinSubtitleIndex);
+  if (!target) return { kind: "notFound" };

-  // Find the subtitle with the matching Jellyfin index
-  const targetSub = allSubs.find((s) => s.Index === jellyfinSubtitleIndex);
+  if (isExternalSubtitle(target)) {
+    const playerExternals = playerTracks.filter((t) => t.external === true);

-  // If the target subtitle isn't in MPV (e.g., image-based during transcode), return undefined
-  if (!targetSub || !isSubtitleInMpv(targetSub, isTranscoding)) {
-    return undefined;
-  }
+    // 1) Exact identity by external filename — robust against hidden-embedded offset.
+    const expectedUrl = getExpectedExternalUrl?.(target);
+    const byName = playerExternals.find((t) =>
+      externalFilenameMatches(t.externalFilename, expectedUrl),
+    );
+    if (byName) return { kind: "select", trackId: byName.id };

-  // Count MPV track position (1-based)
-  let mpvIndex = 0;
-  for (const sub of allSubs) {
-    if (isSubtitleInMpv(sub, isTranscoding)) {
-      mpvIndex++;
-      if (sub.Index === jellyfinSubtitleIndex) {
-        return mpvIndex;
-      }
+    // 2) Fallback: externals are appended in MediaStreams order → ordinal among
+    //    *loadable* externals (those actually added to the player) stays in lockstep
+    //    with the player's external list, skipping ones with no DeliveryUrl (#1763).
+    const externalStreams = subtitleStreams.filter(isExternalSubtitle);
+    const loadableExternals = getExpectedExternalUrl
+      ? externalStreams.filter((s) => getExpectedExternalUrl(s))
+      : externalStreams;
+    const ordinal = loadableExternals.findIndex(
+      (s) => s.Index === jellyfinSubtitleIndex,
+    );
+    if (ordinal >= 0 && ordinal < playerExternals.length) {
+      return { kind: "select", trackId: playerExternals[ordinal].id };
    }
+    return { kind: "notFound" };
  }

-  return undefined;
+  // Embedded / in-container subtitle.
+  const embeddedStreams = subtitleStreams.filter((s) => !isExternalSubtitle(s));
+  const playerEmbedded = playerTracks.filter((t) => t.external !== true);
+
+  // 1) Identity by language/title (unique match wins).
+  const identityMatches = playerEmbedded.filter((t) =>
+    embeddedIdentityMatches(t, target),
+  );
+  if (identityMatches.length === 1) {
+    return { kind: "select", trackId: identityMatches[0].id };
+  }
+
+  // 2) Fallback: embedded order is container order on both sides → ordinal.
+  const ordinal = embeddedStreams.findIndex(
+    (s) => s.Index === jellyfinSubtitleIndex,
+  );
+  if (identityMatches.length > 1 && ordinal >= 0) {
+    // Multiple same-language tracks: pick by position among the matches.
+    const idx = Math.min(ordinal, identityMatches.length - 1);
+    return { kind: "select", trackId: identityMatches[idx].id };
+  }
+  if (ordinal >= 0 && ordinal < playerEmbedded.length) {
+    return { kind: "select", trackId: playerEmbedded[ordinal].id };
+  }
+  return { kind: "notFound" };
+};
+
+/**
+ * A subtitle track as reported by a concrete player's track-list API
+ * (mpv `getSubtitleTracks`, or a Cast track list). `lang` mirrors mpv's field name.
+ */
+export type PlayerSubtitleTrackRaw = {
+  id: number;
+  lang?: string;
+  title?: string;
+  codec?: string;
+  external?: boolean;
+  externalFilename?: string;
+};
+
+/**
+ * Minimal player surface needed to select a subtitle. Satisfied structurally by
+ * the mpv player ref and (later) implementable by the Chromecast backend.
+ */
+export interface SubtitleSelectablePlayer {
+  getSubtitleTracks: () => Promise<PlayerSubtitleTrackRaw[] | null | undefined>;
+  setSubtitleTrack: (trackId: number) => unknown;
+  disableSubtitles: () => unknown;
+}
+
+/**
+ * Read the player's real track list, resolve the Jellyfin subtitle index by
+ * identity ({@link resolveSubtitleTrack}) and apply the result. Single entry point
+ * for both the mobile controls and the player screen, so selection stays
+ * consistent everywhere. Returns the resolution for callers that want to react.
+ */
+export const applyMpvSubtitleSelection = async (
+  player: SubtitleSelectablePlayer | null | undefined,
+  params: {
+    subtitleStreams: MediaStream[] | undefined;
+    jellyfinSubtitleIndex: number;
+    /** Build the exact URL/path an external sub was loaded into the player with. */
+    getExpectedExternalUrl?: (sub: MediaStream) => string | undefined;
+  },
+): Promise<SubtitleSelection> => {
+  if (!player) return { kind: "notFound" };
+
+  // Called fire-and-forget (`void applyMpvSubtitleSelection(...)`), so any native
+  // rejection from getSubtitleTracks/setSubtitleTrack/disableSubtitles must be
+  // swallowed here instead of escaping as an unhandled promise rejection.
+  try {
+    const tracks = (await player.getSubtitleTracks()) ?? [];
+    const selection = resolveSubtitleTrack({
+      subtitleStreams: params.subtitleStreams,
+      jellyfinSubtitleIndex: params.jellyfinSubtitleIndex,
+      playerTracks: tracks.map((t) => ({
+        id: t.id,
+        external: t.external,
+        externalFilename: t.externalFilename,
+        language: t.lang,
+        title: t.title,
+        codec: t.codec,
+      })),
+      getExpectedExternalUrl: params.getExpectedExternalUrl,
+    });
+
+    if (selection.kind === "select") {
+      await player.setSubtitleTrack(selection.trackId);
+    } else if (selection.kind === "disable") {
+      await player.disableSubtitles();
+    }
+    // notFound → leave current selection (e.g. image subs burned in while transcoding)
+    return selection;
+  } catch {
+    return { kind: "notFound" };
+  }
 };

 /**
--- a/utils/profiles/download.ts
+++ b/utils/profiles/download.ts
@@ -3,17 +3,17 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
-import { generateDeviceProfile } from "./native";
-
-/**
- * @typedef {"auto" | "stereo" | "5.1" | "passthrough"} AudioTranscodeModeType
- */
+import type {
+  DeviceProfile,
+  SubtitleProfile,
+} from "@jellyfin/sdk/lib/generated-client/models";
+import { type AudioTranscodeModeType, generateDeviceProfile } from "./native";

 /**
 * Download-specific subtitle profiles.
 * These are more permissive than streaming profiles since we can embed subtitles.
 */
-const downloadSubtitleProfiles = [
+const downloadSubtitleProfiles: SubtitleProfile[] = [
  // Official formats
  { Format: "vtt", Method: "Encode" },
  { Format: "webvtt", Method: "Encode" },
@@ -46,11 +46,10 @@ const downloadSubtitleProfiles = [
 /**
 * Generates a device profile optimized for downloads.
 * Uses the same audio codec logic as streaming but with download-specific bitrate limits.
- *
- * @param {AudioTranscodeModeType} [audioMode="auto"] - Audio transcoding mode
- * @returns {Object} Jellyfin device profile for downloads
 */
-export const generateDownloadProfile = (audioMode = "auto") => {
+export const generateDownloadProfile = (
+  audioMode: AudioTranscodeModeType = "auto",
+): DeviceProfile => {
  // Get the base profile with proper audio codec configuration
  const baseProfile = generateDeviceProfile({ audioMode });

--- a/utils/profiles/native.ts
+++ b/utils/profiles/native.ts
@@ -3,6 +3,7 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
+import type { DeviceProfile } from "@jellyfin/sdk/lib/generated-client/models";
 import { Platform } from "react-native";
 import MediaTypes from "../../constants/MediaTypes";
 import { getSubtitleProfiles } from "./subtitles";
@@ -193,7 +194,7 @@ export const generateDeviceProfile = (options: ProfileOptions = {}) => {
      },
    ],
    SubtitleProfiles: getSubtitleProfiles(),
-  };
+  } satisfies DeviceProfile;

  return profile;
 };
--- a/utils/profiles/subtitles.ts
+++ b/utils/profiles/subtitles.ts
@@ -3,6 +3,7 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
+import type { SubtitleProfile } from "@jellyfin/sdk/lib/generated-client/models";

 // Image-based formats - these need to be burned in by Jellyfin (Encode method)
 // because MPV cannot load them externally over HTTP
@@ -13,7 +14,7 @@ const IMAGE_BASED_FORMATS = [
  "pgssub",
  "teletext",
  "vobsub",
-];
+] as const;

 // Text-based formats - these can be loaded externally by MPV
 const TEXT_BASED_FORMATS = [
@@ -37,10 +38,10 @@ const TEXT_BASED_FORMATS = [
  "text",
  "vplayer",
  "xsub",
-];
+] as const;

-export const getSubtitleProfiles = () => {
-  const profiles = [];
+export const getSubtitleProfiles = (): SubtitleProfile[] => {
+  const profiles: SubtitleProfile[] = [];

  // Image-based formats: Embed or Encode (burn-in), NOT External
  for (const format of IMAGE_BASED_FORMATS) {
@@ -58,4 +59,4 @@ export const getSubtitleProfiles = () => {
 };

 // Export for use in player filtering
-export const IMAGE_SUBTITLE_CODECS = IMAGE_BASED_FORMATS;
+export const IMAGE_SUBTITLE_CODECS: readonly string[] = IMAGE_BASED_FORMATS;
--- a/utils/profiles/trackplayer.d.ts
+++ b/utils/profiles/trackplayer.d.ts
@@ -1,19 +0,0 @@
-/**
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- */
-
-export type PlatformType = "ios" | "android";
-
-export interface TrackPlayerProfileOptions {
-  /** Target platform */
-  platform?: PlatformType;
-}
-
-export function generateTrackPlayerProfile(
-  options?: TrackPlayerProfileOptions,
-): any;
-
-declare const _default: any;
-export default _default;
--- a/utils/profiles/trackplayer.ts
+++ b/utils/profiles/trackplayer.ts
@@ -3,23 +3,25 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
+import type {
+  CodecProfile,
+  DeviceProfile,
+  DirectPlayProfile,
+} from "@jellyfin/sdk/lib/generated-client/models";
 import { Platform } from "react-native";
 import MediaTypes from "../../constants/MediaTypes";
+import type { PlatformType } from "./native";

-/**
- * @typedef {"ios" | "android"} PlatformType
- *
- * @typedef {Object} TrackPlayerProfileOptions
- * @property {PlatformType} [platform] - Target platform
- */
+export interface TrackPlayerProfileOptions {
+  /** Target platform */
+  platform?: PlatformType;
+}

 /**
 * Audio direct play profiles for react-native-track-player.
 * iOS uses AVPlayer, Android uses ExoPlayer - each has different codec support.
- *
- * @param {PlatformType} platform
 */
-const getDirectPlayProfile = (platform) => {
+const getDirectPlayProfile = (platform: PlatformType): DirectPlayProfile => {
  if (platform === "ios") {
    // iOS AVPlayer supported formats
    return {
@@ -39,10 +41,8 @@ const getDirectPlayProfile = (platform) => {

 /**
 * Audio codec profiles for react-native-track-player.
- *
- * @param {PlatformType} platform
 */
-const getCodecProfile = (platform) => {
+const getCodecProfile = (platform: PlatformType): CodecProfile => {
  if (platform === "ios") {
    // iOS AVPlayer codec constraints
    return {
@@ -64,12 +64,11 @@ const getCodecProfile = (platform) => {
 * This profile is specifically for standalone audio playback using:
 * - AVPlayer on iOS
 * - ExoPlayer on Android
- *
- * @param {TrackPlayerProfileOptions} [options] - Profile configuration options
- * @returns {Object} Jellyfin device profile for track player
 */
-export const generateTrackPlayerProfile = (options = {}) => {
-  const platform = options.platform || Platform.OS;
+export const generateTrackPlayerProfile = (
+  options: TrackPlayerProfileOptions = {},
+): DeviceProfile => {
+  const platform = (options.platform || Platform.OS) as PlatformType;

  return {
    Name: "Track Player",
Author	SHA1	Message	Date
Gauvain	a58a4da4f3	fix(subtitles): guard track-list effect against stale async runs The track-building effect in VideoContext reruns once api?.basePath and isCurrentSubImageBased settle. An earlier async run could resolve after a rerun and overwrite subtitleTracks/audioTracks with setTrack callbacks bound to a stale `api`, breaking external-subtitle identity matching. Add a cancellation token and route every state commit through guarded committers so all six commit points (offline-transcoded audio/subs, burned-in, and the online audio/subs paths) drop writes from a dead run, plus bail out right after the awaited getAudioTracks when cancelled.	2026-06-30 01:56:58 +02:00
Gauvain	c02baf2831	fix(subtitles): rebuild track callbacks when isCurrentSubImageBased changes The setTrack/Disable callbacks close over isCurrentSubImageBased for the transcode replacePlayer decision; add it to the track-building effect deps so they rebuild when it flips (otherwise, in a transcoding session, callbacks could stay on the MPV path after switching to/from a burned-in image sub and the player would not refresh). Addresses CodeRabbit.	2026-06-30 01:41:21 +02:00
Gauvain	3848877021	fix(subtitles): only show the burned-in entry for image subs in offline transcoded When an image subtitle was burned into a transcoded download it lives in the video pixels and can't be disabled or swapped. Show only that '(burned in)' entry instead of advertising Disable/text controls whose handlers can't affect it (which would let the UI show a different selection than what's on screen). Addresses CodeRabbit.	2026-06-30 01:32:43 +02:00
Gauvain	1f54ccc52c	fix(subtitles): rebuild VideoContext track callbacks when api.basePath changes The setTrack callbacks build external-sub URLs from api?.basePath; add it to the track-building effect deps so the list rebuilds once the API is ready (otherwise online externals could resolve with undefined → notFound). Addresses CodeRabbit.	2026-06-30 01:19:18 +02:00
Gauvain	08efa1b0f7	Merge branch 'develop' into fix/subtitle-track-selection	2026-06-30 01:10:59 +02:00
Gauvain	90ea934548	fix(subtitles): address CodeRabbit review - Unify external detection: isExternalSubtitle drops the bare-DeliveryUrl case (an Hls-delivered sub has a DeliveryUrl but isn't sub-add-ed) so sorting, loading and resolution agree; compareTracksForMenu now uses it. - applyMpvSubtitleSelection wraps player calls in try/catch — fire-and-forget call sites no longer risk unhandled rejections. - VideoContext offline-transcoded branch: treat missing IsTextSubtitleStream as text (use !isImageBasedSubtitle), matching the shared helper. - ItemContent.tv refreshSubtitleTracks: apply compareTracksForMenu like the initial list. - Tests: use the @/ alias; rework the embedded cases to actually exercise identity (reversed player order) and the ordinal fallback (same-language, no title).	2026-06-30 01:08:50 +02:00
Gauvain	1c158dea4e	fix(subtitles): order detail-page & TV subtitle menus like jellyfin-web The detail-page selector (MediaSourceButton, the #1176 replacement for TrackSheet) and the TV detail/refresh paths (ItemContent.tv, Controls.tv refreshSubtitleTracks) still listed subtitles in raw MediaStreams order (externals first). Apply compareTracksForMenu there too so every menu matches web. The in-player TV modal was already covered (fed from the sorted VideoContext tracks).	2026-06-30 00:39:29 +02:00
Gauvain	9a7b9c9de2	fix(subtitles): select subtitles by identity across all player paths direct-player resolves the selection on onTracksReady (online + offline, init + runtime), VideoContext does the same for the mobile menu (incl. offline-transcoded), and the menus (SubtitleTrackSelector, VideoContext, TVSubtitleSheet) now order tracks like jellyfin-web. Fixes wrong-subtitle/wrong-language selection. Fixes #954	2026-06-30 00:11:45 +02:00
Gauvain	ceeacda7f9	feat(subtitles): identity-based track resolver + jellyfin-web menu order resolveSubtitleTrack matches a Jellyfin subtitle against the player's real track list (external by external-filename, embedded by language/title) instead of positional counting, which mis-selects when externals/embedded are reordered or the server hides embedded subs. applyMpvSubtitleSelection is the shared entry point (reusable for the cast backend). compareTracksForMenu mirrors web's itemHelper.sortTracks. Drops dead getMpvSubtitleId/isSubtitleInMpv. 14 unit tests.	2026-06-30 00:11:12 +02:00
Gauvain	b8780f34ec	feat(mpv): expose external/external-filename/ff-index/codec on subtitle track-list These identity fields let the JS layer map a Jellyfin subtitle to the real MPV track instead of guessing a positional sid.	2026-06-30 00:10:57 +02:00
Gauvain	97b6a912e0	refactor: migrate JS/MJS sources and scripts to TypeScript (#1717 ) Some checks are pending 🏗️ Build Apps / 🤖 Build Android APK (Phone) (push) Waiting to run Details 🏗️ Build Apps / 🤖 Build Android APK (TV) (push) Waiting to run Details 🏗️ Build Apps / 🍎 Build iOS IPA (Phone) (push) Waiting to run Details 🏗️ Build Apps / 🍎 Build iOS IPA (Phone - Unsigned) (push) Waiting to run Details 🏗️ Build Apps / 🍎 Build tvOS IPA (push) Waiting to run Details 🏗️ Build Apps / 🍎 Build tvOS IPA (Unsigned) (push) Waiting to run Details 🔒 Lockfile Consistency Check / 🔍 Check bun.lock and package.json consistency (push) Waiting to run Details 🛡️ CodeQL Analysis / 🔎 Analyze with CodeQL (actions) (push) Waiting to run Details 🛡️ CodeQL Analysis / 🔎 Analyze with CodeQL (javascript-typescript) (push) Waiting to run Details 🏷️🔀Merge Conflict Labeler / 🏷️ Labeling Merge Conflicts (push) Waiting to run Details 🚦 Security & Quality Gate / 📝 Validate PR Title (push) Waiting to run Details 🚦 Security & Quality Gate / 🔍 Vulnerable Dependencies (push) Waiting to run Details 🚦 Security & Quality Gate / 🚑 Expo Doctor Check (push) Waiting to run Details 🚦 Security & Quality Gate / 🔍 Lint & Test (check) (push) Waiting to run Details 🚦 Security & Quality Gate / 🔍 Lint & Test (format) (push) Waiting to run Details 🚦 Security & Quality Gate / 🔍 Lint & Test (i18n:check) (push) Waiting to run Details 🚦 Security & Quality Gate / 🔍 Lint & Test (lint) (push) Waiting to run Details 🚦 Security & Quality Gate / 🔍 Lint & Test (typecheck) (push) Waiting to run Details 🛡️ Trivy Security Scan / 🔎 Filesystem scan (push) Waiting to run Details	2026-06-29 19:48:32 +02:00
lance chant	cc0007926d	fix: fixing some performance issues and mpv upgrade (#1765 ) Some checks failed 🏗️ Build Apps / 🤖 Build Android APK (Phone) (push) Has been cancelled Details 🏗️ Build Apps / 🤖 Build Android APK (TV) (push) Has been cancelled Details 🏗️ Build Apps / 🍎 Build iOS IPA (Phone) (push) Has been cancelled Details 🏗️ Build Apps / 🍎 Build iOS IPA (Phone - Unsigned) (push) Has been cancelled Details 🏗️ Build Apps / 🍎 Build tvOS IPA (push) Has been cancelled Details 🏗️ Build Apps / 🍎 Build tvOS IPA (Unsigned) (push) Has been cancelled Details 🔒 Lockfile Consistency Check / 🔍 Check bun.lock and package.json consistency (push) Has been cancelled Details 🛡️ CodeQL Analysis / 🔎 Analyze with CodeQL (actions) (push) Has been cancelled Details 🛡️ CodeQL Analysis / 🔎 Analyze with CodeQL (javascript-typescript) (push) Has been cancelled Details 🛡️ Trivy Security Scan / 🔎 Filesystem scan (push) Has been cancelled Details 🏷️🔀Merge Conflict Labeler / 🏷️ Labeling Merge Conflicts (push) Has been cancelled Details 🚦 Security & Quality Gate / 📝 Validate PR Title (push) Has been cancelled Details 🚦 Security & Quality Gate / 🔍 Vulnerable Dependencies (push) Has been cancelled Details 🚦 Security & Quality Gate / 🚑 Expo Doctor Check (push) Has been cancelled Details 🚦 Security & Quality Gate / 🔍 Lint & Test (typecheck) (push) Has been cancelled Details 🚦 Security & Quality Gate / 🔍 Lint & Test (check) (push) Has been cancelled Details 🚦 Security & Quality Gate / 🔍 Lint & Test (format) (push) Has been cancelled Details 🚦 Security & Quality Gate / 🔍 Lint & Test (i18n:check) (push) Has been cancelled Details 🚦 Security & Quality Gate / 🔍 Lint & Test (lint) (push) Has been cancelled Details 🌐 Translation Sync / sync-translations (push) Has been cancelled Details Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> Co-authored-by: Gauvain <contact@uruk.dev> Signed-off-by: Lance Chant <13349722+lancechant@users.noreply.github.com>	2026-06-28 17:35:00 +02:00