diff --git a/.github/nightly-notes/2026-10-22-fix-watch-later-swipe-music-speed-resume-loudness.md b/.github/nightly-notes/2026-10-22-fix-watch-later-swipe-music-speed-resume-loudness.md
new file mode 100644
index 0000000000..160562e8ee
--- /dev/null
+++ b/.github/nightly-notes/2026-10-22-fix-watch-later-swipe-music-speed-resume-loudness.md
@@ -0,0 +1,12 @@
+## New
+- Swipe a notification to the right to save its video to Watch Later, or long-press it for more options (#1363)
+- Music speed now goes up to 4x with the same speed control as videos (#1346)
+- Podcasts and other long tracks can resume where you stopped, from a new switch in Settings, Playback (#1346)
+
+## Improved
+- Videos and Shorts are turned down to YouTube's loudness level, so loud uploads no longer play louder than the rest (#1335)
+- Picture-in-picture now starts automatically when you leave a playing video
+- Playback settings show whether the equalizer is on (#1335)
+
+## Fixed
+- Stable Voice made every video 6 dB louder; it is replaced by Normalize volume (#1335)
diff --git a/app/src/main/java/io/github/aedev/flow/data/engagement/VideoFeedbackUseCase.kt b/app/src/main/java/io/github/aedev/flow/data/engagement/VideoFeedbackUseCase.kt
index b57587cb67..b1d6895596 100644
--- a/app/src/main/java/io/github/aedev/flow/data/engagement/VideoFeedbackUseCase.kt
+++ b/app/src/main/java/io/github/aedev/flow/data/engagement/VideoFeedbackUseCase.kt
@@ -39,10 +39,14 @@ class VideoFeedbackUseCase
     ) {
         /** Adds [video] to Watch later, or takes it out; returns whether it is saved afterwards. */
         suspend fun toggleWatchLater(video: Video): Boolean {
-            if (playlistRepository.isInWatchLater(video.id)) {
-                playlistRepository.removeFromWatchLater(video.id)
-                return false
-            }
+            if (saveToWatchLater(video)) return true
+            playlistRepository.removeFromWatchLater(video.id)
+            return false
+        }
+
+        /** Adds [video] to Watch later unless it is there already; returns whether it was added. */
+        suspend fun saveToWatchLater(video: Video): Boolean {
+            if (playlistRepository.isInWatchLater(video.id)) return false
             playlistRepository.addToWatchLater(video)
             videoStats.onAction(LedgerAction.SAVE)
             runCatching { FlowNeuroEngine.onVideoInteraction(context, video, InteractionType.SAVED) }
diff --git a/app/src/main/java/io/github/aedev/flow/data/local/PlayerPreferences.kt b/app/src/main/java/io/github/aedev/flow/data/local/PlayerPreferences.kt
index bf89c879ce..c0c38b4166 100644
--- a/app/src/main/java/io/github/aedev/flow/data/local/PlayerPreferences.kt
+++ b/app/src/main/java/io/github/aedev/flow/data/local/PlayerPreferences.kt
@@ -103,7 +103,7 @@ class PlayerPreferences(
         val SPONSOR_BLOCK_ENABLED = booleanPreferencesKey("sponsor_block_enabled")
         val AUTO_PIP_ENABLED = booleanPreferencesKey("auto_pip_enabled")
         val MANUAL_PIP_BUTTON_ENABLED = booleanPreferencesKey("manual_pip_button_enabled")
-        val STABLE_VOLUME_ENABLED = booleanPreferencesKey("stable_volume_enabled")
+        val VIDEO_VOLUME_NORMALIZATION = booleanPreferencesKey("video_volume_normalization")
 
         // Buffer settings
         val MIN_BUFFER_MS = intPreferencesKey("min_buffer_ms")
@@ -331,6 +331,7 @@ class PlayerPreferences(
         val ANIMATED_ARTWORK = booleanPreferencesKey("animated_artwork")
         val MUSIC_REPEAT_MODE = intPreferencesKey("music_repeat_mode")
         val PAUSE_MUSIC_WHEN_MUTED = booleanPreferencesKey("pause_music_when_muted")
+        val MUSIC_RESUME_LONG_TRACKS = booleanPreferencesKey("music_resume_long_tracks")
         val ANIMATED_ARTWORK_WIFI_ONLY = booleanPreferencesKey("animated_artwork_wifi_only")
         val AUTO_DOWNLOAD_LIKED_MUSIC = booleanPreferencesKey("auto_download_liked_music")
         val RECAP_SOURCE = stringPreferencesKey("recap_source")
@@ -1688,16 +1689,15 @@ class PlayerPreferences(
         }
     }
 
-    // Stable Volume
-    val stableVolumeEnabled: Flow<Boolean> =
+    /** Videos and Shorts are turned down to YouTube's loudness level, as on youtube.com. */
+    val videoVolumeNormalizationEnabled: Flow<Boolean> =
         context.playerPreferencesDataStore.data
-            .map { preferences ->
-                preferences[Keys.STABLE_VOLUME_ENABLED] ?: false
-            }
+            .map { preferences -> preferences[Keys.VIDEO_VOLUME_NORMALIZATION] ?: true }
+            .distinctUntilChanged()
 
-    suspend fun setStableVolumeEnabled(enabled: Boolean) {
+    suspend fun setVideoVolumeNormalizationEnabled(enabled: Boolean) {
         context.playerPreferencesDataStore.edit { preferences ->
-            preferences[Keys.STABLE_VOLUME_ENABLED] = enabled
+            preferences[Keys.VIDEO_VOLUME_NORMALIZATION] = enabled
         }
     }
 
@@ -2208,6 +2208,18 @@ class PlayerPreferences(
         }
     }
 
+    /** Podcasts and other long tracks pick up where they stopped when played again. */
+    val musicResumeLongTracks: Flow<Boolean> =
+        context.playerPreferencesDataStore.data
+            .map { preferences -> preferences[Keys.MUSIC_RESUME_LONG_TRACKS] ?: false }
+            .distinctUntilChanged()
+
+    suspend fun setMusicResumeLongTracks(enabled: Boolean) {
+        context.playerPreferencesDataStore.edit { preferences ->
+            preferences[Keys.MUSIC_RESUME_LONG_TRACKS] = enabled
+        }
+    }
+
     /** The music player's repeat mode, as Media3's own Player.REPEAT_MODE_* value. */
     val musicRepeatMode: Flow<Int> =
         context.playerPreferencesDataStore.data
@@ -2577,7 +2589,7 @@ class PlayerPreferences(
     val autoPipEnabled: Flow<Boolean> =
         context.playerPreferencesDataStore.data
             .map { preferences ->
-                preferences[Keys.AUTO_PIP_ENABLED] ?: false
+                preferences[Keys.AUTO_PIP_ENABLED] ?: true
             }
 
     suspend fun setAutoPipEnabled(enabled: Boolean) {
diff --git a/app/src/main/java/io/github/aedev/flow/data/local/PlaylistRepository.kt b/app/src/main/java/io/github/aedev/flow/data/local/PlaylistRepository.kt
index aafa330e94..492af07cab 100644
--- a/app/src/main/java/io/github/aedev/flow/data/local/PlaylistRepository.kt
+++ b/app/src/main/java/io/github/aedev/flow/data/local/PlaylistRepository.kt
@@ -39,7 +39,7 @@ class PlaylistRepository
         }
 
         suspend fun updateVideoMetadata(video: Video) {
-            videoDao.upsertMetadata(listOf(normalizedEntity(video)))
+            videoDao.mergeMetadata(listOf(normalizedEntity(video)))
         }
 
         private fun normalizedEntity(video: Video): VideoEntity {
diff --git a/app/src/main/java/io/github/aedev/flow/data/local/ViewHistory.kt b/app/src/main/java/io/github/aedev/flow/data/local/ViewHistory.kt
index aeaac462f6..fc56e0ec84 100644
--- a/app/src/main/java/io/github/aedev/flow/data/local/ViewHistory.kt
+++ b/app/src/main/java/io/github/aedev/flow/data/local/ViewHistory.kt
@@ -133,6 +133,43 @@ class ViewHistory private constructor(
 
     suspend fun getSavedPosition(videoId: String): Long = dao.getPosition(videoId) ?: 0L
 
+    suspend fun getSavedDuration(videoId: String): Long = dao.getDuration(videoId) ?: 0L
+
+    /** Records that a song started without moving the place a long track was left at. */
+    suspend fun touchMusicEntry(
+        videoId: String,
+        duration: Long,
+        title: String,
+        thumbnailUrl: String,
+        channelName: String,
+        channelId: String,
+        isLocal: Boolean = LocalMediaIds.isLocal(videoId),
+    ) = savePlaybackPosition(
+        videoId = videoId,
+        position = dao.getPosition(videoId) ?: 0L,
+        duration = duration,
+        title = title,
+        thumbnailUrl = thumbnailUrl,
+        channelName = channelName,
+        channelId = channelId,
+        isMusic = true,
+        isLocal = isLocal,
+    )
+
+    /** Where a long track stopped. A row history already holds keeps its title, artist and time. */
+    suspend fun saveMusicPosition(
+        videoId: String,
+        position: Long,
+        duration: Long,
+        title: String,
+        thumbnailUrl: String,
+        channelName: String,
+    ) {
+        if (PlayerPreferences(context).isWatchHistorySavingBlocked()) return
+        if (dao.updateProgress(videoId, position, duration) > 0) return
+        savePlaybackPosition(videoId, position, duration, title, thumbnailUrl, channelName, isMusic = true)
+    }
+
     /**
      * Create-or-touch a history entry **without** overwriting an already-saved
      * playback position.  Call this on video open so the video appears in history
diff --git a/app/src/main/java/io/github/aedev/flow/data/local/dao/CacheDao.kt b/app/src/main/java/io/github/aedev/flow/data/local/dao/CacheDao.kt
index 9424e6060c..cac96716b1 100644
--- a/app/src/main/java/io/github/aedev/flow/data/local/dao/CacheDao.kt
+++ b/app/src/main/java/io/github/aedev/flow/data/local/dao/CacheDao.kt
@@ -42,6 +42,9 @@ interface CacheDao {
     @Query("SELECT * FROM subscription_feed_cache WHERE channelId IN (:channelIds)")
     suspend fun getSubscriptionFeedForChannels(channelIds: List<String>): List<SubscriptionFeedEntity>
 
+    @Query("SELECT * FROM subscription_feed_cache WHERE videoId = :videoId")
+    suspend fun getSubscriptionFeedRow(videoId: String): SubscriptionFeedEntity?
+
     @Query("SELECT DISTINCT channelId, channelName FROM subscription_feed_cache WHERE channelId IN (:channelIds) AND channelName != ''")
     suspend fun subscriptionFeedChannelNames(channelIds: List<String>): List<ChannelNameRow>
 
diff --git a/app/src/main/java/io/github/aedev/flow/data/local/dao/VideoDao.kt b/app/src/main/java/io/github/aedev/flow/data/local/dao/VideoDao.kt
index 332d734afc..9530955faf 100644
--- a/app/src/main/java/io/github/aedev/flow/data/local/dao/VideoDao.kt
+++ b/app/src/main/java/io/github/aedev/flow/data/local/dao/VideoDao.kt
@@ -118,27 +118,6 @@ interface VideoDao {
         }
     }
 
-    /** Inserts or refreshes many videos as one change, so a list observing them updates once. */
-    @Transaction
-    suspend fun upsertMetadata(entities: List<VideoEntity>) {
-        entities.forEach { entity ->
-            insertVideoOrIgnore(entity)
-            updateVideoMetadata(
-                id = entity.id,
-                title = entity.title,
-                channelName = entity.channelName,
-                channelId = entity.channelId,
-                thumbnailUrl = entity.thumbnailUrl,
-                duration = entity.duration,
-                viewCount = entity.viewCount,
-                uploadDate = entity.uploadDate,
-                timestamp = entity.timestamp,
-                description = entity.description,
-                channelThumbnailUrl = entity.channelThumbnailUrl,
-            )
-        }
-    }
-
     @Query("SELECT * FROM videos WHERE id = :id")
     suspend fun getVideo(id: String): VideoEntity?
 
diff --git a/app/src/main/java/io/github/aedev/flow/data/local/dao/WatchHistoryDao.kt b/app/src/main/java/io/github/aedev/flow/data/local/dao/WatchHistoryDao.kt
index e8648db7c4..ee5b7dacbc 100644
--- a/app/src/main/java/io/github/aedev/flow/data/local/dao/WatchHistoryDao.kt
+++ b/app/src/main/java/io/github/aedev/flow/data/local/dao/WatchHistoryDao.kt
@@ -98,6 +98,14 @@ interface WatchHistoryDao {
         durationMs: Long,
     )
 
+    /** Moves only the saved place; 0 means [videoId] has no row yet. */
+    @Query("UPDATE watch_history SET position = :position, duration = :duration WHERE videoId = :videoId")
+    suspend fun updateProgress(
+        videoId: String,
+        position: Long,
+        duration: Long,
+    ): Int
+
     /** Drops saved progress without deleting the history row, so the card no longer reads as watched. */
     @Query("UPDATE watch_history SET position = 0 WHERE videoId = :videoId")
     suspend fun clearProgress(videoId: String)
diff --git a/app/src/main/java/io/github/aedev/flow/data/shorts/ShortsStreamResolver.kt b/app/src/main/java/io/github/aedev/flow/data/shorts/ShortsStreamResolver.kt
index ebdab1fc4c..61d4b02dd2 100644
--- a/app/src/main/java/io/github/aedev/flow/data/shorts/ShortsStreamResolver.kt
+++ b/app/src/main/java/io/github/aedev/flow/data/shorts/ShortsStreamResolver.kt
@@ -3,6 +3,7 @@ package io.github.aedev.flow.data.shorts
 import android.util.Log
 import io.github.aedev.flow.data.local.PlayerPreferences
 import io.github.aedev.flow.innertube.models.response.PlayerResponse
+import io.github.aedev.flow.player.audio.LoudnessGain
 import io.github.aedev.flow.player.shorts.ShortsStartupTrace
 import io.github.aedev.flow.player.stream.InFlightRequestCoalescer
 import io.github.aedev.flow.player.stream.InnerTubeVideoStreamExtractor
@@ -36,6 +37,8 @@ data class ShortPlaybackStreams(
     val videoDashManifest: String? = null,
     val audioDashManifest: String? = null,
     val details: ShortDetails? = null,
+    /** YouTube's loudness for the reel, in dB, for volume normalization. */
+    val loudnessGainDb: Float? = null,
 )
 
 data class ShortVideoQuality(
@@ -209,6 +212,7 @@ class ShortsStreamResolver internal constructor(
             videoDashManifest = ShortsDashManifest.forVideo(video, videoUrl, durationMs),
             audioDashManifest = audio?.url?.let { ShortsDashManifest.forAudio(audio, it, durationMs) },
             details = playerResponse.videoDetails?.toShortDetails(durationMs),
+            loudnessGainDb = LoudnessGain.gainDb(playerResponse.playerConfig?.audioConfig, audio?.loudnessDb),
         )
     }
 
diff --git a/app/src/main/java/io/github/aedev/flow/data/subscriptions/SubscriptionFeedRepository.kt b/app/src/main/java/io/github/aedev/flow/data/subscriptions/SubscriptionFeedRepository.kt
index 0eb8566701..151e7a6862 100644
--- a/app/src/main/java/io/github/aedev/flow/data/subscriptions/SubscriptionFeedRepository.kt
+++ b/app/src/main/java/io/github/aedev/flow/data/subscriptions/SubscriptionFeedRepository.kt
@@ -328,6 +328,10 @@ class SubscriptionFeedRepository
             Log.d(TAG, "Seeded ${rows.size} row(s) for $channelId from the notification check")
         }
 
+        /** The feed's stored copy of [videoId], or null when the feed has never seen it. */
+        suspend fun cachedVideo(videoId: String): Video? =
+            withContext(PerformanceDispatcher.diskIO) { cacheDao.getSubscriptionFeedRow(videoId)?.toVideo() }
+
         /** Writes back metadata the on-demand player lookup resolved for already-cached rows. */
         suspend fun updateEnrichedMetadata(videos: Collection<Video>) {
             if (videos.isEmpty()) return
diff --git a/app/src/main/java/io/github/aedev/flow/player/EnhancedMusicPlayerManager.kt b/app/src/main/java/io/github/aedev/flow/player/EnhancedMusicPlayerManager.kt
index 2d4f3a6ef3..4f902bda8e 100644
--- a/app/src/main/java/io/github/aedev/flow/player/EnhancedMusicPlayerManager.kt
+++ b/app/src/main/java/io/github/aedev/flow/player/EnhancedMusicPlayerManager.kt
@@ -1065,9 +1065,13 @@ object EnhancedMusicPlayerManager {
         }
     }
 
-    fun setPlaybackSpeed(speed: Float) {
+    /** A slider passes [persist] false while dragging and saves once on release. */
+    fun setPlaybackSpeed(
+        speed: Float,
+        persist: Boolean = true,
+    ) {
         _playbackSpeed.value = speed
-        scope.launch { audioSettingsPersistence?.saveSpeed(speed) }
+        if (persist) scope.launch { audioSettingsPersistence?.saveSpeed(speed) }
 
         player?.let { p ->
             val currentPitch = p.playbackParameters.pitch
@@ -1075,9 +1079,12 @@ object EnhancedMusicPlayerManager {
         }
     }
 
-    fun setPlaybackPitch(semitones: Float) {
+    fun setPlaybackPitch(
+        semitones: Float,
+        persist: Boolean = true,
+    ) {
         _playbackPitch.value = semitones
-        scope.launch { audioSettingsPersistence?.savePitch(semitones) }
+        if (persist) scope.launch { audioSettingsPersistence?.savePitch(semitones) }
 
         player?.let { p ->
             val pitch = 2.0.pow(semitones.toDouble() / 12.0).toFloat()
diff --git a/app/src/main/java/io/github/aedev/flow/player/EnhancedPlayerManager.kt b/app/src/main/java/io/github/aedev/flow/player/EnhancedPlayerManager.kt
index 4efffdc9c3..cf26b6ba0d 100644
--- a/app/src/main/java/io/github/aedev/flow/player/EnhancedPlayerManager.kt
+++ b/app/src/main/java/io/github/aedev/flow/player/EnhancedPlayerManager.kt
@@ -780,12 +780,20 @@ class EnhancedPlayerManager private constructor() {
         audioFeaturesManager?.setVolumeBoost(player, volume)
     }
 
+    /** YouTube's loudness for [videoId], in dB; null when the stream carries none. */
+    fun setLoudness(
+        videoId: String,
+        gainDb: Float?,
+    ) {
+        audioFeaturesManager?.setLoudness(videoId, gainDb)
+    }
+
     private fun observePreferences(
         context: Context,
         built: CoroutineScope,
     ) {
         audioFeaturesManager?.observeSkipSilencePreference(context, built)
-        audioFeaturesManager?.observeStableVolumePreference(context, built)
+        audioFeaturesManager?.observeVolumeNormalizationPreference(context, built)
 
         val prefs = PlayerPreferences(context)
         built.launch {
@@ -948,6 +956,7 @@ class EnhancedPlayerManager private constructor() {
                     reason: Int,
                 ) {
                     autoNextLog("onMediaItemTransition reason=$reason mediaId=${mediaItem?.mediaId}")
+                    audioFeaturesManager?.onMediaItemChanged()
                     if (reason == Player.MEDIA_ITEM_TRANSITION_REASON_AUTO ||
                         reason == Player.MEDIA_ITEM_TRANSITION_REASON_SEEK
                     ) {
@@ -2905,7 +2914,7 @@ class EnhancedPlayerManager private constructor() {
 
     fun toggleSkipSilence(isEnabled: Boolean) = audioFeaturesManager?.toggleSkipSilence(isEnabled, appContext)
 
-    fun toggleStableVolume(isEnabled: Boolean) = audioFeaturesManager?.toggleStableVolume(isEnabled, appContext)
+    fun toggleVolumeNormalization(isEnabled: Boolean) = audioFeaturesManager?.toggleVolumeNormalization(isEnabled, appContext)
 
     fun toggleSponsorBlock(isEnabled: Boolean) {
         sponsorBlockHandler?.setEnabled(isEnabled)
diff --git a/app/src/main/java/io/github/aedev/flow/player/MusicResumePolicy.kt b/app/src/main/java/io/github/aedev/flow/player/MusicResumePolicy.kt
new file mode 100644
index 0000000000..1b5140bce6
--- /dev/null
+++ b/app/src/main/java/io/github/aedev/flow/player/MusicResumePolicy.kt
@@ -0,0 +1,18 @@
+package io.github.aedev.flow.player
+
+/** Podcasts, audiobooks and long mixes pick up where they stopped; songs always start over. */
+object MusicResumePolicy {
+    const val MIN_DURATION_MS = 10 * 60 * 1000L
+
+    fun isLongTrack(durationMs: Long): Boolean = durationMs >= MIN_DURATION_MS
+
+    fun startPosition(
+        savedPosition: Long,
+        durationMs: Long,
+    ): Long =
+        PlaybackResumePolicy.resolveStartPosition(
+            savedPosition = savedPosition,
+            durationMs = durationMs,
+            resumeAllowed = isLongTrack(durationMs),
+        )
+}
diff --git a/app/src/main/java/io/github/aedev/flow/player/MusicResumeTracker.kt b/app/src/main/java/io/github/aedev/flow/player/MusicResumeTracker.kt
new file mode 100644
index 0000000000..d1396698cb
--- /dev/null
+++ b/app/src/main/java/io/github/aedev/flow/player/MusicResumeTracker.kt
@@ -0,0 +1,77 @@
+package io.github.aedev.flow.player
+
+import androidx.media3.common.C
+import androidx.media3.common.MediaItem
+import androidx.media3.common.Player
+import io.github.aedev.flow.data.local.PlayerPreferences
+import io.github.aedev.flow.data.local.ViewHistory
+import io.github.aedev.flow.utils.PerformanceDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * Saves where podcasts and other long tracks stop, on the player's own events: a pause, leaving the
+ * track, and the service going away. No timer runs, and nothing is written while the setting is off.
+ */
+@Singleton
+class MusicResumeTracker
+    @Inject
+    constructor(
+        private val viewHistory: ViewHistory,
+        private val preferences: PlayerPreferences,
+    ) {
+        // Outlives the service, so the save from onDestroy still lands.
+        private val scope = CoroutineScope(SupervisorJob() + PerformanceDispatcher.diskIO)
+
+        fun attach(player: Player) {
+            player.addListener(
+                object : Player.Listener {
+                    override fun onIsPlayingChanged(isPlaying: Boolean) {
+                        if (!isPlaying) saveCurrent(player)
+                    }
+
+                    override fun onPositionDiscontinuity(
+                        oldPosition: Player.PositionInfo,
+                        newPosition: Player.PositionInfo,
+                        reason: Int,
+                    ) {
+                        val left = oldPosition.mediaItem ?: return
+                        if (left.mediaId == newPosition.mediaItem?.mediaId) return
+                        val durationMs = left.mediaMetadata.durationMs ?: return
+                        val finished = reason == Player.DISCONTINUITY_REASON_AUTO_TRANSITION
+                        save(left, if (finished) durationMs else oldPosition.positionMs, durationMs)
+                    }
+                },
+            )
+        }
+
+        fun saveCurrent(player: Player) {
+            val item = player.currentMediaItem ?: return
+            val durationMs = item.mediaMetadata.durationMs ?: player.duration.takeIf { it != C.TIME_UNSET } ?: return
+            save(item, player.currentPosition, durationMs)
+        }
+
+        private fun save(
+            item: MediaItem,
+            positionMs: Long,
+            durationMs: Long,
+        ) {
+            if (!MusicResumePolicy.isLongTrack(durationMs)) return
+            val metadata = item.mediaMetadata
+            scope.launch {
+                if (!preferences.musicResumeLongTracks.first()) return@launch
+                viewHistory.saveMusicPosition(
+                    videoId = item.mediaId,
+                    position = positionMs.coerceIn(0L, durationMs),
+                    duration = durationMs,
+                    title = metadata.title?.toString().orEmpty(),
+                    thumbnailUrl = metadata.artworkUri?.toString().orEmpty(),
+                    channelName = metadata.artist?.toString().orEmpty(),
+                )
+            }
+        }
+    }
diff --git a/app/src/main/java/io/github/aedev/flow/player/audio/AudioFeaturesManager.kt b/app/src/main/java/io/github/aedev/flow/player/audio/AudioFeaturesManager.kt
index 75367cc1a1..d768261ccb 100644
--- a/app/src/main/java/io/github/aedev/flow/player/audio/AudioFeaturesManager.kt
+++ b/app/src/main/java/io/github/aedev/flow/player/audio/AudioFeaturesManager.kt
@@ -47,14 +47,15 @@ class AudioFeaturesManager(
     private var playerRef: ExoPlayer? = null
 
     private var pendingSkipSilence: Boolean? = null
-    private var pendingStableVolume: Boolean? = null
     private var loudnessEnhancer: LoudnessEnhancer? = null
     private var desiredPlaybackSpeed: Float = 1.0f
-
-    // Two features want gain on the same session, so they are summed into one effect rather than
-    // each owning a LoudnessEnhancer and overwriting the other's target.
-    private var stableVolumeGainMb: Int = 0
     private var boostGainMb: Int = 0
+    private var userVolume: Float = 1f
+    private var normalizationEnabled: Boolean = true
+
+    // Keyed by media id, so a queue item the screen never loaded plays at full level rather than
+    // inheriting the gain of the video before it.
+    private var loudness: Pair<String, Float>? = null
 
     /**
      * Set the player reference. Must be called after ExoPlayer is created.
@@ -78,10 +79,7 @@ class AudioFeaturesManager(
             pendingSkipSilence = null
             Log.d(TAG, "Applied pending skip silence: $pending")
         }
-        pendingStableVolume?.let { pending ->
-            applyLoudnessEnhancer(player, pending)
-            pendingStableVolume = null
-        }
+        applyVolume(player)
     }
 
     /** Moves the gain onto the player's audio session, which ExoPlayer reports only after build. */
@@ -162,12 +160,34 @@ class AudioFeaturesManager(
         volume: Float,
     ) {
         val exoPlayer = player ?: return
-        exoPlayer.volume = volume.coerceIn(0f, 1f)
+        userVolume = volume
         boostGainMb = boostGainMillibels(volume)
+        applyVolume(exoPlayer)
         applyLoudnessGain(exoPlayer)
         Log.d(TAG, "Volume set to: $volume (player=${exoPlayer.volume}, boost=${boostGainMb}mB)")
     }
 
+    /** YouTube's loudness for [mediaId], applied while that item is the one playing. */
+    fun setLoudness(
+        mediaId: String,
+        gainDb: Float?,
+    ) {
+        loudness = gainDb?.let { mediaId to it }
+        playerRef?.let(::applyVolume)
+    }
+
+    fun onMediaItemChanged() {
+        playerRef?.let(::applyVolume)
+    }
+
+    private fun applyVolume(player: ExoPlayer) {
+        val gainDb =
+            loudness
+                ?.takeIf { (mediaId, _) -> normalizationEnabled && mediaId == player.currentMediaItem?.mediaId }
+                ?.second
+        player.volume = userVolume.coerceIn(0f, 1f) * LoudnessGain.volume(gainDb)
+    }
+
     /**
      * Observe skip silence preference changes.
      */
@@ -182,57 +202,31 @@ class AudioFeaturesManager(
         }
     }
 
-    /**
-     * Observe stable volume preference and apply on startup.
-     */
-    fun observeStableVolumePreference(
+    fun observeVolumeNormalizationPreference(
         context: Context,
         observerScope: CoroutineScope,
     ) {
         observerScope.launch {
-            PlayerPreferences(context).stableVolumeEnabled.collect { isEnabled ->
-                val player = playerRef
-                if (player != null) {
-                    applyLoudnessEnhancer(player, isEnabled)
-                } else {
-                    pendingStableVolume = isEnabled
-                }
-                stateFlow.value = stateFlow.value.copy(isStableVolumeEnabled = isEnabled)
-            }
+            PlayerPreferences(context).videoVolumeNormalizationEnabled.collect(::setVolumeNormalizationInternal)
         }
     }
 
-    /**
-     * Toggle stable volume (audio normalization via LoudnessEnhancer) and persist preference.
-     */
-    fun toggleStableVolume(
+    fun toggleVolumeNormalization(
         isEnabled: Boolean,
         context: Context?,
     ) {
-        val player = playerRef
-        if (player != null) {
-            applyLoudnessEnhancer(player, isEnabled)
-        } else {
-            pendingStableVolume = isEnabled
-        }
-        stateFlow.value = stateFlow.value.copy(isStableVolumeEnabled = isEnabled)
-        context?.let { ctx ->
-            scope.launch {
-                PlayerPreferences(ctx).setStableVolumeEnabled(isEnabled)
-            }
-        }
+        setVolumeNormalizationInternal(isEnabled)
+        context?.let { ctx -> scope.launch { PlayerPreferences(ctx).setVideoVolumeNormalizationEnabled(isEnabled) } }
     }
 
-    private fun applyLoudnessEnhancer(
-        player: ExoPlayer,
-        enable: Boolean,
-    ) {
-        stableVolumeGainMb = if (enable) STABLE_VOLUME_GAIN_MB else 0
-        applyLoudnessGain(player)
+    private fun setVolumeNormalizationInternal(isEnabled: Boolean) {
+        normalizationEnabled = isEnabled
+        playerRef?.let(::applyVolume)
+        stateFlow.value = stateFlow.value.copy(isVolumeNormalizationEnabled = isEnabled)
     }
 
     private fun applyLoudnessGain(player: ExoPlayer) {
-        val targetGainMb = (stableVolumeGainMb + boostGainMb).coerceIn(0, MAX_GAIN_MB)
+        val targetGainMb = boostGainMb.coerceIn(0, MAX_GAIN_MB)
         try {
             if (targetGainMb <= 0) {
                 loudnessEnhancer?.release()
@@ -263,10 +257,7 @@ class AudioFeaturesManager(
     }
 }
 
-/** Normalisation gain applied by the stable-volume toggle. */
-private const val STABLE_VOLUME_GAIN_MB = 600
-
-/** Ceiling for the summed gain, a little over the 2x the boost slider can ask for. */
+/** Ceiling for the boost gain, a little over the 2x the boost slider can ask for. */
 private const val MAX_GAIN_MB = 2000
 
 /**
diff --git a/app/src/main/java/io/github/aedev/flow/player/audio/LoudnessGain.kt b/app/src/main/java/io/github/aedev/flow/player/audio/LoudnessGain.kt
new file mode 100644
index 0000000000..1cbe8ec5e9
--- /dev/null
+++ b/app/src/main/java/io/github/aedev/flow/player/audio/LoudnessGain.kt
@@ -0,0 +1,25 @@
+package io.github.aedev.flow.player.audio
+
+import io.github.aedev.flow.innertube.models.response.PlayerResponse
+import kotlin.math.pow
+
+/** YouTube's loudness metadata as a playback gain: loud tracks are turned down, quiet ones stay as they are. */
+object LoudnessGain {
+    private const val TARGET_LKFS = -14.0
+    private const val MIN_GAIN_DB = -20f
+
+    fun gainDb(
+        audioConfig: PlayerResponse.PlayerConfig.AudioConfig?,
+        formatLoudnessDb: Double?,
+    ): Float? {
+        val gainDb =
+            audioConfig?.perceptualLoudnessDb?.let { (audioConfig.loudnessTargetLkfs ?: TARGET_LKFS) - it }
+                ?: audioConfig?.loudnessDb?.let { -it }
+                ?: formatLoudnessDb?.let { -it }
+                ?: return null
+        return gainDb.toFloat().coerceIn(MIN_GAIN_DB, 0f)
+    }
+
+    /** The player volume for [gainDb]; 1 when there is nothing to apply. */
+    fun volume(gainDb: Float?): Float = gainDb?.let { 10.0.pow(it / 20.0).toFloat() } ?: 1f
+}
diff --git a/app/src/main/java/io/github/aedev/flow/player/shorts/ShortsMediaSources.kt b/app/src/main/java/io/github/aedev/flow/player/shorts/ShortsMediaSources.kt
new file mode 100644
index 0000000000..ba331a32ed
--- /dev/null
+++ b/app/src/main/java/io/github/aedev/flow/player/shorts/ShortsMediaSources.kt
@@ -0,0 +1,52 @@
+package io.github.aedev.flow.player.shorts
+
+import android.net.Uri
+import android.util.Log
+import androidx.annotation.OptIn
+import androidx.media3.common.MediaItem
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.datasource.DataSource
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.media3.exoplayer.source.MediaSource
+import androidx.media3.exoplayer.source.MergingMediaSource
+import androidx.media3.exoplayer.source.ProgressiveMediaSource
+import io.github.aedev.flow.player.resolver.MediaSourceBuilder
+
+/** Loads a reel into a pooled player: separate video and audio merged, or one muxed stream. */
+@OptIn(UnstableApi::class)
+internal object ShortsMediaSources {
+    private const val TAG = "ShortsPlayerPool"
+
+    fun load(
+        player: ExoPlayer,
+        factory: DataSource.Factory,
+        videoUrl: String,
+        audioUrl: String?,
+        videoDashManifest: String?,
+        audioDashManifest: String?,
+    ) {
+        if (audioUrl != null && audioUrl != videoUrl) {
+            val videoSource = sourceFor(factory, videoUrl, videoDashManifest)
+            val audioSource = sourceFor(factory, audioUrl, audioDashManifest)
+            player.setMediaSource(MergingMediaSource(true, true, videoSource, audioSource))
+        } else {
+            player.setMediaSource(sourceFor(factory, videoUrl, videoDashManifest))
+        }
+        player.prepare()
+    }
+
+    private fun sourceFor(
+        factory: DataSource.Factory,
+        url: String,
+        dashManifest: String?,
+    ): MediaSource {
+        if (dashManifest != null) {
+            runCatching {
+                return MediaSourceBuilder.buildDashSource(factory, dashManifest, Uri.parse(url))
+            }.onFailure { Log.w(TAG, "Generated DASH manifest rejected, falling back to progressive: ${it.message}") }
+        }
+        return ProgressiveMediaSource
+            .Factory(factory)
+            .createMediaSource(MediaItem.fromUri(url))
+    }
+}
diff --git a/app/src/main/java/io/github/aedev/flow/player/shorts/ShortsPlayerFactory.kt b/app/src/main/java/io/github/aedev/flow/player/shorts/ShortsPlayerFactory.kt
new file mode 100644
index 0000000000..23f253070b
--- /dev/null
+++ b/app/src/main/java/io/github/aedev/flow/player/shorts/ShortsPlayerFactory.kt
@@ -0,0 +1,153 @@
+package io.github.aedev.flow.player.shorts
+
+import android.content.Context
+import android.util.Log
+import androidx.annotation.OptIn
+import androidx.media3.common.AudioAttributes
+import androidx.media3.common.C
+import androidx.media3.common.PlaybackException
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.datasource.DataSource
+import androidx.media3.datasource.DefaultDataSource
+import androidx.media3.datasource.cache.Cache
+import androidx.media3.datasource.cache.CacheDataSource
+import androidx.media3.exoplayer.DefaultRenderersFactory
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.media3.exoplayer.audio.AudioSink
+import androidx.media3.exoplayer.audio.DefaultAudioSink
+import androidx.media3.exoplayer.source.DefaultMediaSourceFactory
+import androidx.media3.exoplayer.trackselection.AdaptiveTrackSelection
+import androidx.media3.exoplayer.trackselection.DefaultTrackSelector
+import androidx.media3.session.MediaSession
+import io.github.aedev.flow.player.analytics.PlaybackAnalyticsLogger
+import io.github.aedev.flow.player.audio.eq.EqualizerAudioProcessor
+import io.github.aedev.flow.player.config.PlayerConfig
+import io.github.aedev.flow.player.config.VideoSizeCap
+import io.github.aedev.flow.player.datasource.YouTubeHttpDataSource
+import io.github.aedev.flow.player.factory.LoadControlFactory
+
+/** Builds what the Shorts pool runs on: its players, the cached data source and the one media session. */
+@OptIn(UnstableApi::class)
+internal object ShortsPlayerFactory {
+    private const val SESSION_ID = "flow_shorts_session"
+    private const val TAG = "ShortsPlayerPool"
+
+    fun cachedDataSourceFactory(
+        appContext: Context,
+        cache: Cache,
+    ): DataSource.Factory =
+        CacheDataSource
+            .Factory()
+            .setCache(cache)
+            .setUpstreamDataSourceFactory(DefaultDataSource.Factory(appContext, YouTubeHttpDataSource.Factory()))
+            .setFlags(CacheDataSource.FLAG_IGNORE_CACHE_ON_ERROR)
+
+    fun mediaSession(
+        context: Context,
+        player: ExoPlayer,
+    ): MediaSession? =
+        try {
+            MediaSession
+                .Builder(context, player)
+                .setId(SESSION_ID)
+                .build()
+        } catch (e: Exception) {
+            Log.w(TAG, "Shorts MediaSession unavailable; media buttons will not reach the reel", e)
+            null
+        }
+
+    fun player(
+        context: Context,
+        equalizer: EqualizerAudioProcessor,
+        dataSourceFactory: DataSource.Factory,
+        preferredAudioLanguage: String,
+        currentVideoId: () -> String?,
+    ): ExoPlayer {
+        // The device cap is landscape; a Short is portrait, so its axes swap.
+        val (maxVideoWidth, maxVideoHeight) = VideoSizeCap.forDevice(context).let { it.maxHeight to it.maxWidth }
+
+        val loadControl = LoadControlFactory.forShorts()
+
+        val trackSelector =
+            DefaultTrackSelector(
+                context,
+                AdaptiveTrackSelection.Factory(),
+            ).apply {
+                val builder =
+                    buildUponParameters()
+                        .setPreferredVideoMimeTypes(*PlayerConfig.PREFERRED_VIDEO_MIME_TYPES)
+                        .setAllowVideoMixedMimeTypeAdaptiveness(true)
+                        .setForceHighestSupportedBitrate(false)
+                        .setViewportSizeToPhysicalDisplaySize(context, true)
+                        .setMaxVideoSize(maxVideoWidth, maxVideoHeight)
+
+                if (preferredAudioLanguage != "original" && preferredAudioLanguage.isNotEmpty()) {
+                    builder.setPreferredAudioLanguage(preferredAudioLanguage)
+                }
+
+                setParameters(builder.build())
+            }
+
+        // One processor per pooled player: they are all live at once and each keeps its own filter history.
+        val renderersFactory =
+            object : DefaultRenderersFactory(context) {
+                override fun buildAudioSink(
+                    context: Context,
+                    enableFloatOutput: Boolean,
+                    enableAudioTrackPlaybackParams: Boolean,
+                ): AudioSink =
+                    DefaultAudioSink
+                        .Builder(context)
+                        .setEnableFloatOutput(enableFloatOutput)
+                        .setEnableAudioTrackPlaybackParams(enableAudioTrackPlaybackParams)
+                        .setAudioProcessors(arrayOf(equalizer))
+                        .build()
+            }.setExtensionRendererMode(DefaultRenderersFactory.EXTENSION_RENDERER_MODE_ON)
+                .setEnableDecoderFallback(true)
+
+        return ExoPlayer
+            .Builder(context, renderersFactory)
+            .setTrackSelector(trackSelector)
+            .setAudioAttributes(
+                AudioAttributes
+                    .Builder()
+                    .setContentType(C.AUDIO_CONTENT_TYPE_MOVIE)
+                    .setUsage(C.USAGE_MEDIA)
+                    .build(),
+                false,
+            ).setHandleAudioBecomingNoisy(true)
+            .setLoadControl(loadControl)
+            .setMediaSourceFactory(DefaultMediaSourceFactory(dataSourceFactory))
+            .build()
+            .apply {
+                repeatMode = Player.REPEAT_MODE_ONE
+                playWhenReady = false
+                videoScalingMode = C.VIDEO_SCALING_MODE_SCALE_TO_FIT_WITH_CROPPING
+                addAnalyticsListener(PlaybackAnalyticsLogger(TAG) { currentVideoId() })
+                addListener(
+                    object : Player.Listener {
+                        override fun onRenderedFirstFrame() {
+                            ShortsStartupTrace.onFirstFrame(currentVideoId())
+                        }
+
+                        override fun onPlaybackStateChanged(playbackState: Int) {
+                            ShortsStartupTrace.onState(
+                                currentVideoId(),
+                                when (playbackState) {
+                                    Player.STATE_IDLE -> "IDLE"
+                                    Player.STATE_BUFFERING -> "BUFFERING"
+                                    Player.STATE_READY -> "READY"
+                                    else -> "ENDED"
+                                },
+                            )
+                        }
+
+                        override fun onPlayerError(error: PlaybackException) {
+                            ShortsStartupTrace.onState(currentVideoId(), "ERROR ${error.errorCodeName}: ${error.message}")
+                        }
+                    },
+                )
+            }
+    }
+}
diff --git a/app/src/main/java/io/github/aedev/flow/player/shorts/ShortsPlayerPool.kt b/app/src/main/java/io/github/aedev/flow/player/shorts/ShortsPlayerPool.kt
index 59e79f031f..df011cc38e 100644
--- a/app/src/main/java/io/github/aedev/flow/player/shorts/ShortsPlayerPool.kt
+++ b/app/src/main/java/io/github/aedev/flow/player/shorts/ShortsPlayerPool.kt
@@ -2,43 +2,27 @@ package io.github.aedev.flow.player.shorts
 
 import android.content.Context
 import android.media.audiofx.AudioEffect
-import android.net.Uri
 import android.util.Log
 import androidx.annotation.OptIn
 import androidx.media3.common.AudioAttributes
 import androidx.media3.common.C
-import androidx.media3.common.MediaItem
 import androidx.media3.common.Player
 import androidx.media3.common.util.UnstableApi
 import androidx.media3.datasource.DataSource
 import androidx.media3.datasource.DefaultDataSource
-import androidx.media3.datasource.cache.Cache
-import androidx.media3.datasource.cache.CacheDataSource
-import androidx.media3.exoplayer.DefaultRenderersFactory
 import androidx.media3.exoplayer.ExoPlayer
-import androidx.media3.exoplayer.audio.AudioSink
-import androidx.media3.exoplayer.audio.DefaultAudioSink
-import androidx.media3.exoplayer.source.DefaultMediaSourceFactory
-import androidx.media3.exoplayer.source.MediaSource
-import androidx.media3.exoplayer.source.MergingMediaSource
-import androidx.media3.exoplayer.source.ProgressiveMediaSource
-import androidx.media3.exoplayer.trackselection.AdaptiveTrackSelection
 import androidx.media3.exoplayer.trackselection.DefaultTrackSelector
 import androidx.media3.session.MediaSession
 import dagger.hilt.android.EntryPointAccessors
 import io.github.aedev.flow.data.local.PlayerPreferences
 import io.github.aedev.flow.data.model.ShortVideo
-import io.github.aedev.flow.player.analytics.PlaybackAnalyticsLogger
 import io.github.aedev.flow.player.audio.AudioEffectsEntryPoint
 import io.github.aedev.flow.player.audio.AudioSessionAnnouncer
+import io.github.aedev.flow.player.audio.LoudnessGain
 import io.github.aedev.flow.player.audio.eq.EqualizerAudioProcessor
 import io.github.aedev.flow.player.cache.PlayerCacheManager
 import io.github.aedev.flow.player.cache.SharedPlayerCacheProvider
-import io.github.aedev.flow.player.config.PlayerConfig
-import io.github.aedev.flow.player.config.VideoSizeCap
 import io.github.aedev.flow.player.datasource.YouTubeHttpDataSource
-import io.github.aedev.flow.player.factory.LoadControlFactory
-import io.github.aedev.flow.player.resolver.MediaSourceBuilder
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
@@ -47,7 +31,6 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
 
 /**
  * ShortsPlayerPool — 3-player pool for instant swipe transitions.
@@ -71,9 +54,14 @@ import kotlinx.coroutines.withContext
 @OptIn(UnstableApi::class)
 class ShortsPlayerPool private constructor() {
     companion object {
-        private const val SESSION_ID = "flow_shorts_session"
         private const val TAG = "ShortsPlayerPool"
         private const val POOL_SIZE = 3
+        private val MovieAudio =
+            AudioAttributes
+                .Builder()
+                .setContentType(C.AUDIO_CONTENT_TYPE_MOVIE)
+                .setUsage(C.USAGE_MEDIA)
+                .build()
 
         @Volatile
         private var instance: ShortsPlayerPool? = null
@@ -85,17 +73,7 @@ class ShortsPlayerPool private constructor() {
     }
 
     private val players = arrayOfNulls<ExoPlayer>(POOL_SIZE)
-    private val playerVideoIds = arrayOfNulls<String>(POOL_SIZE)
-
-    // Tracks which content index (absolute position in the list) currently owns this player slot
-    private val playerOwnerIndices = arrayOfNulls<Int>(POOL_SIZE)
-
-    // Track the last video and audio URLs per slot so we can hot-swap audio/quality
-    private val playerVideoUrls = arrayOfNulls<String>(POOL_SIZE)
-    private val playerAudioUrls = arrayOfNulls<String?>(POOL_SIZE)
-
-    private val playerVideoManifests = arrayOfNulls<String?>(POOL_SIZE)
-    private val playerAudioManifests = arrayOfNulls<String?>(POOL_SIZE)
+    private val slots = ShortsSlots(POOL_SIZE)
 
     private val equalizers = arrayOfNulls<EqualizerAudioProcessor>(POOL_SIZE)
     private val audioSessionAnnouncers = arrayOfNulls<AudioSessionAnnouncer>(POOL_SIZE)
@@ -148,6 +126,7 @@ class ShortsPlayerPool private constructor() {
     private var preferredAudioLanguage: String = "original"
     private var shortsPlaybackMode: String = "loop"
     private var basePlaybackSpeed: Float = 1f
+    private var volumeNormalization: Boolean = true
 
     private val preferenceObservers = ShortsPreferenceObservers()
 
@@ -203,6 +182,11 @@ class ShortsPlayerPool private constructor() {
             onPlaybackSpeed = { speed ->
                 setBasePlaybackSpeed(speed)
             },
+            volumeNormalization = preferences.videoVolumeNormalizationEnabled,
+            onVolumeNormalization = { enabled ->
+                volumeNormalization = enabled
+                for (slot in 0 until POOL_SIZE) applyVolume(slot)
+            },
         )
 
         val effects = EntryPointAccessors.fromApplication(appContext, AudioEffectsEntryPoint::class.java)
@@ -217,15 +201,21 @@ class ShortsPlayerPool private constructor() {
                 val equalizer = EqualizerAudioProcessor().also { it.setSpec(equalizerSpec.value) }
                 equalizers[i] = equalizer
                 players[i] =
-                    createShortsPlayer(appContext, equalizer).also {
-                        audioSessionAnnouncers[i] =
-                            AudioSessionAnnouncer(effects.audioSessionRegistry(), AudioEffect.CONTENT_TYPE_MOVIE)
-                                .apply { attach(it) }
-                    }
-                playerOwnerIndices[i] = null
-                playerVideoIds[i] = null
+                    ShortsPlayerFactory
+                        .player(
+                            appContext,
+                            equalizer,
+                            dataSourceFactory!!,
+                            preferredAudioLanguage,
+                        ) { _currentVideoId.value }
+                        .also {
+                            audioSessionAnnouncers[i] =
+                                AudioSessionAnnouncer(effects.audioSessionRegistry(), AudioEffect.CONTENT_TYPE_MOVIE)
+                                    .apply { attach(it) }
+                        }
+                slots.clear(i)
             }
-            mediaSession = createMediaSession(appContext, players[0]!!)
+            mediaSession = ShortsPlayerFactory.mediaSession(appContext, players[0]!!)
             isInitialized = true
             Log.d(TAG, "Player pool initialized with $POOL_SIZE players")
         } catch (error: Throwable) {
@@ -241,7 +231,7 @@ class ShortsPlayerPool private constructor() {
      */
     private fun attachSharedCache(appContext: Context) {
         SharedPlayerCacheProvider.existing()?.let {
-            cachedDataSourceFactory = buildCachedFactory(appContext, it)
+            cachedDataSourceFactory = ShortsPlayerFactory.cachedDataSourceFactory(appContext, it)
             return
         }
         val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO).also { poolScope = it }
@@ -251,37 +241,13 @@ class ShortsPlayerPool private constructor() {
                 SharedPlayerCacheProvider.existing()
             }.onSuccess { cache ->
                 if (cache != null) {
-                    cachedDataSourceFactory = buildCachedFactory(appContext, cache)
+                    cachedDataSourceFactory = ShortsPlayerFactory.cachedDataSourceFactory(appContext, cache)
                     Log.d(TAG, "Shorts playback now reads through the shared media cache")
                 }
             }.onFailure { Log.w(TAG, "Shared cache unavailable; Shorts will stream uncached", it) }
         }
     }
 
-    private fun buildCachedFactory(
-        appContext: Context,
-        cache: Cache,
-    ): DataSource.Factory =
-        CacheDataSource
-            .Factory()
-            .setCache(cache)
-            .setUpstreamDataSourceFactory(DefaultDataSource.Factory(appContext, YouTubeHttpDataSource.Factory()))
-            .setFlags(CacheDataSource.FLAG_IGNORE_CACHE_ON_ERROR)
-
-    private fun createMediaSession(
-        context: Context,
-        player: ExoPlayer,
-    ): MediaSession? =
-        try {
-            MediaSession
-                .Builder(context, player)
-                .setId(SESSION_ID)
-                .build()
-        } catch (e: Exception) {
-            Log.w(TAG, "Shorts MediaSession unavailable; media buttons will not reach the reel", e)
-            null
-        }
-
     private fun updateTrackSelectors(language: String) {
         players.filterNotNull().forEach { player ->
             val trackSelector = player.trackSelector as? DefaultTrackSelector
@@ -293,97 +259,6 @@ class ShortsPlayerPool private constructor() {
         }
     }
 
-    private fun createShortsPlayer(
-        context: Context,
-        equalizer: EqualizerAudioProcessor,
-    ): ExoPlayer {
-        // The device cap is landscape; a Short is portrait, so its axes swap.
-        val (maxVideoWidth, maxVideoHeight) = VideoSizeCap.forDevice(context).let { it.maxHeight to it.maxWidth }
-
-        val loadControl = LoadControlFactory.forShorts()
-
-        val trackSelector =
-            DefaultTrackSelector(
-                context,
-                AdaptiveTrackSelection.Factory(),
-            ).apply {
-                val builder =
-                    buildUponParameters()
-                        .setPreferredVideoMimeTypes(*PlayerConfig.PREFERRED_VIDEO_MIME_TYPES)
-                        .setAllowVideoMixedMimeTypeAdaptiveness(true)
-                        .setForceHighestSupportedBitrate(false)
-                        .setViewportSizeToPhysicalDisplaySize(context, true)
-                        .setMaxVideoSize(maxVideoWidth, maxVideoHeight)
-
-                if (preferredAudioLanguage != "original" && preferredAudioLanguage.isNotEmpty()) {
-                    builder.setPreferredAudioLanguage(preferredAudioLanguage)
-                }
-
-                setParameters(builder.build())
-            }
-
-        // One processor per pooled player: they are all live at once and each keeps its own filter history.
-        val renderersFactory =
-            object : DefaultRenderersFactory(context) {
-                override fun buildAudioSink(
-                    context: Context,
-                    enableFloatOutput: Boolean,
-                    enableAudioTrackPlaybackParams: Boolean,
-                ): AudioSink =
-                    DefaultAudioSink
-                        .Builder(context)
-                        .setEnableFloatOutput(enableFloatOutput)
-                        .setEnableAudioTrackPlaybackParams(enableAudioTrackPlaybackParams)
-                        .setAudioProcessors(arrayOf(equalizer))
-                        .build()
-            }.setExtensionRendererMode(DefaultRenderersFactory.EXTENSION_RENDERER_MODE_ON)
-                .setEnableDecoderFallback(true)
-
-        return ExoPlayer
-            .Builder(context, renderersFactory)
-            .setTrackSelector(trackSelector)
-            .setAudioAttributes(
-                AudioAttributes
-                    .Builder()
-                    .setContentType(C.AUDIO_CONTENT_TYPE_MOVIE)
-                    .setUsage(C.USAGE_MEDIA)
-                    .build(),
-                false,
-            ).setHandleAudioBecomingNoisy(true)
-            .setLoadControl(loadControl)
-            .setMediaSourceFactory(DefaultMediaSourceFactory(dataSourceFactory!!))
-            .build()
-            .apply {
-                repeatMode = Player.REPEAT_MODE_ONE
-                playWhenReady = false
-                videoScalingMode = C.VIDEO_SCALING_MODE_SCALE_TO_FIT_WITH_CROPPING
-                addAnalyticsListener(PlaybackAnalyticsLogger(TAG) { _currentVideoId.value })
-                addListener(
-                    object : Player.Listener {
-                        override fun onRenderedFirstFrame() {
-                            ShortsStartupTrace.onFirstFrame(_currentVideoId.value)
-                        }
-
-                        override fun onPlaybackStateChanged(playbackState: Int) {
-                            ShortsStartupTrace.onState(
-                                _currentVideoId.value,
-                                when (playbackState) {
-                                    Player.STATE_IDLE -> "IDLE"
-                                    Player.STATE_BUFFERING -> "BUFFERING"
-                                    Player.STATE_READY -> "READY"
-                                    else -> "ENDED"
-                                },
-                            )
-                        }
-
-                        override fun onPlayerError(error: androidx.media3.common.PlaybackException) {
-                            ShortsStartupTrace.onState(_currentVideoId.value, "ERROR ${error.errorCodeName}: ${error.message}")
-                        }
-                    },
-                )
-            }
-    }
-
     // PLAYER ACCESS
 
     /**
@@ -402,7 +277,7 @@ class ShortsPlayerPool private constructor() {
     ): ExoPlayer? {
         if (!isInitialized || index < 0) return null
         val slot = ShortsSlotRules.slotFor(index, POOL_SIZE)
-        if (!ShortsSlotRules.canAttach(playerOwnerIndices[slot], playerVideoIds[slot], index, videoId)) return null
+        if (!ShortsSlotRules.canAttach(slots.ownerIndices[slot], slots.videoIds[slot], index, videoId)) return null
         return players[slot]
     }
 
@@ -417,7 +292,7 @@ class ShortsPlayerPool private constructor() {
     ): ExoPlayer? {
         if (!isInitialized || index < 0 || videoId == null) return null
         val slot = ShortsSlotRules.slotFor(index, POOL_SIZE)
-        if (!ShortsSlotRules.isOwnedBy(playerOwnerIndices[slot], playerVideoIds[slot], index, videoId)) return null
+        if (!ShortsSlotRules.isOwnedBy(slots.ownerIndices[slot], slots.videoIds[slot], index, videoId)) return null
         return players[slot]
     }
 
@@ -426,7 +301,7 @@ class ShortsPlayerPool private constructor() {
         videoId: String,
     ): String? {
         if (ownedPlayer(index, videoId) == null) return null
-        return playerVideoUrls[ShortsSlotRules.slotFor(index, POOL_SIZE)]
+        return slots.videoUrls[ShortsSlotRules.slotFor(index, POOL_SIZE)]
     }
 
     fun getCurrentVideoId(): String? = _currentVideoId.value
@@ -446,14 +321,13 @@ class ShortsPlayerPool private constructor() {
         shouldPlay: Boolean,
         videoDashManifest: String? = null,
         audioDashManifest: String? = null,
+        loudnessGainDb: Float? = null,
     ) {
         if (!isInitialized || index < 0) return
         val slot = index % POOL_SIZE
         val player = players[slot] ?: return
 
-        val isSameVideo = playerVideoIds[slot] == videoId && playerOwnerIndices[slot] == index
-
-        if (isSameVideo) {
+        if (slots.owns(slot, index, videoId)) {
             if (shouldPlay && !player.isPlaying) {
                 Log.d(TAG, "Player at index $index (slot $slot) already prepared. Resuming.")
                 activatePlayer(index, videoId)
@@ -467,13 +341,8 @@ class ShortsPlayerPool private constructor() {
         player.stop()
         player.clearMediaItems()
 
-        // Update ownership
-        playerOwnerIndices[slot] = index
-        playerVideoIds[slot] = videoId
-        playerVideoUrls[slot] = videoUrl
-        playerAudioUrls[slot] = audioUrl
-        playerVideoManifests[slot] = videoDashManifest
-        playerAudioManifests[slot] = audioDashManifest
+        slots.assign(slot, index, videoId, videoUrl, audioUrl, videoDashManifest, audioDashManifest, loudnessGainDb)
+        applyVolume(slot)
         bumpOwnership()
 
         // Load media
@@ -486,27 +355,9 @@ class ShortsPlayerPool private constructor() {
         // Set repeat mode based on playback preference: "loop" → REPEAT_MODE_ONE, "auto_next" → REPEAT_MODE_OFF
         player.repeatMode = if (shortsPlaybackMode == "loop") Player.REPEAT_MODE_ONE else Player.REPEAT_MODE_OFF
 
-        if (shouldPlay) {
-            _currentVideoId.value = videoId
-
-            player.setAudioAttributes(
-                AudioAttributes
-                    .Builder()
-                    .setContentType(C.AUDIO_CONTENT_TYPE_MOVIE)
-                    .setUsage(C.USAGE_MEDIA)
-                    .build(),
-                true,
-            )
-        } else {
-            player.setAudioAttributes(
-                AudioAttributes
-                    .Builder()
-                    .setContentType(C.AUDIO_CONTENT_TYPE_MOVIE)
-                    .setUsage(C.USAGE_MEDIA)
-                    .build(),
-                false,
-            )
-        }
+        if (shouldPlay) _currentVideoId.value = videoId
+        // Only the reel on screen takes audio focus; the buffering neighbours must not.
+        player.setAudioAttributes(MovieAudio, shouldPlay)
     }
 
     /**
@@ -528,18 +379,11 @@ class ShortsPlayerPool private constructor() {
             val isTarget = (i == activeSlot)
 
             if (isTarget) {
-                if (ShortsSlotRules.isOwnedBy(playerOwnerIndices[i], playerVideoIds[i], index, videoId)) {
+                if (ShortsSlotRules.isOwnedBy(slots.ownerIndices[i], slots.videoIds[i], index, videoId)) {
                     player.playWhenReady = true
                     player.setPlaybackSpeed(basePlaybackSpeed)
-                    player.setAudioAttributes(
-                        AudioAttributes
-                            .Builder()
-                            .setContentType(C.AUDIO_CONTENT_TYPE_MOVIE)
-                            .setUsage(C.USAGE_MEDIA)
-                            .build(),
-                        true,
-                    )
-                    _currentVideoId.value = playerVideoIds[i]
+                    player.setAudioAttributes(MovieAudio, true)
+                    _currentVideoId.value = slots.videoIds[i]
                 } else {
                     // The slot still holds another short until prepare() swaps it; it must not play meanwhile.
                     player.playWhenReady = false
@@ -559,18 +403,13 @@ class ShortsPlayerPool private constructor() {
 
         var released = false
         for (i in 0 until POOL_SIZE) {
-            val ownerIndex = playerOwnerIndices[i] ?: continue
+            val ownerIndex = slots.ownerIndices[i] ?: continue
             if (ShortsSlotRules.shouldRelease(ownerIndex, currentIndex)) {
                 Log.d(TAG, "Releasing stale player slot $i (owned by index $ownerIndex, current is $currentIndex)")
                 players[i]?.stop()
                 players[i]?.clearMediaItems()
-                playerVideoIds[i]?.let { ShortsStartupTrace.forget(it) }
-                playerOwnerIndices[i] = null
-                playerVideoIds[i] = null
-                playerVideoUrls[i] = null
-                playerAudioUrls[i] = null
-                playerVideoManifests[i] = null
-                playerAudioManifests[i] = null
+                slots.videoIds[i]?.let { ShortsStartupTrace.forget(it) }
+                slots.clear(i)
                 released = true
             }
         }
@@ -590,17 +429,17 @@ class ShortsPlayerPool private constructor() {
         if (!isInitialized || index < 0) return
         val slot = index % POOL_SIZE
         val player = players[slot] ?: return
-        if (playerOwnerIndices[slot] != index || playerVideoIds[slot] != videoId) return
+        if (!slots.owns(slot, index, videoId)) return
 
-        val videoUrl = playerVideoUrls[slot] ?: return
+        val videoUrl = slots.videoUrls[slot] ?: return
         val wasPlaying = player.isPlaying || player.playWhenReady
 
         player.stop()
         player.clearMediaItems()
-        playerAudioUrls[slot] = newAudioUrl
-        playerAudioManifests[slot] = newAudioDashManifest
+        slots.audioUrls[slot] = newAudioUrl
+        slots.audioManifests[slot] = newAudioDashManifest
 
-        preparePlayerInternal(player, videoUrl, newAudioUrl, playerVideoManifests[slot], newAudioDashManifest)
+        preparePlayerInternal(player, videoUrl, newAudioUrl, slots.videoManifests[slot], newAudioDashManifest)
         player.setPlaybackSpeed(basePlaybackSpeed)
         player.playWhenReady = wasPlaying
         player.repeatMode = if (shortsPlaybackMode == "loop") Player.REPEAT_MODE_ONE else Player.REPEAT_MODE_OFF
@@ -619,18 +458,18 @@ class ShortsPlayerPool private constructor() {
         if (!isInitialized || index < 0) return
         val slot = index % POOL_SIZE
         val player = players[slot] ?: return
-        if (playerOwnerIndices[slot] != index || playerVideoIds[slot] != videoId) return
+        if (!slots.owns(slot, index, videoId)) return
 
         val wasPlaying = player.isPlaying || player.playWhenReady
         val position = player.currentPosition
 
         player.stop()
         player.clearMediaItems()
-        playerVideoUrls[slot] = newVideoUrl
-        playerVideoManifests[slot] = newVideoDashManifest
+        slots.videoUrls[slot] = newVideoUrl
+        slots.videoManifests[slot] = newVideoDashManifest
 
-        val audioUrl = playerAudioUrls[slot]
-        preparePlayerInternal(player, newVideoUrl, audioUrl, newVideoDashManifest, playerAudioManifests[slot])
+        val audioUrl = slots.audioUrls[slot]
+        preparePlayerInternal(player, newVideoUrl, audioUrl, newVideoDashManifest, slots.audioManifests[slot])
         player.setPlaybackSpeed(basePlaybackSpeed)
         player.playWhenReady = wasPlaying
         player.seekTo(position)
@@ -645,33 +484,13 @@ class ShortsPlayerPool private constructor() {
         audioDashManifest: String?,
     ) {
         val factory = cachedDataSourceFactory ?: dataSourceFactory ?: return
-
-        if (audioUrl != null && audioUrl != videoUrl) {
-            val videoSource = mediaSourceFor(factory, videoUrl, videoDashManifest)
-            val audioSource = mediaSourceFor(factory, audioUrl, audioDashManifest)
-            val mergingSource = MergingMediaSource(true, true, videoSource, audioSource)
-            player.setMediaSource(mergingSource)
-        } else {
-            player.setMediaSource(mediaSourceFor(factory, videoUrl, videoDashManifest))
-        }
-
-        player.prepare()
+        ShortsMediaSources.load(player, factory, videoUrl, audioUrl, videoDashManifest, audioDashManifest)
         player.setPlaybackSpeed(basePlaybackSpeed)
     }
 
-    private fun mediaSourceFor(
-        factory: DataSource.Factory,
-        url: String,
-        dashManifest: String?,
-    ): MediaSource {
-        if (dashManifest != null) {
-            runCatching {
-                return MediaSourceBuilder.buildDashSource(factory, dashManifest, Uri.parse(url))
-            }.onFailure { Log.w(TAG, "Generated DASH manifest rejected, falling back to progressive: ${it.message}") }
-        }
-        return ProgressiveMediaSource
-            .Factory(factory)
-            .createMediaSource(MediaItem.fromUri(url))
+    private fun applyVolume(slot: Int) {
+        val gainDb = slots.loudnessGainsDb[slot].takeIf { volumeNormalization }
+        players[slot]?.volume = LoudnessGain.volume(gainDb)
     }
 
     // PLAYBACK CONTROL
@@ -747,12 +566,7 @@ class ShortsPlayerPool private constructor() {
             players[i]?.stop()
             players[i]?.release()
             players[i] = null
-            playerVideoIds[i] = null
-            playerOwnerIndices[i] = null
-            playerVideoUrls[i] = null
-            playerAudioUrls[i] = null
-            playerVideoManifests[i] = null
-            playerAudioManifests[i] = null
+            slots.clear(i)
         }
         dataSourceFactory = null
         isInitialized = false
diff --git a/app/src/main/java/io/github/aedev/flow/player/shorts/ShortsPreferenceObservers.kt b/app/src/main/java/io/github/aedev/flow/player/shorts/ShortsPreferenceObservers.kt
index 06d3d11120..269d41114c 100644
--- a/app/src/main/java/io/github/aedev/flow/player/shorts/ShortsPreferenceObservers.kt
+++ b/app/src/main/java/io/github/aedev/flow/player/shorts/ShortsPreferenceObservers.kt
@@ -6,6 +6,7 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.emptyFlow
 import kotlinx.coroutines.launch
 
 internal class ShortsPreferenceObservers(
@@ -23,6 +24,8 @@ internal class ShortsPreferenceObservers(
         onPreferredAudioLanguage: (String) -> Unit,
         onPlaybackMode: (String) -> Unit,
         onPlaybackSpeed: (Float) -> Unit,
+        volumeNormalization: Flow<Boolean> = emptyFlow(),
+        onVolumeNormalization: (Boolean) -> Unit = {},
     ) {
         stop()
         val observerScope = CoroutineScope(SupervisorJob() + dispatcher)
@@ -36,6 +39,9 @@ internal class ShortsPreferenceObservers(
         observerScope.launch {
             playbackSpeed.collect(onPlaybackSpeed)
         }
+        observerScope.launch {
+            volumeNormalization.collect(onVolumeNormalization)
+        }
     }
 
     fun stop() {
diff --git a/app/src/main/java/io/github/aedev/flow/player/shorts/ShortsSlots.kt b/app/src/main/java/io/github/aedev/flow/player/shorts/ShortsSlots.kt
new file mode 100644
index 0000000000..a3d57e5c32
--- /dev/null
+++ b/app/src/main/java/io/github/aedev/flow/player/shorts/ShortsSlots.kt
@@ -0,0 +1,54 @@
+package io.github.aedev.flow.player.shorts
+
+/** What each pooled player holds, kept together so a slot is assigned and cleared as one. */
+internal class ShortsSlots(
+    size: Int,
+) {
+    /** The absolute list position that owns each slot. */
+    val ownerIndices = arrayOfNulls<Int>(size)
+    val videoIds = arrayOfNulls<String>(size)
+
+    // The last streams per slot, so audio or quality can be swapped without a new lookup.
+    val videoUrls = arrayOfNulls<String>(size)
+    val audioUrls = arrayOfNulls<String?>(size)
+    val videoManifests = arrayOfNulls<String?>(size)
+    val audioManifests = arrayOfNulls<String?>(size)
+
+    /** YouTube's loudness for each slot's reel, in dB; null when its response carried none. */
+    val loudnessGainsDb = arrayOfNulls<Float>(size)
+
+    fun owns(
+        slot: Int,
+        index: Int,
+        videoId: String,
+    ): Boolean = ownerIndices[slot] == index && videoIds[slot] == videoId
+
+    fun assign(
+        slot: Int,
+        index: Int,
+        videoId: String,
+        videoUrl: String,
+        audioUrl: String?,
+        videoManifest: String?,
+        audioManifest: String?,
+        loudnessGainDb: Float? = null,
+    ) {
+        ownerIndices[slot] = index
+        videoIds[slot] = videoId
+        videoUrls[slot] = videoUrl
+        audioUrls[slot] = audioUrl
+        videoManifests[slot] = videoManifest
+        audioManifests[slot] = audioManifest
+        loudnessGainsDb[slot] = loudnessGainDb
+    }
+
+    fun clear(slot: Int) {
+        ownerIndices[slot] = null
+        videoIds[slot] = null
+        videoUrls[slot] = null
+        audioUrls[slot] = null
+        videoManifests[slot] = null
+        audioManifests[slot] = null
+        loudnessGainsDb[slot] = null
+    }
+}
diff --git a/app/src/main/java/io/github/aedev/flow/player/state/PlayerState.kt b/app/src/main/java/io/github/aedev/flow/player/state/PlayerState.kt
index 5a68849c50..f6abc22267 100644
--- a/app/src/main/java/io/github/aedev/flow/player/state/PlayerState.kt
+++ b/app/src/main/java/io/github/aedev/flow/player/state/PlayerState.kt
@@ -23,7 +23,7 @@ data class EnhancedPlayerState(
     val recoveryAttempted: Boolean = false,
     val playbackSpeed: Float = 1.0f,
     val isSkipSilenceEnabled: Boolean = false,
-    val isStableVolumeEnabled: Boolean = false,
+    val isVolumeNormalizationEnabled: Boolean = true,
     val bufferedPercentage: Float = 0f,
     val hasNext: Boolean = false,
     val hasPrevious: Boolean = false,
diff --git a/app/src/main/java/io/github/aedev/flow/service/Media3MusicService.kt b/app/src/main/java/io/github/aedev/flow/service/Media3MusicService.kt
index d51690c036..a2db4f9a74 100644
--- a/app/src/main/java/io/github/aedev/flow/service/Media3MusicService.kt
+++ b/app/src/main/java/io/github/aedev/flow/service/Media3MusicService.kt
@@ -67,9 +67,11 @@ import io.github.aedev.flow.player.MusicPlaybackDiagnostics
 import io.github.aedev.flow.player.MusicPlaybackRecoveryPlanner
 import io.github.aedev.flow.player.MusicQueuePlanner
 import io.github.aedev.flow.player.MusicRadioPlanner
+import io.github.aedev.flow.player.MusicResumeTracker
 import io.github.aedev.flow.player.PlaylistQueueOrder
 import io.github.aedev.flow.player.audio.AudioSessionAnnouncer
 import io.github.aedev.flow.player.audio.AudioSessionRegistry
+import io.github.aedev.flow.player.audio.LoudnessGain
 import io.github.aedev.flow.player.audio.eq.EqualizerAudioProcessor
 import io.github.aedev.flow.player.audio.shouldHandleAudioFocus
 import io.github.aedev.flow.player.datasource.YouTubeHttpDataSource
@@ -101,7 +103,6 @@ import kotlinx.coroutines.withContext
 import java.util.Locale
 import javax.inject.Inject
 import kotlin.math.min
-import kotlin.math.pow
 
 @AndroidEntryPoint
 class Media3MusicService : MediaLibraryService() {
@@ -254,6 +255,9 @@ class Media3MusicService : MediaLibraryService() {
     @Inject
     lateinit var queuePersistence: QueuePersistence
 
+    @Inject
+    lateinit var musicResume: MusicResumeTracker
+
     @Inject
     lateinit var lyricsHelper: io.github.aedev.flow.data.lyrics.LyricsHelper
 
@@ -345,7 +349,7 @@ class Media3MusicService : MediaLibraryService() {
             mediaId
                 ?.takeIf { loudnessNormalizationEnabled && !LocalMediaIds.isLocal(it) }
                 ?.let(MusicPlayerUtils::cachedLoudnessGainDb)
-        player.volume = if (gainDb == null) 1f else 10.0.pow(gainDb / 20.0).toFloat()
+        player.volume = LoudnessGain.volume(gainDb)
     }
 
     private fun applyPlayDuringCallsPreference(playDuringCalls: Boolean) {
@@ -470,6 +474,7 @@ class Media3MusicService : MediaLibraryService() {
         // Shuffle rearranges the queue itself, so the list on screen is the play order. With this
         // order, the player's shuffle flag reorders nothing on its own, whichever controller sets it.
         player.setShuffleOrder(ShuffleOrder.UnshuffledShuffleOrder(0))
+        musicResume.attach(player)
 
         player.addListener(
             object : Player.Listener {
@@ -1383,6 +1388,7 @@ class Media3MusicService : MediaLibraryService() {
             mediaLibrarySession.release()
         }
         if (::player.isInitialized) {
+            musicResume.saveCurrent(player)
             player.release()
         }
         releaseLocks()
diff --git a/app/src/main/java/io/github/aedev/flow/ui/components/musicplayer/sheet/AudioSettingsSheet.kt b/app/src/main/java/io/github/aedev/flow/ui/components/musicplayer/sheet/AudioSettingsSheet.kt
index ee50ba0720..1cab1baedc 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/components/musicplayer/sheet/AudioSettingsSheet.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/components/musicplayer/sheet/AudioSettingsSheet.kt
@@ -35,13 +35,13 @@ import io.github.aedev.flow.ui.components.shared.FlowRowGroup
 import io.github.aedev.flow.ui.components.shared.FlowSectionHeader
 import io.github.aedev.flow.ui.components.shared.FlowSheetHeader
 import io.github.aedev.flow.ui.components.shared.FlowSwitchRow
+import io.github.aedev.flow.ui.components.shared.MediaPlaybackSpeedPicker
 import io.github.aedev.flow.ui.components.shared.flowRowGroupShape
 import io.github.aedev.flow.ui.components.shared.rememberFlowSheetState
 import kotlinx.coroutines.launch
 import kotlin.math.roundToInt
 
 private const val TEMPO_ROWS = 3
-private const val SPEED_STEPS = 34
 private const val PITCH_STEPS = 23
 private val SliderRowPadding = PaddingValues(horizontal = 16.dp, vertical = 12.dp)
 
@@ -55,6 +55,8 @@ fun AudioSettingsSheet(onDismiss: () -> Unit) {
     val context = LocalContext.current
     val preferences = remember { PlayerPreferences(context) }
     val normalizationEnabled by preferences.musicLoudnessNormalizationEnabled.collectAsState(initial = true)
+    val customSpeedsEnabled by preferences.customSpeedsEnabled.collectAsState(initial = false)
+    val customSpeedPresetsRaw by preferences.customSpeedPresets.collectAsState(initial = "")
     val scope = rememberCoroutineScope()
 
     ModalBottomSheet(
@@ -83,19 +85,25 @@ fun AudioSettingsSheet(onDismiss: () -> Unit) {
             FlowSectionHeader(stringResource(R.string.label_tempo_pitch))
             FlowRowGroup {
                 PanelRow(shape = flowRowGroupShape(0, TEMPO_ROWS)) {
-                    SliderRow(
-                        label = stringResource(R.string.template_speed, (speed * 100).roundToInt()),
-                        value = speed,
-                        onValueChange = EnhancedMusicPlayerManager::setPlaybackSpeed,
-                        range = 0.25f..2.0f,
-                        steps = SPEED_STEPS,
+                    MediaPlaybackSpeedPicker(
+                        currentSpeed = speed,
+                        sliderEnabled = true,
+                        customSpeedsEnabled = customSpeedsEnabled,
+                        customSpeedPresetsRaw = customSpeedPresetsRaw,
+                        onSpeedSelected = { EnhancedMusicPlayerManager.setPlaybackSpeed(it, persist = false) },
+                        onSliderSelectionFinished = { EnhancedMusicPlayerManager.setPlaybackSpeed(it) },
                     )
                 }
                 PanelRow(shape = flowRowGroupShape(1, TEMPO_ROWS)) {
                     SliderRow(
                         label = stringResource(R.string.template_pitch, pitch.roundToInt()),
                         value = pitch,
-                        onValueChange = EnhancedMusicPlayerManager::setPlaybackPitch,
+                        onValueChange = { EnhancedMusicPlayerManager.setPlaybackPitch(it, persist = false) },
+                        onValueChangeFinished = {
+                            EnhancedMusicPlayerManager.setPlaybackPitch(
+                                EnhancedMusicPlayerManager.playbackPitch.value,
+                            )
+                        },
                         range = -12f..12f,
                         steps = PITCH_STEPS,
                     )
@@ -131,11 +139,18 @@ private fun SliderRow(
     label: String,
     value: Float,
     onValueChange: (Float) -> Unit,
+    onValueChangeFinished: () -> Unit,
     range: ClosedFloatingPointRange<Float>,
     steps: Int,
 ) {
     Column(modifier = Modifier.fillMaxWidth().padding(SliderRowPadding)) {
         Text(label, style = MaterialTheme.typography.bodyLarge)
-        Slider(value = value, onValueChange = onValueChange, valueRange = range, steps = steps)
+        Slider(
+            value = value,
+            onValueChange = onValueChange,
+            onValueChangeFinished = onValueChangeFinished,
+            valueRange = range,
+            steps = steps,
+        )
     }
 }
diff --git a/app/src/main/java/io/github/aedev/flow/ui/components/settings/SettingsRows.kt b/app/src/main/java/io/github/aedev/flow/ui/components/settings/SettingsRows.kt
index 816b71b070..d798fe0c27 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/components/settings/SettingsRows.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/components/settings/SettingsRows.kt
@@ -102,12 +102,14 @@ fun SettingsGroupScope.choice(
 
 /**
  * A row that opens a page, dialog or sheet for [entry]. A [value] is shown under the title — the
- * current choice of a setting that opens a picker — and otherwise the entry's summary.
+ * current choice of a setting that opens a picker — and otherwise the entry's summary. [valueText]
+ * is the same for a value read from state, so a change recomposes this row alone.
  */
 fun SettingsGroupScope.nav(
     entry: SettingEntry,
     onClick: () -> Unit,
     value: String? = null,
+    valueText: (@Composable () -> String?)? = null,
     enabled: Boolean = true,
     showChevron: Boolean = true,
     selected: Boolean = false,
@@ -118,7 +120,7 @@ fun SettingsGroupScope.nav(
     FlowNavRow(
         title = stringResource(entry.title),
         modifier = modifier,
-        supportingText = value ?: entry.summaryText(),
+        supportingText = valueText?.invoke() ?: value ?: entry.summaryText(),
         onClick = onClick,
         enabled = enabled,
         showChevron = showChevron,
diff --git a/app/src/main/java/io/github/aedev/flow/ui/components/videoplayer/settings/PlayerSettingsMainPage.kt b/app/src/main/java/io/github/aedev/flow/ui/components/videoplayer/settings/PlayerSettingsMainPage.kt
index e4d6c94d69..0f71e453fd 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/components/videoplayer/settings/PlayerSettingsMainPage.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/components/videoplayer/settings/PlayerSettingsMainPage.kt
@@ -53,7 +53,7 @@ internal fun PlayerSettingsMainPage(
     onLoopToggle: (Boolean) -> Unit,
     onAutoplayToggle: (Boolean) -> Unit,
     onSkipSilenceToggle: (Boolean) -> Unit,
-    onStableVolumeToggle: (Boolean) -> Unit,
+    onVolumeNormalizationToggle: (Boolean) -> Unit,
     onAmbientModeToggle: (Boolean) -> Unit,
     sponsorBlockSegmentCount: Int = 0,
     sponsorBlockOffForVideo: Boolean = false,
@@ -200,10 +200,10 @@ internal fun PlayerSettingsMainPage(
         )
         FlowSwitchRow(
             leadingIcon = Icons.AutoMirrored.Rounded.VolumeUp,
-            title = stringResource(R.string.player_settings_stable_voice),
-            checked = playerState.isStableVolumeEnabled,
+            title = stringResource(R.string.player_settings_normalize_volume),
+            checked = playerState.isVolumeNormalizationEnabled,
             shape = flowRowGroupShape(2, EFFECT_ROWS),
-            onCheckedChange = onStableVolumeToggle,
+            onCheckedChange = onVolumeNormalizationToggle,
         )
     }
 
diff --git a/app/src/main/java/io/github/aedev/flow/ui/components/videoplayer/settings/PlayerSettingsSheet.kt b/app/src/main/java/io/github/aedev/flow/ui/components/videoplayer/settings/PlayerSettingsSheet.kt
index a179b08658..7cf009844d 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/components/videoplayer/settings/PlayerSettingsSheet.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/components/videoplayer/settings/PlayerSettingsSheet.kt
@@ -47,7 +47,7 @@ fun SettingsMenuDialog(
     onSubtitleOffsetChange: ((Long) -> Unit)? = null,
     onAutoplayToggle: (Boolean) -> Unit,
     onSkipSilenceToggle: (Boolean) -> Unit,
-    onStableVolumeToggle: (Boolean) -> Unit,
+    onVolumeNormalizationToggle: (Boolean) -> Unit,
     subtitleStyle: SubtitleStyle,
     onSubtitleStyleChange: (SubtitleStyle) -> Unit,
     onLoopToggle: (Boolean) -> Unit,
@@ -151,7 +151,7 @@ fun SettingsMenuDialog(
                         onLoopToggle = onLoopToggle,
                         onAutoplayToggle = onAutoplayToggle,
                         onSkipSilenceToggle = onSkipSilenceToggle,
-                        onStableVolumeToggle = onStableVolumeToggle,
+                        onVolumeNormalizationToggle = onVolumeNormalizationToggle,
                         onAmbientModeToggle = onAmbientModeToggle,
                         sponsorBlockSegmentCount = sponsorBlockSegmentCount,
                         sponsorBlockOffForVideo = sponsorBlockOffForVideo,
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/music/MusicPlayStart.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/music/MusicPlayStart.kt
new file mode 100644
index 0000000000..e7bfed935a
--- /dev/null
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/music/MusicPlayStart.kt
@@ -0,0 +1,52 @@
+package io.github.aedev.flow.ui.screens.music
+
+import android.net.Uri
+import io.github.aedev.flow.data.local.PlayerPreferences
+import io.github.aedev.flow.data.local.ViewHistory
+import io.github.aedev.flow.data.music.DownloadManager
+import io.github.aedev.flow.data.music.model.MusicTrack
+import io.github.aedev.flow.player.MusicResumePolicy
+import io.github.aedev.flow.utils.PerformanceDispatcher
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.withContext
+import java.io.File
+
+/** What a tapped play reads from storage before it starts, and the history row it leaves behind. */
+internal class MusicPlayStart(
+    private val downloadManager: DownloadManager,
+    private val viewHistory: ViewHistory,
+    private val playerPreferences: PlayerPreferences,
+) {
+    /** Offline copies of [queue], so they play from the device instead of the network. */
+    suspend fun downloadedUris(queue: List<MusicTrack>): Map<String, Uri> =
+        withContext(PerformanceDispatcher.diskIO) {
+            queue
+                .mapNotNull { track ->
+                    val path = downloadManager.getDownloadedTrackPath(track.videoId) ?: return@mapNotNull null
+                    val uri = if (path.startsWith("content://")) Uri.parse(path) else Uri.fromFile(File(path))
+                    track.videoId to uri
+                }.toMap()
+        }
+
+    /** Where [track] should start: its saved place when it is long and resuming is on, else 0. */
+    suspend fun resumePosition(track: MusicTrack): Long {
+        if (!playerPreferences.musicResumeLongTracks.first()) return 0L
+        return withContext(PerformanceDispatcher.diskIO) {
+            val durationMs = track.duration * 1000L
+            MusicResumePolicy.startPosition(
+                savedPosition = viewHistory.getSavedPosition(track.videoId),
+                durationMs = durationMs.takeIf { it > 0L } ?: viewHistory.getSavedDuration(track.videoId),
+            )
+        }
+    }
+
+    suspend fun recordStart(track: MusicTrack) =
+        viewHistory.touchMusicEntry(
+            videoId = track.videoId,
+            duration = track.duration.toLong() * 1000,
+            title = track.title,
+            thumbnailUrl = track.thumbnailUrl,
+            channelName = track.artist,
+            channelId = track.channelId,
+        )
+}
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/music/MusicPlayerViewModel.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/music/MusicPlayerViewModel.kt
index 7ae2d5bc87..71dff75785 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/music/MusicPlayerViewModel.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/music/MusicPlayerViewModel.kt
@@ -2,7 +2,6 @@ package io.github.aedev.flow.ui.screens.music
 
 import android.content.Context
 import android.net.Uri
-import android.os.SystemClock
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import androidx.media3.common.Player
@@ -41,7 +40,6 @@ import kotlinx.coroutines.supervisorScope
 import kotlinx.coroutines.withContext
 import kotlinx.coroutines.withTimeoutOrNull
 import javax.inject.Inject
-import kotlin.math.abs
 
 @HiltViewModel
 class MusicPlayerViewModel
@@ -76,9 +74,9 @@ class MusicPlayerViewModel
 
         private var isInitialized = false
         private var loadTrackJob: kotlinx.coroutines.Job? = null
-        private var pendingSeekPosition: Long? = null
-        private var pendingSeekStartedAtMs: Long = 0L
+        private val seekGuard = MusicSeekGuard()
         private val radioSwitch = MusicRadioSwitch(viewModelScope, _uiState, playerPreferences)
+        private val playStart = MusicPlayStart(downloadManager, viewHistory, playerPreferences)
         private val lyrics =
             MusicPlayerLyrics(
                 context,
@@ -145,7 +143,7 @@ class MusicPlayerViewModel
 
             viewModelScope.launch {
                 EnhancedMusicPlayerManager.currentPosition.collect { position ->
-                    acceptedPlaybackPosition(position)?.let { acceptedPosition ->
+                    seekGuard.accept(position)?.let { acceptedPosition ->
                         _currentPositionMs.value = acceptedPosition
                     }
                 }
@@ -259,28 +257,18 @@ class MusicPlayerViewModel
                             playingFrom = context.getString(R.string.local_media_title),
                         )
                     }
+                    val startPositionMs = playStart.resumePosition(track)
                     withContext(kotlinx.coroutines.Dispatchers.Main) {
                         EnhancedMusicPlayerManager.playTrack(
                             track = track,
                             audioUrl = localUris[track.videoId]?.toString() ?: "",
                             queue = activeQueue,
+                            startPositionMs = startPositionMs,
                             sourceName = context.getString(R.string.local_media_title),
                             localUriOverrides = localUris,
                         )
                     }
-                    launch(PerformanceDispatcher.diskIO) {
-                        viewHistory.savePlaybackPosition(
-                            videoId = track.videoId,
-                            position = 0,
-                            duration = track.duration.toLong() * 1000,
-                            title = track.title,
-                            thumbnailUrl = track.thumbnailUrl,
-                            channelName = track.artist,
-                            channelId = track.channelId,
-                            isMusic = true,
-                            isLocal = true,
-                        )
-                    }
+                    launch(PerformanceDispatcher.diskIO) { playStart.recordStart(track) }
                 }
         }
 
@@ -327,20 +315,8 @@ class MusicPlayerViewModel
                 viewModelScope.launch {
                     val finalSourceName = musicSourceLabel(context, displaySourceName, track)
                     val activeQueue = if (queue.isNotEmpty()) queue else listOf(track)
-                    val localUriOverrides =
-                        withContext(PerformanceDispatcher.diskIO) {
-                            activeQueue
-                                .mapNotNull { queuedTrack ->
-                                    val path = downloadManager.getDownloadedTrackPath(queuedTrack.videoId) ?: return@mapNotNull null
-                                    val uri =
-                                        if (path.startsWith("content://")) {
-                                            Uri.parse(path)
-                                        } else {
-                                            Uri.fromFile(java.io.File(path))
-                                        }
-                                    queuedTrack.videoId to uri
-                                }.toMap()
-                        }
+                    val localUriOverrides = playStart.downloadedUris(activeQueue)
+                    val startPositionMs = playStart.resumePosition(track)
 
                     // ─── PHASE 1: Instant start ───────────────────────────────────────────
                     _uiState.update {
@@ -362,6 +338,7 @@ class MusicPlayerViewModel
                             track = track,
                             audioUrl = "music://${track.videoId}",
                             queue = activeQueue,
+                            startPositionMs = startPositionMs,
                             sourceName = finalSourceName,
                             localUriOverrides = localUriOverrides,
                         )
@@ -380,16 +357,7 @@ class MusicPlayerViewModel
 
                         launch(PerformanceDispatcher.diskIO) {
                             playlistRepository.addToHistory(track)
-                            viewHistory.savePlaybackPosition(
-                                videoId = track.videoId,
-                                position = 0,
-                                duration = track.duration.toLong() * 1000,
-                                title = track.title,
-                                thumbnailUrl = track.thumbnailUrl,
-                                channelName = track.artist,
-                                channelId = track.channelId,
-                                isMusic = true,
-                            )
+                            playStart.recordStart(track)
                         }
 
                         launch(PerformanceDispatcher.networkIO) {
@@ -498,33 +466,11 @@ class MusicPlayerViewModel
                 _uiState.value.duration.takeIf { it > 0 }
                     ?: EnhancedMusicPlayerManager.getDuration().takeIf { it > 0 }
             val target = duration?.let { position.coerceIn(0L, it) } ?: position.coerceAtLeast(0L)
-            pendingSeekPosition = target
-            pendingSeekStartedAtMs = SystemClock.elapsedRealtime()
+            seekGuard.seekRequested(target)
             EnhancedMusicPlayerManager.seekTo(target)
             _currentPositionMs.value = target
         }
 
-        private fun acceptedPlaybackPosition(position: Long): Long? {
-            val pending = pendingSeekPosition ?: return position
-            val elapsedMs = SystemClock.elapsedRealtime() - pendingSeekStartedAtMs
-            val seekHasLanded = abs(position - pending) <= SEEK_POSITION_CONFIRM_TOLERANCE_MS
-            val guardExpired = elapsedMs >= SEEK_POSITION_GUARD_MS
-
-            if (seekHasLanded) {
-                if (elapsedMs >= SEEK_POSITION_MIN_HOLD_MS) {
-                    pendingSeekPosition = null
-                }
-                return position
-            }
-
-            if (guardExpired) {
-                pendingSeekPosition = null
-                return position
-            }
-
-            return null
-        }
-
         fun skipToNext() {
             EnhancedMusicPlayerManager.playNext()
         }
@@ -630,7 +576,3 @@ class MusicPlayerViewModel
             super.onCleared()
         }
     }
-
-private const val SEEK_POSITION_CONFIRM_TOLERANCE_MS = 1_000L
-private const val SEEK_POSITION_MIN_HOLD_MS = 250L
-private const val SEEK_POSITION_GUARD_MS = 1_500L
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/music/MusicSeekGuard.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/music/MusicSeekGuard.kt
new file mode 100644
index 0000000000..7677013253
--- /dev/null
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/music/MusicSeekGuard.kt
@@ -0,0 +1,36 @@
+package io.github.aedev.flow.ui.screens.music
+
+import android.os.SystemClock
+import kotlin.math.abs
+
+private const val SEEK_POSITION_CONFIRM_TOLERANCE_MS = 1_000L
+private const val SEEK_POSITION_MIN_HOLD_MS = 250L
+private const val SEEK_POSITION_GUARD_MS = 1_500L
+
+/** Holds the seek bar on a requested position until the player reports it, so it never jumps back. */
+internal class MusicSeekGuard(
+    private val now: () -> Long = SystemClock::elapsedRealtime,
+) {
+    private var pendingPosition: Long? = null
+    private var startedAtMs: Long = 0L
+
+    fun seekRequested(target: Long) {
+        pendingPosition = target
+        startedAtMs = now()
+    }
+
+    /** The position to show for a player report, or null while a seek is still in flight. */
+    fun accept(position: Long): Long? {
+        val pending = pendingPosition ?: return position
+        val elapsedMs = now() - startedAtMs
+        if (abs(position - pending) <= SEEK_POSITION_CONFIRM_TOLERANCE_MS) {
+            if (elapsedMs >= SEEK_POSITION_MIN_HOLD_MS) pendingPosition = null
+            return position
+        }
+        if (elapsedMs >= SEEK_POSITION_GUARD_MS) {
+            pendingPosition = null
+            return position
+        }
+        return null
+    }
+}
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/notifications/NotificationRow.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/notifications/NotificationRow.kt
index 96f44f8e40..7e89862b1c 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/notifications/NotificationRow.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/notifications/NotificationRow.kt
@@ -10,6 +10,7 @@ import androidx.compose.foundation.layout.padding
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.Delete
 import androidx.compose.material.icons.outlined.Notifications
+import androidx.compose.material.icons.outlined.WatchLater
 import androidx.compose.material3.Badge
 import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
 import androidx.compose.material3.Icon
@@ -21,11 +22,16 @@ import androidx.compose.material3.SwipeToDismissBoxValue
 import androidx.compose.material3.Text
 import androidx.compose.material3.rememberSwipeToDismissBoxState
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.Shape
+import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.CustomAccessibilityAction
+import androidx.compose.ui.semantics.customActions
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.semantics.stateDescription
 import androidx.compose.ui.text.font.FontWeight
@@ -34,15 +40,16 @@ import androidx.compose.ui.unit.dp
 import io.github.aedev.flow.R
 import io.github.aedev.flow.data.local.entity.NotificationEntity
 import io.github.aedev.flow.ui.components.shared.MediaThumbnail
+import kotlinx.coroutines.launch
 
 private val ThumbnailWidth = 120.dp
 private val RowPadding = PaddingValues(start = 12.dp, end = 16.dp, top = 12.dp, bottom = 12.dp)
 private val MetaSpacing = 6.dp
-private val DeleteIconPadding = 24.dp
+private val SwipeIconPadding = 24.dp
 
 /**
- * One notification in a segmented group. Swiping it towards the start removes it; the screen offers
- * the undo, so the row itself carries no delete button.
+ * One notification in a segmented group. Swiping it towards the start removes it, and towards the
+ * end saves its video to Watch later and leaves the row in place; the screen shows the result.
  */
 @Composable
 internal fun NotificationRow(
@@ -51,36 +58,80 @@ internal fun NotificationRow(
     time: String,
     shape: Shape,
     onClick: () -> Unit,
+    onLongClick: () -> Unit,
     onDismiss: () -> Unit,
+    onSave: () -> Unit,
     modifier: Modifier = Modifier,
 ) {
     val state = rememberSwipeToDismissBoxState()
+    val scope = rememberCoroutineScope()
+    val saveLabel = stringResource(R.string.notifications_save_to_watch_later)
+    val deleteLabel = stringResource(R.string.delete)
     SwipeToDismissBox(
         state = state,
-        modifier = modifier.clip(shape),
-        enableDismissFromStartToEnd = false,
-        onDismiss = { value -> if (value == SwipeToDismissBoxValue.EndToStart) onDismiss() },
-        backgroundContent = { DeleteBackground() },
+        modifier =
+            modifier.clip(shape).semantics {
+                customActions =
+                    listOf(
+                        CustomAccessibilityAction(saveLabel) {
+                            onSave()
+                            true
+                        },
+                        CustomAccessibilityAction(deleteLabel) {
+                            onDismiss()
+                            true
+                        },
+                    )
+            },
+        onDismiss = { value ->
+            if (value == SwipeToDismissBoxValue.StartToEnd) {
+                onSave()
+                scope.launch { state.reset() }
+            } else if (value == SwipeToDismissBoxValue.EndToStart) {
+                onDismiss()
+            }
+        },
+        backgroundContent = {
+            if (state.dismissDirection == SwipeToDismissBoxValue.StartToEnd) {
+                SwipeBackground(
+                    icon = Icons.Outlined.WatchLater,
+                    label = saveLabel,
+                    container = MaterialTheme.colorScheme.secondaryContainer,
+                    content = MaterialTheme.colorScheme.onSecondaryContainer,
+                    alignment = Alignment.CenterStart,
+                )
+            } else {
+                SwipeBackground(
+                    icon = Icons.Outlined.Delete,
+                    label = deleteLabel,
+                    container = MaterialTheme.colorScheme.errorContainer,
+                    content = MaterialTheme.colorScheme.onErrorContainer,
+                    alignment = Alignment.CenterEnd,
+                )
+            }
+        },
     ) {
-        NotificationContent(notification, isNew, time, shape, onClick)
+        NotificationContent(notification, isNew, time, shape, onClick, onLongClick)
     }
 }
 
 @Composable
-private fun DeleteBackground() {
+private fun SwipeBackground(
+    icon: ImageVector,
+    label: String,
+    container: Color,
+    content: Color,
+    alignment: Alignment,
+) {
     Box(
         modifier =
             Modifier
                 .fillMaxSize()
-                .background(MaterialTheme.colorScheme.errorContainer)
-                .padding(end = DeleteIconPadding),
-        contentAlignment = Alignment.CenterEnd,
+                .background(container)
+                .padding(horizontal = SwipeIconPadding),
+        contentAlignment = alignment,
     ) {
-        Icon(
-            imageVector = Icons.Outlined.Delete,
-            contentDescription = stringResource(R.string.delete),
-            tint = MaterialTheme.colorScheme.onErrorContainer,
-        )
+        Icon(imageVector = icon, contentDescription = label, tint = content)
     }
 }
 
@@ -92,11 +143,14 @@ private fun NotificationContent(
     time: String,
     shape: Shape,
     onClick: () -> Unit,
+    onLongClick: () -> Unit,
 ) {
     val newLabel = stringResource(R.string.notifications_group_new)
     val colors = MaterialTheme.colorScheme
     SegmentedListItem(
         onClick = onClick,
+        onLongClick = onLongClick,
+        onLongClickLabel = stringResource(R.string.more_options),
         shapes = ListItemDefaults.shapes(shape = shape),
         modifier = if (isNew) Modifier.semantics { stateDescription = newLabel } else Modifier,
         verticalAlignment = Alignment.CenterVertically,
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/notifications/NotificationScreen.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/notifications/NotificationScreen.kt
index 088e5c3454..bb35d659b8 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/notifications/NotificationScreen.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/notifications/NotificationScreen.kt
@@ -10,6 +10,7 @@ import androidx.compose.foundation.layout.widthIn
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.itemsIndexed
 import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Delete
 import androidx.compose.material.icons.outlined.DeleteSweep
 import androidx.compose.material.icons.outlined.NotificationsNone
 import androidx.compose.material.icons.outlined.Settings
@@ -44,6 +45,7 @@ import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import io.github.aedev.flow.R
 import io.github.aedev.flow.data.local.entity.NotificationEntity
+import io.github.aedev.flow.data.model.Video
 import io.github.aedev.flow.ui.components.layout.LocalFlowBottomInsets
 import io.github.aedev.flow.ui.components.layout.floatAboveBottomChrome
 import io.github.aedev.flow.ui.components.layout.flowBottomContentPadding
@@ -54,6 +56,7 @@ import io.github.aedev.flow.ui.components.shared.FlowMaxContentWidth
 import io.github.aedev.flow.ui.components.shared.FlowSectionHeader
 import io.github.aedev.flow.ui.components.shared.FlowSegmentedGap
 import io.github.aedev.flow.ui.components.shared.flowSegmentShape
+import io.github.aedev.flow.ui.components.shared.quickactions.VideoQuickActionsBottomSheet
 import kotlinx.coroutines.launch
 import java.time.ZoneId
 
@@ -77,6 +80,9 @@ fun NotificationScreen(
     var confirmClear by rememberSaveable { mutableStateOf(false) }
     val removedMessage = stringResource(R.string.notifications_removed)
     val undoLabel = stringResource(R.string.undo)
+    val savedMessage = stringResource(R.string.toast_added_to_watch_later)
+    val alreadySavedMessage = stringResource(R.string.notifications_already_in_watch_later)
+    var menu by remember { mutableStateOf<NotificationMenu?>(null) }
 
     LaunchedEffect(Unit) { viewModel.openInbox() }
 
@@ -89,6 +95,20 @@ fun NotificationScreen(
         }
     }
 
+    fun save(item: NotificationEntity) {
+        viewModel.saveToWatchLater(item) { saved ->
+            scope.launch {
+                snackbarHostState.currentSnackbarData?.dismiss()
+                if (!saved) {
+                    snackbarHostState.showSnackbar(alreadySavedMessage, duration = SnackbarDuration.Short)
+                    return@launch
+                }
+                val result = snackbarHostState.showSnackbar(savedMessage, undoLabel, duration = SnackbarDuration.Short)
+                if (result == SnackbarResult.ActionPerformed) viewModel.undoSave()
+            }
+        }
+    }
+
     Scaffold(
         containerColor = MaterialTheme.colorScheme.background,
         contentWindowInsets = WindowInsets(0.dp),
@@ -137,7 +157,9 @@ fun NotificationScreen(
                             time = notificationTime(item.timestamp, today, zone).label(),
                             shape = flowSegmentShape(index, section.items.size),
                             onClick = { onNotificationClick(item.videoId) },
+                            onLongClick = { scope.launch { menu = NotificationMenu(item, viewModel.videoFor(item)) } },
                             onDismiss = { remove(item) },
+                            onSave = { save(item) },
                             modifier = Modifier.animateItem().padding(bottom = FlowSegmentedGap),
                         )
                     }
@@ -146,6 +168,16 @@ fun NotificationScreen(
         }
     }
 
+    menu?.let { open ->
+        VideoQuickActionsBottomSheet(
+            video = open.video,
+            onDismiss = { menu = null },
+            onRemoveFromCollection = { remove(open.notification) },
+            removeFromCollectionLabel = stringResource(R.string.delete),
+            removeFromCollectionIcon = Icons.Outlined.Delete,
+        )
+    }
+
     if (confirmClear) {
         ClearAllDialog(
             count = notifications.size,
@@ -193,3 +225,8 @@ private fun ClearAllDialog(
         dismissButton = { TextButton(onClick = onDismiss) { Text(stringResource(R.string.cancel)) } },
     )
 }
+
+private class NotificationMenu(
+    val notification: NotificationEntity,
+    val video: Video,
+)
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/notifications/NotificationViewModel.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/notifications/NotificationViewModel.kt
index 968b9830d9..a44555c860 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/notifications/NotificationViewModel.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/notifications/NotificationViewModel.kt
@@ -2,9 +2,13 @@ package io.github.aedev.flow.ui.screens.notifications
 
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
+import dagger.Lazy
 import dagger.hilt.android.lifecycle.HiltViewModel
+import io.github.aedev.flow.data.engagement.VideoFeedbackUseCase
 import io.github.aedev.flow.data.local.NotificationRepository
 import io.github.aedev.flow.data.local.entity.NotificationEntity
+import io.github.aedev.flow.data.model.Video
+import io.github.aedev.flow.data.subscriptions.SubscriptionFeedRepository
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
@@ -19,6 +23,9 @@ class NotificationViewModel
     @Inject
     constructor(
         private val repository: NotificationRepository,
+        // Lazy: the activity-scoped instance behind the badge never saves anything.
+        private val feed: Lazy<SubscriptionFeedRepository>,
+        private val videoFeedback: Lazy<VideoFeedbackUseCase>,
     ) : ViewModel() {
         val notifications: StateFlow<List<NotificationEntity>> =
             repository.allNotifications
@@ -35,6 +42,7 @@ class NotificationViewModel
 
         private var inboxOpened = false
         private var lastRemoved: NotificationEntity? = null
+        private var lastSaved: Video? = null
 
         /**
          * Takes the unread snapshot, then clears the badge. Only the inbox route calls this: the
@@ -64,8 +72,44 @@ class NotificationViewModel
             viewModelScope.launch { repository.insertNotification(notification.copy(isRead = true)) }
         }
 
+        /** Saves [notification]'s video to Watch later; [onResult] gets false when it was already there. */
+        fun saveToWatchLater(
+            notification: NotificationEntity,
+            onResult: (Boolean) -> Unit,
+        ) {
+            viewModelScope.launch {
+                val video = videoFor(notification)
+                val saved = videoFeedback.get().saveToWatchLater(video)
+                lastSaved = video.takeIf { saved }
+                onResult(saved)
+            }
+        }
+
+        fun undoSave() {
+            val video = lastSaved ?: return
+            lastSaved = null
+            viewModelScope.launch { videoFeedback.get().setWatchLater(video, saved = false) }
+        }
+
+        /** The feed's copy carries the channel and length a notification never stored. */
+        suspend fun videoFor(notification: NotificationEntity): Video =
+            feed.get().cachedVideo(notification.videoId) ?: notification.toVideo()
+
         fun clearAll() {
             lastRemoved = null
             viewModelScope.launch { repository.clearAll() }
         }
     }
+
+private fun NotificationEntity.toVideo() =
+    Video(
+        id = videoId,
+        title = title,
+        channelName = channelName,
+        channelId = "",
+        thumbnailUrl = thumbnailUrl.orEmpty(),
+        duration = 0,
+        viewCount = 0,
+        uploadDate = "",
+        timestamp = timestamp,
+    )
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/player/PlaybackSessionApplier.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/player/PlaybackSessionApplier.kt
index 51751e72fc..7218fa13c1 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/player/PlaybackSessionApplier.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/player/PlaybackSessionApplier.kt
@@ -17,6 +17,7 @@ import io.github.aedev.flow.data.video.OfflineSubtitleStore
 import io.github.aedev.flow.data.video.VideoDownloadManager
 import io.github.aedev.flow.player.EnhancedPlayerManager
 import io.github.aedev.flow.player.GlobalPlayerState
+import io.github.aedev.flow.player.audio.LoudnessGain
 import io.github.aedev.flow.player.error.VideoErrorMapper
 import io.github.aedev.flow.player.stream.InnerTubeVideoStreamExtractor
 import io.github.aedev.flow.player.stream.PlaybackFailure
@@ -412,6 +413,10 @@ internal class PlaybackSessionApplier(
             loadToken = load.token,
         )
 
+        playerManager.setLoudness(
+            videoId,
+            LoudnessGain.gainDb(result.playerResponse.playerConfig?.audioConfig, result.audioFormats.firstOrNull()?.loudnessDb),
+        )
         playbackPreparer.prepareVodStreams(
             videoId = videoId,
             streams = streams,
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/player/PlaybackSettingsController.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/player/PlaybackSettingsController.kt
index 32d607fc9c..51aafbb9ae 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/player/PlaybackSettingsController.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/player/PlaybackSettingsController.kt
@@ -83,8 +83,8 @@ internal class PlaybackSettingsController(
         playerManager.toggleSkipSilence(isEnabled)
     }
 
-    fun toggleStableVolume(isEnabled: Boolean) {
-        playerManager.toggleStableVolume(isEnabled)
+    fun toggleVolumeNormalization(isEnabled: Boolean) {
+        playerManager.toggleVolumeNormalization(isEnabled)
     }
 
     private suspend fun applyAutoplayPreference(autoplay: Boolean) {
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/player/VideoPlayerViewModel.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/player/VideoPlayerViewModel.kt
index 290167d4ab..ee6faddcd7 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/player/VideoPlayerViewModel.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/player/VideoPlayerViewModel.kt
@@ -596,5 +596,5 @@ class VideoPlayerViewModel
 
         fun toggleSkipSilence(isEnabled: Boolean) = settings.toggleSkipSilence(isEnabled)
 
-        fun toggleStableVolume(isEnabled: Boolean) = settings.toggleStableVolume(isEnabled)
+        fun toggleVolumeNormalization(isEnabled: Boolean) = settings.toggleVolumeNormalization(isEnabled)
     }
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/player/dialogs/PlayerSettingsSheetHost.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/player/dialogs/PlayerSettingsSheetHost.kt
index 61e568fba6..439a3a41ba 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/player/dialogs/PlayerSettingsSheetHost.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/player/dialogs/PlayerSettingsSheetHost.kt
@@ -126,7 +126,7 @@ internal fun PlayerSettingsSheetHost(
             }.takeIf { uiState.localFilePath != null },
         onAutoplayToggle = { viewModel.toggleAutoplay(it) },
         onSkipSilenceToggle = { viewModel.toggleSkipSilence(it) },
-        onStableVolumeToggle = { viewModel.toggleStableVolume(it) },
+        onVolumeNormalizationToggle = { viewModel.toggleVolumeNormalization(it) },
         subtitleStyle = screenState.subtitleStyle,
         onSubtitleStyleChange = { style ->
             screenState.subtitleStyle = style
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/settings/index/PlaybackIndex.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/settings/index/PlaybackIndex.kt
index 7793855a31..a18be551f3 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/settings/index/PlaybackIndex.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/settings/index/PlaybackIndex.kt
@@ -172,6 +172,14 @@ internal object PlaybackIndex {
             section = R.string.player_appearance_gestures_header,
             destination = page,
         )
+    val normalizeVolume =
+        SettingEntry(
+            key = "playback.normalize_volume",
+            title = R.string.player_settings_normalize_volume,
+            summary = R.string.player_settings_normalize_volume_summary,
+            section = R.string.eq_settings_section,
+            destination = page,
+        )
     val volumeBoost =
         SettingEntry(
             key = "playback.volume_boost",
@@ -469,6 +477,14 @@ internal object PlaybackIndex {
             section = R.string.settings_section_music,
             destination = page,
         )
+    val musicResume =
+        SettingEntry(
+            key = "playback.music_resume",
+            title = R.string.settings_music_resume_title,
+            summary = R.string.settings_music_resume_summary,
+            section = R.string.settings_section_music,
+            destination = page,
+        )
     val musicVideoSwitch =
         SettingEntry(
             key = "playback.music_video_switch",
@@ -496,6 +512,7 @@ internal object PlaybackIndex {
             loopAll,
             skipSilence,
             playDuringCalls,
+            normalizeVolume,
             rememberSpeed,
             musicNormalSpeed,
             speedPerChannel,
@@ -545,6 +562,7 @@ internal object PlaybackIndex {
             shortsContinueIntoFeed,
             endlessRadio,
             pauseMusicWhenMuted,
+            musicResume,
             musicVideoSwitch,
             lyricsProviders,
         )
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/settings/playback/PlaybackSections.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/settings/playback/PlaybackSections.kt
index 1e82b157f9..d0bb8152ce 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/settings/playback/PlaybackSections.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/settings/playback/PlaybackSections.kt
@@ -7,6 +7,7 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import io.github.aedev.flow.R
 import io.github.aedev.flow.data.local.PlayerRelatedCardStyle
 import io.github.aedev.flow.data.local.SpeedSwipeSide
+import io.github.aedev.flow.ui.components.equalizer.equalizerSummary
 import io.github.aedev.flow.ui.components.settings.SettingsDestination
 import io.github.aedev.flow.ui.components.settings.SettingsListScope
 import io.github.aedev.flow.ui.components.settings.SettingsTarget
@@ -42,7 +43,12 @@ internal fun SettingsListScope.playbackSections(
         switch(PlaybackIndex.playDuringCalls, viewModel.playDuringCalls, viewModel::setPlayDuringCalls)
     }
     group(key = "playback.sound", header = R.string.eq_settings_section) {
-        nav(DestinationIndex.entry(SettingsDestination.EQUALIZER), onClick = { onNavigate(SettingsTarget(SettingsDestination.EQUALIZER)) })
+        nav(
+            DestinationIndex.entry(SettingsDestination.EQUALIZER),
+            onClick = { onNavigate(SettingsTarget(SettingsDestination.EQUALIZER)) },
+            valueText = { equalizerSummary() },
+        )
+        switch(PlaybackIndex.normalizeVolume, viewModel.normalizeVolume, viewModel::setNormalizeVolume)
     }
     group(key = "playback.speed", header = R.string.settings_section_speed) {
         switch(PlaybackIndex.rememberSpeed, viewModel.rememberSpeed, viewModel::setRememberSpeed)
@@ -134,6 +140,7 @@ internal fun SettingsListScope.playbackSections(
     group(key = "playback.music", header = R.string.settings_section_music) {
         switch(PlaybackIndex.endlessRadio, viewModel.endlessRadio, viewModel::setEndlessRadio)
         switch(PlaybackIndex.pauseMusicWhenMuted, viewModel.pauseMusicWhenMuted, viewModel::setPauseMusicWhenMuted)
+        switch(PlaybackIndex.musicResume, viewModel.musicResume, viewModel::setMusicResume)
         switch(PlaybackIndex.musicVideoSwitch, viewModel.musicVideoSwitch, viewModel::setMusicVideoSwitch)
         choice(PlaybackIndex.lyricsProviders, onClick = { openDialog(PlaybackDialog.LYRICS) }) {
             val providers by viewModel.lyricsProviders.collectAsStateWithLifecycle()
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/settings/playback/PlaybackSettingsViewModel.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/settings/playback/PlaybackSettingsViewModel.kt
index 6d452756e9..7217731856 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/settings/playback/PlaybackSettingsViewModel.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/settings/playback/PlaybackSettingsViewModel.kt
@@ -73,7 +73,7 @@ class PlaybackSettingsViewModel
         val sponsorBlockButton = preferences.overlaySponsorBlockEnabled.asState(overlay.sponsorBlockEnabled)
         val nextPrevButtons = preferences.overlayNextPrevEnabled.asState(overlay.nextPrevButtonsEnabled)
 
-        val autoPip = preferences.autoPipEnabled.asState(false)
+        val autoPip = preferences.autoPipEnabled.asState(true)
         val continueWatchingMiniPlayer = preferences.miniPlayerContinueWatchingEnabled.asState(true)
         val restoreMusicMiniPlayer = preferences.showRestoredMusicMiniPlayer.asState(true)
         val openMusicPlayerOnPlay = preferences.openMusicPlayerOnPlay.asState(false)
@@ -101,6 +101,8 @@ class PlaybackSettingsViewModel
         val endlessRadio = preferences.musicEndlessRadioEnabled.asState(true)
         val musicVideoSwitch = preferences.musicVideoSwitch.asState(false)
         val pauseMusicWhenMuted = preferences.pauseMusicWhenMuted.asState(false)
+        val musicResume = preferences.musicResumeLongTracks.asState(false)
+        val normalizeVolume = preferences.videoVolumeNormalizationEnabled.asState(true)
         val lyricsProviders =
             combine(preferences.lyricsProviderOrder, preferences.allLyricsProviderEnabledStates()) { order, enabled ->
                 LyricsProviderOrder.resolve(order).map { LyricsProviderState(it, enabled[it] ?: true) }
@@ -236,6 +238,10 @@ class PlaybackSettingsViewModel
 
         fun setPauseMusicWhenMuted(value: Boolean) = write { preferences.setPauseMusicWhenMuted(value) }
 
+        fun setMusicResume(value: Boolean) = write { preferences.setMusicResumeLongTracks(value) }
+
+        fun setNormalizeVolume(value: Boolean) = write { preferences.setVideoVolumeNormalizationEnabled(value) }
+
         fun setLyricsProviderEnabled(
             name: String,
             enabled: Boolean,
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/shorts/ShortsPagerEffects.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/shorts/ShortsPagerEffects.kt
index ff2d52c915..060bdf1aaa 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/shorts/ShortsPagerEffects.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/shorts/ShortsPagerEffects.kt
@@ -132,6 +132,7 @@ private suspend fun prepareReel(
             shouldPlay = shouldPlay,
             videoDashManifest = streams.videoDashManifest,
             audioDashManifest = streams.audioDashManifest,
+            loudnessGainDb = streams.loudnessGainDb,
         )
     } catch (e: Exception) {
         Log.e(TAG, "Failed to prepare player for ${short.id}", e)
diff --git a/app/src/main/java/io/github/aedev/flow/utils/MusicPlayerUtils.kt b/app/src/main/java/io/github/aedev/flow/utils/MusicPlayerUtils.kt
index 9471e680ef..06846d941e 100644
--- a/app/src/main/java/io/github/aedev/flow/utils/MusicPlayerUtils.kt
+++ b/app/src/main/java/io/github/aedev/flow/utils/MusicPlayerUtils.kt
@@ -6,6 +6,7 @@ import io.github.aedev.flow.data.local.MusicAudioQuality
 import io.github.aedev.flow.data.local.PlayerPreferences
 import io.github.aedev.flow.innertube.models.YouTubeClient
 import io.github.aedev.flow.innertube.models.response.PlayerResponse
+import io.github.aedev.flow.player.audio.LoudnessGain
 import io.github.aedev.flow.player.error.PlayerDiagnostics
 import io.github.aedev.flow.player.error.StreamDenialClassifier
 import io.github.aedev.flow.player.stream.AudioStreamSelector
@@ -40,8 +41,6 @@ object MusicPlayerUtils {
 
     private val resultCache = ConcurrentHashMap<String, CachedResult>()
     private const val MAX_RESULT_CACHE_TTL_MS = 600_000L // 10 minutes
-    private const val LOUDNESS_TARGET_LKFS = -14.0
-    private const val MIN_LOUDNESS_GAIN_DB = -20f
 
     // Matches the video player's load budget. The ladder can reach TV_TIZEN, whose remote decoder
     // calls and pre-roll wait have no bound of their own, and an unbounded resolve is a spinner
@@ -88,13 +87,7 @@ object MusicPlayerUtils {
 
     fun cachedLoudnessGainDb(videoId: String): Float? {
         val data = resultCache[videoId]?.result?.getOrNull() ?: return null
-        val audioConfig = data.audioConfig
-        val gainDb =
-            audioConfig?.perceptualLoudnessDb?.let { (audioConfig.loudnessTargetLkfs ?: LOUDNESS_TARGET_LKFS) - it }
-                ?: audioConfig?.loudnessDb?.let { -it }
-                ?: data.format.loudnessDb?.let { -it }
-                ?: return null
-        return gainDb.toFloat().coerceIn(MIN_LOUDNESS_GAIN_DB, 0f)
+        return LoudnessGain.gainDb(data.audioConfig, data.format.loudnessDb)
     }
 
     /** The resolved playback of [videoId] while it is still fresh, without waiting on a request. */
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index 002a753ef3..083a9d43e8 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -659,6 +659,8 @@
     <string name="notifications_group_last_week">Last 7 days</string>
     <string name="notifications_meta">%1$s · %2$s</string>
     <string name="notifications_removed">Notification removed</string>
+    <string name="notifications_already_in_watch_later">Already in Watch Later</string>
+    <string name="notifications_save_to_watch_later">Save to Watch Later</string>
     <string name="notifications_open_settings">Notification settings</string>
     <string name="notifications_clear_title">Clear all notifications?</string>
     <plurals name="notifications_clear_body">
@@ -1327,8 +1329,8 @@
     <string name="speed_slider_apply">Apply</string>
     <string name="playback_speed_multiplier">%1$s×</string>
     <string name="playback_speed_multiplier_precise">%1$.2f×</string>
-    <string name="player_settings_stable_voice">Stable Voice</string>
-    <string name="player_settings_stable_voice_subtitle">Normalize audio volume for consistent playback</string>
+    <string name="player_settings_normalize_volume">Normalize volume</string>
+    <string name="player_settings_normalize_volume_summary">Turn loud videos down to YouTube\'s level</string>
     <string name="player_settings_display">Display</string>
     <string name="player_settings_ambient_mode">Ambient mode</string>
     <string name="player_settings_ambient_mode_subtitle">A soft glow of the video\'s colors around it</string>
@@ -2147,6 +2149,8 @@
     <string name="music_watch_video">Watch video</string>
     <string name="settings_pause_music_muted_title">Pause music when muted</string>
     <string name="settings_pause_music_muted_summary">Resume when the volume comes back</string>
+    <string name="settings_music_resume_title">Resume podcasts and long tracks</string>
+    <string name="settings_music_resume_summary">Start tracks over 10 minutes where you left off</string>
     <string name="music_watch_video_desc">Open the music video in the video player</string>
     <string name="player_appearance_animated_artwork_title">Animated artwork</string>
     <string name="player_appearance_animated_artwork_subtitle">Loop an album\'s motion artwork when it has one</string>
@@ -2249,7 +2253,6 @@
     <string name="template_bass_boost">Bass Boost: %1$ddB</string>
     <string name="label_tempo_pitch">Tempo &amp; Pitch</string>
     <string name="action_reset">Reset</string>
-    <string name="template_speed">Speed: %1$d%%</string>
     <string name="template_pitch">Pitch: %1$d Semitones</string>
     <string name="label_parametric_equalizer">Parametric Equalizer</string>
     <string name="action_add_band">Add Band</string>
diff --git a/app/src/test/java/io/github/aedev/flow/data/shorts/ShortsStreamResolverTest.kt b/app/src/test/java/io/github/aedev/flow/data/shorts/ShortsStreamResolverTest.kt
index c642fa3e2b..5d4ee714bc 100644
--- a/app/src/test/java/io/github/aedev/flow/data/shorts/ShortsStreamResolverTest.kt
+++ b/app/src/test/java/io/github/aedev/flow/data/shorts/ShortsStreamResolverTest.kt
@@ -1,6 +1,7 @@
 package io.github.aedev.flow.data.shorts
 
 import io.github.aedev.flow.data.local.PlayerPreferences
+import io.github.aedev.flow.innertube.models.response.PlayerResponse
 import io.github.aedev.flow.player.stream.InnerTubeVideoStreamExtractor.VideoExtractionResult
 import io.mockk.every
 import io.mockk.mockk
@@ -87,6 +88,24 @@ class ShortsStreamResolverTest {
             assertNotNull(streams.audioDashManifest)
         }
 
+    @Test
+    fun `a loud reel carries the gain that turns it down to YouTube's level`() =
+        runBlocking {
+            result =
+                reelExtraction(
+                    videoFormats = result!!.videoFormats,
+                    audioFormats = result!!.audioFormats,
+                    playerConfig =
+                        PlayerResponse.PlayerConfig(
+                            audioConfig = PlayerResponse.PlayerConfig.AudioConfig(loudnessDb = 6.0, perceptualLoudnessDb = null),
+                        ),
+                )
+
+            val streams = resolver.resolve("reel1234567", targetHeight = 720, preferredAudioLanguage = "")
+
+            assertEquals(-6f, streams!!.loudnessGainDb)
+        }
+
     @Test
     fun `one extraction serves playback, the quality sheet, the audio sheet and the download dialog`() =
         runBlocking {
diff --git a/app/src/test/java/io/github/aedev/flow/data/shorts/ShortsTestFormats.kt b/app/src/test/java/io/github/aedev/flow/data/shorts/ShortsTestFormats.kt
index bdca4cfc00..c492f78b08 100644
--- a/app/src/test/java/io/github/aedev/flow/data/shorts/ShortsTestFormats.kt
+++ b/app/src/test/java/io/github/aedev/flow/data/shorts/ShortsTestFormats.kt
@@ -83,6 +83,7 @@ internal fun reelExtraction(
     videoId: String = "reel1234567",
     expiresInSeconds: Int = 21_540,
     lengthSeconds: String = "28",
+    playerConfig: PlayerResponse.PlayerConfig? = null,
 ): VideoExtractionResult =
     VideoExtractionResult(
         videoFormats = videoFormats,
@@ -91,7 +92,7 @@ internal fun reelExtraction(
             PlayerResponse(
                 responseContext = ResponseContext(visitorData = null, serviceTrackingParams = null),
                 playabilityStatus = PlayerResponse.PlayabilityStatus(status = "OK", reason = null),
-                playerConfig = null,
+                playerConfig = playerConfig,
                 streamingData =
                     PlayerResponse.StreamingData(
                         adaptiveFormats = videoFormats + audioFormats,
diff --git a/app/src/test/java/io/github/aedev/flow/player/MusicResumePolicyTest.kt b/app/src/test/java/io/github/aedev/flow/player/MusicResumePolicyTest.kt
new file mode 100644
index 0000000000..19b51dded2
--- /dev/null
+++ b/app/src/test/java/io/github/aedev/flow/player/MusicResumePolicyTest.kt
@@ -0,0 +1,34 @@
+package io.github.aedev.flow.player
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+
+class MusicResumePolicyTest {
+    private val episode = 45 * 60_000L
+
+    @Test
+    fun `a long track resumes where it stopped`() {
+        assertThat(MusicResumePolicy.startPosition(savedPosition = 23 * 60_000L, durationMs = episode)).isEqualTo(23 * 60_000L)
+    }
+
+    @Test
+    fun `a song always starts over`() {
+        assertThat(MusicResumePolicy.startPosition(savedPosition = 90_000L, durationMs = 4 * 60_000L)).isEqualTo(0L)
+    }
+
+    @Test
+    fun `ten minutes is long enough`() {
+        assertThat(MusicResumePolicy.isLongTrack(10 * 60_000L)).isTrue()
+        assertThat(MusicResumePolicy.isLongTrack(10 * 60_000L - 1)).isFalse()
+    }
+
+    @Test
+    fun `a finished track starts over`() {
+        assertThat(MusicResumePolicy.startPosition(savedPosition = episode, durationMs = episode)).isEqualTo(0L)
+    }
+
+    @Test
+    fun `an unknown length never resumes`() {
+        assertThat(MusicResumePolicy.startPosition(savedPosition = 60_000L, durationMs = 0L)).isEqualTo(0L)
+    }
+}
diff --git a/app/src/test/java/io/github/aedev/flow/player/audio/LoudnessGainTest.kt b/app/src/test/java/io/github/aedev/flow/player/audio/LoudnessGainTest.kt
new file mode 100644
index 0000000000..9b86445fd3
--- /dev/null
+++ b/app/src/test/java/io/github/aedev/flow/player/audio/LoudnessGainTest.kt
@@ -0,0 +1,42 @@
+package io.github.aedev.flow.player.audio
+
+import com.google.common.truth.Truth.assertThat
+import io.github.aedev.flow.innertube.models.response.PlayerResponse
+import org.junit.Test
+
+class LoudnessGainTest {
+    private fun config(
+        loudnessDb: Double? = null,
+        perceptual: Double? = null,
+        target: Double? = null,
+    ) = PlayerResponse.PlayerConfig.AudioConfig(loudnessDb = loudnessDb, perceptualLoudnessDb = perceptual, loudnessTargetLkfs = target)
+
+    @Test
+    fun `perceptual loudness is measured against the target`() {
+        assertThat(LoudnessGain.gainDb(config(loudnessDb = 9.0, perceptual = -8.0), null)).isEqualTo(-6f)
+        assertThat(LoudnessGain.gainDb(config(perceptual = -10.0, target = -16.0), null)).isEqualTo(-6f)
+    }
+
+    @Test
+    fun `loudnessDb is next, then the format's own value`() {
+        assertThat(LoudnessGain.gainDb(config(loudnessDb = 4.5), 9.0)).isEqualTo(-4.5f)
+        assertThat(LoudnessGain.gainDb(null, 3.0)).isEqualTo(-3f)
+    }
+
+    @Test
+    fun `quiet tracks are never boosted and loud ones stop at minus 20 dB`() {
+        assertThat(LoudnessGain.gainDb(config(loudnessDb = -7.0), null)).isEqualTo(0f)
+        assertThat(LoudnessGain.gainDb(config(loudnessDb = 35.0), null)).isEqualTo(-20f)
+    }
+
+    @Test
+    fun `no metadata means no gain`() {
+        assertThat(LoudnessGain.gainDb(null, null)).isNull()
+        assertThat(LoudnessGain.volume(null)).isEqualTo(1f)
+    }
+
+    @Test
+    fun `minus 6 dB is about half the amplitude`() {
+        assertThat(LoudnessGain.volume(-6f).toDouble()).isWithin(0.01).of(0.501)
+    }
+}
diff --git a/app/src/test/java/io/github/aedev/flow/player/shorts/ShortsPreferenceObserversTest.kt b/app/src/test/java/io/github/aedev/flow/player/shorts/ShortsPreferenceObserversTest.kt
index 065e312c5b..bc2eec935a 100644
--- a/app/src/test/java/io/github/aedev/flow/player/shorts/ShortsPreferenceObserversTest.kt
+++ b/app/src/test/java/io/github/aedev/flow/player/shorts/ShortsPreferenceObserversTest.kt
@@ -13,66 +13,92 @@ import org.junit.Test
 @OptIn(ExperimentalCoroutinesApi::class)
 class ShortsPreferenceObserversTest {
     @Test
-    fun restartAndStopKeepOnlyCurrentCollectorsActive() = runTest {
-        val firstLanguage = MutableStateFlow("original")
-        val firstMode = MutableStateFlow("loop")
-        val firstSpeed = MutableStateFlow(1f)
-        val secondLanguage = MutableStateFlow("en")
-        val secondMode = MutableStateFlow("swipe")
-        val secondSpeed = MutableStateFlow(1.25f)
-        val languages = mutableListOf<String>()
-        val modes = mutableListOf<String>()
-        val speeds = mutableListOf<Float>()
-        val observers = ShortsPreferenceObservers(
-            dispatcher = StandardTestDispatcher(testScheduler),
-        )
+    fun restartAndStopKeepOnlyCurrentCollectorsActive() =
+        runTest {
+            val firstLanguage = MutableStateFlow("original")
+            val firstMode = MutableStateFlow("loop")
+            val firstSpeed = MutableStateFlow(1f)
+            val secondLanguage = MutableStateFlow("en")
+            val secondMode = MutableStateFlow("swipe")
+            val secondSpeed = MutableStateFlow(1.25f)
+            val languages = mutableListOf<String>()
+            val modes = mutableListOf<String>()
+            val speeds = mutableListOf<Float>()
+            val observers =
+                ShortsPreferenceObservers(
+                    dispatcher = StandardTestDispatcher(testScheduler),
+                )
 
-        observers.start(
-            preferredAudioLanguage = firstLanguage,
-            playbackMode = firstMode,
-            playbackSpeed = firstSpeed,
-            onPreferredAudioLanguage = languages::add,
-            onPlaybackMode = modes::add,
-            onPlaybackSpeed = speeds::add,
-        )
-        runCurrent()
+            observers.start(
+                preferredAudioLanguage = firstLanguage,
+                playbackMode = firstMode,
+                playbackSpeed = firstSpeed,
+                onPreferredAudioLanguage = languages::add,
+                onPlaybackMode = modes::add,
+                onPlaybackSpeed = speeds::add,
+            )
+            runCurrent()
 
-        assertTrue(observers.isRunning)
-        assertEquals(listOf("original"), languages)
-        assertEquals(listOf("loop"), modes)
-        assertEquals(listOf(1f), speeds)
+            assertTrue(observers.isRunning)
+            assertEquals(listOf("original"), languages)
+            assertEquals(listOf("loop"), modes)
+            assertEquals(listOf(1f), speeds)
 
-        observers.start(
-            preferredAudioLanguage = secondLanguage,
-            playbackMode = secondMode,
-            playbackSpeed = secondSpeed,
-            onPreferredAudioLanguage = languages::add,
-            onPlaybackMode = modes::add,
-            onPlaybackSpeed = speeds::add,
-        )
-        runCurrent()
+            observers.start(
+                preferredAudioLanguage = secondLanguage,
+                playbackMode = secondMode,
+                playbackSpeed = secondSpeed,
+                onPreferredAudioLanguage = languages::add,
+                onPlaybackMode = modes::add,
+                onPlaybackSpeed = speeds::add,
+            )
+            runCurrent()
 
-        firstLanguage.value = "fr"
-        firstMode.value = "auto"
-        firstSpeed.value = 2f
-        secondLanguage.value = "de"
-        secondMode.value = "loop"
-        secondSpeed.value = 1.5f
-        runCurrent()
+            firstLanguage.value = "fr"
+            firstMode.value = "auto"
+            firstSpeed.value = 2f
+            secondLanguage.value = "de"
+            secondMode.value = "loop"
+            secondSpeed.value = 1.5f
+            runCurrent()
 
-        assertEquals(listOf("original", "en", "de"), languages)
-        assertEquals(listOf("loop", "swipe", "loop"), modes)
-        assertEquals(listOf(1f, 1.25f, 1.5f), speeds)
+            assertEquals(listOf("original", "en", "de"), languages)
+            assertEquals(listOf("loop", "swipe", "loop"), modes)
+            assertEquals(listOf(1f, 1.25f, 1.5f), speeds)
 
-        observers.stop()
-        secondLanguage.value = "es"
-        secondMode.value = "auto"
-        secondSpeed.value = 0.75f
-        runCurrent()
+            observers.stop()
+            secondLanguage.value = "es"
+            secondMode.value = "auto"
+            secondSpeed.value = 0.75f
+            runCurrent()
 
-        assertFalse(observers.isRunning)
-        assertEquals(listOf("original", "en", "de"), languages)
-        assertEquals(listOf("loop", "swipe", "loop"), modes)
-        assertEquals(listOf(1f, 1.25f, 1.5f), speeds)
-    }
+            assertFalse(observers.isRunning)
+            assertEquals(listOf("original", "en", "de"), languages)
+            assertEquals(listOf("loop", "swipe", "loop"), modes)
+            assertEquals(listOf(1f, 1.25f, 1.5f), speeds)
+        }
+
+    @Test
+    fun normalizationFollowsItsSwitch() =
+        runTest {
+            val normalize = MutableStateFlow(true)
+            val seen = mutableListOf<Boolean>()
+            val observers = ShortsPreferenceObservers(dispatcher = StandardTestDispatcher(testScheduler))
+
+            observers.start(
+                preferredAudioLanguage = MutableStateFlow("original"),
+                playbackMode = MutableStateFlow("loop"),
+                playbackSpeed = MutableStateFlow(1f),
+                onPreferredAudioLanguage = {},
+                onPlaybackMode = {},
+                onPlaybackSpeed = {},
+                volumeNormalization = normalize,
+                onVolumeNormalization = seen::add,
+            )
+            runCurrent()
+            normalize.value = false
+            runCurrent()
+
+            assertEquals(listOf(true, false), seen)
+        }
 }
diff --git a/app/src/test/java/io/github/aedev/flow/player/shorts/ShortsSlotsTest.kt b/app/src/test/java/io/github/aedev/flow/player/shorts/ShortsSlotsTest.kt
new file mode 100644
index 0000000000..1f550578c3
--- /dev/null
+++ b/app/src/test/java/io/github/aedev/flow/player/shorts/ShortsSlotsTest.kt
@@ -0,0 +1,30 @@
+package io.github.aedev.flow.player.shorts
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+
+class ShortsSlotsTest {
+    private val slots = ShortsSlots(size = 3)
+
+    @Test
+    fun `a slot is owned only by the index and id it was assigned`() {
+        slots.assign(1, index = 4, videoId = "a", videoUrl = "v", audioUrl = "x", videoManifest = null, audioManifest = "m")
+
+        assertThat(slots.owns(1, index = 4, videoId = "a")).isTrue()
+        assertThat(slots.owns(1, index = 7, videoId = "a")).isFalse()
+        assertThat(slots.owns(1, index = 4, videoId = "b")).isFalse()
+        assertThat(slots.audioManifests[1]).isEqualTo("m")
+    }
+
+    @Test
+    fun `clearing a slot forgets everything it held`() {
+        slots.assign(2, index = 5, videoId = "a", videoUrl = "v", audioUrl = "x", videoManifest = "vm", audioManifest = "am")
+
+        slots.clear(2)
+
+        assertThat(slots.owns(2, index = 5, videoId = "a")).isFalse()
+        assertThat(
+            listOf(slots.videoUrls[2], slots.audioUrls[2], slots.videoManifests[2], slots.audioManifests[2]),
+        ).containsExactly(null, null, null, null)
+    }
+}
diff --git a/app/src/test/java/io/github/aedev/flow/ui/components/videoplayer/settings/PlayerSettingsSheetTest.kt b/app/src/test/java/io/github/aedev/flow/ui/components/videoplayer/settings/PlayerSettingsSheetTest.kt
index 7f22a8cf1a..0ae52eaeb6 100644
--- a/app/src/test/java/io/github/aedev/flow/ui/components/videoplayer/settings/PlayerSettingsSheetTest.kt
+++ b/app/src/test/java/io/github/aedev/flow/ui/components/videoplayer/settings/PlayerSettingsSheetTest.kt
@@ -83,7 +83,7 @@ class PlayerSettingsSheetTest {
                     onDisableSubtitles = { callbacks.subtitlesDisabled = true },
                     onAutoplayToggle = {},
                     onSkipSilenceToggle = {},
-                    onStableVolumeToggle = {},
+                    onVolumeNormalizationToggle = {},
                     subtitleStyle = SubtitleStyle(),
                     onSubtitleStyleChange = {},
                     onLoopToggle = {},
@@ -120,7 +120,7 @@ class PlayerSettingsSheetTest {
             R.string.audio_effects,
             R.string.equalizer,
             R.string.player_settings_skip_silence,
-            R.string.player_settings_stable_voice,
+            R.string.player_settings_normalize_volume,
             R.string.player_settings_display,
             R.string.player_settings_ambient_mode,
         ).forEach { id -> rule.onNodeWithText(string(id)).assertExists() }
diff --git a/app/src/test/java/io/github/aedev/flow/ui/screens/music/MusicSeekGuardTest.kt b/app/src/test/java/io/github/aedev/flow/ui/screens/music/MusicSeekGuardTest.kt
new file mode 100644
index 0000000000..098bdbcd6c
--- /dev/null
+++ b/app/src/test/java/io/github/aedev/flow/ui/screens/music/MusicSeekGuardTest.kt
@@ -0,0 +1,39 @@
+package io.github.aedev.flow.ui.screens.music
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+
+class MusicSeekGuardTest {
+    private var clock = 0L
+    private val guard = MusicSeekGuard(now = { clock })
+
+    @Test
+    fun `reports pass straight through when nothing was sought`() {
+        assertThat(guard.accept(42_000L)).isEqualTo(42_000L)
+    }
+
+    @Test
+    fun `a stale report before the seek lands is held back`() {
+        guard.seekRequested(60_000L)
+        clock = 100L
+
+        assertThat(guard.accept(5_000L)).isNull()
+    }
+
+    @Test
+    fun `the guard releases once the player reaches the target and the hold has passed`() {
+        guard.seekRequested(60_000L)
+        clock = 300L
+
+        assertThat(guard.accept(60_400L)).isEqualTo(60_400L)
+        assertThat(guard.accept(5_000L)).isEqualTo(5_000L)
+    }
+
+    @Test
+    fun `a seek that never lands stops holding after the guard time`() {
+        guard.seekRequested(60_000L)
+        clock = 1_500L
+
+        assertThat(guard.accept(5_000L)).isEqualTo(5_000L)
+    }
+}
diff --git a/app/src/test/java/io/github/aedev/flow/ui/screens/notifications/NotificationViewModelTest.kt b/app/src/test/java/io/github/aedev/flow/ui/screens/notifications/NotificationViewModelTest.kt
index 344f9afd3d..08d01465f5 100644
--- a/app/src/test/java/io/github/aedev/flow/ui/screens/notifications/NotificationViewModelTest.kt
+++ b/app/src/test/java/io/github/aedev/flow/ui/screens/notifications/NotificationViewModelTest.kt
@@ -1,8 +1,13 @@
 package io.github.aedev.flow.ui.screens.notifications
 
 import com.google.common.truth.Truth.assertThat
+import dagger.Lazy
+import io.github.aedev.flow.data.engagement.VideoFeedbackUseCase
 import io.github.aedev.flow.data.local.NotificationRepository
 import io.github.aedev.flow.data.local.entity.NotificationEntity
+import io.github.aedev.flow.data.model.Video
+import io.github.aedev.flow.data.subscriptions.SubscriptionFeedRepository
+import io.mockk.coEvery
 import io.mockk.coVerify
 import io.mockk.every
 import io.mockk.mockk
@@ -21,6 +26,8 @@ class NotificationViewModelTest {
     private val unread = NotificationEntity(id = 1, videoId = "a", title = "a", channelName = "c", thumbnailUrl = null, isRead = false)
     private val read = NotificationEntity(id = 2, videoId = "b", title = "b", channelName = "c", thumbnailUrl = null, isRead = true)
     private val repository: NotificationRepository = mockk(relaxed = true)
+    private val feed: SubscriptionFeedRepository = mockk()
+    private val feedback: VideoFeedbackUseCase = mockk(relaxed = true)
 
     @Before
     fun setUp() {
@@ -34,7 +41,7 @@ class NotificationViewModelTest {
 
     @Test
     fun `opening the inbox keeps what was unread as new and clears the badge once`() {
-        val viewModel = NotificationViewModel(repository)
+        val viewModel = viewModel()
 
         viewModel.openInbox()
         viewModel.openInbox()
@@ -45,14 +52,14 @@ class NotificationViewModelTest {
 
     @Test
     fun `the badge instance never marks anything read`() {
-        NotificationViewModel(repository)
+        viewModel()
 
         coVerify(exactly = 0) { repository.markAllAsRead() }
     }
 
     @Test
     fun `undo puts the removed notification back as read`() {
-        val viewModel = NotificationViewModel(repository)
+        val viewModel = viewModel()
 
         viewModel.deleteNotification(unread)
         viewModel.undoDelete()
@@ -61,4 +68,47 @@ class NotificationViewModelTest {
         coVerify(exactly = 1) { repository.deleteNotification(unread) }
         coVerify(exactly = 1) { repository.insertNotification(unread.copy(isRead = true)) }
     }
+
+    @Test
+    fun `saving uses the feed's copy of the video and undo takes it out again`() {
+        val cached =
+            Video(
+                id = "a",
+                title = "a",
+                channelName = "c",
+                channelId = "UCc",
+                thumbnailUrl = "",
+                duration = 600,
+                viewCount = 9,
+                uploadDate = "",
+            )
+        coEvery { feed.cachedVideo("a") } returns cached
+        coEvery { feedback.saveToWatchLater(cached) } returns true
+        val results = mutableListOf<Boolean>()
+        val viewModel = viewModel()
+
+        viewModel.saveToWatchLater(unread) { results += it }
+        viewModel.undoSave()
+        viewModel.undoSave()
+
+        assertThat(results).containsExactly(true)
+        coVerify(exactly = 1) { feedback.setWatchLater(cached, saved = false) }
+    }
+
+    @Test
+    fun `a video already in Watch later is reported and never taken out by undo`() {
+        coEvery { feed.cachedVideo("b") } returns null
+        coEvery { feedback.saveToWatchLater(any()) } returns false
+        val results = mutableListOf<Boolean>()
+        val viewModel = viewModel()
+
+        viewModel.saveToWatchLater(read) { results += it }
+        viewModel.undoSave()
+
+        assertThat(results).containsExactly(false)
+        coVerify { feedback.saveToWatchLater(match { it.id == "b" && it.title == "b" && it.channelName == "c" }) }
+        coVerify(exactly = 0) { feedback.setWatchLater(any(), any()) }
+    }
+
+    private fun viewModel() = NotificationViewModel(repository, Lazy { feed }, Lazy { feedback })
 }
diff --git a/app/src/test/java/io/github/aedev/flow/ui/screens/player/VideoPlayerViewModelEntryPointsTest.kt b/app/src/test/java/io/github/aedev/flow/ui/screens/player/VideoPlayerViewModelEntryPointsTest.kt
index 07c8a8acc0..bd4acd6a0a 100644
--- a/app/src/test/java/io/github/aedev/flow/ui/screens/player/VideoPlayerViewModelEntryPointsTest.kt
+++ b/app/src/test/java/io/github/aedev/flow/ui/screens/player/VideoPlayerViewModelEntryPointsTest.kt
@@ -393,19 +393,19 @@ class VideoPlayerViewModelEntryPointsTest {
         }
 
     @Test
-    fun `toggleSkipSilence and toggleStableVolume delegate to the player without touching ui state`() =
+    fun `toggleSkipSilence and toggleVolumeNormalization delegate to the player without touching ui state`() =
         runTest {
             val viewModel = newViewModel()
             val before = viewModel.uiState.value
 
             viewModel.toggleSkipSilence(true)
-            viewModel.toggleStableVolume(true)
+            viewModel.toggleVolumeNormalization(true)
             viewModel.toggleSkipSilence(false)
             advanceUntilIdle()
 
             verifyOrder {
                 harness.playerManager.toggleSkipSilence(true)
-                harness.playerManager.toggleStableVolume(true)
+                harness.playerManager.toggleVolumeNormalization(true)
                 harness.playerManager.toggleSkipSilence(false)
             }
             assertThat(viewModel.uiState.value).isEqualTo(before)