diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..741d3a7
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,71 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - dev
+    paths-ignore:
+      - '**.md'
+      - 'assets/**'
+  pull_request:
+    branches:
+      - dev
+      - beta
+      - main
+    paths-ignore:
+      - '**.md'
+      - 'assets/**'
+  workflow_call:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ci-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  CI: true
+  ANDROID_PLATFORM: platforms;android-37.0
+  ANDROID_BUILD_TOOLS: build-tools;36.0.0
+
+jobs:
+  verify:
+    # Hosted runners: pull requests from forks run here, never on a machine of the project.
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v7.0.1
+
+      - name: Set up Java
+        uses: actions/setup-java@v6.0.1
+        with:
+          distribution: temurin
+          java-version: 21
+
+      - name: Set up Gradle
+        uses: gradle/actions/setup-gradle@v6.4.0
+
+      - name: Install Android SDK packages
+        run: yes | "$ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager" --install "$ANDROID_PLATFORM" "$ANDROID_BUILD_TOOLS" > /dev/null
+
+      - name: Test, lint and build
+        run: |
+          ./gradlew --stacktrace \
+            testDebugUnitTest \
+            :app:compileDebugAndroidTestKotlin \
+            lintDebug \
+            :app:assembleRelease
+
+      - name: Upload reports
+        if: ${{ failure() }}
+        uses: actions/upload-artifact@v7.0.1
+        with:
+          name: reports
+          path: |
+            **/build/reports/
+            **/build/test-results/
+          if-no-files-found: ignore
+          retention-days: 14
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 0000000..8462976
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,161 @@
+name: Release
+
+# A push to beta publishes a prerelease, a push to main a stable release. The version comes from app/build.gradle.kts
+# and the text from release-notes/v<version>.md, which must be in the pushed commit.
+on:
+  push:
+    branches:
+      - beta
+      - main
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: release-${{ github.ref_name }}
+  cancel-in-progress: false
+
+env:
+  CI: true
+  APPLICATION_ID: video.typetype.tv
+  ANDROID_PLATFORM: platforms;android-37.0
+  ANDROID_BUILD_TOOLS: build-tools;36.0.0
+  BUILD_TOOLS_VERSION: 36.0.0
+
+jobs:
+  verify:
+    uses: ./.github/workflows/ci.yml
+
+  publish:
+    needs: verify
+    if: ${{ github.ref_name == 'beta' || github.ref_name == 'main' }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+    # The signing key lives in this environment, which only the beta and main branches can use.
+    environment: release
+    permissions:
+      contents: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v7.0.1
+
+      - name: Set up Java
+        uses: actions/setup-java@v6.0.1
+        with:
+          distribution: temurin
+          java-version: 21
+
+      - name: Set up Gradle
+        uses: gradle/actions/setup-gradle@v6.4.0
+
+      - name: Install Android SDK packages
+        run: yes | "$ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager" --install "$ANDROID_PLATFORM" "$ANDROID_BUILD_TOOLS" > /dev/null
+
+      - name: Check the version
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          set -euo pipefail
+          version="$(sed -nE 's/^val appVersion = "([^"]+)"$/\1/p' app/build.gradle.kts)"
+          case "$GITHUB_REF_NAME" in
+            beta) pattern='^[0-9]+\.[0-9]+\.[0-9]+-beta\.[1-9][0-9]?$'; channel=beta ;;
+            main) pattern='^[0-9]+\.[0-9]+\.[0-9]+$'; channel=stable ;;
+          esac
+          if [[ ! "$version" =~ $pattern ]]; then
+            echo "::error::Version '$version' does not fit the $GITHUB_REF_NAME branch"
+            exit 1
+          fi
+          tag="v$version"
+          if [ ! -f "release-notes/$tag.md" ]; then
+            echo "::error::release-notes/$tag.md is missing"
+            exit 1
+          fi
+          if gh api "repos/$GITHUB_REPOSITORY/git/ref/tags/$tag" > /dev/null 2>&1; then
+            echo "::error::Tag $tag already exists: raise the version before publishing"
+            exit 1
+          fi
+          {
+            echo "RELEASE_VERSION=$version"
+            echo "RELEASE_TAG=$tag"
+            echo "RELEASE_CHANNEL=$channel"
+          } >> "$GITHUB_ENV"
+
+      - name: Build
+        run: ./gradlew --stacktrace :app:assembleRelease
+
+      - name: Sign
+        env:
+          KEYSTORE_BASE64: ${{ secrets.TV_KEYSTORE_BASE64 }}
+          KEYSTORE_PASSWORD: ${{ secrets.TV_KEYSTORE_PASSWORD }}
+          KEY_ALIAS: ${{ secrets.TV_KEY_ALIAS }}
+        run: |
+          set -euo pipefail
+          test -n "$KEYSTORE_BASE64" && test -n "$KEYSTORE_PASSWORD" && test -n "$KEY_ALIAS"
+          tools="$ANDROID_HOME/build-tools/$BUILD_TOOLS_VERSION"
+          keystore="$RUNNER_TEMP/release.jks"
+          trap 'rm -f "$keystore"' EXIT
+          printf '%s' "$KEYSTORE_BASE64" | base64 --decode > "$keystore"
+          mkdir -p artifacts
+          "$tools/zipalign" -f -P 16 4 app/build/outputs/apk/release/app-release-unsigned.apk "$RUNNER_TEMP/aligned.apk"
+          "$tools/apksigner" sign --ks "$keystore" --ks-key-alias "$KEY_ALIAS" --v4-signing-enabled false \
+            --ks-pass env:KEYSTORE_PASSWORD --key-pass env:KEYSTORE_PASSWORD \
+            --out "artifacts/TypeType-TV-$RELEASE_TAG.apk" "$RUNNER_TEMP/aligned.apk"
+
+      - name: Check the APK
+        run: |
+          set -euo pipefail
+          tools="$ANDROID_HOME/build-tools/$BUILD_TOOLS_VERSION"
+          apk="artifacts/TypeType-TV-$RELEASE_TAG.apk"
+          "$tools/zipalign" -c -P 16 4 "$apk"
+          "$tools/apksigner" verify --print-certs "$apk" | grep -E 'Signer #1 certificate (DN|SHA-256)'
+          badging="$("$tools/aapt2" dump badging "$apk" | head -n 1)"
+          echo "$badging"
+          package="$(sed -nE "s/^package: name='([^']+)'.*/\1/p" <<< "$badging")"
+          code="$(sed -nE "s/.*versionCode='([0-9]+)'.*/\1/p" <<< "$badging")"
+          name="$(sed -nE "s/.*versionName='([^']+)'.*/\1/p" <<< "$badging")"
+          test "$package" = "$APPLICATION_ID"
+          test "$name" = "$RELEASE_VERSION"
+          echo "RELEASE_CODE=$code" >> "$GITHUB_ENV"
+
+      - name: Write checksum and update manifest
+        run: |
+          set -euo pipefail
+          cd artifacts
+          apk="TypeType-TV-$RELEASE_TAG.apk"
+          sha256sum "$apk" > "$apk.sha256"
+          jq -n \
+            --arg channel "$RELEASE_CHANNEL" \
+            --arg packageName "$APPLICATION_ID" \
+            --arg versionName "$RELEASE_VERSION" \
+            --argjson versionCode "$RELEASE_CODE" \
+            --arg apkAsset "$apk" \
+            --arg sha256 "$(cut -d ' ' -f 1 "$apk.sha256")" \
+            '{schemaVersion: 1, channel: $channel, packageName: $packageName, versionName: $versionName,
+              versionCode: $versionCode, apkAsset: $apkAsset, sha256: $sha256}' > typetype-update.json
+          cat typetype-update.json
+
+      - name: Keep the files with the run
+        uses: actions/upload-artifact@v7.0.1
+        with:
+          name: typetype-tv-${{ env.RELEASE_TAG }}
+          path: artifacts/
+          if-no-files-found: error
+          compression-level: 0
+          retention-days: 30
+
+      - name: Publish the release
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          set -euo pipefail
+          if [ "$RELEASE_CHANNEL" = beta ]; then
+            flags=(--prerelease --latest=false)
+          else
+            flags=(--latest)
+          fi
+          gh release create "$RELEASE_TAG" artifacts/* \
+            --target "$GITHUB_SHA" \
+            --title "TypeType TV $RELEASE_VERSION" \
+            --notes-file "release-notes/$RELEASE_TAG.md" \
+            "${flags[@]}"
diff --git a/README.md b/README.md
index 091ff88..ed74679 100644
--- a/README.md
+++ b/README.md
@@ -31,20 +31,23 @@ synchronization. It supports YouTube, Bilibili, and NicoNico.
 
 | Home | Video details | Player |
 | --- | --- | --- |
-| ![TypeType TV home screen](assets/screenshots/tv-home.png) | ![TypeType TV video details](assets/screenshots/tv-detail.png) | ![TypeType TV player](assets/screenshots/tv-player.png) |
+| ![TypeType TV home with a muted preview](assets/screenshots/tv-home.png) | ![TypeType TV video details](assets/screenshots/tv-detail.png) | ![TypeType TV player](assets/screenshots/tv-player.png) |
 
-| Comments | Search | Settings |
+| Live chat | More videos | Search |
 | --- | --- | --- |
-| ![TypeType TV comments panel](assets/screenshots/tv-comments.png) | ![TypeType TV search with the on-screen keyboard](assets/screenshots/tv-search.png) | ![TypeType TV playback settings](assets/screenshots/tv-settings.png) |
+| ![TypeType TV live stream with its chat](assets/screenshots/tv-live-chat.png) | ![TypeType TV related videos under the player](assets/screenshots/tv-related.png) | ![TypeType TV search with the on-screen keyboard](assets/screenshots/tv-search.png) |
 
 ## Features
 
-- Browse the home feed, search videos and channels, and open channels and playlists.
+- Browse the home feed, search videos, playlists and channels, and open channels and playlists.
+- Rest on a video for two seconds to see a muted preview behind the home screen and the video details.
 - Resume videos and find your history, favorites, and Watch Later in the library.
+- Play up to 4K with AVC, VP9, AV1 or HEVC, chosen from the decoders of your device; HDR on HDR screens.
 - Choose the quality, audio language, captions and their style, and the playback speed.
 - Use chapters, SponsorBlock, the description, comments and their replies, and the Up next queue.
-- Show scrolling comments on Bilibili and NicoNico videos.
-- Watch live streams, or keep only the audio.
+- Press Down twice in the player to browse more videos without leaving playback.
+- Watch YouTube live streams with their chat beside the picture, the live audience, and the quality of your choice.
+- Show scrolling comments on Bilibili and NicoNico videos, or keep only the audio.
 - Subscribe to channels and add videos to your playlists from the player.
 
 ## Build
@@ -52,12 +55,14 @@ synchronization. It supports YouTube, Bilibili, and NicoNico.
 Requirements: JDK 17 and the Android SDK (`ANDROID_HOME` set).
 
 ```sh
-./gradlew :app:testDebugUnitTest :app:assembleDebug
+./gradlew testDebugUnitTest :app:assembleDebug
 ```
 
-The project has two modules:
+The project is split into modules:
 
-- `app`: the TV interface, built with Compose for remote-control focus, and the client for the TypeType Server API.
+- `app`: the TV application, its navigation and startup.
+- `core:*`: shared resources, the TypeType Server client, playback, the design system, and test fakes.
+- `feature:*`: one module per screen family (home, search, library, settings, collections, details, player, sign-in).
 - `player`: the Media3 source for TypeType SABR playback.
 
 ## Acknowledgements
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index ea8cbbe..510b4d5 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -4,6 +4,22 @@ plugins {
     alias(libs.plugins.kotlin.serialization)
 }
 
+// The release workflow reads this line: "x.y.z-beta.n" is published from the beta branch, "x.y.z" from main.
+val appVersion = "0.1.1-beta.1"
+
+// The version code follows from the name, so each release installs over the one before, and a beta sits under the
+// stable release that ends it: 0.3.0-beta.2 is 30002 and 0.3.0 is 30099.
+fun versionCodeOf(name: String): Int {
+    val match = requireNotNull(Regex("""(\d+)\.(\d+)\.(\d+)(?:-beta\.(\d+))?""").matchEntire(name)) {
+        "Version $name is neither x.y.z nor x.y.z-beta.n"
+    }
+    val (major, minor, patch, beta) = match.destructured
+    require(minor.toInt() < 100 && patch.toInt() < 100) { "Minor and patch of $name stay under 100" }
+    val step = if (beta.isEmpty()) 99 else beta.toInt()
+    require(beta.isEmpty() || step in 1..98) { "The beta number of $name is 1 to 98" }
+    return major.toInt() * 1_000_000 + minor.toInt() * 10_000 + patch.toInt() * 100 + step
+}
+
 android {
     namespace = "video.typetype.tv"
     compileSdk = 37
@@ -12,8 +28,8 @@ android {
         applicationId = "video.typetype.tv"
         minSdk = 23
         targetSdk = 37
-        versionCode = 1
-        versionName = "0.2.0"
+        versionCode = versionCodeOf(appVersion)
+        versionName = appVersion
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
 
@@ -41,10 +57,6 @@ android {
         unitTests.isReturnDefaultValues = true
     }
 
-    sourceSets {
-        getByName("test").kotlin.srcDir("src/sharedTest/java")
-        getByName("androidTest").kotlin.srcDir("src/sharedTest/java")
-    }
 }
 
 dependencies {
@@ -57,7 +69,18 @@ dependencies {
     implementation(libs.androidx.concurrent.futures)
     implementation(libs.androidx.lifecycle.runtime.compose)
 
-    implementation(project(":player"))
+    implementation(project(":core:resources"))
+    implementation(project(":core:data"))
+    implementation(project(":core:playback"))
+    implementation(project(":core:ui"))
+    implementation(project(":feature:auth"))
+    implementation(project(":feature:home"))
+    implementation(project(":feature:search"))
+    implementation(project(":feature:library"))
+    implementation(project(":feature:settings"))
+    implementation(project(":feature:collections"))
+    implementation(project(":feature:detail"))
+    implementation(project(":feature:player"))
     implementation(libs.androidx.media3.exoplayer)
     implementation(libs.androidx.media3.exoplayer.hls)
     implementation(libs.androidx.media3.datasource.okhttp)
@@ -77,6 +100,7 @@ dependencies {
     testImplementation(libs.okhttp.mockwebserver)
     testImplementation(libs.okhttp.tls)
 
+    androidTestImplementation(project(":core:testing"))
     androidTestImplementation(platform(libs.androidx.compose.bom))
     androidTestImplementation(libs.androidx.compose.ui.test.junit4)
     androidTestImplementation(libs.androidx.compose.ui.test.accessibility)
diff --git a/app/src/androidTest/java/video/typetype/tv/ui/ChannelPanelTest.kt b/app/src/androidTest/java/video/typetype/tv/ui/ChannelPanelTest.kt
new file mode 100644
index 0000000..d1fa65b
--- /dev/null
+++ b/app/src/androidTest/java/video/typetype/tv/ui/ChannelPanelTest.kt
@@ -0,0 +1,73 @@
+package video.typetype.tv.ui
+
+import androidx.activity.ComponentActivity
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.test.ExperimentalTestApi
+import androidx.compose.ui.test.assertIsFocused
+import androidx.compose.ui.test.junit4.accessibility.enableAccessibilityChecks
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.onRoot
+import androidx.compose.ui.test.performClick
+import androidx.compose.ui.test.performKeyInput
+import androidx.compose.ui.test.pressKey
+import androidx.compose.ui.test.tryPerformAccessibilityChecks
+import org.junit.Assert.assertEquals
+import org.junit.Rule
+import org.junit.Test
+import video.typetype.tv.data.Channel
+import video.typetype.tv.data.MockContentRepository
+import video.typetype.tv.resources.R
+import video.typetype.tv.ui.player.panel.ChannelCardActions
+import video.typetype.tv.ui.player.panel.ChannelPanel
+
+@OptIn(ExperimentalTestApi::class)
+class ChannelPanelTest {
+    @get:Rule
+    val rule = createAndroidComposeRule<ComponentActivity>()
+
+    private val channel = Channel("c", "Blender", "", "1.3M", url = "https://c.example")
+    private val log = mutableListOf<String>()
+
+    private fun show(subscribed: Boolean = false) = rule.setContent {
+        ChannelPanel(
+            channel = channel,
+            repository = MockContentRepository(latencyMillis = 0),
+            actions = ChannelCardActions(
+                subscribed = subscribed,
+                canSubscribe = true,
+                onSubscribe = { log += "subscribe:$it" },
+                onOpenChannel = { log += "open" },
+            ),
+            onClose = { log += "close" },
+        )
+    }
+
+    @Test
+    fun theCardIsAccessibleAndShowsWhoTheChannelIs() {
+        rule.enableAccessibilityChecks()
+        show()
+        rule.waitForIdle()
+        rule.onRoot().tryPerformAccessibilityChecks()
+        rule.onNodeWithText("Blender").assertExists()
+        rule.onNodeWithText(rule.activity.getString(R.string.detail_subscribers, "1.3M")).assertExists()
+    }
+
+    @Test
+    fun openChannelHasTheFocusAndOpensWithOk() {
+        show()
+        rule.waitForIdle()
+        rule.onNodeWithText(rule.activity.getString(R.string.player_open_channel)).run {
+            assertIsFocused()
+            performKeyInput { pressKey(Key.DirectionCenter) }
+        }
+        assertEquals(listOf("open"), log)
+    }
+
+    @Test
+    fun subscribeFollowsTheChannelAndSaysWhenItIsFollowed() {
+        show(subscribed = true)
+        rule.onNodeWithText(rule.activity.getString(R.string.detail_subscribed)).performClick()
+        assertEquals(listOf("subscribe:false"), log)
+    }
+}
diff --git a/app/src/androidTest/java/video/typetype/tv/ui/CollectionScreensAccessibilityTest.kt b/app/src/androidTest/java/video/typetype/tv/ui/CollectionScreensAccessibilityTest.kt
index dc21fd8..3aa9bd2 100644
--- a/app/src/androidTest/java/video/typetype/tv/ui/CollectionScreensAccessibilityTest.kt
+++ b/app/src/androidTest/java/video/typetype/tv/ui/CollectionScreensAccessibilityTest.kt
@@ -52,7 +52,7 @@ class CollectionScreensAccessibilityTest {
 
     @Test
     fun channelNamesEveryControl() = assertEveryControlIsNamed("channel") {
-        ChannelScreen(MockCatalog.all.first().channel.url, repository, onOpen = {}, onOpenPodcast = {})
+        ChannelScreen(MockCatalog.all.first().channel.url, repository, onOpen = {}, onOpenPodcast = {}, onOpenPlaylist = {})
     }
 
     @Test
diff --git a/app/src/androidTest/java/video/typetype/tv/ui/LibraryFocusTest.kt b/app/src/androidTest/java/video/typetype/tv/ui/LibraryFocusTest.kt
new file mode 100644
index 0000000..59aeb93
--- /dev/null
+++ b/app/src/androidTest/java/video/typetype/tv/ui/LibraryFocusTest.kt
@@ -0,0 +1,52 @@
+package video.typetype.tv.ui
+
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.semantics.SemanticsProperties
+import androidx.compose.ui.test.SemanticsMatcher
+import androidx.compose.ui.test.isFocused
+import androidx.compose.ui.test.junit4.createComposeRule
+import androidx.compose.ui.test.onRoot
+import androidx.compose.ui.test.performKeyInput
+import androidx.compose.ui.test.pressKey
+import androidx.compose.ui.test.requestFocus
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotEquals
+import org.junit.Rule
+import org.junit.Test
+import video.typetype.tv.data.MockContentRepository
+import video.typetype.tv.ui.library.LibraryScreen
+import video.typetype.tv.ui.library.LibrarySession
+
+// Coming back from the videos of a library section lands on that section's tab, not on the nearest one.
+class LibraryFocusTest {
+    @get:Rule
+    val rule = createComposeRule()
+
+    private val tabs = SemanticsMatcher.expectValue(SemanticsProperties.Role, Role.Tab)
+
+    private fun focusedId(): Int = rule.onNode(isFocused()).fetchSemanticsNode().id
+
+    private fun press(key: Key) {
+        rule.onRoot().performKeyInput { pressKey(key) }
+        rule.waitForIdle()
+    }
+
+    @Test
+    fun leftFromTheVideosReturnsToTheOpenSection() {
+        rule.setContent { LibraryScreen(MockContentRepository(latencyMillis = 0), LibrarySession(), onOpen = {}) }
+        rule.waitUntil(5_000) { rule.onAllNodes(tabs).fetchSemanticsNodes().size >= 3 }
+        val tab = rule.onAllNodes(tabs)[1]
+        tab.requestFocus()
+        rule.waitForIdle()
+        val tabId = tab.fetchSemanticsNode().id
+        rule.waitUntil(5_000) {
+            press(Key.DirectionRight)
+            focusedId() != tabId
+        }
+        press(Key.DirectionDown)
+        assertNotEquals(tabId, focusedId())
+        press(Key.DirectionLeft)
+        assertEquals(tabId, focusedId())
+    }
+}
diff --git a/app/src/androidTest/java/video/typetype/tv/ui/OptionWheelTest.kt b/app/src/androidTest/java/video/typetype/tv/ui/OptionWheelTest.kt
new file mode 100644
index 0000000..9046fc5
--- /dev/null
+++ b/app/src/androidTest/java/video/typetype/tv/ui/OptionWheelTest.kt
@@ -0,0 +1,102 @@
+package video.typetype.tv.ui
+
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.foundation.focusable
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.size
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.test.assertIsFocused
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.test.junit4.createComposeRule
+import androidx.compose.ui.test.onNodeWithContentDescription
+import androidx.compose.ui.test.performKeyInput
+import androidx.compose.ui.test.pressKey
+import androidx.compose.ui.test.requestFocus
+import org.junit.Assert.assertEquals
+import org.junit.Rule
+import org.junit.Test
+import video.typetype.tv.ui.components.OptionWheel
+import video.typetype.tv.ui.components.WheelOption
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.rounded.Tune
+
+class OptionWheelTest {
+    @get:Rule
+    val rule = createComposeRule()
+
+    private val picks = mutableListOf<Int>()
+
+    private fun show(start: Int) {
+        rule.setContent {
+            var selected by remember { mutableIntStateOf(start) }
+            Column {
+            OptionWheel(
+                options = listOf("Channels", "Videos", "Playlists").map { WheelOption(it, Icons.Rounded.Tune) },
+                selected = selected,
+                onSelect = {
+                    picks += it
+                    selected = it
+                },
+                description = "Type",
+            )
+            Box(Modifier.size(40.dp).semantics { contentDescription = "Below" }.focusable())
+            }
+        }
+        rule.onNodeWithContentDescription("Type").requestFocus()
+    }
+
+    private fun press(key: Key) {
+        rule.onNodeWithContentDescription("Type").performKeyInput { pressKey(key) }
+        rule.waitForIdle()
+    }
+
+    @Test
+    fun okConfirmsTheValueTheWheelWasTurnedTo() {
+        show(start = 1)
+        press(Key.DirectionDown)
+        press(Key.DirectionUp)
+        press(Key.DirectionUp)
+        assertEquals(emptyList<Int>(), picks)
+        press(Key.DirectionCenter)
+        assertEquals(listOf(0), picks)
+    }
+
+    @Test
+    fun okOnTheChosenValueChangesNothing() {
+        show(start = 1)
+        press(Key.DirectionCenter)
+        assertEquals(emptyList<Int>(), picks)
+    }
+
+    @Test
+    fun theEndsLeaveTheKeyToTheScreen() {
+        show(start = 0)
+        press(Key.DirectionUp)
+        assertEquals(emptyList<Int>(), picks)
+    }
+
+    @Test
+    fun okMovesOnToWhatIsBelow() {
+        show(start = 1)
+        press(Key.DirectionDown)
+        press(Key.DirectionCenter)
+        assertEquals(listOf(2), picks)
+        rule.onNodeWithContentDescription("Below").assertIsFocused()
+    }
+
+    @Test
+    fun leavingTheWheelKeepsTheValueItWasTurnedTo() {
+        show(start = 1)
+        press(Key.DirectionDown)
+        rule.onNodeWithContentDescription("Below").requestFocus()
+        rule.waitForIdle()
+        assertEquals(listOf(2), picks)
+    }
+}
diff --git a/app/src/androidTest/java/video/typetype/tv/ui/PlaybackControllerTest.kt b/app/src/androidTest/java/video/typetype/tv/ui/PlaybackControllerTest.kt
index 07b0684..63fde82 100644
--- a/app/src/androidTest/java/video/typetype/tv/ui/PlaybackControllerTest.kt
+++ b/app/src/androidTest/java/video/typetype/tv/ui/PlaybackControllerTest.kt
@@ -17,7 +17,7 @@ import org.junit.After
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertTrue
 import org.junit.Test
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.MockContentRepository
 import video.typetype.tv.data.net.AlwaysOnline
 import video.typetype.tv.data.net.ApiException
diff --git a/app/src/androidTest/java/video/typetype/tv/ui/PlayerControlDescriptionsTest.kt b/app/src/androidTest/java/video/typetype/tv/ui/PlayerControlDescriptionsTest.kt
index 6b729df..19b7ddd 100644
--- a/app/src/androidTest/java/video/typetype/tv/ui/PlayerControlDescriptionsTest.kt
+++ b/app/src/androidTest/java/video/typetype/tv/ui/PlayerControlDescriptionsTest.kt
@@ -28,12 +28,12 @@ class PlayerControlDescriptionsTest {
         rule.setContent {
             PlayerControls(
                 video, remember { PlayerUiState() },
-                PlayerPreferences(true, true, "English", true, "720p", "1.5x", commentsAvailable = true, commentsOn = true, audioLabel = "French"),
-                PlayerControlActions({}, {}, {}, {}, {}, {}, {}),
+                PlayerPreferences(true, true, "English", true, "720p", commentsAvailable = true, commentsOn = true, audioLabel = "French"),
+                PlayerControlActions({}, {}, {}, {}, {}, {}),
                 remember { FocusRequester() },
             )
         }
-        listOf("Video quality, 720p", "Playback speed, 1.5x", "Audio language, French", "Scrolling comments on").forEach {
+        listOf("Video quality, 720p", "Audio language, French", "Scrolling comments on").forEach {
             rule.onNode(hasContentDescription(it)).assertIsDisplayed()
         }
     }
diff --git a/app/src/androidTest/java/video/typetype/tv/ui/PlayerControlsOptionsTest.kt b/app/src/androidTest/java/video/typetype/tv/ui/PlayerControlsOptionsTest.kt
index 0c00387..b699167 100644
--- a/app/src/androidTest/java/video/typetype/tv/ui/PlayerControlsOptionsTest.kt
+++ b/app/src/androidTest/java/video/typetype/tv/ui/PlayerControlsOptionsTest.kt
@@ -2,12 +2,18 @@ package video.typetype.tv.ui
 
 import androidx.compose.runtime.remember
 import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.hasContentDescription
 import androidx.compose.ui.test.junit4.createComposeRule
+import androidx.compose.ui.test.performClick
+import org.junit.Assert.assertEquals
 import androidx.compose.ui.test.onNodeWithText
 import androidx.test.platform.app.InstrumentationRegistry
+import androidx.compose.ui.test.onRoot
+import androidx.compose.ui.test.getBoundsInRoot
+import org.junit.Assert.assertTrue
 import org.junit.Rule
 import org.junit.Test
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.Channel
 import video.typetype.tv.data.Video
 import video.typetype.tv.ui.player.PlayerControlActions
@@ -25,7 +31,7 @@ class PlayerControlsOptionsTest {
         "https://v.example/1", "A title", Channel("c", "Channel", "", "1M"),
         durationSeconds = 120, views = "1 view", age = "today", genre = "", description = "",
     )
-    private val actions = PlayerControlActions({}, {}, {}, {}, {}, {}, {})
+    private val actions = PlayerControlActions({}, {}, {}, {}, {}, {})
 
     private fun show(preferences: PlayerPreferences) = rule.setContent {
         val state = remember { PlayerUiState() }
@@ -35,17 +41,57 @@ class PlayerControlsOptionsTest {
 
     @Test
     fun hidesCaptionAndQualityButtonsWhenTheyCannotWork() {
-        show(PlayerPreferences(false, false, "", false, "Auto", "1x"))
+        show(PlayerPreferences(false, false, "", false, "Auto"))
         rule.onNodeWithText(context.getString(R.string.player_captions)).assertDoesNotExist()
         rule.onNodeWithText("Auto").assertDoesNotExist()
-        rule.onNodeWithText("1x").assertIsDisplayed()
+        rule.onNodeWithText(context.getString(R.string.menu_comments)).assertDoesNotExist()
     }
 
     @Test
     fun showsTheSelectedCaptionLanguageAndQuality() {
-        show(PlayerPreferences(true, true, "English", true, "720p", "1.25x"))
+        show(PlayerPreferences(true, true, "English", true, "720p"))
         rule.onNodeWithText("English").assertIsDisplayed()
         rule.onNodeWithText("720p").assertIsDisplayed()
-        rule.onNodeWithText("1.25x").assertIsDisplayed()
+    }
+
+    @Test
+    fun theCommentsTheChannelAndTheDescriptionAreOnePressAway() {
+        var opened = ""
+        rule.setContent {
+            PlayerControls(
+                video.copy(channel = video.channel.copy(url = "https://c.example")),
+                remember { PlayerUiState() },
+                PlayerPreferences(false, false, "", false, "Auto", commentsPanelAvailable = true),
+                PlayerControlActions({}, {}, {}, {}, {}, {}, onOpenComments = { opened = "comments" }, onShowChannel = { opened = "channel" }, onOpenDescription = { opened = "description" }),
+                remember { FocusRequester() },
+            )
+        }
+        rule.onNodeWithText(context.getString(R.string.menu_comments)).performClick()
+        assertEquals("comments", opened)
+        rule.onNode(hasContentDescription(context.getString(R.string.player_open_channel_description, "Channel"))).performClick()
+        assertEquals("channel", opened)
+        rule.onNode(hasContentDescription(context.getString(R.string.menu_description))).performClick()
+        assertEquals("description", opened)
+    }
+
+    @Test
+    fun manyChoicesWithALongAudioNameStillFitOnTheScreen() {
+        rule.setContent {
+            PlayerControls(
+                video.copy(channel = video.channel.copy(url = "https://c.example")),
+                remember { PlayerUiState() },
+                PlayerPreferences(
+                    true, true, "English (auto-generated)", true, "1080p",
+                    audioLabel = "French (FR) original", commentsPanelAvailable = true,
+                ),
+                actions,
+                remember { FocusRequester() },
+            )
+        }
+        val screen = rule.onRoot().getBoundsInRoot().right
+        val more = rule.onNode(hasContentDescription(context.getString(R.string.player_more_description))).getBoundsInRoot()
+        assertTrue(more.right <= screen)
+        rule.onNodeWithText("French (FR) original").assertDoesNotExist()
+        rule.onNodeWithText(context.getString(R.string.menu_comments)).assertIsDisplayed()
     }
 }
diff --git a/app/src/androidTest/java/video/typetype/tv/ui/PlayerPanelsTest.kt b/app/src/androidTest/java/video/typetype/tv/ui/PlayerPanelsTest.kt
index cff912a..8db22a4 100644
--- a/app/src/androidTest/java/video/typetype/tv/ui/PlayerPanelsTest.kt
+++ b/app/src/androidTest/java/video/typetype/tv/ui/PlayerPanelsTest.kt
@@ -6,13 +6,15 @@ import androidx.compose.ui.semantics.SemanticsNode
 import androidx.compose.ui.semantics.SemanticsProperties
 import androidx.compose.ui.semantics.getOrNull
 import androidx.compose.ui.test.ExperimentalTestApi
+import androidx.compose.ui.test.assert
 import androidx.compose.ui.test.assertIsFocused
 import androidx.compose.ui.test.hasClickAction
 import androidx.compose.ui.test.hasContentDescription
 import androidx.compose.ui.test.hasScrollAction
 import androidx.compose.ui.test.isFocused
 import androidx.compose.ui.test.junit4.accessibility.enableAccessibilityChecks
-import androidx.compose.ui.test.junit4.createComposeRule
+import androidx.activity.ComponentActivity
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
 import androidx.compose.ui.test.onFirst
 import androidx.compose.ui.test.onRoot
 import androidx.compose.ui.test.performKeyInput
@@ -40,7 +42,7 @@ import video.typetype.tv.ui.player.panel.QueuePanel
 @OptIn(ExperimentalTestApi::class)
 class PlayerPanelsTest {
     @get:Rule
-    val rule = createComposeRule()
+    val rule = createAndroidComposeRule<ComponentActivity>()
 
     private val chapters = listOf(Chapter("Intro", 0), Chapter("Part one", 60), Chapter("Part two", 300))
 
@@ -70,12 +72,13 @@ class PlayerPanelsTest {
     private val menuModel = PlayerMenuModel(
         hasChapters = true, queueSize = 3, captionsAvailable = true, activity = VideoActivity(favorite = true),
         channelName = "Channel", canSubscribe = true, audioOnly = false, statsOn = true,
+        speedLabel = "1.5x",
     )
 
     private fun menuActions(log: MutableList<String> = mutableListOf()) = PlayerMenuActions(
         onChapters = { log += "chapters" }, onDescription = { log += "description" }, onComments = { log += "comments" }, onQueue = { log += "queue" },
         onFavorite = { log += "favorite" }, onWatchLater = { log += "watch-later" }, onSubscribe = { log += "subscribe" },
-        onPlaylists = { log += "playlists" }, onAudioOnly = { log += "audio-only" },
+        onPlaylists = { log += "playlists" }, onSpeed = { log += "speed" }, onAudioOnly = { log += "audio-only" },
         onCaptionStyle = { log += "caption-style" }, onStats = { log += "stats" },
     )
 
@@ -93,6 +96,15 @@ class PlayerPanelsTest {
         assertEquals(listOf("chapters"), log)
     }
 
+    @Test
+    fun theMenuOpensOnTheRowItWasLeftOnAndRemembersTheNextOne() {
+        val chosen = mutableListOf<String>()
+        rule.setContent { PlayerMenuPanel(menuModel, menuActions(), onClose = {}, initialEntry = "comments", onEntry = { chosen += it }) }
+        rule.waitForIdle()
+        rule.onAllNodes(isFocused()).onFirst().assert(hasContentDescription("Comments")).performKeyInput { pressKey(Key.DirectionCenter) }
+        assertEquals(listOf("comments"), chosen)
+    }
+
     @Test
     fun theMenuReportsTheStateOfEachToggle() {
         rule.setContent { PlayerMenuPanel(menuModel, menuActions(), onClose = {}) }
@@ -101,6 +113,8 @@ class PlayerPanelsTest {
         rule.onNode(hasContentDescription("Subscribe to Channel")).assertExists()
         rule.onNode(hasScrollAction()).performScrollToNode(hasContentDescription("Playback statistics, On"))
         rule.onNode(hasContentDescription("Playback statistics, On")).assertExists()
+        rule.onNode(hasScrollAction()).performScrollToNode(hasContentDescription("Playback speed, 1.5x"))
+        rule.onNode(hasContentDescription("Playback speed, 1.5x")).assertExists()
     }
 
     @Test
@@ -159,7 +173,7 @@ class PlayerPanelsTest {
         var closed = 0
         rule.setContent { InfoPanel(video, onClose = { closed++ }) }
         rule.waitForIdle()
-        rule.onAllNodes(isFocused()).onFirst().performKeyInput { pressKey(Key.Back) }
+        rule.runOnUiThread { rule.activity.onBackPressedDispatcher.onBackPressed() }
         rule.waitForIdle()
         assertEquals(1, closed)
     }
diff --git a/app/src/androidTest/java/video/typetype/tv/ui/PlayerRemoteKeysTest.kt b/app/src/androidTest/java/video/typetype/tv/ui/PlayerRemoteKeysTest.kt
new file mode 100644
index 0000000..eb91a67
--- /dev/null
+++ b/app/src/androidTest/java/video/typetype/tv/ui/PlayerRemoteKeysTest.kt
@@ -0,0 +1,51 @@
+package video.typetype.tv.ui
+
+import android.view.KeyEvent as AndroidKeyEvent
+import androidx.compose.ui.input.key.KeyEvent
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import video.typetype.tv.ui.player.PlayerPanel
+import video.typetype.tv.ui.player.RemoteKeyActions
+import video.typetype.tv.ui.player.handleRemoteKey
+
+class PlayerRemoteKeysTest {
+    private val calls = mutableListOf<String>()
+    private val actions = RemoteKeyActions(
+        play = { calls += "play" },
+        pause = { calls += "pause" },
+        next = { calls += "next" },
+        startOver = { calls += "start" },
+        toggleCaptions = { calls += "captions" },
+        openPanel = { calls += it.name },
+        seekToFraction = { calls += "seek $it" },
+    )
+
+    private fun press(code: Int, panelOpen: Boolean = false) =
+        handleRemoteKey(KeyEvent(AndroidKeyEvent(AndroidKeyEvent.ACTION_DOWN, code)), panelOpen, actions)
+
+    @Test
+    fun dedicatedKeysReachTheirTargetInOnePress() {
+        assertTrue(press(AndroidKeyEvent.KEYCODE_CAPTIONS))
+        assertTrue(press(AndroidKeyEvent.KEYCODE_INFO))
+        assertTrue(press(AndroidKeyEvent.KEYCODE_MENU))
+        assertTrue(press(AndroidKeyEvent.KEYCODE_MEDIA_NEXT))
+        assertTrue(press(AndroidKeyEvent.KEYCODE_MEDIA_PREVIOUS))
+        assertEquals(listOf("captions", PlayerPanel.Info.name, PlayerPanel.Menu.name, "next", "start"), calls)
+    }
+
+    @Test
+    fun digitsJumpToTenthsOfTheVideo() {
+        assertTrue(press(AndroidKeyEvent.KEYCODE_5))
+        assertTrue(press(AndroidKeyEvent.KEYCODE_0))
+        assertEquals(listOf("seek 0.5", "seek 0.0"), calls)
+    }
+
+    @Test
+    fun arrowsAndOpenPanelsAreLeftAlone() {
+        assertFalse(press(AndroidKeyEvent.KEYCODE_DPAD_DOWN))
+        assertFalse(press(AndroidKeyEvent.KEYCODE_CAPTIONS, panelOpen = true))
+        assertTrue(calls.isEmpty())
+    }
+}
diff --git a/app/src/androidTest/java/video/typetype/tv/ui/PlayerSessionTest.kt b/app/src/androidTest/java/video/typetype/tv/ui/PlayerSessionTest.kt
index ca66647..978e64e 100644
--- a/app/src/androidTest/java/video/typetype/tv/ui/PlayerSessionTest.kt
+++ b/app/src/androidTest/java/video/typetype/tv/ui/PlayerSessionTest.kt
@@ -69,7 +69,8 @@ class PlayerSessionTest {
         press(AndroidKeyEvent.KEYCODE_DPAD_RIGHT)
         press(AndroidKeyEvent.KEYCODE_DPAD_RIGHT)
         press(AndroidKeyEvent.KEYCODE_DPAD_LEFT)
-        assertEquals(105_000L, session.scrub.target)
+        // Each press of one scrub moves a little further: +5 s, +5.25 s, then -5.51 s.
+        assertEquals(104_738L, session.scrub.target)
     }
 
     @Test
@@ -80,26 +81,42 @@ class PlayerSessionTest {
         assertFalse(session.scrub.active)
         onUi { session.controlsVisible = false }
         press(AndroidKeyEvent.KEYCODE_DPAD_LEFT)
-        assertTrue(press(AndroidKeyEvent.KEYCODE_BACK, AndroidKeyEvent.ACTION_DOWN))
-        assertTrue(session.scrub.active)
-        assertTrue(press(AndroidKeyEvent.KEYCODE_BACK, AndroidKeyEvent.ACTION_UP))
+        assertTrue(session.handlesBack(upNextVisible = false))
+        onUi { session.back(upNextVisible = false) }
         assertFalse(session.scrub.active)
     }
 
     @Test
     fun backHidesVisibleControlsBeforeLeaving() {
-        assertTrue(session.controlsVisible)
-        assertTrue(press(AndroidKeyEvent.KEYCODE_BACK, AndroidKeyEvent.ACTION_DOWN))
-        assertTrue(press(AndroidKeyEvent.KEYCODE_BACK, AndroidKeyEvent.ACTION_UP))
+        assertTrue(session.handlesBack(upNextVisible = false))
+        onUi { session.back(upNextVisible = false) }
         assertFalse(session.controlsVisible)
-        assertFalse(press(AndroidKeyEvent.KEYCODE_BACK, AndroidKeyEvent.ACTION_DOWN))
+        assertFalse(session.handlesBack(upNextVisible = false))
+    }
+
+    @Test
+    fun backClosesTheRelatedRowBeforeTheControls() {
+        onUi { session.relatedOpen = true }
+        onUi { session.back(upNextVisible = false) }
+        assertFalse(session.relatedOpen)
+        assertTrue(session.controlsVisible)
+    }
+
+    @Test
+    fun downFromPlaybackLandsOnTheButtons() {
+        onUi { session.controlsVisible = false }
+        assertTrue(press(AndroidKeyEvent.KEYCODE_DPAD_DOWN))
+        assertTrue(session.controlsVisible)
+        assertTrue(session.controlsFromBelow)
+        onUi { session.controlsVisible = false }
+        press(AndroidKeyEvent.KEYCODE_DPAD_UP)
+        assertFalse(session.controlsFromBelow)
     }
 
     @Test
     fun backWithNothingToCancelIsLeftToTheScreen() {
         onUi { session.controlsVisible = false }
-        assertFalse(press(AndroidKeyEvent.KEYCODE_BACK, AndroidKeyEvent.ACTION_DOWN))
-        assertFalse(press(AndroidKeyEvent.KEYCODE_BACK, AndroidKeyEvent.ACTION_UP))
+        assertFalse(session.handlesBack(upNextVisible = false))
     }
 
     @Test
@@ -107,7 +124,8 @@ class PlayerSessionTest {
         onUi { session.controlsVisible = false }
         assertTrue(press(AndroidKeyEvent.KEYCODE_DPAD_CENTER, visible = true))
         assertEquals(1, playedNext)
-        assertTrue(press(AndroidKeyEvent.KEYCODE_BACK, AndroidKeyEvent.ACTION_UP, visible = true))
+        assertTrue(session.handlesBack(upNextVisible = true))
+        onUi { session.back(upNextVisible = true) }
         assertTrue(session.upNext.dismissed)
     }
 
@@ -137,4 +155,34 @@ class PlayerSessionTest {
         assertFalse(press(AndroidKeyEvent.KEYCODE_DPAD_RIGHT))
         assertFalse(session.scrub.active)
     }
+
+    @Test
+    fun aScrubHoldsThePictureThenPlaysFromTheChosenPoint() {
+        onUi {
+            player.play()
+            session.controlsVisible = false
+        }
+        press(AndroidKeyEvent.KEYCODE_DPAD_RIGHT)
+        onUi { assertFalse(player.playWhenReady) }
+        press(AndroidKeyEvent.KEYCODE_DPAD_CENTER)
+        onUi { assertTrue(player.playWhenReady) }
+    }
+
+    @Test
+    fun aCancelledScrubPlaysAgainAndAPausedVideoStaysPaused() {
+        onUi {
+            player.play()
+            session.controlsVisible = false
+        }
+        press(AndroidKeyEvent.KEYCODE_DPAD_LEFT)
+        onUi { session.back(upNextVisible = false) }
+        onUi { assertTrue(player.playWhenReady) }
+        onUi {
+            player.pause()
+            session.controlsVisible = false
+        }
+        press(AndroidKeyEvent.KEYCODE_DPAD_LEFT)
+        press(AndroidKeyEvent.KEYCODE_DPAD_CENTER)
+        onUi { assertFalse(player.playWhenReady) }
+    }
 }
diff --git a/app/src/androidTest/java/video/typetype/tv/ui/RelatedShelfTest.kt b/app/src/androidTest/java/video/typetype/tv/ui/RelatedShelfTest.kt
new file mode 100644
index 0000000..fc24b2b
--- /dev/null
+++ b/app/src/androidTest/java/video/typetype/tv/ui/RelatedShelfTest.kt
@@ -0,0 +1,40 @@
+package video.typetype.tv.ui
+
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.test.isFocused
+import androidx.compose.ui.test.junit4.createComposeRule
+import androidx.compose.ui.test.onFirst
+import androidx.compose.ui.test.performKeyInput
+import androidx.compose.ui.test.pressKey
+import org.junit.Assert.assertEquals
+import org.junit.Rule
+import org.junit.Test
+import video.typetype.tv.data.Chapter
+import video.typetype.tv.ui.player.RelatedShelf
+
+class RelatedShelfTest {
+    @get:Rule
+    val rule = createComposeRule()
+
+    private val chapters = listOf(Chapter("Intro", 0), Chapter("Part one", 60), Chapter("Part two", 300))
+
+    @Test
+    fun theChaptersOpenOnTheOneBeingWatchedAndOkJumpsToTheChosenOne() {
+        val chosen = mutableListOf<String>()
+        rule.setContent {
+            RelatedShelf(
+                videos = emptyList(),
+                chapters = chapters,
+                currentChapter = 1,
+                onChapter = { chosen += it.title },
+                onOpen = {},
+                onClose = {},
+            )
+        }
+        rule.waitForIdle()
+        rule.onAllNodes(isFocused()).onFirst().performKeyInput { pressKey(Key.DirectionRight) }
+        rule.waitForIdle()
+        rule.onAllNodes(isFocused()).onFirst().performKeyInput { pressKey(Key.DirectionCenter) }
+        assertEquals(listOf("Part two"), chosen)
+    }
+}
diff --git a/app/src/androidTest/java/video/typetype/tv/ui/ScreenAccessibilityTest.kt b/app/src/androidTest/java/video/typetype/tv/ui/ScreenAccessibilityTest.kt
index e6e5011..c0f145b 100644
--- a/app/src/androidTest/java/video/typetype/tv/ui/ScreenAccessibilityTest.kt
+++ b/app/src/androidTest/java/video/typetype/tv/ui/ScreenAccessibilityTest.kt
@@ -7,7 +7,7 @@ import androidx.compose.ui.test.tryPerformAccessibilityChecks
 import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.Channel
 import video.typetype.tv.ui.search.SearchScope
 import video.typetype.tv.ui.search.PlaylistResults
@@ -18,18 +18,13 @@ import video.typetype.tv.data.ContentSource
 import video.typetype.tv.data.ChannelSummary
 import video.typetype.tv.ui.detail.PlaylistPickerState
 import video.typetype.tv.ui.detail.PlaylistPicker
-import video.typetype.tv.ui.detail.CommentsState
 import video.typetype.tv.ui.auth.CertificateRequest
 import video.typetype.tv.ui.auth.CertificatePrompt
 import video.typetype.tv.data.net.tls.CertificateInfo
-import video.typetype.tv.data.MockContentRepository
 import video.typetype.tv.data.InMemoryVideoActivity
-import video.typetype.tv.data.ContentRepository
-import video.typetype.tv.data.CommentsPage
-import video.typetype.tv.data.Comment
 import video.typetype.tv.data.SettingItem
 import video.typetype.tv.data.Video
-import video.typetype.tv.ui.auth.UiMessage
+import video.typetype.tv.ui.util.UiMessage
 import video.typetype.tv.ui.components.ScreenFailure
 import video.typetype.tv.ui.player.PlayerControlActions
 import video.typetype.tv.ui.player.PlayerControls
@@ -65,8 +60,8 @@ class ScreenAccessibilityTest {
             val requester = remember { FocusRequester() }
             PlayerControls(
                 video, state,
-                PlayerPreferences(true, true, "English", true, "720p", "1x", commentsAvailable = true, commentsOn = true, audioLabel = "English"),
-                PlayerControlActions({}, {}, {}, {}, {}, {}, {}),
+                PlayerPreferences(true, true, "English", true, "720p", commentsAvailable = true, commentsOn = true, audioLabel = "English"),
+                PlayerControlActions({}, {}, {}, {}, {}, {}),
                 requester,
             )
         }
diff --git a/app/src/androidTest/java/video/typetype/tv/ui/ScreenFailureTest.kt b/app/src/androidTest/java/video/typetype/tv/ui/ScreenFailureTest.kt
index 0e560da..dda8d9b 100644
--- a/app/src/androidTest/java/video/typetype/tv/ui/ScreenFailureTest.kt
+++ b/app/src/androidTest/java/video/typetype/tv/ui/ScreenFailureTest.kt
@@ -8,8 +8,8 @@ import androidx.test.platform.app.InstrumentationRegistry
 import org.junit.Assert.assertEquals
 import org.junit.Rule
 import org.junit.Test
-import video.typetype.tv.R
-import video.typetype.tv.ui.auth.UiMessage
+import video.typetype.tv.resources.R
+import video.typetype.tv.ui.util.UiMessage
 import video.typetype.tv.ui.components.ScreenFailure
 
 class ScreenFailureTest {
diff --git a/app/src/androidTest/java/video/typetype/tv/ui/SeekBarKeysTest.kt b/app/src/androidTest/java/video/typetype/tv/ui/SeekBarKeysTest.kt
index 90b64fd..c8e0264 100644
--- a/app/src/androidTest/java/video/typetype/tv/ui/SeekBarKeysTest.kt
+++ b/app/src/androidTest/java/video/typetype/tv/ui/SeekBarKeysTest.kt
@@ -11,7 +11,7 @@ import org.junit.Assert.assertEquals
 import org.junit.Assert.assertTrue
 import org.junit.Rule
 import org.junit.Test
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.ui.player.SeekBar
 
 class SeekBarKeysTest {
@@ -28,7 +28,7 @@ class SeekBarKeysTest {
                 positionMillis = { 30_000 },
                 bufferedMillis = { 60_000 },
                 durationMillis = 600_000,
-                onScrubBy = { seeks += it },
+                onScrub = { direction, _ -> seeks += direction.toLong() },
                 onTogglePlay = { toggles++ },
             )
         }
diff --git a/app/src/androidTest/java/video/typetype/tv/ui/SettingRowsTest.kt b/app/src/androidTest/java/video/typetype/tv/ui/SettingRowsTest.kt
index 6e99b8a..7a8d631 100644
--- a/app/src/androidTest/java/video/typetype/tv/ui/SettingRowsTest.kt
+++ b/app/src/androidTest/java/video/typetype/tv/ui/SettingRowsTest.kt
@@ -9,8 +9,9 @@ import org.junit.Assert.assertFalse
 import org.junit.Assert.assertTrue
 import org.junit.Rule
 import org.junit.Test
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.SettingItem
+import video.typetype.tv.ui.settings.ChoiceRequest
 import video.typetype.tv.ui.settings.SettingChange
 import video.typetype.tv.ui.settings.SettingRow
 import video.typetype.tv.ui.settings.SettingsSession
@@ -43,15 +44,15 @@ class SettingRowsTest {
     }
 
     @Test
-    fun choiceCyclesThroughTheWireValues() {
+    fun aChoiceOpensItsPickerInsteadOfChangingAlone() {
         val session = SettingsSession()
         val changes = mutableListOf<SettingChange>()
-        show(choice, session, changes)
+        val requests = mutableListOf<ChoiceRequest>()
+        rule.setContent { SettingRow(choice, session, onAction = {}, onChange = { changes += it }, onChoose = { requests += it }) }
         rule.onNodeWithText(context.getString(R.string.settings_default_quality)).performClick()
         rule.waitForIdle()
-        assertEquals("1080p", changes.single().value)
-        assertEquals(1, session.choiceIndex(choice))
-        changes.single().revert()
+        assertEquals(choice, requests.single().item)
+        assertTrue(changes.isEmpty())
         assertEquals(0, session.choiceIndex(choice))
     }
 }
diff --git a/app/src/androidTest/java/video/typetype/tv/ui/SettingsFocusWalkTest.kt b/app/src/androidTest/java/video/typetype/tv/ui/SettingsFocusWalkTest.kt
new file mode 100644
index 0000000..7d292de
--- /dev/null
+++ b/app/src/androidTest/java/video/typetype/tv/ui/SettingsFocusWalkTest.kt
@@ -0,0 +1,77 @@
+package video.typetype.tv.ui
+
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.semantics.SemanticsProperties
+import androidx.compose.ui.test.SemanticsMatcher
+import androidx.compose.ui.test.isFocused
+import androidx.compose.ui.test.junit4.createComposeRule
+import androidx.compose.ui.test.performKeyInput
+import androidx.compose.ui.test.pressKey
+import androidx.compose.ui.test.requestFocus
+import org.junit.Assert.assertEquals
+import org.junit.Rule
+import org.junit.Test
+import video.typetype.tv.data.MockContentRepository
+import video.typetype.tv.data.MockSettings
+import video.typetype.tv.ui.settings.SettingsScreen
+import video.typetype.tv.ui.settings.SettingsSession
+
+// Every row of every settings group can be reached with Down and back with Up, information rows included, and
+// Left from any row returns to that group's tab: the focus never jumps over a row or to another group.
+class SettingsFocusWalkTest {
+    @get:Rule
+    val rule = createComposeRule()
+
+    // A picker opens in its own window; the focused node of the topmost window is the one that receives keys.
+    private fun focused() = rule.onAllNodes(isFocused()).let { it[it.fetchSemanticsNodes().size - 1] }
+
+    private fun focusedId(): Int = focused().fetchSemanticsNode().id
+
+    private fun press(key: Key) {
+        focused().performKeyInput { pressKey(key) }
+        rule.waitForIdle()
+    }
+
+    @Test
+    fun upAndDownVisitEveryRowOfEveryGroup() {
+        rule.setContent { SettingsScreen(MockContentRepository(latencyMillis = 0), SettingsSession(), onAction = {}) }
+        val tabs = SemanticsMatcher.expectValue(SemanticsProperties.Role, Role.Tab)
+        rule.waitUntil(5_000) { rule.onAllNodes(tabs).fetchSemanticsNodes().size == MockSettings.groups.size }
+        MockSettings.groups.forEachIndexed { index, group ->
+            rule.onAllNodes(tabs)[index].requestFocus()
+            rule.waitForIdle()
+            press(Key.DirectionRight)
+            repeat(group.items.size) { press(Key.DirectionUp) }
+            val visited = mutableListOf(focusedId())
+            repeat(group.items.size) {
+                press(Key.DirectionDown)
+                if (focusedId() != visited.last()) visited += focusedId()
+            }
+            assertEquals("rows reached going down in ${group.id}", group.items.size, visited.size)
+            repeat(group.items.size - 1) { press(Key.DirectionUp) }
+            assertEquals("first row reached going back up in ${group.id}", visited.first(), focusedId())
+            // From the last row, Left goes back to this group's tab, not to the nearest one.
+            repeat(group.items.size - 1) { press(Key.DirectionDown) }
+            press(Key.DirectionLeft)
+            assertEquals("Left returns to the tab of ${group.id}", rule.onAllNodes(tabs)[index].fetchSemanticsNode().id, focusedId())
+        }
+    }
+
+    @Test
+    fun pickingAnOptionGivesTheFocusBackToItsRow() {
+        rule.setContent { SettingsScreen(MockContentRepository(latencyMillis = 0), SettingsSession(), onAction = {}) }
+        val tabs = SemanticsMatcher.expectValue(SemanticsProperties.Role, Role.Tab)
+        rule.waitUntil(5_000) { rule.onAllNodes(tabs).fetchSemanticsNodes().size == MockSettings.groups.size }
+        val playback = MockSettings.groups.indexOfFirst { it.id == "playback" }
+        rule.onAllNodes(tabs)[playback].requestFocus()
+        rule.waitForIdle()
+        press(Key.DirectionRight)
+        repeat(MockSettings.groups[playback].items.size) { press(Key.DirectionUp) }
+        val row = focusedId()
+        press(Key.DirectionCenter)
+        press(Key.DirectionDown)
+        press(Key.DirectionCenter)
+        assertEquals("the focus is back on the setting that was changed", row, focusedId())
+    }
+}
diff --git a/app/src/androidTest/java/video/typetype/tv/ui/VideoCardMenuTest.kt b/app/src/androidTest/java/video/typetype/tv/ui/VideoCardMenuTest.kt
new file mode 100644
index 0000000..3f93523
--- /dev/null
+++ b/app/src/androidTest/java/video/typetype/tv/ui/VideoCardMenuTest.kt
@@ -0,0 +1,165 @@
+package video.typetype.tv.ui
+
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.test.junit4.createComposeRule
+import androidx.compose.ui.test.onNodeWithContentDescription
+import androidx.compose.ui.test.onRoot
+import androidx.compose.ui.test.performClick
+import androidx.compose.ui.test.performKeyInput
+import androidx.compose.ui.test.pressKey
+import androidx.compose.ui.test.requestFocus
+import androidx.test.platform.app.InstrumentationRegistry
+import org.junit.Assert.assertEquals
+import org.junit.Rule
+import org.junit.Test
+import video.typetype.tv.data.MockCatalog
+import video.typetype.tv.data.Video
+import video.typetype.tv.resources.R
+import video.typetype.tv.ui.components.LocalVideoMenu
+import video.typetype.tv.ui.components.PlaylistContext
+import video.typetype.tv.ui.components.VideoCard
+import video.typetype.tv.ui.components.VideoMenu
+import video.typetype.tv.data.MockContentRepository
+import video.typetype.tv.ui.detail.VideoMenuActions
+import video.typetype.tv.ui.detail.VideoMenuPanel
+
+class VideoCardMenuTest {
+    @get:Rule
+    val rule = createComposeRule()
+
+    private val video = MockCatalog.all.first()
+    private var opened = 0
+    private var menus = mutableListOf<Video>()
+
+    private fun showCard(withMenu: Boolean) {
+        rule.setContent {
+            val card = @androidx.compose.runtime.Composable { VideoCard(video, onClick = { opened++ }) }
+            if (withMenu) {
+                CompositionLocalProvider(LocalVideoMenu provides recordingMenu()) { card() }
+            } else {
+                card()
+            }
+        }
+        rule.onNodeWithContentDescription(description()).requestFocus()
+    }
+
+    private var playedFromCard = mutableListOf<Video>()
+
+    private fun recordingMenu(onOpen: () -> Unit = {}) = object : VideoMenu {
+        override fun open(video: Video, playlist: PlaylistContext?, onClosed: () -> Unit) {
+            menus += video
+            onOpen()
+        }
+
+        override fun play(video: Video) {
+            playedFromCard += video
+        }
+    }
+
+    private fun description(): String = InstrumentationRegistry.getInstrumentation().targetContext
+        .getString(R.string.card_description, video.title, video.channel.name)
+
+    @Test
+    fun holdingOkOpensTheMenuInsteadOfTheVideo() {
+        showCard(withMenu = true)
+        rule.onNodeWithContentDescription(description()).performKeyInput { pressKey(Key.DirectionCenter, 1_200) }
+        rule.waitForIdle()
+        assertEquals(listOf(video), menus)
+        assertEquals(0, opened)
+    }
+
+    @Test
+    fun aShortPressStillOpensTheVideo() {
+        showCard(withMenu = true)
+        rule.onNodeWithContentDescription(description()).performKeyInput { pressKey(Key.DirectionCenter) }
+        rule.waitForIdle()
+        assertEquals(1, opened)
+        assertEquals(emptyList<Video>(), menus)
+    }
+
+    @Test
+    fun aCardWithoutMenuKeepsItsClick() {
+        showCard(withMenu = false)
+        rule.onNodeWithContentDescription(description()).performKeyInput { pressKey(Key.DirectionCenter) }
+        rule.waitForIdle()
+        assertEquals(1, opened)
+    }
+
+    @Test
+    fun releasingTheOkThatOpenedTheMenuDoesNotPlay() {
+        var played = 0
+        rule.setContent {
+            var shown by remember { mutableStateOf(false) }
+            CompositionLocalProvider(LocalVideoMenu provides recordingMenu { shown = true }) {
+                VideoCard(video, onClick = { opened++ })
+            }
+            if (shown) {
+                VideoMenuPanel(
+                    video = video,
+                    repository = MockContentRepository(),
+                    actions = VideoMenuActions(onPlay = { played++ }, onOpenChannel = {}),
+                    onClose = { shown = false },
+                )
+            }
+        }
+        rule.onNodeWithContentDescription(description()).requestFocus()
+        // OK is held on the card: the menu opens, takes the focus, and the key keeps repeating until released.
+        rule.onRoot().performKeyInput {
+            keyDown(Key.DirectionCenter)
+            advanceEventTime(1_500)
+        }
+        rule.waitForIdle()
+        rule.onRoot().performKeyInput { keyUp(Key.DirectionCenter) }
+        rule.waitForIdle()
+        assertEquals(0, played)
+        assertEquals(0, opened)
+        val play = InstrumentationRegistry.getInstrumentation().targetContext.getString(R.string.detail_play)
+        rule.onNodeWithContentDescription(play).performKeyInput { pressKey(Key.DirectionCenter) }
+        rule.waitForIdle()
+        assertEquals(1, played)
+    }
+
+    @Test
+    fun theMenuKeyOpensTheMenu() {
+        showCard(withMenu = true)
+        rule.onNodeWithContentDescription(description()).performKeyInput { pressKey(Key.Menu) }
+        rule.waitForIdle()
+        assertEquals(listOf(video), menus)
+        assertEquals(0, opened)
+    }
+
+    @Test
+    fun thePlayKeyPlaysWithoutOpeningTheDetailPage() {
+        showCard(withMenu = true)
+        rule.onNodeWithContentDescription(description()).performKeyInput { pressKey(Key.MediaPlayPause) }
+        rule.waitForIdle()
+        assertEquals(listOf(video), playedFromCard)
+        assertEquals(0, opened)
+    }
+
+    @Test
+    fun aPlaylistCardOffersToRemoveTheVideoFromIt() {
+        val removed = mutableListOf<Video>()
+        val closes = mutableListOf<Boolean>()
+        rule.setContent {
+            VideoMenuPanel(
+                video = video,
+                repository = MockContentRepository(latencyMillis = 0),
+                actions = VideoMenuActions(onPlay = {}, onOpenChannel = {}),
+                onClose = { closes += it },
+                playlist = PlaylistContext("mock-1", "memes") { removed += it },
+            )
+        }
+        val label = InstrumentationRegistry.getInstrumentation().targetContext
+            .getString(R.string.video_menu_remove_from_playlist, "memes")
+        rule.onNodeWithContentDescription(label).performClick()
+        rule.waitUntil(5_000) { removed.isNotEmpty() }
+        assertEquals(listOf(video), removed)
+        assertEquals(listOf(false), closes)
+    }
+}
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index 97ec89e..b378659 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -15,7 +15,7 @@
         android:dataExtractionRules="@xml/data_extraction_rules"
         android:fullBackupContent="false"
         android:banner="@drawable/tv_banner"
-        android:icon="@drawable/ic_typetype_mark"
+        android:icon="@drawable/ic_launcher"
         android:label="@string/app_name"
         android:supportsRtl="true"
         android:theme="@style/Theme.TypeTypeTv">
diff --git a/app/src/main/java/video/typetype/tv/AppContainer.kt b/app/src/main/java/video/typetype/tv/AppContainer.kt
index e55f750..d346615 100644
--- a/app/src/main/java/video/typetype/tv/AppContainer.kt
+++ b/app/src/main/java/video/typetype/tv/AppContainer.kt
@@ -4,6 +4,8 @@ import android.content.Context
 import androidx.media3.common.util.UnstableApi
 import video.typetype.tv.data.ContentRepository
 import video.typetype.tv.data.PresenceReport
+import video.typetype.tv.data.device.PerformanceSettings
+import video.typetype.tv.data.device.PreferencesDeviceStore
 import video.typetype.tv.data.dto.UserProfileDto
 import video.typetype.tv.data.net.AndroidConnectivity
 import video.typetype.tv.data.net.Connectivity
@@ -13,9 +15,15 @@ import video.typetype.tv.data.remote.AndroidTextProvider
 import video.typetype.tv.data.remote.RemoteContentRepository
 import video.typetype.tv.data.remote.RemotePresence
 import video.typetype.tv.data.remote.RemoteSettings
+import video.typetype.tv.data.remote.RemoteUserSettings
 import video.typetype.tv.data.session.Backend
 import video.typetype.tv.data.session.DeviceProfileStore
 import video.typetype.tv.data.session.SessionManager
+import video.typetype.tv.data.session.StreamAccess
+import video.typetype.tv.playback.CodecSupport
+import video.typetype.tv.playback.DecoderFailures
+import video.typetype.tv.playback.DeviceCodecSupport
+import video.typetype.tv.playback.LearnedCodecSupport
 import video.typetype.tv.playback.PlaybackProvider
 import video.typetype.tv.playback.RoutingPlaybackProvider
 
@@ -30,12 +38,25 @@ class AppContainer(context: Context) {
     }
 
     private val deviceProfile by lazy { DeviceProfileStore(appContext, appVersion) }
+    val performance by lazy { PerformanceSettings(PreferencesDeviceStore(appContext)) }
 
     fun warmUp() {
         Thread({ secrets.warmUp() }, "secrets-warmup").start()
     }
 
-    fun repository(backend: Backend, profile: UserProfileDto): ContentRepository = RemoteContentRepository(
+    // One account's view of the server: the repository and the players share its settings and how streams are asked.
+    fun services(backend: Backend, profile: UserProfileDto): SignedInServices {
+        val userSettings = RemoteUserSettings(backend.api)
+        val access = StreamAccess(backend.instance.guestAllowed, userSettings::allowListOnly)
+        return SignedInServices(repository(backend, profile, userSettings, access), playback(backend, access))
+    }
+
+    private fun repository(
+        backend: Backend,
+        profile: UserProfileDto,
+        userSettings: RemoteUserSettings,
+        access: StreamAccess,
+    ): ContentRepository = RemoteContentRepository(
         api = backend.api,
         library = backend.library,
         apiBase = backend.apiBase,
@@ -53,9 +74,24 @@ class AppContainer(context: Context) {
             device = deviceProfile.profile(),
             enabled = !profile.id.startsWith("guest"),
         ).also { it.report(PresenceReport.Online) },
+        watch = backend.watch,
+        userSettings = userSettings,
+        access = access,
+        performance = performance,
     )
 
+    private val codecs: CodecSupport by lazy { deviceCodecs() }
+
+    @OptIn(UnstableApi::class)
+    @androidx.annotation.OptIn(UnstableApi::class)
+    private fun playback(backend: Backend, access: StreamAccess): PlaybackProvider =
+        RoutingPlaybackProvider(backend, codecs, access, decoderFailures) { connectivity.online.value }
+
     @OptIn(UnstableApi::class)
     @androidx.annotation.OptIn(UnstableApi::class)
-    fun playback(backend: Backend): PlaybackProvider = RoutingPlaybackProvider(backend) { connectivity.online.value }
+    private fun deviceCodecs(): CodecSupport = LearnedCodecSupport(DeviceCodecSupport(appContext), decoderFailures)
+
+    val decoderFailures by lazy { DecoderFailures(PreferencesDeviceStore(appContext, PreferencesDeviceStore.DECODERS)) }
 }
+
+class SignedInServices(val repository: ContentRepository, val playback: PlaybackProvider)
diff --git a/app/src/main/java/video/typetype/tv/playback/DeviceDecoders.kt b/app/src/main/java/video/typetype/tv/playback/DeviceDecoders.kt
deleted file mode 100644
index 1cac0fb..0000000
--- a/app/src/main/java/video/typetype/tv/playback/DeviceDecoders.kt
+++ /dev/null
@@ -1,26 +0,0 @@
-package video.typetype.tv.playback
-
-import android.media.MediaCodecList
-import android.media.MediaFormat
-
-fun interface DecoderProbe {
-    fun supports(mimeType: String, width: Int, height: Int): Boolean
-}
-
-object DeviceDecoders {
-    val Hardware = DecoderProbe { mimeType, width, height ->
-        MediaCodecList(MediaCodecList.REGULAR_CODECS).codecInfos.any { info ->
-            !info.isEncoder && info.supportedTypes.any { it.equals(mimeType, ignoreCase = true) } &&
-                runCatching {
-                    info.getCapabilitiesForType(mimeType).videoCapabilities?.isSizeSupported(width, height) == true
-                }.getOrDefault(false)
-        }
-    }
-
-    fun maxAvcHeight(probe: DecoderProbe = Hardware): Int =
-        HEIGHT_LADDER.firstOrNull { (height, width) -> probe.supports(MediaFormat.MIMETYPE_VIDEO_AVC, width, height) }
-            ?.first ?: LOWEST_HEIGHT
-
-    private val HEIGHT_LADDER = listOf(1080 to 1920, 720 to 1280, 480 to 854, 360 to 640)
-    private const val LOWEST_HEIGHT = 360
-}
diff --git a/app/src/main/java/video/typetype/tv/playback/PlaybackProvider.kt b/app/src/main/java/video/typetype/tv/playback/PlaybackProvider.kt
deleted file mode 100644
index f6ed381..0000000
--- a/app/src/main/java/video/typetype/tv/playback/PlaybackProvider.kt
+++ /dev/null
@@ -1,45 +0,0 @@
-package video.typetype.tv.playback
-
-import android.content.Context
-import androidx.media3.common.C
-import androidx.media3.exoplayer.ExoPlayer
-import video.typetype.tv.data.SubtitleTrack
-
-data class PlaybackRequest(
-    val startMs: Long = 0L,
-    val maxHeight: Int? = null,
-    val subtitles: List<SubtitleTrack> = emptyList(),
-    val liveManifest: String? = null,
-    val audioTrackId: String? = null,
-    val audioLanguage: String = "",
-    val preferOriginalAudio: Boolean = false,
-    val trace: StartupTrace? = null,
-)
-
-class PlayerHandle(
-    val player: ExoPlayer,
-    val heights: List<Int> = emptyList(),
-    val captionLanguages: List<CaptionLanguage> = emptyList(),
-    val isLive: Boolean = false,
-    val audioTracks: List<AudioTrackChoice> = emptyList(),
-    val audioTrackId: String? = null,
-    private val onRelease: () -> Unit = {},
-) {
-    fun selectCaption(language: String?) {
-        player.trackSelectionParameters = player.trackSelectionParameters.buildUpon()
-            .setTrackTypeDisabled(C.TRACK_TYPE_TEXT, language == null)
-            .apply { if (language != null) setPreferredTextLanguage(language) }
-            .build()
-    }
-
-    fun release() {
-        onRelease()
-        player.release()
-    }
-}
-
-data class CaptionLanguage(val tag: String, val label: String)
-
-interface PlaybackProvider {
-    suspend fun open(context: Context, videoUrl: String, request: PlaybackRequest): PlayerHandle
-}
diff --git a/app/src/main/java/video/typetype/tv/playback/SabrPlaybackProvider.kt b/app/src/main/java/video/typetype/tv/playback/SabrPlaybackProvider.kt
deleted file mode 100644
index 370d349..0000000
--- a/app/src/main/java/video/typetype/tv/playback/SabrPlaybackProvider.kt
+++ /dev/null
@@ -1,92 +0,0 @@
-package video.typetype.tv.playback
-
-import android.content.Context
-import androidx.media3.common.MediaItem
-import androidx.media3.common.util.UnstableApi
-import androidx.media3.datasource.okhttp.OkHttpDataSource
-import dev.typetype.player.TypeTypeMediaSource
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.SupervisorJob
-import video.typetype.tv.data.dto.SabrSessionRequest
-import video.typetype.tv.data.net.ApiException
-import video.typetype.tv.data.net.ApiFailure
-import video.typetype.tv.data.net.FailureCategory
-import video.typetype.tv.data.net.HttpClients
-import video.typetype.tv.data.session.Backend
-
-@UnstableApi
-class SabrPlaybackProvider(
-    private val backend: Backend,
-    private val online: () -> Boolean = { true },
-    private val maxHeight: () -> Int = { DeviceDecoders.maxAvcHeight() },
-) : PlaybackProvider {
-
-    override suspend fun open(context: Context, videoUrl: String, request: PlaybackRequest): PlayerHandle {
-        val startPositionMs = request.startMs
-        val videoId = VideoIds.parse(videoUrl) ?: failure("The video address is not supported")
-        val trace = request.trace
-        val stream = backend.api.streamBootstrap(videoUrl)
-        trace?.step("bootstrap")
-        val deviceLimit = maxHeight()
-        val limit = minOf(deviceLimit, request.maxHeight ?: deviceLimit)
-        val tracks = FormatSelector.audioTracks(stream)
-        val chosenTrack = request.audioTrackId?.takeIf { id -> tracks.any { it.id == id } }
-            ?: FormatSelector.defaultAudioTrack(tracks, request.audioLanguage, request.preferOriginalAudio)
-        val tuple = FormatSelector.select(stream, limit, chosenTrack) ?: failure("No compatible video format")
-        val created = backend.sabr.createSession(
-            videoId,
-            SabrSessionRequest(tuple.videoItag, tuple.audioItag, tuple.audioTrackId, startPositionMs, startPositionMs),
-        )
-        trace?.step("session")
-        val session = SabrSession(videoId, tuple, created)
-        val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
-        val loader = SabrWindowLoader(backend.sabr, session, SabrWindowMapper(backend.apiBase), scope)
-        val firstWindow = try {
-            loader.firstWindow(startPositionMs)
-        } catch (error: Throwable) {
-            loader.release()
-            throw error
-        }
-        trace?.step("first window")
-        val player = TvPlayers.create(context)
-        val tracker = PositionTracker(player).also { it.start() }
-        val media = TypeTypeMediaSource(
-            mediaItem = MediaItem.Builder().setMediaId(videoId).build(),
-            initialPositionUs = startPositionMs * MICROS_PER_MILLI,
-            initialWindow = firstWindow,
-            playbackPositionUs = { tracker.currentMs() * MICROS_PER_MILLI },
-            windowLoader = loader,
-            dataSourceFactory = SabrRetryDataSource.Factory(OkHttpDataSource.Factory(backend.mediaHttp)),
-            loadErrorHandlingPolicy = MediaLoadErrorPolicy(online),
-        )
-        val captions = CaptionChoice.languages(request.subtitles)
-        val source = SubtitleSources.attach(media, captions, OkHttpDataSource.Factory(subtitleHttp))
-        player.setMediaSource(source, startPositionMs)
-        player.prepare()
-        player.playWhenReady = true
-        trace?.let {
-            player.addListener(FirstFrameTrace(it))
-            player.addAnalyticsListener(StartupLoads(it))
-        }
-        return PlayerHandle(
-            player = player,
-            heights = FormatSelector.heights(stream, deviceLimit),
-            audioTracks = tracks,
-            audioTrackId = tuple.audioTrackId,
-            captionLanguages = captions.map { CaptionLanguage(it.language, it.label) },
-        ) {
-            tracker.stop()
-            loader.release()
-        }
-    }
-
-    private val subtitleHttp by lazy { HttpClients.subtitles() }
-
-    private fun failure(message: String): Nothing =
-        throw ApiException(ApiFailure(FailureCategory.Contract, null, "playback_unavailable", message, null))
-
-    private companion object {
-        const val MICROS_PER_MILLI = 1_000L
-    }
-}
diff --git a/app/src/main/java/video/typetype/tv/playback/TvPlayers.kt b/app/src/main/java/video/typetype/tv/playback/TvPlayers.kt
deleted file mode 100644
index 7f828fa..0000000
--- a/app/src/main/java/video/typetype/tv/playback/TvPlayers.kt
+++ /dev/null
@@ -1,60 +0,0 @@
-package video.typetype.tv.playback
-
-import android.app.ActivityManager
-import android.content.Context
-import androidx.media3.common.util.UnstableApi
-import androidx.media3.exoplayer.DefaultLoadControl
-import androidx.media3.exoplayer.ExoPlayer
-import androidx.media3.exoplayer.SeekParameters
-
-/**
- * Every player of the app is built here. ExoPlayer's defaults wait for 2.5 s of media before starting and 5 s after a
- * stall and keep 50 s ahead with no memory cap: slow starts and recoveries, and an out-of-memory risk on TV boxes whose
- * Java heap (where the media buffer lives) is often 128 MB. Here the player keeps 10 to 20 s ahead and 10 s behind,
- * capped in bytes by the device memory class, starts after 1 s and resumes 2 s after a stall. Seeks land on the
- * nearest key frame, as on the web player.
- */
-@UnstableApi
-object TvPlayers {
-    fun create(context: Context): ExoPlayer {
-        val budget = BufferBudget.forDevice(context)
-        val loadControl = DefaultLoadControl.Builder()
-            .setBufferDurationsMs(budget.minBufferMs, budget.maxBufferMs, budget.startMs, budget.afterStallMs)
-            .setTargetBufferBytes(budget.targetBytes)
-            .setPrioritizeTimeOverSizeThresholds(false)
-            .setBackBuffer(budget.backBufferMs, true)
-            .build()
-        return ExoPlayer.Builder(context)
-            .setLoadControl(loadControl)
-            .setSeekParameters(SeekParameters.CLOSEST_SYNC)
-            .build()
-    }
-}
-
-data class BufferBudget(
-    val minBufferMs: Int = 10_000,
-    val maxBufferMs: Int = 20_000,
-    val startMs: Int = 1_000,
-    val afterStallMs: Int = 2_000,
-    val backBufferMs: Int = 10_000,
-    val targetBytes: Int,
-) {
-    companion object {
-        private const val MEBIBYTE = 1024 * 1024
-        private const val SMALL_HEAP_MB = 128
-        private const val MEDIUM_HEAP_MB = 192
-
-        fun forMemory(memoryClassMb: Int, lowRam: Boolean): BufferBudget = BufferBudget(
-            targetBytes = when {
-                lowRam || memoryClassMb <= SMALL_HEAP_MB -> 20 * MEBIBYTE
-                memoryClassMb <= MEDIUM_HEAP_MB -> 32 * MEBIBYTE
-                else -> 48 * MEBIBYTE
-            },
-        )
-
-        fun forDevice(context: Context): BufferBudget {
-            val manager = context.getSystemService(ActivityManager::class.java)
-            return forMemory(manager?.memoryClass ?: SMALL_HEAP_MB, manager?.isLowRamDevice ?: true)
-        }
-    }
-}
diff --git a/app/src/main/java/video/typetype/tv/ui/AppEntry.kt b/app/src/main/java/video/typetype/tv/ui/AppEntry.kt
index f4775a7..fd124bc 100644
--- a/app/src/main/java/video/typetype/tv/ui/AppEntry.kt
+++ b/app/src/main/java/video/typetype/tv/ui/AppEntry.kt
@@ -1,6 +1,21 @@
+@file:OptIn(androidx.compose.ui.ExperimentalComposeUiApi::class)
+
 package video.typetype.tv.ui
 
 import androidx.compose.runtime.Composable
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.runtime.withFrameNanos
+import androidx.compose.foundation.focusGroup
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.ui.input.key.onPreviewKeyEvent
+import android.os.Build
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.input.key.KeyEventType
+import androidx.compose.ui.input.key.key
+import androidx.compose.ui.input.key.type
+import androidx.activity.compose.LocalOnBackPressedDispatcherOwner
+import video.typetype.tv.ui.util.LocalIntroPlaying
 import video.typetype.tv.ui.util.tryLoad
 import video.typetype.tv.data.AccountBadge
 import video.typetype.tv.data.AccountInitials
@@ -8,9 +23,15 @@ import video.typetype.tv.data.InstanceUrls
 import androidx.compose.runtime.setValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.ui.Modifier
+import kotlinx.coroutines.CoroutineScope
 import androidx.compose.ui.platform.LocalContext
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.media3.common.util.UnstableApi
@@ -18,8 +39,11 @@ import kotlinx.coroutines.launch
 import video.typetype.tv.AppContainer
 import video.typetype.tv.data.session.SessionState
 import video.typetype.tv.ui.auth.LoginScreen
+import video.typetype.tv.ui.auth.ReconnectScreen
 import video.typetype.tv.ui.auth.SetupScreen
 import video.typetype.tv.ui.components.InkBackground
+import video.typetype.tv.data.device.Intro
+import video.typetype.tv.ui.splash.StartupSplash
 
 @OptIn(UnstableApi::class)
 @androidx.annotation.OptIn(UnstableApi::class)
@@ -29,15 +53,75 @@ fun AppEntry(container: AppContainer) {
     val scope = rememberCoroutineScope()
     val state by session.state.collectAsStateWithLifecycle()
     LaunchedEffect(Unit) { session.restore() }
+    val intro = remember { container.performance.current.value.intro }
+    var splash by rememberSaveable { mutableStateOf(intro != Intro.Off) }
+    // Changing the server opens the setup screen over the app, which stays as it was below: Back returns to it
+    // and gives the focus back to what had it, such as the Change instance row of the settings.
+    val appFocus = remember { FocusRequester() }
+    var restoreFocus by remember { mutableStateOf(false) }
+    val changeInstance = {
+        appFocus.saveFocusedChild()
+        session.startInstanceChange()
+    }
+    val changing = state as? SessionState.ChangingInstance
+    LaunchedEffect(changing == null, restoreFocus) {
+        if (changing != null || !restoreFocus) return@LaunchedEffect
+        withFrameNanos { }
+        appFocus.restoreFocusedChild()
+        restoreFocus = false
+    }
+    // Keys are held back while the intro plays, so the remote cannot move focus into a field behind it. Before
+    // Android 13 the Back key reaches Compose first, which turns it into "leave the focus group", so inside a panel
+    // the first press only moved the focus: there it goes to the back dispatcher. From Android 13 the system sends
+    // Back to the dispatcher itself, and doing it here as well would go back twice.
+    val backDispatcher = LocalOnBackPressedDispatcherOwner.current?.onBackPressedDispatcher
+    Box(
+        Modifier.fillMaxSize().onPreviewKeyEvent { event ->
+            when {
+                splash -> true
+                event.key == Key.Back && backDispatcher != null && Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU -> {
+                    if (event.type == KeyEventType.KeyUp) backDispatcher.onBackPressed()
+                    true
+                }
+                else -> false
+            }
+        },
+    ) {
+        CompositionLocalProvider(LocalIntroPlaying provides splash) {
+            Box(Modifier.fillMaxSize().focusRequester(appFocus).focusGroup()) {
+                AppState(container, changing?.previous ?: state, scope, changeInstance)
+            }
+            if (changing != null) {
+                SetupScreen(
+                    session,
+                    onCancel = {
+                        restoreFocus = true
+                        session.cancelInstanceChange()
+                    },
+                )
+            }
+        }
+        if (splash) StartupSplash(onFinished = { splash = false }, short = intro == Intro.Short)
+    }
+}
+
+@OptIn(UnstableApi::class)
+@androidx.annotation.OptIn(UnstableApi::class)
+@Composable
+private fun AppState(container: AppContainer, state: SessionState, scope: CoroutineScope, onChangeInstance: () -> Unit) {
+    val session = container.session
     when (val current = state) {
         SessionState.Starting -> InkBackground()
         SessionState.Unconfigured -> SetupScreen(session)
-        is SessionState.SignedOut -> LoginScreen(current.backend, session, current.notice)
+        is SessionState.ChangingInstance -> InkBackground()
+        is SessionState.Reconnecting ->
+            ReconnectScreen(session, current.backend.apiBase.host, current.failedAttempts, onChangeInstance)
+        is SessionState.SignedOut -> LoginScreen(current.backend, session, current.notice, onChangeInstance)
         is SessionState.SignedIn -> {
-            val repository = remember(current.backend, current.profile.id) {
-                container.repository(current.backend, current.profile)
-            }
-            val playback = remember(current.backend) { container.playback(current.backend) }
+            val services = remember(current.backend, current.profile.id) { container.services(current.backend, current.profile) }
+            val repository = services.repository
+            val playback = services.playback
+            val performance by container.performance.current.collectAsState()
             val guest = current.profile.id.startsWith("guest")
             var accountName by remember(current.profile.id) { mutableStateOf(current.profile.publicUsername) }
             LaunchedEffect(current.profile.id) {
@@ -56,12 +140,14 @@ fun AppEntry(container: AppContainer) {
                     scope.launch {
                         when (action) {
                             "sign-out" -> session.signOut()
-                            "change-instance" -> session.changeInstance()
+                            "change-instance" -> onChangeInstance()
                             "forget-certificate" -> session.forgetCertificate()
                             "mark-notifications-read" -> tryLoad({}) { repository.markNotificationsRead() }
+                            "forget-decoders" -> container.decoderFailures.forget()
                         }
                     }
                 },
+                performance = performance,
             )
         }
     }
diff --git a/app/src/main/java/video/typetype/tv/ui/AppRoot.kt b/app/src/main/java/video/typetype/tv/ui/AppRoot.kt
index 35a18dc..49c9bf3 100644
--- a/app/src/main/java/video/typetype/tv/ui/AppRoot.kt
+++ b/app/src/main/java/video/typetype/tv/ui/AppRoot.kt
@@ -1,6 +1,13 @@
 package video.typetype.tv.ui
 
 import androidx.activity.compose.BackHandler
+import android.view.KeyEvent as AndroidKeyEvent
+import androidx.compose.ui.platform.LocalFocusManager
+import androidx.compose.ui.input.key.type
+import androidx.compose.ui.input.key.onPreviewKeyEvent
+import androidx.compose.ui.input.key.KeyEventType
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.FocusDirection
 import androidx.compose.animation.AnimatedContent
 import androidx.compose.animation.AnimatedVisibility
 import androidx.compose.animation.fadeIn
@@ -12,10 +19,13 @@ import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.ui.unit.dp
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.withFrameNanos
+import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
@@ -23,6 +33,7 @@ import video.typetype.tv.data.AccountBadge
 import video.typetype.tv.data.ContentRepository
 import video.typetype.tv.data.LibrarySection
 import video.typetype.tv.data.LandingPage
+import video.typetype.tv.data.Video
 import video.typetype.tv.data.net.Connectivity
 import video.typetype.tv.navigation.MockNavigator
 import video.typetype.tv.playback.PlaybackProvider
@@ -30,6 +41,7 @@ import video.typetype.tv.navigation.Route
 import video.typetype.tv.navigation.TopTab
 import video.typetype.tv.navigation.routeTransition
 import video.typetype.tv.navigation.topTab
+import video.typetype.tv.theme.Dimens
 import video.typetype.tv.theme.Palette
 import video.typetype.tv.ui.components.TopNav
 import video.typetype.tv.ui.home.HomeScreen
@@ -45,6 +57,25 @@ import video.typetype.tv.ui.search.SearchScreen
 import video.typetype.tv.ui.search.SearchSession
 import video.typetype.tv.ui.settings.SettingsScreen
 import video.typetype.tv.ui.settings.SettingsSession
+import video.typetype.tv.ui.components.LocalStreamPrewarm
+import video.typetype.tv.ui.components.LocalVideoPreviews
+import video.typetype.tv.ui.detail.VideoMenuPanel
+import video.typetype.tv.ui.detail.VideoMenuActions
+import video.typetype.tv.ui.components.VideoMenu
+import video.typetype.tv.ui.components.LocalVideoMenu
+import video.typetype.tv.ui.components.PlaylistContext
+import video.typetype.tv.ui.components.VideoPreviews
+import video.typetype.tv.ui.components.PlaybackPreload
+import video.typetype.tv.ui.components.LocalPlaybackPreload
+import video.typetype.tv.playback.PlaybackPreloader
+import video.typetype.tv.ui.util.LocalPerformance
+import video.typetype.tv.data.device.Performance
+import video.typetype.tv.ui.player.MutedPreview
+import video.typetype.tv.ui.components.StreamPrewarm
+import video.typetype.tv.ui.util.RemoteActivity
+import video.typetype.tv.ui.util.SettleRemote
+import video.typetype.tv.ui.util.LocalRemoteActivity
+import android.os.SystemClock
 
 @Composable
 fun AppRoot(
@@ -53,6 +84,7 @@ fun AppRoot(
     connectivity: Connectivity,
     account: AccountBadge,
     onSettingsAction: (String) -> Unit,
+    performance: Performance = Performance(),
 ) {
     val navigator = remember { MockNavigator() }
     val homeSession = remember { HomeSession() }
@@ -79,93 +111,199 @@ fun AppRoot(
         }
     }
     BackHandler(enabled = navigator.canPop()) { navigator.pop() }
+    // On a tab, the first Back takes the focus up to the tabs, as on YouTube's TV app; only the next one leaves.
+    val navEntry = remember { FocusRequester() }
+    var navFocused by remember { mutableStateOf(false) }
+    BackHandler(enabled = activeTab != null && !navigator.canPop() && !navFocused) { navEntry.requestFocus() }
+    val focusManager = LocalFocusManager.current
+    val remote = remember { RemoteActivity() }
+    SettleRemote(remote)
+    val appKeys = Modifier.onPreviewKeyEvent { event ->
+        val code = event.nativeKeyEvent.keyCode
+        val fresh = event.type == KeyEventType.KeyDown && event.nativeKeyEvent.repeatCount == 0
+        if (event.type == KeyEventType.KeyDown) remote.keyPressed(SystemClock.uptimeMillis())
+        when {
+            // The remote's search or microphone key, from any screen: the search opens listening.
+            code == AndroidKeyEvent.KEYCODE_SEARCH -> {
+                if (fresh) {
+                    searchSession.voiceRequested = true
+                    navigator.selectTab(Route.Search)
+                }
+                true
+            }
+            code in PAGE_KEYS && navigator.current !is Route.Player -> {
+                if (event.type == KeyEventType.KeyDown) {
+                    val direction = if (code in PAGE_DOWN_KEYS) FocusDirection.Down else FocusDirection.Up
+                    repeat(PAGE_STEPS) { focusManager.moveFocus(direction) }
+                }
+                true
+            }
+            else -> false
+        }
+    }
+    val openDetail: (Video) -> Unit = { navigator.push(Route.Detail(it.id, it)) }
+    val scope = rememberCoroutineScope()
+    val prewarm = remember(repository) { StreamPrewarm(repository::prewarm, scope) }
+    val playbackPreload = remember(repository, playback) {
+        val preloader = PlaybackPreloader(repository, playback, scope)
+        PlaybackPreload { preloader.preload(it) }
+    }
 
-    Box(Modifier.fillMaxSize()) {
-        AnimatedContent(
-            targetState = navigator.current,
-            transitionSpec = { routeTransition(initialState, targetState) },
-            label = "routes",
-        ) { route ->
-            when (route) {
-                Route.Home -> HomeScreen(
-                    repository = repository,
-                    session = homeSession,
-                    onOpen = { navigator.push(Route.Detail(it.id)) },
-                    onPlay = { navigator.push(Route.Player(it.id)) },
-                )
-                Route.Search -> SearchScreen(
-                    repository = repository,
-                    session = searchSession,
-                    onOpen = { navigator.push(Route.Detail(it.id)) },
-                    onOpenPlaylist = { navigator.push(Route.Playlist(it)) },
-                    onOpenChannel = { navigator.push(Route.Channel(it)) },
-                )
-                Route.Library -> LibraryScreen(
-                    repository = repository,
-                    session = librarySession,
-                    onOpen = { navigator.push(Route.Detail(it.id)) },
-                )
-                Route.Settings -> SettingsScreen(repository, settingsSession, onSettingsAction)
-                is Route.Detail -> DetailScreen(
-                    videoId = route.videoId,
-                    repository = repository,
-                    onOpenChannel = { navigator.push(Route.Channel(it)) },
-                    onPlay = { navigator.push(Route.Player(it.id)) },
-                    onOpen = { navigator.push(Route.Detail(it.id)) },
-                )
-                is Route.Playlist -> PlaylistScreen(
-                    url = route.url,
-                    kind = CollectionKind.Playlist,
-                    repository = repository,
-                    onOpen = { navigator.push(Route.Detail(it.id)) },
-                )
-                is Route.Podcast -> PlaylistScreen(
-                    url = route.url,
-                    kind = CollectionKind.Podcast,
-                    repository = repository,
-                    onOpen = { navigator.push(Route.Detail(it.id)) },
-                )
-                is Route.Channel -> ChannelScreen(
-                    url = route.url,
-                    repository = repository,
-                    onOpen = { navigator.push(Route.Detail(it.id)) },
-                    onOpenPodcast = { navigator.push(Route.Podcast(it)) },
-                )
-                is Route.Player -> PlayerScreen(
-                    videoId = route.videoId,
-                    repository = repository,
-                    playback = playback,
-                    connectivity = connectivity,
-                    startWithControls = !route.continued,
-                    onOpenNext = { navigator.replaceTop(Route.Player(it.id, continued = true)) },
-                )
+    val previews = remember(playback) {
+        VideoPreviews { video, onPlaying, modifier -> MutedPreview(video, playback, onPlaying, modifier) }
+    }.takeIf { performance.videoPreviews }
+    var menuRequest by remember { mutableStateOf<MenuRequest?>(null) }
+    // The menu keeps the focus while it is shown, so the card gets it back only once the menu is gone.
+    var menuClosed by remember { mutableStateOf<MenuRequest?>(null) }
+    LaunchedEffect(menuRequest, menuClosed) {
+        val closed = menuClosed ?: return@LaunchedEffect
+        if (menuRequest != null) return@LaunchedEffect
+        withFrameNanos { }
+        closed.onClosed()
+        menuClosed = null
+    }
+    val videoMenu = remember(navigator) {
+        object : VideoMenu {
+            override fun open(video: Video, playlist: PlaylistContext?, onClosed: () -> Unit) {
+                menuRequest = MenuRequest(video, playlist, onClosed)
             }
+
+            override fun play(video: Video) = navigator.push(Route.Player(video.id, preview = video))
         }
-        AnimatedVisibility(
-            visible = activeTab != null,
-            enter = fadeIn(),
-            exit = fadeOut(),
-            modifier = Modifier.align(Alignment.TopCenter),
-        ) {
-            Box {
-                Box(
-                    Modifier
-                        .fillMaxWidth()
-                        .height(112.dp)
-                        .background(Palette.NavScrim),
-                )
-                TopNav(
-                    selected = activeTab ?: lastTab,
-                    onSelect = {
-                        homeSession.anchor = null
-                        librarySession.restoreVideoId = null
-                        searchSession.restoreVideoId = null
-                        navigator.selectTab(it.route)
+    }
+    val menuActions = remember(navigator) {
+        VideoMenuActions(
+            onPlay = {
+                menuRequest = null
+                navigator.push(Route.Player(it.id, preview = it))
+            },
+            onOpenChannel = {
+                menuRequest = null
+                navigator.push(Route.Channel(it))
+            },
+        )
+    }
+    CompositionLocalProvider(
+        LocalStreamPrewarm provides prewarm,
+        LocalPlaybackPreload provides playbackPreload,
+        LocalVideoPreviews provides previews,
+        LocalPerformance provides performance,
+        LocalRemoteActivity provides remote,
+        LocalVideoMenu provides videoMenu,
+    ) {
+        Box(Modifier.fillMaxSize().then(appKeys)) {
+            AnimatedContent(
+                targetState = navigator.current,
+                transitionSpec = { routeTransition(initialState, targetState, performance.smoothAnimations) },
+                label = "routes",
+            ) { route ->
+                when (route) {
+                    Route.Home -> HomeScreen(
+                        repository = repository,
+                        session = homeSession,
+                        onOpen = openDetail,
+                        onPlay = { navigator.push(Route.Player(it.id, preview = it)) },
+                    )
+                    Route.Search -> SearchScreen(
+                        repository = repository,
+                        session = searchSession,
+                        onOpen = openDetail,
+                        onOpenPlaylist = { navigator.push(Route.Playlist(it)) },
+                        onOpenChannel = { navigator.push(Route.Channel(it)) },
+                    )
+                    Route.Library -> LibraryScreen(
+                        repository = repository,
+                        session = librarySession,
+                        onOpen = openDetail,
+                    )
+                    Route.Settings -> SettingsScreen(repository, settingsSession, onSettingsAction)
+                    is Route.Detail -> DetailScreen(
+                        videoId = route.videoId,
+                        preview = route.preview,
+                        repository = repository,
+                        onOpenChannel = { navigator.push(Route.Channel(it)) },
+                        onPlay = { navigator.push(Route.Player(it.id, preview = it)) },
+                        onOpen = openDetail,
+                    )
+                    is Route.Playlist -> PlaylistScreen(
+                        url = route.url,
+                        kind = CollectionKind.Playlist,
+                        repository = repository,
+                        onOpen = openDetail,
+                    )
+                    is Route.Podcast -> PlaylistScreen(
+                        url = route.url,
+                        kind = CollectionKind.Podcast,
+                        repository = repository,
+                        onOpen = openDetail,
+                    )
+                    is Route.Channel -> ChannelScreen(
+                        url = route.url,
+                        repository = repository,
+                        onOpen = openDetail,
+                        onOpenPodcast = { navigator.push(Route.Podcast(it)) },
+                        onOpenPlaylist = { navigator.push(Route.Playlist(it)) },
+                    )
+                    is Route.Player -> PlayerScreen(
+                        videoId = route.videoId,
+                        repository = repository,
+                        playback = playback,
+                        connectivity = connectivity,
+                        startWithControls = !route.continued,
+                        preview = route.preview,
+                        onOpenNext = { navigator.replaceTop(Route.Player(it.id, continued = true, preview = it)) },
+                        onOpenChannel = { navigator.push(Route.Channel(it)) },
+                    )
+                }
+            }
+            AnimatedVisibility(
+                visible = activeTab != null,
+                enter = fadeIn(),
+                exit = fadeOut(),
+                modifier = Modifier.align(Alignment.TopCenter),
+            ) {
+                Box {
+                    Box(
+                        Modifier
+                            .fillMaxWidth()
+                            .height(Dimens.TabContentTop)
+                            .background(Palette.NavScrim),
+                    )
+                    TopNav(
+                        selected = activeTab ?: lastTab,
+                        onSelect = {
+                            homeSession.anchor = null
+                            librarySession.restoreVideoId = null
+                            searchSession.restoreVideoId = null
+                            navigator.selectTab(it.route)
+                        },
+                        account = account,
+                        contentEntry = homeSession.heroEntry.takeIf { activeTab == TopTab.Home },
+                        navEntry = navEntry,
+                        onNavFocusChange = { navFocused = it },
+                    )
+                }
+            }
+            menuRequest?.let { request ->
+                VideoMenuPanel(
+                    video = request.video,
+                    repository = repository,
+                    actions = menuActions,
+                    playlist = request.playlist,
+                    onClose = { returnFocus ->
+                        if (returnFocus) menuClosed = request
+                        menuRequest = null
                     },
-                    account = account,
-                    contentEntry = homeSession.heroEntry.takeIf { activeTab == TopTab.Home },
                 )
             }
         }
     }
 }
+
+private class MenuRequest(val video: Video, val playlist: PlaylistContext?, val onClosed: () -> Unit)
+
+private val PAGE_DOWN_KEYS = setOf(AndroidKeyEvent.KEYCODE_CHANNEL_DOWN, AndroidKeyEvent.KEYCODE_PAGE_DOWN)
+private val PAGE_KEYS = PAGE_DOWN_KEYS + setOf(AndroidKeyEvent.KEYCODE_CHANNEL_UP, AndroidKeyEvent.KEYCODE_PAGE_UP)
+
+// Channel and page keys skip this many rows at once.
+private const val PAGE_STEPS = 3
diff --git a/app/src/main/java/video/typetype/tv/ui/channel/ChannelScreen.kt b/app/src/main/java/video/typetype/tv/ui/channel/ChannelScreen.kt
deleted file mode 100644
index 732dba9..0000000
--- a/app/src/main/java/video/typetype/tv/ui/channel/ChannelScreen.kt
+++ /dev/null
@@ -1,200 +0,0 @@
-package video.typetype.tv.ui.channel
-
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.lazy.grid.GridCells
-import androidx.compose.foundation.lazy.grid.GridItemSpan
-import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
-import androidx.compose.foundation.lazy.grid.items
-import androidx.compose.foundation.lazy.grid.rememberLazyGridState
-import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.rounded.Block
-import androidx.compose.material.icons.rounded.Check
-import androidx.compose.material.icons.rounded.NotificationsNone
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.derivedStateOf
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableIntStateOf
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.graphics.Brush
-import androidx.compose.ui.focus.FocusRequester
-import androidx.compose.ui.focus.focusRequester
-import androidx.compose.ui.layout.ContentScale
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.unit.dp
-import coil3.compose.AsyncImage
-import video.typetype.tv.R
-import video.typetype.tv.data.ContentRepository
-import video.typetype.tv.data.Video
-import video.typetype.tv.theme.Dimens
-import video.typetype.tv.theme.Palette
-import video.typetype.tv.theme.Type
-import video.typetype.tv.ui.components.ConfirmDialog
-import video.typetype.tv.ui.components.InkBackground
-import video.typetype.tv.ui.components.PillButton
-import video.typetype.tv.ui.components.ScreenFailure
-import video.typetype.tv.ui.components.TextLabel
-import video.typetype.tv.ui.components.VideoCard
-import video.typetype.tv.ui.util.requestFocusWhenReady
-
-private const val GRID_COLUMNS = 3
-private const val PREFETCH_ROWS = 2
-private const val BANNER_ALPHA = 0.45f
-private val BANNER_HEIGHT = 280.dp
-
-@Composable
-fun ChannelScreen(
-    url: String,
-    repository: ContentRepository,
-    onOpen: (Video) -> Unit,
-    onOpenPodcast: (String) -> Unit,
-    modifier: Modifier = Modifier,
-) {
-    val scope = rememberCoroutineScope()
-    val state = remember(url) { ChannelState(url, repository, scope) }
-    var attempt by remember(url) { mutableIntStateOf(0) }
-    LaunchedEffect(url, attempt) { state.load() }
-    val page = state.page
-    if (page == null) {
-        if (state.failure != null) ScreenFailure(state.failure, onRetry = { attempt++ }, modifier = modifier)
-        else InkBackground(modifier)
-        return
-    }
-    val subscribe = remember { FocusRequester() }
-    var confirmingBlock by remember(url) { mutableStateOf(false) }
-    val blockButton = remember { FocusRequester() }
-    var dialogWasOpen by remember(url) { mutableStateOf(false) }
-    LaunchedEffect(confirmingBlock) {
-        if (dialogWasOpen && !confirmingBlock) blockButton.requestFocusWhenReady()
-        dialogWasOpen = confirmingBlock
-    }
-    LaunchedEffect(url) { subscribe.requestFocusWhenReady() }
-    val gridState = rememberLazyGridState()
-    val nearEnd by remember {
-        derivedStateOf {
-            val last = gridState.layoutInfo.visibleItemsInfo.lastOrNull()?.index ?: 0
-            last >= state.videos.size - GRID_COLUMNS * PREFETCH_ROWS
-        }
-    }
-    LaunchedEffect(nearEnd, state.videos.size) { if (nearEnd) state.loadMore() }
-    Box(modifier.fillMaxSize()) {
-        ChannelBackdrop(page.bannerUrl)
-        LazyVerticalGrid(
-            state = gridState,
-            columns = GridCells.Fixed(GRID_COLUMNS),
-            modifier = Modifier.fillMaxSize().padding(start = Dimens.SafeStart, end = Dimens.SafeEnd),
-            contentPadding = PaddingValues(top = Dimens.SafeTop + Dimens.TopNavHeight + 12.dp, bottom = 48.dp, start = 8.dp, end = 8.dp),
-            horizontalArrangement = Arrangement.spacedBy(Dimens.CardGap),
-            verticalArrangement = Arrangement.spacedBy(20.dp),
-        ) {
-            item(key = "header", span = { GridItemSpan(maxLineSpan) }) {
-                Column {
-                    ChannelHeader(state, subscribe, blockButton, onBlock = { if (state.blocked) state.requestBlocked(false) else confirmingBlock = true })
-                    Spacer(Modifier.height(12.dp))
-                }
-            }
-            if (state.podcasts.isNotEmpty()) {
-                item(key = "podcasts", span = { GridItemSpan(maxLineSpan) }) {
-                    PodcastRow(state.podcasts, onOpenPodcast)
-                }
-            }
-            items(state.videos, key = { it.id }) { video -> VideoCard(video = video, onClick = { onOpen(video) }) }
-        }
-        if (confirmingBlock) {
-            ConfirmDialog(
-                title = stringResource(R.string.channel_block_title),
-                message = stringResource(R.string.channel_block_message),
-                confirmLabel = stringResource(R.string.channel_block),
-                onConfirm = {
-                    confirmingBlock = false
-                    state.requestBlocked(true)
-                },
-                onDismiss = { confirmingBlock = false },
-            )
-        }
-    }
-}
-
-@Composable
-private fun ChannelBackdrop(bannerUrl: String?) {
-    Box(Modifier.fillMaxSize().background(Palette.Ink)) {
-        if (bannerUrl != null) {
-            AsyncImage(
-                model = bannerUrl,
-                contentDescription = null,
-                contentScale = ContentScale.Crop,
-                alpha = BANNER_ALPHA,
-                modifier = Modifier.fillMaxWidth().height(BANNER_HEIGHT),
-            )
-        }
-        Box(
-            Modifier
-                .fillMaxWidth()
-                .height(BANNER_HEIGHT)
-                .background(Brush.verticalGradient(listOf(Palette.Ink.copy(alpha = 0.55f), Palette.Ink))),
-        )
-    }
-}
-
-@Composable
-private fun ChannelHeader(state: ChannelState, subscribe: FocusRequester, blockButton: FocusRequester, onBlock: () -> Unit) {
-    val page = state.page ?: return
-    Row(horizontalArrangement = Arrangement.spacedBy(20.dp), verticalAlignment = Alignment.CenterVertically) {
-        Box(Modifier.size(84.dp).clip(CircleShape).background(Palette.SurfaceRaised), contentAlignment = Alignment.Center) {
-            TextLabel(page.channel.name.take(1).uppercase(), Type.Headline)
-            page.channel.avatarUrl?.let {
-                AsyncImage(model = it, contentDescription = null, contentScale = ContentScale.Crop, modifier = Modifier.fillMaxSize())
-            }
-        }
-        Column(Modifier.weight(1f)) {
-            TextLabel(page.channel.name, Type.Display, maxLines = 1)
-            if (page.channel.subscribers.isNotBlank()) {
-                Spacer(Modifier.height(4.dp))
-                TextLabel(stringResource(R.string.detail_subscribers, page.channel.subscribers), Type.Meta, maxLines = 1)
-            }
-            if (page.description.isNotBlank()) {
-                Spacer(Modifier.height(6.dp))
-                Box(Modifier.width(620.dp)) { TextLabel(page.description, Type.Body, maxLines = 2) }
-            }
-        }
-        Column(horizontalAlignment = Alignment.End) {
-            PillButton(
-                label = stringResource(if (state.subscribed) R.string.detail_subscribed else R.string.detail_subscribe),
-                icon = if (state.subscribed) Icons.Rounded.Check else Icons.Rounded.NotificationsNone,
-                onClick = state::toggleSubscription,
-                emphasized = !state.subscribed,
-                modifier = Modifier.focusRequester(subscribe),
-            )
-            Spacer(Modifier.height(8.dp))
-            PillButton(
-                label = stringResource(if (state.blocked) R.string.channel_unblock else R.string.channel_block),
-                icon = Icons.Rounded.Block,
-                onClick = onBlock,
-                modifier = Modifier.focusRequester(blockButton),
-            )
-            if (state.subscriptionFailed || state.blockFailed) {
-                Spacer(Modifier.height(6.dp))
-                TextLabel(stringResource(R.string.detail_action_failed), Type.Meta.copy(color = Palette.Accent), maxLines = 2)
-            }
-        }
-    }
-}
diff --git a/app/src/main/java/video/typetype/tv/ui/channel/ChannelState.kt b/app/src/main/java/video/typetype/tv/ui/channel/ChannelState.kt
deleted file mode 100644
index bac6683..0000000
--- a/app/src/main/java/video/typetype/tv/ui/channel/ChannelState.kt
+++ /dev/null
@@ -1,113 +0,0 @@
-package video.typetype.tv.ui.channel
-
-import androidx.compose.runtime.Stable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.setValue
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.launch
-import video.typetype.tv.data.ChannelPage
-import video.typetype.tv.data.ContentRepository
-import video.typetype.tv.data.PublicPlaylist
-import video.typetype.tv.data.Video
-import video.typetype.tv.data.net.ApiException
-import video.typetype.tv.ui.auth.UiMessage
-import video.typetype.tv.ui.util.describeLoadFailure
-import java.io.IOException
-
-@Stable
-class ChannelState(
-    private val url: String,
-    private val repository: ContentRepository,
-    private val scope: CoroutineScope,
-) {
-    var page by mutableStateOf<ChannelPage?>(null)
-        private set
-
-    var videos by mutableStateOf<List<Video>>(emptyList())
-        private set
-
-    var failure by mutableStateOf<UiMessage?>(null)
-        private set
-
-    var subscribed by mutableStateOf(false)
-        private set
-
-    var subscriptionFailed by mutableStateOf(false)
-        private set
-
-    var podcasts by mutableStateOf<List<PublicPlaylist>>(emptyList())
-        private set
-
-    var blocked by mutableStateOf(false)
-        private set
-
-    var blockFailed by mutableStateOf(false)
-        private set
-
-    private var nextPage: String? = null
-    private var loadingMore = false
-
-    suspend fun load() {
-        failure = null
-        try {
-            val loaded = repository.channel(url)
-            page = loaded
-            videos = loaded.videos.distinctBy { it.id }
-            nextPage = loaded.nextPage
-            subscribed = runCatching { repository.isSubscribed(url) }.getOrDefault(false)
-            podcasts = runCatching { repository.channelPodcasts(url) }.getOrDefault(emptyList())
-            blocked = runCatching { repository.isChannelBlocked(url) }.getOrDefault(false)
-        } catch (error: IOException) {
-            failure = describeLoadFailure(error)
-        }
-    }
-
-    fun loadMore() {
-        val cursor = nextPage ?: return
-        if (loadingMore) return
-        loadingMore = true
-        scope.launch {
-            try {
-                val more = repository.channel(url, cursor)
-                val known = videos.mapTo(HashSet()) { it.id }
-                videos = videos + more.videos.filter { known.add(it.id) }
-                nextPage = more.nextPage.takeIf { more.videos.isNotEmpty() }
-            } catch (error: IOException) {
-                nextPage = cursor
-            } finally {
-                loadingMore = false
-            }
-        }
-    }
-
-    fun requestBlocked(enabled: Boolean) {
-        val channel = page?.channel ?: return
-        val previous = blocked
-        blocked = enabled
-        blockFailed = false
-        scope.launch {
-            try {
-                if (enabled) repository.blockChannel(channel) else repository.unblockChannel(channel.url)
-            } catch (error: ApiException) {
-                blocked = previous
-                blockFailed = true
-            }
-        }
-    }
-
-    fun toggleSubscription() {
-        val channel = page?.channel ?: return
-        val previous = subscribed
-        subscribed = !previous
-        subscriptionFailed = false
-        scope.launch {
-            try {
-                repository.setSubscribed(channel, !previous)
-            } catch (error: ApiException) {
-                subscribed = previous
-                subscriptionFailed = true
-            }
-        }
-    }
-}
diff --git a/app/src/main/java/video/typetype/tv/ui/components/Backdrop.kt b/app/src/main/java/video/typetype/tv/ui/components/Backdrop.kt
deleted file mode 100644
index 8967d88..0000000
--- a/app/src/main/java/video/typetype/tv/ui/components/Backdrop.kt
+++ /dev/null
@@ -1,112 +0,0 @@
-package video.typetype.tv.ui.components
-
-import androidx.compose.animation.Crossfade
-import androidx.compose.animation.core.tween
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.BiasAlignment
-import androidx.compose.ui.draw.drawWithCache
-import androidx.compose.ui.geometry.Offset
-import androidx.compose.ui.geometry.Size
-import androidx.compose.ui.graphics.Brush
-import androidx.compose.ui.graphics.Canvas
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.FilterQuality
-import androidx.compose.ui.graphics.ImageBitmap
-import androidx.compose.ui.graphics.drawscope.CanvasDrawScope
-import androidx.compose.ui.layout.ContentScale
-import androidx.compose.ui.unit.Density
-import androidx.compose.ui.unit.IntSize
-import androidx.compose.ui.unit.LayoutDirection
-import coil3.compose.AsyncImage
-import kotlin.math.roundToInt
-import video.typetype.tv.theme.Palette
-
-@Composable
-fun Backdrop(
-    artwork: String?,
-    modifier: Modifier = Modifier,
-    focusY: Float = 0.5f,
-) {
-    Box(modifier = modifier.fillMaxSize()) {
-        Crossfade(
-            targetState = artwork to focusY,
-            animationSpec = tween(durationMillis = BACKDROP_FADE_MILLIS),
-            label = "backdrop-image",
-        ) { (resource, bias) ->
-            AsyncImage(
-                model = resource,
-                contentDescription = null,
-                contentScale = ContentScale.Crop,
-                alignment = BiasAlignment(0f, bias * 2f - 1f),
-                modifier = Modifier.fillMaxSize(),
-            )
-        }
-        BackdropScrims()
-    }
-}
-
-@Composable
-private fun BackdropScrims(modifier: Modifier = Modifier) {
-    Box(
-        modifier = modifier
-            .fillMaxSize()
-            .drawWithCache {
-                val overlay = renderScrims(size)
-                val target = IntSize(size.width.roundToInt(), size.height.roundToInt())
-                onDrawBehind { drawImage(overlay, dstSize = target, filterQuality = FilterQuality.Low) }
-            },
-    )
-}
-
-private fun Density.renderScrims(size: Size): ImageBitmap {
-    val width = (size.width / SCRIM_DOWNSCALE).roundToInt().coerceAtLeast(1)
-    val height = (size.height / SCRIM_DOWNSCALE).roundToInt().coerceAtLeast(1)
-    val bitmap = ImageBitmap(width, height)
-    val tint = Palette.Ink.copy(alpha = TINT_ALPHA)
-    CanvasDrawScope().draw(this, LayoutDirection.Ltr, Canvas(bitmap), Size(width.toFloat(), height.toFloat())) {
-        val glow = Brush.radialGradient(
-            colors = listOf(Palette.Accent.copy(alpha = GLOW_ALPHA), Color.Transparent),
-            center = Offset(width * GLOW_CENTER_X, 0f),
-            radius = width * GLOW_RADIUS,
-        )
-        drawRect(tint)
-        drawRect(Palette.BackdropScrimHorizontal)
-        drawRect(Palette.BackdropScrimVertical)
-        drawRect(glow)
-    }
-    return bitmap
-}
-
-@Composable
-fun AccentGlow(modifier: Modifier = Modifier) {
-    Box(
-        modifier = modifier
-            .fillMaxSize()
-            .drawWithCache {
-                val glow = Brush.radialGradient(
-                    colors = listOf(Palette.Accent.copy(alpha = GLOW_ALPHA), Color.Transparent),
-                    center = Offset(size.width * GLOW_CENTER_X, 0f),
-                    radius = size.width * GLOW_RADIUS,
-                )
-                onDrawBehind { drawRect(glow) }
-            },
-    )
-}
-
-@Composable
-fun InkBackground(modifier: Modifier = Modifier) {
-    Box(modifier = modifier.fillMaxSize().background(Palette.Ink)) {
-        AccentGlow()
-    }
-}
-
-private const val TINT_ALPHA = 0.24f
-private const val GLOW_ALPHA = 0.16f
-private const val GLOW_CENTER_X = 0.9f
-private const val GLOW_RADIUS = 0.5f
-private const val SCRIM_DOWNSCALE = 4f
-private const val BACKDROP_FADE_MILLIS = 700
diff --git a/app/src/main/java/video/typetype/tv/ui/player/PlayerPanel.kt b/app/src/main/java/video/typetype/tv/ui/player/PlayerPanel.kt
deleted file mode 100644
index b2a74e3..0000000
--- a/app/src/main/java/video/typetype/tv/ui/player/PlayerPanel.kt
+++ /dev/null
@@ -1,3 +0,0 @@
-package video.typetype.tv.ui.player
-
-enum class PlayerPanel { Menu, Chapters, Info, Comments, Queue, Quality, Audio, CaptionStyle, Playlists }
diff --git a/app/src/main/java/video/typetype/tv/ui/player/PlayerSession.kt b/app/src/main/java/video/typetype/tv/ui/player/PlayerSession.kt
deleted file mode 100644
index 4d2c2e4..0000000
--- a/app/src/main/java/video/typetype/tv/ui/player/PlayerSession.kt
+++ /dev/null
@@ -1,88 +0,0 @@
-package video.typetype.tv.ui.player
-
-import android.os.SystemClock
-import androidx.compose.runtime.Stable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableLongStateOf
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.input.key.Key
-import androidx.compose.ui.input.key.KeyEvent
-import androidx.compose.ui.input.key.KeyEventType
-import androidx.compose.ui.input.key.key
-import androidx.compose.ui.input.key.type
-import androidx.media3.common.Player
-
-@Stable
-class PlayerSession(
-    private val player: Player,
-    private val state: PlayerUiState,
-    startWithControls: Boolean = true,
-) {
-    var controlsVisible by mutableStateOf(startWithControls)
-    var interaction by mutableLongStateOf(0L)
-    var panel by mutableStateOf<PlayerPanel?>(null)
-    val scrub = ScrubState()
-    val notice = SponsorNotice()
-    val upNext = UpNextState()
-
-    fun showControls() {
-        controlsVisible = true
-    }
-
-    fun togglePlay() {
-        if (player.isPlaying) player.pause() else player.play()
-    }
-
-    fun seekBy(deltaMillis: Long) {
-        player.seekTo(SeekMath.target(player.currentPosition, deltaMillis, state.durationMillis))
-    }
-
-    fun scrubBy(deltaMillis: Long) {
-        scrub.move(state.positionMillis, deltaMillis, state.durationMillis)
-        controlsVisible = true
-    }
-
-    fun commitScrub() {
-        scrub.commit()?.let(player::seekTo)
-    }
-
-    fun undoSkip(): Boolean {
-        val start = notice.undo() ?: return false
-        player.seekTo(start)
-        return true
-    }
-
-    fun onKey(event: KeyEvent, upNextVisible: Boolean, playNext: () -> Unit): Boolean {
-        if (panel != null) return false
-        if (event.key == Key.Back) return handleBack(event, upNextVisible)
-        if (event.type != KeyEventType.KeyDown) return false
-        interaction = SystemClock.elapsedRealtime()
-        val step = SeekMath.scrubStep(event.nativeKeyEvent.repeatCount, state.durationMillis)
-        val confirm = event.key == Key.DirectionCenter || event.key == Key.Enter
-        return when {
-            event.key == Key.MediaPlayPause -> { togglePlay(); showControls(); true }
-            scrub.active && confirm -> { commitScrub(); true }
-            scrub.active && event.key == Key.DirectionLeft -> { scrubBy(-step); true }
-            scrub.active && event.key == Key.DirectionRight -> { scrubBy(step); true }
-            controlsVisible || state.isEnded -> false
-            upNextVisible && confirm -> { playNext(); true }
-            confirm -> { togglePlay(); showControls(); true }
-            event.key == Key.DirectionLeft && notice.segment != null -> undoSkip()
-            event.key == Key.DirectionLeft || event.key == Key.MediaRewind -> { scrubBy(-step); true }
-            event.key == Key.DirectionRight || event.key == Key.MediaFastForward -> { scrubBy(step); true }
-            event.key == Key.DirectionUp || event.key == Key.DirectionDown -> { showControls(); true }
-            else -> false
-        }
-    }
-
-    private fun handleBack(event: KeyEvent, upNextVisible: Boolean): Boolean {
-        val released = event.type == KeyEventType.KeyUp
-        return when {
-            scrub.active -> { if (released) scrub.cancel(); true }
-            upNextVisible -> { if (released) upNext.dismiss(); true }
-            controlsVisible -> { if (released) controlsVisible = false; true }
-            else -> false
-        }
-    }
-}
diff --git a/app/src/main/java/video/typetype/tv/ui/player/SeekMath.kt b/app/src/main/java/video/typetype/tv/ui/player/SeekMath.kt
deleted file mode 100644
index c355cda..0000000
--- a/app/src/main/java/video/typetype/tv/ui/player/SeekMath.kt
+++ /dev/null
@@ -1,33 +0,0 @@
-package video.typetype.tv.ui.player
-
-object SeekMath {
-    const val SHORT_STEP_MILLIS = 5_000L
-    const val LONG_STEP_MILLIS = 10_000L
-    const val JUMP_MILLIS = 10_000L
-    private const val REPEATS_BEFORE_LONG_STEP = 3
-    private const val REPEATS_FOR_MEDIUM_SCRUB = 8
-    private const val REPEATS_FOR_FAST_SCRUB = 20
-    private const val MEDIUM_SCRUB_DIVISOR = 200
-    private const val FAST_SCRUB_DIVISOR = 60
-    private const val MEDIUM_STEP_MILLIS = 15_000L
-    private const val MIN_FAST_STEP_MILLIS = 30_000L
-
-    fun stepFor(repeatCount: Int): Long =
-        if (repeatCount >= REPEATS_BEFORE_LONG_STEP) LONG_STEP_MILLIS else SHORT_STEP_MILLIS
-
-    fun scrubStep(repeatCount: Int, durationMillis: Long): Long = when {
-        repeatCount >= REPEATS_FOR_FAST_SCRUB -> (durationMillis / FAST_SCRUB_DIVISOR).coerceAtLeast(MIN_FAST_STEP_MILLIS)
-        repeatCount >= REPEATS_FOR_MEDIUM_SCRUB -> (durationMillis / MEDIUM_SCRUB_DIVISOR).coerceAtLeast(MEDIUM_STEP_MILLIS)
-        else -> stepFor(repeatCount)
-    }
-
-    fun target(currentMillis: Long, deltaMillis: Long, durationMillis: Long): Long {
-        val upper = durationMillis.coerceAtLeast(0L)
-        return (currentMillis + deltaMillis).coerceIn(0L, upper)
-    }
-
-    fun fraction(positionMillis: Long, durationMillis: Long): Float {
-        if (durationMillis <= 0L) return 0f
-        return (positionMillis.toFloat() / durationMillis.toFloat()).coerceIn(0f, 1f)
-    }
-}
diff --git a/app/src/main/java/video/typetype/tv/ui/search/SourcePicker.kt b/app/src/main/java/video/typetype/tv/ui/search/SourcePicker.kt
deleted file mode 100644
index c6857a7..0000000
--- a/app/src/main/java/video/typetype/tv/ui/search/SourcePicker.kt
+++ /dev/null
@@ -1,51 +0,0 @@
-package video.typetype.tv.ui.search
-
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Row
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.rounded.Public
-import androidx.compose.material.icons.rounded.Tune
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.semantics.contentDescription
-import androidx.compose.ui.semantics.semantics
-import androidx.compose.ui.unit.dp
-import video.typetype.tv.R
-import video.typetype.tv.data.ContentSource
-import video.typetype.tv.data.SearchKind
-import video.typetype.tv.ui.components.PillButton
-
-fun nextSource(current: ContentSource): ContentSource {
-    val all = ContentSource.entries
-    return all[(all.indexOf(current) + 1) % all.size]
-}
-
-@Composable
-fun SearchScope(
-    source: ContentSource,
-    kind: SearchKind,
-    onCycleSource: () -> Unit,
-    onCycleKind: () -> Unit,
-) {
-    val sourceName = stringResource(source.labelRes)
-    val kindName = stringResource(kind.labelRes)
-    val sourceDescription = stringResource(R.string.search_source, sourceName)
-    val kindDescription = stringResource(R.string.search_kind, kindName)
-    Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
-        PillButton(
-            label = sourceName,
-            icon = Icons.Rounded.Public,
-            onClick = onCycleSource,
-            modifier = Modifier.semantics { contentDescription = sourceDescription },
-        )
-        if (SearchKind.available(source).size > 1) {
-            PillButton(
-                label = kindName,
-                icon = Icons.Rounded.Tune,
-                onClick = onCycleKind,
-                modifier = Modifier.semantics { contentDescription = kindDescription },
-            )
-        }
-    }
-}
diff --git a/app/src/main/java/video/typetype/tv/ui/splash/SplashMark.kt b/app/src/main/java/video/typetype/tv/ui/splash/SplashMark.kt
new file mode 100644
index 0000000..1de50d3
--- /dev/null
+++ b/app/src/main/java/video/typetype/tv/ui/splash/SplashMark.kt
@@ -0,0 +1,143 @@
+package video.typetype.tv.ui.splash
+
+import androidx.compose.ui.geometry.CornerRadius
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Rect
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.geometry.lerp
+import androidx.compose.ui.graphics.BlendMode
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Path
+import androidx.compose.ui.graphics.PathMeasure
+import androidx.compose.ui.graphics.StrokeCap
+import androidx.compose.ui.graphics.StrokeJoin
+import androidx.compose.ui.graphics.drawscope.DrawScope
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.graphics.drawscope.rotate
+import kotlin.math.PI
+import kotlin.math.sin
+
+// The TypeType mark (ic_typetype_mark, with a heavier stroke) in its 24-unit viewport, drawn by a small square
+// that hops along it: both antennas, a drop onto the divider, the screen outline, then the two buttons.
+internal class SplashMark {
+    private sealed interface Move {
+        data class Trace(val stroke: Int, val from: Float, val to: Float) : Move
+
+        data class Jump(val from: Offset, val to: Offset, val lift: Float, val becomesDot: Boolean) : Move
+    }
+
+    private val antennas = Path().apply {
+        moveTo(8f, 2.6f)
+        lineTo(12f, 6.6f)
+        lineTo(16f, 2.6f)
+    }
+    private val divider = Path().apply {
+        moveTo(16.2f, 7.8f)
+        lineTo(16.2f, 20.6f)
+    }
+    private val screen = Path().apply {
+        moveTo(16.2f, 21f)
+        lineTo(5f, 21f)
+        arcTo(Rect(3f, 17f, 7f, 21f), 90f, 90f, false)
+        lineTo(3f, 9.4f)
+        arcTo(Rect(3f, 7.4f, 7f, 11.4f), 180f, 90f, false)
+        lineTo(19f, 7.4f)
+        arcTo(Rect(17f, 7.4f, 21f, 11.4f), 270f, 90f, false)
+        lineTo(21f, 19f)
+        arcTo(Rect(17f, 17f, 21f, 21f), 0f, 90f, false)
+        lineTo(16.2f, 21f)
+    }
+    private val measures = listOf(antennas, divider, screen).map { path -> PathMeasure().apply { setPath(path, false) } }
+    private val lowerButton = Offset(18.7f, 15.6f)
+    private val upperButton = Offset(18.7f, 11.4f)
+
+    private val moves: List<Move> = buildList {
+        add(Move.Trace(0, 0f, 0.5f))
+        add(Move.Trace(0, 0.5f, 1f))
+        add(Move.Jump(Offset(16f, 2.6f), Offset(16.2f, 7.8f), lift = 3f, becomesDot = false))
+        add(Move.Trace(1, 0f, 0.5f))
+        add(Move.Trace(1, 0.5f, 1f))
+        for (piece in 0 until SCREEN_PIECES) add(Move.Trace(2, piece / SCREEN_PIECES.toFloat(), (piece + 1) / SCREEN_PIECES.toFloat()))
+        add(Move.Jump(Offset(16.2f, 21f), lowerButton, lift = 2f, becomesDot = true))
+        add(Move.Jump(lowerButton, upperButton, lift = 2f, becomesDot = true))
+    }
+
+    private val revealed = FloatArray(measures.size)
+    private val segment = Path()
+
+    init {
+        check(moves.size == SplashTimeline.HOPS)
+    }
+
+    fun draw(
+        scope: DrawScope,
+        progress: Float,
+        appear: Float,
+        color: Color,
+        alpha: Float = 1f,
+        blendMode: BlendMode = BlendMode.SrcOver,
+    ) = with(scope) {
+        val step = progress.toInt().coerceAtMost(moves.size)
+        val fraction = progress - step
+        revealed.fill(0f)
+        moves.take(step).forEach { move -> if (move is Move.Trace) revealed[move.stroke] = move.to }
+        val current = moves.getOrNull(step)
+        if (current is Move.Trace) revealed[current.stroke] = current.from + (current.to - current.from) * fraction
+        measures.forEachIndexed { index, measure ->
+            if (revealed[index] <= 0f) return@forEachIndexed
+            segment.reset()
+            measure.getSegment(0f, measure.length * revealed[index], segment, true)
+            drawPath(segment, color, alpha, LINE, blendMode = blendMode)
+        }
+        moves.take(step).forEach { move ->
+            if (move is Move.Jump && move.becomesDot) drawCircle(color, BUTTON_RADIUS, move.to, alpha, blendMode = blendMode)
+        }
+        if (current != null) drawCursor(current, fraction, progress, appear, color, alpha, blendMode)
+    }
+
+    private fun DrawScope.drawCursor(
+        move: Move,
+        fraction: Float,
+        progress: Float,
+        appear: Float,
+        color: Color,
+        alpha: Float,
+        blendMode: BlendMode,
+    ) {
+        val position: Offset
+        val morph: Float
+        when (move) {
+            is Move.Trace -> {
+                val measure = measures[move.stroke]
+                position = measure.getPosition(measure.length * (move.from + (move.to - move.from) * fraction))
+                morph = 0f
+            }
+            is Move.Jump -> {
+                position = lerp(move.from, move.to, fraction) - Offset(0f, move.lift * sin(PI * fraction).toFloat())
+                morph = if (move.becomesDot) fraction else 0f
+            }
+        }
+        val side = (CURSOR_SIDE + (BUTTON_RADIUS * 2 - CURSOR_SIDE) * morph) * appear
+        val corner = CURSOR_CORNER + (side / 2 - CURSOR_CORNER) * morph
+        rotate(degrees = 90f * progress * (1f - morph), pivot = position) {
+            drawRoundRect(
+                color = color,
+                topLeft = position - Offset(side / 2, side / 2),
+                size = Size(side, side),
+                cornerRadius = CornerRadius(corner),
+                alpha = alpha,
+                blendMode = blendMode,
+            )
+        }
+    }
+
+    companion object {
+        val Pivot = Offset(12f, 11.8f)
+        const val VIEWPORT = 24f
+        private const val SCREEN_PIECES = 6
+        private const val BUTTON_RADIUS = 1f
+        private const val CURSOR_SIDE = 3.2f
+        private const val CURSOR_CORNER = 0.6f
+        private val LINE = Stroke(width = 2.3f, cap = StrokeCap.Round, join = StrokeJoin.Round)
+    }
+}
diff --git a/app/src/main/java/video/typetype/tv/ui/splash/SplashTimeline.kt b/app/src/main/java/video/typetype/tv/ui/splash/SplashTimeline.kt
new file mode 100644
index 0000000..5dfaa51
--- /dev/null
+++ b/app/src/main/java/video/typetype/tv/ui/splash/SplashTimeline.kt
@@ -0,0 +1,90 @@
+package video.typetype.tv.ui.splash
+
+import androidx.compose.animation.core.CubicBezierEasing
+import androidx.compose.animation.core.Easing
+import androidx.compose.ui.geometry.Offset
+import kotlin.math.cos
+import kotlin.math.exp
+import kotlin.math.sin
+
+// Every time is in milliseconds from the first frame. The startup sound is built on the same numbers: each
+// hop lands on a note and the last landing is the chord, so a change here needs a new sound.
+internal object SplashTimeline {
+    const val TOTAL = 6_000
+    const val HOPS = 13
+    private const val CURSOR_IN = 400f
+    private const val TRACE_START = 450f
+    private const val HOP = 210f
+    private const val HOP_MOTION = 0.85f
+    const val BURST = TRACE_START + (HOPS - 1) * HOP + HOP * HOP_MOTION
+
+    // The short intro starts on the last hop, so it keeps the burst, the settle and the written name.
+    const val SHORT_START = TRACE_START + (HOPS - 1) * HOP
+    private const val BURST_RISE = 90f
+    private const val BURST_FALL = 900f
+    private const val PUNCH_RISE = 80f
+    private const val PUNCH_DECAY = 180f
+    private const val SHAKE_LENGTH = 500f
+    private const val SHAKE_DECAY = 150f
+    private const val SHAKE_SPEED = 0.11f
+    private const val SETTLE_START = 3_250f
+    private const val SETTLE = 900f
+    private const val WRITE_START = 3_700f
+    private const val WRITE = 1_500f
+    private const val BLINK = 200f
+    private const val EXIT_START = 5_600f
+
+    private val Glide: Easing = CubicBezierEasing(0.2f, 0f, 0f, 1f)
+    private val Hop: Easing = CubicBezierEasing(0.4f, 0f, 0.2f, 1f)
+    private val Pen: Easing = CubicBezierEasing(0.45f, 0f, 0.3f, 1f)
+
+    fun cursorAppear(time: Float): Float = Glide.transform(fraction(time, 0f, CURSOR_IN))
+
+    // Whole hops done plus the eased part of the current one: each hop moves for most of its slot, then rests.
+    fun traceProgress(time: Float): Float {
+        if (time <= TRACE_START) return 0f
+        val elapsed = time - TRACE_START
+        val step = (elapsed / HOP).toInt()
+        if (step >= HOPS) return HOPS.toFloat()
+        val motion = fraction(elapsed - step * HOP, 0f, HOP * HOP_MOTION)
+        return step + Hop.transform(motion)
+    }
+
+    fun burst(time: Float): Float = when {
+        time < BURST -> 0f
+        time < BURST + BURST_RISE -> (time - BURST) / BURST_RISE
+        else -> 1f - Glide.transform(fraction(time, BURST + BURST_RISE, BURST + BURST_RISE + BURST_FALL))
+    }
+
+    // The chord lands with weight: the mark swells at once, then eases back while the screen settles.
+    fun punch(time: Float): Float {
+        val since = time - BURST
+        return when {
+            since < 0f -> 0f
+            since < PUNCH_RISE -> Glide.transform(since / PUNCH_RISE)
+            else -> exp(-(since - PUNCH_RISE) / PUNCH_DECAY)
+        }
+    }
+
+    fun shake(time: Float): Offset {
+        val since = time - BURST
+        if (since < 0f || since > SHAKE_LENGTH) return Offset.Zero
+        val amount = exp(-since / SHAKE_DECAY)
+        return Offset(sin(since * SHAKE_SPEED) * amount, cos(since * SHAKE_SPEED * 1.3f) * amount)
+    }
+
+    fun settle(time: Float): Float = Glide.transform(fraction(time, SETTLE_START, SETTLE_START + SETTLE))
+
+    // How much of the word the pen has written: slow to start, quick through the middle, gentle at the end.
+    fun writeProgress(time: Float): Float = Pen.transform(fraction(time, WRITE_START, WRITE_START + WRITE))
+
+    // The pen becomes the text cursor once the word is written, and blinks until the screen fades out.
+    fun textCursorShown(time: Float): Boolean {
+        val written = WRITE_START + WRITE
+        return time >= written && time < EXIT_START && ((time - written) / BLINK).toInt() % 2 == 0
+    }
+
+    fun exitAlpha(time: Float): Float = 1f - fraction(time, EXIT_START, TOTAL.toFloat())
+
+    private fun fraction(time: Float, start: Float, end: Float): Float = ((time - start) / (end - start)).coerceIn(0f, 1f)
+}
diff --git a/app/src/main/java/video/typetype/tv/ui/splash/SplashWordmark.kt b/app/src/main/java/video/typetype/tv/ui/splash/SplashWordmark.kt
new file mode 100644
index 0000000..e288e87
--- /dev/null
+++ b/app/src/main/java/video/typetype/tv/ui/splash/SplashWordmark.kt
@@ -0,0 +1,85 @@
+package video.typetype.tv.ui.splash
+
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.lerp
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Path
+import androidx.compose.ui.graphics.PathMeasure
+import androidx.compose.ui.graphics.StrokeCap
+import androidx.compose.ui.graphics.StrokeJoin
+import androidx.compose.ui.graphics.drawscope.DrawScope
+import androidx.compose.ui.graphics.drawscope.Stroke
+import video.typetype.tv.ui.brand.WordmarkLettering
+
+// The lettered wordmark (WordmarkLettering) written in one gesture: a pen point inks each stroke, glides to the
+// next one and ends as the text cursor. Units: cap height 10, y down.
+internal class SplashWordmark {
+    private sealed interface Piece {
+        val length: Float
+    }
+
+    private class Ink(val path: Path) : Piece {
+        val measure = PathMeasure().apply { setPath(path, false) }
+        override val length = measure.length
+        val start: Offset = measure.getPosition(0f)
+        val end: Offset = measure.getPosition(length)
+    }
+
+    // A pen-up move between two strokes: it takes time, but less than inking the same distance.
+    private class Glide(val from: Offset, val to: Offset) : Piece {
+        override val length = (to - from).getDistance() * GLIDE_WEIGHT
+    }
+
+    private val pieces: List<Piece>
+    private val total: Float
+    private val cursorAt: Offset
+    private val segment = Path()
+    val width: Float
+
+    init {
+        val inks = WordmarkLettering.strokes().map(::Ink)
+        width = WordmarkLettering.width
+        cursorAt = Offset(width + WordmarkLettering.CURSOR_GAP, CAP / 2)
+        pieces = buildList {
+            inks.forEachIndexed { index, ink ->
+                if (index > 0) add(Glide(inks[index - 1].end, ink.start))
+                add(ink)
+            }
+            add(Glide(inks.last().end, cursorAt))
+        }
+        total = pieces.sumOf { it.length.toDouble() }.toFloat()
+    }
+
+    fun draw(scope: DrawScope, time: Float, color: Color, penColor: Color) = with(scope) {
+        val written = SplashTimeline.writeProgress(time)
+        if (written <= 0f) return@with
+        var left = written * total
+        var pen = cursorAt
+        for (piece in pieces) {
+            val part = left.coerceIn(0f, piece.length)
+            when (piece) {
+                is Ink -> if (part > 0f) {
+                    segment.reset()
+                    piece.measure.getSegment(0f, part, segment, true)
+                    drawPath(segment, color, style = LINE)
+                    if (part < piece.length) pen = piece.measure.getPosition(part)
+                }
+                is Glide -> if (part > 0f && part < piece.length) pen = lerp(piece.from, piece.to, part / piece.length)
+            }
+            left -= piece.length
+            if (left <= 0f) break
+        }
+        if (written < 1f) {
+            drawCircle(penColor, PEN_RADIUS, pen)
+        } else if (SplashTimeline.textCursorShown(time)) {
+            drawLine(penColor, cursorAt - Offset(0f, CAP / 2 + 1.6f), cursorAt + Offset(0f, CAP / 2 + 1.6f), 1.8f, StrokeCap.Round)
+        }
+    }
+
+    companion object {
+        const val CAP = WordmarkLettering.CAP
+        private const val GLIDE_WEIGHT = 0.45f
+        private const val PEN_RADIUS = 1.5f
+        private val LINE = Stroke(width = WordmarkLettering.STROKE, cap = StrokeCap.Round, join = StrokeJoin.Round)
+    }
+}
diff --git a/app/src/main/java/video/typetype/tv/ui/splash/StartupChime.kt b/app/src/main/java/video/typetype/tv/ui/splash/StartupChime.kt
new file mode 100644
index 0000000..377437d
--- /dev/null
+++ b/app/src/main/java/video/typetype/tv/ui/splash/StartupChime.kt
@@ -0,0 +1,38 @@
+package video.typetype.tv.ui.splash
+
+import android.content.Context
+import android.media.AudioAttributes
+import android.media.MediaPlayer
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import video.typetype.tv.resources.R
+import java.io.IOException
+
+object StartupChime {
+    suspend fun play(context: Context) {
+        val player = withContext(Dispatchers.IO) { prepared(context) } ?: return
+        player.setOnCompletionListener { it.release() }
+        player.start()
+    }
+
+    private fun prepared(context: Context): MediaPlayer? {
+        val player = MediaPlayer()
+        return try {
+            player.setAudioAttributes(
+                AudioAttributes.Builder()
+                    .setUsage(AudioAttributes.USAGE_MEDIA)
+                    .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
+                    .build(),
+            )
+            context.resources.openRawResourceFd(R.raw.startup_chime).use { file ->
+                player.setDataSource(file.fileDescriptor, file.startOffset, file.length)
+            }
+            player.prepare()
+            player
+        } catch (_: IOException) {
+            // A box without a working audio output still starts; the chime is only decoration.
+            player.release()
+            null
+        }
+    }
+}
diff --git a/app/src/main/java/video/typetype/tv/ui/splash/StartupSplash.kt b/app/src/main/java/video/typetype/tv/ui/splash/StartupSplash.kt
new file mode 100644
index 0000000..943d98b
--- /dev/null
+++ b/app/src/main/java/video/typetype/tv/ui/splash/StartupSplash.kt
@@ -0,0 +1,124 @@
+package video.typetype.tv.ui.splash
+
+import androidx.compose.animation.core.Animatable
+import androidx.compose.animation.core.LinearEasing
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.focusable
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.lerp
+import androidx.compose.ui.graphics.BlendMode
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.drawscope.DrawScope
+import androidx.compose.ui.graphics.drawscope.scale
+import androidx.compose.ui.graphics.drawscope.translate
+import androidx.compose.ui.graphics.drawscope.withTransform
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.unit.dp
+import video.typetype.tv.resources.R
+import video.typetype.tv.theme.Palette
+import video.typetype.tv.ui.util.requestFocusWhenReady
+
+private val TraceSize = 250.dp
+private val FinalSize = 104.dp
+private val WordmarkCap = 46.dp
+private val WordmarkGap = 30.dp
+private val ShakeReach = 8.dp
+private const val PUNCH_GROW = 0.14f
+
+// Color ghosts of the mark that spring apart on the chord and close back onto the red mark.
+private class PrismLayer(val color: Color, val dx: Float, val dy: Float, val grow: Float)
+
+private val Prism = listOf(
+    PrismLayer(Color(0xFFFF3B3B), dx = -1.5f, dy = 0f, grow = 0.05f),
+    PrismLayer(Color(0xFFFF4FD8), dx = 0.2f, dy = -0.8f, grow = 0.11f),
+    PrismLayer(Color(0xFF5B6CFF), dx = 1.5f, dy = 0.4f, grow = 0.17f),
+)
+
+// The whole splash is one Canvas reading one clock in the draw phase: it never recomposes while it plays,
+// and the box GPU only redraws.
+@Composable
+fun StartupSplash(onFinished: () -> Unit, modifier: Modifier = Modifier, short: Boolean = false) {
+    val context = LocalContext.current.applicationContext
+    val start = if (short) SplashTimeline.SHORT_START else 0f
+    val clock = remember { Animatable(start) }
+    LaunchedEffect(Unit) {
+        // The picture waits for the sound to be ready: each hop of the mark lands on one of its notes. The short
+        // intro plays silently.
+        if (!short) StartupChime.play(context)
+        val left = (SplashTimeline.TOTAL - start).toInt()
+        clock.animateTo(SplashTimeline.TOTAL.toFloat(), tween(left, easing = LinearEasing))
+        onFinished()
+    }
+    val mark = remember { SplashMark() }
+    val wordmark = remember { SplashWordmark() }
+    val description = stringResource(R.string.logo_description)
+    // The splash holds the focus while it plays: with nothing focused, the first arrow key would move the focus
+    // into the screen behind, onto a text field that opens the keyboard. AppEntry drops the keys meanwhile.
+    val focus = remember { FocusRequester() }
+    LaunchedEffect(Unit) { focus.requestFocusWhenReady() }
+    Canvas(
+        modifier
+            .fillMaxSize()
+            .focusRequester(focus)
+            .focusable()
+            .semantics { contentDescription = description }
+            .graphicsLayer { alpha = SplashTimeline.exitAlpha(clock.value) },
+    ) {
+        drawSplashFrame(clock.value, mark, wordmark)
+    }
+}
+
+internal fun DrawScope.drawSplashFrame(time: Float, mark: SplashMark, wordmark: SplashWordmark) {
+    drawRect(Palette.Ink)
+    val shake = SplashTimeline.shake(time) * ShakeReach.toPx()
+    translate(shake.x, shake.y) { drawSplash(time, mark, wordmark) }
+}
+
+private fun DrawScope.drawSplash(time: Float, mark: SplashMark, wordmark: SplashWordmark) {
+    val finalSize = FinalSize.toPx()
+    val letterUnit = WordmarkCap.toPx() / SplashWordmark.CAP
+    val rowWidth = finalSize + WordmarkGap.toPx() + wordmark.width * letterUnit
+    val finalCenter = Offset(center.x - rowWidth / 2 + finalSize / 2, center.y)
+    val settle = SplashTimeline.settle(time)
+    val punch = 1f + PUNCH_GROW * SplashTimeline.punch(time)
+    val unit = (TraceSize.toPx() + (finalSize - TraceSize.toPx()) * settle) / SplashMark.VIEWPORT * punch
+    val markCenter = lerp(center, finalCenter, settle)
+    val burst = SplashTimeline.burst(time)
+    withTransform({
+        translate(markCenter.x - SplashMark.Pivot.x * unit, markCenter.y - SplashMark.Pivot.y * unit)
+        scale(unit, unit, pivot = Offset.Zero)
+    }) {
+        val progress = SplashTimeline.traceProgress(time)
+        val appear = SplashTimeline.cursorAppear(time)
+        mark.draw(this, progress, appear, Palette.Accent, alpha = 1f - 0.85f * burst)
+        if (burst > 0f) {
+            Prism.forEach { layer ->
+                translate(layer.dx * burst, layer.dy * burst) {
+                    scale(1f + layer.grow * burst, pivot = SplashMark.Pivot) {
+                        mark.draw(this, progress, appear, layer.color, alpha = burst, blendMode = BlendMode.Plus)
+                    }
+                }
+            }
+        }
+    }
+    val wordLeft = finalCenter.x + finalSize / 2 + WordmarkGap.toPx()
+    val wordTop = center.y - WordmarkCap.toPx() / 2
+    withTransform({
+        translate(wordLeft, wordTop)
+        scale(letterUnit, letterUnit, pivot = Offset.Zero)
+    }) {
+        wordmark.draw(this, time, Palette.TextHigh, Palette.Accent)
+    }
+}
diff --git a/app/src/main/res/drawable-anydpi-v26/ic_launcher.xml b/app/src/main/res/drawable-anydpi-v26/ic_launcher.xml
new file mode 100644
index 0000000..0f4233f
--- /dev/null
+++ b/app/src/main/res/drawable-anydpi-v26/ic_launcher.xml
@@ -0,0 +1,5 @@
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@color/tv_ink" />
+    <foreground android:drawable="@drawable/ic_launcher_foreground" />
+    <monochrome android:drawable="@drawable/ic_launcher_foreground" />
+</adaptive-icon>
diff --git a/app/src/main/res/drawable/ic_launcher.xml b/app/src/main/res/drawable/ic_launcher.xml
new file mode 100644
index 0000000..0a2f3f3
--- /dev/null
+++ b/app/src/main/res/drawable/ic_launcher.xml
@@ -0,0 +1,39 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="48dp"
+    android:height="48dp"
+    android:viewportWidth="48"
+    android:viewportHeight="48">
+    <path
+        android:fillColor="#FF09090B"
+        android:pathData="M10,2 H38 A8,8 0 0 1 46,10 V38 A8,8 0 0 1 38,46 H10 A8,8 0 0 1 2,38 V10 A8,8 0 0 1 10,2 Z" />
+    <group
+        android:scaleX="1.3"
+        android:scaleY="1.3"
+        android:translateX="8.40"
+        android:translateY="8.66">
+        <path
+            android:pathData="M5,7.4 L19,7.4 A2,2 0 0 1 21,9.4 L21,19 A2,2 0 0 1 19,21 L5,21 A2,2 0 0 1 3,19 L3,9.4 A2,2 0 0 1 5,7.4 Z"
+            android:strokeColor="#FFEF4444"
+            android:strokeWidth="2.3"
+            android:strokeLineCap="round"
+            android:strokeLineJoin="round" />
+        <path
+            android:pathData="M8,2.6 L12,6.6 L16,2.6"
+            android:strokeColor="#FFEF4444"
+            android:strokeWidth="2.3"
+            android:strokeLineCap="round"
+            android:strokeLineJoin="round" />
+        <path
+            android:pathData="M16.2,7.8 L16.2,20.6"
+            android:strokeColor="#FFEF4444"
+            android:strokeWidth="2.3"
+            android:strokeLineCap="round"
+            android:strokeLineJoin="round" />
+        <path
+            android:fillColor="#FFEF4444"
+            android:pathData="M18.7,11.4 m-1,0 a1,1 0 1,0 2,0 a1,1 0 1,0 -2,0" />
+        <path
+            android:fillColor="#FFEF4444"
+            android:pathData="M18.7,15.6 m-1,0 a1,1 0 1,0 2,0 a1,1 0 1,0 -2,0" />
+    </group>
+</vector>
diff --git a/app/src/main/res/drawable/ic_launcher_foreground.xml b/app/src/main/res/drawable/ic_launcher_foreground.xml
new file mode 100644
index 0000000..5476d10
--- /dev/null
+++ b/app/src/main/res/drawable/ic_launcher_foreground.xml
@@ -0,0 +1,36 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportWidth="108"
+    android:viewportHeight="108">
+    <group
+        android:scaleX="2.3"
+        android:scaleY="2.3"
+        android:translateX="26.40"
+        android:translateY="26.86">
+        <path
+            android:pathData="M5,7.4 L19,7.4 A2,2 0 0 1 21,9.4 L21,19 A2,2 0 0 1 19,21 L5,21 A2,2 0 0 1 3,19 L3,9.4 A2,2 0 0 1 5,7.4 Z"
+            android:strokeColor="#FFEF4444"
+            android:strokeWidth="2.3"
+            android:strokeLineCap="round"
+            android:strokeLineJoin="round" />
+        <path
+            android:pathData="M8,2.6 L12,6.6 L16,2.6"
+            android:strokeColor="#FFEF4444"
+            android:strokeWidth="2.3"
+            android:strokeLineCap="round"
+            android:strokeLineJoin="round" />
+        <path
+            android:pathData="M16.2,7.8 L16.2,20.6"
+            android:strokeColor="#FFEF4444"
+            android:strokeWidth="2.3"
+            android:strokeLineCap="round"
+            android:strokeLineJoin="round" />
+        <path
+            android:fillColor="#FFEF4444"
+            android:pathData="M18.7,11.4 m-1,0 a1,1 0 1,0 2,0 a1,1 0 1,0 -2,0" />
+        <path
+            android:fillColor="#FFEF4444"
+            android:pathData="M18.7,15.6 m-1,0 a1,1 0 1,0 2,0 a1,1 0 1,0 -2,0" />
+    </group>
+</vector>
diff --git a/app/src/main/res/drawable/tv_banner.xml b/app/src/main/res/drawable/tv_banner.xml
index e4d72c4..40ce36c 100644
--- a/app/src/main/res/drawable/tv_banner.xml
+++ b/app/src/main/res/drawable/tv_banner.xml
@@ -1,13 +1,112 @@
-<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
-    <item>
-        <shape android:shape="rectangle">
-            <solid android:color="#FF09090B" />
-        </shape>
-    </item>
-    <item
-        android:bottom="42dp"
-        android:drawable="@drawable/ic_typetype_mark"
-        android:gravity="center"
-        android:height="56dp"
-        android:width="56dp" />
-</layer-list>
+<!-- Kept as a vector above the usual icon size: the launcher draws it once, and a bitmap would blur on 4K TVs. -->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:width="320dp"
+    android:height="180dp"
+    android:viewportWidth="320"
+    android:viewportHeight="180"
+    tools:ignore="VectorRaster">
+    <path
+        android:fillColor="#FF09090B"
+        android:pathData="M0,0 H320 V180 H0 Z" />
+    <group
+        android:scaleX="2.6667"
+        android:scaleY="2.6667"
+        android:translateX="16.88"
+        android:translateY="58.53">
+        <path
+            android:pathData="M5,7.4 L19,7.4 A2,2 0 0 1 21,9.4 L21,19 A2,2 0 0 1 19,21 L5,21 A2,2 0 0 1 3,19 L3,9.4 A2,2 0 0 1 5,7.4 Z"
+            android:strokeColor="#FFEF4444"
+            android:strokeWidth="2.3"
+            android:strokeLineCap="round"
+            android:strokeLineJoin="round" />
+        <path
+            android:pathData="M8,2.6 L12,6.6 L16,2.6"
+            android:strokeColor="#FFEF4444"
+            android:strokeWidth="2.3"
+            android:strokeLineCap="round"
+            android:strokeLineJoin="round" />
+        <path
+            android:pathData="M16.2,7.8 L16.2,20.6"
+            android:strokeColor="#FFEF4444"
+            android:strokeWidth="2.3"
+            android:strokeLineCap="round"
+            android:strokeLineJoin="round" />
+        <path
+            android:fillColor="#FFEF4444"
+            android:pathData="M18.7,11.4 m-1,0 a1,1 0 1,0 2,0 a1,1 0 1,0 -2,0" />
+        <path
+            android:fillColor="#FFEF4444"
+            android:pathData="M18.7,15.6 m-1,0 a1,1 0 1,0 2,0 a1,1 0 1,0 -2,0" />
+    </group>
+    <group
+        android:scaleX="2.4"
+        android:scaleY="2.4"
+        android:translateX="96.95"
+        android:translateY="78.00">
+        <group android:translateX="0">
+            <path
+                android:pathData="M0,0 L8,0 M4,0 L4,10"
+                android:strokeColor="#FFF4F4F5"
+                android:strokeWidth="2.5"
+                android:strokeLineCap="round"
+                android:strokeLineJoin="round" />
+        </group>
+        <group android:translateX="11.4">
+            <path
+                android:pathData="M0,0 C0,3.6 1.6,5.2 4,5.2 C6.4,5.2 8,3.6 8,0 M4,5.2 L4,10"
+                android:strokeColor="#FFF4F4F5"
+                android:strokeWidth="2.5"
+                android:strokeLineCap="round"
+                android:strokeLineJoin="round" />
+        </group>
+        <group android:translateX="22.8">
+            <path
+                android:pathData="M0,10 L0,0 L3.4,0 A3,3 0 0 1 3.4,6 L0,6"
+                android:strokeColor="#FFF4F4F5"
+                android:strokeWidth="2.5"
+                android:strokeLineCap="round"
+                android:strokeLineJoin="round" />
+        </group>
+        <group android:translateX="32.6">
+            <path
+                android:pathData="M7,0 L2.6,0 A2.6,2.6 0 0 0 0,2.6 L0,7.4 A2.6,2.6 0 0 0 2.6,10 L7,10 M0,5 L5.4,5"
+                android:strokeColor="#FFF4F4F5"
+                android:strokeWidth="2.5"
+                android:strokeLineCap="round"
+                android:strokeLineJoin="round" />
+        </group>
+        <group android:translateX="43">
+            <path
+                android:pathData="M0,0 L8,0 M4,0 L4,10"
+                android:strokeColor="#FFF4F4F5"
+                android:strokeWidth="2.5"
+                android:strokeLineCap="round"
+                android:strokeLineJoin="round" />
+        </group>
+        <group android:translateX="54.4">
+            <path
+                android:pathData="M0,0 C0,3.6 1.6,5.2 4,5.2 C6.4,5.2 8,3.6 8,0 M4,5.2 L4,10"
+                android:strokeColor="#FFF4F4F5"
+                android:strokeWidth="2.5"
+                android:strokeLineCap="round"
+                android:strokeLineJoin="round" />
+        </group>
+        <group android:translateX="65.8">
+            <path
+                android:pathData="M0,10 L0,0 L3.4,0 A3,3 0 0 1 3.4,6 L0,6"
+                android:strokeColor="#FFF4F4F5"
+                android:strokeWidth="2.5"
+                android:strokeLineCap="round"
+                android:strokeLineJoin="round" />
+        </group>
+        <group android:translateX="75.6">
+            <path
+                android:pathData="M7,0 L2.6,0 A2.6,2.6 0 0 0 0,2.6 L0,7.4 A2.6,2.6 0 0 0 2.6,10 L7,10 M0,5 L5.4,5"
+                android:strokeColor="#FFF4F4F5"
+                android:strokeWidth="2.5"
+                android:strokeLineCap="round"
+                android:strokeLineJoin="round" />
+        </group>
+    </group>
+</vector>
diff --git a/app/src/test/java/video/typetype/tv/ui/SeekMathTest.kt b/app/src/test/java/video/typetype/tv/ui/SeekMathTest.kt
deleted file mode 100644
index 0fe9f8a..0000000
--- a/app/src/test/java/video/typetype/tv/ui/SeekMathTest.kt
+++ /dev/null
@@ -1,35 +0,0 @@
-package video.typetype.tv.ui
-
-import org.junit.Assert.assertEquals
-import org.junit.Test
-import video.typetype.tv.ui.player.SeekMath
-
-class SeekMathTest {
-    @Test
-    fun `short press seeks five seconds and long press ten`() {
-        assertEquals(5_000L, SeekMath.stepFor(0))
-        assertEquals(5_000L, SeekMath.stepFor(2))
-        assertEquals(10_000L, SeekMath.stepFor(3))
-        assertEquals(10_000L, SeekMath.stepFor(20))
-    }
-
-    @Test
-    fun `target never leaves the media bounds`() {
-        assertEquals(0L, SeekMath.target(3_000L, -10_000L, 40_000L))
-        assertEquals(40_000L, SeekMath.target(35_000L, 10_000L, 40_000L))
-        assertEquals(18_000L, SeekMath.target(8_000L, 10_000L, 40_000L))
-    }
-
-    @Test
-    fun `target is zero when the duration is unknown`() {
-        assertEquals(0L, SeekMath.target(5_000L, 5_000L, -1L))
-    }
-
-    @Test
-    fun `fraction is clamped and safe for unknown duration`() {
-        assertEquals(0f, SeekMath.fraction(1_000L, 0L), 0f)
-        assertEquals(0.5f, SeekMath.fraction(20_000L, 40_000L), 0.0001f)
-        assertEquals(1f, SeekMath.fraction(90_000L, 40_000L), 0f)
-        assertEquals(0f, SeekMath.fraction(-5L, 40_000L), 0f)
-    }
-}
diff --git a/app/src/test/java/video/typetype/tv/ui/splash/SplashTimelineTest.kt b/app/src/test/java/video/typetype/tv/ui/splash/SplashTimelineTest.kt
new file mode 100644
index 0000000..573d109
--- /dev/null
+++ b/app/src/test/java/video/typetype/tv/ui/splash/SplashTimelineTest.kt
@@ -0,0 +1,50 @@
+package video.typetype.tv.ui.splash
+
+import androidx.compose.ui.geometry.Offset
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class SplashTimelineTest {
+    @Test
+    fun theMarkIsTracedHopByHopBeforeTheChord() {
+        assertEquals(0f, SplashTimeline.traceProgress(0f))
+        val beforeChord = SplashTimeline.traceProgress(SplashTimeline.BURST - 1f)
+        assertTrue(beforeChord > SplashTimeline.HOPS - 1 && beforeChord <= SplashTimeline.HOPS)
+        assertEquals(SplashTimeline.HOPS.toFloat(), SplashTimeline.traceProgress(SplashTimeline.TOTAL.toFloat()))
+    }
+
+    @Test
+    fun theTraceRestsBetweenHops() {
+        val restA = SplashTimeline.traceProgress(450f + 200f)
+        val restB = SplashTimeline.traceProgress(450f + 209f)
+        assertEquals(1f, restA, 0.0001f)
+        assertEquals(restA, restB)
+    }
+
+    @Test
+    fun theBurstAndShakeOnlyFollowTheChord() {
+        assertEquals(0f, SplashTimeline.burst(SplashTimeline.BURST - 1f))
+        assertEquals(Offset.Zero, SplashTimeline.shake(SplashTimeline.BURST - 1f))
+        assertTrue(SplashTimeline.burst(SplashTimeline.BURST + 90f) > 0.99f)
+        assertEquals(0f, SplashTimeline.burst(SplashTimeline.TOTAL.toFloat()), 0.0001f)
+        assertEquals(Offset.Zero, SplashTimeline.shake(SplashTimeline.TOTAL.toFloat()))
+    }
+
+    @Test
+    fun theWordIsWrittenThenTheCursorBlinksUntilTheFade() {
+        assertEquals(0f, SplashTimeline.writeProgress(3_600f))
+        assertEquals(1f, SplashTimeline.writeProgress(5_200f), 0.0001f)
+        assertFalse(SplashTimeline.textCursorShown(5_100f))
+        assertTrue(SplashTimeline.textCursorShown(5_250f))
+        assertFalse(SplashTimeline.textCursorShown(5_450f))
+        assertFalse(SplashTimeline.textCursorShown(5_700f))
+    }
+
+    @Test
+    fun theSplashFadesOutAtTheEnd() {
+        assertEquals(1f, SplashTimeline.exitAlpha(5_600f))
+        assertEquals(0f, SplashTimeline.exitAlpha(SplashTimeline.TOTAL.toFloat()))
+    }
+}
diff --git a/assets/screenshots/tv-comments.png b/assets/screenshots/tv-comments.png
deleted file mode 100644
index 5336232..0000000
Binary files a/assets/screenshots/tv-comments.png and /dev/null differ
diff --git a/assets/screenshots/tv-detail.png b/assets/screenshots/tv-detail.png
index 96686fe..302d113 100644
Binary files a/assets/screenshots/tv-detail.png and b/assets/screenshots/tv-detail.png differ
diff --git a/assets/screenshots/tv-home.png b/assets/screenshots/tv-home.png
index 89d8687..d18b018 100644
Binary files a/assets/screenshots/tv-home.png and b/assets/screenshots/tv-home.png differ
diff --git a/assets/screenshots/tv-live-chat.png b/assets/screenshots/tv-live-chat.png
new file mode 100644
index 0000000..55c79fa
Binary files /dev/null and b/assets/screenshots/tv-live-chat.png differ
diff --git a/assets/screenshots/tv-player.png b/assets/screenshots/tv-player.png
index 626cd3d..ac4877b 100644
Binary files a/assets/screenshots/tv-player.png and b/assets/screenshots/tv-player.png differ
diff --git a/assets/screenshots/tv-related.png b/assets/screenshots/tv-related.png
new file mode 100644
index 0000000..795790d
Binary files /dev/null and b/assets/screenshots/tv-related.png differ
diff --git a/assets/screenshots/tv-search.png b/assets/screenshots/tv-search.png
index d12781b..fa0bbe9 100644
Binary files a/assets/screenshots/tv-search.png and b/assets/screenshots/tv-search.png differ
diff --git a/assets/screenshots/tv-settings.png b/assets/screenshots/tv-settings.png
deleted file mode 100644
index 8ad068c..0000000
Binary files a/assets/screenshots/tv-settings.png and /dev/null differ
diff --git a/build-logic/convention/build.gradle.kts b/build-logic/convention/build.gradle.kts
new file mode 100644
index 0000000..66512a1
--- /dev/null
+++ b/build-logic/convention/build.gradle.kts
@@ -0,0 +1,21 @@
+plugins {
+    `kotlin-dsl`
+}
+
+dependencies {
+    compileOnly(libs.android.gradlePlugin)
+    compileOnly(libs.compose.gradlePlugin)
+}
+
+gradlePlugin {
+    plugins {
+        register("androidLibrary") {
+            id = "typetype.android.library"
+            implementationClass = "AndroidLibraryConventionPlugin"
+        }
+        register("androidCompose") {
+            id = "typetype.android.compose"
+            implementationClass = "AndroidComposeConventionPlugin"
+        }
+    }
+}
diff --git a/build-logic/convention/src/main/kotlin/AndroidComposeConventionPlugin.kt b/build-logic/convention/src/main/kotlin/AndroidComposeConventionPlugin.kt
new file mode 100644
index 0000000..e278aa5
--- /dev/null
+++ b/build-logic/convention/src/main/kotlin/AndroidComposeConventionPlugin.kt
@@ -0,0 +1,24 @@
+import com.android.build.api.dsl.LibraryExtension
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.artifacts.VersionCatalogsExtension
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.dependencies
+import org.gradle.kotlin.dsl.getByType
+
+class AndroidComposeConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) = with(target) {
+        pluginManager.apply("typetype.android.library")
+        pluginManager.apply("org.jetbrains.kotlin.plugin.compose")
+        extensions.configure<LibraryExtension> {
+            buildFeatures.compose = true
+        }
+        val libs = extensions.getByType<VersionCatalogsExtension>().named("libs")
+        dependencies {
+            add("implementation", platform(libs.findLibrary("androidx-compose-bom").get()))
+            add("implementation", libs.findLibrary("androidx-compose-ui").get())
+            add("implementation", libs.findLibrary("androidx-compose-foundation").get())
+            add("implementation", libs.findLibrary("androidx-compose-material-icons-extended").get())
+        }
+    }
+}
diff --git a/build-logic/convention/src/main/kotlin/AndroidLibraryConventionPlugin.kt b/build-logic/convention/src/main/kotlin/AndroidLibraryConventionPlugin.kt
new file mode 100644
index 0000000..ff4f1ec
--- /dev/null
+++ b/build-logic/convention/src/main/kotlin/AndroidLibraryConventionPlugin.kt
@@ -0,0 +1,25 @@
+import com.android.build.api.dsl.LibraryExtension
+import org.gradle.api.JavaVersion
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.configure
+
+class AndroidLibraryConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) = with(target) {
+        pluginManager.apply("com.android.library")
+        extensions.configure<LibraryExtension> {
+            compileSdk = 37
+            defaultConfig {
+                minSdk = 23
+                testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+            }
+            compileOptions {
+                sourceCompatibility = JavaVersion.VERSION_17
+                targetCompatibility = JavaVersion.VERSION_17
+            }
+            testOptions {
+                unitTests.isReturnDefaultValues = true
+            }
+        }
+    }
+}
diff --git a/build-logic/settings.gradle.kts b/build-logic/settings.gradle.kts
new file mode 100644
index 0000000..875164f
--- /dev/null
+++ b/build-logic/settings.gradle.kts
@@ -0,0 +1,15 @@
+dependencyResolutionManagement {
+    repositories {
+        google()
+        mavenCentral()
+        gradlePluginPortal()
+    }
+    versionCatalogs {
+        create("libs") {
+            from(files("../gradle/libs.versions.toml"))
+        }
+    }
+}
+
+rootProject.name = "build-logic"
+include(":convention")
diff --git a/core/data/build.gradle.kts b/core/data/build.gradle.kts
new file mode 100644
index 0000000..7f2bebd
--- /dev/null
+++ b/core/data/build.gradle.kts
@@ -0,0 +1,21 @@
+plugins {
+    alias(libs.plugins.typetype.android.library)
+    alias(libs.plugins.kotlin.serialization)
+}
+
+android {
+    namespace = "video.typetype.tv.data"
+}
+
+dependencies {
+    implementation(project(":core:resources"))
+    api(libs.okhttp)
+    api(libs.kotlinx.coroutines.android)
+    api(libs.kotlinx.serialization.json)
+    implementation(libs.google.tink.android)
+
+    testImplementation(project(":core:testing"))
+    testImplementation(libs.junit)
+    testImplementation(libs.okhttp.mockwebserver)
+    testImplementation(libs.okhttp.tls)
+}
diff --git a/core/data/src/main/AndroidManifest.xml b/core/data/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..221161f
--- /dev/null
+++ b/core/data/src/main/AndroidManifest.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+</manifest>
diff --git a/app/src/main/java/video/typetype/tv/data/AccountBadge.kt b/core/data/src/main/java/video/typetype/tv/data/AccountBadge.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/AccountBadge.kt
rename to core/data/src/main/java/video/typetype/tv/data/AccountBadge.kt
diff --git a/app/src/main/java/video/typetype/tv/data/AccountInitials.kt b/core/data/src/main/java/video/typetype/tv/data/AccountInitials.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/AccountInitials.kt
rename to core/data/src/main/java/video/typetype/tv/data/AccountInitials.kt
diff --git a/app/src/main/java/video/typetype/tv/data/BulletComment.kt b/core/data/src/main/java/video/typetype/tv/data/BulletComment.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/BulletComment.kt
rename to core/data/src/main/java/video/typetype/tv/data/BulletComment.kt
diff --git a/app/src/main/java/video/typetype/tv/data/CaptionStyles.kt b/core/data/src/main/java/video/typetype/tv/data/CaptionStyles.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/CaptionStyles.kt
rename to core/data/src/main/java/video/typetype/tv/data/CaptionStyles.kt
diff --git a/app/src/main/java/video/typetype/tv/data/ChannelPage.kt b/core/data/src/main/java/video/typetype/tv/data/ChannelPage.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/ChannelPage.kt
rename to core/data/src/main/java/video/typetype/tv/data/ChannelPage.kt
diff --git a/core/data/src/main/java/video/typetype/tv/data/ChannelTabs.kt b/core/data/src/main/java/video/typetype/tv/data/ChannelTabs.kt
new file mode 100644
index 0000000..e3a8a25
--- /dev/null
+++ b/core/data/src/main/java/video/typetype/tv/data/ChannelTabs.kt
@@ -0,0 +1,37 @@
+package video.typetype.tv.data
+
+import androidx.annotation.StringRes
+import video.typetype.tv.resources.R
+
+// The parts of a channel page, as the web shows them. The server reaches the live and playlist tabs, and sorts the
+// videos, for YouTube channels only; other services offer their videos as they come.
+enum class ChannelTab(@StringRes val labelRes: Int) {
+    Videos(R.string.channel_tab_videos),
+    Live(R.string.channel_tab_live),
+    Playlists(R.string.channel_tab_playlists),
+    ;
+
+    companion object {
+        fun available(channelUrl: String): List<ChannelTab> =
+            if (ContentSource.of(channelUrl) == ContentSource.YouTube) entries else listOf(Videos)
+    }
+}
+
+enum class ChannelSort(val wire: String, @StringRes val labelRes: Int) {
+    Latest("latest", R.string.channel_sort_latest),
+    Popular("popular", R.string.channel_sort_popular),
+    Oldest("oldest", R.string.channel_sort_oldest),
+    ;
+
+    companion object {
+        fun available(channelUrl: String): List<ChannelSort> =
+            if (ContentSource.of(channelUrl) == ContentSource.YouTube) entries else emptyList()
+    }
+}
+
+// Searching inside a channel, which the server offers for YouTube channels, as the web does.
+object ChannelSearch {
+    fun available(channelUrl: String): Boolean = ContentSource.of(channelUrl) == ContentSource.YouTube
+}
+
+data class ChannelPlaylists(val playlists: List<PublicPlaylist>, val nextPage: String?)
diff --git a/app/src/main/java/video/typetype/tv/data/Comment.kt b/core/data/src/main/java/video/typetype/tv/data/Comment.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/Comment.kt
rename to core/data/src/main/java/video/typetype/tv/data/Comment.kt
diff --git a/app/src/main/java/video/typetype/tv/data/ContentRepository.kt b/core/data/src/main/java/video/typetype/tv/data/ContentRepository.kt
similarity index 63%
rename from app/src/main/java/video/typetype/tv/data/ContentRepository.kt
rename to core/data/src/main/java/video/typetype/tv/data/ContentRepository.kt
index e1f9b27..010beff 100644
--- a/app/src/main/java/video/typetype/tv/data/ContentRepository.kt
+++ b/core/data/src/main/java/video/typetype/tv/data/ContentRepository.kt
@@ -1,13 +1,22 @@
 package video.typetype.tv.data
 
+import kotlinx.coroutines.flow.Flow
+
 interface ContentRepository : VideoActivityRepository, PresenceSink {
     suspend fun home(): HomeContent
 
     suspend fun video(id: String): Video?
 
+    suspend fun prewarm(videoId: String)
+
     suspend fun related(id: String): List<Video>
 
-    suspend fun search(query: String, source: ContentSource = ContentSource.YouTube, kind: SearchKind = SearchKind.Videos): SearchResults
+    suspend fun search(
+        query: String,
+        source: ContentSource = ContentSource.YouTube,
+        kind: SearchKind = SearchKind.Videos,
+        page: String? = null,
+    ): SearchResults
 
     suspend fun libraryTabs(): List<LibrarySection>
 
@@ -33,9 +42,26 @@ interface ContentRepository : VideoActivityRepository, PresenceSink {
 
     suspend fun unblockChannel(url: String)
 
+    suspend fun isVideoBlocked(url: String): Boolean
+
+    suspend fun blockVideo(video: Video)
+
+    suspend fun unblockVideo(url: String)
+
     suspend fun bulletComments(videoUrl: String): List<BulletComment>
 
-    suspend fun channel(url: String, page: String? = null): ChannelPage
+    fun liveChat(videoUrl: String): Flow<LiveChatEvent>
+
+    // Videos or Live; the Playlists tab has its own call below. A query searches the channel's videos instead.
+    suspend fun channel(
+        url: String,
+        page: String? = null,
+        tab: ChannelTab = ChannelTab.Videos,
+        sort: ChannelSort? = null,
+        query: String? = null,
+    ): ChannelPage
+
+    suspend fun channelPlaylists(url: String, page: String? = null): ChannelPlaylists
 
     suspend fun publicPlaylist(url: String, page: String? = null): PublicPlaylistPage
 
diff --git a/app/src/main/java/video/typetype/tv/data/ContentSource.kt b/core/data/src/main/java/video/typetype/tv/data/ContentSource.kt
similarity index 71%
rename from app/src/main/java/video/typetype/tv/data/ContentSource.kt
rename to core/data/src/main/java/video/typetype/tv/data/ContentSource.kt
index 530b651..8bea1d2 100644
--- a/app/src/main/java/video/typetype/tv/data/ContentSource.kt
+++ b/core/data/src/main/java/video/typetype/tv/data/ContentSource.kt
@@ -1,13 +1,14 @@
 package video.typetype.tv.data
 
+import androidx.annotation.DrawableRes
 import androidx.annotation.StringRes
 import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 
-enum class ContentSource(val serviceId: Int, @StringRes val labelRes: Int, val badge: String?) {
-    YouTube(0, R.string.source_youtube, null),
-    BiliBili(5, R.string.source_bilibili, "Bilibili"),
-    NicoNico(6, R.string.source_niconico, "NicoNico"),
+enum class ContentSource(val serviceId: Int, @StringRes val labelRes: Int, @DrawableRes val iconRes: Int) {
+    YouTube(0, R.string.source_youtube, R.drawable.ic_service_youtube),
+    BiliBili(5, R.string.source_bilibili, R.drawable.ic_service_bilibili),
+    NicoNico(6, R.string.source_niconico, R.drawable.ic_service_niconico),
     ;
 
     companion object {
diff --git a/app/src/main/java/video/typetype/tv/data/DeviceProfile.kt b/core/data/src/main/java/video/typetype/tv/data/DeviceProfile.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/DeviceProfile.kt
rename to core/data/src/main/java/video/typetype/tv/data/DeviceProfile.kt
diff --git a/app/src/main/java/video/typetype/tv/data/InstanceUrls.kt b/core/data/src/main/java/video/typetype/tv/data/InstanceUrls.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/InstanceUrls.kt
rename to core/data/src/main/java/video/typetype/tv/data/InstanceUrls.kt
diff --git a/core/data/src/main/java/video/typetype/tv/data/LiveChat.kt b/core/data/src/main/java/video/typetype/tv/data/LiveChat.kt
new file mode 100644
index 0000000..7e723be
--- /dev/null
+++ b/core/data/src/main/java/video/typetype/tv/data/LiveChat.kt
@@ -0,0 +1,14 @@
+package video.typetype.tv.data
+
+data class LiveChatMessage(
+    val id: String,
+    val author: String,
+    val text: String,
+    val moderator: Boolean = false,
+)
+
+sealed interface LiveChatEvent {
+    data class Message(val message: LiveChatMessage) : LiveChatEvent
+
+    data object Unavailable : LiveChatEvent
+}
diff --git a/app/src/main/java/video/typetype/tv/data/Models.kt b/core/data/src/main/java/video/typetype/tv/data/Models.kt
similarity index 98%
rename from app/src/main/java/video/typetype/tv/data/Models.kt
rename to core/data/src/main/java/video/typetype/tv/data/Models.kt
index 978ad69..7acf769 100644
--- a/app/src/main/java/video/typetype/tv/data/Models.kt
+++ b/core/data/src/main/java/video/typetype/tv/data/Models.kt
@@ -103,6 +103,7 @@ sealed interface SettingItem {
         val options: List<String>,
         val defaultIndex: Int,
         val wireValues: List<String> = options,
+        @StringRes val summaryRes: Int? = null,
     ) : SettingItem
 
     data class Info(
diff --git a/app/src/main/java/video/typetype/tv/data/PlaybackSetup.kt b/core/data/src/main/java/video/typetype/tv/data/PlaybackSetup.kt
similarity index 94%
rename from app/src/main/java/video/typetype/tv/data/PlaybackSetup.kt
rename to core/data/src/main/java/video/typetype/tv/data/PlaybackSetup.kt
index 321b9a8..0bb8966 100644
--- a/app/src/main/java/video/typetype/tv/data/PlaybackSetup.kt
+++ b/core/data/src/main/java/video/typetype/tv/data/PlaybackSetup.kt
@@ -1,5 +1,7 @@
 package video.typetype.tv.data
 
+import video.typetype.tv.data.dto.StreamDto
+
 data class SubtitleTrack(
     val url: String,
     val mimeType: String,
@@ -42,4 +44,5 @@ data class PlaybackSetup(
     val sponsorSegments: List<SponsorSegment> = emptyList(),
     val liveManifest: String? = null,
     val storyboard: Storyboard? = null,
+    val stream: StreamDto? = null,
 )
diff --git a/app/src/main/java/video/typetype/tv/data/PresenceReport.kt b/core/data/src/main/java/video/typetype/tv/data/PresenceReport.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/PresenceReport.kt
rename to core/data/src/main/java/video/typetype/tv/data/PresenceReport.kt
diff --git a/app/src/main/java/video/typetype/tv/data/PresenceSink.kt b/core/data/src/main/java/video/typetype/tv/data/PresenceSink.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/PresenceSink.kt
rename to core/data/src/main/java/video/typetype/tv/data/PresenceSink.kt
diff --git a/app/src/main/java/video/typetype/tv/data/PublicPlaylist.kt b/core/data/src/main/java/video/typetype/tv/data/PublicPlaylist.kt
similarity index 89%
rename from app/src/main/java/video/typetype/tv/data/PublicPlaylist.kt
rename to core/data/src/main/java/video/typetype/tv/data/PublicPlaylist.kt
index 3aabc0b..8e1ecbc 100644
--- a/app/src/main/java/video/typetype/tv/data/PublicPlaylist.kt
+++ b/core/data/src/main/java/video/typetype/tv/data/PublicPlaylist.kt
@@ -1,7 +1,7 @@
 package video.typetype.tv.data
 
 import androidx.annotation.StringRes
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 
 data class PublicPlaylist(
     val url: String,
@@ -45,12 +45,6 @@ enum class SearchKind(@StringRes val labelRes: Int, private val filters: Map<Con
 
     companion object {
         fun available(source: ContentSource): List<SearchKind> = entries.filter { it.supports(source) }
-
-        fun next(source: ContentSource, current: SearchKind): SearchKind {
-            val kinds = available(source)
-            val index = kinds.indexOf(current)
-            return kinds[(index + 1).mod(kinds.size)]
-        }
     }
 }
 
@@ -58,6 +52,7 @@ data class SearchResults(
     val videos: List<Video> = emptyList(),
     val playlists: List<PublicPlaylist> = emptyList(),
     val channels: List<ChannelSummary> = emptyList(),
+    val nextPage: String? = null,
 ) {
     val size: Int get() = videos.size + playlists.size + channels.size
 }
diff --git a/app/src/main/java/video/typetype/tv/data/SettingActions.kt b/core/data/src/main/java/video/typetype/tv/data/SettingActions.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/SettingActions.kt
rename to core/data/src/main/java/video/typetype/tv/data/SettingActions.kt
diff --git a/app/src/main/java/video/typetype/tv/data/SponsorBlockSettings.kt b/core/data/src/main/java/video/typetype/tv/data/SponsorBlockSettings.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/SponsorBlockSettings.kt
rename to core/data/src/main/java/video/typetype/tv/data/SponsorBlockSettings.kt
diff --git a/app/src/main/java/video/typetype/tv/data/StartupPreferences.kt b/core/data/src/main/java/video/typetype/tv/data/StartupPreferences.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/StartupPreferences.kt
rename to core/data/src/main/java/video/typetype/tv/data/StartupPreferences.kt
diff --git a/app/src/main/java/video/typetype/tv/data/Storyboard.kt b/core/data/src/main/java/video/typetype/tv/data/Storyboard.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/Storyboard.kt
rename to core/data/src/main/java/video/typetype/tv/data/Storyboard.kt
diff --git a/app/src/main/java/video/typetype/tv/data/VideoActivityRepository.kt b/core/data/src/main/java/video/typetype/tv/data/VideoActivityRepository.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/VideoActivityRepository.kt
rename to core/data/src/main/java/video/typetype/tv/data/VideoActivityRepository.kt
diff --git a/app/src/main/java/video/typetype/tv/playback/VideoIds.kt b/core/data/src/main/java/video/typetype/tv/data/VideoIds.kt
similarity index 93%
rename from app/src/main/java/video/typetype/tv/playback/VideoIds.kt
rename to core/data/src/main/java/video/typetype/tv/data/VideoIds.kt
index 8e00619..98f7599 100644
--- a/app/src/main/java/video/typetype/tv/playback/VideoIds.kt
+++ b/core/data/src/main/java/video/typetype/tv/data/VideoIds.kt
@@ -1,4 +1,4 @@
-package video.typetype.tv.playback
+package video.typetype.tv.data
 
 import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
 
diff --git a/app/src/main/java/video/typetype/tv/data/api/AuthApi.kt b/core/data/src/main/java/video/typetype/tv/data/api/AuthApi.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/api/AuthApi.kt
rename to core/data/src/main/java/video/typetype/tv/data/api/AuthApi.kt
diff --git a/app/src/main/java/video/typetype/tv/data/api/LibraryWriteApi.kt b/core/data/src/main/java/video/typetype/tv/data/api/LibraryWriteApi.kt
similarity index 91%
rename from app/src/main/java/video/typetype/tv/data/api/LibraryWriteApi.kt
rename to core/data/src/main/java/video/typetype/tv/data/api/LibraryWriteApi.kt
index ab3034f..fbcf903 100644
--- a/app/src/main/java/video/typetype/tv/data/api/LibraryWriteApi.kt
+++ b/core/data/src/main/java/video/typetype/tv/data/api/LibraryWriteApi.kt
@@ -3,6 +3,7 @@ package video.typetype.tv.data.api
 import kotlinx.serialization.builtins.ListSerializer
 import kotlinx.serialization.encodeToString
 import video.typetype.tv.data.dto.BlockChannelRequest
+import video.typetype.tv.data.dto.BlockVideoRequest
 import video.typetype.tv.data.dto.HistoryRequest
 import video.typetype.tv.data.dto.PlaylistVideoRequest
 import video.typetype.tv.data.dto.ProgressDto
@@ -67,6 +68,14 @@ class LibraryWriteApi(private val client: ApiClient) {
         client.send("DELETE", client.urlWithSegment("blocked/channels", channelUrl), null)
     }
 
+    suspend fun blockVideo(request: BlockVideoRequest) {
+        client.send("POST", "blocked/videos", client.json.encodeToString(request))
+    }
+
+    suspend fun unblockVideo(videoUrl: String) {
+        client.send("DELETE", client.urlWithSegment("blocked/videos", videoUrl), null)
+    }
+
     suspend fun addHistory(request: HistoryRequest) {
         client.send("POST", "history", client.json.encodeToString(request))
     }
diff --git a/core/data/src/main/java/video/typetype/tv/data/api/LiveChatApi.kt b/core/data/src/main/java/video/typetype/tv/data/api/LiveChatApi.kt
new file mode 100644
index 0000000..819c407
--- /dev/null
+++ b/core/data/src/main/java/video/typetype/tv/data/api/LiveChatApi.kt
@@ -0,0 +1,35 @@
+package video.typetype.tv.data.api
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.flowOn
+import okhttp3.Request
+import video.typetype.tv.data.net.ApiClient
+import java.io.IOException
+
+class LiveChatRefused(val status: Int, val retryAfterSeconds: Long?) : IOException("Live chat refused with $status")
+
+class LiveChatApi(private val client: ApiClient) {
+    fun events(videoUrl: String): Flow<SseEvent> = flow {
+        val request = Request.Builder()
+            .url(client.url("live-chat", mapOf("url" to videoUrl)))
+            .header("Accept", "text/event-stream")
+            .build()
+        val call = client.http.newCall(request)
+        val cancel = currentCoroutineContext()[Job]?.invokeOnCompletion { call.cancel() }
+        try {
+            call.execute().use { response ->
+                if (!response.isSuccessful) {
+                    throw LiveChatRefused(response.code, response.header("Retry-After")?.toLongOrNull())
+                }
+                val reader = SseReader(response.body.source())
+                while (true) emit(reader.next() ?: break)
+            }
+        } finally {
+            cancel?.dispose()
+        }
+    }.flowOn(Dispatchers.IO)
+}
diff --git a/app/src/main/java/video/typetype/tv/data/api/PresenceApi.kt b/core/data/src/main/java/video/typetype/tv/data/api/PresenceApi.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/api/PresenceApi.kt
rename to core/data/src/main/java/video/typetype/tv/data/api/PresenceApi.kt
diff --git a/app/src/main/java/video/typetype/tv/data/api/SabrApi.kt b/core/data/src/main/java/video/typetype/tv/data/api/SabrApi.kt
similarity index 95%
rename from app/src/main/java/video/typetype/tv/data/api/SabrApi.kt
rename to core/data/src/main/java/video/typetype/tv/data/api/SabrApi.kt
index a3ef653..58af127 100644
--- a/app/src/main/java/video/typetype/tv/data/api/SabrApi.kt
+++ b/core/data/src/main/java/video/typetype/tv/data/api/SabrApi.kt
@@ -10,12 +10,13 @@ import video.typetype.tv.data.net.ApiClient
 class SabrApi(private val client: ApiClient) {
     val baseUrl get() = client.baseUrl
 
-    suspend fun createSession(videoId: String, request: SabrSessionRequest): SabrSessionDto =
+    suspend fun createSession(videoId: String, request: SabrSessionRequest, anonymous: Boolean = false): SabrSessionDto =
         client.postAllowing(
             "sabr/playback/$videoId",
             client.json.encodeToString(request),
             SabrSessionDto.serializer(),
             READY_OR_PENDING,
+            anonymous,
         ).second
 
     suspend fun position(sessionId: String, request: SabrWindowRequest) {
diff --git a/core/data/src/main/java/video/typetype/tv/data/api/SseReader.kt b/core/data/src/main/java/video/typetype/tv/data/api/SseReader.kt
new file mode 100644
index 0000000..cc0d632
--- /dev/null
+++ b/core/data/src/main/java/video/typetype/tv/data/api/SseReader.kt
@@ -0,0 +1,30 @@
+package video.typetype.tv.data.api
+
+import okio.BufferedSource
+
+data class SseEvent(val name: String, val data: String)
+
+// Server-sent events: "event:" and "data:" lines, a blank line ends an event, ":" starts a comment
+// (the server's keep-alive).
+class SseReader(private val source: BufferedSource) {
+    fun next(): SseEvent? {
+        var name = DEFAULT_EVENT
+        val data = StringBuilder()
+        while (true) {
+            val line = source.readUtf8Line() ?: return null
+            when {
+                line.isEmpty() -> if (data.isNotEmpty()) return SseEvent(name, data.toString()) else name = DEFAULT_EVENT
+                line.startsWith(":") -> Unit
+                line.startsWith("event:") -> name = line.removePrefix("event:").trim()
+                line.startsWith("data:") -> {
+                    if (data.isNotEmpty()) data.append('\n')
+                    data.append(line.removePrefix("data:").removePrefix(" "))
+                }
+            }
+        }
+    }
+
+    private companion object {
+        const val DEFAULT_EVENT = "message"
+    }
+}
diff --git a/app/src/main/java/video/typetype/tv/data/api/TypeTypeApi.kt b/core/data/src/main/java/video/typetype/tv/data/api/TypeTypeApi.kt
similarity index 88%
rename from app/src/main/java/video/typetype/tv/data/api/TypeTypeApi.kt
rename to core/data/src/main/java/video/typetype/tv/data/api/TypeTypeApi.kt
index 89e99a6..4d89bed 100644
--- a/app/src/main/java/video/typetype/tv/data/api/TypeTypeApi.kt
+++ b/core/data/src/main/java/video/typetype/tv/data/api/TypeTypeApi.kt
@@ -8,6 +8,7 @@ import video.typetype.tv.data.dto.AccountDto
 import video.typetype.tv.data.dto.BlockedItemDto
 import video.typetype.tv.data.dto.BulletCommentsDto
 import video.typetype.tv.data.dto.ChannelPageDto
+import video.typetype.tv.data.dto.ChannelPlaylistsDto
 import video.typetype.tv.data.dto.ChannelPageRequest
 import video.typetype.tv.data.dto.CommentsPageDto
 import video.typetype.tv.data.dto.ChannelPodcastsDto
@@ -33,6 +34,8 @@ import video.typetype.tv.data.net.ApiFailure
 import video.typetype.tv.data.net.FailureCategory
 
 class TypeTypeApi(private val client: ApiClient) {
+    val liveChat = LiveChatApi(client)
+
     suspend fun me(): UserProfileDto = client.get("auth/me", UserProfileDto.serializer())
 
     suspend fun account(): AccountDto = client.get("profile/account", AccountDto.serializer())
@@ -53,11 +56,16 @@ class TypeTypeApi(private val client: ApiClient) {
     suspend fun trending(source: ContentSource = ContentSource.YouTube): List<VideoItemDto> =
         client.get("trending", ListSerializer(VideoItemDto.serializer()), mapOf("service" to source.serviceId.toString()))
 
-    suspend fun search(query: String, source: ContentSource = ContentSource.YouTube, filter: String? = null): SearchResultDto =
+    suspend fun search(
+        query: String,
+        source: ContentSource = ContentSource.YouTube,
+        filter: String? = null,
+        nextPage: String? = null,
+    ): SearchResultDto =
         client.get(
             "search",
             SearchResultDto.serializer(),
-            mapOf("q" to query, "service" to source.serviceId.toString(), "contentFilter" to filter),
+            mapOf("q" to query, "service" to source.serviceId.toString(), "contentFilter" to filter, "nextpage" to nextPage),
         )
 
     suspend fun publicPlaylist(url: String, nextPage: String? = null): PublicPlaylistDto =
@@ -102,8 +110,11 @@ class TypeTypeApi(private val client: ApiClient) {
         client.send("PUT", "settings", patch.toString())
     }
 
-    suspend fun channelPage(url: String, nextPage: String? = null): ChannelPageDto =
-        client.post("channel/page", client.json.encodeToString(ChannelPageRequest(url, nextPage)), ChannelPageDto.serializer())
+    suspend fun channelPage(url: String, nextPage: String? = null, sort: String? = null): ChannelPageDto =
+        client.post("channel/page", client.json.encodeToString(ChannelPageRequest(url, nextPage, sort)), ChannelPageDto.serializer())
+
+    suspend fun channelPlaylists(url: String, nextPage: String? = null): ChannelPlaylistsDto =
+        client.get("channel/playlists", ChannelPlaylistsDto.serializer(), mapOf("url" to url, "nextpage" to nextPage))
 
     suspend fun notifications(): NotificationsDto = client.get("notifications", NotificationsDto.serializer())
 
@@ -131,10 +142,10 @@ class TypeTypeApi(private val client: ApiClient) {
     suspend fun bulletComments(videoUrl: String): BulletCommentsDto =
         client.get("bullet-comments", BulletCommentsDto.serializer(), mapOf("url" to videoUrl))
 
-    suspend fun streamBootstrap(videoUrl: String): StreamDto =
-        client.get("streams/youtube/sabr/bootstrap", StreamDto.serializer(), mapOf("url" to videoUrl))
+    suspend fun streamBootstrap(videoUrl: String, anonymous: Boolean = false): StreamDto =
+        client.get("streams/youtube/sabr/bootstrap", StreamDto.serializer(), mapOf("url" to videoUrl), anonymous)
 
-    suspend fun streamFor(videoUrl: String): StreamDto {
+    suspend fun streamFor(videoUrl: String, anonymous: Boolean = false): StreamDto {
         val endpoint = when (ContentSource.of(videoUrl)) {
             ContentSource.YouTube -> "streams/youtube/sabr"
             ContentSource.BiliBili -> "streams/bilibili"
@@ -143,6 +154,6 @@ class TypeTypeApi(private val client: ApiClient) {
                 ApiFailure(FailureCategory.Contract, null, "unsupported_source", "This video source is not supported", null),
             )
         }
-        return client.get(endpoint, StreamDto.serializer(), mapOf("url" to videoUrl))
+        return client.get(endpoint, StreamDto.serializer(), mapOf("url" to videoUrl), anonymous)
     }
 }
diff --git a/core/data/src/main/java/video/typetype/tv/data/device/DeviceStore.kt b/core/data/src/main/java/video/typetype/tv/data/device/DeviceStore.kt
new file mode 100644
index 0000000..4de5142
--- /dev/null
+++ b/core/data/src/main/java/video/typetype/tv/data/device/DeviceStore.kt
@@ -0,0 +1,31 @@
+package video.typetype.tv.data.device
+
+import android.content.Context
+
+// Choices kept on this box only, whatever account is signed in.
+interface DeviceStore {
+    fun flag(key: String, fallback: Boolean): Boolean
+
+    fun putFlag(key: String, value: Boolean)
+
+    fun text(key: String, fallback: String): String
+
+    fun putText(key: String, value: String)
+}
+
+class PreferencesDeviceStore(context: Context, name: String = PERFORMANCE) : DeviceStore {
+    private val preferences = context.getSharedPreferences(name, Context.MODE_PRIVATE)
+
+    override fun flag(key: String, fallback: Boolean) = preferences.getBoolean(key, fallback)
+
+    override fun putFlag(key: String, value: Boolean) = preferences.edit().putBoolean(key, value).apply()
+
+    override fun text(key: String, fallback: String) = preferences.getString(key, fallback) ?: fallback
+
+    override fun putText(key: String, value: String) = preferences.edit().putString(key, value).apply()
+
+    companion object {
+        const val PERFORMANCE = "performance"
+        const val DECODERS = "decoders"
+    }
+}
diff --git a/core/data/src/main/java/video/typetype/tv/data/device/PerformanceSettings.kt b/core/data/src/main/java/video/typetype/tv/data/device/PerformanceSettings.kt
new file mode 100644
index 0000000..7668def
--- /dev/null
+++ b/core/data/src/main/java/video/typetype/tv/data/device/PerformanceSettings.kt
@@ -0,0 +1,86 @@
+package video.typetype.tv.data.device
+
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import video.typetype.tv.data.SettingItem
+import video.typetype.tv.data.SettingsGroup
+import video.typetype.tv.data.remote.TextProvider
+import video.typetype.tv.resources.R
+
+enum class Intro(val wire: String) { Full("full"), Short("short"), Off("off") }
+
+data class Performance(
+    val animatedAvatar: Boolean = true,
+    val videoPreviews: Boolean = true,
+    val smoothAnimations: Boolean = true,
+    val backdrop: Boolean = true,
+    val intro: Intro = Intro.Full,
+)
+
+// What a slow box can turn off to stay smooth. The choice belongs to the box, not to the account: a strong
+// television and a small stick signed in to the same account each keep their own.
+class PerformanceSettings(private val store: DeviceStore) {
+    private val state = MutableStateFlow(read())
+    val current: StateFlow<Performance> = state.asStateFlow()
+
+    // The section sits with the everyday ones, before the account and the server.
+    fun addTo(groups: List<SettingsGroup>, texts: TextProvider): List<SettingsGroup> {
+        val at = groups.indexOfFirst { it.id == BEFORE_GROUP }.takeIf { it >= 0 } ?: groups.size
+        return groups.take(at) + group(texts) + groups.drop(at)
+    }
+
+    // Returns false for a setting kept on the server.
+    fun update(id: String, value: String): Boolean {
+        when (id) {
+            in FLAGS -> store.putFlag(id, value.toBoolean())
+            INTRO -> store.putText(id, Intro.entries.firstOrNull { it.wire == value }?.wire ?: return false)
+            else -> return false
+        }
+        state.value = read()
+        return true
+    }
+
+    private fun group(texts: TextProvider): SettingsGroup {
+        val now = state.value
+        return SettingsGroup(
+            id = GROUP,
+            titleRes = R.string.settings_group_performance,
+            items = listOf(
+                SettingItem.Toggle(SMOOTH_ANIMATIONS, R.string.settings_smooth_animations, R.string.settings_smooth_animations_summary, now.smoothAnimations),
+                SettingItem.Toggle(VIDEO_PREVIEWS, R.string.settings_video_previews, R.string.settings_video_previews_summary, now.videoPreviews),
+                SettingItem.Toggle(BACKDROP, R.string.settings_backdrop, R.string.settings_backdrop_summary, now.backdrop),
+                SettingItem.Toggle(ANIMATED_AVATAR, R.string.settings_animated_avatar, R.string.settings_animated_avatar_summary, now.animatedAvatar),
+                SettingItem.Choice(
+                    id = INTRO,
+                    titleRes = R.string.settings_intro,
+                    options = listOf(R.string.settings_intro_full, R.string.settings_intro_short, R.string.settings_intro_off).map(texts::text),
+                    defaultIndex = now.intro.ordinal,
+                    wireValues = Intro.entries.map { it.wire },
+                    summaryRes = R.string.settings_intro_summary,
+                ),
+                SettingItem.Action(FORGET_DECODERS, R.string.settings_forget_decoders, R.string.settings_forget_decoders_summary),
+            ),
+        )
+    }
+
+    private fun read() = Performance(
+        animatedAvatar = store.flag(ANIMATED_AVATAR, true),
+        videoPreviews = store.flag(VIDEO_PREVIEWS, true),
+        smoothAnimations = store.flag(SMOOTH_ANIMATIONS, true),
+        backdrop = store.flag(BACKDROP, true),
+        intro = store.text(INTRO, Intro.Full.wire).let { wire -> Intro.entries.firstOrNull { it.wire == wire } ?: Intro.Full },
+    )
+
+    private companion object {
+        const val GROUP = "performance"
+        const val BEFORE_GROUP = "account"
+        const val ANIMATED_AVATAR = "animated-avatar"
+        const val VIDEO_PREVIEWS = "video-previews"
+        const val SMOOTH_ANIMATIONS = "smooth-animations"
+        const val BACKDROP = "backdrop"
+        const val INTRO = "intro"
+        const val FORGET_DECODERS = "forget-decoders"
+        val FLAGS = setOf(ANIMATED_AVATAR, VIDEO_PREVIEWS, SMOOTH_ANIMATIONS, BACKDROP)
+    }
+}
diff --git a/app/src/main/java/video/typetype/tv/data/dto/AuthDto.kt b/core/data/src/main/java/video/typetype/tv/data/dto/AuthDto.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/dto/AuthDto.kt
rename to core/data/src/main/java/video/typetype/tv/data/dto/AuthDto.kt
diff --git a/app/src/main/java/video/typetype/tv/data/dto/BulletCommentDto.kt b/core/data/src/main/java/video/typetype/tv/data/dto/BulletCommentDto.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/dto/BulletCommentDto.kt
rename to core/data/src/main/java/video/typetype/tv/data/dto/BulletCommentDto.kt
diff --git a/app/src/main/java/video/typetype/tv/data/dto/LibraryWriteDto.kt b/core/data/src/main/java/video/typetype/tv/data/dto/LibraryWriteDto.kt
similarity index 91%
rename from app/src/main/java/video/typetype/tv/data/dto/LibraryWriteDto.kt
rename to core/data/src/main/java/video/typetype/tv/data/dto/LibraryWriteDto.kt
index 13fd7f5..b8812be 100644
--- a/app/src/main/java/video/typetype/tv/data/dto/LibraryWriteDto.kt
+++ b/core/data/src/main/java/video/typetype/tv/data/dto/LibraryWriteDto.kt
@@ -61,6 +61,10 @@ data class PlaylistVideoRequest(
 @Serializable
 data class SavePlaylistRequest(val url: String)
 
+// The web sends only the address; `global` is for moderators and stays off.
+@Serializable
+data class BlockVideoRequest(val url: String)
+
 @Serializable
 data class BlockChannelRequest(
     val url: String,
diff --git a/core/data/src/main/java/video/typetype/tv/data/dto/LiveChatDto.kt b/core/data/src/main/java/video/typetype/tv/data/dto/LiveChatDto.kt
new file mode 100644
index 0000000..52e99b5
--- /dev/null
+++ b/core/data/src/main/java/video/typetype/tv/data/dto/LiveChatDto.kt
@@ -0,0 +1,11 @@
+package video.typetype.tv.data.dto
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class LiveChatMessageDto(
+    val id: String = "",
+    val text: String = "",
+    val authorName: String? = null,
+    val moderator: Boolean = false,
+)
diff --git a/app/src/main/java/video/typetype/tv/data/dto/PresenceDto.kt b/core/data/src/main/java/video/typetype/tv/data/dto/PresenceDto.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/dto/PresenceDto.kt
rename to core/data/src/main/java/video/typetype/tv/data/dto/PresenceDto.kt
diff --git a/app/src/main/java/video/typetype/tv/data/dto/SabrDto.kt b/core/data/src/main/java/video/typetype/tv/data/dto/SabrDto.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/dto/SabrDto.kt
rename to core/data/src/main/java/video/typetype/tv/data/dto/SabrDto.kt
diff --git a/app/src/main/java/video/typetype/tv/data/dto/StreamDto.kt b/core/data/src/main/java/video/typetype/tv/data/dto/StreamDto.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/dto/StreamDto.kt
rename to core/data/src/main/java/video/typetype/tv/data/dto/StreamDto.kt
diff --git a/app/src/main/java/video/typetype/tv/data/dto/VideoDto.kt b/core/data/src/main/java/video/typetype/tv/data/dto/VideoDto.kt
similarity index 96%
rename from app/src/main/java/video/typetype/tv/data/dto/VideoDto.kt
rename to core/data/src/main/java/video/typetype/tv/data/dto/VideoDto.kt
index 1dc4f3b..1e850c0 100644
--- a/app/src/main/java/video/typetype/tv/data/dto/VideoDto.kt
+++ b/core/data/src/main/java/video/typetype/tv/data/dto/VideoDto.kt
@@ -83,6 +83,7 @@ data class PlaylistDto(
 data class ChannelPageRequest(
     val url: String,
     val nextpage: String? = null,
+    val sort: String? = null,
 )
 
 @Serializable
@@ -186,6 +187,12 @@ data class SavedPlaylistDto(
     val streamCount: Long = 0,
 )
 
+@Serializable
+data class ChannelPlaylistsDto(
+    val playlists: List<PlaylistItemDto> = emptyList(),
+    val nextpage: String? = null,
+)
+
 @Serializable
 data class ChannelPodcastsDto(
     val podcasts: List<PlaylistItemDto> = emptyList(),
diff --git a/app/src/main/java/video/typetype/tv/data/net/ApiClient.kt b/core/data/src/main/java/video/typetype/tv/data/net/ApiClient.kt
similarity index 84%
rename from app/src/main/java/video/typetype/tv/data/net/ApiClient.kt
rename to core/data/src/main/java/video/typetype/tv/data/net/ApiClient.kt
index e406869..c592106 100644
--- a/app/src/main/java/video/typetype/tv/data/net/ApiClient.kt
+++ b/core/data/src/main/java/video/typetype/tv/data/net/ApiClient.kt
@@ -17,7 +17,6 @@ import okhttp3.RequestBody.Companion.toRequestBody
 import okhttp3.Response
 import java.io.IOException
 import javax.net.ssl.SSLException
-import kotlin.coroutines.resume
 import kotlin.coroutines.resumeWithException
 
 class ApiClient(
@@ -46,8 +45,9 @@ class ApiClient(
         path: String,
         strategy: DeserializationStrategy<T>,
         query: Map<String, String?> = emptyMap(),
+        anonymous: Boolean = false,
     ): T = withRetry {
-        checked(execute(Request.Builder().url(url(path, query)).get().build())).decode(json, strategy)
+        checked(execute(jsonRequest("GET", url(path, query), null, anonymous))).decode(json, strategy)
     }
 
     suspend fun <T> post(
@@ -62,8 +62,9 @@ class ApiClient(
         body: String?,
         strategy: DeserializationStrategy<T>,
         accepted: Set<Int>,
+        anonymous: Boolean = false,
     ): Pair<Int, T> {
-        val raw = execute(jsonRequest("POST", url(path), body))
+        val raw = execute(jsonRequest("POST", url(path), body, anonymous))
         if (raw.status !in accepted) throw ApiException(raw.toFailure(json))
         return raw.status to raw.decode(json, strategy)
     }
@@ -94,19 +95,21 @@ class ApiClient(
         } catch (failure: IOException) {
             throw ApiException(transportFailure(failure), failure)
         }
-        return withContext(Dispatchers.IO) {
-            response.use {
+        return try {
+            withContext(Dispatchers.IO) {
                 RawResponse(
-                    status = it.code,
+                    status = response.code,
                     body = try {
-                        it.body.string()
+                        response.body.string()
                     } catch (failure: IOException) {
                         throw ApiException(transportFailure(failure), failure)
                     },
-                    requestId = it.header(REQUEST_ID_HEADER),
-                    retryAfterMillis = it.header("Retry-After")?.toLongOrNull()?.times(1_000L),
+                    requestId = response.header(REQUEST_ID_HEADER),
+                    retryAfterMillis = response.header("Retry-After")?.toLongOrNull()?.times(1_000L),
                 )
             }
+        } finally {
+            response.close()
         }
     }
 
@@ -115,13 +118,15 @@ class ApiClient(
         return raw
     }
 
-    private fun jsonRequest(method: String, url: HttpUrl, body: String?): Request {
+    private fun jsonRequest(method: String, url: HttpUrl, body: String?, anonymous: Boolean = false): Request {
         val requestBody: RequestBody? = when {
             body != null -> body.toRequestBody(JSON_TYPE)
             method == "GET" || method == "DELETE" -> null
             else -> "".toRequestBody(JSON_TYPE)
         }
-        return Request.Builder().url(url).method(method, requestBody).build()
+        val request = Request.Builder().url(url).method(method, requestBody)
+        if (anonymous) request.tag(Anonymous::class.java, Anonymous)
+        return request.build()
     }
 
     companion object {
@@ -143,7 +148,7 @@ private suspend fun Call.await(): Response = suspendCancellableCoroutine { conti
         }
 
         override fun onResponse(call: Call, response: Response) {
-            if (continuation.isActive) continuation.resume(response) else response.close()
+            continuation.resume(response) { _, _, _ -> response.close() }
         }
     })
 }
diff --git a/app/src/main/java/video/typetype/tv/data/net/ApiFailure.kt b/core/data/src/main/java/video/typetype/tv/data/net/ApiFailure.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/net/ApiFailure.kt
rename to core/data/src/main/java/video/typetype/tv/data/net/ApiFailure.kt
diff --git a/app/src/main/java/video/typetype/tv/data/net/ApiJson.kt b/core/data/src/main/java/video/typetype/tv/data/net/ApiJson.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/net/ApiJson.kt
rename to core/data/src/main/java/video/typetype/tv/data/net/ApiJson.kt
diff --git a/app/src/main/java/video/typetype/tv/data/net/Connectivity.kt b/core/data/src/main/java/video/typetype/tv/data/net/Connectivity.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/net/Connectivity.kt
rename to core/data/src/main/java/video/typetype/tv/data/net/Connectivity.kt
diff --git a/app/src/main/java/video/typetype/tv/data/net/HttpClients.kt b/core/data/src/main/java/video/typetype/tv/data/net/HttpClients.kt
similarity index 92%
rename from app/src/main/java/video/typetype/tv/data/net/HttpClients.kt
rename to core/data/src/main/java/video/typetype/tv/data/net/HttpClients.kt
index 8c70a41..c66b01f 100644
--- a/app/src/main/java/video/typetype/tv/data/net/HttpClients.kt
+++ b/core/data/src/main/java/video/typetype/tv/data/net/HttpClients.kt
@@ -30,13 +30,17 @@ class AccessTokenInterceptor(
     override fun intercept(chain: Interceptor.Chain): Response {
         val request = chain.request()
         val token = tokens.current()
-        if (token == null || request.url.host != host || request.header("Authorization") != null) {
+        val anonymous = request.tag(Anonymous::class.java) != null
+        if (token == null || anonymous || request.url.host != host || request.header("Authorization") != null) {
             return chain.proceed(request)
         }
         return chain.proceed(request.newBuilder().header("Authorization", "Bearer $token").build())
     }
 }
 
+// Marks a request sent without the account, so the server can answer it from its shared cache.
+object Anonymous
+
 class RefreshAuthenticator(private val refresher: TokenRefresher) : Authenticator {
     override fun authenticate(route: Route?, response: Response): Request? {
         val failed = response.request.header("Authorization")?.removePrefix("Bearer ") ?: return null
diff --git a/app/src/main/java/video/typetype/tv/data/net/LazySecretStore.kt b/core/data/src/main/java/video/typetype/tv/data/net/LazySecretStore.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/net/LazySecretStore.kt
rename to core/data/src/main/java/video/typetype/tv/data/net/LazySecretStore.kt
diff --git a/app/src/main/java/video/typetype/tv/data/net/RawResponse.kt b/core/data/src/main/java/video/typetype/tv/data/net/RawResponse.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/net/RawResponse.kt
rename to core/data/src/main/java/video/typetype/tv/data/net/RawResponse.kt
diff --git a/app/src/main/java/video/typetype/tv/data/net/RefreshCookieJar.kt b/core/data/src/main/java/video/typetype/tv/data/net/RefreshCookieJar.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/net/RefreshCookieJar.kt
rename to core/data/src/main/java/video/typetype/tv/data/net/RefreshCookieJar.kt
diff --git a/app/src/main/java/video/typetype/tv/data/net/RetryPolicy.kt b/core/data/src/main/java/video/typetype/tv/data/net/RetryPolicy.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/net/RetryPolicy.kt
rename to core/data/src/main/java/video/typetype/tv/data/net/RetryPolicy.kt
diff --git a/app/src/main/java/video/typetype/tv/data/net/SecretStore.kt b/core/data/src/main/java/video/typetype/tv/data/net/SecretStore.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/net/SecretStore.kt
rename to core/data/src/main/java/video/typetype/tv/data/net/SecretStore.kt
diff --git a/core/data/src/main/java/video/typetype/tv/data/net/ServerWatch.kt b/core/data/src/main/java/video/typetype/tv/data/net/ServerWatch.kt
new file mode 100644
index 0000000..4295517
--- /dev/null
+++ b/core/data/src/main/java/video/typetype/tv/data/net/ServerWatch.kt
@@ -0,0 +1,67 @@
+package video.typetype.tv.data.net
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.async
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.selects.select
+import kotlinx.coroutines.withContext
+import okhttp3.HttpUrl
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import java.io.IOException
+import java.util.concurrent.TimeUnit
+
+class ServerWatch(
+    private val reachable: suspend () -> Boolean,
+    private val slowAfterMillis: Long = SLOW_AFTER_MILLIS,
+    private val probeEveryMillis: Long = PROBE_EVERY_MILLIS,
+) {
+    suspend fun <T> watch(block: suspend () -> T): T {
+        val context = currentCoroutineContext()
+        val jobs = SupervisorJob(context[Job])
+        val scope = CoroutineScope(context + jobs)
+        try {
+            val work = scope.async { block() }
+            val silence = scope.async {
+                delay(slowAfterMillis)
+                while (reachable()) delay(probeEveryMillis)
+            }
+            return select {
+                work.onAwait { it }
+                silence.onAwait {
+                    throw ApiException(ApiFailure(FailureCategory.Network, null, UNREACHABLE, "The server is not answering", null))
+                }
+            }
+        } finally {
+            jobs.cancel()
+        }
+    }
+
+    companion object {
+        const val UNREACHABLE = "server_unreachable"
+        private const val SLOW_AFTER_MILLIS = 5_000L
+        private const val PROBE_EVERY_MILLIS = 5_000L
+        private const val PROBE_TIMEOUT_SECONDS = 4L
+
+        fun health(apiBase: HttpUrl, client: OkHttpClient): ServerWatch {
+            val url = apiBase.resolve("health") ?: apiBase
+            val probe = client.newBuilder()
+                .callTimeout(PROBE_TIMEOUT_SECONDS, TimeUnit.SECONDS)
+                .retryOnConnectionFailure(false)
+                .build()
+            return ServerWatch({
+                withContext(Dispatchers.IO) {
+                    try {
+                        probe.newCall(Request.Builder().url(url).build()).execute().use { it.isSuccessful }
+                    } catch (_: IOException) {
+                        false
+                    }
+                }
+            })
+        }
+    }
+}
diff --git a/app/src/main/java/video/typetype/tv/data/net/TinkSecretStore.kt b/core/data/src/main/java/video/typetype/tv/data/net/TinkSecretStore.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/net/TinkSecretStore.kt
rename to core/data/src/main/java/video/typetype/tv/data/net/TinkSecretStore.kt
diff --git a/app/src/main/java/video/typetype/tv/data/net/tls/CertificateProbe.kt b/core/data/src/main/java/video/typetype/tv/data/net/tls/CertificateProbe.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/net/tls/CertificateProbe.kt
rename to core/data/src/main/java/video/typetype/tv/data/net/tls/CertificateProbe.kt
diff --git a/app/src/main/java/video/typetype/tv/data/net/tls/PinTrust.kt b/core/data/src/main/java/video/typetype/tv/data/net/tls/PinTrust.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/net/tls/PinTrust.kt
rename to core/data/src/main/java/video/typetype/tv/data/net/tls/PinTrust.kt
diff --git a/app/src/main/java/video/typetype/tv/data/net/tls/TlsPin.kt b/core/data/src/main/java/video/typetype/tv/data/net/tls/TlsPin.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/net/tls/TlsPin.kt
rename to core/data/src/main/java/video/typetype/tv/data/net/tls/TlsPin.kt
diff --git a/app/src/main/java/video/typetype/tv/data/remote/ContentFilter.kt b/core/data/src/main/java/video/typetype/tv/data/remote/ContentFilter.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/remote/ContentFilter.kt
rename to core/data/src/main/java/video/typetype/tv/data/remote/ContentFilter.kt
diff --git a/core/data/src/main/java/video/typetype/tv/data/remote/ContentSettings.kt b/core/data/src/main/java/video/typetype/tv/data/remote/ContentSettings.kt
new file mode 100644
index 0000000..2263258
--- /dev/null
+++ b/core/data/src/main/java/video/typetype/tv/data/remote/ContentSettings.kt
@@ -0,0 +1,75 @@
+package video.typetype.tv.data.remote
+
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonObjectBuilder
+import kotlinx.serialization.json.booleanOrNull
+import kotlinx.serialization.json.contentOrNull
+import kotlinx.serialization.json.intOrNull
+import kotlinx.serialization.json.jsonPrimitive
+import kotlinx.serialization.json.put
+import video.typetype.tv.data.ContentSource
+import video.typetype.tv.data.SettingItem
+import video.typetype.tv.data.SettingsGroup
+import video.typetype.tv.resources.R
+
+// What the app shows and where it starts. The server stores "hide" flags; the TV words them as "show" so a switch
+// that is on always means the thing is there.
+internal object ContentSettings {
+    private class Shown(val id: String, val key: String, val titleRes: Int, val summaryRes: Int)
+
+    private val shown = listOf(
+        Shown("show-continue", "hideContinueWatching", R.string.settings_show_continue, R.string.settings_show_continue_summary),
+        Shown("show-recommendations", "hideHomeRecommendations", R.string.settings_show_recommendations, R.string.settings_show_recommendations_summary),
+        Shown("show-related", "hideRelatedVideos", R.string.settings_show_related, R.string.settings_show_related_summary),
+        Shown("show-comments", "hideComments", R.string.settings_show_comments, R.string.settings_show_comments_summary),
+        Shown("show-shorts", "hideShorts", R.string.settings_show_shorts, R.string.settings_show_shorts_summary),
+    )
+
+    private val landings = listOf("home", "history", "favorites", "watch-later")
+    private val landingLabels = listOf(
+        R.string.settings_start_home,
+        R.string.settings_start_history,
+        R.string.settings_start_favorites,
+        R.string.settings_start_watch_later,
+    )
+
+    fun group(settings: JsonObject?, texts: TextProvider): SettingsGroup {
+        fun flag(key: String) = settings?.get(key)?.jsonPrimitive?.booleanOrNull ?: false
+        val landing = settings?.get("defaultLandingPage")?.jsonPrimitive?.contentOrNull
+        val service = settings?.get("defaultService")?.jsonPrimitive?.intOrNull
+        val sources = ContentSource.entries
+        val items = listOf(
+            SettingItem.Choice(
+                id = "landing",
+                titleRes = R.string.settings_start_page,
+                options = landingLabels.map(texts::text),
+                defaultIndex = landings.indexOf(landing).coerceAtLeast(0),
+                wireValues = landings,
+                summaryRes = R.string.settings_start_page_summary,
+            ),
+            SettingItem.Choice(
+                id = "service",
+                titleRes = R.string.settings_search_service,
+                options = sources.map { texts.text(it.labelRes) },
+                defaultIndex = sources.indexOfFirst { it.serviceId == service }.coerceAtLeast(0),
+                wireValues = sources.map { it.serviceId.toString() },
+                summaryRes = R.string.settings_search_service_summary,
+            ),
+        ) + shown.map { SettingItem.Toggle(it.id, it.titleRes, it.summaryRes, !flag(it.key)) }
+        return SettingsGroup("content", R.string.settings_group_content, items)
+    }
+
+    // Writes the change if it is a content setting; false lets the caller handle other settings.
+    fun write(patch: JsonObjectBuilder, id: String, value: String): Boolean {
+        shown.firstOrNull { it.id == id }?.let {
+            patch.put(it.key, !value.toBoolean())
+            return true
+        }
+        when (id) {
+            "landing" -> patch.put("defaultLandingPage", value)
+            "service" -> patch.put("defaultService", value.toInt())
+            else -> return false
+        }
+        return true
+    }
+}
diff --git a/app/src/main/java/video/typetype/tv/data/remote/DeArrowBranding.kt b/core/data/src/main/java/video/typetype/tv/data/remote/DeArrowBranding.kt
similarity index 98%
rename from app/src/main/java/video/typetype/tv/data/remote/DeArrowBranding.kt
rename to core/data/src/main/java/video/typetype/tv/data/remote/DeArrowBranding.kt
index 451565b..c899809 100644
--- a/app/src/main/java/video/typetype/tv/data/remote/DeArrowBranding.kt
+++ b/core/data/src/main/java/video/typetype/tv/data/remote/DeArrowBranding.kt
@@ -11,7 +11,7 @@ import video.typetype.tv.data.ContentSource
 import video.typetype.tv.data.InstanceUrls
 import video.typetype.tv.data.Video
 import video.typetype.tv.data.api.TypeTypeApi
-import video.typetype.tv.playback.VideoIds
+import video.typetype.tv.data.VideoIds
 
 data class BrandingPreferences(
     val enabled: Boolean = false,
diff --git a/app/src/main/java/video/typetype/tv/data/remote/Formatters.kt b/core/data/src/main/java/video/typetype/tv/data/remote/Formatters.kt
similarity index 87%
rename from app/src/main/java/video/typetype/tv/data/remote/Formatters.kt
rename to core/data/src/main/java/video/typetype/tv/data/remote/Formatters.kt
index cab96a9..8561048 100644
--- a/app/src/main/java/video/typetype/tv/data/remote/Formatters.kt
+++ b/core/data/src/main/java/video/typetype/tv/data/remote/Formatters.kt
@@ -16,6 +16,13 @@ object Formatters {
         return if (compact.isEmpty()) "" else "$compact views"
     }
 
+    // On a live stream the server's view count is the audience connected right now.
+    fun audience(count: Long, live: Boolean): String {
+        if (!live) return views(count)
+        val compact = compactCount(count)
+        return if (compact.isEmpty()) "" else "$compact watching"
+    }
+
     fun age(nowMillis: Long, thenMillis: Long): String {
         if (thenMillis <= 0L || thenMillis > nowMillis) return ""
         val minutes = (nowMillis - thenMillis) / 60_000L
diff --git a/app/src/main/java/video/typetype/tv/data/remote/HomeLoader.kt b/core/data/src/main/java/video/typetype/tv/data/remote/HomeLoader.kt
similarity index 99%
rename from app/src/main/java/video/typetype/tv/data/remote/HomeLoader.kt
rename to core/data/src/main/java/video/typetype/tv/data/remote/HomeLoader.kt
index 7911b06..1ec001f 100644
--- a/app/src/main/java/video/typetype/tv/data/remote/HomeLoader.kt
+++ b/core/data/src/main/java/video/typetype/tv/data/remote/HomeLoader.kt
@@ -4,7 +4,7 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Deferred
 import kotlinx.coroutines.async
 import kotlinx.coroutines.coroutineScope
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.ContentSource
 import video.typetype.tv.data.HomeContent
 import video.typetype.tv.data.Shelf
diff --git a/app/src/main/java/video/typetype/tv/data/remote/HtmlText.kt b/core/data/src/main/java/video/typetype/tv/data/remote/HtmlText.kt
similarity index 70%
rename from app/src/main/java/video/typetype/tv/data/remote/HtmlText.kt
rename to core/data/src/main/java/video/typetype/tv/data/remote/HtmlText.kt
index fd621a9..e2a7807 100644
--- a/app/src/main/java/video/typetype/tv/data/remote/HtmlText.kt
+++ b/core/data/src/main/java/video/typetype/tv/data/remote/HtmlText.kt
@@ -9,6 +9,13 @@ object HtmlText {
         "&#39;" to "'", "&nbsp;" to " ", "&hellip;" to "...",
     )
 
+    // YouTube titles can carry U+FFFC, the placeholder of an inline object the text API cannot show; on screen
+    // it draws as a boxed "OBJ". Zero-width marks would only shift the ellipsis.
+    private val INVISIBLE = Regex("[\\uFFFC\\u200B\\u200C\\u200D\\u2060\\uFEFF]")
+    private val SPACES = Regex("\\s+")
+
+    fun title(raw: String): String = SPACES.replace(INVISIBLE.replace(raw, ""), " ").trim()
+
     fun plain(html: String): String {
         var text = LINE_BREAK.replace(html, "\n")
         text = TAG.replace(text, "")
@@ -18,6 +25,7 @@ object HtmlText {
             if (value != null && value in 1..Character.MAX_CODE_POINT) String(Character.toChars(value)) else match.value
         }
         NAMED.forEach { (entity, replacement) -> text = text.replace(entity, replacement) }
+        text = INVISIBLE.replace(text, "")
         return text.replace(' ', ' ').lines().joinToString("\n") { it.trimEnd() }.trim()
     }
 }
diff --git a/core/data/src/main/java/video/typetype/tv/data/remote/LibraryMembership.kt b/core/data/src/main/java/video/typetype/tv/data/remote/LibraryMembership.kt
new file mode 100644
index 0000000..6463b45
--- /dev/null
+++ b/core/data/src/main/java/video/typetype/tv/data/remote/LibraryMembership.kt
@@ -0,0 +1,60 @@
+package video.typetype.tv.data.remote
+
+import kotlinx.coroutines.async
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import java.io.IOException
+
+// The server can only answer "is this video saved?" for favorites, so the detail page would download the
+// whole favorites, watch-later and subscription lists on every open. They are kept here for a short while and
+// patched by this device's own writes; changes made elsewhere show up once the snapshot expires.
+class LibraryMembership(
+    private val favorites: suspend () -> Set<String>,
+    private val watchLater: suspend () -> Set<String>,
+    private val subscriptions: suspend () -> Set<String>,
+    private val clock: () -> Long = System::currentTimeMillis,
+    private val ttlMillis: Long = TTL_MILLIS,
+) {
+    data class Snapshot(
+        val favorites: Set<String> = emptySet(),
+        val watchLater: Set<String> = emptySet(),
+        val subscriptions: Set<String> = emptySet(),
+    )
+
+    private val lock = Mutex()
+    private var stored: Snapshot? = null
+    private var storedAt = 0L
+
+    suspend fun current(): Snapshot = lock.withLock {
+        stored?.takeIf { clock() - storedAt <= ttlMillis }?.let { return it }
+        val loaded = coroutineScope {
+            val favorites = async { attempt(favorites) }
+            val watchLater = async { attempt(watchLater) }
+            val subscriptions = async { attempt(subscriptions) }
+            listOf(favorites.await(), watchLater.await(), subscriptions.await())
+        }
+        val snapshot = Snapshot(loaded[0].orEmpty(), loaded[1].orEmpty(), loaded[2].orEmpty())
+        // A list that failed to load is shown as empty this time but never kept.
+        if (loaded.all { it != null }) {
+            stored = snapshot
+            storedAt = clock()
+        }
+        snapshot
+    }
+
+    suspend fun update(change: (Snapshot) -> Snapshot) = lock.withLock {
+        stored = stored?.let(change)
+    }
+
+    private suspend fun attempt(load: suspend () -> Set<String>): Set<String>? =
+        try {
+            load()
+        } catch (_: IOException) {
+            null
+        }
+
+    private companion object {
+        const val TTL_MILLIS = 2 * 60_000L
+    }
+}
diff --git a/core/data/src/main/java/video/typetype/tv/data/remote/LiveChatSource.kt b/core/data/src/main/java/video/typetype/tv/data/remote/LiveChatSource.kt
new file mode 100644
index 0000000..8d7fa28
--- /dev/null
+++ b/core/data/src/main/java/video/typetype/tv/data/remote/LiveChatSource.kt
@@ -0,0 +1,72 @@
+package video.typetype.tv.data.remote
+
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+import kotlinx.serialization.SerializationException
+import video.typetype.tv.data.LiveChatEvent
+import video.typetype.tv.data.LiveChatMessage
+import video.typetype.tv.data.api.LiveChatApi
+import video.typetype.tv.data.api.LiveChatRefused
+import video.typetype.tv.data.dto.LiveChatMessageDto
+import video.typetype.tv.data.net.ApiJson
+import java.io.IOException
+
+// The server polls YouTube and pushes each batch as server-sent events. A dropped stream reconnects with
+// backoff; 422 means the video has no chat, so the source stops; 429 waits for the server's Retry-After.
+class LiveChatSource(
+    private val api: LiveChatApi,
+    private val pause: suspend (Long) -> Unit = { delay(it) },
+) {
+    fun events(videoUrl: String): Flow<LiveChatEvent> = flow {
+        var failures = 0
+        while (true) {
+            var wait: Long? = null
+            try {
+                api.events(videoUrl).collect { event ->
+                    when (event.name) {
+                        MESSAGE -> decode(event.data)?.let {
+                            failures = 0
+                            emit(LiveChatEvent.Message(it))
+                        }
+                        ERROR -> throw IOException("Live chat error: ${event.data}")
+                    }
+                }
+            } catch (refused: LiveChatRefused) {
+                if (refused.status == UNSUPPORTED) {
+                    emit(LiveChatEvent.Unavailable)
+                    return@flow
+                }
+                wait = refused.retryAfterSeconds?.times(MILLIS_PER_SECOND)
+            } catch (_: IOException) {
+                // A dropped stream or a server error event: reconnect below.
+            }
+            failures++
+            if (failures > MAX_FAILURES) {
+                emit(LiveChatEvent.Unavailable)
+                return@flow
+            }
+            pause(wait ?: BACKOFF_MILLIS[(failures - 1).coerceAtMost(BACKOFF_MILLIS.lastIndex)])
+        }
+    }
+
+    private fun decode(data: String): LiveChatMessage? = try {
+        val dto = ApiJson.instance.decodeFromString(LiveChatMessageDto.serializer(), data)
+        dto.takeIf { it.text.isNotBlank() }?.let {
+            LiveChatMessage(it.id, it.authorName.orEmpty().trim(), HtmlText.plain(it.text), it.moderator)
+        }
+    } catch (_: SerializationException) {
+        null
+    } catch (_: IllegalArgumentException) {
+        null
+    }
+
+    private companion object {
+        const val MESSAGE = "message"
+        const val ERROR = "error"
+        const val UNSUPPORTED = 422
+        const val MAX_FAILURES = 6
+        const val MILLIS_PER_SECOND = 1_000L
+        val BACKOFF_MILLIS = longArrayOf(1_000L, 2_000L, 4_000L, 8_000L, 15_000L, 30_000L)
+    }
+}
diff --git a/app/src/main/java/video/typetype/tv/data/remote/Mappers.kt b/core/data/src/main/java/video/typetype/tv/data/remote/Mappers.kt
similarity index 96%
rename from app/src/main/java/video/typetype/tv/data/remote/Mappers.kt
rename to core/data/src/main/java/video/typetype/tv/data/remote/Mappers.kt
index ec9c24d..f2a1e05 100644
--- a/app/src/main/java/video/typetype/tv/data/remote/Mappers.kt
+++ b/core/data/src/main/java/video/typetype/tv/data/remote/Mappers.kt
@@ -31,10 +31,10 @@ internal fun VideoItemDto.toVideo(now: Long, keepShorts: Boolean = false): Video
     if (url.isBlank() || title.isBlank() || (!keepShorts && (isShortFormContent || isShortUrl(url)))) return null
     return Video(
         id = url,
-        title = title,
+        title = HtmlText.title(title),
         channel = channelOf(uploaderName, uploaderUrl, uploaderAvatarUrl),
         durationSeconds = duration.coerceAtLeast(0L).toInt(),
-        views = Formatters.views(viewCount),
+        views = Formatters.audience(viewCount, isLive || streamType == "live_stream"),
         age = Formatters.age(now, if (uploaded > 0L) uploaded else publishedAt),
         genre = "",
         description = HtmlText.plain(shortDescription.orEmpty()),
@@ -49,7 +49,7 @@ internal fun LibraryVideoDto.toVideo(now: Long, resume: Boolean): Video? {
     val resumeSeconds = if (progress > 0L) progress else watchPosition / 1_000L
     return Video(
         id = url,
-        title = title,
+        title = HtmlText.title(title),
         channel = channelOf(channelName, channelUrl, channelAvatar),
         durationSeconds = duration.coerceAtLeast(0L).toInt(),
         views = Formatters.views(viewCount),
@@ -63,13 +63,13 @@ internal fun LibraryVideoDto.toVideo(now: Long, resume: Boolean): Video? {
 
 internal fun StreamDto.toVideo(url: String, now: Long): Video = Video(
     id = url,
-    title = title,
+    title = HtmlText.title(title),
     channel = channelOf(
         uploaderName, uploaderUrl, uploaderAvatarUrl,
         Formatters.compactCount(uploaderSubscriberCount),
     ),
     durationSeconds = duration.coerceAtLeast(0L).toInt(),
-    views = Formatters.views(viewCount),
+    views = Formatters.audience(viewCount, streamType == "live_stream"),
     age = Formatters.age(now, uploaded),
     genre = category,
     description = HtmlText.plain(description),
diff --git a/app/src/main/java/video/typetype/tv/data/remote/PublicPlaylistSource.kt b/core/data/src/main/java/video/typetype/tv/data/remote/PublicPlaylistSource.kt
similarity index 81%
rename from app/src/main/java/video/typetype/tv/data/remote/PublicPlaylistSource.kt
rename to core/data/src/main/java/video/typetype/tv/data/remote/PublicPlaylistSource.kt
index 1509208..6b7863a 100644
--- a/app/src/main/java/video/typetype/tv/data/remote/PublicPlaylistSource.kt
+++ b/core/data/src/main/java/video/typetype/tv/data/remote/PublicPlaylistSource.kt
@@ -1,6 +1,7 @@
 package video.typetype.tv.data.remote
 
 import video.typetype.tv.data.ChannelSummary
+import video.typetype.tv.data.ChannelPlaylists
 import video.typetype.tv.data.ContentSource
 import video.typetype.tv.data.PublicPlaylist
 import video.typetype.tv.data.PublicPlaylistPage
@@ -19,14 +20,17 @@ class PublicPlaylistSource(
     private val branding: DeArrowBranding,
     private val clock: () -> Long,
 ) {
-    suspend fun search(query: String, source: ContentSource, kind: SearchKind): SearchResults {
+    suspend fun search(query: String, source: ContentSource, kind: SearchKind, page: String? = null): SearchResults {
         val effective = kind.takeIf { it.supports(source) } ?: SearchKind.Videos
-        val response = api.search(query, source, effective.filterFor(source))
+        val response = api.search(query, source, effective.filterFor(source), page)
         val now = clock()
         return when (effective) {
-            SearchKind.Playlists -> SearchResults(playlists = response.playlists.mapNotNull { it.toPlaylist() })
-            SearchKind.Channels -> SearchResults(channels = response.channels.mapNotNull { it.toSummary() })
-            else -> SearchResults(videos = branding.apply(filter.allowed(response.items.mapNotNull { it.toVideo(now) })))
+            SearchKind.Playlists -> SearchResults(playlists = response.playlists.mapNotNull { it.toPlaylist() }, nextPage = response.nextpage)
+            SearchKind.Channels -> SearchResults(channels = response.channels.mapNotNull { it.toSummary() }, nextPage = response.nextpage)
+            else -> SearchResults(
+                videos = branding.apply(filter.allowed(response.items.mapNotNull { it.toVideo(now) })),
+                nextPage = response.nextpage,
+            )
         }
     }
 
@@ -38,6 +42,11 @@ class PublicPlaylistSource(
         return PublicPlaylistPage(playlist, videos, dto.nextpage)
     }
 
+    suspend fun channelPlaylists(channelUrl: String, cursor: String?): ChannelPlaylists {
+        val dto = api.channelPlaylists(channelUrl, cursor)
+        return ChannelPlaylists(dto.playlists.mapNotNull { it.toPlaylist() }, dto.nextpage)
+    }
+
     suspend fun podcasts(channelUrl: String): List<PublicPlaylist> =
         api.channelPodcasts(channelUrl).podcasts.mapNotNull { it.toPlaylist() }
 
diff --git a/core/data/src/main/java/video/typetype/tv/data/remote/RelatedFallback.kt b/core/data/src/main/java/video/typetype/tv/data/remote/RelatedFallback.kt
new file mode 100644
index 0000000..ebf953e
--- /dev/null
+++ b/core/data/src/main/java/video/typetype/tv/data/remote/RelatedFallback.kt
@@ -0,0 +1,22 @@
+package video.typetype.tv.data.remote
+
+import video.typetype.tv.data.Video
+import java.io.IOException
+
+// YouTube sends no related videos for some videos, and the server keeps that answer: the channel's latest videos
+// fill the row instead of leaving it empty. A channel that fails to load leaves the row empty.
+internal suspend fun relatedOrLatest(
+    videoId: String,
+    related: List<Video>,
+    channelUrl: String,
+    limit: Int,
+    latest: suspend (String) -> List<Video>,
+): List<Video> {
+    if (related.isNotEmpty() || channelUrl.isBlank()) return related.take(limit)
+    val videos = try {
+        latest(channelUrl)
+    } catch (_: IOException) {
+        return emptyList()
+    }
+    return videos.filter { it.id != videoId }.take(limit)
+}
diff --git a/app/src/main/java/video/typetype/tv/data/remote/RemoteContentRepository.kt b/core/data/src/main/java/video/typetype/tv/data/remote/RemoteContentRepository.kt
similarity index 71%
rename from app/src/main/java/video/typetype/tv/data/remote/RemoteContentRepository.kt
rename to core/data/src/main/java/video/typetype/tv/data/remote/RemoteContentRepository.kt
index a7ba038..4956c7e 100644
--- a/app/src/main/java/video/typetype/tv/data/remote/RemoteContentRepository.kt
+++ b/core/data/src/main/java/video/typetype/tv/data/remote/RemoteContentRepository.kt
@@ -1,15 +1,21 @@
 package video.typetype.tv.data.remote
 
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.ContentRepository
 import video.typetype.tv.data.HomeContent
 import video.typetype.tv.data.LibrarySection
 import video.typetype.tv.data.SettingsGroup
 import video.typetype.tv.data.Video
 import video.typetype.tv.data.BulletComment
+import video.typetype.tv.data.LiveChatEvent
+import kotlinx.coroutines.flow.Flow
 import video.typetype.tv.data.Channel
 import okhttp3.HttpUrl
+import java.net.URLEncoder
 import video.typetype.tv.data.ChannelPage
+import video.typetype.tv.data.ChannelTab
+import video.typetype.tv.data.ChannelSort
+import video.typetype.tv.data.ChannelPlaylists
 import video.typetype.tv.data.CommentsPage
 import video.typetype.tv.data.PlaylistChoice
 import video.typetype.tv.data.PublicPlaylist
@@ -26,8 +32,12 @@ import video.typetype.tv.data.VideoActivity
 import video.typetype.tv.data.api.LibraryWriteApi
 import video.typetype.tv.data.api.TypeTypeApi
 import video.typetype.tv.data.dto.BlockChannelRequest
+import video.typetype.tv.data.dto.BlockVideoRequest
 import video.typetype.tv.data.dto.StreamDto
 import video.typetype.tv.data.net.ApiException
+import video.typetype.tv.data.device.PerformanceSettings
+import video.typetype.tv.data.net.ServerWatch
+import video.typetype.tv.data.session.StreamAccess
 
 class RemoteContentRepository(
     private val api: TypeTypeApi,
@@ -36,12 +46,16 @@ class RemoteContentRepository(
     private val settingsSource: RemoteSettings,
     private val texts: TextProvider,
     private val presence: RemotePresence,
+    private val watch: ServerWatch,
+    private val userSettings: RemoteUserSettings,
+    access: StreamAccess,
+    private val performance: PerformanceSettings,
     private val clock: () -> Long = System::currentTimeMillis,
 ) : ContentRepository {
-    private val streams = TtlCache<String, StreamDto>(STREAM_TTL_MILLIS, STREAM_ENTRIES, clock)
+    private val streams = StreamStore({ url -> access.anonymousFirst { api.streamFor(url, it) } }, clock)
+    private val liveChat = LiveChatSource(api.liveChat)
     private val homeCache = TtlCache<String, HomeContent>(HOME_TTL_MILLIS, 1, clock)
     private val firstComments = TtlCache<String, CommentsPage>(STREAM_TTL_MILLIS, COMMENT_ENTRIES, clock)
-    private val userSettings = RemoteUserSettings(api, clock)
     private val filter = ContentFilter(api, userSettings, clock)
     private val branding = DeArrowBranding(api, apiBase, userSettings, clock)
     private val homeLoader = HomeLoader(api, filter, branding, texts, clock)
@@ -51,24 +65,33 @@ class RemoteContentRepository(
     override suspend fun home(): HomeContent {
         homeCache.fresh(HOME_KEY)?.let { return it }
         return try {
-            homeLoader.load().also { homeCache.put(HOME_KEY, it) }
+            watch.watch { homeLoader.load() }.also { homeCache.put(HOME_KEY, it) }
         } catch (failure: ApiException) {
             homeCache.stale(HOME_KEY) ?: throw failure
         }
     }
 
-    override suspend fun video(id: String): Video? = branding.apply(listOf(stream(id).toVideo(id, clock()))).single()
+    override suspend fun video(id: String): Video? = watch.watch { branding.apply(listOf(stream(id).toVideo(id, clock()))).single() }
+
+    override suspend fun prewarm(videoId: String) {
+        stream(videoId)
+    }
 
     override suspend fun related(id: String): List<Video> {
         if (filter.visibility().hideRelatedVideos) return emptyList()
         val now = clock()
-        return branding.apply(filter.allowed(stream(id).relatedStreams.mapNotNull { it.toVideo(now) }).take(RELATED_LIMIT))
+        val stream = stream(id)
+        val related = branding.apply(filter.allowed(stream.relatedStreams.mapNotNull { it.toVideo(now) }))
+        return relatedOrLatest(id, related, stream.uploaderUrl, RELATED_LIMIT) { url ->
+            channel(url, null, ChannelTab.Videos, null, null).videos
+        }
     }
 
-    override suspend fun search(query: String, source: ContentSource, kind: SearchKind): SearchResults =
-        playlists.search(query, source, kind)
+    override suspend fun search(query: String, source: ContentSource, kind: SearchKind, page: String?): SearchResults = watch.watch {
+        playlists.search(query, source, kind, page)
+    }
 
-    override suspend fun publicPlaylist(url: String, page: String?): PublicPlaylistPage = playlists.page(url, page)
+    override suspend fun publicPlaylist(url: String, page: String?): PublicPlaylistPage = watch.watch { playlists.page(url, page) }
 
     override suspend fun channelPodcasts(channelUrl: String): List<PublicPlaylist> =
         if (ContentSource.of(channelUrl) == ContentSource.YouTube) playlists.podcasts(channelUrl) else emptyList()
@@ -90,7 +113,7 @@ class RemoteContentRepository(
         return listOf(LibrarySection.History, LibrarySection.Favorites, LibrarySection.WatchLater) + playlists + saved
     }
 
-    override suspend fun library(section: LibrarySection): List<Video> {
+    override suspend fun library(section: LibrarySection): List<Video> = watch.watch {
         val now = clock()
         val items = when (section) {
             LibrarySection.History -> api.history(HISTORY_LIMIT).map { it.toVideo(now, resume = true) }
@@ -100,7 +123,7 @@ class RemoteContentRepository(
             is LibrarySection.Saved -> this.playlists.page(section.url, null).videos
             LibrarySection.Downloads -> emptyList()
         }
-        return items.filterNotNull().distinctBy { it.id }.take(LIBRARY_LIMIT)
+        items.filterNotNull().distinctBy { it.id }.take(LIBRARY_LIMIT)
     }
 
     override suspend fun searchIdeas(): List<String> =
@@ -110,7 +133,7 @@ class RemoteContentRepository(
             .distinct()
             .take(IDEA_LIMIT)
 
-    override suspend fun settings(): List<SettingsGroup> = settingsSource.groups(api)
+    override suspend fun settings(): List<SettingsGroup> = performance.addTo(watch.watch { settingsSource.groups(api) }, texts)
 
     override suspend fun startupPreferences(): StartupPreferences = userSettings.startupPreferences()
 
@@ -128,6 +151,18 @@ class RemoteContentRepository(
         afterBlockedChange()
     }
 
+    override suspend fun isVideoBlocked(url: String): Boolean = url in filter.blocked().videos
+
+    override suspend fun blockVideo(video: Video) {
+        library.blockVideo(BlockVideoRequest(video.id))
+        afterBlockedChange()
+    }
+
+    override suspend fun unblockVideo(url: String) {
+        library.unblockVideo(url)
+        afterBlockedChange()
+    }
+
     private fun afterBlockedChange() {
         filter.invalidate()
         homeCache.clear()
@@ -139,6 +174,7 @@ class RemoteContentRepository(
     }
 
     override suspend fun updateSetting(id: String, value: String) {
+        if (performance.update(id, value)) return
         settingsSource.update(api, id, value)
         userSettings.invalidate()
     }
@@ -157,8 +193,34 @@ class RemoteContentRepository(
         return api.commentReplies(videoUrl, repliesPage).toCommentsPage(clock())
     }
 
-    override suspend fun channel(url: String, page: String?): ChannelPage =
-        api.channelPage(url, page).toChannelPage(url, clock()).let { it.copy(videos = branding.apply(filter.allowed(it.videos))) }
+    override suspend fun channel(
+        url: String,
+        page: String?,
+        tab: ChannelTab,
+        sort: ChannelSort?,
+        query: String?,
+    ): ChannelPage = watch.watch {
+        val target = when {
+            tab == ChannelTab.Live -> liveTabUrl(url)
+            query != null -> searchUrl(url, query)
+            else -> url
+        }
+        api.channelPage(target, page, sort?.wire.takeIf { query == null }).toChannelPage(url, clock())
+            .let { it.copy(videos = branding.apply(filter.allowed(it.videos))) }
+    }
+
+    override suspend fun channelPlaylists(url: String, page: String?): ChannelPlaylists = watch.watch {
+        playlists.channelPlaylists(url, page)
+    }
+
+    // The live tab is the channel's address with /streams, as the web asks for it.
+    private fun liveTabUrl(url: String): String = url.substringBefore('?').substringBefore('#').trimEnd('/') + "/streams"
+
+    // A search inside the channel is the channel's address with /search and the query, as the web asks for it.
+    private fun searchUrl(url: String, query: String): String =
+        url.substringBefore('?').substringBefore('#').trimEnd('/') + "/search?query=" + URLEncoder.encode(query, Charsets.UTF_8.name())
+
+    override fun liveChat(videoUrl: String): Flow<LiveChatEvent> = liveChat.events(videoUrl)
 
     override suspend fun bulletComments(videoUrl: String): List<BulletComment> {
         if (ContentSource.of(videoUrl) == ContentSource.YouTube) return emptyList()
@@ -178,6 +240,7 @@ class RemoteContentRepository(
             ),
             liveManifest = stream.liveManifest(),
             storyboard = stream.toStoryboard(),
+            stream = stream,
         )
     }
 
@@ -203,17 +266,13 @@ class RemoteContentRepository(
 
     override fun reportPresence(report: PresenceReport) = presence.report(report)
 
-    private suspend fun stream(url: String): StreamDto {
-        streams.fresh(url)?.let { return it }
-        return api.streamFor(url).also { streams.put(url, it) }
-    }
+    private suspend fun stream(url: String): StreamDto = streams.get(url)
 
     private companion object {
         const val HOME_KEY = "home"
         const val MILLIS_PER_SECOND = 1_000L
         const val STREAM_TTL_MILLIS = 5 * 60_000L
         const val HOME_TTL_MILLIS = 2 * 60_000L
-        const val STREAM_ENTRIES = 24
         const val COMMENT_ENTRIES = 8
         const val HISTORY_LIMIT = 120
         const val LIBRARY_LIMIT = 240
diff --git a/app/src/main/java/video/typetype/tv/data/remote/RemotePresence.kt b/core/data/src/main/java/video/typetype/tv/data/remote/RemotePresence.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/remote/RemotePresence.kt
rename to core/data/src/main/java/video/typetype/tv/data/remote/RemotePresence.kt
diff --git a/app/src/main/java/video/typetype/tv/data/remote/RemoteSettings.kt b/core/data/src/main/java/video/typetype/tv/data/remote/RemoteSettings.kt
similarity index 89%
rename from app/src/main/java/video/typetype/tv/data/remote/RemoteSettings.kt
rename to core/data/src/main/java/video/typetype/tv/data/remote/RemoteSettings.kt
index 17df6ed..e62a80e 100644
--- a/app/src/main/java/video/typetype/tv/data/remote/RemoteSettings.kt
+++ b/core/data/src/main/java/video/typetype/tv/data/remote/RemoteSettings.kt
@@ -8,7 +8,7 @@ import kotlinx.serialization.json.doubleOrNull
 import kotlinx.serialization.json.jsonPrimitive
 import kotlinx.serialization.json.put
 import okhttp3.HttpUrl
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.BlockedChannel
 import video.typetype.tv.data.SettingActions
 import video.typetype.tv.data.SettingItem
@@ -31,11 +31,13 @@ class RemoteSettings(
         val account = runCatching { api.account() }.getOrNull()
         val settings = runCatching { api.settings() }.getOrNull()
         val unread = runCatching { api.unreadNotifications() }.getOrNull()?.takeIf { it.available }?.unreadCount
+        // The groups used every day come first; the account and the server are visited rarely.
         return listOf(
-            accountGroup(profile?.role, account?.name ?: profile?.publicUsername, account?.email, unread),
-            instanceGroup(),
             playbackGroup(settings),
+            ContentSettings.group(settings, texts),
             blockedGroup(runCatching { api.blockedChannels() }.getOrNull()),
+            accountGroup(profile?.role, account?.name ?: profile?.publicUsername, account?.email, unread),
+            instanceGroup(),
             SettingsGroup(
                 id = "about",
                 titleRes = R.string.settings_group_about,
@@ -76,7 +78,6 @@ class RemoteSettings(
             SettingItem.Info("instance-name", R.string.settings_instance_name, instance.name),
             SettingItem.Info("instance-address", R.string.settings_instance_address, apiBase.host),
             SettingItem.Info("instance-version", R.string.settings_instance_version, instance.version),
-            SettingItem.Info("instance-api", R.string.settings_instance_api, instance.apiVersion.toString()),
             *certificateItems(),
             SettingItem.Action("change-instance", R.string.settings_change_instance, R.string.settings_change_instance_summary),
         ),
@@ -84,7 +85,7 @@ class RemoteSettings(
 
     suspend fun update(api: TypeTypeApi, id: String, value: String) {
         val patch = buildJsonObject {
-            when (id) {
+            if (!ContentSettings.write(this, id, value)) when (id) {
                 "quality" -> put("defaultQuality", value)
                 "speed" -> put("defaultPlaybackSpeed", value.toDouble())
                 "autoplay" -> put("autoplay", value.toBoolean())
@@ -115,9 +116,16 @@ class RemoteSettings(
             SettingItem.Choice(
                 id = "quality",
                 titleRes = R.string.settings_default_quality,
-                options = qualities.map { if (it == "auto") texts.text(R.string.settings_quality_auto) else it },
+                options = qualities.map {
+                    when (it) {
+                        "auto" -> texts.text(R.string.settings_quality_auto)
+                        "2160p" -> texts.text(R.string.settings_quality_4k)
+                        else -> it
+                    }
+                },
                 defaultIndex = qualities.indexOf(quality),
                 wireValues = qualities,
+                summaryRes = R.string.settings_default_quality_summary,
             ),
             SettingItem.Choice(
                 id = "speed",
@@ -125,6 +133,7 @@ class RemoteSettings(
                 options = SPEED_VALUES.map { "${it}x".replace(".0x", "x") },
                 defaultIndex = SPEED_VALUES.indices.minByOrNull { abs(SPEED_VALUES[it] - speed) } ?: 1,
                 wireValues = SPEED_VALUES.map { it.toString() },
+                summaryRes = R.string.settings_playback_speed_summary,
             ),
             SettingItem.Toggle("autoplay", R.string.settings_autoplay, R.string.settings_autoplay_summary, flag("autoplay", true)),
             SettingItem.Toggle("captions", R.string.settings_captions, R.string.settings_captions_summary, flag("subtitlesEnabled", false)),
@@ -135,6 +144,7 @@ class RemoteSettings(
                     .map { texts.text(it) },
                 defaultIndex = SPONSOR_VALUES.indexOf(sponsorMode).coerceAtLeast(0),
                 wireValues = SPONSOR_VALUES,
+                summaryRes = R.string.settings_sponsorblock_summary,
             ),
             SettingItem.Toggle("watch-history", R.string.settings_watch_history, R.string.settings_watch_history_summary, !flag("disableWatchHistory", false)),
         )
@@ -142,7 +152,7 @@ class RemoteSettings(
     }
 
     private companion object {
-        val QUALITY_VALUES = listOf("auto", "1080p", "720p", "480p", "360p")
+        val QUALITY_VALUES = listOf("auto", "2160p", "1440p", "1080p", "720p", "480p", "360p")
         val SPEED_VALUES = listOf(0.75, 1.0, 1.25, 1.5, 2.0)
         val SPONSOR_VALUES = listOf("auto_skip", "mark_only", "disabled")
         const val CERT_PREVIEW = 23
diff --git a/app/src/main/java/video/typetype/tv/data/remote/RemoteUserSettings.kt b/core/data/src/main/java/video/typetype/tv/data/remote/RemoteUserSettings.kt
similarity index 98%
rename from app/src/main/java/video/typetype/tv/data/remote/RemoteUserSettings.kt
rename to core/data/src/main/java/video/typetype/tv/data/remote/RemoteUserSettings.kt
index 0b4f061..72eb686 100644
--- a/app/src/main/java/video/typetype/tv/data/remote/RemoteUserSettings.kt
+++ b/core/data/src/main/java/video/typetype/tv/data/remote/RemoteUserSettings.kt
@@ -117,6 +117,8 @@ class RemoteUserSettings(
 
     suspend fun historyDisabled(): Boolean = flag(load(), "disableWatchHistory") ?: false
 
+    suspend fun allowListOnly(): Boolean = load()?.let { text(it, "accessMode") } == ALLOW_LIST
+
     suspend fun playbackPreferences(): PlaybackPreferences {
         val settings = load()
         return PlaybackPreferences(
@@ -153,5 +155,6 @@ class RemoteUserSettings(
         const val TTL_MILLIS = 60_000L
         const val AUTO_SKIP = "auto_skip"
         const val ORIGINAL = "original"
+        const val ALLOW_LIST = "allow_list"
     }
 }
diff --git a/app/src/main/java/video/typetype/tv/data/remote/RemoteVideoActivity.kt b/core/data/src/main/java/video/typetype/tv/data/remote/RemoteVideoActivity.kt
similarity index 83%
rename from app/src/main/java/video/typetype/tv/data/remote/RemoteVideoActivity.kt
rename to core/data/src/main/java/video/typetype/tv/data/remote/RemoteVideoActivity.kt
index 33c4be5..978dbe5 100644
--- a/app/src/main/java/video/typetype/tv/data/remote/RemoteVideoActivity.kt
+++ b/core/data/src/main/java/video/typetype/tv/data/remote/RemoteVideoActivity.kt
@@ -26,22 +26,24 @@ class RemoteVideoActivity(
     private val onLibraryChanged: () -> Unit,
 ) : VideoActivityRepository {
     private val writes = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+    private val membership = LibraryMembership(
+        favorites = { api.favorites().mapTo(HashSet()) { it.link } },
+        watchLater = { api.watchLater().mapTo(HashSet()) { it.link } },
+        subscriptions = { library.subscriptions().mapTo(HashSet()) { it.channelUrl } },
+    )
 
     override suspend fun activity(video: Video): VideoActivity = coroutineScope {
-        val favorites = async { runCatching { api.favorites() }.getOrDefault(emptyList()) }
-        val watchLater = async { runCatching { api.watchLater() }.getOrDefault(emptyList()) }
-        val subscriptions = async { runCatching { library.subscriptions() }.getOrDefault(emptyList()) }
         val progress = async { runCatching { library.progress(video.id) }.getOrNull() }
+        val saved = membership.current()
         VideoActivity(
-            watchLater = watchLater.await().any { it.link == video.id },
-            favorite = favorites.await().any { it.link == video.id },
-            subscribed = video.channel.url.isNotBlank() && subscriptions.await().any { it.channelUrl == video.channel.url },
+            watchLater = video.id in saved.watchLater,
+            favorite = video.id in saved.favorites,
+            subscribed = video.channel.url.isNotBlank() && video.channel.url in saved.subscriptions,
             resumePositionMs = progress.await()?.position ?: 0L,
         )
     }
 
-    override suspend fun isSubscribed(channelUrl: String): Boolean =
-        runCatching { library.subscriptions() }.getOrDefault(emptyList()).any { it.channelUrl == channelUrl }
+    override suspend fun isSubscribed(channelUrl: String): Boolean = channelUrl in membership.current().subscriptions
 
     override suspend fun playlists(video: Video): List<PlaylistChoice> = coroutineScope {
         api.playlists()
@@ -89,11 +91,13 @@ class RemoteVideoActivity(
         } else {
             library.removeWatchLater(video.id)
         }
+        membership.update { it.copy(watchLater = it.watchLater.toggled(video.id, enabled)) }
         onLibraryChanged()
     }
 
     override suspend fun setFavorite(video: Video, enabled: Boolean) {
         if (enabled) library.addFavorite(video.id) else library.removeFavorite(video.id)
+        membership.update { it.copy(favorites = it.favorites.toggled(video.id, enabled)) }
         onLibraryChanged()
     }
 
@@ -103,6 +107,7 @@ class RemoteVideoActivity(
         } else {
             library.unsubscribe(channel.url)
         }
+        membership.update { it.copy(subscriptions = it.subscriptions.toggled(channel.url, enabled)) }
         onLibraryChanged()
     }
 
@@ -122,6 +127,8 @@ class RemoteVideoActivity(
         }
     }
 
+    private fun Set<String>.toggled(value: String, enabled: Boolean): Set<String> = if (enabled) this + value else this - value
+
     private fun historyRequest(video: Video, positionMs: Long) = HistoryRequest(
         url = video.id,
         title = video.title,
diff --git a/core/data/src/main/java/video/typetype/tv/data/remote/StreamStore.kt b/core/data/src/main/java/video/typetype/tv/data/remote/StreamStore.kt
new file mode 100644
index 0000000..d4d4c61
--- /dev/null
+++ b/core/data/src/main/java/video/typetype/tv/data/remote/StreamStore.kt
@@ -0,0 +1,38 @@
+package video.typetype.tv.data.remote
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.async
+import video.typetype.tv.data.dto.StreamDto
+
+class StreamStore(
+    private val load: suspend (String) -> StreamDto,
+    clock: () -> Long = System::currentTimeMillis,
+    private val scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.IO),
+) {
+    private val cache = TtlCache<String, StreamDto>(TTL_MILLIS, ENTRIES, clock)
+    private val inFlight = HashMap<String, Deferred<StreamDto>>()
+
+    // A load outlives the caller that started it: a prewarm left by the focus still fills the cache
+    // for the detail page or the player that asks for the same video next.
+    suspend fun get(url: String): StreamDto {
+        cache.fresh(url)?.let { return it }
+        return shared(url).await()
+    }
+
+    private fun shared(url: String): Deferred<StreamDto> = synchronized(inFlight) {
+        inFlight[url] ?: scope.async { load(url).also { cache.put(url, it) } }.also { pending ->
+            inFlight[url] = pending
+            pending.invokeOnCompletion {
+                synchronized(inFlight) { if (inFlight[url] === pending) inFlight.remove(url) }
+            }
+        }
+    }
+
+    private companion object {
+        const val TTL_MILLIS = 5 * 60_000L
+        const val ENTRIES = 12
+    }
+}
diff --git a/app/src/main/java/video/typetype/tv/data/remote/TextProvider.kt b/core/data/src/main/java/video/typetype/tv/data/remote/TextProvider.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/remote/TextProvider.kt
rename to core/data/src/main/java/video/typetype/tv/data/remote/TextProvider.kt
diff --git a/app/src/main/java/video/typetype/tv/data/remote/TtlCache.kt b/core/data/src/main/java/video/typetype/tv/data/remote/TtlCache.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/remote/TtlCache.kt
rename to core/data/src/main/java/video/typetype/tv/data/remote/TtlCache.kt
diff --git a/app/src/main/java/video/typetype/tv/data/session/DeviceProfileStore.kt b/core/data/src/main/java/video/typetype/tv/data/session/DeviceProfileStore.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/session/DeviceProfileStore.kt
rename to core/data/src/main/java/video/typetype/tv/data/session/DeviceProfileStore.kt
diff --git a/app/src/main/java/video/typetype/tv/data/session/InstanceDiscovery.kt b/core/data/src/main/java/video/typetype/tv/data/session/InstanceDiscovery.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/data/session/InstanceDiscovery.kt
rename to core/data/src/main/java/video/typetype/tv/data/session/InstanceDiscovery.kt
diff --git a/core/data/src/main/java/video/typetype/tv/data/session/ProfileCache.kt b/core/data/src/main/java/video/typetype/tv/data/session/ProfileCache.kt
new file mode 100644
index 0000000..3af4e00
--- /dev/null
+++ b/core/data/src/main/java/video/typetype/tv/data/session/ProfileCache.kt
@@ -0,0 +1,23 @@
+package video.typetype.tv.data.session
+
+import video.typetype.tv.data.dto.UserProfileDto
+import video.typetype.tv.data.net.ApiJson
+import video.typetype.tv.data.net.SecretStore
+
+class ProfileCache(private val store: SecretStore) {
+    fun get(): UserProfileDto? = store.get(KEY)?.let { raw ->
+        runCatching { ApiJson.instance.decodeFromString(UserProfileDto.serializer(), raw) }.getOrNull()
+    }
+
+    fun put(profile: UserProfileDto) {
+        store.put(KEY, ApiJson.instance.encodeToString(UserProfileDto.serializer(), profile))
+    }
+
+    fun clear() {
+        store.remove(KEY)
+    }
+
+    private companion object {
+        const val KEY = "profile"
+    }
+}
diff --git a/core/data/src/main/java/video/typetype/tv/data/session/SessionCheck.kt b/core/data/src/main/java/video/typetype/tv/data/session/SessionCheck.kt
new file mode 100644
index 0000000..50a7eed
--- /dev/null
+++ b/core/data/src/main/java/video/typetype/tv/data/session/SessionCheck.kt
@@ -0,0 +1,30 @@
+package video.typetype.tv.data.session
+
+import video.typetype.tv.data.dto.UserProfileDto
+import video.typetype.tv.data.net.ApiException
+import video.typetype.tv.data.net.FailureCategory
+import java.io.IOException
+
+sealed interface SessionCheck {
+    data class Valid(val profile: UserProfileDto) : SessionCheck
+
+    data object Rejected : SessionCheck
+
+    data object Unknown : SessionCheck
+
+    companion object {
+        suspend fun of(backend: Backend): SessionCheck = try {
+            Valid(backend.watch.watch { backend.api.me() })
+        } catch (failure: ApiException) {
+            if (failure.failure.category == FailureCategory.Unauthorized) Rejected else Unknown
+        } catch (_: IOException) {
+            Unknown
+        }
+
+        fun retryDelayMillis(attempt: Int): Long =
+            (FIRST_RETRY_MILLIS shl (attempt - 1).coerceIn(0, 4)).coerceAtMost(MAX_RETRY_MILLIS)
+
+        private const val FIRST_RETRY_MILLIS = 2_000L
+        private const val MAX_RETRY_MILLIS = 30_000L
+    }
+}
diff --git a/app/src/main/java/video/typetype/tv/data/session/SessionManager.kt b/core/data/src/main/java/video/typetype/tv/data/session/SessionManager.kt
similarity index 71%
rename from app/src/main/java/video/typetype/tv/data/session/SessionManager.kt
rename to core/data/src/main/java/video/typetype/tv/data/session/SessionManager.kt
index e137ffa..5e67161 100644
--- a/app/src/main/java/video/typetype/tv/data/session/SessionManager.kt
+++ b/core/data/src/main/java/video/typetype/tv/data/session/SessionManager.kt
@@ -19,10 +19,10 @@ import video.typetype.tv.data.net.AccessTokens
 import video.typetype.tv.data.net.ApiClient
 import video.typetype.tv.data.net.ApiException
 import video.typetype.tv.data.net.ApiJson
-import video.typetype.tv.data.net.FailureCategory
 import video.typetype.tv.data.net.HttpClients
 import video.typetype.tv.data.net.RefreshCookieJar
 import video.typetype.tv.data.net.SecretStore
+import video.typetype.tv.data.net.ServerWatch
 import video.typetype.tv.data.net.tls.CertificateInfo
 import video.typetype.tv.data.net.tls.CertificateProbe
 import video.typetype.tv.data.net.tls.PinTrust
@@ -30,7 +30,9 @@ import video.typetype.tv.data.net.tls.TlsPin
 import video.typetype.tv.data.net.TokenRefresher
 import java.io.IOException
 import java.util.concurrent.atomic.AtomicReference
+import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeoutOrNull
 import kotlinx.coroutines.Dispatchers
 import java.util.concurrent.atomic.AtomicBoolean
 
@@ -42,6 +44,8 @@ class SessionManager(private val store: SecretStore) : AccessTokens, TokenRefres
     private val token = AtomicReference<String?>(null)
     private val tokenLoaded = AtomicBoolean(false)
     private val refreshLock = Any()
+    private val profiles = ProfileCache(store)
+    private val retryNow = Channel<Unit>(Channel.CONFLATED)
     private val mutableState = MutableStateFlow<SessionState>(SessionState.Starting)
     private var backend: Backend? = null
 
@@ -70,20 +74,60 @@ class SessionManager(private val store: SecretStore) : AccessTokens, TokenRefres
             mutableState.value = SessionState.SignedOut(built)
             return
         }
-        try {
-            mutableState.value = SessionState.SignedIn(built, built.api.me())
-        } catch (failure: ApiException) {
-            val reason = if (failure.failure.category == FailureCategory.Unauthorized) {
-                SignOutReason.Expired
-            } else {
-                SignOutReason.Unreachable
+        val cached = profiles.get()
+        if (cached == null) {
+            reconnect(built)
+            return
+        }
+        mutableState.value = SessionState.SignedIn(built, cached)
+        val check = SessionCheck.of(built)
+        if ((state.value as? SessionState.SignedIn)?.backend !== built) return
+        when (check) {
+            is SessionCheck.Valid -> {
+                profiles.put(check.profile)
+                mutableState.value = SessionState.SignedIn(built, check.profile)
+            }
+            SessionCheck.Rejected -> expire()
+            SessionCheck.Unknown -> Unit
+        }
+    }
+
+    private suspend fun reconnect(built: Backend) {
+        var attempt = 0
+        while (backend === built && token.get() != null) {
+            mutableState.value = SessionState.Reconnecting(built, attempt)
+            val check = SessionCheck.of(built)
+            if (backend !== built) return
+            when (check) {
+                is SessionCheck.Valid -> {
+                    profiles.put(check.profile)
+                    mutableState.value = SessionState.SignedIn(built, check.profile)
+                    return
+                }
+                SessionCheck.Rejected -> {
+                    expire()
+                    return
+                }
+                SessionCheck.Unknown -> {
+                    attempt++
+                    mutableState.value = SessionState.Reconnecting(built, attempt)
+                    withTimeoutOrNull(SessionCheck.retryDelayMillis(attempt)) { retryNow.receive() }
+                }
             }
-            mutableState.value = SessionState.SignedOut(built, reason)
         }
     }
 
+    fun retryConnection() {
+        retryNow.trySend(Unit)
+    }
+
     suspend fun configure(origin: String): DiscoveryResult {
         val result = discovery.discover(origin)
+        val changing = mutableState.value as? SessionState.ChangingInstance
+        if (result is DiscoveryResult.Compatible && changing != null && store.get(KEY_API_BASE) == result.apiBase.toString()) {
+            mutableState.value = changing.previous
+            return result
+        }
         if (result is DiscoveryResult.Compatible) {
             if (store.get(KEY_API_BASE) != result.apiBase.toString()) clearCredentials()
             store.put(KEY_API_BASE, result.apiBase.toString())
@@ -136,6 +180,17 @@ class SessionManager(private val store: SecretStore) : AccessTokens, TokenRefres
         mutableState.value = SessionState.SignedOut(current)
     }
 
+    // Opens the setup screen without forgetting the current server: cancelling returns to it as it was.
+    fun startInstanceChange() {
+        val current = mutableState.value
+        if (current !is SessionState.ChangingInstance) mutableState.value = SessionState.ChangingInstance(current)
+    }
+
+    fun cancelInstanceChange() {
+        val changing = mutableState.value as? SessionState.ChangingInstance ?: return
+        mutableState.value = changing.previous
+    }
+
     suspend fun changeInstance() {
         clearCredentials()
         store.remove(KEY_API_BASE)
@@ -152,15 +207,17 @@ class SessionManager(private val store: SecretStore) : AccessTokens, TokenRefres
             .url(apiBase.resolve("auth/refresh") ?: return null)
             .post("{}".toRequestBody(JSON))
             .build()
+        var rejected = false
         val fresh = try {
             plainHttp.newCall(request).execute().use { response ->
+                rejected = response.code == 401 || response.code == 403
                 if (!response.isSuccessful) return@use null
                 ApiJson.instance.decodeFromString(SessionResponse.serializer(), response.body.string()).accessToken
             }
         } catch (_: IOException) {
             null
         }
-        if (fresh != null) storeToken(fresh) else expire()
+        if (fresh != null) storeToken(fresh) else if (rejected) expire()
         fresh
     }
 
@@ -168,7 +225,9 @@ class SessionManager(private val store: SecretStore) : AccessTokens, TokenRefres
         val current = backend ?: error("Instance not configured")
         val fresh = obtain(current)
         storeToken(fresh)
-        mutableState.value = SessionState.SignedIn(current, current.api.me())
+        val profile = current.api.me()
+        profiles.put(profile)
+        mutableState.value = SessionState.SignedIn(current, profile)
     }
 
     private fun build(apiBase: HttpUrl, instance: InstanceDto): Backend {
@@ -182,6 +241,7 @@ class SessionManager(private val store: SecretStore) : AccessTokens, TokenRefres
             presence = PresenceApi(ApiClient(apiBase, authed)),
             sabr = SabrApi(ApiClient(apiBase, authed)),
             mediaHttp = HttpClients.media(apiBase.host, this, this, pinTrust),
+            watch = ServerWatch.health(apiBase, plainHttp),
         )
         backend = built
         return built
@@ -199,12 +259,14 @@ class SessionManager(private val store: SecretStore) : AccessTokens, TokenRefres
     private fun expire() {
         token.set(null)
         store.remove(KEY_ACCESS)
+        profiles.clear()
         backend?.let { mutableState.value = SessionState.SignedOut(it, SignOutReason.Expired) }
     }
 
     private fun clearCredentials() {
         token.set(null)
         store.remove(KEY_ACCESS)
+        profiles.clear()
         cookieJar.clear()
     }
 
diff --git a/app/src/main/java/video/typetype/tv/data/session/SessionState.kt b/core/data/src/main/java/video/typetype/tv/data/session/SessionState.kt
similarity index 74%
rename from app/src/main/java/video/typetype/tv/data/session/SessionState.kt
rename to core/data/src/main/java/video/typetype/tv/data/session/SessionState.kt
index 93db74e..54613cd 100644
--- a/app/src/main/java/video/typetype/tv/data/session/SessionState.kt
+++ b/core/data/src/main/java/video/typetype/tv/data/session/SessionState.kt
@@ -7,6 +7,7 @@ import video.typetype.tv.data.api.SabrApi
 import video.typetype.tv.data.api.TypeTypeApi
 import video.typetype.tv.data.dto.InstanceDto
 import video.typetype.tv.data.dto.UserProfileDto
+import video.typetype.tv.data.net.ServerWatch
 import okhttp3.HttpUrl
 import okhttp3.OkHttpClient
 
@@ -19,6 +20,7 @@ class Backend(
     val presence: PresenceApi,
     val sabr: SabrApi,
     val mediaHttp: OkHttpClient,
+    val watch: ServerWatch,
 )
 
 sealed interface SessionState {
@@ -26,6 +28,11 @@ sealed interface SessionState {
 
     data object Unconfigured : SessionState
 
+    // The setup screen is open over a working session: nothing is forgotten until another server is connected.
+    data class ChangingInstance(val previous: SessionState) : SessionState
+
+    data class Reconnecting(val backend: Backend, val failedAttempts: Int) : SessionState
+
     data class SignedOut(val backend: Backend, val notice: SignOutReason? = null) : SessionState
 
     data class SignedIn(val backend: Backend, val profile: UserProfileDto) : SessionState
@@ -33,5 +40,4 @@ sealed interface SessionState {
 
 enum class SignOutReason {
     Expired,
-    Unreachable,
 }
diff --git a/core/data/src/main/java/video/typetype/tv/data/session/StreamAccess.kt b/core/data/src/main/java/video/typetype/tv/data/session/StreamAccess.kt
new file mode 100644
index 0000000..5a53b3f
--- /dev/null
+++ b/core/data/src/main/java/video/typetype/tv/data/session/StreamAccess.kt
@@ -0,0 +1,21 @@
+package video.typetype.tv.data.session
+
+import video.typetype.tv.data.net.ApiException
+
+// Like the web player, streams and SABR sessions are asked without the account first: the server answers them
+// from what it shares between users in tens of milliseconds, where a request with the account is resolved again
+// for that account each time, over a second per call. The account goes first only when the instance refuses
+// guests or the account is limited to an allow list, and it takes over whenever the anonymous request fails.
+class StreamAccess(
+    private val guestsAllowed: Boolean,
+    private val allowListOnly: suspend () -> Boolean,
+) {
+    suspend fun <T> anonymousFirst(call: suspend (anonymous: Boolean) -> T): T {
+        if (!guestsAllowed || allowListOnly()) return call(false)
+        return try {
+            call(true)
+        } catch (_: ApiException) {
+            call(false)
+        }
+    }
+}
diff --git a/app/src/test/java/video/typetype/tv/data/AccountInitialsTest.kt b/core/data/src/test/java/video/typetype/tv/data/AccountInitialsTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/data/AccountInitialsTest.kt
rename to core/data/src/test/java/video/typetype/tv/data/AccountInitialsTest.kt
diff --git a/app/src/test/java/video/typetype/tv/data/ChannelPageTest.kt b/core/data/src/test/java/video/typetype/tv/data/ChannelPageTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/data/ChannelPageTest.kt
rename to core/data/src/test/java/video/typetype/tv/data/ChannelPageTest.kt
diff --git a/app/src/test/java/video/typetype/tv/data/ContentSourceTest.kt b/core/data/src/test/java/video/typetype/tv/data/ContentSourceTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/data/ContentSourceTest.kt
rename to core/data/src/test/java/video/typetype/tv/data/ContentSourceTest.kt
diff --git a/app/src/test/java/video/typetype/tv/data/InstanceUrlsTest.kt b/core/data/src/test/java/video/typetype/tv/data/InstanceUrlsTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/data/InstanceUrlsTest.kt
rename to core/data/src/test/java/video/typetype/tv/data/InstanceUrlsTest.kt
diff --git a/app/src/test/java/video/typetype/tv/data/SearchKindTest.kt b/core/data/src/test/java/video/typetype/tv/data/SearchKindTest.kt
similarity index 78%
rename from app/src/test/java/video/typetype/tv/data/SearchKindTest.kt
rename to core/data/src/test/java/video/typetype/tv/data/SearchKindTest.kt
index 492def5..25dd2a6 100644
--- a/app/src/test/java/video/typetype/tv/data/SearchKindTest.kt
+++ b/core/data/src/test/java/video/typetype/tv/data/SearchKindTest.kt
@@ -41,12 +41,4 @@ class SearchKindTest {
         assertFalse(SearchKind.Playlists.supports(ContentSource.NicoNico))
         assertEquals("|1|lives", SearchKind.Live.filterFor(ContentSource.NicoNico))
     }
-
-    @Test
-    fun cyclingStaysWithinTheServiceAndWraps() {
-        assertEquals(SearchKind.Live, SearchKind.next(ContentSource.NicoNico, SearchKind.Videos))
-        assertEquals(SearchKind.Videos, SearchKind.next(ContentSource.NicoNico, SearchKind.Live))
-        assertEquals(SearchKind.Videos, SearchKind.next(ContentSource.YouTube, SearchKind.MusicVideos))
-        assertEquals(SearchKind.Videos, SearchKind.next(ContentSource.NicoNico, SearchKind.Anime))
-    }
 }
diff --git a/app/src/test/java/video/typetype/tv/data/SponsorBlockSettingsTest.kt b/core/data/src/test/java/video/typetype/tv/data/SponsorBlockSettingsTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/data/SponsorBlockSettingsTest.kt
rename to core/data/src/test/java/video/typetype/tv/data/SponsorBlockSettingsTest.kt
diff --git a/app/src/test/java/video/typetype/tv/data/VideoActivityTest.kt b/core/data/src/test/java/video/typetype/tv/data/VideoActivityTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/data/VideoActivityTest.kt
rename to core/data/src/test/java/video/typetype/tv/data/VideoActivityTest.kt
diff --git a/app/src/test/java/video/typetype/tv/playback/VideoIdsTest.kt b/core/data/src/test/java/video/typetype/tv/data/VideoIdsTest.kt
similarity index 95%
rename from app/src/test/java/video/typetype/tv/playback/VideoIdsTest.kt
rename to core/data/src/test/java/video/typetype/tv/data/VideoIdsTest.kt
index 7345be3..48ca722 100644
--- a/app/src/test/java/video/typetype/tv/playback/VideoIdsTest.kt
+++ b/core/data/src/test/java/video/typetype/tv/data/VideoIdsTest.kt
@@ -1,4 +1,4 @@
-package video.typetype.tv.playback
+package video.typetype.tv.data
 
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNull
diff --git a/core/data/src/test/java/video/typetype/tv/data/api/SseReaderTest.kt b/core/data/src/test/java/video/typetype/tv/data/api/SseReaderTest.kt
new file mode 100644
index 0000000..3170762
--- /dev/null
+++ b/core/data/src/test/java/video/typetype/tv/data/api/SseReaderTest.kt
@@ -0,0 +1,29 @@
+package video.typetype.tv.data.api
+
+import okio.Buffer
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class SseReaderTest {
+    private fun reader(text: String) = SseReader(Buffer().writeUtf8(text))
+
+    @Test
+    fun readsNamedEventsAndSkipsComments() {
+        val reader = reader(": connected\n\nevent: message\ndata: {\"id\":\"1\"}\n\n: keep-alive\n\nevent: error\ndata: {}\n\n")
+        assertEquals(SseEvent("message", "{\"id\":\"1\"}"), reader.next())
+        assertEquals(SseEvent("error", "{}"), reader.next())
+        assertNull(reader.next())
+    }
+
+    @Test
+    fun joinsDataLinesAndDefaultsToMessage() {
+        val reader = reader("data: one\ndata: two\n\n")
+        assertEquals(SseEvent("message", "one\ntwo"), reader.next())
+    }
+
+    @Test
+    fun anUnfinishedEventAtTheEndIsDropped() {
+        assertNull(reader("event: message\ndata: half").next())
+    }
+}
diff --git a/core/data/src/test/java/video/typetype/tv/data/device/PerformanceSettingsTest.kt b/core/data/src/test/java/video/typetype/tv/data/device/PerformanceSettingsTest.kt
new file mode 100644
index 0000000..ffda8d1
--- /dev/null
+++ b/core/data/src/test/java/video/typetype/tv/data/device/PerformanceSettingsTest.kt
@@ -0,0 +1,93 @@
+package video.typetype.tv.data.device
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import video.typetype.tv.data.SettingItem
+import video.typetype.tv.data.SettingsGroup
+import video.typetype.tv.data.remote.TextProvider
+
+class PerformanceSettingsTest {
+    private class MemoryStore : DeviceStore {
+        val values = mutableMapOf<String, Any>()
+
+        override fun flag(key: String, fallback: Boolean) = values[key] as? Boolean ?: fallback
+
+        override fun putFlag(key: String, value: Boolean) {
+            values[key] = value
+        }
+
+        override fun text(key: String, fallback: String) = values[key] as? String ?: fallback
+
+        override fun putText(key: String, value: String) {
+            values[key] = value
+        }
+    }
+
+    private val texts = object : TextProvider {
+        override fun text(id: Int) = "text-$id"
+    }
+    private val store = MemoryStore()
+    private val settings = PerformanceSettings(store)
+
+    private fun section() = settings.addTo(emptyList(), texts).single()
+
+    @Test
+    fun everythingIsOnUntilTheBoxTurnsItOff() {
+        assertEquals(Performance(), settings.current.value)
+        assertEquals(Intro.Full, settings.current.value.intro)
+        assertTrue(settings.current.value.smoothAnimations)
+    }
+
+    @Test
+    fun aChoiceIsKeptOnTheBoxAndSeenAtOnce() {
+        assertTrue(settings.update("video-previews", "false"))
+        assertFalse(settings.current.value.videoPreviews)
+        assertEquals(false, store.values["video-previews"])
+        assertFalse(PerformanceSettings(store).current.value.videoPreviews)
+    }
+
+    @Test
+    fun theIntroCanBeShortenedOrTurnedOff() {
+        assertTrue(settings.update("intro", "short"))
+        assertEquals(Intro.Short, settings.current.value.intro)
+        assertTrue(settings.update("intro", "off"))
+        assertEquals(Intro.Off, PerformanceSettings(store).current.value.intro)
+        assertFalse(settings.update("intro", "sideways"))
+        assertEquals(Intro.Off, settings.current.value.intro)
+    }
+
+    @Test
+    fun animationsAndTheBackgroundPictureCanBeTurnedOff() {
+        settings.update("smooth-animations", "false")
+        settings.update("backdrop", "false")
+        assertFalse(settings.current.value.smoothAnimations)
+        assertFalse(settings.current.value.backdrop)
+    }
+
+    @Test
+    fun serverSettingsAreLeftToTheServer() {
+        assertFalse(settings.update("autoplay", "false"))
+        assertTrue(store.values.isEmpty())
+    }
+
+    @Test
+    fun theSectionComesBeforeTheAccount() {
+        val groups = listOf("playback", "content", "account", "about").map { SettingsGroup(it, 0, emptyList()) }
+        assertEquals(listOf("playback", "content", "performance", "account", "about"), settings.addTo(groups, texts).map { it.id })
+    }
+
+    @Test
+    fun theRowsShowTheCurrentChoice() {
+        settings.update("animated-avatar", "false")
+        settings.update("intro", "short")
+        val items = section().items
+        val toggles = items.filterIsInstance<SettingItem.Toggle>().associate { it.id to it.defaultValue }
+        assertEquals(mapOf("smooth-animations" to true, "video-previews" to true, "backdrop" to true, "animated-avatar" to false), toggles)
+        val intro = items.filterIsInstance<SettingItem.Choice>().single()
+        assertEquals(listOf("full", "short", "off"), intro.wireValues)
+        assertEquals(1, intro.defaultIndex)
+        assertEquals("forget-decoders", items.filterIsInstance<SettingItem.Action>().single().id)
+    }
+}
diff --git a/core/data/src/test/java/video/typetype/tv/data/net/AnonymousRequestTest.kt b/core/data/src/test/java/video/typetype/tv/data/net/AnonymousRequestTest.kt
new file mode 100644
index 0000000..8456ad5
--- /dev/null
+++ b/core/data/src/test/java/video/typetype/tv/data/net/AnonymousRequestTest.kt
@@ -0,0 +1,41 @@
+package video.typetype.tv.data.net
+
+import kotlinx.coroutines.runBlocking
+import kotlinx.serialization.builtins.serializer
+import okhttp3.OkHttpClient
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Before
+import org.junit.Test
+
+class AnonymousRequestTest {
+    private lateinit var server: MockWebServer
+    private lateinit var client: ApiClient
+
+    @Before
+    fun start() {
+        server = MockWebServer().apply { start() }
+        val http = OkHttpClient.Builder().addInterceptor(AccessTokenInterceptor(server.hostName) { "secret" }).build()
+        client = ApiClient(server.url("/api/"), http, retry = RetryPolicy.NONE)
+    }
+
+    @After
+    fun stop() = server.shutdown()
+
+    @Test
+    fun anAnonymousRequestLeavesTheAccountOut() = runBlocking {
+        server.enqueue(MockResponse().setBody("\"ok\""))
+        client.get("streams", String.serializer(), anonymous = true)
+        assertNull(server.takeRequest().getHeader("Authorization"))
+    }
+
+    @Test
+    fun otherRequestsCarryTheAccount() = runBlocking {
+        server.enqueue(MockResponse().setBody("\"ok\""))
+        client.get("streams", String.serializer())
+        assertEquals("Bearer secret", server.takeRequest().getHeader("Authorization"))
+    }
+}
diff --git a/app/src/test/java/video/typetype/tv/data/net/ApiClientTest.kt b/core/data/src/test/java/video/typetype/tv/data/net/ApiClientTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/data/net/ApiClientTest.kt
rename to core/data/src/test/java/video/typetype/tv/data/net/ApiClientTest.kt
diff --git a/app/src/test/java/video/typetype/tv/data/net/LibraryWriteApiTest.kt b/core/data/src/test/java/video/typetype/tv/data/net/LibraryWriteApiTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/data/net/LibraryWriteApiTest.kt
rename to core/data/src/test/java/video/typetype/tv/data/net/LibraryWriteApiTest.kt
diff --git a/app/src/test/java/video/typetype/tv/data/net/RetryTest.kt b/core/data/src/test/java/video/typetype/tv/data/net/RetryTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/data/net/RetryTest.kt
rename to core/data/src/test/java/video/typetype/tv/data/net/RetryTest.kt
diff --git a/core/data/src/test/java/video/typetype/tv/data/net/ServerWatchTest.kt b/core/data/src/test/java/video/typetype/tv/data/net/ServerWatchTest.kt
new file mode 100644
index 0000000..f3cc036
--- /dev/null
+++ b/core/data/src/test/java/video/typetype/tv/data/net/ServerWatchTest.kt
@@ -0,0 +1,46 @@
+package video.typetype.tv.data.net
+
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.fail
+import org.junit.Test
+
+class ServerWatchTest {
+    private fun watch(reachable: Boolean) = ServerWatch({ reachable }, slowAfterMillis = 50, probeEveryMillis = 20)
+
+    @Test
+    fun aQuickAnswerNeverAsksTheServerHowItIs() = runBlocking {
+        var probes = 0
+        val watch = ServerWatch({ probes++; true }, slowAfterMillis = 200, probeEveryMillis = 20)
+        assertEquals("done", watch.watch { "done" })
+        assertEquals(0, probes)
+    }
+
+    @Test
+    fun aSlowServerThatStillAnswersIsWaitedFor() = runBlocking {
+        assertEquals("slow", watch(reachable = true).watch { delay(300); "slow" })
+    }
+
+    @Test
+    fun aSilentServerEndsTheWaitAsUnreachable() = runBlocking {
+        try {
+            watch(reachable = false).watch { delay(60_000); "never" }
+            fail("expected the wait to end")
+        } catch (failure: ApiException) {
+            assertEquals(FailureCategory.Network, failure.failure.category)
+            assertEquals(ServerWatch.UNREACHABLE, failure.failure.code)
+        }
+    }
+
+    @Test
+    fun aFailureFromTheServerIsKeptAsItIs() = runBlocking {
+        val refused = ApiException(ApiFailure(FailureCategory.NotFound, 404, null, "missing", null))
+        try {
+            watch(reachable = true).watch { throw refused }
+            fail("expected the failure")
+        } catch (failure: ApiException) {
+            assertEquals(refused, failure)
+        }
+    }
+}
diff --git a/app/src/test/java/video/typetype/tv/data/net/tls/PinTrustTest.kt b/core/data/src/test/java/video/typetype/tv/data/net/tls/PinTrustTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/data/net/tls/PinTrustTest.kt
rename to core/data/src/test/java/video/typetype/tv/data/net/tls/PinTrustTest.kt
diff --git a/app/src/test/java/video/typetype/tv/data/remote/BlockedSettingsTest.kt b/core/data/src/test/java/video/typetype/tv/data/remote/BlockedSettingsTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/data/remote/BlockedSettingsTest.kt
rename to core/data/src/test/java/video/typetype/tv/data/remote/BlockedSettingsTest.kt
diff --git a/app/src/test/java/video/typetype/tv/data/remote/ContentFilterTest.kt b/core/data/src/test/java/video/typetype/tv/data/remote/ContentFilterTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/data/remote/ContentFilterTest.kt
rename to core/data/src/test/java/video/typetype/tv/data/remote/ContentFilterTest.kt
diff --git a/core/data/src/test/java/video/typetype/tv/data/remote/ContentSettingsTest.kt b/core/data/src/test/java/video/typetype/tv/data/remote/ContentSettingsTest.kt
new file mode 100644
index 0000000..8277e4d
--- /dev/null
+++ b/core/data/src/test/java/video/typetype/tv/data/remote/ContentSettingsTest.kt
@@ -0,0 +1,58 @@
+package video.typetype.tv.data.remote
+
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.buildJsonObject
+import kotlinx.serialization.json.put
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import video.typetype.tv.data.SettingItem
+
+class ContentSettingsTest {
+    private val texts = object : TextProvider {
+        override fun text(id: Int): String = "text $id"
+    }
+
+    @Test
+    fun aHiddenRowShowsAsASwitchThatIsOff() {
+        val settings = buildJsonObject {
+            put("hideShorts", true)
+            put("hideComments", false)
+        }
+        val items = ContentSettings.group(settings, texts).items.filterIsInstance<SettingItem.Toggle>().associateBy { it.id }
+        assertFalse(items.getValue("show-shorts").defaultValue)
+        assertTrue(items.getValue("show-comments").defaultValue)
+        assertTrue(items.getValue("show-related").defaultValue)
+    }
+
+    @Test
+    fun turningAShowSwitchOffWritesTheHideFlag() {
+        val patch = buildJsonObject { assertTrue(ContentSettings.write(this, "show-shorts", "false")) }
+        assertEquals(JsonPrimitive(true), patch["hideShorts"])
+    }
+
+    @Test
+    fun theStartPageAndSearchServiceUseTheServerNames() {
+        val settings = buildJsonObject {
+            put("defaultLandingPage", "watch-later")
+            put("defaultService", 6)
+        }
+        val choices = ContentSettings.group(settings, texts).items.filterIsInstance<SettingItem.Choice>().associateBy { it.id }
+        val landing = choices.getValue("landing")
+        val service = choices.getValue("service")
+        assertEquals("watch-later", landing.wireValues[landing.defaultIndex])
+        assertEquals("6", service.wireValues[service.defaultIndex])
+        val patch = buildJsonObject {
+            assertTrue(ContentSettings.write(this, "service", "5"))
+            assertTrue(ContentSettings.write(this, "landing", "history"))
+        }
+        assertEquals(JsonPrimitive(5), patch["defaultService"])
+        assertEquals(JsonPrimitive("history"), patch["defaultLandingPage"])
+    }
+
+    @Test
+    fun otherSettingsAreLeftToTheCaller() {
+        buildJsonObject { assertFalse(ContentSettings.write(this, "quality", "720p")) }
+    }
+}
diff --git a/app/src/test/java/video/typetype/tv/data/remote/DeArrowBrandingTest.kt b/core/data/src/test/java/video/typetype/tv/data/remote/DeArrowBrandingTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/data/remote/DeArrowBrandingTest.kt
rename to core/data/src/test/java/video/typetype/tv/data/remote/DeArrowBrandingTest.kt
diff --git a/app/src/test/java/video/typetype/tv/data/remote/HtmlTextTest.kt b/core/data/src/test/java/video/typetype/tv/data/remote/HtmlTextTest.kt
similarity index 89%
rename from app/src/test/java/video/typetype/tv/data/remote/HtmlTextTest.kt
rename to core/data/src/test/java/video/typetype/tv/data/remote/HtmlTextTest.kt
index 747336e..c9de35d 100644
--- a/app/src/test/java/video/typetype/tv/data/remote/HtmlTextTest.kt
+++ b/core/data/src/test/java/video/typetype/tv/data/remote/HtmlTextTest.kt
@@ -60,4 +60,10 @@ class HtmlTextTest {
         assertEquals(Formatters.age(now, now - 3 * 86_400_000L), comment?.published)
         assertEquals("fallback", CommentDto(id = "1", text = "x", publishedTime = "fallback").toComment(now)?.published)
     }
+
+    @Test
+    fun titlesDropObjectPlaceholdersAndExtraSpaces() {
+        assertEquals("IL DEVIENT PATRON il nous raconte tout", HtmlText.title("IL DEVIENT PATRON  il nous raconte tout \uFFFC"))
+        assertEquals("a b", HtmlText.title("a\u200B \uFEFFb"))
+    }
 }
diff --git a/core/data/src/test/java/video/typetype/tv/data/remote/LibraryMembershipTest.kt b/core/data/src/test/java/video/typetype/tv/data/remote/LibraryMembershipTest.kt
new file mode 100644
index 0000000..960ca54
--- /dev/null
+++ b/core/data/src/test/java/video/typetype/tv/data/remote/LibraryMembershipTest.kt
@@ -0,0 +1,49 @@
+package video.typetype.tv.data.remote
+
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import java.io.IOException
+
+class LibraryMembershipTest {
+    private var now = 0L
+    private var loads = 0
+    private var failWatchLater = false
+
+    private val membership = LibraryMembership(
+        favorites = { loads++; setOf("fav") },
+        watchLater = { if (failWatchLater) throw IOException("down") else setOf("later") },
+        subscriptions = { setOf("chan") },
+        clock = { now },
+        ttlMillis = 1_000L,
+    )
+
+    @Test
+    fun aFreshSnapshotIsReusedUntilItExpires() = runBlocking {
+        membership.current()
+        now = 900L
+        membership.current()
+        assertEquals(1, loads)
+        now = 2_000L
+        membership.current()
+        assertEquals(2, loads)
+    }
+
+    @Test
+    fun writesPatchTheKeptSnapshot() = runBlocking {
+        membership.current()
+        membership.update { it.copy(favorites = it.favorites + "new") }
+        assertTrue("new" in membership.current().favorites)
+        assertEquals(1, loads)
+    }
+
+    @Test
+    fun aSnapshotWithAFailedListIsNotKept() = runBlocking {
+        failWatchLater = true
+        assertEquals(emptySet<String>(), membership.current().watchLater)
+        failWatchLater = false
+        assertEquals(setOf("later"), membership.current().watchLater)
+        assertEquals(2, loads)
+    }
+}
diff --git a/core/data/src/test/java/video/typetype/tv/data/remote/LiveChatSourceTest.kt b/core/data/src/test/java/video/typetype/tv/data/remote/LiveChatSourceTest.kt
new file mode 100644
index 0000000..05f5676
--- /dev/null
+++ b/core/data/src/test/java/video/typetype/tv/data/remote/LiveChatSourceTest.kt
@@ -0,0 +1,78 @@
+package video.typetype.tv.data.remote
+
+import kotlinx.coroutines.flow.take
+import kotlinx.coroutines.flow.toList
+import kotlinx.coroutines.runBlocking
+import okhttp3.OkHttpClient
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Before
+import org.junit.Test
+import video.typetype.tv.data.LiveChatEvent
+import video.typetype.tv.data.LiveChatMessage
+import video.typetype.tv.data.api.LiveChatApi
+import video.typetype.tv.data.net.ApiClient
+import video.typetype.tv.data.net.RetryPolicy
+
+class LiveChatSourceTest {
+    private lateinit var server: MockWebServer
+    private val pauses = mutableListOf<Long>()
+    private lateinit var source: LiveChatSource
+
+    @Before
+    fun start() {
+        server = MockWebServer().also { it.start() }
+        val client = ApiClient(server.url("/api/"), OkHttpClient(), retry = RetryPolicy.NONE)
+        source = LiveChatSource(LiveChatApi(client)) { pauses += it }
+    }
+
+    @After
+    fun stop() {
+        server.shutdown()
+    }
+
+    private fun stream(body: String) = MockResponse().setHeader("Content-Type", "text/event-stream").setBody(body)
+
+    private fun message(id: String, text: String) =
+        "event: message\ndata: {\"id\":\"$id\",\"text\":\"$text\",\"receivedAtMs\":1,\"authorName\":\"@viewer\"}\n\n"
+
+    @Test
+    fun messagesArriveAndADroppedStreamReconnects() = runBlocking {
+        server.enqueue(stream(": connected\n\n" + message("1", "hello")))
+        server.enqueue(stream(message("2", "again")))
+        val events = source.events("https://www.youtube.com/watch?v=live").take(2).toList()
+        assertEquals(
+            listOf(
+                LiveChatEvent.Message(LiveChatMessage("1", "@viewer", "hello")),
+                LiveChatEvent.Message(LiveChatMessage("2", "@viewer", "again")),
+            ),
+            events,
+        )
+        assertEquals(listOf(1_000L), pauses)
+        assertEquals("https://www.youtube.com/watch?v=live", server.takeRequest().requestUrl?.queryParameter("url"))
+    }
+
+    @Test
+    fun aVideoWithoutChatStopsAtOnce() = runBlocking {
+        server.enqueue(MockResponse().setResponseCode(422).setBody("{\"error\":\"Live chat requires a live YouTube video\"}"))
+        assertEquals(listOf(LiveChatEvent.Unavailable), source.events("u").toList())
+        assertEquals(emptyList<Long>(), pauses)
+    }
+
+    @Test
+    fun aFullServerIsAskedAgainAfterItsDelay() = runBlocking {
+        server.enqueue(MockResponse().setResponseCode(429).setHeader("Retry-After", "5"))
+        server.enqueue(stream(message("1", "in")))
+        source.events("u").take(1).toList()
+        assertEquals(listOf(5_000L), pauses)
+    }
+
+    @Test
+    fun repeatedFailuresGiveUp() = runBlocking {
+        repeat(7) { server.enqueue(MockResponse().setResponseCode(502)) }
+        assertEquals(listOf(LiveChatEvent.Unavailable), source.events("u").toList())
+        assertEquals(6, pauses.size)
+    }
+}
diff --git a/app/src/test/java/video/typetype/tv/data/remote/MappersTest.kt b/core/data/src/test/java/video/typetype/tv/data/remote/MappersTest.kt
similarity index 95%
rename from app/src/test/java/video/typetype/tv/data/remote/MappersTest.kt
rename to core/data/src/test/java/video/typetype/tv/data/remote/MappersTest.kt
index c330e10..ae9816f 100644
--- a/app/src/test/java/video/typetype/tv/data/remote/MappersTest.kt
+++ b/core/data/src/test/java/video/typetype/tv/data/remote/MappersTest.kt
@@ -46,7 +46,10 @@ class MappersTest {
 
     @Test
     fun marksLiveStreams() {
-        assertTrue(item().copy(streamType = "live_stream").toVideo(now)?.isLive == true)
+        val live = item().copy(streamType = "live_stream").toVideo(now)
+        assertTrue(live?.isLive == true)
+        assertEquals("1.3M watching", live?.views)
+        assertEquals("1.3M views", item().toVideo(now)?.views)
     }
 
     @Test
diff --git a/app/src/test/java/video/typetype/tv/data/remote/NotificationsTest.kt b/core/data/src/test/java/video/typetype/tv/data/remote/NotificationsTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/data/remote/NotificationsTest.kt
rename to core/data/src/test/java/video/typetype/tv/data/remote/NotificationsTest.kt
diff --git a/app/src/test/java/video/typetype/tv/data/remote/PublicPlaylistSourceTest.kt b/core/data/src/test/java/video/typetype/tv/data/remote/PublicPlaylistSourceTest.kt
similarity index 94%
rename from app/src/test/java/video/typetype/tv/data/remote/PublicPlaylistSourceTest.kt
rename to core/data/src/test/java/video/typetype/tv/data/remote/PublicPlaylistSourceTest.kt
index e91cb35..3cf63d9 100644
--- a/app/src/test/java/video/typetype/tv/data/remote/PublicPlaylistSourceTest.kt
+++ b/core/data/src/test/java/video/typetype/tv/data/remote/PublicPlaylistSourceTest.kt
@@ -35,7 +35,8 @@ class PublicPlaylistSourceTest {
                     path.startsWith("/api/search") -> MockResponse().setResponseCode(200).setBody(
                         """{"items":[],"playlists":[{"title":"Linux course","url":"https://www.youtube.com/playlist?list=PL1","thumbnailUrl":"https://i.example/t.jpg","uploaderName":"Teacher","streamCount":18},
                         {"title":"","url":"https://www.youtube.com/playlist?list=PL2"}],
-                        "channels":[{"name":"Darkone","url":"https://www.youtube.com/channel/UC1","description":" Linux ","subscriberCount":12500,"thumbnailUrl":""},{"name":"","url":"x"}]}""",
+                        "channels":[{"name":"Darkone","url":"https://www.youtube.com/channel/UC1","description":" Linux ","subscriberCount":12500,"thumbnailUrl":""},{"name":"","url":"x"}],
+                        "nextpage":"p2"}""",
                     )
                     path.startsWith("/api/podcasts/episodes") -> MockResponse().setResponseCode(200).setBody(
                         """{"podcast":{"title":"The Show","url":"https://www.youtube.com/playlist?list=PODCAST","uploaderName":"Host","streamCount":2},
@@ -151,4 +152,12 @@ class PublicPlaylistSourceTest {
         assertEquals("more", page.nextPage)
         assertEquals("Host", page.playlist.uploader)
     }
+
+    @Test
+    fun videoSearchSendsAndReturnsThePageCursor() = runBlocking {
+        val results = source.search("q", ContentSource.YouTube, SearchKind.Videos, page = "p1")
+        assertEquals("p2", results.nextPage)
+        val search = requests.single { it.path.orEmpty().startsWith("/api/search") }
+        assertEquals("p1", search.requestUrl?.queryParameter("nextpage"))
+    }
 }
diff --git a/core/data/src/test/java/video/typetype/tv/data/remote/RelatedFallbackTest.kt b/core/data/src/test/java/video/typetype/tv/data/remote/RelatedFallbackTest.kt
new file mode 100644
index 0000000..f4458ea
--- /dev/null
+++ b/core/data/src/test/java/video/typetype/tv/data/remote/RelatedFallbackTest.kt
@@ -0,0 +1,42 @@
+package video.typetype.tv.data.remote
+
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import video.typetype.tv.data.Channel
+import video.typetype.tv.data.Video
+import video.typetype.tv.data.net.ApiException
+import video.typetype.tv.data.net.ApiFailure
+import video.typetype.tv.data.net.FailureCategory
+
+class RelatedFallbackTest {
+    private fun video(id: String) = Video(id, "Title $id", Channel("c", "C", "", ""), 60, "", "", "", "")
+
+    @Test
+    fun relatedVideosAreKeptWhenThereAreSome() = runBlocking {
+        var asked = false
+        val result = relatedOrLatest("v", listOf(video("a"), video("b")), "https://c", limit = 1) { asked = true; emptyList() }
+        assertEquals(listOf("a"), result.map { it.id })
+        assertTrue(!asked)
+    }
+
+    @Test
+    fun theChannelsLatestVideosFillAnEmptyRowWithoutTheVideoItself() = runBlocking {
+        val result = relatedOrLatest("v", emptyList(), "https://c", limit = 2) { listOf(video("v"), video("x"), video("y"), video("z")) }
+        assertEquals(listOf("x", "y"), result.map { it.id })
+    }
+
+    @Test
+    fun aChannelThatFailsLeavesTheRowEmpty() = runBlocking {
+        val result = relatedOrLatest("v", emptyList(), "https://c", limit = 5) {
+            throw ApiException(ApiFailure(FailureCategory.Network, null, "offline", "offline", null))
+        }
+        assertTrue(result.isEmpty())
+    }
+
+    @Test
+    fun noChannelMeansNoFallback() = runBlocking {
+        assertTrue(relatedOrLatest("v", emptyList(), "", limit = 5) { listOf(video("x")) }.isEmpty())
+    }
+}
diff --git a/app/src/test/java/video/typetype/tv/data/remote/RemotePresenceTest.kt b/core/data/src/test/java/video/typetype/tv/data/remote/RemotePresenceTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/data/remote/RemotePresenceTest.kt
rename to core/data/src/test/java/video/typetype/tv/data/remote/RemotePresenceTest.kt
diff --git a/app/src/test/java/video/typetype/tv/data/remote/RemoteSettingsCertificateTest.kt b/core/data/src/test/java/video/typetype/tv/data/remote/RemoteSettingsCertificateTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/data/remote/RemoteSettingsCertificateTest.kt
rename to core/data/src/test/java/video/typetype/tv/data/remote/RemoteSettingsCertificateTest.kt
diff --git a/app/src/test/java/video/typetype/tv/data/remote/RemoteUserSettingsTest.kt b/core/data/src/test/java/video/typetype/tv/data/remote/RemoteUserSettingsTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/data/remote/RemoteUserSettingsTest.kt
rename to core/data/src/test/java/video/typetype/tv/data/remote/RemoteUserSettingsTest.kt
diff --git a/app/src/test/java/video/typetype/tv/data/remote/RemoteVideoActivityPlaylistTest.kt b/core/data/src/test/java/video/typetype/tv/data/remote/RemoteVideoActivityPlaylistTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/data/remote/RemoteVideoActivityPlaylistTest.kt
rename to core/data/src/test/java/video/typetype/tv/data/remote/RemoteVideoActivityPlaylistTest.kt
diff --git a/core/data/src/test/java/video/typetype/tv/data/remote/StreamStoreTest.kt b/core/data/src/test/java/video/typetype/tv/data/remote/StreamStoreTest.kt
new file mode 100644
index 0000000..825f829
--- /dev/null
+++ b/core/data/src/test/java/video/typetype/tv/data/remote/StreamStoreTest.kt
@@ -0,0 +1,54 @@
+package video.typetype.tv.data.remote
+
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.async
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import video.typetype.tv.data.dto.StreamDto
+import java.util.concurrent.atomic.AtomicInteger
+
+class StreamStoreTest {
+    @Test
+    fun concurrentCallersShareOneLoad() = runBlocking {
+        val calls = AtomicInteger()
+        val gate = CompletableDeferred<Unit>()
+        val store = StreamStore({ url ->
+            calls.incrementAndGet()
+            gate.await()
+            StreamDto(id = url)
+        })
+        val first = async { store.get("a") }
+        val second = async { store.get("a") }
+        gate.complete(Unit)
+        assertEquals("a", first.await().id)
+        assertEquals("a", second.await().id)
+        assertEquals(1, calls.get())
+    }
+
+    @Test
+    fun aLoadedStreamIsServedFromTheCache() = runBlocking {
+        val calls = AtomicInteger()
+        val store = StreamStore({ url -> calls.incrementAndGet(); StreamDto(id = url) })
+        store.get("a")
+        store.get("a")
+        assertEquals(1, calls.get())
+    }
+
+    @Test
+    fun aLoadSurvivesTheCallerThatStartedIt() = runBlocking {
+        val calls = AtomicInteger()
+        val gate = CompletableDeferred<Unit>()
+        val store = StreamStore({ url ->
+            calls.incrementAndGet()
+            gate.await()
+            StreamDto(id = url)
+        })
+        val abandoned = async { store.get("a") }
+        while (calls.get() == 0) kotlinx.coroutines.yield()
+        abandoned.cancel()
+        gate.complete(Unit)
+        assertEquals("a", store.get("a").id)
+        assertEquals(1, calls.get())
+    }
+}
diff --git a/core/data/src/test/java/video/typetype/tv/data/session/InstanceChangeTest.kt b/core/data/src/test/java/video/typetype/tv/data/session/InstanceChangeTest.kt
new file mode 100644
index 0000000..ef8facd
--- /dev/null
+++ b/core/data/src/test/java/video/typetype/tv/data/session/InstanceChangeTest.kt
@@ -0,0 +1,71 @@
+package video.typetype.tv.data.session
+
+import kotlinx.coroutines.runBlocking
+import okhttp3.mockwebserver.Dispatcher
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import okhttp3.mockwebserver.RecordedRequest
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertSame
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import video.typetype.tv.data.dto.InstanceDto
+import video.typetype.tv.data.net.ApiJson
+import video.typetype.tv.data.net.InMemorySecretStore
+
+class InstanceChangeTest {
+    private lateinit var server: MockWebServer
+    private val store = InMemorySecretStore()
+
+    @Before
+    fun start() {
+        server = MockWebServer().apply {
+            dispatcher = object : Dispatcher() {
+                override fun dispatch(request: RecordedRequest): MockResponse =
+                    if (request.path.orEmpty().contains("auth/me")) {
+                        MockResponse().setBody("""{"id":"user-1","publicUsername":"Viewer"}""")
+                    } else {
+                        MockResponse().setResponseCode(404)
+                    }
+            }
+            start()
+        }
+        store.put("api_base", server.url("/api/").toString())
+        store.put("instance", ApiJson.instance.encodeToString(InstanceDto.serializer(), InstanceDto(name = "Test")))
+        store.put("access_token", "token-1")
+    }
+
+    @After
+    fun stop() {
+        server.shutdown()
+    }
+
+    @Test
+    fun cancellingAChangeReturnsToTheSameSignedInSession() = runBlocking {
+        val session = SessionManager(store)
+        session.restore()
+        val signedIn = session.state.value
+        assertTrue(signedIn is SessionState.SignedIn)
+
+        session.startInstanceChange()
+        assertEquals(SessionState.ChangingInstance(signedIn), session.state.value)
+        session.cancelInstanceChange()
+
+        assertSame(signedIn, session.state.value)
+    }
+
+    @Test
+    fun openingTheSetupScreenForgetsNothing() = runBlocking {
+        val session = SessionManager(store)
+        session.restore()
+        session.startInstanceChange()
+        session.startInstanceChange()
+
+        assertEquals("token-1", store.get("access_token"))
+        assertEquals(server.url("/api/").toString(), store.get("api_base"))
+        val changing = session.state.value as SessionState.ChangingInstance
+        assertTrue(changing.previous is SessionState.SignedIn)
+    }
+}
diff --git a/core/data/src/test/java/video/typetype/tv/data/session/SessionRestoreTest.kt b/core/data/src/test/java/video/typetype/tv/data/session/SessionRestoreTest.kt
new file mode 100644
index 0000000..78499e0
--- /dev/null
+++ b/core/data/src/test/java/video/typetype/tv/data/session/SessionRestoreTest.kt
@@ -0,0 +1,107 @@
+package video.typetype.tv.data.session
+
+import kotlinx.coroutines.async
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+import okhttp3.mockwebserver.Dispatcher
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import okhttp3.mockwebserver.RecordedRequest
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import video.typetype.tv.data.dto.InstanceDto
+import video.typetype.tv.data.net.ApiJson
+import video.typetype.tv.data.net.InMemorySecretStore
+
+class SessionRestoreTest {
+    private lateinit var server: MockWebServer
+    private val store = InMemorySecretStore()
+    private val responses = mutableMapOf<String, () -> MockResponse>()
+
+    @Before
+    fun start() {
+        server = MockWebServer().apply {
+            dispatcher = object : Dispatcher() {
+                override fun dispatch(request: RecordedRequest): MockResponse {
+                    val path = request.path.orEmpty().substringAfter("/api/").substringBefore('?')
+                    return responses[path]?.invoke() ?: MockResponse().setResponseCode(404)
+                }
+            }
+            start()
+        }
+        store.put("api_base", server.url("/api/").toString())
+        store.put("instance", ApiJson.instance.encodeToString(InstanceDto.serializer(), InstanceDto(name = "Test")))
+        store.put("access_token", "token-1")
+    }
+
+    @After
+    fun stop() {
+        server.shutdown()
+    }
+
+    private fun profile(name: String) = MockResponse().setBody("""{"id":"user-1","publicUsername":"$name"}""")
+
+    @Test
+    fun aCachedProfileOpensTheAppWhileTheServerIsDown() = runBlocking {
+        store.put("profile", """{"id":"user-1","publicUsername":"Cached"}""")
+        responses["auth/me"] = { MockResponse().setResponseCode(522) }
+        val session = SessionManager(store)
+        session.restore()
+        val state = session.state.value as SessionState.SignedIn
+        assertEquals("Cached", state.profile.publicUsername)
+        assertEquals("token-1", store.get("access_token"))
+    }
+
+    @Test
+    fun aCachedProfileIsRefreshedWhenTheServerAnswers() = runBlocking {
+        store.put("profile", """{"id":"user-1","publicUsername":"Cached"}""")
+        responses["auth/me"] = { profile("Fresh") }
+        val session = SessionManager(store)
+        session.restore()
+        assertEquals("Fresh", (session.state.value as SessionState.SignedIn).profile.publicUsername)
+        assertTrue(store.get("profile").orEmpty().contains("Fresh"))
+    }
+
+    @Test
+    fun withoutACachedProfileTheAppWaitsForTheServerThenContinues() = runBlocking {
+        var up = false
+        responses["auth/me"] = { if (up) profile("Back") else MockResponse().setResponseCode(503) }
+        val session = SessionManager(store)
+        val restoring = async { session.restore() }
+        withTimeout(30_000) { session.state.first { it is SessionState.Reconnecting && it.failedAttempts > 0 } }
+        up = true
+        session.retryConnection()
+        withTimeout(30_000) { restoring.await() }
+        assertEquals("Back", (session.state.value as SessionState.SignedIn).profile.publicUsername)
+    }
+
+    @Test
+    fun aSessionTheServerRefusesGoesBackToSignIn() = runBlocking {
+        store.put("profile", """{"id":"user-1"}""")
+        responses["auth/me"] = { MockResponse().setResponseCode(401) }
+        responses["auth/refresh"] = { MockResponse().setResponseCode(401) }
+        val session = SessionManager(store)
+        session.restore()
+        assertEquals(SignOutReason.Expired, (session.state.value as SessionState.SignedOut).notice)
+        assertEquals(null, store.get("access_token"))
+        assertEquals(null, store.get("profile"))
+    }
+
+    @Test
+    fun aRefreshThatCannotReachTheServerKeepsTheSession() {
+        store.put("profile", """{"id":"user-1"}""")
+        val session = SessionManager(store)
+        runBlocking {
+            responses["auth/me"] = { profile("Ok") }
+            session.restore()
+        }
+        server.shutdown()
+        assertEquals(null, session.refreshBlocking("token-1"))
+        assertEquals("token-1", store.get("access_token"))
+        assertTrue(session.state.value is SessionState.SignedIn)
+    }
+}
diff --git a/core/data/src/test/java/video/typetype/tv/data/session/StreamAccessTest.kt b/core/data/src/test/java/video/typetype/tv/data/session/StreamAccessTest.kt
new file mode 100644
index 0000000..66fb95b
--- /dev/null
+++ b/core/data/src/test/java/video/typetype/tv/data/session/StreamAccessTest.kt
@@ -0,0 +1,44 @@
+package video.typetype.tv.data.session
+
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import video.typetype.tv.data.net.ApiException
+import video.typetype.tv.data.net.ApiFailure
+import video.typetype.tv.data.net.FailureCategory
+
+class StreamAccessTest {
+    private val asked = mutableListOf<Boolean>()
+
+    private suspend fun call(anonymous: Boolean, failAnonymous: Boolean = false): String {
+        asked += anonymous
+        if (anonymous && failAnonymous) throw ApiException(ApiFailure(FailureCategory.Server, 503, "blocked", "blocked", null))
+        return if (anonymous) "shared" else "account"
+    }
+
+    @Test
+    fun asksWithoutTheAccountFirst() = runBlocking {
+        val result = StreamAccess(guestsAllowed = true) { false }.anonymousFirst { call(it) }
+        assertEquals("shared", result)
+        assertEquals(listOf(true), asked)
+    }
+
+    @Test
+    fun fallsBackToTheAccountWhenTheAnonymousRequestFails() = runBlocking {
+        val result = StreamAccess(guestsAllowed = true) { false }.anonymousFirst { call(it, failAnonymous = true) }
+        assertEquals("account", result)
+        assertEquals(listOf(true, false), asked)
+    }
+
+    @Test
+    fun usesTheAccountWhenTheInstanceRefusesGuests() = runBlocking {
+        StreamAccess(guestsAllowed = false) { false }.anonymousFirst { call(it) }
+        assertEquals(listOf(false), asked)
+    }
+
+    @Test
+    fun usesTheAccountWhenItIsLimitedToAnAllowList() = runBlocking {
+        StreamAccess(guestsAllowed = true) { true }.anonymousFirst { call(it) }
+        assertEquals(listOf(false), asked)
+    }
+}
diff --git a/core/playback/build.gradle.kts b/core/playback/build.gradle.kts
new file mode 100644
index 0000000..f82c7ed
--- /dev/null
+++ b/core/playback/build.gradle.kts
@@ -0,0 +1,18 @@
+plugins {
+    alias(libs.plugins.typetype.android.library)
+}
+
+android {
+    namespace = "video.typetype.tv.playback"
+}
+
+dependencies {
+    api(project(":core:data"))
+    api(project(":player"))
+    api(libs.androidx.media3.exoplayer)
+    implementation(libs.androidx.media3.exoplayer.hls)
+    implementation(libs.androidx.media3.datasource.okhttp)
+
+    testImplementation(libs.junit)
+    testImplementation(libs.okhttp.mockwebserver)
+}
diff --git a/app/src/main/java/video/typetype/tv/playback/CaptionChoice.kt b/core/playback/src/main/java/video/typetype/tv/playback/CaptionChoice.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/playback/CaptionChoice.kt
rename to core/playback/src/main/java/video/typetype/tv/playback/CaptionChoice.kt
diff --git a/core/playback/src/main/java/video/typetype/tv/playback/CodecSupport.kt b/core/playback/src/main/java/video/typetype/tv/playback/CodecSupport.kt
new file mode 100644
index 0000000..86ad164
--- /dev/null
+++ b/core/playback/src/main/java/video/typetype/tv/playback/CodecSupport.kt
@@ -0,0 +1,137 @@
+package video.typetype.tv.playback
+
+import android.content.Context
+import android.hardware.display.DisplayManager
+import android.os.Build
+import android.view.Display
+import androidx.media3.common.Format
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.mediacodec.MediaCodecUtil
+import video.typetype.tv.data.dto.VideoStreamDto
+import java.util.concurrent.ConcurrentHashMap
+
+enum class DecoderSupport(val rank: Int) {
+    Unsupported(0),
+    Software(1),
+    Hardware(2),
+}
+
+fun interface CodecSupport {
+    fun video(stream: VideoStreamDto): DecoderSupport
+}
+
+// Asks Media3 which decoders accept each format, size and frame rate included, as TypeType-Android does.
+// HDR formats are kept out unless the screen can show HDR: decoded on an SDR screen they look washed out.
+// Pictures larger than the largest mode the box can send to the screen are kept out too: they cost decoding and
+// memory for nothing, and some decoders that claim 4K fail on it.
+@UnstableApi
+class DeviceCodecSupport(context: Context) : CodecSupport {
+    private val appContext = context.applicationContext
+    private val hdrScreen: Boolean by lazy { screenSupportsHdr(appContext) }
+    private val screenLines: Int? by lazy { screenShortSide(appContext) }
+    private val cache = ConcurrentHashMap<String, DecoderSupport>()
+
+    override fun video(stream: VideoStreamDto): DecoderSupport {
+        if (VideoCodecs.isHdr(stream.codec) && !hdrScreen) return DecoderSupport.Unsupported
+        if (!ScreenFit.fits(stream.width, stream.height, screenLines)) return DecoderSupport.Unsupported
+        val key = "${stream.codec}|${stream.width}|${stream.height}|${stream.fps}"
+        return cache.getOrPut(key) { query(stream) }
+    }
+
+    private fun query(stream: VideoStreamDto): DecoderSupport {
+        val mimeType = VideoCodecs.mimeType(stream.codec) ?: return DecoderSupport.Unsupported
+        val format = Format.Builder()
+            .setSampleMimeType(mimeType)
+            .setCodecs(stream.codec.takeIf { it.contains('.') && !it.startsWith("vp9.") })
+            .setWidth(stream.width)
+            .setHeight(stream.height)
+            .apply { if (stream.fps > 0) setFrameRate(stream.fps.toFloat()) }
+            .build()
+        return try {
+            val decoders = MediaCodecUtil.getDecoderInfos(mimeType, false, false)
+                .filter { it.isFormatSupported(appContext, format) }
+            when {
+                decoders.any { it.hardwareAccelerated } -> DecoderSupport.Hardware
+                decoders.isNotEmpty() -> DecoderSupport.Software
+                else -> DecoderSupport.Unsupported
+            }
+        } catch (_: MediaCodecUtil.DecoderQueryException) {
+            DecoderSupport.Unsupported
+        }
+    }
+
+    private fun screenShortSide(context: Context): Int? {
+        val display = context.getSystemService(DisplayManager::class.java)?.getDisplay(Display.DEFAULT_DISPLAY) ?: return null
+        return display.supportedModes.maxOfOrNull { minOf(it.physicalWidth, it.physicalHeight) }?.takeIf { it > 0 }
+    }
+
+    private fun screenSupportsHdr(context: Context): Boolean {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) return false
+        val display = context.getSystemService(DisplayManager::class.java)?.getDisplay(Display.DEFAULT_DISPLAY) ?: return false
+        return display.hdrCapabilities?.supportedHdrTypes?.isNotEmpty() == true
+    }
+}
+
+object ScreenFit {
+    // Compares the short sides, so a vertical video is measured like a horizontal one.
+    fun fits(width: Int, height: Int, screenLines: Int?): Boolean {
+        if (screenLines == null || width <= 0 || height <= 0) return true
+        return minOf(width, height) <= screenLines
+    }
+}
+
+object VideoCodecs {
+    const val H264 = "video/avc"
+    const val H265 = "video/hevc"
+    const val VP9 = "video/x-vnd.on2.vp9"
+    const val AV1 = "video/av01"
+    private const val PQ = "16"
+    private const val HLG = "18"
+
+    fun mimeType(codec: String): String? {
+        val normalized = codec.trim().lowercase()
+        return when {
+            normalized.isEmpty() || normalized.startsWith("avc1") || normalized.startsWith("avc3") -> H264
+            normalized.startsWith("hvc1") || normalized.startsWith("hev1") -> H265
+            normalized.startsWith("vp9") || normalized.startsWith("vp09") -> VP9
+            normalized.startsWith("av01") -> AV1
+            else -> null
+        }
+    }
+
+    // "vp9.2" is the server's label for VP9 profile 2 (10-bit HDR); AV1 and vp09 strings carry the
+    // transfer characteristics (16 is PQ, 18 is HLG) in their seventh field.
+    fun isHdr(codec: String): Boolean {
+        val normalized = codec.trim().lowercase()
+        if (normalized == "vp9.2") return true
+        val fields = normalized.split('.')
+        return when {
+            fields.firstOrNull() == "av01" -> fields.getOrNull(7) in setOf(PQ, HLG)
+            fields.firstOrNull() == "vp09" -> fields.getOrNull(6) in setOf(PQ, HLG)
+            else -> false
+        }
+    }
+
+    // On a hardware decoder the newer codecs give the best picture for the bandwidth; in software AVC is
+    // the cheapest to decode, which is what keeps playback smooth.
+    fun priority(codec: String, support: DecoderSupport): Int {
+        val mime = mimeType(codec)
+        return when (support) {
+            DecoderSupport.Hardware -> when (mime) {
+                AV1 -> 4
+                VP9 -> 3
+                H265 -> 3
+                H264 -> 2
+                else -> 1
+            }
+            DecoderSupport.Software -> when (mime) {
+                H264 -> 4
+                H265 -> 3
+                VP9 -> 3
+                AV1 -> 2
+                else -> 1
+            }
+            DecoderSupport.Unsupported -> 0
+        }
+    }
+}
diff --git a/core/playback/src/main/java/video/typetype/tv/playback/DecoderFailures.kt b/core/playback/src/main/java/video/typetype/tv/playback/DecoderFailures.kt
new file mode 100644
index 0000000..c6f271a
--- /dev/null
+++ b/core/playback/src/main/java/video/typetype/tv/playback/DecoderFailures.kt
@@ -0,0 +1,39 @@
+package video.typetype.tv.playback
+
+import video.typetype.tv.data.device.DeviceStore
+import video.typetype.tv.data.dto.VideoStreamDto
+
+// Codecs whose decoder failed on this box. Some decoders claim a codec and then stop a second after the first frame:
+// the box remembers it, so the next videos open in another codec at once instead of failing first. AVC is never set
+// aside, since every box decodes it and nothing would be left to play.
+class DecoderFailures(private val store: DeviceStore) {
+    @Volatile
+    private var failed: Set<String> = store.text(KEY, "").split(SEPARATOR).filter { it.isNotBlank() }.toSet()
+
+    fun excludes(mimeType: String?): Boolean = mimeType != null && mimeType in failed
+
+    // Returns true when another codec will be used from now on, false when there is nothing left to switch to.
+    @Synchronized
+    fun record(mimeType: String): Boolean {
+        if (mimeType == VideoCodecs.H264 || mimeType in failed) return false
+        failed = failed + mimeType
+        store.putText(KEY, failed.joinToString(SEPARATOR))
+        return true
+    }
+
+    @Synchronized
+    fun forget() {
+        failed = emptySet()
+        store.putText(KEY, "")
+    }
+
+    private companion object {
+        const val KEY = "failed-codecs"
+        const val SEPARATOR = ","
+    }
+}
+
+class LearnedCodecSupport(private val device: CodecSupport, private val failures: DecoderFailures) : CodecSupport {
+    override fun video(stream: VideoStreamDto): DecoderSupport =
+        if (failures.excludes(VideoCodecs.mimeType(stream.codec))) DecoderSupport.Unsupported else device.video(stream)
+}
diff --git a/app/src/main/java/video/typetype/tv/playback/FormatSelector.kt b/core/playback/src/main/java/video/typetype/tv/playback/FormatSelector.kt
similarity index 63%
rename from app/src/main/java/video/typetype/tv/playback/FormatSelector.kt
rename to core/playback/src/main/java/video/typetype/tv/playback/FormatSelector.kt
index 7d6e37d..226a078 100644
--- a/app/src/main/java/video/typetype/tv/playback/FormatSelector.kt
+++ b/core/playback/src/main/java/video/typetype/tv/playback/FormatSelector.kt
@@ -18,34 +18,21 @@ object FormatSelector {
     private const val SABR = "sabr"
     private const val PREFERRED_AUDIO_ITAG = 140
 
-    fun select(stream: StreamDto, maxHeight: Int, audioTrackId: String? = null): PlaybackTuple? {
-        val video = pickVideo(stream.videoOnlyStreams, maxHeight) ?: return null
+    fun select(stream: StreamDto, maxHeight: Int, support: CodecSupport, audioTrackId: String? = null): PlaybackTuple? {
+        val video = VideoRanking.pick(sabrVideo(stream.videoOnlyStreams), maxHeight, support) ?: return null
         val audio = pickAudio(stream.audioStreams, audioTrackId) ?: return null
         return PlaybackTuple(video.itag, audio.itag, audio.audioTrackId, video.height)
     }
 
-    fun heights(stream: StreamDto, maxHeight: Int): List<Int> =
-        compatible(stream.videoOnlyStreams).map { it.height }.filter { it <= maxHeight }.distinct().sortedDescending()
+    fun hasSabrFormats(stream: StreamDto): Boolean =
+        sabrVideo(stream.videoOnlyStreams).isNotEmpty() && stream.audioStreams.any { it.deliveryMethod == SABR && isMp4Audio(it) }
 
-    private fun compatible(streams: List<VideoStreamDto>): List<VideoStreamDto> =
-        streams.filter { it.deliveryMethod == SABR && it.height > 0 && (it.isAvc() || it.isVp9()) }
+    fun heights(stream: StreamDto, maxHeight: Int, support: CodecSupport): List<Int> =
+        VideoRanking.heights(sabrVideo(stream.videoOnlyStreams), maxHeight, support)
 
-    private fun pickVideo(streams: List<VideoStreamDto>, maxHeight: Int): VideoStreamDto? {
-        val candidates = compatible(streams)
-        val capped = candidates.filter { it.height <= maxHeight }.ifEmpty {
-            val lowest = candidates.minOfOrNull { it.height } ?: return null
-            candidates.filter { it.height == lowest }
-        }
-        val ordered = compareByDescending<VideoStreamDto> { it.height }
-            .thenBy { if (it.fps <= COMPATIBLE_FPS) 0 else 1 }
-            .thenByDescending { it.bitrate }
-        return capped.filter { it.isAvc() }.sortedWith(ordered).firstOrNull()
-            ?: capped.filter { it.isVp9() }.sortedWith(ordered).firstOrNull()
-    }
-
-    private fun VideoStreamDto.isAvc() = codec.startsWith("avc1")
-
-    private fun VideoStreamDto.isVp9() = codec.startsWith("vp9") || codec.startsWith("vp09")
+    // The server's SABR contract carries AVC, VP9 and AV1 video, the same set TypeType-Android accepts.
+    private fun sabrVideo(streams: List<VideoStreamDto>): List<VideoStreamDto> =
+        streams.filter { it.deliveryMethod == SABR && it.height > 0 && VideoCodecs.mimeType(it.codec) != null && !it.codec.startsWith("hvc") }
 
     fun audioTracks(stream: StreamDto): List<AudioTrackChoice> =
         stream.audioStreams
@@ -72,6 +59,4 @@ object FormatSelector {
             .sortedWith(compareByDescending<AudioStreamDto> { it.isOriginal }.thenBy { abs(it.itag - PREFERRED_AUDIO_ITAG) })
             .firstOrNull()
     }
-
-    private const val COMPATIBLE_FPS = 30
 }
diff --git a/app/src/main/java/video/typetype/tv/playback/HlsPlayerFactory.kt b/core/playback/src/main/java/video/typetype/tv/playback/HlsPlayerFactory.kt
similarity index 85%
rename from app/src/main/java/video/typetype/tv/playback/HlsPlayerFactory.kt
rename to core/playback/src/main/java/video/typetype/tv/playback/HlsPlayerFactory.kt
index 94a9e7b..42c4299 100644
--- a/app/src/main/java/video/typetype/tv/playback/HlsPlayerFactory.kt
+++ b/core/playback/src/main/java/video/typetype/tv/playback/HlsPlayerFactory.kt
@@ -13,7 +13,7 @@ import video.typetype.tv.data.session.Backend
 
 @UnstableApi
 class HlsPlayerFactory(private val backend: Backend, private val online: () -> Boolean = { true }) {
-    fun open(context: Context, manifest: String): PlayerHandle {
+    fun open(context: Context, manifest: String, maxHeight: Int?): PlayerHandle {
         val address = InstanceUrls.resolve(backend.apiBase, manifest) ?: throw ApiException(
             ApiFailure(FailureCategory.Contract, null, "live_manifest_invalid", "The live address is not valid", null),
         )
@@ -22,8 +22,10 @@ class HlsPlayerFactory(private val backend: Backend, private val online: () -> B
             .setLoadErrorHandlingPolicy(MediaLoadErrorPolicy(online))
             .createMediaSource(MediaItem.fromUri(address))
         player.setMediaSource(source)
+        val handle = PlayerHandle(player = player, isLive = true)
+        handle.capVideoHeight(maxHeight)
         player.prepare()
         player.playWhenReady = true
-        return PlayerHandle(player = player, isLive = true)
+        return handle
     }
 }
diff --git a/core/playback/src/main/java/video/typetype/tv/playback/KeyframeStart.kt b/core/playback/src/main/java/video/typetype/tv/playback/KeyframeStart.kt
new file mode 100644
index 0000000..1735974
--- /dev/null
+++ b/core/playback/src/main/java/video/typetype/tv/playback/KeyframeStart.kt
@@ -0,0 +1,15 @@
+package video.typetype.tv.playback
+
+import dev.typetype.player.PlaybackWindow
+
+object KeyframeStart {
+    // A start inside a segment counts nothing as buffered until that segment is complete; its first key frame does.
+    fun of(window: PlaybackWindow, requestedMs: Long): Long {
+        val requestedUs = requestedMs * MICROS_PER_MILLI
+        val segment = window.video?.segments?.firstOrNull { requestedUs >= it.startPositionUs && requestedUs < it.endPositionUs }
+            ?: return requestedMs
+        return segment.startPositionUs / MICROS_PER_MILLI
+    }
+
+    private const val MICROS_PER_MILLI = 1_000L
+}
diff --git a/app/src/main/java/video/typetype/tv/playback/MediaLoadErrorPolicy.kt b/core/playback/src/main/java/video/typetype/tv/playback/MediaLoadErrorPolicy.kt
similarity index 92%
rename from app/src/main/java/video/typetype/tv/playback/MediaLoadErrorPolicy.kt
rename to core/playback/src/main/java/video/typetype/tv/playback/MediaLoadErrorPolicy.kt
index e8d01d9..f86da26 100644
--- a/app/src/main/java/video/typetype/tv/playback/MediaLoadErrorPolicy.kt
+++ b/core/playback/src/main/java/video/typetype/tv/playback/MediaLoadErrorPolicy.kt
@@ -9,12 +9,10 @@ import androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy
 import java.io.IOException
 import java.util.concurrent.ConcurrentHashMap
 
-/**
- * Retries failed media loads inside the player, so a network hiccup or a busy server never throws the buffer away:
- * SABR "not ready yet" answers follow the server's pace, temporary server errors back off, and a lost connection
- * is waited out (up to ten minutes offline) instead of failing. Only what cannot get better by waiting reaches the
- * player as an error.
- */
+// Retries failed media loads inside the player, so a network hiccup or a busy server never throws the buffer away: SABR
+// "not ready yet" answers follow the server's pace, temporary server errors back off, and a lost connection is waited
+// out (up to ten minutes offline) instead of failing. Only what cannot get better by waiting reaches the player as an
+// error.
 @UnstableApi
 class MediaLoadErrorPolicy(
     private val online: () -> Boolean = { true },
diff --git a/core/playback/src/main/java/video/typetype/tv/playback/PlaybackPreloader.kt b/core/playback/src/main/java/video/typetype/tv/playback/PlaybackPreloader.kt
new file mode 100644
index 0000000..444ac36
--- /dev/null
+++ b/core/playback/src/main/java/video/typetype/tv/playback/PlaybackPreloader.kt
@@ -0,0 +1,26 @@
+package video.typetype.tv.playback
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import video.typetype.tv.data.ContentRepository
+import video.typetype.tv.data.Video
+import java.io.IOException
+
+class PlaybackPreloader(
+    private val repository: ContentRepository,
+    private val provider: PlaybackProvider,
+    private val scope: CoroutineScope,
+) {
+    fun preload(video: Video) {
+        if (video.isLive) return
+        scope.launch {
+            val setup = try {
+                repository.playbackSetup(video.id)
+            } catch (_: IOException) {
+                return@launch
+            }
+            val start = PlaybackRequests.resumeStart(repository, video)
+            provider.preload(video.id, PlaybackRequests.of(setup, start))
+        }
+    }
+}
diff --git a/core/playback/src/main/java/video/typetype/tv/playback/PlaybackProvider.kt b/core/playback/src/main/java/video/typetype/tv/playback/PlaybackProvider.kt
new file mode 100644
index 0000000..2ca28b6
--- /dev/null
+++ b/core/playback/src/main/java/video/typetype/tv/playback/PlaybackProvider.kt
@@ -0,0 +1,83 @@
+package video.typetype.tv.playback
+
+import android.content.Context
+import androidx.media3.common.C
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.media3.exoplayer.analytics.AnalyticsListener
+import video.typetype.tv.data.SubtitleTrack
+import video.typetype.tv.data.dto.StreamDto
+
+data class PlaybackRequest(
+    val startMs: Long = 0L,
+    val maxHeight: Int? = null,
+    val subtitles: List<SubtitleTrack> = emptyList(),
+    val liveManifest: String? = null,
+    val audioTrackId: String? = null,
+    val audioLanguage: String = "",
+    val preferOriginalAudio: Boolean = false,
+    val stream: StreamDto? = null,
+    val trace: StartupTrace? = null,
+    val preview: Boolean = false,
+)
+
+@androidx.annotation.OptIn(UnstableApi::class)
+class PlayerHandle(
+    val player: ExoPlayer,
+    val heights: List<Int> = emptyList(),
+    val captionLanguages: List<CaptionLanguage> = emptyList(),
+    val isLive: Boolean = false,
+    val audioTracks: List<AudioTrackChoice> = emptyList(),
+    val audioTrackId: String? = null,
+    private val onRelease: () -> Unit = {},
+) {
+    // The decoder starts once media arrives, after the handle exists; the statistics can be opened at any time.
+    @Volatile
+    var videoDecoder: String? = null
+        private set
+
+    init {
+        player.addAnalyticsListener(object : AnalyticsListener {
+            override fun onVideoDecoderInitialized(
+                eventTime: AnalyticsListener.EventTime,
+                decoderName: String,
+                initializedTimestampMs: Long,
+                initializationDurationMs: Long,
+            ) {
+                videoDecoder = decoderName
+            }
+        })
+    }
+
+    fun selectCaption(language: String?) {
+        player.trackSelectionParameters = player.trackSelectionParameters.buildUpon()
+            .setTrackTypeDisabled(C.TRACK_TYPE_TEXT, language == null)
+            .apply { if (language != null) setPreferredTextLanguage(language) }
+            .build()
+    }
+
+    // A live stream is adaptive HLS: its quality is capped in place instead of reopening the stream.
+    fun capVideoHeight(height: Int?) {
+        player.trackSelectionParameters = player.trackSelectionParameters.buildUpon()
+            .setMaxVideoSize(Int.MAX_VALUE, height ?: Int.MAX_VALUE)
+            .setMinVideoSize(0, height ?: 0)
+            .build()
+    }
+
+    fun release() {
+        onRelease()
+        player.release()
+    }
+}
+
+data class CaptionLanguage(val tag: String, val label: String)
+
+interface PlaybackProvider {
+    suspend fun open(context: Context, videoUrl: String, request: PlaybackRequest): PlayerHandle
+
+    // Prepares what open() will need for this request, in the background; providers with nothing to prepare ignore it.
+    fun preload(videoUrl: String, request: PlaybackRequest) = Unit
+
+    // A decoder of this codec failed while playing. Returns true when the next open will use another codec.
+    fun decoderFailed(mimeType: String): Boolean = false
+}
diff --git a/core/playback/src/main/java/video/typetype/tv/playback/PlaybackRequests.kt b/core/playback/src/main/java/video/typetype/tv/playback/PlaybackRequests.kt
new file mode 100644
index 0000000..f709edc
--- /dev/null
+++ b/core/playback/src/main/java/video/typetype/tv/playback/PlaybackRequests.kt
@@ -0,0 +1,40 @@
+package video.typetype.tv.playback
+
+import video.typetype.tv.data.PlaybackSetup
+import video.typetype.tv.data.Video
+import video.typetype.tv.data.VideoActivityRepository
+import video.typetype.tv.data.withResume
+import java.io.IOException
+
+// How the player asks for a video. A preload builds the very same request, so the player finds the session that was
+// prepared for it.
+object PlaybackRequests {
+    fun of(
+        setup: PlaybackSetup,
+        startMs: Long,
+        maxHeight: Int? = null,
+        audioTrackId: String? = null,
+        trace: StartupTrace? = null,
+    ) = PlaybackRequest(
+        startMs = startMs,
+        maxHeight = maxHeight ?: setup.preferences.maxHeight,
+        subtitles = setup.subtitles,
+        liveManifest = setup.liveManifest,
+        audioTrackId = audioTrackId,
+        audioLanguage = setup.preferences.audioLanguage,
+        preferOriginalAudio = setup.preferences.preferOriginalAudio,
+        stream = setup.stream,
+        trace = trace,
+    )
+
+    // The same rule as the progress bar on cards: a video barely started or nearly finished starts from the beginning.
+    suspend fun resumeStart(repository: VideoActivityRepository, video: Video?): Long {
+        if (video == null) return 0L
+        val position = try {
+            repository.resumePositionMs(video.id)
+        } catch (_: IOException) {
+            0L
+        }
+        return if (video.withResume(position).resumeFraction != null) position else 0L
+    }
+}
diff --git a/app/src/main/java/video/typetype/tv/playback/PositionTracker.kt b/core/playback/src/main/java/video/typetype/tv/playback/PositionTracker.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/playback/PositionTracker.kt
rename to core/playback/src/main/java/video/typetype/tv/playback/PositionTracker.kt
diff --git a/app/src/main/java/video/typetype/tv/playback/RoutingPlaybackProvider.kt b/core/playback/src/main/java/video/typetype/tv/playback/RoutingPlaybackProvider.kt
similarity index 57%
rename from app/src/main/java/video/typetype/tv/playback/RoutingPlaybackProvider.kt
rename to core/playback/src/main/java/video/typetype/tv/playback/RoutingPlaybackProvider.kt
index 6b389c3..ac6e8d5 100644
--- a/app/src/main/java/video/typetype/tv/playback/RoutingPlaybackProvider.kt
+++ b/core/playback/src/main/java/video/typetype/tv/playback/RoutingPlaybackProvider.kt
@@ -7,15 +7,28 @@ import video.typetype.tv.data.net.ApiException
 import video.typetype.tv.data.net.ApiFailure
 import video.typetype.tv.data.net.FailureCategory
 import video.typetype.tv.data.session.Backend
+import video.typetype.tv.data.session.StreamAccess
 
 @UnstableApi
-class RoutingPlaybackProvider(backend: Backend, online: () -> Boolean = { true }) : PlaybackProvider {
-    private val youtube = SabrPlaybackProvider(backend, online)
-    private val standard = StandardPlaybackProvider(backend, online)
+class RoutingPlaybackProvider(
+    backend: Backend,
+    codecs: CodecSupport,
+    access: StreamAccess,
+    private val failures: DecoderFailures? = null,
+    online: () -> Boolean = { true },
+) : PlaybackProvider {
+    private val youtube = SabrPlaybackProvider(backend, codecs, access, online)
+    private val standard = StandardPlaybackProvider(backend, codecs, access, online)
     private val live = HlsPlayerFactory(backend, online)
 
+    override fun preload(videoUrl: String, request: PlaybackRequest) {
+        if (request.liveManifest == null && ContentSource.of(videoUrl) == ContentSource.YouTube) youtube.preload(videoUrl, request)
+    }
+
+    override fun decoderFailed(mimeType: String): Boolean = failures?.record(mimeType) ?: false
+
     override suspend fun open(context: Context, videoUrl: String, request: PlaybackRequest): PlayerHandle {
-        request.liveManifest?.let { return live.open(context, it) }
+        request.liveManifest?.let { return live.open(context, it, request.maxHeight) }
         return when (ContentSource.of(videoUrl)) {
             ContentSource.YouTube -> youtube.open(context, videoUrl, request)
             ContentSource.BiliBili, ContentSource.NicoNico -> standard.open(context, videoUrl, request)
diff --git a/app/src/main/java/video/typetype/tv/playback/SabrMediaPaths.kt b/core/playback/src/main/java/video/typetype/tv/playback/SabrMediaPaths.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/playback/SabrMediaPaths.kt
rename to core/playback/src/main/java/video/typetype/tv/playback/SabrMediaPaths.kt
diff --git a/core/playback/src/main/java/video/typetype/tv/playback/SabrPlaybackProvider.kt b/core/playback/src/main/java/video/typetype/tv/playback/SabrPlaybackProvider.kt
new file mode 100644
index 0000000..fd3a1b3
--- /dev/null
+++ b/core/playback/src/main/java/video/typetype/tv/playback/SabrPlaybackProvider.kt
@@ -0,0 +1,145 @@
+package video.typetype.tv.playback
+
+import video.typetype.tv.data.VideoIds
+import android.content.Context
+import androidx.media3.common.MediaItem
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.datasource.okhttp.OkHttpDataSource
+import dev.typetype.player.TypeTypeMediaSource
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.ensureActive
+import kotlinx.coroutines.launch
+import video.typetype.tv.data.dto.SabrSessionRequest
+import video.typetype.tv.data.dto.StreamDto
+import video.typetype.tv.data.net.ApiException
+import video.typetype.tv.data.net.ApiFailure
+import video.typetype.tv.data.net.FailureCategory
+import video.typetype.tv.data.net.HttpClients
+import video.typetype.tv.data.session.Backend
+import video.typetype.tv.data.session.StreamAccess
+import java.io.IOException
+
+@UnstableApi
+class SabrPlaybackProvider(
+    private val backend: Backend,
+    private val codecs: CodecSupport,
+    private val access: StreamAccess,
+    private val online: () -> Boolean = { true },
+) : PlaybackProvider {
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+    private val preloads = SabrPreloads<SabrTarget, PreparedSabr>(scope, release = { it.loader.release() })
+
+    private class Plan(val target: SabrTarget, val stream: StreamDto, val tracks: List<AudioTrackChoice>)
+
+    override fun preload(videoUrl: String, request: PlaybackRequest) {
+        scope.launch {
+            val plan = try {
+                plan(videoUrl, request)
+            } catch (_: IOException) {
+                return@launch
+            }
+            preloads.reserve(plan.target) { prepare(plan.target, null) }
+        }
+    }
+
+    override suspend fun open(context: Context, videoUrl: String, request: PlaybackRequest): PlayerHandle {
+        val trace = request.trace
+        val plan = plan(videoUrl, request)
+        trace?.step("bootstrap")
+        val prepared = preloaded(plan.target)?.also { trace?.step("preloaded session") } ?: prepare(plan.target, trace)
+        val loader = prepared.loader
+        val startPositionMs = plan.target.startMs
+        val playFromMs = KeyframeStart.of(prepared.firstWindow, startPositionMs)
+        val player = TvPlayers.create(context, request.preview)
+        trace?.step("player")
+        val tracker = PositionTracker(player).also { it.start() }
+        val media = TypeTypeMediaSource(
+            mediaItem = MediaItem.Builder().setMediaId(plan.target.videoId).build(),
+            initialPositionUs = playFromMs * MICROS_PER_MILLI,
+            initialWindow = prepared.firstWindow,
+            playbackPositionUs = { tracker.currentMs() * MICROS_PER_MILLI },
+            windowLoader = loader,
+            dataSourceFactory = SabrRetryDataSource.Factory(OkHttpDataSource.Factory(backend.mediaHttp)),
+            loadErrorHandlingPolicy = MediaLoadErrorPolicy(online),
+        )
+        val captions = CaptionChoice.languages(request.subtitles)
+        val source = SubtitleSources.attach(media, captions, OkHttpDataSource.Factory(subtitleHttp))
+        player.setMediaSource(source, playFromMs)
+        player.prepare()
+        player.playWhenReady = true
+        trace?.let {
+            player.addListener(FirstFrameTrace(it))
+            player.addAnalyticsListener(StartupLoads(it))
+        }
+        return PlayerHandle(
+            player = player,
+            heights = FormatSelector.heights(plan.stream, Int.MAX_VALUE, codecs),
+            audioTracks = plan.tracks,
+            audioTrackId = plan.target.tuple.audioTrackId,
+            captionLanguages = captions.map { CaptionLanguage(it.language, it.label) },
+        ) {
+            tracker.stop()
+            loader.release()
+        }
+    }
+
+    private suspend fun plan(videoUrl: String, request: PlaybackRequest): Plan {
+        val videoId = VideoIds.parse(videoUrl) ?: failure("The video address is not supported")
+        val stream = request.stream?.takeIf(FormatSelector::hasSabrFormats)
+            ?: access.anonymousFirst { backend.api.streamBootstrap(videoUrl, it) }
+        val tracks = FormatSelector.audioTracks(stream)
+        val chosenTrack = request.audioTrackId?.takeIf { id -> tracks.any { it.id == id } }
+            ?: FormatSelector.defaultAudioTrack(tracks, request.audioLanguage, request.preferOriginalAudio)
+        val tuple = FormatSelector.select(stream, request.maxHeight ?: Int.MAX_VALUE, codecs, chosenTrack)
+            ?: failure("No compatible video format")
+        return Plan(SabrTarget(videoId, tuple, request.startMs), stream, tracks)
+    }
+
+    private suspend fun prepare(target: SabrTarget, trace: StartupTrace?): PreparedSabr {
+        val tuple = target.tuple
+        val sessionRequest = SabrSessionRequest(tuple.videoItag, tuple.audioItag, tuple.audioTrackId, target.startMs, target.startMs)
+        val created = access.anonymousFirst { backend.sabr.createSession(target.videoId, sessionRequest, it) }
+        trace?.step("session")
+        val session = SabrSession(target.videoId, tuple, created)
+        val loader = SabrWindowLoader(
+            backend.sabr,
+            session,
+            SabrWindowMapper(backend.apiBase),
+            CoroutineScope(SupervisorJob() + Dispatchers.IO),
+        )
+        val firstWindow = try {
+            loader.firstWindow(target.startMs)
+        } catch (error: Throwable) {
+            loader.release()
+            throw error
+        }
+        trace?.step("first window")
+        return PreparedSabr(session, loader, firstWindow)
+    }
+
+    // A preparation that failed, or was dropped, leaves the player to prepare its own session.
+    private suspend fun preloaded(target: SabrTarget): PreparedSabr? {
+        val pending = preloads.take(target) ?: return null
+        return try {
+            pending.await()
+        } catch (cancelled: CancellationException) {
+            currentCoroutineContext().ensureActive()
+            null
+        } catch (_: IOException) {
+            null
+        }
+    }
+
+    private val subtitleHttp by lazy { HttpClients.subtitles() }
+
+    private fun failure(message: String): Nothing =
+        throw ApiException(ApiFailure(FailureCategory.Contract, null, "playback_unavailable", message, null))
+
+    private companion object {
+        const val MICROS_PER_MILLI = 1_000L
+    }
+}
diff --git a/core/playback/src/main/java/video/typetype/tv/playback/SabrPreloads.kt b/core/playback/src/main/java/video/typetype/tv/playback/SabrPreloads.kt
new file mode 100644
index 0000000..86827cf
--- /dev/null
+++ b/core/playback/src/main/java/video/typetype/tv/playback/SabrPreloads.kt
@@ -0,0 +1,62 @@
+package video.typetype.tv.playback
+
+import android.os.SystemClock
+import dev.typetype.player.PlaybackWindow
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.async
+
+internal class PreparedSabr(val session: SabrSession, val loader: SabrWindowLoader, val firstWindow: PlaybackWindow)
+
+internal data class SabrTarget(val videoId: String, val tuple: PlaybackTuple, val startMs: Long)
+
+// Like the Android app, the session of a video about to be played is prepared ahead, so its first window is ready when
+// the player opens it. Two at most, each kept two minutes, well within the four minutes the server keeps an idle
+// session; one never played is released.
+internal class SabrPreloads<K, T : Any>(
+    private val scope: CoroutineScope,
+    private val release: (T) -> Unit,
+    private val clock: () -> Long = SystemClock::elapsedRealtime,
+    private val ttlMillis: Long = TTL_MILLIS,
+) {
+    private inner class Entry(prepare: suspend () -> T) {
+        @Volatile
+        private var prepared: T? = null
+        val result: Deferred<T> = scope.async { prepare().also { prepared = it } }
+        val expiresAt = clock() + ttlMillis
+
+        fun discard() {
+            result.cancel()
+            prepared?.let(release)
+        }
+    }
+
+    private val entries = LinkedHashMap<K, Entry>()
+
+    // With two preparations already waiting, the oldest is released to make room for the new one.
+    @Synchronized
+    fun reserve(target: K, prepare: suspend () -> T) {
+        dropExpired()
+        if (target in entries) return
+        if (entries.size >= MAX_PRELOADS) entries.remove(entries.keys.first())?.discard()
+        entries[target] = Entry(prepare)
+    }
+
+    // Hands the preparation over to the player, which owns its session from then on.
+    @Synchronized
+    fun take(target: K): Deferred<T>? {
+        dropExpired()
+        return entries.remove(target)?.result
+    }
+
+    private fun dropExpired() {
+        val now = clock()
+        val expired = entries.filterValues { it.expiresAt <= now }.keys
+        expired.forEach { entries.remove(it)?.discard() }
+    }
+
+    private companion object {
+        const val MAX_PRELOADS = 2
+        const val TTL_MILLIS = 120_000L
+    }
+}
diff --git a/app/src/main/java/video/typetype/tv/playback/SabrRetryDataSource.kt b/core/playback/src/main/java/video/typetype/tv/playback/SabrRetryDataSource.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/playback/SabrRetryDataSource.kt
rename to core/playback/src/main/java/video/typetype/tv/playback/SabrRetryDataSource.kt
diff --git a/app/src/main/java/video/typetype/tv/playback/SabrSession.kt b/core/playback/src/main/java/video/typetype/tv/playback/SabrSession.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/playback/SabrSession.kt
rename to core/playback/src/main/java/video/typetype/tv/playback/SabrSession.kt
diff --git a/app/src/main/java/video/typetype/tv/playback/SabrWindowLoader.kt b/core/playback/src/main/java/video/typetype/tv/playback/SabrWindowLoader.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/playback/SabrWindowLoader.kt
rename to core/playback/src/main/java/video/typetype/tv/playback/SabrWindowLoader.kt
diff --git a/app/src/main/java/video/typetype/tv/playback/SabrWindowMapper.kt b/core/playback/src/main/java/video/typetype/tv/playback/SabrWindowMapper.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/playback/SabrWindowMapper.kt
rename to core/playback/src/main/java/video/typetype/tv/playback/SabrWindowMapper.kt
diff --git a/app/src/main/java/video/typetype/tv/playback/StandardFormatSelector.kt b/core/playback/src/main/java/video/typetype/tv/playback/StandardFormatSelector.kt
similarity index 58%
rename from app/src/main/java/video/typetype/tv/playback/StandardFormatSelector.kt
rename to core/playback/src/main/java/video/typetype/tv/playback/StandardFormatSelector.kt
index 35276a3..c12a079 100644
--- a/app/src/main/java/video/typetype/tv/playback/StandardFormatSelector.kt
+++ b/core/playback/src/main/java/video/typetype/tv/playback/StandardFormatSelector.kt
@@ -16,19 +16,14 @@ object StandardFormatSelector {
     fun heightOf(stream: VideoStreamDto): Int =
         if (stream.height > 0) stream.height else stream.resolution.takeWhile { it.isDigit() }.toIntOrNull() ?: 0
 
-    fun select(stream: StreamDto, maxHeight: Int): StandardSelection? {
-        val candidates = stream.videoOnlyStreams.filter { it.url.isNotBlank() && it.deliveryMethod in DELIVERY && isAvc(it) }
-        if (candidates.isEmpty()) return null
+    // Bilibili lists AVC, HEVC and AV1 at every height; NicoNico's HLS variants carry no codec and are AVC.
+    fun select(stream: StreamDto, maxHeight: Int, support: CodecSupport): StandardSelection? {
+        val candidates = stream.videoOnlyStreams.filter { it.url.isNotBlank() && it.deliveryMethod in DELIVERY }
         val audio = pickAudio(stream.audioStreams) ?: return null
-        val ordered = compareByDescending<VideoStreamDto> { heightOf(it) }.thenByDescending { it.bitrate }
-        val capped = candidates.filter { heightOf(it) <= maxHeight }
-        val video = capped.sortedWith(ordered).firstOrNull() ?: candidates.minByOrNull { heightOf(it) } ?: return null
-        val heights = candidates.map { heightOf(it) }.filter { it in 1..maxHeight }.distinct().sortedDescending()
-        return StandardSelection(video, audio, heights)
+        val video = VideoRanking.pick(candidates, maxHeight, support, ::heightOf) ?: return null
+        return StandardSelection(video, audio, VideoRanking.heights(candidates, Int.MAX_VALUE, support, ::heightOf))
     }
 
-    private fun isAvc(stream: VideoStreamDto): Boolean = stream.codec.isBlank() || stream.codec.startsWith("avc1")
-
     private fun pickAudio(streams: List<AudioStreamDto>): AudioStreamDto? =
         streams.filter { it.url.isNotBlank() && it.deliveryMethod in DELIVERY && (it.codec.isBlank() || it.codec.startsWith("mp4a")) }
             .sortedWith(compareByDescending<AudioStreamDto> { it.bitrate }.thenByDescending { it.quality.toIntOrNull() ?: 0 })
diff --git a/app/src/main/java/video/typetype/tv/playback/StandardPlaybackProvider.kt b/core/playback/src/main/java/video/typetype/tv/playback/StandardPlaybackProvider.kt
similarity index 86%
rename from app/src/main/java/video/typetype/tv/playback/StandardPlaybackProvider.kt
rename to core/playback/src/main/java/video/typetype/tv/playback/StandardPlaybackProvider.kt
index a31b63e..85a87cf 100644
--- a/app/src/main/java/video/typetype/tv/playback/StandardPlaybackProvider.kt
+++ b/core/playback/src/main/java/video/typetype/tv/playback/StandardPlaybackProvider.kt
@@ -15,18 +15,19 @@ import video.typetype.tv.data.net.ApiException
 import video.typetype.tv.data.net.ApiFailure
 import video.typetype.tv.data.net.FailureCategory
 import video.typetype.tv.data.session.Backend
+import video.typetype.tv.data.session.StreamAccess
 
 @UnstableApi
 class StandardPlaybackProvider(
     private val backend: Backend,
+    private val codecs: CodecSupport,
+    private val access: StreamAccess,
     private val online: () -> Boolean = { true },
-    private val maxHeight: () -> Int = { DeviceDecoders.maxAvcHeight() },
 ) {
     suspend fun open(context: Context, videoUrl: String, request: PlaybackRequest): PlayerHandle {
         val source = ContentSource.of(videoUrl) ?: failure("unsupported_source", "This video source is not supported")
-        val stream = backend.api.streamFor(videoUrl)
-        val deviceLimit = maxHeight()
-        val selection = StandardFormatSelector.select(stream, minOf(deviceLimit, request.maxHeight ?: deviceLimit))
+        val stream = access.anonymousFirst { backend.api.streamFor(videoUrl, it) }
+        val selection = StandardFormatSelector.select(stream, request.maxHeight ?: Int.MAX_VALUE, codecs)
             ?: failure("playback_unavailable", "No compatible video format")
         val factory = OkHttpDataSource.Factory(backend.mediaHttp)
         val hls = source == ContentSource.NicoNico
@@ -34,7 +35,7 @@ class StandardPlaybackProvider(
             mediaSource(selection.video.url, hls, factory),
             mediaSource(selection.audio.url, hls, factory),
         )
-        val player = TvPlayers.create(context)
+        val player = TvPlayers.create(context, request.preview)
         player.setMediaSource(merged, request.startMs)
         player.prepare()
         player.playWhenReady = true
diff --git a/app/src/main/java/video/typetype/tv/playback/StartupTrace.kt b/core/playback/src/main/java/video/typetype/tv/playback/StartupTrace.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/playback/StartupTrace.kt
rename to core/playback/src/main/java/video/typetype/tv/playback/StartupTrace.kt
diff --git a/app/src/main/java/video/typetype/tv/playback/SubtitleSources.kt b/core/playback/src/main/java/video/typetype/tv/playback/SubtitleSources.kt
similarity index 56%
rename from app/src/main/java/video/typetype/tv/playback/SubtitleSources.kt
rename to core/playback/src/main/java/video/typetype/tv/playback/SubtitleSources.kt
index cee7737..3e6737d 100644
--- a/app/src/main/java/video/typetype/tv/playback/SubtitleSources.kt
+++ b/core/playback/src/main/java/video/typetype/tv/playback/SubtitleSources.kt
@@ -1,16 +1,14 @@
 package video.typetype.tv.playback
 
 import android.net.Uri
-import androidx.media3.common.Format
+import androidx.media3.common.C
 import androidx.media3.common.MediaItem
 import androidx.media3.common.MimeTypes
 import androidx.media3.common.util.UnstableApi
 import androidx.media3.datasource.DataSource
 import androidx.media3.exoplayer.source.MediaSource
 import androidx.media3.exoplayer.source.MergingMediaSource
-import androidx.media3.exoplayer.source.ProgressiveMediaSource
-import androidx.media3.extractor.text.DefaultSubtitleParserFactory
-import androidx.media3.extractor.text.SubtitleExtractor
+import androidx.media3.exoplayer.source.SingleSampleMediaSource
 import video.typetype.tv.data.SubtitleTrack
 
 @UnstableApi
@@ -20,15 +18,13 @@ object SubtitleSources {
         return MergingMediaSource(base, *tracks.map { sideload(it, factory) }.toTypedArray())
     }
 
+    // Declares the track at once and downloads the file only if captions are shown, so playback never waits for it.
     private fun sideload(track: SubtitleTrack, factory: DataSource.Factory): MediaSource {
-        val format = Format.Builder()
-            .setSampleMimeType(track.mimeType.ifBlank { MimeTypes.APPLICATION_TTML })
+        val subtitle = MediaItem.SubtitleConfiguration.Builder(Uri.parse(track.url))
+            .setMimeType(track.mimeType.ifBlank { MimeTypes.APPLICATION_TTML })
             .setLanguage(track.language)
             .setLabel(track.label)
             .build()
-        val parsers = DefaultSubtitleParserFactory()
-        val extractors = androidx.media3.extractor.ExtractorsFactory { arrayOf(SubtitleExtractor(parsers.create(format), format)) }
-        return ProgressiveMediaSource.Factory(factory, extractors)
-            .createMediaSource(MediaItem.fromUri(Uri.parse(track.url)))
+        return SingleSampleMediaSource.Factory(factory).createMediaSource(subtitle, C.TIME_UNSET)
     }
 }
diff --git a/core/playback/src/main/java/video/typetype/tv/playback/TvPlayers.kt b/core/playback/src/main/java/video/typetype/tv/playback/TvPlayers.kt
new file mode 100644
index 0000000..72e7f37
--- /dev/null
+++ b/core/playback/src/main/java/video/typetype/tv/playback/TvPlayers.kt
@@ -0,0 +1,92 @@
+package video.typetype.tv.playback
+
+import android.app.ActivityManager
+import android.content.Context
+import android.os.Looper
+import androidx.media3.common.util.ExperimentalApi
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.DefaultLoadControl
+import androidx.media3.exoplayer.DefaultRenderersFactory
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.media3.exoplayer.Renderer
+import androidx.media3.exoplayer.SeekParameters
+import androidx.media3.exoplayer.text.TextOutput
+import androidx.media3.exoplayer.text.TextRenderer
+
+// Every player of the app is built here. ExoPlayer's defaults wait for 2.5 s of media before starting and 5 s after a
+// stall and keep 50 s ahead with no memory cap: slow starts and recoveries, and an out-of-memory risk on TV boxes whose
+// Java heap (where the media buffer lives) is often 128 MB. Here the player keeps 10 to 20 s ahead and 10 s behind,
+// capped in bytes by the device memory class, starts after 1 s and resumes 2 s after a stall. Seeks land on the nearest
+// key frame, as on the web player.
+@UnstableApi
+object TvPlayers {
+    fun create(context: Context, preview: Boolean = false): ExoPlayer {
+        val budget = if (preview) BufferBudget.PREVIEW else BufferBudget.forDevice(context)
+        val loadControl = DefaultLoadControl.Builder()
+            .setBufferDurationsMs(budget.minBufferMs, budget.maxBufferMs, budget.startMs, budget.afterStallMs)
+            .setTargetBufferBytes(budget.targetBytes)
+            .setPrioritizeTimeOverSizeThresholds(false)
+            .setBackBuffer(budget.backBufferMs, true)
+            .build()
+        // A decoder that refuses to start leaves the next one able to play the format, often the software one.
+        return ExoPlayer.Builder(context, SideloadedTextRenderers(context).setEnableDecoderFallback(true))
+            .setLoadControl(loadControl)
+            .setSeekParameters(SeekParameters.CLOSEST_SYNC)
+            .build()
+            // A preview stays silent through the volume: the SABR source needs its audio track selected to
+            // keep loading windows, so the track cannot simply be disabled.
+            .also { if (preview) it.volume = 0f }
+    }
+}
+
+@UnstableApi
+private class SideloadedTextRenderers(context: Context) : DefaultRenderersFactory(context) {
+    @androidx.annotation.OptIn(ExperimentalApi::class)
+    override fun buildTextRenderers(
+        context: Context,
+        output: TextOutput,
+        outputLooper: Looper,
+        extensionRendererMode: Int,
+        out: ArrayList<Renderer>,
+    ) {
+        super.buildTextRenderers(context, output, outputLooper, extensionRendererMode, out)
+        out.filterIsInstance<TextRenderer>().forEach { it.experimentalSetLegacyDecodingEnabled(true) }
+    }
+}
+
+data class BufferBudget(
+    val minBufferMs: Int = 10_000,
+    val maxBufferMs: Int = 20_000,
+    val startMs: Int = 1_000,
+    val afterStallMs: Int = 2_000,
+    val backBufferMs: Int = 10_000,
+    val targetBytes: Int,
+) {
+    companion object {
+        private const val MEBIBYTE = 1024 * 1024
+        private const val SMALL_HEAP_MB = 128
+        private const val MEDIUM_HEAP_MB = 192
+
+        // A muted preview behind the browse screens only needs a few seconds ahead and nothing behind; it can
+        // briefly live next to the real player while a screen transition runs, on a 128 MB heap.
+        val PREVIEW = BufferBudget(
+            minBufferMs = 4_000,
+            maxBufferMs = 8_000,
+            backBufferMs = 0,
+            targetBytes = 6 * MEBIBYTE,
+        )
+
+        fun forMemory(memoryClassMb: Int, lowRam: Boolean): BufferBudget = BufferBudget(
+            targetBytes = when {
+                lowRam || memoryClassMb <= SMALL_HEAP_MB -> 20 * MEBIBYTE
+                memoryClassMb <= MEDIUM_HEAP_MB -> 32 * MEBIBYTE
+                else -> 48 * MEBIBYTE
+            },
+        )
+
+        fun forDevice(context: Context): BufferBudget {
+            val manager = context.getSystemService(ActivityManager::class.java)
+            return forMemory(manager?.memoryClass ?: SMALL_HEAP_MB, manager?.isLowRamDevice ?: true)
+        }
+    }
+}
diff --git a/core/playback/src/main/java/video/typetype/tv/playback/VideoRanking.kt b/core/playback/src/main/java/video/typetype/tv/playback/VideoRanking.kt
new file mode 100644
index 0000000..625203b
--- /dev/null
+++ b/core/playback/src/main/java/video/typetype/tv/playback/VideoRanking.kt
@@ -0,0 +1,43 @@
+package video.typetype.tv.playback
+
+import video.typetype.tv.data.dto.VideoStreamDto
+
+// Hardware decoding first, then height, then the codec that suits that decoder, as TypeType-Android ranks
+// its "recommended" choice. A capped height keeps the user's quality choice; with nothing under the cap,
+// the lowest playable format is used rather than failing.
+object VideoRanking {
+    private class Candidate(val stream: VideoStreamDto, val height: Int, val support: DecoderSupport)
+
+    fun pick(
+        streams: List<VideoStreamDto>,
+        maxHeight: Int,
+        support: CodecSupport,
+        heightOf: (VideoStreamDto) -> Int = { it.height },
+    ): VideoStreamDto? {
+        val playable = playable(streams, support, heightOf)
+        val capped = playable.filter { it.height <= maxHeight }
+        val ranked = compareBy<Candidate> { it.support.rank }
+            .thenBy { it.height }
+            .thenBy { VideoCodecs.priority(it.stream.codec, it.support) }
+            .thenBy { it.stream.fps }
+            .thenBy { it.stream.bitrate }
+        return capped.maxWithOrNull(ranked)?.stream
+            ?: playable.minWithOrNull(
+                compareBy<Candidate> { it.height }.thenByDescending { it.support.rank },
+            )?.stream
+    }
+
+    fun heights(
+        streams: List<VideoStreamDto>,
+        maxHeight: Int,
+        support: CodecSupport,
+        heightOf: (VideoStreamDto) -> Int = { it.height },
+    ): List<Int> = playable(streams, support, heightOf).map { it.height }.filter { it <= maxHeight }.distinct().sortedDescending()
+
+    private fun playable(streams: List<VideoStreamDto>, support: CodecSupport, heightOf: (VideoStreamDto) -> Int) =
+        streams.mapNotNull { stream ->
+            val height = heightOf(stream)
+            val decoder = support.video(stream)
+            if (height <= 0 || decoder == DecoderSupport.Unsupported) null else Candidate(stream, height, decoder)
+        }
+}
diff --git a/app/src/test/java/video/typetype/tv/playback/BufferBudgetTest.kt b/core/playback/src/test/java/video/typetype/tv/playback/BufferBudgetTest.kt
similarity index 76%
rename from app/src/test/java/video/typetype/tv/playback/BufferBudgetTest.kt
rename to core/playback/src/test/java/video/typetype/tv/playback/BufferBudgetTest.kt
index 29f75ee..3e84a7c 100644
--- a/app/src/test/java/video/typetype/tv/playback/BufferBudgetTest.kt
+++ b/core/playback/src/test/java/video/typetype/tv/playback/BufferBudgetTest.kt
@@ -20,4 +20,11 @@ class BufferBudgetTest {
         assertEquals(20_000, budget.maxBufferMs)
         assertEquals(10_000, budget.backBufferMs)
     }
+
+    @Test
+    fun previewsKeepAFewSecondsAndNothingBehind() {
+        assertEquals(0, BufferBudget.PREVIEW.backBufferMs)
+        assertEquals(6 * 1024 * 1024, BufferBudget.PREVIEW.targetBytes)
+        assertEquals(8_000, BufferBudget.PREVIEW.maxBufferMs)
+    }
 }
diff --git a/app/src/test/java/video/typetype/tv/playback/CaptionChoiceTest.kt b/core/playback/src/test/java/video/typetype/tv/playback/CaptionChoiceTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/playback/CaptionChoiceTest.kt
rename to core/playback/src/test/java/video/typetype/tv/playback/CaptionChoiceTest.kt
diff --git a/core/playback/src/test/java/video/typetype/tv/playback/DecoderFailuresTest.kt b/core/playback/src/test/java/video/typetype/tv/playback/DecoderFailuresTest.kt
new file mode 100644
index 0000000..05a00e2
--- /dev/null
+++ b/core/playback/src/test/java/video/typetype/tv/playback/DecoderFailuresTest.kt
@@ -0,0 +1,53 @@
+package video.typetype.tv.playback
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import video.typetype.tv.data.device.DeviceStore
+import video.typetype.tv.data.dto.VideoStreamDto
+
+class DecoderFailuresTest {
+    private class MemoryStore : DeviceStore {
+        val texts = mutableMapOf<String, String>()
+        override fun flag(key: String, fallback: Boolean) = fallback
+        override fun putFlag(key: String, value: Boolean) = Unit
+        override fun text(key: String, fallback: String) = texts[key] ?: fallback
+        override fun putText(key: String, value: String) {
+            texts[key] = value
+        }
+    }
+
+    private val store = MemoryStore()
+
+    @Test
+    fun aFailedCodecIsSetAsideOnThisBoxForGood() {
+        val failures = DecoderFailures(store)
+        assertTrue(failures.record(VideoCodecs.VP9))
+        assertTrue(failures.excludes(VideoCodecs.VP9))
+        assertTrue(DecoderFailures(store).excludes(VideoCodecs.VP9))
+        assertFalse(failures.record(VideoCodecs.VP9))
+    }
+
+    @Test
+    fun avcIsNeverSetAside() {
+        val failures = DecoderFailures(store)
+        assertFalse(failures.record(VideoCodecs.H264))
+        assertFalse(failures.excludes(VideoCodecs.H264))
+    }
+
+    @Test
+    fun theLearnedSupportHidesTheFailedCodecOnly() {
+        val failures = DecoderFailures(store).also { it.record(VideoCodecs.VP9) }
+        val support = LearnedCodecSupport({ DecoderSupport.Hardware }, failures)
+        assertEquals(DecoderSupport.Unsupported, support.video(VideoStreamDto(codec = "vp9", height = 1080)))
+        assertEquals(DecoderSupport.Hardware, support.video(VideoStreamDto(codec = "avc1.640028", height = 1080)))
+    }
+
+    @Test
+    fun forgettingGivesEveryCodecAnotherChance() {
+        val failures = DecoderFailures(store).also { it.record(VideoCodecs.AV1) }
+        failures.forget()
+        assertFalse(DecoderFailures(store).excludes(VideoCodecs.AV1))
+    }
+}
diff --git a/core/playback/src/test/java/video/typetype/tv/playback/FakeCodecSupport.kt b/core/playback/src/test/java/video/typetype/tv/playback/FakeCodecSupport.kt
new file mode 100644
index 0000000..94ff7ad
--- /dev/null
+++ b/core/playback/src/test/java/video/typetype/tv/playback/FakeCodecSupport.kt
@@ -0,0 +1,14 @@
+package video.typetype.tv.playback
+
+import video.typetype.tv.data.dto.VideoStreamDto
+
+class FakeCodecSupport(
+    private val byPrefix: Map<String, DecoderSupport> = mapOf("avc1" to DecoderSupport.Software, "vp9" to DecoderSupport.Software, "hvc1" to DecoderSupport.Software),
+    private val rejects: (VideoStreamDto) -> Boolean = { false },
+) : CodecSupport {
+    override fun video(stream: VideoStreamDto): DecoderSupport {
+        if (rejects(stream)) return DecoderSupport.Unsupported
+        val codec = stream.codec.ifBlank { "avc1" }
+        return byPrefix.entries.firstOrNull { codec.startsWith(it.key) }?.value ?: DecoderSupport.Unsupported
+    }
+}
diff --git a/app/src/test/java/video/typetype/tv/playback/FormatSelectorTest.kt b/core/playback/src/test/java/video/typetype/tv/playback/FormatSelectorTest.kt
similarity index 66%
rename from app/src/test/java/video/typetype/tv/playback/FormatSelectorTest.kt
rename to core/playback/src/test/java/video/typetype/tv/playback/FormatSelectorTest.kt
index f0e457a..277a335 100644
--- a/app/src/test/java/video/typetype/tv/playback/FormatSelectorTest.kt
+++ b/core/playback/src/test/java/video/typetype/tv/playback/FormatSelectorTest.kt
@@ -8,6 +8,8 @@ import video.typetype.tv.data.dto.StreamDto
 import video.typetype.tv.data.dto.VideoStreamDto
 
 class FormatSelectorTest {
+    private val software = FakeCodecSupport()
+
     private fun video(itag: Int, codec: String, height: Int, fps: Int = 30, bitrate: Int = 1_000, method: String = "sabr") =
         VideoStreamDto(itag, codec, "video/mp4", height * 16 / 9, height, fps, bitrate, method)
 
@@ -23,7 +25,7 @@ class FormatSelectorTest {
             videoOnlyStreams = listOf(video(137, "avc1.640028", 1080), video(136, "avc1.4d401f", 720), video(401, "av01.0.12M.08", 2160)),
             audioStreams = listOf(audio(140)),
         )
-        val tuple = FormatSelector.select(stream, 1080)
+        val tuple = FormatSelector.select(stream, 1080, software)
         assertEquals(137, tuple?.videoItag)
         assertEquals(140, tuple?.audioItag)
     }
@@ -34,7 +36,7 @@ class FormatSelectorTest {
             videoOnlyStreams = listOf(video(137, "avc1.640028", 1080), video(136, "avc1.4d401f", 720)),
             audioStreams = listOf(audio(140)),
         )
-        assertEquals(136, FormatSelector.select(stream, 720)?.videoItag)
+        assertEquals(136, FormatSelector.select(stream, 720, software)?.videoItag)
     }
 
     @Test
@@ -43,16 +45,50 @@ class FormatSelectorTest {
             videoOnlyStreams = listOf(video(248, "vp9", 1080), video(401, "av01.0.12M.08", 1080)),
             audioStreams = listOf(audio(140)),
         )
-        assertEquals(248, FormatSelector.select(stream, 1080)?.videoItag)
+        assertEquals(248, FormatSelector.select(stream, 1080, software)?.videoItag)
     }
 
     @Test
-    fun prefersThirtyFramesOverSixtyAtTheSameHeight() {
+    fun prefersSixtyFramesWhenTheDecoderAcceptsThem() {
         val stream = StreamDto(
             videoOnlyStreams = listOf(video(299, "avc1.64002a", 1080, fps = 60), video(137, "avc1.640028", 1080, fps = 30)),
             audioStreams = listOf(audio(140)),
         )
-        assertEquals(137, FormatSelector.select(stream, 1080)?.videoItag)
+        assertEquals(299, FormatSelector.select(stream, 1080, software)?.videoItag)
+        val noSixty = FakeCodecSupport(rejects = { it.fps > 30 })
+        assertEquals(137, FormatSelector.select(stream, 1080, noSixty)?.videoItag)
+    }
+
+    @Test
+    fun aHardwareDecoderUnlocksFourK() {
+        val stream = StreamDto(
+            videoOnlyStreams = listOf(video(299, "avc1.64002a", 1080, fps = 60), video(315, "vp9", 2160, fps = 60), video(701, "av01.0.13M.08", 2160, fps = 60)),
+            audioStreams = listOf(audio(140)),
+        )
+        val hardware = FakeCodecSupport(mapOf("avc1" to DecoderSupport.Hardware, "vp9" to DecoderSupport.Hardware))
+        assertEquals(315, FormatSelector.select(stream, Int.MAX_VALUE, hardware)?.videoItag)
+        assertEquals(299, FormatSelector.select(stream, 1080, hardware)?.videoItag)
+        val withAv1 = FakeCodecSupport(mapOf("avc1" to DecoderSupport.Hardware, "vp9" to DecoderSupport.Hardware, "av01" to DecoderSupport.Hardware))
+        assertEquals(701, FormatSelector.select(stream, Int.MAX_VALUE, withAv1)?.videoItag)
+    }
+
+    @Test
+    fun hardwareDecodingWinsOverAHigherSoftwareFormat() {
+        val stream = StreamDto(
+            videoOnlyStreams = listOf(video(137, "avc1.640028", 1080), video(315, "vp9", 2160)),
+            audioStreams = listOf(audio(140)),
+        )
+        val mixed = FakeCodecSupport(mapOf("avc1" to DecoderSupport.Hardware, "vp9" to DecoderSupport.Software))
+        assertEquals(137, FormatSelector.select(stream, Int.MAX_VALUE, mixed)?.videoItag)
+    }
+
+    @Test
+    fun hdrCodecsAreRecognised() {
+        assertEquals(true, VideoCodecs.isHdr("vp9.2"))
+        assertEquals(true, VideoCodecs.isHdr("av01.0.13M.10.0.110.09.16.09.0"))
+        assertEquals(false, VideoCodecs.isHdr("av01.0.08M.08.0.110.01.01.01.0"))
+        assertEquals(false, VideoCodecs.isHdr("vp9"))
+        assertEquals(false, VideoCodecs.isHdr("avc1.640028"))
     }
 
     @Test
@@ -61,7 +97,7 @@ class FormatSelectorTest {
             videoOnlyStreams = listOf(video(137, "avc1.640028", 1080)),
             audioStreams = listOf(audio(140, original = false, track = "fr.3"), audio(139, original = true, track = "en.4")),
         )
-        val tuple = FormatSelector.select(stream, 1080)
+        val tuple = FormatSelector.select(stream, 1080, software)
         assertEquals(139, tuple?.audioItag)
         assertEquals("en.4", tuple?.audioTrackId)
     }
@@ -72,13 +108,13 @@ class FormatSelectorTest {
             videoOnlyStreams = listOf(video(137, "avc1.640028", 1080, method = "progressive_http")),
             audioStreams = listOf(audio(140)),
         )
-        assertNull(FormatSelector.select(stream, 1080))
+        assertNull(FormatSelector.select(stream, 1080, software))
     }
 
     @Test
     fun returnsNothingWithoutAudio() {
         val stream = StreamDto(videoOnlyStreams = listOf(video(137, "avc1.640028", 1080)))
-        assertNull(FormatSelector.select(stream, 1080))
+        assertNull(FormatSelector.select(stream, 1080, software))
     }
 
     @Test
@@ -90,8 +126,8 @@ class FormatSelectorTest {
             ),
             audioStreams = listOf(audio(140)),
         )
-        assertEquals(listOf(1080, 720, 480), FormatSelector.heights(stream, 1080))
-        assertEquals(listOf(480), FormatSelector.heights(stream, 480))
+        assertEquals(listOf(1080, 720, 480), FormatSelector.heights(stream, 1080, software))
+        assertEquals(listOf(480), FormatSelector.heights(stream, 480, software))
     }
 
     @Test
@@ -100,7 +136,7 @@ class FormatSelectorTest {
             videoOnlyStreams = listOf(video(136, "avc1.4d401f", 720), video(135, "avc1.4d401e", 480)),
             audioStreams = listOf(audio(140)),
         )
-        assertEquals(135, FormatSelector.select(stream, 240)?.videoItag)
+        assertEquals(135, FormatSelector.select(stream, 240, software)?.videoItag)
     }
 
     private fun dubbed(itag: Int, track: String, name: String, locale: String, original: Boolean = false) =
@@ -125,8 +161,8 @@ class FormatSelectorTest {
 
     @Test
     fun selectsTheRequestedAudioTrack() {
-        assertEquals("fr-FR.10", FormatSelector.select(multiAudio, 1080, "fr-FR.10")?.audioTrackId)
-        assertEquals("en-US.4", FormatSelector.select(multiAudio, 1080, "unknown")?.audioTrackId)
+        assertEquals("fr-FR.10", FormatSelector.select(multiAudio, 1080, software, "fr-FR.10")?.audioTrackId)
+        assertEquals("en-US.4", FormatSelector.select(multiAudio, 1080, software, "unknown")?.audioTrackId)
     }
 
     @Test
diff --git a/core/playback/src/test/java/video/typetype/tv/playback/KeyframeStartTest.kt b/core/playback/src/test/java/video/typetype/tv/playback/KeyframeStartTest.kt
new file mode 100644
index 0000000..6a930a6
--- /dev/null
+++ b/core/playback/src/test/java/video/typetype/tv/playback/KeyframeStartTest.kt
@@ -0,0 +1,42 @@
+package video.typetype.tv.playback
+
+import dev.typetype.player.PlaybackSegment
+import dev.typetype.player.PlaybackTrack
+import dev.typetype.player.PlaybackTrackKind
+import dev.typetype.player.PlaybackWindow
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class KeyframeStartTest {
+    private fun track(kind: PlaybackTrackKind, vararg startsMs: Long, lengthMs: Long) = PlaybackTrack(
+        kind = kind,
+        id = kind.name,
+        mimeType = "video/mp4",
+        initializationUrl = "/init",
+        segments = startsMs.map { PlaybackSegment("/s$it", it * 1_000, lengthMs * 1_000) },
+    )
+
+    private val window = PlaybackWindow(
+        generation = 0,
+        durationUs = 60_000_000,
+        startPositionUs = 10_240_000,
+        endOfStream = false,
+        audio = track(PlaybackTrackKind.Audio, 10_000, 20_000, lengthMs = 10_000),
+        video = track(PlaybackTrackKind.Video, 10_240, 15_360, lengthMs = 5_120),
+    )
+
+    @Test
+    fun aResumeInsideASegmentStartsAtItsFirstKeyFrame() {
+        assertEquals(15_360L, KeyframeStart.of(window, 17_000))
+    }
+
+    @Test
+    fun aStartOnASegmentBoundaryIsKept() {
+        assertEquals(10_240L, KeyframeStart.of(window, 10_240))
+    }
+
+    @Test
+    fun aStartOutsideTheWindowIsKept() {
+        assertEquals(42_000L, KeyframeStart.of(window, 42_000))
+    }
+}
diff --git a/app/src/test/java/video/typetype/tv/playback/SabrMediaPathsTest.kt b/core/playback/src/test/java/video/typetype/tv/playback/SabrMediaPathsTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/playback/SabrMediaPathsTest.kt
rename to core/playback/src/test/java/video/typetype/tv/playback/SabrMediaPathsTest.kt
diff --git a/core/playback/src/test/java/video/typetype/tv/playback/SabrPreloadsTest.kt b/core/playback/src/test/java/video/typetype/tv/playback/SabrPreloadsTest.kt
new file mode 100644
index 0000000..b795f19
--- /dev/null
+++ b/core/playback/src/test/java/video/typetype/tv/playback/SabrPreloadsTest.kt
@@ -0,0 +1,59 @@
+package video.typetype.tv.playback
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class SabrPreloadsTest {
+    private val released = mutableListOf<String>()
+    private var now = 0L
+    private val preloads = SabrPreloads<String, String>(
+        scope = CoroutineScope(Dispatchers.Unconfined),
+        release = { released += it },
+        clock = { now },
+        ttlMillis = 1_000L,
+    )
+
+    @Test
+    fun thePlayerTakesWhatWasPrepared() = runBlocking {
+        preloads.reserve("a") { "session a" }
+        assertEquals("session a", preloads.take("a")?.await())
+        assertNull(preloads.take("a"))
+    }
+
+    @Test
+    fun aTargetIsPreparedOnce() = runBlocking {
+        var preparations = 0
+        repeat(3) { preloads.reserve("a") { preparations++; "session a" } }
+        assertEquals(1, preparations)
+    }
+
+    @Test
+    fun aThirdTargetReleasesTheOldest() {
+        preloads.reserve("a") { "session a" }
+        preloads.reserve("b") { "session b" }
+        preloads.reserve("c") { "session c" }
+        assertEquals(listOf("session a"), released)
+        assertNull(preloads.take("a"))
+    }
+
+    @Test
+    fun anExpiredPreparationIsReleasedAndNotHandedOver() {
+        preloads.reserve("a") { "session a" }
+        now = 1_000L
+        assertNull(preloads.take("a"))
+        assertEquals(listOf("session a"), released)
+    }
+
+    @Test
+    fun aTakenPreparationIsNotReleased() = runBlocking {
+        preloads.reserve("a") { "session a" }
+        preloads.take("a")?.await()
+        now = 5_000L
+        preloads.reserve("b") { "session b" }
+        assertEquals(emptyList<String>(), released)
+    }
+}
diff --git a/app/src/test/java/video/typetype/tv/playback/SabrWindowLoaderTest.kt b/core/playback/src/test/java/video/typetype/tv/playback/SabrWindowLoaderTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/playback/SabrWindowLoaderTest.kt
rename to core/playback/src/test/java/video/typetype/tv/playback/SabrWindowLoaderTest.kt
diff --git a/app/src/test/java/video/typetype/tv/playback/SabrWindowMapperTest.kt b/core/playback/src/test/java/video/typetype/tv/playback/SabrWindowMapperTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/playback/SabrWindowMapperTest.kt
rename to core/playback/src/test/java/video/typetype/tv/playback/SabrWindowMapperTest.kt
diff --git a/core/playback/src/test/java/video/typetype/tv/playback/ScreenFitTest.kt b/core/playback/src/test/java/video/typetype/tv/playback/ScreenFitTest.kt
new file mode 100644
index 0000000..197ab51
--- /dev/null
+++ b/core/playback/src/test/java/video/typetype/tv/playback/ScreenFitTest.kt
@@ -0,0 +1,26 @@
+package video.typetype.tv.playback
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class ScreenFitTest {
+    @Test
+    fun aPictureLargerThanTheScreenIsLeftOut() {
+        assertTrue(ScreenFit.fits(1920, 1080, screenLines = 1080))
+        assertFalse(ScreenFit.fits(2560, 1440, screenLines = 1080))
+        assertFalse(ScreenFit.fits(3840, 2160, screenLines = 1080))
+        assertTrue(ScreenFit.fits(3840, 2160, screenLines = 2160))
+    }
+
+    @Test
+    fun aVerticalVideoIsMeasuredByItsShortSide() {
+        assertTrue(ScreenFit.fits(1080, 1920, screenLines = 1080))
+    }
+
+    @Test
+    fun anUnknownScreenOrSizeKeepsEverything() {
+        assertTrue(ScreenFit.fits(3840, 2160, screenLines = null))
+        assertTrue(ScreenFit.fits(0, 0, screenLines = 720))
+    }
+}
diff --git a/app/src/test/java/video/typetype/tv/playback/StandardFormatSelectorTest.kt b/core/playback/src/test/java/video/typetype/tv/playback/StandardFormatSelectorTest.kt
similarity index 73%
rename from app/src/test/java/video/typetype/tv/playback/StandardFormatSelectorTest.kt
rename to core/playback/src/test/java/video/typetype/tv/playback/StandardFormatSelectorTest.kt
index f0bb6f8..a83b744 100644
--- a/app/src/test/java/video/typetype/tv/playback/StandardFormatSelectorTest.kt
+++ b/core/playback/src/test/java/video/typetype/tv/playback/StandardFormatSelectorTest.kt
@@ -8,6 +8,8 @@ import video.typetype.tv.data.dto.StreamDto
 import video.typetype.tv.data.dto.VideoStreamDto
 
 class StandardFormatSelectorTest {
+    private val software = FakeCodecSupport()
+
     private fun video(url: String, height: Int, codec: String = "avc1.640032", bitrate: Int = 1_000, resolution: String = "", method: String = "progressive") =
         VideoStreamDto(codec = codec, height = height, bitrate = bitrate, deliveryMethod = method, url = url, resolution = resolution)
 
@@ -20,14 +22,14 @@ class StandardFormatSelectorTest {
             videoOnlyStreams = listOf(video("/v1080", 1080), video("/v720", 720), video("/v360", 360), video("/h1080", 1080, "hvc1.1.6")),
             audioStreams = listOf(audio("/a", 64)),
         )
-        assertEquals("/v720", StandardFormatSelector.select(stream, 720)?.video?.url)
-        assertEquals("/v1080", StandardFormatSelector.select(stream, 1080)?.video?.url)
+        assertEquals("/v720", StandardFormatSelector.select(stream, 720, software)?.video?.url)
+        assertEquals("/v1080", StandardFormatSelector.select(stream, 1080, software)?.video?.url)
     }
 
     @Test
     fun fallsBackToTheLowestFormatBelowTheCap() {
         val stream = StreamDto(videoOnlyStreams = listOf(video("/v720", 720), video("/v480", 480)), audioStreams = listOf(audio("/a", 64)))
-        assertEquals("/v480", StandardFormatSelector.select(stream, 240)?.video?.url)
+        assertEquals("/v480", StandardFormatSelector.select(stream, 240, software)?.video?.url)
     }
 
     @Test
@@ -39,7 +41,7 @@ class StandardFormatSelectorTest {
             ),
             audioStreams = listOf(audio("/a", codec = "", quality = "128", method = "hls")),
         )
-        val selection = StandardFormatSelector.select(stream, 1080)
+        val selection = StandardFormatSelector.select(stream, 1080, software)
         assertEquals("/high", selection?.video?.url)
         assertEquals(listOf(720, 360), selection?.heights)
     }
@@ -50,12 +52,23 @@ class StandardFormatSelectorTest {
             videoOnlyStreams = listOf(video("/v", 720)),
             audioStreams = listOf(audio("/low", 64), audio("/high", 128), audio("/opus", 256, codec = "opus")),
         )
-        assertEquals("/high", StandardFormatSelector.select(stream, 720)?.audio?.url)
+        assertEquals("/high", StandardFormatSelector.select(stream, 720, software)?.audio?.url)
     }
 
     @Test
     fun needsBothVideoAndAudio() {
-        assertNull(StandardFormatSelector.select(StreamDto(audioStreams = listOf(audio("/a", 64))), 720))
-        assertNull(StandardFormatSelector.select(StreamDto(videoOnlyStreams = listOf(video("/v", 720))), 720))
+        assertNull(StandardFormatSelector.select(StreamDto(audioStreams = listOf(audio("/a", 64))), 720, software))
+        assertNull(StandardFormatSelector.select(StreamDto(videoOnlyStreams = listOf(video("/v", 720))), 720, software))
+    }
+
+    @Test
+    fun bilibiliUsesTheCodecTheDecoderHandlesBest() {
+        val stream = StreamDto(
+            videoOnlyStreams = listOf(video("/avc", 1080), video("/hevc", 1080, "hvc1.1.6.L150.90"), video("/av1", 1080, "av01.0.08M.08.0.110.01.01.01.0")),
+            audioStreams = listOf(audio("/a", 64)),
+        )
+        assertEquals("/avc", StandardFormatSelector.select(stream, 1080, software)?.video?.url)
+        val hevcInHardware = FakeCodecSupport(mapOf("avc1" to DecoderSupport.Software, "hvc1" to DecoderSupport.Hardware))
+        assertEquals("/hevc", StandardFormatSelector.select(stream, 1080, hevcInHardware)?.video?.url)
     }
 }
diff --git a/core/resources/build.gradle.kts b/core/resources/build.gradle.kts
new file mode 100644
index 0000000..a89f0e6
--- /dev/null
+++ b/core/resources/build.gradle.kts
@@ -0,0 +1,7 @@
+plugins {
+    alias(libs.plugins.typetype.android.library)
+}
+
+android {
+    namespace = "video.typetype.tv.resources"
+}
diff --git a/core/resources/src/main/res/drawable/ic_service_bilibili.xml b/core/resources/src/main/res/drawable/ic_service_bilibili.xml
new file mode 100644
index 0000000..3f81b99
--- /dev/null
+++ b/core/resources/src/main/res/drawable/ic_service_bilibili.xml
@@ -0,0 +1,12 @@
+<!-- The Bilibili mark from simple-icons 16.25.0 (icons/bilibili.svg), CC0-1.0, as TypeType-Frontend
+     draws it. The mark stays a trademark of its owner and only names where a video comes from. The path is
+     unchanged; the app tints it at runtime with the frontend's colour. -->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="#FFFFFFFF"
+        android:pathData="M17.813 4.653h.854c1.51.054 2.769.578 3.773 1.574 1.004.995 1.524 2.249 1.56 3.76v7.36c-.036 1.51-.556 2.769-1.56 3.773s-2.262 1.524-3.773 1.56H5.333c-1.51-.036-2.769-.556-3.773-1.56S.036 18.858 0 17.347v-7.36c.036-1.511.556-2.765 1.56-3.76 1.004-.996 2.262-1.52 3.773-1.574h.774l-1.174-1.12a1.234 1.234 0 0 1-.373-.906c0-.356.124-.658.373-.907l.027-.027c.267-.249.573-.373.92-.373.347 0 .653.124.92.373L9.653 4.44c.071.071.134.142.187.213h4.267a.836.836 0 0 1 .16-.213l2.853-2.747c.267-.249.573-.373.92-.373.347 0 .662.151.929.4.267.249.391.551.391.907 0 .355-.124.657-.373.906zM5.333 7.24c-.746.018-1.373.276-1.88.773-.506.498-.769 1.13-.786 1.894v7.52c.017.764.28 1.395.786 1.893.507.498 1.134.756 1.88.773h13.334c.746-.017 1.373-.275 1.88-.773.506-.498.769-1.129.786-1.893v-7.52c-.017-.765-.28-1.396-.786-1.894-.507-.497-1.134-.755-1.88-.773zM8 11.107c.373 0 .684.124.933.373.25.249.383.569.4.96v1.173c-.017.391-.15.711-.4.96-.249.25-.56.374-.933.374s-.684-.125-.933-.374c-.25-.249-.383-.569-.4-.96V12.44c0-.373.129-.689.386-.947.258-.257.574-.386.947-.386zm8 0c.373 0 .684.124.933.373.25.249.383.569.4.96v1.173c-.017.391-.15.711-.4.96-.249.25-.56.374-.933.374s-.684-.125-.933-.374c-.25-.249-.383-.569-.4-.96V12.44c.017-.391.15-.711.4-.96.249-.249.56-.373.933-.373Z" />
+</vector>
diff --git a/core/resources/src/main/res/drawable/ic_service_niconico.xml b/core/resources/src/main/res/drawable/ic_service_niconico.xml
new file mode 100644
index 0000000..602d311
--- /dev/null
+++ b/core/resources/src/main/res/drawable/ic_service_niconico.xml
@@ -0,0 +1,12 @@
+<!-- The niconico mark from simple-icons 16.25.0 (icons/niconico.svg), CC0-1.0, as TypeType-Frontend
+     draws it. The mark stays a trademark of its owner and only names where a video comes from. The path is
+     unchanged; the app tints it at runtime with the frontend's colour. -->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="#FFFFFFFF"
+        android:pathData="M.4787 7.534v12.1279A2.0213 2.0213 0 0 0 2.5 21.6832h2.3888l1.323 2.0948a.4778.4778 0 0 0 .4043.2205.4778.4778 0 0 0 .441-.2205l1.323-2.0948h6.9828l1.323 2.0948a.4778.4778 0 0 0 .441.2205c.1838 0 .3308-.0735.4043-.2205l1.323-2.0948h2.6462a2.0213 2.0213 0 0 0 2.0213-2.0213V7.5339a2.0213 2.0213 0 0 0-2.0213-1.9845h-7.681l4.4468-4.4469L17.1637 0l-5.1452 5.1452L6.8 0 5.6973 1.1025l4.4102 4.4102H2.5367a2.0213 2.0213 0 0 0-2.058 2.058z" />
+</vector>
diff --git a/core/resources/src/main/res/drawable/ic_service_youtube.xml b/core/resources/src/main/res/drawable/ic_service_youtube.xml
new file mode 100644
index 0000000..bf3d9ca
--- /dev/null
+++ b/core/resources/src/main/res/drawable/ic_service_youtube.xml
@@ -0,0 +1,12 @@
+<!-- The YouTube mark from simple-icons 16.25.0 (icons/youtube.svg), CC0-1.0, as TypeType-Frontend
+     draws it. The mark stays a trademark of its owner and only names where a video comes from. The path is
+     unchanged; the app tints it at runtime with the frontend's colour. -->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="#FFFFFFFF"
+        android:pathData="M23.498 6.186a3.016 3.016 0 0 0-2.122-2.136C19.505 3.545 12 3.545 12 3.545s-7.505 0-9.377.505A3.017 3.017 0 0 0 .502 6.186C0 8.07 0 12 0 12s0 3.93.502 5.814a3.016 3.016 0 0 0 2.122 2.136c1.871.505 9.376.505 9.376.505s7.505 0 9.377-.505a3.015 3.015 0 0 0 2.122-2.136C24 15.93 24 12 24 12s0-3.93-.502-5.814zM9.545 15.568V8.432L15.818 12l-6.273 3.568z" />
+</vector>
diff --git a/app/src/main/res/drawable/ic_typetype_mark.xml b/core/resources/src/main/res/drawable/ic_typetype_mark.xml
similarity index 89%
rename from app/src/main/res/drawable/ic_typetype_mark.xml
rename to core/resources/src/main/res/drawable/ic_typetype_mark.xml
index fb4fe6a..853482c 100644
--- a/app/src/main/res/drawable/ic_typetype_mark.xml
+++ b/core/resources/src/main/res/drawable/ic_typetype_mark.xml
@@ -6,18 +6,18 @@
     <path
         android:pathData="M5,7.4 L19,7.4 A2,2 0 0 1 21,9.4 L21,19 A2,2 0 0 1 19,21 L5,21 A2,2 0 0 1 3,19 L3,9.4 A2,2 0 0 1 5,7.4 Z"
         android:strokeColor="#EF4444"
-        android:strokeWidth="1.8"
+        android:strokeWidth="2.3"
         android:strokeLineJoin="round" />
     <path
         android:pathData="M8,2.6 L12,6.6 L16,2.6"
         android:strokeColor="#EF4444"
-        android:strokeWidth="1.8"
+        android:strokeWidth="2.3"
         android:strokeLineCap="round"
         android:strokeLineJoin="round" />
     <path
         android:pathData="M16.2,7.8 L16.2,20.6"
         android:strokeColor="#EF4444"
-        android:strokeWidth="1.8" />
+        android:strokeWidth="2.3" />
     <path
         android:fillColor="#EF4444"
         android:pathData="M18.7,11.4 m-1,0 a1,1 0 1,0 2,0 a1,1 0 1,0 -2,0" />
diff --git a/core/resources/src/main/res/raw/startup_chime.ogg b/core/resources/src/main/res/raw/startup_chime.ogg
new file mode 100644
index 0000000..5a900ac
Binary files /dev/null and b/core/resources/src/main/res/raw/startup_chime.ogg differ
diff --git a/app/src/main/res/values/strings.xml b/core/resources/src/main/res/values/strings.xml
similarity index 71%
rename from app/src/main/res/values/strings.xml
rename to core/resources/src/main/res/values/strings.xml
index dce1302..544cca1 100644
--- a/app/src/main/res/values/strings.xml
+++ b/core/resources/src/main/res/values/strings.xml
@@ -1,6 +1,5 @@
 <resources>
     <string name="app_name">TypeType</string>
-    <string name="wordmark">TYPETYPE</string>
     <string name="logo_description">TypeType</string>
     <string name="profile_description">Profile, %1$s</string>
     <string name="profile_description_anonymous">Profile</string>
@@ -21,6 +20,18 @@
     <string name="home_progress_left">%1$s left</string>
 
     <string name="detail_play">Play</string>
+    <string name="video_menu_open">Video options</string>
+    <string name="video_menu_channel">Open channel</string>
+    <string name="video_menu_remove_from_playlist">Remove from %1$s</string>
+    <string name="video_menu_watch_later_add">Add to Watch later</string>
+    <string name="video_menu_watch_later_remove">Remove from Watch later</string>
+    <string name="video_menu_favorite_add">Add to Favorites</string>
+    <string name="video_menu_favorite_remove">Remove from Favorites</string>
+    <string name="video_menu_block_video">Block this video</string>
+    <string name="video_menu_unblock_video">Unblock this video</string>
+    <string name="video_menu_block_channel">Block this channel</string>
+    <string name="video_menu_unblock_channel">Unblock this channel</string>
+    <string name="detail_watch_live">Watch live</string>
     <string name="detail_resume">Resume</string>
     <string name="detail_watch_later">Watch later</string>
     <string name="detail_saved">Saved</string>
@@ -37,7 +48,7 @@
     <string name="player_pause">Pause</string>
     <string name="player_rewind">Back 10 seconds</string>
     <string name="player_forward">Forward 10 seconds</string>
-    <string name="player_previous">Previous video</string>
+    <string name="player_previous">Start over</string>
     <string name="player_next">Next video</string>
     <string name="player_captions">Captions</string>
     <string name="player_captions_on_description">Captions on, %1$s</string>
@@ -46,17 +57,26 @@
     <string name="player_comments_on_description">Scrolling comments on</string>
     <string name="player_comments_off_description">Scrolling comments off</string>
     <string name="player_quality_description">Video quality, %1$s</string>
-    <string name="player_speed_description">Playback speed, %1$s</string>
+    <string name="player_open_comments_description">Comments, opens the comments on this video</string>
+    <string name="player_open_channel_description">%1$s, shows the channel</string>
+    <string name="player_open_channel">Open channel</string>
     <string name="player_seek_description">Seek bar</string>
     <string name="player_up_next">UP NEXT</string>
+    <string name="player_more_videos">More videos</string>
     <string name="player_replay">Replay</string>
     <string name="player_buffering">Buffering</string>
 
-    <string name="search_placeholder">Search videos, channels, genres</string>
+    <string name="search_placeholder">Type anything</string>
     <string name="search_space">Space</string>
     <string name="search_delete">Delete</string>
     <string name="search_clear">Clear</string>
-    <string name="search_trending">TRENDING SEARCHES</string>
+    <string name="search_recent">RECENT SEARCHES</string>
+    <string name="voice_search">Search by voice</string>
+    <string name="voice_stop">Stop listening</string>
+    <string name="voice_listening">Listening…</string>
+    <string name="voice_not_heard">Didn\'t catch that. Try again.</string>
+    <string name="voice_network">Voice search needs an internet connection.</string>
+    <string name="voice_permission">Allow the microphone to search by voice.</string>
     <plurals name="search_results">
         <item quantity="one">%1$d RESULT</item>
         <item quantity="other">%1$d RESULTS</item>
@@ -64,7 +84,7 @@
     <string name="search_empty_title">Nothing found</string>
     <string name="search_empty_body">Try a shorter word, or search by genre or channel.</string>
     <string name="search_start_title">What do you want to watch?</string>
-    <string name="search_start_body">Type with the on-screen keyboard or pick a trending search.</string>
+    <string name="search_start_body">Type with the on-screen keyboard or pick a recent search.</string>
 
     <string name="library_title">Library</string>
     <string name="library_history">History</string>
@@ -81,6 +101,28 @@
     <string name="settings_title">Settings</string>
     <string name="settings_group_account">Account</string>
     <string name="settings_group_playback">Playback</string>
+    <string name="settings_group_content">Content</string>
+    <string name="settings_start_page">Start on</string>
+    <string name="settings_start_page_summary">The screen the app opens on.</string>
+    <string name="settings_start_home">Home</string>
+    <string name="settings_start_history">History</string>
+    <string name="settings_start_favorites">Favorites</string>
+    <string name="settings_start_watch_later">Watch later</string>
+    <string name="settings_search_service">Search service</string>
+    <string name="settings_search_service_summary">Where a new search looks first.</string>
+    <string name="settings_show_continue">Continue watching</string>
+    <string name="settings_show_continue_summary">The videos you started, at the top of Home.</string>
+    <string name="settings_show_recommendations">Recommendations</string>
+    <string name="settings_show_recommendations_summary">Suggested videos on Home.</string>
+    <string name="settings_show_related">More videos</string>
+    <string name="settings_show_related_summary">Related videos on a video page and in the player.</string>
+    <string name="settings_show_comments">Comments</string>
+    <string name="settings_show_comments_summary">Comments under a video.</string>
+    <string name="settings_show_shorts">Shorts</string>
+    <string name="settings_show_shorts_summary">Short vertical videos in lists and search.</string>
+    <string name="settings_default_quality_summary">The quality a video starts in. Auto picks the best your TV can show.</string>
+    <string name="settings_playback_speed_summary">The speed a video starts at.</string>
+    <string name="settings_sponsorblock_summary">What to do with sponsored parts of a video.</string>
     <string name="settings_group_about">About</string>
     <string name="settings_account_name">Signed in as</string>
     <string name="settings_default_quality">Default quality</string>
@@ -103,7 +145,6 @@
     <string name="settings_instance_name">Name</string>
     <string name="settings_instance_address">Address</string>
     <string name="settings_instance_version">Server version</string>
-    <string name="settings_instance_api">API version</string>
     <string name="settings_account_email">Email</string>
     <string name="settings_account_role">Role</string>
     <string name="settings_guest">Guest session</string>
@@ -142,19 +183,27 @@
     <string name="login_error_generic">Something went wrong. Try again.</string>
     <string name="login_error_missing">Fill in every field first.</string>
     <string name="login_notice_expired">Your session expired. Sign in again.</string>
-    <string name="login_notice_unreachable">The server could not be reached. Sign in again when it is back.</string>
+    <string name="reconnect_title">Connecting to your server</string>
+    <string name="reconnect_checking">Checking your session.</string>
+    <string name="reconnect_waiting">The server is not answering. The app keeps trying and continues as soon as it is back.</string>
     <string name="request_id">Request id: %1$s</string>
     <string name="state_retry">Try again</string>
     <string name="player_error_title">This video could not be played</string>
     <string name="detail_action_failed">The change could not be saved. Check the connection and try again.</string>
     <string name="load_error_title">This content could not be loaded</string>
+    <plurals name="load_retry_countdown">
+        <item quantity="one">Trying again in %1$d second</item>
+        <item quantity="other">Trying again in %1$d seconds</item>
+    </plurals>
     <string name="load_error_generic">The server returned an unexpected answer.</string>
     <string name="settings_quality_auto">Auto</string>
+    <string name="settings_quality_4k">4K</string>
     <string name="settings_sponsor_auto_skip">Skip automatically</string>
     <string name="settings_sponsor_mark_only">Mark only</string>
     <string name="settings_sponsor_disabled">Off</string>
     <string name="player_live">LIVE</string>
     <string name="player_go_live">Go live</string>
+    <string name="player_live_ended">The live stream has ended</string>
     <string name="load_error_unavailable">This video is not available, for example because of a regional restriction.</string>
     <string name="player_error_playback">Playback stopped after several attempts to recover.</string>
     <string name="source_youtube">YouTube</string>
@@ -163,6 +212,12 @@
     <string name="shelf_trending_bilibili">Trending on Bilibili</string>
     <string name="shelf_trending_niconico">Trending on NicoNico</string>
     <string name="player_comments">Danmaku</string>
+    <string name="player_chat">Chat</string>
+    <string name="player_chat_on_description">Live chat shown</string>
+    <string name="player_chat_off_description">Live chat hidden</string>
+    <string name="live_chat_title">Live chat</string>
+    <string name="live_chat_connecting">Connecting to the live chat</string>
+    <string name="live_chat_unavailable">Live chat is not available for this stream</string>
     <string name="search_source">Source: %1$s</string>
     <string name="detail_channel">Channel</string>
     <string name="comment_likes">%1$s likes</string>
@@ -215,7 +270,39 @@
     <string name="search_kind_music_songs">Music: songs</string>
     <string name="search_kind_music_videos">Music: videos</string>
     <string name="channel_podcasts">Podcasts</string>
+    <string name="channel_verified">Verified channel</string>
+    <string name="channel_more">More options</string>
+    <string name="channel_sort">Sort: %1$s</string>
+    <string name="channel_tab_empty">Nothing to show here yet.</string>
+    <string name="channel_search">Search</string>
+    <string name="channel_search_title">Search %1$s</string>
+    <string name="channel_search_query">“%1$s”</string>
+    <string name="channel_search_change">Searching for %1$s. OK changes the search.</string>
+    <string name="channel_search_clear">Clear the search</string>
+    <string name="channel_search_empty">No video of this channel matches “%1$s”.</string>
+    <string name="channel_tab_videos">Videos</string>
+    <string name="channel_tab_live">Live</string>
+    <string name="channel_tab_playlists">Playlists</string>
+    <string name="channel_sort_latest">Newest</string>
+    <string name="channel_sort_popular">Popular</string>
+    <string name="channel_sort_oldest">Oldest</string>
     <string name="settings_group_blocked">Blocked channels</string>
+    <string name="settings_group_performance">Performance</string>
+    <string name="settings_animated_avatar">Animated profile picture</string>
+    <string name="settings_animated_avatar_summary">Plays an animated picture in the top bar. Turn it off on a slow box.</string>
+    <string name="settings_video_previews">Video previews</string>
+    <string name="settings_video_previews_summary">Plays a muted preview behind the home page. Turn it off on a slow box.</string>
+    <string name="settings_smooth_animations">Smooth animations</string>
+    <string name="settings_smooth_animations_summary">Zooms and fades between screens, and shadows under the focused card. Turn it off on a slow box.</string>
+    <string name="settings_backdrop">Background picture</string>
+    <string name="settings_backdrop_summary">Shows the selected video\'s picture behind the home and video pages. Turn it off on a slow box.</string>
+    <string name="settings_intro">Startup intro</string>
+    <string name="settings_intro_summary">The animation and sound when the app opens.</string>
+    <string name="settings_intro_full">Full</string>
+    <string name="settings_intro_short">Short</string>
+    <string name="settings_intro_off">Off</string>
+    <string name="settings_forget_decoders">Check the video decoders again</string>
+    <string name="settings_forget_decoders_summary">Gives another chance to the video formats that failed on this TV.</string>
     <string name="settings_blocked_count">Blocked channels</string>
     <string name="settings_blocked_unblock">Select to unblock this channel</string>
     <string name="channel_block">Block channel</string>
@@ -252,6 +339,7 @@
     <string name="menu_subscribed">Subscribed to %1$s</string>
     <string name="menu_audio_only">Audio only</string>
     <string name="menu_stats">Playback statistics</string>
+    <string name="menu_speed">Playback speed</string>
     <string name="menu_caption_style">Subtitle style</string>
     <string name="menu_toggle_on">On</string>
     <string name="menu_toggle_off">Off</string>
@@ -262,6 +350,9 @@
     <string name="caption_preview">Sample subtitle</string>
     <string name="stats_video">Video</string>
     <string name="stats_audio">Audio</string>
+    <string name="stats_decoder">Decoder</string>
+    <string name="stats_decoder_hardware">(hardware)</string>
+    <string name="stats_decoder_software">(software)</string>
     <string name="stats_dropped">Dropped frames</string>
     <string name="stats_buffer">Buffer</string>
     <string name="stats_network">Network</string>
diff --git a/core/testing/build.gradle.kts b/core/testing/build.gradle.kts
new file mode 100644
index 0000000..a9f2bdb
--- /dev/null
+++ b/core/testing/build.gradle.kts
@@ -0,0 +1,12 @@
+plugins {
+    alias(libs.plugins.typetype.android.library)
+}
+
+android {
+    namespace = "video.typetype.tv.testing"
+}
+
+dependencies {
+    api(project(":core:data"))
+    implementation(project(":core:resources"))
+}
diff --git a/app/src/sharedTest/java/video/typetype/tv/data/InMemoryVideoActivity.kt b/core/testing/src/main/java/video/typetype/tv/data/InMemoryVideoActivity.kt
similarity index 100%
rename from app/src/sharedTest/java/video/typetype/tv/data/InMemoryVideoActivity.kt
rename to core/testing/src/main/java/video/typetype/tv/data/InMemoryVideoActivity.kt
diff --git a/app/src/sharedTest/java/video/typetype/tv/data/MockCatalog.kt b/core/testing/src/main/java/video/typetype/tv/data/MockCatalog.kt
similarity index 99%
rename from app/src/sharedTest/java/video/typetype/tv/data/MockCatalog.kt
rename to core/testing/src/main/java/video/typetype/tv/data/MockCatalog.kt
index 47d5cc5..696cd4b 100644
--- a/app/src/sharedTest/java/video/typetype/tv/data/MockCatalog.kt
+++ b/core/testing/src/main/java/video/typetype/tv/data/MockCatalog.kt
@@ -1,6 +1,6 @@
 package video.typetype.tv.data
 
-internal object MockCatalog {
+object MockCatalog {
     private val reel = MockChannels.ReelSociety
     private val atlas = MockChannels.AtlasField
     private val orbit = MockChannels.LowOrbit
diff --git a/app/src/sharedTest/java/video/typetype/tv/data/MockChannels.kt b/core/testing/src/main/java/video/typetype/tv/data/MockChannels.kt
similarity index 95%
rename from app/src/sharedTest/java/video/typetype/tv/data/MockChannels.kt
rename to core/testing/src/main/java/video/typetype/tv/data/MockChannels.kt
index 7ea9981..b594ab0 100644
--- a/app/src/sharedTest/java/video/typetype/tv/data/MockChannels.kt
+++ b/core/testing/src/main/java/video/typetype/tv/data/MockChannels.kt
@@ -1,6 +1,6 @@
 package video.typetype.tv.data
 
-internal object MockChannels {
+object MockChannels {
     val ReelSociety = Channel("reel-society", "Reel Society", "@reelsociety", "2.4M")
     val AtlasField = Channel("atlas-field", "Atlas Field Notes", "@atlasfield", "842K")
     val LowOrbit = Channel("low-orbit", "Low Orbit", "@loworbit", "560K")
diff --git a/app/src/sharedTest/java/video/typetype/tv/data/MockContentRepository.kt b/core/testing/src/main/java/video/typetype/tv/data/MockContentRepository.kt
similarity index 83%
rename from app/src/sharedTest/java/video/typetype/tv/data/MockContentRepository.kt
rename to core/testing/src/main/java/video/typetype/tv/data/MockContentRepository.kt
index 4bd6404..a587657 100644
--- a/app/src/sharedTest/java/video/typetype/tv/data/MockContentRepository.kt
+++ b/core/testing/src/main/java/video/typetype/tv/data/MockContentRepository.kt
@@ -1,6 +1,8 @@
 package video.typetype.tv.data
 
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.emptyFlow
 
 class MockContentRepository(
     private val latencyMillis: Long = DEFAULT_LATENCY_MILLIS,
@@ -66,6 +68,10 @@ class MockContentRepository(
         return MockCatalog.all.firstOrNull { it.id == id }
     }
 
+    override suspend fun prewarm(videoId: String) = Unit
+
+    override fun liveChat(videoUrl: String): Flow<LiveChatEvent> = emptyFlow()
+
     override suspend fun related(id: String): List<Video> {
         delay(latencyMillis / 2)
         val current = MockCatalog.all.firstOrNull { it.id == id } ?: return emptyList()
@@ -74,7 +80,7 @@ class MockContentRepository(
         return (sameGenre + others).take(10)
     }
 
-    override suspend fun search(query: String, source: ContentSource, kind: SearchKind): SearchResults {
+    override suspend fun search(query: String, source: ContentSource, kind: SearchKind, page: String?): SearchResults {
         delay(latencyMillis / 3)
         return SearchResults(videos = if (kind == SearchKind.Videos) MockCatalog.all.search(query) else emptyList())
     }
@@ -135,18 +141,37 @@ class MockContentRepository(
 
     override suspend fun unblockChannel(url: String) = Unit
 
+    override suspend fun isVideoBlocked(url: String): Boolean = false
+
+    override suspend fun blockVideo(video: Video) = Unit
+
+    override suspend fun unblockVideo(url: String) = Unit
+
     override suspend fun bulletComments(videoUrl: String): List<BulletComment> = emptyList()
 
     override suspend fun comments(videoUrl: String, page: String?): CommentsPage = CommentsPage(emptyList(), null, false)
 
     override suspend fun commentReplies(videoUrl: String, repliesPage: String): CommentsPage = CommentsPage(emptyList(), null, false)
 
-    override suspend fun channel(url: String, page: String?): ChannelPage {
+    override suspend fun channel(url: String, page: String?, tab: ChannelTab, sort: ChannelSort?, query: String?): ChannelPage {
         val videos = MockCatalog.all.filter { it.channel.url == url || it.channel.id == url }
         val channel = videos.firstOrNull()?.channel ?: Channel(url, "Channel", "", "", url)
-        return ChannelPage(channel, "", null, false, videos, null)
+        val shown = when {
+            tab == ChannelTab.Live -> videos.filter { it.isLive }
+            query != null -> videos.filter { it.title.contains(query, ignoreCase = true) }
+            else -> videos
+        }
+        return ChannelPage(channel, "", null, false, if (sort == ChannelSort.Oldest) shown.reversed() else shown, null)
     }
 
+    override suspend fun channelPlaylists(url: String, page: String?): ChannelPlaylists =
+        ChannelPlaylists(
+            MockCatalog.all.take(4).mapIndexed { index, video ->
+                PublicPlaylist("$url/playlist-$index", "Collection ${index + 1}", video.channel.name, 8L + index, video.thumbnailUrl)
+            },
+            null,
+        )
+
     private fun outdoors(): List<Video> =
         MockCatalog.all.filter { it.genre == "Landscape" || it.genre == "Travel" }
 
@@ -154,7 +179,7 @@ class MockContentRepository(
         MockCatalog.all.filter { it.resumeFraction != null }
 }
 
-internal fun List<Video>.search(query: String): List<Video> {
+fun List<Video>.search(query: String): List<Video> {
     val needle = query.trim().lowercase()
     if (needle.isEmpty()) return emptyList()
     val scored = mapNotNull { video ->
diff --git a/app/src/sharedTest/java/video/typetype/tv/data/MockSettings.kt b/core/testing/src/main/java/video/typetype/tv/data/MockSettings.kt
similarity index 70%
rename from app/src/sharedTest/java/video/typetype/tv/data/MockSettings.kt
rename to core/testing/src/main/java/video/typetype/tv/data/MockSettings.kt
index 75b0d4d..086ea30 100644
--- a/app/src/sharedTest/java/video/typetype/tv/data/MockSettings.kt
+++ b/core/testing/src/main/java/video/typetype/tv/data/MockSettings.kt
@@ -1,8 +1,8 @@
 package video.typetype.tv.data
 
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 
-internal object MockSettings {
+object MockSettings {
     val groups: List<SettingsGroup> = listOf(
         SettingsGroup(
             id = "account",
@@ -35,6 +35,16 @@ internal object MockSettings {
                 ),
             ),
         ),
+        SettingsGroup(
+            id = "instance",
+            titleRes = R.string.settings_group_instance,
+            items = listOf(
+                SettingItem.Info("instance-name", R.string.settings_instance_name, "TypeType"),
+                SettingItem.Info("instance-address", R.string.settings_instance_address, "typetype.example"),
+                SettingItem.Info("instance-version", R.string.settings_instance_version, "1.0.0"),
+                SettingItem.Action("change-instance", R.string.settings_change_instance, R.string.settings_change_instance_summary),
+            ),
+        ),
         SettingsGroup(
             id = "about",
             titleRes = R.string.settings_group_about,
diff --git a/core/ui/build.gradle.kts b/core/ui/build.gradle.kts
new file mode 100644
index 0000000..5944d89
--- /dev/null
+++ b/core/ui/build.gradle.kts
@@ -0,0 +1,18 @@
+plugins {
+    alias(libs.plugins.typetype.android.compose)
+}
+
+android {
+    namespace = "video.typetype.tv.core.ui"
+}
+
+dependencies {
+    api(project(":core:data"))
+    api(project(":core:resources"))
+    api(libs.androidx.activity.compose)
+    api(libs.coil.compose)
+    implementation(libs.coil.gif)
+
+    testImplementation(project(":core:testing"))
+    testImplementation(libs.junit)
+}
diff --git a/app/src/main/java/video/typetype/tv/navigation/Route.kt b/core/ui/src/main/java/video/typetype/tv/navigation/Route.kt
similarity index 90%
rename from app/src/main/java/video/typetype/tv/navigation/Route.kt
rename to core/ui/src/main/java/video/typetype/tv/navigation/Route.kt
index 323bbea..17692ee 100644
--- a/app/src/main/java/video/typetype/tv/navigation/Route.kt
+++ b/core/ui/src/main/java/video/typetype/tv/navigation/Route.kt
@@ -8,18 +8,19 @@ import androidx.compose.material.icons.rounded.Home
 import androidx.compose.material.icons.rounded.Search
 import androidx.compose.material.icons.rounded.Settings
 import androidx.compose.material.icons.rounded.VideoLibrary
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
+import video.typetype.tv.data.Video
 
 sealed interface Route {
     data object Home : Route
     data object Search : Route
     data object Library : Route
     data object Settings : Route
-    data class Detail(val videoId: String) : Route
+    data class Detail(val videoId: String, val preview: Video? = null) : Route
     data class Channel(val url: String) : Route
     data class Playlist(val url: String) : Route
     data class Podcast(val url: String) : Route
-    data class Player(val videoId: String, val continued: Boolean = false) : Route
+    data class Player(val videoId: String, val continued: Boolean = false, val preview: Video? = null) : Route
 }
 
 enum class TopTab(
diff --git a/app/src/main/java/video/typetype/tv/navigation/RouteTransitions.kt b/core/ui/src/main/java/video/typetype/tv/navigation/RouteTransitions.kt
similarity index 73%
rename from app/src/main/java/video/typetype/tv/navigation/RouteTransitions.kt
rename to core/ui/src/main/java/video/typetype/tv/navigation/RouteTransitions.kt
index 4d682ee..efae665 100644
--- a/app/src/main/java/video/typetype/tv/navigation/RouteTransitions.kt
+++ b/core/ui/src/main/java/video/typetype/tv/navigation/RouteTransitions.kt
@@ -9,7 +9,10 @@ import androidx.compose.animation.scaleOut
 import androidx.compose.animation.slideInVertically
 import androidx.compose.animation.togetherWith
 
-fun routeTransition(from: Route, to: Route): ContentTransform = when {
+// Without smooth animations, a short fade alone: a slow box redraws the whole screen for every frame, and two
+// screens zooming at once is what it struggles with most.
+fun routeTransition(from: Route, to: Route, smooth: Boolean = true): ContentTransform = when {
+    !smooth -> fadeIn(tween(QUICK_FADE_MILLIS)) togetherWith fadeOut(tween(QUICK_FADE_MILLIS))
     from is Route.Player || to is Route.Player ->
         fadeIn(tween(460)) togetherWith fadeOut(tween(340))
     to is Route.Detail ->
@@ -22,3 +25,5 @@ fun routeTransition(from: Route, to: Route): ContentTransform = when {
         (fadeIn(tween(300, delayMillis = 80)) + slideInVertically(tween(300, delayMillis = 80)) { it / 28 }) togetherWith
             fadeOut(tween(160))
 }
+
+private const val QUICK_FADE_MILLIS = 120
diff --git a/app/src/main/java/video/typetype/tv/theme/Dimens.kt b/core/ui/src/main/java/video/typetype/tv/theme/Dimens.kt
similarity index 74%
rename from app/src/main/java/video/typetype/tv/theme/Dimens.kt
rename to core/ui/src/main/java/video/typetype/tv/theme/Dimens.kt
index 124a58c..f1753ff 100644
--- a/app/src/main/java/video/typetype/tv/theme/Dimens.kt
+++ b/core/ui/src/main/java/video/typetype/tv/theme/Dimens.kt
@@ -15,6 +15,10 @@ object Dimens {
     val RowGap = 26.dp
 
     val TopNavHeight = 56.dp
+
+    // Where the content of the Search, Library and Settings tabs starts, and how far the shade under the top bar
+    // reaches: content that started higher was darkened by the shade, as if it were cut.
+    val TabContentTop = 128.dp
     val FocusRingWidth = 2.5.dp
     const val FocusScale = 1.06f
     const val FocusScaleSmall = 1.035f
diff --git a/app/src/main/java/video/typetype/tv/theme/Palette.kt b/core/ui/src/main/java/video/typetype/tv/theme/Palette.kt
similarity index 88%
rename from app/src/main/java/video/typetype/tv/theme/Palette.kt
rename to core/ui/src/main/java/video/typetype/tv/theme/Palette.kt
index 7753056..73f06ff 100644
--- a/app/src/main/java/video/typetype/tv/theme/Palette.kt
+++ b/core/ui/src/main/java/video/typetype/tv/theme/Palette.kt
@@ -37,9 +37,10 @@ object Palette {
         1.0f to Ink,
     )
 
+    // Nearly opaque down to where the previous row's text stops when a row scrolls under the bar.
     val NavScrim: Brush = Brush.verticalGradient(
-        0.0f to Ink.copy(alpha = 0.94f),
-        0.7f to Ink.copy(alpha = 0.55f),
+        0.0f to Ink.copy(alpha = 0.97f),
+        0.75f to Ink.copy(alpha = 0.92f),
         1.0f to Color.Transparent,
     )
 
diff --git a/app/src/main/java/video/typetype/tv/theme/Type.kt b/core/ui/src/main/java/video/typetype/tv/theme/Type.kt
similarity index 87%
rename from app/src/main/java/video/typetype/tv/theme/Type.kt
rename to core/ui/src/main/java/video/typetype/tv/theme/Type.kt
index b231318..657167d 100644
--- a/app/src/main/java/video/typetype/tv/theme/Type.kt
+++ b/core/ui/src/main/java/video/typetype/tv/theme/Type.kt
@@ -5,22 +5,15 @@ import androidx.compose.ui.text.font.FontFamily
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.sp
 
+// Line heights stay near 1.25 times the size: tighter, the letters that go below the line (g, p, y) are cut off.
 object Type {
     private val family = FontFamily.SansSerif
 
-    val Wordmark = TextStyle(
-        fontFamily = family,
-        fontWeight = FontWeight.Light,
-        fontSize = 20.sp,
-        letterSpacing = 3.sp,
-        color = Palette.TextHigh,
-    )
-
     val Display = TextStyle(
         fontFamily = family,
         fontWeight = FontWeight.SemiBold,
         fontSize = 38.sp,
-        lineHeight = 42.sp,
+        lineHeight = 48.sp,
         letterSpacing = (-0.6).sp,
         color = Palette.TextHigh,
     )
@@ -29,7 +22,7 @@ object Type {
         fontFamily = family,
         fontWeight = FontWeight.SemiBold,
         fontSize = 24.sp,
-        lineHeight = 28.sp,
+        lineHeight = 30.sp,
         letterSpacing = (-0.3).sp,
         color = Palette.TextHigh,
     )
diff --git a/core/ui/src/main/java/video/typetype/tv/ui/brand/BrandLogo.kt b/core/ui/src/main/java/video/typetype/tv/ui/brand/BrandLogo.kt
new file mode 100644
index 0000000..24383f9
--- /dev/null
+++ b/core/ui/src/main/java/video/typetype/tv/ui/brand/BrandLogo.kt
@@ -0,0 +1,63 @@
+package video.typetype.tv.ui.brand
+
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.StrokeCap
+import androidx.compose.ui.graphics.StrokeJoin
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.graphics.drawscope.scale
+import androidx.compose.ui.graphics.drawscope.translate
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.clearAndSetSemantics
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import video.typetype.tv.resources.R
+import video.typetype.tv.theme.Palette
+
+// The TypeType logo: the red mark and the lettered wordmark, read by TalkBack as one name.
+@Composable
+fun BrandLogo(modifier: Modifier = Modifier, markSize: Dp = 30.dp) {
+    val description = stringResource(R.string.logo_description)
+    Row(
+        modifier.clearAndSetSemantics { contentDescription = description },
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Image(painterResource(R.drawable.ic_typetype_mark), contentDescription = null, modifier = Modifier.size(markSize))
+        Spacer(Modifier.width(markSize * 0.36f))
+        Wordmark(capHeight = markSize * 0.5f)
+    }
+}
+
+@Composable
+fun Wordmark(capHeight: Dp, modifier: Modifier = Modifier, color: Color = Palette.TextHigh) {
+    val strokes = remember { WordmarkLettering.strokes() }
+    val unit = capHeight / WordmarkLettering.CAP
+    val margin = WordmarkLettering.STROKE / 2
+    Canvas(
+        modifier.size(
+            width = unit * (WordmarkLettering.width + WordmarkLettering.STROKE),
+            height = unit * (WordmarkLettering.CAP + WordmarkLettering.STROKE),
+        ),
+    ) {
+        val scale = size.height / (WordmarkLettering.CAP + WordmarkLettering.STROKE)
+        scale(scale, pivot = Offset.Zero) {
+            translate(margin, margin) {
+                strokes.forEach { drawPath(it, color, style = LINE) }
+            }
+        }
+    }
+}
+
+private val LINE = Stroke(width = WordmarkLettering.STROKE, cap = StrokeCap.Round, join = StrokeJoin.Round)
diff --git a/core/ui/src/main/java/video/typetype/tv/ui/brand/WordmarkLettering.kt b/core/ui/src/main/java/video/typetype/tv/ui/brand/WordmarkLettering.kt
new file mode 100644
index 0000000..0bf8bf3
--- /dev/null
+++ b/core/ui/src/main/java/video/typetype/tv/ui/brand/WordmarkLettering.kt
@@ -0,0 +1,74 @@
+package video.typetype.tv.ui.brand
+
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Rect
+import androidx.compose.ui.graphics.Path
+
+// TYPETYPE lettered in the stroke of the mark: heavy, round caps, a curved Y. The logo, the startup intro and the
+// TV banner (tv_banner.xml, generated from these numbers) all draw it. Units: cap height 10, y down.
+object WordmarkLettering {
+    const val CAP = 10f
+    const val STROKE = 2.5f
+    private const val WORD = "TYPETYPE"
+    private const val GAP = 3.4f
+
+    val width: Float = WORD.mapIndexed { index, letter -> letterWidth(letter) + if (index > 0) GAP else 0f }.sum()
+
+    // Space after the last letter, where a text cursor stands.
+    const val CURSOR_GAP = GAP
+
+    // Every stroke of the word, placed in word coordinates, in the order a hand would write them.
+    fun strokes(): List<Path> {
+        var x = 0f
+        return WORD.flatMapIndexed { index, letter ->
+            if (index > 0) x += GAP
+            val placed = letterStrokes(letter).onEach { it.translate(Offset(x, 0f)) }
+            x += letterWidth(letter)
+            placed
+        }
+    }
+
+    private fun letterWidth(letter: Char): Float = when (letter) {
+        'P' -> 6.4f
+        'E' -> 7f
+        else -> 8f
+    }
+
+    private fun letterStrokes(letter: Char): List<Path> = when (letter) {
+        'T' -> listOf(line(0f, 0f, 8f, 0f), line(4f, 0f, 4f, CAP))
+        'Y' -> listOf(
+            Path().apply {
+                moveTo(0f, 0f)
+                cubicTo(0f, 3.6f, 1.6f, 5.2f, 4f, 5.2f)
+                cubicTo(6.4f, 5.2f, 8f, 3.6f, 8f, 0f)
+            },
+            line(4f, 5.2f, 4f, CAP),
+        )
+        'P' -> listOf(
+            Path().apply {
+                moveTo(0f, CAP)
+                lineTo(0f, 0f)
+                lineTo(3.4f, 0f)
+                arcTo(Rect(0.4f, 0f, 6.4f, 6f), 270f, 180f, false)
+                lineTo(0f, 6f)
+            },
+        )
+        'E' -> listOf(
+            Path().apply {
+                moveTo(7f, 0f)
+                lineTo(2.6f, 0f)
+                arcTo(Rect(0f, 0f, 5.2f, 5.2f), 270f, -90f, false)
+                lineTo(0f, 7.4f)
+                arcTo(Rect(0f, 4.8f, 5.2f, 10f), 180f, -90f, false)
+                lineTo(7f, CAP)
+            },
+            line(0f, 5f, 5.4f, 5f),
+        )
+        else -> error("No lettering for $letter")
+    }
+
+    private fun line(x0: Float, y0: Float, x1: Float, y1: Float) = Path().apply {
+        moveTo(x0, y0)
+        lineTo(x1, y1)
+    }
+}
diff --git a/core/ui/src/main/java/video/typetype/tv/ui/components/Backdrop.kt b/core/ui/src/main/java/video/typetype/tv/ui/components/Backdrop.kt
new file mode 100644
index 0000000..19a6e96
--- /dev/null
+++ b/core/ui/src/main/java/video/typetype/tv/ui/components/Backdrop.kt
@@ -0,0 +1,168 @@
+package video.typetype.tv.ui.components
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.Crossfade
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.core.snap
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.BiasAlignment
+import androidx.compose.ui.draw.drawWithCache
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.Brush
+import androidx.compose.ui.graphics.Canvas
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.FilterQuality
+import androidx.compose.ui.graphics.ImageBitmap
+import androidx.compose.ui.graphics.drawscope.CanvasDrawScope
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.unit.Density
+import androidx.compose.ui.unit.IntOffset
+import androidx.compose.ui.unit.IntSize
+import androidx.compose.ui.unit.LayoutDirection
+import coil3.compose.AsyncImage
+import kotlin.math.roundToInt
+import kotlinx.coroutines.delay
+import video.typetype.tv.data.Video
+import video.typetype.tv.theme.Palette
+import video.typetype.tv.ui.util.LocalPerformance
+
+@Composable
+fun Backdrop(
+    artwork: String?,
+    modifier: Modifier = Modifier,
+    focusY: Float = 0.5f,
+    preview: Video? = null,
+    onPreviewPlaying: (Boolean) -> Unit = {},
+) {
+    val previews = LocalVideoPreviews.current
+    val candidate = preview?.takeIf { previews != null && !it.isLive && !it.isShort }
+    var playing by remember(candidate?.id) { mutableStateOf(false) }
+    var started by remember(candidate?.id) { mutableStateOf(false) }
+    var surfaceShown by remember { mutableStateOf(false) }
+    LaunchedEffect(candidate?.id) {
+        if (candidate == null) return@LaunchedEffect
+        delay(PREVIEW_DELAY_MILLIS)
+        started = true
+        surfaceShown = true
+    }
+    val currentOnPlaying by rememberUpdatedState(onPreviewPlaying)
+    LaunchedEffect(playing) { currentOnPlaying(playing) }
+    Box(modifier = modifier.fillMaxSize()) {
+        // The preview's SurfaceView sits under the window; the artwork stays drawn above it until the first
+        // frame, then fades away, so the screen never shows an empty black surface.
+        if (surfaceShown && previews != null) {
+            previews.Show(candidate?.takeIf { started }, onPlaying = { playing = it }, modifier = Modifier.fillMaxSize())
+        }
+        val performance = LocalPerformance.current
+        AnimatedVisibility(
+            visible = !playing && performance.backdrop,
+            enter = fadeIn(tween(BACKDROP_FADE_MILLIS)),
+            exit = fadeOut(tween(BACKDROP_FADE_MILLIS)),
+        ) {
+            Crossfade(
+                targetState = artwork to focusY,
+                animationSpec = if (performance.smoothAnimations) tween(durationMillis = BACKDROP_FADE_MILLIS) else snap(),
+                label = "backdrop-image",
+            ) { (resource, bias) ->
+                AsyncImage(
+                    model = resource,
+                    contentDescription = null,
+                    contentScale = ContentScale.Crop,
+                    alignment = BiasAlignment(0f, bias * 2f - 1f),
+                    modifier = Modifier.fillMaxSize(),
+                )
+            }
+        }
+        BackdropScrims()
+    }
+}
+
+private const val PREVIEW_DELAY_MILLIS = 2_000L
+
+@Composable
+private fun BackdropScrims(modifier: Modifier = Modifier) {
+    Box(
+        modifier = modifier
+            .fillMaxSize()
+            .drawWithCache {
+                val overlay = renderScrims(size)
+                val target = IntSize(size.width.roundToInt(), size.height.roundToInt())
+                onDrawBehind { drawImage(overlay, dstSize = target, filterQuality = FilterQuality.Low) }
+            },
+    )
+}
+
+private fun Density.renderScrims(size: Size): ImageBitmap {
+    val width = (size.width / SCRIM_DOWNSCALE).roundToInt().coerceAtLeast(1)
+    val height = (size.height / SCRIM_DOWNSCALE).roundToInt().coerceAtLeast(1)
+    val bitmap = ImageBitmap(width, height)
+    val tint = Palette.Ink.copy(alpha = TINT_ALPHA)
+    CanvasDrawScope().draw(this, LayoutDirection.Ltr, Canvas(bitmap), Size(width.toFloat(), height.toFloat())) {
+        val glow = Brush.radialGradient(
+            colors = listOf(Palette.Accent.copy(alpha = GLOW_ALPHA), Color.Transparent),
+            center = Offset(width * GLOW_CENTER_X, 0f),
+            radius = width * GLOW_RADIUS,
+        )
+        drawRect(tint)
+        drawRect(Palette.BackdropScrimHorizontal)
+        drawRect(Palette.BackdropScrimVertical)
+        drawRect(glow)
+    }
+    return bitmap
+}
+
+@Composable
+fun InkBackground(modifier: Modifier = Modifier) {
+    Box(
+        modifier = modifier
+            .fillMaxSize()
+            .drawWithCache {
+                val glow = renderGlow(size)
+                onDrawBehind {
+                    drawRect(Palette.Ink)
+                    drawImage(glow.image, dstOffset = glow.offset, dstSize = glow.size, filterQuality = FilterQuality.Low)
+                }
+            },
+    )
+}
+
+private class Glow(val image: ImageBitmap, val offset: IntOffset, val size: IntSize)
+
+// Outside its circle the glow is transparent, so only that corner is drawn over the solid ink, from a small image.
+private fun Density.renderGlow(size: Size): Glow {
+    val radius = size.width * GLOW_RADIUS
+    val left = (size.width * GLOW_CENTER_X - radius).coerceAtLeast(0f)
+    val area = IntSize((size.width - left).roundToInt().coerceAtLeast(1), radius.coerceAtMost(size.height).roundToInt().coerceAtLeast(1))
+    val width = (area.width / SCRIM_DOWNSCALE).roundToInt().coerceAtLeast(1)
+    val height = (area.height / SCRIM_DOWNSCALE).roundToInt().coerceAtLeast(1)
+    val bitmap = ImageBitmap(width, height)
+    CanvasDrawScope().draw(this, LayoutDirection.Ltr, Canvas(bitmap), Size(width.toFloat(), height.toFloat())) {
+        drawRect(
+            Brush.radialGradient(
+                colors = listOf(Palette.Accent.copy(alpha = GLOW_ALPHA), Color.Transparent),
+                center = Offset((size.width * GLOW_CENTER_X - left) / SCRIM_DOWNSCALE, 0f),
+                radius = radius / SCRIM_DOWNSCALE,
+            ),
+        )
+    }
+    return Glow(bitmap, IntOffset(left.roundToInt(), 0), area)
+}
+
+private const val TINT_ALPHA = 0.24f
+private const val GLOW_ALPHA = 0.16f
+private const val GLOW_CENTER_X = 0.9f
+private const val GLOW_RADIUS = 0.5f
+private const val SCRIM_DOWNSCALE = 4f
+private const val BACKDROP_FADE_MILLIS = 700
diff --git a/app/src/main/java/video/typetype/tv/ui/components/Badges.kt b/core/ui/src/main/java/video/typetype/tv/ui/components/Badges.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/components/Badges.kt
rename to core/ui/src/main/java/video/typetype/tv/ui/components/Badges.kt
diff --git a/app/src/main/java/video/typetype/tv/ui/components/Buttons.kt b/core/ui/src/main/java/video/typetype/tv/ui/components/Buttons.kt
similarity index 59%
rename from app/src/main/java/video/typetype/tv/ui/components/Buttons.kt
rename to core/ui/src/main/java/video/typetype/tv/ui/components/Buttons.kt
index 1733edf..e4d3e0e 100644
--- a/app/src/main/java/video/typetype/tv/ui/components/Buttons.kt
+++ b/core/ui/src/main/java/video/typetype/tv/ui/components/Buttons.kt
@@ -1,5 +1,13 @@
 package video.typetype.tv.ui.components
 
+import androidx.compose.ui.unit.Constraints
+import androidx.compose.ui.layout.layout
+import androidx.compose.ui.semantics.clearAndSetSemantics
+import androidx.compose.foundation.background
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.layout.ContentScale
+import coil3.compose.AsyncImage
 import androidx.compose.animation.animateColorAsState
 import androidx.compose.animation.core.tween
 import androidx.compose.foundation.interaction.MutableInteractionSource
@@ -18,6 +26,7 @@ import androidx.compose.runtime.remember
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.drawBehind
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.ColorProducer
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.semantics.Role
@@ -44,6 +53,7 @@ fun PillButton(
     description: String? = null,
     maxLabelWidth: Dp = Dp.Unspecified,
     compact: Boolean = false,
+    leading: (@Composable () -> Unit)? = null,
 ) {
     val source = remember { MutableInteractionSource() }
     val focused by source.collectIsFocusedAsState()
@@ -83,6 +93,8 @@ fun PillButton(
         ) {
             if (icon != null) {
                 Glyph(icon, { content.value }, 20)
+            } else {
+                leading?.invoke()
             }
             BasicText(
                 text = label,
@@ -105,6 +117,41 @@ fun CircleButton(
     diameter: Int = 44,
     emphasized: Boolean = false,
     onFocused: (() -> Unit)? = null,
+    labelOnFocus: Boolean = false,
+) {
+    CircleSurface(description, onClick, modifier, diameter, emphasized, onFocused, description.takeIf { labelOnFocus }) { tint ->
+        Glyph(icon, tint, (diameter * 0.5f).toInt())
+    }
+}
+
+// A round button showing a picture, such as a channel's avatar; the focused one names itself underneath.
+@Composable
+fun AvatarButton(
+    imageUrl: String?,
+    name: String,
+    description: String,
+    onClick: () -> Unit,
+    modifier: Modifier = Modifier,
+    diameter: Int = 44,
+) {
+    CircleSurface(description, onClick, modifier, diameter, emphasized = false, onFocused = null, label = name) { tint ->
+        BasicText(name.take(1).uppercase(), style = Type.Label, color = { tint() }, maxLines = 1)
+        if (imageUrl != null) {
+            AsyncImage(imageUrl, null, Modifier.size(diameter.dp).padding(3.dp).clip(CircleShape), contentScale = ContentScale.Crop)
+        }
+    }
+}
+
+@Composable
+private fun CircleSurface(
+    description: String,
+    onClick: () -> Unit,
+    modifier: Modifier,
+    diameter: Int,
+    emphasized: Boolean,
+    onFocused: (() -> Unit)?,
+    label: String?,
+    content: @Composable (() -> Color) -> Unit,
 ) {
     val source = remember { MutableInteractionSource() }
     val focused by source.collectIsFocusedAsState()
@@ -122,30 +169,52 @@ fun CircleButton(
         animationSpec = tween(160),
         label = "circle-tint",
     )
-    FocusSurface(
-        onClick = onClick,
-        modifier = modifier
-            .size(diameter.dp)
-            .semantics {
-                role = Role.Button
-                contentDescription = description
-            },
-        shape = Shapes.Button,
-        focusedScale = Dimens.FocusScaleSmall,
-        interactionSource = source,
-        onFocused = onFocused,
-    ) {
-        Box(
+    Box(modifier, contentAlignment = Alignment.TopCenter) {
+        FocusSurface(
+            onClick = onClick,
             modifier = Modifier
                 .size(diameter.dp)
-                .drawBehind { drawRect(container.value) },
-            contentAlignment = Alignment.Center,
+                .semantics {
+                    role = Role.Button
+                    contentDescription = description
+                },
+            shape = Shapes.Button,
+            focusedScale = Dimens.FocusScaleSmall,
+            interactionSource = source,
+            onFocused = onFocused,
         ) {
-            Glyph(icon, { tint.value }, (diameter * 0.5f).toInt())
+            Box(
+                modifier = Modifier
+                    .size(diameter.dp)
+                    .drawBehind { drawRect(container.value) },
+                contentAlignment = Alignment.Center,
+            ) {
+                content { tint.value }
+            }
+        }
+        // An icon alone does not say what it does from the sofa; the focused one names itself underneath. The
+        // label takes no room in the layout, so the row never moves.
+        if (label != null && focused) {
+            BasicText(
+                label,
+                style = Type.Meta.copy(color = Palette.TextHigh),
+                maxLines = 1,
+                modifier = Modifier
+                    .layout { measurable, _ ->
+                        val text = measurable.measure(Constraints())
+                        layout(0, 0) { text.place(-text.width / 2, (diameter + LABEL_GAP).dp.roundToPx()) }
+                    }
+                    .background(Palette.Scrim, Shapes.Chip)
+                    .padding(horizontal = 8.dp, vertical = 3.dp)
+                    .clearAndSetSemantics { },
+            )
         }
     }
 }
 
+private const val LABEL_GAP = 6
+
+
 @Composable
 fun TextLabel(
     text: String,
@@ -153,6 +222,7 @@ fun TextLabel(
     modifier: Modifier = Modifier,
     maxLines: Int = Int.MAX_VALUE,
     color: ColorProducer? = null,
+    minLines: Int = 1,
 ) {
     BasicText(
         text = text,
@@ -160,6 +230,7 @@ fun TextLabel(
         style = style,
         color = color,
         maxLines = maxLines,
+        minLines = minLines,
         overflow = androidx.compose.ui.text.style.TextOverflow.Ellipsis,
     )
 }
diff --git a/core/ui/src/main/java/video/typetype/tv/ui/components/CachedLayer.kt b/core/ui/src/main/java/video/typetype/tv/ui/components/CachedLayer.kt
new file mode 100644
index 0000000..dbb2df4
--- /dev/null
+++ b/core/ui/src/main/java/video/typetype/tv/ui/components/CachedLayer.kt
@@ -0,0 +1,9 @@
+package video.typetype.tv.ui.components
+
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.CompositingStrategy
+import androidx.compose.ui.graphics.graphicsLayer
+
+// Some TV GPUs cannot redraw only what changed, so every frame repaints the whole window: a block kept in its own
+// texture is copied back when it did not change instead of being drawn again.
+fun Modifier.cachedLayer(): Modifier = graphicsLayer { compositingStrategy = CompositingStrategy.Offscreen }
diff --git a/app/src/main/java/video/typetype/tv/ui/components/ConfirmDialog.kt b/core/ui/src/main/java/video/typetype/tv/ui/components/ConfirmDialog.kt
similarity index 87%
rename from app/src/main/java/video/typetype/tv/ui/components/ConfirmDialog.kt
rename to core/ui/src/main/java/video/typetype/tv/ui/components/ConfirmDialog.kt
index b57b73e..fa24d79 100644
--- a/app/src/main/java/video/typetype/tv/ui/components/ConfirmDialog.kt
+++ b/core/ui/src/main/java/video/typetype/tv/ui/components/ConfirmDialog.kt
@@ -1,14 +1,11 @@
 package video.typetype.tv.ui.components
 
-import androidx.activity.compose.BackHandler
 import androidx.compose.foundation.background
 import androidx.compose.foundation.focusGroup
 import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.width
@@ -18,7 +15,6 @@ import androidx.compose.material.icons.rounded.Close
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.remember
-import androidx.compose.ui.Alignment
 import androidx.compose.ui.ExperimentalComposeUiApi
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
@@ -27,7 +23,7 @@ import androidx.compose.ui.focus.focusProperties
 import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.theme.Palette
 import video.typetype.tv.theme.Shapes
 import video.typetype.tv.theme.Type
@@ -43,12 +39,11 @@ fun ConfirmDialog(
     onDismiss: () -> Unit,
     modifier: Modifier = Modifier,
 ) {
-    BackHandler(onBack = onDismiss)
     val cancel = remember { FocusRequester() }
     LaunchedEffect(Unit) { cancel.requestFocusWhenReady() }
-    Box(modifier.fillMaxSize().background(Palette.Scrim), contentAlignment = Alignment.Center) {
+    TvOverlay(onDismiss) {
         Column(
-            modifier = Modifier
+            modifier = modifier
                 .width(520.dp)
                 .clip(Shapes.Panel)
                 .background(Palette.Surface)
diff --git a/app/src/main/java/video/typetype/tv/ui/components/FadeVisibility.kt b/core/ui/src/main/java/video/typetype/tv/ui/components/FadeVisibility.kt
similarity index 76%
rename from app/src/main/java/video/typetype/tv/ui/components/FadeVisibility.kt
rename to core/ui/src/main/java/video/typetype/tv/ui/components/FadeVisibility.kt
index 99a5a0d..6590ff8 100644
--- a/app/src/main/java/video/typetype/tv/ui/components/FadeVisibility.kt
+++ b/core/ui/src/main/java/video/typetype/tv/ui/components/FadeVisibility.kt
@@ -13,12 +13,10 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.CompositingStrategy
 import androidx.compose.ui.graphics.graphicsLayer
 
-/**
- * Fades content in and out without an offscreen layer: the alpha is applied to each draw call
- * (ModulateAlpha) instead of rendering the subtree into a full-size texture first, which costs a
- * whole extra pass on the TV GPU for every frame of the fade. Overlapping translucent children
- * show through each other while the fade runs, which is invisible at this speed.
- */
+// Fades content in and out without an offscreen layer: the alpha is applied to each draw call (ModulateAlpha) instead
+// of rendering the subtree into a full-size texture first, which costs a whole extra pass on the TV GPU for every frame
+// of the fade. Overlapping translucent children show through each other while the fade runs, which is invisible at this
+// speed.
 @Composable
 fun FadeVisibility(
     visible: Boolean,
diff --git a/app/src/main/java/video/typetype/tv/ui/components/FocusSurface.kt b/core/ui/src/main/java/video/typetype/tv/ui/components/FocusSurface.kt
similarity index 77%
rename from app/src/main/java/video/typetype/tv/ui/components/FocusSurface.kt
rename to core/ui/src/main/java/video/typetype/tv/ui/components/FocusSurface.kt
index 48627d9..cb09cb7 100644
--- a/app/src/main/java/video/typetype/tv/ui/components/FocusSurface.kt
+++ b/core/ui/src/main/java/video/typetype/tv/ui/components/FocusSurface.kt
@@ -3,9 +3,10 @@ package video.typetype.tv.ui.components
 import androidx.compose.animation.core.Spring
 import androidx.compose.animation.core.animateDpAsState
 import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.animation.core.snap
 import androidx.compose.animation.core.spring
 import androidx.compose.animation.core.tween
-import androidx.compose.foundation.clickable
+import androidx.compose.foundation.combinedClickable
 import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.interaction.collectIsFocusedAsState
 import androidx.compose.foundation.layout.Box
@@ -26,11 +27,10 @@ import androidx.compose.ui.unit.dp
 import video.typetype.tv.theme.Dimens
 import video.typetype.tv.theme.Palette
 import video.typetype.tv.theme.Shapes
+import video.typetype.tv.ui.util.LocalPerformance
 
-/**
- * Focus animations are read only in the layer and draw phases, so moving the focus never
- * recomposes the surface or its content; scale, lift, clip and shadow share one render node.
- */
+// Focus animations are read only in the layer and draw phases, so moving the focus never recomposes the surface or its
+// content; scale, lift, clip and shadow share one render node.
 @Composable
 fun FocusSurface(
     onClick: () -> Unit,
@@ -41,21 +41,25 @@ fun FocusSurface(
     interactionSource: MutableInteractionSource = remember { MutableInteractionSource() },
     onFocused: (() -> Unit)? = null,
     focusLift: Dp = 22.dp,
+    onLongClick: (() -> Unit)? = null,
     content: @Composable BoxScope.(focused: Boolean) -> Unit,
 ) {
     val focused by interactionSource.collectIsFocusedAsState()
+    // Without smooth animations the focus jumps at once and casts no shadow: a slow box redraws the whole screen
+    // for every frame of an animation, and a shadow is drawn again each time.
+    val smooth = LocalPerformance.current.smoothAnimations
     val scale = animateFloatAsState(
         targetValue = if (focused) focusedScale else 1f,
-        animationSpec = spring(dampingRatio = 0.78f, stiffness = Spring.StiffnessMediumLow),
+        animationSpec = if (smooth) spring(dampingRatio = 0.78f, stiffness = Spring.StiffnessMediumLow) else snap(),
         label = "focus-scale",
     )
     val ring = animateFloatAsState(
         targetValue = if (focused) 1f else 0f,
-        animationSpec = tween(durationMillis = 170),
+        animationSpec = if (smooth) tween(durationMillis = 170) else snap(),
         label = "focus-ring",
     )
     val lift = animateDpAsState(
-        targetValue = if (focused) focusLift else 0.dp,
+        targetValue = if (focused && smooth) focusLift else 0.dp,
         animationSpec = tween(durationMillis = 220),
         label = "focus-lift",
     )
@@ -73,9 +77,10 @@ fun FocusSurface(
                 this.shape = shape
                 clip = true
             }
-            .clickable(
+            .combinedClickable(
                 interactionSource = interactionSource,
                 indication = null,
+                onLongClick = onLongClick,
                 onClick = onClick,
             )
             .focusRing(shape, ringColor) { ring.value },
diff --git a/app/src/main/java/video/typetype/tv/ui/components/Glyph.kt b/core/ui/src/main/java/video/typetype/tv/ui/components/Glyph.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/components/Glyph.kt
rename to core/ui/src/main/java/video/typetype/tv/ui/components/Glyph.kt
diff --git a/core/ui/src/main/java/video/typetype/tv/ui/components/MessageText.kt b/core/ui/src/main/java/video/typetype/tv/ui/components/MessageText.kt
new file mode 100644
index 0000000..5302e1c
--- /dev/null
+++ b/core/ui/src/main/java/video/typetype/tv/ui/components/MessageText.kt
@@ -0,0 +1,19 @@
+package video.typetype.tv.ui.components
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import video.typetype.tv.resources.R
+import video.typetype.tv.theme.Palette
+import video.typetype.tv.theme.Type
+import video.typetype.tv.ui.util.UiMessage
+
+@Composable
+fun MessageText(message: UiMessage?, modifier: Modifier = Modifier) {
+    if (message == null) return
+    Column(modifier) {
+        TextLabel(stringResource(message.textRes), Type.Body.copy(color = Palette.AccentSoft), maxLines = 3)
+        message.requestId?.let { TextLabel(stringResource(R.string.request_id, it), Type.Meta, maxLines = 1) }
+    }
+}
diff --git a/core/ui/src/main/java/video/typetype/tv/ui/components/OptionWheel.kt b/core/ui/src/main/java/video/typetype/tv/ui/components/OptionWheel.kt
new file mode 100644
index 0000000..22ffadc
--- /dev/null
+++ b/core/ui/src/main/java/video/typetype/tv/ui/components/OptionWheel.kt
@@ -0,0 +1,193 @@
+package video.typetype.tv.ui.components
+
+import androidx.compose.animation.animateContentSize
+import androidx.compose.animation.core.Animatable
+import androidx.compose.animation.core.animateDpAsState
+import androidx.compose.animation.core.spring
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.background
+import androidx.compose.foundation.focusable
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.interaction.collectIsFocusedAsState
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.defaultMinSize
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.input.key.KeyEventType
+import androidx.compose.ui.input.key.key
+import androidx.compose.ui.input.key.onPreviewKeyEvent
+import androidx.compose.ui.input.key.type
+import androidx.compose.ui.semantics.clearAndSetSemantics
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.stateDescription
+import androidx.compose.ui.focus.FocusDirection
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.platform.LocalFocusManager
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.IntOffset
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.Popup
+import androidx.compose.ui.window.PopupProperties
+import video.typetype.tv.theme.Palette
+import video.typetype.tv.theme.Shapes
+import video.typetype.tv.theme.Type
+import kotlin.math.abs
+
+class WheelOption(val label: String, val icon: ImageVector)
+
+private val RowHeight = 36.dp
+private val PillHeight = 40.dp
+private val PanelPadding = 10.dp
+// One value above and one below the cursor: three at most, the rest fade out as they leave.
+private const val SHOWN_ROWS = 1
+private const val TILT_DEGREES = 24f
+private const val FADE_PER_ROW = 0.38f
+
+// Rows further from the middle come a little closer, as on a drum seen from the front.
+private const val ROW_SQUEEZE = 0.08f
+
+// A short list of values on a drum. At rest it is a pill with the chosen value and its icon. With the focus, the
+// drum opens in a popup anchored on the pill, above everything around it: Up and Down move through the values,
+// OK confirms one and moves on down, and leaving the wheel any other way confirms it too. At either end, Up and
+// Down leave the wheel like any other control. The popup never takes the focus; the drum turns in the layer and
+// draw phases, and only reaches as far as there are values above and below.
+@Composable
+fun OptionWheel(
+    options: List<WheelOption>,
+    selected: Int,
+    onSelect: (Int) -> Unit,
+    description: String,
+    modifier: Modifier = Modifier,
+) {
+    val source = remember { MutableInteractionSource() }
+    val focused by source.collectIsFocusedAsState()
+    val focusManager = LocalFocusManager.current
+    var pending by remember(selected) { mutableIntStateOf(selected) }
+    // Leaving the wheel, in any direction, keeps the value it was turned to, as OK does.
+    LaunchedEffect(focused) { if (!focused && pending != selected) onSelect(pending) }
+    Box(
+        modifier
+            .onPreviewKeyEvent { event ->
+                val ok = event.key == Key.DirectionCenter || event.key == Key.Enter || event.key == Key.NumPadEnter
+                if (ok) {
+                    if (event.type == KeyEventType.KeyUp) {
+                        if (pending != selected) onSelect(pending)
+                        focusManager.moveFocus(FocusDirection.Down)
+                    }
+                    return@onPreviewKeyEvent true
+                }
+                if (event.type != KeyEventType.KeyDown) return@onPreviewKeyEvent false
+                val step = when (event.key) {
+                    Key.DirectionUp -> -1
+                    Key.DirectionDown -> 1
+                    else -> return@onPreviewKeyEvent false
+                }
+                val next = pending + step
+                if (next !in options.indices) return@onPreviewKeyEvent false
+                pending = next
+                true
+            }
+            .focusable(interactionSource = source)
+            // After focusable: what follows is cleared, so the labels are read once but the focus stays reachable.
+            .clearAndSetSemantics {
+                contentDescription = description
+                stateDescription = options[selected].label
+            },
+        contentAlignment = Alignment.CenterStart,
+    ) {
+        WheelRow(
+            option = options[selected],
+            color = if (focused) Palette.Ink else Palette.TextHigh,
+            modifier = Modifier
+                .clip(Shapes.Button)
+                .background(if (focused) Palette.TextHigh else Palette.Glass)
+                .defaultMinSize(minHeight = PillHeight)
+                .padding(horizontal = 18.dp)
+                .animateContentSize(),
+        )
+        if (focused) {
+            val above by animateDpAsState(reachFor(pending), tween(180), label = "drum-above")
+            val below by animateDpAsState(reachFor(options.lastIndex - pending), tween(180), label = "drum-below")
+            val lift = with(LocalDensity.current) { above.roundToPx() }
+            Popup(
+                alignment = Alignment.TopStart,
+                offset = IntOffset(0, -lift),
+                properties = PopupProperties(focusable = false, clippingEnabled = false),
+            ) {
+                Drum(options, pending, above, below)
+            }
+        }
+    }
+}
+
+@Composable
+private fun WheelRow(option: WheelOption, color: Color, modifier: Modifier = Modifier) {
+    Row(
+        modifier = modifier,
+        horizontalArrangement = Arrangement.spacedBy(8.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Glyph(option.icon, color, 20)
+        TextLabel(option.label, Type.Button.copy(color = color), maxLines = 1)
+    }
+}
+
+// The open drum: an opaque panel as wide as the longest value, the value under the cursor in a lit pill at its
+// middle, the others rolling away above and below.
+// Room for the values on one side of the cursor, none when there are none: no empty band at either end.
+private fun reachFor(rows: Int): Dp = if (rows <= 0) 0.dp else RowHeight * rows.coerceAtMost(SHOWN_ROWS) + PanelPadding
+
+@Composable
+private fun Drum(options: List<WheelOption>, pending: Int, above: Dp, below: Dp) {
+    val position = remember { Animatable(pending.toFloat()) }
+    LaunchedEffect(pending) { position.animateTo(pending.toFloat(), spring(dampingRatio = 0.86f, stiffness = 420f)) }
+    val appear = remember { Animatable(0f) }
+    LaunchedEffect(Unit) { appear.animateTo(1f, tween(160)) }
+    Box(
+        Modifier
+            .graphicsLayer { alpha = appear.value }
+            .clip(RoundedCornerShape(PillHeight / 2))
+            .background(Palette.SurfaceRaised)
+            .padding(top = above, bottom = below),
+        contentAlignment = Alignment.CenterStart,
+    ) {
+        Box(Modifier.matchParentSize().clip(Shapes.Button).background(Palette.TextHigh))
+        // Every value is laid out, so the drum is as wide as the longest one.
+        Box(Modifier.height(PillHeight).padding(horizontal = 18.dp), contentAlignment = Alignment.CenterStart) {
+            options.forEachIndexed { index, option ->
+                WheelRow(
+                    option = option,
+                    color = if (index == pending) Palette.Ink else Palette.TextHigh,
+                    modifier = Modifier.graphicsLayer {
+                        val distance = index - position.value
+                        val away = abs(distance)
+                        translationY = RowHeight.toPx() * distance * (1f - ROW_SQUEEZE * away.coerceAtMost(SHOWN_ROWS.toFloat()))
+                        rotationX = -(distance * TILT_DEGREES).coerceIn(-80f, 80f)
+                        cameraDistance = 12f * density
+                        alpha = when {
+                            away < 0.5f -> 1f
+                            away <= SHOWN_ROWS -> 1f - away * FADE_PER_ROW
+                            else -> (1f - FADE_PER_ROW) * ((SHOWN_ROWS + 0.5f - away) / 0.5f).coerceIn(0f, 1f)
+                        }
+                    },
+                )
+            }
+        }
+    }
+}
diff --git a/core/ui/src/main/java/video/typetype/tv/ui/components/PlaybackPreload.kt b/core/ui/src/main/java/video/typetype/tv/ui/components/PlaybackPreload.kt
new file mode 100644
index 0000000..0453d0f
--- /dev/null
+++ b/core/ui/src/main/java/video/typetype/tv/ui/components/PlaybackPreload.kt
@@ -0,0 +1,12 @@
+package video.typetype.tv.ui.components
+
+import androidx.compose.runtime.staticCompositionLocalOf
+import video.typetype.tv.data.Video
+
+// Prepares the playback of a video the viewer is about to play, such as the one whose page is open with Play under
+// the focus, so the player starts without waiting for its session.
+fun interface PlaybackPreload {
+    fun preload(video: Video)
+}
+
+val LocalPlaybackPreload = staticCompositionLocalOf<PlaybackPreload?> { null }
diff --git a/app/src/main/java/video/typetype/tv/ui/components/ScreenFailure.kt b/core/ui/src/main/java/video/typetype/tv/ui/components/ScreenFailure.kt
similarity index 63%
rename from app/src/main/java/video/typetype/tv/ui/components/ScreenFailure.kt
rename to core/ui/src/main/java/video/typetype/tv/ui/components/ScreenFailure.kt
index 6ec9a1f..ba14af3 100644
--- a/app/src/main/java/video/typetype/tv/ui/components/ScreenFailure.kt
+++ b/core/ui/src/main/java/video/typetype/tv/ui/components/ScreenFailure.kt
@@ -8,17 +8,22 @@ import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.rounded.Replay
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.res.pluralStringResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
-import video.typetype.tv.R
+import kotlinx.coroutines.delay
+import video.typetype.tv.resources.R
 import video.typetype.tv.theme.Type
-import video.typetype.tv.ui.auth.MessageText
-import video.typetype.tv.ui.auth.UiMessage
+import video.typetype.tv.ui.util.UiMessage
 import video.typetype.tv.ui.util.requestFocusWhenReady
 
 @Composable
@@ -28,11 +33,25 @@ fun ScreenFailure(
     modifier: Modifier = Modifier,
 ) {
     val retry = remember { FocusRequester() }
+    val currentRetry by rememberUpdatedState(onRetry)
+    var countdown by remember(message) { mutableIntStateOf(AUTO_RETRY_SECONDS) }
     LaunchedEffect(Unit) { retry.requestFocusWhenReady() }
+    if (message?.transient == true) {
+        LaunchedEffect(message) {
+            while (countdown > 0) {
+                delay(1_000)
+                countdown--
+            }
+            currentRetry()
+        }
+    }
     Box(modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
         Column(verticalArrangement = Arrangement.spacedBy(14.dp), horizontalAlignment = Alignment.CenterHorizontally) {
             TextLabel(stringResource(R.string.load_error_title), Type.Headline)
             MessageText(message)
+            if (message?.transient == true) {
+                TextLabel(pluralStringResource(R.plurals.load_retry_countdown, countdown, countdown), Type.Meta)
+            }
             PillButton(
                 label = stringResource(R.string.state_retry),
                 icon = Icons.Rounded.Replay,
@@ -43,3 +62,5 @@ fun ScreenFailure(
         }
     }
 }
+
+private const val AUTO_RETRY_SECONDS = 5
diff --git a/core/ui/src/main/java/video/typetype/tv/ui/components/SearchInput.kt b/core/ui/src/main/java/video/typetype/tv/ui/components/SearchInput.kt
new file mode 100644
index 0000000..b89d23d
--- /dev/null
+++ b/core/ui/src/main/java/video/typetype/tv/ui/components/SearchInput.kt
@@ -0,0 +1,32 @@
+package video.typetype.tv.ui.components
+
+// The rules for typing a search, shared by every on-screen keyboard.
+object SearchInput {
+    const val KEYS = "abcdefghijklmnopqrstuvwxyz0123456789"
+    const val KEYS_PER_ROW = 9
+    const val MAX_LENGTH = 40
+
+    fun append(query: String, character: Char): String {
+        if (query.length >= MAX_LENGTH) return query
+        if (character == ' ' && (query.isEmpty() || query.endsWith(' '))) return query
+        return query + character
+    }
+
+    fun delete(query: String): String = query.dropLast(1)
+
+    // A spoken sentence goes through the same rules as typing, so voice and keyboard queries look alike.
+    fun fromSpeech(sentence: String): String = sentence.fold("") { query, character ->
+        typed(character.code)?.let { append(query, it) } ?: query
+    }
+
+    // A Bluetooth keyboard or a phone remote app sends real characters; letters, digits and spaces are typed.
+    fun typed(codePoint: Int): Char? {
+        if (codePoint <= 0 || Character.charCount(codePoint) != 1) return null
+        val character = codePoint.toChar()
+        return when {
+            character.isLetterOrDigit() -> character.lowercaseChar()
+            character == ' ' -> ' '
+            else -> null
+        }
+    }
+}
diff --git a/app/src/main/java/video/typetype/tv/ui/search/SearchKeyboard.kt b/core/ui/src/main/java/video/typetype/tv/ui/components/SearchKeyboard.kt
similarity index 86%
rename from app/src/main/java/video/typetype/tv/ui/search/SearchKeyboard.kt
rename to core/ui/src/main/java/video/typetype/tv/ui/components/SearchKeyboard.kt
index 863e7ac..4412755 100644
--- a/app/src/main/java/video/typetype/tv/ui/search/SearchKeyboard.kt
+++ b/core/ui/src/main/java/video/typetype/tv/ui/components/SearchKeyboard.kt
@@ -1,4 +1,4 @@
-package video.typetype.tv.ui.search
+package video.typetype.tv.ui.components
 
 import androidx.compose.animation.animateColorAsState
 import androidx.compose.animation.core.tween
@@ -15,7 +15,9 @@ import androidx.compose.foundation.text.BasicText
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.rounded.Backspace
 import androidx.compose.material.icons.rounded.Clear
+import androidx.compose.material.icons.rounded.Mic
 import androidx.compose.material.icons.rounded.SpaceBar
+import androidx.compose.material.icons.rounded.Stop
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
@@ -29,12 +31,10 @@ import androidx.compose.ui.semantics.contentDescription
 import androidx.compose.ui.semantics.role
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.unit.dp
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.theme.Palette
 import video.typetype.tv.theme.Shapes
 import video.typetype.tv.theme.Type
-import video.typetype.tv.ui.components.FocusSurface
-import video.typetype.tv.ui.components.Glyph
 
 @Composable
 fun SearchKeyboard(
@@ -44,6 +44,7 @@ fun SearchKeyboard(
     firstKey: FocusRequester,
     rightEdgeTarget: FocusRequester?,
     modifier: Modifier = Modifier,
+    voice: VoiceKey? = null,
 ) {
     Column(modifier = modifier, verticalArrangement = Arrangement.spacedBy(6.dp)) {
         SearchInput.KEYS.chunked(SearchInput.KEYS_PER_ROW).forEachIndexed { rowIndex, row ->
@@ -64,12 +65,22 @@ fun SearchKeyboard(
             ActionKey(Icons.Rounded.Backspace, stringResource(R.string.search_delete), onDelete)
             ActionKey(
                 Icons.Rounded.Clear, stringResource(R.string.search_clear), onClear,
-                modifier = Modifier.routeRightTo(rightEdgeTarget),
+                modifier = if (voice == null) Modifier.routeRightTo(rightEdgeTarget) else Modifier,
             )
+            if (voice != null) {
+                ActionKey(
+                    icon = if (voice.listening) Icons.Rounded.Stop else Icons.Rounded.Mic,
+                    description = stringResource(if (voice.listening) R.string.voice_stop else R.string.voice_search),
+                    onClick = voice.onClick,
+                    modifier = Modifier.routeRightTo(rightEdgeTarget),
+                )
+            }
         }
     }
 }
 
+class VoiceKey(val listening: Boolean, val onClick: () -> Unit)
+
 private fun Modifier.routeRightTo(target: FocusRequester?): Modifier =
     if (target == null) this else focusProperties { right = target }
 
diff --git a/core/ui/src/main/java/video/typetype/tv/ui/components/ServiceMark.kt b/core/ui/src/main/java/video/typetype/tv/ui/components/ServiceMark.kt
new file mode 100644
index 0000000..5408379
--- /dev/null
+++ b/core/ui/src/main/java/video/typetype/tv/ui/components/ServiceMark.kt
@@ -0,0 +1,59 @@
+package video.typetype.tv.ui.components
+
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.text.BasicText
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.ColorFilter
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.clearAndSetSemantics
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.unit.dp
+import video.typetype.tv.data.ContentSource
+import video.typetype.tv.theme.Palette
+import video.typetype.tv.theme.Type
+
+// The colours TypeType-Frontend gives the same simple-icons marks, so a service looks alike on the web and on TV.
+fun ContentSource.brandColor(): Color = when (this) {
+    ContentSource.YouTube -> Color(0xFFFF0000)
+    ContentSource.BiliBili -> Color(0xFF00A1D6)
+    ContentSource.NicoNico -> Color(0xFFAAAAAA)
+}
+
+@Composable
+fun ServiceMark(source: ContentSource, sizeDp: Int, modifier: Modifier = Modifier) {
+    Image(
+        painter = painterResource(source.iconRes),
+        contentDescription = null,
+        colorFilter = ColorFilter.tint(source.brandColor()),
+        modifier = modifier.size(sizeDp.dp),
+    )
+}
+
+// The service a video comes from: its mark and its name on a small glass label.
+@Composable
+fun ServiceBadge(source: ContentSource, modifier: Modifier = Modifier) {
+    val name = stringResource(source.labelRes)
+    Row(
+        modifier = modifier
+            .clip(RoundedCornerShape(4.dp))
+            .background(Palette.Glass)
+            .padding(horizontal = 6.dp, vertical = 2.dp)
+            .clearAndSetSemantics { contentDescription = name },
+        horizontalArrangement = Arrangement.spacedBy(5.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        ServiceMark(source, 14)
+        BasicText(name, style = Type.Label.copy(color = Palette.TextHigh))
+    }
+}
diff --git a/app/src/main/java/video/typetype/tv/ui/components/ShelfRow.kt b/core/ui/src/main/java/video/typetype/tv/ui/components/ShelfRow.kt
similarity index 98%
rename from app/src/main/java/video/typetype/tv/ui/components/ShelfRow.kt
rename to core/ui/src/main/java/video/typetype/tv/ui/components/ShelfRow.kt
index f5ebf06..6964514 100644
--- a/app/src/main/java/video/typetype/tv/ui/components/ShelfRow.kt
+++ b/core/ui/src/main/java/video/typetype/tv/ui/components/ShelfRow.kt
@@ -48,7 +48,7 @@ fun ShelfRow(
         }
     }
     val cardWidth = if (shelf.wide) Dimens.WideCardWidth else Dimens.CardWidth
-    Column(modifier = modifier) {
+    Column(modifier = modifier.cachedLayer()) {
         TextLabel(
             text = shelf.title.uppercase(),
             style = Type.Label,
diff --git a/app/src/main/java/video/typetype/tv/ui/components/Skeleton.kt b/core/ui/src/main/java/video/typetype/tv/ui/components/Skeleton.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/components/Skeleton.kt
rename to core/ui/src/main/java/video/typetype/tv/ui/components/Skeleton.kt
diff --git a/core/ui/src/main/java/video/typetype/tv/ui/components/StreamPrewarm.kt b/core/ui/src/main/java/video/typetype/tv/ui/components/StreamPrewarm.kt
new file mode 100644
index 0000000..6bcaf14
--- /dev/null
+++ b/core/ui/src/main/java/video/typetype/tv/ui/components/StreamPrewarm.kt
@@ -0,0 +1,41 @@
+package video.typetype.tv.ui.components
+
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.staticCompositionLocalOf
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import video.typetype.tv.data.Video
+import java.io.IOException
+
+// The server extracts a stream once and keeps it in its cache, so asking for the focused video ahead
+// of OK turns a cold detail or player open (up to about 17 s on a busy instance) into a cache hit.
+// Only a card that keeps the focus is warmed: scrolling past a row warms nothing.
+@Stable
+class StreamPrewarm(
+    private val warm: suspend (String) -> Unit,
+    private val scope: CoroutineScope,
+    private val dwellMillis: Long = DWELL_MILLIS,
+) {
+    private var pending: Job? = null
+
+    fun focus(video: Video) {
+        pending?.cancel()
+        if (video.isLive) return
+        pending = scope.launch {
+            delay(dwellMillis)
+            try {
+                warm(video.id)
+            } catch (_: IOException) {
+                // A failed warm costs nothing: the detail page loads and reports on its own.
+            }
+        }
+    }
+
+    private companion object {
+        const val DWELL_MILLIS = 700L
+    }
+}
+
+val LocalStreamPrewarm = staticCompositionLocalOf<StreamPrewarm?> { null }
diff --git a/app/src/main/java/video/typetype/tv/ui/components/TopNav.kt b/core/ui/src/main/java/video/typetype/tv/ui/components/TopNav.kt
similarity index 88%
rename from app/src/main/java/video/typetype/tv/ui/components/TopNav.kt
rename to core/ui/src/main/java/video/typetype/tv/ui/components/TopNav.kt
index 6db0f8c..dfd8376 100644
--- a/app/src/main/java/video/typetype/tv/ui/components/TopNav.kt
+++ b/core/ui/src/main/java/video/typetype/tv/ui/components/TopNav.kt
@@ -3,7 +3,6 @@ package video.typetype.tv.ui.components
 import android.content.Context
 import androidx.compose.animation.animateColorAsState
 import androidx.compose.animation.core.tween
-import androidx.compose.foundation.Image
 import androidx.compose.foundation.background
 import androidx.compose.foundation.focusGroup
 import androidx.compose.foundation.interaction.MutableInteractionSource
@@ -11,7 +10,6 @@ import androidx.compose.foundation.interaction.collectIsFocusedAsState
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
@@ -22,9 +20,7 @@ import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.foundation.text.BasicText
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.ExperimentalComposeUiApi
 import androidx.compose.ui.Modifier
@@ -39,7 +35,6 @@ import androidx.compose.ui.graphics.Brush
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.layout.ContentScale
 import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.Role
 import androidx.compose.ui.semantics.contentDescription
@@ -52,13 +47,16 @@ import coil3.decode.BitmapFactoryDecoder
 import coil3.gif.repeatCount
 import coil3.request.ImageRequest
 import coil3.request.crossfade
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
+import video.typetype.tv.ui.brand.BrandLogo
 import video.typetype.tv.data.AccountBadge
 import video.typetype.tv.navigation.TopTab
 import video.typetype.tv.theme.Dimens
 import video.typetype.tv.theme.Palette
 import video.typetype.tv.theme.Shapes
 import video.typetype.tv.theme.Type
+import video.typetype.tv.ui.util.LocalPerformance
+import video.typetype.tv.ui.util.LocalRemoteActivity
 
 @OptIn(ExperimentalComposeUiApi::class)
 @Composable
@@ -68,6 +66,8 @@ fun TopNav(
     account: AccountBadge,
     modifier: Modifier = Modifier,
     contentEntry: FocusRequester? = null,
+    navEntry: FocusRequester? = null,
+    onNavFocusChange: (Boolean) -> Unit = {},
 ) {
     Box(
         modifier = modifier
@@ -90,26 +90,15 @@ fun TopNav(
             .padding(start = Dimens.SafeStart, end = Dimens.SafeEnd, top = Dimens.SafeTop)
             .height(Dimens.TopNavHeight),
     ) {
-        Row(
-            modifier = Modifier.align(Alignment.CenterStart),
-            verticalAlignment = Alignment.CenterVertically,
-        ) {
-            Image(
-                painter = painterResource(R.drawable.ic_typetype_mark),
-                contentDescription = stringResource(R.string.logo_description),
-                modifier = Modifier.size(30.dp),
-            )
-            Spacer(Modifier.width(10.dp))
-            BasicText(stringResource(R.string.wordmark), style = Type.Wordmark)
-        }
-        val selectedRequester = remember { FocusRequester() }
-        var navFocused by remember { mutableStateOf(false) }
+        BrandLogo(Modifier.align(Alignment.CenterStart))
+        val ownEntry = remember { FocusRequester() }
+        val selectedRequester = navEntry ?: ownEntry
         Row(
             modifier = Modifier
                 .align(Alignment.Center)
                 .focusProperties { enter = { selectedRequester } }
                 .focusGroup()
-                .onFocusChanged { navFocused = it.hasFocus },
+                .onFocusChanged { onNavFocusChange(it.hasFocus) },
             horizontalArrangement = Arrangement.spacedBy(6.dp),
             verticalAlignment = Alignment.CenterVertically,
         ) {
@@ -123,7 +112,7 @@ fun TopNav(
                 )
             }
         }
-        Avatar(account, animated = navFocused, Modifier.align(Alignment.CenterEnd))
+        Avatar(account, animated = LocalPerformance.current.animatedAvatar && LocalRemoteActivity.current.idle, Modifier.align(Alignment.CenterEnd))
     }
 }
 
diff --git a/core/ui/src/main/java/video/typetype/tv/ui/components/TvOverlay.kt b/core/ui/src/main/java/video/typetype/tv/ui/components/TvOverlay.kt
new file mode 100644
index 0000000..88975a7
--- /dev/null
+++ b/core/ui/src/main/java/video/typetype/tv/ui/components/TvOverlay.kt
@@ -0,0 +1,34 @@
+package video.typetype.tv.ui.components
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxScope
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.SideEffect
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalView
+import androidx.compose.ui.window.Dialog
+import androidx.compose.ui.window.DialogProperties
+import androidx.compose.ui.window.DialogWindowProvider
+import video.typetype.tv.theme.Palette
+
+// A list, a picker or a question opened from a screen, shown in its own window above everything, the top bar
+// included: drawn inside the screen, the tabs covered its top. Back closes it.
+@Composable
+fun TvOverlay(onClose: () -> Unit, content: @Composable BoxScope.() -> Unit) {
+    Dialog(
+        onDismissRequest = onClose,
+        properties = DialogProperties(
+            usePlatformDefaultWidth = false,
+            decorFitsSystemWindows = false,
+            dismissOnClickOutside = false,
+        ),
+    ) {
+        // The scrim below is the only dimming; the window's own would darken the screen twice.
+        val window = (LocalView.current.parent as? DialogWindowProvider)?.window
+        SideEffect { window?.setDimAmount(0f) }
+        Box(Modifier.fillMaxSize().background(Palette.Scrim), contentAlignment = Alignment.Center, content = content)
+    }
+}
diff --git a/app/src/main/java/video/typetype/tv/ui/components/VideoCard.kt b/core/ui/src/main/java/video/typetype/tv/ui/components/VideoCard.kt
similarity index 82%
rename from app/src/main/java/video/typetype/tv/ui/components/VideoCard.kt
rename to core/ui/src/main/java/video/typetype/tv/ui/components/VideoCard.kt
index a03ed0a..f6de592 100644
--- a/app/src/main/java/video/typetype/tv/ui/components/VideoCard.kt
+++ b/core/ui/src/main/java/video/typetype/tv/ui/components/VideoCard.kt
@@ -25,11 +25,13 @@ import androidx.compose.ui.semantics.contentDescription
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.unit.dp
 import coil3.compose.AsyncImage
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
+import video.typetype.tv.data.ContentSource
 import video.typetype.tv.data.Video
 import video.typetype.tv.theme.Palette
 import video.typetype.tv.theme.Type
 import video.typetype.tv.ui.util.formatDuration
+import video.typetype.tv.ui.util.metaLine
 
 @Composable
 fun VideoCard(
@@ -46,22 +48,29 @@ fun VideoCard(
         label = "card-title",
     )
     val description = stringResource(R.string.card_description, video.title, video.channel.name)
+    val prewarm = LocalStreamPrewarm.current
+    val menu = rememberVideoMenuTarget(video)
     Column(modifier = modifier) {
         FocusSurface(
             onClick = onClick,
             modifier = Modifier
                 .fillMaxWidth()
                 .aspectRatio(16f / 9f)
+                .then(menu.modifier())
                 .semantics { contentDescription = description },
             interactionSource = source,
-            onFocused = onFocused,
+            onFocused = {
+                prewarm?.focus(video)
+                onFocused?.invoke()
+            },
+            onLongClick = menu.open,
         ) {
             VideoThumbnail(video)
         }
         Spacer(Modifier.height(10.dp))
         TextLabel(video.title, Type.Title.copy(color = titleColor), maxLines = 1)
         Spacer(Modifier.height(2.dp))
-        TextLabel("${video.channel.name}  ·  ${video.views}", Type.Meta, maxLines = 1)
+        TextLabel(metaLine(video.channel.name, video.views), Type.Meta, maxLines = 1)
     }
 }
 
@@ -84,7 +93,7 @@ fun VideoThumbnail(
                 stringResource(R.string.badge_live),
                 Modifier.align(Alignment.TopStart).padding(8.dp),
             )
-        } else {
+        } else if (video.durationSeconds > 0) {
             DurationBadge(
                 formatDuration(video.durationSeconds),
                 Modifier.align(Alignment.BottomEnd).padding(8.dp),
@@ -96,8 +105,9 @@ fun VideoThumbnail(
         if (video.isShort) {
             LiveBadge(stringResource(R.string.badge_short), Modifier.align(Alignment.TopStart).padding(8.dp))
         }
-        video.source?.badge?.let { label ->
-            QualityBadge(label, Modifier.align(Alignment.TopEnd).padding(8.dp))
+        // Most videos come from YouTube: only the other services are named on the card.
+        video.source?.takeIf { it != ContentSource.YouTube }?.let { source ->
+            ServiceBadge(source, Modifier.align(Alignment.TopEnd).padding(8.dp))
         }
     }
 }
diff --git a/core/ui/src/main/java/video/typetype/tv/ui/components/VideoMenu.kt b/core/ui/src/main/java/video/typetype/tv/ui/components/VideoMenu.kt
new file mode 100644
index 0000000..71540a4
--- /dev/null
+++ b/core/ui/src/main/java/video/typetype/tv/ui/components/VideoMenu.kt
@@ -0,0 +1,84 @@
+package video.typetype.tv.ui.components
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.compositionLocalOf
+import androidx.compose.runtime.staticCompositionLocalOf
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.input.key.KeyEventType
+import androidx.compose.ui.input.key.onPreviewKeyEvent
+import androidx.compose.ui.input.key.type
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.CustomAccessibilityAction
+import androidx.compose.ui.semantics.customActions
+import androidx.compose.ui.semantics.semantics
+import video.typetype.tv.data.Video
+import video.typetype.tv.resources.R
+import android.view.KeyEvent as AndroidKeyEvent
+
+// What a video card can do without leaving its row: open the video's menu (a long press on OK, or the Menu key)
+// and play it at once (the Play/Pause key). The app provides it, so every screen with cards behaves the same;
+// onClosed gives the focus back to the card that opened the menu.
+interface VideoMenu {
+    fun open(video: Video, playlist: PlaylistContext?, onClosed: () -> Unit)
+
+    fun play(video: Video)
+}
+
+val LocalVideoMenu = staticCompositionLocalOf<VideoMenu?> { null }
+
+// One of the viewer's own playlists, open on screen: its cards offer to remove the video from it.
+class PlaylistContext(val id: String, val name: String, val onRemoved: (Video) -> Unit)
+
+val LocalPlaylistContext = compositionLocalOf<PlaylistContext?> { null }
+
+// What a video card needs: the long press, the remote's Menu and Play/Pause keys, the focus to return to, and the
+// same menu entry for TalkBack.
+class VideoMenuTarget internal constructor(
+    private val focus: FocusRequester,
+    val open: (() -> Unit)?,
+    private val play: (() -> Unit)?,
+    private val label: String,
+) {
+    fun modifier(): Modifier {
+        val open = open ?: return Modifier.focusRequester(focus)
+        return Modifier
+            .focusRequester(focus)
+            .onPreviewKeyEvent { event ->
+                val action = when (event.nativeKeyEvent.keyCode) {
+                    AndroidKeyEvent.KEYCODE_MENU -> open
+                    AndroidKeyEvent.KEYCODE_MEDIA_PLAY_PAUSE, AndroidKeyEvent.KEYCODE_MEDIA_PLAY -> play
+                    else -> null
+                } ?: return@onPreviewKeyEvent false
+                // The key down acts once; its repeats and its release are kept from the rest of the screen.
+                if (event.type == KeyEventType.KeyDown && event.nativeKeyEvent.repeatCount == 0) action()
+                true
+            }
+            .semantics {
+                customActions = listOf(
+                    CustomAccessibilityAction(label) {
+                        open()
+                        true
+                    },
+                )
+            }
+    }
+}
+
+@Composable
+fun rememberVideoMenuTarget(video: Video): VideoMenuTarget {
+    val menu = LocalVideoMenu.current
+    val playlist = LocalPlaylistContext.current
+    val focus = remember { FocusRequester() }
+    val label = stringResource(R.string.video_menu_open)
+    return remember(menu, playlist, video, label) {
+        VideoMenuTarget(
+            focus = focus,
+            open = menu?.let { { it.open(video, playlist) { focus.requestFocus() } } },
+            play = menu?.let { { it.play(video) } },
+            label = label,
+        )
+    }
+}
diff --git a/core/ui/src/main/java/video/typetype/tv/ui/components/VideoPreviews.kt b/core/ui/src/main/java/video/typetype/tv/ui/components/VideoPreviews.kt
new file mode 100644
index 0000000..21946dd
--- /dev/null
+++ b/core/ui/src/main/java/video/typetype/tv/ui/components/VideoPreviews.kt
@@ -0,0 +1,15 @@
+package video.typetype.tv.ui.components
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.staticCompositionLocalOf
+import androidx.compose.ui.Modifier
+import video.typetype.tv.data.Video
+
+// Implemented by the player module and provided by the app, so browse screens can show a muted preview
+// without depending on playback.
+fun interface VideoPreviews {
+    @Composable
+    fun Show(video: Video?, onPlaying: (Boolean) -> Unit, modifier: Modifier)
+}
+
+val LocalVideoPreviews = staticCompositionLocalOf<VideoPreviews?> { null }
diff --git a/app/src/main/java/video/typetype/tv/ui/util/FocusUtil.kt b/core/ui/src/main/java/video/typetype/tv/ui/util/FocusUtil.kt
similarity index 74%
rename from app/src/main/java/video/typetype/tv/ui/util/FocusUtil.kt
rename to core/ui/src/main/java/video/typetype/tv/ui/util/FocusUtil.kt
index b019598..e551073 100644
--- a/app/src/main/java/video/typetype/tv/ui/util/FocusUtil.kt
+++ b/core/ui/src/main/java/video/typetype/tv/ui/util/FocusUtil.kt
@@ -30,3 +30,8 @@ fun Modifier.trapFocus(directions: List<FocusDirection>): Modifier =
             if (direction in directions) FocusRequester.Cancel else FocusRequester.Default
         }
     }.focusGroup()
+
+// A list of tabs whose focused tab opens its content: coming back into the list always lands on the open tab, never
+// on the nearest one, which would switch the content behind the viewer's back.
+@OptIn(ExperimentalComposeUiApi::class)
+fun Modifier.focusEntersAt(openTab: FocusRequester): Modifier = focusProperties { enter = { openTab } }.focusGroup()
diff --git a/app/src/main/java/video/typetype/tv/ui/util/Format.kt b/core/ui/src/main/java/video/typetype/tv/ui/util/Format.kt
similarity index 77%
rename from app/src/main/java/video/typetype/tv/ui/util/Format.kt
rename to core/ui/src/main/java/video/typetype/tv/ui/util/Format.kt
index 56b6dce..cd4dd4b 100644
--- a/app/src/main/java/video/typetype/tv/ui/util/Format.kt
+++ b/core/ui/src/main/java/video/typetype/tv/ui/util/Format.kt
@@ -19,3 +19,7 @@ fun formatTimeLeft(durationSeconds: Int, watchedFraction: Float): String {
 }
 
 fun formatMillis(millis: Long): String = formatDuration((millis / 1000L).toInt())
+
+fun metaLine(vararg parts: String?): String = parts.filterNot { it.isNullOrBlank() }.joinToString("  ·  ")
+
+fun knownDuration(totalSeconds: Int): String? = totalSeconds.takeIf { it > 0 }?.let(::formatDuration)
diff --git a/core/ui/src/main/java/video/typetype/tv/ui/util/IntroPlaying.kt b/core/ui/src/main/java/video/typetype/tv/ui/util/IntroPlaying.kt
new file mode 100644
index 0000000..f0690df
--- /dev/null
+++ b/core/ui/src/main/java/video/typetype/tv/ui/util/IntroPlaying.kt
@@ -0,0 +1,7 @@
+package video.typetype.tv.ui.util
+
+import androidx.compose.runtime.compositionLocalOf
+
+// True while the startup intro covers the screen. Screens that put the focus on a text field wait for it to end:
+// focusing one opens the keyboard, which would cover the intro.
+val LocalIntroPlaying = compositionLocalOf { false }
diff --git a/core/ui/src/main/java/video/typetype/tv/ui/util/KeylineScroll.kt b/core/ui/src/main/java/video/typetype/tv/ui/util/KeylineScroll.kt
new file mode 100644
index 0000000..dabcc2c
--- /dev/null
+++ b/core/ui/src/main/java/video/typetype/tv/ui/util/KeylineScroll.kt
@@ -0,0 +1,24 @@
+package video.typetype.tv.ui.util
+
+import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.foundation.gestures.BringIntoViewSpec
+import androidx.compose.foundation.gestures.LocalBringIntoViewSpec
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.remember
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.unit.Dp
+
+// Keeps the focused item's top on one line of the list: every press moves the list by exactly one item, so the text
+// being read always starts at the same place instead of the list only moving once the focus reaches its edge.
+class KeylineScroll(private val keylinePx: Float) : BringIntoViewSpec {
+    override fun calculateScrollDistance(offset: Float, size: Float, containerSize: Float): Float = offset - keylinePx
+}
+
+@OptIn(ExperimentalFoundationApi::class)
+@Composable
+fun WithKeylineScroll(keyline: Dp, content: @Composable () -> Unit) {
+    val px = with(LocalDensity.current) { keyline.toPx() }
+    val spec = remember(px) { KeylineScroll(px) }
+    CompositionLocalProvider(LocalBringIntoViewSpec provides spec, content = content)
+}
diff --git a/app/src/main/java/video/typetype/tv/ui/util/LoadFailures.kt b/core/ui/src/main/java/video/typetype/tv/ui/util/LoadFailures.kt
similarity index 65%
rename from app/src/main/java/video/typetype/tv/ui/util/LoadFailures.kt
rename to core/ui/src/main/java/video/typetype/tv/ui/util/LoadFailures.kt
index cd1e4a0..c51900c 100644
--- a/app/src/main/java/video/typetype/tv/ui/util/LoadFailures.kt
+++ b/core/ui/src/main/java/video/typetype/tv/ui/util/LoadFailures.kt
@@ -1,23 +1,26 @@
 package video.typetype.tv.ui.util
 
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.net.ApiException
 import video.typetype.tv.data.net.FailureCategory
-import video.typetype.tv.ui.auth.UiMessage
 import java.io.IOException
 
 private const val CONTENT_UNAVAILABLE = "content_unavailable"
 
+private val GATEWAY_FAILURES = setOf(502, 503, 504) + (520..530)
+
 fun describeLoadFailure(failure: IOException): UiMessage {
-    val details = (failure as? ApiException)?.failure ?: return UiMessage(R.string.login_error_network)
+    val details = (failure as? ApiException)?.failure ?: return UiMessage(R.string.login_error_network, transient = true)
+    val unreachable = details.category == FailureCategory.Network ||
+        details.category == FailureCategory.Server && details.status in GATEWAY_FAILURES
     val text = when {
         details.code == CONTENT_UNAVAILABLE -> R.string.load_error_unavailable
         details.category == FailureCategory.NotFound || details.category == FailureCategory.Gone -> R.string.load_error_unavailable
-        details.category == FailureCategory.Network || details.category == FailureCategory.Tls -> R.string.login_error_network
+        unreachable || details.category == FailureCategory.Tls -> R.string.login_error_network
         details.category == FailureCategory.RateLimited -> R.string.login_error_rate_limited
         else -> R.string.load_error_generic
     }
-    return UiMessage(text, details.requestId)
+    return UiMessage(text, details.requestId, transient = unreachable)
 }
 
 suspend fun <T> tryLoad(onFailure: (UiMessage) -> Unit, block: suspend () -> T): T? =
diff --git a/core/ui/src/main/java/video/typetype/tv/ui/util/Paging.kt b/core/ui/src/main/java/video/typetype/tv/ui/util/Paging.kt
new file mode 100644
index 0000000..f24ad4e
--- /dev/null
+++ b/core/ui/src/main/java/video/typetype/tv/ui/util/Paging.kt
@@ -0,0 +1,21 @@
+package video.typetype.tv.ui.util
+
+import androidx.compose.foundation.lazy.LazyListState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.derivedStateOf
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+
+private const val NEXT_PAGE_DISTANCE = 3
+
+@Composable
+fun LoadMoreNearEnd(state: LazyListState, size: Int, onNearEnd: () -> Unit) {
+    val nearEnd by remember(state, size) {
+        derivedStateOf {
+            val last = state.layoutInfo.visibleItemsInfo.lastOrNull()?.index ?: 0
+            last >= size - NEXT_PAGE_DISTANCE
+        }
+    }
+    LaunchedEffect(nearEnd, size) { if (nearEnd) onNearEnd() }
+}
diff --git a/core/ui/src/main/java/video/typetype/tv/ui/util/PerformanceLocal.kt b/core/ui/src/main/java/video/typetype/tv/ui/util/PerformanceLocal.kt
new file mode 100644
index 0000000..1282332
--- /dev/null
+++ b/core/ui/src/main/java/video/typetype/tv/ui/util/PerformanceLocal.kt
@@ -0,0 +1,6 @@
+package video.typetype.tv.ui.util
+
+import androidx.compose.runtime.compositionLocalOf
+import video.typetype.tv.data.device.Performance
+
+val LocalPerformance = compositionLocalOf { Performance() }
diff --git a/app/src/main/java/video/typetype/tv/ui/util/ReferenceCanvas.kt b/core/ui/src/main/java/video/typetype/tv/ui/util/ReferenceCanvas.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/util/ReferenceCanvas.kt
rename to core/ui/src/main/java/video/typetype/tv/ui/util/ReferenceCanvas.kt
diff --git a/core/ui/src/main/java/video/typetype/tv/ui/util/RemoteActivity.kt b/core/ui/src/main/java/video/typetype/tv/ui/util/RemoteActivity.kt
new file mode 100644
index 0000000..9ff5c6f
--- /dev/null
+++ b/core/ui/src/main/java/video/typetype/tv/ui/util/RemoteActivity.kt
@@ -0,0 +1,47 @@
+package video.typetype.tv.ui.util
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableLongStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.staticCompositionLocalOf
+import kotlinx.coroutines.delay
+
+// Whether the remote is in use. Decoration that redraws the screen on its own, such as an animated picture, waits
+// while the viewer moves around: on a box that redraws the whole window for every frame it would otherwise take the
+// time the focus animations need.
+@Stable
+class RemoteActivity {
+    var idle by mutableStateOf(true)
+        private set
+
+    var lastKeyAt by mutableLongStateOf(0L)
+        private set
+
+    fun keyPressed(now: Long) {
+        lastKeyAt = now
+        idle = false
+    }
+
+    fun settle() {
+        idle = true
+    }
+
+    companion object {
+        const val SETTLE_MILLIS = 2_000L
+    }
+}
+
+val LocalRemoteActivity = staticCompositionLocalOf { RemoteActivity() }
+
+// Only this reads the time of the last key, so a key press recomposes nothing else.
+@Composable
+fun SettleRemote(remote: RemoteActivity) {
+    LaunchedEffect(remote.lastKeyAt) {
+        delay(RemoteActivity.SETTLE_MILLIS)
+        remote.settle()
+    }
+}
diff --git a/core/ui/src/main/java/video/typetype/tv/ui/util/UiMessage.kt b/core/ui/src/main/java/video/typetype/tv/ui/util/UiMessage.kt
new file mode 100644
index 0000000..32fd82a
--- /dev/null
+++ b/core/ui/src/main/java/video/typetype/tv/ui/util/UiMessage.kt
@@ -0,0 +1,5 @@
+package video.typetype.tv.ui.util
+
+import androidx.annotation.StringRes
+
+data class UiMessage(@StringRes val textRes: Int, val requestId: String? = null, val transient: Boolean = false)
diff --git a/app/src/test/java/video/typetype/tv/navigation/MockNavigatorTest.kt b/core/ui/src/test/java/video/typetype/tv/navigation/MockNavigatorTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/navigation/MockNavigatorTest.kt
rename to core/ui/src/test/java/video/typetype/tv/navigation/MockNavigatorTest.kt
diff --git a/app/src/test/java/video/typetype/tv/ui/FormatTest.kt b/core/ui/src/test/java/video/typetype/tv/ui/FormatTest.kt
similarity index 69%
rename from app/src/test/java/video/typetype/tv/ui/FormatTest.kt
rename to core/ui/src/test/java/video/typetype/tv/ui/FormatTest.kt
index cc9cf7f..eeb59cc 100644
--- a/app/src/test/java/video/typetype/tv/ui/FormatTest.kt
+++ b/core/ui/src/test/java/video/typetype/tv/ui/FormatTest.kt
@@ -5,6 +5,8 @@ import org.junit.Test
 import video.typetype.tv.ui.util.formatDuration
 import video.typetype.tv.ui.util.formatMillis
 import video.typetype.tv.ui.util.formatTimeLeft
+import video.typetype.tv.ui.util.knownDuration
+import video.typetype.tv.ui.util.metaLine
 
 class FormatTest {
     @Test
@@ -37,4 +39,17 @@ class FormatTest {
         assertEquals("1 min", formatTimeLeft(60, 0.99f))
         assertEquals("1 h 30 min", formatTimeLeft(10800, 0.5f))
     }
+
+    @Test
+    fun `meta lines skip missing parts instead of leaving a separator`() {
+        assertEquals("Chan  ·  12K views", metaLine("Chan", "12K views"))
+        assertEquals("Chan", metaLine("Chan", ""))
+        assertEquals("1 year ago", metaLine(null, " ", "1 year ago"))
+    }
+
+    @Test
+    fun `an unknown duration has no label`() {
+        assertEquals(null, knownDuration(0))
+        assertEquals("4:33", knownDuration(273))
+    }
 }
diff --git a/core/ui/src/test/java/video/typetype/tv/ui/LoadFailuresTest.kt b/core/ui/src/test/java/video/typetype/tv/ui/LoadFailuresTest.kt
new file mode 100644
index 0000000..90801ed
--- /dev/null
+++ b/core/ui/src/test/java/video/typetype/tv/ui/LoadFailuresTest.kt
@@ -0,0 +1,37 @@
+package video.typetype.tv.ui
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import video.typetype.tv.resources.R
+import video.typetype.tv.data.net.ApiException
+import video.typetype.tv.data.net.ApiFailure
+import video.typetype.tv.data.net.FailureCategory
+import video.typetype.tv.ui.util.describeLoadFailure
+import java.io.IOException
+
+class LoadFailuresTest {
+    private fun failure(category: FailureCategory, status: Int? = null) =
+        ApiException(ApiFailure(category, status, null, "failed", "req"))
+
+    @Test
+    fun aDroppedConnectionIsRetriedAutomatically() {
+        assertTrue(describeLoadFailure(IOException("reset")).transient)
+        assertTrue(describeLoadFailure(failure(FailureCategory.Network)).transient)
+    }
+
+    @Test
+    fun aGatewayThatCannotReachTheServerIsRetriedAutomatically() {
+        val message = describeLoadFailure(failure(FailureCategory.Server, 522))
+        assertTrue(message.transient)
+        assertEquals(R.string.login_error_network, message.textRes)
+    }
+
+    @Test
+    fun answersThatWaitingCannotFixAreNotRetried() {
+        assertFalse(describeLoadFailure(failure(FailureCategory.Server, 500)).transient)
+        assertFalse(describeLoadFailure(failure(FailureCategory.Tls)).transient)
+        assertFalse(describeLoadFailure(failure(FailureCategory.NotFound, 404)).transient)
+    }
+}
diff --git a/app/src/test/java/video/typetype/tv/ui/ScreenScaleTest.kt b/core/ui/src/test/java/video/typetype/tv/ui/ScreenScaleTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/ui/ScreenScaleTest.kt
rename to core/ui/src/test/java/video/typetype/tv/ui/ScreenScaleTest.kt
diff --git a/app/src/test/java/video/typetype/tv/ui/SearchInputTest.kt b/core/ui/src/test/java/video/typetype/tv/ui/SearchInputTest.kt
similarity index 72%
rename from app/src/test/java/video/typetype/tv/ui/SearchInputTest.kt
rename to core/ui/src/test/java/video/typetype/tv/ui/SearchInputTest.kt
index 79b5a6c..58511fa 100644
--- a/app/src/test/java/video/typetype/tv/ui/SearchInputTest.kt
+++ b/core/ui/src/test/java/video/typetype/tv/ui/SearchInputTest.kt
@@ -3,7 +3,7 @@ package video.typetype.tv.ui
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertTrue
 import org.junit.Test
-import video.typetype.tv.ui.search.SearchInput
+import video.typetype.tv.ui.components.SearchInput
 
 class SearchInputTest {
     @Test
@@ -40,4 +40,15 @@ class SearchInputTest {
         assertTrue(('0'..'9').all { it in SearchInput.KEYS })
         assertEquals(0, SearchInput.KEYS.length % SearchInput.KEYS_PER_ROW)
     }
+
+    @Test
+    fun typedKeysKeepLettersDigitsAndSpaces() {
+        assertEquals('a', SearchInput.typed('A'.code))
+        assertEquals('7', SearchInput.typed('7'.code))
+        assertEquals(' ', SearchInput.typed(' '.code))
+        assertEquals('é', SearchInput.typed('É'.code))
+        assertEquals(null, SearchInput.typed(0))
+        assertEquals(null, SearchInput.typed('\n'.code))
+        assertEquals(null, SearchInput.typed('#'.code))
+    }
 }
diff --git a/core/ui/src/test/java/video/typetype/tv/ui/components/StreamPrewarmTest.kt b/core/ui/src/test/java/video/typetype/tv/ui/components/StreamPrewarmTest.kt
new file mode 100644
index 0000000..a254df8
--- /dev/null
+++ b/core/ui/src/test/java/video/typetype/tv/ui/components/StreamPrewarmTest.kt
@@ -0,0 +1,49 @@
+package video.typetype.tv.ui.components
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import video.typetype.tv.data.Channel
+import video.typetype.tv.data.Video
+import java.util.Collections
+
+class StreamPrewarmTest {
+    private val warmed = Collections.synchronizedList(mutableListOf<String>())
+
+    private fun CoroutineScope.prewarm() = StreamPrewarm({ warmed += it }, this, dwellMillis = DWELL)
+
+    private fun video(id: String, live: Boolean = false) =
+        Video(id, id, Channel("c", "C", "", ""), 60, "", "", "", "", isLive = live)
+
+    @Test
+    fun aCardThatKeepsTheFocusIsWarmed() = runBlocking {
+        prewarm().focus(video("a"))
+        delay(DWELL * 3)
+        assertEquals(listOf("a"), warmed.toList())
+    }
+
+    @Test
+    fun scrollingPastCardsWarmsOnlyWhereTheFocusStops() = runBlocking {
+        val prewarm = prewarm()
+        prewarm.focus(video("a"))
+        delay(DWELL / 4)
+        prewarm.focus(video("b"))
+        delay(DWELL / 4)
+        prewarm.focus(video("c"))
+        delay(DWELL * 3)
+        assertEquals(listOf("c"), warmed.toList())
+    }
+
+    @Test
+    fun liveVideosAreNeverWarmed() = runBlocking {
+        prewarm().focus(video("live", live = true))
+        delay(DWELL * 3)
+        assertEquals(emptyList<String>(), warmed.toList())
+    }
+
+    private companion object {
+        const val DWELL = 80L
+    }
+}
diff --git a/feature/auth/build.gradle.kts b/feature/auth/build.gradle.kts
new file mode 100644
index 0000000..4523235
--- /dev/null
+++ b/feature/auth/build.gradle.kts
@@ -0,0 +1,14 @@
+plugins {
+    alias(libs.plugins.typetype.android.compose)
+}
+
+android {
+    namespace = "video.typetype.tv.feature.auth"
+}
+
+dependencies {
+    implementation(project(":core:ui"))
+
+    testImplementation(project(":core:testing"))
+    testImplementation(libs.junit)
+}
diff --git a/app/src/main/java/video/typetype/tv/ui/auth/AuthMessages.kt b/feature/auth/src/main/java/video/typetype/tv/ui/auth/AuthMessages.kt
similarity index 89%
rename from app/src/main/java/video/typetype/tv/ui/auth/AuthMessages.kt
rename to feature/auth/src/main/java/video/typetype/tv/ui/auth/AuthMessages.kt
index 89219e7..f150ffc 100644
--- a/app/src/main/java/video/typetype/tv/ui/auth/AuthMessages.kt
+++ b/feature/auth/src/main/java/video/typetype/tv/ui/auth/AuthMessages.kt
@@ -1,12 +1,10 @@
 package video.typetype.tv.ui.auth
 
-import androidx.annotation.StringRes
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.net.ApiException
 import video.typetype.tv.data.net.FailureCategory
 import video.typetype.tv.data.session.DiscoveryResult
-
-data class UiMessage(@StringRes val textRes: Int, val requestId: String? = null)
+import video.typetype.tv.ui.util.UiMessage
 
 fun describeAuthFailure(failure: ApiException): UiMessage {
     val details = failure.failure
diff --git a/app/src/main/java/video/typetype/tv/ui/auth/AuthScaffold.kt b/feature/auth/src/main/java/video/typetype/tv/ui/auth/AuthScaffold.kt
similarity index 61%
rename from app/src/main/java/video/typetype/tv/ui/auth/AuthScaffold.kt
rename to feature/auth/src/main/java/video/typetype/tv/ui/auth/AuthScaffold.kt
index f4690d6..32fea51 100644
--- a/app/src/main/java/video/typetype/tv/ui/auth/AuthScaffold.kt
+++ b/feature/auth/src/main/java/video/typetype/tv/ui/auth/AuthScaffold.kt
@@ -1,26 +1,20 @@
 package video.typetype.tv.ui.auth
 
-import androidx.compose.foundation.Image
 import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.text.BasicText
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
-import androidx.compose.ui.res.painterResource
-import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
-import video.typetype.tv.R
+import video.typetype.tv.ui.brand.BrandLogo
 import video.typetype.tv.theme.Palette
 import video.typetype.tv.theme.Shapes
 import video.typetype.tv.theme.Type
@@ -40,15 +34,7 @@ fun AuthScaffold(
             modifier = Modifier.align(Alignment.Center).width(520.dp),
             horizontalAlignment = Alignment.Start,
         ) {
-            Row(verticalAlignment = Alignment.CenterVertically) {
-                Image(
-                    painter = painterResource(R.drawable.ic_typetype_mark),
-                    contentDescription = stringResource(R.string.logo_description),
-                    modifier = Modifier.size(30.dp),
-                )
-                Spacer(Modifier.width(10.dp))
-                BasicText(stringResource(R.string.wordmark), style = Type.Wordmark)
-            }
+            BrandLogo()
             Spacer(Modifier.height(24.dp))
             Column(
                 modifier = Modifier
@@ -65,12 +51,3 @@ fun AuthScaffold(
         }
     }
 }
-
-@Composable
-fun MessageText(message: UiMessage?, modifier: Modifier = Modifier) {
-    if (message == null) return
-    Column(modifier) {
-        TextLabel(stringResource(message.textRes), Type.Body.copy(color = Palette.AccentSoft), maxLines = 3)
-        message.requestId?.let { TextLabel(stringResource(R.string.request_id, it), Type.Meta, maxLines = 1) }
-    }
-}
diff --git a/app/src/main/java/video/typetype/tv/ui/auth/CertificatePrompt.kt b/feature/auth/src/main/java/video/typetype/tv/ui/auth/CertificatePrompt.kt
similarity index 98%
rename from app/src/main/java/video/typetype/tv/ui/auth/CertificatePrompt.kt
rename to feature/auth/src/main/java/video/typetype/tv/ui/auth/CertificatePrompt.kt
index 8dc1a0b..ebd82cf 100644
--- a/app/src/main/java/video/typetype/tv/ui/auth/CertificatePrompt.kt
+++ b/feature/auth/src/main/java/video/typetype/tv/ui/auth/CertificatePrompt.kt
@@ -18,7 +18,7 @@ import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.net.tls.CertificateInfo
 import video.typetype.tv.theme.Palette
 import video.typetype.tv.theme.Type
diff --git a/app/src/main/java/video/typetype/tv/ui/auth/LoginScreen.kt b/feature/auth/src/main/java/video/typetype/tv/ui/auth/LoginScreen.kt
similarity index 92%
rename from app/src/main/java/video/typetype/tv/ui/auth/LoginScreen.kt
rename to feature/auth/src/main/java/video/typetype/tv/ui/auth/LoginScreen.kt
index 7e05660..000e689 100644
--- a/app/src/main/java/video/typetype/tv/ui/auth/LoginScreen.kt
+++ b/feature/auth/src/main/java/video/typetype/tv/ui/auth/LoginScreen.kt
@@ -1,5 +1,7 @@
 package video.typetype.tv.ui.auth
 
+import video.typetype.tv.ui.components.MessageText
+import video.typetype.tv.ui.util.UiMessage
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
@@ -28,12 +30,13 @@ import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.text.input.KeyboardType
 import androidx.compose.ui.unit.dp
 import kotlinx.coroutines.launch
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.net.ApiException
 import video.typetype.tv.data.session.Backend
 import video.typetype.tv.data.session.SessionManager
 import video.typetype.tv.data.session.SignOutReason
 import video.typetype.tv.ui.components.PillButton
+import video.typetype.tv.ui.util.LocalIntroPlaying
 import video.typetype.tv.ui.util.requestFocusWhenReady
 
 @Composable
@@ -41,6 +44,7 @@ fun LoginScreen(
     backend: Backend,
     session: SessionManager,
     notice: SignOutReason?,
+    onChangeInstance: () -> Unit,
     modifier: Modifier = Modifier,
 ) {
     var email by rememberSaveable { mutableStateOf("") }
@@ -49,13 +53,14 @@ fun LoginScreen(
     var registering by rememberSaveable { mutableStateOf(false) }
     var busy by remember { mutableStateOf(false) }
     var message by remember {
-        mutableStateOf(notice?.let { UiMessage(if (it == SignOutReason.Expired) R.string.login_notice_expired else R.string.login_notice_unreachable) })
+        mutableStateOf(notice?.let { UiMessage(R.string.login_notice_expired) })
     }
     val scope = rememberCoroutineScope()
     val focus = LocalFocusManager.current
     val first = remember { FocusRequester() }
     val submitButton = remember { FocusRequester() }
-    LaunchedEffect(registering) { first.requestFocusWhenReady() }
+    val introPlaying = LocalIntroPlaying.current
+    LaunchedEffect(registering, introPlaying) { if (!introPlaying) first.requestFocusWhenReady() }
 
     fun attempt(block: suspend () -> Unit) {
         if (busy) return
@@ -147,7 +152,7 @@ fun LoginScreen(
                 PillButton(
                     label = stringResource(R.string.login_change_instance),
                     icon = Icons.Rounded.SwapHoriz,
-                    onClick = { scope.launch { session.changeInstance() } },
+                    onClick = onChangeInstance,
                 )
             }
             MessageText(message)
diff --git a/feature/auth/src/main/java/video/typetype/tv/ui/auth/ReconnectScreen.kt b/feature/auth/src/main/java/video/typetype/tv/ui/auth/ReconnectScreen.kt
new file mode 100644
index 0000000..115f282
--- /dev/null
+++ b/feature/auth/src/main/java/video/typetype/tv/ui/auth/ReconnectScreen.kt
@@ -0,0 +1,69 @@
+package video.typetype.tv.ui.auth
+
+import video.typetype.tv.ui.components.MessageText
+import video.typetype.tv.ui.util.UiMessage
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.height
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.rounded.Replay
+import androidx.compose.material.icons.rounded.SwapHoriz
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import kotlinx.coroutines.launch
+import video.typetype.tv.resources.R
+import video.typetype.tv.data.session.SessionManager
+import video.typetype.tv.theme.Type
+import video.typetype.tv.ui.components.PillButton
+import video.typetype.tv.ui.components.TextLabel
+import video.typetype.tv.ui.util.requestFocusWhenReady
+
+@Composable
+fun ReconnectScreen(
+    session: SessionManager,
+    host: String,
+    failedAttempts: Int,
+    onChangeInstance: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val scope = rememberCoroutineScope()
+    val retry = remember { FocusRequester() }
+    LaunchedEffect(Unit) { retry.requestFocusWhenReady() }
+    AuthScaffold(
+        title = stringResource(R.string.reconnect_title),
+        subtitle = host,
+        modifier = modifier,
+    ) {
+        Column {
+            if (failedAttempts == 0) {
+                TextLabel(stringResource(R.string.reconnect_checking), Type.Body, maxLines = 2)
+            } else {
+                MessageText(UiMessage(R.string.reconnect_waiting))
+            }
+            Spacer(Modifier.height(18.dp))
+            Row(horizontalArrangement = Arrangement.spacedBy(12.dp)) {
+                PillButton(
+                    label = stringResource(R.string.state_retry),
+                    icon = Icons.Rounded.Replay,
+                    onClick = session::retryConnection,
+                    emphasized = true,
+                    modifier = Modifier.focusRequester(retry),
+                )
+                PillButton(
+                    label = stringResource(R.string.settings_change_instance),
+                    icon = Icons.Rounded.SwapHoriz,
+                    onClick = onChangeInstance,
+                )
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/video/typetype/tv/ui/auth/SetupScreen.kt b/feature/auth/src/main/java/video/typetype/tv/ui/auth/SetupScreen.kt
similarity index 87%
rename from app/src/main/java/video/typetype/tv/ui/auth/SetupScreen.kt
rename to feature/auth/src/main/java/video/typetype/tv/ui/auth/SetupScreen.kt
index 35b5408..46a06e8 100644
--- a/app/src/main/java/video/typetype/tv/ui/auth/SetupScreen.kt
+++ b/feature/auth/src/main/java/video/typetype/tv/ui/auth/SetupScreen.kt
@@ -1,5 +1,8 @@
 package video.typetype.tv.ui.auth
 
+import androidx.activity.compose.BackHandler
+import video.typetype.tv.ui.components.MessageText
+import video.typetype.tv.ui.util.UiMessage
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.height
@@ -21,21 +24,25 @@ import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.text.input.KeyboardType
 import androidx.compose.ui.unit.dp
 import kotlinx.coroutines.launch
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.session.DiscoveryResult
 import video.typetype.tv.data.session.SessionManager
 import video.typetype.tv.ui.components.PillButton
+import video.typetype.tv.ui.util.LocalIntroPlaying
 import video.typetype.tv.ui.util.requestFocusWhenReady
 
 @Composable
-fun SetupScreen(session: SessionManager, modifier: Modifier = Modifier) {
+fun SetupScreen(session: SessionManager, modifier: Modifier = Modifier, onCancel: (() -> Unit)? = null) {
+    // Opened over a working session: Back returns to it unchanged.
+    BackHandler(enabled = onCancel != null) { onCancel?.invoke() }
     var address by rememberSaveable { mutableStateOf("") }
     var busy by remember { mutableStateOf(false) }
     var message by remember { mutableStateOf<UiMessage?>(null) }
     var certificate by remember { mutableStateOf<CertificateRequest?>(null) }
     val scope = rememberCoroutineScope()
     val addressRequester = remember { FocusRequester() }
-    LaunchedEffect(Unit) { addressRequester.requestFocusWhenReady() }
+    val introPlaying = LocalIntroPlaying.current
+    LaunchedEffect(introPlaying) { if (!introPlaying) addressRequester.requestFocusWhenReady() }
 
     fun submit() {
         if (busy) return
diff --git a/app/src/main/java/video/typetype/tv/ui/auth/TvTextField.kt b/feature/auth/src/main/java/video/typetype/tv/ui/auth/TvTextField.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/auth/TvTextField.kt
rename to feature/auth/src/main/java/video/typetype/tv/ui/auth/TvTextField.kt
diff --git a/feature/collections/build.gradle.kts b/feature/collections/build.gradle.kts
new file mode 100644
index 0000000..84e3f9c
--- /dev/null
+++ b/feature/collections/build.gradle.kts
@@ -0,0 +1,14 @@
+plugins {
+    alias(libs.plugins.typetype.android.compose)
+}
+
+android {
+    namespace = "video.typetype.tv.feature.collections"
+}
+
+dependencies {
+    implementation(project(":core:ui"))
+
+    testImplementation(project(":core:testing"))
+    testImplementation(libs.junit)
+}
diff --git a/feature/collections/src/main/java/video/typetype/tv/ui/channel/ChannelHeader.kt b/feature/collections/src/main/java/video/typetype/tv/ui/channel/ChannelHeader.kt
new file mode 100644
index 0000000..c80c6f8
--- /dev/null
+++ b/feature/collections/src/main/java/video/typetype/tv/ui/channel/ChannelHeader.kt
@@ -0,0 +1,129 @@
+package video.typetype.tv.ui.channel
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.rounded.Check
+import androidx.compose.material.icons.rounded.MoreHoriz
+import androidx.compose.material.icons.rounded.NotificationsNone
+import androidx.compose.material.icons.rounded.Verified
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.graphics.Brush
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.unit.dp
+import coil3.compose.AsyncImage
+import video.typetype.tv.resources.R
+import video.typetype.tv.theme.Palette
+import video.typetype.tv.theme.Type
+import video.typetype.tv.ui.components.CircleButton
+import video.typetype.tv.ui.components.Glyph
+import video.typetype.tv.ui.components.PillButton
+import video.typetype.tv.ui.components.TextLabel
+
+internal val BannerHeight = 260.dp
+private const val BANNER_ALPHA = 0.9f
+
+// The channel's banner across the top of the screen. It fades out as the page scrolls into the videos; the
+// fraction is read in the layer phase only, so scrolling never recomposes it.
+@Composable
+internal fun ChannelBanner(bannerUrl: String?, scrolled: () -> Float) {
+    Box(Modifier.fillMaxSize().background(Palette.Ink)) {
+        if (bannerUrl != null) {
+            AsyncImage(
+                model = bannerUrl,
+                contentDescription = null,
+                contentScale = ContentScale.Crop,
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .height(BannerHeight)
+                    .graphicsLayer { alpha = BANNER_ALPHA * (1f - scrolled()) },
+            )
+        }
+        Box(
+            Modifier
+                .fillMaxWidth()
+                .height(BannerHeight)
+                .background(
+                    Brush.verticalGradient(
+                        0f to Palette.Ink.copy(alpha = 0.1f),
+                        0.55f to Palette.Ink.copy(alpha = 0.55f),
+                        1f to Palette.Ink,
+                    ),
+                ),
+        )
+    }
+}
+
+@Composable
+internal fun ChannelHeader(state: ChannelState, subscribe: FocusRequester, more: FocusRequester, onMore: () -> Unit) {
+    val page = state.page ?: return
+    Row(horizontalArrangement = Arrangement.spacedBy(24.dp), verticalAlignment = Alignment.Bottom) {
+        Box(
+            Modifier.size(112.dp).clip(CircleShape).background(Palette.Ink).padding(4.dp).clip(CircleShape).background(Palette.SurfaceRaised),
+            contentAlignment = Alignment.Center,
+        ) {
+            TextLabel(page.channel.name.take(1).uppercase(), Type.Headline)
+            page.channel.avatarUrl?.let {
+                AsyncImage(model = it, contentDescription = null, contentScale = ContentScale.Crop, modifier = Modifier.fillMaxSize())
+            }
+        }
+        Column(Modifier.weight(1f).padding(bottom = 4.dp)) {
+            Row(horizontalArrangement = Arrangement.spacedBy(10.dp), verticalAlignment = Alignment.CenterVertically) {
+                TextLabel(page.channel.name, Type.Display, maxLines = 1)
+                if (page.verified) {
+                    val verified = stringResource(R.string.channel_verified)
+                    Glyph(Icons.Rounded.Verified, Palette.TextMid, 26, Modifier.semantics { contentDescription = verified })
+                }
+            }
+            if (page.channel.subscribers.isNotBlank()) {
+                Spacer(Modifier.height(2.dp))
+                TextLabel(stringResource(R.string.detail_subscribers, page.channel.subscribers), Type.Meta, maxLines = 1)
+            }
+            if (page.description.isNotBlank()) {
+                Spacer(Modifier.height(6.dp))
+                Box(Modifier.width(600.dp)) { TextLabel(page.description, Type.Body, maxLines = 2) }
+            }
+        }
+        Column(horizontalAlignment = Alignment.End, modifier = Modifier.padding(bottom = 4.dp)) {
+            Row(horizontalArrangement = Arrangement.spacedBy(10.dp), verticalAlignment = Alignment.CenterVertically) {
+                PillButton(
+                    label = stringResource(if (state.subscribed) R.string.detail_subscribed else R.string.detail_subscribe),
+                    icon = if (state.subscribed) Icons.Rounded.Check else Icons.Rounded.NotificationsNone,
+                    onClick = state::toggleSubscription,
+                    emphasized = !state.subscribed,
+                    modifier = Modifier.focusRequester(subscribe),
+                )
+                CircleButton(
+                    icon = Icons.Rounded.MoreHoriz,
+                    description = stringResource(R.string.channel_more),
+                    onClick = onMore,
+                    modifier = Modifier.focusRequester(more),
+                )
+            }
+            if (state.subscriptionFailed || state.blockFailed) {
+                Spacer(Modifier.height(6.dp))
+                TextLabel(stringResource(R.string.detail_action_failed), Type.Meta.copy(color = Palette.Accent), maxLines = 2)
+            }
+        }
+    }
+}
diff --git a/feature/collections/src/main/java/video/typetype/tv/ui/channel/ChannelScreen.kt b/feature/collections/src/main/java/video/typetype/tv/ui/channel/ChannelScreen.kt
new file mode 100644
index 0000000..ec64569
--- /dev/null
+++ b/feature/collections/src/main/java/video/typetype/tv/ui/channel/ChannelScreen.kt
@@ -0,0 +1,226 @@
+package video.typetype.tv.ui.channel
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.grid.GridCells
+import androidx.compose.foundation.lazy.grid.GridItemSpan
+import androidx.compose.foundation.lazy.grid.LazyGridScope
+import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
+import androidx.compose.foundation.lazy.grid.itemsIndexed
+import androidx.compose.foundation.lazy.grid.rememberLazyGridState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.derivedStateOf
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.withFrameNanos
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import video.typetype.tv.data.ChannelTab
+import video.typetype.tv.data.ContentRepository
+import video.typetype.tv.data.Video
+import video.typetype.tv.resources.R
+import video.typetype.tv.theme.Dimens
+import video.typetype.tv.ui.components.ConfirmDialog
+import video.typetype.tv.ui.components.InkBackground
+import video.typetype.tv.ui.components.ScreenFailure
+import video.typetype.tv.ui.components.VideoCard
+import video.typetype.tv.ui.util.requestFocusWhenReady
+
+private const val GRID_COLUMNS = 3
+private const val PREFETCH_ROWS = 2
+private const val SKELETON_CARDS = 6
+
+// The header sits over the lower part of the banner, so the avatar overlaps it.
+private val HeaderTop = 120.dp
+
+@Composable
+fun ChannelScreen(
+    url: String,
+    repository: ContentRepository,
+    onOpen: (Video) -> Unit,
+    onOpenPodcast: (String) -> Unit,
+    onOpenPlaylist: (String) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val scope = rememberCoroutineScope()
+    val state = remember(url) { ChannelState(url, repository, scope) }
+    var attempt by remember(url) { mutableIntStateOf(0) }
+    LaunchedEffect(url, attempt) { state.load() }
+    val page = state.page
+    if (page == null) {
+        if (state.failure != null) ScreenFailure(state.failure, onRetry = { attempt++ }, modifier = modifier)
+        else InkBackground(modifier)
+        return
+    }
+    val subscribe = remember { FocusRequester() }
+    val more = remember { FocusRequester() }
+    val openTab = remember { FocusRequester() }
+    val firstItem = remember { FocusRequester() }
+    val searchButton = remember { FocusRequester() }
+    var menuOpen by remember(url) { mutableStateOf(false) }
+    var confirmingBlock by remember(url) { mutableStateOf(false) }
+    var searching by remember(url) { mutableStateOf(false) }
+    // The menu, the question and the search keep the focus while shown; the button that opened them gets it back
+    // once they are gone.
+    var returnFocus by remember(url) { mutableStateOf<FocusRequester?>(null) }
+    LaunchedEffect(menuOpen, confirmingBlock, searching, returnFocus) {
+        val target = returnFocus ?: return@LaunchedEffect
+        if (menuOpen || confirmingBlock || searching) return@LaunchedEffect
+        withFrameNanos { }
+        target.requestFocusWhenReady()
+        returnFocus = null
+    }
+    val hasTabsRow = state.tabs.size > 1 || state.sorts.isNotEmpty() || state.searchable
+    // Arriving on the open tab keeps the whole header in view; Down goes on into the videos.
+    LaunchedEffect(url) {
+        val landed = if (hasTabsRow) openTab.requestFocusWhenReady() else firstItem.requestFocusWhenReady()
+        if (!landed) subscribe.requestFocusWhenReady()
+    }
+    val gridState = rememberLazyGridState()
+    val itemCount = if (state.tab == ChannelTab.Playlists) state.playlists.size else state.videos.size
+    val nearEnd by remember(itemCount) {
+        derivedStateOf {
+            val last = gridState.layoutInfo.visibleItemsInfo.lastOrNull()?.index ?: 0
+            last >= gridState.layoutInfo.totalItemsCount - GRID_COLUMNS * PREFETCH_ROWS
+        }
+    }
+    LaunchedEffect(nearEnd, itemCount) { if (nearEnd) state.loadMore() }
+    val bannerPx = with(LocalDensity.current) { BannerHeight.toPx() }
+    Box(modifier.fillMaxSize()) {
+        ChannelBanner(page.bannerUrl) {
+            if (gridState.firstVisibleItemIndex > 0) 1f else (gridState.firstVisibleItemScrollOffset / bannerPx).coerceIn(0f, 1f)
+        }
+        LazyVerticalGrid(
+            state = gridState,
+            columns = GridCells.Fixed(GRID_COLUMNS),
+            modifier = Modifier.fillMaxSize().padding(start = Dimens.SafeStart, end = Dimens.SafeEnd),
+            contentPadding = PaddingValues(top = HeaderTop, bottom = 48.dp, start = 8.dp, end = 8.dp),
+            horizontalArrangement = Arrangement.spacedBy(Dimens.CardGap),
+            verticalArrangement = Arrangement.spacedBy(20.dp),
+        ) {
+            item(key = "header", span = { GridItemSpan(maxLineSpan) }) {
+                ChannelHeader(state, subscribe, more, onMore = { menuOpen = true })
+            }
+            if (state.podcasts.isNotEmpty()) {
+                item(key = "podcasts", span = { GridItemSpan(maxLineSpan) }) {
+                    PodcastRow(state.podcasts, onOpenPodcast)
+                }
+            }
+            if (hasTabsRow) {
+                item(key = "tabs", span = { GridItemSpan(maxLineSpan) }) {
+                    Column {
+                        Spacer(Modifier.height(4.dp))
+                        ChannelTabsRow(
+                            state = state,
+                            openTab = openTab,
+                            searchButton = searchButton,
+                            onSearch = { searching = true },
+                            onClearSearch = {
+                                state.search("")
+                                returnFocus = searchButton
+                            },
+                        )
+                    }
+                }
+            }
+            tabContent(state, firstItem, onOpen, onOpenPlaylist)
+        }
+        if (menuOpen) {
+            ChannelMoreMenu(
+                blocked = state.blocked,
+                onToggleBlock = {
+                    menuOpen = false
+                    if (state.blocked) {
+                        state.requestBlocked(false)
+                        returnFocus = more
+                    } else {
+                        confirmingBlock = true
+                    }
+                },
+                onClose = {
+                    menuOpen = false
+                    returnFocus = more
+                },
+            )
+        }
+        if (searching) {
+            val closeSearch = {
+                searching = false
+                returnFocus = searchButton
+            }
+            ChannelSearchPanel(
+                channelName = page.channel.name,
+                initial = state.query.orEmpty(),
+                onSearch = {
+                    closeSearch()
+                    state.search(it)
+                },
+                onClose = closeSearch,
+            )
+        }
+        if (confirmingBlock) {
+            ConfirmDialog(
+                title = stringResource(R.string.channel_block_title),
+                message = stringResource(R.string.channel_block_message),
+                confirmLabel = stringResource(R.string.channel_block),
+                onConfirm = {
+                    confirmingBlock = false
+                    returnFocus = more
+                    state.requestBlocked(true)
+                },
+                onDismiss = {
+                    confirmingBlock = false
+                    returnFocus = more
+                },
+            )
+        }
+    }
+}
+
+private fun LazyGridScope.tabContent(
+    state: ChannelState,
+    firstItem: FocusRequester,
+    onOpen: (Video) -> Unit,
+    onOpenPlaylist: (String) -> Unit,
+) {
+    val failure = state.tabFailure
+    when {
+        state.tabLoading -> items(SKELETON_CARDS) { ChannelCardSkeleton() }
+        failure != null -> item(key = "failure", span = { GridItemSpan(maxLineSpan) }) {
+            Box(Modifier.fillMaxWidth().height(320.dp)) { ScreenFailure(failure, onRetry = state::retryTab) }
+        }
+        state.tab == ChannelTab.Playlists && state.playlists.isEmpty() ||
+            state.tab != ChannelTab.Playlists && state.videos.isEmpty() ->
+            item(key = "empty", span = { GridItemSpan(maxLineSpan) }) { ChannelTabEmpty(state.query) }
+        state.tab == ChannelTab.Playlists -> itemsIndexed(state.playlists, key = { _, playlist -> playlist.url }) { index, playlist ->
+            ChannelPlaylistCard(
+                playlist = playlist,
+                onOpen = { onOpenPlaylist(playlist.url) },
+                modifier = if (index == 0) Modifier.focusRequester(firstItem) else Modifier,
+            )
+        }
+        else -> itemsIndexed(state.videos, key = { _, video -> video.id }) { index, video ->
+            VideoCard(
+                video = video,
+                onClick = { onOpen(video) },
+                modifier = if (index == 0) Modifier.focusRequester(firstItem) else Modifier,
+            )
+        }
+    }
+}
diff --git a/feature/collections/src/main/java/video/typetype/tv/ui/channel/ChannelSearch.kt b/feature/collections/src/main/java/video/typetype/tv/ui/channel/ChannelSearch.kt
new file mode 100644
index 0000000..2ce7dee
--- /dev/null
+++ b/feature/collections/src/main/java/video/typetype/tv/ui/channel/ChannelSearch.kt
@@ -0,0 +1,135 @@
+package video.typetype.tv.ui.channel
+
+import androidx.compose.animation.core.RepeatMode
+import androidx.compose.animation.core.animateFloat
+import androidx.compose.animation.core.infiniteRepeatable
+import androidx.compose.animation.core.rememberInfiniteTransition
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.height
+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.Search
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.input.key.KeyEventType
+import androidx.compose.ui.input.key.key
+import androidx.compose.ui.input.key.onPreviewKeyEvent
+import androidx.compose.ui.input.key.type
+import androidx.compose.ui.input.key.utf16CodePoint
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.liveRegion
+import androidx.compose.ui.semantics.LiveRegionMode
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.unit.dp
+import video.typetype.tv.resources.R
+import video.typetype.tv.theme.Palette
+import video.typetype.tv.theme.Shapes
+import video.typetype.tv.theme.Type
+import video.typetype.tv.ui.components.Glyph
+import video.typetype.tv.ui.components.PillButton
+import video.typetype.tv.ui.components.SearchInput
+import video.typetype.tv.ui.components.SearchKeyboard
+import video.typetype.tv.ui.components.TextLabel
+import video.typetype.tv.ui.components.TvOverlay
+import video.typetype.tv.ui.util.requestFocusWhenReady
+
+// The search keyboard over the channel page: the query is typed as on the search tab, then OK on Search shows the
+// channel's matching videos in place of its videos. Back leaves the search as it was.
+@Composable
+internal fun ChannelSearchPanel(channelName: String, initial: String, onSearch: (String) -> Unit, onClose: () -> Unit) {
+    var text by remember { mutableStateOf(initial) }
+    val firstKey = remember { FocusRequester() }
+    LaunchedEffect(Unit) { firstKey.requestFocusWhenReady() }
+    TvOverlay(onClose) {
+        Column(
+            modifier = Modifier
+                .width(760.dp)
+                .clip(Shapes.Panel)
+                .background(Palette.Surface)
+                .padding(28.dp)
+                .onPreviewKeyEvent { event ->
+                    if (event.type != KeyEventType.KeyDown) return@onPreviewKeyEvent false
+                    val typed = SearchInput.typed(event.utf16CodePoint)
+                    when {
+                        typed != null -> text = SearchInput.append(text, typed)
+                        event.key == Key.Backspace -> text = SearchInput.delete(text)
+                        else -> return@onPreviewKeyEvent false
+                    }
+                    true
+                },
+            verticalArrangement = Arrangement.spacedBy(16.dp),
+        ) {
+            TextLabel(stringResource(R.string.channel_search_title, channelName), Type.Headline, maxLines = 1)
+            Row(horizontalArrangement = Arrangement.spacedBy(12.dp), verticalAlignment = Alignment.CenterVertically) {
+                QueryLine(text, Modifier.weight(1f))
+                PillButton(
+                    label = stringResource(R.string.channel_search),
+                    icon = Icons.Rounded.Search,
+                    onClick = { onSearch(text) },
+                    emphasized = true,
+                )
+            }
+            SearchKeyboard(
+                onCharacter = { text = SearchInput.append(text, it) },
+                onDelete = { text = SearchInput.delete(text) },
+                onClear = { text = "" },
+                firstKey = firstKey,
+                rightEdgeTarget = null,
+            )
+        }
+    }
+}
+
+@Composable
+private fun QueryLine(text: String, modifier: Modifier = Modifier) {
+    val placeholder = stringResource(R.string.search_placeholder)
+    val cursor by rememberInfiniteTransition(label = "channel-search-cursor").animateFloat(
+        initialValue = 1f,
+        targetValue = 0f,
+        animationSpec = infiniteRepeatable(tween(530), RepeatMode.Reverse),
+        label = "cursor",
+    )
+    Row(
+        modifier = modifier
+            .clip(Shapes.Button)
+            .background(Palette.SurfaceRaised)
+            .height(52.dp)
+            .padding(horizontal = 18.dp)
+            .semantics {
+                contentDescription = text.ifEmpty { placeholder }
+                liveRegion = LiveRegionMode.Polite
+            },
+        horizontalArrangement = Arrangement.spacedBy(10.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Glyph(Icons.Rounded.Search, Palette.TextMid, 22)
+        val caret = Modifier.size(width = 2.dp, height = 24.dp).graphicsLayer { alpha = cursor }.background(Palette.Accent)
+        if (text.isEmpty()) Box(caret)
+        Box(Modifier.weight(1f, fill = false)) {
+            TextLabel(
+                text.ifEmpty { placeholder },
+                Type.Body.copy(color = if (text.isEmpty()) Palette.TextMid else Palette.TextHigh),
+                maxLines = 1,
+            )
+        }
+        if (text.isNotEmpty()) Box(caret)
+    }
+}
diff --git a/feature/collections/src/main/java/video/typetype/tv/ui/channel/ChannelState.kt b/feature/collections/src/main/java/video/typetype/tv/ui/channel/ChannelState.kt
new file mode 100644
index 0000000..594ed09
--- /dev/null
+++ b/feature/collections/src/main/java/video/typetype/tv/ui/channel/ChannelState.kt
@@ -0,0 +1,204 @@
+package video.typetype.tv.ui.channel
+
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+import video.typetype.tv.data.ChannelPage
+import video.typetype.tv.data.ChannelSearch
+import video.typetype.tv.data.ChannelSort
+import video.typetype.tv.data.ChannelTab
+import video.typetype.tv.data.ContentRepository
+import video.typetype.tv.data.PublicPlaylist
+import video.typetype.tv.data.Video
+import video.typetype.tv.data.net.ApiException
+import video.typetype.tv.ui.util.UiMessage
+import video.typetype.tv.ui.util.describeLoadFailure
+import java.io.IOException
+
+@Stable
+class ChannelState(
+    private val url: String,
+    private val repository: ContentRepository,
+    private val scope: CoroutineScope,
+) {
+    var page by mutableStateOf<ChannelPage?>(null)
+        private set
+
+    var videos by mutableStateOf<List<Video>>(emptyList())
+        private set
+
+    var failure by mutableStateOf<UiMessage?>(null)
+        private set
+
+    var subscribed by mutableStateOf(false)
+        private set
+
+    var subscriptionFailed by mutableStateOf(false)
+        private set
+
+    var podcasts by mutableStateOf<List<PublicPlaylist>>(emptyList())
+        private set
+
+    var blocked by mutableStateOf(false)
+        private set
+
+    var blockFailed by mutableStateOf(false)
+        private set
+
+    val tabs: List<ChannelTab> = ChannelTab.available(url)
+    val sorts: List<ChannelSort> = ChannelSort.available(url)
+
+    var tab by mutableStateOf(ChannelTab.Videos)
+        private set
+
+    val searchable: Boolean = ChannelSearch.available(url)
+
+    // Set while the Videos tab shows the channel's videos matching a search instead of all of them.
+    var query by mutableStateOf<String?>(null)
+        private set
+
+    var sort by mutableStateOf(sorts.firstOrNull())
+        private set
+
+    var playlists by mutableStateOf<List<PublicPlaylist>>(emptyList())
+        private set
+
+    // True while the open tab loads its first page: the grid shows skeletons, not the previous tab.
+    var tabLoading by mutableStateOf(false)
+        private set
+
+    var tabFailure by mutableStateOf<UiMessage?>(null)
+        private set
+
+    private var nextPage: String? = null
+    private var loadingMore = false
+    private var tabJob: Job? = null
+
+    suspend fun load() {
+        failure = null
+        try {
+            val loaded = repository.channel(url, sort = sort)
+            page = loaded
+            videos = loaded.videos.distinctBy { it.id }
+            nextPage = loaded.nextPage
+            subscribed = runCatching { repository.isSubscribed(url) }.getOrDefault(false)
+            podcasts = runCatching { repository.channelPodcasts(url) }.getOrDefault(emptyList())
+            blocked = runCatching { repository.isChannelBlocked(url) }.getOrDefault(false)
+        } catch (error: IOException) {
+            failure = describeLoadFailure(error)
+        }
+    }
+
+    fun select(next: ChannelTab) {
+        if (next == tab) return
+        tab = next
+        query = null
+        reloadTab()
+    }
+
+    // A blank search shows the channel's videos again.
+    fun search(text: String) {
+        val next = text.trim().ifEmpty { null }
+        if (next == query && tab == ChannelTab.Videos) return
+        query = next
+        tab = ChannelTab.Videos
+        reloadTab()
+    }
+
+    fun sortBy(next: ChannelSort) {
+        if (next == sort) return
+        sort = next
+        reloadTab()
+    }
+
+    private fun reloadTab() {
+        tabJob?.cancel()
+        loadingMore = false
+        nextPage = null
+        tabFailure = null
+        tabLoading = true
+        tabJob = scope.launch {
+            try {
+                when (tab) {
+                    ChannelTab.Playlists -> {
+                        val loaded = repository.channelPlaylists(url)
+                        playlists = loaded.playlists.distinctBy { it.url }
+                        nextPage = loaded.nextPage
+                    }
+                    else -> {
+                        val loaded = repository.channel(url, tab = tab, sort = sort.takeIf { tab == ChannelTab.Videos }, query = query)
+                        videos = loaded.videos.distinctBy { it.id }
+                        nextPage = loaded.nextPage
+                    }
+                }
+            } catch (error: IOException) {
+                tabFailure = describeLoadFailure(error)
+            } finally {
+                tabLoading = false
+            }
+        }
+    }
+
+    fun retryTab() = reloadTab()
+
+    fun loadMore() {
+        val cursor = nextPage ?: return
+        if (loadingMore || tabLoading) return
+        loadingMore = true
+        val loadingTab = tab
+        val loadingQuery = query
+        tabJob = scope.launch {
+            try {
+                if (loadingTab == ChannelTab.Playlists) {
+                    val more = repository.channelPlaylists(url, cursor)
+                    val known = playlists.mapTo(HashSet()) { it.url }
+                    playlists = playlists + more.playlists.filter { known.add(it.url) }
+                    nextPage = more.nextPage.takeIf { more.playlists.isNotEmpty() }
+                } else {
+                    val more = repository.channel(url, cursor, loadingTab, sort.takeIf { loadingTab == ChannelTab.Videos }, loadingQuery)
+                    val known = videos.mapTo(HashSet()) { it.id }
+                    videos = videos + more.videos.filter { known.add(it.id) }
+                    nextPage = more.nextPage.takeIf { more.videos.isNotEmpty() }
+                }
+            } catch (error: IOException) {
+                nextPage = cursor
+            } finally {
+                loadingMore = false
+            }
+        }
+    }
+
+    fun requestBlocked(enabled: Boolean) {
+        val channel = page?.channel ?: return
+        val previous = blocked
+        blocked = enabled
+        blockFailed = false
+        scope.launch {
+            try {
+                if (enabled) repository.blockChannel(channel) else repository.unblockChannel(channel.url)
+            } catch (error: ApiException) {
+                blocked = previous
+                blockFailed = true
+            }
+        }
+    }
+
+    fun toggleSubscription() {
+        val channel = page?.channel ?: return
+        val previous = subscribed
+        subscribed = !previous
+        subscriptionFailed = false
+        scope.launch {
+            try {
+                repository.setSubscribed(channel, !previous)
+            } catch (error: ApiException) {
+                subscribed = previous
+                subscriptionFailed = true
+            }
+        }
+    }
+}
diff --git a/feature/collections/src/main/java/video/typetype/tv/ui/channel/ChannelTabs.kt b/feature/collections/src/main/java/video/typetype/tv/ui/channel/ChannelTabs.kt
new file mode 100644
index 0000000..4c67a11
--- /dev/null
+++ b/feature/collections/src/main/java/video/typetype/tv/ui/channel/ChannelTabs.kt
@@ -0,0 +1,237 @@
+package video.typetype.tv.ui.channel
+
+import androidx.compose.animation.core.Animatable
+import androidx.compose.animation.core.spring
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateMapOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.focus.onFocusChanged
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.layout.onGloballyPositioned
+import androidx.compose.ui.layout.positionInParent
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.aspectRatio
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+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.Block
+import androidx.compose.material.icons.rounded.Close
+import androidx.compose.material.icons.rounded.History
+import androidx.compose.material.icons.rounded.LiveTv
+import androidx.compose.material.icons.rounded.NewReleases
+import androidx.compose.material.icons.rounded.PlaylistPlay
+import androidx.compose.material.icons.rounded.Search
+import androidx.compose.material.icons.rounded.VideoLibrary
+import androidx.compose.material.icons.rounded.Whatshot
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.role
+import androidx.compose.ui.semantics.selected
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.unit.dp
+import coil3.compose.AsyncImage
+import video.typetype.tv.data.ChannelSort
+import video.typetype.tv.data.ChannelTab
+import video.typetype.tv.data.PublicPlaylist
+import video.typetype.tv.resources.R
+import video.typetype.tv.theme.Palette
+import video.typetype.tv.theme.Shapes
+import video.typetype.tv.theme.Type
+import video.typetype.tv.ui.components.CircleButton
+import video.typetype.tv.ui.components.FocusSurface
+import video.typetype.tv.ui.components.OptionWheel
+import video.typetype.tv.ui.components.PillButton
+import video.typetype.tv.ui.components.QualityBadge
+import video.typetype.tv.ui.components.SkeletonBox
+import video.typetype.tv.ui.components.TextLabel
+import video.typetype.tv.ui.components.TvOverlay
+import video.typetype.tv.ui.components.WheelOption
+import video.typetype.tv.ui.util.focusEntersAt
+import video.typetype.tv.ui.util.metaLine
+import video.typetype.tv.ui.util.requestFocusWhenReady
+
+// A tab opens with OK, not as the focus passes: the sort wheel sits after the tabs, and crossing them to reach it
+// keeps the videos open. Coming back up from the grid lands on the open tab. Videos of YouTube channels can be
+// sorted with the wheel, and searched: the search button shows the query while one is set, with a button to clear it.
+@Composable
+internal fun ChannelTabsRow(
+    state: ChannelState,
+    openTab: FocusRequester,
+    searchButton: FocusRequester,
+    onSearch: () -> Unit,
+    onClearSearch: () -> Unit,
+) {
+    // The red mark follows the focus along the tabs and settles back under the open one when the focus leaves
+    // them. It slides in the layer phase only, so following the focus never recomposes the row.
+    var focusedTab by remember { mutableStateOf<ChannelTab?>(null) }
+    val centers = remember { mutableStateMapOf<ChannelTab, Float>() }
+    val target = focusedTab ?: state.tab
+    val markX = remember { Animatable(0f) }
+    var placed by remember { mutableStateOf(false) }
+    LaunchedEffect(target, centers[target]) {
+        val x = centers[target] ?: return@LaunchedEffect
+        if (placed) {
+            markX.animateTo(x, spring(dampingRatio = 0.8f, stiffness = 500f))
+        } else {
+            markX.snapTo(x)
+            placed = true
+        }
+    }
+    Row(verticalAlignment = Alignment.Top) {
+        Column {
+            Row(Modifier.focusEntersAt(openTab), horizontalArrangement = Arrangement.spacedBy(10.dp)) {
+                state.tabs.forEach { tab ->
+                    val open = tab == state.tab
+                    PillButton(
+                        label = stringResource(tab.labelRes),
+                        icon = tab.icon(),
+                        onClick = { state.select(tab) },
+                        emphasized = open,
+                        modifier = (if (open) Modifier.focusRequester(openTab) else Modifier)
+                            .onGloballyPositioned { centers[tab] = it.positionInParent().x + it.size.width / 2f }
+                            .onFocusChanged { focus ->
+                                if (focus.hasFocus) focusedTab = tab else if (focusedTab == tab) focusedTab = null
+                            }
+                            .semantics {
+                                role = Role.Tab
+                                selected = open
+                            },
+                    )
+                }
+            }
+            Spacer(Modifier.height(6.dp))
+            Box(
+                Modifier
+                    .graphicsLayer {
+                        translationX = markX.value - MarkWidth.toPx() / 2
+                        alpha = if (placed) 1f else 0f
+                    }
+                    .size(width = MarkWidth, height = 3.dp)
+                    .clip(Shapes.Chip)
+                    .background(Palette.Accent),
+            )
+        }
+        val sort = state.sort
+        if (state.tab == ChannelTab.Videos && sort != null && state.query == null) {
+            Spacer(Modifier.width(24.dp))
+            OptionWheel(
+                options = state.sorts.map { WheelOption(stringResource(it.labelRes), it.icon()) },
+                selected = state.sorts.indexOf(sort),
+                onSelect = { state.sortBy(state.sorts[it]) },
+                description = stringResource(R.string.channel_sort, stringResource(sort.labelRes)),
+            )
+        }
+        if (state.searchable) {
+            val query = state.query
+            Spacer(Modifier.width(24.dp))
+            PillButton(
+                label = query?.let { stringResource(R.string.channel_search_query, it) } ?: stringResource(R.string.channel_search),
+                icon = Icons.Rounded.Search,
+                onClick = onSearch,
+                emphasized = query != null,
+                description = query?.let { stringResource(R.string.channel_search_change, it) },
+                maxLabelWidth = 280.dp,
+                modifier = Modifier.focusRequester(searchButton),
+            )
+            if (query != null) {
+                Spacer(Modifier.width(10.dp))
+                CircleButton(Icons.Rounded.Close, stringResource(R.string.channel_search_clear), onClearSearch)
+            }
+        }
+    }
+}
+
+private val MarkWidth = 22.dp
+
+private fun ChannelTab.icon(): ImageVector = when (this) {
+    ChannelTab.Videos -> Icons.Rounded.VideoLibrary
+    ChannelTab.Live -> Icons.Rounded.LiveTv
+    ChannelTab.Playlists -> Icons.Rounded.PlaylistPlay
+}
+
+private fun ChannelSort.icon(): ImageVector = when (this) {
+    ChannelSort.Latest -> Icons.Rounded.NewReleases
+    ChannelSort.Popular -> Icons.Rounded.Whatshot
+    ChannelSort.Oldest -> Icons.Rounded.History
+}
+
+// A playlist laid out like a video card, so the Playlists tab reads like the others.
+@Composable
+internal fun ChannelPlaylistCard(playlist: PublicPlaylist, onOpen: () -> Unit, modifier: Modifier = Modifier) {
+    val count = stringResource(R.string.playlist_video_count, playlist.count.toString())
+    val description = stringResource(R.string.card_description, playlist.title, count)
+    Column(modifier) {
+        FocusSurface(
+            onClick = onOpen,
+            modifier = Modifier.fillMaxWidth().aspectRatio(16f / 9f).semantics { contentDescription = description },
+        ) {
+            Box(Modifier.fillMaxSize().background(Palette.Surface)) {
+                playlist.thumbnailUrl?.let { AsyncImage(it, null, Modifier.fillMaxSize(), contentScale = ContentScale.Crop) }
+                QualityBadge(count, Modifier.align(Alignment.BottomEnd).padding(8.dp))
+            }
+        }
+        Spacer(Modifier.height(10.dp))
+        TextLabel(playlist.title, Type.Title, maxLines = 1)
+        Spacer(Modifier.height(2.dp))
+        TextLabel(metaLine(playlist.uploader), Type.Meta, maxLines = 1)
+    }
+}
+
+@Composable
+internal fun ChannelCardSkeleton() {
+    Column {
+        SkeletonBox(Modifier.fillMaxWidth().aspectRatio(16f / 9f))
+        Spacer(Modifier.height(10.dp))
+        SkeletonBox(Modifier.size(width = 180.dp, height = 12.dp), Shapes.Chip)
+    }
+}
+
+@Composable
+internal fun ChannelTabEmpty(query: String?) {
+    val message = query?.let { stringResource(R.string.channel_search_empty, it) } ?: stringResource(R.string.channel_tab_empty)
+    Box(Modifier.fillMaxWidth().height(160.dp), contentAlignment = Alignment.CenterStart) {
+        TextLabel(message, Type.Body, maxLines = 2)
+    }
+}
+
+// The rarely used channel actions, kept out of the header behind "…".
+@Composable
+internal fun ChannelMoreMenu(blocked: Boolean, onToggleBlock: () -> Unit, onClose: () -> Unit) {
+    val first = remember { FocusRequester() }
+    LaunchedEffect(Unit) { first.requestFocusWhenReady() }
+    TvOverlay(onClose) {
+        Column(
+            Modifier.width(380.dp).clip(Shapes.Panel).background(Palette.Surface).padding(24.dp),
+            verticalArrangement = Arrangement.spacedBy(10.dp),
+        ) {
+            TextLabel(stringResource(R.string.channel_more), Type.Headline, maxLines = 1)
+            PillButton(
+                label = stringResource(if (blocked) R.string.channel_unblock else R.string.channel_block),
+                icon = Icons.Rounded.Block,
+                onClick = onToggleBlock,
+                modifier = Modifier.focusRequester(first),
+            )
+        }
+    }
+}
diff --git a/app/src/main/java/video/typetype/tv/ui/channel/PodcastRow.kt b/feature/collections/src/main/java/video/typetype/tv/ui/channel/PodcastRow.kt
similarity index 98%
rename from app/src/main/java/video/typetype/tv/ui/channel/PodcastRow.kt
rename to feature/collections/src/main/java/video/typetype/tv/ui/channel/PodcastRow.kt
index 214cb42..cb54817 100644
--- a/app/src/main/java/video/typetype/tv/ui/channel/PodcastRow.kt
+++ b/feature/collections/src/main/java/video/typetype/tv/ui/channel/PodcastRow.kt
@@ -23,7 +23,7 @@ import androidx.compose.ui.semantics.contentDescription
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.unit.dp
 import coil3.compose.AsyncImage
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.PublicPlaylist
 import video.typetype.tv.theme.Dimens
 import video.typetype.tv.theme.Palette
diff --git a/app/src/main/java/video/typetype/tv/ui/playlist/CollectionKind.kt b/feature/collections/src/main/java/video/typetype/tv/ui/playlist/CollectionKind.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/playlist/CollectionKind.kt
rename to feature/collections/src/main/java/video/typetype/tv/ui/playlist/CollectionKind.kt
diff --git a/app/src/main/java/video/typetype/tv/ui/playlist/PlaylistScreen.kt b/feature/collections/src/main/java/video/typetype/tv/ui/playlist/PlaylistScreen.kt
similarity index 92%
rename from app/src/main/java/video/typetype/tv/ui/playlist/PlaylistScreen.kt
rename to feature/collections/src/main/java/video/typetype/tv/ui/playlist/PlaylistScreen.kt
index 5ccd0a2..ef2c094 100644
--- a/app/src/main/java/video/typetype/tv/ui/playlist/PlaylistScreen.kt
+++ b/feature/collections/src/main/java/video/typetype/tv/ui/playlist/PlaylistScreen.kt
@@ -33,18 +33,20 @@ import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.ContentRepository
 import video.typetype.tv.data.Video
 import video.typetype.tv.theme.Dimens
 import video.typetype.tv.theme.Palette
 import video.typetype.tv.theme.Type
+import video.typetype.tv.ui.components.Backdrop
 import video.typetype.tv.ui.components.InkBackground
 import video.typetype.tv.ui.components.PillButton
 import video.typetype.tv.ui.components.ScreenFailure
 import video.typetype.tv.ui.components.TextLabel
 import video.typetype.tv.ui.components.VideoCard
 import video.typetype.tv.ui.util.requestFocusWhenReady
+import video.typetype.tv.ui.util.metaLine
 
 private const val GRID_COLUMNS = 3
 private const val PREFETCH_ROWS = 2
@@ -78,6 +80,8 @@ fun PlaylistScreen(
     }
     LaunchedEffect(nearEnd, state.videos.size) { if (nearEnd) state.loadMore() }
     Box(modifier.fillMaxSize().background(Palette.Ink)) {
+        // The playlist's own picture fills the background, as a video does on its page.
+        Backdrop(page.playlist.thumbnailUrl ?: state.videos.firstOrNull()?.thumbnailUrl)
         LazyVerticalGrid(
             state = gridState,
             columns = GridCells.Fixed(GRID_COLUMNS),
@@ -105,7 +109,7 @@ private fun PlaylistHeader(state: PlaylistState, save: FocusRequester, savable:
             TextLabel(page.playlist.title, Type.Display, maxLines = 2)
             Spacer(Modifier.height(6.dp))
             TextLabel(
-                "${page.playlist.uploader}  ·  ${stringResource(R.string.playlist_video_count, page.playlist.count.toString())}",
+                metaLine(page.playlist.uploader, stringResource(R.string.playlist_video_count, page.playlist.count.toString())),
                 Type.Meta,
                 maxLines = 1,
             )
diff --git a/app/src/main/java/video/typetype/tv/ui/playlist/PlaylistState.kt b/feature/collections/src/main/java/video/typetype/tv/ui/playlist/PlaylistState.kt
similarity index 98%
rename from app/src/main/java/video/typetype/tv/ui/playlist/PlaylistState.kt
rename to feature/collections/src/main/java/video/typetype/tv/ui/playlist/PlaylistState.kt
index aebca7b..65c301c 100644
--- a/app/src/main/java/video/typetype/tv/ui/playlist/PlaylistState.kt
+++ b/feature/collections/src/main/java/video/typetype/tv/ui/playlist/PlaylistState.kt
@@ -9,7 +9,7 @@ import kotlinx.coroutines.launch
 import video.typetype.tv.data.ContentRepository
 import video.typetype.tv.data.PublicPlaylistPage
 import video.typetype.tv.data.Video
-import video.typetype.tv.ui.auth.UiMessage
+import video.typetype.tv.ui.util.UiMessage
 import video.typetype.tv.ui.util.describeLoadFailure
 import java.io.IOException
 
diff --git a/app/src/test/java/video/typetype/tv/ui/channel/ChannelStateTest.kt b/feature/collections/src/test/java/video/typetype/tv/ui/channel/ChannelStateTest.kt
similarity index 51%
rename from app/src/test/java/video/typetype/tv/ui/channel/ChannelStateTest.kt
rename to feature/collections/src/test/java/video/typetype/tv/ui/channel/ChannelStateTest.kt
index a3c4fa4..3f2bebd 100644
--- a/app/src/test/java/video/typetype/tv/ui/channel/ChannelStateTest.kt
+++ b/feature/collections/src/test/java/video/typetype/tv/ui/channel/ChannelStateTest.kt
@@ -9,6 +9,9 @@ import org.junit.Assert.assertTrue
 import org.junit.Test
 import video.typetype.tv.data.Channel
 import video.typetype.tv.data.ChannelPage
+import video.typetype.tv.data.ChannelPlaylists
+import video.typetype.tv.data.ChannelSort
+import video.typetype.tv.data.ChannelTab
 import video.typetype.tv.data.ContentRepository
 import video.typetype.tv.data.MockContentRepository
 import video.typetype.tv.data.PublicPlaylist
@@ -26,7 +29,17 @@ class ChannelStateTest {
         val page: ChannelPage,
         var failWrites: Boolean = false,
     ) : ContentRepository by MockContentRepository(0) {
-        override suspend fun channel(url: String, page: String?) = this.page
+        val requests = mutableListOf<Pair<ChannelTab, ChannelSort?>>()
+        val queries = mutableListOf<String?>()
+
+        override suspend fun channel(url: String, page: String?, tab: ChannelTab, sort: ChannelSort?, query: String?): ChannelPage {
+            requests += tab to sort
+            queries += query
+            return this.page
+        }
+
+        override suspend fun channelPlaylists(url: String, page: String?) =
+            ChannelPlaylists(listOf(PublicPlaylist("$url/list", "Best of", "Chan", 4, null)), null)
 
         override suspend fun channelPodcasts(channelUrl: String) = listOf(PublicPlaylist("p", "Show", "Host", 3, null))
 
@@ -74,4 +87,63 @@ class ChannelStateTest {
         assertFalse(state.blocked)
         assertTrue(state.blockFailed)
     }
+
+    private suspend fun ChannelState.settle() {
+        while (tabLoading) kotlinx.coroutines.delay(20)
+    }
+
+    @Test
+    fun aYoutubeChannelOffersItsTabsAndSorts() = runBlocking {
+        val state = ChannelState(url, repository(), scope).also { it.load() }
+        assertEquals(ChannelTab.entries, state.tabs)
+        assertEquals(ChannelSort.Latest, state.sort)
+    }
+
+    @Test
+    fun otherServicesOnlyListVideos() {
+        val state = ChannelState("https://www.bilibili.com/space/1", repository(), scope)
+        assertEquals(listOf(ChannelTab.Videos), state.tabs)
+        assertTrue(state.sorts.isEmpty())
+    }
+
+    @Test
+    fun theTabsAndTheSortReachTheServer() = runBlocking {
+        val repository = repository()
+        val state = ChannelState(url, repository, scope).also { it.load() }
+        state.sortBy(ChannelSort.Popular)
+        state.settle()
+        state.select(ChannelTab.Live)
+        state.settle()
+        state.select(ChannelTab.Playlists)
+        state.settle()
+        assertEquals(
+            listOf(ChannelTab.Videos to ChannelSort.Latest, ChannelTab.Videos to ChannelSort.Popular, ChannelTab.Live to null),
+            repository.requests,
+        )
+        assertEquals(listOf("Best of"), state.playlists.map { it.title })
+    }
+
+    @Test
+    fun aSearchShowsTheMatchingVideosUntilItIsCleared() = runBlocking {
+        val repository = repository()
+        val state = ChannelState(url, repository, scope).also { it.load() }
+        state.search("  sintel ")
+        state.settle()
+        assertEquals("sintel", state.query)
+        state.search("")
+        state.settle()
+        assertEquals(null, state.query)
+        assertEquals(listOf(null, "sintel", null), repository.queries)
+    }
+
+    @Test
+    fun anotherTabLeavesTheSearch() = runBlocking {
+        val state = ChannelState(url, repository(), scope).also { it.load() }
+        state.search("sintel")
+        state.settle()
+        state.select(ChannelTab.Live)
+        state.settle()
+        assertEquals(null, state.query)
+        assertFalse(ChannelState("https://www.bilibili.com/space/1", repository(), scope).searchable)
+    }
 }
diff --git a/app/src/test/java/video/typetype/tv/ui/playlist/PlaylistStateTest.kt b/feature/collections/src/test/java/video/typetype/tv/ui/playlist/PlaylistStateTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/ui/playlist/PlaylistStateTest.kt
rename to feature/collections/src/test/java/video/typetype/tv/ui/playlist/PlaylistStateTest.kt
diff --git a/feature/detail/build.gradle.kts b/feature/detail/build.gradle.kts
new file mode 100644
index 0000000..513fd9f
--- /dev/null
+++ b/feature/detail/build.gradle.kts
@@ -0,0 +1,14 @@
+plugins {
+    alias(libs.plugins.typetype.android.compose)
+}
+
+android {
+    namespace = "video.typetype.tv.feature.detail"
+}
+
+dependencies {
+    implementation(project(":core:ui"))
+
+    testImplementation(project(":core:testing"))
+    testImplementation(libs.junit)
+}
diff --git a/feature/detail/src/main/java/video/typetype/tv/ui/detail/BlockingController.kt b/feature/detail/src/main/java/video/typetype/tv/ui/detail/BlockingController.kt
new file mode 100644
index 0000000..e979fbb
--- /dev/null
+++ b/feature/detail/src/main/java/video/typetype/tv/ui/detail/BlockingController.kt
@@ -0,0 +1,69 @@
+package video.typetype.tv.ui.detail
+
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import video.typetype.tv.data.ContentRepository
+import video.typetype.tv.data.Video
+import java.io.IOException
+
+// Whether a video and its channel are blocked for the account. A change shows at once and is undone if the
+// server refuses it, like the library toggles.
+@Stable
+class BlockingController(
+    private val repository: ContentRepository,
+    private val scope: CoroutineScope,
+) {
+    var videoBlocked by mutableStateOf(false)
+        private set
+
+    var channelBlocked by mutableStateOf(false)
+        private set
+
+    var loaded by mutableStateOf(false)
+        private set
+
+    var failed by mutableStateOf(false)
+        private set
+
+    suspend fun load(video: Video) {
+        try {
+            videoBlocked = repository.isVideoBlocked(video.id)
+            if (video.channel.url.isNotBlank()) channelBlocked = repository.isChannelBlocked(video.channel.url)
+        } catch (failure: IOException) {
+            failed = true
+        }
+        loaded = true
+    }
+
+    fun setVideoBlocked(video: Video, enabled: Boolean) {
+        val previous = videoBlocked
+        videoBlocked = enabled
+        change(undo = { videoBlocked = previous }) {
+            if (enabled) repository.blockVideo(video) else repository.unblockVideo(video.id)
+        }
+    }
+
+    fun setChannelBlocked(video: Video, enabled: Boolean) {
+        val previous = channelBlocked
+        channelBlocked = enabled
+        change(undo = { channelBlocked = previous }) {
+            if (enabled) repository.blockChannel(video.channel) else repository.unblockChannel(video.channel.url)
+        }
+    }
+
+    private fun change(undo: () -> Unit, call: suspend () -> Unit) {
+        failed = false
+        scope.launch {
+            try {
+                call()
+            } catch (failure: IOException) {
+                undo()
+                failed = true
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/video/typetype/tv/ui/detail/ChapterRow.kt b/feature/detail/src/main/java/video/typetype/tv/ui/detail/ChapterRow.kt
similarity index 78%
rename from app/src/main/java/video/typetype/tv/ui/detail/ChapterRow.kt
rename to feature/detail/src/main/java/video/typetype/tv/ui/detail/ChapterRow.kt
index 3a1f92d..4ad078d 100644
--- a/app/src/main/java/video/typetype/tv/ui/detail/ChapterRow.kt
+++ b/feature/detail/src/main/java/video/typetype/tv/ui/detail/ChapterRow.kt
@@ -19,7 +19,12 @@ import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.lazy.LazyRow
-import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.unit.Dp
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
@@ -33,7 +38,7 @@ import androidx.compose.ui.semantics.contentDescription
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.unit.dp
 import coil3.compose.AsyncImage
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.Chapter
 import video.typetype.tv.theme.Dimens
 import video.typetype.tv.theme.Palette
@@ -43,13 +48,20 @@ import video.typetype.tv.ui.components.FocusSurface
 import video.typetype.tv.ui.components.TextLabel
 import video.typetype.tv.ui.util.formatDuration
 
+// The chapters as a row of cards. On the video page OK plays the video; in the player it jumps to the chapter, and the
+// row opens on the chapter being watched.
 @OptIn(ExperimentalComposeUiApi::class, ExperimentalFoundationApi::class)
 @Composable
 fun ChapterRow(
     chapters: List<Chapter>,
-    onPlay: () -> Unit,
+    onSelect: (Chapter) -> Unit,
     modifier: Modifier = Modifier,
+    cardWidth: Dp = Dimens.WideCardWidth,
+    current: Int? = null,
+    currentRequester: FocusRequester? = null,
 ) {
+    val listState = rememberLazyListState()
+    LaunchedEffect(current) { current?.let { listState.scrollToItem(it) } }
     Column(modifier) {
         TextLabel(
             stringResource(R.string.detail_chapters),
@@ -58,6 +70,7 @@ fun ChapterRow(
         )
         Spacer(Modifier.height(10.dp))
         LazyRow(
+            state = listState,
             modifier = Modifier.focusRestorer().focusGroup(),
             contentPadding = PaddingValues(
                 start = Dimens.SafeStart,
@@ -67,8 +80,9 @@ fun ChapterRow(
             ),
             horizontalArrangement = Arrangement.spacedBy(Dimens.CardGap),
         ) {
-            items(chapters, key = { it.startSeconds }) { chapter ->
-                ChapterCard(chapter, onClick = onPlay, modifier = Modifier.width(Dimens.WideCardWidth))
+            itemsIndexed(chapters, key = { _, chapter -> chapter.startSeconds }) { index, chapter ->
+                val focus = if (index == current && currentRequester != null) Modifier.focusRequester(currentRequester) else Modifier
+                ChapterCard(chapter, onClick = { onSelect(chapter) }, modifier = Modifier.width(cardWidth).then(focus))
             }
         }
     }
diff --git a/app/src/main/java/video/typetype/tv/ui/detail/CommentReplies.kt b/feature/detail/src/main/java/video/typetype/tv/ui/detail/CommentReplies.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/detail/CommentReplies.kt
rename to feature/detail/src/main/java/video/typetype/tv/ui/detail/CommentReplies.kt
diff --git a/app/src/main/java/video/typetype/tv/ui/detail/CommentSpeech.kt b/feature/detail/src/main/java/video/typetype/tv/ui/detail/CommentSpeech.kt
similarity index 96%
rename from app/src/main/java/video/typetype/tv/ui/detail/CommentSpeech.kt
rename to feature/detail/src/main/java/video/typetype/tv/ui/detail/CommentSpeech.kt
index 464f1e1..5c80b7c 100644
--- a/app/src/main/java/video/typetype/tv/ui/detail/CommentSpeech.kt
+++ b/feature/detail/src/main/java/video/typetype/tv/ui/detail/CommentSpeech.kt
@@ -3,7 +3,7 @@ package video.typetype.tv.ui.detail
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.res.pluralStringResource
 import androidx.compose.ui.res.stringResource
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.Comment
 
 @Composable
diff --git a/app/src/main/java/video/typetype/tv/ui/detail/CommentsState.kt b/feature/detail/src/main/java/video/typetype/tv/ui/detail/CommentsState.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/detail/CommentsState.kt
rename to feature/detail/src/main/java/video/typetype/tv/ui/detail/CommentsState.kt
diff --git a/app/src/main/java/video/typetype/tv/ui/detail/DetailActions.kt b/feature/detail/src/main/java/video/typetype/tv/ui/detail/DetailActions.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/detail/DetailActions.kt
rename to feature/detail/src/main/java/video/typetype/tv/ui/detail/DetailActions.kt
diff --git a/app/src/main/java/video/typetype/tv/ui/detail/DetailHeader.kt b/feature/detail/src/main/java/video/typetype/tv/ui/detail/DetailHeader.kt
similarity index 78%
rename from app/src/main/java/video/typetype/tv/ui/detail/DetailHeader.kt
rename to feature/detail/src/main/java/video/typetype/tv/ui/detail/DetailHeader.kt
index f282275..89357a3 100644
--- a/app/src/main/java/video/typetype/tv/ui/detail/DetailHeader.kt
+++ b/feature/detail/src/main/java/video/typetype/tv/ui/detail/DetailHeader.kt
@@ -7,6 +7,7 @@ import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.heightIn
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.width
@@ -29,27 +30,33 @@ import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.layout.ContentScale
+import coil3.compose.AsyncImage
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.Video
 import video.typetype.tv.data.VideoActivity
 import video.typetype.tv.theme.Dimens
 import video.typetype.tv.theme.Palette
 import video.typetype.tv.theme.Type
+import video.typetype.tv.ui.components.LiveBadge
 import video.typetype.tv.ui.components.PillButton
 import video.typetype.tv.ui.components.ProgressLine
 import video.typetype.tv.ui.components.QualityBadge
+import video.typetype.tv.ui.components.ServiceBadge
 import video.typetype.tv.ui.components.TextLabel
-import video.typetype.tv.ui.util.formatDuration
+import video.typetype.tv.ui.util.knownDuration
 import video.typetype.tv.ui.util.formatTimeLeft
+import video.typetype.tv.ui.util.metaLine
 
 @Composable
 fun DetailHeader(
     video: Video,
+    pending: Boolean,
     activity: VideoActivity,
     actions: DetailActions,
     playRequester: FocusRequester,
@@ -63,18 +70,22 @@ fun DetailHeader(
     Column(
         modifier = modifier.padding(start = Dimens.SafeStart, top = Dimens.SafeTop + 34.dp),
     ) {
-        if (video.genre.isNotBlank()) {
-            TextLabel(video.genre.uppercase(), Type.Label.copy(color = Palette.Accent))
-            Spacer(Modifier.height(8.dp))
-        }
+        TextLabel(video.genre.uppercase(), Type.Label.copy(color = Palette.Accent))
+        Spacer(Modifier.height(8.dp))
         Box(Modifier.width(500.dp)) {
             TextLabel(video.title, Type.Display, maxLines = 2)
         }
         Spacer(Modifier.height(10.dp))
-        Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(10.dp)) {
+        Row(
+            modifier = Modifier.heightIn(min = 20.dp),
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(10.dp),
+        ) {
+            video.source?.let { ServiceBadge(it) }
+            if (video.isLive) LiveBadge(stringResource(R.string.badge_live))
             if (video.quality.isNotBlank()) QualityBadge(video.quality)
             TextLabel(
-                "${video.views}  ·  ${video.age}  ·  ${formatDuration(video.durationSeconds)}",
+                metaLine(video.views, video.age, knownDuration(video.durationSeconds)),
                 Type.Meta,
             )
         }
@@ -82,7 +93,8 @@ fun DetailHeader(
         ChannelLine(video)
         Spacer(Modifier.height(12.dp))
         Box(Modifier.width(500.dp)) {
-            TextLabel(video.description, Type.Body, maxLines = 3)
+            TextLabel(video.description, Type.Body, maxLines = 3, minLines = 3)
+            if (pending) DescriptionSkeleton()
         }
         video.resumeFraction?.let { fraction ->
             Spacer(Modifier.height(10.dp))
@@ -97,7 +109,13 @@ fun DetailHeader(
         Spacer(Modifier.height(18.dp))
         Row(horizontalArrangement = Arrangement.spacedBy(10.dp)) {
             PillButton(
-                label = stringResource(if (video.resumeFraction != null) R.string.detail_resume else R.string.detail_play),
+                label = stringResource(
+                    when {
+                        video.isLive -> R.string.detail_watch_live
+                        video.resumeFraction != null -> R.string.detail_resume
+                        else -> R.string.detail_play
+                    },
+                ),
                 icon = Icons.Rounded.PlayArrow,
                 onClick = onPlay,
                 emphasized = true,
@@ -152,13 +170,19 @@ private fun ChannelLine(video: Video) {
             contentAlignment = Alignment.Center,
         ) {
             BasicText(
-                video.channel.name.first().toString(),
+                video.channel.name.take(1),
                 style = Type.Title.copy(color = Palette.AccentSoft),
             )
+            video.channel.avatarUrl?.let { AsyncImage(it, null, Modifier.size(32.dp), contentScale = ContentScale.Crop) }
         }
         Column {
             TextLabel(video.channel.name, Type.Title, maxLines = 1)
-            TextLabel(stringResource(R.string.detail_subscribers, video.channel.subscribers), Type.Meta, maxLines = 1)
+            val subscribers = video.channel.subscribers
+            TextLabel(
+                if (subscribers.isBlank()) "" else stringResource(R.string.detail_subscribers, subscribers),
+                Type.Meta,
+                maxLines = 1,
+            )
         }
     }
 }
diff --git a/app/src/main/java/video/typetype/tv/ui/detail/DetailScreen.kt b/feature/detail/src/main/java/video/typetype/tv/ui/detail/DetailScreen.kt
similarity index 73%
rename from app/src/main/java/video/typetype/tv/ui/detail/DetailScreen.kt
rename to feature/detail/src/main/java/video/typetype/tv/ui/detail/DetailScreen.kt
index e10d3b3..28a4f2e 100644
--- a/app/src/main/java/video/typetype/tv/ui/detail/DetailScreen.kt
+++ b/feature/detail/src/main/java/video/typetype/tv/ui/detail/DetailScreen.kt
@@ -20,15 +20,20 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
+import androidx.compose.runtime.snapshotFlow
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.ContentRepository
 import video.typetype.tv.data.Shelf
 import video.typetype.tv.data.Video
 import video.typetype.tv.data.withResume
 import video.typetype.tv.theme.Dimens
 import video.typetype.tv.ui.components.Backdrop
-import video.typetype.tv.ui.auth.UiMessage
+import video.typetype.tv.ui.components.LocalPlaybackPreload
+import video.typetype.tv.ui.util.UiMessage
 import video.typetype.tv.ui.components.ScreenFailure
 import video.typetype.tv.ui.components.ShelfRow
 import video.typetype.tv.ui.util.tryLoad
@@ -42,6 +47,7 @@ fun DetailScreen(
     onOpen: (Video) -> Unit,
     onOpenChannel: (String) -> Unit,
     modifier: Modifier = Modifier,
+    preview: Video? = null,
 ) {
     var video by remember(videoId) { mutableStateOf<Video?>(null) }
     var related by remember(videoId) { mutableStateOf<List<Video>?>(null) }
@@ -49,32 +55,51 @@ fun DetailScreen(
     val controller = remember(videoId) { VideoActivityController(repository, scope) }
     var failure by remember(videoId) { mutableStateOf<UiMessage?>(null) }
     var attempt by remember(videoId) { mutableIntStateOf(0) }
+    val activityFromPreview = preview != null && preview.channel.url.isNotBlank()
     LaunchedEffect(videoId, attempt) {
         failure = null
+        if (activityFromPreview && preview != null) launch { controller.load(preview) }
         val loaded = tryLoad({ failure = it }) { repository.video(videoId) } ?: return@LaunchedEffect
         video = loaded
-        controller.load(loaded)
+        if (!activityFromPreview) controller.load(loaded)
         related = tryLoad({}) { repository.related(videoId) }.orEmpty()
     }
+    // With Play under the focus, the player's session is prepared while the page is read, from the card's own
+    // details when it came from one; a page left at once prepares nothing.
+    val preload = LocalPlaybackPreload.current
+    LaunchedEffect(videoId) {
+        delay(PRELOAD_DWELL_MILLIS)
+        val target = snapshotFlow { video ?: preview }.filterNotNull().first()
+        preload?.preload(target)
+    }
+    val shown = video ?: preview
+    val state = when {
+        video == null && failure != null -> DetailState.Failed
+        shown == null -> DetailState.Loading
+        else -> DetailState.Shown
+    }
     Crossfade(
-        targetState = video,
+        targetState = state,
         animationSpec = tween(400),
         modifier = modifier.fillMaxSize(),
         label = "detail-state",
-    ) { loaded ->
-        if (loaded == null && failure != null) {
-            ScreenFailure(failure, onRetry = { attempt++ })
-        } else if (loaded == null) {
-            DetailSkeleton()
-        } else {
-            DetailContent(loaded, controller, repository, related, onPlay, onOpen, onOpenChannel)
+    ) { current ->
+        when {
+            current == DetailState.Failed -> ScreenFailure(failure, onRetry = { attempt++ })
+            current == DetailState.Loading || shown == null -> DetailSkeleton()
+            else -> DetailContent(shown, video == null, controller, repository, related, onPlay, onOpen, onOpenChannel)
         }
     }
 }
 
+private enum class DetailState { Loading, Failed, Shown }
+
+private const val PRELOAD_DWELL_MILLIS = 300L
+
 @Composable
 private fun DetailContent(
     source: Video,
+    pending: Boolean,
     controller: VideoActivityController,
     repository: ContentRepository,
     related: List<Video>?,
@@ -91,7 +116,7 @@ private fun DetailContent(
     LaunchedEffect(video.id) { playRequester.requestFocusWhenReady() }
     val relatedTitle = stringResource(R.string.detail_related)
     Box(Modifier.fillMaxSize()) {
-        Backdrop(video.thumbnailUrl, focusY = video.focusY)
+        Backdrop(video.thumbnailUrl, focusY = video.focusY, preview = video.takeUnless { pending })
         LazyColumn(
             state = listState,
             modifier = Modifier.fillMaxSize(),
@@ -101,6 +126,7 @@ private fun DetailContent(
             item(key = "header") {
                 DetailHeader(
                     video = video,
+                    pending = pending,
                     activity = activity,
                     actions = DetailActions(
                         failed = controller.failed,
@@ -117,7 +143,7 @@ private fun DetailContent(
             }
             if (video.chapters.isNotEmpty()) {
                 item(key = "chapters") {
-                    ChapterRow(video.chapters, onPlay = { onPlay(video) })
+                    ChapterRow(video.chapters, onSelect = { onPlay(video) })
                 }
             }
             item(key = "related") { RelatedRow(related, relatedTitle, onOpen) }
diff --git a/app/src/main/java/video/typetype/tv/ui/detail/DetailSkeleton.kt b/feature/detail/src/main/java/video/typetype/tv/ui/detail/DetailSkeleton.kt
similarity index 88%
rename from app/src/main/java/video/typetype/tv/ui/detail/DetailSkeleton.kt
rename to feature/detail/src/main/java/video/typetype/tv/ui/detail/DetailSkeleton.kt
index a0616e3..d286681 100644
--- a/app/src/main/java/video/typetype/tv/ui/detail/DetailSkeleton.kt
+++ b/feature/detail/src/main/java/video/typetype/tv/ui/detail/DetailSkeleton.kt
@@ -18,7 +18,7 @@ import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.contentDescription
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.unit.dp
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.theme.Dimens
 import video.typetype.tv.theme.Shapes
 import video.typetype.tv.ui.components.InkBackground
@@ -50,6 +50,14 @@ fun DetailSkeleton(modifier: Modifier = Modifier) {
     }
 }
 
+@Composable
+fun DescriptionSkeleton(modifier: Modifier = Modifier) {
+    Column(modifier.padding(top = 4.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+        SkeletonBox(Modifier.size(width = 480.dp, height = 12.dp), RoundedCornerShape(6.dp))
+        SkeletonBox(Modifier.size(width = 440.dp, height = 12.dp), RoundedCornerShape(6.dp))
+    }
+}
+
 @Composable
 fun RelatedSkeleton(modifier: Modifier = Modifier) {
     Row(
diff --git a/app/src/main/java/video/typetype/tv/ui/detail/PlaylistPicker.kt b/feature/detail/src/main/java/video/typetype/tv/ui/detail/PlaylistPicker.kt
similarity index 93%
rename from app/src/main/java/video/typetype/tv/ui/detail/PlaylistPicker.kt
rename to feature/detail/src/main/java/video/typetype/tv/ui/detail/PlaylistPicker.kt
index 0d58529..a1f08af 100644
--- a/app/src/main/java/video/typetype/tv/ui/detail/PlaylistPicker.kt
+++ b/feature/detail/src/main/java/video/typetype/tv/ui/detail/PlaylistPicker.kt
@@ -1,14 +1,11 @@
 package video.typetype.tv.ui.detail
 
-import androidx.activity.compose.BackHandler
 import androidx.compose.foundation.background
 import androidx.compose.foundation.focusGroup
 import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
@@ -35,7 +32,7 @@ import androidx.compose.ui.semantics.role
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.semantics.stateDescription
 import androidx.compose.ui.unit.dp
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.PlaylistChoice
 import video.typetype.tv.theme.Palette
 import video.typetype.tv.theme.Shapes
@@ -44,17 +41,17 @@ import video.typetype.tv.ui.components.FocusSurface
 import video.typetype.tv.ui.components.Glyph
 import video.typetype.tv.ui.components.PillButton
 import video.typetype.tv.ui.components.TextLabel
+import video.typetype.tv.ui.components.TvOverlay
 import video.typetype.tv.ui.util.requestFocusWhenReady
 
 @OptIn(ExperimentalComposeUiApi::class)
 @Composable
 fun PlaylistPicker(state: PlaylistPickerState, onClose: () -> Unit, modifier: Modifier = Modifier) {
-    BackHandler(onBack = onClose)
     LaunchedEffect(state) { state.load() }
     val done = remember { FocusRequester() }
-    Box(modifier.fillMaxSize().background(Palette.Scrim), contentAlignment = Alignment.Center) {
+    TvOverlay(onClose) {
         Column(
-            modifier = Modifier
+            modifier = modifier
                 .width(560.dp)
                 .clip(Shapes.Panel)
                 .background(Palette.Surface)
diff --git a/app/src/main/java/video/typetype/tv/ui/detail/PlaylistPickerState.kt b/feature/detail/src/main/java/video/typetype/tv/ui/detail/PlaylistPickerState.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/detail/PlaylistPickerState.kt
rename to feature/detail/src/main/java/video/typetype/tv/ui/detail/PlaylistPickerState.kt
diff --git a/app/src/main/java/video/typetype/tv/ui/detail/VideoActivityController.kt b/feature/detail/src/main/java/video/typetype/tv/ui/detail/VideoActivityController.kt
similarity index 91%
rename from app/src/main/java/video/typetype/tv/ui/detail/VideoActivityController.kt
rename to feature/detail/src/main/java/video/typetype/tv/ui/detail/VideoActivityController.kt
index f113e31..ab5882a 100644
--- a/app/src/main/java/video/typetype/tv/ui/detail/VideoActivityController.kt
+++ b/feature/detail/src/main/java/video/typetype/tv/ui/detail/VideoActivityController.kt
@@ -22,12 +22,17 @@ class VideoActivityController(
     var failed by mutableStateOf(false)
         private set
 
+    // False until the library state is known, so a toggle never acts on a guess.
+    var loaded by mutableStateOf(false)
+        private set
+
     suspend fun load(video: Video) {
         activity = try {
             repository.activity(video)
         } catch (failure: ApiException) {
             VideoActivity()
         }
+        loaded = true
     }
 
     fun setWatchLater(video: Video, enabled: Boolean) =
diff --git a/feature/detail/src/main/java/video/typetype/tv/ui/detail/VideoMenuPanel.kt b/feature/detail/src/main/java/video/typetype/tv/ui/detail/VideoMenuPanel.kt
new file mode 100644
index 0000000..8386e13
--- /dev/null
+++ b/feature/detail/src/main/java/video/typetype/tv/ui/detail/VideoMenuPanel.kt
@@ -0,0 +1,256 @@
+package video.typetype.tv.ui.detail
+
+import androidx.activity.compose.BackHandler
+import androidx.compose.animation.core.Animatable
+import androidx.compose.animation.core.CubicBezierEasing
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.background
+import androidx.compose.foundation.focusGroup
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.aspectRatio
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.rounded.AccountCircle
+import androidx.compose.material.icons.rounded.BookmarkAdd
+import androidx.compose.material.icons.rounded.Block
+import androidx.compose.material.icons.rounded.BookmarkAdded
+import androidx.compose.material.icons.rounded.Favorite
+import androidx.compose.material.icons.rounded.FavoriteBorder
+import androidx.compose.material.icons.rounded.PersonOff
+import androidx.compose.material.icons.rounded.PlayArrow
+import androidx.compose.material.icons.rounded.PlaylistAdd
+import androidx.compose.material.icons.rounded.PlaylistRemove
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.ExperimentalComposeUiApi
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusProperties
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.input.key.KeyEvent
+import androidx.compose.ui.input.key.KeyEventType
+import androidx.compose.ui.input.key.key
+import androidx.compose.ui.input.key.onPreviewKeyEvent
+import androidx.compose.ui.input.key.type
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.disabled
+import androidx.compose.ui.semantics.role
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.unit.dp
+import kotlinx.coroutines.launch
+import java.io.IOException
+import video.typetype.tv.data.Video
+import video.typetype.tv.data.ContentRepository
+import video.typetype.tv.data.withResume
+import video.typetype.tv.resources.R
+import video.typetype.tv.theme.Dimens
+import video.typetype.tv.theme.Palette
+import video.typetype.tv.theme.Shapes
+import video.typetype.tv.theme.Type
+import video.typetype.tv.ui.components.FocusSurface
+import video.typetype.tv.ui.components.PlaylistContext
+import video.typetype.tv.ui.components.Glyph
+import video.typetype.tv.ui.components.TextLabel
+import video.typetype.tv.ui.components.VideoThumbnail
+import video.typetype.tv.ui.util.requestFocusWhenReady
+
+class VideoMenuActions(val onPlay: (Video) -> Unit, val onOpenChannel: (String) -> Unit)
+
+private val PanelWidth = 440.dp
+private val Enter = CubicBezierEasing(0.2f, 0f, 0f, 1f)
+
+// The options of one video, opened by a long press on its card: the same actions as the detail page, without
+// leaving the row. The focus stays in the panel until Back closes it.
+@OptIn(ExperimentalComposeUiApi::class)
+@Composable
+fun VideoMenuPanel(
+    video: Video,
+    repository: ContentRepository,
+    actions: VideoMenuActions,
+    onClose: (returnFocus: Boolean) -> Unit,
+    playlist: PlaylistContext? = null,
+) {
+    val scope = rememberCoroutineScope()
+    val controller = remember(video.id) { VideoActivityController(repository, scope) }
+    val blocking = remember(video.id) { BlockingController(repository, scope) }
+    var pickerOpen by remember { mutableStateOf(false) }
+    var pickerUsed by remember { mutableStateOf(false) }
+    val first = remember { FocusRequester() }
+    val playlists = remember { FocusRequester() }
+    val slide = remember { Animatable(1f) }
+    // The menu opens while OK is still held: its repeats and its release would click the first row. OK only counts
+    // again after a fresh press; the arrows move through the menu at once.
+    var okArmed by remember { mutableStateOf(false) }
+    LaunchedEffect(video.id) {
+        controller.load(video)
+        blocking.load(video)
+    }
+    LaunchedEffect(Unit) {
+        first.requestFocusWhenReady()
+        slide.animateTo(0f, tween(260, easing = Enter))
+    }
+    LaunchedEffect(pickerOpen) { if (!pickerOpen && pickerUsed) playlists.requestFocusWhenReady() }
+    BackHandler(enabled = !pickerOpen) { onClose(true) }
+    var removeFailed by remember { mutableStateOf(false) }
+    val activity = controller.activity
+    Box(
+        Modifier
+            .fillMaxSize()
+            .graphicsLayer { alpha = 1f - slide.value }
+            .background(Palette.Scrim)
+            .onPreviewKeyEvent { event ->
+                if (okArmed || !event.isOk()) return@onPreviewKeyEvent false
+                val freshPress = event.type == KeyEventType.KeyDown && event.nativeKeyEvent.repeatCount == 0
+                if (freshPress) okArmed = true
+                !freshPress
+            },
+    ) {
+        Column(
+            modifier = Modifier
+                .align(Alignment.CenterEnd)
+                .fillMaxHeight()
+                .width(PanelWidth)
+                .graphicsLayer { translationX = slide.value * PanelWidth.toPx() }
+                .background(Palette.Surface)
+                .padding(start = 28.dp, end = Dimens.SafeEnd, top = Dimens.SafeTop + 12.dp, bottom = Dimens.SafeBottom)
+                .focusProperties { exit = { FocusRequester.Cancel } }
+                .focusGroup()
+                .verticalScroll(rememberScrollState()),
+            verticalArrangement = Arrangement.spacedBy(6.dp),
+        ) {
+            Row(horizontalArrangement = Arrangement.spacedBy(14.dp), verticalAlignment = Alignment.CenterVertically) {
+                VideoThumbnail(video, Modifier.width(128.dp).aspectRatio(16f / 9f).clip(Shapes.Card))
+                Column(Modifier.weight(1f)) {
+                    TextLabel(video.title, Type.Title, maxLines = 2)
+                    TextLabel(video.channel.name, Type.Meta, maxLines = 1)
+                }
+            }
+            Spacer(Modifier.height(8.dp))
+            MenuRow(Icons.Rounded.PlayArrow, stringResource(R.string.detail_play), Modifier.focusRequester(first)) {
+                actions.onPlay(video.withResume(activity.resumePositionMs))
+            }
+            if (video.channel.url.isNotBlank()) {
+                MenuRow(Icons.Rounded.AccountCircle, stringResource(R.string.video_menu_channel)) {
+                    actions.onOpenChannel(video.channel.url)
+                }
+            }
+            MenuRow(Icons.Rounded.PlaylistAdd, stringResource(R.string.playlist_picker_title), Modifier.focusRequester(playlists)) {
+                pickerUsed = true
+                pickerOpen = true
+            }
+            if (playlist != null) {
+                // The card is gone once removed: the screen moves the focus, so the menu closes without returning it.
+                MenuRow(Icons.Rounded.PlaylistRemove, stringResource(R.string.video_menu_remove_from_playlist, playlist.name)) {
+                    removeFailed = false
+                    scope.launch {
+                        try {
+                            repository.setInPlaylist(video, playlist.id, false)
+                            playlist.onRemoved(video)
+                            onClose(false)
+                        } catch (failure: IOException) {
+                            removeFailed = true
+                        }
+                    }
+                }
+            }
+            MenuRow(
+                icon = if (activity.watchLater) Icons.Rounded.BookmarkAdded else Icons.Rounded.BookmarkAdd,
+                label = stringResource(
+                    if (activity.watchLater) R.string.video_menu_watch_later_remove else R.string.video_menu_watch_later_add,
+                ),
+                enabled = controller.loaded,
+            ) { controller.setWatchLater(video, !activity.watchLater) }
+            MenuRow(
+                icon = if (activity.favorite) Icons.Rounded.Favorite else Icons.Rounded.FavoriteBorder,
+                label = stringResource(
+                    if (activity.favorite) R.string.video_menu_favorite_remove else R.string.video_menu_favorite_add,
+                ),
+                enabled = controller.loaded,
+            ) { controller.setFavorite(video, !activity.favorite) }
+            Spacer(Modifier.height(6.dp))
+            MenuRow(
+                icon = Icons.Rounded.Block,
+                label = stringResource(
+                    if (blocking.videoBlocked) R.string.video_menu_unblock_video else R.string.video_menu_block_video,
+                ),
+                enabled = blocking.loaded,
+            ) { blocking.setVideoBlocked(video, !blocking.videoBlocked) }
+            if (video.channel.url.isNotBlank()) {
+                MenuRow(
+                    icon = Icons.Rounded.PersonOff,
+                    label = stringResource(
+                        if (blocking.channelBlocked) R.string.video_menu_unblock_channel else R.string.video_menu_block_channel,
+                    ),
+                    enabled = blocking.loaded,
+                ) { blocking.setChannelBlocked(video, !blocking.channelBlocked) }
+            }
+            if (controller.failed || blocking.failed || removeFailed) {
+                TextLabel(stringResource(R.string.detail_action_failed), Type.Meta.copy(color = Palette.Accent), maxLines = 2)
+            }
+        }
+        if (pickerOpen) {
+            val picker = remember(video.id) { PlaylistPickerState(video, repository, scope) }
+            PlaylistPicker(picker, onClose = { pickerOpen = false })
+        }
+    }
+}
+
+private fun KeyEvent.isOk(): Boolean = key == Key.DirectionCenter || key == Key.Enter || key == Key.NumPadEnter
+
+@Composable
+private fun MenuRow(
+    icon: ImageVector,
+    label: String,
+    modifier: Modifier = Modifier,
+    enabled: Boolean = true,
+    onClick: () -> Unit,
+) {
+    FocusSurface(
+        onClick = { if (enabled) onClick() },
+        modifier = modifier.fillMaxWidth().semantics {
+            role = Role.Button
+            contentDescription = label
+            if (!enabled) disabled()
+        },
+        shape = Shapes.Card,
+        focusedScale = 1.02f,
+        focusLift = 0.dp,
+    ) { focused ->
+        val content = if (focused) Palette.Ink else Palette.TextHigh
+        Row(
+            Modifier
+                .fillMaxWidth()
+                .background(if (focused) Palette.TextHigh else Palette.SurfaceRaised)
+                .graphicsLayer { alpha = if (enabled) 1f else 0.45f }
+                .padding(horizontal = 16.dp, vertical = 10.dp),
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(14.dp),
+        ) {
+            Glyph(icon, content, 22)
+            TextLabel(label, Type.Button.copy(color = content), maxLines = 1)
+        }
+    }
+}
diff --git a/app/src/test/java/video/typetype/tv/ui/detail/CommentRepliesTest.kt b/feature/detail/src/test/java/video/typetype/tv/ui/detail/CommentRepliesTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/ui/detail/CommentRepliesTest.kt
rename to feature/detail/src/test/java/video/typetype/tv/ui/detail/CommentRepliesTest.kt
diff --git a/app/src/test/java/video/typetype/tv/ui/detail/PlaylistPickerStateTest.kt b/feature/detail/src/test/java/video/typetype/tv/ui/detail/PlaylistPickerStateTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/ui/detail/PlaylistPickerStateTest.kt
rename to feature/detail/src/test/java/video/typetype/tv/ui/detail/PlaylistPickerStateTest.kt
diff --git a/feature/home/build.gradle.kts b/feature/home/build.gradle.kts
new file mode 100644
index 0000000..0e7ff05
--- /dev/null
+++ b/feature/home/build.gradle.kts
@@ -0,0 +1,14 @@
+plugins {
+    alias(libs.plugins.typetype.android.compose)
+}
+
+android {
+    namespace = "video.typetype.tv.feature.home"
+}
+
+dependencies {
+    implementation(project(":core:ui"))
+
+    testImplementation(project(":core:testing"))
+    testImplementation(libs.junit)
+}
diff --git a/app/src/main/java/video/typetype/tv/ui/home/HeroBlock.kt b/feature/home/src/main/java/video/typetype/tv/ui/home/HeroBlock.kt
similarity index 95%
rename from app/src/main/java/video/typetype/tv/ui/home/HeroBlock.kt
rename to feature/home/src/main/java/video/typetype/tv/ui/home/HeroBlock.kt
index a8acde4..f3b450d 100644
--- a/app/src/main/java/video/typetype/tv/ui/home/HeroBlock.kt
+++ b/feature/home/src/main/java/video/typetype/tv/ui/home/HeroBlock.kt
@@ -29,7 +29,7 @@ import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.Video
 import video.typetype.tv.theme.Dimens
 import video.typetype.tv.theme.Palette
@@ -38,8 +38,9 @@ import video.typetype.tv.ui.components.PillButton
 import video.typetype.tv.ui.components.ProgressLine
 import video.typetype.tv.ui.components.QualityBadge
 import video.typetype.tv.ui.components.TextLabel
-import video.typetype.tv.ui.util.formatDuration
+import video.typetype.tv.ui.util.knownDuration
 import video.typetype.tv.ui.util.formatTimeLeft
+import video.typetype.tv.ui.util.metaLine
 
 private val HERO_TEXT_HEIGHT = 212.dp
 
@@ -84,9 +85,7 @@ fun HeroBlock(
                     Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(10.dp)) {
                         if (current.quality.isNotBlank()) QualityBadge(current.quality)
                         TextLabel(
-                            listOf(current.genre, current.channel.name, formatDuration(current.durationSeconds))
-                                .filter { it.isNotBlank() }
-                                .joinToString("  ·  "),
+                            metaLine(current.genre, current.channel.name, knownDuration(current.durationSeconds)),
                             Type.Meta,
                             maxLines = 1,
                         )
diff --git a/app/src/main/java/video/typetype/tv/ui/home/HomeScreen.kt b/feature/home/src/main/java/video/typetype/tv/ui/home/HomeScreen.kt
similarity index 82%
rename from app/src/main/java/video/typetype/tv/ui/home/HomeScreen.kt
rename to feature/home/src/main/java/video/typetype/tv/ui/home/HomeScreen.kt
index 1b4a2c2..3b9570d 100644
--- a/app/src/main/java/video/typetype/tv/ui/home/HomeScreen.kt
+++ b/feature/home/src/main/java/video/typetype/tv/ui/home/HomeScreen.kt
@@ -1,5 +1,6 @@
 package video.typetype.tv.ui.home
 
+import androidx.activity.compose.BackHandler
 import androidx.compose.animation.Crossfade
 import androidx.compose.animation.core.tween
 import androidx.compose.foundation.layout.Box
@@ -19,18 +20,18 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.unit.dp
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import video.typetype.tv.data.ContentRepository
-import video.typetype.tv.ui.auth.UiMessage
+import video.typetype.tv.ui.util.UiMessage
 import video.typetype.tv.ui.components.ScreenFailure
 import video.typetype.tv.ui.util.tryLoad
 import video.typetype.tv.data.HomeContent
 import video.typetype.tv.data.Video
 import video.typetype.tv.theme.Dimens
 import video.typetype.tv.ui.components.Backdrop
+import video.typetype.tv.ui.components.LocalStreamPrewarm
 import video.typetype.tv.ui.components.ShelfRow
 import video.typetype.tv.ui.util.requestFocusWhenReady
 
@@ -83,11 +84,14 @@ private fun HomeLoaded(
     val listState = rememberLazyListState()
     val playRequester = session.heroEntry
     val scope = rememberCoroutineScope()
+    val prewarm = LocalStreamPrewarm.current
     val restoreAnchor = remember { session.anchor }
     var pendingRestore by remember { mutableStateOf(restoreAnchor != null) }
 
-    LaunchedEffect(content) {
-        while (true) {
+    var previewPlaying by remember { mutableStateOf(false) }
+    val heroInView = focusedCard == null && !previewPlaying
+    LaunchedEffect(content, heroInView) {
+        while (heroInView) {
             delay(HERO_ROTATION_MILLIS)
             heroIndex = (heroIndex + 1) % content.featured.size
         }
@@ -100,14 +104,25 @@ private fun HomeLoaded(
         }
     }
 
+    // Back from a row returns to the top first, as on other TV apps; only Back from the top leaves.
+    BackHandler(enabled = focusedCard != null) {
+        focusedCard = null
+        scope.launch {
+            listState.scrollToItem(0)
+            playRequester.requestFocusWhenReady()
+        }
+    }
+
     val target = focusedCard ?: hero
     var shown by remember { mutableStateOf(target) }
     LaunchedEffect(target) {
-        delay(BACKDROP_SETTLE_MILLIS)
+        // Only card focus waits, so a fast scroll through a row does not load every backdrop; the hero
+        // rotation changes title and image together.
+        if (focusedCard != null) delay(BACKDROP_SETTLE_MILLIS)
         shown = target
     }
     Box(Modifier.fillMaxSize()) {
-        Backdrop(shown.thumbnailUrl, focusY = shown.focusY)
+        Backdrop(shown.thumbnailUrl, focusY = shown.focusY, preview = shown, onPreviewPlaying = { previewPlaying = it })
         LazyColumn(
             state = listState,
             modifier = Modifier.fillMaxSize(),
@@ -124,6 +139,7 @@ private fun HomeLoaded(
                     onOpen = { onOpen(hero) },
                     onFocusHero = {
                         focusedCard = null
+                        prewarm?.focus(hero)
                         scope.launch { listState.animateScrollToItem(0) }
                     },
                     modifier = Modifier.padding(bottom = 6.dp),
diff --git a/app/src/main/java/video/typetype/tv/ui/home/HomeSession.kt b/feature/home/src/main/java/video/typetype/tv/ui/home/HomeSession.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/home/HomeSession.kt
rename to feature/home/src/main/java/video/typetype/tv/ui/home/HomeSession.kt
diff --git a/app/src/main/java/video/typetype/tv/ui/home/HomeSkeleton.kt b/feature/home/src/main/java/video/typetype/tv/ui/home/HomeSkeleton.kt
similarity index 98%
rename from app/src/main/java/video/typetype/tv/ui/home/HomeSkeleton.kt
rename to feature/home/src/main/java/video/typetype/tv/ui/home/HomeSkeleton.kt
index edf3be8..618ef9e 100644
--- a/app/src/main/java/video/typetype/tv/ui/home/HomeSkeleton.kt
+++ b/feature/home/src/main/java/video/typetype/tv/ui/home/HomeSkeleton.kt
@@ -17,7 +17,7 @@ import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.contentDescription
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.unit.dp
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.theme.Dimens
 import video.typetype.tv.theme.Shapes
 import video.typetype.tv.ui.components.InkBackground
diff --git a/feature/library/build.gradle.kts b/feature/library/build.gradle.kts
new file mode 100644
index 0000000..6310b38
--- /dev/null
+++ b/feature/library/build.gradle.kts
@@ -0,0 +1,14 @@
+plugins {
+    alias(libs.plugins.typetype.android.compose)
+}
+
+android {
+    namespace = "video.typetype.tv.feature.library"
+}
+
+dependencies {
+    implementation(project(":core:ui"))
+
+    testImplementation(project(":core:testing"))
+    testImplementation(libs.junit)
+}
diff --git a/app/src/main/java/video/typetype/tv/ui/library/LibraryRail.kt b/feature/library/src/main/java/video/typetype/tv/ui/library/LibraryRail.kt
similarity index 95%
rename from app/src/main/java/video/typetype/tv/ui/library/LibraryRail.kt
rename to feature/library/src/main/java/video/typetype/tv/ui/library/LibraryRail.kt
index 99fa6d6..ea96e17 100644
--- a/app/src/main/java/video/typetype/tv/ui/library/LibraryRail.kt
+++ b/feature/library/src/main/java/video/typetype/tv/ui/library/LibraryRail.kt
@@ -24,7 +24,7 @@ import androidx.compose.ui.semantics.role
 import androidx.compose.ui.semantics.selected
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.unit.dp
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.LibrarySection
 import video.typetype.tv.theme.Palette
 import video.typetype.tv.theme.Shapes
@@ -32,6 +32,7 @@ import video.typetype.tv.theme.Type
 import video.typetype.tv.ui.components.FocusSurface
 import video.typetype.tv.ui.components.Glyph
 import video.typetype.tv.ui.components.TextLabel
+import video.typetype.tv.ui.util.focusEntersAt
 import video.typetype.tv.ui.util.trapFocusDown
 
 @Composable
@@ -45,7 +46,7 @@ internal fun LibraryRail(
     Column(modifier = modifier.width(232.dp).trapFocusDown()) {
         TextLabel(stringResource(R.string.library_title), Type.Headline)
         Spacer(Modifier.height(20.dp))
-        Column(verticalArrangement = Arrangement.spacedBy(6.dp)) {
+        Column(Modifier.focusEntersAt(selectedRequester), verticalArrangement = Arrangement.spacedBy(6.dp)) {
             tabs.forEach { section ->
                 val isSelected = section.id == selected.id
                 RailItem(
diff --git a/app/src/main/java/video/typetype/tv/ui/library/LibraryScreen.kt b/feature/library/src/main/java/video/typetype/tv/ui/library/LibraryScreen.kt
similarity index 81%
rename from app/src/main/java/video/typetype/tv/ui/library/LibraryScreen.kt
rename to feature/library/src/main/java/video/typetype/tv/ui/library/LibraryScreen.kt
index 7f99b6f..8a62b02 100644
--- a/app/src/main/java/video/typetype/tv/ui/library/LibraryScreen.kt
+++ b/feature/library/src/main/java/video/typetype/tv/ui/library/LibraryScreen.kt
@@ -2,7 +2,7 @@ package video.typetype.tv.ui.library
 
 import video.typetype.tv.ui.util.tryLoad
 import video.typetype.tv.ui.components.ScreenFailure
-import video.typetype.tv.ui.auth.UiMessage
+import video.typetype.tv.ui.util.UiMessage
 import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.animation.Crossfade
 import androidx.compose.animation.core.tween
@@ -26,6 +26,12 @@ import androidx.compose.foundation.lazy.grid.rememberLazyGridState
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.rounded.Download
 import androidx.compose.runtime.Composable
+import video.typetype.tv.ui.components.PlaylistContext
+import video.typetype.tv.ui.components.LocalPlaylistContext
+import video.typetype.tv.data.LibrarySection
+import kotlinx.coroutines.launch
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
@@ -40,9 +46,8 @@ import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.contentDescription
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.unit.dp
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.ContentRepository
-import video.typetype.tv.data.LibrarySection
 import video.typetype.tv.data.Video
 import video.typetype.tv.theme.Dimens
 import video.typetype.tv.theme.Palette
@@ -70,6 +75,9 @@ fun LibraryScreen(
     var tabsFailure by remember { mutableStateOf<UiMessage?>(null) }
     var tabsAttempt by remember { mutableIntStateOf(0) }
     var itemsFailure by remember { mutableStateOf<UiMessage?>(null) }
+    // After a video leaves the open playlist, the focus goes to the one that took its place.
+    var focusAfterRemoval by remember { mutableStateOf<String?>(null) }
+    val scope = rememberCoroutineScope()
     var itemsAttempt by remember { mutableIntStateOf(0) }
     LaunchedEffect(tabsAttempt) {
         tabsFailure = null
@@ -85,6 +93,17 @@ fun LibraryScreen(
     LaunchedEffect(Unit) {
         if (restoreId == null) selectedRequester.requestFocusWhenReady()
     }
+    val section = session.selected
+    val playlist = (section as? LibrarySection.Playlist)?.let { open ->
+        PlaylistContext(open.id, open.name) { removed ->
+            val current = items.orEmpty()
+            val index = current.indexOfFirst { it.id == removed.id }
+            val remaining = current.filterNot { it.id == removed.id }
+            focusAfterRemoval = remaining.getOrNull(index.coerceAtMost(remaining.lastIndex))?.id
+            items = remaining
+            if (remaining.isEmpty()) scope.launch { selectedRequester.requestFocusWhenReady() }
+        }
+    }
     LaunchedEffect(session.selected, itemsAttempt) {
         items = null
         itemsFailure = null
@@ -98,7 +117,7 @@ fun LibraryScreen(
                 .padding(
                     start = Dimens.SafeStart,
                     end = Dimens.SafeEnd,
-                    top = Dimens.TopNavHeight + Dimens.SafeTop + 22.dp,
+                    top = Dimens.TabContentTop,
                 ),
             horizontalArrangement = Arrangement.spacedBy(36.dp),
         ) {
@@ -118,16 +137,21 @@ fun LibraryScreen(
                     loaded == null && itemsFailure != null -> ScreenFailure(itemsFailure, onRetry = { itemsAttempt++ })
                     loaded == null -> LibraryGridSkeleton()
                     loaded.isEmpty() -> EmptyLibrary()
-                    else -> LibraryGrid(
-                        videos = loaded,
-                        onOpen = {
-                            session.restoreVideoId = it.id
-                            onOpen(it)
-                        },
-                        restoreId = restoreId?.takeIf { pendingRestore },
-                        fallback = selectedRequester,
-                        onRestored = { pendingRestore = false },
-                    )
+                    else -> CompositionLocalProvider(LocalPlaylistContext provides playlist) {
+                        LibraryGrid(
+                            videos = loaded,
+                            onOpen = {
+                                session.restoreVideoId = it.id
+                                onOpen(it)
+                            },
+                            restoreId = focusAfterRemoval ?: restoreId?.takeIf { pendingRestore },
+                            fallback = selectedRequester,
+                            onRestored = {
+                                pendingRestore = false
+                                focusAfterRemoval = null
+                            },
+                        )
+                    }
                 }
             }
         }
diff --git a/app/src/main/java/video/typetype/tv/ui/library/LibrarySession.kt b/feature/library/src/main/java/video/typetype/tv/ui/library/LibrarySession.kt
similarity index 97%
rename from app/src/main/java/video/typetype/tv/ui/library/LibrarySession.kt
rename to feature/library/src/main/java/video/typetype/tv/ui/library/LibrarySession.kt
index 481737a..1a9cc64 100644
--- a/app/src/main/java/video/typetype/tv/ui/library/LibrarySession.kt
+++ b/feature/library/src/main/java/video/typetype/tv/ui/library/LibrarySession.kt
@@ -13,7 +13,7 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.res.stringResource
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.LibrarySection
 
 class LibrarySession {
diff --git a/feature/player/build.gradle.kts b/feature/player/build.gradle.kts
new file mode 100644
index 0000000..c85863e
--- /dev/null
+++ b/feature/player/build.gradle.kts
@@ -0,0 +1,19 @@
+plugins {
+    alias(libs.plugins.typetype.android.compose)
+}
+
+android {
+    namespace = "video.typetype.tv.feature.player"
+}
+
+dependencies {
+    implementation(project(":core:ui"))
+    implementation(project(":core:playback"))
+    implementation(project(":feature:detail"))
+    implementation(libs.androidx.media3.ui)
+    implementation(libs.androidx.media3.datasource.okhttp)
+    implementation(libs.androidx.lifecycle.runtime.compose)
+
+    testImplementation(project(":core:testing"))
+    testImplementation(libs.junit)
+}
diff --git a/app/src/main/java/video/typetype/tv/ui/player/AudioOnlyPoster.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/AudioOnlyPoster.kt
similarity index 98%
rename from app/src/main/java/video/typetype/tv/ui/player/AudioOnlyPoster.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/AudioOnlyPoster.kt
index c3140ae..034ce77 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/AudioOnlyPoster.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/AudioOnlyPoster.kt
@@ -21,7 +21,7 @@ import androidx.compose.ui.layout.ContentScale
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import coil3.compose.AsyncImage
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.Video
 import video.typetype.tv.theme.Palette
 import video.typetype.tv.theme.Type
diff --git a/app/src/main/java/video/typetype/tv/ui/player/CaptionRendering.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/CaptionRendering.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/player/CaptionRendering.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/CaptionRendering.kt
diff --git a/app/src/main/java/video/typetype/tv/ui/player/CaptionStyleOptions.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/CaptionStyleOptions.kt
similarity index 97%
rename from app/src/main/java/video/typetype/tv/ui/player/CaptionStyleOptions.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/CaptionStyleOptions.kt
index e08662b..0aff919 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/CaptionStyleOptions.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/CaptionStyleOptions.kt
@@ -1,7 +1,7 @@
 package video.typetype.tv.ui.player
 
 import androidx.annotation.StringRes
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.CaptionStyles
 
 enum class CaptionColor(val hex: String, @StringRes val labelRes: Int) {
diff --git a/app/src/main/java/video/typetype/tv/ui/player/CaptionViewStyle.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/CaptionViewStyle.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/player/CaptionViewStyle.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/CaptionViewStyle.kt
diff --git a/app/src/main/java/video/typetype/tv/ui/player/ChapterPosition.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/ChapterPosition.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/player/ChapterPosition.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/ChapterPosition.kt
diff --git a/feature/player/src/main/java/video/typetype/tv/ui/player/ControlsTimingEffects.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/ControlsTimingEffects.kt
new file mode 100644
index 0000000..598a4b6
--- /dev/null
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/ControlsTimingEffects.kt
@@ -0,0 +1,48 @@
+package video.typetype.tv.ui.player
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.ui.focus.FocusRequester
+import kotlinx.coroutines.delay
+import video.typetype.tv.ui.util.requestFocusWhenReady
+
+private const val CONTROLS_TIMEOUT_MILLIS = 4_500L
+private const val SCRUB_COMMIT_MILLIS = 800L
+
+// When the controls hide, where the focus goes when they show, and when a scrub is committed.
+@Composable
+fun ControlsTimingEffects(
+    session: PlayerSession,
+    state: PlayerUiState,
+    root: FocusRequester,
+    seek: FocusRequester,
+    play: FocusRequester,
+) {
+    LaunchedEffect(session.interaction, state.isPlaying, session.controlsVisible, session.relatedOpen) {
+        if (state.isPlaying && session.controlsVisible && !session.relatedOpen) {
+            delay(CONTROLS_TIMEOUT_MILLIS)
+            session.controlsVisible = false
+        }
+    }
+    LaunchedEffect(session.controlsVisible, state.isEnded, session.panel, session.relatedOpen) {
+        if (!session.controlsVisible) session.relatedOpen = false
+        val opener = session.origin?.let(session.originFocus::getValue)
+        when {
+            session.panel != null || session.relatedOpen -> Unit
+            state.isEnded -> Unit
+            session.controlsVisible && opener != null -> {
+                session.origin = null
+                if (!opener.requestFocusWhenReady()) seek.requestFocusWhenReady()
+            }
+            session.controlsVisible && session.controlsFromBelow -> play.requestFocusWhenReady()
+            session.controlsVisible -> seek.requestFocusWhenReady()
+            else -> root.requestFocusWhenReady()
+        }
+    }
+    LaunchedEffect(session.scrub.target) {
+        if (session.scrub.active) {
+            delay(SCRUB_COMMIT_MILLIS)
+            session.commitScrub()
+        }
+    }
+}
diff --git a/feature/player/src/main/java/video/typetype/tv/ui/player/FrameDropJudge.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/FrameDropJudge.kt
new file mode 100644
index 0000000..fd2be20
--- /dev/null
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/FrameDropJudge.kt
@@ -0,0 +1,29 @@
+package video.typetype.tv.ui.player
+
+// Reads the decoder's cumulative rendered and dropped frame counts, sampled while the video plays, and says when the
+// box keeps failing to show the picture in time: then the quality is too heavy for it.
+class FrameDropJudge(
+    private val windowSamples: Int = 5,
+    private val minDropped: Int = 60,
+    private val dropRatio: Float = 0.25f,
+) {
+    private val samples = ArrayDeque<Pair<Int, Int>>()
+
+    fun reset() = samples.clear()
+
+    fun struggling(rendered: Int, dropped: Int): Boolean {
+        samples.addLast(rendered to dropped)
+        if (samples.size > windowSamples + 1) samples.removeFirst()
+        if (samples.size <= windowSamples) return false
+        val (firstRendered, firstDropped) = samples.first()
+        val newRendered = rendered - firstRendered
+        val newDropped = dropped - firstDropped
+        // A new decoder starts its counts at zero.
+        if (newRendered < 0 || newDropped < 0) {
+            reset()
+            samples.addLast(rendered to dropped)
+            return false
+        }
+        return newDropped >= minDropped && newDropped >= (newRendered + newDropped) * dropRatio
+    }
+}
diff --git a/feature/player/src/main/java/video/typetype/tv/ui/player/FrameDropWatch.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/FrameDropWatch.kt
new file mode 100644
index 0000000..fb2c830
--- /dev/null
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/FrameDropWatch.kt
@@ -0,0 +1,61 @@
+package video.typetype.tv.ui.player
+
+import androidx.compose.runtime.Composable
+import androidx.media3.common.Player
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.ExoPlayer
+import kotlinx.coroutines.delay
+
+private const val SAMPLE_MILLIS = 2_000L
+private const val WARMUP_SAMPLES = 4
+
+// While the video plays, checks every two seconds whether the decoder keeps up; pauses, seeks and buffering start
+// the count again, since frames skipped there say nothing about the decoder.
+@androidx.annotation.OptIn(UnstableApi::class)
+@Composable
+fun FrameDropWatch(player: ExoPlayer, onStruggling: () -> Unit) {
+    val judge = remember(player) { FrameDropJudge() }
+    val currentOnStruggling by rememberUpdatedState(onStruggling)
+    // A seek flushes the decoder and skips frames on its way; the count starts again after it, as after a start.
+    var seeks by remember(player) { mutableIntStateOf(0) }
+    DisposableEffect(player) {
+        val listener = object : Player.Listener {
+            override fun onPositionDiscontinuity(oldPosition: Player.PositionInfo, newPosition: Player.PositionInfo, reason: Int) {
+                if (reason == Player.DISCONTINUITY_REASON_SEEK) seeks++
+            }
+        }
+        player.addListener(listener)
+        onDispose { player.removeListener(listener) }
+    }
+    LaunchedEffect(player) {
+        var playingSamples = 0
+        var seenSeeks = seeks
+        while (true) {
+            delay(SAMPLE_MILLIS)
+            val counters = player.videoDecoderCounters
+            if (!player.isPlaying || counters == null || seeks != seenSeeks) {
+                seenSeeks = seeks
+                playingSamples = 0
+                judge.reset()
+                continue
+            }
+            // The first seconds after a start, a seek or a pause drop frames while the decoder settles.
+            if (++playingSamples <= WARMUP_SAMPLES) {
+                judge.reset()
+                continue
+            }
+            counters.ensureUpdated()
+            if (judge.struggling(counters.renderedOutputBufferCount, counters.droppedBufferCount)) {
+                judge.reset()
+                currentOnStruggling()
+            }
+        }
+    }
+}
diff --git a/feature/player/src/main/java/video/typetype/tv/ui/player/LiveChatLayer.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/LiveChatLayer.kt
new file mode 100644
index 0000000..7bb7ae7
--- /dev/null
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/LiveChatLayer.kt
@@ -0,0 +1,167 @@
+package video.typetype.tv.ui.player
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.text.BasicText
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.draw.clipToBounds
+import androidx.compose.ui.layout.Layout
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.clearAndSetSemantics
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.text.withStyle
+import androidx.compose.ui.unit.dp
+import kotlinx.coroutines.channels.BufferOverflow
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import video.typetype.tv.data.ContentRepository
+import video.typetype.tv.data.LiveChatEvent
+import video.typetype.tv.data.LiveChatMessage
+import video.typetype.tv.resources.R
+import video.typetype.tv.theme.Palette
+import video.typetype.tv.theme.Dimens
+import video.typetype.tv.theme.Type
+import video.typetype.tv.ui.components.TextLabel
+
+@Stable
+class LiveChatState {
+    var messages by mutableStateOf(emptyList<LiveChatMessage>())
+        private set
+
+    var unavailable by mutableStateOf(false)
+        private set
+
+    fun apply(batch: List<LiveChatEvent>) {
+        val added = batch.filterIsInstance<LiveChatEvent.Message>().map { it.message }
+        if (added.isNotEmpty()) messages = (messages + added).takeLast(KEPT_MESSAGES)
+        if (batch.any { it == LiveChatEvent.Unavailable }) unavailable = true
+    }
+
+    private companion object {
+        const val KEPT_MESSAGES = 30
+    }
+}
+
+// Messages are published to the UI a few times a second, not one by one: the server pushes YouTube's
+// batches in bursts and every recomposition is a full-window redraw on the box GPU.
+@Composable
+fun LiveChatLayer(
+    videoUrl: String,
+    repository: ContentRepository,
+    underControls: Boolean,
+    modifier: Modifier = Modifier,
+) {
+    val state = remember(videoUrl) { LiveChatState() }
+    LaunchedEffect(videoUrl) {
+        val incoming = Channel<LiveChatEvent>(capacity = INCOMING_CAPACITY, onBufferOverflow = BufferOverflow.DROP_OLDEST)
+        launch { repository.liveChat(videoUrl).collect { incoming.send(it) } }
+        while (true) {
+            val batch = mutableListOf(incoming.receive())
+            while (true) batch += incoming.tryReceive().getOrNull() ?: break
+            state.apply(batch)
+            delay(PUBLISH_MILLIS)
+        }
+    }
+    LiveChatPanel(state, underControls, modifier)
+}
+
+@Composable
+private fun LiveChatPanel(state: LiveChatState, underControls: Boolean, modifier: Modifier) {
+    val status = when {
+        state.unavailable -> stringResource(R.string.live_chat_unavailable)
+        state.messages.isEmpty() -> stringResource(R.string.live_chat_connecting)
+        else -> null
+    }
+    // An opaque column: a translucent one over moving video would be blended on every frame.
+    Column(
+        modifier
+            .background(Palette.SurfaceOnInk)
+            .padding(
+                start = 20.dp,
+                end = Dimens.SafeEnd,
+                top = Dimens.SafeTop + 12.dp,
+                bottom = if (underControls) CONTROLS_CLEARANCE else Dimens.SafeBottom,
+            )
+            .clearAndSetSemantics { },
+    ) {
+        Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+            Box(Modifier.size(8.dp).clip(CircleShape).background(if (state.unavailable) Palette.TextLow else Palette.Accent))
+            TextLabel(stringResource(R.string.live_chat_title).uppercase(), Type.Label)
+        }
+        Spacer(Modifier.height(10.dp))
+        if (status != null) {
+            TextLabel(status, Type.Meta, maxLines = 2)
+        } else {
+            NewestThatFit(Modifier.fillMaxWidth().fillMaxHeight()) {
+                state.messages.forEach { message -> ChatLine(message) }
+            }
+        }
+    }
+}
+
+// Stacks lines from the bottom and leaves out any line that would only be partly visible at the top.
+@Composable
+private fun NewestThatFit(modifier: Modifier, content: @Composable () -> Unit) {
+    Layout(content, modifier.clipToBounds()) { measurables, constraints ->
+        val gap = LINE_GAP.roundToPx()
+        val placeables = measurables.map { it.measure(constraints.copy(minWidth = 0, minHeight = 0)) }
+        var used = 0
+        val shown = placeables.asReversed().takeWhile { line ->
+            val next = used + line.height + if (used > 0) gap else 0
+            (next <= constraints.maxHeight).also { if (it) used = next }
+        }
+        layout(constraints.maxWidth, constraints.maxHeight) {
+            var y = constraints.maxHeight
+            shown.forEach { line ->
+                y -= line.height
+                line.placeRelative(0, y)
+                y -= gap
+            }
+        }
+    }
+}
+
+@Composable
+private fun ChatLine(message: LiveChatMessage) {
+    val text = remember(message.id) { chatText(message) }
+    BasicText(text, style = Type.Body, maxLines = 3, overflow = TextOverflow.Ellipsis)
+}
+
+private fun chatText(message: LiveChatMessage): AnnotatedString = buildAnnotatedString {
+    if (message.author.isNotBlank()) {
+        val color = if (message.moderator) Palette.Accent else Palette.AccentSoft
+        withStyle(SpanStyle(color = color, fontWeight = FontWeight.Medium)) { append(message.author) }
+        append("  ")
+    }
+    withStyle(SpanStyle(color = Palette.TextHigh)) { append(message.text) }
+}
+
+private const val INCOMING_CAPACITY = 64
+private const val PUBLISH_MILLIS = 400L
+private val LINE_GAP = 8.dp
+// The control bar keeps the full width; the newest lines stay above it while it is shown.
+private val CONTROLS_CLEARANCE = 150.dp
diff --git a/feature/player/src/main/java/video/typetype/tv/ui/player/MutedPreview.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/MutedPreview.kt
new file mode 100644
index 0000000..5d43d48
--- /dev/null
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/MutedPreview.kt
@@ -0,0 +1,83 @@
+package video.typetype.tv.ui.player
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.viewinterop.AndroidView
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.compose.LifecycleEventEffect
+import androidx.media3.common.PlaybackException
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.ui.AspectRatioFrameLayout
+import androidx.media3.ui.PlayerView
+import video.typetype.tv.data.Video
+import video.typetype.tv.playback.PlaybackProvider
+import video.typetype.tv.playback.PlaybackRequest
+import video.typetype.tv.playback.PlayerHandle
+import java.io.IOException
+
+private const val PREVIEW_MAX_HEIGHT = 480
+
+// A muted, low-quality playback behind a browse screen. Nothing is recorded: no history, no progress.
+// One PlayerView serves every preview of a screen: a second SurfaceView created in the same place never received
+// frames (the player decoded, the video size stayed 0), so only the player is swapped.
+@androidx.annotation.OptIn(UnstableApi::class)
+@Composable
+fun MutedPreview(video: Video?, playback: PlaybackProvider, onPlaying: (Boolean) -> Unit, modifier: Modifier = Modifier) {
+    val context = LocalContext.current.applicationContext
+    var handle by remember { mutableStateOf<PlayerHandle?>(null) }
+    val currentOnPlaying by rememberUpdatedState(onPlaying)
+    LaunchedEffect(video?.id) {
+        handle = null
+        if (video == null) return@LaunchedEffect
+        // Previews start at the beginning, as on YouTube's TV home. With the small preview buffer, a resume point
+        // inside a long video gave the SABR preview audio but no video frames.
+        val request = PlaybackRequest(maxHeight = PREVIEW_MAX_HEIGHT, preview = true)
+        handle = try {
+            playback.open(context, video.id, request)
+        } catch (_: IOException) {
+            null
+        }
+    }
+    val current = handle
+    DisposableEffect(current) {
+        val listener = object : Player.Listener {
+            override fun onRenderedFirstFrame() = currentOnPlaying(true)
+
+            override fun onPlaybackStateChanged(playbackState: Int) {
+                if (playbackState == Player.STATE_ENDED) currentOnPlaying(false)
+            }
+
+            override fun onPlayerError(error: PlaybackException) = currentOnPlaying(false)
+        }
+        current?.player?.addListener(listener)
+        onDispose {
+            current?.player?.removeListener(listener)
+            current?.release()
+            currentOnPlaying(false)
+        }
+    }
+    LifecycleEventEffect(Lifecycle.Event.ON_PAUSE) { current?.player?.pause() }
+    AndroidView(
+        factory = { viewContext ->
+            PlayerView(viewContext).apply {
+                useController = false
+                resizeMode = AspectRatioFrameLayout.RESIZE_MODE_ZOOM
+                isFocusable = false
+                isFocusableInTouchMode = false
+                importantForAccessibility = android.view.View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS
+            }
+        },
+        update = { it.player = current?.player },
+        onRelease = { it.player = null },
+        modifier = modifier,
+    )
+}
diff --git a/app/src/main/java/video/typetype/tv/ui/player/NormalizedSubtitles.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/NormalizedSubtitles.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/player/NormalizedSubtitles.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/NormalizedSubtitles.kt
diff --git a/feature/player/src/main/java/video/typetype/tv/ui/player/OpeningPoster.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/OpeningPoster.kt
new file mode 100644
index 0000000..7034af8
--- /dev/null
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/OpeningPoster.kt
@@ -0,0 +1,60 @@
+package video.typetype.tv.ui.player
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.core.tween
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.EnterTransition
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.unit.dp
+import coil3.compose.AsyncImage
+import video.typetype.tv.data.Video
+import video.typetype.tv.theme.Dimens
+import video.typetype.tv.theme.Palette
+import video.typetype.tv.theme.Type
+import video.typetype.tv.ui.components.TextLabel
+
+private const val POSTER_ALPHA = 0.32f
+
+@Composable
+fun OpeningPoster(video: Video?, visible: Boolean, modifier: Modifier = Modifier) {
+    AnimatedVisibility(
+        visible = visible,
+        enter = EnterTransition.None,
+        exit = fadeOut(tween(300)),
+        modifier = modifier,
+    ) {
+        Box(Modifier.fillMaxSize().background(Color.Black)) {
+            if (video != null) {
+                AsyncImage(
+                    video.thumbnailUrl,
+                    null,
+                    Modifier.fillMaxSize().alpha(POSTER_ALPHA),
+                    contentScale = ContentScale.Crop,
+                )
+                Column(
+                    Modifier
+                        .align(Alignment.BottomStart)
+                        .padding(start = Dimens.SafeStart, bottom = Dimens.SafeTop + 24.dp),
+                ) {
+                    TextLabel(video.channel.name.uppercase(), Type.Label.copy(color = Palette.TextMid), maxLines = 1)
+                    Spacer(Modifier.height(8.dp))
+                    Box(Modifier.width(720.dp)) { TextLabel(video.title, Type.Display, maxLines = 2) }
+                }
+            }
+            BufferingSpinner(true, Modifier.align(Alignment.Center))
+        }
+    }
+}
diff --git a/app/src/main/java/video/typetype/tv/ui/player/PlaybackController.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/PlaybackController.kt
similarity index 73%
rename from app/src/main/java/video/typetype/tv/ui/player/PlaybackController.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/PlaybackController.kt
index 94c9767..ac59e59 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/PlaybackController.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/PlaybackController.kt
@@ -7,6 +7,7 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.setValue
 import androidx.media3.common.PlaybackException
 import androidx.media3.common.Player
+import androidx.media3.exoplayer.ExoPlaybackException
 import java.io.IOException
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
@@ -16,18 +17,17 @@ import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withTimeoutOrNull
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.ContentRepository
 import video.typetype.tv.data.PlaybackSetup
 import video.typetype.tv.data.Video
 import video.typetype.tv.data.net.ApiException
 import video.typetype.tv.data.net.Connectivity
-import video.typetype.tv.data.withResume
 import video.typetype.tv.playback.PlaybackProvider
-import video.typetype.tv.playback.PlaybackRequest
+import video.typetype.tv.playback.PlaybackRequests
 import video.typetype.tv.playback.PlayerHandle
 import video.typetype.tv.playback.StartupTrace
-import video.typetype.tv.ui.auth.UiMessage
+import video.typetype.tv.ui.util.UiMessage
 
 sealed interface PlaybackPhase {
     data object Opening : PlaybackPhase
@@ -73,8 +73,17 @@ class PlaybackController(
 
     fun start() = launch()
 
+    // A quality chosen by the viewer is kept; only Auto steps down when the box cannot keep up.
+    private var chosenQuality = false
+
     fun setQuality(cap: Int?) {
         qualityCap = cap
+        chosenQuality = cap != null
+        val live = (phase as? PlaybackPhase.Playing)?.handle?.takeIf { it.isLive }
+        if (live != null) {
+            live.capVideoHeight(cap)
+            return
+        }
         resumeFromCurrent()
         launch()
     }
@@ -90,6 +99,7 @@ class PlaybackController(
     fun onPlayerError(failed: PlayerHandle, error: PlaybackException? = null) {
         val current = phase as? PlaybackPhase.Playing ?: return
         if (current.handle !== failed) return
+        if (error != null && recoverDecoder(failed, error)) return
         if (error != null && PlaybackFailureClassifier.isNetwork(error) && inPlaceAttempts < MAX_IN_PLACE_ATTEMPTS) {
             prepareAgain(failed)
             return
@@ -105,6 +115,37 @@ class PlaybackController(
         launch()
     }
 
+    // A decoder that fails while playing fails again on the same picture. The box first sets the codec aside and
+    // opens the video again in another one; when there is no other codec, it opens one quality lower and stays there
+    // for the rest of this video.
+    private fun recoverDecoder(failed: PlayerHandle, error: PlaybackException): Boolean {
+        if (failed.isLive || !PlaybackFailureClassifier.isDecoder(error)) return false
+        // The player forgets its format once the renderer failed; the error keeps the one that was playing.
+        val format = (error as? ExoPlaybackException)?.rendererFormat ?: failed.player.videoFormat
+        val otherCodec = format?.sampleMimeType?.let(provider::decoderFailed) == true
+        if (!otherCodec) {
+            val failedHeight = format?.height?.takeIf { it > 0 } ?: qualityCap ?: failed.heights.maxOrNull() ?: return false
+            qualityCap = QualitySteps.below(failed.heights, failedHeight) ?: return false
+        }
+        resumeFromMs = failed.player.currentPosition.coerceAtLeast(0L)
+        failed.release()
+        phase = PlaybackPhase.Reconnecting(0, offline = false)
+        launch()
+        return true
+    }
+
+    // Reopening costs the viewer a reload, so a box that drops frames is stepped down once per video at most.
+    private var steppedForFrames = false
+
+    fun framesStruggling(handle: PlayerHandle) {
+        if (chosenQuality || steppedForFrames || handle.isLive || (phase as? PlaybackPhase.Playing)?.handle !== handle) return
+        steppedForFrames = true
+        val playing = handle.player.videoFormat?.height?.takeIf { it > 0 } ?: return
+        qualityCap = QualitySteps.below(handle.heights, playing) ?: return
+        resumeFromCurrent()
+        launch()
+    }
+
     private fun prepareAgain(handle: PlayerHandle) {
         inPlaceAttempts++
         job?.cancel()
@@ -169,27 +210,12 @@ class PlaybackController(
         val loaded = setup
         val current = video ?: runCatching { repository.video(videoId) }.getOrNull()?.also { video = it }
         trace.step("video")
-        val start = resumeFromMs ?: resumeStart(current)
+        val start = resumeFromMs ?: PlaybackRequests.resumeStart(repository, current)
         trace.step("resume")
-        val request = PlaybackRequest(
-            startMs = start,
-            maxHeight = qualityCap ?: loaded.preferences.maxHeight,
-            subtitles = loaded.subtitles,
-            liveManifest = loaded.liveManifest,
-            audioTrackId = audioTrack,
-            audioLanguage = loaded.preferences.audioLanguage,
-            preferOriginalAudio = loaded.preferences.preferOriginalAudio,
-            trace = trace,
-        )
+        val request = PlaybackRequests.of(loaded, start, maxHeight = qualityCap, audioTrackId = audioTrack, trace = trace)
         return provider.open(context, videoId, request).also { choices.initialize(it, loaded.preferences) }
     }
 
-    private suspend fun resumeStart(current: Video?): Long {
-        if (current == null) return 0L
-        val position = runCatching { repository.resumePositionMs(current.id) }.getOrDefault(0L)
-        return if (current.withResume(position).resumeFraction != null) position else 0L
-    }
-
     private suspend fun waitBeforeRetry(attempt: Int, startedAt: Long) {
         if (connectivity.online.value) {
             delay(policy.delayMillis(attempt))
diff --git a/app/src/main/java/video/typetype/tv/ui/player/PlaybackFailureClassifier.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/PlaybackFailureClassifier.kt
similarity index 88%
rename from app/src/main/java/video/typetype/tv/ui/player/PlaybackFailureClassifier.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/PlaybackFailureClassifier.kt
index b32649a..5c87ead 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/PlaybackFailureClassifier.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/PlaybackFailureClassifier.kt
@@ -45,6 +45,9 @@ object PlaybackFailureClassifier {
         }
     }
 
+    // The decoder itself gave up: opening the same picture again fails the same way.
+    fun isDecoder(error: PlaybackException): Boolean = error.errorCode in DECODER_ERRORS
+
     fun isPermanent(status: Int): Boolean = status in 400..499 && status !in RETRYABLE_CLIENT_STATUSES
 
     fun requestId(body: ByteArray): String? =
@@ -53,4 +56,5 @@ object PlaybackFailureClassifier {
         }.getOrNull()
 
     private const val MAX_DEPTH = 8
+    private val DECODER_ERRORS = PlaybackException.ERROR_CODE_DECODER_INIT_FAILED..PlaybackException.ERROR_CODE_DECODING_RESOURCES_RECLAIMED
 }
diff --git a/app/src/main/java/video/typetype/tv/ui/player/PlaybackStatsFormat.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/PlaybackStatsFormat.kt
similarity index 82%
rename from app/src/main/java/video/typetype/tv/ui/player/PlaybackStatsFormat.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/PlaybackStatsFormat.kt
index 3a5578d..0c3b77f 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/PlaybackStatsFormat.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/PlaybackStatsFormat.kt
@@ -31,6 +31,12 @@ object PlaybackStatsFormat {
         return if (parts.isEmpty()) UNKNOWN else parts.joinToString("  ")
     }
 
+    // Android's own decoders run on the processor; the others belong to the box's video hardware.
+    fun isSoftwareDecoder(name: String?): Boolean =
+        name != null && SOFTWARE_PREFIXES.any { name.startsWith(it, ignoreCase = true) }
+
+    private val SOFTWARE_PREFIXES = listOf("OMX.google.", "c2.android.", "c2.google.")
+
     fun speed(multiplier: Float): String = "${multiplier}x".replace(".0x", "x")
 
     const val UNKNOWN = "-"
diff --git a/app/src/main/java/video/typetype/tv/ui/player/PlaybackStatsOverlay.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/PlaybackStatsOverlay.kt
similarity index 86%
rename from app/src/main/java/video/typetype/tv/ui/player/PlaybackStatsOverlay.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/PlaybackStatsOverlay.kt
index f4a3446..17b94ad 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/PlaybackStatsOverlay.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/PlaybackStatsOverlay.kt
@@ -21,7 +21,7 @@ import androidx.media3.common.util.UnstableApi
 import androidx.media3.exoplayer.ExoPlayer
 import androidx.media3.exoplayer.analytics.AnalyticsListener
 import kotlinx.coroutines.delay
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.theme.Palette
 import video.typetype.tv.theme.Shapes
 import video.typetype.tv.theme.Type
@@ -36,12 +36,13 @@ data class PlaybackStatsSnapshot(
     val bufferMillis: Long = 0L,
     val bandwidthBitsPerSecond: Long = 0L,
     val speed: Float = 1f,
+    val decoder: String? = null,
 )
 
 @UnstableApi
 @androidx.annotation.OptIn(UnstableApi::class)
 @Composable
-fun PlaybackStatsOverlay(player: ExoPlayer, modifier: Modifier = Modifier) {
+fun PlaybackStatsOverlay(player: ExoPlayer, decoder: () -> String?, modifier: Modifier = Modifier) {
     var bandwidth by remember(player) { mutableLongStateOf(0L) }
     DisposableEffect(player) {
         val listener = object : AnalyticsListener {
@@ -55,7 +56,7 @@ fun PlaybackStatsOverlay(player: ExoPlayer, modifier: Modifier = Modifier) {
     val currentBandwidth by rememberUpdatedState(bandwidth)
     val snapshot by produceState(PlaybackStatsSnapshot(), player) {
         while (true) {
-            value = readStats(player, currentBandwidth)
+            value = readStats(player, currentBandwidth, decoder())
             delay(REFRESH_MILLIS)
         }
     }
@@ -63,6 +64,8 @@ fun PlaybackStatsOverlay(player: ExoPlayer, modifier: Modifier = Modifier) {
     Column(modifier.clip(Shapes.Panel).background(Palette.Scrim).padding(horizontal = 16.dp, vertical = 12.dp)) {
         TextLabel("${stringResource(R.string.stats_video)}  ${snapshot.video}", style, maxLines = 2)
         TextLabel("${stringResource(R.string.stats_audio)}  ${snapshot.audio}", style, maxLines = 2)
+        val kind = stringResource(if (PlaybackStatsFormat.isSoftwareDecoder(snapshot.decoder)) R.string.stats_decoder_software else R.string.stats_decoder_hardware)
+        TextLabel("${stringResource(R.string.stats_decoder)}  ${snapshot.decoder?.let { "$it  $kind" } ?: PlaybackStatsFormat.UNKNOWN}", style, maxLines = 2)
         TextLabel("${stringResource(R.string.stats_dropped)}  ${snapshot.droppedFrames}", style, maxLines = 1)
         TextLabel("${stringResource(R.string.stats_buffer)}  ${PlaybackStatsFormat.seconds(snapshot.bufferMillis)}", style, maxLines = 1)
         TextLabel("${stringResource(R.string.stats_network)}  ${PlaybackStatsFormat.bitrate(snapshot.bandwidthBitsPerSecond)}", style, maxLines = 1)
@@ -72,7 +75,7 @@ fun PlaybackStatsOverlay(player: ExoPlayer, modifier: Modifier = Modifier) {
 
 @UnstableApi
 @androidx.annotation.OptIn(UnstableApi::class)
-private fun readStats(player: ExoPlayer, bandwidth: Long): PlaybackStatsSnapshot {
+private fun readStats(player: ExoPlayer, bandwidth: Long, decoder: String?): PlaybackStatsSnapshot {
     val video = player.videoFormat
     val audio = player.audioFormat
     val counters = player.videoDecoderCounters
@@ -86,6 +89,7 @@ private fun readStats(player: ExoPlayer, bandwidth: Long): PlaybackStatsSnapshot
         bufferMillis = player.totalBufferedDuration,
         bandwidthBitsPerSecond = bandwidth,
         speed = player.playbackParameters.speed,
+        decoder = decoder,
     )
 }
 
diff --git a/app/src/main/java/video/typetype/tv/ui/player/PlayerContent.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerContent.kt
similarity index 63%
rename from app/src/main/java/video/typetype/tv/ui/player/PlayerContent.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/PlayerContent.kt
index 75d4410..1306272 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/PlayerContent.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerContent.kt
@@ -1,26 +1,27 @@
 package video.typetype.tv.ui.player
 
-import androidx.compose.animation.AnimatedVisibility
-import androidx.compose.animation.fadeIn
-import androidx.compose.animation.fadeOut
+import androidx.activity.compose.BackHandler
+import androidx.compose.foundation.background
 import androidx.compose.foundation.focusable
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.derivedStateOf
-import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.rememberUpdatedState
-import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.input.key.onPreviewKeyEvent
@@ -39,17 +40,18 @@ import video.typetype.tv.data.PlaybackSetup
 import video.typetype.tv.data.Video
 import video.typetype.tv.playback.PlayerHandle
 import video.typetype.tv.theme.Dimens
-import video.typetype.tv.ui.components.FadeVisibility
+import video.typetype.tv.data.ContentSource
 import video.typetype.tv.ui.detail.CommentsState
 import video.typetype.tv.ui.detail.VideoActivityController
 import video.typetype.tv.ui.player.danmaku.DanmakuOverlay
 import video.typetype.tv.ui.player.panel.PanelScene
 import video.typetype.tv.ui.player.panel.PlayerPanelHost
-import video.typetype.tv.ui.util.requestFocusWhenReady
+import video.typetype.tv.ui.player.panel.SheetWidth
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.getValue
 
-private const val CONTROLS_TIMEOUT_MILLIS = 4_500L
-private const val SCRUB_COMMIT_MILLIS = 800L
 private const val NOTICE_VISIBLE_MILLIS = 5_000L
+private val CHAT_WIDTH = 320.dp
 
 @androidx.annotation.OptIn(UnstableApi::class)
 @OptIn(UnstableApi::class)
@@ -68,6 +70,7 @@ fun PlayerContent(
     onPlayerError: (PlaybackException) -> Unit,
     onOpenNext: (Video) -> Unit,
     modifier: Modifier = Modifier,
+    onOpenChannel: (String) -> Unit = {},
     startWithControls: Boolean = true,
 ) {
     val player = handle.player
@@ -86,6 +89,7 @@ fun PlayerContent(
     var commentsOn by remember(handle) { mutableStateOf(!preferences.hideComments) }
     val root = remember { FocusRequester() }
     val seek = remember { FocusRequester() }
+    val play = remember { FocusRequester() }
     val scope = rememberCoroutineScope()
     val activity = remember(video?.id) { VideoActivityController(repository, scope) }
     val comments = remember(video?.id) { CommentsState(video?.id.orEmpty(), repository, scope) }
@@ -111,6 +115,7 @@ fun PlayerContent(
 
     val autoAdvance = !state.isLive && preferences.autoplay && next != null && !session.upNext.dismissed
     val currentAutoAdvance by rememberUpdatedState(autoAdvance)
+    WarmNextVideo(next, autoAdvance, state)
     val countdownSeconds = preferences.autoplayCountdownSeconds
     val upNextWindow = { UpNextTimeline.windowMillis(state.durationMillis, countdownSeconds) }
     val inUpNextWindow by remember(state, countdownSeconds) {
@@ -122,26 +127,7 @@ fun PlayerContent(
         derivedStateOf { SponsorLabels.current(state.positionMillis, setup.sponsorSegments) }
     }
 
-    LaunchedEffect(session.interaction, state.isPlaying, session.controlsVisible) {
-        if (state.isPlaying && session.controlsVisible) {
-            delay(CONTROLS_TIMEOUT_MILLIS)
-            session.controlsVisible = false
-        }
-    }
-    LaunchedEffect(session.controlsVisible, state.isEnded, session.panel) {
-        when {
-            session.panel != null -> Unit
-            state.isEnded -> Unit
-            session.controlsVisible -> seek.requestFocusWhenReady()
-            else -> root.requestFocusWhenReady()
-        }
-    }
-    LaunchedEffect(session.scrub.target) {
-        if (session.scrub.active) {
-            delay(SCRUB_COMMIT_MILLIS)
-            session.commitScrub()
-        }
-    }
+    ControlsTimingEffects(session, state, root = root, seek = seek, play = play)
     val noticeVisible = session.notice.segment != null && !session.controlsVisible && session.panel == null
     LaunchedEffect(noticeVisible) {
         if (noticeVisible) {
@@ -155,71 +141,78 @@ fun PlayerContent(
         if (currentAutoAdvance) next?.let(onOpenNext)
     }
 
+    BackHandler(enabled = session.handlesBack(upNextVisible)) { session.back(upNextVisible) }
+    val remoteKeys = remoteKeyActions(player, state, session, choices, handle.captionLanguages.size) { next?.let(onOpenNext) }
     Box(
+        // The window has no background of its own; with the chat column the picture is letterboxed, and the
+        // strips around it would otherwise keep whatever was drawn there before (the hidden controls).
         modifier = modifier
             .fillMaxSize()
+            .background(Color.Black)
             .focusRequester(root)
-            .onPreviewKeyEvent { event -> session.onKey(event, upNextVisible) { next?.let(onOpenNext) } }
+            .onPreviewKeyEvent { event ->
+                handleRemoteKey(event, session.panel != null, remoteKeys) || session.onKey(event, upNextVisible) { next?.let(onOpenNext) }
+            }
             .focusable(),
     ) {
-        PlayerVideoSurface(player, captionStyles)
-        AudioOnlyPoster(video, choices.audioOnly)
-        if (commentsOn && bulletComments.isNotEmpty()) {
-            DanmakuOverlay(bulletComments, state, SPEED_CHOICES[speedIndex])
+        val chatAvailable = handle.isLive && video?.source == ContentSource.YouTube
+        val chatUrl = video?.id?.takeIf { choices.chatOn && chatAvailable && !state.isEnded }
+        val heights = if (handle.isLive) state.trackHeights else handle.heights
+        val opening = !state.hasFirstFrame && !state.isPlaying && !choices.audioOnly
+        // With the live chat on, the picture keeps the left part of the screen and the chat its own column,
+        // as YouTube's TV app does, so no message covers the stream.
+        // A side panel takes the right of the screen and the picture shrinks into what is left, whole.
+        val pictureEnd = when {
+            chatUrl != null -> CHAT_WIDTH
+            session.panel.let { it != null && it != PlayerPanel.Playlists } -> SheetWidth
+            else -> 0.dp
         }
-        BufferingSpinner(state.isBuffering && !state.isEnded, Modifier.align(Alignment.Center))
-        val current = video
-        if (current != null) {
-            FadeVisibility(visible = session.controlsVisible) {
-                PlayerControls(
-                    video = current,
-                    state = state,
-                    preferences = playerPreferences(
-                        handle, qualityCap, preferences.maxHeight, captionIndex, speedIndex,
-                        commentsAvailable = bulletComments.isNotEmpty(),
-                        commentsOn = commentsOn,
-                    ),
-                    actions = PlayerControlActions(
-                        onTogglePlay = session::togglePlay,
-                        onSeekBy = session::seekBy,
-                        onPrevious = { player.seekTo(0L) },
-                        onNext = { next?.let(onOpenNext) },
-                        onToggleCaptions = { choices.captionIndex = (captionIndex + 1) % (handle.captionLanguages.size + 1) },
-                        onOpenQuality = {
-                            session.controlsVisible = false
-                            session.panel = PlayerPanel.Quality
-                        },
-                        onCycleSpeed = { choices.speedIndex = (speedIndex + 1) % SPEED_CHOICES.size },
-                        onToggleComments = { commentsOn = !commentsOn },
-                        onOpenAudio = {
-                            session.controlsVisible = false
-                            session.panel = PlayerPanel.Audio
-                        },
-                        onOpenMenu = {
-                            session.controlsVisible = false
-                            session.panel = PlayerPanel.Menu
-                        },
-                        onScrubBy = session::scrubBy,
-                        onGoLive = {
-                            player.seekToDefaultPosition()
-                            player.play()
-                        },
-                    ),
-                    seekRequester = seek,
-                    sponsorSegments = setup.sponsorSegments,
-                    scrubMillis = session.scrub.target,
-                    storyboard = setup.storyboard,
-                )
+        Box(Modifier.fillMaxSize().padding(end = pictureEnd)) {
+            PlayerVideoSurface(player, captionStyles)
+            AudioOnlyPoster(video, choices.audioOnly)
+            if (commentsOn && bulletComments.isNotEmpty()) {
+                DanmakuOverlay(bulletComments, state, SPEED_CHOICES[speedIndex])
+            }
+            BufferingSpinner(state.isBuffering && !state.isEnded && !opening, Modifier.align(Alignment.Center))
+            Column(
+                modifier = Modifier.align(Alignment.TopEnd).padding(end = Dimens.SafeEnd, top = Dimens.SafeTop + 12.dp),
+                horizontalAlignment = Alignment.End,
+                verticalArrangement = Arrangement.spacedBy(10.dp),
+            ) {
+                if (choices.statsOn) PlaybackStatsOverlay(player, decoder = { handle.videoDecoder })
+                SponsorLabelBadge(sponsorLabel.takeIf { preferences.showCurrentSegment && session.panel == null })
             }
         }
-        Column(
-            modifier = Modifier.align(Alignment.TopEnd).padding(end = Dimens.SafeEnd, top = Dimens.SafeTop + 12.dp),
-            horizontalAlignment = Alignment.End,
-            verticalArrangement = Arrangement.spacedBy(10.dp),
-        ) {
-            if (choices.statsOn) PlaybackStatsOverlay(player)
-            SponsorLabelBadge(
-                sponsorLabel.takeIf { preferences.showCurrentSegment && session.panel == null },
+        if (chatUrl != null) {
+            LiveChatLayer(
+                chatUrl,
+                repository,
+                underControls = session.controlsVisible,
+                modifier = Modifier.align(Alignment.TopEnd).width(CHAT_WIDTH).fillMaxHeight(),
+            )
+        }
+        OpeningPoster(video, opening)
+        val current = video
+        if (current != null) {
+            PlayerControlsLayer(
+                video = current,
+                handle = handle,
+                state = state,
+                session = session,
+                choices = choices,
+                preferences = playerPreferences(
+                    handle, heights, qualityCap, preferences.maxHeight, captionIndex,
+                    commentsAvailable = bulletComments.isNotEmpty() || chatAvailable,
+                    commentsOn = if (chatAvailable) choices.chatOn else commentsOn,
+                    commentsAreChat = chatAvailable,
+                    commentsPanelAvailable = !current.isLive,
+                ),
+                onToggleComments = { if (chatAvailable) choices.chatOn = !choices.chatOn else commentsOn = !commentsOn },
+                queue = queue,
+                onOpenNext = onOpenNext,
+                setup = setup,
+                seek = seek,
+                play = play,
             )
         }
         SponsorSkipNotice(
@@ -234,30 +227,27 @@ fun PlayerContent(
             onPlayNow = { next?.let(onOpenNext) },
             modifier = Modifier.align(Alignment.BottomEnd),
         )
-        AnimatedVisibility(
+        EndedOverlay(
             visible = state.isEnded && !autoAdvance,
-            enter = fadeIn(),
-            exit = fadeOut(),
-            modifier = Modifier
-                .align(Alignment.BottomEnd)
-                .padding(end = Dimens.SafeEnd, bottom = Dimens.SafeBottom + 6.dp),
-        ) {
-            UpNextPanel(
-                next = next,
-                onPlayNext = { next?.let(onOpenNext) },
-                onReplay = {
-                    player.seekTo(0L)
-                    player.play()
-                },
-            )
-        }
+            next = next,
+            onPlayNext = { next?.let(onOpenNext) },
+            onReplay = {
+                player.seekTo(0L)
+                player.play()
+            },
+            liveEnded = handle.isLive,
+            modifier = Modifier.align(Alignment.BottomEnd),
+        )
         if (current != null) {
             PlayerPanelHost(
                 panel = session.panel,
                 onPanel = {
+                    if (session.panel == PlayerPanel.Menu) session.panelFromMenu = true
+                    if (it == null) session.menuEntry = null
                     session.panel = it
                     if (it == null) session.controlsVisible = true
                 },
+                openedFromMenu = session.panelFromMenu,
                 scene = PanelScene(
                     video = current,
                     queue = queue,
@@ -275,7 +265,10 @@ fun PlayerContent(
                     },
                     onSeek = { player.seekTo(it) },
                     onOpenVideo = onOpenNext,
-                    qualityHeights = handle.heights,
+                    onOpenChannel = onOpenChannel,
+                    menuEntry = session.menuEntry,
+                    onMenuEntry = { session.menuEntry = it },
+                    qualityHeights = heights,
                     qualitySelected = qualityCap ?: preferences.maxHeight,
                     playingHeight = player.videoSize.height.takeIf { it > 0 },
                     audioTracks = handle.audioTracks,
diff --git a/app/src/main/java/video/typetype/tv/ui/player/PlayerControls.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerControls.kt
similarity index 62%
rename from app/src/main/java/video/typetype/tv/ui/player/PlayerControls.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/PlayerControls.kt
index 5e888b9..ee987fa 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/PlayerControls.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerControls.kt
@@ -12,22 +12,14 @@ import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.width
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.rounded.ClosedCaption
-import androidx.compose.material.icons.rounded.ClosedCaptionOff
-import androidx.compose.material.icons.rounded.Forum
 import androidx.compose.material.icons.rounded.Forward10
-import androidx.compose.material.icons.rounded.Language
-import androidx.compose.material.icons.rounded.MoreHoriz
-import androidx.compose.material.icons.rounded.HighQuality
 import androidx.compose.material.icons.rounded.Pause
 import androidx.compose.material.icons.rounded.PlayArrow
 import androidx.compose.material.icons.rounded.Replay10
 import androidx.compose.material.icons.rounded.SkipNext
 import androidx.compose.material.icons.rounded.SkipPrevious
-import androidx.compose.material.icons.rounded.Speed
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.derivedStateOf
-import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
 import video.typetype.tv.data.Chapter
 import video.typetype.tv.data.SponsorSegment
@@ -35,12 +27,18 @@ import video.typetype.tv.data.Storyboard
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusProperties
 import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.input.key.KeyEventType
+import androidx.compose.ui.input.key.key
+import androidx.compose.ui.input.key.onPreviewKeyEvent
+import androidx.compose.ui.input.key.type
 import androidx.compose.ui.graphics.Brush
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.Video
 import video.typetype.tv.theme.Dimens
 import video.typetype.tv.theme.Palette
@@ -48,8 +46,12 @@ import video.typetype.tv.theme.Type
 import video.typetype.tv.ui.components.CircleButton
 import video.typetype.tv.ui.components.PillButton
 import video.typetype.tv.ui.components.QualityBadge
+import video.typetype.tv.ui.components.ServiceBadge
 import video.typetype.tv.ui.components.TextLabel
 import video.typetype.tv.ui.util.formatMillis
+import video.typetype.tv.ui.components.LiveBadge
+import video.typetype.tv.ui.util.metaLine
+import androidx.compose.runtime.getValue
 
 data class PlayerControlActions(
     val onTogglePlay: () -> Unit,
@@ -58,12 +60,22 @@ data class PlayerControlActions(
     val onNext: () -> Unit,
     val onToggleCaptions: () -> Unit,
     val onOpenQuality: () -> Unit,
-    val onCycleSpeed: () -> Unit,
     val onGoLive: () -> Unit = {},
     val onToggleComments: () -> Unit = {},
     val onOpenAudio: () -> Unit = {},
     val onOpenMenu: () -> Unit = {},
-    val onScrubBy: (Long) -> Unit = {},
+    val onScrub: (direction: Int, repeatCount: Int) -> Unit = { _, _ -> },
+    val onOpenComments: () -> Unit = {},
+    val onShowChannel: () -> Unit = {},
+    val onOpenDescription: () -> Unit = {},
+)
+
+class RelatedVideos(
+    val videos: List<Video> = emptyList(),
+    val open: Boolean = false,
+    val onOpenChange: (Boolean) -> Unit = {},
+    val onPlay: (Video) -> Unit = {},
+    val onChapter: (Chapter) -> Unit = {},
 )
 
 data class PlayerPreferences(
@@ -72,10 +84,11 @@ data class PlayerPreferences(
     val captionLabel: String,
     val qualityAvailable: Boolean,
     val qualityLabel: String,
-    val speedLabel: String,
     val commentsAvailable: Boolean = false,
     val commentsOn: Boolean = false,
+    val commentsAreChat: Boolean = false,
     val audioLabel: String? = null,
+    val commentsPanelAvailable: Boolean = false,
 )
 
 @Composable
@@ -86,9 +99,12 @@ fun PlayerControls(
     actions: PlayerControlActions,
     seekRequester: FocusRequester,
     modifier: Modifier = Modifier,
+    playRequester: FocusRequester = remember { FocusRequester() },
     sponsorSegments: List<SponsorSegment> = emptyList(),
     scrubMillis: Long? = null,
     storyboard: Storyboard? = null,
+    related: RelatedVideos = RelatedVideos(),
+    originFocus: Map<ControlOrigin, FocusRequester> = remember { ControlOrigin.entries.associateWith { FocusRequester() } },
 ) {
     val markers = remember(video.chapters, sponsorSegments, state.durationMillis) {
         SeekMarkers.build(video.chapters, sponsorSegments, state.durationMillis)
@@ -104,7 +120,7 @@ fun PlayerControls(
         Box(
             Modifier
                 .fillMaxWidth()
-                .height(230.dp)
+                .height(if (related.open) 470.dp else 230.dp)
                 .align(Alignment.BottomCenter)
                 .background(Brush.verticalGradient(listOf(Color.Transparent, Palette.Ink.copy(alpha = 0.92f)))),
         )
@@ -112,20 +128,33 @@ fun PlayerControls(
             derivedStateOf { SeekMarkers.currentChapter(video.chapters, state.positionMillis)?.title }
         }
         TitleBlock(video, chapter, Modifier.align(Alignment.TopStart))
-        Column(
-            modifier = Modifier
-                .align(Alignment.BottomCenter)
-                .padding(start = Dimens.SafeStart, end = Dimens.SafeEnd, bottom = Dimens.SafeBottom + 6.dp),
-        ) {
-            TimeLine(state, actions, seekRequester, markers, scrubMillis, storyboard, video.chapters)
-            Spacer(Modifier.height(10.dp))
-            Row(
-                modifier = Modifier.fillMaxWidth(),
-                horizontalArrangement = Arrangement.SpaceBetween,
-                verticalAlignment = Alignment.CenterVertically,
-            ) {
-                TransportRow(state, actions)
-                PreferenceRow(preferences, actions, Modifier.weight(1f, fill = false))
+        Column(Modifier.align(Alignment.BottomCenter).padding(bottom = Dimens.SafeBottom + 6.dp)) {
+            Column(Modifier.padding(start = Dimens.SafeStart, end = Dimens.SafeEnd)) {
+                TimeLine(state, actions, seekRequester, playRequester, markers, scrubMillis, storyboard, video.chapters)
+                Spacer(Modifier.height(10.dp))
+                Row(
+                    modifier = Modifier.fillMaxWidth().onPreviewKeyEvent { event ->
+                        val opens = event.key == Key.DirectionDown && (related.videos.isNotEmpty() || video.chapters.isNotEmpty())
+                        if (opens && event.type == KeyEventType.KeyDown) related.onOpenChange(true)
+                        opens
+                    },
+                    horizontalArrangement = Arrangement.SpaceBetween,
+                    verticalAlignment = Alignment.CenterVertically,
+                ) {
+                    TransportRow(state, actions, playRequester)
+                    PreferenceRow(preferences, actions, video.channel.takeIf { it.url.isNotBlank() }, originFocus, Modifier.weight(1f, fill = false))
+                }
+            }
+            if (related.open) {
+                Spacer(Modifier.height(22.dp))
+                RelatedShelf(
+                    videos = related.videos,
+                    chapters = video.chapters,
+                    currentChapter = remember(video.chapters) { ChapterPosition.currentIndex(state.positionMillis, video.chapters) },
+                    onChapter = related.onChapter,
+                    onOpen = related.onPlay,
+                    onClose = { related.onOpenChange(false) },
+                )
             }
         }
     }
@@ -135,8 +164,10 @@ fun PlayerControls(
 private fun TitleBlock(video: Video, chapter: String?, modifier: Modifier = Modifier) {
     Column(modifier.padding(start = Dimens.SafeStart, top = Dimens.SafeTop + 8.dp, end = 160.dp)) {
         Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(10.dp)) {
+            video.source?.let { ServiceBadge(it) }
+            if (video.isLive) LiveBadge(stringResource(R.string.badge_live))
             if (video.quality.isNotBlank()) QualityBadge(video.quality)
-            TextLabel(video.channel.name.uppercase(), Type.Label, maxLines = 1)
+            TextLabel(metaLine(video.channel.name.uppercase(), video.views.takeIf { video.isLive }), Type.Label, maxLines = 1)
         }
         Spacer(Modifier.height(6.dp))
         TextLabel(video.title, Type.Headline, maxLines = 1)
@@ -152,6 +183,7 @@ private fun TimeLine(
     state: PlayerUiState,
     actions: PlayerControlActions,
     seekRequester: FocusRequester,
+    playRequester: FocusRequester,
     markers: List<SeekMarker>,
     scrubMillis: Long?,
     storyboard: Storyboard?,
@@ -168,13 +200,17 @@ private fun TimeLine(
             positionMillis = { state.positionMillis },
             bufferedMillis = { state.bufferedMillis },
             durationMillis = state.durationMillis,
-            onScrubBy = actions.onScrubBy,
+            onScrub = actions.onScrub,
             onTogglePlay = actions.onTogglePlay,
-            modifier = Modifier.weight(1f).focusRequester(seekRequester),
+            modifier = Modifier
+                .weight(1f)
+                .focusRequester(seekRequester)
+                .focusProperties { down = playRequester },
             markers = markers,
             scrubMillis = scrubMillis,
             storyboard = storyboard,
             chapters = chapters,
+            positionLabel = if (state.isLive) liveLabel(state.durationMillis) else ::formatMillis,
         )
         if (state.isLive) {
             TextLabel(stringResource(R.string.player_live), Type.Label.copy(color = Palette.Accent), Modifier.width(48.dp))
@@ -185,26 +221,33 @@ private fun TimeLine(
 }
 
 @Composable
-private fun TransportRow(state: PlayerUiState, actions: PlayerControlActions) {
+private fun TransportRow(state: PlayerUiState, actions: PlayerControlActions, playRequester: FocusRequester) {
     Row(horizontalArrangement = Arrangement.spacedBy(10.dp), verticalAlignment = Alignment.CenterVertically) {
-        CircleButton(
-            Icons.Rounded.SkipPrevious, stringResource(R.string.player_previous), actions.onPrevious,
-        )
+        // A live stream has no start worth jumping to: the window behind the edge only lasts a few hours.
+        if (!state.isLive) {
+            CircleButton(
+                Icons.Rounded.SkipPrevious, stringResource(R.string.player_previous), actions.onPrevious, labelOnFocus = true,
+            )
+        }
         CircleButton(
             Icons.Rounded.Replay10, stringResource(R.string.player_rewind), { actions.onSeekBy(-SeekMath.JUMP_MILLIS) },
+            labelOnFocus = true,
         )
         CircleButton(
             icon = if (state.isPlaying) Icons.Rounded.Pause else Icons.Rounded.PlayArrow,
             description = stringResource(if (state.isPlaying) R.string.player_pause else R.string.player_play),
             onClick = actions.onTogglePlay,
+            modifier = Modifier.focusRequester(playRequester),
             diameter = 54,
             emphasized = true,
+            labelOnFocus = true,
         )
         CircleButton(
             Icons.Rounded.Forward10, stringResource(R.string.player_forward), { actions.onSeekBy(SeekMath.JUMP_MILLIS) },
+            labelOnFocus = true,
         )
         CircleButton(
-            Icons.Rounded.SkipNext, stringResource(R.string.player_next), actions.onNext,
+            Icons.Rounded.SkipNext, stringResource(R.string.player_next), actions.onNext, labelOnFocus = true,
         )
         if (state.isLive) {
             PillButton(label = stringResource(R.string.player_go_live), onClick = actions.onGoLive, emphasized = true)
@@ -212,67 +255,12 @@ private fun TransportRow(state: PlayerUiState, actions: PlayerControlActions) {
     }
 }
 
+
+// On a live stream the bubble says how far behind the edge the thumb is, like the elapsed label.
 @Composable
-private fun PreferenceRow(preferences: PlayerPreferences, actions: PlayerControlActions, modifier: Modifier = Modifier) {
-    Row(
-        modifier = modifier,
-        horizontalArrangement = Arrangement.spacedBy(8.dp, Alignment.End),
-        verticalAlignment = Alignment.CenterVertically,
-    ) {
-        if (preferences.captionsAvailable) {
-            PillButton(
-                compact = true,
-                label = if (preferences.captionsOn) preferences.captionLabel else stringResource(R.string.player_captions),
-                icon = if (preferences.captionsOn) Icons.Rounded.ClosedCaption else Icons.Rounded.ClosedCaptionOff,
-                onClick = actions.onToggleCaptions,
-                emphasized = preferences.captionsOn,
-                description = if (preferences.captionsOn) {
-                    stringResource(R.string.player_captions_on_description, preferences.captionLabel)
-                } else {
-                    stringResource(R.string.player_captions_off_description)
-                },
-            )
-        }
-        preferences.audioLabel?.let { label ->
-            PillButton(
-                compact = true,
-                label = label,
-                icon = Icons.Rounded.Language,
-                onClick = actions.onOpenAudio,
-                description = stringResource(R.string.player_audio_description, label),
-                maxLabelWidth = AUDIO_LABEL_MAX_WIDTH,
-            )
-        }
-        if (preferences.commentsAvailable) {
-            PillButton(
-                compact = true,
-                label = stringResource(R.string.player_comments),
-                icon = Icons.Rounded.Forum,
-                onClick = actions.onToggleComments,
-                emphasized = preferences.commentsOn,
-                description = stringResource(
-                    if (preferences.commentsOn) R.string.player_comments_on_description else R.string.player_comments_off_description,
-                ),
-            )
-        }
-        if (preferences.qualityAvailable) {
-            PillButton(
-                compact = true,
-                label = preferences.qualityLabel,
-                icon = Icons.Rounded.HighQuality,
-                onClick = actions.onOpenQuality,
-                description = stringResource(R.string.player_quality_description, preferences.qualityLabel),
-            )
-        }
-        PillButton(
-            compact = true,
-            label = preferences.speedLabel,
-            icon = Icons.Rounded.Speed,
-            onClick = actions.onCycleSpeed,
-            description = stringResource(R.string.player_speed_description, preferences.speedLabel),
-        )
-        CircleButton(Icons.Rounded.MoreHoriz, stringResource(R.string.player_more_description), actions.onOpenMenu)
+private fun liveLabel(windowMillis: Long): (Long) -> String {
+    val atEdge = stringResource(R.string.player_live)
+    return remember(windowMillis, atEdge) {
+        { position -> LiveEdge.label((windowMillis - position).coerceAtLeast(0L)) ?: atEdge }
     }
 }
-
-private val AUDIO_LABEL_MAX_WIDTH = 150.dp
diff --git a/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerControlsLayer.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerControlsLayer.kt
new file mode 100644
index 0000000..5650bf9
--- /dev/null
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerControlsLayer.kt
@@ -0,0 +1,73 @@
+package video.typetype.tv.ui.player
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.focus.FocusRequester
+import video.typetype.tv.data.PlaybackSetup
+import video.typetype.tv.data.Video
+import video.typetype.tv.playback.PlayerHandle
+import video.typetype.tv.ui.components.FadeVisibility
+
+// The controls over the picture, wired to the session: every panel they open remembers which control opened it.
+@Composable
+internal fun PlayerControlsLayer(
+    video: Video,
+    handle: PlayerHandle,
+    state: PlayerUiState,
+    session: PlayerSession,
+    choices: PlayerChoices,
+    preferences: PlayerPreferences,
+    onToggleComments: () -> Unit,
+    queue: List<Video>,
+    onOpenNext: (Video) -> Unit,
+    setup: PlaybackSetup,
+    seek: FocusRequester,
+    play: FocusRequester,
+) {
+    val player = handle.player
+    val next = queue.firstOrNull()
+    FadeVisibility(visible = session.controlsVisible) {
+        PlayerControls(
+            video = video,
+            state = state,
+            preferences = preferences,
+            actions = PlayerControlActions(
+                onTogglePlay = session::togglePlay,
+                onSeekBy = session::seekBy,
+                onPrevious = { player.seekTo(0L) },
+                onNext = { next?.let(onOpenNext) },
+                onToggleCaptions = { choices.captionIndex = (choices.captionIndex + 1) % (handle.captionLanguages.size + 1) },
+                onOpenQuality = { session.openPanel(PlayerPanel.Quality, fromMenu = false, from = ControlOrigin.Quality) },
+                onToggleComments = onToggleComments,
+                onOpenAudio = { session.openPanel(PlayerPanel.Audio, fromMenu = false, from = ControlOrigin.Audio) },
+                onOpenMenu = { session.openPanel(PlayerPanel.Menu, fromMenu = true, from = ControlOrigin.Menu) },
+                onScrub = session::scrub,
+                onOpenComments = { session.openPanel(PlayerPanel.Comments, fromMenu = false, from = ControlOrigin.Comments) },
+                onShowChannel = { session.openPanel(PlayerPanel.Channel, fromMenu = false, from = ControlOrigin.Channel) },
+                onOpenDescription = { session.openPanel(PlayerPanel.Info, fromMenu = false, from = ControlOrigin.Description) },
+                onGoLive = {
+                    player.seekToDefaultPosition()
+                    player.play()
+                },
+            ),
+            seekRequester = seek,
+            playRequester = play,
+            related = RelatedVideos(
+                videos = queue,
+                open = session.relatedOpen,
+                onOpenChange = { open ->
+                    session.relatedOpen = open
+                    if (!open) session.controlsFromBelow = true
+                },
+                onPlay = onOpenNext,
+                onChapter = { chapter ->
+                    player.seekTo(ChapterPosition.startMillis(chapter))
+                    session.relatedOpen = false
+                },
+            ),
+            sponsorSegments = setup.sponsorSegments,
+            scrubMillis = session.scrub.target,
+            storyboard = setup.storyboard,
+            originFocus = session.originFocus,
+        )
+    }
+}
diff --git a/app/src/main/java/video/typetype/tv/ui/player/PlayerEffects.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerEffects.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/player/PlayerEffects.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/PlayerEffects.kt
diff --git a/app/src/main/java/video/typetype/tv/ui/player/PlayerFailure.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerFailure.kt
similarity index 94%
rename from app/src/main/java/video/typetype/tv/ui/player/PlayerFailure.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/PlayerFailure.kt
index 5e0730b..cb5833d 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/PlayerFailure.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerFailure.kt
@@ -17,11 +17,11 @@ import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.net.ApiException
 import video.typetype.tv.theme.Type
-import video.typetype.tv.ui.auth.MessageText
-import video.typetype.tv.ui.auth.UiMessage
+import video.typetype.tv.ui.components.MessageText
+import video.typetype.tv.ui.util.UiMessage
 import video.typetype.tv.ui.components.PillButton
 import video.typetype.tv.ui.components.TextLabel
 import video.typetype.tv.ui.util.requestFocusWhenReady
diff --git a/app/src/main/java/video/typetype/tv/ui/player/PlayerOptions.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerOptions.kt
similarity index 83%
rename from app/src/main/java/video/typetype/tv/ui/player/PlayerOptions.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/PlayerOptions.kt
index 7b5d20f..7afdc93 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/PlayerOptions.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerOptions.kt
@@ -22,28 +22,32 @@ internal fun nearestSpeedIndex(speed: Float): Int =
 
 internal fun playerPreferences(
     handle: PlayerHandle,
+    heights: List<Int>,
     qualityCap: Int?,
     defaultCap: Int?,
     captionIndex: Int,
-    speedIndex: Int,
     commentsAvailable: Boolean,
     commentsOn: Boolean,
+    commentsAreChat: Boolean = false,
+    commentsPanelAvailable: Boolean = false,
 ): PlayerPreferences {
     val effective = qualityCap ?: defaultCap
-    val speed = SPEED_CHOICES[speedIndex]
     return PlayerPreferences(
         captionsAvailable = handle.captionLanguages.isNotEmpty(),
         captionsOn = captionIndex > 0,
         captionLabel = handle.captionLanguages.getOrNull(captionIndex - 1)?.label.orEmpty(),
-        qualityAvailable = handle.heights.size > 1,
-        qualityLabel = effective?.takeIf { it in handle.heights }?.let { "${it}p" } ?: "Auto",
-        speedLabel = "${speed}x".replace(".0x", "x"),
+        qualityAvailable = heights.size > 1,
+        qualityLabel = effective?.takeIf { it in heights }?.let { "${it}p" } ?: "Auto",
         commentsAvailable = commentsAvailable,
         commentsOn = commentsOn,
+        commentsAreChat = commentsAreChat,
         audioLabel = audioLabel(handle.audioTracks, handle.audioTrackId),
+        commentsPanelAvailable = commentsPanelAvailable,
     )
 }
 
+internal fun speedLabel(speedIndex: Int): String = "${SPEED_CHOICES[speedIndex]}x".replace(".0x", "x")
+
 internal val SPEED_CHOICES = listOf(0.75f, 1f, 1.25f, 1.5f, 2f)
 
 @Stable
@@ -52,6 +56,7 @@ class PlayerChoices {
     var speedIndex by mutableIntStateOf(UNSET)
     var audioOnly by mutableStateOf(false)
     var statsOn by mutableStateOf(false)
+    var chatOn by mutableStateOf(true)
 
     fun initialize(handle: PlayerHandle, preferences: PlaybackPreferences) {
         if (captionIndex == UNSET) captionIndex = initialCaptionIndex(handle, preferences)
diff --git a/app/src/main/java/video/typetype/tv/ui/player/PlayerOverlays.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerOverlays.kt
similarity index 98%
rename from app/src/main/java/video/typetype/tv/ui/player/PlayerOverlays.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/PlayerOverlays.kt
index 6dc60a5..6428375 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/PlayerOverlays.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerOverlays.kt
@@ -23,7 +23,7 @@ import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.contentDescription
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.unit.dp
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.theme.Palette
 
 @Composable
diff --git a/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerPanel.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerPanel.kt
new file mode 100644
index 0000000..e89a5b9
--- /dev/null
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerPanel.kt
@@ -0,0 +1,6 @@
+package video.typetype.tv.ui.player
+
+enum class PlayerPanel { Menu, Chapters, Info, Comments, Queue, Quality, Audio, CaptionStyle, Playlists, Channel }
+
+// The controls that open a panel: closing the panel gives the focus back to the one that opened it.
+enum class ControlOrigin { Quality, Audio, Comments, Channel, Description, Menu }
diff --git a/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerPreferenceRow.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerPreferenceRow.kt
new file mode 100644
index 0000000..13fb4a4
--- /dev/null
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerPreferenceRow.kt
@@ -0,0 +1,186 @@
+package video.typetype.tv.ui.player
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.BoxWithConstraints
+import androidx.compose.foundation.layout.Row
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.rounded.ChatBubbleOutline
+import androidx.compose.material.icons.rounded.ClosedCaption
+import androidx.compose.material.icons.rounded.ClosedCaptionOff
+import androidx.compose.material.icons.rounded.Forum
+import androidx.compose.material.icons.rounded.HighQuality
+import androidx.compose.material.icons.rounded.Info
+import androidx.compose.material.icons.rounded.Language
+import androidx.compose.material.icons.rounded.MoreHoriz
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.rememberTextMeasurer
+import androidx.compose.ui.unit.dp
+import video.typetype.tv.data.Channel
+import video.typetype.tv.resources.R
+import video.typetype.tv.theme.Type
+import video.typetype.tv.ui.components.AvatarButton
+import video.typetype.tv.ui.components.CircleButton
+import video.typetype.tv.ui.components.PillButton
+
+@Composable
+internal fun PreferenceRow(
+    preferences: PlayerPreferences,
+    actions: PlayerControlActions,
+    channel: Channel?,
+    originFocus: Map<ControlOrigin, FocusRequester>,
+    modifier: Modifier = Modifier,
+) {
+    fun opens(origin: ControlOrigin) = Modifier.focusRequester(originFocus.getValue(origin))
+    val captionsLabel = if (preferences.captionsOn) preferences.captionLabel else stringResource(R.string.player_captions)
+    val toggleLabel = stringResource(if (preferences.commentsAreChat) R.string.player_chat else R.string.player_comments)
+    val commentsLabel = stringResource(R.string.menu_comments)
+    val labels = listOfNotNull(
+        captionsLabel.takeIf { preferences.captionsAvailable },
+        preferences.audioLabel,
+        toggleLabel.takeIf { preferences.commentsAvailable },
+        preferences.qualityLabel.takeIf { preferences.qualityAvailable },
+        commentsLabel.takeIf { preferences.commentsPanelAvailable },
+    )
+    val circles = if (channel != null) 3 else 2
+    val measurer = rememberTextMeasurer()
+    val density = LocalDensity.current
+    BoxWithConstraints(modifier, contentAlignment = Alignment.CenterEnd) {
+        // With long labels the row would run into the playback buttons: the choices then show as round buttons that
+        // name their value when focused. The comments button keeps its label.
+        val compact = remember(labels, circles, maxWidth) {
+            val widths = labels.map { label -> with(density) { measurer.measure(label, Type.Button).size.width.toDp() }.value }
+            RowFit.overflows(widths, circles, maxWidth.value)
+        }
+        Row(
+            horizontalArrangement = Arrangement.spacedBy(RowFit.GAP_DP.dp, Alignment.End),
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            if (preferences.captionsAvailable) {
+                ChoiceButton(
+                    compact = compact,
+                    label = captionsLabel,
+                    icon = if (preferences.captionsOn) Icons.Rounded.ClosedCaption else Icons.Rounded.ClosedCaptionOff,
+                    onClick = actions.onToggleCaptions,
+                    emphasized = preferences.captionsOn,
+                    description = if (preferences.captionsOn) {
+                        stringResource(R.string.player_captions_on_description, preferences.captionLabel)
+                    } else {
+                        stringResource(R.string.player_captions_off_description)
+                    },
+                )
+            }
+            preferences.audioLabel?.let { label ->
+                ChoiceButton(
+                    compact = compact,
+                    label = label,
+                    icon = Icons.Rounded.Language,
+                    onClick = actions.onOpenAudio,
+                    modifier = opens(ControlOrigin.Audio),
+                    description = stringResource(R.string.player_audio_description, label),
+                )
+            }
+            if (preferences.commentsAvailable) {
+                ChoiceButton(
+                    compact = compact,
+                    label = toggleLabel,
+                    icon = Icons.Rounded.Forum,
+                    onClick = actions.onToggleComments,
+                    emphasized = preferences.commentsOn,
+                    description = stringResource(commentsDescription(preferences)),
+                )
+            }
+            if (preferences.qualityAvailable) {
+                ChoiceButton(
+                    compact = compact,
+                    label = preferences.qualityLabel,
+                    icon = Icons.Rounded.HighQuality,
+                    onClick = actions.onOpenQuality,
+                    modifier = opens(ControlOrigin.Quality),
+                    description = stringResource(R.string.player_quality_description, preferences.qualityLabel),
+                )
+            }
+            if (preferences.commentsPanelAvailable) {
+                PillButton(
+                    compact = true,
+                    label = commentsLabel,
+                    icon = Icons.Rounded.ChatBubbleOutline,
+                    onClick = actions.onOpenComments,
+                    modifier = opens(ControlOrigin.Comments),
+                    description = stringResource(R.string.player_open_comments_description),
+                )
+            }
+            if (channel != null) {
+                AvatarButton(
+                    imageUrl = channel.avatarUrl,
+                    name = channel.name,
+                    description = stringResource(R.string.player_open_channel_description, channel.name),
+                    onClick = actions.onShowChannel,
+                    modifier = opens(ControlOrigin.Channel),
+                )
+            }
+            CircleButton(
+                Icons.Rounded.Info, stringResource(R.string.menu_description), actions.onOpenDescription,
+                modifier = opens(ControlOrigin.Description), labelOnFocus = true,
+            )
+            CircleButton(
+                Icons.Rounded.MoreHoriz, stringResource(R.string.player_more_description), actions.onOpenMenu,
+                modifier = opens(ControlOrigin.Menu), labelOnFocus = true,
+            )
+        }
+    }
+}
+
+// The width the row needs with every choice labelled, from the measured labels, against the room it has.
+internal object RowFit {
+    const val GAP_DP = 8f
+    const val LABEL_MAX_DP = 150f
+    private const val PILL_CHROME_DP = 56f
+    private const val CIRCLE_DP = 44f
+
+    fun overflows(labelWidthsDp: List<Float>, circles: Int, availableDp: Float): Boolean {
+        val pills = labelWidthsDp.sumOf { (minOf(it, LABEL_MAX_DP) + PILL_CHROME_DP).toDouble() }
+        val gaps = (labelWidthsDp.size + circles - 1).coerceAtLeast(0) * GAP_DP
+        return pills + circles * CIRCLE_DP + gaps > availableDp
+    }
+}
+
+@Composable
+private fun ChoiceButton(
+    compact: Boolean,
+    label: String,
+    icon: ImageVector,
+    onClick: () -> Unit,
+    description: String,
+    modifier: Modifier = Modifier,
+    emphasized: Boolean = false,
+) {
+    if (compact) {
+        CircleButton(icon, description, onClick, modifier, emphasized = emphasized, labelOnFocus = true)
+    } else {
+        PillButton(
+            compact = true,
+            label = label,
+            icon = icon,
+            onClick = onClick,
+            modifier = modifier,
+            emphasized = emphasized,
+            description = description,
+            maxLabelWidth = RowFit.LABEL_MAX_DP.dp,
+        )
+    }
+}
+
+private fun commentsDescription(preferences: PlayerPreferences): Int = when {
+    preferences.commentsAreChat && preferences.commentsOn -> R.string.player_chat_on_description
+    preferences.commentsAreChat -> R.string.player_chat_off_description
+    preferences.commentsOn -> R.string.player_comments_on_description
+    else -> R.string.player_comments_off_description
+}
diff --git a/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerRemoteKeys.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerRemoteKeys.kt
new file mode 100644
index 0000000..910c8e1
--- /dev/null
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerRemoteKeys.kt
@@ -0,0 +1,60 @@
+package video.typetype.tv.ui.player
+
+import android.view.KeyEvent as AndroidKeyEvent
+import androidx.compose.ui.input.key.KeyEvent
+import androidx.compose.ui.input.key.KeyEventType
+import androidx.compose.ui.input.key.type
+import androidx.media3.common.Player
+
+class RemoteKeyActions(
+    val play: () -> Unit,
+    val pause: () -> Unit,
+    val next: () -> Unit,
+    val startOver: () -> Unit,
+    val toggleCaptions: () -> Unit,
+    val openPanel: (PlayerPanel) -> Unit,
+    val seekToFraction: (Float) -> Unit,
+)
+
+internal fun remoteKeyActions(
+    player: Player,
+    state: PlayerUiState,
+    session: PlayerSession,
+    choices: PlayerChoices,
+    captionCount: Int,
+    playNext: () -> Unit,
+) = RemoteKeyActions(
+    play = player::play,
+    pause = player::pause,
+    next = playNext,
+    startOver = { player.seekTo(0L) },
+    toggleCaptions = { choices.captionIndex = (choices.captionIndex + 1) % (captionCount + 1) },
+    openPanel = { session.openPanel(it, fromMenu = it == PlayerPanel.Menu) },
+    seekToFraction = { fraction ->
+        if (!state.isLive && state.durationMillis > 0) {
+            player.seekTo((state.durationMillis * fraction).toLong())
+            session.showControls()
+        }
+    },
+)
+
+// The dedicated keys many remotes carry: they reach their target in one press wherever the focus is.
+fun handleRemoteKey(event: KeyEvent, panelOpen: Boolean, actions: RemoteKeyActions): Boolean {
+    if (panelOpen || event.type != KeyEventType.KeyDown) return false
+    when (event.nativeKeyEvent.keyCode) {
+        AndroidKeyEvent.KEYCODE_MEDIA_PLAY -> actions.play()
+        AndroidKeyEvent.KEYCODE_MEDIA_PAUSE -> actions.pause()
+        AndroidKeyEvent.KEYCODE_MEDIA_NEXT -> actions.next()
+        AndroidKeyEvent.KEYCODE_MEDIA_PREVIOUS -> actions.startOver()
+        AndroidKeyEvent.KEYCODE_CAPTIONS -> actions.toggleCaptions()
+        AndroidKeyEvent.KEYCODE_MENU -> actions.openPanel(PlayerPanel.Menu)
+        AndroidKeyEvent.KEYCODE_INFO -> actions.openPanel(PlayerPanel.Info)
+        // As on YouTube: 0 to 9 jump to 0 % to 90 % of the video.
+        in AndroidKeyEvent.KEYCODE_0..AndroidKeyEvent.KEYCODE_9 ->
+            actions.seekToFraction((event.nativeKeyEvent.keyCode - AndroidKeyEvent.KEYCODE_0) / DIGITS)
+        else -> return false
+    }
+    return true
+}
+
+private const val DIGITS = 10f
diff --git a/app/src/main/java/video/typetype/tv/ui/player/PlayerScreen.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerScreen.kt
similarity index 65%
rename from app/src/main/java/video/typetype/tv/ui/player/PlayerScreen.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/PlayerScreen.kt
index 0f4b834..bff015f 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/PlayerScreen.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerScreen.kt
@@ -1,8 +1,5 @@
 package video.typetype.tv.ui.player
 
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.LaunchedEffect
@@ -11,9 +8,7 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.LocalContext
 import video.typetype.tv.data.BulletComment
 import video.typetype.tv.data.ContentRepository
@@ -30,7 +25,9 @@ fun PlayerScreen(
     connectivity: Connectivity,
     onOpenNext: (Video) -> Unit,
     modifier: Modifier = Modifier,
+    onOpenChannel: (String) -> Unit = {},
     startWithControls: Boolean = true,
+    preview: Video? = null,
 ) {
     val context = LocalContext.current.applicationContext
     val scope = rememberCoroutineScope()
@@ -45,26 +42,28 @@ fun PlayerScreen(
     LaunchedEffect(videoId) { comments = tryLoad({}) { repository.bulletComments(videoId) }.orEmpty() }
     DisposableEffect(controller) { onDispose { controller.release() } }
     when (val phase = controller.phase) {
-        is PlaybackPhase.Playing -> PlayerContent(
-            handle = phase.handle,
-            video = controller.video,
-            queue = queue,
-            startWithControls = startWithControls,
-            setup = controller.setup,
-            qualityCap = controller.qualityCap,
-            choices = choices,
-            bulletComments = comments,
-            repository = repository,
-            onQualityChange = controller::setQuality,
-            onAudioChange = controller::setAudioTrack,
-            onPlayerError = { error -> controller.onPlayerError(phase.handle, error) },
-            onOpenNext = onOpenNext,
-            modifier = modifier,
-        )
+        is PlaybackPhase.Playing -> {
+            FrameDropWatch(phase.handle.player) { controller.framesStruggling(phase.handle) }
+            PlayerContent(
+                handle = phase.handle,
+                video = controller.video ?: preview,
+                queue = queue,
+                startWithControls = startWithControls,
+                setup = controller.setup,
+                qualityCap = controller.qualityCap,
+                choices = choices,
+                bulletComments = comments,
+                repository = repository,
+                onQualityChange = controller::setQuality,
+                onAudioChange = controller::setAudioTrack,
+                onPlayerError = { error -> controller.onPlayerError(phase.handle, error) },
+                onOpenNext = onOpenNext,
+                modifier = modifier,
+                onOpenChannel = onOpenChannel,
+            )
+        }
         is PlaybackPhase.Reconnecting -> ReconnectingPanel(phase.attempt, phase.offline, modifier)
         is PlaybackPhase.Failed -> PlayerFailure(phase.message, onRetry = controller::retry, modifier = modifier)
-        PlaybackPhase.Opening -> Box(modifier.fillMaxSize().background(Color.Black)) {
-            BufferingSpinner(true, Modifier.align(Alignment.Center))
-        }
+        PlaybackPhase.Opening -> OpeningPoster(controller.video ?: preview, visible = true, modifier = modifier)
     }
 }
diff --git a/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerSession.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerSession.kt
new file mode 100644
index 0000000..bfeb80d
--- /dev/null
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerSession.kt
@@ -0,0 +1,131 @@
+package video.typetype.tv.ui.player
+
+import android.os.SystemClock
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableLongStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.input.key.KeyEvent
+import androidx.compose.ui.input.key.KeyEventType
+import androidx.compose.ui.input.key.key
+import androidx.compose.ui.input.key.type
+import androidx.media3.common.Player
+
+@Stable
+class PlayerSession(
+    private val player: Player,
+    private val state: PlayerUiState,
+    startWithControls: Boolean = true,
+) {
+    var controlsVisible by mutableStateOf(startWithControls)
+    var interaction by mutableLongStateOf(0L)
+    var panel by mutableStateOf<PlayerPanel?>(null)
+    var relatedOpen by mutableStateOf(false)
+    var panelFromMenu by mutableStateOf(true)
+
+    // Where the focus goes back once the panels close, and the options row last chosen, so coming back from a
+    // section lands where the viewer left instead of at the top.
+    var origin by mutableStateOf<ControlOrigin?>(null)
+    val originFocus: Map<ControlOrigin, FocusRequester> = ControlOrigin.entries.associateWith { FocusRequester() }
+    var menuEntry by mutableStateOf<String?>(null)
+
+    fun openPanel(target: PlayerPanel, fromMenu: Boolean, from: ControlOrigin? = null) {
+        origin = from
+        panelFromMenu = fromMenu
+        relatedOpen = false
+        controlsVisible = false
+        panel = target
+    }
+
+    // Down from playback lands on the buttons, so a second Down reaches the related row, as on YouTube.
+    var controlsFromBelow by mutableStateOf(false)
+    val scrub = ScrubState()
+    val notice = SponsorNotice()
+    val upNext = UpNextState()
+
+    fun showControls(fromBelow: Boolean = false) {
+        controlsFromBelow = fromBelow
+        controlsVisible = true
+    }
+
+    fun togglePlay() {
+        if (player.isPlaying) player.pause() else player.play()
+    }
+
+    fun seekBy(deltaMillis: Long) {
+        player.seekTo(SeekMath.target(player.currentPosition, deltaMillis, state.durationMillis))
+    }
+
+    // The picture holds still while the thumb moves, as on YouTube, and plays again from the chosen point.
+    private var resumeAfterScrub = false
+
+    fun scrub(direction: Int, repeatCount: Int = 0) {
+        if (!scrub.active) {
+            resumeAfterScrub = player.playWhenReady
+            player.pause()
+        }
+        scrub.move(state.positionMillis, direction, state.durationMillis, repeatCount)
+        controlsVisible = true
+    }
+
+    fun commitScrub() {
+        scrub.commit()?.let(player::seekTo)
+        resumeScrubbedPlayback()
+    }
+
+    private fun cancelScrub() {
+        scrub.cancel()
+        resumeScrubbedPlayback()
+    }
+
+    private fun resumeScrubbedPlayback() {
+        if (resumeAfterScrub) player.play()
+        resumeAfterScrub = false
+    }
+
+    fun undoSkip(): Boolean {
+        val start = notice.undo() ?: return false
+        player.seekTo(start)
+        return true
+    }
+
+    fun onKey(event: KeyEvent, upNextVisible: Boolean, playNext: () -> Unit): Boolean {
+        if (panel != null) return false
+        if (event.type != KeyEventType.KeyDown) return false
+        interaction = SystemClock.elapsedRealtime()
+        val repeats = event.nativeKeyEvent.repeatCount
+        val confirm = event.key == Key.DirectionCenter || event.key == Key.Enter
+        return when {
+            event.key == Key.MediaPlayPause -> { togglePlay(); showControls(); true }
+            scrub.active && confirm -> { commitScrub(); true }
+            scrub.active && event.key == Key.DirectionLeft -> { scrub(-1, repeats); true }
+            scrub.active && event.key == Key.DirectionRight -> { scrub(1, repeats); true }
+            controlsVisible || state.isEnded -> false
+            upNextVisible && confirm -> { playNext(); true }
+            confirm -> { togglePlay(); showControls(); true }
+            event.key == Key.DirectionLeft && notice.segment != null -> undoSkip()
+            event.key == Key.DirectionLeft || event.key == Key.MediaRewind -> { scrub(-1, repeats); true }
+            event.key == Key.DirectionRight || event.key == Key.MediaFastForward -> { scrub(1, repeats); true }
+            event.key == Key.DirectionUp -> { showControls(); true }
+            event.key == Key.DirectionDown -> { showControls(fromBelow = true); true }
+            else -> false
+        }
+    }
+
+    // Back goes through the activity's back dispatcher, not key events: from Android 16 (predictive back)
+    // the Back key never reaches the views, so a key handler would let Back leave the player at once.
+    fun handlesBack(upNextVisible: Boolean): Boolean =
+        panel == null && (scrub.active || upNextVisible || relatedOpen || controlsVisible)
+
+    fun back(upNextVisible: Boolean) {
+        when {
+            scrub.active -> cancelScrub()
+            upNextVisible -> upNext.dismiss()
+            relatedOpen -> relatedOpen = false
+            controlsVisible -> controlsVisible = false
+        }
+    }
+}
diff --git a/app/src/main/java/video/typetype/tv/ui/player/PlayerUiState.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerUiState.kt
similarity index 82%
rename from app/src/main/java/video/typetype/tv/ui/player/PlayerUiState.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/PlayerUiState.kt
index 7cf9ccb..edbee49 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/PlayerUiState.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerUiState.kt
@@ -11,6 +11,7 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.media3.common.C
 import androidx.media3.common.Player
+import androidx.media3.common.Tracks
 import video.typetype.tv.ui.util.formatMillis
 import kotlinx.coroutines.delay
 
@@ -22,6 +23,8 @@ class PlayerUiState {
     var isPlaying by mutableStateOf(false)
     var isBuffering by mutableStateOf(true)
     var isEnded by mutableStateOf(false)
+    var hasFirstFrame by mutableStateOf(false)
+    var trackHeights by mutableStateOf(emptyList<Int>())
     var isLive by mutableStateOf(false)
     var liveOffsetMillis by mutableLongStateOf(0L)
 }
@@ -49,6 +52,19 @@ fun rememberPlayerUiState(player: Player): PlayerUiState {
                 state.isPlaying = isPlaying
             }
 
+            override fun onRenderedFirstFrame() {
+                state.hasFirstFrame = true
+            }
+
+            override fun onTracksChanged(tracks: Tracks) {
+                state.trackHeights = tracks.groups
+                    .filter { it.type == C.TRACK_TYPE_VIDEO }
+                    .flatMap { group -> (0 until group.length).filter(group::isTrackSupported).map { group.getTrackFormat(it).height } }
+                    .filter { it > 0 }
+                    .distinct()
+                    .sortedDescending()
+            }
+
             override fun onPlaybackStateChanged(playbackState: Int) {
                 // An error being recovered leaves the player idle: still show that playback is coming back.
                 state.isBuffering = playbackState == Player.STATE_BUFFERING ||
diff --git a/app/src/main/java/video/typetype/tv/ui/player/PlayerVideoSurface.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/PlayerVideoSurface.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/player/PlayerVideoSurface.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/PlayerVideoSurface.kt
diff --git a/app/src/main/java/video/typetype/tv/ui/player/PresenceEffects.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/PresenceEffects.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/player/PresenceEffects.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/PresenceEffects.kt
diff --git a/feature/player/src/main/java/video/typetype/tv/ui/player/QualitySteps.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/QualitySteps.kt
new file mode 100644
index 0000000..565a496
--- /dev/null
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/QualitySteps.kt
@@ -0,0 +1,5 @@
+package video.typetype.tv.ui.player
+
+object QualitySteps {
+    fun below(heights: List<Int>, failedHeight: Int): Int? = heights.filter { it < failedHeight }.maxOrNull()
+}
diff --git a/app/src/main/java/video/typetype/tv/ui/player/ReconnectingPanel.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/ReconnectingPanel.kt
similarity index 97%
rename from app/src/main/java/video/typetype/tv/ui/player/ReconnectingPanel.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/ReconnectingPanel.kt
index edcdfb7..e7beada 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/ReconnectingPanel.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/ReconnectingPanel.kt
@@ -11,7 +11,7 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.theme.Type
 import video.typetype.tv.ui.components.TextLabel
 
diff --git a/app/src/main/java/video/typetype/tv/ui/player/RecoveryPolicy.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/RecoveryPolicy.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/player/RecoveryPolicy.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/RecoveryPolicy.kt
diff --git a/feature/player/src/main/java/video/typetype/tv/ui/player/RelatedShelf.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/RelatedShelf.kt
new file mode 100644
index 0000000..6744ac8
--- /dev/null
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/RelatedShelf.kt
@@ -0,0 +1,94 @@
+package video.typetype.tv.ui.player
+
+import androidx.compose.foundation.focusGroup
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.LazyRow
+import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.input.key.KeyEventType
+import androidx.compose.ui.input.key.key
+import androidx.compose.ui.input.key.onPreviewKeyEvent
+import androidx.compose.ui.input.key.type
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import video.typetype.tv.data.Chapter
+import video.typetype.tv.data.Video
+import video.typetype.tv.resources.R
+import video.typetype.tv.theme.Dimens
+import video.typetype.tv.theme.Type
+import video.typetype.tv.ui.components.TextLabel
+import video.typetype.tv.ui.components.VideoCard
+import video.typetype.tv.ui.detail.ChapterRow
+import video.typetype.tv.ui.util.requestFocusWhenReady
+
+// One row's height: the chapters and the next videos do not both fit under the controls, so the shelf scrolls to the
+// row that has the focus.
+private val SHELF_HEIGHT = 236.dp
+
+// What rises under the controls on a second Down, as on YouTube's TV app: the video's chapters, opened on the one
+// being watched, then more videos. Up from the top row closes it; Back is handled by the player session.
+@Composable
+fun RelatedShelf(
+    videos: List<Video>,
+    chapters: List<Chapter>,
+    currentChapter: Int,
+    onChapter: (Chapter) -> Unit,
+    onOpen: (Video) -> Unit,
+    onClose: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val entry = remember { FocusRequester() }
+    LaunchedEffect(Unit) { entry.requestFocusWhenReady() }
+    val closeOnUp = Modifier.onPreviewKeyEvent { event ->
+        val close = event.key == Key.DirectionUp
+        if (close && event.type == KeyEventType.KeyUp) onClose()
+        close
+    }
+    Column(modifier.heightIn(max = SHELF_HEIGHT).verticalScroll(rememberScrollState())) {
+        if (chapters.isNotEmpty()) {
+            ChapterRow(
+                chapters = chapters,
+                onSelect = onChapter,
+                modifier = closeOnUp,
+                cardWidth = Dimens.CardWidth,
+                current = currentChapter,
+                currentRequester = entry,
+            )
+            Spacer(Modifier.height(12.dp))
+        }
+        if (videos.isNotEmpty()) {
+            TextLabel(stringResource(R.string.player_more_videos).uppercase(), Type.Label, Modifier.padding(start = Dimens.SafeStart))
+            Spacer(Modifier.height(10.dp))
+            LazyRow(
+                modifier = (if (chapters.isEmpty()) closeOnUp else Modifier).focusGroup(),
+                contentPadding = PaddingValues(start = Dimens.SafeStart, end = Dimens.SafeEnd, top = 6.dp, bottom = 6.dp),
+                horizontalArrangement = Arrangement.spacedBy(Dimens.CardGap),
+            ) {
+                itemsIndexed(videos, key = { _, video -> video.id }) { index, video ->
+                    VideoCard(
+                        video = video,
+                        onClick = { onOpen(video) },
+                        modifier = Modifier
+                            .width(Dimens.CardWidth)
+                            .then(if (index == 0 && chapters.isEmpty()) Modifier.focusRequester(entry) else Modifier),
+                    )
+                }
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/video/typetype/tv/ui/player/ScrubState.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/ScrubState.kt
similarity index 52%
rename from app/src/main/java/video/typetype/tv/ui/player/ScrubState.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/ScrubState.kt
index 267de9d..22e9186 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/ScrubState.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/ScrubState.kt
@@ -12,17 +12,25 @@ class ScrubState {
 
     val active: Boolean get() = target != null
 
-    fun move(currentMillis: Long, deltaMillis: Long, durationMillis: Long) {
-        target = SeekMath.target(target ?: currentMillis, deltaMillis, durationMillis)
+    // Presses in this scrub so far, held or tapped: each one moves further than the last.
+    var presses = 0
+        private set
+
+    fun move(currentMillis: Long, direction: Int, durationMillis: Long, repeatCount: Int = 0) {
+        val step = SeekMath.scrubStep(maxOf(presses, repeatCount), durationMillis)
+        presses++
+        target = SeekMath.target(target ?: currentMillis, direction * step, durationMillis)
     }
 
     fun commit(): Long? {
         val result = target
         target = null
+        presses = 0
         return result
     }
 
     fun cancel() {
         target = null
+        presses = 0
     }
 }
diff --git a/app/src/main/java/video/typetype/tv/ui/player/SeekBar.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/SeekBar.kt
similarity index 89%
rename from app/src/main/java/video/typetype/tv/ui/player/SeekBar.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/SeekBar.kt
index 653a84e..4f2fcfc 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/SeekBar.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/SeekBar.kt
@@ -35,30 +35,28 @@ import androidx.compose.ui.semantics.progressBarRangeInfo
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.unit.IntOffset
 import androidx.compose.ui.unit.dp
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.Chapter
 import video.typetype.tv.data.Storyboard
 import video.typetype.tv.theme.Palette
 import video.typetype.tv.ui.components.DurationBadge
 import video.typetype.tv.ui.util.formatMillis
 
-/**
- * The playback position changes five times a second, so it is passed as lambdas and read only
- * where it is drawn or placed: a tick redraws the track and moves the badge without recomposing
- * the bar or the controls around it.
- */
+// The playback position changes five times a second, so it is passed as lambdas and read only where it is drawn or
+// placed: a tick redraws the track and moves the badge without recomposing the bar or the controls around it.
 @Composable
 fun SeekBar(
     positionMillis: () -> Long,
     bufferedMillis: () -> Long,
     durationMillis: Long,
-    onScrubBy: (Long) -> Unit,
+    onScrub: (direction: Int, repeatCount: Int) -> Unit,
     onTogglePlay: () -> Unit,
     modifier: Modifier = Modifier,
     markers: List<SeekMarker> = emptyList(),
     scrubMillis: Long? = null,
     storyboard: Storyboard? = null,
     chapters: List<Chapter> = emptyList(),
+    positionLabel: (Long) -> String = ::formatMillis,
 ) {
     val source = remember { MutableInteractionSource() }
     val focused by source.collectIsFocusedAsState()
@@ -81,10 +79,10 @@ fun SeekBar(
             }
             .onKeyEvent { event ->
                 if (event.type != KeyEventType.KeyDown) return@onKeyEvent false
-                val step = SeekMath.scrubStep(event.nativeKeyEvent.repeatCount, durationMillis)
+                val repeats = event.nativeKeyEvent.repeatCount
                 when (event.key) {
-                    Key.DirectionLeft -> { onScrubBy(-step); true }
-                    Key.DirectionRight -> { onScrubBy(step); true }
+                    Key.DirectionLeft -> { onScrub(-1, repeats); true }
+                    Key.DirectionRight -> { onScrub(1, repeats); true }
                     Key.DirectionCenter, Key.Enter -> { onTogglePlay(); true }
                     else -> false
                 }
@@ -130,6 +128,7 @@ fun SeekBar(
                 storyboard = storyboard,
                 positionMillis = scrubMillis,
                 chapterTitle = SeekMarkers.currentChapter(chapters, scrubMillis)?.title,
+                label = positionLabel,
                 modifier = Modifier
                     .wrapContentSize(Alignment.TopStart, unbounded = true)
                     .offset {
@@ -142,6 +141,7 @@ fun SeekBar(
         } else if (focused) {
             PositionBadge(
                 positionMillis,
+                positionLabel,
                 Modifier.offset {
                     val x = widthPx * SeekMath.fraction(positionMillis(), durationMillis)
                     IntOffset((x - BADGE_CENTER.toPx()).toInt(), BADGE_RISE.roundToPx())
@@ -152,8 +152,8 @@ fun SeekBar(
 }
 
 @Composable
-private fun PositionBadge(positionMillis: () -> Long, modifier: Modifier) {
-    val text by remember { derivedStateOf { formatMillis(positionMillis()) } }
+private fun PositionBadge(positionMillis: () -> Long, label: (Long) -> String, modifier: Modifier) {
+    val text by remember(label) { derivedStateOf { label(positionMillis()) } }
     Box(modifier) { DurationBadge(text) }
 }
 
diff --git a/app/src/main/java/video/typetype/tv/ui/player/SeekMarkers.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/SeekMarkers.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/player/SeekMarkers.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/SeekMarkers.kt
diff --git a/feature/player/src/main/java/video/typetype/tv/ui/player/SeekMath.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/SeekMath.kt
new file mode 100644
index 0000000..00ab916
--- /dev/null
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/SeekMath.kt
@@ -0,0 +1,32 @@
+package video.typetype.tv.ui.player
+
+import kotlin.math.pow
+
+object SeekMath {
+    const val JUMP_MILLIS = 10_000L
+    private const val MIN_STEP_MILLIS = 5_000L
+    private const val MIN_CAP_MILLIS = 10_000L
+    private const val CAP_DIVISOR = 40
+    private const val GROWTH = 1.05
+    private const val MAX_GROWTH_PRESSES = 200
+
+    // Every scrub starts with five-second steps and each further press moves a little further than the last. A held key
+    // repeats about twenty times a second, so the growth is gentle: one second held moves about three minutes, and the
+    // step stops at a share of the video, fifteen seconds for ten minutes, fifteen minutes for a ten-hour stream, whose
+    // middle is then about five seconds of holding away.
+    fun scrubStep(press: Int, durationMillis: Long): Long {
+        val cap = (durationMillis / CAP_DIVISOR).coerceAtLeast(MIN_CAP_MILLIS)
+        val grown = MIN_STEP_MILLIS * GROWTH.pow(press.coerceIn(0, MAX_GROWTH_PRESSES))
+        return grown.toLong().coerceIn(MIN_STEP_MILLIS, cap)
+    }
+
+    fun target(currentMillis: Long, deltaMillis: Long, durationMillis: Long): Long {
+        val upper = durationMillis.coerceAtLeast(0L)
+        return (currentMillis + deltaMillis).coerceIn(0L, upper)
+    }
+
+    fun fraction(positionMillis: Long, durationMillis: Long): Float {
+        if (durationMillis <= 0L) return 0f
+        return (positionMillis.toFloat() / durationMillis.toFloat()).coerceIn(0f, 1f)
+    }
+}
diff --git a/app/src/main/java/video/typetype/tv/ui/player/SeekPreview.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/SeekPreview.kt
similarity index 97%
rename from app/src/main/java/video/typetype/tv/ui/player/SeekPreview.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/SeekPreview.kt
index a7762e0..afa8e32 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/SeekPreview.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/SeekPreview.kt
@@ -45,6 +45,7 @@ fun SeekPreview(
     positionMillis: Long,
     chapterTitle: String?,
     modifier: Modifier = Modifier,
+    label: (Long) -> String = ::formatMillis,
 ) {
     Column(modifier.width(SEEK_PREVIEW_WIDTH), horizontalAlignment = Alignment.CenterHorizontally) {
         if (storyboard != null) {
@@ -53,7 +54,7 @@ fun SeekPreview(
         Spacer(Modifier.height(8.dp))
         TextLabel(chapterTitle.orEmpty(), Type.Meta.copy(color = Palette.TextHigh), maxLines = 1)
         Spacer(Modifier.height(6.dp))
-        DurationBadge(formatMillis(positionMillis))
+        DurationBadge(label(positionMillis))
     }
 }
 
diff --git a/app/src/main/java/video/typetype/tv/ui/player/SponsorLabelBadge.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/SponsorLabelBadge.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/player/SponsorLabelBadge.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/SponsorLabelBadge.kt
diff --git a/app/src/main/java/video/typetype/tv/ui/player/SponsorLabels.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/SponsorLabels.kt
similarity index 96%
rename from app/src/main/java/video/typetype/tv/ui/player/SponsorLabels.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/SponsorLabels.kt
index 9f150b5..a95e666 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/SponsorLabels.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/SponsorLabels.kt
@@ -1,7 +1,7 @@
 package video.typetype.tv.ui.player
 
 import androidx.annotation.StringRes
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.SponsorSegment
 
 object SponsorLabels {
diff --git a/app/src/main/java/video/typetype/tv/ui/player/SponsorNotice.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/SponsorNotice.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/player/SponsorNotice.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/SponsorNotice.kt
diff --git a/app/src/main/java/video/typetype/tv/ui/player/SponsorSkipNotice.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/SponsorSkipNotice.kt
similarity index 98%
rename from app/src/main/java/video/typetype/tv/ui/player/SponsorSkipNotice.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/SponsorSkipNotice.kt
index 22f6b57..3cbc691 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/SponsorSkipNotice.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/SponsorSkipNotice.kt
@@ -26,7 +26,7 @@ import androidx.compose.ui.semantics.contentDescription
 import androidx.compose.ui.semantics.liveRegion
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.unit.dp
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.SponsorSegment
 import video.typetype.tv.theme.Palette
 import video.typetype.tv.theme.Shapes
diff --git a/app/src/main/java/video/typetype/tv/ui/player/SponsorSkips.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/SponsorSkips.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/player/SponsorSkips.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/SponsorSkips.kt
diff --git a/app/src/main/java/video/typetype/tv/ui/player/UpNextCard.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/UpNextCard.kt
similarity index 99%
rename from app/src/main/java/video/typetype/tv/ui/player/UpNextCard.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/UpNextCard.kt
index e9b1736..0a14218 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/UpNextCard.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/UpNextCard.kt
@@ -37,7 +37,7 @@ import androidx.compose.ui.semantics.liveRegion
 import androidx.compose.ui.semantics.onClick
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.unit.dp
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.Video
 import video.typetype.tv.theme.Dimens
 import video.typetype.tv.theme.Palette
diff --git a/app/src/main/java/video/typetype/tv/ui/player/UpNextPanel.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/UpNextPanel.kt
similarity index 70%
rename from app/src/main/java/video/typetype/tv/ui/player/UpNextPanel.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/UpNextPanel.kt
index cbafab3..aa82dc2 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/UpNextPanel.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/UpNextPanel.kt
@@ -1,5 +1,9 @@
 package video.typetype.tv.ui.player
 
+import video.typetype.tv.theme.Dimens
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.AnimatedVisibility
 import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
@@ -22,7 +26,7 @@ import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.Video
 import video.typetype.tv.theme.Palette
 import video.typetype.tv.theme.Shapes
@@ -38,6 +42,7 @@ fun UpNextPanel(
     onPlayNext: () -> Unit,
     onReplay: () -> Unit,
     modifier: Modifier = Modifier,
+    liveEnded: Boolean = false,
 ) {
     val primary = remember { FocusRequester() }
     LaunchedEffect(Unit) { primary.requestFocusWhenReady() }
@@ -48,6 +53,10 @@ fun UpNextPanel(
             .background(Palette.Scrim)
             .padding(18.dp),
     ) {
+        if (liveEnded) {
+            TextLabel(stringResource(R.string.player_live_ended), Type.Title)
+            Spacer(Modifier.height(14.dp))
+        }
         if (next != null) {
             TextLabel(stringResource(R.string.player_up_next), Type.Label.copy(color = Palette.Accent))
             Spacer(Modifier.height(10.dp))
@@ -73,12 +82,33 @@ fun UpNextPanel(
                     modifier = Modifier.focusRequester(primary),
                 )
             }
-            PillButton(
-                label = stringResource(R.string.player_replay),
-                icon = Icons.Rounded.Replay,
-                onClick = onReplay,
-                modifier = if (next == null) Modifier.focusRequester(primary) else Modifier,
-            )
+            if (!liveEnded) {
+                PillButton(
+                    label = stringResource(R.string.player_replay),
+                    icon = Icons.Rounded.Replay,
+                    onClick = onReplay,
+                    modifier = if (next == null) Modifier.focusRequester(primary) else Modifier,
+                )
+            }
         }
     }
 }
+
+@Composable
+fun EndedOverlay(
+    visible: Boolean,
+    next: Video?,
+    onPlayNext: () -> Unit,
+    onReplay: () -> Unit,
+    liveEnded: Boolean,
+    modifier: Modifier = Modifier,
+) {
+    AnimatedVisibility(
+        visible = visible,
+        enter = fadeIn(),
+        exit = fadeOut(),
+        modifier = modifier.padding(end = Dimens.SafeEnd, bottom = Dimens.SafeBottom + 6.dp),
+    ) {
+        UpNextPanel(next = next, onPlayNext = onPlayNext, onReplay = onReplay, liveEnded = liveEnded)
+    }
+}
diff --git a/app/src/main/java/video/typetype/tv/ui/player/UpNextTimeline.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/UpNextTimeline.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/player/UpNextTimeline.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/UpNextTimeline.kt
diff --git a/feature/player/src/main/java/video/typetype/tv/ui/player/WarmNextVideo.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/WarmNextVideo.kt
new file mode 100644
index 0000000..69fbbad
--- /dev/null
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/WarmNextVideo.kt
@@ -0,0 +1,28 @@
+package video.typetype.tv.ui.player
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.derivedStateOf
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import video.typetype.tv.data.Video
+import video.typetype.tv.ui.components.LocalPlaybackPreload
+
+private const val WARM_WINDOW_MILLIS = 45_000L
+
+// Like the web player, the video autoplay will open next is prepared during the last 45 seconds of the current one:
+// its stream and its session, so it starts without waiting.
+@Composable
+internal fun WarmNextVideo(next: Video?, autoAdvance: Boolean, state: PlayerUiState) {
+    val preload = LocalPlaybackPreload.current
+    val nearEnd by remember(state) {
+        derivedStateOf {
+            state.positionMillis > 0L && state.durationMillis > 0L &&
+                state.durationMillis - state.positionMillis <= WARM_WINDOW_MILLIS
+        }
+    }
+    val target = next?.takeIf { autoAdvance && nearEnd && !it.isLive }
+    LaunchedEffect(target?.id) {
+        target?.let { preload?.preload(it) }
+    }
+}
diff --git a/app/src/main/java/video/typetype/tv/ui/player/danmaku/DanmakuLayout.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/danmaku/DanmakuLayout.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/player/danmaku/DanmakuLayout.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/danmaku/DanmakuLayout.kt
diff --git a/app/src/main/java/video/typetype/tv/ui/player/danmaku/DanmakuOverlay.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/danmaku/DanmakuOverlay.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/player/danmaku/DanmakuOverlay.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/danmaku/DanmakuOverlay.kt
diff --git a/app/src/main/java/video/typetype/tv/ui/player/panel/AudioPanel.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/panel/AudioPanel.kt
similarity index 98%
rename from app/src/main/java/video/typetype/tv/ui/player/panel/AudioPanel.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/panel/AudioPanel.kt
index d99a08e..9d6ed17 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/panel/AudioPanel.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/panel/AudioPanel.kt
@@ -11,7 +11,7 @@ import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.playback.AudioTrackChoice
 import video.typetype.tv.ui.util.requestFocusWhenReady
 
diff --git a/app/src/main/java/video/typetype/tv/ui/player/panel/CaptionStylePanel.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/panel/CaptionStylePanel.kt
similarity index 98%
rename from app/src/main/java/video/typetype/tv/ui/player/panel/CaptionStylePanel.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/panel/CaptionStylePanel.kt
index b957983..57665a7 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/panel/CaptionStylePanel.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/panel/CaptionStylePanel.kt
@@ -26,7 +26,7 @@ import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.TextStyle
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.CaptionStyles
 import video.typetype.tv.theme.Shapes
 import video.typetype.tv.ui.player.CaptionRenderer
diff --git a/feature/player/src/main/java/video/typetype/tv/ui/player/panel/ChannelPanel.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/panel/ChannelPanel.kt
new file mode 100644
index 0000000..691b1db
--- /dev/null
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/panel/ChannelPanel.kt
@@ -0,0 +1,157 @@
+package video.typetype.tv.ui.player.panel
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxScope
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.rounded.ArrowForward
+import androidx.compose.material.icons.rounded.Check
+import androidx.compose.material.icons.rounded.NotificationsNone
+import androidx.compose.material.icons.rounded.Verified
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.graphics.Brush
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.unit.dp
+import coil3.compose.AsyncImage
+import video.typetype.tv.data.Channel
+import video.typetype.tv.data.ChannelPage
+import video.typetype.tv.data.ChannelTab
+import video.typetype.tv.data.ContentRepository
+import video.typetype.tv.resources.R
+import video.typetype.tv.theme.Palette
+import video.typetype.tv.theme.Type
+import video.typetype.tv.ui.components.Glyph
+import video.typetype.tv.ui.components.PillButton
+import video.typetype.tv.ui.components.TextLabel
+import video.typetype.tv.ui.components.rememberShimmerBrush
+import video.typetype.tv.ui.util.requestFocusWhenReady
+import video.typetype.tv.ui.util.tryLoad
+
+private const val DESCRIPTION_LINES = 9
+private val BANNER_HEIGHT = 190.dp
+private val AVATAR_SIZE = 84.dp
+
+class ChannelCardActions(
+    val subscribed: Boolean,
+    val canSubscribe: Boolean,
+    val onSubscribe: (Boolean) -> Unit,
+    val onOpenChannel: () -> Unit,
+)
+
+// The channel of the video beside the player: what it is and whether to follow it, without leaving the video. The
+// first page of the channel brings the banner and the description; the name, picture and audience show at once.
+@Composable
+fun ChannelPanel(channel: Channel, repository: ContentRepository, actions: ChannelCardActions, onClose: () -> Unit) {
+    var page by remember(channel.url) { mutableStateOf<ChannelPage?>(null) }
+    var loaded by remember(channel.url) { mutableStateOf(false) }
+    LaunchedEffect(channel.url) {
+        page = tryLoad({}) { repository.channel(channel.url, null, ChannelTab.Videos, null, null) }
+        loaded = true
+    }
+    val entry = remember { FocusRequester() }
+    LaunchedEffect(Unit) { entry.requestFocusWhenReady() }
+    PlayerSheet(channel.name, onClose, showTitle = false, background = { Banner(page?.bannerUrl) }) {
+        Column(Modifier.fillMaxSize().padding(start = 8.dp, end = 8.dp, top = BANNER_HEIGHT - AVATAR_SIZE / 2 - 28.dp)) {
+            ChannelAvatar(channel)
+            Spacer(Modifier.height(14.dp))
+            Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                TextLabel(channel.name, Type.Headline, Modifier.weight(1f, fill = false), maxLines = 1)
+                if (page?.verified == true) {
+                    val verified = stringResource(R.string.channel_verified)
+                    Glyph(Icons.Rounded.Verified, Palette.TextMid, 24, Modifier.semantics { contentDescription = verified })
+                }
+            }
+            val subscribers = page?.channel?.subscribers?.takeIf { it.isNotBlank() } ?: channel.subscribers.takeIf { it.isNotBlank() }
+            if (subscribers != null) TextLabel(stringResource(R.string.detail_subscribers, subscribers), Type.Meta, maxLines = 1)
+            Spacer(Modifier.height(18.dp))
+            Row(horizontalArrangement = Arrangement.spacedBy(10.dp)) {
+                PillButton(
+                    label = stringResource(R.string.player_open_channel),
+                    icon = Icons.AutoMirrored.Rounded.ArrowForward,
+                    onClick = actions.onOpenChannel,
+                    modifier = Modifier.focusRequester(entry),
+                    emphasized = true,
+                )
+                if (actions.canSubscribe) {
+                    PillButton(
+                        label = stringResource(if (actions.subscribed) R.string.detail_subscribed else R.string.detail_subscribe),
+                        icon = if (actions.subscribed) Icons.Rounded.Check else Icons.Rounded.NotificationsNone,
+                        onClick = { actions.onSubscribe(!actions.subscribed) },
+                    )
+                }
+            }
+            Spacer(Modifier.height(20.dp))
+            when {
+                !loaded -> DescriptionSkeleton()
+                page?.description.isNullOrBlank() -> Unit
+                else -> TextLabel(
+                    page?.description.orEmpty(),
+                    Type.Body.copy(color = Palette.TextHigh),
+                    maxLines = DESCRIPTION_LINES,
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun BoxScope.Banner(url: String?) {
+    if (url != null) {
+        AsyncImage(url, null, Modifier.fillMaxWidth().height(BANNER_HEIGHT), contentScale = ContentScale.Crop)
+    }
+    Box(
+        Modifier
+            .fillMaxWidth()
+            .height(BANNER_HEIGHT)
+            .background(Brush.verticalGradient(listOf(Palette.Ink.copy(alpha = 0.2f), Palette.Ink.copy(alpha = 0.6f), Palette.Ink))),
+    )
+}
+
+@Composable
+private fun ChannelAvatar(channel: Channel) {
+    Box(
+        Modifier
+            .size(AVATAR_SIZE)
+            .clip(CircleShape)
+            .background(Palette.SurfaceRaised)
+            .border(3.dp, Palette.Ink, CircleShape),
+        contentAlignment = Alignment.Center,
+    ) {
+        TextLabel(channel.name.take(1).uppercase(), Type.Headline, maxLines = 1)
+        channel.avatarUrl?.let { AsyncImage(it, null, Modifier.size(AVATAR_SIZE).padding(3.dp).clip(CircleShape), contentScale = ContentScale.Crop) }
+    }
+}
+
+@Composable
+private fun DescriptionSkeleton() {
+    val brush = rememberShimmerBrush(base = Palette.SurfaceRaised, highlight = Palette.Outline)
+    Column(verticalArrangement = Arrangement.spacedBy(10.dp)) {
+        listOf(1f, 0.92f, 0.6f).forEach { width ->
+            Spacer(Modifier.fillMaxWidth(width).height(14.dp).clip(CircleShape).background(brush))
+        }
+    }
+}
diff --git a/app/src/main/java/video/typetype/tv/ui/player/panel/ChaptersPanel.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/panel/ChaptersPanel.kt
similarity index 98%
rename from app/src/main/java/video/typetype/tv/ui/player/panel/ChaptersPanel.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/panel/ChaptersPanel.kt
index 401e904..abda752 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/panel/ChaptersPanel.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/panel/ChaptersPanel.kt
@@ -14,7 +14,7 @@ import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.Chapter
 import video.typetype.tv.theme.Palette
 import video.typetype.tv.theme.Type
diff --git a/app/src/main/java/video/typetype/tv/ui/player/panel/CommentRows.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/panel/CommentRows.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/player/panel/CommentRows.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/panel/CommentRows.kt
diff --git a/app/src/main/java/video/typetype/tv/ui/player/panel/CommentSkeleton.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/panel/CommentSkeleton.kt
similarity index 90%
rename from app/src/main/java/video/typetype/tv/ui/player/panel/CommentSkeleton.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/panel/CommentSkeleton.kt
index c5e114f..191bf4a 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/panel/CommentSkeleton.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/panel/CommentSkeleton.kt
@@ -18,9 +18,13 @@ import androidx.compose.ui.graphics.Brush
 import androidx.compose.ui.unit.dp
 import video.typetype.tv.theme.Palette
 import video.typetype.tv.theme.Shapes
+import video.typetype.tv.ui.components.rememberShimmerBrush
 
 private val LINE = RoundedCornerShape(6.dp)
 
+@Composable
+fun rememberCommentShimmer(): Brush = rememberShimmerBrush(base = Palette.SurfaceRaised, highlight = Palette.Outline)
+
 @Composable
 fun CommentSkeleton(brush: Brush, reply: Boolean, modifier: Modifier = Modifier) {
     Column(
diff --git a/app/src/main/java/video/typetype/tv/ui/player/panel/CommentsPanel.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/panel/CommentsPanel.kt
similarity index 75%
rename from app/src/main/java/video/typetype/tv/ui/player/panel/CommentsPanel.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/panel/CommentsPanel.kt
index a4c6ccb..14bf5f1 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/panel/CommentsPanel.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/panel/CommentsPanel.kt
@@ -30,8 +30,8 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.focus.focusRequester
-import androidx.compose.ui.graphics.Brush
 import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.LiveRegionMode
 import androidx.compose.ui.semantics.contentDescription
@@ -39,17 +39,19 @@ import androidx.compose.ui.semantics.liveRegion
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.unit.dp
 import coil3.compose.AsyncImage
-import video.typetype.tv.R
+import coil3.decode.BitmapFactoryDecoder
+import coil3.request.ImageRequest
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.Comment
 import video.typetype.tv.theme.Palette
 import video.typetype.tv.theme.Type
 import video.typetype.tv.ui.components.Glyph
 import video.typetype.tv.ui.components.TextLabel
-import video.typetype.tv.ui.components.rememberShimmerBrush
 import video.typetype.tv.ui.detail.CommentsState
 import video.typetype.tv.ui.detail.commentDescription
 import video.typetype.tv.ui.detail.commentLikesLabel
 import video.typetype.tv.ui.detail.commentRepliesLabel
+import video.typetype.tv.ui.util.WithKeylineScroll
 import video.typetype.tv.ui.util.requestFocusWhenReady
 
 private const val PREFETCH_ITEMS = 3
@@ -58,6 +60,7 @@ private const val REPLY_BODY_LINES = 6
 private const val FIRST_PAGE_SKELETONS = 4
 private const val NEXT_PAGE_SKELETONS = 2
 private val REPLY_INDENT = 28.dp
+private val ROW_GAP = 8.dp
 
 @Composable
 fun CommentsPanel(state: CommentsState, onClose: () -> Unit) {
@@ -68,7 +71,6 @@ fun CommentsPanel(state: CommentsState, onClose: () -> Unit) {
     LaunchedEffect(state) { if (!state.loaded) state.load() }
     LaunchedEffect(state.loaded, state.comments.isEmpty()) { entry.requestFocusWhenReady() }
     val rows = CommentRows.build(state.comments, state.replies, state.loadingMore)
-    val shimmer = rememberShimmerBrush(base = Palette.SurfaceRaised, highlight = Palette.Outline)
     LaunchedEffect(restoreId) {
         val id = restoreId ?: return@LaunchedEffect
         val index = rows.indexOfFirst { it is CommentRow.Top && it.comment.id == id }
@@ -80,24 +82,27 @@ fun CommentsPanel(state: CommentsState, onClose: () -> Unit) {
     }
     PlayerSheet(stringResource(R.string.menu_comments), onClose) {
         if (!state.loaded) {
-            FirstPageSkeleton(shimmer, stringResource(R.string.comments_loading), Modifier.focusRequester(entry))
+            FirstPageSkeleton(stringResource(R.string.comments_loading), Modifier.focusRequester(entry))
         } else if (state.comments.isEmpty()) {
             val message = stringResource(R.string.comments_empty)
             SheetSurface(onClick = onClose, spoken = message, current = false, modifier = Modifier.focusRequester(entry)) {
                 TextLabel(message, Type.Body.copy(color = Palette.TextHigh), maxLines = 2)
             }
         } else {
-            LazyColumn(state = listState, contentPadding = SheetContentPadding, verticalArrangement = Arrangement.spacedBy(8.dp)) {
-                itemsIndexed(rows, key = { _, row -> row.key }) { index, row ->
-                    LaunchedEffect(index, state.comments.size) {
-                        if (index >= rows.size - PREFETCH_ITEMS) state.loadMore()
+            // The focused card's top sits one gap below the edge, so nothing of the card above shows.
+            WithKeylineScroll(ROW_GAP) {
+                LazyColumn(state = listState, contentPadding = SheetContentPadding, verticalArrangement = Arrangement.spacedBy(ROW_GAP)) {
+                    itemsIndexed(rows, key = { _, row -> row.key }) { index, row ->
+                        LaunchedEffect(index, state.comments.size) {
+                            if (index >= rows.size - PREFETCH_ITEMS) state.loadMore()
+                        }
+                        val focus = when {
+                            index == 0 -> Modifier.focusRequester(entry)
+                            row is CommentRow.Top && row.comment.id == restoreId -> Modifier.focusRequester(restore)
+                            else -> Modifier
+                        }
+                        RowContent(row, state, focus) { restoreId = it }
                     }
-                    val focus = when {
-                        index == 0 -> Modifier.focusRequester(entry)
-                        row is CommentRow.Top && row.comment.id == restoreId -> Modifier.focusRequester(restore)
-                        else -> Modifier
-                    }
-                    RowContent(row, state, shimmer, focus) { restoreId = it }
                 }
             }
         }
@@ -105,7 +110,8 @@ fun CommentsPanel(state: CommentsState, onClose: () -> Unit) {
 }
 
 @Composable
-private fun FirstPageSkeleton(shimmer: Brush, spoken: String, modifier: Modifier) {
+private fun FirstPageSkeleton(spoken: String, modifier: Modifier) {
+    val shimmer = rememberCommentShimmer()
     Column(
         modifier.padding(SheetContentPadding).focusable().semantics { contentDescription = spoken },
         verticalArrangement = Arrangement.spacedBy(8.dp),
@@ -115,7 +121,8 @@ private fun FirstPageSkeleton(shimmer: Brush, spoken: String, modifier: Modifier
 }
 
 @Composable
-private fun Skeletons(shimmer: Brush, count: Int, reply: Boolean, spoken: String?, modifier: Modifier) {
+private fun Skeletons(count: Int, reply: Boolean, spoken: String?, modifier: Modifier) {
+    val shimmer = rememberCommentShimmer()
     val announced = if (spoken == null) {
         modifier
     } else {
@@ -130,14 +137,14 @@ private fun Skeletons(shimmer: Brush, count: Int, reply: Boolean, spoken: String
 }
 
 @Composable
-private fun RowContent(row: CommentRow, state: CommentsState, shimmer: Brush, modifier: Modifier, onHidden: (String) -> Unit) {
+private fun RowContent(row: CommentRow, state: CommentsState, modifier: Modifier, onHidden: (String) -> Unit) {
     when (row) {
         is CommentRow.Top -> CommentCard(row.comment, row.repliesOpen, modifier, reply = false) { state.toggleReplies(row.comment) }
         is CommentRow.Reply -> CommentCard(row.comment, false, modifier.padding(start = REPLY_INDENT), reply = true) {}
         is CommentRow.LoadingReplies ->
-            Skeletons(shimmer, count = 2, reply = true, stringResource(R.string.comments_replies_loading), modifier)
-        is CommentRow.LoadingMoreReplies -> Skeletons(shimmer, count = 1, reply = true, spoken = null, modifier)
-        CommentRow.LoadingMore -> Skeletons(shimmer, NEXT_PAGE_SKELETONS, reply = false, spoken = null, modifier)
+            Skeletons(count = 2, reply = true, stringResource(R.string.comments_replies_loading), modifier)
+        is CommentRow.LoadingMoreReplies -> Skeletons(count = 1, reply = true, spoken = null, modifier)
+        CommentRow.LoadingMore -> Skeletons(NEXT_PAGE_SKELETONS, reply = false, spoken = null, modifier)
         is CommentRow.FailedReplies -> StatusRow(stringResource(R.string.comments_replies_failed), modifier) {
             state.toggleReplies(row.parent)
             state.toggleReplies(row.parent)
@@ -188,18 +195,23 @@ private fun CommentCard(comment: Comment, repliesOpen: Boolean, modifier: Modifi
                 contentAlignment = Alignment.Center,
             ) {
                 TextLabel(comment.author.take(1).uppercase(), Type.Label, maxLines = 1)
-                comment.avatarUrl?.let { AsyncImage(it, null, Modifier.size(if (reply) 26.dp else 32.dp), contentScale = ContentScale.Crop) }
+                comment.avatarUrl?.let { url ->
+                    val context = LocalContext.current
+                    val still = remember(url) { ImageRequest.Builder(context).data(url).decoderFactory(BitmapFactoryDecoder.Factory()).build() }
+                    AsyncImage(still, null, Modifier.size(if (reply) 26.dp else 32.dp), contentScale = ContentScale.Crop)
+                }
             }
-            TextLabel(comment.author, Type.Title, Modifier.weight(1f), maxLines = 1)
+            TextLabel(comment.author, Type.Title, Modifier.weight(1f, fill = false), maxLines = 1)
+            if (comment.published.isNotBlank()) TextLabel(comment.published, Type.Meta, maxLines = 1)
+            Spacer(Modifier.weight(1f))
             if (comment.pinned) Glyph(Icons.Rounded.PushPin, Palette.AccentSoft, 18)
             if (comment.hearted) Glyph(Icons.Rounded.Favorite, Palette.Accent, 18)
         }
-        if (comment.published.isNotBlank()) TextLabel(comment.published, Type.Meta, maxLines = 1)
-        Spacer(Modifier.height(8.dp))
+        Spacer(Modifier.height(6.dp))
         TextLabel(comment.text, Type.Body.copy(color = Palette.TextHigh), maxLines = if (reply) REPLY_BODY_LINES else BODY_LINES)
         val footer = listOfNotNull(commentLikesLabel(comment), commentRepliesLabel(comment).takeIf { !reply })
         if (footer.isNotEmpty()) {
-            Spacer(Modifier.height(8.dp))
+            Spacer(Modifier.height(6.dp))
             Row(horizontalArrangement = Arrangement.spacedBy(14.dp), verticalAlignment = Alignment.CenterVertically) {
                 footer.forEach { TextLabel(it, Type.Meta, maxLines = 1) }
                 if (canOpen) {
diff --git a/app/src/main/java/video/typetype/tv/ui/player/panel/DescriptionBlocks.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/panel/DescriptionBlocks.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/player/panel/DescriptionBlocks.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/panel/DescriptionBlocks.kt
diff --git a/app/src/main/java/video/typetype/tv/ui/player/panel/InfoPanel.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/panel/InfoPanel.kt
similarity index 95%
rename from app/src/main/java/video/typetype/tv/ui/player/panel/InfoPanel.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/panel/InfoPanel.kt
index b537b26..0b3c6e3 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/panel/InfoPanel.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/panel/InfoPanel.kt
@@ -46,13 +46,14 @@ import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.unit.dp
 import coil3.compose.AsyncImage
 import kotlinx.coroutines.launch
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.Video
 import video.typetype.tv.theme.Palette
 import video.typetype.tv.theme.Type
 import video.typetype.tv.ui.components.TextLabel
-import video.typetype.tv.ui.util.formatDuration
+import video.typetype.tv.ui.util.knownDuration
 import video.typetype.tv.ui.util.requestFocusWhenReady
+import video.typetype.tv.ui.util.metaLine
 
 private const val PAGE_FRACTION = 0.7f
 
@@ -63,9 +64,9 @@ fun InfoPanel(video: Video, onClose: () -> Unit) {
     val scroll = rememberScrollState()
     val scope = rememberCoroutineScope()
     var viewport by remember { mutableIntStateOf(0) }
-    val meta = listOf(video.views, video.age, formatDuration(video.durationSeconds)).filter { it.isNotBlank() }.joinToString("  ·  ")
+    val meta = metaLine(video.views, video.age, knownDuration(video.durationSeconds))
     val subscribers = video.channel.subscribers.takeIf { it.isNotBlank() }?.let { stringResource(R.string.detail_subscribers, it) }
-    val channel = listOfNotNull(video.channel.name, subscribers).joinToString("  ·  ")
+    val channel = metaLine(video.channel.name, subscribers)
     val paragraphs = DescriptionBlocks.build(video.description).ifEmpty { listOf(stringResource(R.string.info_no_description)) }
     val spoken = (listOf(video.title, channel, meta) + paragraphs).filter { it.isNotBlank() }.joinToString(". ")
     PlayerSheet(stringResource(R.string.menu_description), onClose) {
diff --git a/app/src/main/java/video/typetype/tv/ui/player/panel/PlayerMenuPanel.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/panel/PlayerMenuPanel.kt
similarity index 81%
rename from app/src/main/java/video/typetype/tv/ui/player/panel/PlayerMenuPanel.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/panel/PlayerMenuPanel.kt
index d29a3d5..8473fd7 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/panel/PlayerMenuPanel.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/panel/PlayerMenuPanel.kt
@@ -3,6 +3,7 @@ package video.typetype.tv.ui.player.panel
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.rounded.Analytics
 import androidx.compose.material.icons.rounded.BookmarkAdd
@@ -17,6 +18,7 @@ import androidx.compose.material.icons.rounded.Info
 import androidx.compose.material.icons.rounded.NotificationsNone
 import androidx.compose.material.icons.rounded.PlaylistAdd
 import androidx.compose.material.icons.rounded.PlaylistPlay
+import androidx.compose.material.icons.rounded.Speed
 import androidx.compose.material.icons.rounded.Subtitles
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
@@ -27,7 +29,7 @@ import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.VideoActivity
 import video.typetype.tv.ui.util.requestFocusWhenReady
 
@@ -40,6 +42,7 @@ data class PlayerMenuModel(
     val canSubscribe: Boolean,
     val audioOnly: Boolean,
     val statsOn: Boolean,
+    val speedLabel: String,
 )
 
 class PlayerMenuActions(
@@ -51,6 +54,7 @@ class PlayerMenuActions(
     val onWatchLater: () -> Unit,
     val onSubscribe: () -> Unit,
     val onPlaylists: () -> Unit,
+    val onSpeed: () -> Unit,
     val onAudioOnly: () -> Unit,
     val onCaptionStyle: () -> Unit,
     val onStats: () -> Unit,
@@ -65,9 +69,15 @@ private class MenuEntry(
 )
 
 @Composable
-fun PlayerMenuPanel(model: PlayerMenuModel, actions: PlayerMenuActions, onClose: () -> Unit) {
+fun PlayerMenuPanel(
+    model: PlayerMenuModel,
+    actions: PlayerMenuActions,
+    onClose: () -> Unit,
+    initialEntry: String? = null,
+    onEntry: (String) -> Unit = {},
+) {
     val entry = remember { FocusRequester() }
-    LaunchedEffect(Unit) { entry.requestFocusWhenReady() }
+    val listState = rememberLazyListState()
     val on = stringResource(R.string.menu_toggle_on)
     val off = stringResource(R.string.menu_toggle_off)
     val entries = buildList {
@@ -104,21 +114,31 @@ fun PlayerMenuPanel(model: PlayerMenuModel, actions: PlayerMenuActions, onClose:
             )
         }
         add(MenuEntry("playlists", stringResource(R.string.menu_playlists), Icons.Rounded.PlaylistAdd, onClick = actions.onPlaylists))
+        add(MenuEntry("speed", stringResource(R.string.menu_speed), Icons.Rounded.Speed, model.speedLabel, actions.onSpeed))
         add(MenuEntry("audio-only", stringResource(R.string.menu_audio_only), Icons.Rounded.Headphones, if (model.audioOnly) on else off, actions.onAudioOnly))
         if (model.captionsAvailable) {
             add(MenuEntry("caption-style", stringResource(R.string.menu_caption_style), Icons.Rounded.Subtitles, onClick = actions.onCaptionStyle))
         }
         add(MenuEntry("stats", stringResource(R.string.menu_stats), Icons.Rounded.Analytics, if (model.statsOn) on else off, actions.onStats))
     }
+    // Coming back from a section, the row that opened it has the focus again.
+    val start = entries.indexOfFirst { it.key == initialEntry }.coerceAtLeast(0)
+    LaunchedEffect(Unit) {
+        listState.scrollToItem(start)
+        entry.requestFocusWhenReady()
+    }
     PlayerSheet(stringResource(R.string.menu_title), onClose) {
-        LazyColumn(contentPadding = SheetContentPadding, verticalArrangement = Arrangement.spacedBy(8.dp)) {
+        LazyColumn(state = listState, contentPadding = SheetContentPadding, verticalArrangement = Arrangement.spacedBy(8.dp)) {
             itemsIndexed(entries, key = { _, item -> item.key }) { index, item ->
                 SheetRow(
                     label = item.label,
                     value = item.value,
                     icon = item.icon,
-                    onClick = item.onClick,
-                    modifier = if (index == 0) Modifier.focusRequester(entry) else Modifier,
+                    onClick = {
+                        onEntry(item.key)
+                        item.onClick()
+                    },
+                    modifier = if (index == start) Modifier.focusRequester(entry) else Modifier,
                 )
             }
         }
diff --git a/app/src/main/java/video/typetype/tv/ui/player/panel/PlayerPanelHost.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/panel/PlayerPanelHost.kt
similarity index 75%
rename from app/src/main/java/video/typetype/tv/ui/player/panel/PlayerPanelHost.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/panel/PlayerPanelHost.kt
index 4d8e9bc..40c7834 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/panel/PlayerPanelHost.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/panel/PlayerPanelHost.kt
@@ -1,9 +1,7 @@
 package video.typetype.tv.ui.player.panel
 
-import androidx.compose.foundation.layout.Box
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
-import androidx.compose.ui.Modifier
 import kotlinx.coroutines.CoroutineScope
 import video.typetype.tv.data.CaptionStyles
 import video.typetype.tv.data.ContentRepository
@@ -16,6 +14,8 @@ import video.typetype.tv.ui.detail.VideoActivityController
 import video.typetype.tv.ui.player.ChapterPosition
 import video.typetype.tv.ui.player.PlayerChoices
 import video.typetype.tv.ui.player.PlayerPanel
+import video.typetype.tv.ui.player.SPEED_CHOICES
+import video.typetype.tv.ui.player.speedLabel
 
 class PanelScene(
     val video: Video,
@@ -31,6 +31,9 @@ class PanelScene(
     val onCaptionStyles: (CaptionStyles) -> Unit,
     val onSeek: (Long) -> Unit,
     val onOpenVideo: (Video) -> Unit,
+    val onOpenChannel: (String) -> Unit,
+    val menuEntry: String?,
+    val onMenuEntry: (String) -> Unit,
     val qualityHeights: List<Int>,
     val qualitySelected: Int?,
     val playingHeight: Int?,
@@ -41,9 +44,10 @@ class PanelScene(
 )
 
 @Composable
-fun PlayerPanelHost(panel: PlayerPanel?, onPanel: (PlayerPanel?) -> Unit, scene: PanelScene) {
+fun PlayerPanelHost(panel: PlayerPanel?, onPanel: (PlayerPanel?) -> Unit, scene: PanelScene, openedFromMenu: Boolean = true) {
     val video = scene.video
-    val backToMenu = { onPanel(PlayerPanel.Menu) }
+    // A section reached from the player's shortcut row closes back to the video, not to a menu never opened.
+    val backToMenu = { onPanel(if (openedFromMenu) PlayerPanel.Menu else null) }
     when (panel) {
         null -> Unit
         PlayerPanel.Menu -> PlayerMenuPanel(
@@ -56,6 +60,7 @@ fun PlayerPanelHost(panel: PlayerPanel?, onPanel: (PlayerPanel?) -> Unit, scene:
                 canSubscribe = video.channel.url.isNotBlank(),
                 audioOnly = scene.choices.audioOnly,
                 statsOn = scene.choices.statsOn,
+                speedLabel = speedLabel(scene.choices.speedIndex),
             ),
             actions = PlayerMenuActions(
                 onChapters = { onPanel(PlayerPanel.Chapters) },
@@ -66,11 +71,14 @@ fun PlayerPanelHost(panel: PlayerPanel?, onPanel: (PlayerPanel?) -> Unit, scene:
                 onWatchLater = { scene.activity.setWatchLater(video, !scene.activity.activity.watchLater) },
                 onSubscribe = { scene.activity.setSubscribed(video, !scene.activity.activity.subscribed) },
                 onPlaylists = { onPanel(PlayerPanel.Playlists) },
+                onSpeed = { scene.choices.speedIndex = (scene.choices.speedIndex + 1) % SPEED_CHOICES.size },
                 onAudioOnly = { scene.choices.audioOnly = !scene.choices.audioOnly },
                 onCaptionStyle = { onPanel(PlayerPanel.CaptionStyle) },
                 onStats = { scene.choices.statsOn = !scene.choices.statsOn },
             ),
             onClose = { onPanel(null) },
+            initialEntry = scene.menuEntry,
+            onEntry = scene.onMenuEntry,
         )
         PlayerPanel.Chapters -> ChaptersPanel(
             chapters = video.chapters,
@@ -82,6 +90,17 @@ fun PlayerPanelHost(panel: PlayerPanel?, onPanel: (PlayerPanel?) -> Unit, scene:
             onClose = backToMenu,
         )
         PlayerPanel.Info -> InfoPanel(video, onClose = backToMenu)
+        PlayerPanel.Channel -> ChannelPanel(
+            channel = video.channel,
+            repository = scene.repository,
+            actions = ChannelCardActions(
+                subscribed = scene.activity.activity.subscribed,
+                canSubscribe = video.channel.url.isNotBlank(),
+                onSubscribe = { scene.activity.setSubscribed(video, it) },
+                onOpenChannel = { scene.onOpenChannel(video.channel.url) },
+            ),
+            onClose = { onPanel(null) },
+        )
         PlayerPanel.Comments -> CommentsPanel(
             state = scene.comments,
             onClose = backToMenu,
@@ -101,11 +120,9 @@ fun PlayerPanelHost(panel: PlayerPanel?, onPanel: (PlayerPanel?) -> Unit, scene:
         )
         PlayerPanel.Queue -> QueuePanel(scene.queue, onSelect = scene.onOpenVideo, onClose = backToMenu)
         PlayerPanel.CaptionStyle -> CaptionStylePanel(scene.captionStyles, scene.onCaptionStyles, onClose = backToMenu)
-        PlayerPanel.Playlists -> Box(Modifier.closeOnBack(backToMenu)) {
-            PlaylistPicker(
-                state = remember(video.id) { PlaylistPickerState(video, scene.repository, scene.scope) },
-                onClose = backToMenu,
-            )
-        }
+        PlayerPanel.Playlists -> PlaylistPicker(
+            state = remember(video.id) { PlaylistPickerState(video, scene.repository, scene.scope) },
+            onClose = backToMenu,
+        )
     }
 }
diff --git a/app/src/main/java/video/typetype/tv/ui/player/panel/PlayerSheet.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/panel/PlayerSheet.kt
similarity index 51%
rename from app/src/main/java/video/typetype/tv/ui/player/panel/PlayerSheet.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/panel/PlayerSheet.kt
index e22833c..9a4db6d 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/panel/PlayerSheet.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/panel/PlayerSheet.kt
@@ -1,29 +1,28 @@
 package video.typetype.tv.ui.player.panel
 
 import androidx.activity.compose.BackHandler
+import androidx.compose.animation.core.Animatable
+import androidx.compose.animation.core.FastOutSlowInEasing
+import androidx.compose.animation.core.tween
 import androidx.compose.foundation.background
 import androidx.compose.foundation.focusGroup
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.BoxScope
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxHeight
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.remember
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clipToBounds
-import androidx.compose.ui.input.key.Key
-import androidx.compose.ui.input.key.KeyEventType
-import androidx.compose.ui.input.key.key
-import androidx.compose.ui.input.key.onPreviewKeyEvent
-import androidx.compose.ui.input.key.type
+import androidx.compose.ui.graphics.graphicsLayer
 import androidx.compose.ui.semantics.paneTitle
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.unit.dp
@@ -31,8 +30,11 @@ import video.typetype.tv.theme.Dimens
 import video.typetype.tv.theme.Palette
 import video.typetype.tv.theme.Type
 import video.typetype.tv.ui.components.TextLabel
+import video.typetype.tv.ui.util.LocalPerformance
 
-private val PANEL_WIDTH = 540.dp
+val SheetWidth = 540.dp
+private val SheetShape = RoundedCornerShape(topStart = 28.dp, bottomStart = 28.dp)
+private const val SLIDE_MILLIS = 220
 
 val SheetContentPadding = PaddingValues(start = 8.dp, end = 8.dp, top = 12.dp, bottom = 28.dp)
 
@@ -41,34 +43,37 @@ fun PlayerSheet(
     title: String,
     onClose: () -> Unit,
     modifier: Modifier = Modifier,
+    showTitle: Boolean = true,
+    background: @Composable BoxScope.() -> Unit = {},
     content: @Composable BoxScope.() -> Unit,
 ) {
     BackHandler(onBack = onClose)
-    Box(modifier.fillMaxSize().closeOnBack(onClose)) {
-        Column(
+    // The sheet slides in from the edge on its own layer, so the move costs the box no new drawing of the text.
+    val smooth = LocalPerformance.current.smoothAnimations
+    val hidden = remember { Animatable(if (smooth) 1f else 0f) }
+    LaunchedEffect(Unit) { hidden.animateTo(0f, tween(SLIDE_MILLIS, easing = FastOutSlowInEasing)) }
+    Box(modifier.fillMaxSize()) {
+        Box(
             modifier = Modifier
                 .align(Alignment.CenterEnd)
-                .width(PANEL_WIDTH)
+                .width(SheetWidth)
                 .fillMaxHeight()
-                .background(Palette.Ink, RoundedCornerShape(topStart = 28.dp, bottomStart = 28.dp))
-                .padding(start = 28.dp, end = Dimens.SafeEnd - 8.dp, top = Dimens.SafeTop + 22.dp)
+                .graphicsLayer {
+                    translationX = size.width * hidden.value
+                    shape = SheetShape
+                    clip = true
+                }
+                .background(Palette.Ink)
                 .semantics { paneTitle = title }
                 .focusGroup(),
         ) {
-            TextLabel(title, Type.Headline, maxLines = 1)
-            Spacer(Modifier.height(6.dp))
-            Box(Modifier.weight(1f).fillMaxWidth().clipToBounds()) {
-                content()
+            background()
+            Column(Modifier.fillMaxSize().padding(start = 20.dp, end = Dimens.SafeEnd - 16.dp, top = Dimens.SafeTop)) {
+                if (showTitle) TextLabel(title, Type.Headline, Modifier.padding(start = 8.dp), maxLines = 1)
+                Box(Modifier.weight(1f).fillMaxWidth().clipToBounds()) {
+                    content()
+                }
             }
         }
     }
 }
-
-fun Modifier.closeOnBack(onClose: () -> Unit): Modifier = onPreviewKeyEvent { event ->
-    if (event.key == Key.Back) {
-        if (event.type == KeyEventType.KeyUp) onClose()
-        true
-    } else {
-        false
-    }
-}
diff --git a/app/src/main/java/video/typetype/tv/ui/player/panel/QualityPanel.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/panel/QualityPanel.kt
similarity index 98%
rename from app/src/main/java/video/typetype/tv/ui/player/panel/QualityPanel.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/panel/QualityPanel.kt
index 11a188e..53253c6 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/panel/QualityPanel.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/panel/QualityPanel.kt
@@ -13,7 +13,7 @@ import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.ui.util.requestFocusWhenReady
 
 data class QualityChoice(val height: Int?, val label: String, val value: String?, val current: Boolean)
diff --git a/app/src/main/java/video/typetype/tv/ui/player/panel/QueuePanel.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/panel/QueuePanel.kt
similarity index 92%
rename from app/src/main/java/video/typetype/tv/ui/player/panel/QueuePanel.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/panel/QueuePanel.kt
index 5ce2f72..db49070 100644
--- a/app/src/main/java/video/typetype/tv/ui/player/panel/QueuePanel.kt
+++ b/feature/player/src/main/java/video/typetype/tv/ui/player/panel/QueuePanel.kt
@@ -21,14 +21,15 @@ import androidx.compose.ui.layout.ContentScale
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import coil3.compose.AsyncImage
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.Video
 import video.typetype.tv.theme.Palette
 import video.typetype.tv.theme.Shapes
 import video.typetype.tv.theme.Type
 import video.typetype.tv.ui.components.TextLabel
-import video.typetype.tv.ui.util.formatDuration
+import video.typetype.tv.ui.util.knownDuration
 import video.typetype.tv.ui.util.requestFocusWhenReady
+import video.typetype.tv.ui.util.metaLine
 
 private val THUMBNAIL_WIDTH = 120.dp
 
@@ -52,7 +53,7 @@ fun QueuePanel(queue: List<Video>, onSelect: (Video) -> Unit, onClose: () -> Uni
                     Column(Modifier.weight(1f)) {
                         TextLabel(video.title, Type.Title.copy(color = if (focused) Palette.Ink else Palette.TextHigh), maxLines = 2)
                         TextLabel(
-                            listOf(video.channel.name, formatDuration(video.durationSeconds)).filter { it.isNotBlank() }.joinToString("  ·  "),
+                            metaLine(video.channel.name, knownDuration(video.durationSeconds)),
                             Type.Meta.copy(color = if (focused) Palette.Ink else Palette.TextMid),
                             maxLines = 1,
                         )
diff --git a/app/src/main/java/video/typetype/tv/ui/player/panel/ReadingRow.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/panel/ReadingRow.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/player/panel/ReadingRow.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/panel/ReadingRow.kt
diff --git a/app/src/main/java/video/typetype/tv/ui/player/panel/SheetRow.kt b/feature/player/src/main/java/video/typetype/tv/ui/player/panel/SheetRow.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/player/panel/SheetRow.kt
rename to feature/player/src/main/java/video/typetype/tv/ui/player/panel/SheetRow.kt
diff --git a/feature/player/src/test/java/video/typetype/tv/ui/SeekMathTest.kt b/feature/player/src/test/java/video/typetype/tv/ui/SeekMathTest.kt
new file mode 100644
index 0000000..2274156
--- /dev/null
+++ b/feature/player/src/test/java/video/typetype/tv/ui/SeekMathTest.kt
@@ -0,0 +1,59 @@
+package video.typetype.tv.ui
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import video.typetype.tv.ui.player.SeekMath
+
+class SeekMathTest {
+    @Test
+    fun `every scrub starts with five seconds and grows a little each press`() {
+        val tenHours = 36_000_000L
+        val steps = (0..6).map { SeekMath.scrubStep(it, tenHours) }
+        assertEquals(5_000L, steps.first())
+        steps.zipWithNext().forEach { (a, b) -> assertTrue("$a then $b", b > a && b <= a * 11 / 10) }
+    }
+
+    @Test
+    fun `one second held moves a few minutes`() {
+        val moved = (0 until 20).sumOf { SeekMath.scrubStep(it, 7_200_000L) }
+        assertTrue("moved $moved", moved in 120_000L..240_000L)
+    }
+
+    @Test
+    fun `a short video tops out at fifteen seconds a press`() {
+        assertEquals(5_000L, SeekMath.scrubStep(0, 600_000L))
+        assertEquals(15_000L, SeekMath.scrubStep(30, 600_000L))
+        assertEquals(10_000L, SeekMath.scrubStep(30, 120_000L))
+    }
+
+    @Test
+    fun `a ten hour stream reaches its middle in about five seconds of holding`() {
+        val tenHours = 36_000_000L
+        var position = 0L
+        var presses = 0
+        while (position < tenHours / 2) position += SeekMath.scrubStep(presses++, tenHours)
+        assertTrue("took $presses presses", presses in 90..130)
+        assertEquals(900_000L, SeekMath.scrubStep(200, tenHours))
+    }
+
+    @Test
+    fun `target never leaves the media bounds`() {
+        assertEquals(0L, SeekMath.target(3_000L, -10_000L, 40_000L))
+        assertEquals(40_000L, SeekMath.target(35_000L, 10_000L, 40_000L))
+        assertEquals(18_000L, SeekMath.target(8_000L, 10_000L, 40_000L))
+    }
+
+    @Test
+    fun `target is zero when the duration is unknown`() {
+        assertEquals(0L, SeekMath.target(5_000L, 5_000L, -1L))
+    }
+
+    @Test
+    fun `fraction is clamped and safe for unknown duration`() {
+        assertEquals(0f, SeekMath.fraction(1_000L, 0L), 0f)
+        assertEquals(0.5f, SeekMath.fraction(20_000L, 40_000L), 0.0001f)
+        assertEquals(1f, SeekMath.fraction(90_000L, 40_000L), 0f)
+        assertEquals(0f, SeekMath.fraction(-5L, 40_000L), 0f)
+    }
+}
diff --git a/app/src/test/java/video/typetype/tv/ui/player/CaptionStyleTest.kt b/feature/player/src/test/java/video/typetype/tv/ui/player/CaptionStyleTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/ui/player/CaptionStyleTest.kt
rename to feature/player/src/test/java/video/typetype/tv/ui/player/CaptionStyleTest.kt
diff --git a/app/src/test/java/video/typetype/tv/ui/player/CommentRowsTest.kt b/feature/player/src/test/java/video/typetype/tv/ui/player/CommentRowsTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/ui/player/CommentRowsTest.kt
rename to feature/player/src/test/java/video/typetype/tv/ui/player/CommentRowsTest.kt
diff --git a/app/src/test/java/video/typetype/tv/ui/player/DanmakuLayoutTest.kt b/feature/player/src/test/java/video/typetype/tv/ui/player/DanmakuLayoutTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/ui/player/DanmakuLayoutTest.kt
rename to feature/player/src/test/java/video/typetype/tv/ui/player/DanmakuLayoutTest.kt
diff --git a/app/src/test/java/video/typetype/tv/ui/player/DescriptionBlocksTest.kt b/feature/player/src/test/java/video/typetype/tv/ui/player/DescriptionBlocksTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/ui/player/DescriptionBlocksTest.kt
rename to feature/player/src/test/java/video/typetype/tv/ui/player/DescriptionBlocksTest.kt
diff --git a/feature/player/src/test/java/video/typetype/tv/ui/player/FrameDropJudgeTest.kt b/feature/player/src/test/java/video/typetype/tv/ui/player/FrameDropJudgeTest.kt
new file mode 100644
index 0000000..32a1f5d
--- /dev/null
+++ b/feature/player/src/test/java/video/typetype/tv/ui/player/FrameDropJudgeTest.kt
@@ -0,0 +1,61 @@
+package video.typetype.tv.ui.player
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class FrameDropJudgeTest {
+    private fun feed(judge: FrameDropJudge, renderedPerSample: Int, droppedPerSample: Int, samples: Int): Boolean {
+        var rendered = 0
+        var dropped = 0
+        var verdict = false
+        repeat(samples) {
+            rendered += renderedPerSample
+            dropped += droppedPerSample
+            verdict = judge.struggling(rendered, dropped)
+        }
+        return verdict
+    }
+
+    @Test
+    fun aDecoderThatKeepsUpIsLeftAlone() {
+        assertFalse(feed(FrameDropJudge(), renderedPerSample = 60, droppedPerSample = 2, samples = 10))
+    }
+
+    @Test
+    fun aQuarterOfTheFramesDroppedForTenSecondsMeansTheBoxStruggles() {
+        assertTrue(feed(FrameDropJudge(), renderedPerSample = 80, droppedPerSample = 30, samples = 6))
+    }
+
+    @Test
+    fun aFewDroppedFramesAreNotEnough() {
+        assertFalse(feed(FrameDropJudge(), renderedPerSample = 110, droppedPerSample = 10, samples = 6))
+    }
+
+    @Test
+    fun aShortBurstIsNotEnough() {
+        val judge = FrameDropJudge()
+        judge.struggling(0, 0)
+        judge.struggling(60, 80)
+        judge.struggling(120, 80)
+        judge.struggling(180, 80)
+        judge.struggling(240, 80)
+        assertFalse(judge.struggling(300, 80))
+    }
+
+    @Test
+    fun aNewDecoderStartsTheCountAgain() {
+        val judge = FrameDropJudge()
+        judge.struggling(500, 100)
+        judge.struggling(550, 120)
+        assertFalse(judge.struggling(10, 0))
+        assertFalse(judge.struggling(60, 2))
+    }
+
+    @Test
+    fun androidsOwnDecodersAreSoftware() {
+        assertTrue(PlaybackStatsFormat.isSoftwareDecoder("c2.android.vp9.decoder"))
+        assertFalse(PlaybackStatsFormat.isSoftwareDecoder("OMX.vendor.avc.decoder"))
+        assertFalse(PlaybackStatsFormat.isSoftwareDecoder(null))
+    }
+}
diff --git a/app/src/test/java/video/typetype/tv/ui/player/LiveEdgeTest.kt b/feature/player/src/test/java/video/typetype/tv/ui/player/LiveEdgeTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/ui/player/LiveEdgeTest.kt
rename to feature/player/src/test/java/video/typetype/tv/ui/player/LiveEdgeTest.kt
diff --git a/app/src/test/java/video/typetype/tv/ui/player/PlayerOptionsTest.kt b/feature/player/src/test/java/video/typetype/tv/ui/player/PlayerOptionsTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/ui/player/PlayerOptionsTest.kt
rename to feature/player/src/test/java/video/typetype/tv/ui/player/PlayerOptionsTest.kt
diff --git a/app/src/test/java/video/typetype/tv/ui/player/PlayerPanelLogicTest.kt b/feature/player/src/test/java/video/typetype/tv/ui/player/PlayerPanelLogicTest.kt
similarity index 98%
rename from app/src/test/java/video/typetype/tv/ui/player/PlayerPanelLogicTest.kt
rename to feature/player/src/test/java/video/typetype/tv/ui/player/PlayerPanelLogicTest.kt
index dcd43f5..1651c91 100644
--- a/app/src/test/java/video/typetype/tv/ui/player/PlayerPanelLogicTest.kt
+++ b/feature/player/src/test/java/video/typetype/tv/ui/player/PlayerPanelLogicTest.kt
@@ -3,7 +3,7 @@ package video.typetype.tv.ui.player
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNull
 import org.junit.Test
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.Chapter
 import video.typetype.tv.data.SponsorSegment
 
diff --git a/app/src/test/java/video/typetype/tv/ui/player/QualityChoicesTest.kt b/feature/player/src/test/java/video/typetype/tv/ui/player/QualityChoicesTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/ui/player/QualityChoicesTest.kt
rename to feature/player/src/test/java/video/typetype/tv/ui/player/QualityChoicesTest.kt
diff --git a/feature/player/src/test/java/video/typetype/tv/ui/player/QualityStepsTest.kt b/feature/player/src/test/java/video/typetype/tv/ui/player/QualityStepsTest.kt
new file mode 100644
index 0000000..9dd1065
--- /dev/null
+++ b/feature/player/src/test/java/video/typetype/tv/ui/player/QualityStepsTest.kt
@@ -0,0 +1,20 @@
+package video.typetype.tv.ui.player
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class QualityStepsTest {
+    private val heights = listOf(2160, 1440, 1080, 720, 480)
+
+    @Test
+    fun aFailedQualityStepsDownByOne() {
+        assertEquals(1440, QualitySteps.below(heights, 2160))
+        assertEquals(720, QualitySteps.below(heights, 1080))
+    }
+
+    @Test
+    fun theLowestQualityHasNothingBelow() {
+        assertNull(QualitySteps.below(heights, 480))
+    }
+}
diff --git a/feature/player/src/test/java/video/typetype/tv/ui/player/RowFitTest.kt b/feature/player/src/test/java/video/typetype/tv/ui/player/RowFitTest.kt
new file mode 100644
index 0000000..ec4f250
--- /dev/null
+++ b/feature/player/src/test/java/video/typetype/tv/ui/player/RowFitTest.kt
@@ -0,0 +1,22 @@
+package video.typetype.tv.ui.player
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class RowFitTest {
+    @Test
+    fun shortLabelsKeepTheirPills() {
+        assertFalse(RowFit.overflows(listOf(60f, 30f, 80f), circles = 3, availableDp = 600f))
+    }
+
+    @Test
+    fun aLongAudioTrackNameTurnsTheChoicesRound() {
+        assertTrue(RowFit.overflows(listOf(60f, 140f, 30f, 80f), circles = 3, availableDp = 560f))
+    }
+
+    @Test
+    fun aVeryLongLabelCountsOnlyUpToItsCap() {
+        assertFalse(RowFit.overflows(listOf(900f), circles = 2, availableDp = 320f))
+    }
+}
diff --git a/app/src/test/java/video/typetype/tv/ui/player/ScrubAndUpNextTest.kt b/feature/player/src/test/java/video/typetype/tv/ui/player/ScrubAndUpNextTest.kt
similarity index 77%
rename from app/src/test/java/video/typetype/tv/ui/player/ScrubAndUpNextTest.kt
rename to feature/player/src/test/java/video/typetype/tv/ui/player/ScrubAndUpNextTest.kt
index 70c21a4..ae1314d 100644
--- a/app/src/test/java/video/typetype/tv/ui/player/ScrubAndUpNextTest.kt
+++ b/feature/player/src/test/java/video/typetype/tv/ui/player/ScrubAndUpNextTest.kt
@@ -14,41 +14,53 @@ class ScrubAndUpNextTest {
     fun aScrubStartsFromTheCurrentPositionAndAccumulates() {
         val scrub = ScrubState()
         assertFalse(scrub.active)
-        scrub.move(60_000, 5_000, hour)
-        scrub.move(60_000, 5_000, hour)
-        assertEquals(70_000L, scrub.target)
+        scrub.move(60_000, 1, hour)
+        scrub.move(60_000, 1, hour)
+        assertEquals(70_250L, scrub.target)
         assertTrue(scrub.active)
     }
 
     @Test
     fun aScrubIsClampedToTheVideo() {
         val scrub = ScrubState()
-        scrub.move(2_000, -10_000, hour)
+        scrub.move(2_000, -1, hour)
         assertEquals(0L, scrub.target)
-        scrub.move(0, hour * 2, hour)
-        assertEquals(hour, scrub.target)
+        val end = ScrubState()
+        end.move(hour - 1_000, 1, hour)
+        assertEquals(hour, end.target)
+    }
+
+    @Test
+    fun tappingAgainMovesFurtherEachTime() {
+        val scrub = ScrubState()
+        val steps = (1..16).map {
+            val before = scrub.target ?: 0L
+            scrub.move(0, 1, hour)
+            checkNotNull(scrub.target) - before
+        }
+        assertEquals(5_000L, steps.first())
+        assertTrue(steps.zipWithNext().all { (a, b) -> b >= a })
+        assertTrue(steps.last() in 10_000L..11_000L)
     }
 
     @Test
     fun commitReturnsTheTargetOnceAndCancelDropsIt() {
         val scrub = ScrubState()
-        scrub.move(10_000, 10_000, hour)
-        assertEquals(20_000L, scrub.commit())
+        scrub.move(10_000, 1, hour)
+        assertEquals(15_000L, scrub.commit())
         assertNull(scrub.commit())
-        scrub.move(10_000, 10_000, hour)
+        scrub.move(10_000, 1, hour)
+        assertEquals(15_000L, scrub.target)
         scrub.cancel()
         assertFalse(scrub.active)
         assertNull(scrub.commit())
     }
 
     @Test
-    fun scrubStepsGrowWithTheRepeatCountAndTheVideoLength() {
+    fun scrubStepsGrowWithThePressesUpToAShareOfTheVideo() {
         assertEquals(5_000L, SeekMath.scrubStep(0, hour))
-        assertEquals(10_000L, SeekMath.scrubStep(3, hour))
-        assertEquals(18_000L, SeekMath.scrubStep(8, hour))
-        assertEquals(60_000L, SeekMath.scrubStep(20, hour))
-        assertEquals(15_000L, SeekMath.scrubStep(8, 60_000L))
-        assertEquals(30_000L, SeekMath.scrubStep(20, 60_000L))
+        assertEquals(5_250L, SeekMath.scrubStep(1, hour))
+        assertEquals(90_000L, SeekMath.scrubStep(200, hour))
     }
 
     @Test
diff --git a/app/src/test/java/video/typetype/tv/ui/player/SeekMarkersTest.kt b/feature/player/src/test/java/video/typetype/tv/ui/player/SeekMarkersTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/ui/player/SeekMarkersTest.kt
rename to feature/player/src/test/java/video/typetype/tv/ui/player/SeekMarkersTest.kt
diff --git a/app/src/test/java/video/typetype/tv/ui/player/StoryboardTest.kt b/feature/player/src/test/java/video/typetype/tv/ui/player/StoryboardTest.kt
similarity index 100%
rename from app/src/test/java/video/typetype/tv/ui/player/StoryboardTest.kt
rename to feature/player/src/test/java/video/typetype/tv/ui/player/StoryboardTest.kt
diff --git a/feature/search/build.gradle.kts b/feature/search/build.gradle.kts
new file mode 100644
index 0000000..c357761
--- /dev/null
+++ b/feature/search/build.gradle.kts
@@ -0,0 +1,14 @@
+plugins {
+    alias(libs.plugins.typetype.android.compose)
+}
+
+android {
+    namespace = "video.typetype.tv.feature.search"
+}
+
+dependencies {
+    implementation(project(":core:ui"))
+
+    testImplementation(project(":core:testing"))
+    testImplementation(libs.junit)
+}
diff --git a/feature/search/src/main/AndroidManifest.xml b/feature/search/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..32895f6
--- /dev/null
+++ b/feature/search/src/main/AndroidManifest.xml
@@ -0,0 +1,14 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <!-- Voice search: the microphone is optional, so TVs without one still install the app. -->
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
+    <uses-feature
+        android:name="android.hardware.microphone"
+        android:required="false" />
+
+    <queries>
+        <intent>
+            <action android:name="android.speech.RecognitionService" />
+        </intent>
+    </queries>
+</manifest>
diff --git a/app/src/main/java/video/typetype/tv/ui/search/CollectionResults.kt b/feature/search/src/main/java/video/typetype/tv/ui/search/CollectionResults.kt
similarity index 85%
rename from app/src/main/java/video/typetype/tv/ui/search/CollectionResults.kt
rename to feature/search/src/main/java/video/typetype/tv/ui/search/CollectionResults.kt
index 41c08bb..4f321fb 100644
--- a/app/src/main/java/video/typetype/tv/ui/search/CollectionResults.kt
+++ b/feature/search/src/main/java/video/typetype/tv/ui/search/CollectionResults.kt
@@ -18,7 +18,9 @@ import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
 import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
@@ -32,7 +34,7 @@ import androidx.compose.ui.semantics.contentDescription
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.unit.dp
 import coil3.compose.AsyncImage
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.ChannelSummary
 import video.typetype.tv.data.PublicPlaylist
 import video.typetype.tv.theme.Palette
@@ -40,6 +42,8 @@ import video.typetype.tv.theme.Shapes
 import video.typetype.tv.theme.Type
 import video.typetype.tv.ui.components.FocusSurface
 import video.typetype.tv.ui.components.TextLabel
+import video.typetype.tv.ui.util.LoadMoreNearEnd
+import video.typetype.tv.ui.util.metaLine
 
 @Composable
 fun PlaylistResults(
@@ -47,8 +51,9 @@ fun PlaylistResults(
     onOpen: (PublicPlaylist) -> Unit,
     entry: FocusRequester,
     modifier: Modifier = Modifier,
+    paging: CollectionPaging = CollectionPaging(),
 ) {
-    CollectionList(playlists, modifier, entry, key = { it.url }) { playlist, rowModifier ->
+    CollectionList(playlists, modifier, entry, paging, key = { it.url }) { playlist, rowModifier ->
         val count = stringResource(R.string.playlist_video_count, playlist.count.toString())
         val description = stringResource(
             R.string.card_description,
@@ -63,7 +68,7 @@ fun PlaylistResults(
                 TextLabel(playlist.title, Type.Title, maxLines = 2)
                 Spacer(Modifier.height(4.dp))
                 TextLabel(
-                    "${playlist.uploader}  ·  ${stringResource(R.string.playlist_video_count, playlist.count.toString())}",
+                    metaLine(playlist.uploader, stringResource(R.string.playlist_video_count, playlist.count.toString())),
                     Type.Meta,
                     maxLines = 1,
                 )
@@ -78,8 +83,9 @@ fun ChannelResults(
     onOpen: (ChannelSummary) -> Unit,
     entry: FocusRequester,
     modifier: Modifier = Modifier,
+    paging: CollectionPaging = CollectionPaging(),
 ) {
-    CollectionList(channels, modifier, entry, key = { it.url }) { channel, rowModifier ->
+    CollectionList(channels, modifier, entry, paging, key = { it.url }) { channel, rowModifier ->
         val subscribers = if (channel.subscribers.isBlank()) "" else stringResource(R.string.detail_subscribers, channel.subscribers)
         val description = if (subscribers.isBlank()) channel.name else stringResource(R.string.card_description, channel.name, subscribers)
         CollectionRow(onClick = { onOpen(channel) }, description = description, modifier = rowModifier) {
@@ -106,10 +112,14 @@ private fun <T> CollectionList(
     items: List<T>,
     modifier: Modifier,
     entry: FocusRequester,
+    paging: CollectionPaging,
     key: (T) -> Any,
     row: @Composable (T, Modifier) -> Unit,
 ) {
+    val listState = rememberLazyListState()
+    LoadMoreNearEnd(listState, items.size, paging.onNearEnd)
     LazyColumn(
+        state = listState,
         modifier = modifier,
         contentPadding = PaddingValues(top = 6.dp, bottom = 40.dp, end = 8.dp, start = 6.dp),
         verticalArrangement = Arrangement.spacedBy(10.dp),
@@ -117,9 +127,14 @@ private fun <T> CollectionList(
         itemsIndexed(items, key = { _, item -> key(item) }) { index, item ->
             row(item, if (index == 0) Modifier.focusRequester(entry) else Modifier)
         }
+        if (paging.loadingMore) {
+            items(MORE_SKELETONS) { ResultRowSkeleton() }
+        }
     }
 }
 
+class CollectionPaging(val loadingMore: Boolean = false, val onNearEnd: () -> Unit = {})
+
 @Composable
 private fun CollectionRow(
     onClick: () -> Unit,
diff --git a/feature/search/src/main/java/video/typetype/tv/ui/search/QueryField.kt b/feature/search/src/main/java/video/typetype/tv/ui/search/QueryField.kt
new file mode 100644
index 0000000..e052b30
--- /dev/null
+++ b/feature/search/src/main/java/video/typetype/tv/ui/search/QueryField.kt
@@ -0,0 +1,210 @@
+package video.typetype.tv.ui.search
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.rounded.Mic
+import androidx.compose.material.icons.rounded.Search
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.MutableIntState
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clipToBounds
+import androidx.compose.ui.draw.drawBehind
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.drawscope.DrawScope
+import androidx.compose.ui.graphics.drawscope.clipRect
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.clearAndSetSemantics
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.text.TextLayoutResult
+import androidx.compose.ui.text.drawText
+import androidx.compose.ui.text.rememberTextMeasurer
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import kotlinx.coroutines.delay
+import video.typetype.tv.resources.R
+import video.typetype.tv.theme.Palette
+import video.typetype.tv.theme.Shapes
+import video.typetype.tv.theme.Type
+import video.typetype.tv.ui.components.Glyph
+
+private const val BLINK_MILLIS = 530L
+private const val GHOST_ALPHA = 0.42f
+private const val GHOST_LIMIT = 5
+private const val GHOST_MAX_LENGTH = 32
+private const val NOTICE_MILLIS = 4_000L
+private val CursorWidth = 2.dp
+private val CursorHeight = 22.dp
+private val CursorGap = 2.dp
+
+// What the field shows at a given moment. Only the draw phase reads it: typing, erasing and blinking redraw
+// the field without recomposing the screen, which matters on boxes that repaint the whole window.
+private class FieldPicture {
+    val phrase: MutableIntState = mutableIntStateOf(0)
+    val shown: MutableIntState = mutableIntStateOf(0)
+    val cursorOn: MutableState<Boolean> = mutableStateOf(true)
+}
+
+// The search field: a blinking cursor after the query. While it is empty, a translucent ghost types
+// "Type anything" and then the account's recent searches, one after another, and erases each one.
+// While the voice search listens, the heard words take the place of the query and the microphone pulses.
+@Composable
+internal fun QueryField(query: String, recent: List<String>, voice: VoiceSearch? = null) {
+    val placeholder = stringResource(R.string.search_placeholder)
+    val phrases = remember(placeholder, recent) {
+        listOf(placeholder) + recent.map { it.take(GHOST_MAX_LENGTH) }.filter { it != placeholder }.take(GHOST_LIMIT)
+    }
+    val listening = voice?.listening == true
+    val notice = voice?.notice?.let { stringResource(it) }
+    val line = when {
+        listening && voice.heard.isNotEmpty() -> FieldLine(voice.heard, ghostly = false)
+        listening -> FieldLine(stringResource(R.string.voice_listening), ghostly = true)
+        query.isNotEmpty() -> FieldLine(query, ghostly = false)
+        notice != null -> FieldLine(notice, ghostly = true)
+        else -> null
+    }
+    val measurer = rememberTextMeasurer()
+    val queryStyle = Type.Title.copy(color = Palette.TextHigh)
+    val ghostStyle = Type.Title.copy(color = Palette.TextHigh.copy(alpha = GHOST_ALPHA))
+    // Visible overflow: clipped to its line, the text lost the bottom of g, p and y.
+    val ghosts = remember(phrases) {
+        phrases.map { measurer.measure(it, ghostStyle, overflow = TextOverflow.Visible, maxLines = 1, softWrap = false) }
+    }
+    val shown = remember(line) {
+        line?.let {
+            measurer.measure(it.text, if (it.ghostly) ghostStyle else queryStyle, overflow = TextOverflow.Visible, maxLines = 1, softWrap = false)
+        }
+    }
+    val picture = remember { FieldPicture() }
+    LaunchedEffect(line == null, ghosts) {
+        if (line == null) GhostWriter(ghosts.map { it.layoutInput.text.length }).run(picture) else blink(picture)
+    }
+    LaunchedEffect(notice) {
+        if (notice != null) {
+            delay(NOTICE_MILLIS)
+            voice?.clearNotice()
+        }
+    }
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .height(48.dp)
+            .background(Palette.Surface, Shapes.Panel)
+            .padding(horizontal = 14.dp)
+            .clearAndSetSemantics { contentDescription = line?.text ?: placeholder },
+        horizontalArrangement = Arrangement.spacedBy(10.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Glyph(Icons.Rounded.Search, Palette.TextMid, 20)
+        Box(
+            Modifier
+                .weight(1f)
+                .fillMaxHeight()
+                .clipToBounds()
+                .drawBehind {
+                    if (shown == null) {
+                        val ghost = ghosts[picture.phrase.intValue.coerceIn(ghosts.indices)]
+                        drawLine(ghost, picture.shown.intValue, picture.cursorOn.value)
+                    } else {
+                        drawLine(shown, shown.layoutInput.text.length, picture.cursorOn.value)
+                    }
+                },
+        )
+        if (listening && voice != null) MicPulse(voice)
+    }
+}
+
+private class FieldLine(val text: String, val ghostly: Boolean)
+
+// A red disc that swells with the voice behind the microphone glyph. The level is read in the draw phase only.
+@Composable
+private fun MicPulse(voice: VoiceSearch) {
+    Box(
+        Modifier
+            .size(32.dp)
+            .drawBehind {
+                val calm = size.minDimension * 0.34f
+                val radius = calm + (size.minDimension / 2 - calm) * voice.level.floatValue
+                drawCircle(Palette.Accent.copy(alpha = 0.35f), radius)
+                drawCircle(Palette.Accent, calm)
+            },
+        contentAlignment = Alignment.Center,
+    ) {
+        Glyph(Icons.Rounded.Mic, Palette.TextHigh, 14)
+    }
+}
+
+private fun DrawScope.drawLine(text: TextLayoutResult, letters: Int, cursorOn: Boolean) {
+    val top = (size.height - text.size.height) / 2
+    val edge = when {
+        letters <= 0 -> 0f
+        else -> text.getHorizontalPosition(letters.coerceAtMost(text.layoutInput.text.length), usePrimaryDirection = true)
+    }
+    if (letters > 0) clipRect(right = edge) { drawText(text, topLeft = Offset(0f, top)) }
+    if (cursorOn) {
+        drawRect(
+            Palette.Accent,
+            topLeft = Offset(edge + CursorGap.toPx(), (size.height - CursorHeight.toPx()) / 2),
+            size = Size(CursorWidth.toPx(), CursorHeight.toPx()),
+        )
+    }
+}
+
+private suspend fun blink(picture: FieldPicture): Nothing {
+    while (true) {
+        picture.cursorOn.value = true
+        delay(BLINK_MILLIS)
+        picture.cursorOn.value = false
+        delay(BLINK_MILLIS)
+    }
+}
+
+// Types at a hand's uneven pace, rests with a blinking cursor, then erases faster than it typed.
+private class GhostWriter(private val lengths: List<Int>) {
+    suspend fun run(picture: FieldPicture) {
+        picture.shown.intValue = 0
+        while (true) {
+            for ((index, length) in lengths.withIndex()) {
+                picture.phrase.intValue = index
+                picture.cursorOn.value = true
+                for (letter in 1..length) {
+                    picture.shown.intValue = letter
+                    delay(TYPE_MILLIS + (letter * 37 + index * 11) % TYPE_JITTER)
+                }
+                if (lengths.size == 1) blink(picture)
+                repeat(HOLD_BLINKS) {
+                    picture.cursorOn.value = !picture.cursorOn.value
+                    delay(BLINK_MILLIS)
+                }
+                picture.cursorOn.value = true
+                for (letter in length - 1 downTo 0) {
+                    picture.shown.intValue = letter
+                    delay(ERASE_MILLIS)
+                }
+                delay(BETWEEN_MILLIS)
+            }
+        }
+    }
+
+    private companion object {
+        const val TYPE_MILLIS = 60L
+        const val TYPE_JITTER = 50
+        const val HOLD_BLINKS = 4
+        const val ERASE_MILLIS = 28L
+        const val BETWEEN_MILLIS = 420L
+    }
+}
diff --git a/feature/search/src/main/java/video/typetype/tv/ui/search/SearchPager.kt b/feature/search/src/main/java/video/typetype/tv/ui/search/SearchPager.kt
new file mode 100644
index 0000000..abfe740
--- /dev/null
+++ b/feature/search/src/main/java/video/typetype/tv/ui/search/SearchPager.kt
@@ -0,0 +1,61 @@
+package video.typetype.tv.ui.search
+
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import video.typetype.tv.data.ContentRepository
+import video.typetype.tv.data.ContentSource
+import video.typetype.tv.data.SearchKind
+import video.typetype.tv.data.SearchResults
+import java.io.IOException
+
+@Stable
+class SearchPager(
+    private val repository: ContentRepository,
+    private val query: String,
+    private val source: ContentSource,
+    private val kind: SearchKind,
+    val first: SearchResults,
+    private val scope: CoroutineScope,
+) {
+    var videos by mutableStateOf(first.videos)
+        private set
+
+    var playlists by mutableStateOf(first.playlists)
+        private set
+
+    var channels by mutableStateOf(first.channels)
+        private set
+
+    var loadingMore by mutableStateOf(false)
+        private set
+
+    private var nextPage: String? = first.nextPage
+
+    fun loadMore() {
+        val page = nextPage ?: return
+        if (loadingMore) return
+        loadingMore = true
+        scope.launch {
+            try {
+                val more = repository.search(query, source, kind, page)
+                videos = videos.appendNew(more.videos) { it.id }
+                playlists = playlists.appendNew(more.playlists) { it.url }
+                channels = channels.appendNew(more.channels) { it.url }
+                nextPage = more.nextPage?.takeIf { it != page }
+            } catch (_: IOException) {
+                // The list keeps what it has; reaching the end again retries the same page.
+            } finally {
+                loadingMore = false
+            }
+        }
+    }
+
+    private fun <T> List<T>.appendNew(more: List<T>, key: (T) -> String): List<T> {
+        val known = mapTo(HashSet(), key)
+        return this + more.filterNot { key(it) in known }
+    }
+}
diff --git a/app/src/main/java/video/typetype/tv/ui/search/SearchResults.kt b/feature/search/src/main/java/video/typetype/tv/ui/search/SearchResults.kt
similarity index 77%
rename from app/src/main/java/video/typetype/tv/ui/search/SearchResults.kt
rename to feature/search/src/main/java/video/typetype/tv/ui/search/SearchResults.kt
index f7f7f53..342e6a6 100644
--- a/app/src/main/java/video/typetype/tv/ui/search/SearchResults.kt
+++ b/feature/search/src/main/java/video/typetype/tv/ui/search/SearchResults.kt
@@ -20,11 +20,12 @@ import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
 import androidx.compose.foundation.lazy.itemsIndexed
 import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.rounded.Search
-import androidx.compose.material.icons.rounded.TrendingUp
+import androidx.compose.material.icons.rounded.History
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.remember
@@ -38,30 +39,38 @@ import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.contentDescription
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.unit.dp
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.Video
 import video.typetype.tv.theme.Palette
 import video.typetype.tv.theme.Shapes
 import video.typetype.tv.theme.Type
 import video.typetype.tv.ui.components.FocusSurface
 import video.typetype.tv.ui.components.Glyph
+import video.typetype.tv.ui.components.LocalStreamPrewarm
 import video.typetype.tv.ui.components.PillButton
 import video.typetype.tv.ui.components.SkeletonBox
 import video.typetype.tv.ui.components.TextLabel
 import video.typetype.tv.ui.components.VideoThumbnail
-import video.typetype.tv.ui.util.formatDuration
+import video.typetype.tv.ui.components.rememberVideoMenuTarget
+import video.typetype.tv.ui.util.LoadMoreNearEnd
+import video.typetype.tv.ui.util.metaLine
 import video.typetype.tv.ui.util.requestFocusWhenReady
 
+internal const val MORE_SKELETONS = 2
+
 @Composable
 fun ResultList(
     results: List<Video>,
     onOpen: (Video) -> Unit,
     entry: FocusRequester,
     modifier: Modifier = Modifier,
+    loadingMore: Boolean = false,
+    onNearEnd: () -> Unit = {},
     restoreId: String? = null,
     onRestored: () -> Unit = {},
 ) {
     val listState = rememberLazyListState()
+    LoadMoreNearEnd(listState, results.size, onNearEnd)
     val restorer = remember { FocusRequester() }
     LaunchedEffect(restoreId, results) {
         if (restoreId != null) {
@@ -94,6 +103,9 @@ fun ResultList(
                     },
                 )
             }
+            if (loadingMore) {
+                items(MORE_SKELETONS) { ResultRowSkeleton() }
+            }
         }
     }
 }
@@ -101,9 +113,13 @@ fun ResultList(
 @Composable
 private fun ResultRow(video: Video, onClick: () -> Unit, modifier: Modifier = Modifier) {
     val description = stringResource(R.string.card_description, video.title, video.channel.name)
+    val prewarm = LocalStreamPrewarm.current
+    val menu = rememberVideoMenuTarget(video)
     FocusSurface(
         onClick = onClick,
-        modifier = modifier.fillMaxWidth().semantics { contentDescription = description },
+        onFocused = { prewarm?.focus(video) },
+        onLongClick = menu.open,
+        modifier = modifier.fillMaxWidth().then(menu.modifier()).semantics { contentDescription = description },
         shape = Shapes.Panel,
         focusedScale = 1.02f,
     ) { focused ->
@@ -122,12 +138,11 @@ private fun ResultRow(video: Video, onClick: () -> Unit, modifier: Modifier = Mo
             }
             Column(Modifier.weight(1f)) {
                 TextLabel(video.title, Type.Title, maxLines = 2)
-                Spacer(Modifier.height(4.dp))
-                TextLabel("${video.channel.name}  ·  ${video.views}", Type.Meta, maxLines = 1)
                 Spacer(Modifier.height(6.dp))
-                TextLabel(video.description, Type.Meta.copy(color = Palette.TextLow), maxLines = 2)
+                TextLabel(video.channel.name, Type.Meta, maxLines = 1)
+                Spacer(Modifier.height(2.dp))
+                TextLabel(metaLine(video.views, video.age), Type.Meta.copy(color = Palette.TextLow), maxLines = 1)
             }
-            TextLabel(formatDuration(video.durationSeconds), Type.Meta, Modifier.padding(end = 6.dp))
         }
     }
 }
@@ -139,15 +154,18 @@ fun ResultsSkeleton(modifier: Modifier = Modifier) {
         modifier = modifier.semantics { contentDescription = description },
         verticalArrangement = Arrangement.spacedBy(10.dp),
     ) {
-        repeat(4) {
-            Row(Modifier.fillMaxWidth().padding(10.dp), horizontalArrangement = Arrangement.spacedBy(14.dp)) {
-                SkeletonBox(Modifier.width(152.dp).aspectRatio(16f / 9f))
-                Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
-                    SkeletonBox(Modifier.size(width = 280.dp, height = 14.dp), Shapes.Chip)
-                    SkeletonBox(Modifier.size(width = 200.dp, height = 11.dp), Shapes.Chip)
-                    SkeletonBox(Modifier.size(width = 240.dp, height = 11.dp), Shapes.Chip)
-                }
-            }
+        repeat(4) { ResultRowSkeleton() }
+    }
+}
+
+@Composable
+internal fun ResultRowSkeleton() {
+    Row(Modifier.fillMaxWidth().padding(10.dp), horizontalArrangement = Arrangement.spacedBy(14.dp)) {
+        SkeletonBox(Modifier.width(152.dp).aspectRatio(16f / 9f))
+        Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+            SkeletonBox(Modifier.size(width = 280.dp, height = 14.dp), Shapes.Chip)
+            SkeletonBox(Modifier.size(width = 200.dp, height = 11.dp), Shapes.Chip)
+            SkeletonBox(Modifier.size(width = 240.dp, height = 11.dp), Shapes.Chip)
         }
     }
 }
@@ -159,7 +177,8 @@ fun MessagePanel(
     modifier: Modifier = Modifier,
     content: @Composable () -> Unit = {},
 ) {
-    Column(modifier = modifier.fillMaxSize().padding(top = 28.dp)) {
+    // Level with the search field on the left, so the list below keeps its room above the bottom edge.
+    Column(modifier = modifier.fillMaxSize()) {
         Box(
             modifier = Modifier.size(56.dp).clip(Shapes.Panel).background(Palette.Glass),
             contentAlignment = Alignment.Center,
@@ -177,12 +196,12 @@ fun MessagePanel(
 
 @OptIn(ExperimentalLayoutApi::class)
 @Composable
-fun TrendingSearches(
+fun RecentSearches(
     queries: List<String>,
     onPick: (String) -> Unit,
     entry: FocusRequester,
 ) {
-    TextLabel(stringResource(R.string.search_trending), Type.Label)
+    TextLabel(stringResource(R.string.search_recent), Type.Label)
     Spacer(Modifier.height(12.dp))
     FlowRow(
         modifier = Modifier.width(470.dp),
@@ -192,7 +211,7 @@ fun TrendingSearches(
         queries.forEachIndexed { index, query ->
             PillButton(
                 label = query,
-                icon = Icons.Rounded.TrendingUp,
+                icon = Icons.Rounded.History,
                 onClick = { onPick(query) },
                 modifier = if (index == 0) Modifier.focusRequester(entry) else Modifier,
             )
diff --git a/app/src/main/java/video/typetype/tv/ui/search/SearchScreen.kt b/feature/search/src/main/java/video/typetype/tv/ui/search/SearchScreen.kt
similarity index 64%
rename from app/src/main/java/video/typetype/tv/ui/search/SearchScreen.kt
rename to feature/search/src/main/java/video/typetype/tv/ui/search/SearchScreen.kt
index 72c8498..3aa0c55 100644
--- a/app/src/main/java/video/typetype/tv/ui/search/SearchScreen.kt
+++ b/feature/search/src/main/java/video/typetype/tv/ui/search/SearchScreen.kt
@@ -2,15 +2,10 @@ package video.typetype.tv.ui.search
 
 import video.typetype.tv.ui.util.tryLoad
 import video.typetype.tv.ui.components.ScreenFailure
-import video.typetype.tv.ui.auth.UiMessage
+import video.typetype.tv.ui.util.UiMessage
 import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.animation.Crossfade
-import androidx.compose.animation.core.RepeatMode
-import androidx.compose.animation.core.animateFloat
-import androidx.compose.animation.core.infiniteRepeatable
-import androidx.compose.animation.core.rememberInfiniteTransition
 import androidx.compose.animation.core.tween
-import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
@@ -18,38 +13,42 @@ import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxHeight
 import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.text.BasicText
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.rounded.Search
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.setValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
+import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.alpha
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.input.key.KeyEventType
+import androidx.compose.ui.input.key.key
+import androidx.compose.ui.input.key.onPreviewKeyEvent
+import androidx.compose.ui.input.key.type
+import androidx.compose.ui.input.key.utf16CodePoint
 import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.platform.LocalContext
+import android.Manifest
+import android.content.pm.PackageManager
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import kotlinx.coroutines.delay
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.ContentRepository
 import video.typetype.tv.data.SearchResults
 import video.typetype.tv.data.SearchKind
-import video.typetype.tv.data.ContentSource
 import video.typetype.tv.data.Video
 import video.typetype.tv.theme.Dimens
-import video.typetype.tv.theme.Palette
-import video.typetype.tv.theme.Shapes
-import video.typetype.tv.theme.Type
-import video.typetype.tv.ui.components.Glyph
 import video.typetype.tv.ui.components.InkBackground
+import video.typetype.tv.ui.components.SearchInput
+import video.typetype.tv.ui.components.SearchKeyboard
+import video.typetype.tv.ui.components.VoiceKey
 import video.typetype.tv.ui.util.requestFocusWhenReady
 import video.typetype.tv.ui.util.trapFocusDown
 
@@ -58,7 +57,9 @@ private const val SEARCH_DEBOUNCE_MILLIS = 180L
 private sealed interface ResultsState {
     data object Idle : ResultsState
     data object Loading : ResultsState
-    data class Loaded(val results: SearchResults) : ResultsState
+    data class Loaded(val pager: SearchPager) : ResultsState {
+        val results: SearchResults get() = pager.first
+    }
     data class Failed(val message: UiMessage) : ResultsState
 }
 
@@ -72,6 +73,7 @@ fun SearchScreen(
     modifier: Modifier = Modifier,
 ) {
     var state by remember { mutableStateOf<ResultsState>(ResultsState.Idle) }
+    val scope = rememberCoroutineScope()
     val firstKey = remember { FocusRequester() }
     val resultsEntry = remember { FocusRequester() }
     var ideas by remember { mutableStateOf<List<String>>(emptyList()) }
@@ -88,6 +90,27 @@ fun SearchScreen(
     LaunchedEffect(Unit) {
         if (restoreId == null) firstKey.requestFocusWhenReady()
     }
+    val context = LocalContext.current
+    val voice = rememberVoiceSearch()
+    fun listen() = voice.start { sentence ->
+        session.query = SearchInput.fromSpeech(sentence)
+        moveFocusToResults = true
+    }
+    val askMicrophone = rememberLauncherForActivityResult(ActivityResultContracts.RequestPermission()) { granted ->
+        if (granted) listen() else voice.refused()
+    }
+    val onVoice = {
+        when {
+            voice.listening -> voice.stop()
+            context.checkSelfPermission(Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED -> listen()
+            else -> askMicrophone.launch(Manifest.permission.RECORD_AUDIO)
+        }
+    }
+    LaunchedEffect(session.voiceRequested) {
+        if (!session.voiceRequested) return@LaunchedEffect
+        session.voiceRequested = false
+        if (voice.available && !voice.listening) onVoice()
+    }
     LaunchedEffect(session.query, session.source, session.kind, searchAttempt) {
         val query = session.query
         if (query.isBlank()) {
@@ -97,8 +120,11 @@ fun SearchScreen(
         state = ResultsState.Loading
         delay(SEARCH_DEBOUNCE_MILLIS)
         var failed: UiMessage? = null
-        val found = tryLoad({ failed = it }) { repository.search(query, session.source, session.kind) }
-        state = found?.let { ResultsState.Loaded(it) } ?: ResultsState.Failed(failed ?: UiMessage(R.string.load_error_generic))
+        val source = session.source
+        val kind = session.kind
+        val found = tryLoad({ failed = it }) { repository.search(query, source, kind) }
+        state = found?.let { ResultsState.Loaded(SearchPager(repository, query, source, kind, it, scope)) }
+            ?: ResultsState.Failed(failed ?: UiMessage(R.string.load_error_generic))
     }
     LaunchedEffect(state, moveFocusToResults) {
         val loaded = state as? ResultsState.Loaded
@@ -107,7 +133,20 @@ fun SearchScreen(
             moveFocusToResults = false
         }
     }
-    Box(modifier.fillMaxSize()) {
+    Box(
+        modifier
+            .fillMaxSize()
+            .onPreviewKeyEvent { event ->
+                if (event.type != KeyEventType.KeyDown) return@onPreviewKeyEvent false
+                val typed = SearchInput.typed(event.utf16CodePoint)
+                when {
+                    typed != null -> session.query = SearchInput.append(session.query, typed)
+                    event.key == Key.Backspace -> session.query = SearchInput.delete(session.query)
+                    else -> return@onPreviewKeyEvent false
+                }
+                true
+            },
+    ) {
         InkBackground()
         Row(
             modifier = Modifier
@@ -115,12 +154,12 @@ fun SearchScreen(
                 .padding(
                     start = Dimens.SafeStart,
                     end = Dimens.SafeEnd,
-                    top = Dimens.TopNavHeight + Dimens.SafeTop + 22.dp,
+                    top = Dimens.TabContentTop,
                 ),
             horizontalArrangement = Arrangement.spacedBy(44.dp),
         ) {
             Column(Modifier.width(480.dp).trapFocusDown()) {
-                QueryField(session.query)
+                QueryField(session.query, ideas, voice)
                 Spacer(Modifier.height(10.dp))
                 SearchScope(
                     source = session.source,
@@ -129,7 +168,7 @@ fun SearchScreen(
                         session.source = nextSource(session.source)
                         session.kind = SearchKind.Videos
                     },
-                    onCycleKind = { session.kind = SearchKind.next(session.source, session.kind) },
+                    onSelectKind = { session.kind = it },
                 )
                 Spacer(Modifier.height(12.dp))
                 SearchKeyboard(
@@ -138,6 +177,7 @@ fun SearchScreen(
                     onClear = { session.query = "" },
                     firstKey = firstKey,
                     rightEdgeTarget = if (hasEntry) resultsEntry else null,
+                    voice = if (voice.available) VoiceKey(voice.listening, onVoice) else null,
                 )
             }
             Crossfade(
@@ -151,7 +191,7 @@ fun SearchScreen(
                         title = stringResource(R.string.search_start_title),
                         body = stringResource(R.string.search_start_body),
                     ) {
-                        TrendingSearches(
+                        RecentSearches(
                             queries = ideas,
                             onPick = {
                                 session.query = it
@@ -168,12 +208,24 @@ fun SearchScreen(
                             body = stringResource(R.string.search_empty_body),
                         )
                     } else if (current.results.playlists.isNotEmpty()) {
-                        PlaylistResults(current.results.playlists, onOpen = { onOpenPlaylist(it.url) }, entry = resultsEntry)
+                        PlaylistResults(
+                            current.pager.playlists,
+                            onOpen = { onOpenPlaylist(it.url) },
+                            entry = resultsEntry,
+                            paging = CollectionPaging(current.pager.loadingMore, current.pager::loadMore),
+                        )
                     } else if (current.results.channels.isNotEmpty()) {
-                        ChannelResults(current.results.channels, onOpen = { onOpenChannel(it.url) }, entry = resultsEntry)
+                        ChannelResults(
+                            current.pager.channels,
+                            onOpen = { onOpenChannel(it.url) },
+                            entry = resultsEntry,
+                            paging = CollectionPaging(current.pager.loadingMore, current.pager::loadMore),
+                        )
                     } else {
                         ResultList(
-                            results = current.results.videos,
+                            results = current.pager.videos,
+                            loadingMore = current.pager.loadingMore,
+                            onNearEnd = current.pager::loadMore,
                             onOpen = {
                                 session.restoreVideoId = it.id
                                 onOpen(it)
@@ -188,41 +240,3 @@ fun SearchScreen(
         }
     }
 }
-
-@Composable
-private fun QueryField(query: String) {
-    val caret = rememberInfiniteTransition(label = "caret")
-    val caretAlpha by caret.animateFloat(
-        initialValue = 1f,
-        targetValue = 0f,
-        animationSpec = infiniteRepeatable(tween(520), RepeatMode.Reverse),
-        label = "caret-alpha",
-    )
-    Row(
-        modifier = Modifier
-            .fillMaxWidth()
-            .height(48.dp)
-            .background(Palette.Surface, Shapes.Panel)
-            .padding(horizontal = 14.dp),
-        horizontalArrangement = Arrangement.spacedBy(10.dp),
-        verticalAlignment = Alignment.CenterVertically,
-    ) {
-        Glyph(Icons.Rounded.Search, Palette.TextMid, 20)
-        if (query.isEmpty()) {
-            BasicText(
-                stringResource(R.string.search_placeholder),
-                style = Type.Body.copy(color = Palette.TextLow),
-                maxLines = 1,
-            )
-        } else {
-            BasicText(query, style = Type.Title.copy(color = Palette.TextHigh), maxLines = 1)
-        }
-        Box(
-            Modifier
-                .width(2.dp)
-                .height(20.dp)
-                .alpha(caretAlpha)
-                .background(Palette.Accent),
-        )
-    }
-}
diff --git a/app/src/main/java/video/typetype/tv/ui/search/SearchInput.kt b/feature/search/src/main/java/video/typetype/tv/ui/search/SearchSession.kt
similarity index 51%
rename from app/src/main/java/video/typetype/tv/ui/search/SearchInput.kt
rename to feature/search/src/main/java/video/typetype/tv/ui/search/SearchSession.kt
index 63dc50b..e3ee5fb 100644
--- a/app/src/main/java/video/typetype/tv/ui/search/SearchInput.kt
+++ b/feature/search/src/main/java/video/typetype/tv/ui/search/SearchSession.kt
@@ -6,23 +6,12 @@ import video.typetype.tv.data.ContentSource
 import video.typetype.tv.data.SearchKind
 import androidx.compose.runtime.setValue
 
-object SearchInput {
-    const val KEYS = "abcdefghijklmnopqrstuvwxyz0123456789"
-    const val KEYS_PER_ROW = 9
-    const val MAX_LENGTH = 40
-
-    fun append(query: String, character: Char): String {
-        if (query.length >= MAX_LENGTH) return query
-        if (character == ' ' && (query.isEmpty() || query.endsWith(' '))) return query
-        return query + character
-    }
-
-    fun delete(query: String): String = query.dropLast(1)
-}
-
 class SearchSession {
     var query by mutableStateOf("")
     var source by mutableStateOf(ContentSource.YouTube)
     var kind by mutableStateOf(SearchKind.Videos)
     var restoreVideoId by mutableStateOf<String?>(null)
+
+    // Set by the remote's search key from any screen; the search screen starts listening and clears it.
+    var voiceRequested by mutableStateOf(false)
 }
diff --git a/feature/search/src/main/java/video/typetype/tv/ui/search/SourcePicker.kt b/feature/search/src/main/java/video/typetype/tv/ui/search/SourcePicker.kt
new file mode 100644
index 0000000..0782e0a
--- /dev/null
+++ b/feature/search/src/main/java/video/typetype/tv/ui/search/SourcePicker.kt
@@ -0,0 +1,74 @@
+package video.typetype.tv.ui.search
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Row
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.rounded.AccountCircle
+import androidx.compose.material.icons.rounded.Animation
+import androidx.compose.material.icons.rounded.LiveTv
+import androidx.compose.material.icons.rounded.Movie
+import androidx.compose.material.icons.rounded.MusicNote
+import androidx.compose.material.icons.rounded.MusicVideo
+import androidx.compose.material.icons.rounded.PlayCircle
+import androidx.compose.material.icons.rounded.PlaylistPlay
+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.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.unit.dp
+import video.typetype.tv.resources.R
+import video.typetype.tv.data.ContentSource
+import video.typetype.tv.data.SearchKind
+import video.typetype.tv.ui.components.OptionWheel
+import video.typetype.tv.ui.components.WheelOption
+import video.typetype.tv.ui.components.PillButton
+import video.typetype.tv.ui.components.ServiceMark
+
+fun nextSource(current: ContentSource): ContentSource {
+    val all = ContentSource.entries
+    return all[(all.indexOf(current) + 1) % all.size]
+}
+
+@Composable
+fun SearchScope(
+    source: ContentSource,
+    kind: SearchKind,
+    onCycleSource: () -> Unit,
+    onSelectKind: (SearchKind) -> Unit,
+) {
+    val sourceName = stringResource(source.labelRes)
+    val kindName = stringResource(kind.labelRes)
+    val sourceDescription = stringResource(R.string.search_source, sourceName)
+    val kindDescription = stringResource(R.string.search_kind, kindName)
+    Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+        PillButton(
+            label = sourceName,
+            onClick = onCycleSource,
+            modifier = Modifier.semantics { contentDescription = sourceDescription },
+            leading = { ServiceMark(source, 20) },
+        )
+        val kinds = SearchKind.available(source)
+        if (kinds.size > 1) {
+            OptionWheel(
+                options = kinds.map { WheelOption(stringResource(it.labelRes), it.icon()) },
+                selected = kinds.indexOf(kind).coerceAtLeast(0),
+                onSelect = { onSelectKind(kinds[it]) },
+                description = kindDescription,
+            )
+        }
+    }
+}
+
+// The picture of each kind of result, so the wheel shows what it will search for at a glance.
+private fun SearchKind.icon(): ImageVector = when (this) {
+    SearchKind.Videos -> Icons.Rounded.PlayCircle
+    SearchKind.Playlists -> Icons.Rounded.PlaylistPlay
+    SearchKind.Channels -> Icons.Rounded.AccountCircle
+    SearchKind.Live -> Icons.Rounded.LiveTv
+    SearchKind.Anime -> Icons.Rounded.Animation
+    SearchKind.Movies -> Icons.Rounded.Movie
+    SearchKind.MusicSongs -> Icons.Rounded.MusicNote
+    SearchKind.MusicVideos -> Icons.Rounded.MusicVideo
+}
diff --git a/feature/search/src/main/java/video/typetype/tv/ui/search/VoiceSearch.kt b/feature/search/src/main/java/video/typetype/tv/ui/search/VoiceSearch.kt
new file mode 100644
index 0000000..ad62c02
--- /dev/null
+++ b/feature/search/src/main/java/video/typetype/tv/ui/search/VoiceSearch.kt
@@ -0,0 +1,139 @@
+package video.typetype.tv.ui.search
+
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+import android.speech.RecognitionListener
+import android.speech.RecognizerIntent
+import android.speech.SpeechRecognizer
+import androidx.annotation.StringRes
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.MutableFloatState
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.platform.LocalContext
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.compose.LifecycleEventEffect
+import video.typetype.tv.resources.R
+
+// Speech typed into the search field, through the device's recognition service (on most TVs, Google's): the
+// words appear as they are heard and the final sentence becomes the query. Nothing is recorded by the app.
+@Stable
+class VoiceSearch(private val context: Context) {
+    val available: Boolean = SpeechRecognizer.isRecognitionAvailable(context)
+
+    var listening by mutableStateOf(false)
+        private set
+
+    var heard by mutableStateOf("")
+        private set
+
+    @get:StringRes
+    var notice by mutableStateOf<Int?>(null)
+        private set
+
+    // Loudness of the voice from 0 to 1; only the draw phase reads it.
+    val level: MutableFloatState = mutableFloatStateOf(0f)
+
+    private var recognizer: SpeechRecognizer? = null
+
+    fun start(onResult: (String) -> Unit) {
+        if (!available || listening) return
+        val speech = recognizer ?: SpeechRecognizer.createSpeechRecognizer(context).also { recognizer = it }
+        speech.setRecognitionListener(Listener(onResult))
+        heard = ""
+        notice = null
+        listening = true
+        speech.startListening(
+            Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH)
+                .putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, RecognizerIntent.LANGUAGE_MODEL_FREE_FORM)
+                .putExtra(RecognizerIntent.EXTRA_PARTIAL_RESULTS, true)
+                .putExtra(RecognizerIntent.EXTRA_MAX_RESULTS, 1)
+                .putExtra(RecognizerIntent.EXTRA_CALLING_PACKAGE, context.packageName),
+        )
+    }
+
+    fun stop() {
+        if (!listening) return
+        recognizer?.stopListening()
+    }
+
+    fun cancel() {
+        recognizer?.cancel()
+        finish()
+    }
+
+    fun refused() {
+        notice = R.string.voice_permission
+    }
+
+    fun clearNotice() {
+        notice = null
+    }
+
+    fun release() {
+        recognizer?.destroy()
+        recognizer = null
+        finish()
+    }
+
+    private fun finish() {
+        listening = false
+        heard = ""
+        level.floatValue = 0f
+    }
+
+    private inner class Listener(private val onResult: (String) -> Unit) : RecognitionListener {
+        override fun onPartialResults(partialResults: Bundle?) {
+            firstLine(partialResults)?.let { heard = it }
+        }
+
+        override fun onResults(results: Bundle?) {
+            val sentence = firstLine(results)
+            finish()
+            if (sentence.isNullOrBlank()) notice = R.string.voice_not_heard else onResult(sentence)
+        }
+
+        override fun onError(error: Int) {
+            finish()
+            notice = when (error) {
+                SpeechRecognizer.ERROR_INSUFFICIENT_PERMISSIONS -> R.string.voice_permission
+                SpeechRecognizer.ERROR_NETWORK, SpeechRecognizer.ERROR_NETWORK_TIMEOUT -> R.string.voice_network
+                SpeechRecognizer.ERROR_CLIENT -> null
+                else -> R.string.voice_not_heard
+            }
+        }
+
+        // The service reports roughly -2 to 10 dB; the pulse only needs a soft 0 to 1.
+        override fun onRmsChanged(rmsdB: Float) {
+            level.floatValue = ((rmsdB + 2f) / 12f).coerceIn(0f, 1f)
+        }
+
+        override fun onReadyForSpeech(params: Bundle?) = Unit
+
+        override fun onBeginningOfSpeech() = Unit
+
+        override fun onBufferReceived(buffer: ByteArray?) = Unit
+
+        override fun onEndOfSpeech() = Unit
+
+        override fun onEvent(eventType: Int, params: Bundle?) = Unit
+    }
+
+    private fun firstLine(bundle: Bundle?): String? =
+        bundle?.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION)?.firstOrNull()?.trim()
+}
+
+@Composable
+fun rememberVoiceSearch(): VoiceSearch {
+    val context = LocalContext.current
+    val voice = remember { VoiceSearch(context) }
+    LifecycleEventEffect(Lifecycle.Event.ON_PAUSE) { voice.cancel() }
+    DisposableEffect(voice) { onDispose { voice.release() } }
+    return voice
+}
diff --git a/feature/search/src/test/java/video/typetype/tv/ui/search/SearchPagerTest.kt b/feature/search/src/test/java/video/typetype/tv/ui/search/SearchPagerTest.kt
new file mode 100644
index 0000000..59cc281
--- /dev/null
+++ b/feature/search/src/test/java/video/typetype/tv/ui/search/SearchPagerTest.kt
@@ -0,0 +1,77 @@
+package video.typetype.tv.ui.search
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Test
+import video.typetype.tv.data.Channel
+import video.typetype.tv.data.ContentRepository
+import video.typetype.tv.data.ContentSource
+import video.typetype.tv.data.MockContentRepository
+import video.typetype.tv.data.PublicPlaylist
+import video.typetype.tv.data.SearchKind
+import video.typetype.tv.data.SearchResults
+import video.typetype.tv.data.Video
+import video.typetype.tv.data.net.ApiException
+import video.typetype.tv.data.net.ApiFailure
+import video.typetype.tv.data.net.FailureCategory
+
+class SearchPagerTest {
+    private val scope = CoroutineScope(Dispatchers.Unconfined)
+
+    private fun video(id: String) = Video(id, id, Channel("c", "C", "", ""), 60, "", "", "", "")
+
+    private class PagedRepository(val pages: Map<String, SearchResults>, var fail: Boolean = false) :
+        ContentRepository by MockContentRepository(0) {
+        val asked = mutableListOf<String?>()
+
+        override suspend fun search(query: String, source: ContentSource, kind: SearchKind, page: String?): SearchResults {
+            asked += page
+            if (fail) throw ApiException(ApiFailure(FailureCategory.Network, null, null, "down", null))
+            return pages.getValue(page.orEmpty())
+        }
+    }
+
+    private fun pager(repository: ContentRepository, first: SearchResults) =
+        SearchPager(repository, "q", ContentSource.YouTube, SearchKind.Videos, first, scope)
+
+    @Test
+    fun theNextPageIsAppendedWithoutDuplicates() = runBlocking {
+        val repository = PagedRepository(mapOf("p2" to SearchResults(listOf(video("b"), video("c")), nextPage = "p3")))
+        val pager = pager(repository, SearchResults(listOf(video("a"), video("b")), nextPage = "p2"))
+        pager.loadMore()
+        assertEquals(listOf("a", "b", "c"), pager.videos.map { it.id })
+        assertFalse(pager.loadingMore)
+    }
+
+    @Test
+    fun theLastPageStopsPaging() = runBlocking {
+        val repository = PagedRepository(emptyMap())
+        val pager = pager(repository, SearchResults(listOf(video("a"))))
+        pager.loadMore()
+        assertEquals(emptyList<String?>(), repository.asked)
+    }
+
+    @Test
+    fun aFailedPageKeepsTheListAndCanBeRetried() = runBlocking {
+        val repository = PagedRepository(mapOf("p2" to SearchResults(listOf(video("b")))), fail = true)
+        val pager = pager(repository, SearchResults(listOf(video("a")), nextPage = "p2"))
+        pager.loadMore()
+        assertEquals(listOf("a"), pager.videos.map { it.id })
+        repository.fail = false
+        pager.loadMore()
+        assertEquals(listOf("a", "b"), pager.videos.map { it.id })
+        assertEquals(listOf("p2", "p2"), repository.asked)
+    }
+
+    @Test
+    fun playlistResultsPageToo() = runBlocking {
+        val second = SearchResults(playlists = listOf(PublicPlaylist("p2", "Two", "", 1, null)))
+        val repository = PagedRepository(mapOf("n" to second))
+        val pager = pager(repository, SearchResults(playlists = listOf(PublicPlaylist("p1", "One", "", 1, null)), nextPage = "n"))
+        pager.loadMore()
+        assertEquals(listOf("p1", "p2"), pager.playlists.map { it.url })
+    }
+}
diff --git a/feature/settings/build.gradle.kts b/feature/settings/build.gradle.kts
new file mode 100644
index 0000000..aff9508
--- /dev/null
+++ b/feature/settings/build.gradle.kts
@@ -0,0 +1,14 @@
+plugins {
+    alias(libs.plugins.typetype.android.compose)
+}
+
+android {
+    namespace = "video.typetype.tv.feature.settings"
+}
+
+dependencies {
+    implementation(project(":core:ui"))
+
+    testImplementation(project(":core:testing"))
+    testImplementation(libs.junit)
+}
diff --git a/feature/settings/src/main/java/video/typetype/tv/ui/settings/ChoicePicker.kt b/feature/settings/src/main/java/video/typetype/tv/ui/settings/ChoicePicker.kt
new file mode 100644
index 0000000..d047d40
--- /dev/null
+++ b/feature/settings/src/main/java/video/typetype/tv/ui/settings/ChoicePicker.kt
@@ -0,0 +1,101 @@
+package video.typetype.tv.ui.settings
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.focusGroup
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.rounded.Check
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.ExperimentalComposeUiApi
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusProperties
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.semantics.role
+import androidx.compose.ui.semantics.selected
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.unit.dp
+import video.typetype.tv.data.SettingItem
+import video.typetype.tv.theme.Palette
+import video.typetype.tv.theme.Shapes
+import video.typetype.tv.theme.Type
+import video.typetype.tv.ui.components.FocusSurface
+import video.typetype.tv.ui.components.Glyph
+import video.typetype.tv.ui.components.TextLabel
+import video.typetype.tv.ui.components.TvOverlay
+import video.typetype.tv.ui.util.requestFocusWhenReady
+
+// Every option of a setting at once, the current one checked and focused: one press picks, Back keeps it.
+@OptIn(ExperimentalComposeUiApi::class)
+@Composable
+internal fun ChoicePicker(item: SettingItem.Choice, current: Int, onPick: (Int) -> Unit, onClose: () -> Unit) {
+    val focus = remember { FocusRequester() }
+    LaunchedEffect(item.id) { focus.requestFocusWhenReady() }
+    TvOverlay(onClose) {
+        Column(
+            modifier = Modifier
+                .width(440.dp)
+                .clip(Shapes.Panel)
+                .background(Palette.Surface)
+                .padding(24.dp)
+                .focusProperties { exit = { FocusRequester.Cancel } }
+                .focusGroup()
+                .verticalScroll(rememberScrollState()),
+            verticalArrangement = Arrangement.spacedBy(8.dp),
+        ) {
+            TextLabel(stringResource(item.titleRes), Type.Headline, maxLines = 1)
+            item.summaryRes?.let { TextLabel(stringResource(it), Type.Meta, maxLines = 2) }
+            Spacer(Modifier.height(6.dp))
+            item.options.forEachIndexed { index, option ->
+                OptionRow(
+                    label = option,
+                    chosen = index == current,
+                    onClick = { onPick(index) },
+                    modifier = if (index == current) Modifier.focusRequester(focus) else Modifier,
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun OptionRow(label: String, chosen: Boolean, onClick: () -> Unit, modifier: Modifier) {
+    FocusSurface(
+        onClick = onClick,
+        modifier = modifier.fillMaxWidth().semantics {
+            role = Role.RadioButton
+            selected = chosen
+        },
+        shape = Shapes.Card,
+        focusedScale = 1.02f,
+        focusLift = 0.dp,
+    ) { focused ->
+        val content = if (focused) Palette.Ink else Palette.TextHigh
+        Row(
+            Modifier
+                .fillMaxWidth()
+                .background(if (focused) Palette.TextHigh else Palette.SurfaceRaised)
+                .padding(horizontal = 16.dp, vertical = 12.dp),
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(12.dp),
+        ) {
+            TextLabel(label, Type.Button.copy(color = content), Modifier.weight(1f), maxLines = 1)
+            if (chosen) Glyph(Icons.Rounded.Check, if (focused) Palette.Ink else Palette.Accent, 22)
+        }
+    }
+}
diff --git a/app/src/main/java/video/typetype/tv/ui/settings/SettingChange.kt b/feature/settings/src/main/java/video/typetype/tv/ui/settings/SettingChange.kt
similarity index 100%
rename from app/src/main/java/video/typetype/tv/ui/settings/SettingChange.kt
rename to feature/settings/src/main/java/video/typetype/tv/ui/settings/SettingChange.kt
diff --git a/feature/settings/src/main/java/video/typetype/tv/ui/settings/SettingItemIcons.kt b/feature/settings/src/main/java/video/typetype/tv/ui/settings/SettingItemIcons.kt
new file mode 100644
index 0000000..fbc40a1
--- /dev/null
+++ b/feature/settings/src/main/java/video/typetype/tv/ui/settings/SettingItemIcons.kt
@@ -0,0 +1,90 @@
+package video.typetype.tv.ui.settings
+
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.rounded.AlternateEmail
+import androidx.compose.material.icons.rounded.Animation
+import androidx.compose.material.icons.rounded.AutoAwesome
+import androidx.compose.material.icons.rounded.Autorenew
+import androidx.compose.material.icons.rounded.Badge
+import androidx.compose.material.icons.rounded.Block
+import androidx.compose.material.icons.rounded.ChatBubbleOutline
+import androidx.compose.material.icons.rounded.ClosedCaption
+import androidx.compose.material.icons.rounded.Dns
+import androidx.compose.material.icons.rounded.FastForward
+import androidx.compose.material.icons.rounded.WatchLater
+import androidx.compose.material.icons.rounded.Favorite
+import androidx.compose.material.icons.rounded.HighQuality
+import androidx.compose.material.icons.rounded.History
+import androidx.compose.material.icons.rounded.Home
+import androidx.compose.material.icons.rounded.Info
+import androidx.compose.material.icons.rounded.Link
+import androidx.compose.material.icons.rounded.LockReset
+import androidx.compose.material.icons.rounded.Logout
+import androidx.compose.material.icons.rounded.MarkEmailRead
+import androidx.compose.material.icons.rounded.Notifications
+import androidx.compose.material.icons.rounded.Person
+import androidx.compose.material.icons.rounded.PersonOff
+import androidx.compose.material.icons.rounded.Replay
+import androidx.compose.material.icons.rounded.Restore
+import androidx.compose.material.icons.rounded.SmartDisplay
+import androidx.compose.material.icons.rounded.MovieFilter
+import androidx.compose.material.icons.rounded.Wallpaper
+import androidx.compose.material.icons.rounded.Smartphone
+import androidx.compose.material.icons.rounded.Speed
+import androidx.compose.material.icons.rounded.SwapHoriz
+import androidx.compose.material.icons.rounded.Tune
+import androidx.compose.material.icons.rounded.VerifiedUser
+import androidx.compose.material.icons.rounded.VideoLibrary
+import androidx.compose.ui.graphics.vector.ImageVector
+import video.typetype.tv.data.SettingActions
+import video.typetype.tv.data.SettingItem
+
+// A picture for every row, so a setting is found by its icon before its words are read.
+internal fun SettingItem.icon(): ImageVector = when {
+    SettingActions.unblockedChannel(id) != null -> Icons.Rounded.PersonOff
+    else -> when (id) {
+        "quality" -> Icons.Rounded.HighQuality
+        "speed" -> Icons.Rounded.Speed
+        "autoplay" -> Icons.Rounded.Autorenew
+        "captions" -> Icons.Rounded.ClosedCaption
+        "sponsorblock" -> Icons.Rounded.FastForward
+        "watch-history" -> Icons.Rounded.History
+        "landing" -> Icons.Rounded.Home
+        "show-continue" -> Icons.Rounded.Replay
+        "show-recommendations" -> Icons.Rounded.AutoAwesome
+        "show-related" -> Icons.Rounded.VideoLibrary
+        "show-comments" -> Icons.Rounded.ChatBubbleOutline
+        "show-shorts" -> Icons.Rounded.Smartphone
+        "blocked-count" -> Icons.Rounded.Block
+        "animated-avatar" -> Icons.Rounded.Animation
+        "video-previews" -> Icons.Rounded.SmartDisplay
+        "smooth-animations" -> Icons.Rounded.Speed
+        "backdrop" -> Icons.Rounded.Wallpaper
+        "intro" -> Icons.Rounded.MovieFilter
+        "forget-decoders" -> Icons.Rounded.Restore
+        "guest", "name" -> Icons.Rounded.Person
+        "email" -> Icons.Rounded.AlternateEmail
+        "role" -> Icons.Rounded.Badge
+        "unread" -> Icons.Rounded.Notifications
+        "mark-notifications-read" -> Icons.Rounded.MarkEmailRead
+        "sign-out" -> Icons.Rounded.Logout
+        "instance-name" -> Icons.Rounded.Dns
+        "instance-address" -> Icons.Rounded.Link
+        "instance-version", "version" -> Icons.Rounded.Info
+        "certificate" -> Icons.Rounded.VerifiedUser
+        "forget-certificate" -> Icons.Rounded.LockReset
+        "change-instance" -> Icons.Rounded.SwapHoriz
+        else -> Icons.Rounded.Tune
+    }
+}
+
+// A choice whose picture follows its value: the start page shows the place the app will open on.
+internal fun SettingItem.Choice.iconFor(value: String): ImageVector = when (id) {
+    "landing" -> when (value) {
+        "history" -> Icons.Rounded.History
+        "favorites" -> Icons.Rounded.Favorite
+        "watch-later" -> Icons.Rounded.WatchLater
+        else -> Icons.Rounded.Home
+    }
+    else -> icon()
+}
diff --git a/app/src/main/java/video/typetype/tv/ui/settings/SettingRows.kt b/feature/settings/src/main/java/video/typetype/tv/ui/settings/SettingRows.kt
similarity index 69%
rename from app/src/main/java/video/typetype/tv/ui/settings/SettingRows.kt
rename to feature/settings/src/main/java/video/typetype/tv/ui/settings/SettingRows.kt
index 26cafbf..a5fb641 100644
--- a/app/src/main/java/video/typetype/tv/ui/settings/SettingRows.kt
+++ b/feature/settings/src/main/java/video/typetype/tv/ui/settings/SettingRows.kt
@@ -4,6 +4,10 @@ import androidx.compose.animation.animateColorAsState
 import androidx.compose.animation.core.animateDpAsState
 import androidx.compose.animation.core.tween
 import androidx.compose.foundation.background
+import androidx.compose.runtime.getValue
+import androidx.compose.foundation.interaction.collectIsFocusedAsState
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.focusable
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
@@ -14,12 +18,15 @@ import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.rounded.ChevronLeft
-import androidx.compose.material.icons.rounded.ChevronRight
+import androidx.compose.material.icons.rounded.UnfoldMore
 import androidx.compose.runtime.Composable
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.runtime.remember
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.Role
 import androidx.compose.ui.semantics.role
@@ -27,13 +34,15 @@ import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.semantics.stateDescription
 import androidx.compose.ui.unit.IntOffset
 import androidx.compose.ui.unit.dp
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
+import video.typetype.tv.data.ContentSource
 import video.typetype.tv.data.SettingItem
 import video.typetype.tv.theme.Palette
 import video.typetype.tv.theme.Shapes
 import video.typetype.tv.theme.Type
 import video.typetype.tv.ui.components.FocusSurface
 import video.typetype.tv.ui.components.Glyph
+import video.typetype.tv.ui.components.ServiceMark
 import video.typetype.tv.ui.components.TextLabel
 
 @Composable
@@ -42,10 +51,11 @@ fun SettingRow(
     session: SettingsSession,
     onAction: (String) -> Unit,
     onChange: (SettingChange) -> Unit,
+    onChoose: (ChoiceRequest) -> Unit = {},
 ) {
     when (item) {
         is SettingItem.Toggle -> ToggleRow(item, session, onChange)
-        is SettingItem.Choice -> ChoiceRow(item, session, onChange)
+        is SettingItem.Choice -> ChoiceRow(item, session, onChoose)
         is SettingItem.Info -> InfoRow(item)
         is SettingItem.Action -> ActionRow(item, onAction)
         is SettingItem.Blocked -> BlockedRow(item, onAction)
@@ -67,6 +77,7 @@ private fun ToggleRow(item: SettingItem.Toggle, session: SettingsSession, onChan
             stateDescription = stateText
         },
     ) {
+        RowIcon(item)
         Column(Modifier.weight(1f)) {
             TextLabel(stringResource(item.titleRes), Type.Title, maxLines = 1)
             TextLabel(stringResource(item.summaryRes), Type.Meta, maxLines = 2)
@@ -75,25 +86,30 @@ private fun ToggleRow(item: SettingItem.Toggle, session: SettingsSession, onChan
     }
 }
 
+// A setting with a few values: OK opens them all in a picker, and the focus comes back here once it closes.
+class ChoiceRequest(val item: SettingItem.Choice, val restoreFocus: () -> Unit)
+
 @Composable
-private fun ChoiceRow(item: SettingItem.Choice, session: SettingsSession, onChange: (SettingChange) -> Unit) {
+private fun ChoiceRow(item: SettingItem.Choice, session: SettingsSession, onChoose: (ChoiceRequest) -> Unit) {
     val value = item.options[session.choiceIndex(item)]
+    val focus = remember { FocusRequester() }
     InteractiveRow(
-        onClick = {
-            val previous = session.choiceIndex(item)
-            session.cycle(item)
-            onChange(SettingChange(item.id, item.wireValues[session.choiceIndex(item)]) { session.setChoice(item, previous) })
-        },
-        modifier = Modifier.semantics {
+        onClick = { onChoose(ChoiceRequest(item) { focus.requestFocus() }) },
+        modifier = Modifier.focusRequester(focus).semantics {
             role = Role.DropdownList
             stateDescription = value
         },
     ) {
-        TextLabel(stringResource(item.titleRes), Type.Title, Modifier.weight(1f), maxLines = 1)
-        Row(horizontalArrangement = Arrangement.spacedBy(6.dp), verticalAlignment = Alignment.CenterVertically) {
-            Glyph(Icons.Rounded.ChevronLeft, Palette.TextLow, 20)
+        val wire = item.wireValues[session.choiceIndex(item)]
+        val service = ContentSource.entries.firstOrNull { it.serviceId.toString() == wire }.takeIf { item.id == "service" }
+        RowIcon(item, service, item.iconFor(wire))
+        Column(Modifier.weight(1f)) {
+            TextLabel(stringResource(item.titleRes), Type.Title, maxLines = 1)
+            item.summaryRes?.let { TextLabel(stringResource(it), Type.Meta, maxLines = 2) }
+        }
+        Row(horizontalArrangement = Arrangement.spacedBy(4.dp), verticalAlignment = Alignment.CenterVertically) {
             TextLabel(value, Type.Button.copy(color = Palette.TextHigh), maxLines = 1)
-            Glyph(Icons.Rounded.ChevronRight, Palette.TextLow, 20)
+            Glyph(Icons.Rounded.UnfoldMore, Palette.TextLow, 20)
         }
     }
 }
@@ -104,6 +120,7 @@ private fun ActionRow(item: SettingItem.Action, onAction: (String) -> Unit) {
         onClick = { onAction(item.id) },
         modifier = Modifier.semantics { role = Role.Button },
     ) {
+        RowIcon(item)
         Column(Modifier.weight(1f)) {
             TextLabel(stringResource(item.titleRes), Type.Title.copy(color = Palette.AccentSoft), maxLines = 1)
             TextLabel(stringResource(item.summaryRes), Type.Meta, maxLines = 2)
@@ -117,6 +134,7 @@ private fun BlockedRow(item: SettingItem.Blocked, onAction: (String) -> Unit) {
         onClick = { onAction(item.id) },
         modifier = Modifier.semantics { role = Role.Button },
     ) {
+        RowIcon(item)
         Column(Modifier.weight(1f)) {
             TextLabel(item.name, Type.Title, maxLines = 1)
             TextLabel(stringResource(R.string.settings_blocked_unblock), Type.Meta, maxLines = 1)
@@ -125,16 +143,23 @@ private fun BlockedRow(item: SettingItem.Blocked, onAction: (String) -> Unit) {
 }
 
 @Composable
+// Read-only, but it takes the focus like every other row: Up and Down walk through the whole group, and a group
+// made only of information can still be reached and scrolled.
 private fun InfoRow(item: SettingItem.Info) {
+    val source = remember { MutableInteractionSource() }
+    val focused by source.collectIsFocusedAsState()
     Row(
         modifier = Modifier
             .fillMaxWidth()
             .clip(Shapes.Panel)
-            .background(Palette.Surface.copy(alpha = 0.55f))
+            .background(if (focused) Palette.SurfaceRaised else Palette.Surface.copy(alpha = 0.55f))
+            .focusable(interactionSource = source)
+            .semantics(mergeDescendants = true) {}
             .padding(horizontal = 18.dp, vertical = 16.dp),
         horizontalArrangement = Arrangement.spacedBy(16.dp),
         verticalAlignment = Alignment.CenterVertically,
     ) {
+        RowIcon(item)
         TextLabel(stringResource(item.titleRes), Type.Title.copy(color = Palette.TextMid), maxLines = 1)
         Box(Modifier.weight(1f), contentAlignment = Alignment.CenterEnd) {
             TextLabel(item.value, Type.Body.copy(color = Palette.TextHigh), maxLines = 1)
@@ -171,6 +196,17 @@ private fun InteractiveRow(
     }
 }
 
+// The row's picture in a round tile; the search service row shows the mark of the service it is set to.
+@Composable
+private fun RowIcon(item: SettingItem, service: ContentSource? = null, icon: ImageVector = item.icon()) {
+    Box(
+        Modifier.size(40.dp).clip(CircleShape).background(Palette.SurfaceRaised),
+        contentAlignment = Alignment.Center,
+    ) {
+        if (service != null) ServiceMark(service, 22) else Glyph(icon, Palette.TextHigh, 22)
+    }
+}
+
 @Composable
 private fun SwitchGlyph(on: Boolean) {
     val track = animateColorAsState(
diff --git a/feature/settings/src/main/java/video/typetype/tv/ui/settings/SettingsGroupIcons.kt b/feature/settings/src/main/java/video/typetype/tv/ui/settings/SettingsGroupIcons.kt
new file mode 100644
index 0000000..5c4d33e
--- /dev/null
+++ b/feature/settings/src/main/java/video/typetype/tv/ui/settings/SettingsGroupIcons.kt
@@ -0,0 +1,24 @@
+package video.typetype.tv.ui.settings
+
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.rounded.AccountCircle
+import androidx.compose.material.icons.rounded.Block
+import androidx.compose.material.icons.rounded.Bolt
+import androidx.compose.material.icons.rounded.Dashboard
+import androidx.compose.material.icons.rounded.Dns
+import androidx.compose.material.icons.rounded.Info
+import androidx.compose.material.icons.rounded.PlayCircle
+import androidx.compose.material.icons.rounded.Settings
+import androidx.compose.ui.graphics.vector.ImageVector
+import video.typetype.tv.data.SettingsGroup
+
+internal fun SettingsGroup.icon(): ImageVector = when (id) {
+    "account" -> Icons.Rounded.AccountCircle
+    "instance" -> Icons.Rounded.Dns
+    "playback" -> Icons.Rounded.PlayCircle
+    "content" -> Icons.Rounded.Dashboard
+    "blocked" -> Icons.Rounded.Block
+    "performance" -> Icons.Rounded.Bolt
+    "about" -> Icons.Rounded.Info
+    else -> Icons.Rounded.Settings
+}
diff --git a/app/src/main/java/video/typetype/tv/ui/settings/SettingsScreen.kt b/feature/settings/src/main/java/video/typetype/tv/ui/settings/SettingsScreen.kt
similarity index 70%
rename from app/src/main/java/video/typetype/tv/ui/settings/SettingsScreen.kt
rename to feature/settings/src/main/java/video/typetype/tv/ui/settings/SettingsScreen.kt
index 4689812..6e7c0bc 100644
--- a/app/src/main/java/video/typetype/tv/ui/settings/SettingsScreen.kt
+++ b/feature/settings/src/main/java/video/typetype/tv/ui/settings/SettingsScreen.kt
@@ -2,7 +2,7 @@ package video.typetype.tv.ui.settings
 
 import video.typetype.tv.ui.util.tryLoad
 import video.typetype.tv.ui.components.ScreenFailure
-import video.typetype.tv.ui.auth.UiMessage
+import video.typetype.tv.ui.util.UiMessage
 import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.animation.AnimatedContent
 import androidx.compose.animation.animateColorAsState
@@ -11,6 +11,7 @@ import androidx.compose.animation.fadeIn
 import androidx.compose.animation.fadeOut
 import androidx.compose.animation.togetherWith
 import androidx.compose.foundation.background
+import androidx.compose.animation.core.animateDpAsState
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
@@ -25,7 +26,8 @@ import androidx.compose.foundation.layout.heightIn
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.runtime.Composable
 import kotlinx.coroutines.launch
 import androidx.compose.runtime.rememberCoroutineScope
@@ -33,10 +35,13 @@ import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.withFrameNanos
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
+import androidx.compose.ui.ExperimentalComposeUiApi
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusProperties
 import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.Role
@@ -44,7 +49,7 @@ import androidx.compose.ui.semantics.role
 import androidx.compose.ui.semantics.selected
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.unit.dp
-import video.typetype.tv.R
+import video.typetype.tv.resources.R
 import video.typetype.tv.data.ContentRepository
 import video.typetype.tv.data.SettingActions
 import video.typetype.tv.data.SettingsGroup
@@ -55,6 +60,8 @@ import video.typetype.tv.theme.Type
 import video.typetype.tv.ui.components.FocusSurface
 import video.typetype.tv.ui.components.InkBackground
 import video.typetype.tv.ui.components.TextLabel
+import video.typetype.tv.ui.components.Glyph
+import video.typetype.tv.ui.util.focusEntersAt
 import video.typetype.tv.ui.util.requestFocusWhenReady
 import video.typetype.tv.ui.util.trapFocusDown
 
@@ -102,6 +109,16 @@ fun SettingsScreen(
     }
     val firstRequester = remember { FocusRequester() }
     LaunchedEffect(Unit) { firstRequester.requestFocusWhenReady() }
+    var choosing by remember { mutableStateOf<ChoiceRequest?>(null) }
+    // The picker keeps the focus while it is shown, so the row gets it back only once the picker is gone.
+    var returning by remember { mutableStateOf<ChoiceRequest?>(null) }
+    LaunchedEffect(choosing, returning) {
+        val request = returning ?: return@LaunchedEffect
+        if (choosing != null) return@LaunchedEffect
+        withFrameNanos { }
+        request.restoreFocus()
+        returning = null
+    }
     Box(modifier.fillMaxSize()) {
         InkBackground()
         Row(
@@ -110,14 +127,17 @@ fun SettingsScreen(
                 .padding(
                     start = Dimens.SafeStart,
                     end = Dimens.SafeEnd,
-                    top = Dimens.TopNavHeight + Dimens.SafeTop + 22.dp,
+                    top = Dimens.TabContentTop,
                 ),
             horizontalArrangement = Arrangement.spacedBy(36.dp),
         ) {
             Column(Modifier.width(232.dp).trapFocusDown()) {
                 TextLabel(stringResource(R.string.settings_title), Type.Headline)
                 Spacer(Modifier.height(20.dp))
-                Column(verticalArrangement = Arrangement.spacedBy(6.dp)) {
+                Column(
+                    modifier = Modifier.focusEntersAt(firstRequester),
+                    verticalArrangement = Arrangement.spacedBy(6.dp),
+                ) {
                     groups.forEachIndexed { index, group ->
                         GroupItem(
                             group = group,
@@ -134,27 +154,58 @@ fun SettingsScreen(
                 modifier = Modifier.weight(1f).fillMaxHeight().trapFocusDown(),
                 label = "settings-panel",
             ) { index ->
-                GroupPanel(groups[index], session, handleAction, onChange)
+                GroupPanel(groups[index], session, handleAction, onChange) { choosing = it }
             }
         }
+        choosing?.let { request ->
+            val item = request.item
+            ChoicePicker(
+                item = item,
+                current = session.choiceIndex(item),
+                onPick = { index ->
+                    val previous = session.choiceIndex(item)
+                    session.setChoice(item, index)
+                    if (index != previous) onChange(SettingChange(item.id, item.wireValues[index]) { session.setChoice(item, previous) })
+                    returning = request
+                    choosing = null
+                },
+                onClose = {
+                    returning = request
+                    choosing = null
+                },
+            )
+        }
     }
 }
 
+@OptIn(ExperimentalComposeUiApi::class)
 @Composable
 private fun GroupPanel(
     group: SettingsGroup,
     session: SettingsSession,
     onAction: (String) -> Unit,
     onChange: (SettingChange) -> Unit,
+    onChoose: (ChoiceRequest) -> Unit,
 ) {
+    // Coming from the rail lands on the first row while it is in view, not on the row level with the group's name.
+    val list = rememberLazyListState()
+    val firstRow = remember(group.id) { FocusRequester() }
     Column(Modifier.fillMaxSize()) {
         TextLabel(stringResource(group.titleRes).uppercase(), Type.Label)
         Spacer(Modifier.height(14.dp))
         LazyColumn(
+            state = list,
+            modifier = Modifier.focusProperties {
+                enter = { if (list.firstVisibleItemIndex == 0) firstRow else FocusRequester.Default }
+            },
             contentPadding = PaddingValues(start = 6.dp, end = 8.dp, top = 6.dp, bottom = 48.dp),
             verticalArrangement = Arrangement.spacedBy(10.dp),
         ) {
-            items(group.items, key = { it.id }) { item -> SettingRow(item, session, onAction, onChange) }
+            itemsIndexed(group.items, key = { _, item -> item.id }) { index, item ->
+                Box(if (index == 0) Modifier.focusRequester(firstRow) else Modifier) {
+                    SettingRow(item, session, onAction, onChange, onChoose)
+                }
+            }
         }
     }
 }
@@ -196,14 +247,18 @@ private fun GroupItem(
             animationSpec = tween(160),
             label = "group-content",
         )
+        val bar = animateDpAsState(if (selected && !focused) 18.dp else 0.dp, tween(200), label = "group-bar")
         Row(
             modifier = Modifier
                 .fillMaxWidth()
                 .heightIn(min = 48.dp)
                 .background(container.value)
-                .padding(horizontal = 16.dp, vertical = 12.dp),
+                .padding(horizontal = 14.dp, vertical = 12.dp),
+            horizontalArrangement = Arrangement.spacedBy(12.dp),
             verticalAlignment = Alignment.CenterVertically,
         ) {
+            Box(Modifier.width(3.dp).height(bar.value).background(Palette.Accent, Shapes.Chip))
+            Glyph(group.icon(), content.value, 20)
             TextLabel(stringResource(group.titleRes), Type.Button.copy(color = content.value), maxLines = 1)
         }
     }
diff --git a/app/src/main/java/video/typetype/tv/ui/settings/SettingsSession.kt b/feature/settings/src/main/java/video/typetype/tv/ui/settings/SettingsSession.kt
similarity index 88%
rename from app/src/main/java/video/typetype/tv/ui/settings/SettingsSession.kt
rename to feature/settings/src/main/java/video/typetype/tv/ui/settings/SettingsSession.kt
index 5369682..5282916 100644
--- a/app/src/main/java/video/typetype/tv/ui/settings/SettingsSession.kt
+++ b/feature/settings/src/main/java/video/typetype/tv/ui/settings/SettingsSession.kt
@@ -26,8 +26,4 @@ class SettingsSession {
     }
 
     fun choiceIndex(item: SettingItem.Choice): Int = values[item.id] ?: item.defaultIndex
-
-    fun cycle(item: SettingItem.Choice) {
-        values[item.id] = (choiceIndex(item) + 1) % item.options.size
-    }
 }
diff --git a/app/src/test/java/video/typetype/tv/ui/SettingsSessionTest.kt b/feature/settings/src/test/java/video/typetype/tv/ui/SettingsSessionTest.kt
similarity index 82%
rename from app/src/test/java/video/typetype/tv/ui/SettingsSessionTest.kt
rename to feature/settings/src/test/java/video/typetype/tv/ui/SettingsSessionTest.kt
index d0d3b94..7622b99 100644
--- a/app/src/test/java/video/typetype/tv/ui/SettingsSessionTest.kt
+++ b/feature/settings/src/test/java/video/typetype/tv/ui/SettingsSessionTest.kt
@@ -22,13 +22,12 @@ class SettingsSessionTest {
     }
 
     @Test
-    fun `choice cycles and wraps around`() {
+    fun `choice starts at its default and keeps the picked option`() {
         val session = SettingsSession()
         assertEquals(0, session.choiceIndex(choice))
-        session.cycle(choice)
-        session.cycle(choice)
+        session.setChoice(choice, 2)
         assertEquals(2, session.choiceIndex(choice))
-        session.cycle(choice)
-        assertEquals(0, session.choiceIndex(choice))
+        session.setChoice(choice, 1)
+        assertEquals(1, session.choiceIndex(choice))
     }
 }
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index c2c7701..b3c5efc 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -50,8 +50,13 @@ kotlinx-coroutines-android = { group = "org.jetbrains.kotlinx", name = "kotlinx-
 google-tink-android = { group = "com.google.crypto.tink", name = "tink-android", version.ref = "tink" }
 androidx-test-junit = { group = "androidx.test.ext", name = "junit", version.ref = "extJunit" }
 
+android-gradlePlugin = { group = "com.android.tools.build", name = "gradle", version.ref = "gradle" }
+compose-gradlePlugin = { group = "org.jetbrains.kotlin", name = "compose-compiler-gradle-plugin", version.ref = "kotlin" }
+
 [plugins]
 androidLibrary = { id = "com.android.library", version.ref = "gradle" }
 androidApplication = { id = "com.android.application", version.ref = "gradle" }
 kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
 compose-compiler = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
+typetype-android-library = { id = "typetype.android.library" }
+typetype-android-compose = { id = "typetype.android.compose" }
diff --git a/player/src/main/java/dev/typetype/player/PlaybackWindowCoordinator.kt b/player/src/main/java/dev/typetype/player/PlaybackWindowCoordinator.kt
index 07d6440..1f06037 100644
--- a/player/src/main/java/dev/typetype/player/PlaybackWindowCoordinator.kt
+++ b/player/src/main/java/dev/typetype/player/PlaybackWindowCoordinator.kt
@@ -85,7 +85,6 @@ internal class PlaybackWindowCoordinator(
         deferredSeek = null
         isSeeking = false
         listeners.clear()
-        loader.release()
     }
 
     private fun accept(result: Result<PlaybackWindow>) {
diff --git a/player/src/main/java/dev/typetype/player/TypeTypeChunkSource.kt b/player/src/main/java/dev/typetype/player/TypeTypeChunkSource.kt
index ed30682..8ef5c77 100644
--- a/player/src/main/java/dev/typetype/player/TypeTypeChunkSource.kt
+++ b/player/src/main/java/dev/typetype/player/TypeTypeChunkSource.kt
@@ -59,14 +59,7 @@ internal class TypeTypeChunkSource(
     override fun getAdjustedSeekPositionUs(
         positionUs: Long,
         seekParameters: SeekParameters,
-    ): Long {
-        val segments = track.segments
-        val nextIndex = segments.indexOfFirst { it.endPositionUs > positionUs }
-            .takeIf { it >= 0 } ?: return positionUs
-        val first = segments[nextIndex].startPositionUs
-        val second = segments.getOrNull(nextIndex + 1)?.startPositionUs ?: first
-        return seekParameters.resolveSeekPositionUs(positionUs, first, second)
-    }
+    ): Long = adjustedSeekPositionUs(track.segments, positionUs, seekParameters)
 
     override fun maybeThrowError() {
         coordinator.maybeThrowError()
@@ -161,6 +154,22 @@ internal class TypeTypeChunkSource(
     }
 }
 
+// A seek lands on a segment start only inside the segments the window knows. A target outside them, before the window
+// or after it, is kept as asked: the window is fetched again around it. Snapping it to the nearest known segment would
+// pull a seek back to the window that was playing, which made seeking backwards impossible.
+@UnstableApi
+internal fun adjustedSeekPositionUs(
+    segments: List<PlaybackSegment>,
+    positionUs: Long,
+    seekParameters: SeekParameters,
+): Long {
+    val index = segments.indexOfFirst { positionUs >= it.startPositionUs && positionUs < it.endPositionUs }
+        .takeIf { it >= 0 } ?: return positionUs
+    val first = segments[index].startPositionUs
+    val second = segments.getOrNull(index + 1)?.startPositionUs ?: first
+    return seekParameters.resolveSeekPositionUs(positionUs, first, second)
+}
+
 internal fun selectPlaybackSegment(
     segments: List<PlaybackSegment>,
     targetUs: Long,
diff --git a/player/src/main/java/dev/typetype/player/TypeTypeMediaPeriod.kt b/player/src/main/java/dev/typetype/player/TypeTypeMediaPeriod.kt
index 193961b..12405b1 100644
--- a/player/src/main/java/dev/typetype/player/TypeTypeMediaPeriod.kt
+++ b/player/src/main/java/dev/typetype/player/TypeTypeMediaPeriod.kt
@@ -110,7 +110,8 @@ internal class TypeTypeMediaPeriod(
             streams.map { it.chunkSource.bufferedStartPositionUs },
         )
         val bufferedEndUs = loader.bufferedPositionUs
-        if (!canSeekWithinPlaybackBuffer(bufferedStartUs, positionUs, bufferedEndUs)) {
+        val inBuffer = canSeekWithinPlaybackBuffer(bufferedStartUs, positionUs, bufferedEndUs)
+        if (!inBuffer || !windowCovers(coordinator.window, positionUs)) {
             coordinator.seek(positionUs)
         }
         streams.forEach { it.seekToUs(positionUs) }
@@ -294,6 +295,14 @@ internal fun canSeekWithinPlaybackBuffer(
         targetPositionUs <= bufferedEndUs - LOCAL_SEEK_END_MARGIN_US
 }
 
+// What a stream reloads after a seek it cannot serve from its samples comes from the window's segments: a target
+// before them would load the window's first segment instead, after the target. Such a seek asks the server for a
+// window around it.
+internal fun windowCovers(window: PlaybackWindow?, positionUs: Long): Boolean =
+    window != null && listOfNotNull(window.audio, window.video).all { track ->
+        track.segments.first().startPositionUs <= positionUs
+    }
+
 internal fun retainedPlaybackStartUs(trackStartsUs: List<Long>): Long =
     trackStartsUs
         .takeIf { starts -> starts.isNotEmpty() && starts.none { it == C.TIME_UNSET } }
diff --git a/player/src/main/java/dev/typetype/player/TypeTypeMediaSource.kt b/player/src/main/java/dev/typetype/player/TypeTypeMediaSource.kt
index ed25a8f..f0f46ac 100644
--- a/player/src/main/java/dev/typetype/player/TypeTypeMediaSource.kt
+++ b/player/src/main/java/dev/typetype/player/TypeTypeMediaSource.kt
@@ -36,7 +36,7 @@ class TypeTypeMediaSource(
         val playbackCoordinator = PlaybackWindowCoordinator(windowLoader, handler)
         coordinator = playbackCoordinator
         playbackCoordinator.addListener(this)
-        val seededWindow = initialWindow
+        val seededWindow = window ?: initialWindow
         if (seededWindow == null) {
             playbackCoordinator.load(initialPositionUs)
         } else {
@@ -79,7 +79,6 @@ class TypeTypeMediaSource(
         coordinator?.release()
         coordinator = null
         transferListener = null
-        window = null
     }
 
     override fun onWindowAvailable(window: PlaybackWindow) {
diff --git a/player/src/test/java/dev/typetype/player/PlaybackSeekPositionTest.kt b/player/src/test/java/dev/typetype/player/PlaybackSeekPositionTest.kt
new file mode 100644
index 0000000..b54d68d
--- /dev/null
+++ b/player/src/test/java/dev/typetype/player/PlaybackSeekPositionTest.kt
@@ -0,0 +1,46 @@
+package dev.typetype.player
+
+import androidx.media3.exoplayer.SeekParameters
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class PlaybackSeekPositionTest {
+    // The window that is playing covers 689 s to 699 s, in two five-second segments.
+    private val window = listOf(segment("a", 689_000_000L), segment("b", 694_000_000L))
+
+    @Test
+    fun `a seek back before the window goes where it was asked`() {
+        assertEquals(300_000_000L, adjustedSeekPositionUs(window, 300_000_000L, SeekParameters.CLOSEST_SYNC))
+    }
+
+    @Test
+    fun `a seek ahead of the window goes where it was asked`() {
+        assertEquals(800_000_000L, adjustedSeekPositionUs(window, 800_000_000L, SeekParameters.CLOSEST_SYNC))
+    }
+
+    @Test
+    fun `a seek inside the window lands on the closest segment start`() {
+        assertEquals(694_000_000L, adjustedSeekPositionUs(window, 693_000_000L, SeekParameters.CLOSEST_SYNC))
+        assertEquals(689_000_000L, adjustedSeekPositionUs(window, 690_000_000L, SeekParameters.CLOSEST_SYNC))
+    }
+
+    @Test
+    fun `an exact seek is left alone`() {
+        assertEquals(690_000_000L, adjustedSeekPositionUs(window, 690_000_000L, SeekParameters.EXACT))
+    }
+
+    private fun segment(id: String, startUs: Long) =
+        PlaybackSegment(url = "https://example.test/segment/$id", startPositionUs = startUs, durationUs = 5_000_000L)
+
+    @Test
+    fun `a seek before the window's first segment asks for a new window`() {
+        val track = PlaybackTrack(PlaybackTrackKind.Video, "v", "video/webm", "https://example.test/init", window)
+        val playing = PlaybackWindow(
+            generation = 1L, durationUs = 900_000_000L, startPositionUs = 689_000_000L, endOfStream = false,
+            audio = track.copy(kind = PlaybackTrackKind.Audio, id = "a"), video = track,
+        )
+        assertEquals(false, windowCovers(playing, 680_000_000L))
+        assertEquals(true, windowCovers(playing, 690_000_000L))
+        assertEquals(false, windowCovers(null, 690_000_000L))
+    }
+}
diff --git a/player/src/test/java/dev/typetype/player/PlaybackWindowCoordinatorTest.kt b/player/src/test/java/dev/typetype/player/PlaybackWindowCoordinatorTest.kt
index 83de566..fc32ca4 100644
--- a/player/src/test/java/dev/typetype/player/PlaybackWindowCoordinatorTest.kt
+++ b/player/src/test/java/dev/typetype/player/PlaybackWindowCoordinatorTest.kt
@@ -3,6 +3,7 @@ package dev.typetype.player
 import java.io.IOException
 import kotlin.random.Random
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
 import org.junit.Assert.assertTrue
 import org.junit.Test
 
@@ -75,7 +76,7 @@ class PlaybackWindowCoordinatorTest {
     }
 
     @Test
-    fun `release cancels active seek`() {
+    fun `release cancels the active seek and leaves the loader to its owner`() {
         val loader = RecordingLoader()
         val dispatcher = RecordingDispatcher()
         val coordinator = PlaybackWindowCoordinator(loader, dispatcher)
@@ -86,7 +87,18 @@ class PlaybackWindowCoordinatorTest {
         dispatcher.runDelayed()
         assertEquals(listOf(10_000L), loader.seekPositions)
         assertTrue(loader.cancellations.all { it.cancelled })
-        assertTrue(loader.released)
+        assertFalse(loader.released)
+    }
+
+    @Test
+    fun `a coordinator made after a release can still load through the same loader`() {
+        val loader = RecordingLoader()
+        val dispatcher = RecordingDispatcher()
+        PlaybackWindowCoordinator(loader, dispatcher).release()
+
+        PlaybackWindowCoordinator(loader, dispatcher).load(30_000L)
+
+        assertEquals(1, loader.loadCount)
     }
 
     @Test
diff --git a/release-notes/v0.1.0.md b/release-notes/v0.1.0.md
new file mode 100644
index 0000000..24677ed
--- /dev/null
+++ b/release-notes/v0.1.0.md
@@ -0,0 +1,24 @@
+First public release of TypeType TV, the Android TV client for TypeType.
+
+TypeType TV needs a TypeType Server instance: the server chosen during setup handles extraction, playback sessions,
+recommendations, and synchronization. The app runs on Android TV, Google TV, and Fire TV devices with Android 6.0 or
+newer, and does not require Google Play Services. It supports YouTube, Bilibili, and NicoNico.
+
+## Highlights
+
+- Home feed, search, channels, playlists, and a library with history, favorites, and Watch Later.
+- Playback up to 4K with AVC, VP9, AV1, or HEVC, chosen from the decoders of the device, and HDR on HDR screens.
+  When a decoder fails, the app remembers it and plays the next videos in another codec.
+- Quality, audio language, captions, chapters, SponsorBlock, comments, the description, and the channel, all
+  reachable from the player without stopping the video.
+- YouTube live streams with their chat beside the picture.
+- A Performance section in the settings for slower devices: animations, previews, the background picture, and a
+  shorter or silent startup intro.
+
+## Install
+
+Download `TypeType-TV-v0.1.0.apk` below and install it on the TV, for example with a file manager or `adb install`.
+The `.sha256` file lets you check the download.
+
+Betas are published as prereleases. A beta installs over the stable release, and the next stable release installs
+over the beta.
diff --git a/release-notes/v0.1.1-beta.1.md b/release-notes/v0.1.1-beta.1.md
new file mode 100644
index 0000000..88c4c5f
--- /dev/null
+++ b/release-notes/v0.1.1-beta.1.md
@@ -0,0 +1,6 @@
+First beta of TypeType TV. It contains the same app as 0.1.0 and opens the beta channel: new features and fixes
+arrive here before they reach a stable release.
+
+It installs over 0.1.0, and the next stable release installs over it.
+
+Download `TypeType-TV-v0.1.1-beta.1.apk` below; the `.sha256` file lets you check the download.
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 0794ed4..bcef50d 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -1,4 +1,5 @@
 pluginManagement {
+    includeBuild("build-logic")
     repositories {
         gradlePluginPortal()
         google()
@@ -24,3 +25,16 @@ rootProject.name = "TypeType-TV"
 
 include(":app")
 include(":player")
+include(":core:resources")
+include(":core:data")
+include(":core:playback")
+include(":core:ui")
+include(":core:testing")
+include(":feature:auth")
+include(":feature:home")
+include(":feature:search")
+include(":feature:library")
+include(":feature:settings")
+include(":feature:collections")
+include(":feature:detail")
+include(":feature:player")