diff --git a/.github/nightly-notes/2026-10-28-fix-premiere-date-bell-shorts-home-force-dark.md b/.github/nightly-notes/2026-10-28-fix-premiere-date-bell-shorts-home-force-dark.md
new file mode 100644
index 0000000000..2c9fea7db2
--- /dev/null
+++ b/.github/nightly-notes/2026-10-28-fix-premiere-date-bell-shorts-home-force-dark.md
@@ -0,0 +1,8 @@
+## New
+- Choose whether playback keeps going after you swipe Flow away (#1468)
+
+## Fixed
+- Premiere and stream dates fit in the description again (#1466)
+- The notification bell works in search, Shorts, related channels and the video menu (#1467)
+- Shorts stay hidden on a channel's Home tab and in Explore when Show Shorts is off (#1507)
+- Titles and messages stay readable when the phone is in dark mode and Flow is light (#1517)
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 0498c62594..6b89089a3c 100644
--- a/app/src/main/java/io/github/aedev/flow/MainActivity.kt
+++ b/app/src/main/java/io/github/aedev/flow/MainActivity.kt
@@ -150,6 +150,8 @@ class MainActivity : ComponentActivity() {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
             window.isNavigationBarContrastEnforced = false
             window.isStatusBarContrastEnforced = false
+            // Some MIUI builds read force dark from the view rather than the theme (#1517).
+            window.decorView.isForceDarkAllowed = false
         }
 
         // Player setup reads DataStore and opens the media cache index, so it runs off the main
diff --git a/app/src/main/java/io/github/aedev/flow/data/local/PlayerPreferences.kt b/app/src/main/java/io/github/aedev/flow/data/local/PlayerPreferences.kt
index 6955d96af6..ecfa7c2826 100644
--- a/app/src/main/java/io/github/aedev/flow/data/local/PlayerPreferences.kt
+++ b/app/src/main/java/io/github/aedev/flow/data/local/PlayerPreferences.kt
@@ -57,6 +57,9 @@ const val MAX_CONCURRENT_DOWNLOADS = 5
 /** On until turned off, matching NewPipe's default and the Background button (#1298). */
 const val DEFAULT_BACKGROUND_PLAY_ENABLED = true
 
+/** On until turned off: a swipe from recents has kept playback going since #1321. */
+const val DEFAULT_KEEP_PLAYING_AFTER_SWIPE = true
+
 val DEFAULT_NAV_TAB_ORDER = listOf(0, 1, 2, 3, 4, 5, 6, 7)
 
 private const val MAX_UNPLAYABLE_VIDEO_IDS = 1_000
@@ -79,6 +82,7 @@ class PlayerPreferences(
 
     private object Keys {
         val BACKGROUND_PLAY_ENABLED = booleanPreferencesKey("background_play_enabled")
+        val KEEP_PLAYING_AFTER_SWIPE = booleanPreferencesKey("keep_playing_after_swipe")
         val AUTOPLAY_ENABLED = booleanPreferencesKey("autoplay_enabled")
         val QUEUE_AUTOPLAY_ENABLED = booleanPreferencesKey("queue_autoplay_enabled")
         val START_VIDEOS_PAUSED = booleanPreferencesKey("start_videos_paused")
@@ -1652,6 +1656,19 @@ class PlayerPreferences(
         }
     }
 
+    /** Whether swiping Flow away from recent apps leaves a playing video or song going (#1468). */
+    val keepPlayingAfterSwipe: Flow<Boolean> =
+        context.playerPreferencesDataStore.data
+            .map { preferences ->
+                preferences[Keys.KEEP_PLAYING_AFTER_SWIPE] ?: DEFAULT_KEEP_PLAYING_AFTER_SWIPE
+            }
+
+    suspend fun setKeepPlayingAfterSwipe(enabled: Boolean) {
+        context.playerPreferencesDataStore.edit { preferences ->
+            preferences[Keys.KEEP_PLAYING_AFTER_SWIPE] = enabled
+        }
+    }
+
     // Autoplay
     val autoplayEnabled: Flow<Boolean> =
         context.playerPreferencesDataStore.data
diff --git a/app/src/main/java/io/github/aedev/flow/data/local/SubscriptionRepository.kt b/app/src/main/java/io/github/aedev/flow/data/local/SubscriptionRepository.kt
index 97edbeef0b..60782160b3 100644
--- a/app/src/main/java/io/github/aedev/flow/data/local/SubscriptionRepository.kt
+++ b/app/src/main/java/io/github/aedev/flow/data/local/SubscriptionRepository.kt
@@ -11,6 +11,10 @@ import io.github.aedev.flow.data.local.AppDatabase
 import io.github.aedev.flow.data.profile.StoreScope
 import io.github.aedev.flow.utils.ThumbnailUrlResolver
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.map
 
@@ -158,6 +162,12 @@ class SubscriptionRepository private constructor(
             }
         }
 
+    /** The channels whose bell is on. */
+    fun notifyingChannelIds(): Flow<Set<String>> =
+        getAllSubscriptions()
+            .map(::notifyingIds)
+            .distinctUntilChanged()
+
     /**
      * Get all subscription IDs as a Set
      */
@@ -279,6 +289,7 @@ class SubscriptionRepository private constructor(
         channelId: String,
         enabled: Boolean,
     ) {
+        var turnedOn = false
         context.subscriptionsDataStore.edit { preferences ->
             val channelData = preferences[channelKey(channelId)]
             if (channelData != null) {
@@ -286,11 +297,20 @@ class SubscriptionRepository private constructor(
                 if (subscription != null) {
                     val updated = subscription.copy(isNotificationEnabled = enabled)
                     preferences[channelKey(channelId)] = serializeChannel(updated)
+                    turnedOn = enabled && !subscription.isNotificationEnabled
                 }
             }
         }
+        if (turnedOn) bellsTurnedOn.tryEmit(channelId)
     }
 
+    // Every bell in the app writes through updateNotificationState, so this is the one place that
+    // knows a viewer just asked for alerts. Nothing replays: with no shell listening, it is dropped.
+    private val bellsTurnedOn = MutableSharedFlow<String>(extraBufferCapacity = 1)
+
+    /** A channel whose bell the viewer just turned on. */
+    val notificationsTurnedOn: SharedFlow<String> = bellsTurnedOn.asSharedFlow()
+
     /**
      * Record that the subscription feed has just fetched these channels.
      *
@@ -351,3 +371,6 @@ data class ChannelSubscription(
     /** When the subscription feed last fetched this channel; 0 means never. */
     val lastFeedFetchAt: Long = 0L,
 )
+
+internal fun notifyingIds(subscriptions: List<ChannelSubscription>): Set<String> =
+    subscriptions.filter { it.isNotificationEnabled }.mapTo(HashSet()) { it.channelId }
diff --git a/app/src/main/java/io/github/aedev/flow/data/shorts/FeedShelfShorts.kt b/app/src/main/java/io/github/aedev/flow/data/shorts/FeedShelfShorts.kt
new file mode 100644
index 0000000000..3e8c0c8a2e
--- /dev/null
+++ b/app/src/main/java/io/github/aedev/flow/data/shorts/FeedShelfShorts.kt
@@ -0,0 +1,21 @@
+package io.github.aedev.flow.data.shorts
+
+import io.github.aedev.flow.innertube.pages.renderer.FeedItem
+import io.github.aedev.flow.innertube.pages.renderer.FeedShelf
+
+/**
+ * The shelves with every Short taken out, for a viewer who switched Shorts off (#1507). A shelf
+ * left with nothing is dropped rather than drawn as an empty header.
+ */
+fun List<FeedShelf>.withoutShorts(): List<FeedShelf> =
+    mapNotNull { shelf ->
+        val kept = shelf.items.filterNot(FeedItem::isShort)
+        when {
+            kept.size == shelf.items.size -> shelf
+            kept.isEmpty() -> null
+            else -> shelf.copy(items = kept)
+        }
+    }
+
+/** A collaboration reel arrives as a plain video lockup marked as a Short, so both shapes count. */
+fun FeedItem.isShort(): Boolean = this is FeedItem.ShortItem || (this is FeedItem.VideoItem && video.isShort)
diff --git a/app/src/main/java/io/github/aedev/flow/player/LifecyclePlaybackPreferences.kt b/app/src/main/java/io/github/aedev/flow/player/LifecyclePlaybackPreferences.kt
index 69b021c900..1e83bcd574 100644
--- a/app/src/main/java/io/github/aedev/flow/player/LifecyclePlaybackPreferences.kt
+++ b/app/src/main/java/io/github/aedev/flow/player/LifecyclePlaybackPreferences.kt
@@ -1,6 +1,7 @@
 package io.github.aedev.flow.player
 
 import io.github.aedev.flow.data.local.DEFAULT_BACKGROUND_PLAY_ENABLED
+import io.github.aedev.flow.data.local.DEFAULT_KEEP_PLAYING_AFTER_SWIPE
 import io.github.aedev.flow.data.local.PlayerPreferences
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.Flow
@@ -10,8 +11,9 @@ import javax.inject.Inject
 import javax.inject.Singleton
 
 /**
- * The playback preferences read synchronously: by the activity lifecycle callbacks, and by opening a
- * video, which has to know whether to start before any stream is handed to the player.
+ * The playback preferences read synchronously: by the activity lifecycle callbacks, by opening a
+ * video, which has to know whether to start before any stream is handed to the player, and by the
+ * media services when Flow is swiped away, which can happen after the activity is gone.
  */
 data class LifecyclePlaybackSettings(
     val autoPipEnabled: Boolean = false,
@@ -20,6 +22,7 @@ data class LifecyclePlaybackSettings(
     val shortsPipEnabled: Boolean = false,
     val startVideosPaused: Boolean = false,
     val openVideosFullscreen: Boolean = false,
+    val keepPlayingAfterSwipe: Boolean = DEFAULT_KEEP_PLAYING_AFTER_SWIPE,
 )
 
 /**
@@ -68,6 +71,11 @@ private fun PlayerPreferences.lifecyclePlaybackSettings(): Flow<LifecyclePlaybac
         },
         startVideosPaused,
         openVideosFullscreen,
-    ) { settings, startPaused, openFullscreen ->
-        settings.copy(startVideosPaused = startPaused, openVideosFullscreen = openFullscreen)
+        keepPlayingAfterSwipe,
+    ) { settings, startPaused, openFullscreen, keepPlaying ->
+        settings.copy(
+            startVideosPaused = startPaused,
+            openVideosFullscreen = openFullscreen,
+            keepPlayingAfterSwipe = keepPlaying,
+        )
     }
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 159555039e..aaf2bffe8f 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
@@ -63,6 +63,7 @@ import io.github.aedev.flow.data.scrobble.ScrobbleRules
 import io.github.aedev.flow.extensions.setOffloadEnabled
 import io.github.aedev.flow.innertube.YouTube
 import io.github.aedev.flow.innertube.models.WatchEndpoint
+import io.github.aedev.flow.player.LifecyclePlaybackPreferences
 import io.github.aedev.flow.player.MusicFailureStreak
 import io.github.aedev.flow.player.MusicLoadErrorPolicy
 import io.github.aedev.flow.player.MusicMutePause
@@ -222,6 +223,9 @@ class Media3MusicService : MediaLibraryService() {
     @Inject
     lateinit var downloadUtil: DownloadUtil
 
+    @Inject
+    lateinit var lifecyclePlaybackPreferences: LifecyclePlaybackPreferences
+
     @Inject
     lateinit var legacySongs: LegacySongDownloads
 
@@ -531,7 +535,8 @@ class Media3MusicService : MediaLibraryService() {
                             }
                         }
 
-                        if (!versionSwap && !videoId.isNullOrBlank() && !title.isNullOrBlank() && !artist.isNullOrBlank()) {
+                        val wantsLyrics = !versionSwap && !videoId.isNullOrBlank() && !LocalMediaIds.isLocal(videoId)
+                        if (wantsLyrics && !title.isNullOrBlank() && !artist.isNullOrBlank()) {
                             lifecycleScope.launch(Dispatchers.IO) {
                                 try {
                                     Log.d(TAG, "Pre-warming lyrics cache in background for: $videoId - \"$title\"")
@@ -1369,7 +1374,9 @@ class Media3MusicService : MediaLibraryService() {
      */
     @OptIn(UnstableApi::class)
     override fun onTaskRemoved(rootIntent: Intent?) {
-        val keepsPlaying = ::player.isInitialized && player.keepsPlayingOnTaskRemoved(isPlaybackOngoing())
+        val keepsPlaying =
+            ::player.isInitialized &&
+                player.keepsPlayingOnTaskRemoved(lifecyclePlaybackPreferences.settings.keepPlayingAfterSwipe, isPlaybackOngoing())
         PlayerDiagnostics.logInfo(TAG, "onTaskRemoved keepsPlaying=$keepsPlaying ${taskRemovalSnapshot()}")
         if (keepsPlaying) return
         pauseAllPlayersAndStopSelf()
diff --git a/app/src/main/java/io/github/aedev/flow/service/PlaybackServiceEntryPoint.kt b/app/src/main/java/io/github/aedev/flow/service/PlaybackServiceEntryPoint.kt
new file mode 100644
index 0000000000..fc630fecad
--- /dev/null
+++ b/app/src/main/java/io/github/aedev/flow/service/PlaybackServiceEntryPoint.kt
@@ -0,0 +1,13 @@
+package io.github.aedev.flow.service
+
+import dagger.hilt.EntryPoint
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import io.github.aedev.flow.player.LifecyclePlaybackPreferences
+
+/** [VideoPlayerService] is not a Hilt entry point, so the singletons it reads come through here. */
+@EntryPoint
+@InstallIn(SingletonComponent::class)
+interface PlaybackServiceEntryPoint {
+    fun lifecyclePlaybackPreferences(): LifecyclePlaybackPreferences
+}
diff --git a/app/src/main/java/io/github/aedev/flow/service/TaskRemovalPolicy.kt b/app/src/main/java/io/github/aedev/flow/service/TaskRemovalPolicy.kt
index 804666b42d..49d1166ab8 100644
--- a/app/src/main/java/io/github/aedev/flow/service/TaskRemovalPolicy.kt
+++ b/app/src/main/java/io/github/aedev/flow/service/TaskRemovalPolicy.kt
@@ -5,22 +5,29 @@ import androidx.media3.common.Player
 /**
  * Whether a media service stays up when Flow is swiped away from recents. Media3's own rule keeps it
  * only while a session is playing; this also keeps it while a requested song or video is still
- * loading, so a swipe between tracks or during a stall does not end playback. A pause ends it.
+ * loading, so a swipe between tracks or during a stall does not end playback. A pause ends it, and so
+ * does every swipe for a viewer who turned [keepPlayingAfterSwipe] off (#1468).
  */
 internal fun keepsPlayingOnTaskRemoved(
+    keepPlayingAfterSwipe: Boolean,
     playbackOngoing: Boolean,
     playWhenReady: Boolean,
     playbackState: Int,
     hasMedia: Boolean,
 ): Boolean =
-    playbackOngoing &&
+    keepPlayingAfterSwipe &&
+        playbackOngoing &&
         hasMedia &&
         playWhenReady &&
         playbackState != Player.STATE_IDLE &&
         playbackState != Player.STATE_ENDED
 
-internal fun Player.keepsPlayingOnTaskRemoved(playbackOngoing: Boolean): Boolean =
+internal fun Player.keepsPlayingOnTaskRemoved(
+    keepPlayingAfterSwipe: Boolean,
+    playbackOngoing: Boolean,
+): Boolean =
     keepsPlayingOnTaskRemoved(
+        keepPlayingAfterSwipe = keepPlayingAfterSwipe,
         playbackOngoing = playbackOngoing,
         playWhenReady = playWhenReady,
         playbackState = playbackState,
diff --git a/app/src/main/java/io/github/aedev/flow/service/VideoPlayerService.kt b/app/src/main/java/io/github/aedev/flow/service/VideoPlayerService.kt
index 364de957f4..a82e42f6a5 100644
--- a/app/src/main/java/io/github/aedev/flow/service/VideoPlayerService.kt
+++ b/app/src/main/java/io/github/aedev/flow/service/VideoPlayerService.kt
@@ -12,6 +12,7 @@ import androidx.media3.common.util.UnstableApi
 import androidx.media3.session.DefaultMediaNotificationProvider
 import androidx.media3.session.MediaSession
 import androidx.media3.session.MediaSessionService
+import dagger.hilt.android.EntryPointAccessors
 import io.github.aedev.flow.R
 import io.github.aedev.flow.notification.NotificationHelper
 import io.github.aedev.flow.player.EnhancedPlayerManager
@@ -163,8 +164,13 @@ class VideoPlayerService : MediaSessionService() {
             return
         }
 
+        val keepPlayingAfterSwipe =
+            EntryPointAccessors
+                .fromApplication(applicationContext, PlaybackServiceEntryPoint::class.java)
+                .lifecyclePlaybackPreferences()
+                .settings.keepPlayingAfterSwipe
         val player = EnhancedPlayerManager.getInstance().getPlayer()
-        if (player?.keepsPlayingOnTaskRemoved(isPlaybackOngoing()) == true) return
+        if (player?.keepsPlayingOnTaskRemoved(keepPlayingAfterSwipe, isPlaybackOngoing()) == true) return
 
         EnhancedPlayerManager.getInstance().stop()
         releaseLocks()
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 d18dbe6fca..0ca9662370 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
@@ -55,6 +55,7 @@ import io.github.aedev.flow.ui.components.musicplayer.sheet.rememberMusicPlayerS
 import io.github.aedev.flow.ui.components.shared.LocalMediaOpenOrigins
 import io.github.aedev.flow.ui.components.shared.MediaMiniBarDefaults
 import io.github.aedev.flow.ui.components.shared.MediaOpenOrigins
+import io.github.aedev.flow.ui.components.shared.SubscriptionBellAlerts
 import io.github.aedev.flow.ui.components.shared.mediaMiniBarBounds
 import io.github.aedev.flow.ui.components.videoplayer.PlayerSheetValue
 import io.github.aedev.flow.ui.components.videoplayer.rememberPlayerDraggableState
@@ -507,6 +508,7 @@ fun FlowApp(
                                     LocalFlowSnackbarHostState provides snackbarHostState,
                                     LocalStatusBarHero provides statusBarHero,
                                 ) {
+                                    if (needsOnboarding == false) SubscriptionBellAlerts(snackbarHostState)
                                     NavHost(
                                         navController = navController,
                                         startDestination = if (needsOnboarding == true) "onboarding" else defaultStartRoute,
diff --git a/app/src/main/java/io/github/aedev/flow/ui/components/channel/ChannelCards.kt b/app/src/main/java/io/github/aedev/flow/ui/components/channel/ChannelCards.kt
index 8286caa9fa..8e75981e63 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/components/channel/ChannelCards.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/components/channel/ChannelCards.kt
@@ -41,6 +41,8 @@ internal fun ChannelRow(
     isSubscribed: Boolean? = null,
     onSubscribeClick: () -> Unit = {},
     onUnsubscribeClick: () -> Unit = {},
+    isNotificationsEnabled: Boolean = false,
+    onNotificationChange: ((Boolean) -> Unit)? = null,
 ) {
     Row(
         modifier =
@@ -82,6 +84,8 @@ internal fun ChannelRow(
                 isSubscribed = isSubscribed,
                 onSubscribeClick = onSubscribeClick,
                 onUnsubscribeClick = onUnsubscribeClick,
+                isNotificationsEnabled = isNotificationsEnabled,
+                onNotificationChange = onNotificationChange,
                 size = FlowSubscribeButtonSize.Compact,
             )
         }
diff --git a/app/src/main/java/io/github/aedev/flow/ui/components/search/SearchChannelHeroCard.kt b/app/src/main/java/io/github/aedev/flow/ui/components/search/SearchChannelHeroCard.kt
index 0f1b8f0ce8..174e90ec8c 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/components/search/SearchChannelHeroCard.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/components/search/SearchChannelHeroCard.kt
@@ -56,6 +56,8 @@ fun SearchChannelHeroCard(
     onSubscribeToggle: () -> Unit,
     onClick: () -> Unit,
     modifier: Modifier = Modifier,
+    isNotificationsEnabled: Boolean = false,
+    onNotificationChange: ((Boolean) -> Unit)? = null,
     latestTitle: String? = null,
     latestVideos: List<Video> = emptyList(),
     onVideoClick: (Video) -> Unit = {},
@@ -94,6 +96,8 @@ fun SearchChannelHeroCard(
                         ChannelActions(
                             isSubscribed = isSubscribed,
                             onSubscribeToggle = onSubscribeToggle,
+                            isNotificationsEnabled = isNotificationsEnabled,
+                            onNotificationChange = onNotificationChange,
                             onOpen = onClick,
                             tint = tint,
                             modifier = Modifier.width(InlineActionsColumn),
@@ -105,6 +109,8 @@ fun SearchChannelHeroCard(
                     ChannelActions(
                         isSubscribed = isSubscribed,
                         onSubscribeToggle = onSubscribeToggle,
+                        isNotificationsEnabled = isNotificationsEnabled,
+                        onNotificationChange = onNotificationChange,
                         onOpen = onClick,
                         tint = tint,
                         modifier = Modifier.fillMaxWidth().padding(horizontal = CardHorizontalPadding),
@@ -171,6 +177,8 @@ private fun ChannelIdentity(
 private fun ChannelActions(
     isSubscribed: Boolean,
     onSubscribeToggle: () -> Unit,
+    isNotificationsEnabled: Boolean,
+    onNotificationChange: ((Boolean) -> Unit)?,
     onOpen: () -> Unit,
     tint: MediaArtworkTint,
     modifier: Modifier = Modifier,
@@ -184,6 +192,8 @@ private fun ChannelActions(
             isSubscribed = isSubscribed,
             onSubscribeClick = onSubscribeToggle,
             onUnsubscribeClick = onSubscribeToggle,
+            isNotificationsEnabled = isNotificationsEnabled,
+            onNotificationChange = onNotificationChange,
             size = FlowSubscribeButtonSize.Wide,
             tint = tint,
             modifier = if (isSubscribed) Modifier else Modifier.weight(1f),
diff --git a/app/src/main/java/io/github/aedev/flow/ui/components/search/SearchResults.kt b/app/src/main/java/io/github/aedev/flow/ui/components/search/SearchResults.kt
index 376e7fea10..618840ac57 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/components/search/SearchResults.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/components/search/SearchResults.kt
@@ -41,6 +41,8 @@ data class SearchResultActions(
     val dismissKeyboard: () -> Unit,
     val isSubscribed: (String) -> Boolean = { false },
     val onSubscribeToggle: (Channel) -> Unit = {},
+    val isNotifying: (String) -> Boolean = { false },
+    val onNotificationChange: (Channel, Boolean) -> Unit = { _, _ -> },
 )
 
 @Composable
@@ -92,6 +94,8 @@ fun SearchResults(
                         channel = item.channel,
                         isSubscribed = actions.isSubscribed(item.channel.id),
                         onSubscribeToggle = { actions.onSubscribeToggle(item.channel) },
+                        isNotificationsEnabled = actions.isNotifying(item.channel.id),
+                        onNotificationChange = { actions.onNotificationChange(item.channel, it) },
                         onClick = { actions.onChannelClick(item.channel) },
                         latestTitle = item.latestTitle,
                         latestVideos = item.latestVideos,
diff --git a/app/src/main/java/io/github/aedev/flow/ui/components/shared/CollaboratorsBottomSheet.kt b/app/src/main/java/io/github/aedev/flow/ui/components/shared/CollaboratorsBottomSheet.kt
index 6233fb6f19..66f9bf2962 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/components/shared/CollaboratorsBottomSheet.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/components/shared/CollaboratorsBottomSheet.kt
@@ -52,6 +52,8 @@ internal fun collaboratorRows(
     viewModel: QuickActionsViewModel,
 ): List<QuickActionRow> {
     val subscribedChannelIds = subscribedCollaboratorIds(collaborators, viewModel)
+    val bell = sharedSubscriptionBellViewModel()
+    val notifyingChannelIds by bell.notifyingChannelIds.collectAsStateWithLifecycle()
     val navigator = LocalMediaNavigator.current
     val fallbackName = stringResource(R.string.collaborator)
     val ringColor = MaterialTheme.colorScheme.surfaceContainerHigh
@@ -87,6 +89,8 @@ internal fun collaboratorRows(
                                 isSubscribed = collaborator.channelId in subscribedChannelIds,
                                 onSubscribeClick = toggle,
                                 onUnsubscribeClick = toggle,
+                                isNotificationsEnabled = collaborator.channelId in notifyingChannelIds,
+                                onNotificationChange = { bell.setNotifications(collaborator.channelId, it) },
                                 size = FlowSubscribeButtonSize.Compact,
                             )
                         }
diff --git a/app/src/main/java/io/github/aedev/flow/ui/components/shared/DescriptionFactoids.kt b/app/src/main/java/io/github/aedev/flow/ui/components/shared/DescriptionFactoids.kt
new file mode 100644
index 0000000000..1f2371e2ce
--- /dev/null
+++ b/app/src/main/java/io/github/aedev/flow/ui/components/shared/DescriptionFactoids.kt
@@ -0,0 +1,111 @@
+package io.github.aedev.flow.ui.components.shared
+
+import android.text.format.DateFormat
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.res.stringResource
+import io.github.aedev.flow.R
+import io.github.aedev.flow.data.model.Video
+import io.github.aedev.flow.innertube.YouTube
+import io.github.aedev.flow.innertube.pages.VideoDescriptionFactoid
+import io.github.aedev.flow.innertube.pages.VideoDescriptionPage
+import io.github.aedev.flow.utils.DateDisplayMode
+import io.github.aedev.flow.utils.DateFormatStyle
+import io.github.aedev.flow.utils.exactUploadTimestamp
+import io.github.aedev.flow.utils.formatLikeCount
+import io.github.aedev.flow.utils.formatUploadDateConfigured
+import io.github.aedev.flow.utils.resolveDisplayUploadTimestamp
+import io.github.aedev.flow.utils.withoutStreamOrPremiereWords
+import java.text.NumberFormat
+import java.time.Instant
+import java.time.ZoneId
+import java.time.format.DateTimeFormatter
+import java.util.Locale
+
+internal enum class DescriptionDateKind { UPLOADED, PREMIERED, STREAMED }
+
+/** What the description's date card can say: a calendar day, or only an age. */
+internal sealed interface DescriptionDate {
+    data class OnDay(
+        val timestampMs: Long,
+    ) : DescriptionDate
+
+    data class Aged(
+        val ageText: String,
+        val kind: DescriptionDateKind,
+    ) : DescriptionDate
+}
+
+internal fun readDescriptionDate(
+    dateText: String?,
+    timestampMs: Long,
+    timestampIsExact: Boolean,
+    nowMillis: Long = System.currentTimeMillis(),
+    hl: String? = YouTube.locale.hl,
+): DescriptionDate {
+    val resolved = resolveDisplayUploadTimestamp(dateText, timestampMs, nowMillis, hl)
+    val exact = exactUploadTimestamp(dateText, resolved, timestampMs, timestampIsExact, nowMillis, hl)
+    if (exact != null && exact > 0L) return DescriptionDate.OnDay(exact)
+    val text = dateText?.trim().orEmpty()
+    val kind =
+        when {
+            text.startsWith("premiered ", ignoreCase = true) -> DescriptionDateKind.PREMIERED
+            text.startsWith("streamed ", ignoreCase = true) -> DescriptionDateKind.STREAMED
+            else -> DescriptionDateKind.UPLOADED
+        }
+    return DescriptionDate.Aged(withoutStreamOrPremiereWords(text), kind)
+}
+
+/**
+ * The three cards for a description the server sent no figures for, which is every premiere and past
+ * stream (#1466). The date takes the shape YouTube's app gives it, the day on top and the year below,
+ * because a whole "Premiered 2 days ago" does not fit a third of the row.
+ */
+@Composable
+internal fun fallbackFactoids(
+    video: Video,
+    descriptionPage: VideoDescriptionPage?,
+): List<VideoDescriptionFactoid> {
+    val locale = Locale.getDefault()
+    val dateText = descriptionPage?.publishedDateText ?: video.uploadDate
+    val date =
+        when (val read = readDescriptionDate(dateText, video.timestamp, video.timestampIsExact)) {
+            is DescriptionDate.OnDay -> {
+                val day = Instant.ofEpochMilli(read.timestampMs).atZone(ZoneId.systemDefault())
+                VideoDescriptionFactoid(
+                    value = DateTimeFormatter.ofPattern(DateFormat.getBestDateTimePattern(locale, "MMMd"), locale).format(day),
+                    label = DateTimeFormatter.ofPattern("y", locale).format(day),
+                )
+            }
+
+            is DescriptionDate.Aged -> {
+                VideoDescriptionFactoid(
+                    value =
+                        formatUploadDateConfigured(
+                            date = read.ageText,
+                            mode = DateDisplayMode.RELATIVE,
+                            style = DateFormatStyle.SYSTEM,
+                            timestampFallbackMs = video.timestamp,
+                            locale = locale,
+                            timestampIsExact = video.timestampIsExact,
+                        ),
+                    label =
+                        when (read.kind) {
+                            DescriptionDateKind.PREMIERED -> stringResource(R.string.description_premiered)
+                            DescriptionDateKind.STREAMED -> stringResource(R.string.description_streamed)
+                            DescriptionDateKind.UPLOADED -> stringResource(R.string.uploaded)
+                        },
+                )
+            }
+        }
+    return listOf(
+        VideoDescriptionFactoid(
+            value = formatLikeCount(video.likeCount.toInt()),
+            label = stringResource(R.string.likes),
+        ),
+        VideoDescriptionFactoid(
+            value = NumberFormat.getIntegerInstance(locale).format(descriptionPage?.viewCount ?: video.viewCount),
+            label = stringResource(R.string.views),
+        ),
+        date,
+    )
+}
diff --git a/app/src/main/java/io/github/aedev/flow/ui/components/shared/FlowDescriptionBottomSheet.kt b/app/src/main/java/io/github/aedev/flow/ui/components/shared/FlowDescriptionBottomSheet.kt
index 6910af21dc..10455de43e 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/components/shared/FlowDescriptionBottomSheet.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/components/shared/FlowDescriptionBottomSheet.kt
@@ -31,20 +31,15 @@ import io.github.aedev.flow.R
 import io.github.aedev.flow.data.model.RichTextTarget
 import io.github.aedev.flow.data.model.Video
 import io.github.aedev.flow.data.model.plainRichText
-import io.github.aedev.flow.innertube.pages.VideoDescriptionFactoid
 import io.github.aedev.flow.innertube.pages.VideoDescriptionPage
 import io.github.aedev.flow.ui.components.layout.navigation.LocalMediaNavigator
 import io.github.aedev.flow.ui.components.shared.FlowBottomSheet
 import io.github.aedev.flow.ui.components.shared.FlowSheetHeader
 import io.github.aedev.flow.ui.components.shared.card.LocalVideoCardPreferences
 import io.github.aedev.flow.ui.components.shared.defaultSheetExpandedHeight
-import io.github.aedev.flow.ui.components.shared.rememberDateDisplaySettings
 import io.github.aedev.flow.ui.components.shared.rememberFlowBottomSheetState
 import io.github.aedev.flow.ui.components.shared.rememberRichTextInlineContent
 import io.github.aedev.flow.ui.openYouTubeUrl
-import io.github.aedev.flow.utils.DateContext
-import io.github.aedev.flow.utils.formatLikeCount
-import io.github.aedev.flow.utils.formatViewCount
 import io.github.aedev.flow.utils.toAnnotatedString
 
 @OptIn(ExperimentalLayoutApi::class)
@@ -173,29 +168,7 @@ fun FlowDescriptionBottomSheet(
                 )
             }
 
-            val dateSettings = rememberDateDisplaySettings()
-            val stats =
-                descriptionPage?.factoids?.takeIf { it.isNotEmpty() }
-                    ?: listOf(
-                        VideoDescriptionFactoid(
-                            value = formatLikeCount(video.likeCount.toInt()),
-                            label = stringResource(R.string.likes),
-                        ),
-                        VideoDescriptionFactoid(
-                            value = formatViewCount(descriptionPage?.viewCount ?: video.viewCount),
-                            label = stringResource(R.string.views),
-                        ),
-                        VideoDescriptionFactoid(
-                            value =
-                                dateSettings.format(
-                                    descriptionPage?.publishedDateText ?: video.uploadDate,
-                                    DateContext.DESCRIPTION,
-                                    video.timestamp,
-                                    video.timestampIsExact,
-                                ),
-                            label = stringResource(R.string.uploaded),
-                        ),
-                    )
+            val stats = descriptionPage?.factoids?.takeIf { it.isNotEmpty() } ?: fallbackFactoids(video, descriptionPage)
 
             Row(horizontalArrangement = Arrangement.spacedBy(CardSpacing)) {
                 stats.forEach { factoid ->
diff --git a/app/src/main/java/io/github/aedev/flow/ui/components/shared/FlowSubscribeButton.kt b/app/src/main/java/io/github/aedev/flow/ui/components/shared/FlowSubscribeButton.kt
index a440420fe5..e640159f50 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/components/shared/FlowSubscribeButton.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/components/shared/FlowSubscribeButton.kt
@@ -141,7 +141,9 @@ fun FlowSubscribeButton(
             SplitButtonLayout(
                 leadingButton = {
                     SplitButtonDefaults.TonalLeadingButton(
-                        onClick = { onNotificationChange?.invoke(!isNotificationsEnabled) },
+                        onClick = {
+                            if (onNotificationChange != null) onNotificationChange(!isNotificationsEnabled) else menuExpanded = true
+                        },
                         colors = tonalColors,
                         contentPadding =
                             if (compact) {
@@ -160,18 +162,22 @@ fun FlowSubscribeButton(
                                     },
                                 ),
                     ) {
-                        Icon(
-                            imageVector =
-                                if (isNotificationsEnabled) {
-                                    Icons.Rounded.NotificationsActive
-                                } else {
-                                    Icons.Rounded.NotificationsOff
-                                },
-                            contentDescription = if (showSubscribedLabel) null else stringResource(R.string.notifications),
-                            modifier = Modifier.size(leadingIconSize),
-                        )
+                        // A bell nothing listens to would look like a broken control (#1467), so a
+                        // caller that cannot change notifications shows the label alone.
+                        if (onNotificationChange != null || !showSubscribedLabel) {
+                            Icon(
+                                imageVector =
+                                    if (isNotificationsEnabled) {
+                                        Icons.Rounded.NotificationsActive
+                                    } else {
+                                        Icons.Rounded.NotificationsOff
+                                    },
+                                contentDescription = if (showSubscribedLabel) null else stringResource(R.string.notifications),
+                                modifier = Modifier.size(leadingIconSize),
+                            )
+                        }
                         if (showSubscribedLabel) {
-                            Spacer(modifier = Modifier.width(ButtonDefaults.IconSpacing))
+                            if (onNotificationChange != null) Spacer(modifier = Modifier.width(ButtonDefaults.IconSpacing))
                             Text(text = stringResource(R.string.subscribed), maxLines = 1)
                         }
                     }
diff --git a/app/src/main/java/io/github/aedev/flow/ui/components/shared/SubscriptionBell.kt b/app/src/main/java/io/github/aedev/flow/ui/components/shared/SubscriptionBell.kt
new file mode 100644
index 0000000000..05fee53a03
--- /dev/null
+++ b/app/src/main/java/io/github/aedev/flow/ui/components/shared/SubscriptionBell.kt
@@ -0,0 +1,133 @@
+package io.github.aedev.flow.ui.components.shared
+
+import android.content.Context
+import android.content.Intent
+import android.provider.Settings
+import androidx.activity.ComponentActivity
+import androidx.compose.material3.SnackbarDuration
+import androidx.compose.material3.SnackbarHostState
+import androidx.compose.material3.SnackbarResult
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.core.app.NotificationManagerCompat
+import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.compose.LocalLifecycleOwner
+import androidx.lifecycle.repeatOnLifecycle
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import dagger.hilt.android.qualifiers.ApplicationContext
+import io.github.aedev.flow.R
+import io.github.aedev.flow.data.local.PlayerPreferences
+import io.github.aedev.flow.data.local.SubscriptionRepository
+import io.github.aedev.flow.utils.PerformanceDispatcher
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.mapNotNull
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+private const val BELL_SUBSCRIPTION_TIMEOUT_MS = 5_000L
+
+/** Why a bell that is on cannot deliver anything. */
+internal enum class BellAlertBlock {
+    /** The system blocks Flow's notifications, or the Android 13 permission was never granted. */
+    System,
+
+    /** Flow's own Notifications or New videos switch is off. */
+    App,
+}
+
+internal fun bellAlertBlock(
+    systemAllows: Boolean,
+    notificationsOn: Boolean,
+    newVideosOn: Boolean,
+): BellAlertBlock? =
+    when {
+        !systemAllows -> BellAlertBlock.System
+        !notificationsOn || !newVideosOn -> BellAlertBlock.App
+        else -> null
+    }
+
+/** The bell on every subscribe button that has no screen of its own behind it. */
+@HiltViewModel
+class SubscriptionBellViewModel
+    @Inject
+    constructor(
+        @ApplicationContext private val appContext: Context,
+        private val subscriptionRepository: SubscriptionRepository,
+        private val playerPreferences: PlayerPreferences,
+    ) : ViewModel() {
+        val notifyingChannelIds: StateFlow<Set<String>> =
+            subscriptionRepository
+                .notifyingChannelIds()
+                .stateIn(viewModelScope, SharingStarted.WhileSubscribed(BELL_SUBSCRIPTION_TIMEOUT_MS), emptySet())
+
+        fun setNotifications(
+            channelId: String,
+            enabled: Boolean,
+        ) {
+            viewModelScope.launch(PerformanceDispatcher.diskIO) {
+                subscriptionRepository.updateNotificationState(channelId, enabled)
+            }
+        }
+
+        internal val blockedBells: Flow<BellAlertBlock> =
+            subscriptionRepository.notificationsTurnedOn.mapNotNull {
+                bellAlertBlock(
+                    systemAllows = NotificationManagerCompat.from(appContext).areNotificationsEnabled(),
+                    notificationsOn = playerPreferences.notificationsEnabled.first(),
+                    newVideosOn = playerPreferences.notifNewVideosEnabled.first(),
+                )
+            }
+
+        fun turnOnNewVideoAlerts() {
+            viewModelScope.launch {
+                playerPreferences.setNotificationsEnabled(true)
+                playerPreferences.setNotifNewVideosEnabled(true)
+            }
+        }
+    }
+
+/** The activity's [SubscriptionBellViewModel], so every card, sheet and Short shares one. */
+@Composable
+fun sharedSubscriptionBellViewModel(): SubscriptionBellViewModel {
+    val activity = LocalContext.current as? ComponentActivity
+    return if (activity != null) hiltViewModel(activity) else hiltViewModel()
+}
+
+/**
+ * Says so when a bell is turned on but nothing can arrive, with an action that fixes it (#1467).
+ * Mounted once in the shell: it reacts to taps only, never to what is already stored.
+ */
+@Composable
+fun SubscriptionBellAlerts(
+    snackbarHostState: SnackbarHostState,
+    viewModel: SubscriptionBellViewModel = sharedSubscriptionBellViewModel(),
+) {
+    val context = LocalContext.current
+    val lifecycleOwner = LocalLifecycleOwner.current
+    val message = stringResource(R.string.subscription_bell_alerts_off)
+    val action = stringResource(R.string.subscription_bell_alerts_turn_on)
+    LaunchedEffect(viewModel, snackbarHostState, lifecycleOwner) {
+        lifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
+            viewModel.blockedBells.collect { block ->
+                val result = snackbarHostState.showSnackbar(message, action, duration = SnackbarDuration.Long)
+                if (result == SnackbarResult.ActionPerformed) {
+                    viewModel.turnOnNewVideoAlerts()
+                    if (block == BellAlertBlock.System) {
+                        context.startActivity(
+                            Intent(Settings.ACTION_APP_NOTIFICATION_SETTINGS).putExtra(Settings.EXTRA_APP_PACKAGE, context.packageName),
+                        )
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/io/github/aedev/flow/ui/components/shared/quickactions/VideoQuickActionsSheet.kt b/app/src/main/java/io/github/aedev/flow/ui/components/shared/quickactions/VideoQuickActionsSheet.kt
index 57dae6f595..826cb4829f 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/components/shared/quickactions/VideoQuickActionsSheet.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/components/shared/quickactions/VideoQuickActionsSheet.kt
@@ -57,6 +57,7 @@ import io.github.aedev.flow.ui.components.shared.card.rememberCollaboratorItems
 import io.github.aedev.flow.ui.components.shared.card.rememberWatchProgress
 import io.github.aedev.flow.ui.components.shared.collaboratorRows
 import io.github.aedev.flow.ui.components.shared.rememberVideoShareAction
+import io.github.aedev.flow.ui.components.shared.sharedSubscriptionBellViewModel
 import io.github.aedev.flow.utils.youtubeWatchUrl
 import kotlinx.coroutines.launch
 
@@ -246,6 +247,8 @@ private fun channelRow(
 ): QuickActionRow {
     val channelLabel = rememberCollaboratorChannelDisplayName(video.channelName, collaborators)
     val subscribedChannelIds by viewModel.subscribedChannelIds.collectAsStateWithLifecycle()
+    val bell = sharedSubscriptionBellViewModel()
+    val notifyingChannelIds by bell.notifyingChannelIds.collectAsStateWithLifecycle()
     val navigator = LocalMediaNavigator.current
     val isCollaboration = collaborators.size > 1
     val ringColor = MaterialTheme.colorScheme.surfaceContainerHigh
@@ -290,6 +293,8 @@ private fun channelRow(
                             isSubscribed = video.channelId in subscribedChannelIds,
                             onSubscribeClick = toggle,
                             onUnsubscribeClick = toggle,
+                            isNotificationsEnabled = video.channelId in notifyingChannelIds,
+                            onNotificationChange = { bell.setNotifications(video.channelId, it) },
                             size = FlowSubscribeButtonSize.Compact,
                         )
                     }
diff --git a/app/src/main/java/io/github/aedev/flow/ui/components/shorts/ShortsMetadataOverlay.kt b/app/src/main/java/io/github/aedev/flow/ui/components/shorts/ShortsMetadataOverlay.kt
index cbdb6d6880..e0a708d903 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/components/shorts/ShortsMetadataOverlay.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/components/shorts/ShortsMetadataOverlay.kt
@@ -74,6 +74,8 @@ internal fun ShortsMetadataOverlay(
     onSubscribeToggle: () -> Unit,
     onDescriptionClick: () -> Unit,
     modifier: Modifier = Modifier,
+    isNotificationsEnabled: Boolean = false,
+    onNotificationChange: ((Boolean) -> Unit)? = null,
 ) {
     Column(modifier = modifier) {
         Row(
@@ -114,6 +116,8 @@ internal fun ShortsMetadataOverlay(
                         isSubscribed = isSubscribed,
                         onSubscribeClick = onSubscribeToggle,
                         onUnsubscribeClick = onSubscribeToggle,
+                        isNotificationsEnabled = isNotificationsEnabled,
+                        onNotificationChange = onNotificationChange,
                         size = FlowSubscribeButtonSize.Compact,
                     )
                 }
diff --git a/app/src/main/java/io/github/aedev/flow/ui/components/shorts/ShortsReelPage.kt b/app/src/main/java/io/github/aedev/flow/ui/components/shorts/ShortsReelPage.kt
index 3787b37c0c..4c49ce2edd 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/components/shorts/ShortsReelPage.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/components/shorts/ShortsReelPage.kt
@@ -52,6 +52,7 @@ import io.github.aedev.flow.player.GlobalPlayerState
 import io.github.aedev.flow.player.shorts.ShortsPlayerPool
 import io.github.aedev.flow.player.toDisplayAspectRatioOrNull
 import io.github.aedev.flow.ui.components.shared.MediaSeekBar
+import io.github.aedev.flow.ui.components.shared.sharedSubscriptionBellViewModel
 import io.github.aedev.flow.ui.components.videoplayer.ambient.VideoAmbientBackground
 import io.github.aedev.flow.ui.components.videoplayer.ambient.rememberAmbientFrame
 import io.github.aedev.flow.ui.components.videoplayer.overlay.SpeedBoostOverlay
@@ -99,6 +100,8 @@ internal fun ShortsReelPage(
 
     val isLiked by remember(short.id) { viewModel.isVideoLikedState(short.id) }.collectAsState()
     val isSubscribed by remember(short.channelId) { viewModel.isChannelSubscribedState(short.channelId) }.collectAsState()
+    val bell = sharedSubscriptionBellViewModel()
+    val notifyingChannelIds by bell.notifyingChannelIds.collectAsState()
     val isSaved by remember(short.id) { viewModel.isShortSavedState(short.id) }.collectAsState()
 
     // In Picture-in-Picture the window is a thumbnail: every overlay drawn at its authored size
@@ -322,6 +325,8 @@ internal fun ShortsReelPage(
                     onChannelClick = actions.onChannelClick,
                     onSubscribeToggle = ::toggleSubscription,
                     onDescriptionClick = actions.onDescriptionClick,
+                    isNotificationsEnabled = short.channelId in notifyingChannelIds,
+                    onNotificationChange = { bell.setNotifications(short.channelId, it) },
                     modifier =
                         Modifier
                             .weight(1f)
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/categories/CategoriesScreen.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/categories/CategoriesScreen.kt
index e978862b2c..b27a823932 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/categories/CategoriesScreen.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/categories/CategoriesScreen.kt
@@ -60,6 +60,7 @@ fun CategoriesScreen(
     viewModel: CategoriesViewModel = hiltViewModel(),
 ) {
     val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+    val shelves by viewModel.visibleShelves.collectAsStateWithLifecycle()
     val trendingRegion by viewModel.trendingRegion.collectAsStateWithLifecycle()
     val pagingItems = viewModel.gridItems.collectAsLazyPagingItems()
     var showRegionDialog by rememberSaveable { mutableStateOf(false) }
@@ -158,7 +159,7 @@ fun CategoriesScreen(
 
                     else -> {
                         CategoryShelfPage(
-                            shelves = uiState.shelves,
+                            shelves = shelves,
                             isLoading = uiState.isLoading,
                             listState = shelfState,
                             columnPreference = columnPreference,
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/categories/CategoriesViewModel.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/categories/CategoriesViewModel.kt
index abc6dd2b51..30343b0edf 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/categories/CategoriesViewModel.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/categories/CategoriesViewModel.kt
@@ -7,6 +7,7 @@ import androidx.paging.Pager
 import androidx.paging.PagingConfig
 import androidx.paging.PagingData
 import androidx.paging.cachedIn
+import androidx.paging.filter
 import dagger.hilt.android.lifecycle.HiltViewModel
 import dagger.hilt.android.qualifiers.ApplicationContext
 import io.github.aedev.flow.R
@@ -14,6 +15,8 @@ import io.github.aedev.flow.data.local.PlayerPreferences
 import io.github.aedev.flow.data.model.Video
 import io.github.aedev.flow.data.paging.FeedTabPagingSource
 import io.github.aedev.flow.data.repository.YouTubeRepository
+import io.github.aedev.flow.data.shorts.isShort
+import io.github.aedev.flow.data.shorts.withoutShorts
 import io.github.aedev.flow.innertube.YouTube
 import io.github.aedev.flow.innertube.pages.channel.ChannelTabKind
 import io.github.aedev.flow.innertube.pages.explore.ExploreDestination
@@ -30,9 +33,12 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.filterNotNull
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
@@ -74,6 +80,12 @@ class CategoriesViewModel
         private val _uiState = MutableStateFlow(CategoriesUiState())
         val uiState: StateFlow<CategoriesUiState> = _uiState.asStateFlow()
 
+        /** The shelves to draw: [CategoriesUiState.shelves] without Shorts while they are switched off (#1507). */
+        val visibleShelves: StateFlow<List<FeedShelf>> =
+            combine(_uiState.map { it.shelves }.distinctUntilChanged(), preferences.shortsContentEnabled) { shelves, shortsEnabled ->
+                if (shortsEnabled) shelves else shelves.withoutShorts()
+            }.stateIn(viewModelScope, SharingStarted.WhileSubscribed(SUBSCRIPTION_GRACE_MS), emptyList())
+
         val trendingRegion: StateFlow<String> =
             preferences.trendingRegion.stateIn(viewModelScope, SharingStarted.WhileSubscribed(SUBSCRIPTION_GRACE_MS), "US")
 
@@ -133,6 +145,9 @@ class CategoriesViewModel
                         },
                     ).flow
                 }.cachedIn(viewModelScope)
+                .combine(preferences.shortsContentEnabled) { items, shortsEnabled ->
+                    if (shortsEnabled) items else items.filter { !it.isShort() }
+                }
 
         private var loadJob: Job? = null
 
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/channel/ChannelContent.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/channel/ChannelContent.kt
index 567bdb6f55..c89549c70a 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/channel/ChannelContent.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/channel/ChannelContent.kt
@@ -84,6 +84,8 @@ internal fun ChannelContent(
     showShortsTab: Boolean,
     onFilterSelected: (ChannelTabKind, Int, Int) -> Unit,
     subscribedChannelIds: Set<String>,
+    notifyingChannelIds: Set<String>,
+    onChannelNotificationChange: (String, Boolean) -> Unit,
     channelNote: String?,
     onEditNote: (() -> Unit)?,
     onSubscribeChannel: (io.github.aedev.flow.data.model.Channel, Boolean) -> Unit,
@@ -333,7 +335,7 @@ internal fun ChannelContent(
                 tab.kind == ChannelTabKind.Home -> {
                     FeedShelfSections(
                         sections = tabStates[tab.kind]?.sections.orEmpty(),
-                        isLoading = tabStates[tab.kind]?.sections.isNullOrEmpty(),
+                        isLoading = tabStates[tab.kind]?.loaded != true,
                         listState = homeListState,
                         columnPreference = columnPreference,
                         contentPadding = listPadding,
@@ -382,6 +384,8 @@ internal fun ChannelContent(
                                         isSubscribed = isSubscribed,
                                         onSubscribeClick = { onSubscribeChannel(channel, true) },
                                         onUnsubscribeClick = { onSubscribeChannel(channel, false) },
+                                        isNotificationsEnabled = channel.id in notifyingChannelIds,
+                                        onNotificationChange = { onChannelNotificationChange(channel.id, it) },
                                     )
                                 },
                             ),
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/channel/ChannelScreen.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/channel/ChannelScreen.kt
index ecff9cfd0e..c9404f8591 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/channel/ChannelScreen.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/channel/ChannelScreen.kt
@@ -139,6 +139,7 @@ fun ChannelScreen(
     val communityUiState by viewModel.communityUiState.collectAsState()
     val tabStates by viewModel.tabStates.collectAsStateWithLifecycle()
     val subscribedChannelIds by viewModel.subscribedChannelIds.collectAsStateWithLifecycle()
+    val notifyingChannelIds by viewModel.notifyingChannelIds.collectAsStateWithLifecycle()
     val channelNote by viewModel.channelNote.collectAsStateWithLifecycle()
     val notesEnabled by viewModel.notesEnabled.collectAsStateWithLifecycle()
     val showShortsTab by viewModel.showShortsTab.collectAsStateWithLifecycle()
@@ -243,6 +244,8 @@ fun ChannelScreen(
                             showShortsTab = showShorts && showShortsTab,
                             onFilterSelected = viewModel::selectTabFilter,
                             subscribedChannelIds = subscribedChannelIds,
+                            notifyingChannelIds = notifyingChannelIds,
+                            onChannelNotificationChange = viewModel::setChannelNotifications,
                             channelNote = channelNote.takeIf { notesEnabled },
                             onEditNote = { showNoteEditor = true }.takeIf { notesEnabled },
                             onSubscribeChannel = viewModel::setChannelSubscription,
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/channel/ChannelViewModel.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/channel/ChannelViewModel.kt
index 15b3b2ccdb..f2eafe458f 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/channel/ChannelViewModel.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/channel/ChannelViewModel.kt
@@ -20,6 +20,7 @@ import io.github.aedev.flow.data.model.toUiModel
 import io.github.aedev.flow.data.notes.NoteKind
 import io.github.aedev.flow.data.notes.NoteSubject
 import io.github.aedev.flow.data.notes.NotesRepository
+import io.github.aedev.flow.data.shorts.withoutShorts
 import io.github.aedev.flow.innertube.YouTube
 import io.github.aedev.flow.innertube.pages.channel.ChannelTabKind
 import io.github.aedev.flow.innertube.pages.renderer.CommunityPost
@@ -32,6 +33,7 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
@@ -89,6 +91,20 @@ class ChannelViewModel
                 .map { subscriptions -> subscriptions.map { it.channelId }.toSet() }
                 .stateIn(viewModelScope, SharingStarted.WhileSubscribed(GROUPS_SUBSCRIPTION_TIMEOUT_MS), emptySet())
 
+        val notifyingChannelIds: StateFlow<Set<String>> =
+            subscriptionRepository
+                .notifyingChannelIds()
+                .stateIn(viewModelScope, SharingStarted.WhileSubscribed(GROUPS_SUBSCRIPTION_TIMEOUT_MS), emptySet())
+
+        fun setChannelNotifications(
+            channelId: String,
+            enabled: Boolean,
+        ) {
+            viewModelScope.launch(PerformanceDispatcher.diskIO) {
+                subscriptionRepository.updateNotificationState(channelId, enabled)
+            }
+        }
+
         fun setChannelSubscription(
             channel: io.github.aedev.flow.data.model.Channel,
             subscribed: Boolean,
@@ -159,7 +175,10 @@ class ChannelViewModel
         internal val communityUiState: StateFlow<ChannelCommunityUiState> = communityController.state
 
         private val tabController = ChannelTabController(viewModelScope)
-        internal val tabStates: StateFlow<Map<ChannelTabKind, ChannelTabState>> = tabController.states
+        internal val tabStates: StateFlow<Map<ChannelTabKind, ChannelTabState>> =
+            combine(tabController.states, playerPreferences.shortsContentEnabled) { states, shortsEnabled ->
+                if (shortsEnabled) states else states.mapValues { (_, state) -> state.copy(sections = state.sections.withoutShorts()) }
+            }.stateIn(viewModelScope, SharingStarted.WhileSubscribed(GROUPS_SUBSCRIPTION_TIMEOUT_MS), emptyMap())
 
         private fun channelOwner(): FeedItemOwner {
             val state = _uiState.value
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/search/SearchResultsBody.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/search/SearchResultsBody.kt
index df509d184d..3ea43cb5c8 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/search/SearchResultsBody.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/search/SearchResultsBody.kt
@@ -39,7 +39,9 @@ import io.github.aedev.flow.ui.components.search.SearchShortsGrid
 import io.github.aedev.flow.ui.components.shared.FeedGridSkeleton
 import io.github.aedev.flow.ui.components.shared.FlowEmptyState
 import io.github.aedev.flow.ui.components.shared.FlowErrorState
+import io.github.aedev.flow.ui.components.shared.SubscriptionBellViewModel
 import io.github.aedev.flow.ui.components.shared.quickactions.QuickActionsViewModel
+import io.github.aedev.flow.ui.components.shared.sharedSubscriptionBellViewModel
 import io.github.aedev.flow.utils.YouTubeLink
 import io.github.aedev.flow.utils.parseYouTubeLink
 
@@ -95,8 +97,10 @@ internal fun ColumnScope.SearchResultsBody(
     dismissKeyboard: () -> Unit,
     maxAutoColumns: Int = FEED_MAX_AUTO_COLUMNS,
     minCellWidth: Dp = FeedCardMinWidth,
+    bell: SubscriptionBellViewModel = sharedSubscriptionBellViewModel(),
 ) {
     val subscribedIds by quickActions.subscribedChannelIds.collectAsStateWithLifecycle()
+    val notifyingIds by bell.notifyingChannelIds.collectAsStateWithLifecycle()
     val currentOnVideoClick by rememberUpdatedState(onVideoClick)
 
     SearchFilterBar(
@@ -110,7 +114,7 @@ internal fun ColumnScope.SearchResultsBody(
     BoxWithConstraints(modifier = Modifier.weight(1f)) {
         val feedLayout = rememberFeedGridLayout(maxWidth, feedColumns, maxAutoColumns, minCellWidth)
         val actions =
-            remember(feedLayout, subscribedIds) {
+            remember(feedLayout, subscribedIds, notifyingIds) {
                 SearchResultActions(
                     onVideoClick = { currentOnVideoClick(it) },
                     onShortsClick = { shelf, tapped ->
@@ -123,6 +127,8 @@ internal fun ColumnScope.SearchResultsBody(
                     onSubscribeToggle = { channel ->
                         quickActions.toggleSubscription(channel.id, channel.name, channel.thumbnailUrl)
                     },
+                    isNotifying = { it in notifyingIds },
+                    onNotificationChange = { channel, enabled -> bell.setNotifications(channel.id, enabled) },
                 )
             }
 
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/settings/index/PlaybackIndex.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/settings/index/PlaybackIndex.kt
index 440d38ca1c..f566527388 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/settings/index/PlaybackIndex.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/settings/index/PlaybackIndex.kt
@@ -16,6 +16,14 @@ internal object PlaybackIndex {
             section = R.string.playback_header,
             destination = page,
         )
+    val keepPlayingAfterSwipe =
+        SettingEntry(
+            key = "playback.keep_playing_after_swipe",
+            title = R.string.player_settings_keep_playing_after_swipe,
+            summary = R.string.player_settings_keep_playing_after_swipe_subtitle,
+            section = R.string.playback_header,
+            destination = page,
+        )
     val startPaused =
         SettingEntry(
             key = "playback.start_paused",
@@ -450,6 +458,7 @@ internal object PlaybackIndex {
     val all =
         listOf(
             backgroundPlay,
+            keepPlayingAfterSwipe,
             startPaused,
             openFullscreen,
             tiltFullscreen,
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/settings/playback/PlaybackSections.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/settings/playback/PlaybackSections.kt
index 906e2ce170..ed0be7ad18 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/settings/playback/PlaybackSections.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/settings/playback/PlaybackSections.kt
@@ -36,6 +36,7 @@ internal fun SettingsListScope.playbackSections(
 ) {
     group(key = "playback.general", header = R.string.playback_header) {
         switch(PlaybackIndex.backgroundPlay, viewModel.backgroundPlay, viewModel::setBackgroundPlay)
+        switch(PlaybackIndex.keepPlayingAfterSwipe, viewModel.keepPlayingAfterSwipe, viewModel::setKeepPlayingAfterSwipe)
         if (state.backgroundRestricted) {
             row("playback.background_restricted") { shape ->
                 FlowNavRow(
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/settings/playback/PlaybackSettingsViewModel.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/settings/playback/PlaybackSettingsViewModel.kt
index a2d9d4f3ce..76e681b452 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/settings/playback/PlaybackSettingsViewModel.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/settings/playback/PlaybackSettingsViewModel.kt
@@ -4,6 +4,7 @@ import android.content.Context
 import dagger.hilt.android.lifecycle.HiltViewModel
 import dagger.hilt.android.qualifiers.ApplicationContext
 import io.github.aedev.flow.data.local.DEFAULT_BACKGROUND_PLAY_ENABLED
+import io.github.aedev.flow.data.local.DEFAULT_KEEP_PLAYING_AFTER_SWIPE
 import io.github.aedev.flow.data.local.DEFAULT_SPEED_SWIPE_STEP
 import io.github.aedev.flow.data.local.DoubleTapSeekZone
 import io.github.aedev.flow.data.local.PlayerOverlayPreferences
@@ -35,6 +36,7 @@ class PlaybackSettingsViewModel
         private val overlay = PlayerOverlayPreferences()
 
         val backgroundPlay = preferences.backgroundPlayEnabled.asState(DEFAULT_BACKGROUND_PLAY_ENABLED)
+        val keepPlayingAfterSwipe = preferences.keepPlayingAfterSwipe.asState(DEFAULT_KEEP_PLAYING_AFTER_SWIPE)
         val autoplay = preferences.autoplayEnabled.asState(true)
         val startPaused = preferences.startVideosPaused.asState(false)
         val openFullscreen = preferences.openVideosFullscreen.asState(false)
@@ -118,6 +120,8 @@ class PlaybackSettingsViewModel
 
         fun setBackgroundPlay(value: Boolean) = write { preferences.setBackgroundPlayEnabled(value) }
 
+        fun setKeepPlayingAfterSwipe(value: Boolean) = write { preferences.setKeepPlayingAfterSwipe(value) }
+
         fun setResumeFromHeadphones(value: Boolean) {
             if (!value) HeadphoneResume.set(context, allowed = false)
             write { preferences.setResumeFromHeadphones(value) }
diff --git a/app/src/main/java/io/github/aedev/flow/ui/screens/settings/taste/DiscoverChannelsViewModel.kt b/app/src/main/java/io/github/aedev/flow/ui/screens/settings/taste/DiscoverChannelsViewModel.kt
index fc8575693d..62dab50482 100644
--- a/app/src/main/java/io/github/aedev/flow/ui/screens/settings/taste/DiscoverChannelsViewModel.kt
+++ b/app/src/main/java/io/github/aedev/flow/ui/screens/settings/taste/DiscoverChannelsViewModel.kt
@@ -6,6 +6,7 @@ import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
 import io.github.aedev.flow.data.local.ChannelSubscription
 import io.github.aedev.flow.data.local.SubscriptionRepository
+import io.github.aedev.flow.data.local.notifyingIds
 import io.github.aedev.flow.data.model.Channel
 import io.github.aedev.flow.data.paging.ChannelSearch
 import io.github.aedev.flow.data.recommendation.ChannelMemoryRepository
@@ -136,7 +137,7 @@ internal class DiscoverChannelsViewModel
                     suggestionAvatars = avatarsById,
                     results = found,
                     subscribedIds = subscribed.mapTo(HashSet()) { it.channelId },
-                    notifyingIds = subscribed.filter { it.isNotificationEnabled }.mapTo(HashSet()) { it.channelId },
+                    notifyingIds = notifyingIds(subscribed),
                 )
             }.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), DiscoverChannelsState())
 
diff --git a/app/src/main/java/io/github/aedev/flow/utils/DateDisplay.kt b/app/src/main/java/io/github/aedev/flow/utils/DateDisplay.kt
index 19fdd0f181..a24c2fb5e7 100644
--- a/app/src/main/java/io/github/aedev/flow/utils/DateDisplay.kt
+++ b/app/src/main/java/io/github/aedev/flow/utils/DateDisplay.kt
@@ -231,6 +231,10 @@ private fun applyExactPrefix(
     return "$prefix $value"
 }
 
+private val StreamOrPremiereWords = Regex("(?i)^(streamed|premiered)\\s+(live\\s+)?(on\\s+)?")
+
+internal fun withoutStreamOrPremiereWords(text: String): String = text.replace(StreamOrPremiereWords, "").trim()
+
 fun parseToTimestamp(
     text: String?,
     hl: String? = YouTube.locale.hl,
@@ -239,13 +243,10 @@ fun parseToTimestamp(
     if (raw.isEmpty()) return null
     raw.toLongOrNull()?.takeIf { it > 100_000_000_000L }?.let { return it }
 
-    val cleanRaw =
-        raw
-            // "Streamed live on Jun 19, 2020" and "Premiered on Jan 1, 2020" carry the date behind
-            // words no format string matches, so without dropping them the parse fails and the
-            // caller falls back to whatever timestamp it already had.
-            .replace(Regex("(?i)^(streamed|premiered)\\s+(live\\s+)?(on\\s+)?"), "")
-            .trim()
+    // "Streamed live on Jun 19, 2020" and "Premiered on Jan 1, 2020" carry the date behind words no
+    // format string matches, so without dropping them the parse fails and the caller falls back to
+    // whatever timestamp it already had.
+    val cleanRaw = withoutStreamOrPremiereWords(raw)
 
     val absFormats =
         listOf(
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index 5966b9e5ce..afec930061 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -287,6 +287,8 @@
     <string name="dislikes">Dislikes</string>
     <string name="channel_id">Channel ID</string>
     <string name="uploaded">Uploaded</string>
+    <string name="description_premiered">Premiered</string>
+    <string name="description_streamed">Streamed</string>
     <string name="itag">iTag</string>
     <string name="mime_type">Mime Type</string>
     <!-- Video Status & Metadata -->
@@ -366,6 +368,8 @@
     <string name="nav_subs">Subs</string>
     <string name="nav_library">Library</string>
     <string name="notifications">Notifications</string>
+    <string name="subscription_bell_alerts_off">Alerts for new videos are off</string>
+    <string name="subscription_bell_alerts_turn_on">Turn on</string>
     <string name="search">Search</string>
     <string name="settings">Settings</string>
     <string name="select_artist">Select Artist</string>
@@ -1274,6 +1278,8 @@
     <string name="proxy_settings_saved">Proxy settings saved</string>
     <string name="player_settings_background_play">Background Play</string>
     <string name="player_settings_background_play_subtitle">Continue playing when app is in background</string>
+    <string name="player_settings_keep_playing_after_swipe">Keep playing after closing Flow</string>
+    <string name="player_settings_keep_playing_after_swipe_subtitle">Playback continues when you swipe Flow away from recent apps</string>
     <string name="player_settings_shorts_background_play">Shorts Background Play</string>
     <string name="player_settings_shorts_background_play_subtitle">Continue playing Shorts when app is in background</string>
     <string name="player_settings_shorts_pip">Shorts Picture-in-Picture</string>
diff --git a/app/src/main/res/values/themes.xml b/app/src/main/res/values/themes.xml
index 4985726826..05f635214a 100644
--- a/app/src/main/res/values/themes.xml
+++ b/app/src/main/res/values/themes.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<resources>
+<resources xmlns:tools="http://schemas.android.com/tools">
     <style name="Theme.Flow" parent="android:Theme.Material.Light.NoActionBar">
         <!-- Enable edge-to-edge -->
         <item name="android:windowLayoutInDisplayCutoutMode">shortEdges</item>
@@ -8,6 +8,9 @@
         <item name="android:windowLightStatusBar">true</item>
         <item name="android:enforceNavigationBarContrast">false</item>
         <item name="android:enforceStatusBarContrast">false</item>
+        <!-- The window is a platform Light theme whatever Flow's own theme is, so a system or MIUI
+             dark mode would otherwise invert what Compose already drew dark or light (#1517). -->
+        <item name="android:forceDarkAllowed" tools:targetApi="q">false</item>
     </style>
 
     <!-- The platform splash. Before Android 13 it follows the system night mode; from 13 on,
diff --git a/app/src/test/java/io/github/aedev/flow/data/local/DevicePreferencesSplitTest.kt b/app/src/test/java/io/github/aedev/flow/data/local/DevicePreferencesSplitTest.kt
index ce47fd69b2..d3b09a1d30 100644
--- a/app/src/test/java/io/github/aedev/flow/data/local/DevicePreferencesSplitTest.kt
+++ b/app/src/test/java/io/github/aedev/flow/data/local/DevicePreferencesSplitTest.kt
@@ -25,7 +25,7 @@ class DevicePreferencesSplitTest {
         val device = keyNames("DeviceKeys")
 
         assertThat(device).hasSize(101)
-        assertThat(profile).hasSize(201)
+        assertThat(profile).hasSize(202)
         assertThat(device.toSet()).hasSize(device.size)
         assertThat(profile.toSet()).hasSize(profile.size)
         assertThat(device.intersect(profile.toSet())).isEmpty()
diff --git a/app/src/test/java/io/github/aedev/flow/data/shorts/FeedShelfShortsTest.kt b/app/src/test/java/io/github/aedev/flow/data/shorts/FeedShelfShortsTest.kt
new file mode 100644
index 0000000000..87a009557a
--- /dev/null
+++ b/app/src/test/java/io/github/aedev/flow/data/shorts/FeedShelfShortsTest.kt
@@ -0,0 +1,64 @@
+package io.github.aedev.flow.data.shorts
+
+import com.google.common.truth.Truth.assertThat
+import io.github.aedev.flow.data.model.Playlist
+import io.github.aedev.flow.data.model.Video
+import io.github.aedev.flow.innertube.pages.renderer.FeedItem
+import io.github.aedev.flow.innertube.pages.renderer.FeedShelf
+import org.junit.Test
+
+class FeedShelfShortsTest {
+    private fun video(
+        id: String,
+        isShort: Boolean = false,
+    ) = Video(
+        id = id,
+        title = id,
+        channelName = "",
+        channelId = "",
+        thumbnailUrl = "",
+        duration = 0,
+        viewCount = 0,
+        uploadDate = "",
+        isShort = isShort,
+    )
+
+    private val upload = FeedItem.VideoItem(video("upload"))
+    private val reel = FeedItem.ShortItem(video("reel"))
+    private val collabReel = FeedItem.VideoItem(video("collab", isShort = true))
+
+    @Test
+    fun `a Shorts shelf is dropped whole`() {
+        val shelves = listOf(FeedShelf(id = "shorts", items = listOf(reel, reel.copy(video = video("reel2")))))
+
+        assertThat(shelves.withoutShorts()).isEmpty()
+    }
+
+    @Test
+    fun `a mixed shelf keeps only what is not a Short`() {
+        val shelves = listOf(FeedShelf(id = "mixed", items = listOf(upload, reel, collabReel)))
+
+        assertThat(shelves.withoutShorts().single().items).containsExactly(upload)
+    }
+
+    @Test
+    fun `a collaboration reel in a video lockup counts as a Short`() {
+        assertThat(collabReel.isShort()).isTrue()
+        assertThat(upload.isShort()).isFalse()
+    }
+
+    @Test
+    fun `shelves with no Shorts come back unchanged`() {
+        val playlist = FeedItem.PlaylistItem(Playlist(id = "p", name = "p", thumbnailUrl = "", videoCount = 0))
+        val shelves = listOf(FeedShelf(id = "videos", items = listOf(upload)), FeedShelf(id = "lists", items = listOf(playlist)))
+
+        assertThat(shelves.withoutShorts()).isEqualTo(shelves)
+    }
+
+    @Test
+    fun `a shelf that was already empty is left alone`() {
+        val shelves = listOf(FeedShelf(id = "header"))
+
+        assertThat(shelves.withoutShorts()).isEqualTo(shelves)
+    }
+}
diff --git a/app/src/test/java/io/github/aedev/flow/player/LifecyclePlaybackPreferencesTest.kt b/app/src/test/java/io/github/aedev/flow/player/LifecyclePlaybackPreferencesTest.kt
index 456a9006eb..d4e8a4f96c 100644
--- a/app/src/test/java/io/github/aedev/flow/player/LifecyclePlaybackPreferencesTest.kt
+++ b/app/src/test/java/io/github/aedev/flow/player/LifecyclePlaybackPreferencesTest.kt
@@ -28,6 +28,13 @@ class LifecyclePlaybackPreferencesTest {
         assertThat(LifecyclePlaybackSettings().openVideosFullscreen).isFalse()
     }
 
+    @Test
+    fun `a swipe keeps playback going before the preferences load`() {
+        // A media-button cold start has no activity to load the snapshot, so the cold value is
+        // what onTaskRemoved reads; it must keep the behaviour a user who never chose has (#1468).
+        assertThat(LifecyclePlaybackSettings().keepPlayingAfterSwipe).isTrue()
+    }
+
     @Test
     fun `loaded settings outlive the observing scope`() =
         runTest {
diff --git a/app/src/test/java/io/github/aedev/flow/service/TaskRemovalPolicyTest.kt b/app/src/test/java/io/github/aedev/flow/service/TaskRemovalPolicyTest.kt
index a2a0cf52de..855173b9d4 100644
--- a/app/src/test/java/io/github/aedev/flow/service/TaskRemovalPolicyTest.kt
+++ b/app/src/test/java/io/github/aedev/flow/service/TaskRemovalPolicyTest.kt
@@ -10,7 +10,8 @@ class TaskRemovalPolicyTest {
         playWhenReady: Boolean = true,
         state: Int = Player.STATE_READY,
         hasMedia: Boolean = true,
-    ) = keepsPlayingOnTaskRemoved(ongoing, playWhenReady, state, hasMedia)
+        keepPlayingAfterSwipe: Boolean = true,
+    ) = keepsPlayingOnTaskRemoved(keepPlayingAfterSwipe, ongoing, playWhenReady, state, hasMedia)
 
     @Test
     fun `playing media keeps the service`() {
@@ -35,6 +36,12 @@ class TaskRemovalPolicyTest {
         assertThat(keeps(hasMedia = false)).isFalse()
     }
 
+    @Test
+    fun `with the switch off a swipe stops even playing media`() {
+        assertThat(keeps(keepPlayingAfterSwipe = false)).isFalse()
+        assertThat(keeps(keepPlayingAfterSwipe = false, state = Player.STATE_BUFFERING)).isFalse()
+    }
+
     @Test
     fun `a service that is not in the foreground always stops`() {
         assertThat(keeps(ongoing = false)).isFalse()
diff --git a/app/src/test/java/io/github/aedev/flow/ui/components/shared/DescriptionFactoidsTest.kt b/app/src/test/java/io/github/aedev/flow/ui/components/shared/DescriptionFactoidsTest.kt
new file mode 100644
index 0000000000..9d46d56cb4
--- /dev/null
+++ b/app/src/test/java/io/github/aedev/flow/ui/components/shared/DescriptionFactoidsTest.kt
@@ -0,0 +1,79 @@
+package io.github.aedev.flow.ui.components.shared
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+import java.time.LocalDate
+import java.time.ZoneId
+
+class DescriptionFactoidsTest {
+    private val now =
+        LocalDate
+            .of(2026, 10, 28)
+            .atStartOfDay(ZoneId.systemDefault())
+            .toInstant()
+            .toEpochMilli()
+
+    private fun dayOf(read: DescriptionDate): LocalDate =
+        java.time.Instant
+            .ofEpochMilli((read as DescriptionDate.OnDay).timestampMs)
+            .atZone(ZoneId.systemDefault())
+            .toLocalDate()
+
+    @Test
+    fun `a premiere with a date reads as that day`() {
+        val read = readDescriptionDate("Premiered Oct 24, 2026", 0L, false, now, "en")
+
+        assertThat(dayOf(read)).isEqualTo(LocalDate.of(2026, 10, 24))
+    }
+
+    @Test
+    fun `a past stream with a date reads as that day`() {
+        val read = readDescriptionDate("Streamed live on Jul 12, 2022", 0L, false, now, "en")
+
+        assertThat(dayOf(read)).isEqualTo(LocalDate.of(2022, 7, 12))
+    }
+
+    @Test
+    fun `a plain upload date reads as that day`() {
+        val read = readDescriptionDate("Oct 24, 2009", 0L, false, now, "en")
+
+        assertThat(dayOf(read)).isEqualTo(LocalDate.of(2009, 10, 24))
+    }
+
+    @Test
+    fun `a premiere known only by age keeps the age and the kind apart`() {
+        val read = readDescriptionDate("Premiered 2 days ago", 0L, false, now, "en")
+
+        assertThat(read).isEqualTo(DescriptionDate.Aged("2 days ago", DescriptionDateKind.PREMIERED))
+    }
+
+    @Test
+    fun `a stream known only by age is a stream`() {
+        val read = readDescriptionDate("Streamed 3 weeks ago", 0L, false, now, "en")
+
+        assertThat(read).isEqualTo(DescriptionDate.Aged("3 weeks ago", DescriptionDateKind.STREAMED))
+    }
+
+    @Test
+    fun `an upload known only by age is an upload`() {
+        val read = readDescriptionDate("3 years ago", 0L, false, now, "en")
+
+        assertThat(read).isEqualTo(DescriptionDate.Aged("3 years ago", DescriptionDateKind.UPLOADED))
+    }
+
+    @Test
+    fun `an exact timestamp places the day even behind an age`() {
+        val stamp = now - 2 * 24 * 60 * 60 * 1000L
+
+        val read = readDescriptionDate("Premiered 2 days ago", stamp, true, now, "en")
+
+        assertThat(read).isEqualTo(DescriptionDate.OnDay(stamp))
+    }
+
+    @Test
+    fun `text nothing can read stays as it came`() {
+        val read = readDescriptionDate("sometime", 0L, false, now, "en")
+
+        assertThat(read).isEqualTo(DescriptionDate.Aged("sometime", DescriptionDateKind.UPLOADED))
+    }
+}
diff --git a/app/src/test/java/io/github/aedev/flow/ui/components/shared/SubscriptionBellTest.kt b/app/src/test/java/io/github/aedev/flow/ui/components/shared/SubscriptionBellTest.kt
new file mode 100644
index 0000000000..ba8edf4cef
--- /dev/null
+++ b/app/src/test/java/io/github/aedev/flow/ui/components/shared/SubscriptionBellTest.kt
@@ -0,0 +1,37 @@
+package io.github.aedev.flow.ui.components.shared
+
+import com.google.common.truth.Truth.assertThat
+import io.github.aedev.flow.data.local.ChannelSubscription
+import io.github.aedev.flow.data.local.notifyingIds
+import org.junit.Test
+
+class SubscriptionBellTest {
+    private fun channel(
+        id: String,
+        notify: Boolean,
+    ) = ChannelSubscription(channelId = id, channelName = id, channelThumbnail = "", isNotificationEnabled = notify)
+
+    @Test
+    fun `only channels with the bell on are notifying`() {
+        val ids = notifyingIds(listOf(channel("a", true), channel("b", false), channel("c", true)))
+
+        assertThat(ids).containsExactly("a", "c")
+    }
+
+    @Test
+    fun `alerts that can arrive block nothing`() {
+        assertThat(bellAlertBlock(systemAllows = true, notificationsOn = true, newVideosOn = true)).isNull()
+    }
+
+    @Test
+    fun `the system block wins over the app switches`() {
+        assertThat(bellAlertBlock(systemAllows = false, notificationsOn = false, newVideosOn = false))
+            .isEqualTo(BellAlertBlock.System)
+    }
+
+    @Test
+    fun `either app switch off blocks the bell`() {
+        assertThat(bellAlertBlock(systemAllows = true, notificationsOn = false, newVideosOn = true)).isEqualTo(BellAlertBlock.App)
+        assertThat(bellAlertBlock(systemAllows = true, notificationsOn = true, newVideosOn = false)).isEqualTo(BellAlertBlock.App)
+    }
+}