diff --git a/.github/nightly-notes/2026-10-21-fix-datastore-statusbar-eq-playlists-botwall.md b/.github/nightly-notes/2026-10-21-fix-datastore-statusbar-eq-playlists-botwall.md
new file mode 100644
index 0000000000..01c153a202
--- /dev/null
+++ b/.github/nightly-notes/2026-10-21-fix-datastore-statusbar-eq-playlists-botwall.md
@@ -0,0 +1,12 @@
+## New
+- Playlists say when YouTube hides unavailable videos (#1358)
+- The "not a bot" error can reset the YouTube session in one tap (#1354)
+
+## Fixed
+- Flow no longer crashes on first launch while it creates its settings (#1355) (#1362)
+- The crash screen shows a report once instead of on every launch (#1355)
+- Status bar icons stay readable over the open video player in light theme (#1375)
+- The system equalizer now changes how Flow sounds (#1373)
+- Playlists made only of Shorts load again (#1358)
+- A playlist that stops loading partway no longer shortens your saved copy (#1358)
+- When every YouTube client asks to confirm you're not a bot, Flow retries once with a fresh session (#1354)
diff --git a/AGENTS.md b/AGENTS.md
index e5d34a48ea..5da916beb5 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -93,7 +93,7 @@ Before writing any component, effect, animation, formatter, parser, scheduler, o
 | Paging | Paging 3 (`androidx.paging`, already used by search and channel) | New hand-rolled page cursors |
 | Playback | Media3 1.11.0 — exoplayer, hls, dash, session, datasource-okhttp | Custom player wiring, manifest handling, or media notifications |
 | Background work | WorkManager 2.11.2 | Custom threads, timers, alarms, or wakelocks |
-| Persistence | Room 2.8.4, DataStore Preferences 1.1.1 | Hand-rolled file or SharedPreferences layers |
+| Persistence | Room 2.8.4, DataStore Preferences 1.1.7 | Hand-rolled file or SharedPreferences layers |
 | JSON | `kotlinx.serialization` (103 files) | Gson for new code — it is kept only for legacy DTOs and carries an R8 reflection hazard |
 | HTTP | OkHttp 5.4.0 / Ktor 3.5.2 | Raw sockets or `HttpURLConnection` |
 | Dates and times | `java.time` — **core library desugaring is enabled, minSdk 26**, so all of it is available | `SimpleDateFormat`, `Calendar`, or manual millisecond arithmetic |
diff --git a/app/src/main/java/io/github/aedev/flow/MainActivity.kt b/app/src/main/java/io/github/aedev/flow/MainActivity.kt
index 41bac3b6ca..62f3b93014 100644
--- a/app/src/main/java/io/github/aedev/flow/MainActivity.kt
+++ b/app/src/main/java/io/github/aedev/flow/MainActivity.kt
@@ -231,9 +231,14 @@ class MainActivity : ComponentActivity() {
             SideEffect { cachedAppUiRoot = appUiRoot }
 
             // Check for a crash that happened last session.
-            // If found, show the CrashReportScreen instead of the normal UI.
+            // If found, show the CrashReportScreen instead of the normal UI. It is cleared as soon
+            // as it is read, so leaving the screen any way shows it once, not on every launch.
             var pendingCrashLog by remember {
-                mutableStateOf(FlowCrashHandler.getLastCrash(applicationContext))
+                mutableStateOf(
+                    FlowCrashHandler.getLastCrash(applicationContext)?.also {
+                        FlowCrashHandler.clearLastCrash(applicationContext)
+                    },
+                )
             }
 
             if (pendingCrashLog != null) {
@@ -241,10 +246,7 @@ class MainActivity : ComponentActivity() {
                 FlowTheme(theme.copy(fontFamily = FlowFontFamily)) {
                     CrashReportScreen(
                         report = pendingCrashLog!!,
-                        onContinue = {
-                            FlowCrashHandler.clearLastCrash(applicationContext)
-                            pendingCrashLog = null
-                        },
+                        onContinue = { pendingCrashLog = null },
                     )
                 }
                 return@setContent
diff --git a/app/src/main/java/io/github/aedev/flow/data/local/SafeDataStore.kt b/app/src/main/java/io/github/aedev/flow/data/local/SafeDataStore.kt
index b91312dac0..68dd470972 100644
--- a/app/src/main/java/io/github/aedev/flow/data/local/SafeDataStore.kt
+++ b/app/src/main/java/io/github/aedev/flow/data/local/SafeDataStore.kt
@@ -7,15 +7,58 @@ import androidx.datastore.core.handlers.ReplaceFileCorruptionHandler
 import androidx.datastore.preferences.core.Preferences
 import androidx.datastore.preferences.core.emptyPreferences
 import androidx.datastore.preferences.preferencesDataStore
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.retryWhen
+import java.io.IOException
 import kotlin.properties.ReadOnlyProperty
+import kotlin.reflect.KProperty
 
 private const val SAFE_DATA_STORE_TAG = "SafeDataStore"
+private const val READ_RETRY_ATTEMPTS = 3
+private const val READ_RETRY_DELAY_MS = 100L
 
-fun safePreferencesDataStore(name: String): ReadOnlyProperty<Context, DataStore<Preferences>> =
-    preferencesDataStore(
-        name = name,
-        corruptionHandler = ReplaceFileCorruptionHandler { corruption ->
-            Log.w(SAFE_DATA_STORE_TAG, "Resetting corrupted preferences DataStore: $name", corruption)
-            emptyPreferences()
-        }
-    )
+fun safePreferencesDataStore(name: String): ReadOnlyProperty<Context, DataStore<Preferences>> {
+    val delegate =
+        preferencesDataStore(
+            name = name,
+            corruptionHandler =
+                ReplaceFileCorruptionHandler { corruption ->
+                    Log.w(SAFE_DATA_STORE_TAG, "Resetting corrupted preferences DataStore: $name", corruption)
+                    emptyPreferences()
+                },
+        )
+    var wrapped: DataStore<Preferences>? = null
+    return object : ReadOnlyProperty<Context, DataStore<Preferences>> {
+        override fun getValue(
+            thisRef: Context,
+            property: KProperty<*>,
+        ): DataStore<Preferences> =
+            wrapped ?: synchronized(this) {
+                wrapped ?: ReadSafeDataStore(name, delegate.getValue(thisRef, property)).also { wrapped = it }
+            }
+    }
+}
+
+internal class ReadSafeDataStore(
+    private val name: String,
+    private val delegate: DataStore<Preferences>,
+    private val retryDelayMs: Long = READ_RETRY_DELAY_MS,
+) : DataStore<Preferences> {
+    // A failed read must not crash the collector. Retrying first keeps observers subscribed to
+    // later writes; only a read that keeps failing falls back to defaults and ends the stream.
+    override val data: Flow<Preferences> =
+        delegate.data
+            .retryWhen { cause, attempt ->
+                val retry = cause is IOException && attempt < READ_RETRY_ATTEMPTS
+                if (retry) delay(retryDelayMs * (attempt + 1))
+                retry
+            }.catch { cause ->
+                if (cause !is IOException) throw cause
+                Log.w(SAFE_DATA_STORE_TAG, "Reading preferences DataStore failed, using defaults: $name", cause)
+                emit(emptyPreferences())
+            }
+
+    override suspend fun updateData(transform: suspend (t: Preferences) -> Preferences): Preferences = delegate.updateData(transform)
+}
diff --git a/app/src/main/java/io/github/aedev/flow/data/music/artwork/AnimatedArtworkCache.kt b/app/src/main/java/io/github/aedev/flow/data/music/artwork/AnimatedArtworkCache.kt
index 6d70eaf29a..f0d74a50ea 100644
--- a/app/src/main/java/io/github/aedev/flow/data/music/artwork/AnimatedArtworkCache.kt
+++ b/app/src/main/java/io/github/aedev/flow/data/music/artwork/AnimatedArtworkCache.kt
@@ -3,7 +3,7 @@ package io.github.aedev.flow.data.music.artwork
 import android.content.Context
 import androidx.datastore.preferences.core.edit
 import androidx.datastore.preferences.core.stringPreferencesKey
-import androidx.datastore.preferences.preferencesDataStore
+import io.github.aedev.flow.data.local.safePreferencesDataStore
 import kotlinx.coroutines.flow.first
 
 /** A lookup answered before: the loop, or null when the album has none, and when it was asked. */
@@ -23,7 +23,7 @@ internal interface AnimatedArtworkCache {
     suspend fun remove(key: String)
 }
 
-private val Context.animatedArtworkStore by preferencesDataStore(name = "animated_artwork")
+private val Context.animatedArtworkStore by safePreferencesDataStore(name = "animated_artwork")
 
 /** Answers kept across launches, so the service is asked about an album once in [MAX_ENTRIES]. */
 internal class DataStoreAnimatedArtworkCache(
diff --git a/app/src/main/java/io/github/aedev/flow/data/repository/PlaylistWalk.kt b/app/src/main/java/io/github/aedev/flow/data/repository/PlaylistWalk.kt
new file mode 100644
index 0000000000..588418f049
--- /dev/null
+++ b/app/src/main/java/io/github/aedev/flow/data/repository/PlaylistWalk.kt
@@ -0,0 +1,38 @@
+package io.github.aedev.flow.data.repository
+
+import io.github.aedev.flow.data.model.Video
+
+/** The videos a walk collected, and whether it reached the playlist's last page. */
+internal data class PlaylistWalk(
+    val videos: List<Video>,
+    val finished: Boolean,
+)
+
+/**
+ * Reads the pages after a playlist's first while YouTube sends a token it has not sent before.
+ * A page can parse to nothing and still point further, so only the token ends the walk. A failed
+ * page, a repeated token, the [maxPages] budget or [keepGoing] turning false leave it unfinished,
+ * and an unfinished list must never be cached or synced as the whole playlist.
+ */
+internal suspend fun walkPlaylistPages(
+    firstVideos: List<Video>,
+    firstToken: String?,
+    maxPages: Int,
+    nextPage: suspend (continuation: String) -> Pair<List<Video>, String?>?,
+    keepGoing: (videos: List<Video>) -> Boolean = { true },
+    onPage: (videos: List<Video>) -> Unit = {},
+): PlaylistWalk {
+    var videos = firstVideos.distinctBy { it.id }
+    var token = firstToken
+    val seen = HashSet<String>()
+    var pages = 1
+    while (token != null) {
+        if (!keepGoing(videos) || pages >= maxPages || !seen.add(token)) return PlaylistWalk(videos, finished = false)
+        val (more, next) = nextPage(token) ?: return PlaylistWalk(videos, finished = false)
+        videos = (videos + more).distinctBy { it.id }
+        onPage(videos)
+        token = next
+        pages++
+    }
+    return PlaylistWalk(videos, finished = true)
+}
diff --git a/app/src/main/java/io/github/aedev/flow/data/repository/YouTubePlaylistRepository.kt b/app/src/main/java/io/github/aedev/flow/data/repository/YouTubePlaylistRepository.kt
index 4de6097aba..c1295685ff 100644
--- a/app/src/main/java/io/github/aedev/flow/data/repository/YouTubePlaylistRepository.kt
+++ b/app/src/main/java/io/github/aedev/flow/data/repository/YouTubePlaylistRepository.kt
@@ -25,7 +25,12 @@ data class RemotePlaylistPage(
     val videos: List<Video>,
     val continuation: String?,
     val isCourse: Boolean = false,
-)
+    /** The header's count, unavailable videos included. */
+    val videoCount: Int? = null,
+) {
+    /** The whole list is shorter than the header's count: YouTube leaves out unavailable videos. */
+    fun hidesUnavailable(loaded: Int = videos.size): Boolean = videoCount != null && videoCount > loaded
+}
 
 /**
  * YouTube playlists from InnerTube, one request per page. The first page shows at once and later
@@ -56,25 +61,36 @@ class YouTubePlaylistRepository
             completeLists[playlistId] = CachedList(page.copy(continuation = null), System.currentTimeMillis())
         }
 
-        suspend fun firstPage(playlistId: String): RemotePlaylistPage? =
-            fetch { YouTube.videoPlaylistPage(playlistId) }
-                ?.takeIf { it.title != null || it.videos.isNotEmpty() }
-                ?.let { page ->
-                    RemotePlaylistPage(
-                        title = page.title.orEmpty(),
-                        ownerName = page.ownerName,
-                        ownerId = page.ownerId?.takeIf(String::isNotBlank),
-                        description = page.description.orEmpty(),
-                        thumbnailUrl =
-                            page.thumbnailUrl ?: page.videos
-                                .firstOrNull()
-                                ?.thumbnailUrl
-                                .orEmpty(),
-                        videos = page.videos,
-                        continuation = page.continuation,
-                        isCourse = page.isCourse,
-                    )
-                }
+        suspend fun firstPage(playlistId: String): RemotePlaylistPage? {
+            val page =
+                fetch { YouTube.videoPlaylistPage(playlistId) }
+                    ?.takeIf { it.title != null || it.videos.isNotEmpty() } ?: return null
+            // A Shorts grid stops at 100 with no next page; its "show unavailable" view is a list
+            // that pages through every video. Only grids ask for it: on a list it would add
+            // unplayable entries that look playable.
+            val list =
+                if (page.isShortsGrid) {
+                    fetch { YouTube.videoPlaylistPage(playlistId, params = YouTube.PLAYLIST_SHOW_UNAVAILABLE_PARAMS) }
+                        ?.takeIf { it.videos.isNotEmpty() }
+                } else {
+                    null
+                } ?: page
+            return RemotePlaylistPage(
+                title = page.title.orEmpty(),
+                ownerName = page.ownerName,
+                ownerId = page.ownerId?.takeIf(String::isNotBlank),
+                description = page.description.orEmpty(),
+                thumbnailUrl =
+                    page.thumbnailUrl ?: list.videos
+                        .firstOrNull()
+                        ?.thumbnailUrl
+                        .orEmpty(),
+                videos = list.videos,
+                continuation = list.continuation,
+                isCourse = page.isCourse,
+                videoCount = page.videoCount ?: list.videoCount,
+            )
+        }
 
         /** The videos behind [continuation] and the token after them. */
         suspend fun nextPage(
@@ -82,20 +98,16 @@ class YouTubePlaylistRepository
             continuation: String,
         ): Pair<List<Video>, String?>? = fetch { YouTube.videoPlaylistPage(playlistId, continuation) }?.let { it.videos to it.continuation }
 
-        /** Every video, page by page, for a caller that needs the whole list (syncing a saved copy). */
+        /**
+         * Every video, page by page, for a caller that needs the whole list (syncing a saved copy).
+         * Null unless every page arrived: a partial list would cut the saved copy short.
+         */
         suspend fun complete(playlistId: String): RemotePlaylistPage? {
             cachedComplete(playlistId)?.let { return it }
             val first = firstPage(playlistId) ?: return null
-            val videos = first.videos.toMutableList()
-            var token = first.continuation
-            var pages = 1
-            while (token != null && pages < MAX_PAGES) {
-                val (more, next) = nextPage(playlistId, token) ?: break
-                videos += more
-                token = next.takeIf { more.isNotEmpty() }
-                pages++
-            }
-            val complete = first.copy(videos = videos.distinctBy { it.id }, continuation = null)
+            val walk = walkPlaylistPages(first.videos, first.continuation, MAX_PAGES, { nextPage(playlistId, it) })
+            if (!walk.finished) return null
+            val complete = first.copy(videos = walk.videos, continuation = null)
             rememberComplete(playlistId, complete)
             return complete
         }
diff --git a/app/src/main/java/io/github/aedev/flow/data/stats/RecapImageResolver.kt b/app/src/main/java/io/github/aedev/flow/data/stats/RecapImageResolver.kt
index 17135be896..4bef8b852b 100644
--- a/app/src/main/java/io/github/aedev/flow/data/stats/RecapImageResolver.kt
+++ b/app/src/main/java/io/github/aedev/flow/data/stats/RecapImageResolver.kt
@@ -4,9 +4,9 @@ import android.content.Context
 import android.util.Log
 import androidx.datastore.preferences.core.edit
 import androidx.datastore.preferences.core.stringPreferencesKey
-import androidx.datastore.preferences.preferencesDataStore
 import dagger.hilt.android.qualifiers.ApplicationContext
 import io.github.aedev.flow.data.local.SubscriptionRepository
+import io.github.aedev.flow.data.local.safePreferencesDataStore
 import io.github.aedev.flow.data.recommendation.music.MusicBrainEngine
 import io.github.aedev.flow.data.repository.YouTubeRepository
 import io.github.aedev.flow.di.NetworkIoDispatcher
@@ -23,7 +23,7 @@ import java.util.Collections
 import javax.inject.Inject
 import javax.inject.Singleton
 
-private val Context.recapImages by preferencesDataStore(name = "flow_recap_images")
+private val Context.recapImages by safePreferencesDataStore(name = "flow_recap_images")
 private val IMAGES = stringPreferencesKey("images")
 
 /**
diff --git a/app/src/main/java/io/github/aedev/flow/data/stats/RecapReadiness.kt b/app/src/main/java/io/github/aedev/flow/data/stats/RecapReadiness.kt
index 60b4365cf3..c0a725915d 100644
--- a/app/src/main/java/io/github/aedev/flow/data/stats/RecapReadiness.kt
+++ b/app/src/main/java/io/github/aedev/flow/data/stats/RecapReadiness.kt
@@ -3,15 +3,15 @@ package io.github.aedev.flow.data.stats
 import android.content.Context
 import androidx.datastore.preferences.core.edit
 import androidx.datastore.preferences.core.stringPreferencesKey
-import androidx.datastore.preferences.preferencesDataStore
 import dagger.hilt.android.qualifiers.ApplicationContext
+import io.github.aedev.flow.data.local.safePreferencesDataStore
 import io.github.aedev.flow.data.recommendation.music.MusicBrainEngine
 import kotlinx.coroutines.flow.first
 import java.time.YearMonth
 import javax.inject.Inject
 import javax.inject.Singleton
 
-private val Context.recapPreferences by preferencesDataStore(name = "flow_recap")
+private val Context.recapPreferences by safePreferencesDataStore(name = "flow_recap")
 private val LAST_SHOWN = stringPreferencesKey("last_shown_month")
 
 /**
diff --git a/app/src/main/java/io/github/aedev/flow/innertube/YouTube.kt b/app/src/main/java/io/github/aedev/flow/innertube/YouTube.kt
index cf295fabc1..afd723208c 100644
--- a/app/src/main/java/io/github/aedev/flow/innertube/YouTube.kt
+++ b/app/src/main/java/io/github/aedev/flow/innertube/YouTube.kt
@@ -150,6 +150,9 @@ object YouTube {
     private const val CHANNEL_POSTS_PARAMS = "EgVwb3N0c_IGBAoCSgA="
     private const val CHANNEL_SHORTS_PARAMS = "EgZzaG9ydHPyBgUKA5oBAA=="
 
+    /** The playlist header menu's "Show unavailable videos" view, which lists a Shorts grid in full. */
+    const val PLAYLIST_SHOW_UNAVAILABLE_PARAMS = "wgYCCAA="
+
     var locale: YouTubeLocale
         get() = innerTube.locale
         set(value) {
@@ -841,17 +844,21 @@ object YouTube {
             communityPostCommentsPage(continuation = continuation)
         }
 
-    /** A YouTube playlist's first page when [continuation] is null, otherwise the page it points to. */
+    /**
+     * A YouTube playlist's first page when [continuation] is null, otherwise the page it points to.
+     * [params] picks a view of the first page, such as [PLAYLIST_SHOW_UNAVAILABLE_PARAMS].
+     */
     suspend fun videoPlaylistPage(
         playlistId: String,
         continuation: String? = null,
+        params: String? = null,
     ): Result<VideoPlaylistPage> =
         runCatching {
             val response =
                 innerTube.channelBrowse(
-                    client = currentWebClient(),
+                    client = WEB,
                     channelId = "VL$playlistId".takeIf { continuation == null },
-                    params = null,
+                    params = params.takeIf { continuation == null },
                     continuation = continuation,
                 )
             Json.parseToJsonElement(response.bodyAsText()).toVideoPlaylistPage()
diff --git a/app/src/main/java/io/github/aedev/flow/innertube/pages/VideoPlaylistPage.kt b/app/src/main/java/io/github/aedev/flow/innertube/pages/VideoPlaylistPage.kt
index ff2d2269d6..db1b64b139 100644
--- a/app/src/main/java/io/github/aedev/flow/innertube/pages/VideoPlaylistPage.kt
+++ b/app/src/main/java/io/github/aedev/flow/innertube/pages/VideoPlaylistPage.kt
@@ -20,6 +20,10 @@ data class VideoPlaylistPage(
     val videos: List<Video> = emptyList(),
     val continuation: String? = null,
     val isCourse: Boolean = false,
+    /** Shorts-only playlists arrive as a grid of 100 that YouTube sends no next page for. */
+    val isShortsGrid: Boolean = false,
+    /** The count in the header, unavailable videos included. */
+    val videoCount: Int? = null,
 )
 
 /**
@@ -27,7 +31,7 @@ data class VideoPlaylistPage(
  * lockups carrying their own channel; unavailable entries are simply absent from the response.
  */
 internal fun JsonElement.toVideoPlaylistPage(): VideoPlaylistPage {
-    val items = playlistItems()
+    val (items, isShortsGrid) = playlistItems()
     val header =
         findRenderers(
             "pageHeaderRenderer",
@@ -75,18 +79,33 @@ internal fun JsonElement.toVideoPlaylistPage(): VideoPlaylistPage {
                 .largestImageUrl(),
         videos =
             items
-                .mapNotNull { it.toFeedItem(FeedItemOwner()) }
-                .filterIsInstance<FeedItem.VideoItem>()
-                .map { it.video }
-                .distinctBy { it.id },
+                .mapNotNull { item ->
+                    when (val feedItem = item.toFeedItem(FeedItemOwner())) {
+                        is FeedItem.VideoItem -> feedItem.video
+                        is FeedItem.ShortItem -> feedItem.video
+                        else -> null
+                    }
+                }.distinctBy { it.id },
         continuation = items.lastOrNull().continuationToken(),
         isCourse = header["courseProgressViewModel"] != null,
+        isShortsGrid = isShortsGrid,
+        videoCount =
+            sidebar
+                ?.get("stats")
+                .arrayOrNull()
+                ?.firstOrNull()
+                .youtubeText()
+                ?.filter(Char::isDigit)
+                ?.toIntOrNull(),
     )
 }
 
-/** Items of the first page's list, or of a continuation's append action. */
-private fun JsonElement.playlistItems(): List<JsonElement> {
-    val root = objectOrNull() ?: return emptyList()
+/**
+ * Items of the first page's list, or of a continuation's append action, and whether they came as
+ * the Shorts grid instead of a list.
+ */
+private fun JsonElement.playlistItems(): Pair<List<JsonElement>, Boolean> {
+    val root = objectOrNull() ?: return emptyList<JsonElement>() to false
     root["onResponseReceivedActions"].arrayOrNull()?.let { actions ->
         return actions.flatMap { action ->
             action
@@ -96,15 +115,32 @@ private fun JsonElement.playlistItems(): List<JsonElement> {
                 ?.get("continuationItems")
                 .arrayOrNull()
                 .orEmpty()
-        }
+        } to false
     }
     var list: List<JsonElement> = emptyList()
+    var isGrid = false
     root["contents"].forEachObject { node ->
         if (list.isNotEmpty()) return@forEachObject
-        val contents = node["itemSectionRenderer"].objectOrNull()?.get("contents").arrayOrNull()
-        if (contents?.any { it.objectOrNull()?.containsKey("lockupViewModel") == true } == true) list = contents
+        val contents = node["itemSectionRenderer"].objectOrNull()?.get("contents").arrayOrNull() ?: return@forEachObject
+        if (contents.any { it.objectOrNull()?.containsKey("lockupViewModel") == true }) {
+            list = contents
+            return@forEachObject
+        }
+        contents
+            .firstNotNullOfOrNull {
+                it
+                    .objectOrNull()
+                    ?.get("richGridRenderer")
+                    .objectOrNull()
+                    ?.get("contents")
+                    .arrayOrNull()
+            }?.takeIf { it.isNotEmpty() }
+            ?.let {
+                list = it
+                isGrid = true
+            }
     }
-    return list
+    return list to isGrid
 }
 
 /** The next-page token, from the older `continuationItemRenderer` or the `continuationItemViewModel` that replaced it. */
diff --git a/app/src/main/java/io/github/aedev/flow/network/VpnStateMonitor.kt b/app/src/main/java/io/github/aedev/flow/network/VpnStateMonitor.kt
index 2346c14743..91ed0d320e 100644
--- a/app/src/main/java/io/github/aedev/flow/network/VpnStateMonitor.kt
+++ b/app/src/main/java/io/github/aedev/flow/network/VpnStateMonitor.kt
@@ -48,6 +48,13 @@ class VpnStateMonitor
                 val registered = runCatching { connectivity.registerDefaultNetworkCallback(callback) }.isSuccess
                 awaitClose { if (registered) connectivity.unregisterNetworkCallback(callback) }
             }.distinctUntilChanged()
-
-        private fun NetworkCapabilities?.isVpn(): Boolean = this?.hasTransport(NetworkCapabilities.TRANSPORT_VPN) == true
     }
+
+/** Whether this app's default network is a VPN right now, for a one-off read outside a flow. */
+fun Context.appTrafficUsesVpn(): Boolean =
+    runCatching {
+        val connectivity = getSystemService(ConnectivityManager::class.java)
+        connectivity?.getNetworkCapabilities(connectivity.activeNetwork).isVpn()
+    }.getOrDefault(false)
+
+private fun NetworkCapabilities?.isVpn(): Boolean = this?.hasTransport(NetworkCapabilities.TRANSPORT_VPN) == true
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 df59525bc2..4efffdc9c3 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
@@ -42,6 +42,7 @@ import io.github.aedev.flow.player.analytics.PlaybackAnalyticsLogger
 import io.github.aedev.flow.player.analytics.RenderedFirstFrameListener
 import io.github.aedev.flow.player.audio.AudioEffectsEntryPoint
 import io.github.aedev.flow.player.audio.AudioFeaturesManager
+import io.github.aedev.flow.player.audio.AudioSessionAnnouncer
 import io.github.aedev.flow.player.audio.eq.EqualizerAudioProcessor
 import io.github.aedev.flow.player.cache.PlayerCacheManager
 import io.github.aedev.flow.player.config.PlayerConfig
@@ -143,7 +144,7 @@ class EnhancedPlayerManager private constructor() {
     private var videoEqualizer: EqualizerAudioProcessor? = null
     private var eqObserver: Job? = null
     private var audioEffects: AudioEffectsEntryPoint? = null
-    private var announcedAudioSession = 0
+    private var audioSessionAnnouncer: AudioSessionAnnouncer? = null
 
     // State management
     private val _playerState = MutableStateFlow(EnhancedPlayerState())
@@ -752,7 +753,12 @@ class EnhancedPlayerManager private constructor() {
         player?.addAnalyticsListener(
             RenderedFirstFrameListener(currentVideoId = { currentVideoId }) { videoId -> _firstFrameVideoId.value = videoId },
         )
-        player?.let { announceAudioSession(effects, it.audioSessionId) }
+        player?.let { built ->
+            audioSessionAnnouncer =
+                AudioSessionAnnouncer(effects.audioSessionRegistry(), AudioEffect.CONTENT_TYPE_MOVIE) {
+                    audioFeaturesManager?.onAudioSessionChanged()
+                }.also { it.attach(built) }
+        }
 
         audioFeaturesManager?.setPlayer(player!!)
 
@@ -3327,16 +3333,6 @@ class EnhancedPlayerManager private constructor() {
             duration - player.currentPosition <= LIVE_EDGE_THRESHOLD_MS
     }
 
-    private fun announceAudioSession(
-        effects: AudioEffectsEntryPoint,
-        sessionId: Int,
-    ) {
-        val registry = effects.audioSessionRegistry()
-        if (announcedAudioSession != sessionId) registry.close(announcedAudioSession)
-        announcedAudioSession = sessionId
-        registry.open(sessionId, AudioEffect.CONTENT_TYPE_MOVIE)
-    }
-
     fun release() {
         Log.d(TAG, "release() called")
         releaseAdvanceWakeLock()
@@ -3351,8 +3347,8 @@ class EnhancedPlayerManager private constructor() {
         audioFeaturesManager?.clearPlayer()
         buildScope.close()
         surfaceManager?.release(player)
-        audioEffects?.audioSessionRegistry()?.close(announcedAudioSession)
-        announcedAudioSession = 0
+        audioSessionAnnouncer?.detach()
+        audioSessionAnnouncer = null
         player?.release()
         player = null
         trackSelector = null
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 5566141337..75367cc1a1 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
@@ -84,6 +84,14 @@ class AudioFeaturesManager(
         }
     }
 
+    /** Moves the gain onto the player's audio session, which ExoPlayer reports only after build. */
+    fun onAudioSessionChanged() {
+        val player = playerRef ?: return
+        loudnessEnhancer?.release()
+        loudnessEnhancer = null
+        applyLoudnessGain(player)
+    }
+
     /**
      * Clear the player reference (call on release).
      */
diff --git a/app/src/main/java/io/github/aedev/flow/player/audio/AudioSessionAnnouncer.kt b/app/src/main/java/io/github/aedev/flow/player/audio/AudioSessionAnnouncer.kt
new file mode 100644
index 0000000000..44ce8c0806
--- /dev/null
+++ b/app/src/main/java/io/github/aedev/flow/player/audio/AudioSessionAnnouncer.kt
@@ -0,0 +1,48 @@
+package io.github.aedev.flow.player.audio
+
+import androidx.media3.common.Player
+import androidx.media3.exoplayer.ExoPlayer
+
+/**
+ * Keeps [AudioSessionRegistry] in step with one player's audio session. Since Media3 1.6 the id is
+ * generated after the player is built and arrives through [onAudioSessionIdChanged], so reading
+ * `audioSessionId` right after `build()` returns 0.
+ *
+ * Attach it in the same main-thread task that built the player, so the first id is not missed, and
+ * detach it before the player is released.
+ */
+class AudioSessionAnnouncer(
+    private val registry: AudioSessionRegistry,
+    private val contentType: Int,
+    private val onSessionId: (Int) -> Unit = {},
+) : Player.Listener {
+    private var player: Player? = null
+    private var sessionId = 0
+
+    fun attach(player: ExoPlayer) {
+        this.player = player
+        player.addListener(this)
+        onAudioSessionIdChanged(player.audioSessionId)
+    }
+
+    fun detach() {
+        player?.removeListener(this)
+        player = null
+        registry.close(sessionId)
+        sessionId = 0
+    }
+
+    override fun onAudioSessionIdChanged(audioSessionId: Int) {
+        val id = audioSessionId.coerceAtLeast(0)
+        if (id == sessionId) return
+        registry.close(sessionId)
+        sessionId = id
+        registry.open(id, contentType)
+        if (player?.isPlaying == true) registry.playing(id)
+        onSessionId(id)
+    }
+
+    override fun onIsPlayingChanged(isPlaying: Boolean) {
+        if (isPlaying) registry.playing(sessionId) else registry.paused(sessionId)
+    }
+}
diff --git a/app/src/main/java/io/github/aedev/flow/player/audio/AudioSessionRegistry.kt b/app/src/main/java/io/github/aedev/flow/player/audio/AudioSessionRegistry.kt
index 281a6a5c9e..aff57055a5 100644
--- a/app/src/main/java/io/github/aedev/flow/player/audio/AudioSessionRegistry.kt
+++ b/app/src/main/java/io/github/aedev/flow/player/audio/AudioSessionRegistry.kt
@@ -18,6 +18,10 @@ import javax.inject.Singleton
 /**
  * Announces each player's audio session to equalizer apps, which attach their effects only to
  * sessions they have been told about; Media3 sends no such broadcast itself.
+ *
+ * Several players can be alive at once, and MusicFX follows only the session a package announced
+ * last, so a session is announced when it starts playing, or when it appears while nothing else
+ * plays. The active session is the one announced last.
  */
 @Singleton
 class AudioSessionRegistry
@@ -26,28 +30,54 @@ class AudioSessionRegistry
         @ApplicationContext private val context: Context,
     ) {
         private val open = LinkedHashMap<Int, Int>()
+        private val playing = LinkedHashSet<Int>()
         private val _activeSessionId = MutableStateFlow(AudioEffect.ERROR_BAD_VALUE)
 
-        /** The session opened most recently and still open, or [AudioEffect.ERROR_BAD_VALUE]. */
+        /** The session announced most recently and still open, or [AudioEffect.ERROR_BAD_VALUE]. */
         val activeSessionId: StateFlow<Int> = _activeSessionId.asStateFlow()
 
+        /** The content type [sessionId] was opened with, or null when it is not open. */
+        @Synchronized
+        fun contentTypeOf(sessionId: Int): Int? = open[sessionId]
+
         @Synchronized
         fun open(
             sessionId: Int,
             contentType: Int,
         ) {
             if (sessionId <= 0 || open[sessionId] == contentType) return
-            open.remove(sessionId)
             open[sessionId] = contentType
-            _activeSessionId.value = sessionId
-            broadcast(AudioEffect.ACTION_OPEN_AUDIO_EFFECT_CONTROL_SESSION, sessionId, contentType)
+            val active = _activeSessionId.value
+            if (active == sessionId || active <= 0 || active !in playing) announce(sessionId)
+        }
+
+        @Synchronized
+        fun playing(sessionId: Int) {
+            if (sessionId !in open) return
+            playing.remove(sessionId)
+            playing.add(sessionId)
+            if (_activeSessionId.value != sessionId) announce(sessionId)
+        }
+
+        @Synchronized
+        fun paused(sessionId: Int) {
+            playing.remove(sessionId)
         }
 
         @Synchronized
         fun close(sessionId: Int) {
+            playing.remove(sessionId)
             val contentType = open.remove(sessionId) ?: return
-            _activeSessionId.value = open.keys.lastOrNull() ?: AudioEffect.ERROR_BAD_VALUE
             broadcast(AudioEffect.ACTION_CLOSE_AUDIO_EFFECT_CONTROL_SESSION, sessionId, contentType)
+            if (_activeSessionId.value != sessionId) return
+            val next = playing.lastOrNull() ?: open.keys.lastOrNull()
+            if (next != null) announce(next) else _activeSessionId.value = AudioEffect.ERROR_BAD_VALUE
+        }
+
+        private fun announce(sessionId: Int) {
+            val contentType = open[sessionId] ?: return
+            _activeSessionId.value = sessionId
+            broadcast(AudioEffect.ACTION_OPEN_AUDIO_EFFECT_CONTROL_SESSION, sessionId, contentType)
         }
 
         private fun broadcast(
diff --git a/app/src/main/java/io/github/aedev/flow/player/error/VideoErrorMapper.kt b/app/src/main/java/io/github/aedev/flow/player/error/VideoErrorMapper.kt
index e44fa103fc..c257bc9785 100644
--- a/app/src/main/java/io/github/aedev/flow/player/error/VideoErrorMapper.kt
+++ b/app/src/main/java/io/github/aedev/flow/player/error/VideoErrorMapper.kt
@@ -3,6 +3,7 @@ package io.github.aedev.flow.player.error
 import android.content.Context
 import android.util.Log
 import io.github.aedev.flow.R
+import io.github.aedev.flow.network.appTrafficUsesVpn
 import io.github.aedev.flow.player.stream.PlaybackBlock
 import io.github.aedev.flow.player.stream.PlaybackBlockedException
 import org.schabi.newpipe.extractor.exceptions.AccountTerminatedException
@@ -45,6 +46,8 @@ object VideoErrorMapper {
         val isRetryable: Boolean = true,
         /** Whether this can be "fixed" by the user (vs. a server-side restriction). */
         val isUserActionable: Boolean = false,
+        /** A fresh YouTube session may get past it, so the panel offers the reset. */
+        val offersSessionReset: Boolean = false,
     )
 
     /**
@@ -122,11 +125,27 @@ object VideoErrorMapper {
             }
 
             throwable is PlaybackBlockedException && throwable.block == PlaybackBlock.BOT_WALL -> {
+                VideoError(
+                    message = context.getString(R.string.error_bot_wall_session),
+                    hint = context.getString(R.string.error_bot_wall_session_hint),
+                    isRetryable = true,
+                    isUserActionable = true,
+                    offersSessionReset = true,
+                )
+            }
+
+            // Only a wall that held for a fresh visitor names the network, and only a VPN that is
+            // actually on is named: most walled users have none (#1354).
+            throwable is PlaybackBlockedException && throwable.block == PlaybackBlock.NETWORK_WALL -> {
                 VideoError(
                     message = context.getString(R.string.error_bot_wall),
-                    hint = context.getString(R.string.error_bot_wall_hint),
+                    hint =
+                        context.getString(
+                            if (context.appTrafficUsesVpn()) R.string.error_bot_wall_hint else R.string.error_bot_wall_network_hint,
+                        ),
                     isRetryable = true,
                     isUserActionable = true,
+                    offersSessionReset = true,
                 )
             }
 
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 ebd3dbb091..59e79f031f 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
@@ -30,6 +30,7 @@ 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.eq.EqualizerAudioProcessor
 import io.github.aedev.flow.player.cache.PlayerCacheManager
 import io.github.aedev.flow.player.cache.SharedPlayerCacheProvider
@@ -97,7 +98,7 @@ class ShortsPlayerPool private constructor() {
     private val playerAudioManifests = arrayOfNulls<String?>(POOL_SIZE)
 
     private val equalizers = arrayOfNulls<EqualizerAudioProcessor>(POOL_SIZE)
-    private var audioEffects: AudioEffectsEntryPoint? = null
+    private val audioSessionAnnouncers = arrayOfNulls<AudioSessionAnnouncer>(POOL_SIZE)
     private var equalizerScope: CoroutineScope? = null
 
     private var isInitialized = false
@@ -204,7 +205,7 @@ class ShortsPlayerPool private constructor() {
             },
         )
 
-        val effects = EntryPointAccessors.fromApplication(appContext, AudioEffectsEntryPoint::class.java).also { audioEffects = it }
+        val effects = EntryPointAccessors.fromApplication(appContext, AudioEffectsEntryPoint::class.java)
         val equalizerSpec = effects.equalizerRepository().processingSpec
         equalizerScope =
             CoroutineScope(SupervisorJob() + Dispatchers.Default).also { scope ->
@@ -217,7 +218,9 @@ class ShortsPlayerPool private constructor() {
                 equalizers[i] = equalizer
                 players[i] =
                     createShortsPlayer(appContext, equalizer).also {
-                        effects.audioSessionRegistry().open(it.audioSessionId, AudioEffect.CONTENT_TYPE_MOVIE)
+                        audioSessionAnnouncers[i] =
+                            AudioSessionAnnouncer(effects.audioSessionRegistry(), AudioEffect.CONTENT_TYPE_MOVIE)
+                                .apply { attach(it) }
                     }
                 playerOwnerIndices[i] = null
                 playerVideoIds[i] = null
@@ -738,7 +741,8 @@ class ShortsPlayerPool private constructor() {
         equalizerScope?.cancel()
         equalizerScope = null
         for (i in 0 until POOL_SIZE) {
-            players[i]?.let { audioEffects?.audioSessionRegistry()?.close(it.audioSessionId) }
+            audioSessionAnnouncers[i]?.detach()
+            audioSessionAnnouncers[i] = null
             equalizers[i] = null
             players[i]?.stop()
             players[i]?.release()
diff --git a/app/src/main/java/io/github/aedev/flow/player/stream/InnerTubeVideoStreamExtractor.kt b/app/src/main/java/io/github/aedev/flow/player/stream/InnerTubeVideoStreamExtractor.kt
index cf540e467f..420469d34b 100644
--- a/app/src/main/java/io/github/aedev/flow/player/stream/InnerTubeVideoStreamExtractor.kt
+++ b/app/src/main/java/io/github/aedev/flow/player/stream/InnerTubeVideoStreamExtractor.kt
@@ -16,6 +16,7 @@ import io.github.aedev.flow.player.sabr.integration.SabrStreamInfo
 import io.github.aedev.flow.player.sabr.integration.SabrUrlResolver
 import io.github.aedev.flow.utils.cipher.CipherDeobfuscator
 import io.github.aedev.flow.utils.cipher.PipePipeNsigDecoder
+import io.github.aedev.flow.utils.potoken.PlayerWallReroll
 import io.github.aedev.flow.utils.potoken.PoTokenResult
 import io.github.aedev.flow.utils.potoken.WebPoTokenSession
 import kotlinx.coroutines.CancellationException
@@ -145,10 +146,8 @@ object InnerTubeVideoStreamExtractor {
             dropGatesOnIdentityChange()
             blockedVideoIds.remove(videoId)
             goneVideoIds.remove(videoId)
-            val failureReasons = mutableListOf<String>()
-            val liveDetected = booleanArrayOf(false)
-
             if (forceSabr) {
+                val failureReasons = mutableListOf<String>()
                 trySabrClients(videoId, failureReasons)?.let {
                     Log.w(TAG, "Extraction OK for $videoId via ${it.usedClient.clientName} (mode=SABR/forced)")
                     PlayerDiagnostics.logWarning(TAG, "extract OK $videoId mode=SABR/forced via ${it.usedClient.clientName}")
@@ -160,113 +159,146 @@ object InnerTubeVideoStreamExtractor {
                 return@withContext null
             }
 
-            // 1) Fast path: token-free clients with direct URLs. Skipped while GVS is enforcing
-            // attestation on them — without that memory the ladder walks into the same refusal on
-            // every single video, which is what "every video stops at a minute" looks like.
-            val fastClients = FAST_CLIENTS.ungated()
-            if (fastClients.isEmpty()) {
-                Log.w(TAG, "Fast clients demoted for $videoId (gated: ${ClientGateTracker.gatedClients()}) — trying TV_TIZEN")
-                PlayerDiagnostics.logWarning(
-                    TAG,
-                    "fast path SKIPPED $videoId — gated clients: ${ClientGateTracker.gatedClients().joinToString()}",
-                )
-                // The walled visitor's other app clients and token-backed web clients stop at the
-                // same minute; TV_TIZEN is the measured way past it (#921).
-                TizenStreamResolver.resolve(videoId, failureReasons)?.let {
-                    Log.w(TAG, "Extraction OK for $videoId via TV_TIZEN (mode=DIRECT/walled)")
-                    PlayerDiagnostics.logWarning(TAG, "extract OK $videoId via TV_TIZEN mode=DIRECT/walled")
-                    return@withContext it
-                }
-            } else {
-                // A cold start pays DNS and TLS inside the first request, which can outlast the
-                // per-client timeout; one retry on the warm connection beats falling to the web path.
-                tryDirectClients(
-                    videoId,
-                    fastClients,
-                    failureReasons,
-                    liveDetected = liveDetected,
-                    retryTimeoutOnce = true,
-                )?.let { direct ->
-                    val result = if (audioOnly) direct else maybeUpgradeToSabr(videoId, direct, failureReasons)
-                    Log.w(TAG, "Extraction OK for $videoId via ${result.usedClient.clientName} (mode=${resultMode(result)})")
-                    PlayerDiagnostics.logWarning(TAG, "extract OK $videoId via ${result.usedClient.clientName} mode=${resultMode(result)}")
-                    return@withContext result
-                }
-            }
-
-            if (liveDetected[0]) {
-                tryLiveClients(videoId, failureReasons)?.let {
-                    Log.w(TAG, "Live manifest for $videoId via ${it.usedClient.clientName} (live-clients)")
-                    return@withContext it
-                }
-            }
-
-            // 2) Durable path: web client + BotGuard PoToken + SABR. Ranked above every remaining
-            // direct client because it is the only other path whose token Flow can actually mint —
-            // the clients below it are all served unattested and can be cut off mid-playback.
-            trySabrClients(videoId, failureReasons)?.let {
-                Log.w(TAG, "Extraction OK for $videoId via ${it.usedClient.clientName} (mode=SABR)")
-                PlayerDiagnostics.logWarning(TAG, "extract OK $videoId mode=SABR (durable) via ${it.usedClient.clientName}")
-                return@withContext if (liveDetected[0] && !it.isLive) it.copy(isLive = true) else it
+            var failureReasons = mutableListOf<String>()
+            val walledGeneration = WebPoTokenSession.identityGeneration
+            walkLadder(videoId, audioOnly, failureReasons)?.let { return@withContext it }
+
+            // A wall at /player issues no stream URLs, so no 403 ever reaches the re-roll that GVS
+            // refusals trigger, and a retry would ask again with the same walled visitor (#1354).
+            val fullWall = PlayabilityVerdict.everyClientWalled(failureReasons)
+            val reroll = if (fullWall) WebPoTokenSession.rerollAfterPlayerWall(walledGeneration) else null
+            if (reroll == PlayerWallReroll.REROLLED) {
+                PlayerDiagnostics.logWarning(TAG, "every client bot-walled $videoId, retrying once with a fresh visitor")
+                dropGatesOnIdentityChange()
+                failureReasons = mutableListOf()
+                walkLadder(videoId, audioOnly, failureReasons)?.let { return@withContext it }
             }
+            val freshVisitorWalled = reroll == PlayerWallReroll.REROLLED || reroll == PlayerWallReroll.FRESH_VISITOR_WALLED
 
-            // 2b) Label and kids videos are UNPLAYABLE on the app clients, so once the web clients
-            // fail this is their only source (#1292). The gated clients below stop at a minute and
-            // swap to it mid-playback anyway. Skipped when step 1 already asked it.
-            if (fastClients.isNotEmpty() && !liveDetected[0]) {
-                TizenStreamResolver.resolve(videoId, failureReasons)?.let {
-                    Log.w(TAG, "Extraction OK for $videoId via TV_TIZEN (mode=DIRECT/web-fallback)")
-                    PlayerDiagnostics.logWarning(TAG, "extract OK $videoId via TV_TIZEN mode=DIRECT/web-fallback")
-                    return@withContext it
-                }
+            Log.e(TAG, "All clients failed for $videoId (forceSabr=$forceSabr). Reasons: ${failureReasons.joinToString(" | ")}")
+            PlayerDiagnostics.logError(TAG, "ALL clients failed $videoId: ${failureReasons.joinToString(" | ")}")
+            if (PlayabilityVerdict.everyClientWalled(failureReasons)) {
+                PlayerDiagnostics.logError(TAG, "bot wall $videoId: ${WebPoTokenSession.identitySummary()} freshWalled=$freshVisitorWalled")
             }
+            if (PlayabilityVerdict.isGone(failureReasons)) goneVideoIds += videoId
+            recordBlock(videoId, failureReasons, freshVisitorWalled)
+            null
+        }
 
-            // 3) Gated direct clients. Playable, but GVS stops serving them ~60s in, so they rank
-            // below anything attested and are only reached when the paths above are unavailable.
-            tryDirectClients(videoId, GATED_FALLBACK_CLIENTS.ungated(), failureReasons, liveDetected = liveDetected)?.let { direct ->
-                val result = if (audioOnly) direct else maybeUpgradeToSabr(videoId, direct, failureReasons)
-                Log.w(TAG, "Extraction OK for $videoId via ${result.usedClient.clientName} (mode=${resultMode(result)}/gated)")
-                PlayerDiagnostics.logWarning(
-                    TAG,
-                    "extract OK $videoId via ${result.usedClient.clientName} mode=${resultMode(result)}/GATED — " +
-                        "unattested, GVS may stop serving ~60s in",
-                )
-                return@withContext result
+    /**
+     * Steps 1 to 5 of the ladder, from the fast token-free clients to the demoted retry. Null when
+     * every step failed, with why in [failureReasons].
+     */
+    private suspend fun walkLadder(
+        videoId: String,
+        audioOnly: Boolean,
+        failureReasons: MutableList<String>,
+    ): VideoExtractionResult? {
+        val liveDetected = booleanArrayOf(false)
+
+        // 1) Fast path: token-free clients with direct URLs. Skipped while GVS is enforcing
+        // attestation on them — without that memory the ladder walks into the same refusal on
+        // every single video, which is what "every video stops at a minute" looks like.
+        val fastClients = FAST_CLIENTS.ungated()
+        if (fastClients.isEmpty()) {
+            Log.w(TAG, "Fast clients demoted for $videoId (gated: ${ClientGateTracker.gatedClients()}) — trying TV_TIZEN")
+            PlayerDiagnostics.logWarning(
+                TAG,
+                "fast path SKIPPED $videoId — gated clients: ${ClientGateTracker.gatedClients().joinToString()}",
+            )
+            // The walled visitor's other app clients and token-backed web clients stop at the
+            // same minute; TV_TIZEN is the measured way past it (#921).
+            TizenStreamResolver.resolve(videoId, failureReasons)?.let {
+                Log.w(TAG, "Extraction OK for $videoId via TV_TIZEN (mode=DIRECT/walled)")
+                PlayerDiagnostics.logWarning(TAG, "extract OK $videoId via TV_TIZEN mode=DIRECT/walled")
+                return it
             }
-
-            // 4) Last resort: remaining token-free clients
+        } else {
+            // A cold start pays DNS and TLS inside the first request, which can outlast the
+            // per-client timeout; one retry on the warm connection beats falling to the web path.
             tryDirectClients(
                 videoId,
-                LAST_RESORT_CLIENTS.ungated(),
+                fastClients,
                 failureReasons,
-                allowUntransformedN = true,
                 liveDetected = liveDetected,
-            )?.let {
-                Log.w(TAG, "Extraction OK for $videoId via ${it.usedClient.clientName} (mode=DIRECT/last-resort)")
-                PlayerDiagnostics.logWarning(TAG, "extract OK $videoId via ${it.usedClient.clientName} mode=DIRECT/last-resort")
-                return@withContext if (liveDetected[0] && !it.isLive) it.copy(isLive = true) else it
+                retryTimeoutOnce = true,
+            )?.let { direct ->
+                val result = if (audioOnly) direct else maybeUpgradeToSabr(videoId, direct, failureReasons)
+                Log.w(TAG, "Extraction OK for $videoId via ${result.usedClient.clientName} (mode=${resultMode(result)})")
+                PlayerDiagnostics.logWarning(TAG, "extract OK $videoId via ${result.usedClient.clientName} mode=${resultMode(result)}")
+                return result
             }
+        }
 
-            // 5) Every attested path is gone and the demotion has left nothing to try. A client
-            // that plays a minute beats a client that plays nothing, so the demotions are ignored
-            // for one pass rather than returning a failure the user cannot act on.
-            val demoted = (FAST_CLIENTS + GATED_FALLBACK_CLIENTS + LAST_RESORT_CLIENTS).filter { ClientGateTracker.isGated(it.clientName) }
-            if (demoted.isNotEmpty()) {
-                Log.w(TAG, "Nothing playable for $videoId without the demoted clients — retrying them: ${demoted.map { it.clientName }}")
-                PlayerDiagnostics.logWarning(TAG, "retrying DEMOTED clients for $videoId: ${demoted.joinToString { it.clientName }}")
-                tryDirectClients(videoId, demoted, failureReasons, allowUntransformedN = true, liveDetected = liveDetected)?.let {
-                    PlayerDiagnostics.logWarning(TAG, "extract OK $videoId via ${it.usedClient.clientName} mode=DIRECT/demoted-retry")
-                    return@withContext if (liveDetected[0] && !it.isLive) it.copy(isLive = true) else it
-                }
+        if (liveDetected[0]) {
+            tryLiveClients(videoId, failureReasons)?.let {
+                Log.w(TAG, "Live manifest for $videoId via ${it.usedClient.clientName} (live-clients)")
+                return it
             }
+        }
 
-            Log.e(TAG, "All clients failed for $videoId (forceSabr=$forceSabr). Reasons: ${failureReasons.joinToString(" | ")}")
-            PlayerDiagnostics.logError(TAG, "ALL clients failed $videoId: ${failureReasons.joinToString(" | ")}")
-            if (PlayabilityVerdict.isGone(failureReasons)) goneVideoIds += videoId
-            recordBlock(videoId, failureReasons)
-            null
+        // 2) Durable path: web client + BotGuard PoToken + SABR. Ranked above every remaining
+        // direct client because it is the only other path whose token Flow can actually mint —
+        // the clients below it are all served unattested and can be cut off mid-playback.
+        trySabrClients(videoId, failureReasons)?.let {
+            Log.w(TAG, "Extraction OK for $videoId via ${it.usedClient.clientName} (mode=SABR)")
+            PlayerDiagnostics.logWarning(TAG, "extract OK $videoId mode=SABR (durable) via ${it.usedClient.clientName}")
+            return if (liveDetected[0] && !it.isLive) it.copy(isLive = true) else it
         }
 
+        // 2b) Label and kids videos are UNPLAYABLE on the app clients, so once the web clients
+        // fail this is their only source (#1292). The gated clients below stop at a minute and
+        // swap to it mid-playback anyway. Skipped when step 1 already asked it.
+        if (fastClients.isNotEmpty() && !liveDetected[0]) {
+            TizenStreamResolver.resolve(videoId, failureReasons)?.let {
+                Log.w(TAG, "Extraction OK for $videoId via TV_TIZEN (mode=DIRECT/web-fallback)")
+                PlayerDiagnostics.logWarning(TAG, "extract OK $videoId via TV_TIZEN mode=DIRECT/web-fallback")
+                return it
+            }
+        }
+
+        // 3) Gated direct clients. Playable, but GVS stops serving them ~60s in, so they rank
+        // below anything attested and are only reached when the paths above are unavailable.
+        tryDirectClients(videoId, GATED_FALLBACK_CLIENTS.ungated(), failureReasons, liveDetected = liveDetected)?.let { direct ->
+            val result = if (audioOnly) direct else maybeUpgradeToSabr(videoId, direct, failureReasons)
+            Log.w(TAG, "Extraction OK for $videoId via ${result.usedClient.clientName} (mode=${resultMode(result)}/gated)")
+            PlayerDiagnostics.logWarning(
+                TAG,
+                "extract OK $videoId via ${result.usedClient.clientName} mode=${resultMode(result)}/GATED — " +
+                    "unattested, GVS may stop serving ~60s in",
+            )
+            return result
+        }
+
+        // 4) Last resort: remaining token-free clients
+        tryDirectClients(
+            videoId,
+            LAST_RESORT_CLIENTS.ungated(),
+            failureReasons,
+            allowUntransformedN = true,
+            liveDetected = liveDetected,
+        )?.let {
+            Log.w(TAG, "Extraction OK for $videoId via ${it.usedClient.clientName} (mode=DIRECT/last-resort)")
+            PlayerDiagnostics.logWarning(TAG, "extract OK $videoId via ${it.usedClient.clientName} mode=DIRECT/last-resort")
+            return if (liveDetected[0] && !it.isLive) it.copy(isLive = true) else it
+        }
+
+        // 5) Every attested path is gone and the demotion has left nothing to try. A client
+        // that plays a minute beats a client that plays nothing, so the demotions are ignored
+        // for one pass rather than returning a failure the user cannot act on.
+        val demoted = (FAST_CLIENTS + GATED_FALLBACK_CLIENTS + LAST_RESORT_CLIENTS).filter { ClientGateTracker.isGated(it.clientName) }
+        if (demoted.isNotEmpty()) {
+            Log.w(TAG, "Nothing playable for $videoId without the demoted clients — retrying them: ${demoted.map { it.clientName }}")
+            PlayerDiagnostics.logWarning(TAG, "retrying DEMOTED clients for $videoId: ${demoted.joinToString { it.clientName }}")
+            tryDirectClients(videoId, demoted, failureReasons, allowUntransformedN = true, liveDetected = liveDetected)?.let {
+                PlayerDiagnostics.logWarning(TAG, "extract OK $videoId via ${it.usedClient.clientName} mode=DIRECT/demoted-retry")
+                return if (liveDetected[0] && !it.isLive) it.copy(isLive = true) else it
+            }
+        }
+
+        return null
+    }
+
     /** Videos YouTube reported as removed or unplayable on every client; a queue skips them. */
     private val goneVideoIds: MutableSet<String> =
         java.util.concurrent.ConcurrentHashMap
@@ -282,8 +314,9 @@ object InnerTubeVideoStreamExtractor {
     private fun recordBlock(
         videoId: String,
         failureReasons: List<String>,
+        freshVisitorWalled: Boolean = false,
     ) {
-        PlayabilityVerdict.block(failureReasons)?.let { blockedVideoIds[videoId] = it }
+        PlayabilityVerdict.block(failureReasons, freshVisitorWalled)?.let { blockedVideoIds[videoId] = it }
     }
 
     /** The clients GVS is not currently refusing to serve. See [ClientGateTracker]. */
@@ -682,6 +715,7 @@ object InnerTubeVideoStreamExtractor {
                 val tag = if (PlayabilityVerdict.isBotWall(reason)) "BOT_WALL" else "status=$status"
                 failureReasons.add("$label: $tag, reason=$reason")
                 Log.w(TAG, "$label: $tag, reason=$reason")
+                PlayerDiagnostics.logWarning(TAG, "skip $label v${client.clientVersion}: $tag reason=$reason pot=true")
                 return null
             }
 
diff --git a/app/src/main/java/io/github/aedev/flow/player/stream/PlayabilityVerdict.kt b/app/src/main/java/io/github/aedev/flow/player/stream/PlayabilityVerdict.kt
index 1eb0cd3432..9165412ccc 100644
--- a/app/src/main/java/io/github/aedev/flow/player/stream/PlayabilityVerdict.kt
+++ b/app/src/main/java/io/github/aedev/flow/player/stream/PlayabilityVerdict.kt
@@ -9,11 +9,17 @@ private val BotWallReason = Regex("""not a bot|confirm you.re""", RegexOption.IG
 // Clients the ladder skipped without asking say nothing about the video.
 private val NotAskedReason = Regex("""demoted|no visitorData|PoToken unavailable|not asked""")
 
+// A client that never answered cannot contradict a wall the others reported.
+private val NoAnswerReason = Regex("""timeout or null response|exception=""")
+
 /** Why YouTube refused a video to this viewer, when the refusal is about the viewer and not the video. */
 enum class PlaybackBlock {
-    /** "Sign in to confirm you're not a bot": the network or visitor is flagged. */
+    /** "Sign in to confirm you're not a bot" on every client: this visitor is flagged. */
     BOT_WALL,
 
+    /** The wall held for a fresh visitor too, so the network is the likelier cause. */
+    NETWORK_WALL,
+
     /** The video needs a signed-in account, for its age or its audience. */
     LOGIN_REQUIRED,
 }
@@ -45,12 +51,22 @@ internal object PlayabilityVerdict {
         return statuses.isNotEmpty() && statuses.all { it in GoneStatuses }
     }
 
+    /** Every client that answered was bot-walled, so the refusal is about this viewer only. */
+    fun everyClientWalled(failureReasons: List<String>): Boolean {
+        val answered = failureReasons.filterNot { NotAskedReason.containsMatchIn(it) || NoAnswerReason.containsMatchIn(it) }
+        return answered.isNotEmpty() && answered.all { "BOT_WALL" in it }
+    }
+
     /** Extraction runs in en-US, so the reason is English; "confirm your age" is not a bot wall. */
     fun isBotWall(reason: String?): Boolean = reason != null && BotWallReason.containsMatchIn(reason)
 
-    fun block(failureReasons: List<String>): PlaybackBlock? =
+    /** [freshVisitorWalled]: the wall also held after the visitor was replaced for it. */
+    fun block(
+        failureReasons: List<String>,
+        freshVisitorWalled: Boolean = false,
+    ): PlaybackBlock? =
         when {
-            failureReasons.any { "BOT_WALL" in it } -> PlaybackBlock.BOT_WALL
+            everyClientWalled(failureReasons) -> if (freshVisitorWalled) PlaybackBlock.NETWORK_WALL else PlaybackBlock.BOT_WALL
             failureReasons.any { StatusPattern.find(it)?.groupValues?.get(1) == "LOGIN_REQUIRED" } -> PlaybackBlock.LOGIN_REQUIRED
             else -> null
         }
diff --git a/app/src/main/java/io/github/aedev/flow/player/stream/ResetYouTubeSession.kt b/app/src/main/java/io/github/aedev/flow/player/stream/ResetYouTubeSession.kt
new file mode 100644
index 0000000000..f338a2a68a
--- /dev/null
+++ b/app/src/main/java/io/github/aedev/flow/player/stream/ResetYouTubeSession.kt
@@ -0,0 +1,24 @@
+package io.github.aedev.flow.player.stream
+
+import io.github.aedev.flow.utils.cipher.CipherDeobfuscator
+import io.github.aedev.flow.utils.cipher.PlayerJsFetcher
+import io.github.aedev.flow.utils.potoken.WebPoTokenSession
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import javax.inject.Inject
+
+/**
+ * Re-attesting alone cannot lift a verdict the stream servers already reached about this visitor,
+ * so the identity itself is discarded, along with the client demotions graded against it: the
+ * supported form of the "clear app data" workaround for walled playback.
+ */
+class ResetYouTubeSession
+    @Inject
+    constructor() {
+        suspend operator fun invoke() {
+            WebPoTokenSession.resetIdentity()
+            ClientGateTracker.clear()
+            CipherDeobfuscator.invalidateSignatureTimestamp()
+            withContext(Dispatchers.IO) { PlayerJsFetcher.invalidateCache() }
+        }
+    }
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 44f599a505..065161658a 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,6 +67,7 @@ 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.PlaylistQueueOrder
+import io.github.aedev.flow.player.audio.AudioSessionAnnouncer
 import io.github.aedev.flow.player.audio.AudioSessionRegistry
 import io.github.aedev.flow.player.audio.eq.EqualizerAudioProcessor
 import io.github.aedev.flow.player.audio.shouldHandleAudioFocus
@@ -236,6 +237,7 @@ class Media3MusicService : MediaLibraryService() {
 
     @Inject
     lateinit var audioSessions: AudioSessionRegistry
+    private var audioSessionAnnouncer: AudioSessionAnnouncer? = null
 
     @Inject
     lateinit var autoLibrary: AutoLibrary
@@ -452,9 +454,11 @@ class Media3MusicService : MediaLibraryService() {
                 .build()
 
         // Expose audio session ID for external audio processors (James DSP, etc.)
-        currentAudioSessionId = player.audioSessionId
-        Log.i(TAG, "Audio session initialized - Session ID: $currentAudioSessionId")
-        audioSessions.open(player.audioSessionId, AudioEffect.CONTENT_TYPE_MUSIC)
+        audioSessionAnnouncer =
+            AudioSessionAnnouncer(audioSessions, AudioEffect.CONTENT_TYPE_MUSIC) { sessionId ->
+                currentAudioSessionId = sessionId
+                Log.i(TAG, "Audio session initialized - Session ID: $sessionId")
+            }.also { it.attach(player) }
 
         updateOffload { it.copy(processing = equalizerRepository.needsProcessing.value) }
         observeOffload()
@@ -1320,7 +1324,8 @@ class Media3MusicService : MediaLibraryService() {
         finalizeListenSession()
 
         // Clear audio session ID so external processors know we're gone
-        audioSessions.close(currentAudioSessionId)
+        audioSessionAnnouncer?.detach()
+        audioSessionAnnouncer = null
         currentAudioSessionId = 0
         Log.i(TAG, "Audio session destroyed")
 
diff --git a/app/src/main/java/io/github/aedev/flow/ui/FlowApp.kt b/app/src/main/java/io/github/aedev/flow/ui/FlowApp.kt
index d0bd9c412d..377ec97cf4 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/FlowApp.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/FlowApp.kt
@@ -328,6 +328,7 @@ fun FlowApp(
                 musicPlayerBackgroundStyle == io.github.aedev.flow.data.local.MusicPlayerBackgroundStyle.DEFAULT ||
                     (musicPlayerFollowLightTheme && musicPlayerBackgroundStyle.canTurnLight),
             isShortsPlayer = isShortsPlayerRoute,
+            videoPlayerExpanded = playerVisible && playerSheetState.currentValue == PlayerSheetValue.Expanded,
             heroUnderStatusBar =
                 statusBarHero.heroUnderStatusBar &&
                     !musicPlayerSheetState.isExpanded &&
diff --git a/app/src/main/java/io/github/aedev/flow/ui/FlowStatusBarStyle.kt b/app/src/main/java/io/github/aedev/flow/ui/FlowStatusBarStyle.kt
index 7e35ad6774..6d186aed96 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/FlowStatusBarStyle.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/FlowStatusBarStyle.kt
@@ -28,6 +28,8 @@ internal fun ApplyStatusBarStyle(
     isMusicPlayerImmersive: Boolean = false,
     musicPlayerFollowsTheme: Boolean = false,
     isShortsPlayer: Boolean = false,
+    // The expanded video player paints its black ground under the status bar on every theme.
+    videoPlayerExpanded: Boolean = false,
     // A page's full-bleed hero is under the status bar, so its icons must be light to read on the photo.
     heroUnderStatusBar: Boolean = false,
 ) {
@@ -46,7 +48,8 @@ internal fun ApplyStatusBarStyle(
     SideEffect {
         val window = activity.window
         val insetsController = WindowCompat.getInsetsController(window, view)
-        val shouldDrawBehindStatusBar = isFullscreen || isMusicPlayerImmersive || isShortsPlayer || heroUnderStatusBar
+        val shouldDrawBehindStatusBar =
+            isFullscreen || isMusicPlayerImmersive || isShortsPlayer || videoPlayerExpanded || heroUnderStatusBar
 
         window.statusBarColor =
             if (shouldDrawBehindStatusBar) {
diff --git a/app/src/main/java/io/github/aedev/flow/ui/components/library/PlaylistDetailHeader.kt b/app/src/main/java/io/github/aedev/flow/ui/components/library/PlaylistDetailHeader.kt
index bf90e0fc71..2a42efeb9d 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/components/library/PlaylistDetailHeader.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/components/library/PlaylistDetailHeader.kt
@@ -31,6 +31,7 @@ import androidx.compose.material.icons.outlined.MoreVert
 import androidx.compose.material.icons.outlined.SaveAs
 import androidx.compose.material.icons.outlined.Share
 import androidx.compose.material.icons.outlined.VideoLibrary
+import androidx.compose.material.icons.outlined.VisibilityOff
 import androidx.compose.material3.Button
 import androidx.compose.material3.ButtonDefaults
 import androidx.compose.material3.ButtonGroupDefaults
@@ -74,6 +75,10 @@ private const val DESCRIPTION_COLLAPSED_LINES = 2
 private const val ARTWORK_PLACEHOLDER_ALPHA = 0.5f
 private val PlaceholderIconSize: Dp = 64.dp
 private val DownloadProgressSize: Dp = 28.dp
+private val NoteIconSize: Dp = 18.dp
+private val NoteIconGap: Dp = 8.dp
+private val NoteHorizontalPadding: Dp = 12.dp
+private val NoteVerticalPadding: Dp = 8.dp
 
 /** What the playlist header shows. [downloadProgress] is null while no "Download all" is running. */
 @Immutable
@@ -81,6 +86,8 @@ internal data class PlaylistHeaderState(
     val name: String,
     val metadata: String,
     val description: String,
+    /** A line about the list itself, such as videos YouTube leaves out; null shows none. */
+    val note: String? = null,
     val thumbnailUrl: String,
     val isSaved: Boolean = false,
     val canSave: Boolean = false,
@@ -193,6 +200,7 @@ private fun ColumnScope.PlaylistTitleBlock(state: PlaylistHeaderState) {
             color = MaterialTheme.colorScheme.onSurfaceVariant,
         )
     }
+    state.note?.let { PlaylistNote(it) }
     if (state.description.isNotEmpty()) {
         var expanded by rememberSaveable(state.description) { mutableStateOf(false) }
         Text(
@@ -206,6 +214,31 @@ private fun ColumnScope.PlaylistTitleBlock(state: PlaylistHeaderState) {
     }
 }
 
+@Composable
+private fun PlaylistNote(text: String) {
+    Row(
+        horizontalArrangement = Arrangement.spacedBy(NoteIconGap),
+        verticalAlignment = Alignment.CenterVertically,
+        modifier =
+            Modifier
+                .clip(MaterialTheme.shapes.medium)
+                .background(MaterialTheme.colorScheme.surfaceContainer)
+                .padding(horizontal = NoteHorizontalPadding, vertical = NoteVerticalPadding),
+    ) {
+        Icon(
+            imageVector = Icons.Outlined.VisibilityOff,
+            contentDescription = null,
+            tint = MaterialTheme.colorScheme.onSurfaceVariant,
+            modifier = Modifier.size(NoteIconSize),
+        )
+        Text(
+            text = text,
+            style = MaterialTheme.typography.bodySmall,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+        )
+    }
+}
+
 @Composable
 private fun PlaylistPrimaryActions(actions: PlaylistHeaderActions) {
     FlowActionButtonPair(
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/equalizer/EqualizerScreen.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/equalizer/EqualizerScreen.kt
index 845325dc3c..8702bbe39d 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/equalizer/EqualizerScreen.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/equalizer/EqualizerScreen.kt
@@ -85,7 +85,7 @@ fun EqualizerScreen(
     var showPresets by rememberSaveable { mutableStateOf(false) }
     var selectedBand by rememberSaveable { mutableStateOf<Int?>(null) }
     var dialog by remember { mutableStateOf<EqDialog?>(null) }
-    val systemEqualizer = remember { viewModel.systemEqualizerIntent() }
+    val hasSystemEqualizer = remember { viewModel.systemEqualizerIntent() != null }
     val undoLabel = stringResource(R.string.undo)
     val panes = rememberFlowPaneState()
     val twoPane = !inSettings && panes.showsSidePane
@@ -184,7 +184,12 @@ fun EqualizerScreen(
                 twoPane = twoPane,
                 onOpenPresets = { showPresets = true },
                 onSaveAs = { dialog = EqDialog.SaveAs },
-                onSystemEqualizer = systemEqualizer?.let { intent -> { openSystemEqualizer.launch(intent) } },
+                onSystemEqualizer =
+                    if (hasSystemEqualizer) {
+                        { viewModel.systemEqualizerIntent()?.let(openSystemEqualizer::launch) }
+                    } else {
+                        null
+                    },
                 modifier = Modifier.padding(padding),
             )
         }
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/equalizer/EqualizerViewModel.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/equalizer/EqualizerViewModel.kt
index f729990000..2b27b48e8b 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/equalizer/EqualizerViewModel.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/equalizer/EqualizerViewModel.kt
@@ -278,13 +278,19 @@ class EqualizerViewModel
             _importPreview.value = null
         }
 
-        /** An installed equalizer panel for the current session, or null when none is installed. */
+        /**
+         * An installed equalizer panel for the session playing now, or null when none is installed.
+         * Built at tap time: the active session changes as players start and stop.
+         */
         fun systemEqualizerIntent(): Intent? {
+            val session = sessions.activeSessionId.value
             val intent =
                 Intent(AudioEffect.ACTION_DISPLAY_AUDIO_EFFECT_CONTROL_PANEL)
                     .putExtra(AudioEffect.EXTRA_PACKAGE_NAME, context.packageName)
-                    .putExtra(AudioEffect.EXTRA_CONTENT_TYPE, AudioEffect.CONTENT_TYPE_MUSIC)
-            val session = sessions.activeSessionId.value
+                    .putExtra(
+                        AudioEffect.EXTRA_CONTENT_TYPE,
+                        sessions.contentTypeOf(session) ?: AudioEffect.CONTENT_TYPE_MUSIC,
+                    )
             if (session > 0) intent.putExtra(AudioEffect.EXTRA_AUDIO_SESSION, session)
             return intent.takeIf { it.resolveActivity(context.packageManager) != null }
         }
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/player/PlaybackRecoveryController.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/player/PlaybackRecoveryController.kt
index f986126e2e..f218e9240f 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/player/PlaybackRecoveryController.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/player/PlaybackRecoveryController.kt
@@ -52,6 +52,7 @@ internal class PlaybackRecoveryController(
                 isLoading = false,
                 error = context.getString(R.string.error_all_stream_sources_failed),
                 errorHint = context.getString(R.string.error_playback_retry_hint),
+                errorOffersSessionReset = false,
             )
         }
     }
@@ -64,6 +65,7 @@ internal class PlaybackRecoveryController(
                 isLoading = false,
                 error = context.getString(R.string.error_video_decoder_failed),
                 errorHint = context.getString(R.string.error_video_decoder_failed_hint),
+                errorOffersSessionReset = false,
             )
         }
     }
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 c666d3e350..290167d4ab 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
@@ -30,6 +30,7 @@ import io.github.aedev.flow.player.LifecyclePlaybackPreferences
 import io.github.aedev.flow.player.MiniPlayerExpansionState
 import io.github.aedev.flow.player.state.EnhancedPlayerState
 import io.github.aedev.flow.player.stream.PlaybackLoadResolver
+import io.github.aedev.flow.player.stream.ResetYouTubeSession
 import io.github.aedev.flow.player.stream.UpcomingPremiereProbe
 import io.github.aedev.flow.ui.screens.player.state.*
 import io.github.aedev.flow.utils.NetworkState
@@ -82,6 +83,7 @@ class VideoPlayerViewModel
         private val localMediaDetails: LocalMediaDetails,
         private val lifecyclePlayback: LifecyclePlaybackPreferences,
         private val autoDownload: AutoDownloadTrigger,
+        private val resetYouTubeSession: ResetYouTubeSession,
         @NetworkIoDispatcher private val networkDispatcher: CoroutineDispatcher,
         @IoDispatcher private val ioDispatcher: CoroutineDispatcher,
     ) : ViewModel() {
@@ -390,6 +392,12 @@ class VideoPlayerViewModel
 
         fun showVideoPlayer() = presence.showVideoPlayer()
 
+        fun resetSessionAndRetry() =
+            viewModelScope.launch {
+                resetYouTubeSession()
+                retryLoadVideo()
+            }
+
         fun retryLoadVideo() {
             val videoId = _uiState.value.cachedVideo?.id ?: return
             Log.d("VideoPlayerViewModel", "Retrying video load for $videoId")
@@ -403,7 +411,7 @@ class VideoPlayerViewModel
             }
             recovery.onPlaybackRequested()
             playerManager.clearCurrentVideo()
-            _uiState.update { it.copy(error = null, errorHint = null, isLoading = true) }
+            _uiState.update { it.copy(error = null, errorHint = null, errorOffersSessionReset = false, isLoading = true) }
             loadVideoInfo(videoId, isWifi = detectIsWifi(), forceRefresh = true)
         }
 
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/player/content/PlayerErrorPanel.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/player/content/PlayerErrorPanel.kt
index b277ec1666..2d1fd703b3 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/player/content/PlayerErrorPanel.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/player/content/PlayerErrorPanel.kt
@@ -4,35 +4,54 @@ import android.content.Context
 import android.content.Intent
 import android.net.Uri
 import android.widget.Toast
-import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.RowScope
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.rounded.ContentCopy
 import androidx.compose.material.icons.rounded.OpenInBrowser
 import androidx.compose.material.icons.rounded.Refresh
-import androidx.compose.material3.*
+import androidx.compose.material.icons.rounded.RestartAlt
+import androidx.compose.material3.Button
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
 import io.github.aedev.flow.R
 import io.github.aedev.flow.player.error.PlayerDiagnostics
 
+private val ButtonPadding = PaddingValues(horizontal = 14.dp, vertical = 8.dp)
+
+/** [onResetSession] is null unless a fresh YouTube session may get past the error. */
 @Composable
 internal fun PlayerErrorPanel(
     errorHint: String?,
     videoId: String,
     context: Context,
     onRetryClick: () -> Unit,
+    onResetSession: (() -> Unit)? = null,
 ) {
     Surface(
         modifier =
             Modifier
                 .fillMaxWidth()
                 .padding(horizontal = 16.dp, vertical = 8.dp),
-        shape = RoundedCornerShape(12.dp),
+        shape = MaterialTheme.shapes.medium,
         color = MaterialTheme.colorScheme.errorContainer.copy(alpha = 0.25f),
         tonalElevation = 0.dp,
     ) {
@@ -47,29 +66,41 @@ internal fun PlayerErrorPanel(
                     color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.78f),
                 )
             }
+            if (onResetSession != null) {
+                Button(
+                    onClick = onResetSession,
+                    colors = errorButtonColors(),
+                    shape = MaterialTheme.shapes.small,
+                    contentPadding = ButtonPadding,
+                    modifier = Modifier.fillMaxWidth(),
+                ) {
+                    PanelButtonContent(Icons.Rounded.RestartAlt, stringResource(R.string.diagnostics_reset_session), FontWeight.SemiBold)
+                }
+            }
             // Row 1: Retry + Copy Logs
             Row(
                 horizontalArrangement = Arrangement.spacedBy(8.dp),
                 modifier = Modifier.fillMaxWidth(),
             ) {
-                Button(
-                    onClick = onRetryClick,
-                    colors =
-                        ButtonDefaults.buttonColors(
-                            containerColor = MaterialTheme.colorScheme.error,
-                            contentColor = MaterialTheme.colorScheme.onError,
-                        ),
-                    shape = RoundedCornerShape(8.dp),
-                    contentPadding = PaddingValues(horizontal = 14.dp, vertical = 8.dp),
-                    modifier = Modifier.weight(1f),
-                ) {
-                    Icon(
-                        imageVector = Icons.Rounded.Refresh,
-                        contentDescription = null,
-                        modifier = Modifier.size(16.dp),
-                    )
-                    Spacer(Modifier.width(4.dp))
-                    Text(stringResource(R.string.retry), fontWeight = FontWeight.SemiBold, fontSize = 13.sp)
+                if (onResetSession == null) {
+                    Button(
+                        onClick = onRetryClick,
+                        colors = errorButtonColors(),
+                        shape = MaterialTheme.shapes.small,
+                        contentPadding = ButtonPadding,
+                        modifier = Modifier.weight(1f),
+                    ) {
+                        PanelButtonContent(Icons.Rounded.Refresh, stringResource(R.string.retry), FontWeight.SemiBold)
+                    }
+                } else {
+                    OutlinedButton(
+                        onClick = onRetryClick,
+                        shape = MaterialTheme.shapes.small,
+                        contentPadding = ButtonPadding,
+                        modifier = Modifier.weight(1f),
+                    ) {
+                        PanelButtonContent(Icons.Rounded.Refresh, stringResource(R.string.retry))
+                    }
                 }
                 OutlinedButton(
                     onClick = {
@@ -81,17 +112,11 @@ internal fun PlayerErrorPanel(
                                 Toast.LENGTH_SHORT,
                             ).show()
                     },
-                    shape = RoundedCornerShape(8.dp),
-                    contentPadding = PaddingValues(horizontal = 14.dp, vertical = 8.dp),
+                    shape = MaterialTheme.shapes.small,
+                    contentPadding = ButtonPadding,
                     modifier = Modifier.weight(1f),
                 ) {
-                    Icon(
-                        imageVector = Icons.Rounded.ContentCopy,
-                        contentDescription = null,
-                        modifier = Modifier.size(16.dp),
-                    )
-                    Spacer(Modifier.width(4.dp))
-                    Text(stringResource(R.string.copy_logs), fontSize = 13.sp)
+                    PanelButtonContent(Icons.Rounded.ContentCopy, stringResource(R.string.copy_logs))
                 }
             }
             // Row 2: Open in YouTube (full width)
@@ -104,18 +129,34 @@ internal fun PlayerErrorPanel(
                         )
                     context.startActivity(intent)
                 },
-                shape = RoundedCornerShape(8.dp),
-                contentPadding = PaddingValues(horizontal = 14.dp, vertical = 8.dp),
+                shape = MaterialTheme.shapes.small,
+                contentPadding = ButtonPadding,
                 modifier = Modifier.fillMaxWidth(),
             ) {
-                Icon(
-                    imageVector = Icons.Rounded.OpenInBrowser,
-                    contentDescription = null,
-                    modifier = Modifier.size(16.dp),
-                )
-                Spacer(Modifier.width(6.dp))
-                Text(stringResource(R.string.ui_open_in_youtube), fontSize = 13.sp)
+                PanelButtonContent(Icons.Rounded.OpenInBrowser, stringResource(R.string.ui_open_in_youtube))
             }
         }
     }
 }
+
+@Composable
+private fun errorButtonColors() =
+    ButtonDefaults.buttonColors(
+        containerColor = MaterialTheme.colorScheme.error,
+        contentColor = MaterialTheme.colorScheme.onError,
+    )
+
+@Composable
+private fun RowScope.PanelButtonContent(
+    icon: ImageVector,
+    label: String,
+    fontWeight: FontWeight? = null,
+) {
+    Icon(
+        imageVector = icon,
+        contentDescription = null,
+        modifier = Modifier.size(ButtonDefaults.IconSize),
+    )
+    Spacer(Modifier.width(ButtonDefaults.IconSpacing))
+    Text(label, style = MaterialTheme.typography.labelLarge, fontWeight = fontWeight)
+}
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/player/content/VideoInfoContent.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/player/content/VideoInfoContent.kt
index a673a8b81c..a4a36e625f 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/player/content/VideoInfoContent.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/player/content/VideoInfoContent.kt
@@ -72,6 +72,7 @@ internal fun VideoInfoContent(
             videoId = video.id,
             context = context,
             onRetryClick = { viewModel.retryLoadVideo() },
+            onResetSession = if (uiState.errorOffersSessionReset) ({ viewModel.resetSessionAndRetry() }) else null,
         )
     }
 
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/player/state/PlayerLoadDecisions.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/player/state/PlayerLoadDecisions.kt
index 5d5c78a251..a084f1f895 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/player/state/PlayerLoadDecisions.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/player/state/PlayerLoadDecisions.kt
@@ -50,6 +50,7 @@ internal fun VideoPlayerUiState.beginLoadFor(videoId: String): VideoPlayerUiStat
         isLoading = true,
         error = null,
         errorHint = null,
+        errorOffersSessionReset = false,
         videoStream = null,
         audioStream = null,
         streamSizes = emptyMap(),
@@ -81,6 +82,7 @@ internal fun VideoPlayerUiState.applyCachedUpcoming(releaseTimeMs: Long): VideoP
         isLoading = false,
         error = null,
         errorHint = null,
+        errorOffersSessionReset = false,
         videoStream = null,
         audioStream = null,
         localFilePath = null,
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/player/state/PlayerPlaybackReducers.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/player/state/PlayerPlaybackReducers.kt
index 8cc768751b..8dbf8e501c 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/player/state/PlayerPlaybackReducers.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/player/state/PlayerPlaybackReducers.kt
@@ -42,6 +42,7 @@ internal fun VideoPlayerUiState.applyLocalCopyReady(
         offlineSponsorBlockSegments = step.offlineSegments,
         error = null,
         errorHint = null,
+        errorOffersSessionReset = false,
         isLoading = false,
         isUpcoming = false,
         upcomingReleaseTimeMs = null,
@@ -95,6 +96,7 @@ internal fun VideoPlayerUiState.applyVodStreams(
         isLoading = false,
         error = null,
         errorHint = null,
+        errorOffersSessionReset = false,
         savedPosition = savedPositionMs,
         isAdaptiveMode = isAdaptiveMode,
         autoplayEnabled = autoplayEnabled,
@@ -133,6 +135,7 @@ internal fun VideoPlayerUiState.applyLiveStreams(
         isLoading = false,
         error = null,
         errorHint = null,
+        errorOffersSessionReset = false,
         hlsUrl = hlsUrl,
         isLive = true,
         isUpcoming = false,
@@ -151,6 +154,7 @@ internal fun VideoPlayerUiState.applyVodFailure(
         relatedVideos = relatedVideos,
         error = videoError.message,
         errorHint = videoError.hint,
+        errorOffersSessionReset = videoError.offersSessionReset,
     )
 
 /** Nothing resolved. A null [relatedVideos] leaves the lane the screen is already showing alone. */
@@ -163,6 +167,7 @@ internal fun VideoPlayerUiState.applyPlaybackFailure(
         relatedVideos = relatedVideos ?: this.relatedVideos,
         error = videoError.message,
         errorHint = videoError.hint,
+        errorOffersSessionReset = videoError.offersSessionReset,
     )
 
 /**
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/player/state/UpcomingPremierePolicy.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/player/state/UpcomingPremierePolicy.kt
index f993d081cc..53f5fef011 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/player/state/UpcomingPremierePolicy.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/player/state/UpcomingPremierePolicy.kt
@@ -114,6 +114,7 @@ internal object UpcomingPremierePolicy {
             isLoading = false,
             error = null,
             errorHint = null,
+            errorOffersSessionReset = false,
             videoStream = null,
             audioStream = null,
             relatedVideos = relatedVideos.ifEmpty { state.relatedVideos },
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/player/state/VideoPlayerUiState.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/player/state/VideoPlayerUiState.kt
index 2239ca2599..bb07eb7b81 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/player/state/VideoPlayerUiState.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/player/state/VideoPlayerUiState.kt
@@ -22,6 +22,8 @@ data class VideoPlayerUiState(
     val error: String? = null,
     /** Optional secondary hint shown below the primary error in the player's error panel. */
     val errorHint: String? = null,
+    /** The error is a bot wall, which a fresh YouTube session may get past. */
+    val errorOffersSessionReset: Boolean = false,
     val savedPosition: Long? = null,
     val isAdaptiveMode: Boolean = false,
     val isSubscribed: Boolean = false,
@@ -73,6 +75,7 @@ data class VideoPlayerUiState(
             isLoading = true,
             error = null,
             errorHint = null,
+            errorOffersSessionReset = false,
             videoStream = null,
             audioStream = null,
             streamSizes = emptyMap(),
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/playlists/LinkedPlaylistViewModel.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/playlists/LinkedPlaylistViewModel.kt
index 3a2c941457..0c94b8282d 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/playlists/LinkedPlaylistViewModel.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/playlists/LinkedPlaylistViewModel.kt
@@ -7,6 +7,7 @@ import io.github.aedev.flow.data.music.model.MusicTrack
 import io.github.aedev.flow.data.newmusic.InnertubeMusicService
 import io.github.aedev.flow.data.repository.RemotePlaylistPage
 import io.github.aedev.flow.data.repository.YouTubePlaylistRepository
+import io.github.aedev.flow.data.repository.walkPlaylistPages
 import javax.inject.Inject
 
 /** A playlist a link plays from, positioned at the video the link names. */
@@ -63,18 +64,15 @@ internal suspend fun findLinkedVideoQueue(
     maxPages: Int = LINKED_PLAYLIST_MAX_PAGES,
     nextPage: suspend (continuation: String) -> Pair<List<Video>, String?>?,
 ): LinkedQueue<Video>? {
-    var videos = first.videos
-    var continuation = first.continuation
-    var pages = 1
-    while (true) {
-        linkedQueue(videos, startVideoId, first.title, Video::id)?.let { return it }
-        val token = continuation?.takeIf { pages < maxPages } ?: return null
-        val (more, next) = nextPage(token) ?: return null
-        if (more.isEmpty()) return null
-        videos = videos + more
-        continuation = next
-        pages++
-    }
+    val walk =
+        walkPlaylistPages(
+            firstVideos = first.videos,
+            firstToken = first.continuation,
+            maxPages = maxPages,
+            nextPage = nextPage,
+            keepGoing = { videos -> videos.none { it.id == startVideoId } },
+        )
+    return linkedQueue(walk.videos, startVideoId, first.title, Video::id)
 }
 
 private const val LINKED_PLAYLIST_MAX_PAGES = 10
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/playlists/PlaylistDetailUiState.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/playlists/PlaylistDetailUiState.kt
index 8636089620..811390aa45 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/playlists/PlaylistDetailUiState.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/playlists/PlaylistDetailUiState.kt
@@ -33,5 +33,7 @@ data class PlaylistDetailUiState(
     val isLoading: Boolean = true,
     /** Later pages of a YouTube playlist are still arriving. */
     val isLoadingMore: Boolean = false,
+    /** Every page arrived and YouTube's count is higher: it left out unavailable videos. */
+    val hidesUnavailable: Boolean = false,
     val errorMessage: String? = null,
 )
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/playlists/PlaylistDetailViewModel.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/playlists/PlaylistDetailViewModel.kt
index 4ae615da89..f547f9b180 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/playlists/PlaylistDetailViewModel.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/playlists/PlaylistDetailViewModel.kt
@@ -25,6 +25,7 @@ import io.github.aedev.flow.data.playlist.PlaylistTransfer
 import io.github.aedev.flow.data.repository.RemotePlaylistPage
 import io.github.aedev.flow.data.repository.YouTubePlaylistRepository
 import io.github.aedev.flow.data.repository.YouTubeRepository
+import io.github.aedev.flow.data.repository.walkPlaylistPages
 import io.github.aedev.flow.data.video.BackgroundDownloadQueuer
 import io.github.aedev.flow.data.video.DownloadBatch
 import io.github.aedev.flow.data.video.downloader.collection.CollectionSpec
@@ -458,6 +459,7 @@ class PlaylistDetailViewModel
                         isWatchLater = false,
                         isLoading = false,
                         isLoadingMore = page.continuation != null,
+                        hidesUnavailable = page.continuation == null && page.hidesUnavailable(),
                         errorMessage = null,
                     )
                 }
@@ -513,18 +515,18 @@ class PlaylistDetailViewModel
             first: RemotePlaylistPage,
             firstToken: String,
         ) {
-            var videos = first.videos
-            var token: String? = firstToken
-            var pages = 1
-            while (token != null && pages < YouTubePlaylistRepository.PAGE_LIMIT) {
-                val (more, next) = playlistRepository.nextPage(playlistId, token) ?: break
-                videos = (videos + more).distinctBy { it.id }
-                token = next.takeIf { more.isNotEmpty() }
-                pages++
-                _uiState.update { it.copy(videos = videos) }
+            val walk =
+                walkPlaylistPages(
+                    firstVideos = first.videos,
+                    firstToken = firstToken,
+                    maxPages = YouTubePlaylistRepository.PAGE_LIMIT,
+                    nextPage = { playlistRepository.nextPage(playlistId, it) },
+                    onPage = { videos -> _uiState.update { it.copy(videos = videos) } },
+                )
+            _uiState.update {
+                it.copy(isLoadingMore = false, hidesUnavailable = walk.finished && first.hidesUnavailable(walk.videos.size))
             }
-            _uiState.update { it.copy(isLoadingMore = false) }
-            if (token == null) playlistRepository.rememberComplete(playlistId, first.copy(videos = videos))
+            if (walk.finished) playlistRepository.rememberComplete(playlistId, first.copy(videos = walk.videos))
         }
 
         private fun refreshSavedPlaylist() {
@@ -537,6 +539,7 @@ class PlaylistDetailViewModel
                         ownerName = details.ownerName ?: state.ownerName,
                         description = details.description.ifBlank { state.description },
                         thumbnailUrl = details.thumbnailUrl.ifBlank { state.thumbnailUrl },
+                        hidesUnavailable = details.hidesUnavailable(),
                     )
                 }
             }
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/playlists/PlaylistHeaderStateMapping.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/playlists/PlaylistHeaderStateMapping.kt
index 5829b0c9ae..d47a961be2 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/playlists/PlaylistHeaderStateMapping.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/playlists/PlaylistHeaderStateMapping.kt
@@ -44,6 +44,7 @@ internal fun rememberPlaylistHeaderState(
         name = uiState.playlistName,
         metadata = parts.joinToString(" $separator "),
         description = uiState.description,
+        note = stringResource(R.string.playlist_unavailable_hidden).takeIf { uiState.hidesUnavailable },
         thumbnailUrl = videos.firstOrNull()?.thumbnailUrl ?: uiState.thumbnailUrl,
         isSaved = uiState.isSaved,
         canSave = !isUserCreated,
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/settings/diagnostics/DiagnosticsViewModel.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/settings/diagnostics/DiagnosticsViewModel.kt
index cdd4efdcf7..da260bf376 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/settings/diagnostics/DiagnosticsViewModel.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/settings/diagnostics/DiagnosticsViewModel.kt
@@ -7,13 +7,10 @@ import dagger.hilt.android.lifecycle.HiltViewModel
 import dagger.hilt.android.qualifiers.ApplicationContext
 import io.github.aedev.flow.data.local.PlayerPreferences
 import io.github.aedev.flow.data.recommendation.snapshot.HomeSnapshotStore
-import io.github.aedev.flow.player.stream.ClientGateTracker
+import io.github.aedev.flow.player.stream.ResetYouTubeSession
 import io.github.aedev.flow.ui.screens.settings.SettingsViewModel
 import io.github.aedev.flow.utils.DeviceInfo
 import io.github.aedev.flow.utils.FlowDiagnostics
-import io.github.aedev.flow.utils.cipher.CipherDeobfuscator
-import io.github.aedev.flow.utils.cipher.PlayerJsFetcher
-import io.github.aedev.flow.utils.potoken.WebPoTokenSession
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
@@ -29,6 +26,7 @@ class DiagnosticsViewModel
         @ApplicationContext private val context: Context,
         private val preferences: PlayerPreferences,
         private val snapshots: HomeSnapshotStore,
+        private val resetYouTubeSession: ResetYouTubeSession,
     ) : SettingsViewModel() {
         val device: DeviceInfo by lazy { FlowDiagnostics.deviceInfo(context) }
 
@@ -77,15 +75,5 @@ class DiagnosticsViewModel
                 _crashes.value = LogState.Empty
             }
 
-        /**
-         * Re-attesting alone cannot lift a verdict the stream servers already reached about this
-         * visitor, so the identity itself is discarded: the supported form of the "clear app data"
-         * workaround for videos that stall a minute in.
-         */
-        suspend fun resetSession() {
-            WebPoTokenSession.resetIdentity()
-            ClientGateTracker.clear()
-            CipherDeobfuscator.invalidateSignatureTimestamp()
-            withContext(Dispatchers.IO) { PlayerJsFetcher.invalidateCache() }
-        }
+        suspend fun resetSession() = resetYouTubeSession()
     }
diff --git a/app/src/main/java/io/github/aedev/flow/utils/potoken/VisitorIdentityStore.kt b/app/src/main/java/io/github/aedev/flow/utils/potoken/VisitorIdentityStore.kt
index d3198528f5..6de48cf59c 100644
--- a/app/src/main/java/io/github/aedev/flow/utils/potoken/VisitorIdentityStore.kt
+++ b/app/src/main/java/io/github/aedev/flow/utils/potoken/VisitorIdentityStore.kt
@@ -2,6 +2,7 @@ package io.github.aedev.flow.utils.potoken
 
 import android.content.Context
 import android.content.SharedPreferences
+import android.net.ConnectivityManager
 import dagger.hilt.android.qualifiers.ApplicationContext
 import javax.inject.Inject
 import javax.inject.Singleton
@@ -47,9 +48,31 @@ class VisitorIdentityStore
                 .edit()
                 .putString(KEY_VISITOR, visitorData)
                 .putLong(KEY_SAVED_AT, nowMs)
+                .putLong(KEY_NETWORK, activeNetworkHandle() ?: NO_NETWORK)
                 .apply()
         }
 
+        /** How long ago the visitor in use was saved, or null when none is. */
+        fun visitorAgeMs(nowMs: Long = System.currentTimeMillis()): Long? =
+            prefs.getLong(KEY_SAVED_AT, 0L).takeIf { it > 0L }?.let { nowMs - it }
+
+        /**
+         * Whether the visitor in use was minted on another network than the one active now. A
+         * visitor saved before the network was recorded counts as minted elsewhere.
+         */
+        fun mintedOnOtherNetwork(): Boolean {
+            val minted = prefs.getLong(KEY_NETWORK, NO_NETWORK)
+            return minted == NO_NETWORK || minted != activeNetworkHandle()
+        }
+
+        private fun activeNetworkHandle(): Long? =
+            runCatching {
+                context
+                    .getSystemService(ConnectivityManager::class.java)
+                    ?.activeNetwork
+                    ?.networkHandle
+            }.getOrNull()
+
         /**
          * Spends one identity re-roll from the persisted budget. Returns the time it was taken, to
          * hand back to [refundReroll] if the replacement could not be fetched, or null when the
@@ -86,6 +109,8 @@ class VisitorIdentityStore
             const val KEY_VISITOR = "visitor_data"
             const val KEY_SAVED_AT = "visitor_data_saved_at"
             const val KEY_REROLLS = "visitor_rerolls"
+            const val KEY_NETWORK = "visitor_data_network"
+            const val NO_NETWORK = -1L
             const val LEGACY_PREFS_NAME = "flow_prefs"
             const val LEGACY_KEY_VISITOR = "visitor_data"
             const val LEGACY_KEY_FETCHED_AT = "visitor_data_fetched_at"
diff --git a/app/src/main/java/io/github/aedev/flow/utils/potoken/WebPoTokenSession.kt b/app/src/main/java/io/github/aedev/flow/utils/potoken/WebPoTokenSession.kt
index 02df565329..f0a9dce7ce 100644
--- a/app/src/main/java/io/github/aedev/flow/utils/potoken/WebPoTokenSession.kt
+++ b/app/src/main/java/io/github/aedev/flow/utils/potoken/WebPoTokenSession.kt
@@ -41,6 +41,10 @@ object WebPoTokenSession {
 
     @Volatile
     private var lastWallRerollMs = 0L
+
+    // The generation a /player wall re-roll produced, so its own wall is not answered with another.
+    @Volatile
+    private var playerWallRerollGeneration = -1
     private val visitorMutex = Mutex()
     private val rotationMutex = Mutex()
 
@@ -247,6 +251,61 @@ object WebPoTokenSession {
         }
     }
 
+    /**
+     * Every client was bot-walled at /player, which issues no stream URLs, so no refusal ever
+     * reaches [rerollAfterWall] (#1354). Replaces the visitor that [walledGeneration] names, once:
+     * a fresh visitor walled again points at the network, not the visitor. The first re-roll on a
+     * network the visitor was not minted on skips the shared budget, since carrying a walled
+     * visitor onto a new network is the case this exists for.
+     */
+    suspend fun rerollAfterPlayerWall(walledGeneration: Int): PlayerWallReroll {
+        rotationMutex.withLock {
+            if (identityGeneration != walledGeneration) return PlayerWallReroll.REROLLED
+            if (playerWallRerollGeneration == identityGeneration) {
+                logWall("every client walled a fresh visitor at /player too")
+                return PlayerWallReroll.FRESH_VISITOR_WALLED
+            }
+            val store = identityStore ?: return PlayerWallReroll.UNAVAILABLE
+            val now = System.currentTimeMillis()
+            val newNetwork = store.mintedOnOtherNetwork()
+            val takenAt =
+                if (newNetwork) {
+                    null
+                } else {
+                    store.tryTakeReroll(now) ?: run {
+                        logWall("every client walled this visitor at /player, but the re-roll budget is spent")
+                        return PlayerWallReroll.UNAVAILABLE
+                    }
+                }
+            val fresh = YouTube.visitorData().getOrNull()?.takeIf { it.isNotBlank() }
+            if (fresh == null) {
+                takenAt?.let(store::refundReroll)
+                logWall("every client walled this visitor at /player; no fresh visitor could be fetched")
+                return PlayerWallReroll.UNAVAILABLE
+            }
+            lastWallRerollMs = now
+            generator.resetSession()
+            consecutiveLowTrustMints = 0
+            tokenRejections = 0
+            YouTube.visitorData = fresh
+            identityGeneration++
+            playerWallRerollGeneration = identityGeneration
+            logWall("every client walled this visitor at /player; re-rolled it (new network=$newNetwork)")
+            return PlayerWallReroll.REROLLED
+        }
+    }
+
+    /**
+     * The visitor's age, generation and whether it was minted on another network, so a wall report
+     * can tell a stuck visitor from a flagged network. Never the visitor itself.
+     */
+    fun identitySummary(): String {
+        val store = identityStore
+        val ageMinutes = store?.visitorAgeMs()?.let { it / 60_000L }
+        return "visitorAge=${ageMinutes?.let { "${it}m" } ?: "unknown"} generation=$identityGeneration " +
+            "mintedOnOtherNetwork=${store?.mintedOnOtherNetwork()}"
+    }
+
     private fun logWall(message: String) {
         Log.w(TAG, message)
         PlayerDiagnostics.logWarning(TAG, message)
@@ -275,3 +334,15 @@ object WebPoTokenSession {
         }
     }
 }
+
+/** What [WebPoTokenSession.rerollAfterPlayerWall] did about a wall on every client. */
+enum class PlayerWallReroll {
+    /** A fresh visitor is in place: walk the ladder again. */
+    REROLLED,
+
+    /** The visitor was already fresh from a wall like this one, so the network is the likelier cause. */
+    FRESH_VISITOR_WALLED,
+
+    /** No re-roll was possible: no store, the budget is spent, or no visitor could be fetched. */
+    UNAVAILABLE,
+}
diff --git a/app/src/main/java/io/github/aedev/flow/widget/core/refresh/WidgetContentSync.kt b/app/src/main/java/io/github/aedev/flow/widget/core/refresh/WidgetContentSync.kt
index 260ab8e97c..a56fe1b023 100644
--- a/app/src/main/java/io/github/aedev/flow/widget/core/refresh/WidgetContentSync.kt
+++ b/app/src/main/java/io/github/aedev/flow/widget/core/refresh/WidgetContentSync.kt
@@ -4,10 +4,10 @@ import android.content.Context
 import android.util.Log
 import androidx.datastore.preferences.core.edit
 import androidx.datastore.preferences.core.stringPreferencesKey
-import androidx.datastore.preferences.preferencesDataStore
 import androidx.glance.appwidget.GlanceAppWidgetManager
 import androidx.glance.appwidget.updateAll
 import dagger.hilt.android.qualifiers.ApplicationContext
+import io.github.aedev.flow.data.local.safePreferencesDataStore
 import io.github.aedev.flow.widget.downloads.DownloadsSource
 import io.github.aedev.flow.widget.onrepeat.OnRepeatSource
 import io.github.aedev.flow.widget.playlist.PlaylistWidgetSource
@@ -36,7 +36,7 @@ import kotlinx.coroutines.sync.withLock
 import javax.inject.Inject
 import javax.inject.Singleton
 
-private val Context.widgetContentStore by preferencesDataStore(name = "widget_content")
+private val Context.widgetContentStore by safePreferencesDataStore(name = "widget_content")
 
 /**
  * Re-renders a content widget when what it draws has changed, and only while one is placed.
diff --git a/app/src/main/java/io/github/aedev/flow/widget/core/state/NowPlayingState.kt b/app/src/main/java/io/github/aedev/flow/widget/core/state/NowPlayingState.kt
index de3acfd0eb..0465b7eff7 100644
--- a/app/src/main/java/io/github/aedev/flow/widget/core/state/NowPlayingState.kt
+++ b/app/src/main/java/io/github/aedev/flow/widget/core/state/NowPlayingState.kt
@@ -6,7 +6,7 @@ import androidx.datastore.preferences.core.edit
 import androidx.datastore.preferences.core.floatPreferencesKey
 import androidx.datastore.preferences.core.longPreferencesKey
 import androidx.datastore.preferences.core.stringPreferencesKey
-import androidx.datastore.preferences.preferencesDataStore
+import io.github.aedev.flow.data.local.safePreferencesDataStore
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
 
@@ -29,7 +29,7 @@ data class NowPlayingSnapshot(
     val speed: Float = 1f,
 )
 
-private val Context.nowPlayingWidgetStore by preferencesDataStore(name = "now_playing_widget")
+private val Context.nowPlayingWidgetStore by safePreferencesDataStore(name = "now_playing_widget")
 
 private object Keys {
     val MEDIA_ID = stringPreferencesKey("media_id")
diff --git a/app/src/main/java/io/github/aedev/flow/widget/core/theme/WidgetThemeSignatureStore.kt b/app/src/main/java/io/github/aedev/flow/widget/core/theme/WidgetThemeSignatureStore.kt
index 07723e996f..e3b15bf2b8 100644
--- a/app/src/main/java/io/github/aedev/flow/widget/core/theme/WidgetThemeSignatureStore.kt
+++ b/app/src/main/java/io/github/aedev/flow/widget/core/theme/WidgetThemeSignatureStore.kt
@@ -3,11 +3,11 @@ package io.github.aedev.flow.widget.core.theme
 import android.content.Context
 import androidx.datastore.preferences.core.edit
 import androidx.datastore.preferences.core.stringPreferencesKey
-import androidx.datastore.preferences.preferencesDataStore
+import io.github.aedev.flow.data.local.safePreferencesDataStore
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.map
 
-private val Context.widgetThemeStore by preferencesDataStore(name = "widget_theme")
+private val Context.widgetThemeStore by safePreferencesDataStore(name = "widget_theme")
 
 private val LAST_SIGNATURE = stringPreferencesKey("last_signature")
 
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index d3a42a23ac..33b4b285e9 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -2469,6 +2469,7 @@
     <string name="library_empty_title">Your library is empty</string>
     <string name="library_empty_body">Videos and music you watch, like, save or download will collect here.</string>
     <string name="playlist_load_failed">Could not load this playlist</string>
+    <string name="playlist_unavailable_hidden">Unavailable videos are hidden</string>
     <string name="library_settings_subtitle">Playback, downloads, appearance and data</string>
     <string name="content_settings_header_library">Library</string>
     <string name="content_settings_library_previews_title">Library previews</string>
@@ -2734,6 +2735,9 @@
     <string name="error_captcha_hint">YouTube is asking for bot verification. Please open YouTube in a browser and solve the CAPTCHA, then try again.</string>
     <string name="error_bot_wall">YouTube is blocking this network</string>
     <string name="error_bot_wall_hint">Try another network or turn off your VPN.</string>
+    <string name="error_bot_wall_network_hint">Try another network, such as mobile data.</string>
+    <string name="error_bot_wall_session">YouTube wants to confirm you\'re not a bot</string>
+    <string name="error_bot_wall_session_hint">Reset the YouTube session, then try again.</string>
     <string name="error_login_required">Sign-in required</string>
     <string name="error_login_required_hint">YouTube only plays this video for signed-in accounts.</string>
     <string name="error_not_available">Video not available</string>
diff --git a/app/src/test/java/io/github/aedev/flow/data/local/ReadSafeDataStoreTest.kt b/app/src/test/java/io/github/aedev/flow/data/local/ReadSafeDataStoreTest.kt
new file mode 100644
index 0000000000..7080023ca0
--- /dev/null
+++ b/app/src/test/java/io/github/aedev/flow/data/local/ReadSafeDataStoreTest.kt
@@ -0,0 +1,78 @@
+package io.github.aedev.flow.data.local
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.mutablePreferencesOf
+import androidx.datastore.preferences.core.stringPreferencesKey
+import com.google.common.truth.Truth.assertThat
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.toList
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+import java.io.FileNotFoundException
+import java.io.IOException
+
+class ReadSafeDataStoreTest {
+    private val key = stringPreferencesKey("k")
+    private val stored = mutablePreferencesOf(key to "v")
+
+    private class FailingStore(
+        private val failures: Int,
+        private val error: Throwable,
+        private val value: Preferences,
+    ) : DataStore<Preferences> {
+        var reads = 0
+
+        override val data: Flow<Preferences> =
+            flow {
+                reads++
+                if (reads <= failures) throw error
+                emit(value)
+            }
+
+        override suspend fun updateData(transform: suspend (t: Preferences) -> Preferences): Preferences = transform(value)
+    }
+
+    @Test
+    fun `a read that fails once is retried and returns the stored value`() =
+        runTest {
+            val delegate = FailingStore(1, FileNotFoundException("datastore/player_preferences.preferences_pb"), stored)
+            val store = ReadSafeDataStore("player_preferences", delegate, retryDelayMs = 0)
+
+            assertThat(store.data.first()[key]).isEqualTo("v")
+            assertThat(delegate.reads).isEqualTo(2)
+        }
+
+    @Test
+    fun `a read that keeps failing falls back to defaults instead of throwing`() =
+        runTest {
+            val delegate = FailingStore(Int.MAX_VALUE, IOException("disk"), stored)
+            val store = ReadSafeDataStore("search_history", delegate, retryDelayMs = 0)
+
+            val emitted = store.data.toList()
+
+            assertThat(emitted).hasSize(1)
+            assertThat(emitted.single().asMap()).isEmpty()
+            assertThat(delegate.reads).isEqualTo(4)
+        }
+
+    @Test(expected = IllegalStateException::class)
+    fun `errors that are not IO still propagate`() =
+        runTest {
+            val delegate = FailingStore(1, IllegalStateException("bug"), stored)
+            ReadSafeDataStore("x", delegate, retryDelayMs = 0).data.first()
+        }
+
+    @Test
+    fun `writes go straight to the delegate`() =
+        runTest {
+            val delegate = FailingStore(0, IOException(), stored)
+            val store = ReadSafeDataStore("x", delegate, retryDelayMs = 0)
+
+            val updated = store.updateData { it.toMutablePreferences().apply { set(key, "w") } }
+
+            assertThat(updated[key]).isEqualTo("w")
+        }
+}
diff --git a/app/src/test/java/io/github/aedev/flow/data/repository/PlaylistWalkTest.kt b/app/src/test/java/io/github/aedev/flow/data/repository/PlaylistWalkTest.kt
new file mode 100644
index 0000000000..0dbcc13408
--- /dev/null
+++ b/app/src/test/java/io/github/aedev/flow/data/repository/PlaylistWalkTest.kt
@@ -0,0 +1,90 @@
+package io.github.aedev.flow.data.repository
+
+import com.google.common.truth.Truth.assertThat
+import io.github.aedev.flow.data.model.Video
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class PlaylistWalkTest {
+    private fun video(id: String) =
+        Video(
+            id = id,
+            title = id,
+            channelName = "",
+            channelId = "",
+            thumbnailUrl = "",
+            duration = 0,
+            viewCount = 0L,
+            uploadDate = "",
+        )
+
+    private fun pages(vararg entries: Pair<String, Pair<List<String>, String?>>): Map<String, Pair<List<Video>, String?>> =
+        entries.associate { (token, page) -> token to (page.first.map(::video) to page.second) }
+
+    @Test
+    fun `walks every page until there is no next token`() =
+        runTest {
+            val book = pages("p2" to (listOf("c", "b") to "p3"), "p3" to (listOf("d") to null))
+            val seen = mutableListOf<Int>()
+
+            val walk = walkPlaylistPages(listOf(video("a"), video("b")), "p2", 60, { book[it] }, onPage = { seen += it.size })
+
+            assertThat(walk.finished).isTrue()
+            assertThat(walk.videos.map { it.id }).containsExactly("a", "b", "c", "d").inOrder()
+            assertThat(seen).containsExactly(3, 4).inOrder()
+        }
+
+    @Test
+    fun `an empty page that still points further does not end the walk`() =
+        runTest {
+            val book = pages("p2" to (emptyList<String>() to "p3"), "p3" to (listOf("b") to null))
+
+            val walk = walkPlaylistPages(listOf(video("a")), "p2", 60, { book[it] })
+
+            assertThat(walk.finished).isTrue()
+            assertThat(walk.videos.map { it.id }).containsExactly("a", "b").inOrder()
+        }
+
+    @Test
+    fun `a failed page leaves the walk unfinished`() =
+        runTest {
+            val book = pages("p2" to (listOf("b") to "p3"))
+
+            val walk = walkPlaylistPages(listOf(video("a")), "p2", 60, { book[it] })
+
+            assertThat(walk.finished).isFalse()
+            assertThat(walk.videos.map { it.id }).containsExactly("a", "b").inOrder()
+        }
+
+    @Test
+    fun `a repeated token or the page budget stops an unfinished walk`() =
+        runTest {
+            var loopRequests = 0
+            val looping =
+                walkPlaylistPages(listOf(video("a")), "same", 60, {
+                    loopRequests++
+                    listOf(video("x$loopRequests")) to "same"
+                })
+
+            assertThat(looping.finished).isFalse()
+            assertThat(loopRequests).isEqualTo(1)
+
+            var budgetRequests = 0
+            val capped =
+                walkPlaylistPages(listOf(video("a")), "t0", 3, {
+                    budgetRequests++
+                    listOf(video("y$budgetRequests")) to "t$budgetRequests"
+                })
+
+            assertThat(capped.finished).isFalse()
+            assertThat(budgetRequests).isEqualTo(2)
+        }
+
+    @Test
+    fun `a playlist with one page is finished at once`() =
+        runTest {
+            val walk = walkPlaylistPages(listOf(video("a")), null, 60, { error("no next page") })
+
+            assertThat(walk.finished).isTrue()
+        }
+}
diff --git a/app/src/test/java/io/github/aedev/flow/innertube/pages/VideoPlaylistPageTest.kt b/app/src/test/java/io/github/aedev/flow/innertube/pages/VideoPlaylistPageTest.kt
index 977f421053..e44c37439e 100644
--- a/app/src/test/java/io/github/aedev/flow/innertube/pages/VideoPlaylistPageTest.kt
+++ b/app/src/test/java/io/github/aedev/flow/innertube/pages/VideoPlaylistPageTest.kt
@@ -144,4 +144,66 @@ class VideoPlaylistPageTest {
         assertThat(page.continuation).isNull()
         assertThat(page.title).isNull()
     }
+
+    private fun shortsLockup(
+        id: String,
+        title: String,
+    ) = """
+        {"richItemRenderer": {"content": {"shortsLockupViewModel": {
+          "entityId": "e-$id",
+          "onTap": {"innertubeCommand": {
+            "commandMetadata": {"webCommandMetadata": {"url": "/shorts/$id"}},
+            "reelWatchEndpoint": {"videoId": "$id", "playlistId": "PLshorts"}
+          }},
+          "overlayMetadata": {"primaryText": {"content": "$title"}, "secondaryText": {"content": "407 views"}}
+        }}}}
+        """
+
+    @Test
+    fun `a Shorts-only playlist reads its grid and the header count (#1358)`() {
+        val page =
+            Json
+                .parseToJsonElement(
+                    """
+                    {
+                      "contents": {"twoColumnBrowseResultsRenderer": {"tabs": [{"tabRenderer": {"content": {
+                        "sectionListRenderer": {"contents": [{"itemSectionRenderer": {"contents": [
+                          {"richGridRenderer": {"contents": [
+                            ${shortsLockup("short1", "Say yes")},
+                            ${shortsLockup("short2", "Night drive")}
+                          ]}}
+                        ]}}]}
+                      }}}]}},
+                      "sidebar": {"playlistSidebarRenderer": {"items": [{"playlistSidebarPrimaryInfoRenderer": {
+                        "title": {"runs": [{"text": "Lyrics"}]},
+                        "stats": [{"runs": [{"text": "1,167"}, {"text": " videos"}]}, {"simpleText": "3,691 views"}]
+                      }}]}}
+                    }
+                    """,
+                ).toVideoPlaylistPage()
+
+        assertThat(page.isShortsGrid).isTrue()
+        assertThat(page.videos.map { it.id }).containsExactly("short1", "short2").inOrder()
+        assertThat(page.videos.first().isShort).isTrue()
+        assertThat(page.continuation).isNull()
+        assertThat(page.videoCount).isEqualTo(1167)
+    }
+
+    @Test
+    fun `a list page is not a grid`() {
+        val page =
+            Json
+                .parseToJsonElement(
+                    """
+                    {"contents": {"twoColumnBrowseResultsRenderer": {"tabs": [{"tabRenderer": {"content": {
+                      "sectionListRenderer": {"contents": [{"itemSectionRenderer": {"contents": [
+                        ${lockup("vid1", "Lesson one", "Telusko", "UCtelusko")}
+                      ]}}]}
+                    }}}]}}}
+                    """,
+                ).toVideoPlaylistPage()
+
+        assertThat(page.isShortsGrid).isFalse()
+        assertThat(page.videoCount).isNull()
+    }
 }
diff --git a/app/src/test/java/io/github/aedev/flow/player/audio/AudioSessionAnnouncerTest.kt b/app/src/test/java/io/github/aedev/flow/player/audio/AudioSessionAnnouncerTest.kt
new file mode 100644
index 0000000000..7cd233a4c4
--- /dev/null
+++ b/app/src/test/java/io/github/aedev/flow/player/audio/AudioSessionAnnouncerTest.kt
@@ -0,0 +1,68 @@
+package io.github.aedev.flow.player.audio
+
+import android.media.audiofx.AudioEffect
+import androidx.media3.exoplayer.ExoPlayer
+import com.google.common.truth.Truth.assertThat
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.verify
+import org.junit.Test
+
+class AudioSessionAnnouncerTest {
+    private val registry = AudioSessionRegistry(mockk(relaxed = true))
+
+    private fun player(sessionId: Int): ExoPlayer =
+        mockk(relaxed = true) {
+            every { audioSessionId } returns sessionId
+            every { isPlaying } returns false
+        }
+
+    @Test
+    fun `the id ExoPlayer reports after build is opened`() {
+        val ids = mutableListOf<Int>()
+        val announcer = AudioSessionAnnouncer(registry, AudioEffect.CONTENT_TYPE_MOVIE) { ids += it }
+        announcer.attach(player(0))
+
+        assertThat(registry.activeSessionId.value).isEqualTo(AudioEffect.ERROR_BAD_VALUE)
+
+        announcer.onAudioSessionIdChanged(41)
+
+        assertThat(registry.activeSessionId.value).isEqualTo(41)
+        assertThat(registry.contentTypeOf(41)).isEqualTo(AudioEffect.CONTENT_TYPE_MOVIE)
+        assertThat(ids).containsExactly(41)
+    }
+
+    @Test
+    fun `a changed id closes the old session`() {
+        val announcer = AudioSessionAnnouncer(registry, AudioEffect.CONTENT_TYPE_MUSIC)
+        announcer.attach(player(41))
+        announcer.onAudioSessionIdChanged(42)
+
+        assertThat(registry.contentTypeOf(41)).isNull()
+        assertThat(registry.activeSessionId.value).isEqualTo(42)
+    }
+
+    @Test
+    fun `the player that starts playing takes the system equalizer`() {
+        val video = AudioSessionAnnouncer(registry, AudioEffect.CONTENT_TYPE_MOVIE).apply { attach(player(41)) }
+        AudioSessionAnnouncer(registry, AudioEffect.CONTENT_TYPE_MUSIC).apply { attach(player(42)) }
+
+        assertThat(registry.activeSessionId.value).isEqualTo(42)
+
+        video.onIsPlayingChanged(true)
+
+        assertThat(registry.activeSessionId.value).isEqualTo(41)
+    }
+
+    @Test
+    fun `detach removes the listener and closes the session`() {
+        val exo = player(41)
+        val announcer = AudioSessionAnnouncer(registry, AudioEffect.CONTENT_TYPE_MOVIE)
+        announcer.attach(exo)
+        announcer.detach()
+
+        verify { exo.removeListener(announcer) }
+        assertThat(registry.contentTypeOf(41)).isNull()
+        assertThat(registry.activeSessionId.value).isEqualTo(AudioEffect.ERROR_BAD_VALUE)
+    }
+}
diff --git a/app/src/test/java/io/github/aedev/flow/player/audio/AudioSessionRegistryTest.kt b/app/src/test/java/io/github/aedev/flow/player/audio/AudioSessionRegistryTest.kt
new file mode 100644
index 0000000000..2168ca6c9a
--- /dev/null
+++ b/app/src/test/java/io/github/aedev/flow/player/audio/AudioSessionRegistryTest.kt
@@ -0,0 +1,77 @@
+package io.github.aedev.flow.player.audio
+
+import android.media.audiofx.AudioEffect
+import com.google.common.truth.Truth.assertThat
+import io.mockk.mockk
+import org.junit.Test
+
+class AudioSessionRegistryTest {
+    private val registry = AudioSessionRegistry(mockk(relaxed = true))
+    private val music = AudioEffect.CONTENT_TYPE_MUSIC
+    private val movie = AudioEffect.CONTENT_TYPE_MOVIE
+
+    @Test
+    fun `session id 0 is never opened`() {
+        registry.open(0, music)
+        registry.playing(0)
+
+        assertThat(registry.activeSessionId.value).isEqualTo(AudioEffect.ERROR_BAD_VALUE)
+        assertThat(registry.contentTypeOf(0)).isNull()
+    }
+
+    @Test
+    fun `a session that appears while nothing plays becomes active`() {
+        registry.open(11, music)
+
+        assertThat(registry.activeSessionId.value).isEqualTo(11)
+    }
+
+    @Test
+    fun `a new idle session does not take over from one that is playing`() {
+        registry.open(11, movie)
+        registry.playing(11)
+        registry.open(22, music)
+
+        assertThat(registry.activeSessionId.value).isEqualTo(11)
+    }
+
+    @Test
+    fun `the session that starts playing becomes active`() {
+        registry.open(11, movie)
+        registry.open(22, music)
+        registry.playing(11)
+        registry.paused(11)
+        registry.playing(22)
+
+        assertThat(registry.activeSessionId.value).isEqualTo(22)
+        assertThat(registry.contentTypeOf(22)).isEqualTo(music)
+    }
+
+    @Test
+    fun `closing the active session falls back to one still playing`() {
+        registry.open(11, movie)
+        registry.open(22, movie)
+        registry.open(33, music)
+        registry.playing(22)
+        registry.playing(33)
+        registry.close(33)
+
+        assertThat(registry.activeSessionId.value).isEqualTo(22)
+    }
+
+    @Test
+    fun `closing the last session clears the active one`() {
+        registry.open(11, music)
+        registry.close(11)
+
+        assertThat(registry.activeSessionId.value).isEqualTo(AudioEffect.ERROR_BAD_VALUE)
+    }
+
+    @Test
+    fun `playing a session that is not open changes nothing`() {
+        registry.open(11, music)
+        registry.playing(99)
+
+        assertThat(registry.activeSessionId.value).isEqualTo(11)
+    }
+}
diff --git a/app/src/test/java/io/github/aedev/flow/player/error/VideoErrorMapperTest.kt b/app/src/test/java/io/github/aedev/flow/player/error/VideoErrorMapperTest.kt
index 4362ee26b3..43038dc76b 100644
--- a/app/src/test/java/io/github/aedev/flow/player/error/VideoErrorMapperTest.kt
+++ b/app/src/test/java/io/github/aedev/flow/player/error/VideoErrorMapperTest.kt
@@ -16,12 +16,21 @@ class VideoErrorMapperTest {
         }
 
     @Test
-    fun `a bot wall names the network instead of an unknown error`() {
+    fun `a bot wall on the visitor offers a session reset instead of blaming the network`() {
         val error = VideoErrorMapper.from(context, PlaybackBlockedException(PlaybackBlock.BOT_WALL))
 
-        assertThat(error.message).isEqualTo("string:${R.string.error_bot_wall}")
-        assertThat(error.hint).isEqualTo("string:${R.string.error_bot_wall_hint}")
+        assertThat(error.message).isEqualTo("string:${R.string.error_bot_wall_session}")
+        assertThat(error.hint).isEqualTo("string:${R.string.error_bot_wall_session_hint}")
         assertThat(error.isRetryable).isTrue()
+        assertThat(error.offersSessionReset).isTrue()
+    }
+
+    @Test
+    fun `a wall that held for a fresh visitor names the network, and no VPN unless one is on (#1354)`() {
+        val error = VideoErrorMapper.from(context, PlaybackBlockedException(PlaybackBlock.NETWORK_WALL))
+
+        assertThat(error.message).isEqualTo("string:${R.string.error_bot_wall}")
+        assertThat(error.hint).isEqualTo("string:${R.string.error_bot_wall_network_hint}")
     }
 
     @Test
diff --git a/app/src/test/java/io/github/aedev/flow/player/stream/PlayabilityVerdictTest.kt b/app/src/test/java/io/github/aedev/flow/player/stream/PlayabilityVerdictTest.kt
index 7583b1db23..6c7db2d569 100644
--- a/app/src/test/java/io/github/aedev/flow/player/stream/PlayabilityVerdictTest.kt
+++ b/app/src/test/java/io/github/aedev/flow/player/stream/PlayabilityVerdictTest.kt
@@ -68,10 +68,12 @@ class PlayabilityVerdictTest {
     }
 
     @Test
-    fun `a bot wall on any client blocks the network`() {
+    fun `a wall on every client that answered blocks the visitor, and the network once a fresh one is walled`() {
         val reasons = listOf("VISIONOS: BOT_WALL, reason=Sign in", "MWEB: timeout or null response")
 
         assertThat(PlayabilityVerdict.block(reasons)).isEqualTo(PlaybackBlock.BOT_WALL)
+        assertThat(PlayabilityVerdict.block(reasons, freshVisitorWalled = true)).isEqualTo(PlaybackBlock.NETWORK_WALL)
+        assertThat(PlayabilityVerdict.block(reasons + "IOS: status=ERROR, reason=x")).isNull()
     }
 
     @Test
@@ -86,4 +88,20 @@ class PlayabilityVerdictTest {
         assertThat(PlayabilityVerdict.block(listOf("IOS: status=ERROR, reason=x", "WEB: timeout or null response"))).isNull()
         assertThat(PlayabilityVerdict.block(emptyList())).isNull()
     }
+
+    @Test
+    fun `a wall on every asked client is a full wall, one that answered otherwise is not (#1354)`() {
+        val walled =
+            listOf(
+                "ANDROID_VR: BOT_WALL, reason=Sign in to confirm you're not a bot",
+                "WEB_EMBEDDED: BOT_WALL, reason=Sign in to confirm you're not a bot",
+                "MWEB: PoToken unavailable (WebView missing/broken?)",
+                "all SABR clients demoted: WEB",
+            )
+        assertThat(PlayabilityVerdict.everyClientWalled(walled)).isTrue()
+        assertThat(PlayabilityVerdict.everyClientWalled(walled + "IOS: timeout or null response")).isTrue()
+        assertThat(PlayabilityVerdict.everyClientWalled(walled + "IOS: status=ERROR, reason=x")).isFalse()
+        assertThat(PlayabilityVerdict.everyClientWalled(listOf("MWEB: no visitorData"))).isFalse()
+        assertThat(PlayabilityVerdict.everyClientWalled(emptyList())).isFalse()
+    }
 }
diff --git a/app/src/test/java/io/github/aedev/flow/ui/screens/player/VideoPlayerViewModelHarness.kt b/app/src/test/java/io/github/aedev/flow/ui/screens/player/VideoPlayerViewModelHarness.kt
index bd95198517..82b841798e 100644
--- a/app/src/test/java/io/github/aedev/flow/ui/screens/player/VideoPlayerViewModelHarness.kt
+++ b/app/src/test/java/io/github/aedev/flow/ui/screens/player/VideoPlayerViewModelHarness.kt
@@ -220,6 +220,7 @@ internal class VideoPlayerViewModelHarness(
             localMediaDetails = mockk { coEvery { enrich(any()) } returns null },
             lifecyclePlayback = mockk { every { settings } answers { LifecyclePlaybackSettings(startVideosPaused = startVideosPaused) } },
             autoDownload = autoDownload,
+            resetYouTubeSession = mockk(relaxed = true),
             networkDispatcher = testDispatcher,
             ioDispatcher = testDispatcher,
         )
diff --git a/app/src/test/java/io/github/aedev/flow/ui/screens/playlists/LinkedPlaylistTest.kt b/app/src/test/java/io/github/aedev/flow/ui/screens/playlists/LinkedPlaylistTest.kt
index aceda1f6d9..81857bf61e 100644
--- a/app/src/test/java/io/github/aedev/flow/ui/screens/playlists/LinkedPlaylistTest.kt
+++ b/app/src/test/java/io/github/aedev/flow/ui/screens/playlists/LinkedPlaylistTest.kt
@@ -73,9 +73,9 @@ class LinkedPlaylistTest {
         runTest {
             var requests = 0
             val queue =
-                findLinkedVideoQueue(page(listOf("a"), continuation = "next"), "z", maxPages = 3) {
+                findLinkedVideoQueue(page(listOf("a"), continuation = "next0"), "z", maxPages = 3) {
                     requests++
-                    listOf(video("x$requests")) to "next"
+                    listOf(video("x$requests")) to "next$requests"
                 }
 
             assertNull(queue)
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 8a3e9dac22..c13f476167 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -20,7 +20,7 @@ kotlinxSerialization = "1.11.0"
 gson = "2.14.0"
 media3 = "1.11.0"
 room = "2.8.4"
-datastore = "1.1.1"  # 1.2.1 breaks DataStore unit tests on Windows (renameTo on repeat edits)
+datastore = "1.1.7"  # 1.2.1 breaks DataStore unit tests on Windows (renameTo on repeat edits)
 glance = "1.2.0"
 graphicsShapes = "1.1.0"
 coroutines = "1.11.0"