diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/home/component/HomeSectionRemovalFocusTest.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/home/component/HomeSectionRemovalFocusTest.kt
index b0f67d1b..085988e3 100644
--- a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/home/component/HomeSectionRemovalFocusTest.kt
+++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/home/component/HomeSectionRemovalFocusTest.kt
@@ -248,8 +248,6 @@ internal class HomeSectionRemovalFocusTest {
                         onAction = {},
                         tabRouter = tabRouter,
                         tabAppRouterHolder = tabAppRouterHolder,
-                        onSearchClick = {},
-                        onSettingsClick = {},
                     )
                 }
             }
diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/main/toptabs/TopTabDetailsBackFocusTest.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/main/toptabs/TopTabDetailsBackFocusTest.kt
index eaeee731..446b35a5 100644
--- a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/main/toptabs/TopTabDetailsBackFocusTest.kt
+++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/main/toptabs/TopTabDetailsBackFocusTest.kt
@@ -357,8 +357,6 @@ private data object TopTabDetailsProbeHostScreen : PuberScreen {
             onAction = {},
             tabRouter = TopTabDetailsProbeHost.requireTabRouter(),
             tabAppRouterHolder = TopTabDetailsProbeHost.requireTabAppRouterHolder(),
-            onSearchClick = {},
-            onSettingsClick = {},
         )
     }
 }
diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/main/toptabs/TopTabMainContentHistoryFocusTest.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/main/toptabs/TopTabMainContentHistoryFocusTest.kt
index 04f3be16..463c110a 100644
--- a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/main/toptabs/TopTabMainContentHistoryFocusTest.kt
+++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/main/toptabs/TopTabMainContentHistoryFocusTest.kt
@@ -218,8 +218,6 @@ private data object TopTabHistoryProbeHostScreen : PuberScreen {
             onAction = {},
             tabRouter = requireNotNull(TopTabHistoryProbeHost.tabRouter),
             tabAppRouterHolder = requireNotNull(TopTabHistoryProbeHost.tabAppRouterHolder),
-            onSearchClick = {},
-            onSettingsClick = {},
         )
     }
 }
diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/main/toptabs/TopTabRapidSwitchingFocusTest.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/main/toptabs/TopTabRapidSwitchingFocusTest.kt
index 56a99067..12767b38 100644
--- a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/main/toptabs/TopTabRapidSwitchingFocusTest.kt
+++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/main/toptabs/TopTabRapidSwitchingFocusTest.kt
@@ -196,8 +196,6 @@ private fun RapidSwitchingHost(
         },
         tabRouter = tabRouter,
         tabAppRouterHolder = tabAppRouterHolder,
-        onSearchClick = {},
-        onSettingsClick = {},
     )
 }
 
diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerScreenContentFocusTest.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerScreenContentFocusTest.kt
index 30135997..38afb041 100644
--- a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerScreenContentFocusTest.kt
+++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerScreenContentFocusTest.kt
@@ -525,7 +525,7 @@ internal class PlayerScreenContentFocusTest : PlayerComposeInstrumentationTestCa
         playPauseIndicator = null,
         audioTracks = listOf(AudioTrackUIState(0, "Русский", "ru")),
         selectedAudioTrackIndex = 0,
-        subtitleTracks = listOf(SubtitleTrackUIState(0, "Выкл.", "", "")),
+        subtitleTracks = listOf(SubtitleTrackUIState("Выкл.", "", "")),
         selectedSubtitleIndex = 0,
         soundModes = listOf(SoundModeUIState(0, FIXTURE_SOUND_MODE)),
         selectedSoundModeIndex = 0,
diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerScreenE2ETest.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerScreenE2ETest.kt
index a86355ed..87d9548a 100644
--- a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerScreenE2ETest.kt
+++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/component/PlayerScreenE2ETest.kt
@@ -140,7 +140,7 @@ internal class PlayerScreenE2ETest : PlayerComposeInstrumentationTestCase() {
                 assertFocusedTag(PlayerScreenTestTags.AudioSubtitles, "audio/subtitle button")
             }
 
-            step("Select Spanish audio and external subtitles through typed panel items") {
+            step("Select Spanish audio and the API subtitle marked embedded through typed panel items") {
                 robot.press(PlayerRemoteKey.Select)
                 assertFocusedPanelItem("sound", 0)
                 robot.press(PlayerRemoteKey.Right)
@@ -156,10 +156,9 @@ internal class PlayerScreenE2ETest : PlayerComposeInstrumentationTestCase() {
                 robot.press(PlayerRemoteKey.Right)
                 assertFocusedPanelItem("subtitle", 1)
                 robot.press(PlayerRemoteKey.Select)
-                awaitPlayerCondition("external subtitle is persisted and selected in Media3") {
+                awaitPlayerCondition("API subtitle marked embedded is persisted and selected in Media3") {
                     preferredSubtitleLanguage() == SUBTITLE_LANGUAGE &&
-                        selectedTextTrack() &&
-                        preferredTextLanguages().contains(SUBTITLE_LANGUAGE)
+                        selectedTextTrack()
                 }
                 robot.pressBack()
                 assertFocusedTag(PlayerScreenTestTags.AudioSubtitles, "audio/subtitle button")
@@ -226,8 +225,7 @@ internal class PlayerScreenE2ETest : PlayerComposeInstrumentationTestCase() {
                 }
                 awaitPlayerCondition("recreated Media3 restores audio and subtitle choices") {
                     selectedAudioLanguage() == SPANISH_LANGUAGE &&
-                        selectedTextTrack() &&
-                        preferredTextLanguages().contains(SUBTITLE_LANGUAGE)
+                        selectedTextTrack()
                 }
             }
 
@@ -705,9 +703,6 @@ private class PlayerE2EFixture(
             .any { it.isSelected }
     } == true
 
-    fun preferredTextLanguages(): List<String> =
-        uiPlayerRead { trackSelectionParameters.preferredTextLanguages.toList() }.orEmpty()
-
     fun awaitPlayerReady() {
         awaitPlayerCondition("Media3 READY without PlayerScreen error") {
             uiPlayerRead { playbackState } == Player.STATE_READY
@@ -1170,7 +1165,8 @@ private class PlayerE2EFixture(
                 "lang": "$SUBTITLE_LANGUAGE",
                 "url": "${mediaUrl(
                     "${media.high}/subtitle.vtt?signature=screen-test&scenario=$scenarioToken",
-                )}"
+                )}",
+                "embed": true
               }],
               "watching": {"time": $watchingTime, "duration": 4, "status": 0}
             }]
diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerDeviceTest.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerDeviceTest.kt
index 82165c94..ee006bfa 100644
--- a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerDeviceTest.kt
+++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerDeviceTest.kt
@@ -15,6 +15,7 @@ import androidx.test.core.app.ActivityScenario
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.platform.app.InstrumentationRegistry
 import com.kino.puber.data.repository.PlayerPreferencesRepository
+import com.kino.puber.domain.interactor.player.StreamSource
 import com.kino.puber.playertestfixtures.FixtureId
 import com.kino.puber.playertestfixtures.PlayerTestFixtures
 import com.kino.puber.playertestfixtures.network.LoopbackNetworkJournal
@@ -306,14 +307,20 @@ internal class PlaybackControllerDeviceTest : PlayerInstrumentationTestCase() {
         startPositionMs: Long? = null,
     ): PlayerProbe {
         val probe = PlayerProbe()
-        val streamUrl = when (fixture) {
-            FixtureId.ProgressiveMp4 -> loopbackUrl("/media/progressive.mp4")
-            FixtureId.HlsMaster -> loopbackUrl("/media/hls/master.m3u8")
+        val stream = when (fixture) {
+            FixtureId.ProgressiveMp4 -> StreamSource(
+                url = loopbackUrl("/media/progressive.mp4"),
+                isHls = false,
+            )
+            FixtureId.HlsMaster -> StreamSource(
+                url = loopbackUrl("/media/hls/master.m3u8"),
+                isHls = true,
+            )
             else -> error("Unsupported device fixture: $fixture")
         }
         scenario.onActivity {
             controller.prepare(
-                streamUrl = streamUrl,
+                stream = stream,
                 subtitles = null,
                 startPosition = startPositionMs,
                 bufferPreset = BufferPreset.SMALL,
diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerNetworkTracksTest.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerNetworkTracksTest.kt
index 92c8271c..e0ed1f8f 100644
--- a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerNetworkTracksTest.kt
+++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerNetworkTracksTest.kt
@@ -20,6 +20,7 @@ import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.platform.app.InstrumentationRegistry
 import com.kino.puber.data.api.models.SubtitleLink
 import com.kino.puber.data.repository.PlayerPreferencesRepository
+import com.kino.puber.domain.interactor.player.StreamSource
 import com.kino.puber.playertestfixtures.FixtureId
 import com.kino.puber.playertestfixtures.PlayerTestFixtures
 import com.kino.puber.playertestfixtures.network.LoopbackNetworkJournal
@@ -122,11 +123,11 @@ internal class PlaybackControllerNetworkTracksTest : PlayerInstrumentationTestCa
     }
 
     @Test
-    fun hlsTracks_selectsAudioAndSubtitle_observesCueAndDisablesText() = run {
+    fun hlsTracks_sideLoadsApiSubtitleMarkedEmbedded_selectsCueAndDisablesText() = run {
         lateinit var probe: PlayerProbe
         lateinit var subtitleUrl: String
 
-        step("Prepare HLS with two AAC renditions and side-loaded WebVTT") {
+        step("Prepare HLS with two AAC renditions and API WebVTT marked embedded") {
             server.reset(commonHlsRoutes())
             subtitleUrl = loopbackUrl("/media/subtitle.vtt?signature=test-signature")
             probe = prepare(
@@ -135,6 +136,7 @@ internal class PlaybackControllerNetworkTracksTest : PlayerInstrumentationTestCa
                     SubtitleLink(
                         lang = "en",
                         url = subtitleUrl,
+                        embed = true,
                     ),
                 ),
             )
@@ -158,7 +160,6 @@ internal class PlaybackControllerNetworkTracksTest : PlayerInstrumentationTestCa
 
         step("Select the external WebVTT track without losing audio selection") {
             val subtitle = SubtitleTrackUIState(
-                index = 1,
                 label = "English",
                 language = "en",
                 url = subtitleUrl,
@@ -263,7 +264,7 @@ internal class PlaybackControllerNetworkTracksTest : PlayerInstrumentationTestCa
             highUrl = loopbackUrl("/media/hls/quality-high.m3u8")
             val subtitleUrl = loopbackUrl("/media/subtitle.vtt?scenario=quality-switch")
             subtitle = SubtitleLink(lang = "en", url = subtitleUrl)
-            subtitleTrack = SubtitleTrackUIState(1, "English", "en", subtitleUrl)
+            subtitleTrack = SubtitleTrackUIState(label = "English", language = "en", url = subtitleUrl)
             probe = prepare("/media/hls/quality-low.m3u8", listOf(subtitle))
         }
 
@@ -291,7 +292,9 @@ internal class PlaybackControllerNetworkTracksTest : PlayerInstrumentationTestCa
             runOnPlayer { controller.pause() }
             awaitCondition("paused switch source") { !isPlaying() }
             pausedPosition = currentPosition()
-            runOnPlayer { controller.switchStream(highUrl, listOf(subtitle)) }
+            runOnPlayer {
+                controller.switchStream(StreamSource(url = highUrl, isHls = true), listOf(subtitle))
+            }
             awaitCondition("high quality source prepared") {
                 currentMediaPath() == "/media/hls/quality-high.m3u8" &&
                     playbackState() == Player.STATE_READY
@@ -312,9 +315,9 @@ internal class PlaybackControllerNetworkTracksTest : PlayerInstrumentationTestCa
                 isPlaying() && playbackIntent() == PlaybackIntent.PlayRequested
             }
             runOnPlayer {
-                controller.switchStream(lowUrl, listOf(subtitle))
-                controller.switchStream(highUrl, listOf(subtitle))
-                controller.switchStream(lowUrl, listOf(subtitle))
+                controller.switchStream(StreamSource(url = lowUrl, isHls = true), listOf(subtitle))
+                controller.switchStream(StreamSource(url = highUrl, isHls = true), listOf(subtitle))
+                controller.switchStream(StreamSource(url = lowUrl, isHls = true), listOf(subtitle))
             }
             awaitCondition("last rapid switch wins") {
                 currentMediaPath() == "/media/hls/quality-low.m3u8" &&
@@ -344,7 +347,7 @@ internal class PlaybackControllerNetworkTracksTest : PlayerInstrumentationTestCa
         step("Prepare the first progressive source with external WebVTT") {
             server.reset(commonHlsRoutes())
             subtitleUrl = loopbackUrl("/media/subtitle.vtt")
-            subtitle = SubtitleTrackUIState(1, "English", "en", subtitleUrl)
+            subtitle = SubtitleTrackUIState(label = "English", language = "en", url = subtitleUrl)
             first = prepare(
                 path = "/media/progressive-a.mp4",
                 subtitles = listOf(SubtitleLink(lang = "en", url = subtitleUrl)),
@@ -365,7 +368,7 @@ internal class PlaybackControllerNetworkTracksTest : PlayerInstrumentationTestCa
             val secondUrl = loopbackUrl("/media/progressive-b.mp4")
             runOnPlayer {
                 controller.switchStream(
-                    streamUrl = secondUrl,
+                    stream = StreamSource(url = secondUrl, isHls = false),
                     subtitles = listOf(SubtitleLink(lang = "en", url = subtitleUrl)),
                 )
             }
@@ -643,7 +646,10 @@ internal class PlaybackControllerNetworkTracksTest : PlayerInstrumentationTestCa
         val streamUrl = loopbackUrl(path)
         scenario.onActivity {
             controller.prepare(
-                streamUrl = streamUrl,
+                stream = StreamSource(
+                    url = streamUrl,
+                    isHls = path.endsWith(".m3u8", ignoreCase = true),
+                ),
                 subtitles = subtitles,
                 startPosition = 0L,
                 bufferPreset = BufferPreset.SMALL,
diff --git a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerResourcesTest.kt b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerResourcesTest.kt
index 6f07f47c..eb95e480 100644
--- a/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerResourcesTest.kt
+++ b/app/src/androidTest/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerResourcesTest.kt
@@ -20,6 +20,7 @@ import androidx.test.core.app.ActivityScenario
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.platform.app.InstrumentationRegistry
 import com.kino.puber.data.repository.PlayerPreferencesRepository
+import com.kino.puber.domain.interactor.player.StreamSource
 import com.kino.puber.playertestfixtures.FixtureId
 import com.kino.puber.playertestfixtures.PlayerTestFixtures
 import com.kino.puber.playertestfixtures.network.LoopbackNetworkJournal
@@ -30,6 +31,7 @@ import com.kino.puber.profile.PlayerTestControl
 import com.kino.puber.ui.feature.player.PlayerInstrumentationTestCase
 import com.kino.puber.ui.feature.player.model.AudioTrackUIState
 import com.kino.puber.ui.feature.player.model.BufferPreset
+import com.kino.puber.ui.feature.player.model.SubtitleTrackUIState
 import java.io.File
 import java.io.IOException
 import java.util.UUID
@@ -408,7 +410,7 @@ internal class PlaybackControllerResourcesTest : PlayerInstrumentationTestCase()
         val probe = PlayerProbe()
         scenario.onActivity {
             controller.prepare(
-                streamUrl = url,
+                stream = StreamSource(url = url, isHls = false),
                 subtitles = null,
                 startPosition = 0L,
                 bufferPreset = BufferPreset.SMALL,
@@ -674,7 +676,11 @@ internal class PlaybackControllerResourcesTest : PlayerInstrumentationTestCase()
             record("ended")
         }
 
-        override fun onTracksUpdated(audioTracks: List<AudioTrackUIState>, selectedIndex: Int) {
+        override fun onTracksUpdated(
+            audioTracks: List<AudioTrackUIState>,
+            selectedIndex: Int,
+            subtitleTracks: List<SubtitleTrackUIState>,
+        ) {
             record("tracks:${audioTracks.size}:$selectedIndex")
         }
 
diff --git a/app/src/main/java/com/kino/puber/data/api/models/Models.kt b/app/src/main/java/com/kino/puber/data/api/models/Models.kt
index 4dc26ade..c9b917cd 100644
--- a/app/src/main/java/com/kino/puber/data/api/models/Models.kt
+++ b/app/src/main/java/com/kino/puber/data/api/models/Models.kt
@@ -374,7 +374,11 @@ data class SubtitleLink(
     val url: String,
     val shift: Int? = null,
     val embed: Boolean? = null,
-)
+    val forced: Boolean? = null,
+    val file: String? = null,
+) {
+    fun shouldSideLoad(isHls: Boolean): Boolean = isHls || embed != true
+}
 
 @Serializable
 data class TVChannel(
diff --git a/app/src/main/java/com/kino/puber/domain/interactor/player/PlayerInteractor.kt b/app/src/main/java/com/kino/puber/domain/interactor/player/PlayerInteractor.kt
index c56fee77..af4df984 100644
--- a/app/src/main/java/com/kino/puber/domain/interactor/player/PlayerInteractor.kt
+++ b/app/src/main/java/com/kino/puber/domain/interactor/player/PlayerInteractor.kt
@@ -16,6 +16,15 @@ import kotlinx.coroutines.CancellationException
 private const val WATCHED_STATUS = 1
 private const val UNWATCHED_STATUS = 0
 
+/**
+ * The stream to play, with the container the API published it under.
+ * [isHls] is taken from the field the url came from rather than guessed from its text.
+ */
+internal data class StreamSource(
+    val url: String,
+    val isHls: Boolean,
+)
+
 internal data class ResolvedMedia(
     val files: List<VideoFile>?,
     val audios: List<Audio>?,
@@ -191,11 +200,11 @@ internal class PlayerInteractor(
         }
     }
 
-    fun selectStreamUrl(files: List<VideoFile>?, qualityIndex: Int): String? {
-        return selectBaseStreamUrl(files, qualityIndex)?.let(::withSurroundAudioPreference)
+    fun selectStreamUrl(files: List<VideoFile>?, qualityIndex: Int): StreamSource? {
+        return selectBaseStreamUrl(files, qualityIndex)?.withSurroundAudioPreference()
     }
 
-    private fun selectBaseStreamUrl(files: List<VideoFile>?, qualityIndex: Int): String? {
+    private fun selectBaseStreamUrl(files: List<VideoFile>?, qualityIndex: Int): StreamSource? {
         if (files.isNullOrEmpty()) return null
         return if (qualityIndex == 0) {
             selectAutoStreamUrl(files)
@@ -204,22 +213,29 @@ internal class PlayerInteractor(
         }
     }
 
-    private fun selectAutoStreamUrl(files: List<VideoFile>): String? {
-        val url = files.firstOrNull()?.url
-        return url?.hls4 ?: url?.hls ?: url?.http
+    private fun selectAutoStreamUrl(files: List<VideoFile>): StreamSource? {
+        val url = files.firstOrNull()?.url ?: return null
+        return hlsSource(url.hls4) ?: hlsSource(url.hls) ?: progressiveSource(url.http)
     }
 
-    private fun selectManualStreamUrl(files: List<VideoFile>, qualityIndex: Int): String? {
+    private fun selectManualStreamUrl(files: List<VideoFile>, qualityIndex: Int): StreamSource? {
         val uniqueFiles = files.distinctBy { it.quality ?: "${it.h}p" }
             .sortedByDescending { it.qualityId ?: 0 }
-        val url = (uniqueFiles.getOrNull(qualityIndex - 1) ?: files.first()).url
-        return url?.hls ?: url?.hls4 ?: url?.http
+        val url = (uniqueFiles.getOrNull(qualityIndex - 1) ?: files.first()).url ?: return null
+        return hlsSource(url.hls) ?: hlsSource(url.hls4) ?: progressiveSource(url.http)
     }
 
-    private fun withSurroundAudioPreference(baseUrl: String): String {
-        if (!playerPreferencesRepository.preferSurroundAudio) return baseUrl
-        val separator = if ("?" in baseUrl) "&" else "?"
-        return "${baseUrl}${separator}ac3default=1"
+    private fun hlsSource(url: String?): StreamSource? =
+        url?.let { StreamSource(url = it, isHls = true) }
+
+    // The progressive field is trusted unless it plainly carries a playlist.
+    private fun progressiveSource(url: String?): StreamSource? =
+        url?.let { StreamSource(url = it, isHls = it.substringBefore('?').endsWith(".m3u8", true)) }
+
+    private fun StreamSource.withSurroundAudioPreference(): StreamSource {
+        if (!playerPreferencesRepository.preferSurroundAudio) return this
+        val separator = if ("?" in url) "&" else "?"
+        return copy(url = "$url${separator}ac3default=1")
     }
 
     private fun findFirstUnwatchedEpisode(item: Item): Pair<Int, Int>? {
diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerPreview.kt b/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerPreview.kt
index a04a62c9..6291405b 100644
--- a/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerPreview.kt
+++ b/app/src/main/java/com/kino/puber/ui/feature/player/component/PlayerPreview.kt
@@ -39,11 +39,11 @@ private val previewAudioTracks = listOf(
 )
 
 private val previewSubtitleTracks = listOf(
-    SubtitleTrackUIState(0, "Выкл.", "", ""),
-    SubtitleTrackUIState(1, "Русские", "ru", "https://example.com/ru.vtt"),
-    SubtitleTrackUIState(2, "Русские для слабослышащих", "ru", "https://example.com/ru-sdh.vtt"),
-    SubtitleTrackUIState(3, "English", "en", "https://example.com/en.vtt"),
-    SubtitleTrackUIState(4, "Узбекские · Созданы нейросетью", "uz", "https://example.com/uz.vtt"),
+    SubtitleTrackUIState("Выкл.", "", ""),
+    SubtitleTrackUIState("Русские", "ru", "https://example.com/ru.vtt"),
+    SubtitleTrackUIState("Русские для слабослышащих", "ru", "https://example.com/ru-sdh.vtt"),
+    SubtitleTrackUIState("English", "en", "https://example.com/en.vtt"),
+    SubtitleTrackUIState("Узбекские · Созданы нейросетью", "uz", "https://example.com/uz.vtt"),
 )
 
 private val previewSoundModes = listOf(
diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/model/PlayerUIMapper.kt b/app/src/main/java/com/kino/puber/ui/feature/player/model/PlayerUIMapper.kt
index 6b894570..2855e274 100644
--- a/app/src/main/java/com/kino/puber/ui/feature/player/model/PlayerUIMapper.kt
+++ b/app/src/main/java/com/kino/puber/ui/feature/player/model/PlayerUIMapper.kt
@@ -40,33 +40,19 @@ internal class PlayerUIMapper(
     fun mapSubtitleTracks(subtitles: List<SubtitleLink>?): List<SubtitleTrackUIState> {
         val result = mutableListOf(
             SubtitleTrackUIState(
-                index = 0,
                 label = context.getString(R.string.player_subtitles_off),
                 language = "",
                 url = "",
             )
         )
-        val duplicateLanguages = subtitles
-            ?.groupingBy { it.lang }
-            ?.eachCount()
-            ?.filterValues { it > 1 }
-            ?.keys
-            .orEmpty()
-        val duplicateLanguageCounters = mutableMapOf<String, Int>()
-        subtitles?.forEachIndexed { index, sub ->
-            val duplicateIndex = duplicateLanguageCounters.compute(sub.lang) { _, count ->
-                count?.inc() ?: 1
-            } ?: 1
+        subtitles?.forEach { sub ->
             result.add(
                 SubtitleTrackUIState(
-                    index = index + 1,
-                    label = if (sub.lang in duplicateLanguages) {
-                        context.getString(R.string.player_subtitle_variant_label, sub.lang, duplicateIndex)
-                    } else {
-                        sub.lang
-                    },
+                    label = sub.lang,
                     language = sub.lang,
                     url = sub.url,
+                    isForced = sub.forced,
+                    sourceFile = sub.file,
                 )
             )
         }
diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/model/PlayerUIModels.kt b/app/src/main/java/com/kino/puber/ui/feature/player/model/PlayerUIModels.kt
index 40e3a284..28d9b4d8 100644
--- a/app/src/main/java/com/kino/puber/ui/feature/player/model/PlayerUIModels.kt
+++ b/app/src/main/java/com/kino/puber/ui/feature/player/model/PlayerUIModels.kt
@@ -11,12 +11,30 @@ internal data class AudioTrackUIState(
 
 @Immutable
 internal data class SubtitleTrackUIState(
-    val index: Int,
     val label: String,
     val language: String,
     val url: String,
+    val isForced: Boolean? = null,
+    val sourceFile: String? = null,
+    /** Raw manifest/container label, kept to disambiguate same-language variants. */
+    val descriptiveLabel: String? = null,
+    val playerTrackId: String? = null,
+    /** Media3 `TrackGroup.id`, unique per group once side-loaded subtitles are merged. */
+    val playerTrackGroupId: String? = null,
+    val playerTrackUri: String? = null,
+    val playerGroupIndex: Int? = null,
+    val playerTrackIndex: Int? = null,
 )
 
+internal val SubtitleTrackUIState.isOff: Boolean
+    get() = language.isEmpty() &&
+        url.isEmpty() &&
+        playerTrackId == null &&
+        playerTrackGroupId == null &&
+        playerTrackUri == null &&
+        playerGroupIndex == null &&
+        playerTrackIndex == null
+
 @Immutable
 internal data class SoundModeUIState(
     val index: Int,
diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/vm/AudioTrackPreferenceResolver.kt b/app/src/main/java/com/kino/puber/ui/feature/player/vm/AudioTrackPreferenceResolver.kt
index ea841129..b606bf9c 100644
--- a/app/src/main/java/com/kino/puber/ui/feature/player/vm/AudioTrackPreferenceResolver.kt
+++ b/app/src/main/java/com/kino/puber/ui/feature/player/vm/AudioTrackPreferenceResolver.kt
@@ -2,6 +2,7 @@ package com.kino.puber.ui.feature.player.vm
 
 import com.kino.puber.ui.feature.player.model.AudioTrackUIState
 import com.kino.puber.ui.feature.player.model.SubtitleTrackUIState
+import com.kino.puber.ui.feature.player.model.isOff
 
 internal class AudioTrackPreferenceResolver {
 
@@ -25,31 +26,47 @@ internal class AudioTrackPreferenceResolver {
         tracks: List<SubtitleTrackUIState>,
         preferredLang: String?,
         preferredUrl: String?,
+        preferredPlayerTrackId: String? = null,
+        preferredPlayerGroupIndex: Int? = null,
+        preferredPlayerTrackIndex: Int? = null,
     ): Int {
         val matchers = listOf(
-            { exactSubtitleUrlMatch(tracks, preferredUrl) },
-            { stableSubtitleUrlMatch(tracks, preferredUrl) },
-            { unambiguousSubtitleLanguageMatch(tracks, preferredLang) },
+            { subtitleIdentityMatch(tracks, preferredUrl) },
+            { subtitleIdentityMatch(tracks, preferredPlayerTrackId) },
+            {
+                playerCoordinatesMatch(
+                    tracks,
+                    preferredPlayerGroupIndex,
+                    preferredPlayerTrackIndex,
+                )
+            },
+            { subtitleLanguageMatch(tracks, preferredLang) },
         )
         return matchers.firstNotNullOfOrNull { matcher ->
             matcher().takeIf { it >= 0 }
         } ?: NO_MATCH
     }
 
-    private fun exactSubtitleUrlMatch(
+    private fun subtitleIdentityMatch(
         tracks: List<SubtitleTrackUIState>,
-        preferredUrl: String?,
+        preferredIdentity: String?,
     ): Int {
-        if (preferredUrl == null) return NO_MATCH
-        return tracks.indexOfFirst { it.url == preferredUrl }
+        if (preferredIdentity.isNullOrEmpty()) return NO_MATCH
+        return tracks.withIndex().filter { (_, track) ->
+            track.identities.any { identity -> sameSubtitleIdentity(identity, preferredIdentity) }
+        }.singleOrNull()?.index ?: NO_MATCH
     }
 
-    private fun stableSubtitleUrlMatch(
+    private fun playerCoordinatesMatch(
         tracks: List<SubtitleTrackUIState>,
-        preferredUrl: String?,
+        preferredGroupIndex: Int?,
+        preferredTrackIndex: Int?,
     ): Int {
-        val preferredKey = preferredUrl?.stableSubtitleKey() ?: return NO_MATCH
-        return tracks.indexOfFirst { it.url.stableSubtitleKey() == preferredKey }
+        if (preferredGroupIndex == null || preferredTrackIndex == null) return NO_MATCH
+        return tracks.withIndex().filter { (_, track) ->
+            track.playerGroupIndex == preferredGroupIndex &&
+                track.playerTrackIndex == preferredTrackIndex
+        }.singleOrNull()?.index ?: NO_MATCH
     }
 
     private fun exactLabelMatch(
@@ -89,13 +106,17 @@ internal class AudioTrackPreferenceResolver {
         return tracks.indexOfFirst { it.language == preferredLang }
     }
 
-    private fun unambiguousSubtitleLanguageMatch(
+    private fun subtitleLanguageMatch(
         tracks: List<SubtitleTrackUIState>,
         preferredLang: String?,
     ): Int {
         if (preferredLang == null) return NO_MATCH
-        val matches = tracks.withIndex().filter { it.value.language == preferredLang }
-        return matches.singleOrNull()?.index ?: NO_MATCH
+        if (preferredLang.isEmpty()) return tracks.indexOfFirst { it.isOff }
+        val matches = tracks.withIndex().filter {
+            sameSubtitleLanguage(it.value.language, preferredLang)
+        }
+        val manifestMatches = matches.filter { it.value.playerTrackId != null }
+        return manifestMatches.singleOrNull()?.index ?: matches.singleOrNull()?.index ?: NO_MATCH
     }
 
     /** Extracts voice type from HLS labels like "03. Многоголосый. Red Head Sound (RUS)". */
@@ -114,3 +135,7 @@ internal class AudioTrackPreferenceResolver {
         val NUMBER_PREFIX_REGEX = Regex("""^\d+\.\s*""")
     }
 }
+
+private val SubtitleTrackUIState.identities: List<String>
+    get() = listOfNotNull(url, sourceFile, playerTrackUri, playerTrackId)
+        .filter { it.isNotEmpty() }
diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlaybackController.kt b/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlaybackController.kt
index 8d0977b8..9f21c063 100644
--- a/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlaybackController.kt
+++ b/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlaybackController.kt
@@ -17,26 +17,34 @@ import androidx.media3.datasource.DataSource
 import androidx.media3.datasource.cache.CacheDataSource
 import androidx.media3.datasource.okhttp.OkHttpDataSource
 import androidx.media3.exoplayer.DefaultLoadControl
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.media3.exoplayer.hls.HlsManifest
+import androidx.media3.exoplayer.hls.playlist.HlsMultivariantPlaylist
 import androidx.media3.exoplayer.mediacodec.MediaCodecRenderer
 import androidx.media3.exoplayer.source.BehindLiveWindowException
-import androidx.media3.extractor.DefaultExtractorsFactory
-import okhttp3.OkHttpClient
-import androidx.media3.exoplayer.ExoPlayer
+import androidx.media3.exoplayer.source.DefaultMediaSourceFactory
 import androidx.media3.exoplayer.trackselection.AdaptiveTrackSelection
 import androidx.media3.exoplayer.trackselection.DefaultTrackSelector
 import androidx.media3.exoplayer.upstream.DefaultBandwidthMeter
-import androidx.media3.exoplayer.source.DefaultMediaSourceFactory
+import androidx.media3.extractor.DefaultExtractorsFactory
 import com.kino.puber.BuildConfig
 import com.kino.puber.R
 import com.kino.puber.data.api.models.SubtitleLink
 import com.kino.puber.data.repository.PlayerPreferencesRepository
+import com.kino.puber.domain.interactor.player.StreamSource
 import com.kino.puber.ui.feature.player.model.AudioTrackUIState
 import com.kino.puber.ui.feature.player.model.BufferPreset
 import com.kino.puber.ui.feature.player.model.SubtitleTrackUIState
+import com.kino.puber.ui.feature.player.model.isOff
+import okhttp3.OkHttpClient
 
 internal interface PlaybackControl {
     interface Callback : PlaybackEventSink {
-        fun onTracksUpdated(audioTracks: List<AudioTrackUIState>, selectedIndex: Int)
+        fun onTracksUpdated(
+            audioTracks: List<AudioTrackUIState>,
+            selectedIndex: Int,
+            subtitleTracks: List<SubtitleTrackUIState> = emptyList(),
+        )
         fun onError(message: String)
     }
 
@@ -49,14 +57,14 @@ internal interface PlaybackControl {
 
     fun setCallback(callback: Callback)
     fun prepare(
-        streamUrl: String,
+        stream: StreamSource,
         subtitles: List<SubtitleLink>?,
         startPosition: Long?,
         bufferPreset: BufferPreset = BufferPreset.AUTO,
         fastDns: Boolean = true,
     )
 
-    fun switchStream(streamUrl: String, subtitles: List<SubtitleLink>?)
+    fun switchStream(stream: StreamSource, subtitles: List<SubtitleLink>?)
     fun play()
     fun pause()
     fun seekTo(positionMs: Long)
@@ -82,6 +90,7 @@ internal class PlaybackController(
     private val ac3FallbackPolicy = Ac3FallbackPolicy()
     private val callbackGate = PlaybackCallbackGate()
     private val mediaItemFactory = PlaybackMediaItemFactory()
+    private val subtitleTrackSelector = SubtitleTrackSelector()
 
     @OptIn(UnstableApi::class)
     private val bandwidthMeter = DefaultBandwidthMeter.Builder(context).build()
@@ -174,7 +183,7 @@ internal class PlaybackController(
 
     @OptIn(UnstableApi::class)
     override fun prepare(
-        streamUrl: String,
+        stream: StreamSource,
         subtitles: List<SubtitleLink>?,
         startPosition: Long?,
         bufferPreset: BufferPreset,
@@ -234,8 +243,7 @@ internal class PlaybackController(
         exoPlayer = player
         bindCallbackSession(player)
 
-        val mediaItem = buildMediaItem(streamUrl, subtitles)
-        setMediaSource(player, mediaItem, streamUrl)
+        setMediaSource(player, buildMediaItem(stream, subtitles), stream)
 
         player.prepare()
         if (startPosition != null) {
@@ -259,13 +267,13 @@ internal class PlaybackController(
         ).setExperimentalEnableHagcPlayback(playerPreferencesRepository.hagcPlaybackEnabled)
     }
 
-    override fun switchStream(streamUrl: String, subtitles: List<SubtitleLink>?) {
+    override fun switchStream(stream: StreamSource, subtitles: List<SubtitleLink>?) {
         val player = exoPlayer ?: return
         bindCallbackSession(player)
         val engine = ExoPlayerPlaybackEngine(player)
         PlaybackTransitions.switchStream(
             engine = engine,
-            streamUrl = streamUrl,
+            stream = stream,
             subtitles = subtitles,
         )
         notifyPlaybackState()
@@ -317,7 +325,7 @@ internal class PlaybackController(
 
     override fun selectSubtitle(track: SubtitleTrackUIState?) {
         val player = exoPlayer ?: return
-        if (track == null || track.url.isEmpty()) {
+        if (track == null || track.isOff) {
             pendingSubtitleTrack = null
             player.trackSelectionParameters = player.trackSelectionParameters
                 .buildUpon()
@@ -340,6 +348,7 @@ internal class PlaybackController(
         exoPlayer = null
         trackSelector = null
         dataSourceFactory = null
+        pendingSubtitleTrack = null
     }
 
     @OptIn(UnstableApi::class)
@@ -359,8 +368,8 @@ internal class PlaybackController(
         player.playWhenReady = true
     }
 
-    private fun buildMediaItem(streamUrl: String, subtitles: List<SubtitleLink>?): MediaItem {
-        return mediaItemFactory.build(streamUrl, subtitles)
+    private fun buildMediaItem(stream: StreamSource, subtitles: List<SubtitleLink>?): MediaItem {
+        return mediaItemFactory.build(stream, subtitles)
     }
 
     @OptIn(UnstableApi::class)
@@ -381,19 +390,17 @@ internal class PlaybackController(
     }
 
     @OptIn(UnstableApi::class)
-    private fun setMediaSource(player: ExoPlayer, mediaItem: MediaItem, streamUrl: String) {
+    private fun setMediaSource(player: ExoPlayer, mediaItem: MediaItem, stream: StreamSource) {
         val dsFactory = dataSourceFactory ?: return
-        if (streamUrl.contains(".m3u8") || streamUrl.contains("hls")) {
-            val hlsMediaItem = mediaItem.buildUpon()
-                .setMimeType(MimeTypes.APPLICATION_M3U8)
-                .build()
-            val hlsSource = createMediaSourceFactory(dsFactory)
-                .setLoadErrorHandlingPolicy(HlsErrorPolicy())
-                .createMediaSource(hlsMediaItem)
-            player.setMediaSource(hlsSource)
-        } else {
+        if (!stream.isHls) {
             player.setMediaItem(mediaItem)
+            return
         }
+
+        val hlsSource = createMediaSourceFactory(dsFactory)
+            .setLoadErrorHandlingPolicy(HlsErrorPolicy())
+            .createMediaSource(mediaItem)
+        player.setMediaSource(hlsSource)
     }
 
     data class DebugInfo(
@@ -504,8 +511,8 @@ internal class PlaybackController(
             player.stop()
         }
 
-        override fun setMediaSource(streamUrl: String, subtitles: List<SubtitleLink>?) {
-            setMediaSource(player, buildMediaItem(streamUrl, subtitles), streamUrl)
+        override fun setMediaSource(stream: StreamSource, subtitles: List<SubtitleLink>?) {
+            setMediaSource(player, buildMediaItem(stream, subtitles), stream)
         }
 
         override fun restoreTrackSelection() {
@@ -537,8 +544,8 @@ internal class PlaybackController(
     private fun notifyTracksUpdated(callback: PlaybackControl.Callback?) {
         val player = exoPlayer ?: return
         val audioGroups = player.currentTracks.groups.filter { it.type == C.TRACK_TYPE_AUDIO }
-        if (audioGroups.isEmpty()) return
-
+        val textGroups = player.currentTracks.groups.filter { it.type == C.TRACK_TYPE_TEXT }
+        if (audioGroups.isEmpty() && textGroups.isEmpty()) return
         val audioTracks = audioGroups.mapIndexed { index, group ->
             val format = group.getTrackFormat(0)
             val label = format.label ?: format.language ?: "Track ${index + 1}"
@@ -549,7 +556,83 @@ internal class PlaybackController(
             )
         }
         val selectedIndex = audioGroups.indexOfFirst { it.isSelected }.coerceAtLeast(0)
-        callback?.onTracksUpdated(audioTracks, selectedIndex)
+        val hlsSubtitles = (player.currentManifest as? HlsManifest)
+            ?.multivariantPlaylist
+            ?.subtitles
+            .orEmpty()
+        callback?.onTracksUpdated(
+            audioTracks,
+            selectedIndex,
+            buildSubtitleTracks(textGroups, hlsSubtitles),
+        )
+    }
+
+    private fun buildSubtitleTracks(
+        textGroups: List<Tracks.Group>,
+        hlsSubtitles: List<HlsMultivariantPlaylist.Rendition>,
+    ): List<SubtitleTrackUIState> {
+        var flatIndex = 0
+        val textTrackCount = textGroups.sumOf { it.length }
+        return textGroups.flatMapIndexed { groupIndex, group ->
+            (0 until group.length).map { trackIndex ->
+                val format = group.getTrackFormat(trackIndex)
+                buildSubtitleTrack(
+                    format = format,
+                    hlsRendition = findHlsRendition(
+                        format = format,
+                        renditionIndex = flatIndex++,
+                        textTrackCount = textTrackCount,
+                        hlsSubtitles = hlsSubtitles,
+                    ),
+                    groupIndex = groupIndex,
+                    trackIndex = trackIndex,
+                    groupId = group.mediaTrackGroup.id,
+                )
+            }
+        }
+    }
+
+    private fun findHlsRendition(
+        format: Format,
+        renditionIndex: Int,
+        textTrackCount: Int,
+        hlsSubtitles: List<HlsMultivariantPlaylist.Rendition>,
+    ): HlsMultivariantPlaylist.Rendition? {
+        return hlsSubtitles.filter { rendition ->
+            format.id != null && rendition.format.id == format.id
+        }.singleOrNull() ?: hlsSubtitles.filter { rendition ->
+            rendition.format.label == format.label &&
+                sameSubtitleLanguage(
+                    rendition.format.language.orEmpty(),
+                    format.language.orEmpty(),
+                )
+        }.singleOrNull() ?: hlsSubtitles.getOrNull(renditionIndex)
+            .takeIf { hlsSubtitles.size == textTrackCount }
+    }
+
+    private fun buildSubtitleTrack(
+        format: Format,
+        hlsRendition: HlsMultivariantPlaylist.Rendition?,
+        groupIndex: Int,
+        trackIndex: Int,
+        groupId: String,
+    ): SubtitleTrackUIState {
+        val identityFormat = hlsRendition?.format
+        val language = format.language ?: identityFormat?.language.orEmpty()
+        // SubtitleLabeler builds every visible label once the full track list is known.
+        return SubtitleTrackUIState(
+            label = "",
+            language = language,
+            url = "",
+            descriptiveLabel = format.label ?: identityFormat?.label,
+            isForced = (format.selectionFlags or (identityFormat?.selectionFlags ?: 0)) and
+                C.SELECTION_FLAG_FORCED != 0,
+            playerTrackId = format.id ?: identityFormat?.id,
+            playerTrackGroupId = groupId,
+            playerTrackUri = hlsRendition?.url?.toString(),
+            playerGroupIndex = groupIndex,
+            playerTrackIndex = trackIndex,
+        )
     }
 
     private fun applyPendingSubtitleSelection() {
@@ -558,86 +641,34 @@ internal class PlaybackController(
 
     private fun applySubtitleTrackSelection(track: SubtitleTrackUIState) {
         val player = exoPlayer ?: return
-        val stableKey = track.url.stableSubtitleKey()
         val textGroups = player.currentTracks.groups.filter { it.type == C.TRACK_TYPE_TEXT }
-        val target = findTextTrack(track, stableKey, textGroups)
-        val builder = player.trackSelectionParameters
+        val target = subtitleTrackSelector.select(track, textGroups.toPlayerTextTracks())
+            ?: return
+        val targetGroup = textGroups.getOrNull(target.groupIndex) ?: return
+        player.trackSelectionParameters = player.trackSelectionParameters
             .buildUpon()
             .clearOverridesOfType(C.TRACK_TYPE_TEXT)
             .setTrackTypeDisabled(C.TRACK_TYPE_TEXT, false)
-            .setPreferredTextLanguage(track.language)
-        if (target != null) {
-            builder.setOverrideForType(
-                TrackSelectionOverride(target.group.mediaTrackGroup, target.trackIndex),
+            .setOverrideForType(
+                TrackSelectionOverride(targetGroup.mediaTrackGroup, target.trackIndex),
             )
-        }
-        player.trackSelectionParameters = builder.build()
-    }
-
-    private fun findTextTrack(
-        track: SubtitleTrackUIState,
-        stableKey: String,
-        textGroups: List<Tracks.Group>,
-    ): TextTrackSelection? {
-        return findTextTrackBy(textGroups) { format ->
-            format.id == track.url
-        } ?: findTextTrackBy(textGroups) { format ->
-            format.id == stableKey || format.label == stableKey
-        } ?: findTextTrackBySubtitleIndex(textGroups, track.index)
-        ?: findUnambiguousTextTrackByLanguage(textGroups, track.language)
-    }
-
-    // Media3 may not expose SubtitleConfiguration id/label for every source type.
-    // The current track list still preserves the subtitle configuration order.
-    private fun findTextTrackBySubtitleIndex(
-        textGroups: List<Tracks.Group>,
-        subtitleIndex: Int,
-    ): TextTrackSelection? {
-        val targetIndex = subtitleIndex - 1
-        if (targetIndex < 0) return null
-        return textGroups
-            .flatMap { group ->
-                (0 until group.length).map { trackIndex ->
-                    TextTrackSelection(group = group, trackIndex = trackIndex)
-                }
-            }
-            .getOrNull(targetIndex)
-    }
-
-    private fun findUnambiguousTextTrackByLanguage(
-        textGroups: List<Tracks.Group>,
-        language: String,
-    ): TextTrackSelection? {
-        if (language.isEmpty()) return null
-        val matches = textGroups.flatMap { group ->
-            (0 until group.length).mapNotNull { trackIndex ->
-                group.getTrackFormat(trackIndex).takeIf { format ->
-                    format.language == language
-                }?.let {
-                    TextTrackSelection(group = group, trackIndex = trackIndex)
-                }
-            }
-        }
-        return matches.singleOrNull()
+            .build()
     }
 
-    private fun findTextTrackBy(
-        textGroups: List<Tracks.Group>,
-        predicate: (Format) -> Boolean,
-    ): TextTrackSelection? {
-        return textGroups.firstNotNullOfOrNull { group ->
-            (0 until group.length).firstNotNullOfOrNull { trackIndex ->
-                group.getTrackFormat(trackIndex).takeIf(predicate)?.let {
-                    TextTrackSelection(group = group, trackIndex = trackIndex)
-                }
+    private fun List<Tracks.Group>.toPlayerTextTracks(): List<PlayerTextTrack> =
+        flatMapIndexed { groupIndex, group ->
+            (0 until group.length).map { trackIndex ->
+                val format = group.getTrackFormat(trackIndex)
+                PlayerTextTrack(
+                    groupId = group.mediaTrackGroup.id,
+                    groupIndex = groupIndex,
+                    trackIndex = trackIndex,
+                    formatId = format.id,
+                    formatLabel = format.label,
+                    language = format.language,
+                )
             }
         }
-    }
-
-    private data class TextTrackSelection(
-        val group: Tracks.Group,
-        val trackIndex: Int,
-    )
 
     private companion object {
         const val MIN_DURATION_FOR_QUALITY_INCREASE_MS = 10_000
diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlaybackMediaItemFactory.kt b/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlaybackMediaItemFactory.kt
index 7b0bb6d3..e78b1d28 100644
--- a/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlaybackMediaItemFactory.kt
+++ b/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlaybackMediaItemFactory.kt
@@ -4,22 +4,29 @@ import androidx.core.net.toUri
 import androidx.media3.common.MediaItem
 import androidx.media3.common.MimeTypes
 import com.kino.puber.data.api.models.SubtitleLink
+import com.kino.puber.domain.interactor.player.StreamSource
 import java.util.Locale
 
 internal class PlaybackMediaItemFactory {
 
-    fun build(streamUrl: String, subtitles: List<SubtitleLink>?): MediaItem {
-        val builder = MediaItem.Builder().setUri(streamUrl)
-        if (!subtitles.isNullOrEmpty()) {
-            val subtitleConfigs = subtitles.map { subtitle ->
-                val stableKey = subtitle.url.stableSubtitleKey()
-                MediaItem.SubtitleConfiguration.Builder(subtitle.url.toUri())
-                    .setMimeType(subtitleMimeType(subtitle.url))
-                    .setLanguage(subtitle.lang)
-                    .setLabel(stableKey)
-                    .setId(stableKey)
-                    .build()
-            }
+    fun build(stream: StreamSource, subtitles: List<SubtitleLink>?): MediaItem {
+        val builder = MediaItem.Builder().setUri(stream.url)
+        if (stream.isHls) {
+            builder.setMimeType(MimeTypes.APPLICATION_M3U8)
+        }
+        // `embed` describes the original source container. KinoPub's generated HLS
+        // manifest may omit that track, so HLS keeps every API subtitle as a fallback.
+        val subtitleConfigs = subtitles.orEmpty().mapNotNull { subtitle ->
+            if (!subtitle.shouldSideLoad(stream.isHls)) return@mapNotNull null
+            val stableKey = subtitle.url.stableSubtitleKey()
+            MediaItem.SubtitleConfiguration.Builder(subtitle.url.toUri())
+                .setMimeType(subtitleMimeType(subtitle.url))
+                .setLanguage(subtitle.lang)
+                .setLabel(stableKey)
+                .setId(stableKey)
+                .build()
+        }
+        if (subtitleConfigs.isNotEmpty()) {
             builder.setSubtitleConfigurations(subtitleConfigs)
         }
         return builder.build()
diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlaybackTransitions.kt b/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlaybackTransitions.kt
index 788c4a57..27108f86 100644
--- a/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlaybackTransitions.kt
+++ b/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlaybackTransitions.kt
@@ -1,6 +1,7 @@
 package com.kino.puber.ui.feature.player.vm
 
 import com.kino.puber.data.api.models.SubtitleLink
+import com.kino.puber.domain.interactor.player.StreamSource
 
 internal interface PlaybackEnginePort {
     val isPlaying: Boolean
@@ -13,7 +14,7 @@ internal interface PlaybackEnginePort {
     var trackSelectionParameters: Any
 
     fun stop()
-    fun setMediaSource(streamUrl: String, subtitles: List<SubtitleLink>?)
+    fun setMediaSource(stream: StreamSource, subtitles: List<SubtitleLink>?)
     fun restoreTrackSelection()
     fun prepare()
     fun seekTo(positionMs: Long)
@@ -30,7 +31,7 @@ internal interface PlaybackEventSink {
 internal object PlaybackTransitions {
     fun switchStream(
         engine: PlaybackEnginePort,
-        streamUrl: String,
+        stream: StreamSource,
         subtitles: List<SubtitleLink>?,
     ) {
         val savedPosition = engine.currentPosition
@@ -39,7 +40,7 @@ internal object PlaybackTransitions {
         val shouldResume = engine.snapshot().shouldResumeAfterStreamSwitch
 
         engine.stop()
-        engine.setMediaSource(streamUrl, subtitles)
+        engine.setMediaSource(stream, subtitles)
         engine.trackSelectionParameters = savedTrackSelectionParameters
         engine.restoreTrackSelection()
         engine.setPlayWhenReady(shouldResume)
diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlayerVM.kt b/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlayerVM.kt
index c90933a9..24b5ecbf 100644
--- a/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlayerVM.kt
+++ b/app/src/main/java/com/kino/puber/ui/feature/player/vm/PlayerVM.kt
@@ -26,6 +26,8 @@ import com.kino.puber.domain.interactor.player.WatchedDetailsRefreshException
 import com.kino.puber.ui.feature.player.model.SkipSegmentUIState
 import com.kino.puber.ui.feature.player.model.ActivePanel
 import com.kino.puber.ui.feature.player.model.AudioTrackUIState
+import com.kino.puber.ui.feature.player.model.SubtitleTrackUIState
+import com.kino.puber.ui.feature.player.model.isOff
 import com.kino.puber.ui.feature.player.model.FocusTarget
 import com.kino.puber.ui.feature.player.model.PlayerAction
 import com.kino.puber.ui.feature.player.model.PlayPauseIndicatorState
@@ -120,6 +122,7 @@ internal class PlayerVM(
     )
 
     private var currentMedia: CurrentMedia? = null
+    private var apiSubtitleTracks: List<SubtitleTrackUIState> = emptyList()
     private var mediaGeneration = 0L
 
     private var controlsHideJob: Job? = null
@@ -136,6 +139,9 @@ internal class PlayerVM(
     private var dismissedSegmentType: SkipSegmentType? = null
     private var countdownDismissed = false
     private var tracksRestoredForCurrentMedia = false
+    private var audioRestoredForCurrentMedia = false
+    private var subtitleTracksDiscovered = false
+    private var subtitleRestoreAttempts = 0
     private var episodeSwitchInProgress = false
     private var lastPositionMs: Long = 0L
     private var contentChanges = ContentChangeSet.empty()
@@ -152,6 +158,19 @@ internal class PlayerVM(
     private val controlsStateMachine = ControlsStateMachine()
     private val progressTracker = ProgressTracker()
     private val audioTrackPreferenceResolver = AudioTrackPreferenceResolver()
+    private val subtitleTrackMerger = SubtitleTrackMerger(
+        labeler = SubtitleLabeler(
+            displayLanguageTag = resources.getString(R.string.player_subtitle_language_locale),
+            aiGeneratedLabel = resources.getString(R.string.player_subtitle_ai_generated),
+            forcedQualifier = resources.getString(R.string.player_subtitle_forced),
+            variantLabel = { label, ordinal ->
+                resources.getString(R.string.player_subtitle_variant_label, label, ordinal)
+            },
+            unknownLabel = { position ->
+                resources.getString(R.string.player_subtitle_unknown, position)
+            },
+        ),
+    )
     private val debugOverlayEnabled = interactor.isDebugOverlayEnabled()
 
     private val playbackCallback = object : PlaybackControl.Callback {
@@ -181,16 +200,54 @@ internal class PlayerVM(
             }
         }
 
-        override fun onTracksUpdated(audioTracks: List<AudioTrackUIState>, selectedIndex: Int) {
+        override fun onTracksUpdated(
+            audioTracks: List<AudioTrackUIState>,
+            selectedIndex: Int,
+            subtitleTracks: List<SubtitleTrackUIState>,
+        ) {
+            val currentContent = (stateValue as? PlayerViewState.Content)?.content ?: return
+            val previousSubtitle = currentContent.subtitleTracks
+                .getOrNull(currentContent.selectedSubtitleIndex)
+            val previousPlayerTracks = currentContent.subtitleTracks.filter {
+                it.playerGroupIndex != null && it.playerTrackIndex != null
+            }
+            val effectivePlayerTracks = subtitleTracks.ifEmpty { previousPlayerTracks }
+            // A tracks update may carry only one track type; never let the other list be cleared.
+            val effectiveAudioTracks = audioTracks.ifEmpty { currentContent.audioTracks }
+            val effectiveAudioIndex = if (audioTracks.isEmpty()) {
+                currentContent.selectedAudioTrackIndex
+            } else {
+                selectedIndex
+            }
+            subtitleTracksDiscovered = subtitleTracksDiscovered || effectivePlayerTracks.isNotEmpty()
+            val mergedSubtitleTracks = subtitleTrackMerger.merge(apiSubtitleTracks, effectivePlayerTracks)
+            val mergedSelectedIndex = previousSubtitle?.let { selectedTrack ->
+                audioTrackPreferenceResolver.findSubtitleTrackIndex(
+                    tracks = mergedSubtitleTracks,
+                    preferredLang = selectedTrack.language,
+                    preferredUrl = selectedTrack.url,
+                    preferredPlayerTrackId = selectedTrack.playerTrackId,
+                    preferredPlayerGroupIndex = selectedTrack.playerGroupIndex,
+                    preferredPlayerTrackIndex = selectedTrack.playerTrackIndex,
+                )
+            }?.takeIf { it >= 0 } ?: 0
             updateContent {
                 copy(
-                    audioTracks = audioTracks,
-                    selectedAudioTrackIndex = selectedIndex,
+                    audioTracks = effectiveAudioTracks,
+                    selectedAudioTrackIndex = effectiveAudioIndex,
+                    subtitleTracks = mergedSubtitleTracks,
+                    selectedSubtitleIndex = mergedSelectedIndex,
                 )
             }
             if (!tracksRestoredForCurrentMedia) {
                 tracksRestoredForCurrentMedia = true
-                restoreTrackPreferences()
+                val restored = restoreTrackPreferences(
+                    hasDiscoveredSubtitleTracks = effectivePlayerTracks.isNotEmpty(),
+                )
+                if (!restored && subtitleRestoreAttempts < MAX_SUBTITLE_RESTORE_ATTEMPTS) {
+                    subtitleRestoreAttempts++
+                    tracksRestoredForCurrentMedia = false
+                }
             }
         }
 
@@ -288,10 +345,7 @@ internal class PlayerVM(
         ).copy(
             isMarkCurrentWatchedInFlight = watchedMutationsInFlight[token.key].orZero() > 0,
         )
-
-        controlsHideJob?.cancel()
-        controlsStateMachine.initialize(resumeDialogVisible = resumeDialog != null)
-        updateViewState(PlayerViewState.Content(contentState.withControlsState(controlsStateMachine.state)))
+        showInitialContent(contentState, resumeDialog)
         autoMarkHandledToken = token.takeIf { resolved.isCurrentMediaWatched }
         episodeSwitchInProgress = false
         initializePlayer(savedPosition = if (resumeDialog != null) null else 0L)
@@ -300,6 +354,32 @@ internal class PlayerVM(
         loadSkipSegments(item, resolved.seasonNumber, resolved.episodeNumber, token)
     }
 
+    private fun resetTrackRestoreState() {
+        tracksRestoredForCurrentMedia = false
+        audioRestoredForCurrentMedia = false
+        subtitleTracksDiscovered = false
+        subtitleRestoreAttempts = 0
+    }
+
+    private fun showInitialContent(
+        contentState: PlayerContentState,
+        resumeDialog: ResumeDialogState?,
+    ) {
+        apiSubtitleTracks = contentState.subtitleTracks
+        controlsHideJob?.cancel()
+        controlsStateMachine.initialize(resumeDialogVisible = resumeDialog != null)
+        updateViewState(
+            PlayerViewState.Content(
+                contentState
+                    .copy(
+                        subtitleTracks = contentState.subtitleTracks.filter { it.isOff },
+                        selectedSubtitleIndex = 0,
+                    )
+                    .withControlsState(controlsStateMachine.state),
+            ),
+        )
+    }
+
     private fun isCurrentPrepare(generation: Long): Boolean {
         return !closing && generation == mediaGeneration
     }
@@ -330,31 +410,50 @@ internal class PlayerVM(
             ?.preset
             ?: BufferPreset.AUTO
         val fastDns = content?.fastDnsEnabled ?: true
-        val streamUrl = interactor.selectStreamUrl(media.files, qualityIndex) ?: return
-        playbackController.prepare(streamUrl, media.subtitles, savedPosition, bufferPreset, fastDns)
+        val stream = interactor.selectStreamUrl(media.files, qualityIndex) ?: return
+        playbackController.prepare(stream, media.subtitles, savedPosition, bufferPreset, fastDns)
     }
 
     private fun switchStreamUrl(qualityIndex: Int) {
         val media = currentMedia ?: return
-        val streamUrl = interactor.selectStreamUrl(media.files, qualityIndex) ?: return
-        playbackController.switchStream(streamUrl, media.subtitles)
+        val stream = interactor.selectStreamUrl(media.files, qualityIndex) ?: return
+        playbackController.switchStream(stream, media.subtitles)
     }
 
-    private fun restoreTrackPreferences() {
-        val preferredLabel = interactor.getPreferredAudioLabel(params.itemId)
-        val preferredLang = interactor.getPreferredAudioLang(params.itemId)
-        val subtitleLang = interactor.getPreferredSubtitleLang(params.itemId)
-        val subtitleUrl = interactor.getPreferredSubtitleUrl(params.itemId)
-        val content = (stateValue as? PlayerViewState.Content)?.content ?: return
+    /**
+     * Returns false only while the subtitle preference is still waiting for the player to
+     * report its text tracks, which asks the caller for another attempt.
+     */
+    private fun restoreTrackPreferences(hasDiscoveredSubtitleTracks: Boolean): Boolean {
+        val content = (stateValue as? PlayerViewState.Content)?.content ?: return false
+        restoreAudioTrackPreference(content)
+        return restoreSubtitlePreference(content, hasDiscoveredSubtitleTracks)
+    }
+
+    // Applied at most once per media so retrying the subtitle restore never re-applies
+    // the stored audio track over a selection the user made in the meantime.
+    private fun restoreAudioTrackPreference(content: PlayerContentState) {
+        if (audioRestoredForCurrentMedia || content.audioTracks.isEmpty()) return
+        audioRestoredForCurrentMedia = true
         val audioIndex = audioTrackPreferenceResolver.findAudioTrackIndex(
             tracks = content.audioTracks,
-            preferredLabel = preferredLabel,
-            preferredLang = preferredLang,
+            preferredLabel = interactor.getPreferredAudioLabel(params.itemId),
+            preferredLang = interactor.getPreferredAudioLang(params.itemId),
         )
-
         if (audioIndex >= 0) {
             applyAudioTrackSelection(audioIndex, persist = false)
         }
+    }
+
+    private fun restoreSubtitlePreference(
+        content: PlayerContentState,
+        hasDiscoveredSubtitleTracks: Boolean,
+    ): Boolean {
+        val subtitleLang = interactor.getPreferredSubtitleLang(params.itemId)
+        val subtitleUrl = interactor.getPreferredSubtitleUrl(params.itemId)
+        val hasSubtitlePreference = !subtitleLang.isNullOrEmpty() || !subtitleUrl.isNullOrEmpty()
+        if (!hasSubtitlePreference) return true
+        if (!hasDiscoveredSubtitleTracks) return false
 
         val subtitleIndex = audioTrackPreferenceResolver.findSubtitleTrackIndex(
             tracks = content.subtitleTracks,
@@ -364,6 +463,7 @@ internal class PlayerVM(
         if (subtitleIndex >= 0) {
             applySubtitleSelection(subtitleIndex, persist = false)
         }
+        return true
     }
 
     override fun onAction(action: UIAction) {
@@ -577,8 +677,13 @@ internal class PlayerVM(
         val currentState = (stateValue as? PlayerViewState.Content)?.content ?: return
         if (currentState.selectedQualityIndex == index) return
 
+        resetTrackRestoreState()
         updateContent {
-            copy(selectedQualityIndex = index)
+            copy(
+                selectedQualityIndex = index,
+                subtitleTracks = subtitleTracks.filter { it.isOff },
+                selectedSubtitleIndex = 0,
+            )
         }
         switchStreamUrl(index)
     }
@@ -605,7 +710,7 @@ internal class PlayerVM(
 
         val position = playbackController.currentPosition
         updateContent { copy(selectedBufferPresetIndex = index) }
-        tracksRestoredForCurrentMedia = false
+        resetTrackRestoreState()
         initializePlayer(savedPosition = position)
     }
 
@@ -616,7 +721,7 @@ internal class PlayerVM(
 
         val position = playbackController.currentPosition
         updateContent { copy(fastDnsEnabled = newValue) }
-        tracksRestoredForCurrentMedia = false
+        resetTrackRestoreState()
         initializePlayer(savedPosition = position)
     }
 
@@ -647,7 +752,7 @@ internal class PlayerVM(
         creditsSegment = null
         dismissedSegmentType = null
         countdownDismissed = false
-        tracksRestoredForCurrentMedia = false
+        resetTrackRestoreState()
 
         updateViewState(PlayerViewState.Loading)
         startPreparingPlayback(
@@ -1342,12 +1447,26 @@ internal class PlayerVM(
         val state = (stateValue as? PlayerViewState.Content)?.content ?: return
         val audioTrack = state.audioTracks.getOrNull(state.selectedAudioTrackIndex)
         val subtitle = state.subtitleTracks.getOrNull(state.selectedSubtitleIndex)
+        // Before the player reports its text tracks the picker holds nothing but "off",
+        // so persisting it would silently drop the preference we still have to restore.
+        val subtitleLang = if (subtitleTracksDiscovered) {
+            subtitle?.language?.takeIf { it.isNotEmpty() }
+        } else {
+            interactor.getPreferredSubtitleLang(params.itemId)
+        }
+        val subtitleUrl = if (subtitleTracksDiscovered) {
+            subtitle?.url?.takeIf { it.isNotEmpty() }
+                ?: subtitle?.playerTrackUri?.takeIf { it.isNotEmpty() }
+                ?: subtitle?.playerTrackId?.takeIf { it.isNotEmpty() }
+        } else {
+            interactor.getPreferredSubtitleUrl(params.itemId)
+        }
         interactor.saveTrackPreferences(
             itemId = params.itemId,
             audioLang = audioTrack?.language?.takeIf { it.isNotEmpty() },
             audioLabel = audioTrack?.label?.takeIf { it.isNotEmpty() },
-            subtitleLang = subtitle?.language?.takeIf { it.isNotEmpty() },
-            subtitleUrl = subtitle?.url?.takeIf { it.isNotEmpty() },
+            subtitleLang = subtitleLang,
+            subtitleUrl = subtitleUrl,
         )
     }
 
@@ -1422,5 +1541,8 @@ internal class PlayerVM(
         const val EARLY_NEXT_EPISODE_OFFSET_MS = 30_000L
         const val SEEK_JUMP_THRESHOLD_MS = 2_000L
         const val SKIP_COUNTDOWN_SEC = 7
+        // Bounds the wait for player text tracks so a stream that simply has none
+        // does not re-run the restore on every single track update.
+        const val MAX_SUBTITLE_RESTORE_ATTEMPTS = 10
     }
 }
diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/vm/SubtitleLabeler.kt b/app/src/main/java/com/kino/puber/ui/feature/player/vm/SubtitleLabeler.kt
new file mode 100644
index 00000000..c3e4ec87
--- /dev/null
+++ b/app/src/main/java/com/kino/puber/ui/feature/player/vm/SubtitleLabeler.kt
@@ -0,0 +1,106 @@
+package com.kino.puber.ui.feature.player.vm
+
+import com.kino.puber.ui.feature.player.model.SubtitleTrackUIState
+import java.util.Locale
+
+/**
+ * Builds the strings the subtitle picker shows.
+ *
+ * Every row is named after its language. A qualifier is appended only when two rows would
+ * otherwise read identically, and raw manifest strings only reach the UI when they are
+ * genuinely descriptive: CDN naming such as `RUS #03` and the subtitle file names Media3
+ * uses as side-loaded track labels are rejected.
+ */
+internal class SubtitleLabeler(
+    displayLanguageTag: String,
+    private val aiGeneratedLabel: String,
+    private val forcedQualifier: String,
+    private val variantLabel: (label: String, ordinal: Int) -> String,
+    private val unknownLabel: (position: Int) -> String,
+) {
+    private val displayLocale: Locale = Locale.forLanguageTag(displayLanguageTag)
+
+    fun apply(tracks: List<SubtitleTrackUIState>): List<SubtitleTrackUIState> {
+        val labeled = tracks.mapIndexed { position, track ->
+            track.copy(label = withForcedQualifier(baseLabel(track, position), track))
+        }
+        return disambiguate(labeled)
+    }
+
+    private fun baseLabel(track: SubtitleTrackUIState, position: Int): String {
+        val isAiGenerated = canonicalSubtitleLanguage(track.language) ==
+            AI_GENERATED_SUBTITLE_LANGUAGE
+        val languageLabel = if (isAiGenerated) {
+            aiGeneratedLabel
+        } else {
+            subtitleLanguageDisplayName(track.language, displayLocale)
+        }
+        val descriptiveLabel = track.readableDescriptiveLabel()
+        val sourceLabel = track.sourceDescriptiveLabel()
+        val rawLanguageLabel = track.language
+            .trim()
+            .takeIf { it.isNotEmpty() }
+            ?.uppercase(Locale.ROOT)
+        return languageLabel
+            ?: descriptiveLabel
+            ?: sourceLabel
+            ?: rawLanguageLabel
+            ?: unknownLabel(position + 1)
+    }
+
+    private fun withForcedQualifier(label: String, track: SubtitleTrackUIState): String =
+        if (track.isForced == true) "$label$QUALIFIER_SEPARATOR$forcedQualifier" else label
+
+    /**
+     * Rows that still read the same are separated by their manifest labels when every one
+     * of them has a distinct readable label, and by an ordinal otherwise.
+     */
+    private fun disambiguate(tracks: List<SubtitleTrackUIState>): List<SubtitleTrackUIState> {
+        val collisions = tracks.groupBy { it.label }.filterValues { it.size > 1 }
+        if (collisions.isEmpty()) return tracks
+
+        val describable = collisions.filterValues(::hasDistinctReadableLabels).keys
+        val ordinals = mutableMapOf<String, Int>()
+        return tracks.map { track ->
+            when {
+                track.label !in collisions -> track
+                track.label in describable ->
+                    track.copy(label = withForcedQualifier(track.readableDescriptiveLabel()!!, track))
+                else -> {
+                    val ordinal = ordinals.merge(track.label, 1, Int::plus) ?: 1
+                    track.copy(label = variantLabel(track.label, ordinal))
+                }
+            }
+        }
+    }
+
+    private fun hasDistinctReadableLabels(group: List<SubtitleTrackUIState>): Boolean {
+        val labels = group.mapNotNull { it.readableDescriptiveLabel() }
+        return labels.size == group.size && labels.toSet().size == group.size
+    }
+
+    private companion object {
+        const val QUALIFIER_SEPARATOR = " · "
+    }
+}
+
+/**
+ * A manifest label is worth showing only when it reads as a name. Anything that is really
+ * a file name or a language code with a channel number is not.
+ */
+internal fun SubtitleTrackUIState.readableDescriptiveLabel(): String? {
+    val candidate = sourceDescriptiveLabel() ?: return null
+    val isLanguageCode = candidate.count(Char::isLetter) <= SHORTEST_DESCRIPTIVE_LABEL
+    return candidate.takeUnless { isLanguageCode }
+}
+
+/** A source label is safe to show as a last resort when it is not a file identity. */
+private fun SubtitleTrackUIState.sourceDescriptiveLabel(): String? {
+    val candidate = descriptiveLabel?.trim()?.takeIf { it.isNotEmpty() } ?: return null
+    val isFileName = SUBTITLE_FILE_EXTENSION.containsMatchIn(candidate) ||
+        candidate == sourceFile ||
+        candidate == url.stableSubtitleKey()
+    return candidate.takeUnless { isFileName }
+}
+
+private const val SHORTEST_DESCRIPTIVE_LABEL = 3
diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/vm/SubtitleLanguage.kt b/app/src/main/java/com/kino/puber/ui/feature/player/vm/SubtitleLanguage.kt
new file mode 100644
index 00000000..d90a1f47
--- /dev/null
+++ b/app/src/main/java/com/kino/puber/ui/feature/player/vm/SubtitleLanguage.kt
@@ -0,0 +1,51 @@
+package com.kino.puber.ui.feature.player.vm
+
+import java.util.Locale
+
+internal const val AI_GENERATED_SUBTITLE_LANGUAGE = "ai"
+
+internal fun sameSubtitleLanguage(first: String, second: String): Boolean {
+    if (first.isBlank() || second.isBlank()) return false
+    return canonicalSubtitleLanguage(first) == canonicalSubtitleLanguage(second)
+}
+
+internal fun canonicalSubtitleLanguage(language: String): String {
+    val normalized = language
+        .trim()
+        .lowercase(Locale.ROOT)
+        .substringBefore('-')
+        .substringBefore('_')
+    return runCatching { Locale.forLanguageTag(normalized).isO3Language }
+        .getOrNull()
+        ?.takeIf { it.isNotBlank() && it != "und" }
+        ?: normalized
+}
+
+/**
+ * Localized name of a subtitle language, or null when the code cannot be resolved.
+ *
+ * `Locale.forLanguageTag("rus")` does not resolve to a known locale, so its display name
+ * comes back untranslated. Resolving the three-letter code against the available locales
+ * first is what makes "rus" read as "Русский" rather than "Russian".
+ */
+internal fun subtitleLanguageDisplayName(language: String, displayLocale: Locale): String? {
+    if (language.isBlank()) return null
+    val canonical = canonicalSubtitleLanguage(language)
+    if (canonical.isEmpty()) return null
+    val locale = iso3Locales[canonical] ?: Locale.forLanguageTag(canonical)
+    val name = runCatching { locale.getDisplayLanguage(displayLocale) }.getOrNull().orEmpty()
+    return name
+        .takeIf { it.isNotBlank() && !it.equals(canonical, ignoreCase = true) }
+        ?.replaceFirstChar { it.titlecase(displayLocale) }
+}
+
+private val iso3Locales: Map<String, Locale> by lazy {
+    Locale.getAvailableLocales()
+        .filter { it.language.isNotEmpty() }
+        .mapNotNull { locale ->
+            runCatching { locale.isO3Language }.getOrNull()
+                ?.takeIf { it.isNotBlank() }
+                ?.let { iso3 -> iso3 to Locale.forLanguageTag(locale.language) }
+        }
+        .toMap()
+}
diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/vm/SubtitleTrackIdentity.kt b/app/src/main/java/com/kino/puber/ui/feature/player/vm/SubtitleTrackIdentity.kt
index 9e2f8486..38b28a77 100644
--- a/app/src/main/java/com/kino/puber/ui/feature/player/vm/SubtitleTrackIdentity.kt
+++ b/app/src/main/java/com/kino/puber/ui/feature/player/vm/SubtitleTrackIdentity.kt
@@ -6,7 +6,43 @@ private const val SUBTITLES_PATH_MARKER = "/subtitles/"
 
 internal fun String.stableSubtitleKey(): String {
     if (isEmpty()) return ""
+    val path = normalizedSubtitlePath()
+    return path.substringAfter(SUBTITLES_PATH_MARKER, path)
+}
+
+internal fun sameSubtitleIdentity(first: String, second: String): Boolean {
+    if (first == second) return true
+    val firstPath = first.subtitleIdentityPathOrNull()
+    val secondPath = second.subtitleIdentityPathOrNull()
+    return firstPath != null && secondPath != null && (
+        firstPath == secondPath ||
+            firstPath.endsWith("/$secondPath") ||
+            secondPath.endsWith("/$firstPath") ||
+            firstPath.stableSubtitleKey() == secondPath.stableSubtitleKey()
+        )
+}
+
+private fun String.subtitleIdentityPathOrNull(): String? {
+    if (isEmpty()) return null
+    val path = normalizedSubtitlePath().trim('/')
+    return path.takeIf { candidate ->
+        candidate.contains('/') || SUBTITLE_FILE_EXTENSION.containsMatchIn(candidate)
+    }
+}
+
+/** KinoPub exposes an HLS rendition for a subtitle file as `<file>/index.m3u8`. */
+private fun String.normalizedSubtitlePath(): String {
     val path = runCatching { URI(this).path }.getOrNull()
         ?: substringBefore('?').substringBefore('#')
-    return path.substringAfter(SUBTITLES_PATH_MARKER, path)
+    return HLS_SUBTITLE_PLAYLIST_SUFFIX.replace(path) { match -> match.groupValues[1] }
 }
+
+internal val SUBTITLE_FILE_EXTENSION = Regex(
+    pattern = """\.(srt|vtt|webvtt|ass|ssa|ttml|xml)$""",
+    option = RegexOption.IGNORE_CASE,
+)
+
+private val HLS_SUBTITLE_PLAYLIST_SUFFIX = Regex(
+    pattern = """(\.(?:srt|vtt|webvtt|ass|ssa|ttml|xml))/index\.m3u8$""",
+    option = RegexOption.IGNORE_CASE,
+)
diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/vm/SubtitleTrackMerger.kt b/app/src/main/java/com/kino/puber/ui/feature/player/vm/SubtitleTrackMerger.kt
new file mode 100644
index 00000000..5eea9ff0
--- /dev/null
+++ b/app/src/main/java/com/kino/puber/ui/feature/player/vm/SubtitleTrackMerger.kt
@@ -0,0 +1,118 @@
+package com.kino.puber.ui.feature.player.vm
+
+import com.kino.puber.ui.feature.player.model.SubtitleTrackUIState
+import com.kino.puber.ui.feature.player.model.isOff
+
+internal class SubtitleTrackMerger(
+    private val labeler: SubtitleLabeler,
+) {
+
+    fun merge(
+        apiTracks: List<SubtitleTrackUIState>,
+        playerTracks: List<SubtitleTrackUIState>,
+    ): List<SubtitleTrackUIState> {
+        val offTrack = apiTracks.firstOrNull { it.isOff } ?: SubtitleTrackUIState(
+            label = "",
+            language = "",
+            url = "",
+        )
+        val apiSubtitles = apiTracks.filterNot { it.isOff }
+        val playerSubtitles = playerTracks.filterNot { it.isOff }
+        if (playerSubtitles.isEmpty()) {
+            return listOf(offTrack)
+        }
+
+        val selectedPlayerTracks = selectTracksByLanguage(playerSubtitles)
+        val enrichedPlayerTracks = enrichPlayerTracks(selectedPlayerTracks, apiSubtitles)
+        val orderedPlayerTracks = orderByLanguage(enrichedPlayerTracks)
+        return listOf(offTrack) + labeler.apply(orderedPlayerTracks)
+    }
+
+    /**
+     * API subtitles are side-loaded before the manifest is known. For each language,
+     * keep the source with more tracks, preferring HLS on ties to avoid duplicate variants.
+     * Compare discovered player tracks so every retained row can be selected for playback.
+     */
+    private fun selectTracksByLanguage(
+        tracks: List<SubtitleTrackUIState>,
+    ): List<SubtitleTrackUIState> = tracks.groupBy(::orderingLanguage).values.flatMap { languageTracks ->
+        val (manifestTracks, sideLoadedTracks) = languageTracks.partition { it.isFromManifest }
+        if (manifestTracks.size >= sideLoadedTracks.size) manifestTracks else sideLoadedTracks
+    }
+
+    /**
+     * Player order follows the manifest, which is arbitrary from the viewer's side. Group
+     * the rows by language in the order each language first appears, keeping every variant
+     * of a language together and its partial variant last.
+     */
+    private fun orderByLanguage(
+        tracks: List<SubtitleTrackUIState>,
+    ): List<SubtitleTrackUIState> {
+        val languageOrder = mutableMapOf<String, Int>()
+        tracks.forEach { track ->
+            languageOrder.getOrPut(orderingLanguage(track)) { languageOrder.size }
+        }
+        return tracks.withIndex()
+            .sortedWith(
+                compareBy(
+                    { languageOrder.getValue(orderingLanguage(it.value)) },
+                    { it.value.isForced == true },
+                    { it.index },
+                ),
+            )
+            .map { it.value }
+    }
+
+    private fun orderingLanguage(track: SubtitleTrackUIState): String =
+        canonicalSubtitleLanguage(track.language)
+
+    private fun enrichPlayerTracks(
+        playerSubtitles: List<SubtitleTrackUIState>,
+        apiSubtitles: List<SubtitleTrackUIState>,
+    ): List<SubtitleTrackUIState> {
+        val claimedApiIndices = mutableSetOf<Int>()
+        return playerSubtitles.map { playerTrack ->
+            findExactIdentityMatch(playerTrack, apiSubtitles)
+                ?.takeIf(claimedApiIndices::add)
+                ?.let { apiIndex -> playerTrack.withApiMetadata(apiSubtitles[apiIndex]) }
+                ?: playerTrack
+        }
+    }
+
+    private fun findExactIdentityMatch(
+        playerTrack: SubtitleTrackUIState,
+        apiTracks: List<SubtitleTrackUIState>,
+    ): Int? {
+        val playerIdentities = listOfNotNull(
+            playerTrack.playerTrackUri,
+            playerTrack.playerTrackId?.withoutMergedSourcePrefix(),
+        ).filter { it.isNotEmpty() }
+        if (playerIdentities.isEmpty()) return null
+        return apiTracks.indices.filter { apiIndex ->
+            val apiTrack = apiTracks[apiIndex]
+            val apiIdentities = listOfNotNull(apiTrack.sourceFile, apiTrack.url)
+                .filter { it.isNotEmpty() }
+            apiIdentities.any { apiIdentity ->
+                playerIdentities.any { playerIdentity ->
+                    sameSubtitleIdentity(apiIdentity, playerIdentity)
+                }
+            }
+        }.singleOrNull()
+    }
+
+    private fun SubtitleTrackUIState.withApiMetadata(
+        apiTrack: SubtitleTrackUIState,
+    ): SubtitleTrackUIState = copy(
+        url = apiTrack.url,
+        sourceFile = apiTrack.sourceFile,
+        isForced = apiTrack.isForced ?: isForced,
+    )
+}
+
+private val SubtitleTrackUIState.isFromManifest: Boolean
+    get() = playerTrackUri != null
+
+// MergingMediaSource rewrites child track ids to "<childIndex>:<originalId>".
+private fun String.withoutMergedSourcePrefix(): String = MERGED_SOURCE_PREFIX.replace(this, "")
+
+private val MERGED_SOURCE_PREFIX = Regex("""^\d+:""")
diff --git a/app/src/main/java/com/kino/puber/ui/feature/player/vm/SubtitleTrackSelector.kt b/app/src/main/java/com/kino/puber/ui/feature/player/vm/SubtitleTrackSelector.kt
new file mode 100644
index 00000000..d6984b29
--- /dev/null
+++ b/app/src/main/java/com/kino/puber/ui/feature/player/vm/SubtitleTrackSelector.kt
@@ -0,0 +1,85 @@
+package com.kino.puber.ui.feature.player.vm
+
+import com.kino.puber.ui.feature.player.model.SubtitleTrackUIState
+
+/**
+ * A text track exposed by the player, flattened out of the Media3 track groups.
+ *
+ * [groupId] is `TrackGroup.id`. MergingMediaSource rewrites the ids of its children to
+ * `"<childIndex>:<originalId>"`, so once side-loaded subtitles are merged into an HLS
+ * source the id is unique per track group and stable across track updates. Plain sources
+ * may leave it blank, which is why every match below is uniqueness-checked.
+ */
+internal data class PlayerTextTrack(
+    val groupId: String,
+    val groupIndex: Int,
+    val trackIndex: Int,
+    val formatId: String? = null,
+    val formatLabel: String? = null,
+    val language: String? = null,
+)
+
+/**
+ * Resolves the player text track a picker row points at.
+ *
+ * The rules never guess: every candidate set is reduced with `singleOrNull`, so an
+ * ambiguous match yields nothing and falls through to the next rule rather than
+ * selecting an arbitrary track.
+ */
+internal class SubtitleTrackSelector {
+
+    fun select(
+        track: SubtitleTrackUIState,
+        candidates: List<PlayerTextTrack>,
+    ): PlayerTextTrack? {
+        if (candidates.isEmpty()) return null
+        return matchByTrackGroupId(track, candidates)
+            ?: matchByFormatId(track, candidates)
+            ?: matchByCoordinates(track, candidates)
+            ?: matchByLanguage(track, candidates)
+    }
+
+    /** Exact and order independent: survives track groups being added or reordered. */
+    private fun matchByTrackGroupId(
+        track: SubtitleTrackUIState,
+        candidates: List<PlayerTextTrack>,
+    ): PlayerTextTrack? {
+        val groupId = track.playerTrackGroupId?.takeIf { it.isNotEmpty() } ?: return null
+        val trackIndex = track.playerTrackIndex ?: return null
+        return candidates
+            .filter { it.groupId == groupId && it.trackIndex == trackIndex }
+            .singleOrNull()
+    }
+
+    private fun matchByFormatId(
+        track: SubtitleTrackUIState,
+        candidates: List<PlayerTextTrack>,
+    ): PlayerTextTrack? {
+        val formatId = track.playerTrackId?.takeIf { it.isNotEmpty() } ?: return null
+        return candidates.filter { it.formatId == formatId }.singleOrNull()
+    }
+
+    /** Positional fallback for tracks the manifest exposes without any usable identity. */
+    private fun matchByCoordinates(
+        track: SubtitleTrackUIState,
+        candidates: List<PlayerTextTrack>,
+    ): PlayerTextTrack? {
+        val groupIndex = track.playerGroupIndex ?: return null
+        val trackIndex = track.playerTrackIndex ?: return null
+        return candidates
+            .filter { it.groupIndex == groupIndex && it.trackIndex == trackIndex }
+            .singleOrNull()
+    }
+
+    private fun matchByLanguage(
+        track: SubtitleTrackUIState,
+        candidates: List<PlayerTextTrack>,
+    ): PlayerTextTrack? {
+        if (track.language.isEmpty()) return null
+        return candidates
+            .filter { candidate ->
+                candidate.language?.let { sameSubtitleLanguage(it, track.language) } == true
+            }
+            .singleOrNull()
+    }
+}
diff --git a/app/src/main/res/values/player.xml b/app/src/main/res/values/player.xml
index 054aa4e9..71f39bcd 100644
--- a/app/src/main/res/values/player.xml
+++ b/app/src/main/res/values/player.xml
@@ -14,7 +14,12 @@
     <string name="player_panel_audio">АУДИО</string>
     <string name="player_panel_subtitles">СУБТИТРЫ</string>
     <string name="player_subtitles_off">Выкл.</string>
+    <!-- Language tag used to localize subtitle language names; keep in sync with this values folder. -->
+    <string name="player_subtitle_language_locale" translatable="false">ru</string>
+    <string name="player_subtitle_ai_generated">Созданные ИИ</string>
+    <string name="player_subtitle_forced">частичные</string>
     <string name="player_subtitle_variant_label">%1$s · вариант %2$d</string>
+    <string name="player_subtitle_unknown">Субтитры %1$d</string>
     <string name="player_subtitle_size">Аа Размер</string>
     <string name="player_subtitle_size_small">Маленький</string>
     <string name="player_subtitle_size_medium">Средний</string>
diff --git a/app/src/test/kotlin/com/kino/puber/data/api/models/SubtitleLinkTest.kt b/app/src/test/kotlin/com/kino/puber/data/api/models/SubtitleLinkTest.kt
new file mode 100644
index 00000000..ab0641c1
--- /dev/null
+++ b/app/src/test/kotlin/com/kino/puber/data/api/models/SubtitleLinkTest.kt
@@ -0,0 +1,26 @@
+package com.kino.puber.data.api.models
+
+import org.junit.jupiter.api.Assertions.assertFalse
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Test
+
+internal class SubtitleLinkTest {
+
+    @Test
+    fun shouldSideLoad_sideLoadsEveryApiSubtitleForHls() {
+        val url = "https://cdn.test/subtitle.srt"
+
+        assertTrue(SubtitleLink(lang = "eng", url = url).shouldSideLoad(isHls = true))
+        assertTrue(SubtitleLink(lang = "eng", url = url, embed = false).shouldSideLoad(isHls = true))
+        assertTrue(SubtitleLink(lang = "eng", url = url, embed = true).shouldSideLoad(isHls = true))
+    }
+
+    @Test
+    fun shouldSideLoad_skipsEmbeddedApiSubtitleForProgressiveSource() {
+        val url = "https://cdn.test/subtitle.srt"
+
+        assertTrue(SubtitleLink(lang = "eng", url = url).shouldSideLoad(isHls = false))
+        assertTrue(SubtitleLink(lang = "eng", url = url, embed = false).shouldSideLoad(isHls = false))
+        assertFalse(SubtitleLink(lang = "eng", url = url, embed = true).shouldSideLoad(isHls = false))
+    }
+}
diff --git a/app/src/test/kotlin/com/kino/puber/domain/interactor/player/PlayerInteractorTest.kt b/app/src/test/kotlin/com/kino/puber/domain/interactor/player/PlayerInteractorTest.kt
index 2a897318..0112ca5c 100644
--- a/app/src/test/kotlin/com/kino/puber/domain/interactor/player/PlayerInteractorTest.kt
+++ b/app/src/test/kotlin/com/kino/puber/domain/interactor/player/PlayerInteractorTest.kt
@@ -214,7 +214,7 @@ class PlayerInteractorTest {
             VideoFile(url = VideoUrl(http = "http://video.mp4", hls = "hls://video.m3u8", hls4 = "hls4://video.m3u8")),
         )
         val result = interactor.selectStreamUrl(files, qualityIndex = 0)
-        assertEquals("hls4://video.m3u8", result)
+        assertEquals(StreamSource("hls4://video.m3u8", isHls = true), result)
     }
 
     @Test
@@ -223,7 +223,7 @@ class PlayerInteractorTest {
             VideoFile(url = VideoUrl(http = "http://video.mp4", hls = "hls://video.m3u8", hls4 = null)),
         )
         val result = interactor.selectStreamUrl(files, qualityIndex = 0)
-        assertEquals("hls://video.m3u8", result)
+        assertEquals(StreamSource("hls://video.m3u8", isHls = true), result)
     }
 
     @Test
@@ -232,7 +232,7 @@ class PlayerInteractorTest {
             VideoFile(url = VideoUrl(http = "http://video.mp4", hls = null, hls4 = null)),
         )
         val result = interactor.selectStreamUrl(files, qualityIndex = 0)
-        assertEquals("http://video.mp4", result)
+        assertEquals(StreamSource("http://video.mp4", isHls = false), result)
     }
 
     @Test
@@ -244,7 +244,7 @@ class PlayerInteractorTest {
         )
         // qualityIndex = 1 → first entry after sorting descending by qualityId → 1080p
         val result = interactor.selectStreamUrl(files, qualityIndex = 1)
-        assertEquals("hls://1080p.m3u8", result)
+        assertEquals(StreamSource("hls://1080p.m3u8", isHls = true), result)
     }
 
     @Test
@@ -254,7 +254,7 @@ class PlayerInteractorTest {
             VideoFile(url = VideoUrl(hls = "hls://720p.m3u8"), quality = "720p", qualityId = 3),
         )
         val result = interactor.selectStreamUrl(files, qualityIndex = 2)
-        assertEquals("hls://720p.m3u8", result)
+        assertEquals(StreamSource("hls://720p.m3u8", isHls = true), result)
     }
 
     @Test
diff --git a/app/src/test/kotlin/com/kino/puber/ui/feature/player/model/PlayerUIMapperSubtitleTest.kt b/app/src/test/kotlin/com/kino/puber/ui/feature/player/model/PlayerUIMapperSubtitleTest.kt
new file mode 100644
index 00000000..117ff017
--- /dev/null
+++ b/app/src/test/kotlin/com/kino/puber/ui/feature/player/model/PlayerUIMapperSubtitleTest.kt
@@ -0,0 +1,50 @@
+package com.kino.puber.ui.feature.player.model
+
+import android.content.Context
+import com.kino.puber.R
+import com.kino.puber.data.api.models.SubtitleLink
+import io.mockk.every
+import io.mockk.mockk
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+internal class PlayerUIMapperSubtitleTest {
+
+    private val context = mockk<Context>(relaxed = true).also { context ->
+        every { context.getString(R.string.player_subtitles_off) } returns "Off"
+    }
+    private val mapper = PlayerUIMapper(context)
+
+    @Test
+    fun mapSubtitleTracks_returnsOnlyOffTrack_whenInputIsEmpty() {
+        val result = mapper.mapSubtitleTracks(emptyList())
+
+        assertEquals(listOf(""), result.map { it.language })
+        assertEquals(listOf(""), result.map { it.url })
+    }
+
+    @Test
+    fun mapSubtitleTracks_preservesLanguagesAndIdentityMetadata_inApiOrder() {
+        val embeddedUrl = "https://cdn.test/subtitles/russian.vtt"
+        val externalUrl = "https://cdn.test/subtitles/english.vtt"
+
+        val result = mapper.mapSubtitleTracks(
+            listOf(
+                SubtitleLink(
+                    lang = "rus",
+                    url = embeddedUrl,
+                    embed = true,
+                    forced = false,
+                    file = "/a/71/russian.vtt",
+                ),
+                SubtitleLink(lang = "eng", url = externalUrl, embed = false),
+            )
+        )
+
+        assertEquals(listOf("", "rus", "eng"), result.map { it.language })
+        assertEquals(listOf("", embeddedUrl, externalUrl), result.map { it.url })
+        assertEquals(listOf(null, "/a/71/russian.vtt", null), result.map { it.sourceFile })
+        assertEquals(listOf(null, false, null), result.map { it.isForced })
+    }
+
+}
diff --git a/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/AudioTrackPreferenceResolverTest.kt b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/AudioTrackPreferenceResolverTest.kt
index bbb47ae2..9bfaac32 100644
--- a/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/AudioTrackPreferenceResolverTest.kt
+++ b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/AudioTrackPreferenceResolverTest.kt
@@ -36,9 +36,9 @@ internal class AudioTrackPreferenceResolverTest {
     @Test
     fun findSubtitleTrackIndex_matchesSignedUrlByStablePathBeforeLanguage() {
         val tracks = listOf(
-            SubtitleTrackUIState(0, "Off", "", ""),
-            SubtitleTrackUIState(1, "Russian", "rus", "https://cdn/subtitles/rus.vtt?token=new"),
-            SubtitleTrackUIState(2, "Russian SDH", "rus", "https://cdn/subtitles/rus-sdh.vtt?token=new"),
+            subtitleTrack(index = 0, language = "", url = ""),
+            subtitleTrack(index = 1, language = "rus", url = "https://cdn/subtitles/rus.vtt?token=new"),
+            subtitleTrack(index = 2, language = "rus", url = "https://cdn/subtitles/rus-sdh.vtt?token=new"),
         )
 
         assertEquals(
@@ -54,11 +54,214 @@ internal class AudioTrackPreferenceResolverTest {
     @Test
     fun findSubtitleTrackIndex_rejectsAmbiguousLanguageWithoutUrl() {
         val tracks = listOf(
-            SubtitleTrackUIState(0, "Off", "", ""),
-            SubtitleTrackUIState(1, "Russian", "rus", "https://cdn/subtitles/rus.vtt"),
-            SubtitleTrackUIState(2, "Russian SDH", "rus", "https://cdn/subtitles/rus-sdh.vtt"),
+            subtitleTrack(index = 0, language = "", url = ""),
+            subtitleTrack(index = 1, language = "rus", url = "https://cdn/subtitles/rus.vtt"),
+            subtitleTrack(index = 2, language = "rus", url = "https://cdn/subtitles/rus-sdh.vtt"),
         )
 
         assertEquals(-1, resolver.findSubtitleTrackIndex(tracks, "rus", null))
     }
+
+    @Test
+    fun findSubtitleTrackIndex_usesLanguageForUrlLessManifestTrack() {
+        val tracks = listOf(
+            subtitleTrack(index = 0, language = "", url = ""),
+            subtitleTrack(index = 1, language = "en", url = "", playerTrackId = "hls-english"),
+        )
+
+        val result = resolver.findSubtitleTrackIndex(
+            tracks = tracks,
+            preferredLang = "eng",
+            preferredUrl = "",
+        )
+
+        assertEquals(1, result)
+    }
+
+    @Test
+    fun findSubtitleTrackIndex_preservesExplicitOffPreference() {
+        val tracks = listOf(
+            subtitleTrack(index = 0, language = "", url = ""),
+            subtitleTrack(index = 1, language = "eng", url = "", playerTrackId = "hls-english"),
+        )
+
+        val result = resolver.findSubtitleTrackIndex(
+            tracks = tracks,
+            preferredLang = "",
+            preferredUrl = "",
+        )
+
+        assertEquals(0, result)
+    }
+
+    @Test
+    fun findSubtitleTrackIndex_usesPlayerCoordinates_whenSelectedFormatLosesItsId() {
+        val tracks = listOf(
+            subtitleTrack(index = 0, language = "", url = ""),
+            subtitleTrack(index = 1, language = "eng", url = "", groupIndex = 5),
+            subtitleTrack(index = 2, language = "eng", url = "", groupIndex = 6),
+            subtitleTrack(index = 3, language = "eng", url = "", groupIndex = 7),
+        )
+
+        val result = resolver.findSubtitleTrackIndex(
+            tracks = tracks,
+            preferredLang = "eng",
+            preferredUrl = "",
+            preferredPlayerTrackId = "manifest-id-that-disappeared",
+            preferredPlayerGroupIndex = 6,
+            preferredPlayerTrackIndex = 0,
+        )
+
+        assertEquals(2, result)
+    }
+
+    @Test
+    fun findSubtitleTrackIndex_matchesSavedManifestUri_whenSignedTokenChanges() {
+        val tracks = listOf(
+            subtitleTrack(index = 0, language = "", url = ""),
+            subtitleTrack(
+                index = 1,
+                language = "rus",
+                url = "",
+                playerTrackUri = "https://new.test/pd/subtitle/a/71/russian.srt?token=fresh",
+            ),
+        )
+
+        val result = resolver.findSubtitleTrackIndex(
+            tracks = tracks,
+            preferredLang = "rus",
+            preferredUrl = "https://old.test/pd/subtitle/a/71/russian.srt?token=expired",
+        )
+
+        assertEquals(1, result)
+    }
+
+    @Test
+    fun findSubtitleTrackIndex_matchesApiFileToHlsRenditionPlaylist() {
+        val tracks = listOf(
+            subtitleTrack(index = 0, language = "", url = ""),
+            subtitleTrack(
+                index = 1,
+                language = "rus",
+                url = "",
+                playerTrackUri = "https://cdn.test/hls/token/subtitles/e/53/full.srt/index.m3u8?loc=nl",
+            ),
+            subtitleTrack(
+                index = 2,
+                language = "rus",
+                url = "",
+                playerTrackUri = "https://cdn.test/hls/token/subtitles/e/b5/forced.srt/index.m3u8?loc=nl",
+            ),
+        )
+
+        val result = resolver.findSubtitleTrackIndex(
+            tracks = tracks,
+            preferredLang = "rus",
+            preferredUrl = "https://api.test/subtitles/e/b5/forced.srt?token=expired",
+        )
+
+        assertEquals(2, result)
+    }
+
+    @Test
+    fun findSubtitleTrackIndex_doesNotGuessWhenStableIdentityMatchesMultipleTracks() {
+        val tracks = listOf(
+            subtitleTrack(index = 0, language = "", url = ""),
+            subtitleTrack(index = 1, language = "rus", url = "", playerTrackUri = "https://cdn.test/a/russian.srt"),
+            subtitleTrack(index = 2, language = "rus", url = "", playerTrackUri = "https://cdn.test/b/russian.srt"),
+        )
+
+        val result = resolver.findSubtitleTrackIndex(
+            tracks = tracks,
+            preferredLang = "rus",
+            preferredUrl = "russian.srt",
+        )
+
+        assertEquals(-1, result)
+    }
+
+    @Test
+    fun findSubtitleTrackIndex_usesSavedManifestIdentity_forSameLanguageVariants() {
+        val tracks = listOf(
+            subtitleTrack(index = 0, language = "", url = ""),
+            subtitleTrack(index = 1, language = "rus", url = "", playerTrackId = "rus-full"),
+            subtitleTrack(index = 2, language = "rus", url = "", playerTrackId = "rus-forced"),
+        )
+
+        val result = resolver.findSubtitleTrackIndex(
+            tracks = tracks,
+            preferredLang = "rus",
+            preferredUrl = "rus-forced",
+        )
+
+        assertEquals(2, result)
+    }
+
+    @Test
+    fun findSubtitleTrackIndex_keepsHashSuffixInOpaqueManifestIdentity() {
+        val tracks = listOf(
+            subtitleTrack(index = 0, language = "", url = ""),
+            subtitleTrack(index = 1, language = "rus", url = "", playerTrackId = "subs:Russian #02"),
+            subtitleTrack(index = 2, language = "rus", url = "", playerTrackId = "subs:Russian #03"),
+        )
+
+        val result = resolver.findSubtitleTrackIndex(
+            tracks = tracks,
+            preferredLang = "rus",
+            preferredUrl = "subs:Russian #03",
+        )
+
+        assertEquals(2, result)
+    }
+
+    @Test
+    fun findSubtitleTrackIndex_doesNotGuessBetweenSameLanguageVariants() {
+        val tracks = listOf(
+            subtitleTrack(index = 0, language = "", url = ""),
+            subtitleTrack(index = 1, language = "rus", url = "", playerTrackId = "rus-full"),
+            subtitleTrack(index = 2, language = "rus", url = "", playerTrackId = "rus-forced"),
+        )
+
+        val result = resolver.findSubtitleTrackIndex(
+            tracks = tracks,
+            preferredLang = "rus",
+            preferredUrl = null,
+        )
+
+        assertEquals(-1, result)
+    }
+
+    @Test
+    fun findSubtitleTrackIndex_returnsNoMatch_untilPreferredManifestLanguageAppears() {
+        val tracks = listOf(
+            subtitleTrack(index = 0, language = "", url = ""),
+            subtitleTrack(index = 1, language = "rus", url = "https://cdn.test/subtitles/russian.vtt"),
+        )
+
+        val result = resolver.findSubtitleTrackIndex(
+            tracks = tracks,
+            preferredLang = "ukr",
+            preferredUrl = "",
+        )
+
+        assertEquals(-1, result)
+    }
+
+    private fun subtitleTrack(
+        index: Int,
+        language: String,
+        url: String,
+        playerTrackId: String? = null,
+        playerTrackUri: String? = null,
+        groupIndex: Int? = playerTrackId?.let { index - 1 },
+        trackIndex: Int? = groupIndex?.let { 0 },
+    ) = SubtitleTrackUIState(
+        label = "Track $index",
+        language = language,
+        url = url,
+        playerTrackId = playerTrackId,
+        playerTrackUri = playerTrackUri,
+        playerGroupIndex = groupIndex,
+        playerTrackIndex = trackIndex,
+    )
 }
diff --git a/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerCallbackGenerationTest.kt b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerCallbackGenerationTest.kt
index 61acd1fa..851b3fd7 100644
--- a/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerCallbackGenerationTest.kt
+++ b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerCallbackGenerationTest.kt
@@ -10,7 +10,9 @@ import androidx.media3.datasource.DataSource
 import androidx.media3.datasource.cache.Cache
 import androidx.media3.exoplayer.ExoPlayer
 import com.kino.puber.data.repository.PlayerPreferencesRepository
+import com.kino.puber.domain.interactor.player.StreamSource
 import com.kino.puber.ui.feature.player.model.AudioTrackUIState
+import com.kino.puber.ui.feature.player.model.SubtitleTrackUIState
 import io.mockk.every
 import io.mockk.just
 import io.mockk.mockk
@@ -72,11 +74,11 @@ internal class PlaybackControllerCallbackGenerationTest {
         controller.setPrivateField("exoPlayer", player)
         controller.setPrivateField("dataSourceFactory", mockk<DataSource.Factory>(relaxed = true))
 
-        controller.switchStream(STREAM_A, subtitles = null)
+        controller.switchStream(progressiveStream(STREAM_A), subtitles = null)
         val listenerA = addedListeners.single()
-        controller.switchStream(STREAM_B, subtitles = null)
+        controller.switchStream(progressiveStream(STREAM_B), subtitles = null)
         val listenerB = addedListeners.last()
-        controller.switchStream(STREAM_C, subtitles = null)
+        controller.switchStream(progressiveStream(STREAM_C), subtitles = null)
         val listenerC = addedListeners.last()
 
         assertEquals(listOf(STREAM_A, STREAM_B, STREAM_C), selectedStreams.map(::streamUri))
@@ -130,6 +132,8 @@ internal class PlaybackControllerCallbackGenerationTest {
         return mediaItem.localConfiguration?.uri.toString()
     }
 
+    private fun progressiveStream(url: String) = StreamSource(url = url, isHls = false)
+
     private fun PlaybackController.setPrivateField(name: String, value: Any) {
         PlaybackController::class.java.getDeclaredField(name).apply {
             isAccessible = true
@@ -147,7 +151,11 @@ internal class PlaybackControllerCallbackGenerationTest {
 
         override fun onPlaybackEnded() = Unit
 
-        override fun onTracksUpdated(audioTracks: List<AudioTrackUIState>, selectedIndex: Int) = Unit
+        override fun onTracksUpdated(
+            audioTracks: List<AudioTrackUIState>,
+            selectedIndex: Int,
+            subtitleTracks: List<SubtitleTrackUIState>,
+        ) = Unit
 
         override fun onError(message: String) {
             errors += message
diff --git a/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerTransitionsTest.kt b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerTransitionsTest.kt
index 0581ea42..7a89482b 100644
--- a/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerTransitionsTest.kt
+++ b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackControllerTransitionsTest.kt
@@ -2,6 +2,7 @@ package com.kino.puber.ui.feature.player.vm
 
 import androidx.media3.common.Player
 import com.kino.puber.data.api.models.SubtitleLink
+import com.kino.puber.domain.interactor.player.StreamSource
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Assertions.assertFalse
 import org.junit.jupiter.api.Test
@@ -71,7 +72,7 @@ internal class PlaybackControllerTransitionsTest {
 
             PlaybackTransitions.switchStream(
                 engine = engine,
-                streamUrl = "https://test/new.m3u8",
+                stream = StreamSource("https://test/new.m3u8", isHls = true),
                 subtitles = null,
             )
 
@@ -120,7 +121,7 @@ internal class PlaybackControllerTransitionsTest {
 
         PlaybackTransitions.switchStream(
             engine = engine,
-            streamUrl = "https://test/quality.m3u8",
+            stream = StreamSource("https://test/quality.m3u8", isHls = true),
             subtitles = null,
         )
         PlaybackTransitions.play(engine)
@@ -162,7 +163,7 @@ internal class PlaybackControllerTransitionsTest {
 
             PlaybackTransitions.switchStream(
                 engine = engine,
-                streamUrl = "https://test/quality.m3u8",
+                stream = StreamSource("https://test/quality.m3u8", isHls = true),
                 subtitles = null,
             )
 
@@ -214,8 +215,8 @@ internal class PlaybackControllerTransitionsTest {
             dispatchPlaybackState(Player.STATE_IDLE)
         }
 
-        override fun setMediaSource(streamUrl: String, subtitles: List<SubtitleLink>?) {
-            mutations += "setMediaSource:$streamUrl"
+        override fun setMediaSource(stream: StreamSource, subtitles: List<SubtitleLink>?) {
+            mutations += "setMediaSource:${stream.url}"
         }
 
         override fun restoreTrackSelection() {
diff --git a/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackMediaItemFactoryTest.kt b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackMediaItemFactoryTest.kt
index 60b626b5..810f2577 100644
--- a/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackMediaItemFactoryTest.kt
+++ b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlaybackMediaItemFactoryTest.kt
@@ -3,6 +3,7 @@ package com.kino.puber.ui.feature.player.vm
 import android.app.Application
 import androidx.media3.common.MimeTypes
 import com.kino.puber.data.api.models.SubtitleLink
+import com.kino.puber.domain.interactor.player.StreamSource
 import org.junit.Assert.assertEquals
 import org.junit.runner.RunWith
 import org.junit.Test
@@ -18,7 +19,10 @@ internal class PlaybackMediaItemFactoryTest {
     @Test
     fun build_preservesStreamAndBuildsStableSubtitleConfigurations() {
         val item = factory.build(
-            streamUrl = "http://127.0.0.1:8080/video.m3u8",
+            stream = StreamSource(
+                url = "http://127.0.0.1:8080/video.m3u8",
+                isHls = true,
+            ),
             subtitles = listOf(
                 SubtitleLink(
                     lang = "rus",
@@ -32,6 +36,7 @@ internal class PlaybackMediaItemFactoryTest {
         )
 
         assertEquals("http://127.0.0.1:8080/video.m3u8", item.localConfiguration?.uri.toString())
+        assertEquals(MimeTypes.APPLICATION_M3U8, item.localConfiguration?.mimeType)
         val subtitles = item.localConfiguration?.subtitleConfigurations.orEmpty()
         assertEquals(listOf("rus", "eng"), subtitles.map { it.language })
         assertEquals(listOf("rus.vtt", "eng.webvtt"), subtitles.map { it.id.orEmpty() })
@@ -46,6 +51,37 @@ internal class PlaybackMediaItemFactoryTest {
         )
     }
 
+    @Test
+    fun build_hlsKeepsApiSubtitleMarkedEmbeddedAsManifestFallback() {
+        val item = factory.build(
+            stream = StreamSource(url = "https://test/video", isHls = true),
+            subtitles = listOf(
+                SubtitleLink(lang = "rus", url = "https://test/subtitles/rus.vtt", embed = true),
+                SubtitleLink(lang = "eng", url = "https://test/subtitles/eng.vtt", embed = false),
+            ),
+        )
+
+        val subtitles = item.localConfiguration?.subtitleConfigurations.orEmpty()
+        assertEquals(listOf("rus", "eng"), subtitles.map { it.language })
+        assertEquals(listOf("rus.vtt", "eng.vtt"), subtitles.map { it.id })
+    }
+
+    @Test
+    fun build_progressiveSkipsApiSubtitleAlreadyEmbeddedInSourceContainer() {
+        val item = factory.build(
+            stream = StreamSource(url = "https://hls.test/video.mp4", isHls = false),
+            subtitles = listOf(
+                SubtitleLink(lang = "rus", url = "https://test/subtitles/rus.vtt", embed = true),
+                SubtitleLink(lang = "eng", url = "https://test/subtitles/eng.vtt", embed = false),
+            ),
+        )
+
+        assertEquals(null, item.localConfiguration?.mimeType)
+        val subtitles = item.localConfiguration?.subtitleConfigurations.orEmpty()
+        assertEquals(listOf("eng"), subtitles.map { it.language })
+        assertEquals(listOf("eng.vtt"), subtitles.map { it.id })
+    }
+
     @Test
     fun subtitleMimeType_handlesQueryFragmentAndFallbackExtensions() {
         assertEquals(MimeTypes.TEXT_VTT, factory.subtitleMimeType("https://test/subtitles/a.VTT?sig=1#x"))
diff --git a/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlayerStartModeTest.kt b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlayerStartModeTest.kt
index b11a6536..363ddebf 100644
--- a/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlayerStartModeTest.kt
+++ b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlayerStartModeTest.kt
@@ -7,6 +7,7 @@ import com.kino.puber.data.api.models.ItemType
 import com.kino.puber.domain.interactor.player.PlayerInteractor
 import com.kino.puber.domain.interactor.player.ResolvedMedia
 import com.kino.puber.domain.interactor.player.SkipSegmentInteractor
+import com.kino.puber.domain.interactor.player.StreamSource
 import com.kino.puber.domain.model.SubtitleSize
 import com.kino.puber.ui.ScreensImpl
 import com.kino.puber.ui.feature.player.model.BufferPreset
@@ -88,7 +89,7 @@ internal class PlayerStartModeTest {
         every {
             contentStateFactory.build(any(), any(), any(), any(), any(), any())
         } returns contentState
-        every { interactor.selectStreamUrl(any(), any()) } returns "https://test/v.m3u8"
+        every { interactor.selectStreamUrl(any(), any()) } returns StreamSource("https://test/v.m3u8", isHls = true)
         every { interactor.isDebugOverlayEnabled() } returns false
         every { interactor.getSubtitleSize() } returns SubtitleSize.MEDIUM
         every { interactor.getBufferPreset() } returns BufferPreset.AUTO
@@ -120,7 +121,7 @@ internal class PlayerStartModeTest {
         }
         verify {
             playbackController.prepare(
-                streamUrl = "https://test/v.m3u8",
+                stream = StreamSource("https://test/v.m3u8", isHls = true),
                 subtitles = emptyList(),
                 startPosition = 0L,
                 bufferPreset = BufferPreset.AUTO,
@@ -150,7 +151,7 @@ internal class PlayerStartModeTest {
         }
         verify {
             playbackController.prepare(
-                streamUrl = "https://test/v.m3u8",
+                stream = StreamSource("https://test/v.m3u8", isHls = true),
                 subtitles = emptyList(),
                 startPosition = null,
                 bufferPreset = BufferPreset.AUTO,
diff --git a/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlayerVMCallbackGenerationTest.kt b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlayerVMCallbackGenerationTest.kt
index fcc75888..cf27447e 100644
--- a/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlayerVMCallbackGenerationTest.kt
+++ b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlayerVMCallbackGenerationTest.kt
@@ -1,6 +1,7 @@
 package com.kino.puber.ui.feature.player.vm
 
 import com.kino.puber.data.api.models.SubtitleLink
+import com.kino.puber.domain.interactor.player.StreamSource
 import com.kino.puber.ui.feature.player.model.BufferPreset
 import com.kino.puber.ui.feature.player.model.PlayerAction
 import com.kino.puber.ui.feature.player.model.PlayerViewState
@@ -63,7 +64,10 @@ internal class PlayerVMCallbackGenerationTest : PlayerVMTestFixture() {
                 ),
             )
         every { interactor.selectStreamUrl(any(), any()) } answers {
-            "https://test/${secondArg<Int>()}.m3u8"
+            StreamSource(
+                url = "https://test/${secondArg<Int>()}.m3u8",
+                isHls = true,
+            )
         }
         val vm = startedVM()
         val sessionA = controlledPlayback.currentSession
@@ -129,7 +133,7 @@ internal class PlayerVMCallbackGenerationTest : PlayerVMTestFixture() {
         }
 
         override fun prepare(
-            streamUrl: String,
+            stream: StreamSource,
             subtitles: List<SubtitleLink>?,
             startPosition: Long?,
             bufferPreset: BufferPreset,
@@ -138,7 +142,7 @@ internal class PlayerVMCallbackGenerationTest : PlayerVMTestFixture() {
             currentSession = callbackGate.beginSession()
         }
 
-        override fun switchStream(streamUrl: String, subtitles: List<SubtitleLink>?) {
+        override fun switchStream(stream: StreamSource, subtitles: List<SubtitleLink>?) {
             currentSession = callbackGate.beginSession()
         }
 
diff --git a/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlayerVMSubtitleVariantTest.kt b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlayerVMSubtitleVariantTest.kt
new file mode 100644
index 00000000..eaa135b2
--- /dev/null
+++ b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlayerVMSubtitleVariantTest.kt
@@ -0,0 +1,256 @@
+package com.kino.puber.ui.feature.player.vm
+
+import com.kino.puber.ui.feature.player.model.AudioTrackUIState
+import com.kino.puber.ui.feature.player.model.PlayerAction
+import com.kino.puber.ui.feature.player.model.SubtitleTrackUIState
+import com.kino.puber.util.MainDispatcherExtension
+import io.mockk.every
+import io.mockk.verify
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.RegisterExtension
+
+internal class PlayerVMSubtitleVariantTest : PlayerVMTestFixture() {
+
+    companion object {
+        private const val MAX_TRACK_UPDATES = 15
+
+        @JvmField
+        @RegisterExtension
+        val mainDispatcher = MainDispatcherExtension()
+    }
+
+    @Test
+    fun tracksUpdated_addsAndSelectsManifestOnlySubtitle_withLanguagePreference() {
+        val vm = startedVM()
+        val audioTracks = listOf(AudioTrackUIState(0, "English", "eng"))
+        val manifestTrack = testSubtitleTracks.first().copy(
+            label = "Ukrainian HLS",
+            language = "uk",
+            playerTrackId = "hls-ukrainian",
+            playerTrackUri = "https://cdn.test/subtitle/ukrainian.vtt",
+            playerGroupIndex = 0,
+            playerTrackIndex = 0,
+        )
+
+        callbackSlot.captured.onTracksUpdated(audioTracks, 0, listOf(manifestTrack))
+        vm.onAction(PlayerAction.SelectSubtitle(1))
+
+        val selectedTrack = contentState(vm).subtitleTracks[1]
+        assertEquals("uk", selectedTrack.language)
+        assertEquals("hls-ukrainian", selectedTrack.playerTrackId)
+        verify { playbackController.selectSubtitle(selectedTrack) }
+        verify {
+            interactor.saveTrackPreferences(
+                42,
+                "eng",
+                "English",
+                "uk",
+                "https://cdn.test/subtitle/ukrainian.vtt",
+            )
+        }
+    }
+
+    @Test
+    fun tracksUpdated_defersUrlLessLanguagePreference_untilManifestTracksAppear() {
+        every { interactor.getPreferredSubtitleLang(42) } returns "ukr"
+        every { interactor.getPreferredSubtitleUrl(42) } returns ""
+        val vm = startedVM()
+        val audioTracks = listOf(AudioTrackUIState(0, "English", "eng"))
+        val manifestTrack = testSubtitleTracks.first().copy(
+            label = "Ukrainian HLS",
+            language = "uk",
+            playerTrackId = "hls-ukrainian",
+            playerGroupIndex = 0,
+            playerTrackIndex = 0,
+        )
+
+        callbackSlot.captured.onTracksUpdated(audioTracks, 0, emptyList())
+        verify(exactly = 0) { playbackController.selectSubtitle(any()) }
+
+        callbackSlot.captured.onTracksUpdated(audioTracks, 0, listOf(manifestTrack))
+
+        val selectedTrack = contentState(vm).subtitleTracks[1]
+        assertEquals(1, contentState(vm).selectedSubtitleIndex)
+        assertEquals("hls-ukrainian", selectedTrack.playerTrackId)
+        verify { playbackController.selectSubtitle(selectedTrack) }
+    }
+
+    @Test
+    fun tracksUpdated_restoresForcedManifestSubtitleBySavedIdentity() {
+        every { interactor.getPreferredSubtitleLang(42) } returns "rus"
+        every { interactor.getPreferredSubtitleUrl(42) } returns "hls-russian-forced"
+        val vm = startedVM()
+        val audioTracks = listOf(AudioTrackUIState(0, "English", "eng"))
+        val manifestTracks = listOf(
+            testSubtitleTracks.first().copy(
+                label = "Russian full",
+                language = "ru",
+                isForced = false,
+                playerTrackId = "hls-russian-full",
+                playerGroupIndex = 0,
+                playerTrackIndex = 0,
+            ),
+            testSubtitleTracks.first().copy(
+                label = "Russian forced",
+                language = "ru",
+                isForced = true,
+                playerTrackId = "hls-russian-forced",
+                playerGroupIndex = 1,
+                playerTrackIndex = 0,
+            ),
+        )
+
+        callbackSlot.captured.onTracksUpdated(audioTracks, 0, emptyList())
+        verify(exactly = 0) { playbackController.selectSubtitle(any()) }
+
+        callbackSlot.captured.onTracksUpdated(audioTracks, 0, manifestTracks)
+
+        val selectedTrack = contentState(vm).subtitleTracks[2]
+        assertEquals("hls-russian-forced", selectedTrack.playerTrackId)
+        assertEquals(2, contentState(vm).selectedSubtitleIndex)
+        verify { playbackController.selectSubtitle(selectedTrack) }
+    }
+
+    @Test
+    fun tracksUpdated_keepsSelectedVariant_whenSelectedFormatIdDisappears() {
+        val vm = startedVM()
+        val audioTracks = listOf(AudioTrackUIState(0, "English", "eng"))
+        val manifestTracks = listOf(
+            manifestTrack("English 1", "manifest-eng-1", groupIndex = 5),
+            manifestTrack("English 2", "manifest-eng-2", groupIndex = 6),
+            manifestTrack("English 3", "manifest-eng-3", groupIndex = 7),
+        )
+        callbackSlot.captured.onTracksUpdated(audioTracks, 0, manifestTracks)
+        vm.onAction(PlayerAction.SelectSubtitle(2))
+
+        callbackSlot.captured.onTracksUpdated(
+            audioTracks,
+            0,
+            manifestTracks.map { it.copy(playerTrackId = null, playerTrackUri = null) },
+        )
+
+        assertEquals(2, contentState(vm).selectedSubtitleIndex)
+        assertEquals(6, contentState(vm).subtitleTracks[2].playerGroupIndex)
+    }
+
+    @Test
+    fun tracksUpdated_keepsSelectedVariant_duringTransientEmptyTrackUpdate() {
+        val vm = startedVM()
+        val audioTracks = listOf(AudioTrackUIState(0, "English", "eng"))
+        val manifestTracks = listOf(
+            manifestTrack("English 1", "manifest-eng-1", groupIndex = 5),
+            manifestTrack("English 2", "manifest-eng-2", groupIndex = 6),
+        )
+        callbackSlot.captured.onTracksUpdated(audioTracks, 0, manifestTracks)
+        vm.onAction(PlayerAction.SelectSubtitle(2))
+
+        callbackSlot.captured.onTracksUpdated(audioTracks, 0, emptyList())
+
+        assertEquals(2, contentState(vm).selectedSubtitleIndex)
+        assertEquals("manifest-eng-2", contentState(vm).subtitleTracks[2].playerTrackId)
+    }
+
+    @Test
+    fun tracksUpdated_keepsAudioTracks_whenUpdateCarriesOnlyTextTracks() {
+        val vm = startedVM()
+        val audioTracks = listOf(
+            AudioTrackUIState(0, "English", "eng"),
+            AudioTrackUIState(1, "Russian", "rus"),
+        )
+        callbackSlot.captured.onTracksUpdated(audioTracks, 1, testDiscoveredSubtitleTracks)
+
+        callbackSlot.captured.onTracksUpdated(emptyList(), 0, testDiscoveredSubtitleTracks)
+
+        assertEquals(audioTracks, contentState(vm).audioTracks)
+        assertEquals(1, contentState(vm).selectedAudioTrackIndex)
+    }
+
+    @Test
+    fun tracksUpdated_stopsRetryingRestore_whenSubtitleTracksNeverAppear() {
+        every { interactor.getPreferredAudioLang(42) } returns "rus"
+        every { interactor.getPreferredSubtitleLang(42) } returns "rus"
+        every { interactor.getPreferredSubtitleUrl(42) } returns ""
+        val vm = startedVM()
+        val audioTracks = listOf(
+            AudioTrackUIState(0, "English", "eng"),
+            AudioTrackUIState(1, "Russian", "rus"),
+        )
+
+        repeat(MAX_TRACK_UPDATES) {
+            callbackSlot.captured.onTracksUpdated(audioTracks, 0, emptyList())
+        }
+
+        // The audio restore must run once, not once per deferred subtitle retry.
+        verify(exactly = 1) { playbackController.selectAudioTrack(any()) }
+        assertEquals(0, contentState(vm).selectedSubtitleIndex)
+    }
+
+    @Test
+    fun tracksUpdated_appliesAudioRestoreOnce_andLetsLaterUserChoiceStand() {
+        every { interactor.getPreferredAudioLang(42) } returns "eng"
+        every { interactor.getPreferredSubtitleLang(42) } returns "rus"
+        every { interactor.getPreferredSubtitleUrl(42) } returns ""
+        val vm = startedVM()
+        val audioTracks = listOf(
+            AudioTrackUIState(0, "English", "eng"),
+            AudioTrackUIState(1, "Russian", "rus"),
+        )
+
+        callbackSlot.captured.onTracksUpdated(audioTracks, 0, emptyList())
+        vm.onAction(PlayerAction.SelectAudioTrack(1))
+        callbackSlot.captured.onTracksUpdated(audioTracks, 1, emptyList())
+
+        assertEquals(1, contentState(vm).selectedAudioTrackIndex)
+        // Restored once on the first update, never re-applied over the user's choice.
+        verify(exactly = 1) { playbackController.selectAudioTrack(0) }
+    }
+
+    @Test
+    fun audioSelection_keepsStoredSubtitlePreference_whileSubtitleTracksAreUnknown() {
+        every { interactor.getPreferredSubtitleLang(42) } returns "rus"
+        every { interactor.getPreferredSubtitleUrl(42) } returns "https://api.test/subtitles/rus.srt"
+        val vm = startedVM()
+        val audioTracks = listOf(AudioTrackUIState(0, "English", "eng"))
+        callbackSlot.captured.onTracksUpdated(audioTracks, 0, emptyList())
+
+        vm.onAction(PlayerAction.SelectAudioTrack(0))
+
+        verify {
+            interactor.saveTrackPreferences(
+                42,
+                "eng",
+                "English",
+                "rus",
+                "https://api.test/subtitles/rus.srt",
+            )
+        }
+    }
+
+    @Test
+    fun subtitleSelection_persistsOffChoice_onceSubtitleTracksAreKnown() {
+        every { interactor.getPreferredSubtitleLang(42) } returns "rus"
+        every { interactor.getPreferredSubtitleUrl(42) } returns "https://api.test/subtitles/rus.srt"
+        val vm = startedVM()
+        val audioTracks = listOf(AudioTrackUIState(0, "English", "eng"))
+        callbackSlot.captured.onTracksUpdated(audioTracks, 0, testDiscoveredSubtitleTracks)
+
+        vm.onAction(PlayerAction.SelectSubtitle(0))
+
+        verify { interactor.saveTrackPreferences(42, "eng", "English", null, null) }
+    }
+
+    private fun manifestTrack(
+        label: String,
+        id: String,
+        groupIndex: Int,
+    ) = SubtitleTrackUIState(
+        label = label,
+        language = "en",
+        url = "",
+        playerTrackId = id,
+        playerTrackUri = "https://cdn.test/subtitle/$id.vtt",
+        playerGroupIndex = groupIndex,
+        playerTrackIndex = 0,
+    )
+}
diff --git a/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlayerVMTest.kt b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlayerVMTest.kt
index c4ccc14c..58edbaf4 100644
--- a/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlayerVMTest.kt
+++ b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlayerVMTest.kt
@@ -46,6 +46,7 @@ import timber.log.Timber
  * `startPositionUpdates()` loop forever → OOM.
  * Without `runTest`, the infinite loop stays suspended at its first `delay()` — harmless.
  */
+@Suppress("LargeClass")
 internal class PlayerVMTest : PlayerVMTestFixture() {
 
     companion object {
@@ -71,7 +72,7 @@ internal class PlayerVMTest : PlayerVMTestFixture() {
     fun onStart_preparesPlayer() {
         startedVM()
         verify { playbackController.setCallback(any()) }
-        verify { playbackController.prepare("https://test/v.m3u8", any(), any()) }
+        verify { playbackController.prepare(testStream, any(), any()) }
     }
 
     @Test
@@ -718,9 +719,10 @@ internal class PlayerVMTest : PlayerVMTestFixture() {
     @Test
     fun selectSubtitle_updatesStateAndDelegates() {
         val vm = startedVM()
+        callbackSlot.captured.onTracksUpdated(testContentState.audioTracks, 0, testDiscoveredSubtitleTracks)
         vm.onAction(PlayerAction.SelectSubtitle(1))
         assertEquals(1, contentState(vm).selectedSubtitleIndex)
-        verify { playbackController.selectSubtitle(testSubtitleTracks[1]) }
+        verify { playbackController.selectSubtitle(contentState(vm).subtitleTracks[1]) }
     }
 
     @Test
@@ -738,9 +740,9 @@ internal class PlayerVMTest : PlayerVMTestFixture() {
         val vm = startedVM()
 
         val tracks = listOf(AudioTrackUIState(0, "English", "eng"), AudioTrackUIState(1, "Russian", "rus"))
-        callbackSlot.captured.onTracksUpdated(tracks, 0)
+        callbackSlot.captured.onTracksUpdated(tracks, 0, testDiscoveredSubtitleTracks)
 
-        verify { playbackController.selectSubtitle(testSubtitleTracks[2]) }
+        verify { playbackController.selectSubtitle(contentState(vm).subtitleTracks[2]) }
         assertEquals(2, contentState(vm).selectedSubtitleIndex)
     }
 
@@ -752,9 +754,9 @@ internal class PlayerVMTest : PlayerVMTestFixture() {
         val vm = startedVM()
 
         val tracks = listOf(AudioTrackUIState(0, "English", "eng"), AudioTrackUIState(1, "Russian", "rus"))
-        callbackSlot.captured.onTracksUpdated(tracks, 0)
+        callbackSlot.captured.onTracksUpdated(tracks, 0, testDiscoveredSubtitleTracks)
 
-        verify { playbackController.selectSubtitle(testSubtitleTracks[2]) }
+        verify { playbackController.selectSubtitle(contentState(vm).subtitleTracks[2]) }
         assertEquals(2, contentState(vm).selectedSubtitleIndex)
     }
 
@@ -765,7 +767,7 @@ internal class PlayerVMTest : PlayerVMTestFixture() {
         val vm = startedVM()
 
         val tracks = listOf(AudioTrackUIState(0, "English", "eng"), AudioTrackUIState(1, "Russian", "rus"))
-        callbackSlot.captured.onTracksUpdated(tracks, 0)
+        callbackSlot.captured.onTracksUpdated(tracks, 0, testDiscoveredSubtitleTracks)
 
         verify(exactly = 0) { playbackController.selectSubtitle(any()) }
         assertEquals(0, contentState(vm).selectedSubtitleIndex)
@@ -779,10 +781,10 @@ internal class PlayerVMTest : PlayerVMTestFixture() {
         val vm = startedVM()
 
         val tracks = listOf(AudioTrackUIState(0, "English", "eng"), AudioTrackUIState(1, "Russian", "rus"))
-        callbackSlot.captured.onTracksUpdated(tracks, 0)
+        callbackSlot.captured.onTracksUpdated(tracks, 0, testDiscoveredSubtitleTracks)
 
         verify { playbackController.selectAudioTrack(1) }
-        verify { playbackController.selectSubtitle(testSubtitleTracks[2]) }
+        verify { playbackController.selectSubtitle(contentState(vm).subtitleTracks[2]) }
         verify(exactly = 0) { interactor.saveTrackPreferences(any(), any(), any(), any(), any()) }
         assertEquals(1, contentState(vm).selectedAudioTrackIndex)
         assertEquals(2, contentState(vm).selectedSubtitleIndex)
@@ -823,6 +825,22 @@ internal class PlayerVMTest : PlayerVMTestFixture() {
         verify { playbackController.switchStream(any(), any()) }
     }
 
+    @Test
+    fun selectQuality_clearsDiscoveredSubtitles_whenReplacementHasNone() {
+        val vm = startedVM()
+        callbackSlot.captured.onTracksUpdated(
+            testContentState.audioTracks,
+            0,
+            testDiscoveredSubtitleTracks,
+        )
+
+        vm.onAction(PlayerAction.SelectQuality(1))
+        callbackSlot.captured.onTracksUpdated(testContentState.audioTracks, 0, emptyList())
+
+        assertEquals(testSubtitleTracks.take(1), contentState(vm).subtitleTracks)
+        assertEquals(0, contentState(vm).selectedSubtitleIndex)
+    }
+
     @Test
     fun selectQuality_doesNothing_whenSameIndex() {
         val vm = startedVM()
diff --git a/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlayerVMTestFixture.kt b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlayerVMTestFixture.kt
index b8a5971f..8b3709bf 100644
--- a/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlayerVMTestFixture.kt
+++ b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/PlayerVMTestFixture.kt
@@ -13,6 +13,7 @@ import com.kino.puber.data.api.models.Season
 import com.kino.puber.domain.interactor.player.PlayerInteractor
 import com.kino.puber.domain.interactor.player.ResolvedMedia
 import com.kino.puber.domain.interactor.player.SkipSegmentInteractor
+import com.kino.puber.domain.interactor.player.StreamSource
 import com.kino.puber.domain.model.SubtitleSize
 import com.kino.puber.ui.feature.player.model.ActivePanel
 import com.kino.puber.ui.feature.player.model.AudioTrackUIState
@@ -68,7 +69,7 @@ internal abstract class PlayerVMTestFixture {
         coEvery { contentStateFactory.build(any(), any(), any(), any(), any(), any()) } returns testContentState
         coEvery { interactor.markCurrentAsWatched(any(), any(), any()) } returns
             testItem.withCurrentEpisodeWatched(true)
-        every { interactor.selectStreamUrl(any(), any()) } returns "https://test/v.m3u8"
+        every { interactor.selectStreamUrl(any(), any()) } returns testStream
         every { interactor.getPreferredAudioLabel(any()) } returns null
         every { interactor.getPreferredAudioLang(any()) } returns null
         every { interactor.getPreferredSubtitleLang(any()) } returns null
@@ -189,17 +190,28 @@ internal abstract class PlayerVMTestFixture {
         episodeNumber = 1,
     )
 
+    protected val testStream = StreamSource("https://test/v.m3u8", isHls = true)
+
     protected val testSubtitleTracks = listOf(
-        SubtitleTrackUIState(index = 0, label = "Off", language = "", url = ""),
-        SubtitleTrackUIState(index = 1, label = "Russian", language = "rus", url = "https://test/subtitles/rus.vtt"),
+        SubtitleTrackUIState(label = "Off", language = "", url = ""),
+        SubtitleTrackUIState(label = "Russian", language = "rus", url = "https://test/subtitles/rus.vtt"),
         SubtitleTrackUIState(
-            index = 2,
             label = "Russian forced",
             language = "rus",
             url = "https://test/subtitles/rus-forced.vtt",
         ),
     )
 
+    protected val testDiscoveredSubtitleTracks = testSubtitleTracks.drop(1).mapIndexed { index, track ->
+        track.copy(
+            url = "",
+            playerTrackId = track.url,
+            playerTrackUri = track.url,
+            playerGroupIndex = index,
+            playerTrackIndex = 0,
+        )
+    }
+
     protected val testContentState = PlayerContentState(
         title = "Breaking Bad",
         subtitle = "S1E1",
diff --git a/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/SubtitleLabelerTest.kt b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/SubtitleLabelerTest.kt
new file mode 100644
index 00000000..0a230c8f
--- /dev/null
+++ b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/SubtitleLabelerTest.kt
@@ -0,0 +1,130 @@
+package com.kino.puber.ui.feature.player.vm
+
+import com.kino.puber.ui.feature.player.model.SubtitleTrackUIState
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+internal class SubtitleLabelerTest {
+
+    private val labeler = SubtitleLabeler(
+        displayLanguageTag = "ru",
+        aiGeneratedLabel = "Созданные ИИ",
+        forcedQualifier = "частичные",
+        variantLabel = { label, ordinal -> "$label · вариант $ordinal" },
+        unknownLabel = { position -> "Субтитры $position" },
+    )
+
+    @Test
+    fun apply_namesRowsByLocalizedLanguage_forTwoAndThreeLetterCodes() {
+        val labels = labeler.apply(
+            listOf(track("rus"), track("en"), track("spa"), track("uk")),
+        ).map { it.label }
+
+        assertEquals(listOf("Русский", "Английский", "Испанский", "Украинский"), labels)
+    }
+
+    @Test
+    fun apply_marksPartialTrack() {
+        val labels = labeler.apply(listOf(track("rus"), track("rus", forced = true)))
+            .map { it.label }
+
+        assertEquals(listOf("Русский", "Русский · частичные"), labels)
+    }
+
+    @Test
+    fun apply_namesAiGeneratedTrack_whenApiUsesAiLanguageCode() {
+        val labels = labeler.apply(listOf(track("ai", descriptive = "AI #02")))
+            .map { it.label }
+
+        assertEquals(listOf("Созданные ИИ"), labels)
+    }
+
+    @Test
+    fun apply_neverShowsSubtitleFileNames() {
+        val labels = labeler.apply(
+            listOf(
+                track("spa", descriptive = "29725.srt"),
+                track("spa", descriptive = "29727.srt"),
+            ),
+        ).map { it.label }
+
+        assertEquals(listOf("Испанский · вариант 1", "Испанский · вариант 2"), labels)
+    }
+
+    @Test
+    fun apply_neverShowsCdnChannelNumbering() {
+        val labels = labeler.apply(
+            listOf(
+                track("rus", descriptive = "RUS #03"),
+                track("rus", descriptive = "RUS #05"),
+            ),
+        ).map { it.label }
+
+        assertEquals(listOf("Русский · вариант 1", "Русский · вариант 2"), labels)
+    }
+
+    @Test
+    fun apply_usesManifestLabels_whenTheyReadAsNamesAndSeparateTheRows() {
+        val labels = labeler.apply(
+            listOf(
+                track("rus", descriptive = "Русские полные"),
+                track("rus", descriptive = "Русские SDH"),
+            ),
+        ).map { it.label }
+
+        assertEquals(listOf("Русские полные", "Русские SDH"), labels)
+    }
+
+    @Test
+    fun apply_keepsPartialMarker_whenAManifestLabelSeparatesTheRows() {
+        val labels = labeler.apply(
+            listOf(
+                track("rus", descriptive = "Русские полные", forced = true),
+                track("rus", descriptive = "Русские SDH", forced = true),
+            ),
+        ).map { it.label }
+
+        assertEquals(
+            listOf("Русские полные · частичные", "Русские SDH · частичные"),
+            labels,
+        )
+    }
+
+    @Test
+    fun apply_doesNotQualifyRowsThatAlreadyReadDifferently() {
+        val labels = labeler.apply(
+            listOf(track("rus", descriptive = "RUS #03"), track("eng", descriptive = "ENG #01")),
+        ).map { it.label }
+
+        assertEquals(listOf("Русский", "Английский"), labels)
+    }
+
+    @Test
+    fun apply_preservesUnknownLanguageInformation_beforePositionalFallback() {
+        val labels = labeler.apply(
+            listOf(
+                track(""),
+                track("", descriptive = "Комментарии режиссёра"),
+                track("qqq"),
+                track("xyz", descriptive = "ALT #04"),
+            ),
+        ).map { it.label }
+
+        assertEquals(
+            listOf("Субтитры 1", "Комментарии режиссёра", "QQQ", "ALT #04"),
+            labels,
+        )
+    }
+
+    private fun track(
+        language: String,
+        descriptive: String? = null,
+        forced: Boolean = false,
+    ) = SubtitleTrackUIState(
+        label = "",
+        language = language,
+        url = "",
+        isForced = forced,
+        descriptiveLabel = descriptive,
+    )
+}
diff --git a/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/SubtitleTrackMergerTest.kt b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/SubtitleTrackMergerTest.kt
new file mode 100644
index 00000000..91ee0146
--- /dev/null
+++ b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/SubtitleTrackMergerTest.kt
@@ -0,0 +1,502 @@
+package com.kino.puber.ui.feature.player.vm
+
+import com.kino.puber.ui.feature.player.model.SubtitleTrackUIState
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertFalse
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.CsvSource
+
+internal class SubtitleTrackMergerTest {
+
+    private val merger = SubtitleTrackMerger(labeler = testLabeler())
+
+    private fun testLabeler() = SubtitleLabeler(
+        displayLanguageTag = "ru",
+        aiGeneratedLabel = "Созданные ИИ",
+        forcedQualifier = "частичные",
+        variantLabel = { label, ordinal -> "$label · вариант $ordinal" },
+        unknownLabel = { position -> "Субтитры $position" },
+    )
+
+    @ParameterizedTest
+    @CsvSource(
+        "0, 0, ''",
+        "0, 2, '1:api-0.srt 2:api-1.srt'",
+        "2, 0, 'hls-0 hls-1'",
+        "1, 2, '1:api-0.srt 2:api-1.srt'",
+        "2, 1, 'hls-0 hls-1'",
+        "1, 1, 'hls-0'",
+        "2, 2, 'hls-0 hls-1'",
+    )
+    fun merge_usesLargerLanguageGroup_preferringHlsOnTies(
+        hlsCount: Int,
+        apiCount: Int,
+        expectedIds: String,
+    ) {
+        val apiTracks = List(apiCount) { index ->
+            apiTrack("Russian API", "rus", url = "https://api.test/subtitles/api-$index.srt")
+        }
+        val sideLoadedTracks = List(apiCount) { index ->
+            playerTrack("Russian API", "rus", "${index + 1}:api-$index.srt", index)
+        }
+        val hlsTracks = List(hlsCount) { index ->
+            playerTrack(
+                "Russian HLS", "ru", "hls-$index", apiCount + index,
+                uri = "https://cdn.test/hls/rus-$index.m3u8",
+            )
+        }
+
+        val result = merger.merge(
+            listOf(offTrack()) + apiTracks,
+            listOf(offTrack()) + sideLoadedTracks + hlsTracks,
+        )
+
+        assertEquals(offTrack(), result.first())
+        assertEquals(
+            expectedIds.split(' ').filter { it.isNotEmpty() },
+            result.drop(1).map { it.playerTrackId },
+        )
+    }
+
+    @Test
+    fun merge_choosesSourceIndependentlyForEachCanonicalLanguage() {
+        val apiTracks = listOf(
+            offTrack(),
+            apiTrack("Russian 1", "rus", url = "https://api.test/subtitles/rus-1.srt"),
+            apiTrack("English", "eng", url = "https://api.test/subtitles/eng.srt"),
+            apiTrack("Russian 2", "rus", url = "https://api.test/subtitles/rus-2.srt"),
+        )
+        val playerTracks = listOf(
+            playerTrack("Russian HLS", "ru-RU", "hls-rus", 0, uri = "https://cdn.test/hls/rus.m3u8"),
+            playerTrack("English HLS 1", "en-US", "hls-eng-1", 1, uri = "https://cdn.test/hls/eng-1.m3u8"),
+            playerTrack("Russian API 1", "RUS", "1:rus-1.srt", 2),
+            playerTrack("English API", "eng", "2:eng.srt", 3),
+            playerTrack("Russian API 2", " ru_RU ", "3:rus-2.srt", 4),
+            playerTrack("English HLS 2", "en_GB", "hls-eng-2", 5, uri = "https://cdn.test/hls/eng-2.m3u8"),
+        )
+
+        val result = merger.merge(apiTracks, playerTracks)
+
+        assertEquals(
+            listOf("1:rus-1.srt", "3:rus-2.srt", "hls-eng-1", "hls-eng-2"),
+            result.drop(1).map { it.playerTrackId },
+        )
+        assertEquals(listOf(2, 4, 1, 5), result.drop(1).map { it.playerGroupIndex })
+    }
+
+    @Test
+    fun merge_enrichesWinningApiGroup_andOrdersForcedVariantLast() {
+        val apiTracks = listOf(
+            offTrack(),
+            apiTrack("Russian forced", "rus", "https://api.test/pd/forced", true, "/rus-forced.srt"),
+            apiTrack("Russian full", "rus", "https://api.test/pd/full", false, "/rus-full.srt"),
+        )
+        val playerTracks = listOf(
+            playerTrack(
+                "Russian HLS", "ru", "hls-rus", 0,
+                uri = "https://cdn.test/subtitles/rus-forced.srt/index.m3u8",
+            ),
+            playerTrack("Russian API forced", "rus", "1:rus-forced.srt", 1),
+            playerTrack("Russian API full", "rus", "2:rus-full.srt", 2),
+        )
+
+        val result = merger.merge(apiTracks, playerTracks)
+
+        assertEquals(listOf("Off", "Русский", "Русский · частичные"), result.map { it.label })
+        assertEquals(listOf("2:rus-full.srt", "1:rus-forced.srt"), result.drop(1).map { it.playerTrackId })
+        assertEquals(listOf(2, 1), result.drop(1).map { it.playerGroupIndex })
+        assertEquals(listOf(0, 0), result.drop(1).map { it.playerTrackIndex })
+        assertEquals(listOf(false, true), result.drop(1).map { it.isForced })
+        assertEquals(listOf("/rus-full.srt", "/rus-forced.srt"), result.drop(1).map { it.sourceFile })
+        assertEquals(
+            listOf("https://api.test/pd/full", "https://api.test/pd/forced"),
+            result.drop(1).map { it.url },
+        )
+    }
+
+    @Test
+    fun merge_usesPlayerTracksAsBackbone_andEnrichesExactIdentity() {
+        val apiTracks = listOf(
+            offTrack(),
+            apiTrack(label = "Russian embedded", language = "rus", url = "https://api.test/subtitles/embedded-rus.srt"),
+            apiTrack(label = "Russian external", language = "rus", url = "https://api.test/subtitles/external-rus.srt"),
+        )
+        val playerTracks = listOf(
+            playerTrack(label = "external-rus.srt", language = "rus", id = "external-rus.srt", groupIndex = 0),
+            playerTrack(label = "Русские полные", language = "ru", id = "hls-russian-full", groupIndex = 1),
+        )
+
+        val result = merger.merge(apiTracks, playerTracks)
+
+        assertEquals(
+            listOf("Off", "Русский · вариант 1", "Русский · вариант 2"),
+            result.map { it.label },
+        )
+        assertEquals("external-rus.srt", result[1].playerTrackId)
+        assertEquals("https://api.test/subtitles/external-rus.srt", result[1].url)
+        assertEquals("hls-russian-full", result[2].playerTrackId)
+        assertEquals("ru", result[2].language)
+    }
+
+    @Test
+    fun merge_doesNotPairSameLanguageVariants_withoutExactIdentity() {
+        val apiTracks = listOf(
+            offTrack(),
+            apiTrack("Russian full", "rus", forced = false),
+            apiTrack("Russian forced", "rus", forced = true),
+        )
+        val playerTracks = listOf(
+            playerTrack("Russian forced HLS", "ru", "forced", 0, forced = true),
+            playerTrack("Russian full HLS", "ru", "full", 1, forced = false),
+        )
+
+        val result = merger.merge(apiTracks, playerTracks)
+
+        assertEquals(listOf("Off", "Русский", "Русский · частичные"), result.map { it.label })
+        assertEquals("full", result[1].playerTrackId)
+        assertFalse(result[1].isForced!!)
+        assertEquals("forced", result[2].playerTrackId)
+        assertTrue(result[2].isForced!!)
+    }
+
+    @Test
+    fun merge_dropsUnmatchedApiTrack_whenPlayerTracksAreAvailable() {
+        val apiTracks = listOf(
+            offTrack(),
+            apiTrack(label = "Russian external", language = "rus", url = "https://api.test/subtitles/external.srt"),
+        )
+        val playerTracks = listOf(
+            playerTrack("Russian HLS", "ru", "hls-russian", 0),
+        )
+
+        val result = merger.merge(apiTracks, playerTracks)
+
+        assertEquals(listOf("Off", "Русский"), result.map { it.label })
+        assertEquals("", result[1].url)
+        assertEquals("hls-russian", result[1].playerTrackId)
+    }
+
+    @Test
+    fun merge_doesNotTreatDisplayLabelAsTrackIdentity() {
+        val apiTrack = apiTrack(label = "Spanish API", language = "spa", url = "https://api.test/subtitles/spanish.srt")
+        val playerTrack = playerTrack(label = "spanish.srt", language = "rus", id = "hls-russian", groupIndex = 0)
+
+        val result = merger.merge(listOf(offTrack(), apiTrack), listOf(playerTrack))
+
+        assertEquals("", result[1].url)
+        assertEquals("rus", result[1].language)
+        assertEquals("hls-russian", result[1].playerTrackId)
+    }
+
+    @Test
+    fun merge_groupsVariantsByLanguage_keepingManifestOrderWithinEachLanguage() {
+        val apiTracks = listOf(
+            offTrack(),
+            apiTrack("rus #1", "rus"),
+            apiTrack("rus #2", "rus"),
+            apiTrack("rus #3", "rus"),
+            apiTrack("spa", "spa"),
+        )
+        val playerTracks = listOf(
+            playerTrack("Russian 1", "ru", "rus-1", 0),
+            playerTrack("Spanish", "es", "spa", 1),
+            playerTrack("Russian 2", "ru", "rus-2", 2),
+            playerTrack("Russian 3", "ru", "rus-3", 3),
+        )
+
+        val result = merger.merge(apiTracks, playerTracks)
+
+        assertEquals(
+            listOf(
+                "Off",
+                "Русский · вариант 1",
+                "Русский · вариант 2",
+                "Русский · вариант 3",
+                "Испанский",
+            ),
+            result.map { it.label },
+        )
+        assertEquals(listOf(null, 0, 2, 3, 1), result.map { it.playerGroupIndex })
+        assertEquals(listOf("rus-1", "rus-2", "rus-3", "spa"), result.drop(1).map { it.playerTrackId })
+    }
+
+    @Test
+    fun merge_usesApiFilePathToMatchHlsRenditionUri_whenLanguageOrderDiffers() {
+        val apiTracks = listOf(
+            offTrack(),
+            apiTrack(label = "rus #1", language = "rus", sourceFile = "/a/71/first.srt"),
+            apiTrack(
+                label = "rus #2",
+                language = "rus",
+                forced = true,
+                sourceFile = "/b/82/second.srt",
+            ),
+        )
+        val playerTracks = listOf(
+            playerTrack(
+                label = "Russian 2",
+                language = "ru",
+                id = "subs:Russian #02",
+                groupIndex = 0,
+                uri = "https://cdn.test/hls/token/subtitles/b/82/second.srt/index.m3u8?loc=nl",
+            ),
+            playerTrack(
+                label = "Russian 1",
+                language = "ru",
+                id = "subs:Russian #01",
+                groupIndex = 1,
+                uri = "https://cdn.test/hls/token/subtitles/a/71/first.srt/index.m3u8?loc=nl",
+            ),
+        )
+
+        val result = merger.merge(apiTracks, playerTracks)
+
+        assertEquals(listOf(1, 0), result.drop(1).map { it.playerGroupIndex })
+        assertEquals(
+            listOf("subs:Russian #01", "subs:Russian #02"),
+            result.drop(1).map { it.playerTrackId },
+        )
+        assertEquals(
+            listOf("/a/71/first.srt", "/b/82/second.srt"),
+            result.drop(1).map { it.sourceFile },
+        )
+        assertTrue(result[2].isForced!!)
+    }
+
+    @Test
+    fun merge_matchesSideLoadedTrackByStableUrl_whenHostAndTokenChange() {
+        val apiTrack = apiTrack(
+            label = "Russian external",
+            language = "rus",
+            url = "https://old-cdn.test/subtitles/russian.vtt?token=expired",
+        )
+        val playerTrack = playerTrack(
+            label = "russian.vtt",
+            language = "ru",
+            id = "https://new-cdn.test/subtitles/russian.vtt?token=fresh",
+            groupIndex = 0,
+        )
+
+        val result = merger.merge(listOf(offTrack(), apiTrack), listOf(playerTrack))
+
+        assertEquals(listOf("Off", "Русский"), result.map { it.label })
+        assertEquals(playerTrack.playerTrackId, result[1].playerTrackId)
+        assertEquals("ru", result[1].language)
+        assertEquals(apiTrack.url, result[1].url)
+    }
+
+    @Test
+    fun merge_exposesOnlyOff_untilPlayerTracksAreDiscovered() {
+        val apiTracks = listOf(
+            offTrack(),
+            apiTrack("Russian full", "rus"),
+            apiTrack("Russian forced", "rus"),
+        )
+
+        val result = merger.merge(apiTracks, emptyList())
+
+        assertEquals(listOf("Off"), result.map { it.label })
+    }
+
+    @Test
+    fun merge_marksPartialVariant_andOrdersItLastWithinItsLanguage() {
+        val playerTracks = listOf(
+            playerTrack("rus", "rus", "full", 0, forced = false, descriptiveLabel = "RUS"),
+            playerTrack("rus", "rus", "forced", 1, forced = true, descriptiveLabel = "RUS"),
+        )
+
+        val result = merger.merge(listOf(offTrack()), playerTracks)
+
+        assertEquals(listOf("Off", "Русский", "Русский · частичные"), result.map { it.label })
+        assertEquals(listOf(null, false, true), result.map { it.isForced })
+    }
+
+    /**
+     * Real KinoPub data: the API lists two subtitles, the manifest publishes three
+     * renditions covering both languages, and Media3 prefixes side-loaded track ids with
+     * the merged child index. The renditions win and the side-loaded copies disappear.
+     */
+    @Test
+    fun merge_hidesSideLoadedCopies_whenManifestCoversTheirLanguages() {
+        val apiTracks = listOf(
+            offTrack(),
+            apiTrack("eng", "eng", url = "https://api.test/pd/xyz", sourceFile = "/9/24/2871466.srt"),
+            apiTrack("rus", "rus", url = "https://api.test/pd/abc", sourceFile = "/1/92/2871463.srt"),
+        )
+        val playerTracks = listOf(
+            playerTrack("", "ru", "0:", 0, uri = "https://cdn.test/hls/rus01.m3u8", descriptiveLabel = "RUS #01"),
+            playerTrack("", "ru", "0:", 1, uri = "https://cdn.test/hls/rus02.m3u8", descriptiveLabel = "RUS #02"),
+            playerTrack("", "en", "0:", 2, uri = "https://cdn.test/hls/eng03.m3u8", descriptiveLabel = "ENG #03"),
+            playerTrack("", "en", "1:9/24/2871466.srt", 3),
+            playerTrack("", "ru", "2:1/92/2871463.srt", 4),
+        )
+
+        val result = merger.merge(apiTracks, playerTracks)
+
+        assertEquals(
+            listOf("Off", "Русский · вариант 1", "Русский · вариант 2", "Английский"),
+            result.map { it.label },
+        )
+    }
+
+    @Test
+    fun merge_labelsAiGeneratedManifestTrack_fromKinoPubMetadata() {
+        val apiTracks = listOf(
+            offTrack(),
+            apiTrack(
+                label = "ai",
+                language = "ai",
+                url = "https://api.test/subtitles/f/e3/2900236.srt",
+                forced = false,
+                sourceFile = "/f/e3/2900236.srt",
+            ),
+        )
+        val playerTracks = listOf(
+            playerTrack(
+                label = "",
+                language = "ai",
+                id = "0:",
+                groupIndex = 0,
+                uri = "https://cdn.test/subtitles/f/e3/2900236.srt/index.m3u8",
+                descriptiveLabel = "AI #02",
+            ),
+            playerTrack(
+                label = "",
+                language = "ai",
+                id = "1:f/e3/2900236.srt",
+                groupIndex = 1,
+                descriptiveLabel = "f/e3/2900236.srt",
+            ),
+        )
+
+        val result = merger.merge(apiTracks, playerTracks)
+
+        assertEquals(listOf("Off", "Созданные ИИ"), result.map { it.label })
+        assertEquals("AI #02", result[1].descriptiveLabel)
+        assertEquals("ai", result[1].language)
+    }
+
+    /**
+     * The complement of the case above: with no renditions in the manifest the side-loaded
+     * tracks are the only subtitles there are, so they stay and pick up their API metadata
+     * through the merged child index prefix Media3 puts on their ids.
+     */
+    @Test
+    fun merge_carriesSideLoadedTracks_whenTheManifestPublishesNoSubtitles() {
+        val apiTracks = listOf(
+            offTrack(),
+            apiTrack("rus", "rus", url = "https://api.test/pd/a", sourceFile = "/1/11/1.srt"),
+            apiTrack("eng", "eng", url = "https://api.test/pd/b", sourceFile = "/2/22/2.srt"),
+        )
+        val playerTracks = listOf(
+            playerTrack("", "ru", "1:1/11/1.srt", 0),
+            playerTrack("", "en", "2:2/22/2.srt", 1),
+        )
+
+        val result = merger.merge(apiTracks, playerTracks)
+
+        assertEquals(listOf("Off", "Русский", "Английский"), result.map { it.label })
+        assertEquals(
+            listOf("https://api.test/pd/a", "https://api.test/pd/b"),
+            result.drop(1).map { it.url },
+        )
+    }
+
+    @Test
+    fun merge_keepsSideLoadedTrack_whenItsLanguageIsMissingFromTheManifest() {
+        val apiTracks = listOf(
+            offTrack(),
+            apiTrack("rus", "rus", url = "https://api.test/subtitles/rus.srt"),
+            apiTrack("eng", "eng", url = "https://api.test/subtitles/eng.srt"),
+        )
+        val playerTracks = listOf(
+            playerTrack(
+                label = "rus",
+                language = "rus",
+                id = "hls-rus",
+                groupIndex = 0,
+                uri = "https://cdn.test/subtitles/rus.srt",
+            ),
+            playerTrack("eng", "eng", "eng.srt", 1),
+        )
+
+        val result = merger.merge(apiTracks, playerTracks)
+
+        assertEquals(listOf("Off", "Русский", "Английский"), result.map { it.label })
+        assertEquals(listOf("hls-rus", "eng.srt"), result.drop(1).map { it.playerTrackId })
+        assertEquals(listOf(0, 1), result.drop(1).map { it.playerGroupIndex })
+        assertEquals("https://api.test/subtitles/eng.srt", result[2].url)
+    }
+
+    @Test
+    fun merge_keepsBothManifestRenditions_whenTheyResolveToOneApiEntry() {
+        val apiTracks = listOf(
+            offTrack(),
+            apiTrack("rus", "rus", url = "https://api.test/subtitles/rus.srt"),
+        )
+        val playerTracks = listOf(
+            playerTrack(
+                label = "rus",
+                language = "rus",
+                id = "a",
+                groupIndex = 0,
+                uri = "https://cdn.test/subtitles/rus.srt",
+                descriptiveLabel = "RUS A",
+            ),
+            playerTrack(
+                label = "rus",
+                language = "rus",
+                id = "b",
+                groupIndex = 1,
+                uri = "https://cdn.test/subtitles/rus.srt",
+                descriptiveLabel = "RUS B",
+            ),
+        )
+
+        val result = merger.merge(apiTracks, playerTracks)
+
+        assertEquals(listOf("Off", "RUS A", "RUS B"), result.map { it.label })
+    }
+
+    private fun offTrack() = SubtitleTrackUIState(
+        label = "Off",
+        language = "",
+        url = "",
+    )
+
+    private fun apiTrack(
+        label: String,
+        language: String,
+        url: String = "",
+        forced: Boolean? = null,
+        sourceFile: String? = null,
+    ) = SubtitleTrackUIState(
+        label = label,
+        language = language,
+        url = url,
+        isForced = forced,
+        sourceFile = sourceFile,
+    )
+
+    private fun playerTrack(
+        label: String,
+        language: String,
+        id: String,
+        groupIndex: Int,
+        forced: Boolean = false,
+        uri: String? = null,
+        descriptiveLabel: String? = null,
+    ) = SubtitleTrackUIState(
+        label = label,
+        language = language,
+        url = "",
+        isForced = forced,
+        descriptiveLabel = descriptiveLabel,
+        playerTrackId = id,
+        playerTrackUri = uri,
+        playerGroupIndex = groupIndex,
+        playerTrackIndex = 0,
+    )
+}
diff --git a/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/SubtitleTrackSelectorTest.kt b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/SubtitleTrackSelectorTest.kt
new file mode 100644
index 00000000..46089afa
--- /dev/null
+++ b/app/src/test/kotlin/com/kino/puber/ui/feature/player/vm/SubtitleTrackSelectorTest.kt
@@ -0,0 +1,111 @@
+package com.kino.puber.ui.feature.player.vm
+
+import com.kino.puber.ui.feature.player.model.SubtitleTrackUIState
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertNull
+import org.junit.jupiter.api.Test
+
+internal class SubtitleTrackSelectorTest {
+
+    private val selector = SubtitleTrackSelector()
+
+    /**
+     * The regression that made merged HLS playback unusable before: the picker row is
+     * backed by a manifest rendition, but after merging it also carries the API url, whose
+     * stable key is the id of the hidden side-loaded copy of the same subtitle.
+     */
+    @Test
+    fun select_prefersManifestRendition_overSideLoadedCopyOfTheSameSubtitle() {
+        val manifestRow = manifestTrack(
+            groupId = "0:rus-rendition",
+            trackIndex = 0,
+            formatId = "rus-rendition",
+            url = "https://api.test/subtitles/29725.srt",
+        )
+        val candidates = listOf(
+            PlayerTextTrack("0:rus-rendition", 0, 0, formatId = "rus-rendition", language = "rus"),
+            PlayerTextTrack("1:", 1, 0, formatId = "29725.srt", formatLabel = "29725.srt", language = "rus"),
+        )
+
+        assertEquals(candidates[0], selector.select(manifestRow, candidates))
+    }
+
+    @Test
+    fun select_survivesTrackGroupsBeingReordered() {
+        val row = manifestTrack(
+            groupId = "0:rus-rendition",
+            trackIndex = 0,
+            formatId = "rus-rendition",
+            url = "",
+            groupIndex = 0,
+        )
+        // A later tracks update exposes the same groups in a different order.
+        val candidates = listOf(
+            PlayerTextTrack("2:eng-rendition", 0, 0, formatId = "eng-rendition", language = "eng"),
+            PlayerTextTrack("0:rus-rendition", 1, 0, formatId = "rus-rendition", language = "rus"),
+        )
+
+        assertEquals(candidates[1], selector.select(row, candidates))
+    }
+
+    @Test
+    fun select_picksCorrectVariant_whenGroupIdsAreBlankAndLanguagesCollide() {
+        val row = manifestTrack(groupId = "", trackIndex = 0, formatId = "forced-rus", url = "", groupIndex = 1)
+        val candidates = listOf(
+            PlayerTextTrack("", 0, 0, formatId = "full-rus", language = "rus"),
+            PlayerTextTrack("", 1, 0, formatId = "forced-rus", language = "rus"),
+        )
+
+        assertEquals(candidates[1], selector.select(row, candidates))
+    }
+
+    @Test
+    fun select_fallsBackToCoordinates_whenTheManifestExposesNoIdentity() {
+        val row = manifestTrack(groupId = "", trackIndex = 0, formatId = null, url = "", groupIndex = 1)
+        val candidates = listOf(
+            PlayerTextTrack("", 0, 0, language = "rus"),
+            PlayerTextTrack("", 1, 0, language = "rus"),
+        )
+
+        assertEquals(candidates[1], selector.select(row, candidates))
+    }
+
+    @Test
+    fun select_returnsNull_ratherThanGuessing_whenNothingIdentifiesTheTrack() {
+        val row = SubtitleTrackUIState(label = "rus", language = "", url = "")
+        val candidates = listOf(
+            PlayerTextTrack("", 0, 0, language = "rus"),
+            PlayerTextTrack("", 1, 0, language = "rus"),
+        )
+
+        assertNull(selector.select(row, candidates))
+    }
+
+    @Test
+    fun select_matchesByLanguage_asLastResort() {
+        val row = SubtitleTrackUIState(label = "ukr", language = "ukr", url = "")
+        val candidates = listOf(
+            PlayerTextTrack("", 0, 0, language = "rus"),
+            PlayerTextTrack("", 1, 0, language = "uk"),
+        )
+
+        assertEquals(candidates[1], selector.select(row, candidates))
+    }
+
+    private fun manifestTrack(
+        groupId: String,
+        trackIndex: Int,
+        formatId: String?,
+        url: String,
+        groupIndex: Int = 0,
+    ) = SubtitleTrackUIState(
+        label = "rus",
+        language = "rus",
+        url = url,
+        playerTrackGroupId = groupId,
+        playerTrackId = formatId,
+        playerTrackUri = "https://cdn.test/rendition.m3u8",
+        playerGroupIndex = groupIndex,
+        playerTrackIndex = trackIndex,
+    )
+}