chore: bump version to 2.6.0

close #1262

.clang-format

@@ -0,0 +1,9 @@
+BasedOnStyle: Google
+AlignAfterOpenBracket: AlwaysBreak
+ColumnLimit: 120
+IndentWidth: 2
+ContinuationIndentWidth: 4
+DerivePointerAlignment: false
+LineEnding: LF
+PointerAlignment: Left
+SortIncludes: true

.dockerignore

@@ -1,19 +0,0 @@
-.git
-build/
-.dart_tool/
-.idea/
-*.tar.gz
-nul
-libmpv-prefix/
-steamfiles/
-pubspec_overrides.yaml
-
-# Flutter ephemeral / generated plugin symlinks
-linux/flutter/ephemeral/
-windows/flutter/
-macos/Flutter/
-ios/Flutter/
-android/.gradle/
-android/app/build/
-.flutter-plugins
-.flutter-plugins-dependencies

.editorconfig

@@ -0,0 +1,28 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.{c,cc,cpp,h,hpp,m,mm}]
+indent_style = space
+indent_size = 2
+
+[*.dart]
+indent_style = space
+indent_size = 2
+
+[*.{kt,kts,java}]
+indent_style = space
+indent_size = 2
+ij_kotlin_code_style_defaults = KOTLIN_OFFICIAL
+ktlint_code_style = android_studio
+ktlint_standard_max-line-length = disabled
+ktlint_standard_no-wildcard-imports = disabled
+ktlint_standard_property-naming = disabled
+
+[*.swift]
+indent_style = space
+indent_size = 2

.githooks/pre-commit

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+set -uo pipefail
+
+if [ "${SKIP_HOOKS:-}" = "1" ]; then
+  echo "[pre-commit] skipped (SKIP_HOOKS=1)"
+  exit 0
+fi
+
+GIT_DIR="$(git rev-parse --git-dir)"
+if [ -f "$GIT_DIR/MERGE_MSG" ] || [ -f "$GIT_DIR/MERGE_HEAD" ] || [ -f "$GIT_DIR/REVERT_HEAD" ]; then
+  echo "[pre-commit] skipped (merge/revert in progress)"
+  exit 0
+fi
+
+if git diff --cached --quiet; then
+  echo "[pre-commit] nothing staged — skipping checks"
+  exit 0
+fi
+
+ROOT="$(git rev-parse --show-toplevel)"
+exec "$ROOT/scripts/ci_checks.sh"

.github/FUNDING.yml

@@ -1 +1,2 @@
 github: edde746
+liberapay: edde746

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -68,16 +68,31 @@ body:
         - Windows
         - macOS
         - Android TV
+        - tvOS
         - Linux
     validations:
       required: true
 
+  - type: dropdown
+    id: media-server
+    attributes:
+      label: Media Server
+      description: Are you using Jellyfin or Plex?
+      multiple: true
+      options:
+        - Jellyfin
+        - Plex
+    validations:
+      required: true
+
   - type: input
     id: device
     attributes:
       label: Device Information
       description: What device are you using?
       placeholder: e.g., iPhone 14 Pro, Pixel 7, Chrome on macOS
+    validations:
+      required: true
 
   - type: textarea
     id: logs

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -41,6 +41,8 @@ body:
         1. As a user, I would...
         2. This would help me...
         3. The benefit would be...
+    validations:
+      required: true
 
   - type: dropdown
     id: platform
@@ -54,8 +56,23 @@ body:
         - Windows
         - macOS
         - Android TV
+        - tvOS
         - Linux
         - All platforms
+    validations:
+      required: true
+
+  - type: dropdown
+    id: media-server
+    attributes:
+      label: Media Server
+      description: Which media server(s) is this for?
+      multiple: true
+      options:
+        - Jellyfin
+        - Plex
+    validations:
+      required: true
 
   - type: textarea
     id: additional

.github/workflows/build.yml

@@ -2,13 +2,45 @@ name: Build
 
 on:
   workflow_dispatch:
+    inputs:
+      build_android:
+        description: Build Android
+        default: true
+        type: boolean
+      build_ios:
+        description: Build iOS
+        default: true
+        type: boolean
+      build_macos:
+        description: Build macOS
+        default: true
+        type: boolean
+      build_windows:
+        description: Build Windows
+        default: true
+        type: boolean
+      build_linux:
+        description: Build Linux
+        default: true
+        type: boolean
 
 env:
   SENTRY_DART_DEFINE: ${{ github.repository == 'edde746/plezy' && '--dart-define=ENABLE_SENTRY=true' || '' }}
   GIT_COMMIT_DART_DEFINE: --dart-define=GIT_COMMIT=${{ github.sha }}
+  SENTRY_ENV_DART_DEFINE: --dart-define=SENTRY_ENVIRONMENT=github
+  DONATIONS_DART_DEFINE: --dart-define=ENABLE_DONATIONS=true
+  LINUX_APT_PACKAGES: >
+    clang cmake meson ninja-build pkg-config nasm libgtk-3-dev libevdev-dev liblzma-dev
+    libstdc++-12-dev libasound2-dev libass-dev libfreetype-dev libfontconfig-dev libfribidi-dev
+    libharfbuzz-dev libepoxy-dev libegl-dev libgl-dev libgnutls28-dev libpipewire-0.3-dev
+    libva-dev libvdpau-dev libx11-dev libxext-dev libxrandr-dev libxcursor-dev libxi-dev
+    libxss-dev libxpresent-dev libxkbcommon-dev libpulse-dev libdbus-1-dev libdrm-dev
+    libgbm-dev libwayland-dev wayland-protocols liblcms2-dev libmujs-dev liblua5.2-dev
+    ruby ruby-dev rubygems build-essential rpm libarchive-tools imagemagick libcurl4-openssl-dev
 
 jobs:
   build-android:
+    if: ${{ inputs.build_android }}
     runs-on: ubuntu-latest
     permissions:
       id-token: write
@@ -27,16 +59,16 @@ jobs:
         uses: subosito/flutter-action@v2
         with:
           channel: "stable"
+          flutter-version: "3.44.0"
           cache: true
+          pub-cache: false
 
       - name: Cache Pub dependencies
         uses: actions/cache@v4
         with:
           path: |
             ~/.pub-cache
-          key: ${{ runner.os }}-pub-${{ hashFiles('**/pubspec.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-pub-
+          key: ${{ runner.os }}-${{ runner.arch }}-pub-v2-${{ hashFiles('pubspec.yaml', 'pubspec.lock') }}
 
       - name: Cache Gradle
         uses: actions/cache@v4
@@ -49,7 +81,7 @@ jobs:
             ${{ runner.os }}-gradle-
 
       - name: Install dependencies
-        run: flutter pub get
+        run: flutter pub get --enforce-lockfile --no-example
 
       - name: Configure Android signing
         run: |
@@ -62,7 +94,14 @@ jobs:
           EOF
 
       - name: Build APKs
-        run: flutter build apk --release --split-per-abi --dart-define=ENABLE_UPDATE_CHECK=true ${{ env.SENTRY_DART_DEFINE }} ${{ env.GIT_COMMIT_DART_DEFINE }}
+        run: flutter build apk --release --split-per-abi --dart-define=ENABLE_UPDATE_CHECK=true ${{ env.SENTRY_DART_DEFINE }} ${{ env.GIT_COMMIT_DART_DEFINE }} ${{ env.SENTRY_ENV_DART_DEFINE }} --dart-define=SENTRY_DIST=github-android-apk ${{ env.DONATIONS_DART_DEFINE }} --obfuscate --split-debug-info=debug-info/android-apk --extra-gen-snapshot-options=--save-obfuscation-map=debug-info/android-apk/obfuscation.map.json
+
+      - name: Upload symbols to bugs.plezy.app
+        if: github.repository == 'edde746/plezy'
+        env:
+          BUGS_ADMIN_TOKEN: ${{ secrets.BUGS_ADMIN_TOKEN }}
+          SENTRY_DIST: github-android-apk
+        run: ./scripts/upload-symbols.sh android-apk
 
       - name: Clean up keystore
         if: always()
@@ -92,6 +131,7 @@ jobs:
             plezy-android-x86_64.tar.gz
 
   build-ios:
+    if: ${{ inputs.build_ios }}
     runs-on: macos-26
     permissions:
       id-token: write
@@ -104,16 +144,16 @@ jobs:
         uses: subosito/flutter-action@v2
         with:
           channel: "stable"
+          flutter-version: "3.44.0"
           cache: true
+          pub-cache: false
 
       - name: Cache Pub dependencies
         uses: actions/cache@v4
         with:
           path: |
             ~/.pub-cache
-          key: ${{ runner.os }}-pub-${{ hashFiles('**/pubspec.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-pub-
+          key: ${{ runner.os }}-${{ runner.arch }}-pub-v2-${{ hashFiles('pubspec.yaml', 'pubspec.lock') }}
 
       - name: Cache CocoaPods
         uses: actions/cache@v4
@@ -127,10 +167,17 @@ jobs:
             ${{ runner.os }}-pods-
 
       - name: Install dependencies
-        run: flutter pub get
+        run: flutter pub get --enforce-lockfile --no-example
 
       - name: Build iOS (no codesign)
-        run: flutter build ios --release --no-codesign --dart-define=ENABLE_UPDATE_CHECK=true ${{ env.SENTRY_DART_DEFINE }} ${{ env.GIT_COMMIT_DART_DEFINE }}
+        run: flutter build ios --release --no-codesign --dart-define=ENABLE_UPDATE_CHECK=true ${{ env.SENTRY_DART_DEFINE }} ${{ env.GIT_COMMIT_DART_DEFINE }} ${{ env.SENTRY_ENV_DART_DEFINE }} --dart-define=SENTRY_DIST=github-ios ${{ env.DONATIONS_DART_DEFINE }} --split-debug-info=debug-info/ios
+
+      - name: Upload symbols to bugs.plezy.app
+        if: github.repository == 'edde746/plezy'
+        env:
+          BUGS_ADMIN_TOKEN: ${{ secrets.BUGS_ADMIN_TOKEN }}
+          SENTRY_DIST: github-ios
+        run: ./scripts/upload-symbols.sh ios
 
       - name: Create IPA
         run: |
@@ -150,6 +197,7 @@ jobs:
           path: plezy-ios.ipa
 
   build-macos:
+    if: ${{ inputs.build_macos }}
     runs-on: macos-26
     permissions:
       id-token: write
@@ -162,16 +210,16 @@ jobs:
         uses: subosito/flutter-action@v2
         with:
           channel: "stable"
+          flutter-version: "3.44.0"
           cache: true
+          pub-cache: false
 
       - name: Cache Pub dependencies
         uses: actions/cache@v4
         with:
           path: |
             ~/.pub-cache
-          key: ${{ runner.os }}-pub-${{ hashFiles('**/pubspec.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-pub-
+          key: ${{ runner.os }}-${{ runner.arch }}-pub-v2-${{ hashFiles('pubspec.yaml', 'pubspec.lock') }}
 
       - name: Cache CocoaPods
         uses: actions/cache@v4
@@ -185,10 +233,17 @@ jobs:
             ${{ runner.os }}-macos-pods-
 
       - name: Install dependencies
-        run: flutter pub get
+        run: flutter pub get --enforce-lockfile --no-example
 
       - name: Build macOS
-        run: flutter build macos --release --dart-define=ENABLE_UPDATE_CHECK=true ${{ env.SENTRY_DART_DEFINE }} ${{ env.GIT_COMMIT_DART_DEFINE }}
+        run: flutter build macos --release --dart-define=ENABLE_UPDATE_CHECK=true ${{ env.SENTRY_DART_DEFINE }} ${{ env.GIT_COMMIT_DART_DEFINE }} ${{ env.SENTRY_ENV_DART_DEFINE }} --dart-define=SENTRY_DIST=github-macos ${{ env.DONATIONS_DART_DEFINE }} --split-debug-info=debug-info/macos
+
+      - name: Upload symbols to bugs.plezy.app
+        if: github.repository == 'edde746/plezy'
+        env:
+          BUGS_ADMIN_TOKEN: ${{ secrets.BUGS_ADMIN_TOKEN }}
+          SENTRY_DIST: github-macos
+        run: ./scripts/upload-symbols.sh macos
 
       - name: Import Code Signing Certificate
         env:
@@ -244,6 +299,11 @@ jobs:
           APP_PATH="build/macos/Build/Products/Release/Plezy.app"
           echo "Verifying signature..."
           codesign -dvvv "$APP_PATH"
+          echo "Verifying signed entitlements..."
+          codesign -d --entitlements :- "$APP_PATH" > "$RUNNER_TEMP/macos-entitlements.plist"
+          /usr/libexec/PlistBuddy -c "Print" "$RUNNER_TEMP/macos-entitlements.plist"
+          /usr/libexec/PlistBuddy -c "Print :com.apple.security.cs.allow-jit" "$RUNNER_TEMP/macos-entitlements.plist"
+          /usr/libexec/PlistBuddy -c "Print :com.apple.security.cs.allow-unsigned-executable-memory" "$RUNNER_TEMP/macos-entitlements.plist"
           codesign --verify --deep --strict --verbose=2 "$APP_PATH"
 
       - name: Notarize Application
@@ -314,6 +374,7 @@ jobs:
             macos-dmg-size.txt
 
   build-windows-x64:
+    if: ${{ inputs.build_windows }}
     runs-on: windows-latest
     permissions:
       contents: read
@@ -324,22 +385,36 @@ jobs:
         uses: subosito/flutter-action@v2
         with:
           channel: "stable"
+          flutter-version: "3.44.0"
           cache: true
+          pub-cache: false
 
       - name: Cache Pub dependencies
         uses: actions/cache@v4
         with:
           path: |
             ~\AppData\Local\Pub\Cache
-          key: ${{ runner.os }}-pub-${{ hashFiles('**/pubspec.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-pub-
+          key: ${{ runner.os }}-${{ runner.arch }}-pub-v2-${{ hashFiles('pubspec.yaml', 'pubspec.lock') }}
+
+      - name: Cache Windows native dependencies
+        uses: actions/cache@v4
+        with:
+          path: build/windows/x64/_deps
+          key: windows-native-x64-${{ hashFiles('windows/CMakeLists.txt') }}
 
       - name: Install dependencies
-        run: flutter pub get
+        run: flutter pub get --enforce-lockfile --no-example
 
       - name: Build Windows x64
-        run: flutter build windows --release --dart-define=ENABLE_UPDATE_CHECK=true ${{ env.SENTRY_DART_DEFINE }} ${{ env.GIT_COMMIT_DART_DEFINE }}
+        run: flutter build windows --release --dart-define=ENABLE_UPDATE_CHECK=true ${{ env.SENTRY_DART_DEFINE }} ${{ env.GIT_COMMIT_DART_DEFINE }} ${{ env.SENTRY_ENV_DART_DEFINE }} --dart-define=SENTRY_DIST=github-windows-x64 ${{ env.DONATIONS_DART_DEFINE }} --split-debug-info=debug-info/windows-x64
+
+      - name: Upload symbols to bugs.plezy.app
+        if: github.repository == 'edde746/plezy'
+        shell: pwsh
+        env:
+          BUGS_ADMIN_TOKEN: ${{ secrets.BUGS_ADMIN_TOKEN }}
+          SENTRY_DIST: github-windows-x64
+        run: .\scripts\upload-symbols.ps1 windows-x64
 
       - name: Upload x64 build
         uses: actions/upload-artifact@v4
@@ -348,35 +423,54 @@ jobs:
           path: build/windows/x64/runner/Release/
 
   build-windows-arm64:
+    if: ${{ inputs.build_windows }}
     runs-on: windows-11-arm
     permissions:
       contents: read
     steps:
       - uses: actions/checkout@v4
 
+      - name: Cache Windows native dependencies
+        id: windows-native-cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            build/windows/arm64/_deps
+            build/windows/arm64/mpv-dev-arm64
+          key: windows-native-arm64-${{ hashFiles('windows/CMakeLists.txt') }}
+
       - name: Install 7-Zip
+        if: steps.windows-native-cache.outputs.cache-hit != 'true'
         run: choco install 7zip -y
 
       - name: Setup Flutter
         uses: subosito/flutter-action@v2
         with:
           channel: "master"
+          flutter-version: "3.44.0"
           cache: true
+          pub-cache: false
 
       - name: Cache Pub dependencies
         uses: actions/cache@v4
         with:
           path: |
             ~\AppData\Local\Pub\Cache
-          key: ${{ runner.os }}-arm64-pub-${{ hashFiles('**/pubspec.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-arm64-pub-
+          key: ${{ runner.os }}-${{ runner.arch }}-pub-v2-${{ hashFiles('pubspec.yaml', 'pubspec.lock') }}
 
       - name: Install dependencies
-        run: flutter pub get
+        run: flutter pub get --no-example
 
       - name: Build Windows arm64
-        run: flutter build windows --release --dart-define=ENABLE_UPDATE_CHECK=true ${{ env.SENTRY_DART_DEFINE }} ${{ env.GIT_COMMIT_DART_DEFINE }}
+        run: flutter build windows --release --dart-define=ENABLE_UPDATE_CHECK=true ${{ env.SENTRY_DART_DEFINE }} ${{ env.GIT_COMMIT_DART_DEFINE }} ${{ env.SENTRY_ENV_DART_DEFINE }} --dart-define=SENTRY_DIST=github-windows-arm64 ${{ env.DONATIONS_DART_DEFINE }} --split-debug-info=debug-info/windows-arm64
+
+      - name: Upload symbols to bugs.plezy.app
+        if: github.repository == 'edde746/plezy'
+        shell: pwsh
+        env:
+          BUGS_ADMIN_TOKEN: ${{ secrets.BUGS_ADMIN_TOKEN }}
+          SENTRY_DIST: github-windows-arm64
+        run: .\scripts\upload-symbols.ps1 windows-arm64
 
       - name: Upload arm64 build
         uses: actions/upload-artifact@v4
@@ -386,6 +480,7 @@ jobs:
 
   package-windows:
     needs: [build-windows-x64, build-windows-arm64]
+    if: ${{ inputs.build_windows }}
     runs-on: windows-latest
     permissions:
       id-token: write
@@ -468,6 +563,7 @@ jobs:
             win-installer-size.txt
 
   build-linux-x64:
+    if: ${{ inputs.build_linux }}
     runs-on: ubuntu-latest
     permissions:
       id-token: write
@@ -480,27 +576,38 @@ jobs:
         uses: subosito/flutter-action@v2
         with:
           channel: "stable"
+          flutter-version: "3.44.0"
           cache: true
+          pub-cache: false
 
       - name: Cache Pub dependencies
         uses: actions/cache@v4
         with:
           path: |
             ~/.pub-cache
-          key: ${{ runner.os }}-pub-${{ hashFiles('**/pubspec.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-pub-
+          key: ${{ runner.os }}-${{ runner.arch }}-pub-v2-${{ hashFiles('pubspec.yaml', 'pubspec.lock') }}
 
       - name: Cache APT packages
         uses: awalsh128/cache-apt-pkgs-action@latest
         with:
-          packages: clang cmake meson ninja-build pkg-config nasm libgtk-3-dev libevdev-dev liblzma-dev libstdc++-12-dev libasound2-dev libass-dev libfreetype-dev libfontconfig-dev libfribidi-dev libharfbuzz-dev libepoxy-dev libegl-dev libgl-dev libgnutls28-dev libpipewire-0.3-dev libva-dev libvdpau-dev libx11-dev libxext-dev libxrandr-dev libxcursor-dev libxi-dev libxss-dev libxpresent-dev libxkbcommon-dev libpulse-dev libdbus-1-dev libdrm-dev libgbm-dev libwayland-dev wayland-protocols liblcms2-dev ruby ruby-dev rubygems build-essential rpm libarchive-tools imagemagick libcurl4-openssl-dev
+          packages: ${{ env.LINUX_APT_PACKAGES }}
           version: 1.1
 
       - name: Install Linux dependencies
         run: |
-          sudo apt-get update
-          sudo apt-get install -y clang cmake meson ninja-build pkg-config nasm libgtk-3-dev libevdev-dev liblzma-dev libstdc++-12-dev libasound2-dev libass-dev libfreetype-dev libfontconfig-dev libfribidi-dev libharfbuzz-dev libepoxy-dev libegl-dev libgl-dev libgnutls28-dev libpipewire-0.3-dev libva-dev libvdpau-dev libx11-dev libxext-dev libxrandr-dev libxcursor-dev libxi-dev libxss-dev libxpresent-dev libxkbcommon-dev libpulse-dev libdbus-1-dev libdrm-dev libgbm-dev libwayland-dev wayland-protocols liblcms2-dev ruby ruby-dev rubygems build-essential rpm libarchive-tools imagemagick libcurl4-openssl-dev
+          read -r -a packages <<< "$LINUX_APT_PACKAGES"
+
+          for attempt in 1 2 3; do
+            if sudo apt-get update -o Acquire::Retries=3 && sudo apt-get install -y -o Acquire::Retries=3 "${packages[@]}"; then
+              exit 0
+            fi
+
+            sudo apt-get clean
+            sudo rm -rf /var/lib/apt/lists/*
+            sleep $((attempt * 15))
+          done
+
+          exit 1
 
       - name: Cache libmpv build
         id: libmpv-cache
@@ -517,13 +624,20 @@ jobs:
         run: sudo gem install fpm
 
       - name: Install dependencies
-        run: flutter pub get
+        run: flutter pub get --enforce-lockfile --no-example
 
       - name: Build Linux x64
-        run: flutter build linux --release --dart-define=ENABLE_UPDATE_CHECK=true ${{ env.SENTRY_DART_DEFINE }} ${{ env.GIT_COMMIT_DART_DEFINE }}
+        run: flutter build linux --release --dart-define=ENABLE_UPDATE_CHECK=true ${{ env.SENTRY_DART_DEFINE }} ${{ env.GIT_COMMIT_DART_DEFINE }} ${{ env.SENTRY_ENV_DART_DEFINE }} --dart-define=SENTRY_DIST=github-linux-x64 ${{ env.DONATIONS_DART_DEFINE }} --split-debug-info=debug-info/linux-x64
         env:
           PKG_CONFIG_PATH: ${{ github.workspace }}/libmpv-prefix/lib/pkgconfig:${{ github.workspace }}/libmpv-prefix/lib/x86_64-linux-gnu/pkgconfig
 
+      - name: Upload symbols to bugs.plezy.app
+        if: github.repository == 'edde746/plezy'
+        env:
+          BUGS_ADMIN_TOKEN: ${{ secrets.BUGS_ADMIN_TOKEN }}
+          SENTRY_DIST: github-linux-x64
+        run: ./scripts/upload-symbols.sh linux-x64
+
       - name: Build Linux Packages
         run: ARCH_SUFFIX=x64 OUTPUT_DIR=$GITHUB_WORKSPACE python3 linux/packaging/build-packages.py
 
@@ -576,6 +690,7 @@ jobs:
             plezy-linux-x64.pkg.tar.zst
 
   build-linux-arm64:
+    if: ${{ inputs.build_linux }}
     runs-on: ubuntu-24.04-arm
     permissions:
       id-token: write
@@ -588,27 +703,38 @@ jobs:
         uses: subosito/flutter-action@v2
         with:
           channel: "master"
+          flutter-version: "3.44.0"
           cache: true
+          pub-cache: false
 
       - name: Cache Pub dependencies
         uses: actions/cache@v4
         with:
           path: |
             ~/.pub-cache
-          key: ${{ runner.os }}-arm64-pub-${{ hashFiles('**/pubspec.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-arm64-pub-
+          key: ${{ runner.os }}-${{ runner.arch }}-pub-v2-${{ hashFiles('pubspec.yaml', 'pubspec.lock') }}
 
       - name: Cache APT packages
         uses: awalsh128/cache-apt-pkgs-action@latest
         with:
-          packages: clang cmake meson ninja-build pkg-config nasm libgtk-3-dev libevdev-dev liblzma-dev libstdc++-12-dev libasound2-dev libass-dev libfreetype-dev libfontconfig-dev libfribidi-dev libharfbuzz-dev libepoxy-dev libegl-dev libgl-dev libgnutls28-dev libpipewire-0.3-dev libva-dev libvdpau-dev libx11-dev libxext-dev libxrandr-dev libxcursor-dev libxi-dev libxss-dev libxpresent-dev libxkbcommon-dev libpulse-dev libdbus-1-dev libdrm-dev libgbm-dev libwayland-dev wayland-protocols liblcms2-dev ruby ruby-dev rubygems build-essential rpm libarchive-tools imagemagick libcurl4-openssl-dev
+          packages: ${{ env.LINUX_APT_PACKAGES }}
           version: 1.1
 
       - name: Install Linux dependencies
         run: |
-          sudo apt-get update
-          sudo apt-get install -y clang cmake meson ninja-build pkg-config nasm libgtk-3-dev libevdev-dev liblzma-dev libstdc++-12-dev libasound2-dev libass-dev libfreetype-dev libfontconfig-dev libfribidi-dev libharfbuzz-dev libepoxy-dev libegl-dev libgl-dev libgnutls28-dev libpipewire-0.3-dev libva-dev libvdpau-dev libx11-dev libxext-dev libxrandr-dev libxcursor-dev libxi-dev libxss-dev libxpresent-dev libxkbcommon-dev libpulse-dev libdbus-1-dev libdrm-dev libgbm-dev libwayland-dev wayland-protocols liblcms2-dev ruby ruby-dev rubygems build-essential rpm libarchive-tools imagemagick libcurl4-openssl-dev
+          read -r -a packages <<< "$LINUX_APT_PACKAGES"
+
+          for attempt in 1 2 3; do
+            if sudo apt-get update -o Acquire::Retries=3 && sudo apt-get install -y -o Acquire::Retries=3 "${packages[@]}"; then
+              exit 0
+            fi
+
+            sudo apt-get clean
+            sudo rm -rf /var/lib/apt/lists/*
+            sleep $((attempt * 15))
+          done
+
+          exit 1
 
       - name: Cache libmpv build
         id: libmpv-cache
@@ -625,13 +751,20 @@ jobs:
         run: sudo gem install fpm
 
       - name: Install dependencies
-        run: flutter pub get
+        run: flutter pub get --no-example
 
       - name: Build Linux arm64
-        run: flutter build linux --release --dart-define=ENABLE_UPDATE_CHECK=true ${{ env.SENTRY_DART_DEFINE }} ${{ env.GIT_COMMIT_DART_DEFINE }}
+        run: flutter build linux --release --dart-define=ENABLE_UPDATE_CHECK=true ${{ env.SENTRY_DART_DEFINE }} ${{ env.GIT_COMMIT_DART_DEFINE }} ${{ env.SENTRY_ENV_DART_DEFINE }} --dart-define=SENTRY_DIST=github-linux-arm64 ${{ env.DONATIONS_DART_DEFINE }} --split-debug-info=debug-info/linux-arm64
         env:
           PKG_CONFIG_PATH: ${{ github.workspace }}/libmpv-prefix/lib/pkgconfig:${{ github.workspace }}/libmpv-prefix/lib/aarch64-linux-gnu/pkgconfig
 
+      - name: Upload symbols to bugs.plezy.app
+        if: github.repository == 'edde746/plezy'
+        env:
+          BUGS_ADMIN_TOKEN: ${{ secrets.BUGS_ADMIN_TOKEN }}
+          SENTRY_DIST: github-linux-arm64
+        run: ./scripts/upload-symbols.sh linux-arm64
+
       - name: Find bundle directory
         id: find-bundle
         run: |
@@ -694,7 +827,8 @@ jobs:
             plezy-linux-arm64.pkg.tar.zst
 
   create-release:
-    needs: [build-android, build-ios, build-macos, package-windows, build-linux-x64, build-linux-arm64]
+    needs: [build-android, build-ios, build-macos, build-windows-x64, build-windows-arm64, package-windows, build-linux-x64, build-linux-arm64]
+    if: ${{ always() && !contains(needs.*.result, 'failure') && !contains(needs.*.result, 'cancelled') && (inputs.build_android || inputs.build_ios || inputs.build_macos || inputs.build_windows || inputs.build_linux) }}
     runs-on: ubuntu-latest
     permissions:
       contents: write
@@ -704,10 +838,61 @@ jobs:
           sparse-checkout: pubspec.yaml
           sparse-checkout-cone-mode: false
 
-      - name: Download all artifacts
+      - name: Download Android artifacts
+        if: ${{ inputs.build_android }}
         uses: actions/download-artifact@v4
         with:
-          path: artifacts
+          name: android-apk
+          path: artifacts/android-apk
+
+      - name: Download iOS artifact
+        if: ${{ inputs.build_ios }}
+        uses: actions/download-artifact@v4
+        with:
+          name: ios-ipa
+          path: artifacts/ios-ipa
+
+      - name: Download macOS artifact
+        if: ${{ inputs.build_macos }}
+        uses: actions/download-artifact@v4
+        with:
+          name: macos-dmg
+          path: artifacts/macos-dmg
+
+      - name: Download Windows x64 artifact
+        if: ${{ inputs.build_windows }}
+        uses: actions/download-artifact@v4
+        with:
+          name: windows-x64-portable
+          path: artifacts/windows-x64-portable
+
+      - name: Download Windows arm64 artifact
+        if: ${{ inputs.build_windows }}
+        uses: actions/download-artifact@v4
+        with:
+          name: windows-arm64-portable
+          path: artifacts/windows-arm64-portable
+
+      - name: Download Windows installer artifact
+        if: ${{ inputs.build_windows }}
+        uses: actions/download-artifact@v4
+        with:
+          name: windows-installer
+          path: artifacts/windows-installer
+
+      - name: Download Linux x64 artifacts
+        if: ${{ inputs.build_linux }}
+        uses: actions/download-artifact@v4
+        with:
+          name: linux-x64
+          path: artifacts/linux-x64
+
+      - name: Download Linux arm64 artifacts
+        if: ${{ inputs.build_linux }}
+        uses: actions/download-artifact@v4
+        with:
+          name: linux-arm64
+          path: artifacts/linux-arm64
 
       - name: Display structure of downloaded files
         run: ls -R artifacts
@@ -790,21 +975,39 @@ jobs:
           echo "Generated appcast.xml:"
           cat appcast.xml
 
+      - name: Collect release files
+        id: release-files
+        run: |
+          {
+            echo 'files<<EOF'
+            if [ "${{ inputs.build_android }}" = "true" ]; then
+              echo artifacts/android-apk/plezy-android-arm64-v8a.tar.gz
+              echo artifacts/android-apk/plezy-android-armeabi-v7a.tar.gz
+              echo artifacts/android-apk/plezy-android-x86_64.tar.gz
+            fi
+            if [ "${{ inputs.build_ios }}" = "true" ]; then
+              echo artifacts/ios-ipa/plezy-ios.ipa
+            fi
+            if [ "${{ inputs.build_macos }}" = "true" ]; then
+              echo artifacts/macos-dmg/plezy-macos.dmg
+            fi
+            if [ "${{ inputs.build_windows }}" = "true" ]; then
+              echo artifacts/windows-x64-portable/plezy-windows-x64-portable.7z
+              echo artifacts/windows-arm64-portable/plezy-windows-arm64-portable.7z
+              echo artifacts/windows-installer/plezy-windows-installer.exe
+            fi
+            if [ "${{ inputs.build_linux }}" = "true" ]; then
+              echo 'artifacts/linux-x64/*'
+              echo 'artifacts/linux-arm64/*'
+            fi
+            echo appcast.xml
+            echo EOF
+          } >> "$GITHUB_OUTPUT"
+
       - name: Create Release
         uses: softprops/action-gh-release@v1
         with:
-          files: |
-            artifacts/android-apk/plezy-android-arm64-v8a.tar.gz
-            artifacts/android-apk/plezy-android-armeabi-v7a.tar.gz
-            artifacts/android-apk/plezy-android-x86_64.tar.gz
-            artifacts/ios-ipa/plezy-ios.ipa
-            artifacts/macos-dmg/plezy-macos.dmg
-            artifacts/windows-x64-portable/plezy-windows-x64-portable.7z
-            artifacts/windows-arm64-portable/plezy-windows-arm64-portable.7z
-            artifacts/windows-installer/plezy-windows-installer.exe
-            artifacts/linux-x64/*
-            artifacts/linux-arm64/*
-            appcast.xml
+          files: ${{ steps.release-files.outputs.files }}
           draft: true
           prerelease: false
           generate_release_notes: true

.github/workflows/ci.yml

@@ -23,22 +23,31 @@ jobs:
         uses: subosito/flutter-action@v2
         with:
           channel: "stable"
+          flutter-version: "3.44.0"
           cache: true
+          pub-cache: false
 
       - name: Cache Pub dependencies
         uses: actions/cache@v4
         with:
           path: |
             ~/.pub-cache
-          key: ${{ runner.os }}-pub-v2-${{ hashFiles('**/pubspec.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-pub-v2-
+          key: ${{ runner.os }}-pub-v3-${{ hashFiles('**/pubspec.yaml', '**/pubspec.lock') }}
 
       - name: Install dependencies
         run: |
 
           flutter pub get
 
+      - name: Verify generated files committed
+        run: |
+          scripts/codegen.sh
+          if ! git diff --exit-code lib/; then
+            echo "::error::Generated files (.g.dart / .freezed.dart) are out of date."
+            echo "Run 'scripts/codegen.sh' and commit the result."
+            exit 1
+          fi
+
       - name: Verify formatting
         run: |
           # Find all Dart files excluding generated files
@@ -106,16 +115,16 @@ jobs:
         uses: subosito/flutter-action@v2
         with:
           channel: "stable"
+          flutter-version: "3.44.0"
           cache: true
+          pub-cache: false
 
       - name: Cache Pub dependencies
         uses: actions/cache@v4
         with:
           path: |
             ~/.pub-cache
-          key: ${{ runner.os }}-pub-v2-${{ hashFiles('**/pubspec.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-pub-v2-
+          key: ${{ runner.os }}-pub-v3-${{ hashFiles('**/pubspec.yaml', '**/pubspec.lock') }}
 
       - name: Install dependencies
         run: |
@@ -130,6 +139,24 @@ jobs:
             echo "No tests found, skipping test execution"
           fi
 
+  native-format:
+    name: Native Formatting
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Java
+        uses: actions/setup-java@v4
+        with:
+          distribution: "temurin"
+          java-version: "17"
+
+      - name: Verify native formatting
+        run: scripts/format_native.sh --check
+
   dependency-check:
     name: Dependency Validation
     runs-on: ubuntu-latest
@@ -143,16 +170,16 @@ jobs:
         uses: subosito/flutter-action@v2
         with:
           channel: "stable"
+          flutter-version: "3.44.0"
           cache: true
+          pub-cache: false
 
       - name: Cache Pub dependencies
         uses: actions/cache@v4
         with:
           path: |
             ~/.pub-cache
-          key: ${{ runner.os }}-pub-v2-${{ hashFiles('**/pubspec.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-pub-v2-
+          key: ${{ runner.os }}-pub-v3-${{ hashFiles('**/pubspec.yaml', '**/pubspec.lock') }}
 
       - name: Verify dependencies
         run: |

.github/workflows/sonar.yml

@@ -1,27 +0,0 @@
-name: SonarQube
-
-on:
-  workflow_dispatch:
-
-jobs:
-  sonarqube:
-    name: SonarQube
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Setup Flutter
-        uses: subosito/flutter-action@v2
-        with:
-          channel: "stable"
-          cache: true
-
-      - name: Install dependencies
-        run: flutter pub get
-
-      - name: SonarQube Scan
-        uses: SonarSource/sonarqube-scan-action@v6
-        env:
-          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}

.github/workflows/update-packages.yml

@@ -52,3 +52,27 @@ jobs:
           identifier: edde746.Plezy
           installers-regex: 'plezy-windows-installer\.exe$'
           token: ${{ secrets.WINGET_TOKEN }}
+
+  update-appcast-branch:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Download appcast.xml from release
+        run: |
+          gh release download "${{ github.event.release.tag_name }}" \
+            --pattern "appcast.xml"
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Push to appcast branch
+        run: |
+          VERSION="${{ github.event.release.tag_name }}"
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          BLOB=$(git hash-object -w appcast.xml)
+          TREE=$(printf "100644 blob %s\tappcast.xml\n" "$BLOB" | git mktree)
+          COMMIT=$(git commit-tree "$TREE" -m "Update appcast for $VERSION")
+          git push origin "$COMMIT:refs/heads/appcast" --force

.gitignore

@@ -34,6 +34,20 @@ migrate_working_dir/
 /build/
 /debug-info/
 
+# tvOS: build artifacts and generated assets (regenerated by xcode_appletv.sh)
+tvos/build/
+tvos/Pods/
+tvos/Podfile.lock
+tvos/Runner.xcworkspace/xcuserdata/
+tvos/Runner.xcodeproj/xcuserdata/
+tvos/Runner.xcodeproj/project.xcworkspace/xcuserdata/
+tvos/Flutter/Generated.xcconfig
+tvos/Flutter/flutter_export_environment.sh
+tvos/Flutter/libPods-Runner.a
+tvos/tvos_flutter_assets/
+tvos/Runner/GeneratedPluginRegistrant.h
+tvos/Runner/GeneratedPluginRegistrant.m
+
 # Symbolication related
 app.*.symbols
 
@@ -55,3 +69,5 @@ duplication-report/
 **/fastlane/**/
 **/fastlane/report.xml
 maestro/**/*.png
+
+server/deploy.sh

.jscpd.json

@@ -1,21 +0,0 @@
-{
-  "threshold": 5,
-  "reporters": ["html", "console"],
-  "ignore": [
-    "**/*.g.dart",
-    "**/*.freezed.dart",
-    "**/*.mocks.dart",
-    "**/generated/**",
-    "**/*.config.dart"
-  ],
-  "absolute": true,
-  "gitignore": true,
-  "format": ["dart"],
-  "minLines": 5,
-  "minTokens": 50,
-  "output": "./duplication-report",
-  "mode": "strict",
-  "formatsExts": {
-    "dart": ["dart"]
-  }
-}

.swift-format

@@ -0,0 +1,10 @@
+{
+  "indentation" : {
+    "spaces" : 2
+  },
+  "lineLength" : 120,
+  "maximumBlankLines" : 1,
+  "respectsExistingLineBreaks" : true,
+  "rules" : {},
+  "version" : 1
+}

CONTRIBUTING.md

@@ -10,7 +10,8 @@
 ## Development
 
 - Follow Dart/Flutter conventions
-- Run `dart format .` to format your code (note: generated files like `*.g.dart` are excluded from CI checks)
+- Run `dart format .` to format Dart code (note: generated files like `*.g.dart` are excluded from CI checks)
+- Run `scripts/format_native.sh --fix` to format Kotlin, Swift, C++, C, Objective-C, and native headers
 - Run `flutter analyze` before submitting to check for issues
 - Run `flutter test` if tests are available
 - Test your changes thoroughly
@@ -19,8 +20,9 @@
 
 The project includes automated CI checks that run on all pull requests:
 
-1. **Code Formatting**: Ensures code follows Dart formatting standards
-   - Run locally: `dart format .` to format all files
+1. **Code Formatting**: Ensures code follows Dart and native formatting standards
+   - Run locally: `dart format .` to format Dart files
+   - Run locally: `scripts/format_native.sh --fix` to format native files
    - Note: CI only checks non-generated files (excludes `.g.dart`, `.freezed.dart`)
    - Generated files are reformatted automatically by build tools
 

Casks/plezy.rb

@@ -1,10 +1,10 @@
 cask "plezy" do
-  version "1.27.0"
-  sha256 "39baaece57637889946ef847e678f33817c0b900ae52a626f5db69415a60fb7b"
+  version "2.5.0"
+  sha256 "9f71d8c1cafb74c113e8cbdd8e66ec2a86c26a846b823a3459a8b9a7ab0c31fa"
 
   url "https://github.com/edde746/plezy/releases/download/#{version}/plezy-macos.dmg"
   name "Plezy"
-  desc "Modern Plex client built with Flutter"
+  desc "Modern Plex and Jellyfin client built with Flutter"
   homepage "https://github.com/edde746/plezy"
 
   livecheck do

README.md

@@ -3,13 +3,19 @@
   Plezy
 </h1>
 
-A modern Plex client for desktop and mobile. Built with Flutter for native performance and a clean interface.
+A modern client for Plex and Jellyfin on desktop, mobile, and TV. Built with Flutter for native performance and a clean interface.
 
-<p align="center">
-  <img src="assets/screenshots/macos-home.png" alt="Plezy macOS Home Screen" width="800" />
+<p>
+  <a href="https://plezy.app">Website</a> ·
+  <a href="https://plezy.app/#screenshots">Screenshots</a> ·
+  <a href="#download">Download</a> ·
+  <a href="CONTRIBUTING.md">Contributing</a> ·
+  <a href="LICENSE">License</a>
 </p>
 
-*More screenshots in the [screenshots folder](assets/screenshots/#readme)*
+<p align="center">
+  <img src="assets/readme-showcase.webp" alt="Plezy mobile screenshots" width="900" />
+</p>
 
 ## Download
 
@@ -17,10 +23,16 @@ A modern Plex client for desktop and mobile. Built with Flutter for native perfo
 <a href='https://play.google.com/store/apps/details?id=com.edde746.plezy'><img height='60' alt='Get it on Google Play' src='./assets/play-store-badge.png'/></a>
 <a href='https://www.amazon.com/gp/product/B0GK65CVS1'><img height='60' alt='Available at the Amazon App Store' src='./assets/amazon-badge.png'/></a>
 
-- [Windows (x64, arm64)](https://github.com/edde746/plezy/releases/latest/download/plezy-windows-installer.exe)
-- [macOS (x64, arm64)](https://github.com/edde746/plezy/releases/latest/download/plezy-macos.dmg)
-- [Linux (x64, arm64)](https://github.com/edde746/plezy/releases/latest) - .deb, .rpm, .pkg.tar.zst, and portable tar.gz available
-- [NixOS/Nix](https://github.com/mio-19/nurpkgs/tree/main/pkgs/plezy) - Community package by [@mio-19](https://github.com/mio-19)
+| Platform | Download |
+| --- | --- |
+| Windows | [Installer (x64, arm64)](https://github.com/edde746/plezy/releases/latest/download/plezy-windows-installer.exe) · [Portable x64](https://github.com/edde746/plezy/releases/latest/download/plezy-windows-x64-portable.7z) · [Portable arm64](https://github.com/edde746/plezy/releases/latest/download/plezy-windows-arm64-portable.7z) |
+| macOS | [DMG (x64, arm64)](https://github.com/edde746/plezy/releases/latest/download/plezy-macos.dmg) |
+| Linux x64 | [.deb](https://github.com/edde746/plezy/releases/latest/download/plezy-linux-x64.deb) · [.rpm](https://github.com/edde746/plezy/releases/latest/download/plezy-linux-x64.rpm) · [.pkg.tar.zst](https://github.com/edde746/plezy/releases/latest/download/plezy-linux-x64.pkg.tar.zst) · [portable tar.gz](https://github.com/edde746/plezy/releases/latest/download/plezy-linux-x64.tar.gz) |
+| Linux arm64 | [.deb](https://github.com/edde746/plezy/releases/latest/download/plezy-linux-arm64.deb) · [.rpm](https://github.com/edde746/plezy/releases/latest/download/plezy-linux-arm64.rpm) · [.pkg.tar.zst](https://github.com/edde746/plezy/releases/latest/download/plezy-linux-arm64.pkg.tar.zst) · [portable tar.gz](https://github.com/edde746/plezy/releases/latest/download/plezy-linux-arm64.tar.gz) |
+
+Package managers:
+
+- [Nix](https://search.nixos.org/packages?channel=unstable&query=plezy) - Community package by [@mio-19](https://github.com/mio-19) and [@MiniHarinn](https://github.com/MiniHarinn)
 - **Homebrew** (macOS):
   ```bash
   brew tap edde746/plezy https://github.com/edde746/plezy
@@ -32,48 +44,74 @@ A modern Plex client for desktop and mobile. Built with Flutter for native perfo
   ```
 - **WinGet** (Windows):
   ```bash
-  winget install edde746.plezy
+  winget install edde746.Plezy
   ```
 
 ## Features
 
-### 🔐 Authentication
-- Sign in with Plex
-- Automatic server discovery and smart connection selection
-- Persistent sessions with auto-login
+### <img src="assets/readme_icons/browse.svg" height="20" alt="" align="center" /> Browse & Discover
+- Libraries, collections, and playlists
+- Discover hub — Continue Watching, Next Up, trending, and recommendations
+- Cross-server search
+- Filtering, sorting, and alphabetical jump navigation
+- Extras — trailers, deleted scenes, behind-the-scenes
 
-### 📚 Media Browsing
-- Browse libraries with rich metadata
-- Advanced search across all media
-- Collections and playlists
-
-### 🎬 Playback
+### <img src="assets/readme_icons/playback.svg" height="20" alt="" align="center" /> Playback
 - Wide codec support (HEVC, AV1, VP9, and more)
-- HDR and Dolby Vision (not Linux)
-- Full ASS/SSA subtitle support
-- Audio and subtitle preferences synced with Plex profile
+- HDR and Dolby Vision[^1]
+- Full ASS/SSA subtitles with customizable styling
+- Online subtitle search & download[^2]
+- Audio & subtitle choices remembered per title
 - Progress sync and resume
-- Auto-play next episode
+- Auto-play next episode with skip intro / skip credits
+- Chapter navigation with thumbnail scrub previews
+- Playback speed, audio sync offset, sleep timer
+- Ambient lighting and GLSL shader presets[^3]
+- Picture-in-Picture[^4]
+- Refresh-rate matching[^5]
+- External player launch (VLC, MX Player, etc.)
 
-### 📺 Live TV & DVR
-- EPG guide grid
-- Channel tuning
-- DVR recording rules and scheduled recordings
-- Multi-server DVR support
+### <img src="assets/readme_icons/live-tv.svg" height="20" alt="" align="center" /> Live TV & DVR
+- Live TV channel browsing with favorites
+- DVR support with EPG guide, recording rules, and scheduled recordings[^2]
+- Multi-server Live TV support where available
 
-### 📥 Downloads
+### <img src="assets/readme_icons/downloads.svg" height="20" alt="" align="center" /> Downloads & Offline
 - Download media for offline viewing
-- Background downloads with queue management
+- Background queue with pause / resume
+- Sync rules for automatic downloads
+- Offline browsing with watch state sync-back on reconnect
 
-### 👥 Watch Together
+### <img src="assets/readme_icons/watch-together.svg" height="20" alt="" align="center" /> Watch Together
 - Synchronized playback with friends
-- Real-time play/pause and seek sync
+- Real-time play / pause / seek sync
+
+### <img src="assets/readme_icons/integrations.svg" height="20" alt="" align="center" /> Integrations
+- Discord Rich Presence[^7]
+- Trakt, MyAnimeList, AniList, and Simkl tracking & rating
+- Plezy Remote — control desktop and TV from mobile
+- Watch Next row[^6]
+
+### <img src="assets/readme_icons/customization.svg" height="20" alt="" align="center" /> Platform & Customization
+- Desktop, mobile, and TV — full D-pad, keyboard, and gamepad support
+- Customizable keyboard shortcuts[^7]
+- Metadata and artwork editing[^2]
+- Settings import/export
+- Localized in English plus 14 translations
+
+[^1]: Not available on Linux.
+[^2]: Plex only.
+[^3]: Not available on iOS or tvOS.
+[^4]: Android, iOS, and macOS.
+[^5]: Windows, Android, and tvOS.
+[^6]: Android TV only.
+[^7]: Desktop only.
 
 ## Building from Source
 
 ### Prerequisites
-- Flutter SDK 3.8.1+
-- A Plex account with server access
+- Flutter SDK 3.38.4+
+- A Plex account or Jellyfin server with user credentials
 
 ### Setup
 
@@ -81,20 +119,46 @@ A modern Plex client for desktop and mobile. Built with Flutter for native perfo
 git clone https://github.com/edde746/plezy.git
 cd plezy
 flutter pub get
-dart run build_runner build
+scripts/codegen.sh
 flutter run
 ```
 
 ### Code Generation
 
-After modifying model classes:
+After modifying model classes or other generated sources:
 
 ```bash
-dart run build_runner build --delete-conflicting-outputs
+scripts/codegen.sh
 ```
 
+After modifying translations:
+
+```bash
+dart run slang
+```
+
+### Local Checks
+
+```bash
+scripts/ci_checks.sh
+```
+
+To install the same pre-commit checks locally:
+
+```bash
+scripts/setup_hooks.sh
+```
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development workflow, formatting, tests, and translation guidelines.
+
+## License
+
+Plezy is licensed under [GPL-3.0](LICENSE).
+
 ## Acknowledgments
 
 - Built with [Flutter](https://flutter.dev)
-- Designed for [Plex Media Server](https://www.plex.tv)
-- Playback powered by [mpv](https://mpv.io) via [MPVKit](https://github.com/mpvkit/MPVKit) and [libmpv-android](https://github.com/jarnedemeulemeester/libmpv-android)
+- Supports [Plex Media Server](https://www.plex.tv) and [Jellyfin](https://jellyfin.org)
+- Playback powered by [mpv](https://mpv.io), [MPVKit](https://github.com/mpvkit/MPVKit), Android [ExoPlayer](https://developer.android.com/media/media3/exoplayer), [libass-android](https://github.com/peerless2012/libass-android), and [libmpv-android](https://github.com/jarnedemeulemeester/libmpv-android)

analysis_options.yaml

@@ -7,6 +7,16 @@ analyzer:
   plugins:
     - dart_code_linter
 
+linter:
+  rules:
+    unawaited_futures: true
+    cancel_subscriptions: true
+    close_sinks: true
+    use_super_parameters: true
+    prefer_final_locals: true
+    prefer_final_in_for_each: true
+    avoid_print: true
+
 dart_code_linter:
   extends:
     - package:dart_code_linter/presets/recommended.yaml

android/app/build.gradle.kts

@@ -1,152 +1,193 @@
-import java.util.Properties
 import java.io.FileInputStream
+import java.util.Properties
 
 plugins {
-    id("com.android.application")
-    id("kotlin-android")
-    // The Flutter Gradle Plugin must be applied after the Android and Kotlin Gradle plugins.
-    id("dev.flutter.flutter-gradle-plugin")
+  id("com.android.application")
+  id("kotlin-android")
+  // The Flutter Gradle Plugin must be applied after the Android and Kotlin Gradle plugins.
+  id("dev.flutter.flutter-gradle-plugin")
+}
+
+val mpvVersion = "v1.0.7"
+val mpvDir = layout.buildDirectory.dir("libmpv").get().asFile
+val mpvAar = "libmpv-release.aar"
+
+val downloadLibmpv by tasks.registering {
+  val stamp = File(mpvDir, ".version")
+  outputs.upToDateWhen { stamp.exists() && stamp.readText().trim() == mpvVersion }
+  doLast {
+    mpvDir.mkdirs()
+    val url = "https://github.com/edde746/libmpv-android/releases/download/$mpvVersion/$mpvAar"
+    exec { commandLine("curl", "-sfL", url, "-o", File(mpvDir, mpvAar).absolutePath) }
+    stamp.writeText(mpvVersion)
+  }
+}
+
+val assVersion = "fp-3"
+val assDir = layout.buildDirectory.dir("libass").get().asFile
+val assAars = listOf("lib_ass-release.aar", "lib_ass_kt-release.aar", "lib_ass_media-release.aar")
+
+val downloadLibass by tasks.registering {
+  val stamp = File(assDir, ".version")
+  outputs.upToDateWhen { stamp.exists() && stamp.readText().trim() == assVersion }
+  doLast {
+    assDir.mkdirs()
+    val baseUrl = "https://github.com/edde746/libass-android/releases/download/$assVersion"
+    assAars.forEach { name ->
+      val dest = File(assDir, name)
+      exec { commandLine("curl", "-sfL", "$baseUrl/$name", "-o", dest.absolutePath) }
+    }
+    stamp.writeText(assVersion)
+  }
 }
 
 val doviVersion = "2.3.1"
 val doviDir = layout.buildDirectory.dir("libdovi").get().asFile
 val doviAbis = mapOf(
-    "arm64-v8a" to "aarch64-linux-android",
-    "armeabi-v7a" to "armv7-linux-androideabi",
-    "x86" to "i686-linux-android",
-    "x86_64" to "x86_64-linux-android",
+  "arm64-v8a" to "aarch64-linux-android",
+  "armeabi-v7a" to "armv7-linux-androideabi",
+  "x86" to "i686-linux-android",
+  "x86_64" to "x86_64-linux-android"
 )
 
 val downloadLibdovi by tasks.registering {
-    val stamp = File(doviDir, ".version")
-    outputs.upToDateWhen { stamp.exists() && stamp.readText().trim() == doviVersion }
-    doLast {
-        doviDir.mkdirs()
-        val baseUrl = "https://github.com/edde746/libdovi-builds/releases/download/v$doviVersion"
-        doviAbis.forEach { (abi, triple) ->
-            val archive = File(doviDir, "$triple.tar.gz")
-            exec { commandLine("curl", "-sfL", "$baseUrl/libdovi-$triple.tar.gz", "-o", archive.absolutePath) }
-            val outDir = File(doviDir, "$abi/lib")
-            outDir.mkdirs()
-            exec { commandLine("tar", "-xzf", archive.absolutePath, "-C", outDir.absolutePath) }
-            archive.delete()
-        }
-        stamp.writeText(doviVersion)
+  val stamp = File(doviDir, ".version")
+  outputs.upToDateWhen { stamp.exists() && stamp.readText().trim() == doviVersion }
+  doLast {
+    doviDir.mkdirs()
+    val baseUrl = "https://github.com/edde746/libdovi-builds/releases/download/v$doviVersion"
+    doviAbis.forEach { (abi, triple) ->
+      val archive = File(doviDir, "$triple.tar.gz")
+      exec { commandLine("curl", "-sfL", "$baseUrl/libdovi-$triple.tar.gz", "-o", archive.absolutePath) }
+      val outDir = File(doviDir, "$abi/lib")
+      outDir.mkdirs()
+      exec { commandLine("tar", "-xzf", archive.absolutePath, "-C", outDir.absolutePath) }
+      archive.delete()
     }
+    stamp.writeText(doviVersion)
+  }
 }
 
 android {
-    namespace = "com.edde746.plezy"
-    compileSdk = flutter.compileSdkVersion
-    ndkVersion = flutter.ndkVersion
+  namespace = "com.edde746.plezy"
+  compileSdk = flutter.compileSdkVersion
+  ndkVersion = flutter.ndkVersion
 
-    compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_11
-        targetCompatibility = JavaVersion.VERSION_11
-    }
+  compileOptions {
+    sourceCompatibility = JavaVersion.VERSION_11
+    targetCompatibility = JavaVersion.VERSION_11
+  }
 
-    kotlinOptions {
-        jvmTarget = JavaVersion.VERSION_11.toString()
-    }
+  kotlinOptions {
+    jvmTarget = JavaVersion.VERSION_11.toString()
+  }
 
-    defaultConfig {
-        applicationId = "com.edde746.plezy"
-        // You can update the following values to match your application needs.
-        // For more information, see: https://flutter.dev/to/review-gradle-config.
-        minSdk = 25  // Fire OS 6.x (API 25); overrides libmpv-android's minSdk=26
-        targetSdk = flutter.targetSdkVersion
-        versionCode = flutter.versionCode
-        versionName = flutter.versionName
-
-        externalNativeBuild {
-            cmake {
-                arguments += listOf(
-                    "-DDOVI_ENABLE_LIBDOVI=ON",
-                    "-DDOVI_LIBDOVI_PREBUILT_ROOT=${doviDir.absolutePath}"
-                )
-            }
-        }
-
-        if (System.getenv("AMAZON") != null) {
-            versionCode = (flutter.versionCode ?: 0) + 3000
-            ndk {
-                abiFilters += listOf("armeabi-v7a", "arm64-v8a")
-            }
-        }
-    }
+  defaultConfig {
+    applicationId = "com.edde746.plezy"
+    // You can update the following values to match your application needs.
+    // For more information, see: https://flutter.dev/to/review-gradle-config.
+    minSdk = 25 // Fire OS 6.x (API 25); overrides libmpv-android's minSdk=26
+    targetSdk = flutter.targetSdkVersion
+    versionCode = flutter.versionCode
+    versionName = flutter.versionName
 
     externalNativeBuild {
-        cmake {
-            path = file("src/main/cpp/CMakeLists.txt")
-        }
+      cmake {
+        arguments += listOf(
+          "-DDOVI_ENABLE_LIBDOVI=ON",
+          "-DDOVI_LIBDOVI_PREBUILT_ROOT=${doviDir.absolutePath}"
+        )
+      }
     }
 
-    signingConfigs {
-        create("release") {
-            val keystorePropertiesFile = rootProject.file("key.properties")
-            if (keystorePropertiesFile.exists()) {
-                val keystoreProperties = Properties()
-                keystoreProperties.load(FileInputStream(keystorePropertiesFile))
-
-                keyAlias = keystoreProperties["keyAlias"] as String
-                keyPassword = keystoreProperties["keyPassword"] as String
-                storeFile = file(keystoreProperties["storeFile"] as String)
-                storePassword = keystoreProperties["storePassword"] as String
-            }
-        }
+    if (System.getenv("AMAZON") != null) {
+      versionCode = (flutter.versionCode ?: 0) + 3000
+      ndk {
+        abiFilters += listOf("armeabi-v7a", "arm64-v8a")
+      }
     }
+  }
 
-    buildTypes {
-        release {
-            // Only use release signing if key.properties exists (not in CI/CD)
-            val keystorePropertiesFile = rootProject.file("key.properties")
-            if (keystorePropertiesFile.exists()) {
-                signingConfig = signingConfigs.getByName("release")
-            }
-            // If key.properties doesn't exist, it will use debug signing for CI builds
-            ndk {
-                debugSymbolLevel = "FULL"
-            }
-        }
+  externalNativeBuild {
+    cmake {
+      path = file("src/main/cpp/CMakeLists.txt")
     }
+  }
 
-    packaging {
-        jniLibs {
-            // Resolve conflict between libass-android and libmpv native libraries
-            pickFirsts.add("lib/*/libc++_shared.so")
-        }
+  signingConfigs {
+    create("release") {
+      val keystorePropertiesFile = rootProject.file("key.properties")
+      if (keystorePropertiesFile.exists()) {
+        val keystoreProperties = Properties()
+        keystoreProperties.load(FileInputStream(keystorePropertiesFile))
+
+        keyAlias = keystoreProperties["keyAlias"] as String
+        keyPassword = keystoreProperties["keyPassword"] as String
+        storeFile = file(keystoreProperties["storeFile"] as String)
+        storePassword = keystoreProperties["storePassword"] as String
+      }
     }
+  }
+
+  buildTypes {
+    release {
+      // Only use release signing if key.properties exists (not in CI/CD)
+      val keystorePropertiesFile = rootProject.file("key.properties")
+      if (keystorePropertiesFile.exists()) {
+        signingConfig = signingConfigs.getByName("release")
+      }
+      // If key.properties doesn't exist, it will use debug signing for CI builds
+      ndk {
+        debugSymbolLevel = "FULL"
+      }
+    }
+  }
+
+  packaging {
+    jniLibs {
+      // Resolve conflict between libass-android and libmpv native libraries
+      pickFirsts.add("lib/*/libc++_shared.so")
+    }
+  }
 }
 
 flutter {
-    source = "../.."
+  source = "../.."
 }
 
 // Download libdovi before any CMake/native build task
 tasks.matching { it.name.contains("CMake") || it.name.contains("externalNative") }.configureEach {
-    dependsOn(downloadLibdovi)
+  dependsOn(downloadLibdovi)
+}
+
+// Download libmpv and libass AARs before compilation
+tasks.matching { it.name.startsWith("pre") && it.name.endsWith("Build") }.configureEach {
+  dependsOn(downloadLibmpv)
+  dependsOn(downloadLibass)
 }
 
 dependencies {
-    implementation("dev.jdtech.mpv:libmpv:0.5.1")
+  implementation(files(File(mpvDir, mpvAar)))
+  implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.0")
 
-    // Android TV Watch Next integration
-    implementation("androidx.tvprovider:tvprovider:1.0.0")
+  // Android TV Watch Next integration
+  implementation("androidx.tvprovider:tvprovider:1.0.0")
 
-    // Media3 ExoPlayer for Android
-    implementation("androidx.media3:media3-exoplayer:1.9.2")
-    implementation("androidx.media3:media3-ui:1.9.2")
-    implementation("androidx.media3:media3-common:1.9.2")
+  // Media3 ExoPlayer for Android
+  implementation("androidx.media3:media3-exoplayer:1.9.2")
+  implementation("androidx.media3:media3-exoplayer-hls:1.9.2")
+  implementation("androidx.media3:media3-ui:1.9.2")
+  implementation("androidx.media3:media3-common:1.9.2")
 
-    // OkHttp for connection pooling (prevents TCP reconnect stutter at high bitrates)
-    implementation("com.squareup.okhttp3:okhttp:4.12.0")
-    implementation("androidx.media3:media3-datasource-okhttp:1.9.2")
+  // Cronet for HTTP/2 multiplexing + better connection management
+  implementation("androidx.media3:media3-datasource-cronet:1.9.2")
+  implementation("org.chromium.net:cronet-embedded:143.7445.0")
 
-    // FFmpeg audio decoder for unsupported codecs (ALAC, DTS, TrueHD, etc.)
-    implementation("org.jellyfin.media3:media3-ffmpeg-decoder:1.9.0+1")
+  // FFmpeg audio decoder for unsupported codecs (ALAC, DTS, TrueHD, etc.)
+  implementation("org.jellyfin.media3:media3-ffmpeg-decoder:1.9.0+1")
 
-    // libass-android for ASS/SSA subtitle rendering
-    implementation("io.github.peerless2012:ass-media:0.4.0")
-    // ass-kt core library (needed for AssRender.setFontScale)
-    implementation("io.github.peerless2012:ass-kt:0.4.0")
+  // libass-android for ASS/SSA subtitle rendering
+  assAars.forEach { implementation(files(File(assDir, it))) }
+
+  testImplementation("junit:junit:4.13.2")
 }

android/app/src/main/AndroidManifest.xml

@@ -6,12 +6,11 @@
     <!-- Internet access permissions -->
     <uses-permission android:name="android.permission.INTERNET"/>
 
-    <!-- Camera permission for QR code scanning (companion remote pairing) -->
-    <uses-permission android:name="android.permission.CAMERA"/>
 
     <!-- PIP and media session foreground service permissions -->
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK"/>
+    <uses-permission android:name="android.permission.REORDER_TASKS"/>
 
     <!-- Background download notifications and foreground service -->
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
@@ -23,6 +22,7 @@
     <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" tools:node="remove" />
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" tools:node="remove" />
 
+
     <!-- Android TV support (not required, but allow detection) -->
     <uses-feature android:name="android.software.leanback" android:required="false" />
     <!-- Android TV Watch Next integration -->
@@ -59,6 +59,9 @@
               android:name="io.flutter.embedding.android.NormalTheme"
               android:resource="@style/NormalTheme"
               />
+            <meta-data
+                android:name="flutter_deeplinking_enabled"
+                android:value="false" />
             <intent-filter>
                 <action android:name="android.intent.action.MAIN"/>
                 <category android:name="android.intent.category.LAUNCHER"/>

android/app/src/main/cpp/dovi_bridge.cpp

@@ -1,6 +1,9 @@
-#include <jni.h>
 #include <android/log.h>
+#include <jni.h>
+
 #include <cstring>
+#include <new>
+#include <vector>
 
 #define TAG "DoviBridge"
 #define LOGI(...) __android_log_print(ANDROID_LOG_INFO, TAG, __VA_ARGS__)
@@ -11,95 +14,133 @@
 #endif
 
 static const char* BRIDGE_VERSION = "1.0.0";
+static constexpr jint CONVERT_FAILED = -1;
+static constexpr jint DESTINATION_TOO_SMALL = -2;
+static constexpr jint MAX_RPU_INPUT_SIZE = 8192;
+static constexpr size_t MAX_RPU_OUTPUT_SIZE = 16384;
 
-extern "C" JNIEXPORT jbyteArray JNICALL
-Java_com_edde746_plezy_exoplayer_DoviBridge_nativeConvertDv7RpuToDv81(
-    JNIEnv *env, jclass, jbyteArray payload, jint mode) {
+extern "C" JNIEXPORT jint JNICALL Java_com_edde746_plezy_exoplayer_DoviBridge_nativeConvertDv7RpuToDv81(
+    JNIEnv* env, jclass, jbyteArray payload, jint payload_offset, jint payload_length, jbyteArray output,
+    jint output_offset, jint output_capacity, jint mode) {
 #if !DOVI_REAL_LINKED
-    return nullptr;
+  return CONVERT_FAILED;
 #else
-    if (payload == nullptr) return nullptr;
+  if (payload == nullptr || output == nullptr) return CONVERT_FAILED;
+  if (payload_offset < 0 || payload_length <= 0 || output_offset < 0 || output_capacity < 0) {
+    return CONVERT_FAILED;
+  }
 
-    jsize len = env->GetArrayLength(payload);
-    if (len <= 0) return nullptr;
+  const jsize payload_array_len = env->GetArrayLength(payload);
+  const jsize output_array_len = env->GetArrayLength(output);
+  if (payload_offset > payload_array_len || payload_length > payload_array_len - payload_offset) {
+    return CONVERT_FAILED;
+  }
+  if (output_offset > output_array_len) return DESTINATION_TOO_SMALL;
 
-    jbyte *buf = env->GetByteArrayElements(payload, nullptr);
-    if (buf == nullptr) return nullptr;
+  const jsize logical_output_len = output_capacity < output_array_len ? output_capacity : output_array_len;
+  if (output_offset > logical_output_len) return DESTINATION_TOO_SMALL;
 
-    // Try dovi_parse_unspec62_nalu first (handles escaped NALs), fallback to dovi_parse_rpu
-    DoviRpuOpaque *rpu = dovi_parse_unspec62_nalu(
-        reinterpret_cast<const uint8_t *>(buf), static_cast<size_t>(len));
+  // Valid RPU NALs are typically <2 KiB; reject unreasonable sizes
+  if (payload_length > MAX_RPU_INPUT_SIZE) {
+    LOGW("RPU payload too large (%d bytes), skipping", payload_length);
+    return CONVERT_FAILED;
+  }
 
+  // Copy to native heap so libdovi never touches JVM heap memory.
+  // Do not use GetPrimitiveArrayCritical here: it can block concurrent GC
+  // compaction during sustained playback. A thread-local scratch buffer avoids
+  // per-frame heap churn while keeping libdovi away from JVM heap memory.
+  thread_local std::vector<uint8_t> scratch;
+  try {
+    scratch.resize(static_cast<size_t>(payload_length));
+  } catch (...) {
+    return CONVERT_FAILED;
+  }
+
+  env->GetByteArrayRegion(payload, payload_offset, payload_length, reinterpret_cast<jbyte*>(scratch.data()));
+  if (env->ExceptionCheck()) {
+    return CONVERT_FAILED;
+  }
+
+  // Try dovi_parse_unspec62_nalu first (handles escaped NALs), fallback to dovi_parse_rpu
+  const auto rpu_len = static_cast<size_t>(payload_length);
+  DoviRpuOpaque* rpu = dovi_parse_unspec62_nalu(scratch.data(), rpu_len);
+
+  if (rpu == nullptr) {
+    return CONVERT_FAILED;
+  }
+
+  const char* err = dovi_rpu_get_error(rpu);
+  if (err != nullptr) {
+    // Fallback: try dovi_parse_rpu (raw RPU without NAL framing)
+    dovi_rpu_free(rpu);
+    rpu = dovi_parse_rpu(scratch.data(), rpu_len);
     if (rpu == nullptr) {
-        env->ReleaseByteArrayElements(payload, buf, JNI_ABORT);
-        return nullptr;
+      return CONVERT_FAILED;
     }
-
-    const char *err = dovi_rpu_get_error(rpu);
+    err = dovi_rpu_get_error(rpu);
     if (err != nullptr) {
-        // Fallback: try dovi_parse_rpu (raw RPU without NAL framing)
-        dovi_rpu_free(rpu);
-        rpu = dovi_parse_rpu(
-            reinterpret_cast<const uint8_t *>(buf), static_cast<size_t>(len));
-        if (rpu == nullptr) {
-            env->ReleaseByteArrayElements(payload, buf, JNI_ABORT);
-            return nullptr;
-        }
-        err = dovi_rpu_get_error(rpu);
-        if (err != nullptr) {
-            LOGW("RPU parse failed: %s", err);
-            dovi_rpu_free(rpu);
-            env->ReleaseByteArrayElements(payload, buf, JNI_ABORT);
-            return nullptr;
-        }
+      LOGW("RPU parse failed: %s", err);
+      dovi_rpu_free(rpu);
+      return CONVERT_FAILED;
     }
+  }
 
-    env->ReleaseByteArrayElements(payload, buf, JNI_ABORT);
+  // Mode 2 matches Kodi's P8.1 compatibility path and sets luma/chroma curves to no-op.
+  int32_t ret = dovi_convert_rpu_with_mode(rpu, static_cast<uint8_t>(mode));
+  if (ret != 0) {
+    err = dovi_rpu_get_error(rpu);
+    LOGW("RPU conversion failed (mode %d): %s", mode, err ? err : "unknown");
+    dovi_rpu_free(rpu);
+    return CONVERT_FAILED;
+  }
 
-    // Convert to target profile (mode 2 = P8.1 with no-op curves)
-    int32_t ret = dovi_convert_rpu_with_mode(rpu, static_cast<uint8_t>(mode));
-    if (ret != 0) {
-        err = dovi_rpu_get_error(rpu);
-        LOGW("RPU conversion failed (mode %d): %s", mode, err ? err : "unknown");
-        dovi_rpu_free(rpu);
-        return nullptr;
-    }
-
-    // Write back as UNSPEC62 NAL
-    const DoviData *out = dovi_write_unspec62_nalu(rpu);
-    if (out == nullptr || out->data == nullptr || out->len == 0) {
-        err = dovi_rpu_get_error(rpu);
-        LOGW("RPU write failed: %s", err ? err : "unknown");
-        if (out != nullptr) dovi_data_free(out);
-        dovi_rpu_free(rpu);
-        return nullptr;
-    }
-
-    jbyteArray result = env->NewByteArray(static_cast<jsize>(out->len));
-    if (result != nullptr) {
-        env->SetByteArrayRegion(result, 0, static_cast<jsize>(out->len),
-            reinterpret_cast<const jbyte *>(out->data));
-    }
+  // Write back as UNSPEC62 NAL
+  const DoviData* out = dovi_write_unspec62_nalu(rpu);
+  if (out == nullptr || out->data == nullptr || out->len == 0) {
+    err = dovi_rpu_get_error(rpu);
+    LOGW("RPU write failed: %s", err ? err : "unknown");
+    if (out != nullptr) dovi_data_free(out);
+    dovi_rpu_free(rpu);
+    return CONVERT_FAILED;
+  }
 
+  if (out->len > MAX_RPU_OUTPUT_SIZE) {
+    LOGW("RPU output unexpectedly large (%zu bytes), discarding", out->len);
     dovi_data_free(out);
     dovi_rpu_free(rpu);
+    return CONVERT_FAILED;
+  }
 
-    return result;
+  const auto writable = static_cast<size_t>(logical_output_len - output_offset);
+  if (out->len > writable) {
+    dovi_data_free(out);
+    dovi_rpu_free(rpu);
+    return DESTINATION_TOO_SMALL;
+  }
+
+  env->SetByteArrayRegion(
+      output, output_offset, static_cast<jsize>(out->len), reinterpret_cast<const jbyte*>(out->data));
+  const bool write_failed = env->ExceptionCheck();
+  const auto written = static_cast<jint>(out->len);
+
+  dovi_data_free(out);
+  dovi_rpu_free(rpu);
+
+  return write_failed ? CONVERT_FAILED : written;
 #endif
 }
 
 extern "C" JNIEXPORT jboolean JNICALL
-Java_com_edde746_plezy_exoplayer_DoviBridge_nativeIsConversionPathReady(
-    JNIEnv *, jclass) {
+Java_com_edde746_plezy_exoplayer_DoviBridge_nativeIsConversionPathReady(JNIEnv*, jclass) {
 #if DOVI_REAL_LINKED
-    return JNI_TRUE;
+  return JNI_TRUE;
 #else
-    return JNI_FALSE;
+  return JNI_FALSE;
 #endif
 }
 
 extern "C" JNIEXPORT jstring JNICALL
-Java_com_edde746_plezy_exoplayer_DoviBridge_nativeGetBridgeVersion(
-    JNIEnv *env, jclass) {
-    return env->NewStringUTF(BRIDGE_VERSION);
+Java_com_edde746_plezy_exoplayer_DoviBridge_nativeGetBridgeVersion(JNIEnv* env, jclass) {
+  return env->NewStringUTF(BRIDGE_VERSION);
 }

android/app/src/main/kotlin/com/edde746/plezy/MainActivity.kt

@@ -1,313 +1,734 @@
 package com.edde746.plezy
 
-import android.content.Intent
-import android.net.Uri
-import android.os.Build
-import android.os.Bundle
+import android.app.Activity
+import android.app.ActivityManager
 import android.app.AppOpsManager
 import android.app.PictureInPictureParams
 import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
 import android.content.res.Configuration
+import android.graphics.SurfaceTexture
+import android.net.Uri
+import android.os.Build
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.provider.Settings
+import android.util.Log
 import android.util.Rational
+import android.view.InputDevice
 import android.view.KeyEvent
+import android.view.TextureView
 import android.view.ViewGroup
+import android.view.WindowInsets
 import android.view.inputmethod.InputMethodManager
 import android.widget.FrameLayout
 import androidx.core.content.FileProvider
+import com.edde746.plezy.exoplayer.ExoPlayerPlugin
+import com.edde746.plezy.mpv.MpvPlayerPlugin
+import com.edde746.plezy.shared.DeviceQuirks
+import com.edde746.plezy.shared.ThemeHelper
+import com.edde746.plezy.watchnext.WatchNextPlugin
 import io.flutter.embedding.android.FlutterActivity
+import io.flutter.embedding.android.FlutterTextureView
 import io.flutter.embedding.android.RenderMode
 import io.flutter.embedding.android.TransparencyMode
 import io.flutter.embedding.engine.FlutterEngine
+import io.flutter.embedding.engine.FlutterShellArgs
 import io.flutter.plugin.common.MethodChannel
-import com.edde746.plezy.exoplayer.ExoPlayerPlugin
-import com.edde746.plezy.mpv.MpvPlayerPlugin
-import com.edde746.plezy.shared.ThemeHelper
-import com.edde746.plezy.watchnext.WatchNextPlugin
 import java.io.File
 
 class MainActivity : FlutterActivity() {
 
-    private val PIP_CHANNEL = "com.plezy/pip"
-    private val EXTERNAL_PLAYER_CHANNEL = "com.plezy/external_player"
-    private val THEME_CHANNEL = "com.plezy/theme"
-    private var watchNextPlugin: WatchNextPlugin? = null
+  companion object {
+    private const val TAG = "MainActivity"
+    private const val TEXT_INPUT_DIAGNOSTICS_ENABLED = false
+    private const val EXTERNAL_PLAYER_REQUEST_CODE = 7461
 
-    // Auto PiP state
-    private var autoPipReady = false
-    private var autoPipWidth: Int = 16
-    private var autoPipHeight: Int = 9
+    // External player result APIs used by Jellyfin Android TV.
+    private const val API_MX_RETURN_RESULT = "return_result"
+    private const val API_MX_RESULT_ID = "com.mxtech.intent.result.VIEW"
+    private const val API_MX_RESULT_POSITION = "position"
+    private const val API_MX_RESULT_DURATION = "duration"
+    private const val API_MX_RESULT_END_BY = "end_by"
+    private const val API_MX_RESULT_END_BY_PLAYBACK_COMPLETION = "playback_completion"
+    private const val API_MX_TITLE = "title"
+    private const val API_MX_FILENAME = "filename"
+    private const val API_MX_SECURE_URI = "secure_uri"
+    private const val API_VLC_RESULT_POSITION = "extra_position"
+    private const val API_VLC_RESULT_DURATION = "extra_duration"
 
-    override fun onCreate(savedInstanceState: Bundle?) {
-        // Apply persisted theme color to the window background before anything
-        // else renders.  This prevents a white flash between the native splash
-        // screen and Flutter's first frame for non-default themes (e.g. OLED).
-        val prefs = getSharedPreferences("plezy_prefs", Context.MODE_PRIVATE)
-        val savedTheme = prefs.getString("splash_theme", null)
-        ThemeHelper.themeColor(savedTheme)?.let { window.decorView.setBackgroundColor(it) }
+    private const val API_VIMU_TITLE = "forcename"
+    private const val API_VIMU_SEEK_POSITION = "startfrom"
+    private const val API_VIMU_RESUME = "forceresume"
+    private const val API_VIMU_RESULT_ID = "net.gtvbox.videoplayer.result"
+    private const val API_VIMU_RESULT_ERROR = 4
+    private const val API_VIMU_RESULT_PLAYBACK_COMPLETED = 1
 
-        super.onCreate(savedInstanceState)
+    private val externalPlayerPositionExtras = arrayOf(API_MX_RESULT_POSITION, API_VLC_RESULT_POSITION)
+    private val externalPlayerDurationExtras = arrayOf(API_MX_RESULT_DURATION, API_VLC_RESULT_DURATION)
 
-        // Disable the Android splash screen fade-out animation to avoid
-        // a flicker before Flutter draws its first frame.
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-            splashScreen.setOnExitAnimationListener { splashScreenView -> splashScreenView.remove() }
+    var usingSkia = false
+  }
+
+  private val PIP_CHANNEL = "com.plezy/pip"
+  private val EXTERNAL_PLAYER_CHANNEL = "com.plezy/external_player"
+  private val THEME_CHANNEL = "com.plezy/theme"
+  private val DEVICE_CHANNEL = "com.plezy/device"
+  private val TEXT_INPUT_CHANNEL = "com.plezy/text_input"
+  private val APP_EXIT_CHANNEL = "com.plezy/app_exit"
+  private val APP_FOREGROUND_CHANNEL = "com.plezy/app_foreground"
+  private var watchNextPlugin: WatchNextPlugin? = null
+  private var nativeTextInputFocused = false
+  private var pendingExternalPlayerResult: MethodChannel.Result? = null
+
+  private inline fun logTextInputDiag(message: () -> String) {
+    if (TEXT_INPUT_DIAGNOSTICS_ENABLED) {
+      Log.i(TAG, "TextInputDiag ${message()}")
+    }
+  }
+
+  // Auto PiP state
+  private var autoPipReady = false
+  private var autoPipWidth: Int = 16
+  private var autoPipHeight: Int = 9
+
+  private fun isAndroidTvDevice(): Boolean = getAndroidTvDetection()["isTv"] as Boolean
+
+  private fun isImeVisible(): Boolean {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) return false
+    return window.decorView.rootWindowInsets?.isVisible(WindowInsets.Type.ime()) == true
+  }
+
+  private fun keyActionName(action: Int): String = when (action) {
+    KeyEvent.ACTION_DOWN -> "down"
+    KeyEvent.ACTION_UP -> "up"
+    KeyEvent.ACTION_MULTIPLE -> "multiple"
+    else -> "unknown($action)"
+  }
+
+  private fun sourceNames(source: Int): String {
+    val names = mutableListOf<String>()
+    if ((source and InputDevice.SOURCE_KEYBOARD) == InputDevice.SOURCE_KEYBOARD) names.add("keyboard")
+    if ((source and InputDevice.SOURCE_DPAD) == InputDevice.SOURCE_DPAD) names.add("dpad")
+    if ((source and InputDevice.SOURCE_GAMEPAD) == InputDevice.SOURCE_GAMEPAD) names.add("gamepad")
+    if ((source and InputDevice.SOURCE_JOYSTICK) == InputDevice.SOURCE_JOYSTICK) names.add("joystick")
+    if ((source and InputDevice.SOURCE_TOUCHSCREEN) == InputDevice.SOURCE_TOUCHSCREEN) names.add("touchscreen")
+    if ((source and InputDevice.SOURCE_MOUSE) == InputDevice.SOURCE_MOUSE) names.add("mouse")
+    return names.ifEmpty { listOf("unknown") }.joinToString("+")
+  }
+
+  private fun isDpadKeyCode(keyCode: Int): Boolean = when (keyCode) {
+    KeyEvent.KEYCODE_DPAD_UP,
+    KeyEvent.KEYCODE_DPAD_DOWN,
+    KeyEvent.KEYCODE_DPAD_LEFT,
+    KeyEvent.KEYCODE_DPAD_RIGHT,
+    KeyEvent.KEYCODE_DPAD_CENTER,
+    KeyEvent.KEYCODE_BACK,
+    KeyEvent.KEYCODE_ENTER,
+    KeyEvent.KEYCODE_NUMPAD_ENTER -> true
+    else -> false
+  }
+
+  private fun describeDevice(event: KeyEvent): String {
+    val device = event.device ?: return "device=null deviceId=${event.deviceId}"
+    return "deviceId=${event.deviceId} name=${device.name} vendor=${device.vendorId} product=${device.productId} " +
+      "keyboardType=${device.keyboardType} sources=0x${Integer.toHexString(device.sources)}[${sourceNames(device.sources)}]"
+  }
+
+  private fun describeKeyEvent(event: KeyEvent): String = "action=${keyActionName(event.action)} key=${KeyEvent.keyCodeToString(event.keyCode)}(${event.keyCode}) " +
+    "scan=${event.scanCode} repeat=${event.repeatCount} source=0x${Integer.toHexString(event.source)}[${sourceNames(event.source)}] " +
+    "flags=0x${Integer.toHexString(event.flags)} meta=0x${Integer.toHexString(event.metaState)} ${describeDevice(event)}"
+
+  private fun describeImeState(): String {
+    val imm = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
+    val focus = currentFocus
+    return "nativeTextInputFocused=$nativeTextInputFocused imeVisible=${isImeVisible()} " +
+      "acceptingText=${imm.isAcceptingText} activeDecor=${imm.isActive(window.decorView)} " +
+      "decorHasFocus=${window.decorView.hasFocus()} currentFocus=${focus?.javaClass?.name} " +
+      "currentFocusHasFocus=${focus?.hasFocus()} currentFocusFocused=${focus?.isFocused}"
+  }
+
+  private fun shouldForwardDpadBeforeIme(): Boolean {
+    val imm = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
+    val forward = !nativeTextInputFocused && !isImeVisible() && !imm.isAcceptingText
+    logTextInputDiag { "shouldForwardDpadBeforeIme=$forward ${describeImeState()}" }
+    return forward
+  }
+
+  private fun getAndroidTvDetection(): Map<String, Any> {
+    val pm = packageManager
+    val uiModeType = resources.configuration.uiMode and Configuration.UI_MODE_TYPE_MASK
+    val isTelevisionUiMode = uiModeType == Configuration.UI_MODE_TYPE_TELEVISION
+
+    @Suppress("DEPRECATION")
+    val hasTelevisionFeature = pm.hasSystemFeature(PackageManager.FEATURE_TELEVISION)
+    val hasLeanback = pm.hasSystemFeature(PackageManager.FEATURE_LEANBACK)
+    val hasFireTvFeature = pm.hasSystemFeature("amazon.hardware.fire_tv")
+    val hasTouchscreen = pm.hasSystemFeature(PackageManager.FEATURE_TOUCHSCREEN)
+    val hasFakeTouch = pm.hasSystemFeature(PackageManager.FEATURE_FAKETOUCH)
+
+    val reasons = mutableListOf<String>()
+    if (isTelevisionUiMode) reasons.add("ui_mode_television")
+    if (hasTelevisionFeature) reasons.add("television_feature")
+    if (hasLeanback) reasons.add("leanback")
+    if (hasFireTvFeature) reasons.add("fire_tv")
+    if (!hasTouchscreen) reasons.add("no_touchscreen")
+
+    return mapOf(
+      "isTv" to reasons.isNotEmpty(),
+      "reasons" to reasons,
+      "isTelevisionUiMode" to isTelevisionUiMode,
+      "hasTelevisionFeature" to hasTelevisionFeature,
+      "hasLeanback" to hasLeanback,
+      "hasFireTvFeature" to hasFireTvFeature,
+      "hasTouchscreen" to hasTouchscreen,
+      "hasFakeTouch" to hasFakeTouch,
+      "manufacturer" to Build.MANUFACTURER,
+      "model" to Build.MODEL
+    )
+  }
+
+  /** User-assigned device name (Settings > About > Device name), or null. */
+  private fun getDeviceName(): String? {
+    // The name the user gave the device; also used by Cast/Nearby.
+    val name = Settings.Global.getString(contentResolver, Settings.Global.DEVICE_NAME)
+    if (!name.isNullOrBlank()) return name
+    // Fallback: the Bluetooth name usually mirrors the device name. Reading the
+    // settings string needs no BLUETOOTH permission (unlike BluetoothAdapter).
+    val bt = Settings.Secure.getString(contentResolver, "bluetooth_name")
+    return if (!bt.isNullOrBlank()) bt else null
+  }
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    // Apply persisted theme color to the window background before anything
+    // else renders.  This prevents a white flash between the native splash
+    // screen and Flutter's first frame for non-default themes (e.g. OLED).
+    val prefs = getSharedPreferences("plezy_prefs", Context.MODE_PRIVATE)
+    val savedTheme = prefs.getString("splash_theme", null)
+    ThemeHelper.themeColor(savedTheme)?.let { window.decorView.setBackgroundColor(it) }
+
+    super.onCreate(savedInstanceState)
+
+    // Disable the Android splash screen fade-out animation to avoid
+    // a flicker before Flutter draws its first frame.
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      splashScreen.setOnExitAnimationListener { splashScreenView -> splashScreenView.remove() }
+    }
+
+    // Disable Android's default focus highlight ring that appears when using
+    // D-pad navigation so the Flutter UI can render its own focus state.
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      window.decorView.defaultFocusHighlightEnabled = false
+    }
+
+    // Wrap the content view in a layout that intercepts DPAD key events
+    // before the IME input stage, which can consume DPAD direction events
+    // from virtual remotes before they reach Flutter's key handler.
+    val content = findViewById<ViewGroup>(android.R.id.content)
+    val wrapper = object : FrameLayout(this) {
+      override fun dispatchKeyEventPreIme(event: KeyEvent): Boolean {
+        if (isDpadKeyCode(event.keyCode)) {
+          logTextInputDiag { "preIme received ${describeKeyEvent(event)} ${describeImeState()}" }
         }
-
-        // Disable Android's default focus highlight ring that appears when using
-        // D-pad navigation so the Flutter UI can render its own focus state.
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            window.decorView.defaultFocusHighlightEnabled = false
-        }
-
-        // Wrap the content view in a layout that intercepts DPAD key events
-        // before the IME input stage, which can consume DPAD direction events
-        // from virtual remotes before they reach Flutter's key handler.
-        val content = findViewById<ViewGroup>(android.R.id.content)
-        val wrapper = object : FrameLayout(this) {
-            override fun dispatchKeyEventPreIme(event: KeyEvent): Boolean {
-                when (event.keyCode) {
-                    KeyEvent.KEYCODE_DPAD_UP,
-                    KeyEvent.KEYCODE_DPAD_DOWN,
-                    KeyEvent.KEYCODE_DPAD_LEFT,
-                    KeyEvent.KEYCODE_DPAD_RIGHT,
-                    KeyEvent.KEYCODE_DPAD_CENTER -> {
-                        val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
-                        if (!imm.isAcceptingText) {
-                            super.dispatchKeyEvent(event)
-                            return true
-                        }
-                    }
-                }
-                return super.dispatchKeyEventPreIme(event)
+        when (event.keyCode) {
+          KeyEvent.KEYCODE_DPAD_UP,
+          KeyEvent.KEYCODE_DPAD_DOWN,
+          KeyEvent.KEYCODE_DPAD_LEFT,
+          KeyEvent.KEYCODE_DPAD_RIGHT,
+          KeyEvent.KEYCODE_DPAD_CENTER -> {
+            if (shouldForwardDpadBeforeIme()) {
+              logTextInputDiag { "preIme forwarding-to-Flutter-and-consuming ${describeKeyEvent(event)}" }
+              super.dispatchKeyEvent(event)
+              return true
             }
+            logTextInputDiag { "preIme letting-IME-handle ${describeKeyEvent(event)}" }
+          }
         }
-        while (content.childCount > 0) {
-            val child = content.getChildAt(0)
-            content.removeViewAt(0)
-            wrapper.addView(child)
+        val handled = super.dispatchKeyEventPreIme(event)
+        if (isDpadKeyCode(event.keyCode)) {
+          logTextInputDiag { "preIme superResult=$handled ${describeKeyEvent(event)} ${describeImeState()}" }
         }
-        content.addView(wrapper, ViewGroup.LayoutParams(
-            ViewGroup.LayoutParams.MATCH_PARENT,
-            ViewGroup.LayoutParams.MATCH_PARENT))
+        return handled
+      }
+    }
+    while (content.childCount > 0) {
+      val child = content.getChildAt(0)
+      content.removeViewAt(0)
+      wrapper.addView(child)
+    }
+    content.addView(
+      wrapper,
+      ViewGroup.LayoutParams(
+        ViewGroup.LayoutParams.MATCH_PARENT,
+        ViewGroup.LayoutParams.MATCH_PARENT
+      )
+    )
 
-        // Handle Watch Next deep link from initial launch
-        handleWatchNextIntent(intent)
+    // Handle Watch Next deep link from initial launch
+    handleWatchNextIntent(intent)
+  }
+
+  override fun onNewIntent(intent: Intent) {
+    super.onNewIntent(intent)
+    // Handle Watch Next deep link when app is already running
+    handleWatchNextIntent(intent)
+  }
+
+  override fun dispatchKeyEvent(event: KeyEvent): Boolean {
+    if (isDpadKeyCode(event.keyCode)) {
+      logTextInputDiag { "activity.dispatchKeyEvent before ${describeKeyEvent(event)} ${describeImeState()}" }
+    }
+    val handled = super.dispatchKeyEvent(event)
+    if (isDpadKeyCode(event.keyCode)) {
+      logTextInputDiag {
+        "activity.dispatchKeyEvent after handled=$handled ${describeKeyEvent(event)} ${describeImeState()}"
+      }
+    }
+    return handled
+  }
+
+  override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
+    if (requestCode == EXTERNAL_PLAYER_REQUEST_CODE) {
+      val pendingResult = pendingExternalPlayerResult
+      pendingExternalPlayerResult = null
+      if (pendingResult == null) {
+        Log.w(TAG, "External player result received without a pending channel result")
+      } else {
+        pendingResult.success(buildExternalPlayerResult(resultCode, data))
+      }
+      return
     }
 
-    override fun onNewIntent(intent: Intent) {
-        super.onNewIntent(intent)
-        // Handle Watch Next deep link when app is already running
-        handleWatchNextIntent(intent)
+    super.onActivityResult(requestCode, resultCode, data)
+  }
+
+  private fun buildExternalPlayerResult(resultCode: Int, data: Intent?): Map<String, Any?> {
+    val extras = data?.extras
+    val endPosition = firstNumberExtra(extras, externalPlayerPositionExtras)
+    val duration = firstNumberExtra(extras, externalPlayerDurationExtras)
+    val action = data?.action
+    val playbackCompleted = when (action) {
+      API_MX_RESULT_ID -> extras?.getString(API_MX_RESULT_END_BY) == API_MX_RESULT_END_BY_PLAYBACK_COMPLETION
+      API_VIMU_RESULT_ID -> resultCode == API_VIMU_RESULT_PLAYBACK_COMPLETED
+      else -> false
+    }
+    val playbackError = when (action) {
+      API_VIMU_RESULT_ID -> resultCode == API_VIMU_RESULT_ERROR
+      else -> false
     }
 
-    private fun handleWatchNextIntent(intent: Intent?) {
-        val contentId = WatchNextPlugin.handleIntent(intent)
-        if (contentId != null) {
-            // Notify the plugin to send event to Flutter
-            watchNextPlugin?.notifyDeepLink(contentId)
+    return mapOf(
+      "launched" to true,
+      "resultCode" to resultCode,
+      "resultOk" to (resultCode == Activity.RESULT_OK),
+      "action" to action,
+      "positionMs" to endPosition,
+      "durationMs" to duration,
+      "playbackCompleted" to playbackCompleted,
+      "playbackError" to playbackError
+    )
+  }
+
+  private fun firstNumberExtra(extras: Bundle?, keys: Array<String>): Long? {
+    if (extras == null) return null
+    for (key in keys) {
+      @Suppress("DEPRECATION")
+      val value = extras.get(key)
+      when (value) {
+        is Number -> return value.toLong()
+        is String -> value.toLongOrNull()?.let { return it }
+      }
+    }
+    return null
+  }
+
+  override fun onDestroy() {
+    pendingExternalPlayerResult?.error("ACTIVITY_DESTROYED", "Activity was destroyed while external player was active", null)
+    pendingExternalPlayerResult = null
+    super.onDestroy()
+  }
+
+  private fun handleWatchNextIntent(intent: Intent?) {
+    val contentId = WatchNextPlugin.handleIntent(intent)
+    if (contentId != null) {
+      // Notify the plugin to send event to Flutter
+      watchNextPlugin?.notifyDeepLink(contentId)
+    }
+  }
+
+  override fun getFlutterShellArgs(): FlutterShellArgs {
+    val args = super.getFlutterShellArgs()
+    usingSkia = shouldDisableImpeller()
+    if (usingSkia) args.add("--enable-impeller=false")
+    return args
+  }
+
+  private fun shouldDisableImpeller(): Boolean {
+    // Android TV devices — weaker GPUs, less Impeller testing
+    if (isAndroidTvDevice()) return true
+    if (DeviceQuirks.isEWaste) return true
+    // NVIDIA Tegra (Shield TV)
+    if (Build.MANUFACTURER.equals("NVIDIA", ignoreCase = true)) return true
+    // Huawei/HONOR Kirin SoCs use Mali GPUs
+    if (Build.MANUFACTURER.equals("Huawei", ignoreCase = true) ||
+      Build.MANUFACTURER.equals("HONOR", ignoreCase = true)
+    ) {
+      return true
+    }
+    return false
+  }
+
+  override fun getRenderMode(): RenderMode {
+    // Keep Flutter in the normal View hierarchy so video/subtitle SurfaceViews
+    // remain the only native composition layers. This restores the pre-1.35.0
+    // behavior and avoids compositor regressions with Dolby Vision playback.
+    return RenderMode.texture
+  }
+
+  override fun getTransparencyMode(): TransparencyMode {
+    // Keep Flutter transparent so video/subtitles are visible below.
+    return TransparencyMode.transparent
+  }
+
+  override fun onFlutterTextureViewCreated(flutterTextureView: FlutterTextureView) {
+    val original = flutterTextureView.surfaceTextureListener ?: return
+    val handler = Handler(Looper.getMainLooper())
+    var pendingResize: Runnable? = null
+    var lastWidth = 0
+    var lastHeight = 0
+
+    flutterTextureView.surfaceTextureListener = object : TextureView.SurfaceTextureListener {
+      override fun onSurfaceTextureAvailable(surface: SurfaceTexture, width: Int, height: Int) {
+        original.onSurfaceTextureAvailable(surface, width, height)
+      }
+
+      override fun onSurfaceTextureSizeChanged(surface: SurfaceTexture, width: Int, height: Int) {
+        if (width == lastWidth && height == lastHeight) return
+        lastWidth = width
+        lastHeight = height
+        pendingResize?.let { handler.removeCallbacks(it) }
+        pendingResize = Runnable {
+          if (flutterTextureView.isAvailable) {
+            original.onSurfaceTextureSizeChanged(surface, width, height)
+          }
         }
+        handler.postDelayed(pendingResize!!, 100)
+      }
+
+      override fun onSurfaceTextureUpdated(surface: SurfaceTexture) {
+        original.onSurfaceTextureUpdated(surface)
+      }
+
+      override fun onSurfaceTextureDestroyed(surface: SurfaceTexture): Boolean {
+        pendingResize?.let { handler.removeCallbacks(it) }
+        pendingResize = null
+        lastWidth = 0
+        lastHeight = 0
+        return original.onSurfaceTextureDestroyed(surface)
+      }
+    }
+  }
+
+  override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
+    super.configureFlutterEngine(flutterEngine)
+    flutterEngine.plugins.add(MpvPlayerPlugin())
+    flutterEngine.plugins.add(ExoPlayerPlugin())
+
+    MethodChannel(flutterEngine.dartExecutor.binaryMessenger, DEVICE_CHANNEL).setMethodCallHandler { call, result ->
+      when (call.method) {
+        "getTvDetection" -> result.success(getAndroidTvDetection())
+        "getDeviceName" -> result.success(getDeviceName())
+        else -> result.notImplemented()
+      }
     }
 
-    override fun getRenderMode(): RenderMode {
-        // Use TextureView so Flutter doesn't occupy a SurfaceView layer.
-        // This allows the libass subtitle SurfaceView to sit between video and Flutter UI.
-        return RenderMode.texture
+    MethodChannel(flutterEngine.dartExecutor.binaryMessenger, TEXT_INPUT_CHANNEL).setMethodCallHandler { call, result ->
+      when (call.method) {
+        "setNativeTextInputFocused" -> {
+          val oldValue = nativeTextInputFocused
+          nativeTextInputFocused = call.arguments as? Boolean ?: false
+          logTextInputDiag {
+            "methodChannel setNativeTextInputFocused old=$oldValue new=$nativeTextInputFocused ${describeImeState()}"
+          }
+          result.success(null)
+        }
+        else -> result.notImplemented()
+      }
     }
 
-    override fun getTransparencyMode(): TransparencyMode {
-        // Keep Flutter transparent so video/subtitles are visible below.
-        return TransparencyMode.transparent
+    MethodChannel(flutterEngine.dartExecutor.binaryMessenger, APP_EXIT_CHANNEL).setMethodCallHandler { call, result ->
+      when (call.method) {
+        "requestExit" -> {
+          result.success(true)
+          window.decorView.post {
+            finishAndRemoveTask()
+          }
+        }
+        else -> result.notImplemented()
+      }
     }
 
-    override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
-        super.configureFlutterEngine(flutterEngine)
-        flutterEngine.plugins.add(MpvPlayerPlugin())
-        flutterEngine.plugins.add(ExoPlayerPlugin())
+    MethodChannel(flutterEngine.dartExecutor.binaryMessenger, APP_FOREGROUND_CHANNEL).setMethodCallHandler { call, result ->
+      when (call.method) {
+        "requestForeground" -> result.success(requestForeground())
+        else -> result.notImplemented()
+      }
+    }
 
-        // External player: open local video files with proper content:// URIs
-        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, EXTERNAL_PLAYER_CHANNEL).setMethodCallHandler { call, result ->
-            when (call.method) {
-                "openVideo" -> {
-                    val filePath = call.argument<String>("filePath")
-                    val packageName = call.argument<String>("package")
+    // External player: open local video files with proper content:// URIs
+    MethodChannel(flutterEngine.dartExecutor.binaryMessenger, EXTERNAL_PLAYER_CHANNEL).setMethodCallHandler { call, result ->
+      when (call.method) {
+        "openVideo" -> {
+          val filePath = call.argument<String>("filePath")
+          val packageName = call.argument<String>("package")
+          val title = call.argument<String>("title")?.trim()?.takeIf { it.isNotEmpty() }
+          val startPositionMs = call.argument<Number>("startPositionMs")?.toLong() ?: 0L
 
-                    if (filePath == null) {
-                        result.error("INVALID_ARGUMENT", "filePath is required", null)
-                        return@setMethodCallHandler
-                    }
+          if (filePath == null) {
+            result.error("INVALID_ARGUMENT", "filePath is required", null)
+            return@setMethodCallHandler
+          }
 
-                    try {
-                        val uri: Uri
-                        val grantRead: Boolean
+          if (pendingExternalPlayerResult != null) {
+            result.error("ALREADY_ACTIVE", "An external player is already active", null)
+            return@setMethodCallHandler
+          }
 
-                        if (filePath.startsWith("http://") || filePath.startsWith("https://")) {
-                            uri = Uri.parse(filePath)
-                            grantRead = false
-                        } else if (filePath.startsWith("content://")) {
-                            uri = Uri.parse(filePath)
-                            grantRead = true
-                        } else {
-                            val path = if (filePath.startsWith("file://")) filePath.removePrefix("file://") else filePath
-                            uri = FileProvider.getUriForFile(this, "com.edde746.plezy.fileprovider", File(path))
-                            grantRead = true
-                        }
+          try {
+            val uri: Uri
+            val grantRead: Boolean
+            val fileName: String?
 
-                        val intent = Intent(Intent.ACTION_VIEW).apply {
-                            setDataAndType(uri, "video/*")
-                            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-                            if (grantRead) {
-                                addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
-                            }
-                            if (packageName != null) {
-                                setPackage(packageName)
-                            }
-                        }
-                        startActivity(intent)
-                        result.success(true)
-                    } catch (e: android.content.ActivityNotFoundException) {
-                        result.error("APP_NOT_FOUND", "No app found for package: $packageName", null)
-                    } catch (e: Exception) {
-                        result.error("LAUNCH_FAILED", e.message ?: e.javaClass.simpleName, null)
-                    }
-                }
-                else -> result.notImplemented()
+            if (filePath.startsWith("http://") || filePath.startsWith("https://")) {
+              uri = Uri.parse(filePath)
+              grantRead = false
+              fileName = uri.lastPathSegment
+            } else if (filePath.startsWith("content://")) {
+              uri = Uri.parse(filePath)
+              grantRead = true
+              fileName = uri.lastPathSegment
+            } else {
+              val path = if (filePath.startsWith("file://")) filePath.removePrefix("file://") else filePath
+              fileName = File(path).name
+              uri = FileProvider.getUriForFile(this, "com.edde746.plezy.fileprovider", File(path))
+              grantRead = true
             }
-        }
 
-        // Splash screen theme: persist user's chosen theme for next launch (API 31+)
-        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, THEME_CHANNEL).setMethodCallHandler { call, result ->
-            when (call.method) {
-                "setSplashTheme" -> {
-                    val mode = call.argument<String>("mode")
-
-                    // Persist for next cold start & update window background now
-                    getSharedPreferences("plezy_prefs", Context.MODE_PRIVATE)
-                        .edit().putString("splash_theme", mode).apply()
-                    ThemeHelper.themeColor(mode)?.let { window.decorView.setBackgroundColor(it) }
-
-                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-                        val themeId = when (mode) {
-                            "dark" -> R.style.SplashTheme_Dark
-                            "oled" -> R.style.SplashTheme_Oled
-                            "light" -> R.style.SplashTheme_Light
-                            "system" -> android.content.res.Resources.ID_NULL
-                            else -> android.content.res.Resources.ID_NULL
-                        }
-                        splashScreen.setSplashScreenTheme(themeId)
-                    }
-                    result.success(true)
-                }
-                else -> result.notImplemented()
-            }
-        }
-
-        // Register Watch Next plugin and keep reference for deep link handling
-        watchNextPlugin = WatchNextPlugin()
-        flutterEngine.plugins.add(watchNextPlugin!!)
-
-        MethodChannel( flutterEngine.dartExecutor.binaryMessenger, PIP_CHANNEL ).setMethodCallHandler { call, result ->
-            when (call.method) {
-                "isSupported" -> {
-                    result.success(Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
-                }
-                "enter" -> {
-                    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
-                        result.success(mapOf("success" to false, "errorCode" to "android_version"))
-                        return@setMethodCallHandler
-                    }
-
-                    if (!isPipPermissionGranted()) {
-                        result.success(mapOf("success" to false, "errorCode" to "permission_disabled"))
-                        return@setMethodCallHandler
-                    }
-
-                    try {
-                        val width = call.argument<Int>("width") ?: 16
-                        val height = call.argument<Int>("height") ?: 9
-                        val clamped = clampAspectRatio(width, height)
-
-                        val params = PictureInPictureParams.Builder()
-                            .setAspectRatio(Rational(clamped.first, clamped.second))
-                            .build()
-                        val success = enterPictureInPictureMode(params)
-                        if (success) {
-                            result.success(mapOf("success" to true))
-                        } else {
-                            result.success(mapOf("success" to false, "errorCode" to "failed"))
-                        }
-                    } catch (e: IllegalStateException) {
-                        result.success(mapOf("success" to false, "errorCode" to "not_supported"))
-                    } catch (e: Exception) {
-                        result.success(mapOf("success" to false, "errorCode" to "unknown", "errorMessage" to (e.message ?: "Unknown error")))
-                    }
-                }
-                "setAutoPipReady" -> {
-                    autoPipReady = call.argument<Boolean>("ready") ?: false
-                    autoPipWidth = call.argument<Int>("width") ?: 16
-                    autoPipHeight = call.argument<Int>("height") ?: 9
-
-                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-                        try {
-                            val clamped = clampAspectRatio(autoPipWidth, autoPipHeight)
-                            val params = PictureInPictureParams.Builder()
-                                .setAspectRatio(Rational(clamped.first, clamped.second))
-                                .setAutoEnterEnabled(autoPipReady)
-                                .build()
-                            setPictureInPictureParams(params)
-                        } catch (_: Exception) {}
-                    }
-                    result.success(true)
-                }
-                else -> result.notImplemented()
+            val intent = Intent(Intent.ACTION_VIEW).apply {
+              setDataAndType(uri, "video/*")
+              if (grantRead) {
+                addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+              }
+              if (packageName != null) {
+                setPackage(packageName)
+              }
+              val startPosition = startPositionMs.coerceAtLeast(0).coerceAtMost(Int.MAX_VALUE.toLong()).toInt()
+              if (startPosition > 0) {
+                putExtra(API_MX_RESULT_POSITION, startPosition)
+                putExtra(API_VIMU_SEEK_POSITION, startPosition)
+              }
+              putExtra(API_MX_RETURN_RESULT, true)
+              putExtra(API_MX_SECURE_URI, true)
+              putExtra(API_VIMU_RESUME, false)
+              title?.let {
+                putExtra(API_MX_TITLE, it)
+                putExtra(API_VIMU_TITLE, it)
+              }
+              fileName?.let { putExtra(API_MX_FILENAME, it) }
             }
+            pendingExternalPlayerResult = result
+            startActivityForResult(intent, EXTERNAL_PLAYER_REQUEST_CODE)
+          } catch (e: android.content.ActivityNotFoundException) {
+            pendingExternalPlayerResult = null
+            result.error("APP_NOT_FOUND", "No app found for package: $packageName", null)
+          } catch (e: Exception) {
+            pendingExternalPlayerResult = null
+            result.error("LAUNCH_FAILED", e.message ?: e.javaClass.simpleName, null)
+          }
         }
+        else -> result.notImplemented()
+      }
     }
 
-    override fun onPictureInPictureModeChanged(isInPictureInPictureMode: Boolean,newConfig: Configuration) {
-        super.onPictureInPictureModeChanged(isInPictureInPictureMode, newConfig)
-        flutterEngine?.let { engine ->
-            MethodChannel(engine.dartExecutor.binaryMessenger, PIP_CHANNEL).invokeMethod("onPipChanged", isInPictureInPictureMode)
-            engine.plugins.get(ExoPlayerPlugin::class.java)?.let { plugin ->
-                (plugin as? ExoPlayerPlugin)?.onPipModeChanged(isInPictureInPictureMode)
+    // Splash screen theme: persist user's chosen theme for next launch (API 31+)
+    MethodChannel(flutterEngine.dartExecutor.binaryMessenger, THEME_CHANNEL).setMethodCallHandler { call, result ->
+      when (call.method) {
+        "getRenderer" -> result.success(if (usingSkia) "Skia" else "Impeller")
+        "setSplashTheme" -> {
+          val mode = call.argument<String>("mode")
+
+          // Persist for next cold start & update window background now
+          getSharedPreferences("plezy_prefs", Context.MODE_PRIVATE)
+            .edit().putString("splash_theme", mode).apply()
+          ThemeHelper.themeColor(mode)?.let { window.decorView.setBackgroundColor(it) }
+
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            val themeId = when (mode) {
+              "dark" -> R.style.SplashTheme_Dark
+              "oled" -> R.style.SplashTheme_Oled
+              "light" -> R.style.SplashTheme_Light
+              "system" -> android.content.res.Resources.ID_NULL
+              else -> android.content.res.Resources.ID_NULL
             }
+            splashScreen.setSplashScreenTheme(themeId)
+          }
+          result.success(true)
         }
+        else -> result.notImplemented()
+      }
     }
 
-    override fun onUserLeaveHint() {
-        super.onUserLeaveHint()
-        // Auto PiP for API 26-30 (API 31+ uses setAutoEnterEnabled)
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O &&
-            Build.VERSION.SDK_INT < Build.VERSION_CODES.S &&
-            autoPipReady && isPipPermissionGranted()) {
+    // Register Watch Next plugin and keep reference for deep link handling
+    watchNextPlugin = WatchNextPlugin()
+    flutterEngine.plugins.add(watchNextPlugin!!)
+
+    MethodChannel(flutterEngine.dartExecutor.binaryMessenger, PIP_CHANNEL).setMethodCallHandler { call, result ->
+      when (call.method) {
+        "isSupported" -> {
+          result.success(Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && !isAndroidTvDevice())
+        }
+        "enter" -> {
+          if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+            result.success(mapOf("success" to false, "errorCode" to "android_version"))
+            return@setMethodCallHandler
+          }
+
+          if (isAndroidTvDevice()) {
+            result.success(mapOf("success" to false, "errorCode" to "not_supported"))
+            return@setMethodCallHandler
+          }
+
+          if (!isPipPermissionGranted()) {
+            result.success(mapOf("success" to false, "errorCode" to "permission_disabled"))
+            return@setMethodCallHandler
+          }
+
+          try {
+            val width = call.argument<Int>("width") ?: 16
+            val height = call.argument<Int>("height") ?: 9
+            val params = buildPipParams(width, height)
+            val success = enterPictureInPictureMode(params)
+            if (success) {
+              result.success(mapOf("success" to true))
+            } else {
+              result.success(mapOf("success" to false, "errorCode" to "failed"))
+            }
+          } catch (e: IllegalStateException) {
+            result.success(mapOf("success" to false, "errorCode" to "not_supported"))
+          } catch (e: Exception) {
+            result.success(mapOf("success" to false, "errorCode" to "unknown", "errorMessage" to (e.message ?: "Unknown error")))
+          }
+        }
+        "setAutoPipReady" -> {
+          if (isAndroidTvDevice()) {
+            autoPipReady = false
+            result.success(true)
+            return@setMethodCallHandler
+          }
+
+          autoPipReady = call.argument<Boolean>("ready") ?: false
+          autoPipWidth = call.argument<Int>("width") ?: 16
+          autoPipHeight = call.argument<Int>("height") ?: 9
+
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
             try {
-                // Notify Flutter to prepare video filter before PiP
-                flutterEngine?.dartExecutor?.binaryMessenger?.let { messenger ->
-                    MethodChannel(messenger, PIP_CHANNEL).invokeMethod("onAutoPipEntering", null)
-                }
-                val clamped = clampAspectRatio(autoPipWidth, autoPipHeight)
-                val params = PictureInPictureParams.Builder()
-                    .setAspectRatio(Rational(clamped.first, clamped.second))
-                    .build()
-                enterPictureInPictureMode(params)
-            } catch (_: Exception) {}
+              val params = buildPipParams(autoPipWidth, autoPipHeight, autoEnterEnabled = autoPipReady)
+              setPictureInPictureParams(params)
+            } catch (e: Exception) {
+              Log.w(TAG, "Failed to set auto-PiP params", e)
+            }
+          }
+          result.success(true)
         }
+        else -> result.notImplemented()
+      }
     }
+  }
 
-    private fun isPipPermissionGranted(): Boolean {
-        val appOpsManager = getSystemService(Context.APP_OPS_SERVICE) as AppOpsManager
-        return appOpsManager.checkOpNoThrow(
-            AppOpsManager.OPSTR_PICTURE_IN_PICTURE,
-            applicationInfo.uid,
-            packageName
-        ) == AppOpsManager.MODE_ALLOWED
+  private fun requestForeground(): Boolean = try {
+    val activityManager = getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
+    activityManager.moveTaskToFront(taskId, 0)
+    true
+  } catch (e: Exception) {
+    Log.w(TAG, "Failed to move task to foreground", e)
+    try {
+      val launchIntent = packageManager.getLaunchIntentForPackage(packageName)?.apply {
+        addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT)
+        addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
+        addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
+        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+      }
+      if (launchIntent != null) {
+        startActivity(launchIntent)
+        true
+      } else {
+        false
+      }
+    } catch (launchError: Exception) {
+      Log.w(TAG, "Failed to start foreground activity", launchError)
+      false
     }
+  }
 
-    private fun clampAspectRatio(width: Int, height: Int): Pair<Int, Int> {
-        val ratio = width.toFloat() / height.toFloat()
-        return when {
-            ratio < 0.42f -> Pair(5, 12)
-            ratio > 2.39f -> Pair(12, 5)
-            else -> Pair(width, height)
+  override fun onPictureInPictureModeChanged(isInPictureInPictureMode: Boolean, newConfig: Configuration) {
+    super.onPictureInPictureModeChanged(isInPictureInPictureMode, newConfig)
+    flutterEngine?.let { engine ->
+      MethodChannel(engine.dartExecutor.binaryMessenger, PIP_CHANNEL).invokeMethod("onPipChanged", isInPictureInPictureMode)
+      engine.plugins.get(ExoPlayerPlugin::class.java)?.let { plugin ->
+        (plugin as? ExoPlayerPlugin)?.onPipModeChanged(isInPictureInPictureMode)
+      }
+    }
+  }
+
+  override fun onUserLeaveHint() {
+    super.onUserLeaveHint()
+    // Auto PiP for API 26-30 (API 31+ uses setAutoEnterEnabled)
+    if (!isAndroidTvDevice() &&
+      Build.VERSION.SDK_INT >= Build.VERSION_CODES.O &&
+      Build.VERSION.SDK_INT < Build.VERSION_CODES.S &&
+      autoPipReady &&
+      isPipPermissionGranted()
+    ) {
+      try {
+        // Notify Flutter to prepare video filter before PiP
+        flutterEngine?.dartExecutor?.binaryMessenger?.let { messenger ->
+          MethodChannel(messenger, PIP_CHANNEL).invokeMethod("onAutoPipEntering", null)
         }
+        val params = buildPipParams(autoPipWidth, autoPipHeight)
+        enterPictureInPictureMode(params)
+      } catch (e: Exception) {
+        Log.w(TAG, "Failed to enter auto-PiP", e)
+      }
     }
+  }
+
+  private fun isPipPermissionGranted(): Boolean {
+    val appOpsManager = getSystemService(Context.APP_OPS_SERVICE) as AppOpsManager
+    return appOpsManager.checkOpNoThrow(
+      AppOpsManager.OPSTR_PICTURE_IN_PICTURE,
+      applicationInfo.uid,
+      packageName
+    ) == AppOpsManager.MODE_ALLOWED
+  }
+
+  private fun buildPipParams(width: Int, height: Int, autoEnterEnabled: Boolean? = null): PictureInPictureParams {
+    val (w, h) = if (width <= 0 || height <= 0) {
+      Pair(16, 9)
+    } else {
+      val ratio = width.toFloat() / height.toFloat()
+      when {
+        ratio < 1f / 2.39f -> Pair(100, 239)
+        ratio > 2.39f -> Pair(239, 100)
+        else -> Pair(width, height)
+      }
+    }
+    val builder = PictureInPictureParams.Builder()
+      .setAspectRatio(Rational(w, h))
+    if (autoEnterEnabled != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      builder.setAutoEnterEnabled(autoEnterEnabled)
+    }
+    return builder.build()
+  }
 }

android/app/src/main/kotlin/com/edde746/plezy/exoplayer/CuelessSeekExtractorWrapper.kt

@@ -0,0 +1,169 @@
+package com.edde746.plezy.exoplayer
+
+import android.util.Log
+import androidx.media3.common.C
+import androidx.media3.extractor.Extractor
+import androidx.media3.extractor.ExtractorInput
+import androidx.media3.extractor.ExtractorOutput
+import androidx.media3.extractor.PositionHolder
+import androidx.media3.extractor.SeekMap
+import androidx.media3.extractor.SeekPoint
+import androidx.media3.extractor.TrackOutput
+
+/**
+ * Extractor wrapper that enables approximate seeking for MKV files without Cues.
+ *
+ * When the underlying extractor reports an [SeekMap.Unseekable] seek map (i.e. the MKV
+ * has no Cues element), this wrapper replaces it with a proportional byte-position
+ * estimate and scans for the nearest Cluster boundary after seeking.
+ */
+@androidx.media3.common.util.UnstableApi
+class CuelessSeekExtractorWrapper(
+  private val delegate: Extractor
+) : Extractor {
+
+  companion object {
+    private const val TAG = "CuelessSeek"
+
+    // MKV Cluster element ID: 0x1F43B675 (4-byte EBML Class-D ID)
+    private val CLUSTER_ID = byteArrayOf(0x1F, 0x43, 0xB6.toByte(), 0x75)
+    private const val SCAN_BUFFER_SIZE = 8192
+
+    // Max bytes to scan for a Cluster boundary before giving up
+    private const val MAX_SCAN_BYTES = 1024 * 1024 // 1 MB
+  }
+
+  private var inputLength: Long = C.LENGTH_UNSET.toLong()
+  private var needsClusterResync = false
+  private var isApproximateSeeking = false
+  private var pendingSeekTimeUs: Long = C.TIME_UNSET
+
+  override fun sniff(input: ExtractorInput): Boolean = delegate.sniff(input)
+
+  override fun init(output: ExtractorOutput) {
+    delegate.init(SeekInterceptingOutput(output))
+  }
+
+  override fun read(input: ExtractorInput, seekPosition: PositionHolder): Int {
+    if (inputLength == C.LENGTH_UNSET.toLong()) {
+      inputLength = input.length
+    }
+    if (needsClusterResync) {
+      needsClusterResync = false
+      return scanForCluster(input, seekPosition)
+    }
+    return delegate.read(input, seekPosition)
+  }
+
+  override fun seek(position: Long, timeUs: Long) {
+    if (isApproximateSeeking && position > 0) {
+      needsClusterResync = true
+      pendingSeekTimeUs = timeUs
+    }
+    delegate.seek(position, timeUs)
+  }
+
+  override fun release() = delegate.release()
+
+  /**
+   * Scan forward from the current input position to find the next MKV Cluster
+   * element ID (0x1F43B675). Returns [Extractor.RESULT_SEEK] with the Cluster's
+   * byte position so ExoPlayer repositions the DataSource there.
+   */
+  private fun scanForCluster(input: ExtractorInput, seekPosition: PositionHolder): Int {
+    val buffer = ByteArray(SCAN_BUFFER_SIZE)
+    var totalScanned = 0L
+    // Carry over last 3 bytes across buffer boundaries to detect split IDs
+    var carry = ByteArray(0)
+
+    while (totalScanned < MAX_SCAN_BYTES) {
+      val toRead = minOf(SCAN_BUFFER_SIZE, (MAX_SCAN_BYTES - totalScanned).toInt())
+      val bytesRead: Int
+      try {
+        bytesRead = input.read(buffer, 0, toRead)
+      } catch (_: Exception) {
+        break
+      }
+      if (bytesRead == C.RESULT_END_OF_INPUT) break
+
+      // Combine carry + new data for scanning
+      val scanData = if (carry.isNotEmpty()) carry + buffer.copyOf(bytesRead) else buffer.copyOf(bytesRead)
+
+      for (i in 0..scanData.size - 4) {
+        if (scanData[i] == CLUSTER_ID[0] &&
+          scanData[i + 1] == CLUSTER_ID[1] &&
+          scanData[i + 2] == CLUSTER_ID[2] &&
+          scanData[i + 3] == CLUSTER_ID[3]
+        ) {
+          // Compute the absolute byte position of this Cluster
+          val clusterPosition = input.position - bytesRead - carry.size + i
+          Log.d(TAG, "Found Cluster at byte $clusterPosition (scanned ${totalScanned + i} bytes)")
+          seekPosition.position = clusterPosition
+          delegate.seek(clusterPosition, pendingSeekTimeUs)
+          pendingSeekTimeUs = C.TIME_UNSET
+          return Extractor.RESULT_SEEK
+        }
+      }
+
+      // Keep last 3 bytes as carry for next iteration
+      carry = if (scanData.size >= 3) scanData.copyOfRange(scanData.size - 3, scanData.size) else scanData.copyOf()
+      totalScanned += bytesRead
+    }
+
+    // Failed to find a Cluster — fall back to position 0
+    Log.w(TAG, "No Cluster found after scanning $totalScanned bytes, resetting to start")
+    seekPosition.position = 0
+    delegate.seek(0, 0)
+    return Extractor.RESULT_SEEK
+  }
+
+  /**
+   * ExtractorOutput wrapper that intercepts [seekMap] calls to replace
+   * [SeekMap.Unseekable] with an approximate proportional SeekMap.
+   */
+  private inner class SeekInterceptingOutput(
+    private val delegate: ExtractorOutput
+  ) : ExtractorOutput {
+
+    override fun track(id: Int, type: Int): TrackOutput = delegate.track(id, type)
+    override fun endTracks() = delegate.endTracks()
+
+    override fun seekMap(seekMap: SeekMap) {
+      if (seekMap is SeekMap.Unseekable) {
+        val durationUs = seekMap.durationUs
+        if (durationUs != C.TIME_UNSET && durationUs > 0) {
+          Log.i(TAG, "Replacing Unseekable with approximate SeekMap (duration=${durationUs / 1_000_000}s)")
+          isApproximateSeeking = true
+          delegate.seekMap(ApproximateSeekMap(durationUs))
+          return
+        }
+      }
+      // File has real Cues or unknown duration — pass through
+      isApproximateSeeking = false
+      delegate.seekMap(seekMap)
+    }
+  }
+
+  /**
+   * Approximate SeekMap that estimates byte positions proportionally.
+   * Used when the MKV has no Cues but has a known duration.
+   */
+  private inner class ApproximateSeekMap(
+    private val durationUs: Long
+  ) : SeekMap {
+
+    override fun isSeekable(): Boolean = true
+
+    override fun getDurationUs(): Long = durationUs
+
+    override fun getSeekPoints(timeUs: Long): SeekMap.SeekPoints {
+      val length = inputLength
+      if (length == C.LENGTH_UNSET.toLong() || durationUs <= 0) {
+        return SeekMap.SeekPoints(SeekPoint(0, 0))
+      }
+      val clampedTimeUs = timeUs.coerceIn(0, durationUs)
+      val position = (clampedTimeUs.toDouble() / durationUs * length).toLong().coerceIn(0, length)
+      return SeekMap.SeekPoints(SeekPoint(clampedTimeUs, position))
+    }
+  }
+}

android/app/src/main/kotlin/com/edde746/plezy/exoplayer/DoviBridge.kt

@@ -1,85 +1,362 @@
 package com.edde746.plezy.exoplayer
 
+import android.content.Context
 import android.media.MediaCodecInfo
 import android.media.MediaCodecList
 import android.os.Build
 import android.util.Log
+import android.view.Display
+import android.view.WindowManager
 
 enum class DvConversionMode { DISABLED, DV81, HEVC_STRIP }
 
 object DoviBridge {
-    private const val TAG = "DoviBridge"
+  private const val TAG = "DoviBridge"
 
-    private val nativeLoaded: Boolean by lazy {
-        try {
-            System.loadLibrary("dovi_bridge")
-            true
-        } catch (_: UnsatisfiedLinkError) {
-            Log.w(TAG, "Native lib not found")
-            false
+  data class DvAutoDecision(
+    val mode: DvConversionMode,
+    val reason: String,
+    val bridgeReady: Boolean,
+    val displayDv: Boolean,
+    val nativeDecoder: Boolean,
+    val advertisedP7: Boolean,
+    val advertisedP8: Boolean,
+    val decoders: String,
+    val displayHdr: String
+  ) {
+    fun logMessage(): String = "AUTO P7 DV decision: mode=$mode; reason=$reason; bridgeReady=$bridgeReady, " +
+      "displayDV=$displayDv, nativeDecoder=$nativeDecoder, advertisedP7=$advertisedP7, " +
+      "advertisedP8=$advertisedP8, decoders=$decoders, displayHdr=$displayHdr"
+  }
+
+  data class Dv7FallbackDecision(
+    val mode: DvConversionMode,
+    val reason: String,
+    val bridgeReady: Boolean,
+    val displayDv: Boolean,
+    val advertisedP8: Boolean,
+    val displayHdr: String
+  ) {
+    fun logMessage(): String = "DV7 fallback decision: mode=$mode; reason=$reason; bridgeReady=$bridgeReady, " +
+      "displayDV=$displayDv, advertisedP8=$advertisedP8, displayHdr=$displayHdr"
+  }
+
+  private val DOLBY_VISION_MIME_TYPES = setOf(
+    "video/dolby-vision",
+    "video/hevcdv",
+    "video/dv_hevc"
+  )
+
+  const val CONVERT_FAILED = -1
+  const val DESTINATION_TOO_SMALL = -2
+
+  private data class DvProfileLevel(val profile: Int, val level: Int)
+
+  private data class DvDecoderCapability(
+    val name: String,
+    val mimeType: String,
+    val profileLevels: List<DvProfileLevel>
+  )
+
+  private val nativeLoaded: Boolean by lazy {
+    try {
+      System.loadLibrary("dovi_bridge")
+      true
+    } catch (_: UnsatisfiedLinkError) {
+      Log.w(TAG, "Native lib not found")
+      false
+    }
+  }
+
+  private val conversionPathReady: Boolean by lazy {
+    nativeLoaded && runCatching { nativeIsConversionPathReady() }.getOrDefault(false)
+  }
+
+  fun isAvailable(): Boolean = conversionPathReady
+
+  private val dolbyVisionDecoders: List<DvDecoderCapability> by lazy {
+    try {
+      val codecList = MediaCodecList(MediaCodecList.REGULAR_CODECS)
+      codecList.codecInfos.flatMap { info ->
+        if (info.isEncoder) {
+          emptyList()
+        } else {
+          info.supportedTypes.mapNotNull { type ->
+            if (!DOLBY_VISION_MIME_TYPES.contains(type.lowercase())) return@mapNotNull null
+            val capabilities = runCatching { info.getCapabilitiesForType(type) }
+              .onFailure { Log.w(TAG, "Failed to query ${info.name} capabilities for $type", it) }
+              .getOrNull()
+              ?: return@mapNotNull null
+            DvDecoderCapability(
+              name = info.name,
+              mimeType = type,
+              profileLevels = capabilities.profileLevels.map { DvProfileLevel(it.profile, it.level) }
+            )
+          }
         }
+      }
+    } catch (e: Exception) {
+      Log.w(TAG, "Failed to query native Dolby Vision decoder support", e)
+      emptyList()
+    }
+  }
+
+  val hasNativeDolbyVisionDecoder: Boolean by lazy {
+    dolbyVisionDecoders.isNotEmpty().also {
+      Log.i(TAG, "Native Dolby Vision decoder available: $it; decoders=${describeDolbyVisionDecoders()}")
+    }
+  }
+
+  private fun deviceAdvertisesDvProfile(profile: Int, minApi: Int = 0): Boolean {
+    if (Build.VERSION.SDK_INT < minApi) return false
+    return dolbyVisionDecoders.any { decoder ->
+      decoder.profileLevels.any { it.profile == profile }
+    }
+  }
+
+  val deviceSupportsDvProfile7: Boolean by lazy {
+    deviceAdvertisesDvProfile(MediaCodecInfo.CodecProfileLevel.DolbyVisionProfileDvheDtb)
+      .also { Log.i(TAG, "Device advertises exact DV Profile 7 (DvheDtb): $it") }
+  }
+
+  val deviceSupportsDvProfile8: Boolean by lazy {
+    deviceAdvertisesDvProfile(MediaCodecInfo.CodecProfileLevel.DolbyVisionProfileDvheSt, minApi = 27)
+      .also { Log.i(TAG, "Device advertises DV Profile 8 (DvheSt): $it") }
+  }
+
+  fun displaySupportsDolbyVision(context: Context): Boolean {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) {
+      Log.i(TAG, "Display Dolby Vision support: false (HDR capabilities require API 24, device API=${Build.VERSION.SDK_INT})")
+      return false
     }
 
-    fun isAvailable(): Boolean = nativeLoaded &&
-        runCatching { nativeIsConversionPathReady() }.getOrDefault(false)
+    val display = getCurrentDisplay(context)
+    if (display == null) {
+      Log.i(TAG, "Display Dolby Vision support: false (no active display)")
+      return false
+    }
 
-    private fun deviceSupportsDvProfile(profile: Int, minApi: Int = 0): Boolean {
-        try {
-            if (Build.VERSION.SDK_INT < minApi) return false
-            val codecList = MediaCodecList(MediaCodecList.REGULAR_CODECS)
-            return codecList.codecInfos.any { info ->
-                !info.isEncoder && info.supportedTypes.any { type ->
-                    type.equals("video/dolby-vision", ignoreCase = true) &&
-                        info.getCapabilitiesForType(type).profileLevels.any { it.profile == profile }
-                }
-            }
-        } catch (e: Exception) {
-            Log.w(TAG, "Failed to query DV profile $profile support", e)
-            return false
+    val hdrTypes = runCatching { getDisplayHdrTypes(display) }.getOrElse { error ->
+      Log.w(TAG, "Display Dolby Vision support: false (failed to query HDR types)", error)
+      return false
+    }
+    val supported = hdrTypes.contains(Display.HdrCapabilities.HDR_TYPE_DOLBY_VISION)
+    Log.i(TAG, "Display Dolby Vision support: $supported; ${describeDisplayHdrCapabilities(display)}")
+    return supported
+  }
+
+  fun describeDisplayHdrCapabilities(context: Context): String {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) return "HDR capabilities unavailable (API=${Build.VERSION.SDK_INT})"
+    val display = getCurrentDisplay(context) ?: return "HDR capabilities unavailable (no active display)"
+    return describeDisplayHdrCapabilities(display)
+  }
+
+  fun logSupportSummary(context: Context) {
+    Log.i(
+      TAG,
+      "DV support summary: bridgeReady=${isAvailable()}, displayDV=${displaySupportsDolbyVision(context)}, " +
+        "nativeDecoder=$hasNativeDolbyVisionDecoder, advertisedP7=$deviceSupportsDvProfile7, " +
+        "advertisedP8=$deviceSupportsDvProfile8, decoders=${describeDolbyVisionDecoders()}, " +
+        "displayHdr=${describeDisplayHdrCapabilities(context)}"
+    )
+  }
+
+  fun getConversionDecision(context: Context): DvAutoDecision {
+    val bridgeReady = isAvailable()
+    val displayDv = displaySupportsDolbyVision(context)
+    val nativeDecoder = hasNativeDolbyVisionDecoder
+    val advertisedP7 = deviceSupportsDvProfile7
+    val advertisedP8 = deviceSupportsDvProfile8
+
+    val mode = when {
+      !displayDv -> DvConversionMode.HEVC_STRIP
+      advertisedP7 -> DvConversionMode.DISABLED
+      advertisedP8 && bridgeReady -> DvConversionMode.DV81
+      else -> DvConversionMode.HEVC_STRIP
+    }
+    val reason = when {
+      !displayDv -> "active display does not support Dolby Vision; stripping DV metadata for HEVC fallback"
+      advertisedP7 -> "active display supports Dolby Vision and decoder advertises exact Profile 7; trying native DV first"
+      advertisedP8 && bridgeReady -> "active display supports Dolby Vision and decoder advertises Profile 8; converting to Profile 8.1"
+      !bridgeReady -> "conversion bridge unavailable; stripping DV metadata for HEVC fallback"
+      else -> "Dolby Vision output path is unavailable; stripping DV metadata for HEVC fallback"
+    }
+    val decision = DvAutoDecision(
+      mode = mode,
+      reason = reason,
+      bridgeReady = bridgeReady,
+      displayDv = displayDv,
+      nativeDecoder = nativeDecoder,
+      advertisedP7 = advertisedP7,
+      advertisedP8 = advertisedP8,
+      decoders = describeDolbyVisionDecoders(),
+      displayHdr = describeDisplayHdrCapabilities(context)
+    )
+    Log.i(TAG, decision.logMessage())
+    return decision
+  }
+
+  fun getConversionMode(context: Context): DvConversionMode = getConversionDecision(context).mode
+
+  /** Get the fallback mode when native DV7 decoding fails. */
+  fun getDv7FallbackDecision(context: Context): Dv7FallbackDecision {
+    val bridgeReady = isAvailable()
+    val displayDv = displaySupportsDolbyVision(context)
+    val advertisedP8 = deviceSupportsDvProfile8
+    val mode = if (displayDv && advertisedP8 && bridgeReady) DvConversionMode.DV81 else DvConversionMode.HEVC_STRIP
+    val reason = when {
+      mode == DvConversionMode.DV81 -> "display supports Dolby Vision and decoder advertises Profile 8"
+      !bridgeReady -> "conversion bridge unavailable; stripping DV metadata for HEVC fallback"
+      else -> "Dolby Vision output or Profile 8 support is unavailable"
+    }
+    val decision = Dv7FallbackDecision(
+      mode = mode,
+      reason = reason,
+      bridgeReady = bridgeReady,
+      displayDv = displayDv,
+      advertisedP8 = advertisedP8,
+      displayHdr = describeDisplayHdrCapabilities(context)
+    )
+    Log.i(TAG, decision.logMessage())
+    return decision
+  }
+
+  fun getDv7FallbackMode(context: Context): DvConversionMode = getDv7FallbackDecision(context).mode
+
+  private fun getCurrentDisplay(context: Context): Display? = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+    context.display
+  } else {
+    @Suppress("DEPRECATION")
+    (context.getSystemService(Context.WINDOW_SERVICE) as? WindowManager)?.defaultDisplay
+  }
+
+  private fun describeDolbyVisionDecoders(): String {
+    if (dolbyVisionDecoders.isEmpty()) return "none"
+    return dolbyVisionDecoders.joinToString { decoder ->
+      val profiles = if (decoder.profileLevels.isEmpty()) {
+        "none"
+      } else {
+        decoder.profileLevels.joinToString(prefix = "[", postfix = "]") {
+          "${describeDvProfile(it.profile)}/${describeDvLevel(it.level)}"
         }
+      }
+      "${decoder.name}(${decoder.mimeType}, profiles=$profiles)"
     }
+  }
 
-    val deviceSupportsDvProfile7: Boolean by lazy {
-        deviceSupportsDvProfile(MediaCodecInfo.CodecProfileLevel.DolbyVisionProfileDvheDtr)
-            .also { Log.i(TAG, "Device DV Profile 7 support: $it") }
+  private fun describeHdrTypes(hdrTypes: IntArray): String {
+    if (hdrTypes.isEmpty()) return "none"
+    return hdrTypes.joinToString(prefix = "[", postfix = "]") { type ->
+      when (type) {
+        Display.HdrCapabilities.HDR_TYPE_DOLBY_VISION -> "DOLBY_VISION"
+        Display.HdrCapabilities.HDR_TYPE_HDR10 -> "HDR10"
+        Display.HdrCapabilities.HDR_TYPE_HLG -> "HLG"
+        Display.HdrCapabilities.HDR_TYPE_HDR10_PLUS -> "HDR10_PLUS"
+        else -> "unknown(${hex(type)})"
+      }
     }
+  }
 
-    val deviceSupportsDvProfile8: Boolean by lazy {
-        deviceSupportsDvProfile(MediaCodecInfo.CodecProfileLevel.DolbyVisionProfileDvheSt, minApi = 27)
-            .also { Log.i(TAG, "Device DV Profile 8 support: $it") }
+  private fun describeDisplayHdrCapabilities(display: Display): String {
+    val hdrCapabilities = display.hdrCapabilities
+    val parts = mutableListOf(
+      "display=${display.displayId}:${display.name}",
+      "activeMode=${describeDisplayMode(display.mode)}",
+      "hdrCapabilities=${describeHdrTypes(hdrCapabilities.supportedHdrTypes)}",
+      "desiredLuminance=max=${formatLuminance(hdrCapabilities.desiredMaxLuminance)}, " +
+        "maxAvg=${formatLuminance(hdrCapabilities.desiredMaxAverageLuminance)}, " +
+        "min=${formatLuminance(hdrCapabilities.desiredMinLuminance)}"
+    )
+    parts += "supportedModes=${display.supportedModes.joinToString(prefix = "[", postfix = "]") { describeDisplayMode(it) }}"
+    return parts.joinToString(prefix = "{", postfix = "}")
+  }
+
+  private fun getDisplayHdrTypes(display: Display): IntArray = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+    display.mode.supportedHdrTypes
+  } else {
+    @Suppress("DEPRECATION")
+    display.hdrCapabilities.supportedHdrTypes
+  }
+
+  private fun describeDisplayMode(mode: Display.Mode): String {
+    val hdr = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+      ", hdr=${describeHdrTypes(mode.supportedHdrTypes)}"
+    } else {
+      ""
     }
+    return "#${mode.modeId} ${mode.physicalWidth}x${mode.physicalHeight}@${mode.refreshRate}Hz$hdr"
+  }
 
-    fun getConversionMode(): DvConversionMode = when {
-        !isAvailable() -> DvConversionMode.DISABLED
-        deviceSupportsDvProfile7 -> DvConversionMode.DISABLED // try native first; ExoPlayerCore retries with conversion on failure
-        deviceSupportsDvProfile8 -> DvConversionMode.DV81
-        else -> DvConversionMode.HEVC_STRIP
+  private fun formatLuminance(value: Float): String = if (value.isNaN() || value <= 0f) "unknown" else "${value}nits"
+
+  private fun describeDvProfile(profile: Int): String = when (profile) {
+    MediaCodecInfo.CodecProfileLevel.DolbyVisionProfileDvavPer -> "P0/DvavPer"
+    MediaCodecInfo.CodecProfileLevel.DolbyVisionProfileDvavPen -> "P1/DvavPen"
+    MediaCodecInfo.CodecProfileLevel.DolbyVisionProfileDvheDer -> "P2/DvheDer"
+    MediaCodecInfo.CodecProfileLevel.DolbyVisionProfileDvheDen -> "P3/DvheDen"
+    MediaCodecInfo.CodecProfileLevel.DolbyVisionProfileDvheDtr -> "P4/DvheDtr"
+    MediaCodecInfo.CodecProfileLevel.DolbyVisionProfileDvheStn -> "P5/DvheStn"
+    MediaCodecInfo.CodecProfileLevel.DolbyVisionProfileDvheDth -> "P6/DvheDth"
+    MediaCodecInfo.CodecProfileLevel.DolbyVisionProfileDvheDtb -> "P7/DvheDtb"
+    MediaCodecInfo.CodecProfileLevel.DolbyVisionProfileDvheSt -> "P8/DvheSt"
+    MediaCodecInfo.CodecProfileLevel.DolbyVisionProfileDvavSe -> "P9/DvavSe"
+    else -> "unknown(${hex(profile)})"
+  }
+
+  private fun describeDvLevel(level: Int): String = when (level) {
+    MediaCodecInfo.CodecProfileLevel.DolbyVisionLevelHd24 -> "L1/Hd24"
+    MediaCodecInfo.CodecProfileLevel.DolbyVisionLevelHd30 -> "L2/Hd30"
+    MediaCodecInfo.CodecProfileLevel.DolbyVisionLevelFhd24 -> "L3/Fhd24"
+    MediaCodecInfo.CodecProfileLevel.DolbyVisionLevelFhd30 -> "L4/Fhd30"
+    MediaCodecInfo.CodecProfileLevel.DolbyVisionLevelFhd60 -> "L5/Fhd60"
+    MediaCodecInfo.CodecProfileLevel.DolbyVisionLevelUhd24 -> "L6/Uhd24"
+    MediaCodecInfo.CodecProfileLevel.DolbyVisionLevelUhd30 -> "L7/Uhd30"
+    MediaCodecInfo.CodecProfileLevel.DolbyVisionLevelUhd48 -> "L8/Uhd48"
+    MediaCodecInfo.CodecProfileLevel.DolbyVisionLevelUhd60 -> "L9/Uhd60"
+    MediaCodecInfo.CodecProfileLevel.DolbyVisionLevelUhd120 -> "L10/Uhd120"
+    MediaCodecInfo.CodecProfileLevel.DolbyVisionLevel8k30 -> "L11/8k30"
+    MediaCodecInfo.CodecProfileLevel.DolbyVisionLevel8k60 -> "L12/8k60"
+    else -> "unknown(${hex(level)})"
+  }
+
+  private fun hex(value: Int): String = "0x${value.toString(16)}"
+
+  fun convertRpuNalu(
+    payload: ByteArray,
+    payloadOffset: Int,
+    payloadLength: Int,
+    output: ByteArray,
+    outputOffset: Int,
+    outputCapacity: Int,
+    mode: Int = 2
+  ): Int {
+    if (!conversionPathReady || payloadLength <= 0) return CONVERT_FAILED
+    return runCatching {
+      nativeConvertDv7RpuToDv81(payload, payloadOffset, payloadLength, output, outputOffset, outputCapacity, mode)
     }
+      .onFailure { Log.w(TAG, "RPU conversion failed: ${it.message}") }
+      .getOrDefault(CONVERT_FAILED)
+  }
 
-    /** Get the fallback mode when native DV7 decoding fails. */
-    fun getDv7FallbackMode(): DvConversionMode = when {
-        deviceSupportsDvProfile8 -> DvConversionMode.DV81
-        else -> DvConversionMode.HEVC_STRIP
-    }
+  fun getVersion(): String? {
+    if (!nativeLoaded) return null
+    return runCatching { nativeGetBridgeVersion() }.getOrNull()
+  }
 
-    fun convertRpuNalu(payload: ByteArray, mode: Int = 2): ByteArray? {
-        if (!isAvailable() || payload.isEmpty()) return null
-        return runCatching { nativeConvertDv7RpuToDv81(payload, mode) }
-            .onFailure { Log.w(TAG, "RPU conversion failed: ${it.message}") }
-            .getOrNull()
-    }
+  @JvmStatic
+  private external fun nativeConvertDv7RpuToDv81(
+    payload: ByteArray,
+    payloadOffset: Int,
+    payloadLength: Int,
+    output: ByteArray,
+    outputOffset: Int,
+    outputCapacity: Int,
+    mode: Int
+  ): Int
 
-    fun getVersion(): String? {
-        if (!nativeLoaded) return null
-        return runCatching { nativeGetBridgeVersion() }.getOrNull()
-    }
+  @JvmStatic
+  private external fun nativeIsConversionPathReady(): Boolean
 
-    @JvmStatic
-    private external fun nativeConvertDv7RpuToDv81(payload: ByteArray, mode: Int): ByteArray?
-
-    @JvmStatic
-    private external fun nativeIsConversionPathReady(): Boolean
-
-    @JvmStatic
-    private external fun nativeGetBridgeVersion(): String
+  @JvmStatic
+  private external fun nativeGetBridgeVersion(): String
 }

android/app/src/main/kotlin/com/edde746/plezy/exoplayer/DoviExtractorWrapper.kt

@@ -14,22 +14,23 @@ import androidx.media3.extractor.TrackOutput
  * Shared by DoviExtractorWrapper for both MP4 and MKV containers.
  */
 class DoviExtractorOutputWrapper(
-    private val delegate: ExtractorOutput,
-    private val dvMode: DvConversionMode,
-    private val onVideoTrackWrapped: (DoviConvertingTrackOutput) -> Unit,
+  private val delegate: ExtractorOutput,
+  private val dvMode: DvConversionMode,
+  private val emitLog: ((String, String, String) -> Unit)?,
+  private val onVideoTrackWrapped: (DoviConvertingTrackOutput) -> Unit
 ) : ExtractorOutput {
-    override fun track(id: Int, type: Int): TrackOutput {
-        val original = delegate.track(id, type)
-        if (type == C.TRACK_TYPE_VIDEO) {
-            val wrapper = DoviConvertingTrackOutput(original, dvMode)
-            onVideoTrackWrapped(wrapper)
-            return wrapper
-        }
-        return original
+  override fun track(id: Int, type: Int): TrackOutput {
+    val original = delegate.track(id, type)
+    if (type == C.TRACK_TYPE_VIDEO) {
+      val wrapper = DoviConvertingTrackOutput(original, dvMode, emitLog)
+      onVideoTrackWrapped(wrapper)
+      return wrapper
     }
+    return original
+  }
 
-    override fun endTracks() = delegate.endTracks()
-    override fun seekMap(seekMap: SeekMap) = delegate.seekMap(seekMap)
+  override fun endTracks() = delegate.endTracks()
+  override fun seekMap(seekMap: SeekMap) = delegate.seekMap(seekMap)
 }
 
 /**
@@ -38,23 +39,23 @@ class DoviExtractorOutputWrapper(
  * DV Profile 7 → 8.1 conversion via inline NAL processing.
  */
 class DoviExtractorWrapper(
-    private val delegate: Extractor,
-    private val dvMode: DvConversionMode = DvConversionMode.HEVC_STRIP,
+  private val delegate: Extractor,
+  private val dvMode: DvConversionMode = DvConversionMode.HEVC_STRIP,
+  private val emitLog: ((String, String, String) -> Unit)? = null
 ) : Extractor {
 
-    @Volatile var doviTrackOutput: DoviConvertingTrackOutput? = null
-        private set
+  @Volatile var doviTrackOutput: DoviConvertingTrackOutput? = null
+    private set
 
-    override fun sniff(input: ExtractorInput): Boolean = delegate.sniff(input)
+  override fun sniff(input: ExtractorInput): Boolean = delegate.sniff(input)
 
-    override fun init(output: ExtractorOutput) {
-        delegate.init(DoviExtractorOutputWrapper(output, dvMode) { doviTrackOutput = it })
-    }
+  override fun init(output: ExtractorOutput) {
+    delegate.init(DoviExtractorOutputWrapper(output, dvMode, emitLog) { doviTrackOutput = it })
+  }
 
-    override fun read(input: ExtractorInput, seekPosition: PositionHolder): Int =
-        delegate.read(input, seekPosition)
+  override fun read(input: ExtractorInput, seekPosition: PositionHolder): Int = delegate.read(input, seekPosition)
 
-    override fun seek(position: Long, timeUs: Long) = delegate.seek(position, timeUs)
+  override fun seek(position: Long, timeUs: Long) = delegate.seek(position, timeUs)
 
-    override fun release() = delegate.release()
+  override fun release() = delegate.release()
 }

android/app/src/main/kotlin/com/edde746/plezy/exoplayer/DvBitstreamSanitizer.kt

@@ -0,0 +1,140 @@
+package com.edde746.plezy.exoplayer
+
+import java.nio.ByteBuffer
+
+/**
+ * In-place sanitizer for HEVC Annex B buffers carrying both Dolby Vision and HDR10+
+ * dynamic metadata. Buggy chipsets (Fire TV 4K Max, MediaTek-based Google TV, ...)
+ * crash or black-screen when a native DV codec also receives in-band HDR10+ SEI, so
+ * only the metadata the active decode path consumes may be kept:
+ *
+ * - Native DV codec: strip HDR10+ SEI NALs (types 39/40 with ST 2094-40 payload),
+ *   the decoder follows the DV RPU. Port of androidx/media#3085 / Kodi xbmc#24584.
+ * - HEVC fallback for a DV format: strip DV RPU/EL NALs (types 62/63) instead,
+ *   leaving HDR10+ for the display.
+ *
+ * Pure JVM (no android/media3 imports) so it stays unit-testable on the host.
+ */
+object DvBitstreamSanitizer {
+
+  private const val NAL_TYPE_PREFIX_SEI = 39
+  private const val NAL_TYPE_SUFFIX_SEI = 40
+  private const val NAL_TYPE_UNSPEC62 = 62 // DV RPU
+  private const val NAL_TYPE_UNSPEC63 = 63 // DV Enhancement Layer
+
+  private const val SEI_PAYLOAD_TYPE_ITU_T_T35 = 4
+
+  /**
+   * Scans `[position, limit)` of [data] for Annex B NAL units and removes the selected
+   * metadata NALs by compacting the buffer in place and reducing its limit. The position
+   * is left unchanged.
+   */
+  fun sanitize(data: ByteBuffer, stripHdr10PlusSei: Boolean, stripDvRpu: Boolean) {
+    val startPos = data.position()
+    val limit = data.limit()
+    var writePos = startPos
+    var nalStartIndex = -1
+    var startCodeLen = 0
+
+    var i = startPos
+    while (i <= limit) {
+      // Find next start code or end of buffer.
+      val atEnd = i == limit
+      var foundStartCode = false
+      var nextStartCodeLen = 0
+      if (!atEnd && i + 2 < limit && data.get(i).toInt() == 0 && data.get(i + 1).toInt() == 0) {
+        if (data.get(i + 2).toInt() == 1) {
+          foundStartCode = true
+          nextStartCodeLen = 3
+        } else if (data.get(i + 2).toInt() == 0 && i + 3 < limit && data.get(i + 3).toInt() == 1) {
+          foundStartCode = true
+          nextStartCodeLen = 4
+        }
+      }
+
+      if (foundStartCode || atEnd) {
+        if (nalStartIndex >= 0) {
+          // Complete NAL unit (including its start code) from nalStartIndex to i.
+          val nalDataStart = nalStartIndex + startCodeLen
+          val nalEnd = i
+          var strip = false
+
+          if (nalEnd - nalDataStart >= 2) {
+            // HEVC NAL header: forbidden_zero_bit(1) + nal_unit_type(6) + nuh_layer_id MSB(1).
+            val nalUnitType = (data.get(nalDataStart).toInt() and 0x7E) shr 1
+            strip = when (nalUnitType) {
+              NAL_TYPE_UNSPEC62, NAL_TYPE_UNSPEC63 -> stripDvRpu
+              NAL_TYPE_PREFIX_SEI, NAL_TYPE_SUFFIX_SEI ->
+                stripHdr10PlusSei && isHdr10PlusSeiNalUnit(data, nalDataStart + 2, nalEnd)
+              else -> false
+            }
+          }
+
+          if (!strip) {
+            if (writePos != nalStartIndex) {
+              for (j in nalStartIndex until nalEnd) {
+                data.put(writePos++, data.get(j))
+              }
+            } else {
+              writePos = nalEnd
+            }
+          }
+        }
+        nalStartIndex = i
+        startCodeLen = nextStartCodeLen
+        i += if (nextStartCodeLen > 0) nextStartCodeLen else 1
+      } else {
+        i++
+      }
+    }
+
+    data.limit(writePos)
+    data.position(startPos)
+  }
+
+  /**
+   * Returns whether the SEI RBSP (starting after the 2-byte HEVC NAL header) begins with an
+   * HDR10+ message: user_data_registered_itu_t_t35 with country code 0xB5 (United States),
+   * provider code 0x003C (Samsung), provider oriented code 0x0001, application identifier 4
+   * (ST 2094-40), application version 0 or 1. Malformed/truncated data returns false so the
+   * NAL is kept.
+   */
+  private fun isHdr10PlusSeiNalUnit(data: ByteBuffer, rbspStart: Int, nalEnd: Int): Boolean {
+    var pos = rbspStart
+    if (pos >= nalEnd) return false
+
+    // SEI payload type: accumulated 0xFF bytes plus the final byte.
+    var payloadType = 0
+    while (pos < nalEnd) {
+      val b = data.get(pos++).toInt() and 0xFF
+      payloadType += b
+      if (b != 0xFF) break
+    }
+
+    // SEI payload size, same encoding.
+    var payloadSize = 0
+    while (pos < nalEnd) {
+      val b = data.get(pos++).toInt() and 0xFF
+      payloadSize += b
+      if (b != 0xFF) break
+    }
+
+    if (payloadType != SEI_PAYLOAD_TYPE_ITU_T_T35 || payloadSize < 7 || pos + 7 > nalEnd) {
+      return false
+    }
+
+    // The identifier bytes (B5 00 3C 00 01 04 00/01) cannot contain the 0x000003 emulation
+    // prevention pattern, so they can be read without RBSP unescaping.
+    val countryCode = data.get(pos).toInt() and 0xFF
+    val providerCode = ((data.get(pos + 1).toInt() and 0xFF) shl 8) or (data.get(pos + 2).toInt() and 0xFF)
+    val orientedCode = ((data.get(pos + 3).toInt() and 0xFF) shl 8) or (data.get(pos + 4).toInt() and 0xFF)
+    val appIdentifier = data.get(pos + 5).toInt() and 0xFF
+    val appVersion = data.get(pos + 6).toInt() and 0xFF
+
+    return countryCode == 0xB5 &&
+      providerCode == 0x003C &&
+      orientedCode == 0x0001 &&
+      appIdentifier == 4 &&
+      (appVersion == 0 || appVersion == 1)
+  }
+}

android/app/src/main/kotlin/com/edde746/plezy/exoplayer/PlezyRenderersFactory.kt

@@ -2,11 +2,17 @@ package com.edde746.plezy.exoplayer
 
 import android.content.Context
 import android.media.AudioDeviceInfo
+import android.os.Build
+import android.os.Handler
 import androidx.annotation.OptIn
+import androidx.media3.common.Format
+import androidx.media3.common.MimeTypes
 import androidx.media3.common.PlaybackParameters
 import androidx.media3.common.util.Clock
 import androidx.media3.common.util.UnstableApi
+import androidx.media3.decoder.DecoderInputBuffer
 import androidx.media3.exoplayer.DefaultRenderersFactory
+import androidx.media3.exoplayer.Renderer
 import androidx.media3.exoplayer.analytics.PlayerId
 import androidx.media3.exoplayer.audio.AudioOutput
 import androidx.media3.exoplayer.audio.AudioOutputProvider
@@ -15,41 +21,104 @@ import androidx.media3.exoplayer.audio.AudioTrackAudioOutputProvider
 import androidx.media3.exoplayer.audio.DefaultAudioSink
 import androidx.media3.exoplayer.audio.DefaultAudioTrackBufferSizeProvider
 import androidx.media3.exoplayer.audio.ForwardingAudioSink
+import androidx.media3.exoplayer.mediacodec.MediaCodecAdapter
+import androidx.media3.exoplayer.mediacodec.MediaCodecSelector
+import androidx.media3.exoplayer.video.MediaCodecVideoRenderer
+import androidx.media3.exoplayer.video.VideoRendererEventListener
 import java.nio.ByteBuffer
 import java.util.concurrent.atomic.AtomicLong
+import kotlin.math.abs
 
 @OptIn(UnstableApi::class)
 class PlezyRenderersFactory(context: Context) : DefaultRenderersFactory(context) {
 
-    override fun buildAudioSink(
-        context: Context,
-        enableFloatOutput: Boolean,
-        enableAudioOutputPlaybackParams: Boolean
-    ): AudioSink {
-        AudioTrackAudioOutputProvider.failOnSpuriousAudioTimestamp = false
+  /** Audio delay in microseconds. Shared with PositionFixAudioSink for live updates. */
+  val audioDelayUs = AtomicLong(0L)
 
-        val bufferSizeProvider = DefaultAudioTrackBufferSizeProvider.Builder()
-            .setMinPcmBufferDurationUs(500_000)
-            .setMaxPcmBufferDurationUs(1_500_000)
-            .setPcmBufferMultiplicationFactor(8)
-            .build()
+  /** Returns whether direct encoded output should be hidden so decoded PCM output can be selected. */
+  var shouldBlockDirectAudioOutput: ((Format) -> Boolean)? = null
 
-        val realProvider = AudioTrackAudioOutputProvider.Builder(context)
-            .setAudioTrackBufferSizeProvider(bufferSizeProvider)
-            .build()
+  /** Called before Media3 reacts to an audio route/capability change. */
+  var onAudioCapabilitiesChanged: (() -> Unit)? = null
 
-        // Shared position: RawPositionAudioOutput writes the raw AudioTrack position,
-        // PositionFixAudioSink reads it to bypass DefaultAudioSink's writtenDuration clamp.
-        val rawPositionUs = AtomicLong(Long.MIN_VALUE)
+  var audioDiagnosticsLogger: ((String, String, String) -> Unit)? = null
 
-        val defaultSink = DefaultAudioSink.Builder(context)
-            .setEnableFloatOutput(enableFloatOutput)
-            .setEnableAudioOutputPlaybackParameters(enableAudioOutputPlaybackParams)
-            .setAudioOutputProvider(RawPositionOutputProvider(realProvider, rawPositionUs))
-            .build()
+  var videoDiagnosticsLogger: ((String, String, String) -> Unit)? = null
 
-        return PositionFixAudioSink(defaultSink, rawPositionUs)
-    }
+  override fun buildVideoRenderers(
+    context: Context,
+    extensionRendererMode: Int,
+    mediaCodecSelector: MediaCodecSelector,
+    enableDecoderFallback: Boolean,
+    eventHandler: Handler,
+    eventListener: VideoRendererEventListener,
+    allowedVideoJoiningTimeMs: Long,
+    out: ArrayList<Renderer>
+  ) {
+    // Let super build the full list (it also appends extension renderers reflectively,
+    // e.g. the jellyfin ffmpeg artifact's video renderer), then swap the stock
+    // MediaCodecVideoRenderer for the DV-sanitizing variant at the same index.
+    super.buildVideoRenderers(
+      context,
+      extensionRendererMode,
+      mediaCodecSelector,
+      enableDecoderFallback,
+      eventHandler,
+      eventListener,
+      allowedVideoJoiningTimeMs,
+      out
+    )
+    val index = out.indexOfFirst { it.javaClass == MediaCodecVideoRenderer::class.java }
+    if (index < 0) return
+    out[index] = DvSanitizingVideoRenderer(
+      MediaCodecVideoRenderer.Builder(context)
+        .setCodecAdapterFactory(codecAdapterFactory)
+        .setMediaCodecSelector(mediaCodecSelector)
+        .setAllowedJoiningTimeMs(allowedVideoJoiningTimeMs)
+        .setEnableDecoderFallback(enableDecoderFallback)
+        .setEventHandler(eventHandler)
+        .setEventListener(eventListener)
+        .setMaxDroppedFramesToNotify(MAX_DROPPED_VIDEO_FRAME_COUNT_TO_NOTIFY),
+      videoDiagnosticsLogger
+    )
+  }
+
+  override fun buildAudioSink(
+    context: Context,
+    enableFloatOutput: Boolean,
+    enableAudioOutputPlaybackParams: Boolean
+  ): AudioSink {
+    AudioTrackAudioOutputProvider.failOnSpuriousAudioTimestamp = false
+
+    val bufferSizeProvider = DefaultAudioTrackBufferSizeProvider.Builder()
+      .setMinPcmBufferDurationUs(500_000)
+      .setMaxPcmBufferDurationUs(1_000_000)
+      .setPcmBufferMultiplicationFactor(4)
+      .build()
+
+    val realProvider = AudioTrackAudioOutputProvider.Builder(context)
+      .setAudioTrackBufferSizeProvider(bufferSizeProvider)
+      .build()
+
+    // Shared position: RawPositionAudioOutput writes the raw AudioTrack position,
+    // PositionFixAudioSink reads it to bypass DefaultAudioSink's writtenDuration clamp.
+    val rawPositionUs = AtomicLong(Long.MIN_VALUE)
+
+    val defaultSink = DefaultAudioSink.Builder(context)
+      .setEnableFloatOutput(enableFloatOutput)
+      .setEnableAudioOutputPlaybackParameters(enableAudioOutputPlaybackParams)
+      .setAudioOutputProvider(RawPositionOutputProvider(realProvider, rawPositionUs, audioDiagnosticsLogger))
+      .build()
+
+    return PositionFixAudioSink(
+      defaultSink,
+      rawPositionUs,
+      audioDelayUs,
+      shouldBlockDirectAudioOutput,
+      onAudioCapabilitiesChanged,
+      audioDiagnosticsLogger
+    )
+  }
 }
 
 /**
@@ -75,186 +144,402 @@ class PlezyRenderersFactory(context: Context) : DefaultRenderersFactory(context)
  */
 @OptIn(UnstableApi::class)
 private class PositionFixAudioSink(
-    sink: AudioSink,
-    private val rawPositionUs: AtomicLong
+  sink: AudioSink,
+  private val rawPositionUs: AtomicLong,
+  private val audioDelayUs: AtomicLong,
+  private val shouldBlockDirectAudioOutput: ((Format) -> Boolean)?,
+  private val onAudioCapabilitiesChanged: (() -> Unit)?,
+  private val log: ((String, String, String) -> Unit)?
 ) : ForwardingAudioSink(sink) {
 
-    private var startMediaTimeUs = Long.MIN_VALUE
-    private var suppressedErrorCount = 0
+  private var startMediaTimeUs = Long.MIN_VALUE
+  private var suppressedErrorCount = 0
 
-    // Speed tracking for position bypass
-    private var currentSpeed = 1.0f
-    private var refMediaTimeUs = Long.MIN_VALUE
-    private var refRawPositionUs = 0L
+  // Speed tracking for position bypass
+  private var currentSpeed = 1.0f
+  private var refMediaTimeUs = Long.MIN_VALUE
+  private var refRawPositionUs = 0L
 
-    override fun handleBuffer(
-        buffer: ByteBuffer,
-        presentationTimeUs: Long,
-        encodedAccessUnitCount: Int
-    ): Boolean {
-        if (startMediaTimeUs == Long.MIN_VALUE) {
-            startMediaTimeUs = presentationTimeUs
-            refMediaTimeUs = presentationTimeUs
-            refRawPositionUs = 0
+  // Transient counter-offset: after seek/flush, ramp offset from 0 to full
+  // over recoveryDurationUs to prevent video frame drops.
+  private var recoveryDurationUs = 0L
+  private val loggedDirectBlockMimeTypes = mutableSetOf<String>()
+  private var loggedFirstBuffer = false
+
+  override fun supportsFormat(format: Format): Boolean {
+    if (blocksDirectAudioOutput(format)) return false
+    return super.supportsFormat(format)
+  }
+
+  override fun getFormatSupport(format: Format): Int {
+    if (blocksDirectAudioOutput(format)) return AudioSink.SINK_FORMAT_UNSUPPORTED
+    return super.getFormatSupport(format)
+  }
+
+  private fun blocksDirectAudioOutput(format: Format): Boolean {
+    if (shouldBlockDirectAudioOutput?.invoke(format) != true) return false
+    val mimeType = format.sampleMimeType ?: "unknown"
+    if (loggedDirectBlockMimeTypes.add(mimeType)) {
+      log?.invoke(
+        "info",
+        "audio",
+        "Blocking direct $mimeType output; decoded PCM output will be preferred"
+      )
+    }
+    return true
+  }
+
+  override fun handleBuffer(
+    buffer: ByteBuffer,
+    presentationTimeUs: Long,
+    encodedAccessUnitCount: Int
+  ): Boolean {
+    if (!loggedFirstBuffer && buffer.hasRemaining()) {
+      loggedFirstBuffer = true
+      log?.invoke(
+        "debug",
+        "audio-sink",
+        "First buffer: size=${buffer.remaining()}B, pts=${presentationTimeUs}us, accessUnits=$encodedAccessUnitCount"
+      )
+    }
+    if (startMediaTimeUs == Long.MIN_VALUE) {
+      startMediaTimeUs = presentationTimeUs
+      refMediaTimeUs = presentationTimeUs
+      refRawPositionUs = 0
+      val delayUs = audioDelayUs.get()
+      recoveryDurationUs = if (delayUs == 0L) 0L else maxOf(200_000L, 2L * abs(delayUs))
+    }
+    return super.handleBuffer(buffer, presentationTimeUs, encodedAccessUnitCount)
+  }
+
+  override fun setPlaybackParameters(playbackParameters: PlaybackParameters) {
+    // Capture reference point before speed changes
+    val rawPos = rawPositionUs.get()
+    if (rawPos > 0 && refMediaTimeUs != Long.MIN_VALUE) {
+      refMediaTimeUs = refMediaTimeUs + ((rawPos - refRawPositionUs) * currentSpeed).toLong()
+      refRawPositionUs = rawPos
+    }
+    currentSpeed = playbackParameters.speed
+    super.setPlaybackParameters(playbackParameters)
+  }
+
+  override fun getCurrentPositionUs(sourceEnded: Boolean): Long {
+    val delegatePos = super.getCurrentPositionUs(sourceEnded)
+    if (delegatePos == Long.MIN_VALUE || refMediaTimeUs == Long.MIN_VALUE) {
+      return delegatePos
+    }
+
+    val rawPos = rawPositionUs.get()
+    val basePos = if (rawPos <= 0) {
+      delegatePos
+    } else {
+      val expectedPos = refMediaTimeUs + ((rawPos - refRawPositionUs) * currentSpeed).toLong()
+      if (expectedPos > delegatePos + 30_000) expectedPos else delegatePos
+    }
+
+    // Audio delay with transient counter-offset to prevent frame drops after seeks.
+    // After flush, offset ramps linearly from 0 to full over recoveryDurationUs.
+    val delayUs = audioDelayUs.get()
+    if (delayUs == 0L) return basePos
+
+    val elapsedUs = basePos - startMediaTimeUs
+    val netOffsetUs = if (recoveryDurationUs <= 0L || elapsedUs >= recoveryDurationUs) {
+      delayUs
+    } else {
+      (delayUs * elapsedUs) / recoveryDurationUs
+    }
+    return basePos + netOffsetUs
+  }
+
+  // --- Suppress timestamp discontinuity errors ---
+
+  override fun setListener(listener: AudioSink.Listener) {
+    super.setListener(
+      @OptIn(UnstableApi::class) object : AudioSink.Listener {
+        override fun onPositionDiscontinuity() = listener.onPositionDiscontinuity()
+        override fun onPositionAdvancing(playoutStartSystemTimeUs: Long) = listener.onPositionAdvancing(playoutStartSystemTimeUs)
+        override fun onUnderrun(bufferSize: Int, bufferSizeMs: Long, elapsedSinceLastFeedMs: Long) = listener.onUnderrun(bufferSize, bufferSizeMs, elapsedSinceLastFeedMs)
+        override fun onSkipSilenceEnabledChanged(skipSilenceEnabled: Boolean) = listener.onSkipSilenceEnabledChanged(skipSilenceEnabled)
+        override fun onOffloadBufferEmptying() = listener.onOffloadBufferEmptying()
+        override fun onOffloadBufferFull() = listener.onOffloadBufferFull()
+        override fun onAudioCapabilitiesChanged() {
+          onAudioCapabilitiesChanged?.invoke()
+          listener.onAudioCapabilitiesChanged()
         }
-        return super.handleBuffer(buffer, presentationTimeUs, encodedAccessUnitCount)
-    }
+        override fun onAudioTrackInitialized(audioTrackConfig: AudioSink.AudioTrackConfig) = listener.onAudioTrackInitialized(audioTrackConfig)
+        override fun onAudioTrackReleased(audioTrackConfig: AudioSink.AudioTrackConfig) = listener.onAudioTrackReleased(audioTrackConfig)
+        override fun onSilenceSkipped() = listener.onSilenceSkipped()
+        override fun onAudioSessionIdChanged(audioSessionId: Int) = listener.onAudioSessionIdChanged(audioSessionId)
 
-    override fun setPlaybackParameters(playbackParameters: PlaybackParameters) {
-        // Capture reference point before speed changes
-        val rawPos = rawPositionUs.get()
-        if (rawPos > 0 && refMediaTimeUs != Long.MIN_VALUE) {
-            refMediaTimeUs = refMediaTimeUs + ((rawPos - refRawPositionUs) * currentSpeed).toLong()
-            refRawPositionUs = rawPos
+        override fun onAudioSinkError(audioSinkError: Exception) {
+          if (isTimestampDiscontinuity(audioSinkError)) {
+            suppressedErrorCount++
+            return
+          }
+          listener.onAudioSinkError(audioSinkError)
         }
-        currentSpeed = playbackParameters.speed
-        super.setPlaybackParameters(playbackParameters)
+      }
+    )
+  }
+
+  override fun flush() {
+    startMediaTimeUs = Long.MIN_VALUE
+    refMediaTimeUs = Long.MIN_VALUE
+    refRawPositionUs = 0
+    recoveryDurationUs = 0L
+    rawPositionUs.set(Long.MIN_VALUE)
+    super.flush()
+  }
+
+  override fun reset() {
+    startMediaTimeUs = Long.MIN_VALUE
+    refMediaTimeUs = Long.MIN_VALUE
+    refRawPositionUs = 0
+    recoveryDurationUs = 0L
+    currentSpeed = 1.0f
+    rawPositionUs.set(Long.MIN_VALUE)
+    suppressedErrorCount = 0
+    super.reset()
+  }
+
+  private fun isTimestampDiscontinuity(e: Exception): Boolean {
+    val name = e.javaClass.simpleName
+    val msg = e.message ?: ""
+    return name == "InvalidAudioTrackTimestampException" ||
+      name == "UnexpectedDiscontinuityException" ||
+      msg.contains("timestamp discontinuity", ignoreCase = true)
+  }
+}
+
+/**
+ * Wraps a text renderer to shift subtitle timing by [delayUs] microseconds.
+ * Positive delay → subtitles appear later, negative → earlier.
+ * Only render() needs the offset — the text renderer uses positionUs to decide
+ * which cues are active; other Renderer methods are timing-independent.
+ */
+@OptIn(UnstableApi::class)
+internal class SubtitleDelayRenderer(
+  private val delegate: Renderer,
+  private val delayUs: AtomicLong
+) : Renderer by delegate {
+  override fun render(positionUs: Long, elapsedRealtimeUs: Long) {
+    delegate.render(positionUs - delayUs.get(), elapsedRealtimeUs)
+  }
+}
+
+/**
+ * MediaCodecVideoRenderer that resolves the DV / HDR10+ dual-dynamic-metadata conflict
+ * per decode path (#1296, generalizes androidx/media#3085):
+ * - native DV codec selected (media3 only selects one when decoder AND display support DV):
+ *   strip in-band HDR10+ SEI — conflicting dynamic metadata crashes Fire TV-class chipsets
+ * - HEVC fallback for an HEVC-based DV format: strip DV RPU/EL NALs (profiles 7/8, where the
+ *   base layer remains valid HDR10/HLG), keeping HDR10+ for the display
+ *
+ * Flags are reassigned on every codec init: tunneling toggles and DV retries re-init the
+ * codec without recreating renderers, and decoder fallback can switch the codec MIME.
+ */
+@OptIn(UnstableApi::class)
+internal class DvSanitizingVideoRenderer(
+  builder: Builder,
+  private val log: ((String, String, String) -> Unit)?
+) : MediaCodecVideoRenderer(builder) {
+
+  private var stripHdr10PlusSei = false
+  private var stripDvRpu = false
+
+  override fun onCodecInitialized(
+    name: String,
+    configuration: MediaCodecAdapter.Configuration,
+    initializedTimestampMs: Long,
+    initializationDurationMs: Long
+  ) {
+    super.onCodecInitialized(name, configuration, initializedTimestampMs, initializationDurationMs)
+    val codecs = configuration.format.codecs?.lowercase() ?: ""
+    val dvHevcFormat = configuration.format.sampleMimeType == MimeTypes.VIDEO_DOLBY_VISION &&
+      (codecs.startsWith("dvhe.") || codecs.startsWith("dvh1."))
+    val codecMimeType = configuration.codecInfo.codecMimeType
+    val newStripHdr10PlusSei = dvHevcFormat && codecMimeType == MimeTypes.VIDEO_DOLBY_VISION
+    val newStripDvRpu = dvHevcFormat &&
+      codecMimeType == MimeTypes.VIDEO_H265 &&
+      isBlCompatibleDvProfile(codecs)
+    if (newStripHdr10PlusSei != stripHdr10PlusSei || newStripDvRpu != stripDvRpu) {
+      log?.invoke(
+        "info",
+        "video",
+        "DV bitstream sanitizing: stripHdr10PlusSei=$newStripHdr10PlusSei, " +
+          "stripDvRpu=$newStripDvRpu (codec=$name, codecs=${configuration.format.codecs})"
+      )
     }
+    stripHdr10PlusSei = newStripHdr10PlusSei
+    stripDvRpu = newStripDvRpu
+  }
 
-    override fun getCurrentPositionUs(sourceEnded: Boolean): Long {
-        val delegatePos = super.getCurrentPositionUs(sourceEnded)
-        if (delegatePos == Long.MIN_VALUE || refMediaTimeUs == Long.MIN_VALUE) {
-            return delegatePos
-        }
-
-        val rawPos = rawPositionUs.get()
-        if (rawPos <= 0) return delegatePos
-
-        val expectedPos = refMediaTimeUs + ((rawPos - refRawPositionUs) * currentSpeed).toLong()
-        return if (expectedPos > delegatePos + 30_000) expectedPos else delegatePos
+  override fun onQueueInputBuffer(buffer: DecoderInputBuffer) {
+    if (stripHdr10PlusSei || stripDvRpu) {
+      val data = buffer.data
+      if (data != null && data.hasRemaining() && !buffer.isEncrypted) {
+        DvBitstreamSanitizer.sanitize(data, stripHdr10PlusSei, stripDvRpu)
+      }
     }
+    super.onQueueInputBuffer(buffer)
+  }
 
-    // --- Suppress timestamp discontinuity errors ---
-
-    override fun setListener(listener: AudioSink.Listener) {
-        super.setListener(@OptIn(UnstableApi::class) object : AudioSink.Listener {
-            override fun onPositionDiscontinuity() = listener.onPositionDiscontinuity()
-            override fun onPositionAdvancing(playoutStartSystemTimeUs: Long) = listener.onPositionAdvancing(playoutStartSystemTimeUs)
-            override fun onUnderrun(bufferSize: Int, bufferSizeMs: Long, elapsedSinceLastFeedMs: Long) = listener.onUnderrun(bufferSize, bufferSizeMs, elapsedSinceLastFeedMs)
-            override fun onSkipSilenceEnabledChanged(skipSilenceEnabled: Boolean) = listener.onSkipSilenceEnabledChanged(skipSilenceEnabled)
-            override fun onOffloadBufferEmptying() = listener.onOffloadBufferEmptying()
-            override fun onOffloadBufferFull() = listener.onOffloadBufferFull()
-            override fun onAudioCapabilitiesChanged() = listener.onAudioCapabilitiesChanged()
-            override fun onAudioTrackInitialized(audioTrackConfig: AudioSink.AudioTrackConfig) = listener.onAudioTrackInitialized(audioTrackConfig)
-            override fun onAudioTrackReleased(audioTrackConfig: AudioSink.AudioTrackConfig) = listener.onAudioTrackReleased(audioTrackConfig)
-            override fun onSilenceSkipped() = listener.onSilenceSkipped()
-            override fun onAudioSessionIdChanged(audioSessionId: Int) = listener.onAudioSessionIdChanged(audioSessionId)
-
-            override fun onAudioSinkError(audioSinkError: Exception) {
-                if (isTimestampDiscontinuity(audioSinkError)) {
-                    suppressedErrorCount++
-                    return
-                }
-                listener.onAudioSinkError(audioSinkError)
-            }
-        })
-    }
-
-    override fun flush() {
-        startMediaTimeUs = Long.MIN_VALUE
-        refMediaTimeUs = Long.MIN_VALUE
-        refRawPositionUs = 0
-        rawPositionUs.set(Long.MIN_VALUE)
-        super.flush()
-    }
-
-    override fun reset() {
-        startMediaTimeUs = Long.MIN_VALUE
-        refMediaTimeUs = Long.MIN_VALUE
-        refRawPositionUs = 0
-        currentSpeed = 1.0f
-        rawPositionUs.set(Long.MIN_VALUE)
-        suppressedErrorCount = 0
-        super.reset()
-    }
-
-    private fun isTimestampDiscontinuity(e: Exception): Boolean {
-        val name = e.javaClass.simpleName
-        val msg = e.message ?: ""
-        return name == "InvalidAudioTrackTimestampException" ||
-                name == "UnexpectedDiscontinuityException" ||
-                msg.contains("timestamp discontinuity", ignoreCase = true)
-    }
+  private fun isBlCompatibleDvProfile(codecs: String): Boolean = codecs.startsWith("dvhe.07") ||
+    codecs.startsWith("dvh1.07") ||
+    codecs.startsWith("dvhe.08") ||
+    codecs.startsWith("dvh1.08")
 }
 
 // --- AudioOutput wrapping: shares raw position with PositionFixAudioSink ---
+// Also implements AudioTrack reuse across seeks to avoid expensive teardown/recreation.
+// DefaultAudioSink releases the AudioOutput on every flush (seek), which destroys the
+// AudioTrack and creates a new one. On Android TV with tunneled playback, this causes
+// 7-10s audio dropout while the hardware pipeline reinitializes (Sony Bravia, etc).
+// By flushing instead of releasing and caching the output, we skip the teardown cycle.
 
 @OptIn(UnstableApi::class)
 private class RawPositionOutputProvider(
-    private val delegate: AudioOutputProvider,
-    private val rawPositionUs: AtomicLong
+  private val delegate: AudioOutputProvider,
+  private val rawPositionUs: AtomicLong,
+  private val log: ((String, String, String) -> Unit)?
 ) : AudioOutputProvider {
 
-    override fun getFormatSupport(config: AudioOutputProvider.FormatConfig) =
-        delegate.getFormatSupport(config)
+  private var cachedOutput: RawPositionAudioOutput? = null
+  private var cachedConfig: AudioOutputProvider.OutputConfig? = null
 
-    override fun getOutputConfig(config: AudioOutputProvider.FormatConfig) =
-        delegate.getOutputConfig(config)
+  override fun getFormatSupport(config: AudioOutputProvider.FormatConfig) = delegate.getFormatSupport(config)
 
-    override fun getAudioOutput(config: AudioOutputProvider.OutputConfig): AudioOutput {
-        val realOutput = delegate.getAudioOutput(config)
-        return RawPositionAudioOutput(realOutput, rawPositionUs)
+  override fun getOutputConfig(config: AudioOutputProvider.FormatConfig) = delegate.getOutputConfig(config)
+
+  override fun getAudioOutput(config: AudioOutputProvider.OutputConfig): AudioOutput {
+    val cached = cachedOutput
+    if (cached != null && cachedConfig == config) {
+      cachedOutput = null
+      return cached
     }
+    cached?.forceRelease()
+    cachedOutput = null
 
-    override fun addListener(listener: AudioOutputProvider.Listener) =
-        delegate.addListener(listener)
+    val realOutput = delegate.getAudioOutput(config)
+    cachedConfig = config
+    return RawPositionAudioOutput(realOutput, rawPositionUs, this, log)
+  }
 
-    override fun removeListener(listener: AudioOutputProvider.Listener) =
-        delegate.removeListener(listener)
+  fun returnToCache(output: RawPositionAudioOutput) {
+    val existing = cachedOutput
+    if (existing != null && existing !== output) {
+      existing.forceRelease()
+    }
+    cachedOutput = output
+  }
 
-    override fun setClock(clock: Clock) = delegate.setClock(clock)
+  override fun addListener(listener: AudioOutputProvider.Listener) = delegate.addListener(listener)
 
-    override fun release() = delegate.release()
+  override fun removeListener(listener: AudioOutputProvider.Listener) = delegate.removeListener(listener)
+
+  override fun setClock(clock: Clock) = delegate.setClock(clock)
+
+  override fun release() {
+    cachedOutput?.forceRelease()
+    cachedOutput = null
+    cachedConfig = null
+    delegate.release()
+  }
 }
 
 @OptIn(UnstableApi::class)
 private class RawPositionAudioOutput(
-    private val delegate: AudioOutput,
-    private val rawPositionUs: AtomicLong
+  private val delegate: AudioOutput,
+  private val rawPositionUs: AtomicLong,
+  private val provider: RawPositionOutputProvider,
+  private val log: ((String, String, String) -> Unit)?
 ) : AudioOutput {
 
-    override fun getPositionUs(): Long {
-        val pos = delegate.getPositionUs()
-        rawPositionUs.set(pos)
-        return pos
+  private var loggedFirstWrite = false
+  private var writeCount = 0L
+  private var writtenBytes = 0L
+  private var failed = false
+
+  override fun getPositionUs(): Long {
+    val pos = delegate.getPositionUs()
+    rawPositionUs.set(pos)
+    return pos
+  }
+
+  override fun play() = delegate.play()
+  override fun pause() = delegate.pause()
+
+  @Throws(AudioOutput.WriteException::class)
+  override fun write(buffer: ByteBuffer, size: Int, presentationTimeUs: Long): Boolean {
+    val before = buffer.position()
+    val handled = try {
+      delegate.write(buffer, size, presentationTimeUs)
+    } catch (e: AudioOutput.WriteException) {
+      failed = true
+      rawPositionUs.set(Long.MIN_VALUE)
+      log?.invoke("warn", "audio-output", "Write failed; AudioTrack will not be reused: ${e.message}")
+      throw e
     }
-
-    override fun play() = delegate.play()
-    override fun pause() = delegate.pause()
-
-    @Throws(AudioOutput.WriteException::class)
-    override fun write(buffer: ByteBuffer, size: Int, presentationTimeUs: Long) =
-        delegate.write(buffer, size, presentationTimeUs)
-
-    override fun flush() {
-        rawPositionUs.set(Long.MIN_VALUE)
-        delegate.flush()
+    val written = buffer.position() - before
+    if (written > 0) {
+      writeCount++
+      writtenBytes += written.toLong()
+      if (!loggedFirstWrite) {
+        loggedFirstWrite = true
+        log?.invoke(
+          "debug",
+          "audio-output",
+          "First write: wrote=${written}B, handled=$handled, pts=${presentationTimeUs}us, writes=$writeCount, total=${writtenBytes}B"
+        )
+      }
     }
+    return handled
+  }
 
-    override fun stop() = delegate.stop()
+  override fun flush() {
+    rawPositionUs.set(Long.MIN_VALUE)
+    loggedFirstWrite = false
+    writeCount = 0
+    writtenBytes = 0
+    delegate.flush()
+  }
 
-    override fun release() {
-        rawPositionUs.set(Long.MIN_VALUE)
-        delegate.release()
+  override fun stop() = delegate.stop()
+
+  override fun release() {
+    rawPositionUs.set(Long.MIN_VALUE)
+    if (failed) {
+      delegate.release()
+      return
     }
+    if (Build.VERSION.SDK_INT >= 25) {
+      delegate.stop()
+      delegate.flush()
+      provider.returnToCache(this)
+    } else {
+      delegate.release()
+    }
+  }
 
-    override fun setVolume(volume: Float) = delegate.setVolume(volume)
-    override fun isOffloadedPlayback() = delegate.isOffloadedPlayback()
-    override fun getAudioSessionId() = delegate.getAudioSessionId()
-    override fun getSampleRate() = delegate.getSampleRate()
-    override fun getBufferSizeInFrames() = delegate.getBufferSizeInFrames()
-    override fun getPlaybackParameters() = delegate.getPlaybackParameters()
-    override fun isStalled() = delegate.isStalled()
-    override fun addListener(listener: AudioOutput.Listener) = delegate.addListener(listener)
-    override fun removeListener(listener: AudioOutput.Listener) = delegate.removeListener(listener)
-    override fun setPlaybackParameters(playbackParameters: PlaybackParameters) =
-        delegate.setPlaybackParameters(playbackParameters)
-    override fun setOffloadDelayPadding(delayInFrames: Int, paddingInFrames: Int) =
-        delegate.setOffloadDelayPadding(delayInFrames, paddingInFrames)
-    override fun setOffloadEndOfStream() = delegate.setOffloadEndOfStream()
-    override fun setPlayerId(playerId: PlayerId) = delegate.setPlayerId(playerId)
-    override fun attachAuxEffect(effectId: Int) = delegate.attachAuxEffect(effectId)
-    override fun setAuxEffectSendLevel(level: Float) = delegate.setAuxEffectSendLevel(level)
-    override fun setPreferredDevice(preferredDevice: AudioDeviceInfo?) =
-        delegate.setPreferredDevice(preferredDevice)
+  fun forceRelease() {
+    rawPositionUs.set(Long.MIN_VALUE)
+    delegate.release()
+  }
+
+  override fun setVolume(volume: Float) = delegate.setVolume(volume)
+  override fun isOffloadedPlayback() = delegate.isOffloadedPlayback()
+  override fun getAudioSessionId() = delegate.getAudioSessionId()
+  override fun getSampleRate() = delegate.getSampleRate()
+  override fun getBufferSizeInFrames() = delegate.getBufferSizeInFrames()
+  override fun getPlaybackParameters() = delegate.getPlaybackParameters()
+  override fun isStalled() = delegate.isStalled()
+  override fun addListener(listener: AudioOutput.Listener) = delegate.addListener(listener)
+  override fun removeListener(listener: AudioOutput.Listener) = delegate.removeListener(listener)
+  override fun setPlaybackParameters(playbackParameters: PlaybackParameters) = delegate.setPlaybackParameters(playbackParameters)
+  override fun setOffloadDelayPadding(delayInFrames: Int, paddingInFrames: Int) = delegate.setOffloadDelayPadding(delayInFrames, paddingInFrames)
+  override fun setOffloadEndOfStream() = delegate.setOffloadEndOfStream()
+  override fun setPlayerId(playerId: PlayerId) = delegate.setPlayerId(playerId)
+  override fun attachAuxEffect(effectId: Int) = delegate.attachAuxEffect(effectId)
+  override fun setAuxEffectSendLevel(level: Float) = delegate.setAuxEffectSendLevel(level)
+  override fun setPreferredDevice(preferredDevice: AudioDeviceInfo?) = delegate.setPreferredDevice(preferredDevice)
 }

android/app/src/main/kotlin/com/edde746/plezy/exoplayer/ZlibInflatingTrackOutput.kt

@@ -0,0 +1,130 @@
+package com.edde746.plezy.exoplayer
+
+import android.util.Log
+import androidx.media3.common.DataReader
+import androidx.media3.common.Format
+import androidx.media3.common.util.ParsableByteArray
+import androidx.media3.extractor.TrackOutput
+import java.util.zip.DataFormatException
+import java.util.zip.Inflater
+
+/**
+ * TrackOutput wrapper that inflates zlib-compressed sample data (MKV ContentCompAlgo 0).
+ * Each MKV block is independently zlib-compressed; this wrapper decompresses per-sample
+ * between sampleData() and sampleMetadata() calls.
+ *
+ * All buffers are reused across samples to minimize GC pressure on the hot path.
+ */
+class ZlibInflatingTrackOutput(
+  private val delegate: TrackOutput
+) : TrackOutput {
+
+  companion object {
+    private const val TAG = "ZlibTrackOutput"
+    private const val INITIAL_BUFFER_SIZE = 256 * 1024
+    private const val INFLATE_CHUNK = 64 * 1024
+  }
+
+  var active = false
+
+  private val inflater = Inflater()
+
+  // Reusable buffers — grown as needed, never shrunk
+  private var compressedBuf = ByteArray(INITIAL_BUFFER_SIZE)
+  private var compressedLen = 0
+  private var inflateBuf = ByteArray(INITIAL_BUFFER_SIZE)
+  private var readBuf = ByteArray(INFLATE_CHUNK)
+  private val outputParsable = ParsableByteArray()
+  private var buffering = false
+
+  override fun format(format: Format) = delegate.format(format)
+
+  override fun sampleData(
+    input: DataReader,
+    length: Int,
+    allowEndOfInput: Boolean,
+    sampleDataPart: Int
+  ): Int {
+    if (!active) return delegate.sampleData(input, length, allowEndOfInput, sampleDataPart)
+
+    buffering = true
+    if (readBuf.size < length) readBuf = ByteArray(length)
+    val bytesRead = input.read(readBuf, 0, length)
+    if (bytesRead > 0) appendCompressed(readBuf, 0, bytesRead)
+    return bytesRead
+  }
+
+  override fun sampleData(data: ParsableByteArray, length: Int, sampleDataPart: Int) {
+    if (!active) {
+      delegate.sampleData(data, length, sampleDataPart)
+      return
+    }
+
+    buffering = true
+    ensureCompressedCapacity(compressedLen + length)
+    data.readBytes(compressedBuf, compressedLen, length)
+    compressedLen += length
+  }
+
+  override fun sampleMetadata(
+    timeUs: Long,
+    flags: Int,
+    size: Int,
+    offset: Int,
+    cryptoData: TrackOutput.CryptoData?
+  ) {
+    if (!active || !buffering) {
+      delegate.sampleMetadata(timeUs, flags, size, offset, cryptoData)
+      return
+    }
+
+    buffering = false
+    val srcLen = compressedLen
+    compressedLen = 0
+
+    val inflatedLen = try {
+      inflater.reset()
+      inflater.setInput(compressedBuf, 0, srcLen)
+      var written = 0
+      while (!inflater.finished()) {
+        if (written == inflateBuf.size) growInflateBuf()
+        val count = inflater.inflate(inflateBuf, written, inflateBuf.size - written)
+        if (count == 0 && !inflater.finished()) break
+        written += count
+      }
+      written
+    } catch (e: DataFormatException) {
+      Log.e(TAG, "Zlib inflate failed (${srcLen}B), passing raw", e)
+      // Fall back to raw compressed data
+      ensureInflateCapacity(srcLen)
+      System.arraycopy(compressedBuf, 0, inflateBuf, 0, srcLen)
+      srcLen
+    }
+
+    outputParsable.reset(inflateBuf, inflatedLen)
+    delegate.sampleData(outputParsable, inflatedLen, TrackOutput.SAMPLE_DATA_PART_MAIN)
+    delegate.sampleMetadata(timeUs, flags, inflatedLen, 0, cryptoData)
+  }
+
+  private fun appendCompressed(src: ByteArray, offset: Int, length: Int) {
+    ensureCompressedCapacity(compressedLen + length)
+    System.arraycopy(src, offset, compressedBuf, compressedLen, length)
+    compressedLen += length
+  }
+
+  private fun ensureCompressedCapacity(needed: Int) {
+    if (compressedBuf.size < needed) {
+      compressedBuf = compressedBuf.copyOf(maxOf(needed, compressedBuf.size * 2))
+    }
+  }
+
+  private fun ensureInflateCapacity(needed: Int) {
+    if (inflateBuf.size < needed) {
+      inflateBuf = ByteArray(maxOf(needed, inflateBuf.size * 2))
+    }
+  }
+
+  private fun growInflateBuf() {
+    inflateBuf = inflateBuf.copyOf(inflateBuf.size * 2)
+  }
+}

android/app/src/main/kotlin/com/edde746/plezy/exoplayer/ZlibMatroskaExtractor.kt

@@ -0,0 +1,116 @@
+package com.edde746.plezy.exoplayer
+
+import android.util.Log
+import androidx.media3.extractor.ExtractorInput
+import androidx.media3.extractor.ExtractorOutput
+import androidx.media3.extractor.SeekMap
+import androidx.media3.extractor.TrackOutput
+import androidx.media3.extractor.mkv.MatroskaExtractor
+import androidx.media3.extractor.text.SubtitleParser
+import io.github.peerless2012.ass.media.AssHandler
+import io.github.peerless2012.ass.media.extractor.AssMatroskaExtractor
+
+/**
+ * Extends AssMatroskaExtractor to add support for MKV ContentCompAlgo 0 (zlib).
+ *
+ * Media3's MatroskaExtractor only supports ContentCompAlgo 3 (header stripping).
+ * This subclass intercepts the compression algorithm during track header parsing:
+ * - Tells the parent it's header stripping (algo 3) to avoid the ParserException
+ * - Wraps TrackOutputs with ZlibInflatingTrackOutput to decompress per-sample data
+ * - Skips ContentCompSettings for zlib tracks (not applicable)
+ */
+class ZlibMatroskaExtractor(
+  subtitleParserFactory: SubtitleParser.Factory,
+  assHandler: AssHandler
+) : AssMatroskaExtractor(subtitleParserFactory, assHandler) {
+
+  companion object {
+    private const val TAG = "ZlibMkvExtractor"
+
+    // Matroska EBML element IDs
+    private const val ID_SEGMENT = 0x18538067
+    private const val ID_TRACK_ENTRY = 0xAE
+    private const val ID_CONTENT_COMPRESSION_ALGORITHM = 0x4254
+    private const val ID_CONTENT_COMPRESSION_SETTINGS = 0x4255
+
+    private val extractorOutputField by lazy {
+      MatroskaExtractor::class.java.getDeclaredField("extractorOutput").apply {
+        isAccessible = true
+      }
+    }
+  }
+
+  private var zlibOutput: ZlibExtractorOutputWrapper? = null
+  private var currentTrackUsesZlib = false
+
+  override fun startMasterElement(id: Int, contentPosition: Long, contentSize: Long) {
+    super.startMasterElement(id, contentPosition, contentSize)
+
+    // After super installs AssSubtitleExtractorOutput, wrap it with our zlib layer
+    if (id == ID_SEGMENT && zlibOutput == null) {
+      val currentOutput = extractorOutputField.get(this) as ExtractorOutput
+      val wrapper = ZlibExtractorOutputWrapper(currentOutput)
+      zlibOutput = wrapper
+      extractorOutputField.set(this, wrapper)
+      Log.d(TAG, "Installed zlib ExtractorOutput wrapper")
+    }
+  }
+
+  override fun integerElement(id: Int, value: Long) {
+    if (id == ID_CONTENT_COMPRESSION_ALGORITHM && value == 0L) {
+      currentTrackUsesZlib = true
+      Log.i(TAG, "Track uses ContentCompAlgo 0 (zlib), will inflate samples")
+      // Tell parent it's header stripping (algo 3) to avoid ParserException
+      super.integerElement(id, 3)
+      return
+    }
+    super.integerElement(id, value)
+  }
+
+  override fun binaryElement(id: Int, contentSize: Int, input: ExtractorInput) {
+    if (id == ID_CONTENT_COMPRESSION_SETTINGS && currentTrackUsesZlib) {
+      // Skip ContentCompSettings for zlib tracks — parent would store these as
+      // sampleStrippedBytes and prepend them to every sample, corrupting output.
+      input.skipFully(contentSize)
+      return
+    }
+    super.binaryElement(id, contentSize, input)
+  }
+
+  override fun endMasterElement(id: Int) {
+    val wasZlib = currentTrackUsesZlib
+    super.endMasterElement(id)
+
+    if (id == ID_TRACK_ENTRY && wasZlib) {
+      zlibOutput?.activateLast()
+      currentTrackUsesZlib = false
+      Log.i(TAG, "Activated zlib inflation for track")
+    }
+  }
+
+  /**
+   * ExtractorOutput wrapper that wraps all TrackOutputs with ZlibInflatingTrackOutput.
+   * Tracks are created inactive; activateLast() enables inflation for the most recently
+   * created track (called when we know a track uses zlib compression).
+   */
+  private class ZlibExtractorOutputWrapper(
+    private val delegate: ExtractorOutput
+  ) : ExtractorOutput {
+
+    private var lastCreatedWrapper: ZlibInflatingTrackOutput? = null
+
+    override fun track(id: Int, type: Int): TrackOutput {
+      val original = delegate.track(id, type)
+      val wrapper = ZlibInflatingTrackOutput(original)
+      lastCreatedWrapper = wrapper
+      return wrapper
+    }
+
+    fun activateLast() {
+      lastCreatedWrapper?.active = true
+    }
+
+    override fun endTracks() = delegate.endTracks()
+    override fun seekMap(seekMap: SeekMap) = delegate.seekMap(seekMap)
+  }
+}

android/app/src/main/kotlin/com/edde746/plezy/mpv/MpvPlayerPlugin.kt

@@ -10,290 +10,376 @@ import io.flutter.plugin.common.EventChannel
 import io.flutter.plugin.common.MethodCall
 import io.flutter.plugin.common.MethodChannel
 
-class MpvPlayerPlugin : FlutterPlugin, MethodChannel.MethodCallHandler,
-    EventChannel.StreamHandler, ActivityAware, com.edde746.plezy.shared.PlayerDelegate {
+class MpvPlayerPlugin :
+  FlutterPlugin,
+  MethodChannel.MethodCallHandler,
+  EventChannel.StreamHandler,
+  ActivityAware,
+  com.edde746.plezy.shared.PlayerDelegate {
 
-    companion object {
-        private const val TAG = "MpvPlayerPlugin"
-        private const val METHOD_CHANNEL = "com.plezy/mpv_player"
-        private const val EVENT_CHANNEL = "com.plezy/mpv_player/events"
+  companion object {
+    private const val TAG = "MpvPlayerPlugin"
+    private const val METHOD_CHANNEL = "com.plezy/mpv_player"
+    private const val EVENT_CHANNEL = "com.plezy/mpv_player/events"
+  }
+
+  private lateinit var methodChannel: MethodChannel
+  private lateinit var eventChannel: EventChannel
+  private var eventSink: EventChannel.EventSink? = null
+  private var playerCore: MpvPlayerCore? = null
+  private var activity: Activity? = null
+  private var activityBinding: ActivityPluginBinding? = null
+  private val nameToId = mutableMapOf<String, Int>()
+  private var sessionGeneration = 0
+
+  // Pending `MethodChannel.Result`s for an init that is currently in flight.
+  // Concurrent `invoke('initialize')` calls share the same outcome instead
+  // of each tearing down the in-flight core and starting their own — which
+  // was the root cause of #930.
+  private val pendingInitResults = mutableListOf<MethodChannel.Result>()
+
+  @Volatile private var isInitializing = false
+
+  // FlutterPlugin
+
+  override fun onAttachedToEngine(binding: FlutterPlugin.FlutterPluginBinding) {
+    methodChannel = MethodChannel(binding.binaryMessenger, METHOD_CHANNEL)
+    methodChannel.setMethodCallHandler(this)
+
+    eventChannel = EventChannel(binding.binaryMessenger, EVENT_CHANNEL)
+    eventChannel.setStreamHandler(this)
+
+    Log.d(TAG, "Attached to engine")
+  }
+
+  override fun onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding) {
+    methodChannel.setMethodCallHandler(null)
+    eventChannel.setStreamHandler(null)
+    Log.d(TAG, "Detached from engine")
+  }
+
+  // ActivityAware
+
+  override fun onAttachedToActivity(binding: ActivityPluginBinding) {
+    activity = binding.activity
+    activityBinding = binding
+    Log.d(TAG, "Attached to activity")
+  }
+
+  override fun onDetachedFromActivity() {
+    ++sessionGeneration
+    playerCore?.dispose()
+    playerCore = null
+    // Any in-flight init callback would never fire (its scope is cancelled
+    // by dispose), so close out queued callers explicitly.
+    completePendingInits(success = false)
+    activity = null
+    activityBinding = null
+    Log.d(TAG, "Detached from activity")
+  }
+
+  override fun onReattachedToActivityForConfigChanges(binding: ActivityPluginBinding) {
+    activity = binding.activity
+    activityBinding = binding
+    Log.d(TAG, "Reattached to activity for config changes")
+  }
+
+  override fun onDetachedFromActivityForConfigChanges() {
+    activity = null
+    activityBinding = null
+    Log.d(TAG, "Detached from activity for config changes")
+  }
+
+  // EventChannel.StreamHandler
+
+  override fun onListen(arguments: Any?, events: EventChannel.EventSink?) {
+    eventSink = events
+    Log.d(TAG, "Event stream connected")
+  }
+
+  override fun onCancel(arguments: Any?) {
+    eventSink = null
+    Log.d(TAG, "Event stream disconnected")
+  }
+
+  // MethodChannel.MethodCallHandler
+
+  override fun onMethodCall(call: MethodCall, result: MethodChannel.Result) {
+    when (call.method) {
+      "initialize" -> handleInitialize(result)
+      "dispose" -> handleDispose(result)
+      "setProperty" -> handleSetProperty(call, result)
+      "getProperty" -> handleGetProperty(call, result)
+      "observeProperty" -> handleObserveProperty(call, result)
+      "command" -> handleCommand(call, result)
+      "setVisible" -> handleSetVisible(call, result)
+      "updateFrame" -> handleUpdateFrame(result)
+      "setVideoFrameRate" -> handleSetVideoFrameRate(call, result)
+      "clearVideoFrameRate" -> handleClearVideoFrameRate(result)
+      "requestAudioFocus" -> handleRequestAudioFocus(result)
+      "abandonAudioFocus" -> handleAbandonAudioFocus(result)
+      "openContentFd" -> handleOpenContentFd(call, result)
+      "isInitialized" -> result.success(playerCore?.isInitialized ?: false)
+      "setLogLevel" -> result.success(null)
+      else -> result.notImplemented()
+    }
+  }
+
+  private fun handleInitialize(result: MethodChannel.Result) {
+    val currentActivity = activity
+    if (currentActivity == null) {
+      result.error("NO_ACTIVITY", "Activity not available", null)
+      return
     }
 
-    private lateinit var methodChannel: MethodChannel
-    private lateinit var eventChannel: EventChannel
-    private var eventSink: EventChannel.EventSink? = null
-    private var playerCore: MpvPlayerCore? = null
-    private var activity: Activity? = null
-    private var activityBinding: ActivityPluginBinding? = null
-    private val nameToId = mutableMapOf<String, Int>()
-
-    // FlutterPlugin
-
-    override fun onAttachedToEngine(binding: FlutterPlugin.FlutterPluginBinding) {
-        methodChannel = MethodChannel(binding.binaryMessenger, METHOD_CHANNEL)
-        methodChannel.setMethodCallHandler(this)
-
-        eventChannel = EventChannel(binding.binaryMessenger, EVENT_CHANNEL)
-        eventChannel.setStreamHandler(this)
-
-        Log.d(TAG, "Attached to engine")
+    if (playerCore?.isInitialized == true) {
+      Log.d(TAG, "Already initialized")
+      result.success(true)
+      return
     }
 
-    override fun onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding) {
-        methodChannel.setMethodCallHandler(null)
-        eventChannel.setStreamHandler(null)
-        Log.d(TAG, "Detached from engine")
+    // Coalesce concurrent inits: the second caller waits for the first
+    // call's outcome instead of disposing the in-flight core. The Dart
+    // side memoizes too, but this is defense in depth for any direct
+    // `invoke('initialize')` that bypasses _ensureInitialized.
+    synchronized(pendingInitResults) {
+      pendingInitResults += result
+      if (isInitializing) {
+        Log.d(TAG, "Init already in flight, queuing caller")
+        return
+      }
+      isInitializing = true
     }
 
-    // ActivityAware
-
-    override fun onAttachedToActivity(binding: ActivityPluginBinding) {
-        activity = binding.activity
-        activityBinding = binding
-        Log.d(TAG, "Attached to activity")
-    }
-
-    override fun onDetachedFromActivity() {
-        playerCore?.dispose()
-        playerCore = null
-        activity = null
-        activityBinding = null
-        Log.d(TAG, "Detached from activity")
-    }
-
-    override fun onReattachedToActivityForConfigChanges(binding: ActivityPluginBinding) {
-        activity = binding.activity
-        activityBinding = binding
-        Log.d(TAG, "Reattached to activity for config changes")
-    }
-
-    override fun onDetachedFromActivityForConfigChanges() {
-        activity = null
-        activityBinding = null
-        Log.d(TAG, "Detached from activity for config changes")
-    }
-
-    // EventChannel.StreamHandler
-
-    override fun onListen(arguments: Any?, events: EventChannel.EventSink?) {
-        eventSink = events
-        Log.d(TAG, "Event stream connected")
-    }
-
-    override fun onCancel(arguments: Any?) {
-        eventSink = null
-        Log.d(TAG, "Event stream disconnected")
-    }
-
-    // MethodChannel.MethodCallHandler
-
-    override fun onMethodCall(call: MethodCall, result: MethodChannel.Result) {
-        when (call.method) {
-            "initialize" -> handleInitialize(result)
-            "dispose" -> handleDispose(result)
-            "setProperty" -> handleSetProperty(call, result)
-            "getProperty" -> handleGetProperty(call, result)
-            "observeProperty" -> handleObserveProperty(call, result)
-            "command" -> handleCommand(call, result)
-            "setVisible" -> handleSetVisible(call, result)
-            "setVideoFrameRate" -> handleSetVideoFrameRate(call, result)
-            "clearVideoFrameRate" -> handleClearVideoFrameRate(result)
-            "requestAudioFocus" -> handleRequestAudioFocus(result)
-            "abandonAudioFocus" -> handleAbandonAudioFocus(result)
-            "openContentFd" -> handleOpenContentFd(call, result)
-            "isInitialized" -> result.success(playerCore?.isInitialized ?: false)
-            "setLogLevel" -> result.success(null)
-            else -> result.notImplemented()
-        }
-    }
-
-    private fun handleInitialize(result: MethodChannel.Result) {
-        val currentActivity = activity
-        if (currentActivity == null) {
-            result.error("NO_ACTIVITY", "Activity not available", null)
-            return
+    currentActivity.runOnUiThread {
+      val gen: Int
+      val core: MpvPlayerCore
+      try {
+        // Caller invariant: dispose() was already called explicitly,
+        // OR `playerCore?.isInitialized == true` and we early-exited
+        // above. We never tear down a core that's mid-initialization.
+        if (playerCore != null && playerCore?.isInitialized != true) {
+          Log.w(TAG, "Discarding stale uninitialized core before re-init")
+          playerCore?.dispose()
+          playerCore = null
         }
 
-        if (playerCore?.isInitialized == true) {
-            Log.d(TAG, "Already initialized")
-            result.success(true)
-            return
+        gen = ++sessionGeneration
+        core = MpvPlayerCore(currentActivity).apply {
+          delegate = this@MpvPlayerPlugin
         }
+        playerCore = core
+      } catch (e: Exception) {
+        Log.e(TAG, "Failed to initialize: ${e.message}", e)
+        completePendingInits(success = false, errorMessage = e.message)
+        return@runOnUiThread
+      }
 
-        currentActivity.runOnUiThread {
-            try {
-                playerCore = MpvPlayerCore(currentActivity).apply {
-                    delegate = this@MpvPlayerPlugin
-                }
-
-                playerCore?.initialize { success ->
-                    // Start hidden - now safe because setVisible operates on the container,
-                    // not the SurfaceView directly (matching ExoPlayer's approach)
-                    playerCore?.setVisible(false)
-                    Log.d(TAG, "Initialized: $success")
-                    result.success(success)
-                } ?: result.success(false)
-            } catch (e: Exception) {
-                Log.e(TAG, "Failed to initialize: ${e.message}", e)
-                result.error("INIT_FAILED", e.message, null)
-            }
+      core.initialize { success ->
+        val stale = gen != sessionGeneration || playerCore !== core
+        if (stale) {
+          Log.d(TAG, "Stale init callback (gen=$gen, current=$sessionGeneration)")
+        } else {
+          // Start hidden - now safe because setVisible operates on the container,
+          // not the SurfaceView directly (matching ExoPlayer's approach)
+          core.setVisible(false)
+          Log.d(TAG, "Initialized: $success")
         }
+        completePendingInits(success = !stale && success)
+      }
     }
+  }
 
-    private fun handleDispose(result: MethodChannel.Result) {
-        activity?.runOnUiThread {
-            playerCore?.dispose {
-                playerCore = null
-                Log.d(TAG, "Disposed")
-                result.success(null)
-            } ?: run {
-                playerCore = null
-                result.success(null)
-            }
-        } ?: result.success(null)
+  private fun completePendingInits(success: Boolean, errorMessage: String? = null) {
+    val pending = synchronized(pendingInitResults) {
+      isInitializing = false
+      val copy = pendingInitResults.toList()
+      pendingInitResults.clear()
+      copy
     }
-
-    private fun handleSetProperty(call: MethodCall, result: MethodChannel.Result) {
-        val name = call.argument<String>("name")
-        val value = call.argument<String>("value")
-
-        if (name == null || value == null) {
-            result.error("INVALID_ARGS", "Missing 'name' or 'value'", null)
-            return
-        }
-
-        playerCore?.setPropertyAsync(name, value, result)
-            ?: result.success(null)
+    for (r in pending) {
+      if (errorMessage != null) {
+        r.error("INIT_FAILED", errorMessage, null)
+      } else {
+        r.success(success)
+      }
     }
+  }
 
-    private fun handleGetProperty(call: MethodCall, result: MethodChannel.Result) {
-        val name = call.argument<String>("name")
+  private fun handleDispose(result: MethodChannel.Result) {
+    activity?.runOnUiThread {
+      val core = playerCore
+      ++sessionGeneration
+      playerCore = null
 
-        if (name == null) {
-            result.error("INVALID_ARGS", "Missing 'name'", null)
-            return
-        }
+      // Any in-flight init callback is cancelled with the scope, so
+      // close out queued callers here instead of leaking them.
+      completePendingInits(success = false)
 
-        playerCore?.getPropertyAsync(name, result)
-            ?: result.success(null)
-    }
-
-    private fun handleObserveProperty(call: MethodCall, result: MethodChannel.Result) {
-        val name = call.argument<String>("name")
-        val format = call.argument<String>("format")
-        val id = call.argument<Int>("id")
-
-        if (name == null || format == null || id == null) {
-            result.error("INVALID_ARGS", "Missing 'name', 'format', or 'id'", null)
-            return
-        }
-
-        nameToId[name] = id
-        playerCore?.observePropertyAsync(name, format, result)
-            ?: result.success(null)
-    }
-
-    private fun handleCommand(call: MethodCall, result: MethodChannel.Result) {
-        val args = call.argument<List<String>>("args")
-
-        if (args == null) {
-            result.error("INVALID_ARGS", "Missing 'args'", null)
-            return
-        }
-
-        // Use async command to prevent ANR - command executes off UI thread
-        // and result is called back when complete
-        playerCore?.commandAsync(args.toTypedArray(), result)
-            ?: result.success(null)
-    }
-
-    private fun handleSetVisible(call: MethodCall, result: MethodChannel.Result) {
-        val visible = call.argument<Boolean>("visible")
-
-        if (visible == null) {
-            result.error("INVALID_ARGS", "Missing 'visible'", null)
-            return
-        }
-
-        playerCore?.setVisible(visible)
+      core?.dispose {
+        Log.d(TAG, "Disposed")
         result.success(null)
+      } ?: result.success(null)
+    } ?: result.success(null)
+  }
+
+  private fun handleSetProperty(call: MethodCall, result: MethodChannel.Result) {
+    val name = call.argument<String>("name")
+    val value = call.argument<String>("value")
+
+    if (name == null || value == null) {
+      result.error("INVALID_ARGS", "Missing 'name' or 'value'", null)
+      return
     }
 
-    private fun handleSetVideoFrameRate(call: MethodCall, result: MethodChannel.Result) {
-        val fps = call.argument<Double>("fps")?.toFloat() ?: 0f
-        val duration = call.argument<Number>("duration")?.toLong() ?: 0L
+    playerCore?.setProperty(name, value)
+    result.success(null)
+  }
 
-        Log.d(TAG, "setVideoFrameRate: fps=$fps, duration=$duration")
-        playerCore?.setVideoFrameRate(fps, duration)
-        result.success(null)
+  private fun handleGetProperty(call: MethodCall, result: MethodChannel.Result) {
+    val name = call.argument<String>("name")
+
+    if (name == null) {
+      result.error("INVALID_ARGS", "Missing 'name'", null)
+      return
     }
 
-    private fun handleClearVideoFrameRate(result: MethodChannel.Result) {
-        Log.d(TAG, "clearVideoFrameRate")
-        playerCore?.clearVideoFrameRate()
-        result.success(null)
+    val value = playerCore?.getProperty(name)
+    result.success(value)
+  }
+
+  private fun handleObserveProperty(call: MethodCall, result: MethodChannel.Result) {
+    val name = call.argument<String>("name")
+    val format = call.argument<String>("format")
+    val id = call.argument<Int>("id")
+
+    if (name == null || format == null || id == null) {
+      result.error("INVALID_ARGS", "Missing 'name', 'format', or 'id'", null)
+      return
     }
 
-    private fun handleRequestAudioFocus(result: MethodChannel.Result) {
-        Log.d(TAG, "requestAudioFocus")
-        val granted = playerCore?.requestAudioFocus() ?: false
-        result.success(granted)
+    nameToId[name] = id
+    playerCore?.observeProperty(name, format)
+    result.success(null)
+  }
+
+  private fun handleCommand(call: MethodCall, result: MethodChannel.Result) {
+    val args = call.argument<List<String>>("args")
+
+    if (args == null) {
+      result.error("INVALID_ARGS", "Missing 'args'", null)
+      return
     }
 
-    private fun handleAbandonAudioFocus(result: MethodChannel.Result) {
-        Log.d(TAG, "abandonAudioFocus")
-        playerCore?.abandonAudioFocus()
-        result.success(null)
+    val core = playerCore
+    if (core == null) {
+      result.success(null)
+      return
+    }
+    core.command(args.toTypedArray()) {
+      result.success(null)
+    }
+  }
+
+  private fun handleSetVisible(call: MethodCall, result: MethodChannel.Result) {
+    val visible = call.argument<Boolean>("visible")
+
+    if (visible == null) {
+      result.error("INVALID_ARGS", "Missing 'visible'", null)
+      return
     }
 
-    private fun handleOpenContentFd(call: MethodCall, result: MethodChannel.Result) {
-        val uriString = call.argument<String>("uri")
-        if (uriString == null) {
-            result.error("INVALID_ARGS", "Missing 'uri'", null)
-            return
+    playerCore?.setVisible(visible)
+    result.success(null)
+  }
+
+  private fun handleUpdateFrame(result: MethodChannel.Result) {
+    playerCore?.updateFrame()
+    result.success(null)
+  }
+
+  private fun handleSetVideoFrameRate(call: MethodCall, result: MethodChannel.Result) {
+    val fps = call.argument<Double>("fps")?.toFloat() ?: 0f
+    val duration = call.argument<Number>("duration")?.toLong() ?: 0L
+    val extraDelayMs = call.argument<Number>("extraDelayMs")?.toLong() ?: 0L
+
+    Log.d(TAG, "setVideoFrameRate: fps=$fps, duration=$duration, extraDelayMs=$extraDelayMs")
+    val core = playerCore
+    if (core == null) {
+      result.success(false)
+      return
+    }
+    core.setVideoFrameRate(fps, duration, extraDelayMs) { switched ->
+      result.success(switched)
+    }
+  }
+
+  private fun handleClearVideoFrameRate(result: MethodChannel.Result) {
+    Log.d(TAG, "clearVideoFrameRate")
+    playerCore?.clearVideoFrameRate()
+    result.success(null)
+  }
+
+  private fun handleRequestAudioFocus(result: MethodChannel.Result) {
+    Log.d(TAG, "requestAudioFocus")
+    val granted = playerCore?.requestAudioFocus() ?: false
+    result.success(granted)
+  }
+
+  private fun handleAbandonAudioFocus(result: MethodChannel.Result) {
+    Log.d(TAG, "abandonAudioFocus")
+    playerCore?.abandonAudioFocus()
+    result.success(null)
+  }
+
+  private fun handleOpenContentFd(call: MethodCall, result: MethodChannel.Result) {
+    val uriString = call.argument<String>("uri")
+    if (uriString == null) {
+      result.error("INVALID_ARGS", "Missing 'uri'", null)
+      return
+    }
+
+    val contentResolver = activity?.contentResolver
+    if (contentResolver == null) {
+      result.error("NO_ACTIVITY", "Activity not available", null)
+      return
+    }
+
+    // Open file descriptor off UI thread to prevent ANR on slow storage
+    Thread {
+      try {
+        val uri = Uri.parse(uriString)
+        val pfd = contentResolver.openFileDescriptor(uri, "r")
+        if (pfd == null) {
+          activity?.runOnUiThread {
+            result.error("OPEN_FAILED", "Failed to open file descriptor for $uriString", null)
+          }
+          return@Thread
         }
 
-        val contentResolver = activity?.contentResolver
-        if (contentResolver == null) {
-            result.error("NO_ACTIVITY", "Activity not available", null)
-            return
-        }
+        val fd = pfd.detachFd()
+        Log.d(TAG, "Opened content FD $fd for $uriString")
+        activity?.runOnUiThread { result.success(fd) }
+      } catch (e: Exception) {
+        Log.e(TAG, "Failed to open content FD: ${e.message}", e)
+        activity?.runOnUiThread { result.error("OPEN_FAILED", e.message, null) }
+      }
+    }.start()
+  }
 
-        // Open file descriptor off UI thread to prevent ANR on slow storage
-        playerCore?.runOnExecutor {
-            try {
-                val uri = Uri.parse(uriString)
-                val pfd = contentResolver.openFileDescriptor(uri, "r")
-                if (pfd == null) {
-                    activity?.runOnUiThread {
-                        result.error("OPEN_FAILED", "Failed to open file descriptor for $uriString", null)
-                    }
-                    return@runOnExecutor
-                }
+  // PlayerDelegate
 
-                val fd = pfd.detachFd()
-                Log.d(TAG, "Opened content FD $fd for $uriString")
-                activity?.runOnUiThread { result.success(fd) }
-            } catch (e: Exception) {
-                Log.e(TAG, "Failed to open content FD: ${e.message}", e)
-                activity?.runOnUiThread { result.error("OPEN_FAILED", e.message, null) }
-            }
-        } ?: result.error("NO_PLAYER", "Player not initialized", null)
-    }
+  override fun onPropertyChange(name: String, value: Any?) {
+    val propId = nameToId[name] ?: return
+    eventSink?.success(listOf(propId, value))
+  }
 
-    // PlayerDelegate
-
-    override fun onPropertyChange(name: String, value: Any?) {
-        val propId = nameToId[name] ?: return
-        eventSink?.success(listOf(propId, value))
-    }
-
-    override fun onEvent(name: String, data: Map<String, Any>?) {
-        val event = mutableMapOf<String, Any>(
-            "type" to "event",
-            "name" to name
-        )
-        data?.let { event["data"] = it }
-        eventSink?.success(event)
-    }
+  override fun onEvent(name: String, data: Map<String, Any>?) {
+    val event = mutableMapOf<String, Any>(
+      "type" to "event",
+      "name" to name
+    )
+    data?.let { event["data"] = it }
+    eventSink?.success(event)
+  }
 }

android/app/src/main/kotlin/com/edde746/plezy/shared/AudioFocusManager.kt

@@ -9,97 +9,97 @@ import android.os.Handler
 import android.util.Log
 
 class AudioFocusManager(
-    context: Context,
-    private val handler: Handler,
-    private val onPause: () -> Unit,
-    private val onResume: () -> Unit,
-    private val isPaused: () -> Boolean,
-    private val log: (String) -> Unit = { Log.d(TAG, it) }
+  context: Context,
+  private val handler: Handler,
+  private val onPause: () -> Unit,
+  private val onResume: () -> Unit,
+  private val isPaused: () -> Boolean,
+  private val log: (String) -> Unit = { Log.d(TAG, it) }
 ) {
-    companion object {
-        private const val TAG = "AudioFocusManager"
-    }
+  companion object {
+    private const val TAG = "AudioFocusManager"
+  }
 
-    private val audioManager = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
-    private var audioFocusRequest: AudioFocusRequest? = null
-    private var hasAudioFocus: Boolean = false
-    var wasPlayingBeforeFocusLoss: Boolean = false
-        private set
+  private val audioManager = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+  private var audioFocusRequest: AudioFocusRequest? = null
+  private var hasAudioFocus: Boolean = false
+  var wasPlayingBeforeFocusLoss: Boolean = false
+    private set
 
-    private val audioFocusChangeListener = AudioManager.OnAudioFocusChangeListener { focusChange ->
-        when (focusChange) {
-            AudioManager.AUDIOFOCUS_GAIN -> {
-                log("Focus gained")
-                hasAudioFocus = true
-                if (wasPlayingBeforeFocusLoss) {
-                    onResume()
-                    wasPlayingBeforeFocusLoss = false
-                }
-            }
-            AudioManager.AUDIOFOCUS_LOSS -> {
-                log("Focus lost permanently")
-                hasAudioFocus = false
-                wasPlayingBeforeFocusLoss = !isPaused()
-                onPause()
-            }
-            AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
-                log("Focus lost transiently")
-                hasAudioFocus = false
-                wasPlayingBeforeFocusLoss = !isPaused()
-                onPause()
-            }
-            AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> {
-                log("Focus lost transiently (can duck)")
-            }
+  private val audioFocusChangeListener = AudioManager.OnAudioFocusChangeListener { focusChange ->
+    when (focusChange) {
+      AudioManager.AUDIOFOCUS_GAIN -> {
+        log("Focus gained")
+        hasAudioFocus = true
+        if (wasPlayingBeforeFocusLoss) {
+          onResume()
+          wasPlayingBeforeFocusLoss = false
         }
-    }
-
-    fun requestAudioFocus(): Boolean {
-        Log.d(TAG, "Requesting audio focus")
-
-        val result = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            val focusRequest = AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN)
-                .setAudioAttributes(
-                    AudioAttributes.Builder()
-                        .setUsage(AudioAttributes.USAGE_MEDIA)
-                        .setContentType(AudioAttributes.CONTENT_TYPE_MOVIE)
-                        .build()
-                )
-                .setOnAudioFocusChangeListener(audioFocusChangeListener, handler)
-                .build()
-
-            audioFocusRequest = focusRequest
-            audioManager.requestAudioFocus(focusRequest)
-        } else {
-            @Suppress("DEPRECATION")
-            audioManager.requestAudioFocus(
-                audioFocusChangeListener,
-                AudioManager.STREAM_MUSIC,
-                AudioManager.AUDIOFOCUS_GAIN
-            )
-        }
-
-        hasAudioFocus = (result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED)
-        Log.d(TAG, "Audio focus request result: $result, granted: $hasAudioFocus")
-        return hasAudioFocus
-    }
-
-    fun abandonAudioFocus() {
-        Log.d(TAG, "Abandoning audio focus")
-
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            audioFocusRequest?.let { audioManager.abandonAudioFocusRequest(it) }
-            audioFocusRequest = null
-        } else {
-            @Suppress("DEPRECATION")
-            audioManager.abandonAudioFocus(audioFocusChangeListener)
-        }
-
+      }
+      AudioManager.AUDIOFOCUS_LOSS -> {
+        log("Focus lost permanently")
         hasAudioFocus = false
-        wasPlayingBeforeFocusLoss = false
+        wasPlayingBeforeFocusLoss = !isPaused()
+        onPause()
+      }
+      AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
+        log("Focus lost transiently")
+        hasAudioFocus = false
+        wasPlayingBeforeFocusLoss = !isPaused()
+        onPause()
+      }
+      AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> {
+        log("Focus lost transiently (can duck)")
+      }
+    }
+  }
+
+  fun requestAudioFocus(): Boolean {
+    Log.d(TAG, "Requesting audio focus")
+
+    val result = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      val focusRequest = AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN)
+        .setAudioAttributes(
+          AudioAttributes.Builder()
+            .setUsage(AudioAttributes.USAGE_MEDIA)
+            .setContentType(AudioAttributes.CONTENT_TYPE_MOVIE)
+            .build()
+        )
+        .setOnAudioFocusChangeListener(audioFocusChangeListener, handler)
+        .build()
+
+      audioFocusRequest = focusRequest
+      audioManager.requestAudioFocus(focusRequest)
+    } else {
+      @Suppress("DEPRECATION")
+      audioManager.requestAudioFocus(
+        audioFocusChangeListener,
+        AudioManager.STREAM_MUSIC,
+        AudioManager.AUDIOFOCUS_GAIN
+      )
     }
 
-    fun release() {
-        abandonAudioFocus()
+    hasAudioFocus = (result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED)
+    Log.d(TAG, "Audio focus request result: $result, granted: $hasAudioFocus")
+    return hasAudioFocus
+  }
+
+  fun abandonAudioFocus() {
+    Log.d(TAG, "Abandoning audio focus")
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      audioFocusRequest?.let { audioManager.abandonAudioFocusRequest(it) }
+      audioFocusRequest = null
+    } else {
+      @Suppress("DEPRECATION")
+      audioManager.abandonAudioFocus(audioFocusChangeListener)
     }
+
+    hasAudioFocus = false
+    wasPlayingBeforeFocusLoss = false
+  }
+
+  fun release() {
+    abandonAudioFocus()
+  }
 }

android/app/src/main/kotlin/com/edde746/plezy/shared/DeviceQuirks.kt

@@ -0,0 +1,23 @@
+package com.edde746.plezy.shared
+
+import android.os.Build
+
+object DeviceQuirks {
+  val isEWaste: Boolean
+    get() = isGooglePixelDevice || isGoogleTensorDevice
+
+  private val isGooglePixelDevice: Boolean
+    get() = (
+      Build.MANUFACTURER.equals("Google", ignoreCase = true) ||
+        Build.BRAND.equals("google", ignoreCase = true)
+      ) &&
+      Build.MODEL.contains("Pixel", ignoreCase = true)
+
+  private val isGoogleTensorDevice: Boolean
+    get() {
+      if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) return false
+      val soc = Build.SOC_MODEL
+      return soc.startsWith("Tensor", ignoreCase = true) ||
+        soc.startsWith("GS", ignoreCase = true)
+    }
+}

android/app/src/main/kotlin/com/edde746/plezy/shared/FlutterOverlayHelper.kt

@@ -1,6 +1,7 @@
 package com.edde746.plezy.shared
 
 import android.graphics.PixelFormat
+import android.os.Build
 import android.view.SurfaceView
 import android.view.TextureView
 import android.view.View
@@ -8,52 +9,84 @@ import android.view.ViewGroup
 
 object FlutterOverlayHelper {
 
-    /**
-     * Find the FlutterView container in the content view hierarchy.
-     * First tries to match by class name (works in debug builds),
-     * then falls back to picking the last ViewGroup with children
-     * (needed for release builds where FlutterView may be obfuscated).
-     */
-    fun findFlutterContainer(contentView: ViewGroup, excludeView: View? = null): ViewGroup? {
-        // First pass: look for FlutterView by name (debug builds)
-        for (i in 0 until contentView.childCount) {
-            val child = contentView.getChildAt(i)
-            if (child is ViewGroup && child.javaClass.name.contains("FlutterView")) {
-                return child
-            }
-        }
-
-        // Fallback for release (FlutterView may be obfuscated): pick the last ViewGroup
-        // that is not our video container and has children.
-        for (i in contentView.childCount - 1 downTo 0) {
-            val child = contentView.getChildAt(i)
-            if (child is ViewGroup && child != excludeView && child.childCount > 0) {
-                return child
-            }
-        }
-
-        return null
+  /**
+   * Find the top-level container holding the Flutter render surface. Returns the
+   * direct child of [contentView] that contains a FlutterSurfaceView/FlutterTextureView
+   * at any depth — `bringChildToFront` only works for direct children, so this is the
+   * node to pass to [configureFlutterZOrder].
+   *
+   * Searches any depth because an app may wrap Flutter (e.g. for key-event dispatch)
+   * and push it below the direct-child level.
+   */
+  fun findFlutterContainer(contentView: ViewGroup, excludeView: View? = null): ViewGroup? {
+    for (i in contentView.childCount - 1 downTo 0) {
+      val child = contentView.getChildAt(i)
+      if (child === excludeView || child !is ViewGroup) continue
+      if (findRenderSurface(child) != null) return child
     }
+    return null
+  }
 
-    /**
-     * Configure z-ordering so the Flutter UI renders above the video surface.
-     *
-     * @param zOrderOnTop true for MPV (Flutter needs to be fully on top),
-     *                    false for ExoPlayer (subtitle layer sits between video and Flutter)
-     */
-    fun configureFlutterZOrder(contentView: ViewGroup, container: ViewGroup, zOrderOnTop: Boolean) {
-        contentView.bringChildToFront(container)
-        for (j in 0 until container.childCount) {
-            val flutterChild = container.getChildAt(j)
-            if (flutterChild is SurfaceView) {
-                flutterChild.setZOrderOnTop(zOrderOnTop)
-                flutterChild.setZOrderMediaOverlay(true)
-                flutterChild.holder.setFormat(PixelFormat.TRANSLUCENT)
-                break
-            } else if (flutterChild is TextureView) {
-                flutterChild.isOpaque = false
-                break
-            }
-        }
+  private fun findRenderSurface(root: ViewGroup): View? {
+    for (i in 0 until root.childCount) {
+      val child = root.getChildAt(i)
+      if (child is SurfaceView || child is TextureView) return child
+      if (child is ViewGroup) findRenderSurface(child)?.let { return it }
     }
+    return null
+  }
+
+  /**
+   * Apply [SurfaceView.setCompositionOrder] on API 36+; no-op on older APIs where
+   * the legacy [SurfaceView.setZOrderOnTop]/[SurfaceView.setZOrderMediaOverlay]
+   * bucket settings govern Z-order instead.
+   *
+   * The value maps directly to the SurfaceView's `mSubLayer`. Per AOSP semantics:
+   * `mSubLayer >= 0` (non-negative `order`) is composited above the parent window
+   * and skips the hole-punch in `draw()`; `mSubLayer < 0` (negative `order`) is
+   * behind the parent window and the SurfaceView is made visible by punching a
+   * transparent hole in the parent canvas. Valid range is `[-2, 2]`. Picking the
+   * right sign matters: any view that draws on the parent canvas (e.g. Media3's
+   * `CanvasSubtitleOutput` for SRT/VTT/SDH) is hidden by SurfaceViews with
+   * non-negative orders that sit on top of the same area.
+   */
+  fun applyCompositionOrder(view: SurfaceView, order: Int) {
+    if (Build.VERSION.SDK_INT >= 36) view.compositionOrder = order
+  }
+
+  /**
+   * Configure z-ordering so the Flutter UI renders above the video/subtitle surfaces.
+   *
+   * On API 36+ the value is applied via [SurfaceView.setCompositionOrder] and maps
+   * directly to `mSubLayer` (see [applyCompositionOrder] for the sign semantics).
+   * On pre-36 SurfaceView builds the value is mapped to the legacy on-top bucket
+   * when positive. On TextureView builds the value is unused (view hierarchy order
+   * handles it).
+   *
+   * Pass a non-negative value (e.g. `1`) so Flutter renders above the parent canvas
+   * and lets the legacy transparent-mode `setZOrderOnTop(true)` semantics carry over.
+   */
+  fun configureFlutterZOrder(contentView: ViewGroup, container: ViewGroup, compositionOrder: Int) {
+    contentView.bringChildToFront(container)
+    when (val surface = findRenderSurface(container)) {
+      is SurfaceView -> {
+        if (Build.VERSION.SDK_INT >= 36) {
+          // Clear legacy bucket hints so compositionOrder is authoritative.
+          // Flutter's FlutterSurfaceView sets setZOrderOnTop(true) in its
+          // transparent-mode constructor, which otherwise pins it to z=1.
+          surface.setZOrderOnTop(false)
+          surface.setZOrderMediaOverlay(false)
+          surface.compositionOrder = compositionOrder
+        } else {
+          // Pre-36 has 3 coarse sublayer buckets. Put Flutter in the on-top
+          // bucket so it renders above the video (default) and libass subtitle
+          // (media overlay) SurfaceViews. NB: setZOrderMediaOverlay overwrites
+          // mSubLayer internally, so don't call it here or it cancels setZOrderOnTop.
+          surface.setZOrderOnTop(compositionOrder > 0)
+        }
+        surface.holder.setFormat(PixelFormat.TRANSLUCENT)
+      }
+      is TextureView -> surface.isOpaque = false
+    }
+  }
 }

android/app/src/main/kotlin/com/edde746/plezy/shared/FrameRateManager.kt

@@ -6,176 +6,264 @@ import android.hardware.display.DisplayManager
 import android.os.Build
 import android.os.Handler
 import android.util.Log
-import android.view.Surface
+import android.view.Display
 import android.view.WindowManager
 import androidx.annotation.RequiresApi
-import java.math.BigDecimal
-import java.math.RoundingMode
+import kotlin.math.abs
+import kotlin.math.roundToInt
 
 class FrameRateManager(
-    private val activity: Activity,
-    private val handler: Handler,
-    private val onDisplayChanged: () -> Unit,
-    private val log: (String) -> Unit = { Log.d(TAG, it) }
+  private val activity: Activity,
+  private val handler: Handler,
+  private val log: (String) -> Unit = { Log.d(TAG, it) }
 ) {
-    companion object {
-        private const val TAG = "FrameRateManager"
-        private const val SHORT_VIDEO_LENGTH_MS = 300000L // 5 minutes
+  companion object {
+    private const val TAG = "FrameRateManager"
+    private const val DISPLAY_SETTLE_MS = 2000L
+    private const val WATCHDOG_MARGIN_MS = 3000L
+    private const val RATE_TOLERANCE = 0.1f
+  }
+
+  private data class RefreshRateMatch(
+    val reason: String,
+    val priority: Int,
+    val error: Float
+  )
+
+  @RequiresApi(Build.VERSION_CODES.M)
+  private data class DisplayModeCandidate(
+    val mode: Display.Mode,
+    val match: RefreshRateMatch
+  )
+
+  private var currentVideoFps: Float = 0f
+  private var displayListener: DisplayManager.DisplayListener? = null
+  private var pendingSettleRunnable: Runnable? = null
+  private var watchdogRunnable: Runnable? = null
+  private var pendingCompletion: ((switched: Boolean) -> Unit)? = null
+
+  private fun getDisplayManager(): DisplayManager = activity.getSystemService(Context.DISPLAY_SERVICE) as DisplayManager
+
+  // Request a display frame-rate switch. Invokes [onComplete] once, either:
+  // - immediately with `switched=false` when no switch is needed (invalid fps,
+  //   no matching mode, or already matching); or
+  // - after the real DisplayListener event + [DISPLAY_SETTLE_MS] + the caller's
+  //   [extraDelayMs], with `switched=true`; or
+  // - via a watchdog if the real event never arrives, so the caller doesn't hang.
+  //
+  // The caller is responsible for pausing playback before calling and resuming
+  // it after [onComplete] fires.
+  fun setVideoFrameRate(
+    fps: Float,
+    videoDurationMs: Long,
+    extraDelayMs: Long,
+    onComplete: (switched: Boolean) -> Unit
+  ) {
+    currentVideoFps = fps
+    if (fps <= 0f) {
+      Log.d(TAG, "setVideoFrameRate: Invalid fps ($fps), skipping")
+      onComplete(false)
+      return
     }
 
-    private var currentVideoFps: Float = 0f
-    private var displayListener: DisplayManager.DisplayListener? = null
+    log(
+      "request fps=$fps, duration=${videoDurationMs}ms, extraDelayMs=$extraDelayMs, " +
+        "API=${Build.VERSION.SDK_INT}, currentMode=${currentModeDescription()}"
+    )
 
-    private fun getDisplayManager(): DisplayManager {
-        return activity.getSystemService(Context.DISPLAY_SERVICE) as DisplayManager
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+      setDisplayMode(fps, extraDelayMs, onComplete)
+    } else {
+      onComplete(false)
+    }
+  }
+
+  fun clearVideoFrameRate() {
+    Log.d(TAG, "clearVideoFrameRate")
+    currentVideoFps = 0f
+    // Resolve any pending setVideoFrameRate future as "not switched" so
+    // the Dart caller's await doesn't hang on player dispose.
+    firePendingCompletion("clear", switched = false)
+    // Restore default display mode on API M (preferredDisplayModeId persists)
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+      activity.window?.attributes?.let { attrs ->
+        attrs.preferredDisplayModeId = 0
+        activity.window?.attributes = attrs
+      }
+    }
+  }
+
+  // Release pending callbacks/listener without restoring the display mode.
+  // Used by player-core dispose paths so a backend handoff (e.g. ExoPlayer→MPV
+  // audio fallback) doesn't clobber the just-applied refresh-rate switch —
+  // window-scoped preferredDisplayModeId persists across the SurfaceView swap,
+  // letting MPV inherit the rate without a second HDMI renegotiation.
+  fun releasePending() {
+    Log.d(TAG, "releasePending")
+    currentVideoFps = 0f
+    firePendingCompletion("release", switched = false)
+  }
+
+  private fun cancelPendingCallbacks() {
+    pendingSettleRunnable?.let { handler.removeCallbacks(it) }
+    watchdogRunnable?.let { handler.removeCallbacks(it) }
+    pendingSettleRunnable = null
+    watchdogRunnable = null
+  }
+
+  private fun firePendingCompletion(reason: String, switched: Boolean) {
+    cancelPendingCallbacks()
+    displayListener?.let {
+      getDisplayManager().unregisterDisplayListener(it)
+      displayListener = null
+    }
+    val cb = pendingCompletion ?: return
+    pendingCompletion = null
+    log("complete reason=$reason, switched=$switched, currentMode=${currentModeDescription()}")
+    cb(switched)
+  }
+
+  private fun registerDisplayListener(fps: Float, extraDelayMs: Long, onComplete: (switched: Boolean) -> Unit) {
+    // Resolve any previous pending op before starting a new one.
+    firePendingCompletion("superseded", switched = false)
+    pendingCompletion = onComplete
+
+    displayListener = object : DisplayManager.DisplayListener {
+      override fun onDisplayAdded(displayId: Int) = Unit
+      override fun onDisplayRemoved(displayId: Int) = Unit
+      override fun onDisplayChanged(displayId: Int) {
+        // Unregister immediately so a chatty display (e.g. several
+        // onDisplayChanged events during HDMI renegotiation) doesn't
+        // queue multiple settle callbacks.
+        getDisplayManager().unregisterDisplayListener(this)
+        displayListener = null
+
+        val settle = Runnable { firePendingCompletion("display settled", switched = currentRateMatch(fps) != null) }
+        pendingSettleRunnable = settle
+        handler.postDelayed(settle, DISPLAY_SETTLE_MS + extraDelayMs)
+      }
+    }
+    getDisplayManager().registerDisplayListener(displayListener, handler)
+
+    // Watchdog: if the TV never signals a display change (silently ignoring
+    // the mode request), still complete after a bounded wait so the caller
+    // doesn't hang.
+    val watchdog = Runnable { firePendingCompletion("watchdog", switched = currentRateMatch(fps) != null) }
+    watchdogRunnable = watchdog
+    handler.postDelayed(watchdog, DISPLAY_SETTLE_MS + extraDelayMs + WATCHDOG_MARGIN_MS)
+  }
+
+  private fun matchRefreshRate(refreshRate: Float, fps: Float): RefreshRateMatch? {
+    if (refreshRate <= 0f || fps <= 0f) return null
+
+    val exactError = abs(refreshRate - fps)
+    if (exactError < RATE_TOLERANCE) {
+      return RefreshRateMatch(reason = "exact", priority = 0, error = exactError)
     }
 
-    fun setVideoFrameRate(fps: Float, videoDurationMs: Long, surface: Surface?) {
-        currentVideoFps = fps
-        if (fps <= 0f) {
-            Log.d(TAG, "setVideoFrameRate: Invalid fps ($fps), skipping")
-            return
-        }
-
-        if (surface == null) {
-            Log.d(TAG, "setVideoFrameRate: Surface not available")
-            return
-        }
-
-        log("fps=$fps, duration=${videoDurationMs}ms, API=${Build.VERSION.SDK_INT}")
-
-        when {
-            Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> setFrameRateS(fps, surface, videoDurationMs)
-            Build.VERSION.SDK_INT >= Build.VERSION_CODES.R -> setFrameRateR(fps, surface)
-            Build.VERSION.SDK_INT >= Build.VERSION_CODES.M -> setFrameRateM(fps)
-        }
+    val multiple = (refreshRate / fps).roundToInt()
+    if (multiple > 1) {
+      val multipleError = abs(refreshRate - (fps * multiple))
+      if (multipleError < RATE_TOLERANCE) {
+        return RefreshRateMatch(reason = "${multiple}x", priority = 1, error = multipleError)
+      }
     }
 
-    fun clearVideoFrameRate() {
-        Log.d(TAG, "clearVideoFrameRate")
-        currentVideoFps = 0f
-        displayListener?.let {
-            getDisplayManager().unregisterDisplayListener(it)
-            displayListener = null
-        }
+    return null
+  }
+
+  private fun currentRateMatch(fps: Float): RefreshRateMatch? {
+    val current = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+      currentDisplayMode()?.refreshRate
+    } else {
+      null
+    } ?: return null
+    return matchRefreshRate(current, fps)
+  }
+
+  private fun currentModeDescription(): String = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+    describeMode(currentDisplayMode())
+  } else {
+    "unavailable"
+  }
+
+  @RequiresApi(Build.VERSION_CODES.M)
+  private fun currentDisplay(): Display? = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+    activity.display
+  } else {
+    @Suppress("DEPRECATION")
+    (activity.getSystemService(Context.WINDOW_SERVICE) as WindowManager).defaultDisplay
+  }
+
+  @RequiresApi(Build.VERSION_CODES.M)
+  private fun currentDisplayMode(): Display.Mode? = currentDisplay()?.mode
+
+  @RequiresApi(Build.VERSION_CODES.M)
+  private fun describeMode(mode: Display.Mode?): String {
+    if (mode == null) return "unknown"
+    return "#${mode.modeId} ${mode.physicalWidth}x${mode.physicalHeight}@${mode.refreshRate}Hz"
+  }
+
+  @RequiresApi(Build.VERSION_CODES.M)
+  private fun describeSupportedModes(modes: Array<Display.Mode>): String = modes.joinToString(prefix = "[", postfix = "]") { describeMode(it) }
+
+  @RequiresApi(Build.VERSION_CODES.M)
+  private fun findBestModeMatch(fps: Float, currentMode: Display.Mode, supportedModes: Array<Display.Mode>): DisplayModeCandidate? = supportedModes.asSequence()
+    .filter { mode ->
+      mode.physicalHeight == currentMode.physicalHeight &&
+        mode.physicalWidth == currentMode.physicalWidth
+    }
+    .mapNotNull { mode -> matchRefreshRate(mode.refreshRate, fps)?.let { DisplayModeCandidate(mode, it) } }
+    .minWithOrNull(
+      compareBy<DisplayModeCandidate> { it.match.priority }
+        .thenBy { it.match.error }
+        .thenBy { abs(it.mode.refreshRate - currentMode.refreshRate) }
+    )
+
+  @RequiresApi(Build.VERSION_CODES.M)
+  private fun setDisplayMode(fps: Float, extraDelayMs: Long, onComplete: (switched: Boolean) -> Unit) {
+    log("setDisplayMode fps=$fps")
+    val display = currentDisplay()
+    if (display == null) {
+      log("display unavailable")
+      onComplete(false)
+      return
     }
 
-    private fun registerDisplayListener() {
-        displayListener?.let {
-            getDisplayManager().unregisterDisplayListener(it)
-        }
+    val supportedModes = display.supportedModes
+    if (supportedModes == null) {
+      log("supported display modes unavailable")
+      onComplete(false)
+      return
+    }
+    val currentMode = display.mode
+    log("supported modes=${describeSupportedModes(supportedModes)}")
 
-        displayListener = object : DisplayManager.DisplayListener {
-            override fun onDisplayAdded(displayId: Int) = Unit
-            override fun onDisplayRemoved(displayId: Int) = Unit
-            override fun onDisplayChanged(displayId: Int) {
-                handler.postDelayed({
-                    onDisplayChanged()
-                }, 2000L)
-                getDisplayManager().unregisterDisplayListener(this)
-                displayListener = null
-            }
-        }
-        getDisplayManager().registerDisplayListener(displayListener, handler)
+    val modeMatch = findBestModeMatch(fps, currentMode, supportedModes)
+    if (modeMatch == null) {
+      log("no matching display mode for ${fps}fps at ${currentMode.physicalWidth}x${currentMode.physicalHeight}")
+      onComplete(false)
+      return
     }
 
-    @RequiresApi(Build.VERSION_CODES.R)
-    private fun setFrameRateR(fps: Float, surface: Surface) {
-        Log.d(TAG, "setFrameRateR: Setting frame rate to $fps")
-        surface.setFrameRate(fps, Surface.FRAME_RATE_COMPATIBILITY_FIXED_SOURCE)
-        registerDisplayListener()
+    val modeToUse = modeMatch.mode
+    if (modeToUse.modeId == currentMode.modeId) {
+      log("current mode already matches ${fps}fps (${modeMatch.match.reason}), no switch needed")
+      onComplete(false)
+      return
     }
 
-    @RequiresApi(Build.VERSION_CODES.S)
-    private fun setFrameRateS(fps: Float, surface: Surface, videoDurationMs: Long) {
-        Log.d(TAG, "setFrameRateS: fps=$fps, duration=${videoDurationMs}ms")
-
-        if (videoDurationMs < SHORT_VIDEO_LENGTH_MS) {
-            Log.d(TAG, "Short video, using seamless-only switching")
-            surface.setFrameRate(
-                fps,
-                Surface.FRAME_RATE_COMPATIBILITY_FIXED_SOURCE,
-                Surface.CHANGE_FRAME_RATE_ONLY_IF_SEAMLESS
-            )
-            return
-        }
-
-        var seamless = false
-        activity.display?.mode?.alternativeRefreshRates?.let { refreshRates ->
-            for (rate in refreshRates) {
-                if (fps.toString().startsWith(rate.toString()) ||
-                    rate.toString().startsWith(fps.toString()) ||
-                    rate % fps == 0f) {
-                    seamless = true
-                    break
-                }
-            }
-        }
-
-        if (seamless) {
-            log("Seamless switch available for ${fps}fps")
-            surface.setFrameRate(
-                fps,
-                Surface.FRAME_RATE_COMPATIBILITY_FIXED_SOURCE,
-                Surface.CHANGE_FRAME_RATE_ALWAYS
-            )
-            registerDisplayListener()
-        } else {
-            val userPreference = getDisplayManager().matchContentFrameRateUserPreference
-            if (userPreference == DisplayManager.MATCH_CONTENT_FRAMERATE_ALWAYS) {
-                Log.d(TAG, "User preference allows non-seamless switch")
-                surface.setFrameRate(
-                    fps,
-                    Surface.FRAME_RATE_COMPATIBILITY_FIXED_SOURCE,
-                    Surface.CHANGE_FRAME_RATE_ALWAYS
-                )
-                registerDisplayListener()
-            } else {
-                Log.d(TAG, "Non-seamless switch not allowed, using seamless-only")
-                surface.setFrameRate(
-                    fps,
-                    Surface.FRAME_RATE_COMPATIBILITY_FIXED_SOURCE,
-                    Surface.CHANGE_FRAME_RATE_ONLY_IF_SEAMLESS
-                )
-            }
-        }
-    }
-
-    @RequiresApi(Build.VERSION_CODES.M)
-    private fun setFrameRateM(fps: Float) {
-        Log.d(TAG, "setFrameRateM: fps=$fps")
-        val wm = activity.getSystemService(Context.WINDOW_SERVICE) as WindowManager
-        @Suppress("DEPRECATION")
-        val display = wm.defaultDisplay ?: return
-
-        display.supportedModes?.let { supportedModes ->
-            val currentMode = display.mode
-            var modeToUse = currentMode
-
-            for (mode in supportedModes) {
-                if (mode.physicalHeight != currentMode.physicalHeight ||
-                    mode.physicalWidth != currentMode.physicalWidth) {
-                    continue
-                }
-
-                if (BigDecimal(fps.toString()).setScale(1, RoundingMode.FLOOR) ==
-                    BigDecimal(mode.refreshRate.toString()).setScale(1, RoundingMode.FLOOR)) {
-                    modeToUse = mode
-                    break
-                } else if (mode.refreshRate % fps == 0f) {
-                    modeToUse = mode
-                    break
-                }
-            }
-
-            if (modeToUse != currentMode) {
-                Log.d(TAG, "Switching to mode ${modeToUse.modeId} (${modeToUse.refreshRate}Hz)")
-                activity.window?.attributes?.let { attrs ->
-                    attrs.preferredDisplayModeId = modeToUse.modeId
-                    activity.window?.attributes = attrs
-                }
-                registerDisplayListener()
-            }
-        }
+    log(
+      "switching to ${describeMode(modeToUse)} for ${fps}fps " +
+        "(${modeMatch.match.reason}, error=${modeMatch.match.error})"
+    )
+    val window = activity.window
+    if (window == null) {
+      log("window unavailable")
+      onComplete(false)
+      return
     }
+    registerDisplayListener(fps, extraDelayMs, onComplete)
+    window.attributes = window.attributes.apply { preferredDisplayModeId = modeToUse.modeId }
+  }
 }

android/app/src/main/kotlin/com/edde746/plezy/shared/PlayerDelegate.kt

@@ -1,6 +1,6 @@
 package com.edde746.plezy.shared
 
 interface PlayerDelegate {
-    fun onPropertyChange(name: String, value: Any?)
-    fun onEvent(name: String, data: Map<String, Any>?)
+  fun onPropertyChange(name: String, value: Any?)
+  fun onEvent(name: String, data: Map<String, Any>?)
 }

android/app/src/main/kotlin/com/edde746/plezy/shared/ThemeHelper.kt

@@ -3,10 +3,10 @@ package com.edde746.plezy.shared
 import android.graphics.Color
 
 object ThemeHelper {
-    fun themeColor(mode: String?): Int? = when (mode) {
-        "oled" -> Color.BLACK
-        "dark" -> Color.parseColor("#0E0F12")
-        "light" -> Color.parseColor("#F7F7F8")
-        else -> null
-    }
+  fun themeColor(mode: String?): Int? = when (mode) {
+    "oled" -> Color.BLACK
+    "dark" -> Color.parseColor("#0E0F12")
+    "light" -> Color.parseColor("#F7F7F8")
+    else -> null
+  }
 }

android/app/src/main/kotlin/com/edde746/plezy/watchnext/WatchNextPlugin.kt

@@ -16,167 +16,169 @@ import java.util.concurrent.Executors
  * Flutter plugin for Android TV Watch Next integration.
  * Syncs Plex "On Deck" content to the Android TV launcher's Watch Next row.
  */
-class WatchNextPlugin : FlutterPlugin, MethodChannel.MethodCallHandler {
+class WatchNextPlugin :
+  FlutterPlugin,
+  MethodChannel.MethodCallHandler {
 
-    companion object {
-        private const val TAG = "WatchNextPlugin"
-        private const val METHOD_CHANNEL = "com.plezy/watch_next"
+  companion object {
+    private const val TAG = "WatchNextPlugin"
+    private const val METHOD_CHANNEL = "com.plezy/watch_next"
 
-        private var pendingDeepLink: String? = null
-
-        /**
-         * Parse a Watch Next deep link intent.
-         * Returns the content ID if this was a Watch Next intent, null otherwise.
-         */
-        fun handleIntent(intent: Intent?): String? {
-            val data = intent?.data ?: return null
-            if (data.scheme == "plezy" && data.authority == "play") {
-                return data.getQueryParameter("content_id")
-            }
-            return null
-        }
-    }
-
-    private lateinit var methodChannel: MethodChannel
-    private var applicationContext: Context? = null
-    private var watchNextProvider: WatchNextProvider? = null
-    private val ioExecutor by lazy { Executors.newSingleThreadExecutor() }
-    private val mainHandler = Handler(Looper.getMainLooper())
-
-    override fun onAttachedToEngine(binding: FlutterPlugin.FlutterPluginBinding) {
-        applicationContext = binding.applicationContext
-        watchNextProvider = WatchNextProvider(binding.applicationContext)
-        methodChannel = MethodChannel(binding.binaryMessenger, METHOD_CHANNEL)
-        methodChannel.setMethodCallHandler(this)
-    }
-
-    override fun onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding) {
-        methodChannel.setMethodCallHandler(null)
-        applicationContext = null
-        watchNextProvider = null
-        ioExecutor.shutdown()
-    }
-
-    override fun onMethodCall(call: MethodCall, result: MethodChannel.Result) {
-        when (call.method) {
-            "isSupported" -> handleIsSupported(result)
-            "sync" -> handleSync(call, result)
-            "clear" -> handleClear(result)
-            "remove" -> handleRemove(call, result)
-            "getInitialDeepLink" -> handleGetInitialDeepLink(result)
-            else -> result.notImplemented()
-        }
-    }
-
-    private fun handleIsSupported(result: MethodChannel.Result) {
-        val context = applicationContext
-        if (context == null) {
-            result.success(false)
-            return
-        }
-        result.success(context.packageManager.hasSystemFeature(PackageManager.FEATURE_LEANBACK))
-    }
-
-    private fun handleSync(call: MethodCall, result: MethodChannel.Result) {
-        val provider = watchNextProvider
-        if (provider == null) {
-            result.error("NOT_INITIALIZED", "WatchNextProvider not initialized", null)
-            return
-        }
-
-        val itemsData = call.argument<List<Map<String, Any?>>>("items")
-        if (itemsData == null) {
-            result.error("INVALID_ARGS", "Missing 'items' argument", null)
-            return
-        }
-
-        val items = itemsData.mapNotNull { parseWatchNextItem(it) }
-        executeOnIo(result) { provider.syncWatchNextPrograms(items) }
-    }
-
-    private fun handleClear(result: MethodChannel.Result) {
-        val provider = watchNextProvider
-        if (provider == null) {
-            result.error("NOT_INITIALIZED", "WatchNextProvider not initialized", null)
-            return
-        }
-        executeOnIo(result) { provider.clearAll() }
-    }
-
-    private fun handleRemove(call: MethodCall, result: MethodChannel.Result) {
-        val provider = watchNextProvider
-        if (provider == null) {
-            result.error("NOT_INITIALIZED", "WatchNextProvider not initialized", null)
-            return
-        }
-
-        val contentId = call.argument<String>("contentId")
-        if (contentId == null) {
-            result.error("INVALID_ARGS", "Missing 'contentId' argument", null)
-            return
-        }
-        executeOnIo(result) { provider.removeItem(contentId) }
-    }
-
-    private fun executeOnIo(result: MethodChannel.Result, block: () -> Any?) {
-        try {
-            ioExecutor.execute {
-                try {
-                    val value = block()
-                    mainHandler.post { result.success(value) }
-                } catch (e: Exception) {
-                    Log.e(TAG, "IO operation failed: ${e.message}", e)
-                    mainHandler.post { result.error("IO_ERROR", e.message, null) }
-                }
-            }
-        } catch (e: java.util.concurrent.RejectedExecutionException) {
-            result.error("SHUTDOWN", "Plugin is shutting down", null)
-        }
-    }
-
-    private fun handleGetInitialDeepLink(result: MethodChannel.Result) {
-        val contentId = pendingDeepLink
-        pendingDeepLink = null
-        result.success(contentId)
-    }
-
-    private fun parseWatchNextItem(data: Map<String, Any?>): WatchNextProvider.WatchNextItem? {
-        val contentId = data["contentId"] as? String ?: return null
-        val title = data["title"] as? String ?: return null
-
-        val typeString = data["type"] as? String ?: "movie"
-        val type = when (typeString.lowercase()) {
-            "episode" -> TvContractCompat.WatchNextPrograms.TYPE_TV_EPISODE
-            "movie" -> TvContractCompat.WatchNextPrograms.TYPE_MOVIE
-            else -> TvContractCompat.WatchNextPrograms.TYPE_MOVIE
-        }
-
-        return WatchNextProvider.WatchNextItem(
-            contentId = contentId,
-            title = title,
-            episodeTitle = data["episodeTitle"] as? String,
-            description = data["description"] as? String,
-            posterUri = data["posterUri"] as? String,
-            type = type,
-            duration = (data["duration"] as? Number)?.toLong() ?: 0L,
-            lastPlaybackPosition = (data["lastPlaybackPosition"] as? Number)?.toLong() ?: 0L,
-            lastEngagementTime = (data["lastEngagementTime"] as? Number)?.toLong() ?: System.currentTimeMillis(),
-            seriesTitle = data["seriesTitle"] as? String,
-            seasonNumber = (data["seasonNumber"] as? Number)?.toInt(),
-            episodeNumber = (data["episodeNumber"] as? Number)?.toInt()
-        )
-    }
+    private var pendingDeepLink: String? = null
 
     /**
-     * Store a deep link content ID for delivery to Flutter.
-     * Called from MainActivity on intent receipt.
+     * Parse a Watch Next deep link intent.
+     * Returns the content ID if this was a Watch Next intent, null otherwise.
      */
-    fun notifyDeepLink(contentId: String) {
-        pendingDeepLink = contentId
-        try {
-            methodChannel.invokeMethod("onWatchNextTap", mapOf("contentId" to contentId))
-        } catch (e: Exception) {
-            Log.d(TAG, "Method channel not ready, stored as pending deep link")
-        }
+    fun handleIntent(intent: Intent?): String? {
+      val data = intent?.data ?: return null
+      if (data.scheme == "plezy" && data.authority == "play") {
+        return data.getQueryParameter("content_id")
+      }
+      return null
     }
+  }
+
+  private lateinit var methodChannel: MethodChannel
+  private var applicationContext: Context? = null
+  private var watchNextProvider: WatchNextProvider? = null
+  private val ioExecutor by lazy { Executors.newSingleThreadExecutor() }
+  private val mainHandler = Handler(Looper.getMainLooper())
+
+  override fun onAttachedToEngine(binding: FlutterPlugin.FlutterPluginBinding) {
+    applicationContext = binding.applicationContext
+    watchNextProvider = WatchNextProvider(binding.applicationContext)
+    methodChannel = MethodChannel(binding.binaryMessenger, METHOD_CHANNEL)
+    methodChannel.setMethodCallHandler(this)
+  }
+
+  override fun onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding) {
+    methodChannel.setMethodCallHandler(null)
+    applicationContext = null
+    watchNextProvider = null
+    ioExecutor.shutdown()
+  }
+
+  override fun onMethodCall(call: MethodCall, result: MethodChannel.Result) {
+    when (call.method) {
+      "isSupported" -> handleIsSupported(result)
+      "sync" -> handleSync(call, result)
+      "clear" -> handleClear(result)
+      "remove" -> handleRemove(call, result)
+      "getInitialDeepLink" -> handleGetInitialDeepLink(result)
+      else -> result.notImplemented()
+    }
+  }
+
+  private fun handleIsSupported(result: MethodChannel.Result) {
+    val context = applicationContext
+    if (context == null) {
+      result.success(false)
+      return
+    }
+    result.success(context.packageManager.hasSystemFeature(PackageManager.FEATURE_LEANBACK))
+  }
+
+  private fun handleSync(call: MethodCall, result: MethodChannel.Result) {
+    val provider = watchNextProvider
+    if (provider == null) {
+      result.error("NOT_INITIALIZED", "WatchNextProvider not initialized", null)
+      return
+    }
+
+    val itemsData = call.argument<List<Map<String, Any?>>>("items")
+    if (itemsData == null) {
+      result.error("INVALID_ARGS", "Missing 'items' argument", null)
+      return
+    }
+
+    val items = itemsData.mapNotNull { parseWatchNextItem(it) }
+    executeOnIo(result) { provider.syncWatchNextPrograms(items) }
+  }
+
+  private fun handleClear(result: MethodChannel.Result) {
+    val provider = watchNextProvider
+    if (provider == null) {
+      result.error("NOT_INITIALIZED", "WatchNextProvider not initialized", null)
+      return
+    }
+    executeOnIo(result) { provider.clearAll() }
+  }
+
+  private fun handleRemove(call: MethodCall, result: MethodChannel.Result) {
+    val provider = watchNextProvider
+    if (provider == null) {
+      result.error("NOT_INITIALIZED", "WatchNextProvider not initialized", null)
+      return
+    }
+
+    val contentId = call.argument<String>("contentId")
+    if (contentId == null) {
+      result.error("INVALID_ARGS", "Missing 'contentId' argument", null)
+      return
+    }
+    executeOnIo(result) { provider.removeItem(contentId) }
+  }
+
+  private fun executeOnIo(result: MethodChannel.Result, block: () -> Any?) {
+    try {
+      ioExecutor.execute {
+        try {
+          val value = block()
+          mainHandler.post { result.success(value) }
+        } catch (e: Exception) {
+          Log.e(TAG, "IO operation failed: ${e.message}", e)
+          mainHandler.post { result.error("IO_ERROR", e.message, null) }
+        }
+      }
+    } catch (e: java.util.concurrent.RejectedExecutionException) {
+      result.error("SHUTDOWN", "Plugin is shutting down", null)
+    }
+  }
+
+  private fun handleGetInitialDeepLink(result: MethodChannel.Result) {
+    val contentId = pendingDeepLink
+    pendingDeepLink = null
+    result.success(contentId)
+  }
+
+  private fun parseWatchNextItem(data: Map<String, Any?>): WatchNextProvider.WatchNextItem? {
+    val contentId = data["contentId"] as? String ?: return null
+    val title = data["title"] as? String ?: return null
+
+    val typeString = data["type"] as? String ?: "movie"
+    val type = when (typeString.lowercase()) {
+      "episode" -> TvContractCompat.WatchNextPrograms.TYPE_TV_EPISODE
+      "movie" -> TvContractCompat.WatchNextPrograms.TYPE_MOVIE
+      else -> TvContractCompat.WatchNextPrograms.TYPE_MOVIE
+    }
+
+    return WatchNextProvider.WatchNextItem(
+      contentId = contentId,
+      title = title,
+      episodeTitle = data["episodeTitle"] as? String,
+      description = data["description"] as? String,
+      posterUri = data["posterUri"] as? String,
+      type = type,
+      duration = (data["duration"] as? Number)?.toLong() ?: 0L,
+      lastPlaybackPosition = (data["lastPlaybackPosition"] as? Number)?.toLong() ?: 0L,
+      lastEngagementTime = (data["lastEngagementTime"] as? Number)?.toLong() ?: System.currentTimeMillis(),
+      seriesTitle = data["seriesTitle"] as? String,
+      seasonNumber = (data["seasonNumber"] as? Number)?.toInt(),
+      episodeNumber = (data["episodeNumber"] as? Number)?.toInt()
+    )
+  }
+
+  /**
+   * Store a deep link content ID for delivery to Flutter.
+   * Called from MainActivity on intent receipt.
+   */
+  fun notifyDeepLink(contentId: String) {
+    pendingDeepLink = contentId
+    try {
+      methodChannel.invokeMethod("onWatchNextTap", mapOf("contentId" to contentId))
+    } catch (e: Exception) {
+      Log.d(TAG, "Method channel not ready, stored as pending deep link")
+    }
+  }
 }

android/app/src/main/kotlin/com/edde746/plezy/watchnext/WatchNextProvider.kt

@@ -14,154 +14,151 @@ import androidx.tvprovider.media.tv.WatchNextProgram
  */
 class WatchNextProvider(private val context: Context) {
 
-    companion object {
-        private const val TAG = "WatchNextProvider"
-    }
+  companion object {
+    private const val TAG = "WatchNextProvider"
+  }
 
-    data class WatchNextItem(
-        val contentId: String,
-        val title: String,
-        val episodeTitle: String?,
-        val description: String?,
-        val posterUri: String?,
-        val type: Int,
-        val duration: Long,
-        val lastPlaybackPosition: Long,
-        val lastEngagementTime: Long,
-        val seriesTitle: String?,
-        val seasonNumber: Int?,
-        val episodeNumber: Int?
+  data class WatchNextItem(
+    val contentId: String,
+    val title: String,
+    val episodeTitle: String?,
+    val description: String?,
+    val posterUri: String?,
+    val type: Int,
+    val duration: Long,
+    val lastPlaybackPosition: Long,
+    val lastEngagementTime: Long,
+    val seriesTitle: String?,
+    val seasonNumber: Int?,
+    val episodeNumber: Int?
+  )
+
+  /**
+   * Sync items to Watch Next row.
+   * Uses applyBatch to delete + insert in a single transaction so the
+   * launcher receives one content-change notification with the full set.
+   */
+  fun syncWatchNextPrograms(items: List<WatchNextItem>): Boolean = try {
+    val ops = ArrayList<ContentProviderOperation>()
+
+    ops.add(
+      ContentProviderOperation.newDelete(
+        TvContractCompat.WatchNextPrograms.CONTENT_URI
+      ).build()
     )
 
-    /**
-     * Sync items to Watch Next row.
-     * Uses applyBatch to delete + insert in a single transaction so the
-     * launcher receives one content-change notification with the full set.
-     */
-    fun syncWatchNextPrograms(items: List<WatchNextItem>): Boolean {
-        return try {
-            val ops = ArrayList<ContentProviderOperation>()
+    for (item in items) {
+      val program = buildProgram(item)
+      ops.add(
+        ContentProviderOperation.newInsert(
+          TvContractCompat.WatchNextPrograms.CONTENT_URI
+        ).withValues(program.toContentValues()).build()
+      )
+    }
 
-            ops.add(
-                ContentProviderOperation.newDelete(
-                    TvContractCompat.WatchNextPrograms.CONTENT_URI
-                ).build()
+    context.contentResolver.applyBatch(TvContractCompat.AUTHORITY, ops)
+    Log.d(TAG, "Synced ${items.size} Watch Next entries")
+    true
+  } catch (e: Exception) {
+    Log.e(TAG, "Failed to sync Watch Next programs", e)
+    false
+  }
+
+  fun clearAll(): Boolean = try {
+    context.contentResolver.delete(
+      TvContractCompat.WatchNextPrograms.CONTENT_URI,
+      null,
+      null
+    )
+    true
+  } catch (e: Exception) {
+    Log.e(TAG, "Failed to clear Watch Next entries", e)
+    false
+  }
+
+  fun removeItem(contentId: String): Boolean {
+    return try {
+      val cursor = context.contentResolver.query(
+        TvContractCompat.WatchNextPrograms.CONTENT_URI,
+        arrayOf(
+          TvContractCompat.WatchNextPrograms._ID,
+          TvContractCompat.WatchNextPrograms.COLUMN_INTERNAL_PROVIDER_ID
+        ),
+        null,
+        null,
+        null
+      )
+
+      cursor?.use {
+        val idIndex = it.getColumnIndex(TvContractCompat.WatchNextPrograms._ID)
+        val providerIdIndex = it.getColumnIndex(TvContractCompat.WatchNextPrograms.COLUMN_INTERNAL_PROVIDER_ID)
+
+        if (idIndex < 0 || providerIdIndex < 0) return false
+
+        while (it.moveToNext()) {
+          if (it.getString(providerIdIndex) == contentId) {
+            val id = it.getLong(idIndex)
+            val deleteUri = ContentUris.withAppendedId(
+              TvContractCompat.WatchNextPrograms.CONTENT_URI,
+              id
             )
-
-            for (item in items) {
-                val program = buildProgram(item)
-                ops.add(
-                    ContentProviderOperation.newInsert(
-                        TvContractCompat.WatchNextPrograms.CONTENT_URI
-                    ).withValues(program.toContentValues()).build()
-                )
-            }
-
-            context.contentResolver.applyBatch(TvContractCompat.AUTHORITY, ops)
-            Log.d(TAG, "Synced ${items.size} Watch Next entries")
-            true
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to sync Watch Next programs", e)
-            false
+            context.contentResolver.delete(deleteUri, null, null)
+            return true
+          }
         }
+      }
+      false
+    } catch (e: Exception) {
+      Log.e(TAG, "Failed to remove Watch Next item: $contentId", e)
+      false
+    }
+  }
+
+  private fun buildProgram(item: WatchNextItem): WatchNextProgram {
+    val watchNextType = if (item.lastPlaybackPosition > 0) {
+      TvContractCompat.WatchNextPrograms.WATCH_NEXT_TYPE_CONTINUE
+    } else {
+      TvContractCompat.WatchNextPrograms.WATCH_NEXT_TYPE_NEXT
     }
 
-    fun clearAll(): Boolean {
-        return try {
-            context.contentResolver.delete(
-                TvContractCompat.WatchNextPrograms.CONTENT_URI,
-                null,
-                null
-            )
-            true
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to clear Watch Next entries", e)
-            false
-        }
+    val builder = WatchNextProgram.Builder()
+      .setType(item.type)
+      .setWatchNextType(watchNextType)
+      .setTitle(item.title)
+      .setInternalProviderId(item.contentId)
+      .setLastEngagementTimeUtcMillis(item.lastEngagementTime)
+
+    item.description?.let { builder.setDescription(it) }
+
+    item.posterUri?.let { uri ->
+      try {
+        builder.setPosterArtUri(Uri.parse(uri))
+        builder.setPosterArtAspectRatio(TvContractCompat.PreviewPrograms.ASPECT_RATIO_16_9)
+      } catch (e: Exception) {
+        Log.w(TAG, "Failed to parse poster URI: $uri", e)
+      }
     }
 
-    fun removeItem(contentId: String): Boolean {
-        return try {
-            val cursor = context.contentResolver.query(
-                TvContractCompat.WatchNextPrograms.CONTENT_URI,
-                arrayOf(
-                    TvContractCompat.WatchNextPrograms._ID,
-                    TvContractCompat.WatchNextPrograms.COLUMN_INTERNAL_PROVIDER_ID
-                ),
-                null,
-                null,
-                null
-            )
-
-            cursor?.use {
-                val idIndex = it.getColumnIndex(TvContractCompat.WatchNextPrograms._ID)
-                val providerIdIndex = it.getColumnIndex(TvContractCompat.WatchNextPrograms.COLUMN_INTERNAL_PROVIDER_ID)
-
-                if (idIndex < 0 || providerIdIndex < 0) return false
-
-                while (it.moveToNext()) {
-                    if (it.getString(providerIdIndex) == contentId) {
-                        val id = it.getLong(idIndex)
-                        val deleteUri = ContentUris.withAppendedId(
-                            TvContractCompat.WatchNextPrograms.CONTENT_URI,
-                            id
-                        )
-                        context.contentResolver.delete(deleteUri, null, null)
-                        return true
-                    }
-                }
-            }
-            false
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to remove Watch Next item: $contentId", e)
-            false
-        }
+    if (item.duration > 0) {
+      builder.setDurationMillis(item.duration.toInt())
+      if (item.lastPlaybackPosition > 0) {
+        builder.setLastPlaybackPositionMillis(item.lastPlaybackPosition.toInt())
+      }
     }
 
-    private fun buildProgram(item: WatchNextItem): WatchNextProgram {
-        val watchNextType = if (item.lastPlaybackPosition > 0)
-            TvContractCompat.WatchNextPrograms.WATCH_NEXT_TYPE_CONTINUE
-        else
-            TvContractCompat.WatchNextPrograms.WATCH_NEXT_TYPE_NEXT
-
-        val builder = WatchNextProgram.Builder()
-            .setType(item.type)
-            .setWatchNextType(watchNextType)
-            .setTitle(item.title)
-            .setInternalProviderId(item.contentId)
-            .setLastEngagementTimeUtcMillis(item.lastEngagementTime)
-
-        item.description?.let { builder.setDescription(it) }
-
-        item.posterUri?.let { uri ->
-            try {
-                builder.setPosterArtUri(Uri.parse(uri))
-                builder.setPosterArtAspectRatio(TvContractCompat.PreviewPrograms.ASPECT_RATIO_16_9)
-            } catch (e: Exception) {
-                Log.w(TAG, "Failed to parse poster URI: $uri", e)
-            }
-        }
-
-        if (item.duration > 0) {
-            builder.setDurationMillis(item.duration.toInt())
-            if (item.lastPlaybackPosition > 0) {
-                builder.setLastPlaybackPositionMillis(item.lastPlaybackPosition.toInt())
-            }
-        }
-
-        if (item.type == TvContractCompat.WatchNextPrograms.TYPE_TV_EPISODE) {
-            item.episodeTitle?.let { builder.setEpisodeTitle(it) }
-            item.seasonNumber?.let { builder.setSeasonNumber(it) }
-            item.episodeNumber?.let { builder.setEpisodeNumber(it) }
-        }
-
-        val intentUri = Uri.Builder()
-            .scheme("plezy")
-            .authority("play")
-            .appendQueryParameter("content_id", item.contentId)
-            .build()
-        builder.setIntentUri(intentUri)
-
-        return builder.build()
+    if (item.type == TvContractCompat.WatchNextPrograms.TYPE_TV_EPISODE) {
+      item.episodeTitle?.let { builder.setEpisodeTitle(it) }
+      item.seasonNumber?.let { builder.setSeasonNumber(it) }
+      item.episodeNumber?.let { builder.setEpisodeNumber(it) }
     }
+
+    val intentUri = Uri.Builder()
+      .scheme("plezy")
+      .authority("play")
+      .appendQueryParameter("content_id", item.contentId)
+      .build()
+    builder.setIntentUri(intentUri)
+
+    return builder.build()
+  }
 }

android/app/src/test/kotlin/com/edde746/plezy/exoplayer/DvBitstreamSanitizerTest.kt

@@ -0,0 +1,201 @@
+package com.edde746.plezy.exoplayer
+
+import java.nio.ByteBuffer
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class DvBitstreamSanitizerTest {
+
+  // --- HDR10+ SEI stripping (native DV codec path) ---
+
+  @Test
+  fun stripsHdr10PlusPrefixSeiBetweenVclNals() {
+    val vcl1 = annexBNal(1, byteArrayOf(0x01, 0x02))
+    val vcl2 = annexBNal(1, byteArrayOf(0x03, 0x04))
+    val buffer = bufferOf(vcl1, hdr10PlusSei(), vcl2)
+    val originalLimit = buffer.limit()
+
+    DvBitstreamSanitizer.sanitize(buffer, stripHdr10PlusSei = true, stripDvRpu = false)
+
+    assertArrayEquals(concat(vcl1, vcl2), remainingBytes(buffer))
+    assertTrue(buffer.limit() < originalLimit)
+    assertEquals(0, buffer.position())
+  }
+
+  @Test
+  fun stripsSuffixSei() {
+    val vcl = annexBNal(1, byteArrayOf(0x01))
+    val suffixSei = annexBNal(40, hdr10PlusSeiPayload())
+    val buffer = bufferOf(vcl, suffixSei)
+
+    DvBitstreamSanitizer.sanitize(buffer, stripHdr10PlusSei = true, stripDvRpu = false)
+
+    assertArrayEquals(vcl, remainingBytes(buffer))
+  }
+
+  @Test
+  fun handles3ByteStartCodes() {
+    val vcl1 = annexBNal(1, byteArrayOf(0x01, 0x02), startCodeLen = 3)
+    val sei = annexBNal(39, hdr10PlusSeiPayload(), startCodeLen = 3)
+    val vcl2 = annexBNal(1, byteArrayOf(0x03), startCodeLen = 3)
+    val buffer = bufferOf(vcl1, sei, vcl2)
+
+    DvBitstreamSanitizer.sanitize(buffer, stripHdr10PlusSei = true, stripDvRpu = false)
+
+    assertArrayEquals(concat(vcl1, vcl2), remainingBytes(buffer))
+  }
+
+  @Test
+  fun preservesNonHdr10PlusT35Sei() {
+    // Same T.35 layout but wrong country code (0x00 instead of 0xB5).
+    val sei = annexBNal(
+      39,
+      byteArrayOf(0x04, 0x07, 0x00, 0x00, 0x3C, 0x00, 0x01, 0x04, 0x00)
+    )
+    val buffer = bufferOf(annexBNal(1, byteArrayOf(0x01)), sei, annexBNal(1, byteArrayOf(0x02)))
+    val original = remainingBytes(buffer)
+
+    DvBitstreamSanitizer.sanitize(buffer, stripHdr10PlusSei = true, stripDvRpu = false)
+
+    assertArrayEquals(original, remainingBytes(buffer))
+  }
+
+  @Test
+  fun noOpWithoutSeiNals() {
+    val buffer = bufferOf(annexBNal(1, byteArrayOf(0x01, 0x02)), annexBNal(1, byteArrayOf(0x03)))
+    val original = remainingBytes(buffer)
+
+    DvBitstreamSanitizer.sanitize(buffer, stripHdr10PlusSei = true, stripDvRpu = true)
+
+    assertArrayEquals(original, remainingBytes(buffer))
+  }
+
+  @Test
+  fun keepsTruncatedSei() {
+    // Declares payload size 7 but the identifier bytes are cut short.
+    val truncated = annexBNal(39, byteArrayOf(0x04, 0x07, 0xB5.toByte(), 0x00, 0x3C))
+    val buffer = bufferOf(annexBNal(1, byteArrayOf(0x01)), truncated)
+    val original = remainingBytes(buffer)
+
+    DvBitstreamSanitizer.sanitize(buffer, stripHdr10PlusSei = true, stripDvRpu = false)
+
+    assertArrayEquals(original, remainingBytes(buffer))
+  }
+
+  @Test
+  fun keepsHdr10PlusSeiWhenFlagOff() {
+    val buffer = bufferOf(annexBNal(1, byteArrayOf(0x01)), hdr10PlusSei())
+    val original = remainingBytes(buffer)
+
+    DvBitstreamSanitizer.sanitize(buffer, stripHdr10PlusSei = false, stripDvRpu = false)
+
+    assertArrayEquals(original, remainingBytes(buffer))
+  }
+
+  // --- DV RPU/EL stripping (HEVC fallback path) ---
+
+  @Test
+  fun rpuModeStripsRpuAndElButKeepsHdr10PlusSei() {
+    val vcl = annexBNal(1, byteArrayOf(0x01))
+    val rpu = annexBNal(62, byteArrayOf(0x19, 0x08))
+    val el = annexBNal(63, byteArrayOf(0x42))
+    val sei = hdr10PlusSei()
+    val buffer = bufferOf(vcl, rpu, sei, el)
+
+    DvBitstreamSanitizer.sanitize(buffer, stripHdr10PlusSei = false, stripDvRpu = true)
+
+    assertArrayEquals(concat(vcl, sei), remainingBytes(buffer))
+  }
+
+  @Test
+  fun bothFlagsStripBothMetadataKinds() {
+    val vcl1 = annexBNal(19, byteArrayOf(0x00)) // IDR_W_RADL
+    val vcl2 = annexBNal(1, byteArrayOf(0x05))
+    val buffer = bufferOf(vcl1, annexBNal(62, byteArrayOf(0x19)), hdr10PlusSei(), vcl2)
+
+    DvBitstreamSanitizer.sanitize(buffer, stripHdr10PlusSei = true, stripDvRpu = true)
+
+    assertArrayEquals(concat(vcl1, vcl2), remainingBytes(buffer))
+  }
+
+  // --- Buffer handling ---
+
+  @Test
+  fun respectsPositionAndRestoresIt() {
+    val prefix = byteArrayOf(0xAA.toByte(), 0xBB.toByte())
+    val vcl = annexBNal(1, byteArrayOf(0x01))
+    val content = concat(prefix, vcl, hdr10PlusSei())
+    val buffer = ByteBuffer.wrap(content.copyOf())
+    buffer.position(prefix.size)
+
+    DvBitstreamSanitizer.sanitize(buffer, stripHdr10PlusSei = true, stripDvRpu = false)
+
+    assertEquals(prefix.size, buffer.position())
+    assertArrayEquals(vcl, remainingBytes(buffer))
+    // Bytes before the position are untouched.
+    assertEquals(0xAA.toByte(), buffer.get(0))
+    assertEquals(0xBB.toByte(), buffer.get(1))
+  }
+
+  @Test
+  fun worksOnDirectBuffers() {
+    val vcl = annexBNal(1, byteArrayOf(0x01, 0x02))
+    val content = concat(vcl, hdr10PlusSei())
+    val buffer = ByteBuffer.allocateDirect(content.size)
+    buffer.put(content)
+    buffer.flip()
+
+    DvBitstreamSanitizer.sanitize(buffer, stripHdr10PlusSei = true, stripDvRpu = false)
+
+    assertArrayEquals(vcl, remainingBytes(buffer))
+  }
+
+  @Test
+  fun emptyBufferIsNoOp() {
+    val buffer = ByteBuffer.allocate(0)
+
+    DvBitstreamSanitizer.sanitize(buffer, stripHdr10PlusSei = true, stripDvRpu = true)
+
+    assertEquals(0, buffer.position())
+    assertEquals(0, buffer.limit())
+  }
+
+  // --- Helpers ---
+
+  /** Builds an HEVC NAL unit: start code + 2-byte NAL header encoding [nalUnitType] + payload. */
+  private fun annexBNal(nalUnitType: Int, payload: ByteArray, startCodeLen: Int = 4): ByteArray {
+    val startCode = if (startCodeLen == 3) byteArrayOf(0, 0, 1) else byteArrayOf(0, 0, 0, 1)
+    val header = byteArrayOf(((nalUnitType shl 1) and 0x7E).toByte(), 0x01)
+    return concat(startCode, header, payload)
+  }
+
+  /**
+   * SEI payload: type 4 (user_data_registered_itu_t_t35), size 7, then the HDR10+
+   * identifiers — country 0xB5, provider 0x003C, oriented code 0x0001, app id 4, version 0 —
+   * closed by the rbsp_trailing_bits stop byte real SEI NALs always end with (a trailing 0x00
+   * would otherwise be ambiguous against a following 3-byte start code).
+   */
+  private fun hdr10PlusSeiPayload(): ByteArray = byteArrayOf(0x04, 0x07, 0xB5.toByte(), 0x00, 0x3C, 0x00, 0x01, 0x04, 0x00, 0x80.toByte())
+
+  private fun hdr10PlusSei(): ByteArray = annexBNal(39, hdr10PlusSeiPayload())
+
+  private fun concat(vararg parts: ByteArray): ByteArray {
+    val result = ByteArray(parts.sumOf { it.size })
+    var offset = 0
+    for (part in parts) {
+      part.copyInto(result, offset)
+      offset += part.size
+    }
+    return result
+  }
+
+  private fun bufferOf(vararg parts: ByteArray): ByteBuffer = ByteBuffer.wrap(concat(*parts))
+
+  private fun remainingBytes(buffer: ByteBuffer): ByteArray {
+    val copy = ByteArray(buffer.remaining())
+    buffer.duplicate().get(copy)
+    return copy
+  }
+}

android/fastlane/Fastfile

@@ -1,5 +1,10 @@
 require 'dotenv/load'
-Dotenv.load("../../.env")
+require 'shellwords'
+
+PROJECT_ROOT = File.expand_path("../..", __dir__)
+PROJECT_ROOT_ARG = Shellwords.escape(PROJECT_ROOT)
+
+Dotenv.load(File.join(PROJECT_ROOT, ".env"))
 
 default_platform(:android)
 
@@ -7,7 +12,7 @@ platform :android do
   desc "Build and deploy to Google Play Store"
   lane :release do
     # Get version from pubspec.yaml
-    pubspec_path = "#{ENV['PWD']}/../pubspec.yaml"
+    pubspec_path = File.join(PROJECT_ROOT, "pubspec.yaml")
     pubspec_content = File.read(pubspec_path)
     version_match = pubspec_content.match(/version:\s*(.+)\+(\d+)/)
 
@@ -19,11 +24,11 @@ platform :android do
       UI.user_error!("Could not extract version from pubspec.yaml")
     end
 
-    debug_info_dir = "./debug-info/#{version_name}+#{version_code}"
-    git_commit = `git rev-parse --short HEAD`.strip
+    git_commit = `git -C #{PROJECT_ROOT_ARG} rev-parse --short HEAD`.strip
 
     # Build the Flutter app
-    sh("cd #{ENV['PWD']}/.. && flutter build appbundle --dart-define=ENABLE_IN_APP_REVIEW=true --dart-define=ENABLE_SENTRY=true --dart-define=GIT_COMMIT=#{git_commit} --obfuscate --split-debug-info=#{debug_info_dir}/aab")
+    sh("cd #{PROJECT_ROOT_ARG} && flutter build appbundle --dart-define=ENABLE_SENTRY=true --dart-define=GIT_COMMIT=#{git_commit} --dart-define=SENTRY_ENVIRONMENT=play-store --dart-define=SENTRY_DIST=play-store --obfuscate --split-debug-info=debug-info/android-aab --extra-gen-snapshot-options=--save-obfuscation-map=debug-info/android-aab/obfuscation.map.json")
+    sh("cd #{PROJECT_ROOT_ARG} && SENTRY_DIST=play-store ./scripts/upload-symbols.sh android-aab")
 
     upload_to_play_store(
       track: "production",
@@ -33,7 +38,8 @@ platform :android do
     )
 
     # Build universal APK for Amazon Appstore (doesn't accept AABs, excludes x86 via env var)
-    sh("cd #{ENV['PWD']}/.. && AMAZON=1 flutter build apk --release --dart-define=ENABLE_SENTRY=true --dart-define=GIT_COMMIT=#{git_commit} --obfuscate --split-debug-info=#{debug_info_dir}/apk")
+    sh("cd #{PROJECT_ROOT_ARG} && AMAZON=1 flutter build apk --release --dart-define=ENABLE_SENTRY=true --dart-define=GIT_COMMIT=#{git_commit} --dart-define=SENTRY_ENVIRONMENT=amazon --dart-define=SENTRY_DIST=amazon --obfuscate --split-debug-info=debug-info/android-apk --extra-gen-snapshot-options=--save-obfuscation-map=debug-info/android-apk/obfuscation.map.json")
+    sh("cd #{PROJECT_ROOT_ARG} && SENTRY_DIST=amazon ./scripts/upload-symbols.sh android-apk")
 
     upload_to_amazon_appstore(
       apk_paths: [

android/gradle.properties

@@ -1,3 +1,7 @@
 org.gradle.jvmargs=-Xmx8G -XX:MaxMetaspaceSize=4G -XX:ReservedCodeCacheSize=512m -XX:+HeapDumpOnOutOfMemoryError
 android.useAndroidX=true
 android.enableJetifier=true
+# This builtInKotlin flag was added automatically by Flutter migrator
+android.builtInKotlin=false
+# This newDsl flag was added automatically by Flutter migrator
+android.newDsl=false

assets/anilist_mark.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="75 75 363 363"><path fill="#02a9ff" d="M321.92 323.27V136.6c0-10.698-5.887-16.602-16.558-16.602h-36.433c-10.672 0-16.561 5.904-16.561 16.602v88.651c0 2.497 23.996 14.089 24.623 16.541 18.282 71.61 3.972 128.92-13.359 131.6 28.337 1.405 31.455 15.064 10.348 5.731 3.229-38.209 15.828-38.134 52.049-1.406.31.317 7.427 15.282 7.87 15.282h85.545c10.672 0 16.558-5.9 16.558-16.6v-36.524c0-10.698-5.886-16.602-16.558-16.602z"/><path fill="currentColor" d="M170.68 120 74.999 393h74.338l16.192-47.222h80.96L262.315 393h73.968l-95.314-273zm11.776 165.28 23.183-75.629 25.393 75.629z"/></svg>

assets/jellyfin_icon.svg

@@ -0,0 +1,4 @@
+<svg viewBox="0 0 72 72" xmlns="http://www.w3.org/2000/svg" fill="currentColor">
+  <path d="M24.2116 49.1581C22.6599 46.0424 32.8378 27.5879 35.9999 27.5879C39.1666 27.5895 49.3228 46.0764 47.7882 49.1581C46.2536 52.2398 25.7632 52.2738 24.2116 49.1581Z"/>
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M0.481861 64.9951C-4.19479 55.6047 26.4765 0 36 0C45.5328 0 76.153 55.713 71.5274 64.9951C66.9018 74.2773 5.15852 74.3856 0.481861 64.9951ZM12.7358 56.847C15.8005 62.9995 56.2536 62.9314 59.2843 56.847C62.3149 50.761 42.2515 14.2605 36.0093 14.2605C29.767 14.2605 9.67118 50.6944 12.7358 56.847Z"/>
+</svg>

assets/mal_mark.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="25 37 900 900"><path fill="currentColor" d="M360.18,640.05h-93.37v-215.38h-.85l-71.97,95.92-70.16-95.92h-.96v215.38H29.5v-356.23h88.57l75.91,104.66,77.61-104.66h88.58v356.23Z"/><path fill="currentColor" d="M667.97,640.05h-93.37v-112.96h-101.99c.5,36.48,12.42,74.14,35.77,112.96l-75.8,50.14c-11.5-17.25-21.42-35.61-29.76-55.09-8.34-19.48-14.71-39.57-19.11-60.26-4.4-20.69-6.6-41.26-6.6-61.7s2.31-42.21,6.92-62.76c4.61-20.55,11.71-40.12,21.29-58.72,9.58-18.59,21.58-35.1,35.98-49.51,15.83-15.97,32.77-28.19,50.84-36.68,18.06-8.48,36.89-14.21,56.48-17.19,19.59-2.98,42.09-4.47,67.5-4.47h45.78l21.83,80.27h-73.25c-30.38,0-54.35,4.36-71.92,13.08-17.57,8.72-29.85,18.47-36.84,29.24-6.99,10.77-13.65,24.24-19.96,40.4h92.84v-71.76h93.37v264.99Z"/><path fill="currentColor" d="M797.69,559.78h122.54l-21.83,80.28h-194.08v-356.23h93.37v275.96Z"/></svg>

assets/plex_chevron.svg

@@ -0,0 +1,3 @@
+<svg viewBox="636.71 89.58 269.72 269.72" xmlns="http://www.w3.org/2000/svg" fill="currentColor">
+  <path d="M774.47 359.3H677.74L768.67 224.5L677.74 89.58H774.47L865.4 224.5L774.47 359.3Z"/>
+</svg>

assets/readme_icons/browse.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><defs><linearGradient id="g" x1="0" y1="24" x2="24" y2="0" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#ab543a"/><stop offset="1" stop-color="#ff7e57"/></linearGradient></defs><path fill="url(#g)" d="M12 10.9c-.61 0-1.1.49-1.1 1.1s.49 1.1 1.1 1.1c.61 0 1.1-.49 1.1-1.1s-.49-1.1-1.1-1.1zM12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm2.19 12.19L6 18l3.81-8.19L18 6l-3.81 8.19z"/></svg>

assets/readme_icons/customization.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><defs><linearGradient id="g" x1="0" y1="24" x2="24" y2="0" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#ab543a"/><stop offset="1" stop-color="#ff7e57"/></linearGradient></defs><path fill="url(#g)" d="M3 17v2h6v-2H3zM3 5v2h10V5H3zm10 16v-2h8v-2h-8v-2h-2v6h2zM7 9v2H3v2h4v2h2V9H7zm14 4v-2H11v2h10zm-6-4h2V7h4V5h-4V3h-2v6z"/></svg>

assets/readme_icons/downloads.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><defs><linearGradient id="g" x1="0" y1="24" x2="24" y2="0" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#ab543a"/><stop offset="1" stop-color="#ff7e57"/></linearGradient></defs><path fill="url(#g)" d="M19 9h-4V3H9v6H5l7 7 7-7zM5 18v2h14v-2H5z"/></svg>

assets/readme_icons/integrations.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><defs><linearGradient id="g" x1="0" y1="24" x2="24" y2="0" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#ab543a"/><stop offset="1" stop-color="#ff7e57"/></linearGradient></defs><path fill="url(#g)" d="M20.5 11H19V7c0-1.1-.9-2-2-2h-4V3.5C13 2.12 11.88 1 10.5 1S8 2.12 8 3.5V5H4c-1.1 0-1.99.9-1.99 2v3.8H3.5c1.49 0 2.7 1.21 2.7 2.7s-1.21 2.7-2.7 2.7H2V20c0 1.1.9 2 2 2h3.8v-1.5c0-1.49 1.21-2.7 2.7-2.7 1.49 0 2.7 1.21 2.7 2.7V22H17c1.1 0 2-.9 2-2v-4h1.5c1.38 0 2.5-1.12 2.5-2.5S21.88 11 20.5 11z"/></svg>

assets/readme_icons/live-tv.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><defs><linearGradient id="g" x1="0" y1="24" x2="24" y2="0" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#ab543a"/><stop offset="1" stop-color="#ff7e57"/></linearGradient></defs><path fill="url(#g)" d="M21 6h-7.59l3.29-3.29L16 2l-4 4-4-4-.71.71L10.59 6H3c-1.1 0-2 .89-2 2v12c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V8c0-1.11-.9-2-2-2zm0 14H3V8h18v12zM9 10v8l7-4z"/></svg>

assets/readme_icons/playback.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><defs><linearGradient id="g" x1="0" y1="24" x2="24" y2="0" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#ab543a"/><stop offset="1" stop-color="#ff7e57"/></linearGradient></defs><path fill="url(#g)" d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm-2 14.5v-9l6 4.5-6 4.5z"/></svg>

assets/readme_icons/watch-together.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><defs><linearGradient id="g" x1="0" y1="24" x2="24" y2="0" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#ab543a"/><stop offset="1" stop-color="#ff7e57"/></linearGradient></defs><path fill="url(#g)" d="M12 12.75c1.63 0 3.07.39 4.24.9 1.08.48 1.76 1.56 1.76 2.73V18H6v-1.61c0-1.18.68-2.26 1.76-2.73 1.17-.52 2.61-.91 4.24-.91zM4 13c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm1.13 1.1c-.37-.06-.74-.1-1.13-.1-.99 0-1.93.21-2.78.58C.48 14.9 0 15.62 0 16.43V18h4.5v-1.61c0-.83.23-1.61.63-2.29zM20 13c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm4 3.43c0-.81-.48-1.53-1.22-1.85-.85-.37-1.79-.58-2.78-.58-.39 0-.76.04-1.13.1.4.68.63 1.46.63 2.29V18H24v-1.57zM12 6c1.66 0 3 1.34 3 3s-1.34 3-3 3-3-1.34-3-3 1.34-3 3-3z"/></svg>

assets/screenshots/README.md

@@ -1,15 +0,0 @@
-## iOS
-
-| Home | Library | Media Card | Season |
-|------|---------|------------|--------|
-| ![iOS Home - Content discovery and recommendations](ios-home.png) | ![iOS Library - Media collection view](ios-library.png) | ![iOS Media Card](ios-media-card.png) | ![iOS Season View](ios-season.png) |
-
-## macOS
-
-![macOS Home - Content discovery and recommendations](macos-home.png)
-
-![macOS Library - Media collection view](macos-library.png)
-
-![macOS Media Card](macos-media-card.png)
-
-![macOS Season View](macos-season.png)

assets/simkl_mark.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="205 196 1124 1124"><path fill="currentColor" d="M205.832 970.284c0 35.322 1.82 65.9 5.433 91.774 6.709 53.176 28.198 94.359 64.507 123.51 33.579 27.302 88.907 45.656 165.984 55.065 63.178 7.983 165.983 11.993 308.45 11.993 234.287 0 377.455-7.982 429.428-23.947 52.859-15.964 90.936-45.77 114.232-89.46 23.295-44.153 34.944-113.446 34.944-207.843 0-84.525-11.907-145.798-35.645-183.858-15.702-25.836-36.64-45.772-62.885-59.885-26.244-14.074-61.52-24.64-105.9-31.697-43.937-7.018-145.452-12.917-304.58-17.622-175.752-5.63-274.576-11.49-296.545-17.584-26.024-7.519-39-28.188-39-62.006 0-35.205 12.312-57.03 36.972-65.514 21.97-7.018 92.115-10.566 210.476-10.566 119.65 0 194.955 1.427 225.92 4.203 34.942 3.317 55.584 18.04 61.85 44.26 2.25 8.908 3.835 24.833 4.72 47.777h271c.368-22.442.589-38.83.589-49.127 0-95.475-21.527-161.676-64.58-198.657-31.847-26.683-83.858-45.386-156.032-56.183-54.7-7.944-148.4-11.915-281.099-11.915-204.024 0-333.149 4.704-387.407 14.075-60.082 10.797-104.942 33.047-134.505 66.748-39.477 44.538-59.198 121.158-59.198 229.823 0 51.555 4.017 93.278 12.09 125.129 14.338 57.649 44.822 98.407 91.451 122.276 36.309 18.741 98.861 29.538 187.622 32.353 34.058.926 108.444 4.204 223.228 9.833 111.172 5.63 184.23 8.445 219.212 8.445 50.645.926 82.678 8.213 96.168 21.787 9.843 9.832 14.783 26.915 14.783 51.286 0 35.63-7.852 58.612-23.518 68.908-11.206 7.018-34.502 11.953-69.887 14.73-18.837.963-87.84 1.658-207.011 2.12-86.954-.462-138.265-.924-153.93-1.387-31.369-.926-53.338-2.584-65.871-4.936-12.532-2.314-23.738-6.44-33.58-12.996-18.835-13.573-28.014-44.036-27.571-91.389H205.832v50.824-.347z"/></svg>

assets/trakt_circlemark.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48"><circle cx="24" cy="24" r="24" fill="transparent"/><path fill="currentColor" d="M45.99 14.39 30.17 30.22l-1.46-1.46 16.31-16.32c-.15-.3-.32-.58-.5-.87l-17.2 17.2 2.16 2.16-1.46 1.46-3.62-3.62L43.34 9.82c-.18-.27-.38-.53-.6-.78L23.01 28.78l4.31 4.31-1.46 1.46-14.4-14.4 1.46-1.46 8.62 8.62L41.37 7.46c-.12-.14-.26-.28-.4-.42C36.62 2.69 30.62 0 24 0S11.38 2.69 7.03 7.03C2.69 11.37 0 17.37 0 24c0 13.25 10.75 24 24 24 6.62 0 12.62-2.69 16.97-7.03C45.31 36.64 48 30.64 48 24c0-3.42-.71-6.67-2.01-9.61ZM21.54 25.9l-7.93-7.92 1.46-1.46L23 24.44l-1.46 1.46Zm2.16-2.16-7.93-7.92 1.46-1.46 7.93 7.92-1.46 1.46Zm.3 19.65c-10.7 0-19.39-8.7-19.39-19.39S13.3 4.61 24 4.61c2.91 0 5.72.63 8.33 1.88l-.89 1.88c-2.33-1.11-4.84-1.68-7.43-1.68-9.55 0-17.33 7.77-17.33 17.32s7.78 17.33 17.33 17.33c6.82 0 13.03-4.03 15.82-10.25l1.89.84C38.6 38.9 31.65 43.41 24.01 43.41Z"/></svg>

build.yaml

@@ -0,0 +1,17 @@
+targets:
+  $default:
+    builders:
+      json_serializable:
+        options:
+          create_to_json: true
+          explicit_to_json: true
+          field_rename: none
+          include_if_null: true
+          checked: false
+      freezed:
+        options:
+          copy_with: true
+          equal: true
+          to_string: true
+      slang_build_runner:
+        enabled: false

ios/Podfile.lock

@@ -1,222 +1,34 @@
 PODS:
-  - background_downloader (0.0.1):
-    - Flutter
-  - connectivity_plus (0.0.1):
-    - Flutter
-  - device_info_plus (0.0.1):
-    - Flutter
-  - file_picker (0.0.1):
+  - cupertino_http (0.0.1):
     - Flutter
+    - FlutterMacOS
   - Flutter (1.0.0)
-  - GoogleDataTransport (10.1.0):
-    - nanopb (~> 3.30910.0)
-    - PromisesObjC (~> 2.4)
-  - GoogleMLKit/BarcodeScanning (7.0.0):
-    - GoogleMLKit/MLKitCore
-    - MLKitBarcodeScanning (~> 6.0.0)
-  - GoogleMLKit/MLKitCore (7.0.0):
-    - MLKitCommon (~> 12.0.0)
-  - GoogleToolboxForMac/Defines (4.2.1)
-  - GoogleToolboxForMac/Logger (4.2.1):
-    - GoogleToolboxForMac/Defines (= 4.2.1)
-  - "GoogleToolboxForMac/NSData+zlib (4.2.1)":
-    - GoogleToolboxForMac/Defines (= 4.2.1)
-  - GoogleUtilities/Environment (8.1.0):
-    - GoogleUtilities/Privacy
-  - GoogleUtilities/Logger (8.1.0):
-    - GoogleUtilities/Environment
-    - GoogleUtilities/Privacy
-  - GoogleUtilities/Privacy (8.1.0)
-  - GoogleUtilities/UserDefaults (8.1.0):
-    - GoogleUtilities/Logger
-    - GoogleUtilities/Privacy
-  - GTMSessionFetcher/Core (3.5.0)
-  - in_app_review (2.0.0):
+  - os_media_controls (0.2.4):
     - Flutter
-  - MLImage (1.0.0-beta6)
-  - MLKitBarcodeScanning (6.0.0):
-    - MLKitCommon (~> 12.0)
-    - MLKitVision (~> 8.0)
-  - MLKitCommon (12.0.0):
-    - GoogleDataTransport (~> 10.0)
-    - GoogleToolboxForMac/Logger (< 5.0, >= 4.2.1)
-    - "GoogleToolboxForMac/NSData+zlib (< 5.0, >= 4.2.1)"
-    - GoogleUtilities/Logger (~> 8.0)
-    - GoogleUtilities/UserDefaults (~> 8.0)
-    - GTMSessionFetcher/Core (< 4.0, >= 3.3.2)
-  - MLKitVision (8.0.0):
-    - GoogleToolboxForMac/Logger (< 5.0, >= 4.2.1)
-    - "GoogleToolboxForMac/NSData+zlib (< 5.0, >= 4.2.1)"
-    - GTMSessionFetcher/Core (< 4.0, >= 3.3.2)
-    - MLImage (= 1.0.0-beta6)
-    - MLKitCommon (~> 12.0)
-  - mobile_scanner (6.0.2):
-    - Flutter
-    - GoogleMLKit/BarcodeScanning (~> 7.0.0)
-  - nanopb (3.30910.0):
-    - nanopb/decode (= 3.30910.0)
-    - nanopb/encode (= 3.30910.0)
-  - nanopb/decode (3.30910.0)
-  - nanopb/encode (3.30910.0)
-  - os_media_controls (0.0.1):
-    - Flutter
-  - package_info_plus (0.4.5):
-    - Flutter
-  - path_provider_foundation (0.0.1):
-    - Flutter
-    - FlutterMacOS
-  - PromisesObjC (2.4.0)
-  - Sentry/HybridSDK (8.46.0)
-  - sentry_flutter (8.14.2):
-    - Flutter
-    - FlutterMacOS
-    - Sentry/HybridSDK (= 8.46.0)
-  - shared_preferences_foundation (0.0.1):
-    - Flutter
-    - FlutterMacOS
-  - sqflite_darwin (0.0.4):
-    - Flutter
-    - FlutterMacOS
-  - sqlite3 (3.51.1):
-    - sqlite3/common (= 3.51.1)
-  - sqlite3/common (3.51.1)
-  - sqlite3/dbstatvtab (3.51.1):
-    - sqlite3/common
-  - sqlite3/fts5 (3.51.1):
-    - sqlite3/common
-  - sqlite3/math (3.51.1):
-    - sqlite3/common
-  - sqlite3/perf-threadsafe (3.51.1):
-    - sqlite3/common
-  - sqlite3/rtree (3.51.1):
-    - sqlite3/common
-  - sqlite3/session (3.51.1):
-    - sqlite3/common
-  - sqlite3_flutter_libs (0.0.1):
-    - Flutter
-    - FlutterMacOS
-    - sqlite3 (~> 3.51.1)
-    - sqlite3/dbstatvtab
-    - sqlite3/fts5
-    - sqlite3/math
-    - sqlite3/perf-threadsafe
-    - sqlite3/rtree
-    - sqlite3/session
   - universal_gamepad (0.1.0):
     - Flutter
-  - url_launcher_ios (0.0.1):
-    - Flutter
-  - wakelock_plus (0.0.1):
-    - Flutter
-  - workmanager_apple (0.0.1):
-    - Flutter
 
 DEPENDENCIES:
-  - background_downloader (from `.symlinks/plugins/background_downloader/ios`)
-  - connectivity_plus (from `.symlinks/plugins/connectivity_plus/ios`)
-  - device_info_plus (from `.symlinks/plugins/device_info_plus/ios`)
-  - file_picker (from `.symlinks/plugins/file_picker/ios`)
+  - cupertino_http (from `.symlinks/plugins/cupertino_http/darwin`)
   - Flutter (from `Flutter`)
-  - in_app_review (from `.symlinks/plugins/in_app_review/ios`)
-  - mobile_scanner (from `.symlinks/plugins/mobile_scanner/ios`)
   - os_media_controls (from `.symlinks/plugins/os_media_controls/ios`)
-  - package_info_plus (from `.symlinks/plugins/package_info_plus/ios`)
-  - path_provider_foundation (from `.symlinks/plugins/path_provider_foundation/darwin`)
-  - sentry_flutter (from `.symlinks/plugins/sentry_flutter/ios`)
-  - shared_preferences_foundation (from `.symlinks/plugins/shared_preferences_foundation/darwin`)
-  - sqflite_darwin (from `.symlinks/plugins/sqflite_darwin/darwin`)
-  - sqlite3_flutter_libs (from `.symlinks/plugins/sqlite3_flutter_libs/darwin`)
   - universal_gamepad (from `.symlinks/plugins/universal_gamepad/ios`)
-  - url_launcher_ios (from `.symlinks/plugins/url_launcher_ios/ios`)
-  - wakelock_plus (from `.symlinks/plugins/wakelock_plus/ios`)
-  - workmanager_apple (from `.symlinks/plugins/workmanager_apple/ios`)
-
-SPEC REPOS:
-  trunk:
-    - GoogleDataTransport
-    - GoogleMLKit
-    - GoogleToolboxForMac
-    - GoogleUtilities
-    - GTMSessionFetcher
-    - MLImage
-    - MLKitBarcodeScanning
-    - MLKitCommon
-    - MLKitVision
-    - nanopb
-    - PromisesObjC
-    - Sentry
-    - sqlite3
 
 EXTERNAL SOURCES:
-  background_downloader:
-    :path: ".symlinks/plugins/background_downloader/ios"
-  connectivity_plus:
-    :path: ".symlinks/plugins/connectivity_plus/ios"
-  device_info_plus:
-    :path: ".symlinks/plugins/device_info_plus/ios"
-  file_picker:
-    :path: ".symlinks/plugins/file_picker/ios"
+  cupertino_http:
+    :path: ".symlinks/plugins/cupertino_http/darwin"
   Flutter:
     :path: Flutter
-  in_app_review:
-    :path: ".symlinks/plugins/in_app_review/ios"
-  mobile_scanner:
-    :path: ".symlinks/plugins/mobile_scanner/ios"
   os_media_controls:
     :path: ".symlinks/plugins/os_media_controls/ios"
-  package_info_plus:
-    :path: ".symlinks/plugins/package_info_plus/ios"
-  path_provider_foundation:
-    :path: ".symlinks/plugins/path_provider_foundation/darwin"
-  sentry_flutter:
-    :path: ".symlinks/plugins/sentry_flutter/ios"
-  shared_preferences_foundation:
-    :path: ".symlinks/plugins/shared_preferences_foundation/darwin"
-  sqflite_darwin:
-    :path: ".symlinks/plugins/sqflite_darwin/darwin"
-  sqlite3_flutter_libs:
-    :path: ".symlinks/plugins/sqlite3_flutter_libs/darwin"
   universal_gamepad:
     :path: ".symlinks/plugins/universal_gamepad/ios"
-  url_launcher_ios:
-    :path: ".symlinks/plugins/url_launcher_ios/ios"
-  wakelock_plus:
-    :path: ".symlinks/plugins/wakelock_plus/ios"
-  workmanager_apple:
-    :path: ".symlinks/plugins/workmanager_apple/ios"
 
 SPEC CHECKSUMS:
-  background_downloader: 50e91d979067b82081aba359d7d916b3ba5fadad
-  connectivity_plus: cb623214f4e1f6ef8fe7403d580fdad517d2f7dd
-  device_info_plus: 21fcca2080fbcd348be798aa36c3e5ed849eefbe
-  file_picker: 8fc6fe5e42585a217d44d22f79ec046cb8d81140
+  cupertino_http: 94ac07f5ff090b8effa6c5e2c47871d48ab7c86c
   Flutter: cabc95a1d2626b1b06e7179b784ebcf0c0cde467
-  GoogleDataTransport: aae35b7ea0c09004c3797d53c8c41f66f219d6a7
-  GoogleMLKit: eff9e23ec1d90ea4157a1ee2e32a4f610c5b3318
-  GoogleToolboxForMac: d1a2cbf009c453f4d6ded37c105e2f67a32206d8
-  GoogleUtilities: 00c88b9a86066ef77f0da2fab05f65d7768ed8e1
-  GTMSessionFetcher: 5aea5ba6bd522a239e236100971f10cb71b96ab6
-  in_app_review: 7dd1ea365263f834b8464673f9df72c80c17c937
-  MLImage: 0ad1c5f50edd027672d8b26b0fee78a8b4a0fc56
-  MLKitBarcodeScanning: 0a3064da0a7f49ac24ceb3cb46a5bc67496facd2
-  MLKitCommon: 07c2c33ae5640e5380beaaa6e4b9c249a205542d
-  MLKitVision: 45e79d68845a2de77e2dd4d7f07947f0ed157b0e
-  mobile_scanner: af8f71879eaba2bbcb4d86c6a462c3c0e7f23036
-  nanopb: fad817b59e0457d11a5dfbde799381cd727c1275
-  os_media_controls: 86dceab6245a5325af90fc0fdebe243c42d789b4
-  package_info_plus: af8e2ca6888548050f16fa2f1938db7b5a5df499
-  path_provider_foundation: bb55f6dbba17d0dccd6737fe6f7f34fbd0376880
-  PromisesObjC: f5707f49cb48b9636751c5b2e7d227e43fba9f47
-  Sentry: da60d980b197a46db0b35ea12cb8f39af48d8854
-  sentry_flutter: 27892878729f42701297c628eb90e7c6529f3684
-  shared_preferences_foundation: 7036424c3d8ec98dfe75ff1667cb0cd531ec82bb
-  sqflite_darwin: 20b2a3a3b70e43edae938624ce550a3cbf66a3d0
-  sqlite3: 8d708bc63e9f4ce48f0ad9d6269e478c5ced1d9b
-  sqlite3_flutter_libs: d13b8b3003f18f596e542bcb9482d105577eff41
-  universal_gamepad: e10172778a8a399cce234494968f38724974919e
-  url_launcher_ios: 7a95fa5b60cc718a708b8f2966718e93db0cef1b
-  wakelock_plus: e29112ab3ef0b318e58cfa5c32326458be66b556
-  workmanager_apple: 904529ae31e97fc5be632cf628507652294a0778
+  os_media_controls: 048eb9a75974191b2496d85575b6edcefc572d4e
+  universal_gamepad: 838bbb70d37d8c7c719038aa397214f2c4c4f866
 
 PODFILE CHECKSUM: 16bb7f67e16d8aaa2bfb97666803fbfb291b6559
 

ios/Runner.xcodeproj/project.pbxproj

@@ -10,18 +10,20 @@
 		1498D2341E8E89220040F4C2 /* GeneratedPluginRegistrant.m in Sources */ = {isa = PBXBuildFile; fileRef = 1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */; };
 		331C808B294A63AB00263BE5 /* RunnerTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 331C807B294A618700263BE5 /* RunnerTests.swift */; };
 		3B3967161E833CAA004F5970 /* AppFrameworkInfo.plist in Resources */ = {isa = PBXBuildFile; fileRef = 3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */; };
-		50DEEA8E23D1B433DE5341D6 /* Pods_Runner.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 2C12D873DE8572579684A82C /* Pods_Runner.framework */; };
+		69E1B4BB161DC9D84D1DFC62 /* Pods_Runner.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = BB346A1D0705AB171F80B11B /* Pods_Runner.framework */; };
 		6A48DFB02EA70C7100C1F7CD /* plezy.icon in Resources */ = {isa = PBXBuildFile; fileRef = 6A48DFAF2EA70C7100C1F7CD /* plezy.icon */; };
 		6A8A46212EDB320D0057B88C /* MPVKit in Frameworks */ = {isa = PBXBuildFile; productRef = 6A8A46202EDB320D0057B88C /* MPVKit */; };
 		6A8A46252EDB370C0057B88C /* MpvPlayerPlugin.swift in Sources */ = {isa = PBXBuildFile; fileRef = 6A8A46232EDB370C0057B88C /* MpvPlayerPlugin.swift */; };
 		6A8A46262EDB370C0057B88C /* MpvPlayerCore.swift in Sources */ = {isa = PBXBuildFile; fileRef = 6A8A46222EDB370C0057B88C /* MpvPlayerCore.swift */; };
-		B1D51A6A2F00110000000001 /* MpvPlayerCoreBase.swift in Sources */ = {isa = PBXBuildFile; fileRef = B1D51A6A2F00110000000002 /* MpvPlayerCoreBase.swift */; };
-		B1D51A6A2F00110000000005 /* MpvPlayerPluginShared.swift in Sources */ = {isa = PBXBuildFile; fileRef = B1D51A6A2F00110000000006 /* MpvPlayerPluginShared.swift */; };
-		92F969587D0E464D999910F5 /* MpvPipController.swift in Sources */ = {isa = PBXBuildFile; fileRef = 92F969587D0E464D999910F4 /* MpvPipController.swift */; };
 		74858FAF1ED2DC5600515810 /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 74858FAE1ED2DC5600515810 /* AppDelegate.swift */; };
+		748A259343D7FF8DFD2C3910 /* Pods_RunnerTests.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 75D2EEFFFFE26C0F3CD48133 /* Pods_RunnerTests.framework */; };
+		92F969587D0E464D999910F5 /* MpvPipController.swift in Sources */ = {isa = PBXBuildFile; fileRef = 92F969587D0E464D999910F4 /* MpvPipController.swift */; };
 		97C146FC1CF9000F007C117D /* Main.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FA1CF9000F007C117D /* Main.storyboard */; };
 		97C147011CF9000F007C117D /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */; };
-		F37BB572E0F0606E20596E43 /* Pods_RunnerTests.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 3469ED9D4F3E58F8C3AEB7DC /* Pods_RunnerTests.framework */; };
+		B1D51A6A2F00110000000001 /* MpvPlayerCoreBase.swift in Sources */ = {isa = PBXBuildFile; fileRef = B1D51A6A2F00110000000002 /* MpvPlayerCoreBase.swift */; };
+		B1D51A6A2F00110000000005 /* MpvPlayerPluginShared.swift in Sources */ = {isa = PBXBuildFile; fileRef = B1D51A6A2F00110000000006 /* MpvPlayerPluginShared.swift */; };
+		B1D51A6A2F00110000000008 /* ExternalDisplayManager.swift in Sources */ = {isa = PBXBuildFile; fileRef = B1D51A6A2F00110000000007 /* ExternalDisplayManager.swift */; };
+		78A318202AECB46A00862997 /* FlutterGeneratedPluginSwiftPackage in Frameworks */ = {isa = PBXBuildFile; productRef = 78A3181F2AECB46A00862997 /* FlutterGeneratedPluginSwiftPackage */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXContainerItemProxy section */
@@ -50,32 +52,34 @@
 /* Begin PBXFileReference section */
 		1498D2321E8E86230040F4C2 /* GeneratedPluginRegistrant.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = GeneratedPluginRegistrant.h; sourceTree = "<group>"; };
 		1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = GeneratedPluginRegistrant.m; sourceTree = "<group>"; };
-		1E1EC7646F3085BF9127AB2A /* Pods-Runner.profile.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.profile.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.profile.xcconfig"; sourceTree = "<group>"; };
-		2C12D873DE8572579684A82C /* Pods_Runner.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Pods_Runner.framework; sourceTree = BUILT_PRODUCTS_DIR; };
+		28ABDA890783B15438AA8137 /* Pods-RunnerTests.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-RunnerTests.debug.xcconfig"; path = "Target Support Files/Pods-RunnerTests/Pods-RunnerTests.debug.xcconfig"; sourceTree = "<group>"; };
 		331C807B294A618700263BE5 /* RunnerTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RunnerTests.swift; sourceTree = "<group>"; };
 		331C8081294A63A400263BE5 /* RunnerTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = RunnerTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
-		3469ED9D4F3E58F8C3AEB7DC /* Pods_RunnerTests.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Pods_RunnerTests.framework; sourceTree = BUILT_PRODUCTS_DIR; };
+		3A9EF9720208222F20B1495D /* Pods-RunnerTests.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-RunnerTests.release.xcconfig"; path = "Target Support Files/Pods-RunnerTests/Pods-RunnerTests.release.xcconfig"; sourceTree = "<group>"; };
 		3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; name = AppFrameworkInfo.plist; path = Flutter/AppFrameworkInfo.plist; sourceTree = "<group>"; };
-		5B81FA7048BFA976F49D555E /* Pods-RunnerTests.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-RunnerTests.debug.xcconfig"; path = "Target Support Files/Pods-RunnerTests/Pods-RunnerTests.debug.xcconfig"; sourceTree = "<group>"; };
 		6A48DFAF2EA70C7100C1F7CD /* plezy.icon */ = {isa = PBXFileReference; lastKnownFileType = folder.iconcomposer.icon; path = plezy.icon; sourceTree = "<group>"; };
 		6A8A46222EDB370C0057B88C /* MpvPlayerCore.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MpvPlayerCore.swift; sourceTree = "<group>"; };
 		6A8A46232EDB370C0057B88C /* MpvPlayerPlugin.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MpvPlayerPlugin.swift; sourceTree = "<group>"; };
-		B1D51A6A2F00110000000002 /* MpvPlayerCoreBase.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = MpvPlayerCoreBase.swift; path = ../shared/apple/MpvPlayer/MpvPlayerCoreBase.swift; sourceTree = SOURCE_ROOT; };
-		B1D51A6A2F00110000000006 /* MpvPlayerPluginShared.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = MpvPlayerPluginShared.swift; path = ../shared/apple/MpvPlayer/MpvPlayerPluginShared.swift; sourceTree = SOURCE_ROOT; };
-		92F969587D0E464D999910F4 /* MpvPipController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MpvPipController.swift; sourceTree = "<group>"; };
 		74858FAD1ED2DC5600515810 /* Runner-Bridging-Header.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "Runner-Bridging-Header.h"; sourceTree = "<group>"; };
 		74858FAE1ED2DC5600515810 /* AppDelegate.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = AppDelegate.swift; sourceTree = "<group>"; };
+		75D2EEFFFFE26C0F3CD48133 /* Pods_RunnerTests.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Pods_RunnerTests.framework; sourceTree = BUILT_PRODUCTS_DIR; };
+		792502911151E64A2B752567 /* Pods-RunnerTests.profile.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-RunnerTests.profile.xcconfig"; path = "Target Support Files/Pods-RunnerTests/Pods-RunnerTests.profile.xcconfig"; sourceTree = "<group>"; };
 		7AFA3C8E1D35360C0083082E /* Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = Release.xcconfig; path = Flutter/Release.xcconfig; sourceTree = "<group>"; };
-		83B9EB35C25EEF40090F6A88 /* Pods-Runner.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.release.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.release.xcconfig"; sourceTree = "<group>"; };
-		87ADF6219C65A13967DFF03C /* Pods-RunnerTests.profile.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-RunnerTests.profile.xcconfig"; path = "Target Support Files/Pods-RunnerTests/Pods-RunnerTests.profile.xcconfig"; sourceTree = "<group>"; };
+		7F4B79C5218D46EDB4E433B0 /* Pods-Runner.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.debug.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.debug.xcconfig"; sourceTree = "<group>"; };
+		92F969587D0E464D999910F4 /* MpvPipController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MpvPipController.swift; sourceTree = "<group>"; };
 		9740EEB21CF90195004384FC /* Debug.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; name = Debug.xcconfig; path = Flutter/Debug.xcconfig; sourceTree = "<group>"; };
 		9740EEB31CF90195004384FC /* Generated.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; name = Generated.xcconfig; path = Flutter/Generated.xcconfig; sourceTree = "<group>"; };
 		97C146EE1CF9000F007C117D /* Runner.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = Runner.app; sourceTree = BUILT_PRODUCTS_DIR; };
 		97C146FB1CF9000F007C117D /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/Main.storyboard; sourceTree = "<group>"; };
 		97C147001CF9000F007C117D /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/LaunchScreen.storyboard; sourceTree = "<group>"; };
 		97C147021CF9000F007C117D /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
-		A8738BEC00467F05948734DD /* Pods-Runner.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.debug.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.debug.xcconfig"; sourceTree = "<group>"; };
-		D239CED757CED630C2B0A161 /* Pods-RunnerTests.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-RunnerTests.release.xcconfig"; path = "Target Support Files/Pods-RunnerTests/Pods-RunnerTests.release.xcconfig"; sourceTree = "<group>"; };
+		B1D51A6A2F00110000000002 /* MpvPlayerCoreBase.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = MpvPlayerCoreBase.swift; path = ../shared/apple/MpvPlayer/MpvPlayerCoreBase.swift; sourceTree = SOURCE_ROOT; };
+		B1D51A6A2F00110000000006 /* MpvPlayerPluginShared.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = MpvPlayerPluginShared.swift; path = ../shared/apple/MpvPlayer/MpvPlayerPluginShared.swift; sourceTree = SOURCE_ROOT; };
+		B1D51A6A2F00110000000007 /* ExternalDisplayManager.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ExternalDisplayManager.swift; sourceTree = "<group>"; };
+		BB346A1D0705AB171F80B11B /* Pods_Runner.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Pods_Runner.framework; sourceTree = BUILT_PRODUCTS_DIR; };
+		DE48FF2E074644167608B23D /* Pods-Runner.profile.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.profile.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.profile.xcconfig"; sourceTree = "<group>"; };
+		F3553CDE70191F0FC81A782E /* Pods-Runner.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.release.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.release.xcconfig"; sourceTree = "<group>"; };
+		78E0A7A72DC9AD7400C4905E /* FlutterGeneratedPluginSwiftPackage */ = {isa = PBXFileReference; lastKnownFileType = wrapper; name = FlutterGeneratedPluginSwiftPackage; path = Flutter/ephemeral/Packages/FlutterGeneratedPluginSwiftPackage; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
 /* Begin PBXFrameworksBuildPhase section */
@@ -83,7 +87,7 @@
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				F37BB572E0F0606E20596E43 /* Pods_RunnerTests.framework in Frameworks */,
+				748A259343D7FF8DFD2C3910 /* Pods_RunnerTests.framework in Frameworks */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -91,8 +95,9 @@
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				50DEEA8E23D1B433DE5341D6 /* Pods_Runner.framework in Frameworks */,
+				78A318202AECB46A00862997 /* FlutterGeneratedPluginSwiftPackage in Frameworks */,
 				6A8A46212EDB320D0057B88C /* MPVKit in Frameworks */,
+				69E1B4BB161DC9D84D1DFC62 /* Pods_Runner.framework in Frameworks */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -107,11 +112,11 @@
 			path = RunnerTests;
 			sourceTree = "<group>";
 		};
-		67716449E04A72AA71A90156 /* Frameworks */ = {
+		3DBA2EB0C0219E797C60DE48 /* Frameworks */ = {
 			isa = PBXGroup;
 			children = (
-				2C12D873DE8572579684A82C /* Pods_Runner.framework */,
-				3469ED9D4F3E58F8C3AEB7DC /* Pods_RunnerTests.framework */,
+				BB346A1D0705AB171F80B11B /* Pods_Runner.framework */,
+				75D2EEFFFFE26C0F3CD48133 /* Pods_RunnerTests.framework */,
 			);
 			name = Frameworks;
 			sourceTree = "<group>";
@@ -121,6 +126,7 @@
 			children = (
 				B1D51A6A2F00110000000002 /* MpvPlayerCoreBase.swift */,
 				B1D51A6A2F00110000000006 /* MpvPlayerPluginShared.swift */,
+				B1D51A6A2F00110000000007 /* ExternalDisplayManager.swift */,
 				6A8A46222EDB370C0057B88C /* MpvPlayerCore.swift */,
 				6A8A46232EDB370C0057B88C /* MpvPlayerPlugin.swift */,
 				92F969587D0E464D999910F4 /* MpvPipController.swift */,
@@ -131,12 +137,12 @@
 		875C8AEFBBA3759A1849D674 /* Pods */ = {
 			isa = PBXGroup;
 			children = (
-				A8738BEC00467F05948734DD /* Pods-Runner.debug.xcconfig */,
-				83B9EB35C25EEF40090F6A88 /* Pods-Runner.release.xcconfig */,
-				1E1EC7646F3085BF9127AB2A /* Pods-Runner.profile.xcconfig */,
-				5B81FA7048BFA976F49D555E /* Pods-RunnerTests.debug.xcconfig */,
-				D239CED757CED630C2B0A161 /* Pods-RunnerTests.release.xcconfig */,
-				87ADF6219C65A13967DFF03C /* Pods-RunnerTests.profile.xcconfig */,
+				7F4B79C5218D46EDB4E433B0 /* Pods-Runner.debug.xcconfig */,
+				F3553CDE70191F0FC81A782E /* Pods-Runner.release.xcconfig */,
+				DE48FF2E074644167608B23D /* Pods-Runner.profile.xcconfig */,
+				28ABDA890783B15438AA8137 /* Pods-RunnerTests.debug.xcconfig */,
+				3A9EF9720208222F20B1495D /* Pods-RunnerTests.release.xcconfig */,
+				792502911151E64A2B752567 /* Pods-RunnerTests.profile.xcconfig */,
 			);
 			path = Pods;
 			sourceTree = "<group>";
@@ -144,6 +150,7 @@
 		9740EEB11CF90186004384FC /* Flutter */ = {
 			isa = PBXGroup;
 			children = (
+				78E0A7A72DC9AD7400C4905E /* FlutterGeneratedPluginSwiftPackage */,
 				3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */,
 				9740EEB21CF90195004384FC /* Debug.xcconfig */,
 				7AFA3C8E1D35360C0083082E /* Release.xcconfig */,
@@ -160,8 +167,8 @@
 				97C146EF1CF9000F007C117D /* Products */,
 				331C8082294A63A400263BE5 /* RunnerTests */,
 				875C8AEFBBA3759A1849D674 /* Pods */,
-				67716449E04A72AA71A90156 /* Frameworks */,
 				6A48DFAF2EA70C7100C1F7CD /* plezy.icon */,
+				3DBA2EB0C0219E797C60DE48 /* Frameworks */,
 			);
 			sourceTree = "<group>";
 		};
@@ -196,7 +203,7 @@
 			isa = PBXNativeTarget;
 			buildConfigurationList = 331C8087294A63A400263BE5 /* Build configuration list for PBXNativeTarget "RunnerTests" */;
 			buildPhases = (
-				684A4A968F313A7FDAEBF3B8 /* [CP] Check Pods Manifest.lock */,
+				87A3350E66D519725E5CD790 /* [CP] Check Pods Manifest.lock */,
 				331C807D294A63A400263BE5 /* Sources */,
 				331C807F294A63A400263BE5 /* Resources */,
 				582EBCC1C90BEBEC365D972D /* Frameworks */,
@@ -212,18 +219,20 @@
 			productType = "com.apple.product-type.bundle.unit-test";
 		};
 		97C146ED1CF9000F007C117D /* Runner */ = {
+			packageProductDependencies = (
+				78A3181F2AECB46A00862997 /* FlutterGeneratedPluginSwiftPackage */,
+			);
 			isa = PBXNativeTarget;
 			buildConfigurationList = 97C147051CF9000F007C117D /* Build configuration list for PBXNativeTarget "Runner" */;
 			buildPhases = (
-				01D58DD9E289D97FD8DBE66E /* [CP] Check Pods Manifest.lock */,
+				6838C6976E568CE05DBDE228 /* [CP] Check Pods Manifest.lock */,
 				9740EEB61CF901F6004384FC /* Run Script */,
 				97C146EA1CF9000F007C117D /* Sources */,
 				97C146EB1CF9000F007C117D /* Frameworks */,
 				97C146EC1CF9000F007C117D /* Resources */,
 				9705A1C41CF9048500538489 /* Embed Frameworks */,
 				3B06AD1E1E4923F5004D2608 /* Thin Binary */,
-				2E10BAE564A4AFFCFF5B4EF0 /* [CP] Embed Pods Frameworks */,
-				BE3E47DA555D39F032C6A1DB /* [CP] Copy Pods Resources */,
+				898098BAEC57934A6822754B /* [CP] Embed Pods Frameworks */,
 			);
 			buildRules = (
 			);
@@ -264,6 +273,7 @@
 			);
 			mainGroup = 97C146E51CF9000F007C117D;
 			packageReferences = (
+				781AD8BC2B33823900A9FFBB /* XCLocalSwiftPackageReference "Flutter/ephemeral/Packages/FlutterGeneratedPluginSwiftPackage" */,
 				6A8A461F2EDB320D0057B88C /* XCRemoteSwiftPackageReference "MPVKit" */,
 			);
 			productRefGroup = 97C146EF1CF9000F007C117D /* Products */;
@@ -298,7 +308,23 @@
 /* End PBXResourcesBuildPhase section */
 
 /* Begin PBXShellScriptBuildPhase section */
-		01D58DD9E289D97FD8DBE66E /* [CP] Check Pods Manifest.lock */ = {
+		3B06AD1E1E4923F5004D2608 /* Thin Binary */ = {
+			isa = PBXShellScriptBuildPhase;
+			alwaysOutOfDate = 1;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputPaths = (
+				"${TARGET_BUILD_DIR}/${INFOPLIST_PATH}",
+			);
+			name = "Thin Binary";
+			outputPaths = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "/bin/sh \"$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh\" embed_and_thin";
+		};
+		6838C6976E568CE05DBDE228 /* [CP] Check Pods Manifest.lock */ = {
 			isa = PBXShellScriptBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
@@ -320,40 +346,7 @@
 			shellScript = "diff \"${PODS_PODFILE_DIR_PATH}/Podfile.lock\" \"${PODS_ROOT}/Manifest.lock\" > /dev/null\nif [ $? != 0 ] ; then\n    # print error to STDERR\n    echo \"error: The sandbox is not in sync with the Podfile.lock. Run 'pod install' or update your CocoaPods installation.\" >&2\n    exit 1\nfi\n# This output is used by Xcode 'outputs' to avoid re-running this script phase.\necho \"SUCCESS\" > \"${SCRIPT_OUTPUT_FILE_0}\"\n";
 			showEnvVarsInLog = 0;
 		};
-		2E10BAE564A4AFFCFF5B4EF0 /* [CP] Embed Pods Frameworks */ = {
-			isa = PBXShellScriptBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			inputFileListPaths = (
-				"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks-${CONFIGURATION}-input-files.xcfilelist",
-			);
-			name = "[CP] Embed Pods Frameworks";
-			outputFileListPaths = (
-				"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks-${CONFIGURATION}-output-files.xcfilelist",
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-			shellPath = /bin/sh;
-			shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks.sh\"\n";
-			showEnvVarsInLog = 0;
-		};
-		3B06AD1E1E4923F5004D2608 /* Thin Binary */ = {
-			isa = PBXShellScriptBuildPhase;
-			alwaysOutOfDate = 1;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			inputPaths = (
-				"${TARGET_BUILD_DIR}/${INFOPLIST_PATH}",
-			);
-			name = "Thin Binary";
-			outputPaths = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-			shellPath = /bin/sh;
-			shellScript = "/bin/sh \"$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh\" embed_and_thin";
-		};
-		684A4A968F313A7FDAEBF3B8 /* [CP] Check Pods Manifest.lock */ = {
+		87A3350E66D519725E5CD790 /* [CP] Check Pods Manifest.lock */ = {
 			isa = PBXShellScriptBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
@@ -375,6 +368,23 @@
 			shellScript = "diff \"${PODS_PODFILE_DIR_PATH}/Podfile.lock\" \"${PODS_ROOT}/Manifest.lock\" > /dev/null\nif [ $? != 0 ] ; then\n    # print error to STDERR\n    echo \"error: The sandbox is not in sync with the Podfile.lock. Run 'pod install' or update your CocoaPods installation.\" >&2\n    exit 1\nfi\n# This output is used by Xcode 'outputs' to avoid re-running this script phase.\necho \"SUCCESS\" > \"${SCRIPT_OUTPUT_FILE_0}\"\n";
 			showEnvVarsInLog = 0;
 		};
+		898098BAEC57934A6822754B /* [CP] Embed Pods Frameworks */ = {
+			isa = PBXShellScriptBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputFileListPaths = (
+				"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks-${CONFIGURATION}-input-files.xcfilelist",
+			);
+			name = "[CP] Embed Pods Frameworks";
+			outputFileListPaths = (
+				"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks-${CONFIGURATION}-output-files.xcfilelist",
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks.sh\"\n";
+			showEnvVarsInLog = 0;
+		};
 		9740EEB61CF901F6004384FC /* Run Script */ = {
 			isa = PBXShellScriptBuildPhase;
 			alwaysOutOfDate = 1;
@@ -390,23 +400,6 @@
 			shellPath = /bin/sh;
 			shellScript = "/bin/sh \"$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh\" build";
 		};
-		BE3E47DA555D39F032C6A1DB /* [CP] Copy Pods Resources */ = {
-			isa = PBXShellScriptBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			inputFileListPaths = (
-				"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-resources-${CONFIGURATION}-input-files.xcfilelist",
-			);
-			name = "[CP] Copy Pods Resources";
-			outputFileListPaths = (
-				"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-resources-${CONFIGURATION}-output-files.xcfilelist",
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-			shellPath = /bin/sh;
-			shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-resources.sh\"\n";
-			showEnvVarsInLog = 0;
-		};
 /* End PBXShellScriptBuildPhase section */
 
 /* Begin PBXSourcesBuildPhase section */
@@ -424,6 +417,7 @@
 			files = (
 				B1D51A6A2F00110000000001 /* MpvPlayerCoreBase.swift in Sources */,
 				B1D51A6A2F00110000000005 /* MpvPlayerPluginShared.swift in Sources */,
+				B1D51A6A2F00110000000008 /* ExternalDisplayManager.swift in Sources */,
 				6A8A46252EDB370C0057B88C /* MpvPlayerPlugin.swift in Sources */,
 				6A8A46262EDB370C0057B88C /* MpvPlayerCore.swift in Sources */,
 				92F969587D0E464D999910F5 /* MpvPipController.swift in Sources */,
@@ -542,7 +536,7 @@
 		};
 		331C8088294A63A400263BE5 /* Debug */ = {
 			isa = XCBuildConfiguration;
-			baseConfigurationReference = 5B81FA7048BFA976F49D555E /* Pods-RunnerTests.debug.xcconfig */;
+			baseConfigurationReference = 28ABDA890783B15438AA8137 /* Pods-RunnerTests.debug.xcconfig */;
 			buildSettings = {
 				BUNDLE_LOADER = "$(TEST_HOST)";
 				CODE_SIGN_STYLE = Automatic;
@@ -560,7 +554,7 @@
 		};
 		331C8089294A63A400263BE5 /* Release */ = {
 			isa = XCBuildConfiguration;
-			baseConfigurationReference = D239CED757CED630C2B0A161 /* Pods-RunnerTests.release.xcconfig */;
+			baseConfigurationReference = 3A9EF9720208222F20B1495D /* Pods-RunnerTests.release.xcconfig */;
 			buildSettings = {
 				BUNDLE_LOADER = "$(TEST_HOST)";
 				CODE_SIGN_STYLE = Automatic;
@@ -576,7 +570,7 @@
 		};
 		331C808A294A63A400263BE5 /* Profile */ = {
 			isa = XCBuildConfiguration;
-			baseConfigurationReference = 87ADF6219C65A13967DFF03C /* Pods-RunnerTests.profile.xcconfig */;
+			baseConfigurationReference = 792502911151E64A2B752567 /* Pods-RunnerTests.profile.xcconfig */;
 			buildSettings = {
 				BUNDLE_LOADER = "$(TEST_HOST)";
 				CODE_SIGN_STYLE = Automatic;
@@ -795,7 +789,7 @@
 			repositoryURL = "https://github.com/edde746/MPVKit";
 			requirement = {
 				kind = revision;
-				revision = b2179eec26c6ceda339e6c6b512e457341768761;
+				revision = 1fc33029bc0317583866c62811dc0ab2aa2415b6;
 			};
 		};
 /* End XCRemoteSwiftPackageReference section */
@@ -804,9 +798,19 @@
 		6A8A46202EDB320D0057B88C /* MPVKit */ = {
 			isa = XCSwiftPackageProductDependency;
 			package = 6A8A461F2EDB320D0057B88C /* XCRemoteSwiftPackageReference "MPVKit" */;
-			productName = "MPVKit";
+			productName = MPVKit;
+		};
+		78A3181F2AECB46A00862997 /* FlutterGeneratedPluginSwiftPackage */ = {
+			isa = XCSwiftPackageProductDependency;
+			productName = FlutterGeneratedPluginSwiftPackage;
 		};
 /* End XCSwiftPackageProductDependency section */
+/* Begin XCLocalSwiftPackageReference section */
+		781AD8BC2B33823900A9FFBB /* XCLocalSwiftPackageReference "Flutter/ephemeral/Packages/FlutterGeneratedPluginSwiftPackage" */ = {
+			isa = XCLocalSwiftPackageReference;
+			relativePath = Flutter/ephemeral/Packages/FlutterGeneratedPluginSwiftPackage;
+		};
+/* End XCLocalSwiftPackageReference section */
 	};
 	rootObject = 97C146E61CF9000F007C117D /* Project object */;
 }

ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -1,14 +1,84 @@
 {
-  "originHash" : "c535d3cdb62bd4e11e67f3c9e68290fa7ee9306634c5f56d2b0396eb75ed41ee",
   "pins" : [
+    {
+      "identity" : "csqlite",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/simolus3/CSQLite.git",
+      "state" : {
+        "revision" : "1ee46d19a4f451a7aa64ffc64fc99b4748131e62"
+      }
+    },
+    {
+      "identity" : "dkcamera",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/zhangao0086/DKCamera",
+      "state" : {
+        "branch" : "master",
+        "revision" : "5c691d11014b910aff69f960475d70e65d9dcc96"
+      }
+    },
+    {
+      "identity" : "dkimagepickercontroller",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/zhangao0086/DKImagePickerController",
+      "state" : {
+        "branch" : "4.3.9",
+        "revision" : "0bdfeacefa308545adde07bef86e349186335915"
+      }
+    },
+    {
+      "identity" : "dkphotogallery",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/zhangao0086/DKPhotoGallery",
+      "state" : {
+        "branch" : "master",
+        "revision" : "311c1bc7a94f1538f82773a79c84374b12a2ef3d"
+      }
+    },
     {
       "identity" : "mpvkit",
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/edde746/MPVKit",
       "state" : {
-        "revision" : "b2179eec26c6ceda339e6c6b512e457341768761"
+        "revision" : "1fc33029bc0317583866c62811dc0ab2aa2415b6"
+      }
+    },
+    {
+      "identity" : "sdwebimage",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/SDWebImage/SDWebImage",
+      "state" : {
+        "revision" : "2de3a496eaf6df9a1312862adcfd54acd73c39c0",
+        "version" : "5.21.7"
+      }
+    },
+    {
+      "identity" : "sentry-cocoa",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/getsentry/sentry-cocoa",
+      "state" : {
+        "revision" : "16cd512711375fa73f25ae5e373f596bdf4251ae",
+        "version" : "8.58.0"
+      }
+    },
+    {
+      "identity" : "swiftygif",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/kirualex/SwiftyGif.git",
+      "state" : {
+        "revision" : "4430cbc148baa3907651d40562d96325426f409a",
+        "version" : "5.4.5"
+      }
+    },
+    {
+      "identity" : "tocropviewcontroller",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/TimOliver/TOCropViewController",
+      "state" : {
+        "revision" : "d4a6d8100f4b886fdbc8ae399bf144ff3e9afb7e",
+        "version" : "2.8.0"
       }
     }
   ],
-  "version" : 3
+  "version" : 2
 }

ios/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme

@@ -5,6 +5,24 @@
    <BuildAction
       parallelizeBuildables = "YES"
       buildImplicitDependencies = "YES">
+      <PreActions>
+         <ExecutionAction
+            ActionType = "Xcode.IDEStandardExecutionActionsCore.ExecutionActionType.ShellScriptAction">
+            <ActionContent
+               title = "Run Prepare Flutter Framework Script"
+               scriptText = "/bin/sh &quot;$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh&quot; prepare&#10;">
+               <EnvironmentBuildable>
+                  <BuildableReference
+                     BuildableIdentifier = "primary"
+                     BlueprintIdentifier = "97C146ED1CF9000F007C117D"
+                     BuildableName = "Runner.app"
+                     BlueprintName = "Runner"
+                     ReferencedContainer = "container:Runner.xcodeproj">
+                  </BuildableReference>
+               </EnvironmentBuildable>
+            </ActionContent>
+         </ExecutionAction>
+      </PreActions>
       <BuildActionEntries>
          <BuildActionEntry
             buildForTesting = "YES"

ios/Runner.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -1,14 +1,84 @@
 {
-  "originHash" : "c535d3cdb62bd4e11e67f3c9e68290fa7ee9306634c5f56d2b0396eb75ed41ee",
   "pins" : [
+    {
+      "identity" : "csqlite",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/simolus3/CSQLite.git",
+      "state" : {
+        "revision" : "1ee46d19a4f451a7aa64ffc64fc99b4748131e62"
+      }
+    },
+    {
+      "identity" : "dkcamera",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/zhangao0086/DKCamera",
+      "state" : {
+        "branch" : "master",
+        "revision" : "5c691d11014b910aff69f960475d70e65d9dcc96"
+      }
+    },
+    {
+      "identity" : "dkimagepickercontroller",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/zhangao0086/DKImagePickerController",
+      "state" : {
+        "branch" : "4.3.9",
+        "revision" : "0bdfeacefa308545adde07bef86e349186335915"
+      }
+    },
+    {
+      "identity" : "dkphotogallery",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/zhangao0086/DKPhotoGallery",
+      "state" : {
+        "branch" : "master",
+        "revision" : "311c1bc7a94f1538f82773a79c84374b12a2ef3d"
+      }
+    },
     {
       "identity" : "mpvkit",
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/edde746/MPVKit",
       "state" : {
-        "revision" : "b2179eec26c6ceda339e6c6b512e457341768761"
+        "revision" : "1fc33029bc0317583866c62811dc0ab2aa2415b6"
+      }
+    },
+    {
+      "identity" : "sdwebimage",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/SDWebImage/SDWebImage",
+      "state" : {
+        "revision" : "2de3a496eaf6df9a1312862adcfd54acd73c39c0",
+        "version" : "5.21.7"
+      }
+    },
+    {
+      "identity" : "sentry-cocoa",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/getsentry/sentry-cocoa",
+      "state" : {
+        "revision" : "16cd512711375fa73f25ae5e373f596bdf4251ae",
+        "version" : "8.58.0"
+      }
+    },
+    {
+      "identity" : "swiftygif",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/kirualex/SwiftyGif.git",
+      "state" : {
+        "revision" : "4430cbc148baa3907651d40562d96325426f409a",
+        "version" : "5.4.5"
+      }
+    },
+    {
+      "identity" : "tocropviewcontroller",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/TimOliver/TOCropViewController",
+      "state" : {
+        "revision" : "d4a6d8100f4b886fdbc8ae399bf144ff3e9afb7e",
+        "version" : "2.8.0"
       }
     }
   ],
-  "version" : 3
+  "version" : 2
 }

ios/Runner/Info.plist

@@ -24,6 +24,8 @@
 	<string>????</string>
 	<key>CFBundleVersion</key>
 	<string>$(FLUTTER_BUILD_NUMBER)</string>
+	<key>ITSAppUsesNonExemptEncryption</key>
+	<false/>
 	<key>LSRequiresIPhoneOS</key>
 	<true/>
 	<key>LSSupportsOpeningDocumentsInPlace</key>
@@ -33,12 +35,12 @@
 		<key>NSAllowsArbitraryLoads</key>
 		<true/>
 	</dict>
-	<key>NSBonjourServices</key>
-	<array>
-		<string>_plexmediasvr._tcp</string>
-	</array>
 	<key>NSLocalNetworkUsageDescription</key>
-	<string>This app needs to connect to your Plex Media Server on your local network.</string>
+	<string>This app needs to connect to your media servers on your local network.</string>
+	<key>NSLocationWhenInUseUsageDescription</key>
+	<string>Plezy uses location access when iOS requires it to detect your local network and connect to your media servers.</string>
+	<key>NSPhotoLibraryUsageDescription</key>
+	<string>Plezy needs photo library access so you can choose images to upload as media artwork.</string>
 	<key>NSCameraUsageDescription</key>
 	<string>Camera is used to scan QR codes for Companion Remote pairing.</string>
 	<key>UIApplicationSupportsIndirectInputEvents</key>
@@ -70,7 +72,7 @@
 	<key>UIApplicationSceneManifest</key>
 	<dict>
 		<key>UIApplicationSupportsMultipleScenes</key>
-		<false/>
+		<true/>
 		<key>UISceneConfigurations</key>
 		<dict>
 			<key>UIWindowSceneSessionRoleApplication</key>
@@ -86,6 +88,28 @@
 					<string>Main</string>
 				</dict>
 			</array>
+			<key>UIWindowSceneSessionRoleExternalDisplay</key>
+			<array>
+				<dict>
+					<key>UISceneClassName</key>
+					<string>UIWindowScene</string>
+					<key>UISceneDelegateClassName</key>
+					<string>$(PRODUCT_MODULE_NAME).ExternalDisplaySceneDelegate</string>
+					<key>UISceneConfigurationName</key>
+					<string>external-display</string>
+				</dict>
+			</array>
+			<key>UIWindowSceneSessionRoleExternalDisplayNonInteractive</key>
+			<array>
+				<dict>
+					<key>UISceneClassName</key>
+					<string>UIWindowScene</string>
+					<key>UISceneDelegateClassName</key>
+					<string>$(PRODUCT_MODULE_NAME).ExternalDisplaySceneDelegate</string>
+					<key>UISceneConfigurationName</key>
+					<string>external-display</string>
+				</dict>
+			</array>
 		</dict>
 	</dict>
 </dict>

ios/Runner/MpvPlayer/ExternalDisplayManager.swift

@@ -0,0 +1,172 @@
+import UIKit
+
+final class ExternalDisplayManager {
+  static let shared = ExternalDisplayManager()
+
+  private weak var activeCore: MpvPlayerCore?
+  private var externalScene: UIWindowScene?
+  private var externalWindow: UIWindow?
+  private var externalRootViewController: UIViewController?
+
+  private init() {}
+
+  static func isExternalDisplayRole(_ role: UISceneSession.Role) -> Bool {
+    role.rawValue == "UIWindowSceneSessionRoleExternalDisplay"
+      || role.rawValue == "UIWindowSceneSessionRoleExternalDisplayNonInteractive"
+  }
+
+  static var hasActiveApplicationScene: Bool {
+    applicationWindowScenes.contains { $0.activationState == .foregroundActive }
+  }
+
+  static func mainApplicationWindow() -> UIWindow? {
+    let scenes = applicationWindowScenes.sorted {
+      scenePriority($0.activationState) < scenePriority($1.activationState)
+    }
+
+    for scene in scenes {
+      if let window = scene.windows.first(where: { $0.isKeyWindow }) {
+        return window
+      }
+    }
+
+    for scene in scenes {
+      if let window = scene.windows.first(where: { !$0.isHidden }) {
+        return window
+      }
+    }
+
+    return scenes.first?.windows.first
+  }
+
+  private static var applicationWindowScenes: [UIWindowScene] {
+    UIApplication.shared.connectedScenes.compactMap { scene in
+      guard let windowScene = scene as? UIWindowScene,
+        !isExternalDisplayRole(windowScene.session.role)
+      else { return nil }
+      return windowScene
+    }
+  }
+
+  private static func scenePriority(_ state: UIScene.ActivationState) -> Int {
+    switch state {
+    case .foregroundActive:
+      return 0
+    case .foregroundInactive:
+      return 1
+    case .background:
+      return 2
+    case .unattached:
+      return 3
+    @unknown default:
+      return 4
+    }
+  }
+
+  var videoSuperview: UIView? {
+    externalRootViewController?.view
+  }
+
+  func attach(core: MpvPlayerCore) {
+    activeCore = core
+    discoverExistingExternalScene()
+    activeCore?.externalDisplayDidChange()
+  }
+
+  func detach(core: MpvPlayerCore) {
+    if activeCore === core {
+      activeCore = nil
+    }
+  }
+
+  @discardableResult
+  func connect(scene: UIWindowScene) -> UIWindow? {
+    guard Self.isExternalDisplayRole(scene.session.role) else { return nil }
+
+    externalScene = scene
+    let window = ensureWindow(for: scene)
+    activeCore?.externalDisplayDidChange()
+    print("[ExternalDisplayManager] External display connected")
+    return window
+  }
+
+  func disconnect(scene: UIScene) {
+    guard scene === externalScene else { return }
+
+    externalWindow?.isHidden = true
+    externalWindow = nil
+    externalRootViewController = nil
+    externalScene = nil
+    activeCore?.externalDisplayDidChange()
+    print("[ExternalDisplayManager] External display disconnected")
+  }
+
+  func update(scene: UIWindowScene) {
+    guard scene === externalScene else { return }
+    externalRootViewController?.view.frame = scene.coordinateSpace.bounds
+    activeCore?.externalDisplayDidChange()
+  }
+
+  private func discoverExistingExternalScene() {
+    guard externalScene == nil else { return }
+
+    for scene in UIApplication.shared.connectedScenes {
+      guard let windowScene = scene as? UIWindowScene,
+        Self.isExternalDisplayRole(windowScene.session.role)
+      else { continue }
+      _ = connect(scene: windowScene)
+      return
+    }
+  }
+
+  private func ensureWindow(for scene: UIWindowScene) -> UIWindow {
+    if let existing = externalWindow, existing.windowScene === scene {
+      return existing
+    }
+
+    externalWindow?.isHidden = true
+
+    let rootViewController = UIViewController()
+    rootViewController.view.frame = scene.coordinateSpace.bounds
+    rootViewController.view.backgroundColor = .black
+
+    let window = UIWindow(windowScene: scene)
+    window.rootViewController = rootViewController
+    window.backgroundColor = .black
+    window.isHidden = false
+
+    externalRootViewController = rootViewController
+    externalWindow = window
+    return window
+  }
+}
+
+class ExternalDisplaySceneDelegate: UIResponder, UIWindowSceneDelegate {
+  var window: UIWindow?
+
+  func scene(
+    _ scene: UIScene,
+    willConnectTo session: UISceneSession,
+    options connectionOptions: UIScene.ConnectionOptions
+  ) {
+    guard let windowScene = scene as? UIWindowScene,
+      ExternalDisplayManager.isExternalDisplayRole(session.role)
+    else { return }
+
+    window = ExternalDisplayManager.shared.connect(scene: windowScene)
+  }
+
+  func sceneDidDisconnect(_ scene: UIScene) {
+    ExternalDisplayManager.shared.disconnect(scene: scene)
+    window = nil
+  }
+
+  func windowScene(
+    _ windowScene: UIWindowScene,
+    didUpdate previousCoordinateSpace: UICoordinateSpace,
+    interfaceOrientation previousInterfaceOrientation: UIInterfaceOrientation,
+    traitCollection previousTraitCollection: UITraitCollection
+  ) {
+    ExternalDisplayManager.shared.update(scene: windowScene)
+  }
+}

ios/Runner/MpvPlayer/MpvPipController.swift

@@ -1,8 +1,44 @@
+import AVFoundation
 import AVKit
 import UIKit
 
-/// Delegate to notify the plugin of PiP lifecycle events
-protocol MpvPipDelegate: AnyObject {
+#if os(tvOS)
+  // tvOS stub: AVPictureInPictureController has different constraints on tvOS
+  // and is not supported by the Plezy flow. Provide a no-op shell so callers
+  // in MpvPlayerPlugin compile unchanged; isSupported reports false so PiP is
+  // never attempted at runtime.
+  protocol MpvPipDelegate: AnyObject {
+    func pipWillStart()
+    func pipDidStart()
+    func pipDidStop(restored: Bool)
+    func pipDidFailToStart(error: Error?)
+    func pipSetPlaying(_ playing: Bool)
+    func pipSkip(byInterval seconds: Double, completion: @escaping () -> Void)
+    var isPipPlaying: Bool { get }
+    var pipDuration: Double { get }
+  }
+
+  class MpvPipController: NSObject {
+    static var isSupported: Bool { false }
+    weak var delegate: MpvPipDelegate?
+    var isPipActive: Bool { false }
+    var autoStartEnabled: Bool { false }
+    init(sampleBufferDisplayLayer: AVSampleBufferDisplayLayer) { super.init() }
+    func setup(with layer: CALayer, containerView: UIView) {}
+    func setAutoStart(_ enabled: Bool) {}
+    func warmLayer(currentTime: Double, isPlaying: Bool) {}
+    func startPip(waitForFrame: Bool = true, completion: @escaping (Bool) -> Void) {
+      completion(false)
+    }
+    func stopPip() {}
+    func invalidatePlaybackState() {}
+    func syncTimebase(currentTime: Double, isPlaying: Bool) {}
+    func teardown() {}
+  }
+#else
+
+  /// Delegate to notify the plugin of PiP lifecycle events
+  protocol MpvPipDelegate: AnyObject {
     /// Called when PiP is about to start (system or app-initiated)
     func pipWillStart()
     func pipDidStart()
@@ -12,359 +48,258 @@ protocol MpvPipDelegate: AnyObject {
     /// Forward play/pause commands from PiP overlay to mpv
     func pipSetPlaying(_ playing: Bool)
     /// Forward skip forward/backward commands from PiP overlay to mpv
-    func pipSkip(byInterval seconds: Double)
+    func pipSkip(byInterval seconds: Double, completion: @escaping () -> Void)
     /// Query whether mpv is currently playing
     var isPipPlaying: Bool { get }
     /// Get total duration in seconds
     var pipDuration: Double { get }
-}
+  }
 
-/// Encapsulates all iOS Picture-in-Picture logic using AVSampleBufferDisplayLayer.
-/// Requires iOS 15+ for the ContentSource API; on older versions, `setup()` is a no-op.
-class MpvPipController: NSObject {
+  /// Encapsulates all iOS Picture-in-Picture logic using AVSampleBufferDisplayLayer.
+  /// Requires iOS 15+ for the ContentSource API; on older versions, `setup()` is a no-op.
+  class MpvPipController: NSObject {
 
     // MARK: - Properties
 
     private var pipController: AVPictureInPictureController?
-    private let sampleBufferLayer = AVSampleBufferDisplayLayer()
-    private var containerView: UIView?
+    private weak var sampleBufferLayer: AVSampleBufferDisplayLayer?
     weak var delegate: MpvPipDelegate?
 
-    /// Pointer to the sample buffer layer for passing to mpv as `wid`
-    var layerPointer: UnsafeMutableRawPointer {
-        Unmanaged.passUnretained(sampleBufferLayer).toOpaque()
-    }
-
     // MARK: - Initialization
 
-    override init() {
-        super.init()
-        setup()
+    init(sampleBufferDisplayLayer: AVSampleBufferDisplayLayer) {
+      self.sampleBufferLayer = sampleBufferDisplayLayer
+      super.init()
+      setup()
     }
 
     private func setup() {
-        guard #available(iOS 15.0, *) else { return }
+      guard #available(iOS 15.0, *) else { return }
 
-        do {
-            try AVAudioSession.sharedInstance().setCategory(.playback, mode: .moviePlayback)
-            try AVAudioSession.sharedInstance().setActive(true)
-        } catch {
-            print("[MpvPipController] Failed to configure audio session: \(error)")
-        }
+      do {
+        try AVAudioSession.sharedInstance().setCategory(.playback, mode: .moviePlayback)
+        try AVAudioSession.sharedInstance().setActive(true)
+      } catch {
+        print("[MpvPipController] Failed to configure audio session: \(error)")
+      }
 
-        // The sample buffer layer must be in a visible view hierarchy for
-        // isPictureInPicturePossible to become true.
-        if let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene,
-           let window = windowScene.windows.first(where: { $0.isKeyWindow }) {
-            let view = UIView(frame: window.bounds)
-            view.autoresizingMask = [.flexibleWidth, .flexibleHeight]
-            view.clipsToBounds = true
-            view.isUserInteractionEnabled = false
-            sampleBufferLayer.frame = view.bounds
-            view.layer.addSublayer(sampleBufferLayer)
-            window.addSubview(view)
-            containerView = view
-        }
-
-        createPipController()
+      createPipController()
     }
 
     /// Helper that conforms to the iOS 15+ delegate protocols
     private var delegateHelper: AnyObject?
 
     private func createPipController() {
-        guard #available(iOS 15.0, *) else { return }
-        let helper = PipDelegateHelper(controller: self)
-        let contentSource = AVPictureInPictureController.ContentSource(
-            sampleBufferDisplayLayer: sampleBufferLayer,
-            playbackDelegate: helper
-        )
-        self.delegateHelper = helper
-        pipController = AVPictureInPictureController(contentSource: contentSource)
-        pipController?.delegate = helper
-        if #available(iOS 14.2, *) {
-            pipController?.canStartPictureInPictureAutomaticallyFromInline = false
-        }
+      guard #available(iOS 15.0, *), let sampleBufferLayer else { return }
+      let helper = PipDelegateHelper(controller: self)
+      let contentSource = AVPictureInPictureController.ContentSource(
+        sampleBufferDisplayLayer: sampleBufferLayer,
+        playbackDelegate: helper
+      )
+      self.delegateHelper = helper
+      pipController = AVPictureInPictureController(contentSource: contentSource)
+      pipController?.delegate = helper
+      pipController?.canStartPictureInPictureAutomaticallyFromInline = false
     }
 
     /// Enable/disable system auto-PiP (starts PiP automatically on background transition)
     func setAutoStart(_ enabled: Bool) {
-        guard #available(iOS 14.2, *) else { return }
-        pipController?.canStartPictureInPictureAutomaticallyFromInline = enabled
+      guard #available(iOS 14.2, *) else { return }
+      pipController?.canStartPictureInPictureAutomaticallyFromInline = enabled
     }
 
-    /// Push a black frame to the sample buffer layer so PiP has content
-    /// to display immediately (before vo_pip decodes the first real frame).
-    func pushBlankFrame(width: Int32 = 1920, height: Int32 = 1080) {
-        var pixelBuffer: CVPixelBuffer?
-        let attrs: [String: Any] = [
-            kCVPixelBufferIOSurfacePropertiesKey as String: [:],
-        ]
-        let status = CVPixelBufferCreate(
-            kCFAllocatorDefault, Int(width), Int(height),
-            kCVPixelFormatType_32BGRA, attrs as CFDictionary, &pixelBuffer
-        )
-        guard status == kCVReturnSuccess, let pb = pixelBuffer else { return }
-
-        // Fill with black
-        CVPixelBufferLockBaseAddress(pb, [])
-        if let base = CVPixelBufferGetBaseAddress(pb) {
-            memset(base, 0, CVPixelBufferGetDataSize(pb))
-        }
-        CVPixelBufferUnlockBaseAddress(pb, [])
-
-        // Use current timebase time for PTS (if available) so the frame isn't stale
-        let pts: CMTime
-        if let tb = sampleBufferLayer.controlTimebase {
-            pts = CMTimebaseGetTime(tb)
-        } else {
-            pts = CMTime(value: 0, timescale: 30)
-        }
-
-        var timing = CMSampleTimingInfo(
-            duration: CMTime(value: 1, timescale: 30),
-            presentationTimeStamp: pts,
-            decodeTimeStamp: .invalid
-        )
-
-        // Create format description and sample buffer
-        var formatDesc: CMVideoFormatDescription?
-        CMVideoFormatDescriptionCreateForImageBuffer(
-            allocator: kCFAllocatorDefault,
-            imageBuffer: pb,
-            formatDescriptionOut: &formatDesc
-        )
-        guard let fmt = formatDesc else { return }
-
-        var sampleBuffer: CMSampleBuffer?
-        CMSampleBufferCreateReadyWithImageBuffer(
-            allocator: kCFAllocatorDefault,
-            imageBuffer: pb,
-            formatDescription: fmt,
-            sampleTiming: &timing,
-            sampleBufferOut: &sampleBuffer
-        )
-        guard let sb = sampleBuffer else { return }
-
-        // Set DisplayImmediately so it shows regardless of timebase timing
-        if let attachments = CMSampleBufferGetSampleAttachmentsArray(sb, createIfNecessary: true) as? [NSMutableDictionary],
-           let dict = attachments.first {
-            dict[kCMSampleAttachmentKey_DisplayImmediately] = true
-        }
-
-        sampleBufferLayer.enqueue(sb)
-    }
-
-    /// Sync the layer's controlTimebase with the actual playback position.
-    /// This makes the PiP progress bar show the correct time.
+    /// MPVKit owns the sample-buffer layer timebase. PiP only reads it.
     func syncTimebase(currentTime: Double, isPlaying: Bool) {
-        guard let timebase = sampleBufferLayer.controlTimebase else { return }
-        let cmTime = CMTime(seconds: currentTime, preferredTimescale: 1000)
-        CMTimebaseSetTime(timebase, time: cmTime)
-        CMTimebaseSetRate(timebase, rate: isPlaying ? 1.0 : 0.0)
     }
 
-    /// Ensure the layer has a timebase and blank frame so the system considers
-    /// PiP possible (required for canStartPictureInPictureAutomaticallyFromInline).
+    /// Ensure the layer has MPVKit's renderer-owned timebase before PiP starts.
     func warmLayer(currentTime: Double, isPlaying: Bool) {
-        if sampleBufferLayer.controlTimebase == nil {
-            var timebase: CMTimebase?
-            CMTimebaseCreateWithSourceClock(
-                allocator: kCFAllocatorDefault,
-                sourceClock: CMClockGetHostTimeClock(),
-                timebaseOut: &timebase
-            )
-            if let tb = timebase {
-                sampleBufferLayer.controlTimebase = tb
-            }
-        }
-        syncTimebase(currentTime: currentTime, isPlaying: isPlaying)
-        pushBlankFrame()
+      if sampleBufferLayer?.controlTimebase == nil {
+        print("[MpvPipController] Waiting for MPVKit renderer timebase before PiP")
+      }
     }
 
     // MARK: - Public API
 
     static var isSupported: Bool {
-        guard #available(iOS 15.0, *) else { return false }
-        return AVPictureInPictureController.isPictureInPictureSupported()
+      guard #available(iOS 15.0, *) else { return false }
+      return AVPictureInPictureController.isPictureInPictureSupported()
     }
 
     /// Start PiP. When `waitForFrame` is false (auto-PiP), skips the frame
     /// readiness check since the scene is about to deactivate.
     func startPip(waitForFrame: Bool = true, completion: @escaping (Bool) -> Void) {
-        guard let pipController = pipController else {
-            completion(false)
-            return
+      guard let pipController = pipController else {
+        completion(false)
+        return
+      }
+
+      var attempts = 0
+      func tryStart() {
+        let possible = pipController.isPictureInPicturePossible
+        let hasTimebase = self.sampleBufferLayer?.controlTimebase != nil
+
+        let hasFrame: Bool
+        if !waitForFrame {
+          hasFrame = true  // Skip frame check for auto-PiP
+        } else if #available(iOS 17.4, *) {
+          hasFrame = self.sampleBufferLayer?.isReadyForDisplay ?? false
+        } else {
+          hasFrame = true
         }
 
-        var attempts = 0
-        func tryStart() {
-            let possible = pipController.isPictureInPicturePossible
-            let hasTimebase = sampleBufferLayer.controlTimebase != nil
-
-            let hasFrame: Bool
-            if !waitForFrame {
-                hasFrame = true  // Skip frame check for auto-PiP
-            } else if #available(iOS 17.4, *) {
-                hasFrame = sampleBufferLayer.isReadyForDisplay
-            } else {
-                hasFrame = true
-            }
-
-            if possible && hasTimebase && hasFrame {
-                print("[MpvPipController] vo_pip ready after \(attempts) retries, starting PiP")
-                pipController.startPictureInPicture()
-                completion(true)
-            } else if attempts < 40 {
-                attempts += 1
-                DispatchQueue.main.asyncAfter(deadline: .now() + 0.05) { tryStart() }
-            } else {
-                print("[MpvPipController] PiP not ready after \(attempts) retries (possible=\(possible), timebase=\(hasTimebase))")
-                completion(false)
-            }
+        if possible && hasTimebase && hasFrame {
+          print("[MpvPipController] vo_avfoundation ready after \(attempts) retries, starting PiP")
+          pipController.startPictureInPicture()
+          completion(true)
+        } else if attempts < 40 {
+          attempts += 1
+          DispatchQueue.main.asyncAfter(deadline: .now() + 0.05) { tryStart() }
+        } else {
+          print(
+            "[MpvPipController] PiP not ready after \(attempts) retries (possible=\(possible), timebase=\(hasTimebase))"
+          )
+          completion(false)
         }
-        tryStart()
+      }
+      tryStart()
     }
 
     func stopPip() {
-        pipController?.stopPictureInPicture()
+      pipController?.stopPictureInPicture()
     }
 
     /// Invalidate the playback state so PiP updates its UI (play/pause button)
     func invalidatePlaybackState() {
-        pipController?.invalidatePlaybackState()
+      guard #available(iOS 15.0, *) else { return }
+      pipController?.invalidatePlaybackState()
     }
 
-    /// Fully tear down PiP — removes the container view from the window and
-    /// destroys the AVPictureInPictureController so the system can no longer
-    /// trigger auto-PiP after the player is disposed.
+    /// Fully tear down PiP without touching the shared inline display layer.
     func teardown() {
-        pipController?.stopPictureInPicture()
-        if #available(iOS 14.2, *) {
-            pipController?.canStartPictureInPictureAutomaticallyFromInline = false
-        }
-        pipController = nil
-        delegateHelper = nil
-        sampleBufferLayer.flushAndRemoveImage()
-        sampleBufferLayer.controlTimebase = nil
-        sampleBufferLayer.removeFromSuperlayer()
-        containerView?.removeFromSuperview()
-        containerView = nil
+      pipController?.stopPictureInPicture()
+      if #available(iOS 14.2, *) {
+        pipController?.canStartPictureInPictureAutomaticallyFromInline = false
+      }
+      pipController = nil
+      delegateHelper = nil
     }
 
-    /// Flush enqueued sample buffers from the layer to free video frame memory
-    func flushLayer() {
-        sampleBufferLayer.flushAndRemoveImage()
-    }
-}
+  }
 
-// MARK: - PiP Delegate Helper (iOS 15+)
+  // MARK: - PiP Delegate Helper (iOS 15+)
 
-/// Separate class conforming to AVPictureInPictureControllerDelegate and
-/// AVPictureInPictureSampleBufferPlaybackDelegate since these require iOS 15+
-/// availability for the ContentSource-based delegate methods.
-@available(iOS 15.0, *)
-private class PipDelegateHelper: NSObject, AVPictureInPictureControllerDelegate,
+  /// Separate class conforming to AVPictureInPictureControllerDelegate and
+  /// AVPictureInPictureSampleBufferPlaybackDelegate since these require iOS 15+
+  /// availability for the ContentSource-based delegate methods.
+  @available(iOS 15.0, *)
+  private class PipDelegateHelper: NSObject, AVPictureInPictureControllerDelegate,
     AVPictureInPictureSampleBufferPlaybackDelegate
-{
+  {
     weak var controller: MpvPipController?
     private var isRestoring = false
 
     init(controller: MpvPipController) {
-        self.controller = controller
-        super.init()
+      self.controller = controller
+      super.init()
     }
 
     // MARK: - AVPictureInPictureControllerDelegate
 
     func pictureInPictureControllerWillStartPictureInPicture(
-        _ pictureInPictureController: AVPictureInPictureController
+      _ pictureInPictureController: AVPictureInPictureController
     ) {
-        print("[MpvPipController] PiP will start")
-        controller?.delegate?.pipWillStart()
+      print("[MpvPipController] PiP will start")
+      controller?.delegate?.pipWillStart()
     }
 
     func pictureInPictureControllerDidStartPictureInPicture(
-        _ pictureInPictureController: AVPictureInPictureController
+      _ pictureInPictureController: AVPictureInPictureController
     ) {
-        print("[MpvPipController] PiP did start")
-        controller?.delegate?.pipDidStart()
+      print("[MpvPipController] PiP did start")
+      controller?.delegate?.pipDidStart()
     }
 
     func pictureInPictureControllerDidStopPictureInPicture(
-        _ pictureInPictureController: AVPictureInPictureController
+      _ pictureInPictureController: AVPictureInPictureController
     ) {
-        let restored = isRestoring
-        isRestoring = false
-        print("[MpvPipController] PiP did stop (restored: \(restored))")
-        controller?.delegate?.pipDidStop(restored: restored)
+      let restored = isRestoring
+      isRestoring = false
+      print("[MpvPipController] PiP did stop (restored: \(restored))")
+      controller?.delegate?.pipDidStop(restored: restored)
     }
 
     func pictureInPictureController(
-        _ pictureInPictureController: AVPictureInPictureController,
-        failedToStartPictureInPictureWithError error: Error
+      _ pictureInPictureController: AVPictureInPictureController,
+      failedToStartPictureInPictureWithError error: Error
     ) {
-        print("[MpvPipController] PiP failed to start: \(error)")
-        controller?.delegate?.pipDidFailToStart(error: error)
+      print("[MpvPipController] PiP failed to start: \(error)")
+      controller?.delegate?.pipDidFailToStart(error: error)
     }
 
     func pictureInPictureController(
-        _ pictureInPictureController: AVPictureInPictureController,
-        restoreUserInterfaceForPictureInPictureStopWithCompletionHandler completionHandler: @escaping (Bool) -> Void
+      _ pictureInPictureController: AVPictureInPictureController,
+      restoreUserInterfaceForPictureInPictureStopWithCompletionHandler completionHandler:
+        @escaping (Bool) -> Void
     ) {
-        print("[MpvPipController] PiP restore user interface")
-        isRestoring = true
-        completionHandler(true)
+      print("[MpvPipController] PiP restore user interface")
+      isRestoring = true
+      completionHandler(true)
     }
 
     func pictureInPictureControllerWillStopPictureInPicture(
-        _ pictureInPictureController: AVPictureInPictureController
+      _ pictureInPictureController: AVPictureInPictureController
     ) {
-        print("[MpvPipController] PiP will stop")
+      print("[MpvPipController] PiP will stop")
     }
 
     // MARK: - AVPictureInPictureSampleBufferPlaybackDelegate
 
     func pictureInPictureController(
-        _ pictureInPictureController: AVPictureInPictureController,
-        setPlaying playing: Bool
+      _ pictureInPictureController: AVPictureInPictureController,
+      setPlaying playing: Bool
     ) {
-        print("[MpvPipController] PiP setPlaying: \(playing)")
-        controller?.delegate?.pipSetPlaying(playing)
+      print("[MpvPipController] PiP setPlaying: \(playing)")
+      controller?.delegate?.pipSetPlaying(playing)
     }
 
     func pictureInPictureControllerTimeRangeForPlayback(
-        _ pictureInPictureController: AVPictureInPictureController
+      _ pictureInPictureController: AVPictureInPictureController
     ) -> CMTimeRange {
-        let duration = controller?.delegate?.pipDuration ?? 0
-        if duration > 0 {
-            return CMTimeRange(
-                start: .zero,
-                duration: CMTime(seconds: duration, preferredTimescale: 1000)
-            )
-        }
-        return CMTimeRange(start: .zero, duration: CMTime(seconds: 1, preferredTimescale: 1))
+      let duration = controller?.delegate?.pipDuration ?? 0
+      if duration > 0 {
+        return CMTimeRange(
+          start: .zero,
+          duration: CMTime(seconds: duration, preferredTimescale: 1000)
+        )
+      }
+      return CMTimeRange(start: .zero, duration: CMTime(seconds: 1, preferredTimescale: 1))
     }
 
     func pictureInPictureControllerIsPlaybackPaused(
-        _ pictureInPictureController: AVPictureInPictureController
+      _ pictureInPictureController: AVPictureInPictureController
     ) -> Bool {
-        return !(controller?.delegate?.isPipPlaying ?? false)
+      return !(controller?.delegate?.isPipPlaying ?? false)
     }
 
     func pictureInPictureController(
-        _ pictureInPictureController: AVPictureInPictureController,
-        didTransitionToRenderSize newRenderSize: CMVideoDimensions
+      _ pictureInPictureController: AVPictureInPictureController,
+      didTransitionToRenderSize newRenderSize: CMVideoDimensions
     ) {}
 
     func pictureInPictureController(
-        _ pictureInPictureController: AVPictureInPictureController,
-        skipByInterval skipInterval: CMTime,
-        completion completionHandler: @escaping () -> Void
+      _ pictureInPictureController: AVPictureInPictureController,
+      skipByInterval skipInterval: CMTime,
+      completion completionHandler: @escaping () -> Void
     ) {
-        let seconds = CMTimeGetSeconds(skipInterval)
-        print("[MpvPipController] PiP skip by \(seconds)s")
-        controller?.delegate?.pipSkip(byInterval: seconds)
+      let seconds = CMTimeGetSeconds(skipInterval)
+      print("[MpvPipController] PiP skip by \(seconds)s")
+      guard let delegate = controller?.delegate else {
         completionHandler()
+        return
+      }
+      delegate.pipSkip(byInterval: seconds, completion: completionHandler)
     }
-}
+  }
+
+#endif  // !os(tvOS)

ios/Runner/MpvPlayer/MpvPlayerPlugin.swift

@@ -5,389 +5,506 @@ import AVKit
 /// Flutter plugin that bridges MPV player to Dart via method and event channels
 class MpvPlayerPlugin: NSObject, FlutterPlugin, FlutterStreamHandler, MpvPluginShared {
 
-    // MARK: - Properties
+  // MARK: - Properties
 
-    private var playerCore: MpvPlayerCore?
-    var eventSink: FlutterEventSink?
-    private weak var registrar: FlutterPluginRegistrar?
-    var nameToId: [String: Int] = [:]
+  private var playerCore: MpvPlayerCore?
+  var eventSink: FlutterEventSink?
+  private weak var registrar: FlutterPluginRegistrar?
+  var nameToId: [String: Int] = [:]
 
-    // MpvPluginShared conformance
-    var coreBase: MpvPlayerCoreBase? { playerCore }
-    func setPlayerVisible(_ visible: Bool) { playerCore?.setVisible(visible) }
-    func updatePlayerFrame() { playerCore?.updateFrame() }
+  // MpvPluginShared conformance
+  var coreBase: MpvPlayerCoreBase? { playerCore }
+  func setPlayerVisible(_ visible: Bool, restoreOnWindowVisible _: Bool) { playerCore?.setVisible(visible) }
+  func updatePlayerFrame() { playerCore?.updateFrame() }
 
-    // PiP
-    private var pipController: MpvPipController?
-    private var pipChannel: FlutterMethodChannel?
-    private var autoPipEnabled = false
-    private var isManualPipRequest = false
-    private var pipTimebaseSyncTimer: Timer?
-    private var pendingInlineRestoreAfterPip = false
-    private var sceneActivationObserverRegistered = false
+  // PiP
+  private var pipController: MpvPipController?
+  private var pipChannel: FlutterMethodChannel?
+  private var autoPipEnabled = false
+  private var isManualPipRequest = false
+  private var pipTimebaseSyncTimer: Timer?
+  private var pendingInlineRestoreAfterPip = false
+  private var sceneActivationObserverRegistered = false
 
-    // MARK: - FlutterPlugin Registration
+  // MARK: - FlutterPlugin Registration
 
-    static func register(with registrar: FlutterPluginRegistrar) {
-        let methodChannel = FlutterMethodChannel(
-            name: "com.plezy/mpv_player",
-            binaryMessenger: registrar.messenger()
-        )
-        let eventChannel = FlutterEventChannel(
-            name: "com.plezy/mpv_player/events",
-            binaryMessenger: registrar.messenger()
-        )
-        let pipChannel = FlutterMethodChannel(
-            name: "com.plezy/pip",
-            binaryMessenger: registrar.messenger()
-        )
+  static func register(with registrar: FlutterPluginRegistrar) {
+    let methodChannel = FlutterMethodChannel(
+      name: "com.plezy/mpv_player",
+      binaryMessenger: registrar.messenger()
+    )
+    let eventChannel = FlutterEventChannel(
+      name: "com.plezy/mpv_player/events",
+      binaryMessenger: registrar.messenger()
+    )
+    let pipChannel = FlutterMethodChannel(
+      name: "com.plezy/pip",
+      binaryMessenger: registrar.messenger()
+    )
 
-        let instance = MpvPlayerPlugin()
-        instance.registrar = registrar
-        instance.pipChannel = pipChannel
+    let instance = MpvPlayerPlugin()
+    instance.registrar = registrar
+    instance.pipChannel = pipChannel
 
-        registrar.addMethodCallDelegate(instance, channel: methodChannel)
-        eventChannel.setStreamHandler(instance)
-        pipChannel.setMethodCallHandler(instance.handlePipCall)
+    registrar.addMethodCallDelegate(instance, channel: methodChannel)
+    eventChannel.setStreamHandler(instance)
+    pipChannel.setMethodCallHandler(instance.handlePipCall)
+  }
+
+  // MARK: - FlutterStreamHandler
+
+  func onListen(withArguments arguments: Any?, eventSink events: @escaping FlutterEventSink)
+    -> FlutterError?
+  {
+    self.eventSink = events
+    return nil
+  }
+
+  func onCancel(withArguments arguments: Any?) -> FlutterError? {
+    self.eventSink = nil
+    return nil
+  }
+
+  // MARK: - FlutterPlugin Method Handler
+
+  func handle(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
+    switch call.method {
+    case "initialize":
+      handleInitialize(result: result)
+    case "dispose":
+      handleDispose(call: call, result: result)
+    case "setProperty":
+      handleSetProperty(call: call, result: result)
+    case "getProperty":
+      handleGetProperty(call: call, result: result)
+    case "observeProperty":
+      handleObserveProperty(call: call, result: result)
+    case "command":
+      handleCommand(call: call, result: result)
+    case "setDisplayCriteria":
+      handleSetDisplayCriteria(call: call, result: result)
+    case "setVisible":
+      handleSetVisible(call: call, result: result)
+    case "isInitialized":
+      result(playerCore?.isInitialized ?? false)
+    case "updateFrame":
+      handleUpdateFrame(result: result)
+    case "setLogLevel":
+      handleSetLogLevel(call: call, result: result)
+    default:
+      result(FlutterMethodNotImplemented)
     }
+  }
 
-    // MARK: - FlutterStreamHandler
+  // MARK: - PiP
 
-    func onListen(withArguments arguments: Any?, eventSink events: @escaping FlutterEventSink) -> FlutterError? {
-        self.eventSink = events
-        return nil
+  private func ensurePipController() -> MpvPipController? {
+    if let existing = pipController { return existing }
+    guard let layer = playerCore?.sampleBufferDisplayLayer else { return nil }
+    let controller = MpvPipController(sampleBufferDisplayLayer: layer)
+    controller.delegate = self
+    pipController = controller
+    return controller
+  }
+
+  private func registerSceneActivationObserver() {
+    guard !sceneActivationObserverRegistered else { return }
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(sceneDidActivate),
+      name: UIScene.didActivateNotification,
+      object: nil
+    )
+    sceneActivationObserverRegistered = true
+  }
+
+  private func unregisterSceneActivationObserver() {
+    guard sceneActivationObserverRegistered else { return }
+    NotificationCenter.default.removeObserver(
+      self, name: UIScene.didActivateNotification, object: nil)
+    sceneActivationObserverRegistered = false
+  }
+
+  private var isSceneActive: Bool {
+    #if os(iOS)
+      ExternalDisplayManager.hasActiveApplicationScene
+    #else
+      UIApplication.shared.connectedScenes.contains { $0.activationState == .foregroundActive }
+    #endif
+  }
+
+  private func restoreInlinePlayerAfterPip() {
+    guard pendingInlineRestoreAfterPip,
+      let playerCore = playerCore,
+      !playerCore.isPipActive,
+      !playerCore.isPipStarting
+    else { return }
+
+    print("[MpvPlayerPlugin] Restoring inline player after PiP")
+    playerCore.setVisible(true)
+    playerCore.updateFrame()
+    if playerCore.isPaused {
+      playerCore.forceDraw()
     }
+    pendingInlineRestoreAfterPip = false
+  }
 
-    func onCancel(withArguments arguments: Any?) -> FlutterError? {
-        self.eventSink = nil
-        return nil
-    }
-
-    // MARK: - FlutterPlugin Method Handler
-
-    func handle(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
-        switch call.method {
-        case "initialize":
-            handleInitialize(result: result)
-        case "dispose":
-            handleDispose(result: result)
-        case "setProperty":
-            handleSetProperty(call: call, result: result)
-        case "getProperty":
-            handleGetProperty(call: call, result: result)
-        case "observeProperty":
-            handleObserveProperty(call: call, result: result)
-        case "command":
-            handleCommand(call: call, result: result)
-        case "setVisible":
-            handleSetVisible(call: call, result: result)
-        case "isInitialized":
-            result(playerCore?.isInitialized ?? false)
-        case "updateFrame":
-            handleUpdateFrame(result: result)
-        case "setLogLevel":
-            handleSetLogLevel(call: call, result: result)
-        default:
-            result(FlutterMethodNotImplemented)
-        }
-    }
-
-    // MARK: - PiP
-
-    private func ensurePipController() -> MpvPipController {
-        if let existing = pipController { return existing }
-        let controller = MpvPipController()
-        controller.delegate = self
-        pipController = controller
-        return controller
-    }
-
-    private func registerSceneActivationObserver() {
-        guard !sceneActivationObserverRegistered else { return }
-        NotificationCenter.default.addObserver(
-            self,
-            selector: #selector(sceneDidActivate),
-            name: UIScene.didActivateNotification,
-            object: nil
-        )
-        sceneActivationObserverRegistered = true
-    }
-
-    private func unregisterSceneActivationObserver() {
-        guard sceneActivationObserverRegistered else { return }
-        NotificationCenter.default.removeObserver(self, name: UIScene.didActivateNotification, object: nil)
-        sceneActivationObserverRegistered = false
-    }
-
-    private var isSceneActive: Bool {
-        UIApplication.shared.connectedScenes.contains { $0.activationState == .foregroundActive }
-    }
-
-    private func restoreInlinePlayerAfterPip() {
-        guard pendingInlineRestoreAfterPip,
-              let playerCore = playerCore,
-              !playerCore.isPipActive,
-              !playerCore.isPipStarting else { return }
-
-        print("[MpvPlayerPlugin] Restoring inline player after PiP")
-        playerCore.setVisible(true)
-        playerCore.updateFrame()
-        if playerCore.isPaused {
-            playerCore.forceDraw()
-        }
-        pendingInlineRestoreAfterPip = false
-    }
-
-    private func handlePipCall(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
-        switch call.method {
-        case "isSupported":
-            result(MpvPipController.isSupported)
-        case "enter":
-            enterPip(manual: true, result: result)
-        case "setAutoPipReady":
-            if let args = call.arguments as? [String: Any], let ready = args["ready"] as? Bool {
-                autoPipEnabled = ready
-                if ready {
-                    let pip = ensurePipController()
-                    pip.setAutoStart(true)
-                    // Warm the layer so the system considers PiP possible
-                    if let pc = playerCore {
-                        pip.warmLayer(currentTime: pc.timePos, isPlaying: !pc.isPaused)
-                    }
-                } else {
-                    pipController?.setAutoStart(false)
-                }
+  private func handlePipCall(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
+    DispatchQueue.main.async { [weak self] in
+      guard let self = self else { result(nil); return }
+      switch call.method {
+      case "isSupported":
+        result(MpvPipController.isSupported)
+      case "enter":
+        self.enterPip(manual: true, result: result)
+      case "setAutoPipReady":
+        if let args = call.arguments as? [String: Any], let ready = args["ready"] as? Bool {
+          self.autoPipEnabled = ready
+          if ready {
+            guard let pip = self.ensurePipController() else {
+              result(nil)
+              return
             }
-            result(nil)
-        default:
-            result(FlutterMethodNotImplemented)
-        }
-    }
-
-    /// Switch to PiP VO and prepare the sample buffer layer for PiP display.
-    /// Returns the MpvPipController on success, nil on failure.
-    @discardableResult
-    private func switchToPipAndPrepare() -> MpvPipController? {
-        guard let playerCore = playerCore else { return nil }
-        let pip = ensurePipController()
-        guard playerCore.switchToPipVO(layerPtr: pip.layerPointer) else { return nil }
-        pendingInlineRestoreAfterPip = false
-        playerCore.isPipStarting = true
-        pip.pushBlankFrame()
-        pip.syncTimebase(currentTime: playerCore.timePos, isPlaying: !playerCore.isPaused)
-        pip.invalidatePlaybackState()
-        return pip
-    }
-
-    /// Manual PiP entry (button press). Auto-PiP is handled by the system via
-    /// canStartPictureInPictureAutomaticallyFromInline + pipWillStart delegate.
-    private func enterPip(manual: Bool, result: FlutterResult? = nil) {
-        guard MpvPipController.isSupported else {
-            result?(["success": false, "errorCode": "ios_version", "errorMessage": "Requires iOS 15.0+"])
-            return
-        }
-        guard playerCore != nil else {
-            result?(["success": false, "errorCode": "failed", "errorMessage": "Player not initialized"])
-            return
-        }
-        guard let pip = switchToPipAndPrepare() else {
-            result?(["success": false, "errorCode": "vo_switch_failed", "errorMessage": "Failed to switch VO"])
-            return
-        }
-
-        isManualPipRequest = manual
-        pip.startPip(waitForFrame: manual) { [weak self] started in
-            if started {
-                result?(["success": true])
-            } else {
-                self?.cleanupPip(notify: false)
-                result?(["success": false, "errorCode": "failed", "errorMessage": "PiP failed to start"])
+            pip.setAutoStart(true)
+            // Warm the layer so the system considers PiP possible
+            if let pc = self.playerCore {
+              pip.warmLayer(currentTime: pc.timePos, isPlaying: !pc.isPaused)
             }
+          } else {
+            self.pipController?.setAutoStart(false)
+          }
         }
-    }
-
-    /// Unified cleanup for all PiP exit paths
-    private func cleanupPip(notify: Bool, pause: Bool = false) {
-        playerCore?.isPipStarting = false
-        playerCore?.isPipActive = false
-        isManualPipRequest = false
-        stopPipTimebaseSync()
-        pipController?.flushLayer()
-        let restoredInlineVO = playerCore?.switchToGpuNextVO() ?? false
-        if pause { playerCore?.setProperty("pause", value: "yes") }
-        pendingInlineRestoreAfterPip = restoredInlineVO
-        if pendingInlineRestoreAfterPip {
-            if isSceneActive {
-                restoreInlinePlayerAfterPip()
-            } else {
-                print("[MpvPlayerPlugin] Deferring inline restore until scene activation")
-            }
-        }
-        if notify { pipChannel?.invokeMethod("onPipChanged", arguments: false) }
-    }
-
-    /// Scene became active — restore inline playback if needed and re-warm the
-    /// sample-buffer layer so future auto-PiP remains possible.
-    @objc private func sceneDidActivate() {
-        restoreInlinePlayerAfterPip()
-        if autoPipEnabled, let pip = pipController, let pc = playerCore, !pc.isPipActive {
-            pip.warmLayer(currentTime: pc.timePos, isPlaying: !pc.isPaused)
-        }
-    }
-
-    // MARK: - Timebase Sync
-
-    private func syncPipTimebase() {
-        guard let playerCore = playerCore, let pipController = pipController else { return }
-        pipController.syncTimebase(
-            currentTime: playerCore.timePos,
-            isPlaying: !playerCore.isPaused
-        )
-    }
-
-    private func startPipTimebaseSync() {
-        stopPipTimebaseSync()
-        pipTimebaseSyncTimer = Timer.scheduledTimer(withTimeInterval: 5.0, repeats: true) { [weak self] _ in
-            self?.syncPipTimebase()
-        }
-    }
-
-    private func stopPipTimebaseSync() {
-        pipTimebaseSyncTimer?.invalidate()
-        pipTimebaseSyncTimer = nil
-    }
-
-    // MARK: - Platform-Specific Method Handlers
-
-    private func handleInitialize(result: @escaping FlutterResult) {
-        DispatchQueue.main.async { [weak self] in
-            guard let self = self else {
-                result(FlutterError(code: "ERROR", message: "Plugin deallocated", details: nil))
-                return
-            }
-
-            if self.playerCore?.isInitialized == true {
-                self.registerSceneActivationObserver()
-                result(true)
-                return
-            }
-
-            guard let window = self.findKeyWindow() else {
-                result(FlutterError(code: "NO_WINDOW", message: "Could not find key window", details: nil))
-                return
-            }
-
-            let core = MpvPlayerCore()
-            core.delegate = self
-
-            guard core.initialize(in: window) else {
-                result(FlutterError(code: "MPV_INIT_FAILED", message: "Failed to initialize MPV", details: nil))
-                return
-            }
-
-            self.playerCore = core
-            self.registerSceneActivationObserver()
-            core.setVisible(false)
-            result(true)
-        }
-    }
-
-    private func handleDispose(result: @escaping FlutterResult) {
-        DispatchQueue.main.async { [weak self] in
-            guard let self = self else { result(nil); return }
-            self.pipController?.teardown()
-            self.pipController = nil
-            self.autoPipEnabled = false
-            self.pendingInlineRestoreAfterPip = false
-            self.unregisterSceneActivationObserver()
-            self.stopPipTimebaseSync()
-            self.playerCore?.dispose()
-            self.playerCore = nil
-            result(nil)
-        }
-    }
-
-    private func handleSetProperty(call: FlutterMethodCall, result: @escaping FlutterResult) {
-        guard let args = call.arguments as? [String: Any],
-              let name = args["name"] as? String,
-              let value = args["value"] as? String else {
-            result(FlutterError(code: "INVALID_ARGS", message: "Missing 'name' or 'value' argument", details: nil))
-            return
-        }
-
-        playerCore?.setProperty(name, value: value)
-
-        if name == "pause" {
-            pipController?.invalidatePlaybackState()
-            if playerCore?.isPipActive == true { syncPipTimebase() }
-        }
-
         result(nil)
+      default:
+        result(FlutterMethodNotImplemented)
+      }
+    }
+  }
+
+  /// Prepare the shared AVFoundation display layer for PiP display.
+  /// Returns the MpvPipController on success, nil on failure.
+  @discardableResult
+  private func preparePip() -> MpvPipController? {
+    guard let playerCore = playerCore else { return nil }
+    guard let pip = ensurePipController() else { return nil }
+    pendingInlineRestoreAfterPip = false
+    playerCore.setPipSubtitleCompositing(true)
+    playerCore.isPipStarting = true
+    pip.syncTimebase(currentTime: playerCore.timePos, isPlaying: !playerCore.isPaused)
+    pip.invalidatePlaybackState()
+    return pip
+  }
+
+  /// Manual PiP entry (button press). Auto-PiP is handled by the system via
+  /// canStartPictureInPictureAutomaticallyFromInline + pipWillStart delegate.
+  private func enterPip(manual: Bool, result: FlutterResult? = nil) {
+    guard MpvPipController.isSupported else {
+      result?([
+        "success": false, "errorCode": "ios_version", "errorMessage": "Requires iOS 15.0+",
+      ])
+      return
+    }
+    guard playerCore != nil else {
+      result?([
+        "success": false, "errorCode": "failed", "errorMessage": "Player not initialized",
+      ])
+      return
+    }
+    guard let pip = preparePip() else {
+      result?([
+        "success": false, "errorCode": "pip_prepare_failed",
+        "errorMessage": "Failed to prepare PiP",
+      ])
+      return
     }
 
-    // MARK: - Helpers
+    isManualPipRequest = manual
+    pip.startPip(waitForFrame: manual) { [weak self] started in
+      if started {
+        result?(["success": true])
+      } else {
+        self?.cleanupPip(notify: false)
+        result?([
+          "success": false, "errorCode": "failed", "errorMessage": "PiP failed to start",
+        ])
+      }
+    }
+  }
 
-    private func findKeyWindow() -> UIWindow? {
-        guard let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene,
-              let window = windowScene.windows.first(where: { $0.isKeyWindow }) else {
-            return nil
+  /// Unified cleanup for all PiP exit paths
+  private func cleanupPip(notify: Bool, pause: Bool = false) {
+    playerCore?.setPipSubtitleCompositing(false)
+    playerCore?.isPipStarting = false
+    playerCore?.isPipActive = false
+    isManualPipRequest = false
+    stopPipTimebaseSync()
+    if pause {
+      playerCore?.setPropertyAsync("pause", value: "yes") { [weak self] _ in
+        self?.pipController?.invalidatePlaybackState()
+        self?.syncPipTimebase()
+      }
+    }
+    pendingInlineRestoreAfterPip = true
+    if pendingInlineRestoreAfterPip {
+      if isSceneActive {
+        restoreInlinePlayerAfterPip()
+      } else {
+        print("[MpvPlayerPlugin] Deferring inline restore until scene activation")
+      }
+    }
+    if notify { pipChannel?.invokeMethod("onPipChanged", arguments: false) }
+  }
+
+  /// Scene became active — restore inline playback if needed and re-warm the
+  /// sample-buffer layer so future auto-PiP remains possible.
+  @objc private func sceneDidActivate() {
+    restoreInlinePlayerAfterPip()
+    if autoPipEnabled, let pip = pipController, let pc = playerCore, !pc.isPipActive {
+      pip.warmLayer(currentTime: pc.timePos, isPlaying: !pc.isPaused)
+    }
+  }
+
+  // MARK: - Timebase Sync
+
+  private func syncPipTimebase() {
+    guard let playerCore = playerCore, let pipController = pipController else { return }
+    pipController.syncTimebase(
+      currentTime: playerCore.timePos,
+      isPlaying: !playerCore.isPaused
+    )
+  }
+
+  private func startPipTimebaseSync() {
+    stopPipTimebaseSync()
+    pipTimebaseSyncTimer = Timer.scheduledTimer(withTimeInterval: 5.0, repeats: true) {
+      [weak self] _ in
+      self?.syncPipTimebase()
+    }
+  }
+
+  private func stopPipTimebaseSync() {
+    pipTimebaseSyncTimer?.invalidate()
+    pipTimebaseSyncTimer = nil
+  }
+
+  // MARK: - Platform-Specific Method Handlers
+
+  private func handleInitialize(result: @escaping FlutterResult) {
+    DispatchQueue.main.async { [weak self] in
+      guard let self = self else {
+        result(FlutterError(code: "ERROR", message: "Plugin deallocated", details: nil))
+        return
+      }
+
+      if self.playerCore?.isInitialized == true {
+        self.registerSceneActivationObserver()
+        result(true)
+        return
+      }
+
+      guard let window = self.findKeyWindow() else {
+        result(
+          FlutterError(
+            code: "NO_WINDOW", message: "Could not find key window", details: nil))
+        return
+      }
+
+      let core = MpvPlayerCore()
+      core.delegate = self
+
+      guard core.initialize(in: window) else {
+        result(
+          FlutterError(
+            code: "MPV_INIT_FAILED", message: "Failed to initialize MPV", details: nil))
+        return
+      }
+
+      self.playerCore = core
+      self.registerSceneActivationObserver()
+      core.setVisible(false)
+      result(true)
+    }
+  }
+
+  private func handleDispose(call: FlutterMethodCall, result: @escaping FlutterResult) {
+    let args = call.arguments as? [String: Any]
+    let preserveDisplayMode = args?["preserveDisplayMode"] as? Bool ?? false
+    DispatchQueue.main.async { [weak self] in
+      guard let self = self else { result(nil); return }
+      NSLog("[MpvPlayerPlugin] dispose preserveDisplayMode=%@", preserveDisplayMode.description)
+      self.pipController?.teardown()
+      self.pipController = nil
+      self.autoPipEnabled = false
+      self.pendingInlineRestoreAfterPip = false
+      self.unregisterSceneActivationObserver()
+      self.stopPipTimebaseSync()
+      self.playerCore?.dispose(preserveDisplayCriteria: preserveDisplayMode)
+      self.playerCore = nil
+      result(nil)
+    }
+  }
+
+  func didSetPauseProperty(value: String) {
+    pipController?.invalidatePlaybackState()
+    if playerCore?.isPipActive == true { syncPipTimebase() }
+  }
+
+  private func handleSetDisplayCriteria(call: FlutterMethodCall, result: @escaping FlutterResult) {
+    guard let args = call.arguments as? [String: Any] else {
+      result(FlutterError(code: "INVALID_ARGS", message: "Missing arguments", details: nil))
+      return
+    }
+
+    guard let core = playerCore else {
+      result(nil)
+      return
+    }
+
+    let extraDelayMs = int64Value(args["extraDelayMs"]).map { Int(clamping: $0) } ?? 0
+    guard let raw = args["criteria"] as? [String: Any] else {
+      DispatchQueue.main.async {
+        core.setServerDisplayCriteriaForPlayback(nil, extraDelayMs: extraDelayMs) {
+          result(nil)
         }
-        return window
+      }
+      return
     }
+
+    let criteria = ServerDisplayCriteria(
+      doviProfile: int64Value(raw["doviProfile"]) ?? 0,
+      doviLevel: int64Value(raw["doviLevel"]) ?? 0,
+      doviCompatibilityId: int64Value(raw["doviCompatibilityId"]),
+      fps: doubleValue(raw["fps"]) ?? 0,
+      width: Int32(truncatingIfNeeded: int64Value(raw["width"]) ?? 0),
+      height: Int32(truncatingIfNeeded: int64Value(raw["height"]) ?? 0),
+      gamma: stringValue(raw["transfer"]),
+      primaries: stringValue(raw["primaries"]),
+      colorMatrix: stringValue(raw["matrix"])
+    )
+    DispatchQueue.main.async {
+      core.setServerDisplayCriteriaForPlayback(criteria, extraDelayMs: extraDelayMs) {
+        result(nil)
+      }
+    }
+  }
+
+  private func int64Value(_ value: Any?) -> Int64? {
+    switch value {
+    case let value as Int64:
+      return value
+    case let value as Int:
+      return Int64(value)
+    case let value as NSNumber:
+      return value.int64Value
+    case let value as String:
+      return Int64(value)
+    default:
+      return nil
+    }
+  }
+
+  private func doubleValue(_ value: Any?) -> Double? {
+    switch value {
+    case let value as Double:
+      return value
+    case let value as NSNumber:
+      return value.doubleValue
+    case let value as String:
+      return Double(value)
+    default:
+      return nil
+    }
+  }
+
+  private func stringValue(_ value: Any?) -> String? {
+    guard let value else { return nil }
+    let string = String(describing: value).trimmingCharacters(in: .whitespacesAndNewlines)
+    return string.isEmpty ? nil : string
+  }
+
+  // MARK: - Helpers
+
+  private func findKeyWindow() -> UIWindow? {
+    #if os(iOS)
+      return ExternalDisplayManager.mainApplicationWindow()
+    #else
+      let scenes = UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }
+
+      for scene in scenes {
+        if let window = scene.windows.first(where: { $0.isKeyWindow }) {
+          return window
+        }
+      }
+
+      for scene in scenes {
+        if let window = scene.windows.first(where: { !$0.isHidden }) {
+          return window
+        }
+      }
+
+      return scenes.first?.windows.first
+    #endif
+  }
 }
 
 // MARK: - MpvPipDelegate
 
 extension MpvPlayerPlugin: MpvPipDelegate {
 
-    func pipWillStart() {
-        // If PiP was system-initiated (not via our enterPip), switch VO now
-        guard let playerCore = playerCore, !playerCore.isPipStarting else { return }
-        print("[MpvPlayerPlugin] System-initiated PiP detected, switching VO")
-        if switchToPipAndPrepare() == nil {
-            print("[MpvPlayerPlugin] VO switch failed for system-initiated PiP")
-            pipController?.stopPip()
-        }
+  func pipWillStart() {
+    // If PiP was system-initiated (not via our enterPip), prepare the shared layer now.
+    guard let playerCore = playerCore, !playerCore.isPipStarting else { return }
+    print("[MpvPlayerPlugin] System-initiated PiP detected, preparing shared layer")
+    if preparePip() == nil {
+      print("[MpvPlayerPlugin] PiP preparation failed for system-initiated PiP")
+      pipController?.stopPip()
     }
+  }
 
-    func pipDidStart() {
-        playerCore?.isPipStarting = false
-        playerCore?.isPipActive = true
-        pendingInlineRestoreAfterPip = false
-        pipChannel?.invokeMethod("onPipChanged", arguments: true)
-        syncPipTimebase()
-        startPipTimebaseSync()
+  func pipDidStart() {
+    playerCore?.isPipStarting = false
+    playerCore?.isPipActive = true
+    pendingInlineRestoreAfterPip = false
+    pipChannel?.invokeMethod("onPipChanged", arguments: true)
+    syncPipTimebase()
+    startPipTimebaseSync()
 
-        if isManualPipRequest {
-            isManualPipRequest = false
-            UIControl().sendAction(#selector(URLSessionTask.suspend), to: UIApplication.shared, for: nil)
-        }
+    if isManualPipRequest {
+      isManualPipRequest = false
+      UIControl().sendAction(
+        #selector(URLSessionTask.suspend), to: UIApplication.shared, for: nil)
     }
+  }
 
-    func pipDidStop(restored: Bool) {
-        cleanupPip(notify: true, pause: !restored)
+  func pipDidStop(restored: Bool) {
+    cleanupPip(notify: true, pause: !restored)
+  }
+
+  func pipDidFailToStart(error: Error?) {
+    cleanupPip(notify: true)
+  }
+
+  func pipSetPlaying(_ playing: Bool) {
+    playerCore?.setPropertyAsync("pause", value: playing ? "no" : "yes") { [weak self] _ in
+      self?.pipController?.invalidatePlaybackState()
+      self?.syncPipTimebase()
     }
+  }
 
-    func pipDidFailToStart(error: Error?) {
-        cleanupPip(notify: true)
+  func pipSkip(byInterval seconds: Double, completion: @escaping () -> Void) {
+    guard let playerCore = playerCore else {
+      completion()
+      return
     }
-
-    func pipSetPlaying(_ playing: Bool) {
-        playerCore?.setProperty("pause", value: playing ? "no" : "yes")
-        pipController?.invalidatePlaybackState()
-        syncPipTimebase()
+    let newTime = max(0, playerCore.timePos + seconds)
+    playerCore.commandAsync(["seek", String(newTime), "absolute"]) { [weak self] _ in
+      DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
+        self?.pipController?.invalidatePlaybackState()
+        completion()
+      }
     }
+  }
 
-    func pipSkip(byInterval seconds: Double) {
-        guard let playerCore = playerCore else { return }
-        let newTime = max(0, playerCore.timePos + seconds)
-        playerCore.command(["seek", String(newTime), "absolute"])
-        DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) { [weak self] in
-            self?.syncPipTimebase()
-            self?.pipController?.invalidatePlaybackState()
-        }
-    }
-
-    var isPipPlaying: Bool { !(playerCore?.isPaused ?? true) }
-    var pipDuration: Double { playerCore?.duration ?? 0 }
+  var isPipPlaying: Bool { !(playerCore?.isPaused ?? true) }
+  var pipDuration: Double { playerCore?.duration ?? 0 }
 }

ios/fastlane/Fastfile

@@ -1,15 +1,23 @@
 require 'dotenv/load'
-Dotenv.load("../../.env")
+require 'shellwords'
+
+PROJECT_ROOT = File.expand_path("../..", __dir__)
+PROJECT_ROOT_ARG = Shellwords.escape(PROJECT_ROOT)
+
+Dotenv.load(File.join(PROJECT_ROOT, ".env"))
 
 default_platform(:ios)
 
 platform :ios do
   desc "Build and deploy to App Store"
   lane :deploy_appstore do
-    git_commit = `git rev-parse --short HEAD`.strip
+    git_commit = `git -C #{PROJECT_ROOT_ARG} rev-parse --short HEAD`.strip
 
     # Build the Flutter app
-    sh("cd #{ENV['PWD']}/.. && flutter build ipa --dart-define=ENABLE_IN_APP_REVIEW=true --dart-define=ENABLE_SENTRY=true --dart-define=GIT_COMMIT=#{git_commit}")
+    sh("cd #{PROJECT_ROOT_ARG} && flutter build ipa --dart-define=ENABLE_SENTRY=true --dart-define=GIT_COMMIT=#{git_commit} --dart-define=SENTRY_ENVIRONMENT=app-store --dart-define=SENTRY_DIST=app-store --split-debug-info=debug-info/ios")
+
+    # Upload debug symbols
+    sh("cd #{PROJECT_ROOT_ARG} && SENTRY_DIST=app-store ./scripts/upload-symbols.sh ios")
 
     # Upload to App Store
     upload_to_app_store(

lib/connection/connection.dart

@@ -0,0 +1,365 @@
+import '../media/media_backend.dart';
+import '../models/plex/plex_home_user.dart';
+import '../services/plex_auth_service.dart';
+
+/// Identifier of a backend kind a [Connection] points at. Lighter-weight than
+/// [MediaBackend] for places that only care about persistence/auth shape
+/// (e.g. database column values).
+enum ConnectionKind {
+  plex,
+  jellyfin;
+
+  String get id => switch (this) {
+    ConnectionKind.plex => 'plex',
+    ConnectionKind.jellyfin => 'jellyfin',
+  };
+
+  static ConnectionKind fromId(String id) => switch (id) {
+    'plex' => ConnectionKind.plex,
+    'jellyfin' => ConnectionKind.jellyfin,
+    _ => throw ArgumentError('Unknown ConnectionKind id: $id'),
+  };
+
+  MediaBackend get backend => switch (this) {
+    ConnectionKind.plex => MediaBackend.plex,
+    ConnectionKind.jellyfin => MediaBackend.jellyfin,
+  };
+}
+
+/// Health snapshot for a connection. Updated by the orchestrator each time a
+/// session is established or refreshed.
+enum ConnectionStatus { unknown, online, offline, authError, disabled }
+
+/// A media server connection — a unit of authentication the user added.
+///
+/// A `PlexAccountConnection` carries one Plex account + its discovered servers + an
+/// optional active Home profile. A `JellyfinConnection` is a single server +
+/// user. Most users only ever add one connection.
+sealed class Connection {
+  String get id;
+  ConnectionKind get kind;
+  String get displayName;
+  ConnectionStatus get status;
+  DateTime get createdAt;
+  DateTime? get lastAuthenticatedAt;
+
+  /// Backend kind as a [MediaBackend] — for UI that branches on backend
+  /// (badges, etc.). Just a passthrough to [kind.backend].
+  MediaBackend get backend => kind.backend;
+
+  /// Primary label shown in connection-list UIs. Plex shows the active
+  /// profile/account name; Jellyfin shows the server name.
+  String get displayLabel;
+
+  /// Secondary line shown beneath [displayLabel] in connection-list UIs.
+  /// Plex: server count; Jellyfin: `userName · baseUrl`. May be null when
+  /// no useful subtitle exists.
+  String? get displaySubtitle;
+
+  /// Backend-specific config payload, persisted as JSON. Each subclass
+  /// defines the schema.
+  Map<String, Object?> toConfigJson();
+}
+
+/// A Plex account connection.
+///
+/// Fields here mirror what [PlexAuthService] gathers during PIN OAuth: an
+/// account token (long-lived), the per-device client identifier (so plex.tv
+/// doesn't see a "new device" each launch), and the optional Home user the
+/// user has switched into.
+class PlexAccountConnection extends Connection {
+  @override
+  final String id;
+
+  @override
+  final ConnectionStatus status;
+
+  @override
+  final DateTime createdAt;
+
+  @override
+  final DateTime? lastAuthenticatedAt;
+
+  /// plex.tv account access token.
+  final String accountToken;
+
+  /// Per-device client identifier. Stable across launches.
+  final String clientIdentifier;
+
+  /// Display name shown for this connection (typically the Plex account email
+  /// or username, fallback "Plex").
+  final String accountLabel;
+
+  /// Active Home user, or `null` for the main account.
+  final PlexHomeUser? activeProfile;
+
+  /// Servers discovered for this account (cached). Populated by the auth
+  /// flow and refreshed periodically.
+  final List<PlexServer> servers;
+
+  PlexAccountConnection({
+    required this.id,
+    required this.accountToken,
+    required this.clientIdentifier,
+    required this.accountLabel,
+    this.activeProfile,
+    this.servers = const [],
+    this.status = ConnectionStatus.unknown,
+    required this.createdAt,
+    this.lastAuthenticatedAt,
+  });
+
+  @override
+  ConnectionKind get kind => ConnectionKind.plex;
+
+  @override
+  String get displayName => activeProfile != null && activeProfile!.title.isNotEmpty
+      ? '${activeProfile!.title} · $accountLabel'
+      : accountLabel;
+
+  @override
+  String get displayLabel => displayName;
+
+  @override
+  String? get displaySubtitle => servers.length == 1 ? '1 Plex server' : '${servers.length} Plex servers';
+
+  PlexAccountConnection copyWith({
+    String? id,
+    String? accountToken,
+    String? clientIdentifier,
+    String? accountLabel,
+    PlexHomeUser? activeProfile,
+    bool clearActiveProfile = false,
+    List<PlexServer>? servers,
+    ConnectionStatus? status,
+    DateTime? createdAt,
+    DateTime? lastAuthenticatedAt,
+  }) {
+    return PlexAccountConnection(
+      id: id ?? this.id,
+      accountToken: accountToken ?? this.accountToken,
+      clientIdentifier: clientIdentifier ?? this.clientIdentifier,
+      accountLabel: accountLabel ?? this.accountLabel,
+      activeProfile: clearActiveProfile ? null : (activeProfile ?? this.activeProfile),
+      servers: servers ?? this.servers,
+      status: status ?? this.status,
+      createdAt: createdAt ?? this.createdAt,
+      lastAuthenticatedAt: lastAuthenticatedAt ?? this.lastAuthenticatedAt,
+    );
+  }
+
+  @override
+  Map<String, Object?> toConfigJson() {
+    return {
+      'accountToken': accountToken,
+      'clientIdentifier': clientIdentifier,
+      'accountLabel': accountLabel,
+      'activeProfile': activeProfile?.toJson(),
+      'servers': servers.map((s) => s.toJson()).toList(),
+    };
+  }
+
+  factory PlexAccountConnection.fromConfigJson({
+    required String id,
+    required Map<String, Object?> json,
+    required ConnectionStatus status,
+    required DateTime createdAt,
+    DateTime? lastAuthenticatedAt,
+  }) {
+    final profileJson = json['activeProfile'];
+    final activeProfile = profileJson is Map<String, dynamic> ? PlexHomeUser.fromJson(profileJson) : null;
+    final serversJson = json['servers'];
+    final servers = serversJson is List
+        ? serversJson.whereType<Map<String, dynamic>>().map(PlexServer.fromJson).toList()
+        : <PlexServer>[];
+    return PlexAccountConnection(
+      id: id,
+      accountToken: json['accountToken'] as String? ?? '',
+      clientIdentifier: json['clientIdentifier'] as String? ?? '',
+      accountLabel: json['accountLabel'] as String? ?? 'Plex',
+      activeProfile: activeProfile,
+      servers: servers,
+      status: status,
+      createdAt: createdAt,
+      lastAuthenticatedAt: lastAuthenticatedAt,
+    );
+  }
+}
+
+/// A single-server Jellyfin connection.
+class JellyfinConnection extends Connection {
+  @override
+  final String id;
+
+  @override
+  final ConnectionStatus status;
+
+  @override
+  final DateTime createdAt;
+
+  @override
+  final DateTime? lastAuthenticatedAt;
+
+  /// Active server base URL, no trailing slash. e.g. `https://jellyfin.home.lan`.
+  final String baseUrl;
+
+  /// Candidate server URLs for this Jellyfin server, with [baseUrl] first.
+  /// Existing installs only have [baseUrl]; deserialization backfills this.
+  final List<String> baseUrls;
+
+  /// Server's reported name (System/Info).
+  final String serverName;
+
+  /// Server's machine identifier (System/Info `Id`).
+  final String serverMachineId;
+
+  /// Authenticated Jellyfin user id (UUID).
+  final String userId;
+
+  /// Authenticated user's display name.
+  final String userName;
+
+  /// Long-lived access token from `/Users/AuthenticateByName`.
+  final String accessToken;
+
+  /// Per-device client identifier (same value sent in the
+  /// `Authorization: MediaBrowser DeviceId="..."` header).
+  final String deviceId;
+
+  /// Whether this user is a Jellyfin admin (`/Users/{id}.Policy.IsAdministrator`).
+  /// Captured at auth time so the UI can gate admin-only entries (delete,
+  /// match/unmatch, edit metadata) without an extra round-trip.
+  final bool isAdministrator;
+
+  JellyfinConnection({
+    required this.id,
+    required this.baseUrl,
+    List<String>? baseUrls,
+    required this.serverName,
+    required this.serverMachineId,
+    required this.userId,
+    required this.userName,
+    required this.accessToken,
+    required this.deviceId,
+    this.isAdministrator = false,
+    this.status = ConnectionStatus.unknown,
+    required this.createdAt,
+    this.lastAuthenticatedAt,
+  }) : baseUrls = _normalizeBaseUrls(baseUrl, baseUrls);
+
+  @override
+  ConnectionKind get kind => ConnectionKind.jellyfin;
+
+  @override
+  String get displayName => '$userName · $serverName';
+
+  @override
+  String get displayLabel => serverName;
+
+  @override
+  String? get displaySubtitle {
+    final extraCount = baseUrls.length - 1;
+    final suffix = extraCount > 0 ? ' +$extraCount' : '';
+    return '$userName · ${_truncateUrl(baseUrl)}$suffix';
+  }
+
+  static String _truncateUrl(String url) {
+    if (url.length <= 40) return url;
+    return '${url.substring(0, 37)}…';
+  }
+
+  static List<String> _normalizeBaseUrls(String activeBaseUrl, List<String>? urls) {
+    final result = <String>[];
+    final seen = <String>{};
+
+    void add(String url) {
+      final trimmed = url.trim();
+      if (trimmed.isEmpty || !seen.add(trimmed)) return;
+      result.add(trimmed);
+    }
+
+    add(activeBaseUrl);
+    for (final url in urls ?? const <String>[]) {
+      add(url);
+    }
+    return List.unmodifiable(result);
+  }
+
+  JellyfinConnection copyWith({
+    String? id,
+    String? baseUrl,
+    List<String>? baseUrls,
+    String? serverName,
+    String? serverMachineId,
+    String? userId,
+    String? userName,
+    String? accessToken,
+    String? deviceId,
+    bool? isAdministrator,
+    ConnectionStatus? status,
+    DateTime? createdAt,
+    DateTime? lastAuthenticatedAt,
+  }) {
+    final nextBaseUrl = baseUrl ?? this.baseUrl;
+    return JellyfinConnection(
+      id: id ?? this.id,
+      baseUrl: nextBaseUrl,
+      baseUrls: baseUrls ?? this.baseUrls,
+      serverName: serverName ?? this.serverName,
+      serverMachineId: serverMachineId ?? this.serverMachineId,
+      userId: userId ?? this.userId,
+      userName: userName ?? this.userName,
+      accessToken: accessToken ?? this.accessToken,
+      deviceId: deviceId ?? this.deviceId,
+      isAdministrator: isAdministrator ?? this.isAdministrator,
+      status: status ?? this.status,
+      createdAt: createdAt ?? this.createdAt,
+      lastAuthenticatedAt: lastAuthenticatedAt ?? this.lastAuthenticatedAt,
+    );
+  }
+
+  @override
+  Map<String, Object?> toConfigJson() {
+    return {
+      'baseUrl': baseUrl,
+      'baseUrls': baseUrls,
+      'serverName': serverName,
+      'serverMachineId': serverMachineId,
+      'userId': userId,
+      'userName': userName,
+      'accessToken': accessToken,
+      'deviceId': deviceId,
+      'isAdministrator': isAdministrator,
+    };
+  }
+
+  factory JellyfinConnection.fromConfigJson({
+    required String id,
+    required Map<String, Object?> json,
+    required ConnectionStatus status,
+    required DateTime createdAt,
+    DateTime? lastAuthenticatedAt,
+  }) {
+    final rawBaseUrls = json['baseUrls'];
+    final baseUrls = rawBaseUrls is List ? rawBaseUrls.whereType<String>().toList(growable: false) : const <String>[];
+    final rawBaseUrl = json['baseUrl'] as String?;
+    final baseUrl = rawBaseUrl != null && rawBaseUrl.isNotEmpty
+        ? rawBaseUrl
+        : (baseUrls.isNotEmpty ? baseUrls.first : '');
+    return JellyfinConnection(
+      id: id,
+      baseUrl: baseUrl,
+      baseUrls: baseUrls,
+      serverName: json['serverName'] as String? ?? 'Jellyfin',
+      serverMachineId: json['serverMachineId'] as String? ?? '',
+      userId: json['userId'] as String? ?? '',
+      userName: json['userName'] as String? ?? '',
+      accessToken: json['accessToken'] as String? ?? '',
+      deviceId: json['deviceId'] as String? ?? '',
+      isAdministrator: json['isAdministrator'] as bool? ?? false,
+      status: status,
+      createdAt: createdAt,
+      lastAuthenticatedAt: lastAuthenticatedAt,
+    );
+  }
+}

lib/connection/connection_auth_service.dart

@@ -0,0 +1,20 @@
+import 'connection.dart';
+
+/// Backend-neutral auth service interface. Each backend's implementation
+/// (`PlexConnectionAuthService`, `JellyfinConnectionAuthService`) drives its
+/// own UX (PIN flow vs. password) but produces the same opaque
+/// [Connection] record at the end.
+abstract class ConnectionAuthService {
+  /// Best-effort check that an existing token still works. Returns false on
+  /// 401/403; throws on transport failures the caller should retry.
+  Future<bool> validate(Connection connection);
+
+  /// Refresh whatever side-channel state belongs to a connection — for Plex
+  /// that's the discovered server list and Home users; for Jellyfin it's a
+  /// no-op once auth has succeeded. Returns the updated connection.
+  Future<Connection> refresh(Connection connection);
+
+  /// Revoke the token server-side and forget local credentials. The caller
+  /// is responsible for removing the row from [ConnectionRegistry].
+  Future<void> signOut(Connection connection);
+}

lib/connection/connection_bootstrap.dart

@@ -0,0 +1,304 @@
+import 'dart:convert';
+
+import '../models/plex/plex_home.dart';
+import '../models/plex/plex_home_user.dart';
+import '../profiles/profile.dart';
+import '../profiles/profile_registry.dart';
+import '../services/plex_auth_service.dart';
+import '../services/server_registry.dart';
+import '../services/storage_service.dart';
+import '../utils/app_logger.dart';
+import 'connection.dart';
+import 'connection_registry.dart';
+
+/// One-shot helpers that bridge between the legacy single-Plex-account
+/// SharedPreferences state (`StorageService.plexToken` +
+/// `currentUserUUID` + `homeUsersCache` + `ServerRegistry.getServers()`)
+/// and the new [ConnectionRegistry] world.
+///
+/// Plex Home users are NOT persisted here — the bootstrap copies the
+/// legacy `homeUsersCache` into the per-connection
+/// `plex_home_users_{connectionId}` SharedPreferences slot so
+/// [PlexHomeService] picks it up on cold start.
+class ConnectionBootstrap {
+  ConnectionBootstrap({
+    required this.storage,
+    required this.connectionRegistry,
+    required this.serverRegistry,
+    required this.profileRegistry,
+    Future<List<PlexHomeUser>> Function(String accountToken)? plexHomeUserFetcher,
+    Future<Map<String, dynamic>> Function(String accountToken)? plexUserInfoFetcher,
+  }) : _plexHomeUserFetcher = plexHomeUserFetcher ?? _fetchPlexHomeUsers,
+       _plexUserInfoFetcher = plexUserInfoFetcher ?? _fetchPlexUserInfo;
+
+  final StorageService storage;
+  final ConnectionRegistry connectionRegistry;
+  final ServerRegistry serverRegistry;
+  final ProfileRegistry profileRegistry;
+  final Future<List<PlexHomeUser>> Function(String accountToken) _plexHomeUserFetcher;
+  final Future<Map<String, dynamic>> Function(String accountToken) _plexUserInfoFetcher;
+
+  static const String _keyProfileMigrationV1Done = 'profile_migration_v1_done';
+
+  /// Run all idempotent boot-time migrations. Best-effort — errors are
+  /// logged but never thrown.
+  Future<void> run() async {
+    await seedFromDevTokenDefine();
+    final hadLegacyPlexToken = (storage.getPlexToken() ?? '').isNotEmpty;
+    final hadLegacyProfileState = _hasLegacyProfileState();
+    final migratedAccount = await migrateLegacyPlexAccount();
+    final account = await _firstPlexAccount(migratedAccount);
+    final alreadyMigrated = storage.prefs.getBool(_keyProfileMigrationV1Done) ?? false;
+    if (!alreadyMigrated) {
+      if (account == null && (hadLegacyPlexToken || hadLegacyProfileState)) {
+        appLogger.w('Migration: legacy profile state present but Plex account was not migrated; will retry later');
+        return;
+      }
+      // Drop any plex_home rows left over from the pre-refactor data
+      // model — Plex Home users are now fetched live, never persisted.
+      await profileRegistry.dropAllPlexHomeRows();
+      if (account != null) {
+        final prepared = await _preparePlexVirtualProfile(account);
+        if (!prepared) {
+          if (migratedAccount != null && hadLegacyPlexToken) {
+            await connectionRegistry.remove(migratedAccount.id);
+          }
+          appLogger.w('Migration: could not hydrate Plex Home profiles for ${account.id}; will retry later');
+          return;
+        }
+      }
+      if (hadLegacyPlexToken) {
+        await storage.clearLegacyPlexToken();
+      }
+      await storage.clearServersList();
+      await storage.prefs.setBool(_keyProfileMigrationV1Done, true);
+    } else {
+      await storage.clearServersList();
+      await _recoverLegacyProfilePromotionIfNeeded(account);
+      await _migrateLegacyPlexHomeUsersCacheForExistingAccount(account);
+    }
+  }
+
+  bool _hasLegacyProfileState() {
+    return (storage.getCurrentUserUUID() ?? '').isNotEmpty ||
+        (storage.prefs.getString('home_users_cache') ?? '').isNotEmpty;
+  }
+
+  /// Screenshot automation injects a Plex token via the `PLEX_TOKEN`
+  /// dart-define so the app boots already-signed-in. Inserts a
+  /// [PlexAccountConnection] directly when the env var is non-empty AND
+  /// the registry doesn't already have a Plex account, fetching the user
+  /// info + servers like the auth screen does. No-op in normal builds.
+  Future<void> seedFromDevTokenDefine() async {
+    const devToken = String.fromEnvironment('PLEX_TOKEN');
+    if (devToken.isEmpty) return;
+    final existing = await connectionRegistry.list();
+    if (existing.whereType<PlexAccountConnection>().isNotEmpty) return;
+
+    try {
+      final auth = await PlexAuthService.create();
+      try {
+        final info = await auth.getUserInfo(devToken);
+        final servers = await auth.fetchServers(devToken);
+        final clientId = await storage.getOrCreateClientIdentifier();
+        final conn = PlexAccountConnection(
+          id: 'plex.$clientId',
+          accountToken: devToken,
+          clientIdentifier: clientId,
+          accountLabel: (info['username'] as String?) ?? (info['email'] as String?) ?? 'Plex',
+          servers: servers,
+          createdAt: DateTime.now(),
+          lastAuthenticatedAt: DateTime.now(),
+        );
+        await connectionRegistry.upsert(conn);
+        appLogger.i('Seeded Plex account from PLEX_TOKEN dart-define as ${conn.id}');
+      } finally {
+        auth.dispose();
+      }
+    } catch (e, st) {
+      appLogger.w('PLEX_TOKEN seed failed', error: e, stackTrace: st);
+    }
+  }
+
+  /// If a legacy Plex token sits in [StorageService] without a corresponding
+  /// row in [ConnectionRegistry], wrap it as a [PlexAccountConnection] and
+  /// insert. Best-effort: errors are logged but never thrown.
+  Future<PlexAccountConnection?> migrateLegacyPlexAccount() async {
+    final token = storage.getPlexToken();
+    if (token == null || token.isEmpty) return null;
+
+    final existing = await connectionRegistry.list();
+    final alreadyMigrated = existing
+        .whereType<PlexAccountConnection>()
+        .where((c) => c.accountToken == token)
+        .firstOrNull;
+    if (alreadyMigrated != null) {
+      return alreadyMigrated;
+    }
+
+    try {
+      final clientId = await storage.getOrCreateClientIdentifier();
+      final servers = await serverRegistry.getServers();
+
+      String accountLabel = 'Plex';
+      String accountUuid = '';
+      try {
+        final info = await _plexUserInfoFetcher(token);
+        accountLabel = (info['username'] as String?) ?? (info['email'] as String?) ?? 'Plex';
+        accountUuid = (info['uuid'] as String?)?.trim() ?? '';
+      } catch (e) {
+        appLogger.d('Plex migration: account label lookup failed (using fallback): $e');
+      }
+
+      final conn = PlexAccountConnection(
+        id: 'plex.${accountUuid.isNotEmpty ? accountUuid : clientId}',
+        accountToken: token,
+        clientIdentifier: clientId,
+        accountLabel: accountLabel,
+        servers: servers,
+        createdAt: DateTime.now(),
+        lastAuthenticatedAt: DateTime.now(),
+      );
+      await connectionRegistry.upsert(conn);
+      appLogger.i('Migrated legacy Plex account into ConnectionRegistry as ${conn.id}');
+      return conn;
+    } catch (e, st) {
+      appLogger.w('Plex account migration failed', error: e, stackTrace: st);
+      return null;
+    }
+  }
+
+  /// Hydrate Plex Home users for [account] and select a virtual Plex Home
+  /// profile. Plex users are never persisted as local Plezy profiles.
+  Future<bool> _preparePlexVirtualProfile(PlexAccountConnection account) async {
+    final copied = await _migrateLegacyPlexHomeUsersCache(account.id);
+    var users = copied ? _readPlexHomeUsersCache(account.id) : null;
+    users ??= await _fetchAndCachePlexHomeUsers(account);
+    final hydratedUsers = users;
+    if (hydratedUsers.isEmpty) return false;
+
+    final legacyActiveUuid = storage.getCurrentUserUUID();
+    PlexHomeUser selected;
+    if (legacyActiveUuid != null && legacyActiveUuid.isNotEmpty) {
+      selected = hydratedUsers.firstWhere(
+        (u) => u.uuid == legacyActiveUuid,
+        orElse: () => _preferredPlexHomeUser(hydratedUsers),
+      );
+      if (selected.uuid != legacyActiveUuid) {
+        appLogger.w('Migration: legacy Plex Home UUID $legacyActiveUuid not found; using ${selected.uuid} instead');
+      }
+    } else {
+      selected = _preferredPlexHomeUser(hydratedUsers);
+    }
+
+    final activeProfileId = plexHomeProfileId(accountConnectionId: account.id, homeUserUuid: selected.uuid);
+    await storage.setActiveProfileId(activeProfileId);
+    await storage.clearCurrentUserUUID();
+    await Future.wait([storage.prefs.remove('home_users_cache'), storage.prefs.remove('home_users_cache_expiry')]);
+    appLogger.i('Migration: selected Plex Home profile ${selected.displayName} → $activeProfileId');
+    return true;
+  }
+
+  PlexHomeUser _preferredPlexHomeUser(List<PlexHomeUser> users) {
+    return users.firstWhere((u) => u.admin, orElse: () => users.first);
+  }
+
+  Future<bool> _migrateLegacyPlexHomeUsersCache(String connectionId) async {
+    final raw = storage.prefs.getString('home_users_cache');
+    if (raw == null || raw.isEmpty) return false;
+
+    try {
+      final decoded = jsonDecode(raw);
+      if (decoded is! Map<String, dynamic>) return false;
+      final home = PlexHome.fromJson(decoded);
+      if (home.users.isEmpty) return false;
+      await storage.savePlexHomeUsersCache(connectionId, home.users.map((u) => u.toJson()).toList());
+      appLogger.i('Migration: copied ${home.users.length} Plex Home users into cache for $connectionId');
+      return true;
+    } catch (e, st) {
+      appLogger.w('Plex Home cache migration failed', error: e, stackTrace: st);
+      return false;
+    }
+  }
+
+  List<PlexHomeUser>? _readPlexHomeUsersCache(String connectionId) {
+    final raw = storage.getPlexHomeUsersCacheJson(connectionId);
+    if (raw == null || raw.isEmpty) return null;
+    try {
+      final decoded = jsonDecode(raw);
+      if (decoded is! List) return null;
+      return decoded.whereType<Map<String, dynamic>>().map(PlexHomeUser.fromJson).toList();
+    } catch (e, st) {
+      appLogger.w('Migration: failed to read Plex Home cache for $connectionId', error: e, stackTrace: st);
+      return null;
+    }
+  }
+
+  Future<List<PlexHomeUser>> _fetchAndCachePlexHomeUsers(PlexAccountConnection account) async {
+    try {
+      final users = await _plexHomeUserFetcher(account.accountToken);
+      if (users.isNotEmpty) {
+        await storage.savePlexHomeUsersCache(account.id, users.map((u) => u.toJson()).toList());
+        appLogger.i('Migration: fetched ${users.length} Plex Home users for ${account.id}');
+      }
+      return users;
+    } catch (e, st) {
+      appLogger.w('Migration: Plex Home fetch failed for ${account.id}', error: e, stackTrace: st);
+      return const [];
+    }
+  }
+
+  Future<void> _migrateLegacyPlexHomeUsersCacheForExistingAccount(PlexAccountConnection? account) async {
+    if (storage.prefs.getString('home_users_cache') == null) return;
+    var target = account;
+    if (target == null) {
+      final connections = await connectionRegistry.list();
+      for (final conn in connections) {
+        if (conn is PlexAccountConnection) {
+          target = conn;
+          break;
+        }
+      }
+    }
+    if (target == null) return;
+    final copied = await _migrateLegacyPlexHomeUsersCache(target.id);
+    if (copied) {
+      await Future.wait([storage.prefs.remove('home_users_cache'), storage.prefs.remove('home_users_cache_expiry')]);
+    }
+  }
+
+  Future<PlexAccountConnection?> _firstPlexAccount(PlexAccountConnection? preferred) async {
+    if (preferred != null) return preferred;
+    final connections = await connectionRegistry.list();
+    for (final conn in connections) {
+      if (conn is PlexAccountConnection) return conn;
+    }
+    return null;
+  }
+
+  Future<void> _recoverLegacyProfilePromotionIfNeeded(PlexAccountConnection? account) async {
+    if (!_hasLegacyProfileState()) return;
+    final target = await _firstPlexAccount(account);
+    if (target == null) return;
+    await _preparePlexVirtualProfile(target);
+  }
+}
+
+Future<List<PlexHomeUser>> _fetchPlexHomeUsers(String accountToken) async {
+  final auth = await PlexAuthService.create();
+  try {
+    final home = await auth.getHomeUsers(accountToken);
+    return home.users;
+  } finally {
+    auth.dispose();
+  }
+}
+
+Future<Map<String, dynamic>> _fetchPlexUserInfo(String accountToken) async {
+  final auth = await PlexAuthService.create();
+  try {
+    return await auth.getUserInfo(accountToken);
+  } finally {
+    auth.dispose();
+  }
+}

lib/connection/connection_registry.dart

@@ -0,0 +1,188 @@
+import 'dart:async';
+import 'dart:convert';
+
+import 'package:collection/collection.dart';
+import 'package:drift/drift.dart';
+
+import '../database/app_database.dart';
+import '../services/credential_vault.dart';
+import '../utils/app_logger.dart';
+import 'connection.dart';
+
+/// CRUD over the persisted [Connections] table. The registry is the source
+/// of truth for which connections the user has added; the runtime
+/// `MultiServerManager` populates per-server clients from these records.
+///
+/// Single-connection users get a default automatically — power users with
+/// multiple connections can override it via [setDefault].
+class ConnectionRegistry {
+  ConnectionRegistry(this._db);
+
+  final AppDatabase _db;
+
+  /// Emits the current set of connections after every mutation. Drift's
+  /// `watch()` provides this for free.
+  Stream<List<Connection>> watchConnections() {
+    return (_db.select(_db.connections)..orderBy([(t) => OrderingTerm.asc(t.createdAt)])).watch().asyncMap(
+      (rows) async => (await Future.wait(rows.map(_rowToConnection))).whereType<Connection>().toList(),
+    );
+  }
+
+  /// One-shot fetch of all stored connections.
+  Future<List<Connection>> list() async {
+    final rows = await (_db.select(_db.connections)..orderBy([(t) => OrderingTerm.asc(t.createdAt)])).get();
+    return (await Future.wait(rows.map(_rowToConnection))).whereType<Connection>().toList();
+  }
+
+  /// Lookup a connection by id.
+  Future<Connection?> get(String id) async {
+    final row = await (_db.select(_db.connections)..where((t) => t.id.equals(id))).getSingleOrNull();
+    if (row == null) return null;
+    return _rowToConnection(row);
+  }
+
+  /// Returns the user's preferred connection — either the row marked
+  /// [Connections.isDefault], or the only row if exactly one exists, or
+  /// null when no connections are stored.
+  Future<Connection?> getDefault() async {
+    final rows = await _db.select(_db.connections).get();
+    if (rows.isEmpty) return null;
+    final flagged = rows.firstWhereOrNull((r) => r.isDefault);
+    final picked = flagged ?? (rows.length == 1 ? rows.single : null);
+    return picked == null ? null : _rowToConnection(picked);
+  }
+
+  /// Insert or replace [connection]. If this is the first stored connection
+  /// it is automatically marked default; re-upserting an existing row keeps
+  /// the row's current `isDefault` (so token/metadata refreshes don't clear
+  /// the default flag).
+  Future<void> upsert(Connection connection) async {
+    final existing = await (_db.select(_db.connections)..where((t) => t.id.equals(connection.id))).getSingleOrNull();
+    final bool isDefault;
+    if (existing != null) {
+      isDefault = existing.isDefault;
+    } else {
+      final any =
+          await (_db.selectOnly(_db.connections)
+                ..addColumns([_db.connections.id])
+                ..limit(1))
+              .getSingleOrNull();
+      isDefault = any == null;
+    }
+    final protectedConfig = await CredentialVault.protectConnectionConfig(
+      connection.kind.id,
+      connection.toConfigJson(),
+    );
+    final row = ConnectionsCompanion(
+      id: Value(connection.id),
+      kind: Value(connection.kind.id),
+      displayName: Value(connection.displayName),
+      configJson: Value(jsonEncode(protectedConfig)),
+      isDefault: Value(isDefault),
+      createdAt: Value(connection.createdAt.millisecondsSinceEpoch),
+      lastAuthenticatedAt: Value(connection.lastAuthenticatedAt?.millisecondsSinceEpoch),
+    );
+    await _db.into(_db.connections).insertOnConflictUpdate(row);
+    appLogger.d('ConnectionRegistry: upserted ${connection.kind.id}/${connection.id}');
+  }
+
+  /// Remove a stored connection. If the removed row was the default, the
+  /// oldest remaining connection (if any) becomes default.
+  Future<void> remove(String id) async {
+    await (_db.delete(_db.connections)..where((t) => t.id.equals(id))).go();
+    final remaining = await (_db.select(_db.connections)..orderBy([(t) => OrderingTerm.asc(t.createdAt)])).get();
+    if (remaining.isNotEmpty && !remaining.any((r) => r.isDefault)) {
+      await (_db.update(
+        _db.connections,
+      )..where((t) => t.id.equals(remaining.first.id))).write(const ConnectionsCompanion(isDefault: Value(true)));
+    }
+    appLogger.d('ConnectionRegistry: removed $id');
+  }
+
+  /// Set [id] as the default connection. Clears the flag on all others.
+  Future<void> setDefault(String id) async {
+    await _db.transaction(() async {
+      await _db.update(_db.connections).write(const ConnectionsCompanion(isDefault: Value(false)));
+      await (_db.update(
+        _db.connections,
+      )..where((t) => t.id.equals(id))).write(const ConnectionsCompanion(isDefault: Value(true)));
+    });
+  }
+
+  /// Update only the auth-related metadata on an existing row (token,
+  /// `lastAuthenticatedAt`). Used by the auth flow after a successful
+  /// silent refresh without touching the rest of the config.
+  Future<void> recordAuthSuccess(String id, DateTime at) async {
+    await (_db.update(_db.connections)..where((t) => t.id.equals(id))).write(
+      ConnectionsCompanion(lastAuthenticatedAt: Value(at.millisecondsSinceEpoch)),
+    );
+  }
+
+  Future<void> clear() async {
+    await _db.delete(_db.connections).go();
+  }
+
+  /// All Plex accounts in insertion order. Convenience over
+  /// `(await list()).whereType<PlexAccountConnection>()` — cuts ~3 lines from
+  /// every caller that needs to filter by backend.
+  Future<List<PlexAccountConnection>> listPlexAccounts() async {
+    final all = await list();
+    return all.whereType<PlexAccountConnection>().toList();
+  }
+
+  /// All Jellyfin connections in insertion order. Symmetric helper to
+  /// [listPlexAccounts].
+  Future<List<JellyfinConnection>> listJellyfin() async {
+    final all = await list();
+    return all.whereType<JellyfinConnection>().toList();
+  }
+
+  /// Lookup a [PlexAccountConnection] by id. Returns `null` if no row
+  /// matches OR the row exists but isn't a Plex account.
+  Future<PlexAccountConnection?> getPlexAccount(String id) async {
+    final c = await get(id);
+    return c is PlexAccountConnection ? c : null;
+  }
+
+  /// Lookup a [JellyfinConnection] by id. Returns `null` if no row matches
+  /// OR the row exists but isn't a Jellyfin connection.
+  Future<JellyfinConnection?> getJellyfin(String id) async {
+    final c = await get(id);
+    return c is JellyfinConnection ? c : null;
+  }
+
+  Future<Connection?> _rowToConnection(ConnectionRow row) async {
+    try {
+      final json = jsonDecode(row.configJson) as Map<String, dynamic>;
+      final kind = ConnectionKind.fromId(row.kind);
+      final revealed = await CredentialVault.revealConnectionConfig(kind.id, json);
+      final createdAt = DateTime.fromMillisecondsSinceEpoch(row.createdAt);
+      final lastAuth = row.lastAuthenticatedAt == null
+          ? null
+          : DateTime.fromMillisecondsSinceEpoch(row.lastAuthenticatedAt!);
+      final connection = switch (kind) {
+        ConnectionKind.plex => PlexAccountConnection.fromConfigJson(
+          id: row.id,
+          json: revealed.config,
+          status: ConnectionStatus.unknown,
+          createdAt: createdAt,
+          lastAuthenticatedAt: lastAuth,
+        ),
+        ConnectionKind.jellyfin => JellyfinConnection.fromConfigJson(
+          id: row.id,
+          json: revealed.config,
+          status: ConnectionStatus.unknown,
+          createdAt: createdAt,
+          lastAuthenticatedAt: lastAuth,
+        ),
+      };
+      if (revealed.migrated) {
+        await upsert(connection);
+      }
+      return connection;
+    } catch (e, st) {
+      appLogger.e('ConnectionRegistry: failed to decode connection ${row.id}', error: e, stackTrace: st);
+      return null;
+    }
+  }
+}

lib/data/hid_key_labels.dart

@@ -0,0 +1,335 @@
+// Generated from USB HID Usage Tables — do not edit by hand.
+
+/// Human-readable labels for physical keyboard keys, keyed by USB HID usage code.
+const hidKeyLabels = <int, String>{
+  // Special
+  0x00000010: 'Hyper',
+  0x00000011: 'Super',
+  0x00000012: 'Fn',
+  0x00000013: 'Fn Lock',
+  0x00000014: 'Suspend',
+  0x00000015: 'Resume',
+  0x00000016: 'Turbo',
+  0x00000017: 'Privacy Screen Toggle',
+  0x00000018: 'Microphone Mute',
+  // Generic Desktop
+  0x00010082: 'Sleep',
+  0x00010083: 'Wake Up',
+  0x000100b5: 'Display Toggle',
+  // Game Buttons
+  0x0005ff01: 'Game Button 1',
+  0x0005ff02: 'Game Button 2',
+  0x0005ff03: 'Game Button 3',
+  0x0005ff04: 'Game Button 4',
+  0x0005ff05: 'Game Button 5',
+  0x0005ff06: 'Game Button 6',
+  0x0005ff07: 'Game Button 7',
+  0x0005ff08: 'Game Button 8',
+  0x0005ff09: 'Game Button 9',
+  0x0005ff0a: 'Game Button 10',
+  0x0005ff0b: 'Game Button 11',
+  0x0005ff0c: 'Game Button 12',
+  0x0005ff0d: 'Game Button 13',
+  0x0005ff0e: 'Game Button 14',
+  0x0005ff0f: 'Game Button 15',
+  0x0005ff10: 'Game Button 16',
+  0x0005ff11: 'Game Button A',
+  0x0005ff12: 'Game Button B',
+  0x0005ff13: 'Game Button C',
+  0x0005ff14: 'Game Button Left 1',
+  0x0005ff15: 'Game Button Left 2',
+  0x0005ff16: 'Game Button Mode',
+  0x0005ff17: 'Game Button Right 1',
+  0x0005ff18: 'Game Button Right 2',
+  0x0005ff19: 'Game Button Select',
+  0x0005ff1a: 'Game Button Start',
+  0x0005ff1b: 'Game Button Thumb Left',
+  0x0005ff1c: 'Game Button Thumb Right',
+  0x0005ff1d: 'Game Button X',
+  0x0005ff1e: 'Game Button Y',
+  0x0005ff1f: 'Game Button Z',
+  // Keyboard/Keypad
+  0x00070004: 'A',
+  0x00070005: 'B',
+  0x00070006: 'C',
+  0x00070007: 'D',
+  0x00070008: 'E',
+  0x00070009: 'F',
+  0x0007000a: 'G',
+  0x0007000b: 'H',
+  0x0007000c: 'I',
+  0x0007000d: 'J',
+  0x0007000e: 'K',
+  0x0007000f: 'L',
+  0x00070010: 'M',
+  0x00070011: 'N',
+  0x00070012: 'O',
+  0x00070013: 'P',
+  0x00070014: 'Q',
+  0x00070015: 'R',
+  0x00070016: 'S',
+  0x00070017: 'T',
+  0x00070018: 'U',
+  0x00070019: 'V',
+  0x0007001a: 'W',
+  0x0007001b: 'X',
+  0x0007001c: 'Y',
+  0x0007001d: 'Z',
+  0x0007001e: '1',
+  0x0007001f: '2',
+  0x00070020: '3',
+  0x00070021: '4',
+  0x00070022: '5',
+  0x00070023: '6',
+  0x00070024: '7',
+  0x00070025: '8',
+  0x00070026: '9',
+  0x00070027: '0',
+  0x00070028: 'Enter',
+  0x00070029: 'Escape',
+  0x0007002a: 'Backspace',
+  0x0007002b: 'Tab',
+  0x0007002c: 'Space',
+  0x0007002d: '-',
+  0x0007002e: '=',
+  0x0007002f: '[',
+  0x00070030: ']',
+  0x00070031: r'\',
+  0x00070033: ';',
+  0x00070034: "'",
+  0x00070035: '`',
+  0x00070036: ',',
+  0x00070037: '.',
+  0x00070038: '/',
+  0x00070039: 'Caps Lock',
+  0x0007003a: 'F1',
+  0x0007003b: 'F2',
+  0x0007003c: 'F3',
+  0x0007003d: 'F4',
+  0x0007003e: 'F5',
+  0x0007003f: 'F6',
+  0x00070040: 'F7',
+  0x00070041: 'F8',
+  0x00070042: 'F9',
+  0x00070043: 'F10',
+  0x00070044: 'F11',
+  0x00070045: 'F12',
+  0x00070046: 'Print Screen',
+  0x00070047: 'Scroll Lock',
+  0x00070048: 'Pause',
+  0x00070049: 'Insert',
+  0x0007004a: 'Home',
+  0x0007004b: 'Page Up',
+  0x0007004c: 'Delete',
+  0x0007004d: 'End',
+  0x0007004e: 'Page Down',
+  0x0007004f: 'Arrow Right',
+  0x00070050: 'Arrow Left',
+  0x00070051: 'Arrow Down',
+  0x00070052: 'Arrow Up',
+  0x00070053: 'Num Lock',
+  0x00070054: 'Numpad /',
+  0x00070055: 'Numpad *',
+  0x00070056: 'Numpad -',
+  0x00070057: 'Numpad +',
+  0x00070058: 'Numpad Enter',
+  0x00070059: 'Numpad 1',
+  0x0007005a: 'Numpad 2',
+  0x0007005b: 'Numpad 3',
+  0x0007005c: 'Numpad 4',
+  0x0007005d: 'Numpad 5',
+  0x0007005e: 'Numpad 6',
+  0x0007005f: 'Numpad 7',
+  0x00070060: 'Numpad 8',
+  0x00070061: 'Numpad 9',
+  0x00070062: 'Numpad 0',
+  0x00070063: 'Numpad .',
+  0x00070064: 'Intl Backslash',
+  0x00070065: 'Context Menu',
+  0x00070066: 'Power',
+  0x00070067: 'Numpad =',
+  0x00070068: 'F13',
+  0x00070069: 'F14',
+  0x0007006a: 'F15',
+  0x0007006b: 'F16',
+  0x0007006c: 'F17',
+  0x0007006d: 'F18',
+  0x0007006e: 'F19',
+  0x0007006f: 'F20',
+  0x00070070: 'F21',
+  0x00070071: 'F22',
+  0x00070072: 'F23',
+  0x00070073: 'F24',
+  0x00070074: 'Open',
+  0x00070075: 'Help',
+  0x00070077: 'Select',
+  0x00070079: 'Again',
+  0x0007007a: 'Undo',
+  0x0007007b: 'Cut',
+  0x0007007c: 'Copy',
+  0x0007007d: 'Paste',
+  0x0007007e: 'Find',
+  0x0007007f: 'Volume Mute',
+  0x00070080: 'Volume Up',
+  0x00070081: 'Volume Down',
+  0x00070085: 'Numpad ,',
+  0x00070087: 'Intl Ro',
+  0x00070088: 'Kana Mode',
+  0x00070089: 'Intl Yen',
+  0x0007008a: 'Convert',
+  0x0007008b: 'Non Convert',
+  0x00070090: 'Lang 1',
+  0x00070091: 'Lang 2',
+  0x00070092: 'Lang 3',
+  0x00070093: 'Lang 4',
+  0x00070094: 'Lang 5',
+  0x0007009b: 'Abort',
+  0x000700a3: 'Props',
+  0x000700b6: 'Numpad (',
+  0x000700b7: 'Numpad )',
+  0x000700bb: 'Numpad Backspace',
+  0x000700d0: 'Numpad Memory Store',
+  0x000700d1: 'Numpad Memory Recall',
+  0x000700d2: 'Numpad Memory Clear',
+  0x000700d3: 'Numpad Memory Add',
+  0x000700d4: 'Numpad Memory Subtract',
+  0x000700d7: 'Numpad Sign Change',
+  0x000700d8: 'Numpad Clear',
+  0x000700d9: 'Numpad Clear Entry',
+  0x000700e0: 'Ctrl',
+  0x000700e1: 'Shift',
+  0x000700e2: 'Alt',
+  0x000700e3: 'Meta',
+  0x000700e4: 'Ctrl',
+  0x000700e5: 'Shift',
+  0x000700e6: 'Alt',
+  0x000700e7: 'Meta',
+  // Consumer
+  0x000c0030: 'Power',
+  0x000c0032: 'Sleep',
+  0x000c0040: 'Menu',
+  0x000c0041: 'Menu Pick',
+  0x000c0042: 'Menu Up',
+  0x000c0043: 'Menu Down',
+  0x000c0044: 'Menu Left',
+  0x000c0045: 'Menu Right',
+  0x000c0046: 'Menu Escape',
+  0x000c0047: 'Menu Value Increase',
+  0x000c0048: 'Menu Value Decrease',
+  0x000c0060: 'Info',
+  0x000c0061: 'Closed Caption',
+  0x000c0062: 'Closed Caption Select',
+  0x000c0063: 'VCR/TV',
+  0x000c0064: 'Broadcast Mode',
+  0x000c0065: 'Snapshot',
+  0x000c0066: 'Still',
+  0x000c0067: 'PiP Toggle',
+  0x000c0068: 'PiP Swap',
+  0x000c0069: 'Red Button',
+  0x000c006a: 'Green Button',
+  0x000c006b: 'Blue Button',
+  0x000c006c: 'Yellow Button',
+  0x000c006d: 'Aspect',
+  0x000c006e: '3D Mode Select',
+  0x000c006f: 'Brightness Up',
+  0x000c0070: 'Brightness Down',
+  0x000c0072: 'Brightness Toggle',
+  0x000c0073: 'Brightness Min',
+  0x000c0074: 'Brightness Max',
+  0x000c0075: 'Brightness Auto',
+  0x000c0079: 'Kbd Illum Up',
+  0x000c007a: 'Kbd Illum Down',
+  0x000c0082: 'Mode Step',
+  0x000c0083: 'Recall Last',
+  0x000c0084: 'Enter Channel',
+  0x000c0085: 'Order Movie',
+  0x000c0086: 'Channel',
+  0x000c0088: 'Media Computer',
+  0x000c0089: 'Media TV',
+  0x000c008a: 'Media WWW',
+  0x000c008b: 'Media DVD',
+  0x000c008c: 'Media Telephone',
+  0x000c008d: 'Program Guide',
+  0x000c008e: 'Media Video Phone',
+  0x000c008f: 'Media Games',
+  0x000c0090: 'Media Messages',
+  0x000c0091: 'Media CD',
+  0x000c0092: 'Media VCR',
+  0x000c0093: 'Media Tuner',
+  0x000c0094: 'Quit',
+  0x000c0095: 'Help',
+  0x000c0096: 'Media Tape',
+  0x000c0097: 'Media Cable',
+  0x000c0098: 'Media Satellite',
+  0x000c0099: 'Media Security',
+  0x000c009a: 'Media Home',
+  0x000c009b: 'Media Call',
+  0x000c009c: 'Channel Up',
+  0x000c009d: 'Channel Down',
+  0x000c009e: 'Media SAP',
+  0x000c00b0: 'Play',
+  0x000c00b1: 'Pause',
+  0x000c00b2: 'Record',
+  0x000c00b3: 'Fast Forward',
+  0x000c00b4: 'Rewind',
+  0x000c00b5: 'Next Track',
+  0x000c00b6: 'Previous Track',
+  0x000c00b7: 'Stop',
+  0x000c00b8: 'Eject',
+  0x000c00b9: 'Random Play',
+  0x000c00ba: 'Select Disc',
+  0x000c00bb: 'Enter Disc',
+  0x000c00bc: 'Repeat',
+  0x000c00c0: 'Frame Forward',
+  0x000c00c1: 'Frame Back',
+  0x000c00cc: 'Stop/Eject',
+  0x000c00cd: 'Play/Pause',
+  0x000c00ce: 'Play/Skip',
+  0x000c00cf: 'Voice Command',
+  0x000c00e0: 'Volume',
+  0x000c00e2: 'Mute',
+  0x000c00e5: 'Bass Boost',
+  0x000c00e6: 'Surround Mode',
+  0x000c00e7: 'Loudness',
+  0x000c00e9: 'Volume Up',
+  0x000c00ea: 'Volume Down',
+  0x000c0183: 'Media Select',
+  0x000c0184: 'Launch Word Processor',
+  0x000c0186: 'Launch Spreadsheet',
+  0x000c018a: 'Launch Mail',
+  0x000c018d: 'Launch Contacts',
+  0x000c018e: 'Launch Calendar',
+  0x000c0192: 'Launch Calculator',
+  0x000c0194: 'Launch File Browser',
+  0x000c0196: 'Launch Browser',
+  0x000c019c: 'Log Off',
+  0x000c019e: 'Lock Screen',
+  0x000c019f: 'Launch Control Panel',
+  0x000c01a2: 'Select Task',
+  0x000c01a7: 'Launch Documents',
+  0x000c01ab: 'Spell Check',
+  0x000c01ae: 'Launch Keyboard Layout',
+  0x000c01b1: 'Launch Screen Saver',
+  0x000c01b7: 'Launch Audio Browser',
+  0x000c01cb: 'Launch Assistant',
+  0x000c0201: 'New',
+  0x000c0203: 'Close',
+  0x000c0207: 'Save',
+  0x000c0208: 'Print',
+  0x000c0221: 'Browser Search',
+  0x000c0223: 'Browser Home',
+  0x000c0224: 'Browser Back',
+  0x000c0225: 'Browser Forward',
+  0x000c0226: 'Browser Stop',
+  0x000c0227: 'Browser Refresh',
+  0x000c022a: 'Browser Favorites',
+  0x000c022d: 'Zoom In',
+  0x000c022e: 'Zoom Out',
+  0x000c0232: 'Zoom Toggle',
+  0x000c0279: 'Redo',
+  0x000c0289: 'Mail Reply',
+  0x000c028b: 'Mail Forward',
+  0x000c028c: 'Mail Send',
+  0x000c029d: 'Keyboard Layout Select',
+  0x000c029f: 'Show All Windows',
+};

lib/data/iso_639_data.dart

@@ -0,0 +1,406 @@
+// Generated from iso_639_codes.json — do not edit by hand.
+
+class LanguageEntry {
+  final String code1;
+  final String code2;
+  final String? code2B;
+  final String name;
+  const LanguageEntry(this.code1, this.code2, this.code2B, this.name);
+}
+
+const languageEntries = <String, LanguageEntry>{
+  'aa': LanguageEntry('aa', 'aar', null, 'Afar'),
+  'ab': LanguageEntry('ab', 'abk', null, 'Abkhaz'),
+  'ae': LanguageEntry('ae', 'ave', null, 'Avestan'),
+  'af': LanguageEntry('af', 'afr', null, 'Afrikaans'),
+  'ak': LanguageEntry('ak', 'aka', null, 'Akan'),
+  'am': LanguageEntry('am', 'amh', null, 'Amharic'),
+  'an': LanguageEntry('an', 'arg', null, 'Aragonese'),
+  'ar': LanguageEntry('ar', 'ara', null, 'Arabic'),
+  'as': LanguageEntry('as', 'asm', null, 'Assamese'),
+  'av': LanguageEntry('av', 'ava', null, 'Avaric'),
+  'ay': LanguageEntry('ay', 'aym', null, 'Aymara'),
+  'az': LanguageEntry('az', 'aze', null, 'Azerbaijani'),
+  'ba': LanguageEntry('ba', 'bak', null, 'Bashkir'),
+  'be': LanguageEntry('be', 'bel', null, 'Belarusian'),
+  'bg': LanguageEntry('bg', 'bul', null, 'Bulgarian'),
+  'bh': LanguageEntry('bh', 'bih', null, 'Bihari'),
+  'bi': LanguageEntry('bi', 'bis', null, 'Bislama'),
+  'bm': LanguageEntry('bm', 'bam', null, 'Bambara'),
+  'bn': LanguageEntry('bn', 'ben', null, 'Bengali, Bangla'),
+  'bo': LanguageEntry('bo', 'bod', 'tib', 'Tibetan Standard, Tibetan, Central'),
+  'br': LanguageEntry('br', 'bre', null, 'Breton'),
+  'bs': LanguageEntry('bs', 'bos', null, 'Bosnian'),
+  'ca': LanguageEntry('ca', 'cat', null, 'Catalan'),
+  'ce': LanguageEntry('ce', 'che', null, 'Chechen'),
+  'ch': LanguageEntry('ch', 'cha', null, 'Chamorro'),
+  'co': LanguageEntry('co', 'cos', null, 'Corsican'),
+  'cr': LanguageEntry('cr', 'cre', null, 'Cree'),
+  'cs': LanguageEntry('cs', 'ces', 'cze', 'Czech'),
+  'cu': LanguageEntry('cu', 'chu', null, 'Old Church Slavonic, Church Slavonic, Old Bulgarian'),
+  'cv': LanguageEntry('cv', 'chv', null, 'Chuvash'),
+  'cy': LanguageEntry('cy', 'cym', 'wel', 'Welsh'),
+  'da': LanguageEntry('da', 'dan', null, 'Danish'),
+  'de': LanguageEntry('de', 'deu', 'ger', 'German'),
+  'dv': LanguageEntry('dv', 'div', null, 'Divehi, Dhivehi, Maldivian'),
+  'dz': LanguageEntry('dz', 'dzo', null, 'Dzongkha'),
+  'ee': LanguageEntry('ee', 'ewe', null, 'Ewe'),
+  'el': LanguageEntry('el', 'ell', 'gre', 'Greek (modern)'),
+  'en': LanguageEntry('en', 'eng', null, 'English'),
+  'eo': LanguageEntry('eo', 'epo', null, 'Esperanto'),
+  'es': LanguageEntry('es', 'spa', null, 'Spanish'),
+  'et': LanguageEntry('et', 'est', null, 'Estonian'),
+  'eu': LanguageEntry('eu', 'eus', 'baq', 'Basque'),
+  'fa': LanguageEntry('fa', 'fas', 'per', 'Persian (Farsi)'),
+  'ff': LanguageEntry('ff', 'ful', null, 'Fula, Fulah, Pulaar, Pular'),
+  'fi': LanguageEntry('fi', 'fin', null, 'Finnish'),
+  'fj': LanguageEntry('fj', 'fij', null, 'Fijian'),
+  'fo': LanguageEntry('fo', 'fao', null, 'Faroese'),
+  'fr': LanguageEntry('fr', 'fra', 'fre', 'French'),
+  'fy': LanguageEntry('fy', 'fry', null, 'Western Frisian'),
+  'ga': LanguageEntry('ga', 'gle', null, 'Irish'),
+  'gd': LanguageEntry('gd', 'gla', null, 'Scottish Gaelic, Gaelic'),
+  'gl': LanguageEntry('gl', 'glg', null, 'Galician'),
+  'gn': LanguageEntry('gn', 'grn', null, 'Guaraní'),
+  'gu': LanguageEntry('gu', 'guj', null, 'Gujarati'),
+  'gv': LanguageEntry('gv', 'glv', null, 'Manx'),
+  'ha': LanguageEntry('ha', 'hau', null, 'Hausa'),
+  'he': LanguageEntry('he', 'heb', null, 'Hebrew (modern)'),
+  'hi': LanguageEntry('hi', 'hin', null, 'Hindi'),
+  'ho': LanguageEntry('ho', 'hmo', null, 'Hiri Motu'),
+  'hr': LanguageEntry('hr', 'hrv', null, 'Croatian'),
+  'ht': LanguageEntry('ht', 'hat', null, 'Haitian, Haitian Creole'),
+  'hu': LanguageEntry('hu', 'hun', null, 'Hungarian'),
+  'hy': LanguageEntry('hy', 'hye', 'arm', 'Armenian'),
+  'hz': LanguageEntry('hz', 'her', null, 'Herero'),
+  'ia': LanguageEntry('ia', 'ina', null, 'Interlingua'),
+  'id': LanguageEntry('id', 'ind', null, 'Indonesian'),
+  'ie': LanguageEntry('ie', 'ile', null, 'Interlingue'),
+  'ig': LanguageEntry('ig', 'ibo', null, 'Igbo'),
+  'ii': LanguageEntry('ii', 'iii', null, 'Nuosu'),
+  'ik': LanguageEntry('ik', 'ipk', null, 'Inupiaq'),
+  'io': LanguageEntry('io', 'ido', null, 'Ido'),
+  'is': LanguageEntry('is', 'isl', 'ice', 'Icelandic'),
+  'it': LanguageEntry('it', 'ita', null, 'Italian'),
+  'iu': LanguageEntry('iu', 'iku', null, 'Inuktitut'),
+  'ja': LanguageEntry('ja', 'jpn', null, 'Japanese'),
+  'jv': LanguageEntry('jv', 'jav', null, 'Javanese'),
+  'ka': LanguageEntry('ka', 'kat', 'geo', 'Georgian'),
+  'kg': LanguageEntry('kg', 'kon', null, 'Kongo'),
+  'ki': LanguageEntry('ki', 'kik', null, 'Kikuyu, Gikuyu'),
+  'kj': LanguageEntry('kj', 'kua', null, 'Kwanyama, Kuanyama'),
+  'kk': LanguageEntry('kk', 'kaz', null, 'Kazakh'),
+  'kl': LanguageEntry('kl', 'kal', null, 'Kalaallisut, Greenlandic'),
+  'km': LanguageEntry('km', 'khm', null, 'Khmer'),
+  'kn': LanguageEntry('kn', 'kan', null, 'Kannada'),
+  'ko': LanguageEntry('ko', 'kor', null, 'Korean'),
+  'kr': LanguageEntry('kr', 'kau', null, 'Kanuri'),
+  'ks': LanguageEntry('ks', 'kas', null, 'Kashmiri'),
+  'ku': LanguageEntry('ku', 'kur', null, 'Kurdish'),
+  'kv': LanguageEntry('kv', 'kom', null, 'Komi'),
+  'kw': LanguageEntry('kw', 'cor', null, 'Cornish'),
+  'ky': LanguageEntry('ky', 'kir', null, 'Kyrgyz'),
+  'la': LanguageEntry('la', 'lat', null, 'Latin'),
+  'lb': LanguageEntry('lb', 'ltz', null, 'Luxembourgish, Letzeburgesch'),
+  'lg': LanguageEntry('lg', 'lug', null, 'Ganda'),
+  'li': LanguageEntry('li', 'lim', null, 'Limburgish, Limburgan, Limburger'),
+  'ln': LanguageEntry('ln', 'lin', null, 'Lingala'),
+  'lo': LanguageEntry('lo', 'lao', null, 'Lao'),
+  'lt': LanguageEntry('lt', 'lit', null, 'Lithuanian'),
+  'lu': LanguageEntry('lu', 'lub', null, 'Luba-Katanga'),
+  'lv': LanguageEntry('lv', 'lav', null, 'Latvian'),
+  'mg': LanguageEntry('mg', 'mlg', null, 'Malagasy'),
+  'mh': LanguageEntry('mh', 'mah', null, 'Marshallese'),
+  'mi': LanguageEntry('mi', 'mri', 'mao', 'Māori'),
+  'mk': LanguageEntry('mk', 'mkd', 'mac', 'Macedonian'),
+  'ml': LanguageEntry('ml', 'mal', null, 'Malayalam'),
+  'mn': LanguageEntry('mn', 'mon', null, 'Mongolian'),
+  'mr': LanguageEntry('mr', 'mar', null, 'Marathi (Marāṭhī)'),
+  'ms': LanguageEntry('ms', 'msa', 'may', 'Malay'),
+  'mt': LanguageEntry('mt', 'mlt', null, 'Maltese'),
+  'my': LanguageEntry('my', 'mya', 'bur', 'Burmese'),
+  'na': LanguageEntry('na', 'nau', null, 'Nauruan'),
+  'nb': LanguageEntry('nb', 'nob', null, 'Norwegian Bokmål'),
+  'nd': LanguageEntry('nd', 'nde', null, 'Northern Ndebele'),
+  'ne': LanguageEntry('ne', 'nep', null, 'Nepali'),
+  'ng': LanguageEntry('ng', 'ndo', null, 'Ndonga'),
+  'nl': LanguageEntry('nl', 'nld', 'dut', 'Dutch'),
+  'nn': LanguageEntry('nn', 'nno', null, 'Norwegian Nynorsk'),
+  'no': LanguageEntry('no', 'nor', null, 'Norwegian'),
+  'nr': LanguageEntry('nr', 'nbl', null, 'Southern Ndebele'),
+  'nv': LanguageEntry('nv', 'nav', null, 'Navajo, Navaho'),
+  'ny': LanguageEntry('ny', 'nya', null, 'Chichewa, Chewa, Nyanja'),
+  'oc': LanguageEntry('oc', 'oci', null, 'Occitan'),
+  'oj': LanguageEntry('oj', 'oji', null, 'Ojibwe, Ojibwa'),
+  'om': LanguageEntry('om', 'orm', null, 'Oromo'),
+  'or': LanguageEntry('or', 'ori', null, 'Oriya'),
+  'os': LanguageEntry('os', 'oss', null, 'Ossetian, Ossetic'),
+  'pa': LanguageEntry('pa', 'pan', null, '(Eastern) Punjabi'),
+  'pi': LanguageEntry('pi', 'pli', null, 'Pāli'),
+  'pl': LanguageEntry('pl', 'pol', null, 'Polish'),
+  'ps': LanguageEntry('ps', 'pus', null, 'Pashto, Pushto'),
+  'pt': LanguageEntry('pt', 'por', null, 'Portuguese'),
+  'qu': LanguageEntry('qu', 'que', null, 'Quechua'),
+  'rm': LanguageEntry('rm', 'roh', null, 'Romansh'),
+  'rn': LanguageEntry('rn', 'run', null, 'Kirundi'),
+  'ro': LanguageEntry('ro', 'ron', 'rum', 'Romanian'),
+  'ru': LanguageEntry('ru', 'rus', null, 'Russian'),
+  'rw': LanguageEntry('rw', 'kin', null, 'Kinyarwanda'),
+  'sa': LanguageEntry('sa', 'san', null, 'Sanskrit (Saṁskṛta)'),
+  'sc': LanguageEntry('sc', 'srd', null, 'Sardinian'),
+  'sd': LanguageEntry('sd', 'snd', null, 'Sindhi'),
+  'se': LanguageEntry('se', 'sme', null, 'Northern Sami'),
+  'sg': LanguageEntry('sg', 'sag', null, 'Sango'),
+  'si': LanguageEntry('si', 'sin', null, 'Sinhalese, Sinhala'),
+  'sk': LanguageEntry('sk', 'slk', 'slo', 'Slovak'),
+  'sl': LanguageEntry('sl', 'slv', null, 'Slovene'),
+  'sm': LanguageEntry('sm', 'smo', null, 'Samoan'),
+  'sn': LanguageEntry('sn', 'sna', null, 'Shona'),
+  'so': LanguageEntry('so', 'som', null, 'Somali'),
+  'sq': LanguageEntry('sq', 'sqi', 'alb', 'Albanian'),
+  'sr': LanguageEntry('sr', 'srp', null, 'Serbian'),
+  'ss': LanguageEntry('ss', 'ssw', null, 'Swati'),
+  'st': LanguageEntry('st', 'sot', null, 'Southern Sotho'),
+  'su': LanguageEntry('su', 'sun', null, 'Sundanese'),
+  'sv': LanguageEntry('sv', 'swe', null, 'Swedish'),
+  'sw': LanguageEntry('sw', 'swa', null, 'Swahili'),
+  'ta': LanguageEntry('ta', 'tam', null, 'Tamil'),
+  'te': LanguageEntry('te', 'tel', null, 'Telugu'),
+  'tg': LanguageEntry('tg', 'tgk', null, 'Tajik'),
+  'th': LanguageEntry('th', 'tha', null, 'Thai'),
+  'ti': LanguageEntry('ti', 'tir', null, 'Tigrinya'),
+  'tk': LanguageEntry('tk', 'tuk', null, 'Turkmen'),
+  'tl': LanguageEntry('tl', 'tgl', null, 'Tagalog'),
+  'tn': LanguageEntry('tn', 'tsn', null, 'Tswana'),
+  'to': LanguageEntry('to', 'ton', null, 'Tonga (Tonga Islands)'),
+  'tr': LanguageEntry('tr', 'tur', null, 'Turkish'),
+  'ts': LanguageEntry('ts', 'tso', null, 'Tsonga'),
+  'tt': LanguageEntry('tt', 'tat', null, 'Tatar'),
+  'tw': LanguageEntry('tw', 'twi', null, 'Twi'),
+  'ty': LanguageEntry('ty', 'tah', null, 'Tahitian'),
+  'ug': LanguageEntry('ug', 'uig', null, 'Uyghur'),
+  'uk': LanguageEntry('uk', 'ukr', null, 'Ukrainian'),
+  'ur': LanguageEntry('ur', 'urd', null, 'Urdu'),
+  'uz': LanguageEntry('uz', 'uzb', null, 'Uzbek'),
+  've': LanguageEntry('ve', 'ven', null, 'Venda'),
+  'vi': LanguageEntry('vi', 'vie', null, 'Vietnamese'),
+  'vo': LanguageEntry('vo', 'vol', null, 'Volapük'),
+  'wa': LanguageEntry('wa', 'wln', null, 'Walloon'),
+  'wo': LanguageEntry('wo', 'wol', null, 'Wolof'),
+  'xh': LanguageEntry('xh', 'xho', null, 'Xhosa'),
+  'yi': LanguageEntry('yi', 'yid', null, 'Yiddish'),
+  'yo': LanguageEntry('yo', 'yor', null, 'Yoruba'),
+  'za': LanguageEntry('za', 'zha', null, 'Zhuang, Chuang'),
+  'zh': LanguageEntry('zh', 'zho', 'chi', 'Chinese'),
+  'zu': LanguageEntry('zu', 'zul', null, 'Zulu'),
+};
+
+const code2ToCode1 = <String, String>{
+  'aar': 'aa',
+  'abk': 'ab',
+  'ave': 'ae',
+  'afr': 'af',
+  'aka': 'ak',
+  'amh': 'am',
+  'arg': 'an',
+  'ara': 'ar',
+  'asm': 'as',
+  'ava': 'av',
+  'aym': 'ay',
+  'aze': 'az',
+  'bak': 'ba',
+  'bel': 'be',
+  'bul': 'bg',
+  'bih': 'bh',
+  'bis': 'bi',
+  'bam': 'bm',
+  'ben': 'bn',
+  'bod': 'bo',
+  'bre': 'br',
+  'bos': 'bs',
+  'cat': 'ca',
+  'che': 'ce',
+  'cha': 'ch',
+  'cos': 'co',
+  'cre': 'cr',
+  'ces': 'cs',
+  'chu': 'cu',
+  'chv': 'cv',
+  'cym': 'cy',
+  'dan': 'da',
+  'deu': 'de',
+  'div': 'dv',
+  'dzo': 'dz',
+  'ewe': 'ee',
+  'ell': 'el',
+  'eng': 'en',
+  'epo': 'eo',
+  'spa': 'es',
+  'est': 'et',
+  'eus': 'eu',
+  'fas': 'fa',
+  'ful': 'ff',
+  'fin': 'fi',
+  'fij': 'fj',
+  'fao': 'fo',
+  'fra': 'fr',
+  'fry': 'fy',
+  'gle': 'ga',
+  'gla': 'gd',
+  'glg': 'gl',
+  'grn': 'gn',
+  'guj': 'gu',
+  'glv': 'gv',
+  'hau': 'ha',
+  'heb': 'he',
+  'hin': 'hi',
+  'hmo': 'ho',
+  'hrv': 'hr',
+  'hat': 'ht',
+  'hun': 'hu',
+  'hye': 'hy',
+  'her': 'hz',
+  'ina': 'ia',
+  'ind': 'id',
+  'ile': 'ie',
+  'ibo': 'ig',
+  'iii': 'ii',
+  'ipk': 'ik',
+  'ido': 'io',
+  'isl': 'is',
+  'ita': 'it',
+  'iku': 'iu',
+  'jpn': 'ja',
+  'jav': 'jv',
+  'kat': 'ka',
+  'kon': 'kg',
+  'kik': 'ki',
+  'kua': 'kj',
+  'kaz': 'kk',
+  'kal': 'kl',
+  'khm': 'km',
+  'kan': 'kn',
+  'kor': 'ko',
+  'kau': 'kr',
+  'kas': 'ks',
+  'kur': 'ku',
+  'kom': 'kv',
+  'cor': 'kw',
+  'kir': 'ky',
+  'lat': 'la',
+  'ltz': 'lb',
+  'lug': 'lg',
+  'lim': 'li',
+  'lin': 'ln',
+  'lao': 'lo',
+  'lit': 'lt',
+  'lub': 'lu',
+  'lav': 'lv',
+  'mlg': 'mg',
+  'mah': 'mh',
+  'mri': 'mi',
+  'mkd': 'mk',
+  'mal': 'ml',
+  'mon': 'mn',
+  'mar': 'mr',
+  'msa': 'ms',
+  'mlt': 'mt',
+  'mya': 'my',
+  'nau': 'na',
+  'nob': 'nb',
+  'nde': 'nd',
+  'nep': 'ne',
+  'ndo': 'ng',
+  'nld': 'nl',
+  'nno': 'nn',
+  'nor': 'no',
+  'nbl': 'nr',
+  'nav': 'nv',
+  'nya': 'ny',
+  'oci': 'oc',
+  'oji': 'oj',
+  'orm': 'om',
+  'ori': 'or',
+  'oss': 'os',
+  'pan': 'pa',
+  'pli': 'pi',
+  'pol': 'pl',
+  'pus': 'ps',
+  'por': 'pt',
+  'que': 'qu',
+  'roh': 'rm',
+  'run': 'rn',
+  'ron': 'ro',
+  'rus': 'ru',
+  'kin': 'rw',
+  'san': 'sa',
+  'srd': 'sc',
+  'snd': 'sd',
+  'sme': 'se',
+  'sag': 'sg',
+  'sin': 'si',
+  'slk': 'sk',
+  'slv': 'sl',
+  'smo': 'sm',
+  'sna': 'sn',
+  'som': 'so',
+  'sqi': 'sq',
+  'srp': 'sr',
+  'ssw': 'ss',
+  'sot': 'st',
+  'sun': 'su',
+  'swe': 'sv',
+  'swa': 'sw',
+  'tam': 'ta',
+  'tel': 'te',
+  'tgk': 'tg',
+  'tha': 'th',
+  'tir': 'ti',
+  'tuk': 'tk',
+  'tgl': 'tl',
+  'tsn': 'tn',
+  'ton': 'to',
+  'tur': 'tr',
+  'tso': 'ts',
+  'tat': 'tt',
+  'twi': 'tw',
+  'tah': 'ty',
+  'uig': 'ug',
+  'ukr': 'uk',
+  'urd': 'ur',
+  'uzb': 'uz',
+  'ven': 've',
+  'vie': 'vi',
+  'vol': 'vo',
+  'wln': 'wa',
+  'wol': 'wo',
+  'xho': 'xh',
+  'yid': 'yi',
+  'yor': 'yo',
+  'zha': 'za',
+  'zho': 'zh',
+  'zul': 'zu',
+};
+
+const code2BToCode1 = <String, String>{
+  'tib': 'bo',
+  'cze': 'cs',
+  'wel': 'cy',
+  'ger': 'de',
+  'gre': 'el',
+  'baq': 'eu',
+  'per': 'fa',
+  'fre': 'fr',
+  'arm': 'hy',
+  'ice': 'is',
+  'geo': 'ka',
+  'mao': 'mi',
+  'mac': 'mk',
+  'may': 'ms',
+  'bur': 'my',
+  'dut': 'nl',
+  'rum': 'ro',
+  'slo': 'sk',
+  'alb': 'sq',
+  'chi': 'zh',
+};

lib/database/app_database.dart

@@ -1,6 +1,8 @@
 import 'dart:io';
+import '../media/ids.dart';
 import 'package:drift/drift.dart';
 import 'package:drift/native.dart';
+import 'package:flutter/foundation.dart';
 import 'package:path_provider/path_provider.dart';
 import 'package:path/path.dart' as p;
 
@@ -11,17 +13,68 @@ import '../utils/global_key_utils.dart';
 
 part 'app_database.g.dart';
 
-// Simplified database with API cache for offline support
-@DriftDatabase(tables: [DownloadedMedia, DownloadQueue, ApiCache, OfflineWatchProgress])
+/// Action queued in the offline watch-progress sync table. The serialized
+/// form ([id]) is what gets persisted in [OfflineWatchProgress.actionType];
+/// keep these strings stable across renames so existing rows resolve.
+enum OfflineActionType {
+  progress,
+  watched,
+  unwatched;
+
+  /// Stable string id used for persistence. Survives an enum-name rename
+  /// (e.g. `progress` → `inProgress`) — `.name` would corrupt every row.
+  String get id => switch (this) {
+    OfflineActionType.progress => 'progress',
+    OfflineActionType.watched => 'watched',
+    OfflineActionType.unwatched => 'unwatched',
+  };
+
+  /// Inverse of [id]. Throws on unknown so a typo in production doesn't
+  /// silently fall back to the wrong action.
+  static OfflineActionType fromId(String id) => switch (id) {
+    'progress' => OfflineActionType.progress,
+    'watched' => OfflineActionType.watched,
+    'unwatched' => OfflineActionType.unwatched,
+    _ => throw ArgumentError('Unknown OfflineActionType id: $id'),
+  };
+}
+
+@DriftDatabase(
+  tables: [
+    DownloadedMedia,
+    DownloadOwners,
+    DownloadQueue,
+    ApiCache,
+    OfflineWatchProgress,
+    SyncRules,
+    Connections,
+    Profiles,
+    ProfileConnections,
+  ],
+)
 class AppDatabase extends _$AppDatabase {
   AppDatabase() : super(_openConnection());
 
+  /// Test-only constructor — inject an in-memory [QueryExecutor]
+  /// (e.g. `NativeDatabase.memory()`) so tests don't touch real disk.
+  @visibleForTesting
+  AppDatabase.forTesting(super.e);
+
   @override
-  int get schemaVersion => 8; // Added bgTaskId column to DownloadedMedia
+  int get schemaVersion => 15;
 
   @override
   MigrationStrategy get migration {
     return MigrationStrategy(
+      // Enforce ProfileConnections → Profiles/Connections cascades.
+      // Drift turns FKs *off* during migrations, so the per-connection
+      // pragma we set in `_openConnection` is wiped on first open. This
+      // hook runs after migrations and re-enables it for subsequent
+      // queries — also applies to in-memory test databases that don't go
+      // through `_openConnection`.
+      beforeOpen: (details) async {
+        await customStatement('PRAGMA foreign_keys = ON');
+      },
       onCreate: (Migrator m) async {
         await m.createAll();
       },
@@ -32,59 +85,287 @@ class AppDatabase extends _$AppDatabase {
         }
         if (from < 8) {
           appLogger.i('Adding bgTaskId column to DownloadedMedia (v8 migration)');
-          try {
-            await m.addColumn(downloadedMedia, downloadedMedia.bgTaskId);
-          } catch (e) {
-            appLogger.w('bgTaskId column may already exist: $e');
+          await _ignoreAlreadyExists(
+            'DownloadedMedia.bgTaskId column',
+            () => m.addColumn(downloadedMedia, downloadedMedia.bgTaskId),
+          );
+        }
+        if (from < 9) {
+          appLogger.i('Adding mediaIndex column to DownloadedMedia (v9 migration)');
+          await _ignoreAlreadyExists(
+            'DownloadedMedia.mediaIndex column',
+            () => m.addColumn(downloadedMedia, downloadedMedia.mediaIndex),
+          );
+        }
+        if (from < 10) {
+          appLogger.i('Adding SyncRules table (v10 migration)');
+          await m.createTable(syncRules);
+        }
+        if (from < 11) {
+          appLogger.i('Adding enabled column to SyncRules (v11 migration)');
+          await _ignoreAlreadyExists('SyncRules.enabled column', () => m.addColumn(syncRules, syncRules.enabled));
+        }
+        if (from < 12) {
+          appLogger.i('Adding downloadFilter column to SyncRules (v12 migration)');
+          await _ignoreAlreadyExists(
+            'SyncRules.downloadFilter column',
+            () => m.addColumn(syncRules, syncRules.downloadFilter),
+          );
+        }
+        if (from < 13) {
+          appLogger.i('Adding indexes on DownloadedMedia hot-queried columns (v13 migration)');
+          final indexes = {
+            'idx_downloaded_media_status': idxDownloadedMediaStatus,
+            'idx_downloaded_media_server': idxDownloadedMediaServer,
+            'idx_downloaded_media_parent': idxDownloadedMediaParent,
+            'idx_downloaded_media_grandparent': idxDownloadedMediaGrandparent,
+          };
+          for (final entry in indexes.entries) {
+            await _ignoreAlreadyExists('Index ${entry.key}', () => m.create(entry.value));
           }
         }
+        if (from < 14) {
+          appLogger.i(
+            'Adding Connections, Profiles, ProfileConnections, DownloadOwners + scope/profile columns (v14 migration)',
+          );
+
+          await m.createTable(connections);
+          await _ignoreAlreadyExists('Index idx_connections_kind', () => m.create(idxConnectionsKind));
+
+          await m.createTable(profiles);
+          await _ignoreAlreadyExists('Index idx_profiles_kind', () => m.create(idxProfilesKind));
+
+          await m.createTable(profileConnections);
+          await _ignoreAlreadyExists(
+            'Index idx_profile_connections_connection_id',
+            () => m.create(idxProfileConnectionsConnectionId),
+          );
+          await _ignoreAlreadyExists(
+            'Index idx_profile_connections_profile_id',
+            () => m.create(idxProfileConnectionsProfileId),
+          );
+
+          await _ignoreAlreadyExists('DownloadOwners table', () => m.createTable(downloadOwners));
+          await _ignoreAlreadyExists('Index idx_download_owners_profile', () => m.create(idxDownloadOwnersProfile));
+          await _ignoreAlreadyExists(
+            'Index idx_download_owners_global_key',
+            () => m.create(idxDownloadOwnersGlobalKey),
+          );
+
+          await _ignoreAlreadyExists(
+            'DownloadedMedia.clientScopeId column',
+            () => m.addColumn(downloadedMedia, downloadedMedia.clientScopeId),
+          );
+          await _ignoreAlreadyExists(
+            'OfflineWatchProgress.clientScopeId column',
+            () => m.addColumn(offlineWatchProgress, offlineWatchProgress.clientScopeId),
+          );
+          await _ignoreAlreadyExists('SyncRules.profileId column', () => m.addColumn(syncRules, syncRules.profileId));
+          await _ignoreAlreadyExists(
+            'OfflineWatchProgress.profileId column',
+            () => m.addColumn(offlineWatchProgress, offlineWatchProgress.profileId),
+          );
+
+          await customStatement('''
+            UPDATE downloaded_media
+            SET client_scope_id = (
+              SELECT id FROM connections
+              WHERE kind = 'jellyfin'
+                AND substr(id, 1, length(downloaded_media.server_id) + 1) = downloaded_media.server_id || '/'
+              LIMIT 1
+            )
+            WHERE client_scope_id IS NULL
+              AND EXISTS (
+                SELECT 1 FROM connections
+                WHERE kind = 'jellyfin'
+                  AND substr(id, 1, length(downloaded_media.server_id) + 1) = downloaded_media.server_id || '/'
+              )
+          ''');
+          await customStatement('''
+            UPDATE offline_watch_progress
+            SET client_scope_id = (
+              SELECT id FROM connections
+              WHERE kind = 'jellyfin'
+                AND substr(id, 1, length(offline_watch_progress.server_id) + 1) = offline_watch_progress.server_id || '/'
+              LIMIT 1
+            )
+            WHERE client_scope_id IS NULL
+              AND EXISTS (
+                SELECT 1 FROM connections
+                WHERE kind = 'jellyfin'
+                  AND substr(id, 1, length(offline_watch_progress.server_id) + 1) = offline_watch_progress.server_id || '/'
+              )
+          ''');
+
+          await _ignoreAlreadyExists(
+            'Index idx_offline_watch_progress_server',
+            () => m.create(idxOfflineWatchProgressServer),
+          );
+          await _ignoreAlreadyExists('Index idx_sync_rules_profile', () => m.create(idxSyncRulesProfile));
+          await _ignoreAlreadyExists(
+            'Index idx_offline_watch_progress_profile',
+            () => m.create(idxOfflineWatchProgressProfile),
+          );
+        }
+        if (from < 15) {
+          appLogger.i('Adding mediaSourceId column to DownloadedMedia (v15 migration)');
+          await _ignoreAlreadyExists(
+            'DownloadedMedia.mediaSourceId column',
+            () => m.addColumn(downloadedMedia, downloadedMedia.mediaSourceId),
+          );
+        }
       },
     );
   }
 
-  // ============================================================
-  // Offline Watch Progress Operations
-  // ============================================================
+  Future<void> _ignoreAlreadyExists(String label, Future<void> Function() operation) async {
+    try {
+      await operation();
+    } catch (e) {
+      final message = e.toString().toLowerCase();
+      if (message.contains('already exists') || message.contains('duplicate column name')) {
+        appLogger.w('$label already exists during migration: $e');
+        return;
+      }
+      rethrow;
+    }
+  }
+
+  Expression<bool> _clientScopePredicate(GeneratedColumn<String> column, String? clientScopeId) {
+    return clientScopeId == null ? column.isNull() : column.equals(clientScopeId);
+  }
+
+  Expression<bool> _nullableTextPredicate(GeneratedColumn<String> column, String? value) {
+    return value == null ? column.isNull() : column.equals(value);
+  }
 
   /// Get all pending offline watch actions for sync
-  Future<List<OfflineWatchProgressItem>> getPendingWatchActions() {
-    return (select(offlineWatchProgress)..orderBy([(t) => OrderingTerm.asc(t.createdAt)])).get();
+  Future<List<OfflineWatchProgressItem>> getPendingWatchActions({String? profileId}) {
+    final query = select(offlineWatchProgress)..orderBy([(t) => OrderingTerm.asc(t.createdAt)]);
+    if (profileId != null) {
+      query.where((t) => t.profileId.equals(profileId));
+    }
+    return query.get();
+  }
+
+  /// Claim pre-v18 offline watch actions for [profileId]. Those rows predate
+  /// profile ownership and have `NULL profile_id`; the first active profile
+  /// inherits them so already-watched offline progress is not stranded.
+  Future<void> adoptLegacyOfflineWatchActionsForProfile(String profileId) async {
+    if (profileId.isEmpty) return;
+    await (update(
+      offlineWatchProgress,
+    )..where((t) => t.profileId.isNull())).write(OfflineWatchProgressCompanion(profileId: Value(profileId)));
   }
 
   /// Get pending watch actions for a specific server
-  Future<List<OfflineWatchProgressItem>> getPendingWatchActionsForServer(String serverId) {
+  Future<List<OfflineWatchProgressItem>> getPendingWatchActionsForServer(ServerId serverId, {String? profileId}) {
     return (select(offlineWatchProgress)
-          ..where((t) => t.serverId.equals(serverId))
+          ..where(
+            (t) =>
+                t.serverId.equals(serverId) &
+                (profileId == null ? const Constant(true) : t.profileId.equals(profileId)),
+          )
           ..orderBy([(t) => OrderingTerm.asc(t.createdAt)]))
         .get();
   }
 
   /// Get the latest action for a specific item
-  Future<OfflineWatchProgressItem?> getLatestWatchAction(String globalKey) {
+  Future<OfflineWatchProgressItem?> getLatestWatchAction(
+    String globalKey, {
+    String? profileId,
+    bool filterProfile = false,
+    String? clientScopeId,
+    bool filterClientScope = false,
+  }) {
     return (select(offlineWatchProgress)
-          ..where((t) => t.globalKey.equals(globalKey))
-          ..orderBy([(t) => OrderingTerm.desc(t.updatedAt)])
+          ..where(
+            (t) =>
+                t.globalKey.equals(globalKey) &
+                (filterProfile ? _nullableTextPredicate(t.profileId, profileId) : const Constant(true)) &
+                (filterClientScope ? _clientScopePredicate(t.clientScopeId, clientScopeId) : const Constant(true)),
+          )
+          ..orderBy([(t) => OrderingTerm.desc(t.updatedAt), (t) => OrderingTerm.desc(t.id)])
           ..limit(1))
         .getSingleOrNull();
   }
 
+  Future<List<OfflineWatchProgressItem>> getWatchActionsForKey(
+    String globalKey, {
+    String? profileId,
+    bool filterProfile = false,
+    String? clientScopeId,
+    bool filterClientScope = false,
+  }) {
+    return (select(offlineWatchProgress)
+          ..where(
+            (t) =>
+                t.globalKey.equals(globalKey) &
+                (filterProfile ? _nullableTextPredicate(t.profileId, profileId) : const Constant(true)) &
+                (filterClientScope ? _clientScopePredicate(t.clientScopeId, clientScopeId) : const Constant(true)),
+          )
+          ..orderBy([(t) => OrderingTerm.desc(t.updatedAt), (t) => OrderingTerm.desc(t.id)]))
+        .get();
+  }
+
+  Future<Map<String, List<OfflineWatchProgressItem>>> getWatchActionsForKeys(
+    Set<String> globalKeys, {
+    String? profileId,
+    bool filterProfile = false,
+    Map<String, String?>? clientScopeIdsByGlobalKey,
+  }) async {
+    if (globalKeys.isEmpty) return const {};
+    final rows =
+        await (select(offlineWatchProgress)
+              ..where(
+                (t) =>
+                    t.globalKey.isIn(globalKeys) &
+                    (filterProfile ? _nullableTextPredicate(t.profileId, profileId) : const Constant(true)),
+              )
+              ..orderBy([(t) => OrderingTerm.desc(t.updatedAt), (t) => OrderingTerm.desc(t.id)]))
+            .get();
+
+    final result = <String, List<OfflineWatchProgressItem>>{};
+    for (final action in rows) {
+      if (clientScopeIdsByGlobalKey != null && clientScopeIdsByGlobalKey.containsKey(action.globalKey)) {
+        final expectedScope = clientScopeIdsByGlobalKey[action.globalKey];
+        if (!_clientScopeValuesMatch(action.clientScopeId, expectedScope)) continue;
+      }
+      result.putIfAbsent(action.globalKey, () => <OfflineWatchProgressItem>[]).add(action);
+    }
+    return result;
+  }
+
   /// Get the latest actions for multiple items in a single query
   ///
   /// Returns a map of globalKey -> latest action for each key.
   /// Keys with no actions will not be present in the returned map.
-  Future<Map<String, OfflineWatchProgressItem>> getLatestWatchActionsForKeys(Set<String> globalKeys) async {
+  Future<Map<String, OfflineWatchProgressItem>> getLatestWatchActionsForKeys(
+    Set<String> globalKeys, {
+    String? profileId,
+    bool filterProfile = false,
+    Map<String, String?>? clientScopeIdsByGlobalKey,
+  }) async {
     if (globalKeys.isEmpty) return {};
 
     // Query all actions for the given keys
     final allActions =
         await (select(offlineWatchProgress)
-              ..where((t) => t.globalKey.isIn(globalKeys))
-              ..orderBy([(t) => OrderingTerm.desc(t.updatedAt)]))
+              ..where(
+                (t) =>
+                    t.globalKey.isIn(globalKeys) &
+                    (filterProfile ? _nullableTextPredicate(t.profileId, profileId) : const Constant(true)),
+              )
+              ..orderBy([(t) => OrderingTerm.desc(t.updatedAt), (t) => OrderingTerm.desc(t.id)]))
             .get();
 
     // Group by globalKey and take the latest (first due to ordering)
     final result = <String, OfflineWatchProgressItem>{};
     for (final action in allActions) {
+      if (clientScopeIdsByGlobalKey != null && clientScopeIdsByGlobalKey.containsKey(action.globalKey)) {
+        final expectedScope = clientScopeIdsByGlobalKey[action.globalKey];
+        if (!_clientScopeValuesMatch(action.clientScopeId, expectedScope)) continue;
+      }
       // Only keep the first (latest) action for each key
       result.putIfAbsent(action.globalKey, () => action);
     }
@@ -92,69 +373,101 @@ class AppDatabase extends _$AppDatabase {
     return result;
   }
 
-  /// Insert or update a progress action (merges with existing)
-  Future<void> upsertProgressAction({
-    required String serverId,
-    required String ratingKey,
-    required int viewOffset,
-    required int duration,
-    required bool shouldMarkWatched,
-  }) async {
-    final globalKey = buildGlobalKey(serverId, ratingKey);
-    final now = DateTime.now().millisecondsSinceEpoch;
-
-    // Check for existing progress entry
-    final existing =
-        await (select(offlineWatchProgress)
-              ..where((t) => t.globalKey.equals(globalKey) & t.actionType.equals('progress'))
-              ..limit(1))
-            .getSingleOrNull();
-
-    if (existing != null) {
-      // Update existing progress entry
-      await (update(offlineWatchProgress)..where((t) => t.id.equals(existing.id))).write(
-        OfflineWatchProgressCompanion(
-          viewOffset: Value(viewOffset),
-          duration: Value(duration),
-          shouldMarkWatched: Value(shouldMarkWatched),
-          updatedAt: Value(now),
-        ),
-      );
-    } else {
-      // Insert new progress entry
-      await into(offlineWatchProgress).insert(
-        OfflineWatchProgressCompanion.insert(
-          serverId: serverId,
-          ratingKey: ratingKey,
-          globalKey: globalKey,
-          actionType: 'progress',
-          viewOffset: Value(viewOffset),
-          duration: Value(duration),
-          shouldMarkWatched: Value(shouldMarkWatched),
-          createdAt: now,
-          updatedAt: now,
-        ),
-      );
-    }
+  bool _clientScopeValuesMatch(String? actual, String? expected) {
+    final normalizedActual = actual == null || actual.isEmpty ? null : actual;
+    final normalizedExpected = expected == null || expected.isEmpty ? null : expected;
+    return normalizedActual == normalizedExpected;
   }
 
-  /// Insert a manual watch action (watched or unwatched)
-  /// Removes conflicting actions for the same item
+  /// Insert or update a progress action (merges with existing).
+  Future<void> upsertProgressAction({
+    String? profileId,
+    required ServerId serverId,
+    String? clientScopeId,
+    required String ratingKey,
+    required int viewOffset,
+    required int? duration,
+    required bool shouldMarkWatched,
+  }) async {
+    final globalKey = buildGlobalKey(ServerId(serverId), ratingKey);
+    final now = DateTime.now().millisecondsSinceEpoch;
+
+    await transaction(() async {
+      final existing =
+          await (select(offlineWatchProgress)
+                ..where(
+                  (t) =>
+                      t.globalKey.equals(globalKey) &
+                      _nullableTextPredicate(t.profileId, profileId) &
+                      _clientScopePredicate(t.clientScopeId, clientScopeId) &
+                      t.actionType.equals(OfflineActionType.progress.id),
+                )
+                ..orderBy([(t) => OrderingTerm.asc(t.id)]))
+              .get();
+
+      final keep = existing.isEmpty ? null : existing.first;
+      if (keep != null) {
+        await (update(offlineWatchProgress)..where((t) => t.id.equals(keep.id))).write(
+          OfflineWatchProgressCompanion(
+            viewOffset: Value(viewOffset),
+            duration: Value(duration),
+            shouldMarkWatched: Value(shouldMarkWatched),
+            profileId: Value(profileId),
+            clientScopeId: Value(clientScopeId),
+            updatedAt: Value(now),
+          ),
+        );
+        final duplicateIds = existing.skip(1).map((row) => row.id).toList(growable: false);
+        if (duplicateIds.isNotEmpty) {
+          await (delete(offlineWatchProgress)..where((t) => t.id.isIn(duplicateIds))).go();
+        }
+      } else {
+        await into(offlineWatchProgress).insert(
+          OfflineWatchProgressCompanion.insert(
+            serverId: serverId,
+            profileId: Value(profileId),
+            clientScopeId: Value(clientScopeId),
+            ratingKey: ratingKey,
+            globalKey: globalKey,
+            actionType: OfflineActionType.progress.id,
+            viewOffset: Value(viewOffset),
+            duration: Value(duration),
+            shouldMarkWatched: Value(shouldMarkWatched),
+            createdAt: now,
+            updatedAt: now,
+          ),
+        );
+      }
+    });
+  }
+
+  /// Insert a manual watch action (watched or unwatched).
+  /// Removes conflicting actions for the same item.
   Future<void> insertWatchAction({
-    required String serverId,
+    String? profileId,
+    required ServerId serverId,
+    String? clientScopeId,
     required String ratingKey,
     required String actionType, // 'watched' or 'unwatched'
   }) async {
-    final globalKey = buildGlobalKey(serverId, ratingKey);
+    final globalKey = buildGlobalKey(ServerId(serverId), ratingKey);
     final now = DateTime.now().millisecondsSinceEpoch;
 
     // Remove conflicting actions (opposite action type and progress)
-    await (delete(offlineWatchProgress)..where((t) => t.globalKey.equals(globalKey))).go();
+    await (delete(offlineWatchProgress)..where(
+          (t) =>
+              t.globalKey.equals(globalKey) &
+              _nullableTextPredicate(t.profileId, profileId) &
+              _clientScopePredicate(t.clientScopeId, clientScopeId),
+        ))
+        .go();
 
     // Insert the new action
     await into(offlineWatchProgress).insert(
       OfflineWatchProgressCompanion.insert(
         serverId: serverId,
+        profileId: Value(profileId),
+        clientScopeId: Value(clientScopeId),
         ratingKey: ratingKey,
         globalKey: globalKey,
         actionType: actionType,
@@ -181,10 +494,15 @@ class AppDatabase extends _$AppDatabase {
   }
 
   /// Get count of pending sync items
-  Future<int> getPendingSyncCount() async {
-    final count = await (selectOnly(offlineWatchProgress)..addColumns([offlineWatchProgress.id.count()]))
-        .map((row) => row.read(offlineWatchProgress.id.count()))
-        .getSingle();
+  Future<int> getPendingSyncCount({String? profileId, int? maxSyncAttempts}) async {
+    final query = selectOnly(offlineWatchProgress)..addColumns([offlineWatchProgress.id.count()]);
+    if (profileId != null) {
+      query.where(offlineWatchProgress.profileId.equals(profileId));
+    }
+    if (maxSyncAttempts != null) {
+      query.where(offlineWatchProgress.syncAttempts.isSmallerThanValue(maxSyncAttempts));
+    }
+    final count = await query.map((row) => row.read(offlineWatchProgress.id.count())).getSingle();
     return count ?? 0;
   }
 
@@ -193,9 +511,105 @@ class AppDatabase extends _$AppDatabase {
     return delete(offlineWatchProgress).go();
   }
 
-  // ============================================================
-  // Downloaded Media Queries for Watch State Sync
-  // ============================================================
+  Future<List<SyncRuleItem>> getSyncRules({String? profileId}) {
+    final query = select(syncRules);
+    if (profileId != null) {
+      query.where((t) => t.profileId.equals(profileId));
+    }
+    return query.get();
+  }
+
+  Future<SyncRuleItem?> getSyncRule(String globalKey) {
+    return (select(syncRules)..where((t) => t.globalKey.equals(globalKey))).getSingleOrNull();
+  }
+
+  Future<void> insertSyncRule({
+    String profileId = '',
+    required ServerId serverId,
+    required String ratingKey,
+    required String globalKey,
+    required String targetType,
+    required int episodeCount,
+    int mediaIndex = 0,
+    String downloadFilter = 'unwatched',
+  }) async {
+    // [insertOnConflictUpdate] defaults the conflict target to the primary
+    // key (`id`), which is auto-incremented — the conflict never triggers
+    // and the row's UNIQUE [globalKey] constraint blows up instead. Drive
+    // the upsert off the public [globalKey] so re-creating a rule for the same
+    // shared target updates the existing row.
+    await into(syncRules).insert(
+      SyncRulesCompanion.insert(
+        serverId: serverId,
+        profileId: Value(profileId),
+        ratingKey: ratingKey,
+        globalKey: globalKey,
+        targetType: targetType,
+        episodeCount: episodeCount,
+        createdAt: DateTime.now().millisecondsSinceEpoch,
+        mediaIndex: Value(mediaIndex),
+        downloadFilter: Value(downloadFilter),
+      ),
+      onConflict: DoUpdate(
+        (_) => SyncRulesCompanion(
+          serverId: Value(serverId),
+          profileId: Value(profileId),
+          ratingKey: Value(ratingKey),
+          targetType: Value(targetType),
+          episodeCount: Value(episodeCount),
+          mediaIndex: Value(mediaIndex),
+          downloadFilter: Value(downloadFilter),
+        ),
+        target: [syncRules.globalKey],
+      ),
+    );
+  }
+
+  /// Claim pre-v16 public sync rules for [profileId]. Rules created before
+  /// profile ownership have an empty profile id and a public global key.
+  Future<void> adoptLegacySyncRulesForProfile(String profileId) async {
+    if (profileId.isEmpty) return;
+    final legacyRules = await (select(syncRules)..where((t) => t.profileId.equals(''))).get();
+    for (final rule in legacyRules) {
+      final scopedKey = buildProfileScopedGlobalKey(profileId, ServerId(rule.serverId), rule.ratingKey);
+      final duplicate = await getSyncRule(scopedKey);
+      if (duplicate != null) {
+        await (delete(syncRules)..where((t) => t.id.equals(rule.id))).go();
+        continue;
+      }
+      await (update(syncRules)..where((t) => t.id.equals(rule.id))).write(
+        SyncRulesCompanion(profileId: Value(profileId), globalKey: Value(scopedKey)),
+      );
+    }
+  }
+
+  Future<void> updateSyncRuleCount(String globalKey, int episodeCount) async {
+    await (update(
+      syncRules,
+    )..where((t) => t.globalKey.equals(globalKey))).write(SyncRulesCompanion(episodeCount: Value(episodeCount)));
+  }
+
+  Future<void> updateSyncRuleFilter(String globalKey, String downloadFilter) async {
+    await (update(
+      syncRules,
+    )..where((t) => t.globalKey.equals(globalKey))).write(SyncRulesCompanion(downloadFilter: Value(downloadFilter)));
+  }
+
+  Future<void> updateSyncRuleEnabled(String globalKey, bool enabled) async {
+    await (update(
+      syncRules,
+    )..where((t) => t.globalKey.equals(globalKey))).write(SyncRulesCompanion(enabled: Value(enabled)));
+  }
+
+  Future<void> updateSyncRuleLastExecuted(String globalKey) async {
+    await (update(syncRules)..where((t) => t.globalKey.equals(globalKey))).write(
+      SyncRulesCompanion(lastExecutedAt: Value(DateTime.now().millisecondsSinceEpoch)),
+    );
+  }
+
+  Future<void> deleteSyncRule(String globalKey) async {
+    await (delete(syncRules)..where((t) => t.globalKey.equals(globalKey))).go();
+  }
 
   /// Get all downloaded media items (for syncing watch states)
   Future<List<DownloadedMediaItem>> getAllDownloadedMetadata() {
@@ -211,20 +625,77 @@ LazyDatabase _openConnection() {
 
     final file = File(p.join(dbFolder.path, 'plezy_downloads.db'));
 
-    // Ensure directory exists
     if (!await file.parent.exists()) {
       await file.parent.create(recursive: true);
     }
 
     // Migrate from old location on desktop (was in Documents subfolder)
     if (!Platform.isAndroid && !Platform.isIOS && !await file.exists()) {
-      final oldFolder = await getApplicationDocumentsDirectory();
-      final oldFile = File(p.join(oldFolder.path, 'plezy_downloads.db'));
-      if (await oldFile.exists()) {
-        await oldFile.rename(file.path);
-      }
+      await migrateLegacyDesktopDatabase(target: file);
     }
 
-    return NativeDatabase(file);
+    return NativeDatabase.createInBackground(
+      file,
+      setup: (db) {
+        db.execute('PRAGMA journal_mode=WAL');
+        db.execute('PRAGMA synchronous=NORMAL');
+        // Enforce ProfileConnections → Profiles/Connections cascades.
+        // SQLite requires this on every connection — it's not persisted.
+        db.execute('PRAGMA foreign_keys = ON');
+      },
+    );
   });
 }
+
+/// Move the legacy desktop DB from `Documents/` to `ApplicationSupport/`.
+/// `File.rename` only works within a single volume — Windows users with
+/// OneDrive-redirected Documents (or any cross-drive setup) hit
+/// `ERROR_NOT_SAME_DEVICE` (errno 17), and the uncaught throw used to
+/// strand the splash on "Loading servers..." forever (#1022). Falls back
+/// to copy + delete on any [FileSystemException] and swallows all errors
+/// so a failed migration never propagates fatally.
+///
+/// [sourceOverride] and [renameOverride] are test seams — production
+/// callers leave them null.
+Future<void> migrateLegacyDesktopDatabase({
+  required File target,
+  File? sourceOverride,
+  Future<void> Function(File source, String targetPath)? renameOverride,
+}) async {
+  final File oldFile;
+  if (sourceOverride != null) {
+    oldFile = sourceOverride;
+  } else {
+    final oldFolder = await getApplicationDocumentsDirectory();
+    oldFile = File(p.join(oldFolder.path, 'plezy_downloads.db'));
+  }
+  if (!await oldFile.exists()) return;
+
+  try {
+    if (renameOverride != null) {
+      await renameOverride(oldFile, target.path);
+    } else {
+      await oldFile.rename(target.path);
+    }
+    appLogger.i('Moved legacy DB from ${oldFile.path} → ${target.path}');
+    return;
+  } on FileSystemException catch (e) {
+    appLogger.w('Legacy DB rename failed (osError=${e.osError?.errorCode}); falling back to copy', error: e);
+  }
+
+  try {
+    await oldFile.copy(target.path);
+    try {
+      await oldFile.delete();
+    } catch (e) {
+      // Leaving the source behind is non-fatal — the new file is canonical.
+      appLogger.w('Legacy DB copied but old file delete failed: $e');
+    }
+    appLogger.i('Copied legacy DB from ${oldFile.path} → ${target.path}');
+  } catch (e, st) {
+    // Copy itself failed (disk full, source locked by OneDrive sync,
+    // permissions). Leave both files alone — drift will create a fresh
+    // empty DB at the new location, and a future relaunch can retry.
+    appLogger.e('Legacy DB migration failed entirely', error: e, stackTrace: st);
+  }
+}

lib/database/download_operations.dart

@@ -1,35 +1,110 @@
 import 'package:drift/drift.dart';
+import '../media/ids.dart';
 
 import 'app_database.dart';
 import '../models/download_models.dart';
+import '../profiles/profile.dart';
 
-/// Extension methods on AppDatabase for download operations
 extension DownloadDatabaseOperations on AppDatabase {
-  /// Insert a new download into the database
+  Future<void> addDownloadOwner({required String profileId, required String globalKey}) async {
+    if (profileId.isEmpty) return;
+    await into(downloadOwners).insert(
+      DownloadOwnersCompanion.insert(
+        profileId: profileId,
+        globalKey: globalKey,
+        createdAt: DateTime.now().millisecondsSinceEpoch,
+      ),
+      mode: InsertMode.insertOrIgnore,
+    );
+  }
+
+  Future<void> removeDownloadOwner({required String profileId, required String globalKey}) async {
+    await (delete(downloadOwners)..where((t) => t.profileId.equals(profileId) & t.globalKey.equals(globalKey))).go();
+  }
+
+  Future<void> removeDownloadOwnersForProfile(String profileId) async {
+    if (profileId.isEmpty) return;
+    await (delete(downloadOwners)..where((t) => t.profileId.equals(profileId))).go();
+  }
+
+  Future<Set<String>> getDownloadOwnerKeysForProfile(String profileId) async {
+    if (profileId.isEmpty) return const {};
+    final rows = await (select(downloadOwners)..where((t) => t.profileId.equals(profileId))).get();
+    return rows.map((row) => row.globalKey).toSet();
+  }
+
+  Future<int> getDownloadOwnerCount(String globalKey) async {
+    return (await _validDownloadOwnerRows(globalKey)).length;
+  }
+
+  Future<bool> hasDownloadOwner(String globalKey, {String? excludingProfileId}) async {
+    final rows = await _validDownloadOwnerRows(globalKey, excludingProfileId: excludingProfileId);
+    return rows.isNotEmpty;
+  }
+
+  Future<List<DownloadOwnerItem>> _validDownloadOwnerRows(String globalKey, {String? excludingProfileId}) async {
+    final rows = await (select(downloadOwners)..where((t) => t.globalKey.equals(globalKey))).get();
+    if (rows.isEmpty) return const [];
+    final candidates = rows
+        .where((row) => excludingProfileId == null || excludingProfileId.isEmpty || row.profileId != excludingProfileId)
+        .toList(growable: false);
+    if (candidates.isEmpty) return const [];
+
+    final localProfileRows = await select(profiles).get();
+    final localProfileIds = localProfileRows.map((row) => row.id).toSet();
+    final connectionRows = await select(connections).get();
+    final connectionIds = connectionRows.map((row) => row.id).toSet();
+    return candidates
+        .where((row) {
+          if (localProfileIds.contains(row.profileId)) return true;
+          final plexHome = parsePlexHomeProfileId(row.profileId);
+          if (plexHome != null) return connectionIds.contains(plexHome.accountConnectionId);
+          return localProfileIds.isEmpty;
+        })
+        .toList(growable: false);
+  }
+
+  /// Claim pre-v17 shared download rows for [profileId]. Rows that already
+  /// have any owner are left untouched so later profiles do not inherit them.
+  Future<void> adoptLegacyDownloadsForProfile(String profileId) async {
+    if (profileId.isEmpty) return;
+    final rows = await select(downloadedMedia).get();
+    for (final row in rows) {
+      if (await getDownloadOwnerCount(row.globalKey) == 0) {
+        await addDownloadOwner(profileId: profileId, globalKey: row.globalKey);
+      }
+    }
+  }
+
   Future<void> insertDownload({
-    required String serverId,
+    required ServerId serverId,
+    String? clientScopeId,
     required String ratingKey,
     required String globalKey,
     required String type,
     String? parentRatingKey,
     String? grandparentRatingKey,
     required int status,
+    int mediaIndex = 0,
+    String? mediaSourceId,
   }) async {
     await into(downloadedMedia).insert(
       DownloadedMediaCompanion.insert(
         serverId: serverId,
+        clientScopeId: Value(clientScopeId),
         ratingKey: ratingKey,
         globalKey: globalKey,
         type: type,
         parentRatingKey: Value(parentRatingKey),
         grandparentRatingKey: Value(grandparentRatingKey),
         status: status,
+        mediaIndex: Value(mediaIndex),
+        mediaSourceId: Value(mediaSourceId),
       ),
       mode: InsertMode.insertOrReplace,
     );
   }
 
-  /// Add item to download queue
   Future<void> addToQueue({
     required String mediaGlobalKey,
     int priority = 0,
@@ -51,7 +126,6 @@ extension DownloadDatabaseOperations on AppDatabase {
   /// Get next item from queue (highest priority, oldest first)
   /// Only returns items that are not paused
   Future<DownloadQueueItem?> getNextQueueItem() async {
-    // Join with downloadedMedia to check status and filter out paused items
     final query = select(
       downloadQueue,
     ).join([innerJoin(downloadedMedia, downloadedMedia.globalKey.equalsExp(downloadQueue.mediaGlobalKey))]);
@@ -68,14 +142,18 @@ extension DownloadDatabaseOperations on AppDatabase {
     return result?.readTable(downloadQueue);
   }
 
-  /// Update download status
   Future<void> updateDownloadStatus(String globalKey, int status) async {
     await (update(
       downloadedMedia,
     )..where((t) => t.globalKey.equals(globalKey))).write(DownloadedMediaCompanion(status: Value(status)));
   }
 
-  /// Update download progress
+  Future<void> updateDownloadMediaSource(String globalKey, String? mediaSourceId) async {
+    await (update(downloadedMedia)..where((t) => t.globalKey.equals(globalKey))).write(
+      DownloadedMediaCompanion(mediaSourceId: Value(mediaSourceId)),
+    );
+  }
+
   Future<void> updateDownloadProgress(String globalKey, int progress, int downloadedBytes, int totalBytes) async {
     await (update(downloadedMedia)..where((t) => t.globalKey.equals(globalKey))).write(
       DownloadedMediaCompanion(
@@ -86,7 +164,6 @@ extension DownloadDatabaseOperations on AppDatabase {
     );
   }
 
-  /// Update video file path
   Future<void> updateVideoFilePath(String globalKey, String filePath) async {
     await (update(downloadedMedia)..where((t) => t.globalKey.equals(globalKey))).write(
       DownloadedMediaCompanion(
@@ -96,16 +173,13 @@ extension DownloadDatabaseOperations on AppDatabase {
     );
   }
 
-  /// Update artwork paths
   Future<void> updateArtworkPaths({required String globalKey, String? thumbPath}) async {
     await (update(
       downloadedMedia,
     )..where((t) => t.globalKey.equals(globalKey))).write(DownloadedMediaCompanion(thumbPath: Value(thumbPath)));
   }
 
-  /// Update download error and increment retry count
   Future<void> updateDownloadError(String globalKey, String errorMessage) async {
-    // Get current retry count to increment it
     final existing = await getDownloadedMedia(globalKey);
     final currentCount = existing?.retryCount ?? 0;
 
@@ -114,52 +188,84 @@ extension DownloadDatabaseOperations on AppDatabase {
     );
   }
 
-  /// Clear download error and reset retry count (for retry)
   Future<void> clearDownloadError(String globalKey) async {
     await (update(downloadedMedia)..where((t) => t.globalKey.equals(globalKey))).write(
       const DownloadedMediaCompanion(errorMessage: Value(null), retryCount: Value(0)),
     );
   }
 
-  /// Remove item from queue
   Future<void> removeFromQueue(String mediaGlobalKey) async {
     await (delete(downloadQueue)..where((t) => t.mediaGlobalKey.equals(mediaGlobalKey))).go();
   }
 
-  /// Get downloaded media item
   Future<DownloadedMediaItem?> getDownloadedMedia(String globalKey) {
     return (select(downloadedMedia)..where((t) => t.globalKey.equals(globalKey))).getSingleOrNull();
   }
 
-  /// Delete a download
   Future<void> deleteDownload(String globalKey) async {
+    await (delete(downloadOwners)..where((t) => t.globalKey.equals(globalKey))).go();
     await (delete(downloadedMedia)..where((t) => t.globalKey.equals(globalKey))).go();
     await (delete(downloadQueue)..where((t) => t.mediaGlobalKey.equals(globalKey))).go();
   }
 
-  /// Get all downloaded episodes for a season
-  Future<List<DownloadedMediaItem>> getEpisodesBySeason(String seasonKey) {
-    return (select(downloadedMedia)..where((t) => t.parentRatingKey.equals(seasonKey))).get();
+  Future<List<DownloadedMediaItem>> getEpisodesBySeason(
+    String seasonKey, {
+    ServerId? serverId,
+    String? clientScopeId,
+    bool filterClientScope = false,
+  }) {
+    return (select(downloadedMedia)..where(
+          (t) =>
+              t.parentRatingKey.equals(seasonKey) &
+              _optionalServerPredicate(t.serverId, serverIdOrNull(serverId)) &
+              _optionalClientScopePredicate(t.clientScopeId, clientScopeId, filterClientScope: filterClientScope),
+        ))
+        .get();
   }
 
-  /// Get all downloaded episodes for a show
-  Future<List<DownloadedMediaItem>> getEpisodesByShow(String showKey) {
-    return (select(downloadedMedia)..where((t) => t.grandparentRatingKey.equals(showKey))).get();
+  Future<List<DownloadedMediaItem>> getEpisodesByShow(
+    String showKey, {
+    ServerId? serverId,
+    String? clientScopeId,
+    bool filterClientScope = false,
+  }) {
+    return (select(downloadedMedia)..where(
+          (t) =>
+              t.grandparentRatingKey.equals(showKey) &
+              _optionalServerPredicate(t.serverId, serverIdOrNull(serverId)) &
+              _optionalClientScopePredicate(t.clientScopeId, clientScopeId, filterClientScope: filterClientScope),
+        ))
+        .get();
   }
 
-  /// Get all downloaded items for a specific server
-  Future<List<DownloadedMediaItem>> getDownloadsByServerId(String serverId) {
+  Future<List<DownloadedMediaItem>> getDownloadsByServerId(ServerId serverId) {
     return (select(downloadedMedia)..where((t) => t.serverId.equals(serverId))).get();
   }
 
-  /// Update the background_downloader task ID for a download
+  Expression<bool> _optionalServerPredicate(GeneratedColumn<String> column, ServerId? serverId) {
+    return serverId == null ? const Constant(true) : column.equals(serverId);
+  }
+
+  Expression<bool> _optionalClientScopePredicate(
+    GeneratedColumn<String> column,
+    String? clientScopeId, {
+    required bool filterClientScope,
+  }) {
+    if (!filterClientScope && (clientScopeId == null || clientScopeId.isEmpty)) {
+      return const Constant(true);
+    }
+    if (clientScopeId == null || clientScopeId.isEmpty) {
+      return column.isNull() | column.equals('');
+    }
+    return column.equals(clientScopeId);
+  }
+
   Future<void> updateBgTaskId(String globalKey, String? taskId) async {
     await (update(
       downloadedMedia,
     )..where((t) => t.globalKey.equals(globalKey))).write(DownloadedMediaCompanion(bgTaskId: Value(taskId)));
   }
 
-  /// Get the background_downloader task ID for a download
   Future<String?> getBgTaskId(String globalKey) async {
     final item = await getDownloadedMedia(globalKey);
     return item?.bgTaskId;

lib/database/tables.dart

@@ -1,12 +1,12 @@
 import 'package:drift/drift.dart';
 
-/// Key-value cache table for Plex API responses.
+/// Key-value cache table for media-server API responses (Plex, Jellyfin).
 /// Used for offline support - stores raw JSON responses.
 class ApiCache extends Table {
-  /// Composite key: serverId:endpoint (e.g., "abc123:/library/metadata/12345")
+  /// Composite key: serverId:endpoint (e.g., "abc123:/library/metadata/12345"
+  /// for Plex, "abc123:/Users/.../Items/..." for Jellyfin)
   TextColumn get cacheKey => text()();
 
-  /// JSON response data
   TextColumn get data => text()();
 
   /// Whether this item is pinned for offline access
@@ -30,9 +30,19 @@ class DownloadQueue extends Table {
 }
 
 @DataClassName('DownloadedMediaItem')
+@TableIndex(name: 'idx_downloaded_media_status', columns: {#status})
+@TableIndex(name: 'idx_downloaded_media_server', columns: {#serverId})
+@TableIndex(name: 'idx_downloaded_media_parent', columns: {#parentRatingKey})
+@TableIndex(name: 'idx_downloaded_media_grandparent', columns: {#grandparentRatingKey})
 class DownloadedMedia extends Table {
   IntColumn get id => integer().autoIncrement()();
   TextColumn get serverId => text()();
+  // Downloads are intentionally app-wide/shared, keyed by the public
+  // serverId:ratingKey globalKey below. For Jellyfin, clientScopeId records
+  // which scoped client produced the cached metadata/download request; it is
+  // not part of download ownership and must not be used to hide or duplicate
+  // the physical downloaded item per user/profile.
+  TextColumn get clientScopeId => text().nullable()();
   TextColumn get ratingKey => text()();
   TextColumn get globalKey => text().unique()();
   TextColumn get type => text()();
@@ -48,20 +58,176 @@ class DownloadedMedia extends Table {
   TextColumn get errorMessage => text().nullable()();
   IntColumn get retryCount => integer().withDefault(const Constant(0))();
   TextColumn get bgTaskId => text().nullable()();
+  IntColumn get mediaIndex => integer().withDefault(const Constant(0))();
+  TextColumn get mediaSourceId => text().nullable()();
+}
+
+/// Profile ownership for shared physical downloads.
+///
+/// [DownloadedMedia] stores one physical row per public serverId:ratingKey so
+/// files are deduped across profiles. This table controls which active profile
+/// can see/use that shared row.
+@DataClassName('DownloadOwnerItem')
+@TableIndex(name: 'idx_download_owners_profile', columns: {#profileId})
+@TableIndex(name: 'idx_download_owners_global_key', columns: {#globalKey})
+class DownloadOwners extends Table {
+  TextColumn get profileId => text()();
+  TextColumn get globalKey => text()();
+  IntColumn get createdAt => integer()();
+
+  @override
+  Set<Column> get primaryKey => {profileId, globalKey};
+}
+
+/// Persistent sync rules for auto-downloading unwatched episodes.
+///
+/// Each rule keeps a rolling window of N unwatched episodes for a show/season,
+/// or mirrors the current contents of a collection/playlist.
+/// Rules are owned by the active top-level profile. Downloads remain app-wide
+/// and shared by public serverId:ratingKey identity, but rule ownership must not
+/// cross users because Jellyfin permissions and watch state are user-scoped.
+@DataClassName('SyncRuleItem')
+@TableIndex(name: 'idx_sync_rules_profile', columns: {#profileId})
+class SyncRules extends Table {
+  IntColumn get id => integer().autoIncrement()();
+  TextColumn get profileId => text().withDefault(const Constant(''))();
+  TextColumn get serverId => text()();
+  TextColumn get ratingKey => text()();
+  TextColumn get globalKey => text().unique()();
+  TextColumn get targetType => text()(); // 'show', 'season', 'collection', 'playlist'
+  IntColumn get episodeCount => integer()();
+  BoolColumn get enabled => boolean().withDefault(const Constant(true))();
+  IntColumn get createdAt => integer()();
+  IntColumn get lastExecutedAt => integer().nullable()();
+  IntColumn get mediaIndex => integer().withDefault(const Constant(0))();
+  TextColumn get downloadFilter => text().withDefault(const Constant('unwatched'))();
+}
+
+/// Persisted media-server connections.
+///
+/// One row per "connection" the user has added — a Plex account (with its
+/// discovered servers and active Home profile) or a single Jellyfin server.
+/// The [configJson] payload is backend-specific and parsed by the
+/// [Connection] sealed class.
+@DataClassName('ConnectionRow')
+@TableIndex(name: 'idx_connections_kind', columns: {#kind})
+class Connections extends Table {
+  /// Stable identifier for the connection. For Plex it's a generated UUID
+  /// (one per account); for Jellyfin it's the server's machineId.
+  TextColumn get id => text()();
+
+  /// Backend kind: `'plex'` or `'jellyfin'`.
+  TextColumn get kind => text()();
+
+  /// User-visible label (account email, server name).
+  TextColumn get displayName => text()();
+
+  /// Backend-specific config payload (token, baseUrl, profile id, …).
+  TextColumn get configJson => text()();
+
+  /// Whether this is the default connection used at app launch when only
+  /// one connection is present.
+  BoolColumn get isDefault => boolean().withDefault(const Constant(false))();
+
+  /// Timestamp this connection was added (milliseconds since epoch).
+  IntColumn get createdAt => integer()();
+
+  /// Timestamp of the most-recent successful auth refresh (milliseconds
+  /// since epoch). Null until the first successful auth.
+  IntColumn get lastAuthenticatedAt => integer().nullable()();
+
+  @override
+  Set<Column> get primaryKey => {id};
+}
+
+/// Top-level profiles — see [Profile].
+///
+/// A profile is the user-facing identity. Plex Home users auto-surface as
+/// `kind='plex_home'` rows when their parent Plex account is added; users
+/// can also create `kind='local'` rows manually. Each profile owns one or
+/// more connections via [ProfileConnections].
+@DataClassName('ProfileRow')
+@TableIndex(name: 'idx_profiles_kind', columns: {#kind})
+class Profiles extends Table {
+  /// Stable identifier. For Plex Home profiles: `plex-home-{accountId}-{homeUserUuid}`
+  /// (deterministic so re-discovery is idempotent). For locals: `local-{uuid}`.
+  TextColumn get id => text()();
+
+  /// `'local'` | `'plex_home'`.
+  TextColumn get kind => text()();
+
+  TextColumn get displayName => text()();
+
+  /// Plex Home users have a thumb URL; locals fall back to initials/colour.
+  TextColumn get avatarThumbUrl => text().nullable()();
+
+  /// Per-kind config:
+  /// - `local`: `{ "pinHash": "..." }`
+  /// - `plex_home`: `{ "restricted": bool, "admin": bool, "hasPassword": bool, "parentConnectionId": "..." }`
+  TextColumn get configJson => text()();
+
+  IntColumn get sortOrder => integer().withDefault(const Constant(0))();
+  IntColumn get createdAt => integer()();
+  IntColumn get lastUsedAt => integer().nullable()();
+
+  @override
+  Set<Column> get primaryKey => {id};
+}
+
+/// Many-to-many join between [Profiles] and [Connections], carrying the
+/// per-profile user-level token used when the profile is active.
+///
+/// For Plex: `userToken` is a Home-user token from `/home/users/{uuid}/switch`,
+/// `userIdentifier` is the Plex Home user UUID. An empty `userToken` is a
+/// lazy-fetch sentinel — the binder calls `/switch` on first activation.
+/// The Dart-side [ProfileConnection] model surfaces empty as `null`; the
+/// column stays non-nullable here to avoid a schema migration.
+///
+/// For Jellyfin: `userToken` mirrors the Connection's accessToken (one user
+/// per Jellyfin connection) and `userIdentifier` is the Jellyfin user id.
+@DataClassName('ProfileConnectionRow')
+@TableIndex(name: 'idx_profile_connections_connection_id', columns: {#connectionId})
+@TableIndex(name: 'idx_profile_connections_profile_id', columns: {#profileId})
+class ProfileConnections extends Table {
+  // No FK on profile_id: Plex Home profiles are virtual (built by
+  // Profile.virtualPlexHome from PlexHomeService's live cache, never
+  // persisted in `profiles`), so an FK here would reject every join row
+  // they need. The two profile-delete sites clean up join rows manually
+  // via ProfileConnectionRegistry.removeAllForProfile before calling
+  // ProfileRegistry.remove.
+  TextColumn get profileId => text()();
+  TextColumn get connectionId => text().references(Connections, #id, onDelete: KeyAction.cascade)();
+  TextColumn get userToken => text().withDefault(const Constant(''))();
+  TextColumn get userIdentifier => text()();
+  BoolColumn get isDefault => boolean().withDefault(const Constant(false))();
+  IntColumn get tokenAcquiredAt => integer().nullable()();
+  IntColumn get lastUsedAt => integer().nullable()();
+
+  @override
+  Set<Column> get primaryKey => {profileId, connectionId};
 }
 
 /// Queue for offline watch progress and manual watch actions.
 ///
 /// Stores watch progress updates and manual watch/unwatch actions
-/// that need to be synced to the Plex server when back online.
+/// that need to be synced to the originating media server when back online.
 @DataClassName('OfflineWatchProgressItem')
+@TableIndex(name: 'idx_offline_watch_progress_server', columns: {#serverId})
+@TableIndex(name: 'idx_offline_watch_progress_profile', columns: {#profileId})
 class OfflineWatchProgress extends Table {
   /// Auto-incrementing primary key
   IntColumn get id => integer().autoIncrement()();
 
+  /// Active Plezy profile that owns this queued action.
+  TextColumn get profileId => text().nullable()();
+
   /// Server ID this media belongs to
   TextColumn get serverId => text()();
 
+  /// Optional user-scoped client/cache id for backends where [serverId] is
+  /// shared by multiple users on the same server.
+  TextColumn get clientScopeId => text().nullable()();
+
   /// Rating key of the media item
   TextColumn get ratingKey => text()();
 

lib/exceptions/media_server_exceptions.dart

@@ -0,0 +1,104 @@
+import 'dart:async';
+import 'dart:io';
+
+import 'package:http/http.dart';
+
+/// Sealed base for backend-agnostic media-server exceptions. Both Plex and
+/// Jellyfin auth/HTTP layers throw subtypes from this hierarchy so consumers
+/// can catch with one filter and match exhaustively when they care which
+/// failure mode it is.
+sealed class MediaServerException implements Exception {
+  final String message;
+  const MediaServerException(this.message);
+
+  @override
+  String toString() => '$runtimeType: $message';
+}
+
+/// The supplied base URL is unreachable, returns the wrong shape, or doesn't
+/// look like the expected backend at all. Surfaces in onboarding probes
+/// (Jellyfin `/System/Info/Public`, Plex resource discovery).
+class MediaServerUrlException extends MediaServerException {
+  const MediaServerUrlException(super.message);
+}
+
+/// Authentication failed — bad password, expired token, disabled user,
+/// rate-limit. [statusCode] is the HTTP status when the failure was a 4xx
+/// response; null for transport-layer auth signals (e.g. token rejected
+/// during refresh).
+class MediaServerAuthException extends MediaServerException {
+  final int? statusCode;
+  const MediaServerAuthException(super.message, {this.statusCode});
+}
+
+/// Auth polling reached a terminal server-side expiry/rejection state before
+/// the user completed the external sign-in flow.
+class MediaServerPinExpiredException extends MediaServerAuthException {
+  const MediaServerPinExpiredException() : super('PIN expired before sign-in');
+}
+
+/// HTTP transport / non-2xx errors. Carries the status code (when known),
+/// the parsed response body, and the originating URI so callers can log
+/// useful diagnostics. Both Plex and Jellyfin route their HTTP failures
+/// through this type — it's the canonical backend-agnostic transport
+/// exception.
+enum MediaServerHttpErrorType { connectionTimeout, receiveTimeout, connectionError, cancelled, unknown }
+
+class MediaServerHttpException extends MediaServerException {
+  final MediaServerHttpErrorType type;
+  final int? statusCode;
+  final dynamic responseData;
+  final Uri? requestUri;
+
+  MediaServerHttpException({required this.type, String? message, this.statusCode, this.responseData, this.requestUri})
+    : super(message ?? '');
+
+  /// Map a caught exception to a [MediaServerHttpException].
+  factory MediaServerHttpException.from(Object error, {Uri? uri}) {
+    return switch (error) {
+      MediaServerHttpException() => error,
+      RequestAbortedException(:final message, uri: final errorUri) => MediaServerHttpException(
+        type: MediaServerHttpErrorType.cancelled,
+        message: message,
+        requestUri: errorUri ?? uri,
+      ),
+      TimeoutException(:final message) => MediaServerHttpException(
+        type: MediaServerHttpErrorType.connectionTimeout,
+        message: message,
+        requestUri: uri,
+      ),
+      SocketException(:final message) => MediaServerHttpException(
+        type: MediaServerHttpErrorType.connectionError,
+        message: message,
+        requestUri: uri,
+      ),
+      HttpException(:final message) => MediaServerHttpException(
+        type: MediaServerHttpErrorType.connectionError,
+        message: message,
+        requestUri: uri,
+      ),
+      ClientException(:final message, uri: final errorUri) => MediaServerHttpException(
+        type: MediaServerHttpErrorType.connectionError,
+        message: message,
+        requestUri: errorUri ?? uri,
+      ),
+      _ => MediaServerHttpException(type: MediaServerHttpErrorType.unknown, message: error.toString(), requestUri: uri),
+    };
+  }
+
+  /// Whether the error looks transient (network/timeout) and worth retrying.
+  bool get isTransient =>
+      type == MediaServerHttpErrorType.connectionTimeout ||
+      type == MediaServerHttpErrorType.connectionError ||
+      type == MediaServerHttpErrorType.receiveTimeout;
+
+  @override
+  String toString() {
+    final parts = <String>[type.name];
+    if (statusCode != null) parts.add('HTTP $statusCode');
+    if (message.isNotEmpty) parts.add(message);
+    final uri = requestUri;
+    if (uri != null) parts.add('${uri.host}${uri.path}');
+    return 'MediaServerHttpException(${parts.join(': ')})';
+  }
+}

lib/focus/dpad_navigator.dart

@@ -1,13 +1,29 @@
+import 'dart:ui' as ui;
+
 import 'package:flutter/services.dart';
 
-/// Extension on KeyEvent for common event type checks.
 extension KeyEventActionable on KeyEvent {
-  /// Whether this event should trigger an action (KeyDownEvent or KeyRepeatEvent).
-  /// Use this to filter out KeyUpEvents early in key handlers.
   bool get isActionable => this is KeyDownEvent || this is KeyRepeatEvent;
+  bool get isPhysicalKeyboardEvent => deviceType == ui.KeyEventDeviceType.keyboard;
+  // Only true keyboard submit keys belong here. LogicalKeyboardKey.select is
+  // a TV-remote / dpad-center key (Android DPAD_CENTER, tvOS UIPressTypeSelect)
+  // — USB keyboards never emit it. The custom Flutter tvOS engine reports its
+  // synthesized Siri Remote presses with deviceType=keyboard, so classifying
+  // select-with-keyboard-deviceType as a "keyboard enter" would route center
+  // dpad through TextField submit and skip the TV virtual keyboard.
+  bool get isPhysicalKeyboardEnter =>
+      deviceType == ui.KeyEventDeviceType.keyboard &&
+      (logicalKey == LogicalKeyboardKey.enter || logicalKey == LogicalKeyboardKey.numpadEnter);
+
+  bool get isTvSelectEvent {
+    // Dpad-center / gamepad-A are TV-remote-only — always treat as TV select,
+    // regardless of the deviceType claim from the engine.
+    if (logicalKey == LogicalKeyboardKey.select || logicalKey == LogicalKeyboardKey.gameButtonA) return true;
+    if (isPhysicalKeyboardEvent) return false;
+    return logicalKey == LogicalKeyboardKey.enter || logicalKey == LogicalKeyboardKey.numpadEnter;
+  }
 }
 
-/// Shared sets for keyboard key categories.
 final _dpadDirectionKeys = {
   LogicalKeyboardKey.arrowUp,
   LogicalKeyboardKey.arrowDown,
@@ -31,35 +47,18 @@ final _backKeys = {
 
 final _contextMenuKeys = {LogicalKeyboardKey.contextMenu, LogicalKeyboardKey.gameButtonX};
 
-/// Extension methods for checking D-pad related keys.
 extension DpadKeyExtension on LogicalKeyboardKey {
-  /// Whether this key is a D-pad directional key.
   bool get isDpadDirection => _dpadDirectionKeys.contains(this);
-
-  /// Whether this key is a select/activate key.
   bool get isSelectKey => _selectKeys.contains(this);
-
-  /// Whether this key is a back/cancel key.
   bool get isBackKey => _backKeys.contains(this);
-
-  /// Whether this key is a context menu key.
   bool get isContextMenuKey => _contextMenuKeys.contains(this);
 
-  /// Whether this key is a navigation key (dpad, select, back, context menu, tab).
-  /// Use this to distinguish navigation keys from typing/volume/media keys.
   bool get isNavigationKey =>
       isDpadDirection || isSelectKey || isBackKey || isContextMenuKey || this == LogicalKeyboardKey.tab;
 
-  /// Whether this key moves focus left.
   bool get isLeftKey => this == LogicalKeyboardKey.arrowLeft;
-
-  /// Whether this key moves focus right.
   bool get isRightKey => this == LogicalKeyboardKey.arrowRight;
-
-  /// Whether this key moves focus up.
   bool get isUpKey => this == LogicalKeyboardKey.arrowUp;
-
-  /// Whether this key moves focus down.
   bool get isDownKey => this == LogicalKeyboardKey.arrowDown;
 }