brand: lift the icon background off black

The near-black #120C12 behind the icon reads as black on dark home
screens, and the same fill backs the store icon, feature graphic and
README logo. Raise it to a plum #2D1C2D (L* 4.6 -> 13.1) so the
background is visible without costing the #F862F8 foreground its
contrast. The amber nightly background moves from #1A1200 to #2E2000 by
the same lightness step, so it stays amber instead of drifting to
brown-black.

Raster assets were recoloured from the committed originals; the vector
sources in images/ have no background and are unchanged.

.github/actions/build/action.yml

@@ -40,6 +40,11 @@ runs:
         path: ~/.gradle/caches
         key: gradle-v2-${{ hashFiles('**/*.gradle*', '**/gradle.properties', 'gradle/libs.versions.toml', 'gradle/wrapper/gradle-wrapper.properties') }}
         restore-keys: gradle-v2-
+    - uses: actions/cache@v6
+      with:
+        path: ~/.m2/repository/org/robolectric
+        key: robolectric-m2-v1-${{ hashFiles('gradle/libs.versions.toml', 'app/src/test/resources/robolectric.properties') }}
+        restore-keys: robolectric-m2-v1-
     - id: signing
       if: inputs.sign == 'true'
       shell: bash

.github/workflows/ci.yml

@@ -50,5 +50,5 @@ jobs:
       - uses: actions/cache@v6
         with:
           path: .integration/music
-          key: integration-music-v1
+          key: integration-music-v3
       - run: nix develop .#integration --command nu tools/integration-test.nu

.github/workflows/release.yml

@@ -85,7 +85,9 @@ jobs:
             echo "value=false" >> "$GITHUB_OUTPUT"
           fi
       - name: Check release notes exist
-        run: test -f "metadata/en-US/changelogs/${{ needs.build.outputs.version-code }}.txt"
+        run: |
+          test -f "metadata/en-US/changelogs/${{ needs.build.outputs.version-code }}.txt"
+          test -f "docs/releases/$GITHUB_REF_NAME.md"
       - name: Write Play service account
         if: steps.stable.outputs.value == 'true'
         env:
@@ -123,7 +125,7 @@ jobs:
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
-          args=(--verify-tag --title "$GITHUB_REF_NAME" --notes-file "metadata/en-US/changelogs/${{ needs.build.outputs.version-code }}.txt")
+          args=(--verify-tag --title "$GITHUB_REF_NAME" --notes-file "docs/releases/$GITHUB_REF_NAME.md")
           if [ "${{ steps.stable.outputs.value }}" != "true" ]; then
             args+=(--prerelease)
           fi

README.md

@@ -37,6 +37,7 @@ See [signing/README.md](signing/README.md) for the fingerprints and the commands
 - **Adaptive Theming:** Colours drawn from the current song's artwork.
 - **Search:** Fast search across the whole library, with per-list sort and filter controls.
 - **Playback:** Gapless playback, an editable queue you can reorder and jump through, plus loop and shuffle modes.
+- **ReplayGain:** Loudness normalization from the tags your server reports, with Auto, track and album modes and a preamp.
 - **Up Next:** Add items into the currently playing queue without rewriting it.
 - **Multiple Servers:** Connect several servers and switch between them quickly.
 - **Stream Quality:** Bitrate and format settings for Wi-Fi and mobile, with automatic switching.

app/build.gradle.kts

@@ -36,8 +36,8 @@ android {
         applicationId = "com.subtracks"
         minSdk = 24
         targetSdk = 37
-        versionCode = 13
+        versionCode = 14
-        versionName = "3.0.0"
+        versionName = "3.1.0"
         buildConfigField("String", "COMMIT_HASH", "\"$commitHash\"")
     }
 
@@ -119,7 +119,7 @@ android {
     }
 
     sourceSets {
-        getByName("debug").res.srcDir("src/nightly/res")
+        getByName("debug").res.directories.add("src/nightly/res")
     }
 
     buildTypes {
@@ -181,6 +181,8 @@ val demoScreenshotClass = "com.subtracks.ui.DemoScreenshotTest"
 val queryTimingClass = "com.subtracks.data.db.QueryTimingMeasurementTest"
 
 tasks.withType<Test>().configureEach {
+    // Robolectric fetches its Android SDK jar itself, outside Gradle's repositories.
+    systemProperty("robolectric.dependency.repo.url", providers.gradleProperty("mavenCentralMirrorUrl").get())
     if (name.endsWith("UnitTest")) {
         filter {
             (integrationTestClasses + demoScreenshotClass + queryTimingClass).forEach { excludeTestsMatching(it) }

app/src/integrationTest/kotlin/com/subtracks/data/source/subsonic/SubsonicSourceIntegrationTest.kt

@@ -56,7 +56,7 @@ class SubsonicSourceIntegrationTest(
             assertNotNull(kosmo.starred)
             assertTrue(kosmo.created <= System.currentTimeMillis() / 1000)
 
-            assertNull(albums.first { it.name == "Retroconnaissance EP" }.starred)
+            assertNull(albums.first { it.name == "Retroconnaissance" }.starred)
             assertNull(albums.first { it.name == "I Don't Know What I'm Doing" }.starred)
         }
 
@@ -92,7 +92,7 @@ class SubsonicSourceIntegrationTest(
                     .filter { it.artistId == artists.first { a -> a.name == "Ugress" }.id }
                     .map { it.name }
                     .sorted()
-            assertEquals(listOf("Kosmonaut", "Retroconnaissance EP"), ugressAlbums)
+            assertEquals(listOf("Kosmonaut", "Retroconnaissance"), ugressAlbums)
 
             val bradAlbums =
                 albums

app/src/integrationTest/kotlin/com/subtracks/data/source/subsonic/SubsonicWriteIntegrationTest.kt

@@ -22,7 +22,7 @@ class SubsonicWriteIntegrationTest(
                     .albums()
                     .toList()
                     .flatten()
-                    .first { it.name == "Retroconnaissance EP" }
+                    .first { it.name == "Retroconnaissance" }
 
             source.setStar(StarType.Album, album.id, true)
             try {
@@ -94,7 +94,7 @@ class SubsonicWriteIntegrationTest(
                     .songs()
                     .toList()
                     .flatten()
-                    .first { it.album == "Retroconnaissance EP" }
+                    .first { it.album == "Retroconnaissance" }
 
             source.setStar(StarType.Song, song.id, true)
             try {

app/src/integrationTest/kotlin/com/subtracks/data/sync/MultiSourceSyncIntegrationTest.kt

@@ -1,11 +1,7 @@
 package com.subtracks.data.sync
 
-import android.content.Context
-import androidx.room3.Room
-import androidx.sqlite.driver.bundled.BundledSQLiteDriver
-import androidx.test.core.app.ApplicationProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
-import com.subtracks.data.db.SubtracksDatabase
+import com.subtracks.data.db.createTestDatabase
 import com.subtracks.data.model.Source
 import com.subtracks.data.source.subsonic.TestServers
 import kotlinx.coroutines.runBlocking
@@ -18,12 +14,7 @@ class MultiSourceSyncIntegrationTest {
     @Test
     fun syncsEveryServerIntoOneLibraryWithoutInterference() =
         runBlocking {
-            val context = ApplicationProvider.getApplicationContext<Context>()
+            val db = createTestDatabase()
-            val db =
-                Room
-                    .inMemoryDatabaseBuilder(context, SubtracksDatabase::class.java)
-                    .setDriver(BundledSQLiteDriver())
-                    .build()
             try {
                 TestServers.all.forEachIndexed { index, server ->
                     val id = index + 1L

app/src/integrationTest/kotlin/com/subtracks/data/sync/PruneSyncIntegrationTest.kt

@@ -1,11 +1,7 @@
 package com.subtracks.data.sync
 
-import android.content.Context
-import androidx.room3.Room
-import androidx.sqlite.driver.bundled.BundledSQLiteDriver
-import androidx.test.core.app.ApplicationProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
-import com.subtracks.data.db.SubtracksDatabase
+import com.subtracks.data.db.createTestDatabase
 import com.subtracks.data.model.Source
 import com.subtracks.data.source.subsonic.SubsonicClient
 import com.subtracks.data.source.subsonic.SubsonicSource
@@ -28,12 +24,7 @@ class PruneSyncIntegrationTest {
             val removed = File(musicDir, REMOVED_ALBUM_DIR)
             check(removed.isDirectory) { "$removed is missing; the harness must prepare the prune library" }
 
-            val context = ApplicationProvider.getApplicationContext<Context>()
+            val db = createTestDatabase()
-            val db =
-                Room
-                    .inMemoryDatabaseBuilder(context, SubtracksDatabase::class.java)
-                    .setDriver(BundledSQLiteDriver())
-                    .build()
             try {
                 db.sourcesDao().upsertSource(
                     Source(id = 1, name = "prune", address = baseUrl, isActive = true, createdAt = 0),
@@ -93,7 +84,7 @@ class PruneSyncIntegrationTest {
             ?: error("$name is not set; run the integration harness (tools/integration-test.nu)")
 
     private companion object {
-        const val REMOVED_ALBUM_DIR = "197"
+        const val REMOVED_ALBUM_DIR = "7GZYpfn8wypaTR00LWeNI4"
-        const val REMOVED_ALBUM_NAME = "Retroconnaissance EP"
+        const val REMOVED_ALBUM_NAME = "Retroconnaissance"
     }
 }

app/src/integrationTest/kotlin/com/subtracks/data/sync/SyncServiceIntegrationTest.kt

@@ -1,11 +1,7 @@
 package com.subtracks.data.sync
 
-import android.content.Context
-import androidx.room3.Room
-import androidx.sqlite.driver.bundled.BundledSQLiteDriver
-import androidx.test.core.app.ApplicationProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
-import com.subtracks.data.db.SubtracksDatabase
+import com.subtracks.data.db.createTestDatabase
 import com.subtracks.data.model.Source
 import com.subtracks.data.source.subsonic.TestServers
 import kotlinx.coroutines.runBlocking
@@ -19,12 +15,7 @@ class SyncServiceIntegrationTest {
     fun syncMirrorsTheLibraryIntoRoomForEveryServer() =
         runBlocking {
             servers.forEach { server ->
-                val context = ApplicationProvider.getApplicationContext<Context>()
+                val db = createTestDatabase()
-                val db =
-                    Room
-                        .inMemoryDatabaseBuilder(context, SubtracksDatabase::class.java)
-                        .setDriver(BundledSQLiteDriver())
-                        .build()
                 try {
                     db.sourcesDao().upsertSource(
                         Source(id = 1, name = server.name, address = server.baseUrl, isActive = true, createdAt = 0),

app/src/main/kotlin/com/subtracks/data/db/AlbumCredits.kt

@@ -0,0 +1,127 @@
+package com.subtracks.data.db
+
+import androidx.room3.RoomRawQuery
+
+internal val CREDITED_ALBUM_ROWS = albumCreditRows(AlbumCreditQuery())
+internal val DOWNLOADED_ALBUM_ROWS = albumCreditRows(AlbumCreditQuery(downloaded = true))
+internal val DOWNLOADED_ALBUM_DETAILS_FOR_ARTIST =
+    albumCreditRows(AlbumCreditQuery(downloaded = true, artistScoped = true, selectAlbums = true))
+internal val DOWNLOADED_COVER_ALBUM_ROWS = albumCreditRows(AlbumCreditQuery(downloaded = true, coverOnly = true))
+internal val ARTIST_COVER_CREDITS = albumCreditRows(AlbumCreditQuery(coverOnly = true))
+internal val ARTIST_COVER_CREDITS_FOR_ARTIST = albumCreditRows(AlbumCreditQuery(coverOnly = true, artistScoped = true))
+
+private data class AlbumCreditQuery(
+    val artistScoped: Boolean = false,
+    val coverOnly: Boolean = false,
+    val downloaded: Boolean = false,
+    val selectAlbums: Boolean = false,
+)
+
+private fun albumCreditRows(query: AlbumCreditQuery): String =
+    if (query.selectAlbums) {
+        listOf(
+            primaryAlbumCredits(query),
+            albumRelationCredits(query),
+            trackRelationCredits(query),
+            trackCredits(query),
+        )
+    } else {
+        listOf(
+            primaryAlbumCredits(query),
+            albumRelationCredits(query),
+            trackCredits(query),
+            trackRelationCredits(query),
+        )
+    }.joinToString(if (query.downloaded) " UNION " else " UNION ALL ")
+
+private fun primaryAlbumCredits(query: AlbumCreditQuery): String =
+    buildString {
+        append(
+            when {
+                query.selectAlbums -> "SELECT albums.* FROM albums "
+                query.downloaded -> "SELECT albums.id AS albumId, albums.artistId AS artistId FROM albums "
+                else -> "SELECT albums.artistId AS artistId, albums.id AS albumId, 'album' AS creditType FROM albums "
+            },
+        )
+        append("WHERE albums.sourceId = :sourceId AND ${query.directArtist("albums.artistId")} ")
+        append(query.coverFilter())
+        if (query.downloaded) append("AND $ALBUM_DOWNLOADED ")
+    }.trim()
+
+private fun albumRelationCredits(query: AlbumCreditQuery): String =
+    buildString {
+        append(
+            when {
+                query.selectAlbums -> "SELECT albums.* FROM album_artists "
+                query.downloaded -> "SELECT albums.id, album_artists.artistId FROM album_artists "
+                else -> "SELECT album_artists.artistId, albums.id, 'album' FROM album_artists "
+            },
+        )
+        append("JOIN albums ON albums.sourceId = album_artists.sourceId AND albums.id = album_artists.albumId ")
+        append("WHERE album_artists.sourceId = :sourceId ")
+        if (query.artistScoped) append("AND album_artists.artistId = :artistId ")
+        append(query.coverFilter())
+        if (query.downloaded) append("AND $ALBUM_DOWNLOADED ")
+    }.trim()
+
+private fun trackCredits(query: AlbumCreditQuery): String =
+    buildString {
+        append(
+            when {
+                query.selectAlbums -> "SELECT albums.* FROM songs "
+                query.downloaded -> "SELECT songs.albumId, songs.artistId FROM songs "
+                else -> "SELECT songs.artistId, songs.albumId, 'track' FROM songs "
+            },
+        )
+        append(SONG_ALBUM_JOIN)
+        if (query.downloaded) append(TRACK_DOWNLOAD_JOIN)
+        append("WHERE songs.sourceId = :sourceId AND ${query.directArtist("songs.artistId")} ")
+        append(query.coverFilter())
+        if (query.downloaded) append("AND sd.status = 'Completed' ")
+    }.trim()
+
+private fun trackRelationCredits(query: AlbumCreditQuery): String =
+    buildString {
+        append(
+            when {
+                query.selectAlbums -> "SELECT albums.* FROM song_artists "
+                query.downloaded -> "SELECT songs.albumId, song_artists.artistId FROM song_artists "
+                else -> "SELECT song_artists.artistId, songs.albumId, 'track' FROM song_artists "
+            },
+        )
+        append("JOIN songs ON songs.sourceId = song_artists.sourceId AND songs.id = song_artists.songId ")
+        append(SONG_ALBUM_JOIN)
+        if (query.downloaded) append(TRACK_DOWNLOAD_JOIN)
+        append("WHERE song_artists.sourceId = :sourceId ")
+        if (query.artistScoped) append("AND song_artists.artistId = :artistId ")
+        append(query.coverFilter())
+        if (query.downloaded) append("AND sd.status = 'Completed' ")
+    }.trim()
+
+private fun AlbumCreditQuery.directArtist(column: String): String = if (artistScoped) "$column = :artistId" else "$column IS NOT NULL"
+
+private fun AlbumCreditQuery.coverFilter(): String = if (coverOnly) "AND albums.coverArt IS NOT NULL " else ""
+
+private const val SONG_ALBUM_JOIN = "JOIN albums ON albums.sourceId = songs.sourceId AND albums.id = songs.albumId "
+
+private const val TRACK_DOWNLOAD_JOIN = "JOIN song_downloads sd ON sd.sourceId = songs.sourceId AND sd.songId = songs.id "
+
+private const val ALBUM_DOWNLOADED =
+    "EXISTS (SELECT 1 FROM songs " +
+        "JOIN song_downloads sd ON sd.sourceId = songs.sourceId AND sd.songId = songs.id " +
+        "WHERE songs.sourceId = albums.sourceId AND songs.albumId = albums.id AND sd.status = 'Completed')"
+
+internal fun downloadedArtistArtQuery(
+    sourceId: Long,
+    artistIds: List<String>,
+): RoomRawQuery {
+    val bindings = mutableMapOf<String, Any?>("sourceId" to sourceId)
+    val placeholders =
+        artistIds
+            .mapIndexed { index, artistId ->
+                val name = "artistId$index"
+                bindings[name] = artistId
+                ":$name"
+            }.ifEmpty { listOf("NULL") }
+    return rawQuery(DOWNLOADED_ARTIST_ART_UPDATE_SQL.replace(":artistIds", placeholders.joinToString(",")), bindings)
+}

app/src/main/kotlin/com/subtracks/data/db/Databases.kt

@@ -2,6 +2,7 @@ package com.subtracks.data.db
 
 import android.content.Context
 import androidx.room3.Room
+import androidx.room3.RoomDatabase
 import androidx.sqlite.driver.bundled.BundledSQLiteDriver
 import com.subtracks.log.Log
 
@@ -11,6 +12,9 @@ fun createAndroidDatabase(context: Context): SubtracksDatabase {
         .databaseBuilder<SubtracksDatabase>(context, "subtracks.db")
         .setDriver(driver)
         .addMigrations(*MIGRATIONS.map(::LoggedMigration).toTypedArray())
-        .addCallback(SqliteLifecycleLogging)
+        .addSubtracksDatabaseCallbacks()
         .build()
 }
+
+internal fun RoomDatabase.Builder<SubtracksDatabase>.addSubtracksDatabaseCallbacks(): RoomDatabase.Builder<SubtracksDatabase> =
+    addCallback(ArtistSearchTriggerOptimization).addCallback(SqliteLifecycleLogging)

app/src/main/kotlin/com/subtracks/data/db/DbLogging.kt

@@ -114,6 +114,16 @@ class LoggedMigration(
     }
 }
 
+internal object ArtistSearchTriggerOptimization : RoomDatabase.Callback() {
+    override suspend fun onCreate(connection: SQLiteConnection) {
+        optimizeArtistSearchTriggers(connection)
+    }
+
+    override suspend fun onOpen(connection: SQLiteConnection) {
+        if (!artistSearchTriggersOptimized(connection)) optimizeArtistSearchTriggers(connection)
+    }
+}
+
 internal object SqliteLifecycleLogging : RoomDatabase.Callback() {
     override suspend fun onCreate(connection: SQLiteConnection) {
         Log.i("sql", "created fresh database")

app/src/main/kotlin/com/subtracks/data/db/DownloadDao.kt

@@ -162,12 +162,15 @@ interface DownloadDao {
 
     @Query(
         "SELECT d.sourceId AS sourceId, s.albumId AS albumId, s.artistId AS artistId, " +
+            "al.artistId AS albumArtistId, " +
             "al.id AS albumRow, al.coverArt AS albumCoverArt, " +
-            "ar.id AS artistRow, ar.coverArt AS artistCoverArt " +
+            "ar.id AS artistRow, ar.coverArt AS artistCoverArt, " +
+            "aar.coverArt AS albumArtistCoverArt " +
             "FROM song_downloads d " +
             "LEFT JOIN songs s ON s.sourceId = d.sourceId AND s.id = d.songId " +
             "LEFT JOIN albums al ON al.sourceId = s.sourceId AND al.id = s.albumId " +
-            "LEFT JOIN artists ar ON ar.sourceId = s.sourceId AND ar.id = s.artistId",
+            "LEFT JOIN artists ar ON ar.sourceId = s.sourceId AND ar.id = s.artistId " +
+            "LEFT JOIN artists aar ON aar.sourceId = al.sourceId AND aar.id = al.artistId",
     )
     suspend fun artwork(): List<DownloadArtwork>
 

app/src/main/kotlin/com/subtracks/data/db/LibraryDao.kt

@@ -10,15 +10,21 @@ import androidx.room3.Transaction
 import androidx.room3.Upsert
 import androidx.room3.paging.PagingSourceDaoReturnTypeConverter
 import com.subtracks.data.model.Album
+import com.subtracks.data.model.AlbumArtistRef
+import com.subtracks.data.model.AlbumSearch
 import com.subtracks.data.model.AlbumSongItem
 import com.subtracks.data.model.Artist
 import com.subtracks.data.model.ArtistBio
+import com.subtracks.data.model.ArtistSearch
 import com.subtracks.data.model.Disc
 import com.subtracks.data.model.DiscKey
 import com.subtracks.data.model.Playlist
+import com.subtracks.data.model.PlaylistSearch
 import com.subtracks.data.model.PlaylistSong
 import com.subtracks.data.model.PlaylistSongItem
 import com.subtracks.data.model.Song
+import com.subtracks.data.model.SongArtistRef
+import com.subtracks.data.model.SongDownload
 import com.subtracks.data.model.Source
 import kotlinx.coroutines.flow.Flow
 
@@ -36,25 +42,6 @@ internal const val DOWNLOADED_SONG =
     "EXISTS (SELECT 1 FROM song_downloads sd WHERE sd.sourceId = playlist_songs.sourceId " +
         "AND sd.songId = playlist_songs.songId AND sd.status = 'Completed')"
 
-internal const val ALBUMS_FILTER =
-    "FROM albums WHERE sourceId = :sourceId " +
-        "AND (:starredFilter = 0 OR (:starredFilter = 1 AND starred IS NOT NULL) OR (:starredFilter = 2 AND starred IS NULL)) " +
-        "AND (:downloadedFilter = 0 OR EXISTS (SELECT 1 FROM songs " +
-        "JOIN song_downloads sd ON sd.sourceId = songs.sourceId AND sd.songId = songs.id " +
-        "WHERE songs.sourceId = albums.sourceId AND songs.albumId = albums.id AND sd.status = 'Completed')) " +
-        "AND (:search = '' " +
-        "OR (length(:search) >= 3 AND rowid IN (SELECT rowid FROM album_search " +
-        "WHERE album_search MATCH '\"' || replace(:search, '\"', '\"\"') || '\"')) " +
-        "OR (length(:search) < 3 AND (instr(lower(name), lower(:search)) > 0 " +
-        "OR instr(lower(albumArtist), lower(:search)) > 0 " +
-        "OR instr(lower(sortName), lower(:search)) > 0 " +
-        "OR instr(lower(albumArtistSort), lower(:search)) > 0))) "
-
-internal const val ALBUM_ORDER_BY_NAME = "sortName COLLATE NOCASE, id"
-internal const val ALBUM_ORDER_BY_NAME_REVERSED = "sortName COLLATE NOCASE DESC, id DESC"
-internal const val ALBUM_ORDER_BY_ARTIST = "albumArtistSort COLLATE NOCASE, year, sortName COLLATE NOCASE, id"
-internal const val ALBUM_ORDER_BY_ARTIST_REVERSED =
-    "albumArtistSort COLLATE NOCASE DESC, year DESC, sortName COLLATE NOCASE DESC, id DESC"
 internal const val ALBUM_ORDER_BY_YEAR = "year DESC, sortName COLLATE NOCASE, id"
 internal const val ALBUM_ORDER_BY_YEAR_REVERSED = "year ASC, sortName COLLATE NOCASE DESC, id DESC"
 internal const val ALBUM_ORDER_BY_ADDED = "created DESC, sortName COLLATE NOCASE, id"
@@ -70,6 +57,10 @@ internal const val ALBUM_ORDER_BY_FREQUENT_REVERSED = "playCount ASC, sortName C
 internal const val ALBUM_ORDER_BY_RECENT = "played DESC NULLS LAST, sortName COLLATE NOCASE, id"
 internal const val ALBUM_ORDER_BY_RECENT_REVERSED = "played ASC NULLS LAST, sortName COLLATE NOCASE DESC, id DESC"
 
+private const val ALBUM_NAME_SORT_KEY_MODE =
+    "(CASE :sortMode WHEN 'Name' THEN name WHEN 'NonLatin' THEN (CASE WHEN name GLOB '*[A-Za-z]*' THEN name ELSE sortName END) ELSE sortName END) COLLATE NOCASE"
+internal const val ALBUM_ORDER_BY_NAME_SORT_MODE = "$ALBUM_NAME_SORT_KEY_MODE, id"
+
 internal const val ARTIST_CREDITED =
     "(artists.credited = 1 OR COALESCE((SELECT creditsStale FROM sources WHERE id = artists.sourceId), 1) = 1)"
 
@@ -93,124 +84,100 @@ internal const val CREDITED_SONG_ROWS =
         "ON songs.sourceId = album_artists.sourceId AND songs.albumId = album_artists.albumId " +
         "WHERE album_artists.sourceId = :sourceId"
 
-// May repeat an (artistId, albumId) pair when several credit paths reach it; consumers dedupe.
+internal val ALBUMS_FOR_ARTIST =
-internal const val CREDITED_ALBUM_ROWS =
-    "SELECT albums.artistId AS artistId, albums.id AS albumId, 'album' AS creditType " +
-        "FROM albums WHERE albums.sourceId = :sourceId AND albums.artistId IS NOT NULL " +
-        "UNION ALL " +
-        "SELECT album_artists.artistId, albums.id, 'album' " +
-        "FROM album_artists JOIN albums " +
-        "ON albums.sourceId = album_artists.sourceId AND albums.id = album_artists.albumId " +
-        "WHERE album_artists.sourceId = :sourceId " +
-        "UNION ALL " +
-        "SELECT songs.artistId, songs.albumId, 'track' " +
-        "FROM songs JOIN albums ON albums.sourceId = songs.sourceId AND albums.id = songs.albumId " +
-        "WHERE songs.sourceId = :sourceId AND songs.artistId IS NOT NULL " +
-        "UNION ALL " +
-        "SELECT song_artists.artistId, songs.albumId, 'track' " +
-        "FROM song_artists JOIN songs " +
-        "ON songs.sourceId = song_artists.sourceId AND songs.id = song_artists.songId " +
-        "JOIN albums ON albums.sourceId = songs.sourceId AND albums.id = songs.albumId " +
-        "WHERE song_artists.sourceId = :sourceId"
-
-internal const val ALBUMS_FOR_ARTIST =
     "SELECT albums.* FROM (SELECT DISTINCT albumId FROM ($CREDITED_ALBUM_ROWS) WHERE artistId = :artistId) credits " +
         "JOIN albums ON albums.sourceId = :sourceId AND albums.id = credits.albumId " +
         "ORDER BY year DESC, sortName COLLATE NOCASE, id"
 
-internal const val ALBUM_CREDIT_ALBUM_IDS =
+internal val ALBUM_CREDIT_ALBUM_IDS =
     "SELECT DISTINCT albumId FROM ($CREDITED_ALBUM_ROWS) " +
         "WHERE artistId = :artistId AND creditType = 'album'"
 
-// Download visibility follows the credit path: an album credit includes the album when any song is
+internal val DOWNLOADED_ARTIST_ALBUMS =
-// downloaded, while a track credit includes it only when the credited track is downloaded.
+    "SELECT albumId AS id FROM ($DOWNLOADED_ALBUM_ROWS) WHERE artistId = artists.id"
-private const val DOWNLOADED_ARTIST_ALBUMS =
-    "SELECT albums.id FROM albums " +
-        "WHERE albums.sourceId = :sourceId AND albums.artistId = artists.id " +
-        "AND EXISTS (SELECT 1 FROM songs " +
-        "JOIN song_downloads sd ON sd.sourceId = songs.sourceId AND sd.songId = songs.id " +
-        "WHERE songs.sourceId = albums.sourceId AND songs.albumId = albums.id AND sd.status = 'Completed') " +
-        "UNION " +
-        "SELECT albums.id FROM album_artists " +
-        "JOIN albums ON albums.sourceId = album_artists.sourceId AND albums.id = album_artists.albumId " +
-        "WHERE album_artists.sourceId = :sourceId AND album_artists.artistId = artists.id " +
-        "AND EXISTS (SELECT 1 FROM songs " +
-        "JOIN song_downloads sd ON sd.sourceId = songs.sourceId AND sd.songId = songs.id " +
-        "WHERE songs.sourceId = albums.sourceId AND songs.albumId = albums.id AND sd.status = 'Completed') " +
-        "UNION " +
-        "SELECT songs.albumId FROM songs " +
-        "JOIN albums ON albums.sourceId = songs.sourceId AND albums.id = songs.albumId " +
-        "JOIN song_downloads sd ON sd.sourceId = songs.sourceId AND sd.songId = songs.id " +
-        "WHERE songs.sourceId = :sourceId AND songs.artistId = artists.id " +
-        "AND sd.status = 'Completed' " +
-        "UNION " +
-        "SELECT songs.albumId FROM song_artists " +
-        "JOIN songs ON songs.sourceId = song_artists.sourceId AND songs.id = song_artists.songId " +
-        "JOIN albums ON albums.sourceId = songs.sourceId AND albums.id = songs.albumId " +
-        "JOIN song_downloads sd ON sd.sourceId = songs.sourceId AND sd.songId = songs.id " +
-        "WHERE song_artists.sourceId = :sourceId AND song_artists.artistId = artists.id " +
-        "AND sd.status = 'Completed'"
 
-internal const val ARTISTS_FILTER =
+private const val ARTIST_COVER_RANKS_TAIL =
-    "FROM artists WHERE sourceId = :sourceId " +
+    "ranked AS (SELECT credits.artistId AS artistId, albums.coverArt AS coverArt, " +
-        "AND (:starredFilter = 0 OR (:starredFilter = 1 AND starred IS NOT NULL) OR (:starredFilter = 2 AND starred IS NULL)) " +
+        "ROW_NUMBER() OVER (PARTITION BY credits.artistId " +
-        "AND $ARTIST_CREDITED " +
+        "ORDER BY credits.creditRank, albums.year DESC, albums.sortName COLLATE NOCASE, albums.id) AS coverRank " +
-        "AND (:downloadedFilter = 0 OR EXISTS (" +
+        "FROM credits JOIN albums ON albums.sourceId = :sourceId AND albums.id = credits.albumId " +
-        "SELECT 1 FROM ($ARTIST_DOWNLOAD_ROWS) dl " +
+        "WHERE albums.coverArt IS NOT NULL), " +
-        "WHERE dl.id = artists.id AND dl.status = 'Completed')) " +
+        "unique_ranked AS (SELECT artistId, coverArt, MIN(coverRank) AS coverRank FROM ranked GROUP BY artistId, coverArt), " +
-        "AND (:search = '' " +
+        "deduped AS (SELECT artistId, coverArt, " +
-        "OR (length(:search) >= 3 AND rowid IN (SELECT rowid FROM artist_search " +
+        "ROW_NUMBER() OVER (PARTITION BY artistId ORDER BY coverRank) AS coverRank FROM unique_ranked)"
-        "WHERE artist_search MATCH '\"' || replace(:search, '\"', '\"\"') || '\"')) " +
-        "OR (length(:search) < 3 AND (instr(lower(name), lower(:search)) > 0 " +
-        "OR instr(lower(sortName), lower(:search)) > 0))) "
 
-internal const val ARTIST_ALBUM_CREDIT_ART =
+private val ARTIST_COVER_RANKS =
-    "SELECT albums.coverArt FROM (" +
+    "credits AS (SELECT artistId, albumId, " +
-        "SELECT albums.id, albums.coverArt, albums.year, albums.sortName FROM albums " +
+        "MIN(CASE creditType WHEN 'album' THEN 0 ELSE 1 END) AS creditRank " +
-        "INDEXED BY index_albums_sourceId_artistId " +
+        "FROM ($ARTIST_COVER_CREDITS) GROUP BY artistId, albumId), " +
-        "WHERE albums.sourceId = artists.sourceId AND albums.artistId = artists.id " +
+        ARTIST_COVER_RANKS_TAIL
-        "UNION ALL " +
-        "SELECT albums.id, albums.coverArt, albums.year, albums.sortName FROM album_artists " +
-        "JOIN albums ON albums.sourceId = album_artists.sourceId AND albums.id = album_artists.albumId " +
-        "WHERE album_artists.sourceId = artists.sourceId AND album_artists.artistId = artists.id" +
-        ") albums ORDER BY albums.year DESC, albums.sortName COLLATE NOCASE, albums.id LIMIT 1"
 
-internal const val ARTIST_TRACK_CREDIT_ART =
+private val ARTIST_COVER_RANKS_FOR_ARTIST =
-    "SELECT albums.coverArt FROM (" +
+    "credits AS (SELECT artistId, albumId, " +
-        "SELECT albums.id, albums.coverArt, albums.year, albums.sortName FROM songs " +
+        "MIN(CASE creditType WHEN 'album' THEN 0 ELSE 1 END) AS creditRank " +
-        "JOIN albums ON albums.sourceId = songs.sourceId AND albums.id = songs.albumId " +
+        "FROM ($ARTIST_COVER_CREDITS_FOR_ARTIST) GROUP BY artistId, albumId), " +
-        "WHERE songs.sourceId = artists.sourceId AND songs.artistId = artists.id " +
+        ARTIST_COVER_RANKS_TAIL
-        "UNION ALL " +
-        "SELECT albums.id, albums.coverArt, albums.year, albums.sortName FROM song_artists " +
-        "JOIN songs ON songs.sourceId = song_artists.sourceId AND songs.id = song_artists.songId " +
-        "JOIN albums ON albums.sourceId = songs.sourceId AND albums.id = songs.albumId " +
-        "WHERE song_artists.sourceId = artists.sourceId AND song_artists.artistId = artists.id" +
-        ") albums ORDER BY albums.year DESC, albums.sortName COLLATE NOCASE, albums.id LIMIT 1"
 
-internal const val ARTIST_COVER_ART =
+internal val ARTIST_ART_UPDATE_SQL =
-    "COALESCE(artists.coverArt, CASE " +
+    "WITH $ARTIST_COVER_RANKS, " +
-        "WHEN EXISTS (SELECT 1 FROM albums WHERE albums.sourceId = artists.sourceId AND albums.artistId = artists.id) " +
+        "covers AS (SELECT artistId, group_concat(coverArt, char(31)) AS coverArts FROM (" +
-        "OR EXISTS (SELECT 1 FROM album_artists " +
+        "SELECT artistId, coverArt, coverRank FROM deduped WHERE coverRank <= 4 ORDER BY artistId, coverRank" +
-        "WHERE album_artists.sourceId = artists.sourceId AND album_artists.artistId = artists.id) " +
+        ") GROUP BY artistId), " +
-        "THEN ($ARTIST_ALBUM_CREDIT_ART) ELSE ($ARTIST_TRACK_CREDIT_ART) END)"
+        "downloaded_albums AS (SELECT DISTINCT artistId, albumId FROM ($DOWNLOADED_COVER_ALBUM_ROWS)), " +
+        "downloaded AS (SELECT dl.artistId AS artistId, albums.coverArt AS coverArt, " +
+        "ROW_NUMBER() OVER (PARTITION BY dl.artistId " +
+        "ORDER BY albums.year DESC, albums.sortName COLLATE NOCASE, albums.id) AS coverRank " +
+        "FROM downloaded_albums dl JOIN albums ON albums.sourceId = :sourceId AND albums.id = dl.albumId " +
+        "WHERE albums.coverArt IS NOT NULL), " +
+        "unique_downloaded AS (SELECT artistId, coverArt, MIN(coverRank) AS coverRank FROM downloaded GROUP BY artistId, coverArt), " +
+        "downloaded_deduped AS (SELECT artistId, coverArt, " +
+        "ROW_NUMBER() OVER (PARTITION BY artistId ORDER BY coverRank) AS coverRank FROM unique_downloaded), " +
+        "downloaded_covers AS (SELECT artistId, group_concat(coverArt, char(31)) AS coverArts FROM (" +
+        "SELECT artistId, coverArt, coverRank FROM downloaded_deduped WHERE coverRank <= 4 ORDER BY artistId, coverRank" +
+        ") GROUP BY artistId), " +
+        "desired AS (SELECT artists.rowid AS rowid, " +
+        "COALESCE((SELECT coverArts FROM covers WHERE covers.artistId = artists.id), '') AS coverArts, " +
+        "COALESCE((SELECT coverArts FROM downloaded_covers " +
+        "WHERE downloaded_covers.artistId = artists.id), '') AS downloadedCoverArts " +
+        "FROM artists WHERE artists.sourceId = :sourceId) " +
+        "UPDATE artists SET coverArts = desired.coverArts, downloadedCoverArts = desired.downloadedCoverArts " +
+        "FROM desired WHERE artists.rowid = desired.rowid AND " +
+        "(artists.coverArts != desired.coverArts OR artists.downloadedCoverArts != desired.downloadedCoverArts)"
 
-internal const val ARTIST_COLUMNS =
+internal val ARTIST_COVER_ARTS_SQL =
-    "artists.sourceId, artists.id, artists.name, artists.albumCount, artists.starred, " +
+    "WITH $ARTIST_COVER_RANKS_FOR_ARTIST " +
-        "$ARTIST_COVER_ART AS coverArt, artists.playCount, artists.played, artists.songCount, " +
+        "SELECT coverArt FROM deduped WHERE coverRank <= 4 ORDER BY coverRank"
+
+internal val DOWNLOADED_ARTIST_ART_UPDATE_SQL =
+    "WITH downloaded_albums AS (SELECT DISTINCT artistId, albumId FROM ($DOWNLOADED_COVER_ALBUM_ROWS) " +
+        "WHERE artistId IN (:artistIds)), " +
+        "downloaded AS (SELECT dl.artistId AS artistId, albums.coverArt AS coverArt, " +
+        "ROW_NUMBER() OVER (PARTITION BY dl.artistId " +
+        "ORDER BY albums.year DESC, albums.sortName COLLATE NOCASE, albums.id) AS coverRank " +
+        "FROM downloaded_albums dl JOIN albums ON albums.sourceId = :sourceId AND albums.id = dl.albumId " +
+        "WHERE albums.coverArt IS NOT NULL), " +
+        "unique_downloaded AS (SELECT artistId, coverArt, MIN(coverRank) AS coverRank FROM downloaded GROUP BY artistId, coverArt), " +
+        "downloaded_deduped AS (SELECT artistId, coverArt, " +
+        "ROW_NUMBER() OVER (PARTITION BY artistId ORDER BY coverRank) AS coverRank FROM unique_downloaded), " +
+        "downloaded_covers AS (SELECT artistId, group_concat(coverArt, char(31)) AS coverArts FROM (" +
+        "SELECT artistId, coverArt, coverRank FROM downloaded_deduped WHERE coverRank <= 4 ORDER BY artistId, coverRank" +
+        ") GROUP BY artistId), " +
+        "desired AS (SELECT artists.rowid AS rowid, " +
+        "COALESCE((SELECT coverArts FROM downloaded_covers " +
+        "WHERE downloaded_covers.artistId = artists.id), '') AS downloadedCoverArts " +
+        "FROM artists WHERE artists.sourceId = :sourceId AND artists.id IN (:artistIds)) " +
+        "UPDATE artists SET downloadedCoverArts = desired.downloadedCoverArts " +
+        "FROM desired WHERE artists.rowid = desired.rowid AND " +
+        "artists.downloadedCoverArts != desired.downloadedCoverArts"
+
+internal const val ARTIST_COLUMNS_TAIL =
+    "artists.starred, artists.coverArt, artists.artistImageUrl, artists.coverArts, " +
+        "artists.downloadedCoverArts, artists.playCount, artists.played, artists.songCount, " +
         "artists.sortName, artists.credited"
 
-// With the Downloaded filter on, count the albums that actually have a download so the number under
+internal const val ARTIST_COLUMNS =
-// an artist matches the albums its detail screen lists.
+    "artists.sourceId, artists.id, artists.name, artists.albumCount, $ARTIST_COLUMNS_TAIL"
-internal const val ARTISTS_SELECT =
-    "SELECT artists.sourceId, artists.id, artists.name, " +
-        "CASE WHEN :downloadedFilter = 1 THEN (" +
-        "SELECT COUNT(*) FROM ($DOWNLOADED_ARTIST_ALBUMS)" +
-        ") ELSE artists.albumCount END AS albumCount, " +
-        "artists.starred, $ARTIST_COVER_ART AS coverArt, artists.playCount, artists.played, artists.songCount, " +
-        "artists.sortName, artists.credited "
 
-internal const val ARTIST_ORDER_BY_NAME = "sortName COLLATE NOCASE, id"
-internal const val ARTIST_ORDER_BY_NAME_REVERSED = "sortName COLLATE NOCASE DESC, id DESC"
 internal const val ARTIST_ORDER_BY_ALBUM_COUNT = "albumCount DESC, sortName COLLATE NOCASE, id"
 internal const val ARTIST_ORDER_BY_ALBUM_COUNT_REVERSED = "albumCount ASC, sortName COLLATE NOCASE DESC, id DESC"
 internal const val ARTIST_ORDER_BY_STARRED = "starred DESC NULLS LAST, sortName COLLATE NOCASE, id"
@@ -220,26 +187,13 @@ internal const val ARTIST_ORDER_BY_FREQUENT_REVERSED = "artists.playCount ASC, s
 internal const val ARTIST_ORDER_BY_RECENT = "artists.played DESC NULLS LAST, sortName COLLATE NOCASE, id"
 internal const val ARTIST_ORDER_BY_RECENT_REVERSED = "artists.played ASC NULLS LAST, sortName COLLATE NOCASE DESC, id DESC"
 
-internal const val PLAYLISTS_FILTER =
+private const val ARTIST_NAME_SORT_KEY_MODE =
-    "FROM playlists WHERE sourceId = :sourceId " +
+    "(CASE :sortMode WHEN 'Name' THEN name WHEN 'NonLatin' THEN (CASE WHEN name GLOB '*[A-Za-z]*' THEN name ELSE sortName END) ELSE sortName END) COLLATE NOCASE"
-        "AND (:downloadedFilter = 0 OR EXISTS (SELECT 1 FROM playlist_songs ps " +
+internal const val ARTIST_ORDER_BY_NAME_SORT_MODE = "$ARTIST_NAME_SORT_KEY_MODE, id"
-        "JOIN song_downloads sd ON sd.sourceId = ps.sourceId AND sd.songId = ps.songId " +
-        "WHERE ps.sourceId = playlists.sourceId AND ps.playlistId = playlists.id AND sd.status = 'Completed')) " +
-        "AND (:search = '' " +
-        "OR (length(:search) >= 3 AND rowid IN (SELECT rowid FROM playlist_search " +
-        "WHERE playlist_search MATCH '\"' || replace(:search, '\"', '\"\"') || '\"')) " +
-        "OR (length(:search) < 3 AND instr(lower(name), lower(:search)) > 0)) "
 
-// With the Downloaded filter on, count the songs that actually have a download so the number under
+private const val SONG_NAME_SORT_KEY_MODE =
-// a playlist matches the songs its detail screen lists.
+    "(CASE :sortMode WHEN 'Name' THEN songs.title WHEN 'NonLatin' THEN (CASE WHEN songs.title GLOB '*[A-Za-z]*' THEN songs.title ELSE songs.sortName END) ELSE songs.sortName END) COLLATE NOCASE"
-internal const val PLAYLISTS_SELECT =
+internal const val SONG_SEARCH_ORDER_SORT_MODE = "$SONG_NAME_SORT_KEY_MODE, songs.id"
-    "SELECT playlists.sourceId, playlists.id, playlists.name, playlists.comment, playlists.coverArt, " +
-        "CASE WHEN :downloadedFilter = 1 THEN (" +
-        "SELECT COUNT(DISTINCT ps.songId) FROM playlist_songs ps " +
-        "JOIN song_downloads sd ON sd.sourceId = ps.sourceId AND sd.songId = ps.songId AND sd.status = 'Completed' " +
-        "WHERE ps.sourceId = playlists.sourceId AND ps.playlistId = playlists.id " +
-        ") ELSE playlists.songCount END AS songCount, " +
-        "playlists.created, playlists.changed, playlists.duration "
 
 internal const val PLAYLIST_ORDER_BY_NAME = "name COLLATE NOCASE, id"
 internal const val PLAYLIST_ORDER_BY_NAME_REVERSED = "name COLLATE NOCASE DESC, id DESC"
@@ -268,6 +222,39 @@ internal const val SONG_SEARCH_FILTER =
     "(length(:search) >= $SEARCH_MIN_LENGTH AND songs.rowid IN (SELECT rowid FROM song_search " +
         "WHERE song_search MATCH '\"' || replace(:search, '\"', '\"\"') || '\"'))"
 
+internal val ARTIST_AGGREGATES_SQL =
+    "WITH credited AS (SELECT DISTINCT * FROM ($CREDITED_SONG_ROWS)), " +
+        "credited_albums AS ($CREDITED_ALBUM_ROWS), " +
+        "totals AS (" +
+        "SELECT artistId AS id, COUNT(DISTINCT songId) AS songCount, " +
+        "SUM(playCount) AS playCount, MAX(played) AS played " +
+        "FROM credited GROUP BY artistId" +
+        "), album_totals AS (" +
+        "SELECT artistId AS id, COUNT(DISTINCT albumId) AS albumCount " +
+        "FROM credited_albums GROUP BY artistId" +
+        ") " +
+        "UPDATE artists SET songCount = c.songCount, albumCount = c.albumCount, " +
+        "playCount = c.playCount, played = c.played, credited = c.credited " +
+        "FROM (SELECT artists.id AS id, COALESCE(totals.songCount, 0) AS songCount, " +
+        "COALESCE(album_totals.albumCount, 0) AS albumCount, " +
+        "COALESCE(totals.playCount, 0) AS playCount, totals.played AS played, " +
+        "((NOT EXISTS (SELECT 1 FROM album_artists WHERE sourceId = artists.sourceId) " +
+        "AND NOT EXISTS (SELECT 1 FROM song_artists WHERE sourceId = artists.sourceId)) " +
+        "OR EXISTS (SELECT 1 FROM album_artists aa " +
+        "WHERE aa.sourceId = artists.sourceId AND aa.artistId = artists.id) " +
+        "OR EXISTS (SELECT 1 FROM song_artists sa " +
+        "WHERE sa.sourceId = artists.sourceId AND sa.artistId = artists.id)) AS credited " +
+        "FROM artists LEFT JOIN totals ON totals.id = artists.id " +
+        "LEFT JOIN album_totals ON album_totals.id = artists.id " +
+        "WHERE artists.sourceId = :sourceId) c " +
+        "WHERE artists.sourceId = :sourceId AND artists.id = c.id " +
+        "AND (artists.songCount != c.songCount OR artists.albumCount != c.albumCount " +
+        "OR artists.playCount != c.playCount OR artists.played IS NOT c.played " +
+        "OR artists.credited != c.credited)"
+
+internal val ALBUMS_FOR_ARTIST_DOWNLOADED =
+    "SELECT * FROM ($DOWNLOADED_ALBUM_DETAILS_FOR_ARTIST) ORDER BY year DESC, sortName COLLATE NOCASE, id"
+
 @Dao
 @DaoReturnTypeConverters(PagingSourceDaoReturnTypeConverter::class)
 interface LibraryDao {
@@ -300,44 +287,46 @@ interface LibraryDao {
     )
     suspend fun recomputeAlbumPlayData(sourceId: Long)
 
-    // Counts, plays and the credited flag come from the shared credit unions. The download-aware
+    @RawQuery
-    // queries are separate because their visibility follows the credit path.
+    suspend fun recomputeArtistAggregates(query: RoomRawQuery): Int
-    @Query(
+
-        "WITH credited AS (SELECT DISTINCT * FROM ($CREDITED_SONG_ROWS)), " +
+    suspend fun recomputeArtistAggregates(sourceId: Long) {
-            "credited_albums AS ($CREDITED_ALBUM_ROWS), " +
+        recomputeArtistAggregates(rawQuery(ARTIST_AGGREGATES_SQL, mapOf("sourceId" to sourceId)))
-            "totals AS (" +
+    }
-            "SELECT artistId AS id, COUNT(DISTINCT songId) AS songCount, " +
+
-            "SUM(playCount) AS playCount, MAX(played) AS played " +
+    @RawQuery
-            "FROM credited GROUP BY artistId" +
+    suspend fun recomputeArtistArt(query: RoomRawQuery): Int
-            "), album_totals AS (" +
+
-            "SELECT artistId AS id, COUNT(DISTINCT albumId) AS albumCount " +
+    suspend fun recomputeArtistArt(sourceId: Long) {
-            "FROM credited_albums GROUP BY artistId" +
+        recomputeArtistArt(rawQuery(ARTIST_ART_UPDATE_SQL, mapOf("sourceId" to sourceId)))
-            ") " +
+    }
-            "UPDATE artists SET songCount = c.songCount, albumCount = c.albumCount, " +
+
-            "playCount = c.playCount, played = c.played, credited = c.credited " +
+    @RawQuery(observedEntities = [Album::class, AlbumArtistRef::class, Song::class, SongArtistRef::class])
-            "FROM (SELECT artists.id AS id, COALESCE(totals.songCount, 0) AS songCount, " +
+    fun artistCoverArts(query: RoomRawQuery): Flow<List<String>>
-            "COALESCE(album_totals.albumCount, 0) AS albumCount, " +
+
-            "COALESCE(totals.playCount, 0) AS playCount, totals.played AS played, " +
+    fun artistCoverArts(
-            "((NOT EXISTS (SELECT 1 FROM album_artists WHERE sourceId = artists.sourceId) " +
+        sourceId: Long,
-            "AND NOT EXISTS (SELECT 1 FROM song_artists WHERE sourceId = artists.sourceId)) " +
+        artistId: String,
-            "OR EXISTS (SELECT 1 FROM album_artists aa " +
+    ): Flow<List<String>> = artistCoverArts(rawQuery(ARTIST_COVER_ARTS_SQL, mapOf("sourceId" to sourceId, "artistId" to artistId)))
-            "WHERE aa.sourceId = artists.sourceId AND aa.artistId = artists.id) " +
+
-            "OR EXISTS (SELECT 1 FROM song_artists sa " +
+    @RawQuery
-            "WHERE sa.sourceId = artists.sourceId AND sa.artistId = artists.id)) AS credited " +
+    suspend fun recomputeDownloadedArtistArt(query: RoomRawQuery): Int
-            "FROM artists LEFT JOIN totals ON totals.id = artists.id " +
+
-            "LEFT JOIN album_totals ON album_totals.id = artists.id " +
+    suspend fun recomputeDownloadedArtistArt(
-            "WHERE artists.sourceId = :sourceId) c " +
+        sourceId: Long,
-            "WHERE artists.sourceId = :sourceId AND artists.id = c.id " +
+        artistIds: List<String>,
-            "AND (artists.songCount != c.songCount OR artists.albumCount != c.albumCount " +
+    ) {
-            "OR artists.playCount != c.playCount OR artists.played IS NOT c.played " +
+        recomputeDownloadedArtistArt(downloadedArtistArtQuery(sourceId, artistIds))
-            "OR artists.credited != c.credited)",
+    }
-    )
+
-    suspend fun recomputeArtistAggregates(sourceId: Long)
+    @Query("UPDATE artists SET downloadedCoverArts = '' WHERE sourceId = :sourceId AND downloadedCoverArts != ''")
+    suspend fun clearDownloadedArtistArt(sourceId: Long)
 
     @Transaction
     suspend fun recomputeAggregates(sourceId: Long) {
         recomputeAlbumPlayData(sourceId)
         recomputeArtistAggregates(sourceId)
+        recomputeArtistArt(sourceId)
     }
 
     @Query(
@@ -381,6 +370,12 @@ interface LibraryDao {
         songId: String,
     ): String?
 
+    @Query("SELECT DISTINCT artistId FROM ($CREDITED_SONG_ROWS) WHERE songId IN (:songIds)")
+    suspend fun creditedArtistIdsForSongs(
+        sourceId: Long,
+        songIds: List<String>,
+    ): List<String>
+
     // Counted locally when a scrobble is submitted, so the play sorts move before the next sync; the
     // sync then overwrites with the server's own number.
     @Transaction
@@ -471,22 +466,24 @@ interface LibraryDao {
 
     @Query(
         "SELECT * FROM albums WHERE sourceId = :sourceId AND $ALBUM_SEARCH_FILTER " +
-            "ORDER BY sortName COLLATE NOCASE, id LIMIT :limit",
+            "ORDER BY $ALBUM_ORDER_BY_NAME_SORT_MODE LIMIT :limit",
     )
     fun searchAlbums(
         sourceId: Long,
         search: String,
         limit: Int,
+        sortMode: String = "",
     ): Flow<List<Album>>
 
     @Query(
         "SELECT $ARTIST_COLUMNS FROM artists WHERE sourceId = :sourceId AND $ARTIST_SEARCH_FILTER AND $ARTIST_CREDITED " +
-            "ORDER BY sortName COLLATE NOCASE, id LIMIT :limit",
+            "ORDER BY $ARTIST_ORDER_BY_NAME_SORT_MODE LIMIT :limit",
     )
     fun searchArtists(
         sourceId: Long,
         search: String,
         limit: Int,
+        sortMode: String = "",
     ): Flow<List<Artist>>
 
     @Query(
@@ -503,12 +500,13 @@ interface LibraryDao {
         "SELECT songs.*, albums.coverArt AS coverArt FROM songs " +
             "LEFT JOIN albums ON albums.sourceId = songs.sourceId AND albums.id = songs.albumId " +
             "WHERE songs.sourceId = :sourceId AND $SONG_SEARCH_FILTER " +
-            "ORDER BY songs.sortName COLLATE NOCASE, songs.id LIMIT :limit",
+            "ORDER BY $SONG_SEARCH_ORDER_SORT_MODE LIMIT :limit",
     )
     fun searchSongs(
         sourceId: Long,
         search: String,
         limit: Int,
+        sortMode: String = "",
     ): Flow<List<AlbumSongItem>>
 
     @Query(
@@ -650,239 +648,27 @@ interface LibraryDao {
     @RawQuery(observedEntities = [Playlist::class])
     fun playlistsPaging(query: RoomRawQuery): PagingSource<Int, Playlist>
 
-    @Query("SELECT * $ALBUMS_FILTER ORDER BY $ALBUM_ORDER_BY_NAME")
+    // These observe every table the statements read; the sets match what Room inferred for the
-    fun albumsByName(
+    // old downloaded @Query methods, so download and library writes invalidate as before.
-        sourceId: Long,
+    @RawQuery(observedEntities = [Album::class, Song::class, SongDownload::class, AlbumSearch::class])
-        starredFilter: Int,
+    fun downloadedAlbumsPaging(query: RoomRawQuery): PagingSource<Int, Album>
-        search: String,
-        downloadedFilter: Int = 0,
-    ): PagingSource<Int, Album>
 
-    @Query("SELECT * $ALBUMS_FILTER ORDER BY $ALBUM_ORDER_BY_NAME_REVERSED")
+    @RawQuery(
-    fun albumsByNameReversed(
+        observedEntities = [
-        sourceId: Long,
+            Album::class,
-        starredFilter: Int,
+            Song::class,
-        search: String,
+            SongDownload::class,
-        downloadedFilter: Int = 0,
+            AlbumArtistRef::class,
-    ): PagingSource<Int, Album>
+            SongArtistRef::class,
+            Artist::class,
+            Source::class,
+            ArtistSearch::class,
+        ],
+    )
+    fun downloadedArtistsPaging(query: RoomRawQuery): PagingSource<Int, Artist>
 
-    @Query("SELECT * $ALBUMS_FILTER ORDER BY $ALBUM_ORDER_BY_ARTIST")
+    @RawQuery(observedEntities = [PlaylistSong::class, SongDownload::class, Playlist::class, PlaylistSearch::class])
-    fun albumsByArtist(
+    fun downloadedPlaylistsPaging(query: RoomRawQuery): PagingSource<Int, Playlist>
-        sourceId: Long,
-        starredFilter: Int,
-        search: String,
-        downloadedFilter: Int = 0,
-    ): PagingSource<Int, Album>
-
-    @Query("SELECT * $ALBUMS_FILTER ORDER BY $ALBUM_ORDER_BY_ARTIST_REVERSED")
-    fun albumsByArtistReversed(
-        sourceId: Long,
-        starredFilter: Int,
-        search: String,
-        downloadedFilter: Int = 0,
-    ): PagingSource<Int, Album>
-
-    @Query("SELECT * $ALBUMS_FILTER ORDER BY $ALBUM_ORDER_BY_YEAR")
-    fun albumsByYear(
-        sourceId: Long,
-        starredFilter: Int,
-        search: String,
-        downloadedFilter: Int = 0,
-    ): PagingSource<Int, Album>
-
-    @Query("SELECT * $ALBUMS_FILTER ORDER BY $ALBUM_ORDER_BY_YEAR_REVERSED")
-    fun albumsByYearReversed(
-        sourceId: Long,
-        starredFilter: Int,
-        search: String,
-        downloadedFilter: Int = 0,
-    ): PagingSource<Int, Album>
-
-    @Query("SELECT * $ALBUMS_FILTER ORDER BY $ALBUM_ORDER_BY_ADDED")
-    fun albumsByRecentlyAdded(
-        sourceId: Long,
-        starredFilter: Int,
-        search: String,
-        downloadedFilter: Int = 0,
-    ): PagingSource<Int, Album>
-
-    @Query("SELECT * $ALBUMS_FILTER ORDER BY $ALBUM_ORDER_BY_ADDED_REVERSED")
-    fun albumsByRecentlyAddedReversed(
-        sourceId: Long,
-        starredFilter: Int,
-        search: String,
-        downloadedFilter: Int = 0,
-    ): PagingSource<Int, Album>
-
-    @Query("SELECT * $ALBUMS_FILTER ORDER BY $ALBUM_ORDER_BY_STARRED")
-    fun albumsByStarred(
-        sourceId: Long,
-        starredFilter: Int,
-        search: String,
-        downloadedFilter: Int = 0,
-    ): PagingSource<Int, Album>
-
-    @Query("SELECT * $ALBUMS_FILTER ORDER BY $ALBUM_ORDER_BY_STARRED_REVERSED")
-    fun albumsByStarredReversed(
-        sourceId: Long,
-        starredFilter: Int,
-        search: String,
-        downloadedFilter: Int = 0,
-    ): PagingSource<Int, Album>
-
-    @Query("SELECT * $ALBUMS_FILTER ORDER BY $ALBUM_ORDER_BY_FREQUENT")
-    fun albumsByFrequent(
-        sourceId: Long,
-        starredFilter: Int,
-        search: String,
-        downloadedFilter: Int = 0,
-    ): PagingSource<Int, Album>
-
-    @Query("SELECT * $ALBUMS_FILTER ORDER BY $ALBUM_ORDER_BY_FREQUENT_REVERSED")
-    fun albumsByFrequentReversed(
-        sourceId: Long,
-        starredFilter: Int,
-        search: String,
-        downloadedFilter: Int = 0,
-    ): PagingSource<Int, Album>
-
-    @Query("SELECT * $ALBUMS_FILTER ORDER BY $ALBUM_ORDER_BY_RECENT")
-    fun albumsByRecent(
-        sourceId: Long,
-        starredFilter: Int,
-        search: String,
-        downloadedFilter: Int = 0,
-    ): PagingSource<Int, Album>
-
-    @Query("SELECT * $ALBUMS_FILTER ORDER BY $ALBUM_ORDER_BY_RECENT_REVERSED")
-    fun albumsByRecentReversed(
-        sourceId: Long,
-        starredFilter: Int,
-        search: String,
-        downloadedFilter: Int = 0,
-    ): PagingSource<Int, Album>
-
-    @Query("$ARTISTS_SELECT $ARTISTS_FILTER ORDER BY $ARTIST_ORDER_BY_NAME")
-    fun artistsByName(
-        sourceId: Long,
-        starredFilter: Int,
-        search: String,
-        downloadedFilter: Int = 0,
-    ): PagingSource<Int, Artist>
-
-    @Query("$ARTISTS_SELECT $ARTISTS_FILTER ORDER BY $ARTIST_ORDER_BY_NAME_REVERSED")
-    fun artistsByNameReversed(
-        sourceId: Long,
-        starredFilter: Int,
-        search: String,
-        downloadedFilter: Int = 0,
-    ): PagingSource<Int, Artist>
-
-    @Query("$ARTISTS_SELECT $ARTISTS_FILTER ORDER BY $ARTIST_ORDER_BY_ALBUM_COUNT")
-    fun artistsByAlbumCount(
-        sourceId: Long,
-        starredFilter: Int,
-        search: String,
-        downloadedFilter: Int = 0,
-    ): PagingSource<Int, Artist>
-
-    @Query("$ARTISTS_SELECT $ARTISTS_FILTER ORDER BY $ARTIST_ORDER_BY_ALBUM_COUNT_REVERSED")
-    fun artistsByAlbumCountReversed(
-        sourceId: Long,
-        starredFilter: Int,
-        search: String,
-        downloadedFilter: Int = 0,
-    ): PagingSource<Int, Artist>
-
-    @Query("$ARTISTS_SELECT $ARTISTS_FILTER ORDER BY $ARTIST_ORDER_BY_STARRED")
-    fun artistsByStarred(
-        sourceId: Long,
-        starredFilter: Int,
-        search: String,
-        downloadedFilter: Int = 0,
-    ): PagingSource<Int, Artist>
-
-    @Query("$ARTISTS_SELECT $ARTISTS_FILTER ORDER BY $ARTIST_ORDER_BY_STARRED_REVERSED")
-    fun artistsByStarredReversed(
-        sourceId: Long,
-        starredFilter: Int,
-        search: String,
-        downloadedFilter: Int = 0,
-    ): PagingSource<Int, Artist>
-
-    @Query("$ARTISTS_SELECT $ARTISTS_FILTER ORDER BY $ARTIST_ORDER_BY_FREQUENT")
-    fun artistsByFrequent(
-        sourceId: Long,
-        starredFilter: Int,
-        search: String,
-        downloadedFilter: Int = 0,
-    ): PagingSource<Int, Artist>
-
-    @Query("$ARTISTS_SELECT $ARTISTS_FILTER ORDER BY $ARTIST_ORDER_BY_FREQUENT_REVERSED")
-    fun artistsByFrequentReversed(
-        sourceId: Long,
-        starredFilter: Int,
-        search: String,
-        downloadedFilter: Int = 0,
-    ): PagingSource<Int, Artist>
-
-    @Query("$ARTISTS_SELECT $ARTISTS_FILTER ORDER BY $ARTIST_ORDER_BY_RECENT")
-    fun artistsByRecent(
-        sourceId: Long,
-        starredFilter: Int,
-        search: String,
-        downloadedFilter: Int = 0,
-    ): PagingSource<Int, Artist>
-
-    @Query("$ARTISTS_SELECT $ARTISTS_FILTER ORDER BY $ARTIST_ORDER_BY_RECENT_REVERSED")
-    fun artistsByRecentReversed(
-        sourceId: Long,
-        starredFilter: Int,
-        search: String,
-        downloadedFilter: Int = 0,
-    ): PagingSource<Int, Artist>
-
-    @Query("$PLAYLISTS_SELECT $PLAYLISTS_FILTER ORDER BY $PLAYLIST_ORDER_BY_NAME")
-    fun playlistsByName(
-        sourceId: Long,
-        search: String,
-        downloadedFilter: Int = 0,
-    ): PagingSource<Int, Playlist>
-
-    @Query("$PLAYLISTS_SELECT $PLAYLISTS_FILTER ORDER BY $PLAYLIST_ORDER_BY_NAME_REVERSED")
-    fun playlistsByNameReversed(
-        sourceId: Long,
-        search: String,
-        downloadedFilter: Int = 0,
-    ): PagingSource<Int, Playlist>
-
-    @Query("$PLAYLISTS_SELECT $PLAYLISTS_FILTER ORDER BY $PLAYLIST_ORDER_BY_ADDED")
-    fun playlistsByAdded(
-        sourceId: Long,
-        search: String,
-        downloadedFilter: Int = 0,
-    ): PagingSource<Int, Playlist>
-
-    @Query("$PLAYLISTS_SELECT $PLAYLISTS_FILTER ORDER BY $PLAYLIST_ORDER_BY_ADDED_REVERSED")
-    fun playlistsByAddedReversed(
-        sourceId: Long,
-        search: String,
-        downloadedFilter: Int = 0,
-    ): PagingSource<Int, Playlist>
-
-    @Query("$PLAYLISTS_SELECT $PLAYLISTS_FILTER ORDER BY $PLAYLIST_ORDER_BY_UPDATED")
-    fun playlistsByUpdated(
-        sourceId: Long,
-        search: String,
-        downloadedFilter: Int = 0,
-    ): PagingSource<Int, Playlist>
-
-    @Query("$PLAYLISTS_SELECT $PLAYLISTS_FILTER ORDER BY $PLAYLIST_ORDER_BY_UPDATED_REVERSED")
-    fun playlistsByUpdatedReversed(
-        sourceId: Long,
-        search: String,
-        downloadedFilter: Int = 0,
-    ): PagingSource<Int, Playlist>
 
     @Query("SELECT * FROM albums WHERE sourceId = :sourceId AND played IS NOT NULL ORDER BY played DESC, sortName COLLATE NOCASE, id")
     fun homeRecentlyPlayedAlbums(sourceId: Long): PagingSource<Int, Album>
@@ -1116,17 +902,21 @@ interface LibraryDao {
         songId: String,
     ): Flow<List<String>>
 
-    @Query(ALBUMS_FOR_ARTIST)
+    @RawQuery(observedEntities = [Album::class, AlbumArtistRef::class, Song::class, SongArtistRef::class])
+    fun albumsForArtist(query: RoomRawQuery): Flow<List<Album>>
+
     fun albumsForArtist(
         sourceId: Long,
         artistId: String,
-    ): Flow<List<Album>>
+    ): Flow<List<Album>> = albumsForArtist(rawQuery(ALBUMS_FOR_ARTIST, mapOf("sourceId" to sourceId, "artistId" to artistId)))
+
+    @RawQuery(observedEntities = [Album::class, AlbumArtistRef::class, Song::class, SongArtistRef::class])
+    fun albumCreditAlbumIds(query: RoomRawQuery): Flow<List<String>>
 
-    @Query(ALBUM_CREDIT_ALBUM_IDS)
     fun albumCreditAlbumIds(
         sourceId: Long,
         artistId: String,
-    ): Flow<List<String>>
+    ): Flow<List<String>> = albumCreditAlbumIds(rawQuery(ALBUM_CREDIT_ALBUM_IDS, mapOf("sourceId" to sourceId, "artistId" to artistId)))
 
     @Query("SELECT * FROM discs WHERE sourceId = :sourceId AND albumId = :albumId ORDER BY disc")
     fun discs(
@@ -1163,36 +953,16 @@ interface LibraryDao {
         playlistId: String,
     ): PagingSource<Int, PlaylistSongItem>
 
-    // Download visibility follows the credit path: see DOWNLOADED_ARTIST_ALBUMS.
+    @RawQuery(
-    @Query(
+        observedEntities = [Album::class, Song::class, SongDownload::class, AlbumArtistRef::class, SongArtistRef::class],
-        "SELECT * FROM (" +
-            "SELECT albums.* FROM albums " +
-            "WHERE albums.sourceId = :sourceId AND albums.artistId = :artistId " +
-            "AND EXISTS (SELECT 1 FROM songs " +
-            "JOIN song_downloads sd ON sd.sourceId = songs.sourceId AND sd.songId = songs.id " +
-            "WHERE songs.sourceId = albums.sourceId AND songs.albumId = albums.id AND sd.status = 'Completed') " +
-            "UNION " +
-            "SELECT albums.* FROM album_artists " +
-            "JOIN albums ON albums.sourceId = album_artists.sourceId AND albums.id = album_artists.albumId " +
-            "WHERE album_artists.sourceId = :sourceId AND album_artists.artistId = :artistId " +
-            "AND EXISTS (SELECT 1 FROM songs " +
-            "JOIN song_downloads sd ON sd.sourceId = songs.sourceId AND sd.songId = songs.id " +
-            "WHERE songs.sourceId = albums.sourceId AND songs.albumId = albums.id AND sd.status = 'Completed') " +
-            "UNION " +
-            "SELECT albums.* FROM song_artists " +
-            "JOIN songs ON songs.sourceId = song_artists.sourceId AND songs.id = song_artists.songId " +
-            "JOIN albums ON albums.sourceId = songs.sourceId AND albums.id = songs.albumId " +
-            "JOIN song_downloads sd ON sd.sourceId = songs.sourceId AND sd.songId = songs.id AND sd.status = 'Completed' " +
-            "WHERE song_artists.sourceId = :sourceId AND song_artists.artistId = :artistId " +
-            "UNION " +
-            "SELECT albums.* FROM songs " +
-            "JOIN albums ON albums.sourceId = songs.sourceId AND albums.id = songs.albumId " +
-            "JOIN song_downloads sd ON sd.sourceId = songs.sourceId AND sd.songId = songs.id AND sd.status = 'Completed' " +
-            "WHERE songs.sourceId = :sourceId AND songs.artistId = :artistId" +
-            ") ORDER BY year DESC, sortName COLLATE NOCASE, id",
     )
+    fun albumsForArtistDownloaded(query: RoomRawQuery): Flow<List<Album>>
+
     fun albumsForArtistDownloaded(
         sourceId: Long,
         artistId: String,
-    ): Flow<List<Album>>
+    ): Flow<List<Album>> =
+        albumsForArtistDownloaded(
+            rawQuery(ALBUMS_FOR_ARTIST_DOWNLOADED, mapOf("sourceId" to sourceId, "artistId" to artistId)),
+        )
 }

app/src/main/kotlin/com/subtracks/data/db/LibraryPaging.kt

@@ -5,49 +5,163 @@ import androidx.sqlite.SQLiteStatement
 import com.subtracks.data.prefs.AlbumSort
 import com.subtracks.data.prefs.ArtistSort
 import com.subtracks.data.prefs.PlaylistSort
+import com.subtracks.data.prefs.SortNameMode
 
-// These filters mirror the download-aware ones in LibraryDao but never mention song_downloads, so
+// The default filters intentionally omit song_downloads: the unfiltered lists do not need the
-// the resulting PagingSource is not invalidated by download writes (including progress updates).
+// join, and their paging sources do not observe download writes (including progress updates).
-internal const val ALBUMS_FILTER_BASE =
+internal const val ALBUMS_FILTER = """
-    "FROM albums WHERE sourceId = ? " +
+FROM albums WHERE sourceId = :sourceId
-        "AND (? = 0 OR (? = 1 AND starred IS NOT NULL) OR (? = 2 AND starred IS NULL)) " +
+AND (:starredFilter = 0 OR (:starredFilter = 1 AND starred IS NOT NULL) OR (:starredFilter = 2 AND starred IS NULL))
-        "AND (? = '' " +
+AND (:search = ''
-        "OR (length(?) >= 3 AND rowid IN (SELECT rowid FROM album_search " +
+    OR (length(:search) >= $SEARCH_MIN_LENGTH AND rowid IN (SELECT rowid FROM album_search
-        "WHERE album_search MATCH '\"' || replace(?, '\"', '\"\"') || '\"')) " +
+        WHERE album_search MATCH '"' || replace(:search, '"', '""') || '"'))
-        "OR (length(?) < 3 AND (instr(lower(name), lower(?)) > 0 " +
+    OR (length(:search) < $SEARCH_MIN_LENGTH AND (instr(lower(name), lower(:search)) > 0
-        "OR instr(lower(albumArtist), lower(?)) > 0 " +
+        OR instr(lower(albumArtist), lower(:search)) > 0
-        "OR instr(lower(sortName), lower(?)) > 0 " +
+        OR instr(lower(sortName), lower(:search)) > 0
-        "OR instr(lower(albumArtistSort), lower(?)) > 0))) "
+        OR instr(lower(albumArtistSort), lower(:search)) > 0)))
+"""
 
-internal const val ARTISTS_FILTER_BASE =
+internal const val ALBUMS_FILTER_DOWNLOADED = """
-    "FROM artists WHERE sourceId = ? " +
+FROM albums WHERE sourceId = :sourceId
-        "AND (? = 0 OR (? = 1 AND starred IS NOT NULL) OR (? = 2 AND starred IS NULL)) " +
+AND (:starredFilter = 0 OR (:starredFilter = 1 AND starred IS NOT NULL) OR (:starredFilter = 2 AND starred IS NULL))
-        "AND $ARTIST_CREDITED " +
+AND EXISTS (SELECT 1 FROM songs
-        "AND (? = '' " +
+    JOIN song_downloads sd ON sd.sourceId = songs.sourceId AND sd.songId = songs.id
-        "OR (length(?) >= 3 AND rowid IN (SELECT rowid FROM artist_search " +
+    WHERE songs.sourceId = albums.sourceId AND songs.albumId = albums.id AND sd.status = 'Completed')
-        "WHERE artist_search MATCH '\"' || replace(?, '\"', '\"\"') || '\"')) " +
+AND (:search = ''
-        "OR (length(?) < 3 AND (instr(lower(name), lower(?)) > 0 " +
+    OR (length(:search) >= $SEARCH_MIN_LENGTH AND rowid IN (SELECT rowid FROM album_search
-        "OR instr(lower(sortName), lower(?)) > 0))) "
+        WHERE album_search MATCH '"' || replace(:search, '"', '""') || '"'))
+    OR (length(:search) < $SEARCH_MIN_LENGTH AND (instr(lower(name), lower(:search)) > 0
+        OR instr(lower(albumArtist), lower(:search)) > 0
+        OR instr(lower(sortName), lower(:search)) > 0
+        OR instr(lower(albumArtistSort), lower(:search)) > 0)))
+"""
 
-internal const val PLAYLISTS_FILTER_BASE =
+internal const val ARTISTS_FILTER = """
-    "FROM playlists WHERE sourceId = ? " +
+FROM artists WHERE sourceId = :sourceId
-        "AND (? = '' " +
+AND (:starredFilter = 0 OR (:starredFilter = 1 AND starred IS NOT NULL) OR (:starredFilter = 2 AND starred IS NULL))
-        "OR (length(?) >= 3 AND rowid IN (SELECT rowid FROM playlist_search " +
+AND $ARTIST_CREDITED
-        "WHERE playlist_search MATCH '\"' || replace(?, '\"', '\"\"') || '\"')) " +
+AND (:search = ''
-        "OR (length(?) < 3 AND instr(lower(name), lower(?)) > 0)) "
+    OR (length(:search) >= $SEARCH_MIN_LENGTH AND rowid IN (SELECT rowid FROM artist_search
+        WHERE artist_search MATCH '"' || replace(:search, '"', '""') || '"'))
+    OR (length(:search) < $SEARCH_MIN_LENGTH AND (instr(lower(name), lower(:search)) > 0
+        OR instr(lower(sortName), lower(:search)) > 0)))
+"""
 
-internal fun albumsDefaultQuery(
+internal const val ARTISTS_FILTER_DOWNLOADED = """
+FROM artists WHERE sourceId = :sourceId
+AND (:starredFilter = 0 OR (:starredFilter = 1 AND starred IS NOT NULL) OR (:starredFilter = 2 AND starred IS NULL))
+AND $ARTIST_CREDITED
+AND EXISTS (SELECT 1 FROM ($ARTIST_DOWNLOAD_ROWS) dl
+    WHERE dl.id = artists.id AND dl.status = 'Completed')
+AND (:search = ''
+    OR (length(:search) >= $SEARCH_MIN_LENGTH AND rowid IN (SELECT rowid FROM artist_search
+        WHERE artist_search MATCH '"' || replace(:search, '"', '""') || '"'))
+    OR (length(:search) < $SEARCH_MIN_LENGTH AND (instr(lower(name), lower(:search)) > 0
+        OR instr(lower(sortName), lower(:search)) > 0)))
+"""
+
+// The downloaded list counts the albums that actually have a download so the number under an artist
+// matches the albums its detail screen lists.
+internal val ARTIST_COLUMNS_DOWNLOADED = """
+artists.sourceId, artists.id, artists.name,
+(SELECT COUNT(*) FROM ($DOWNLOADED_ARTIST_ALBUMS)) AS albumCount,
+$ARTIST_COLUMNS_TAIL
+"""
+
+internal const val PLAYLISTS_FILTER = """
+FROM playlists WHERE sourceId = :sourceId
+AND (:search = ''
+    OR (length(:search) >= $SEARCH_MIN_LENGTH AND rowid IN (SELECT rowid FROM playlist_search
+        WHERE playlist_search MATCH '"' || replace(:search, '"', '""') || '"'))
+    OR (length(:search) < $SEARCH_MIN_LENGTH AND instr(lower(name), lower(:search)) > 0))
+"""
+
+internal const val PLAYLISTS_FILTER_DOWNLOADED = """
+FROM playlists WHERE sourceId = :sourceId
+AND EXISTS (SELECT 1 FROM playlist_songs ps
+    JOIN song_downloads sd ON sd.sourceId = ps.sourceId AND sd.songId = ps.songId
+    WHERE ps.sourceId = playlists.sourceId AND ps.playlistId = playlists.id AND sd.status = 'Completed')
+AND (:search = ''
+    OR (length(:search) >= $SEARCH_MIN_LENGTH AND rowid IN (SELECT rowid FROM playlist_search
+        WHERE playlist_search MATCH '"' || replace(:search, '"', '""') || '"'))
+    OR (length(:search) < $SEARCH_MIN_LENGTH AND instr(lower(name), lower(:search)) > 0))
+"""
+
+// The downloaded list counts the songs that actually have a download so the number under a
+// playlist matches the songs its detail screen lists.
+internal const val PLAYLISTS_COLUMNS_DOWNLOADED = """
+playlists.sourceId, playlists.id, playlists.name, playlists.comment, playlists.coverArt,
+(SELECT COUNT(DISTINCT ps.songId)
+    FROM playlist_songs ps
+    JOIN song_downloads sd ON sd.sourceId = ps.sourceId AND sd.songId = ps.songId AND sd.status = 'Completed'
+    WHERE ps.sourceId = playlists.sourceId AND ps.playlistId = playlists.id
+) AS songCount,
+playlists.created, playlists.changed, playlists.duration, playlists.owner, playlists.shared
+"""
+
+internal fun albumsPageQuery(
     sourceId: Long,
     starredFilter: Int,
     search: String,
     sort: AlbumSort,
     descending: Boolean,
-): RoomRawQuery {
+    downloaded: Boolean,
-    val order = albumOrder(sort, descending)
+    sortNameMode: SortNameMode = SortNameMode.SortName,
-    return RoomRawQuery("SELECT * $ALBUMS_FILTER_BASE ORDER BY $order") { stmt ->
+): RoomRawQuery =
-        stmt.bindAlbumFilters(sourceId, starredFilter, search)
+    rawQuery(
-    }
+        sql = "SELECT * ${if (downloaded) ALBUMS_FILTER_DOWNLOADED else ALBUMS_FILTER} ORDER BY ${albumOrder(
-}
+            sort,
+            descending,
+            sortNameMode,
+        )}",
+        bindings =
+            mapOf(
+                "sourceId" to sourceId,
+                "starredFilter" to starredFilter,
+                "search" to search,
+            ),
+    )
+
+internal fun artistsPageQuery(
+    sourceId: Long,
+    starredFilter: Int,
+    search: String,
+    sort: ArtistSort,
+    descending: Boolean,
+    downloaded: Boolean,
+    sortNameMode: SortNameMode = SortNameMode.SortName,
+): RoomRawQuery =
+    rawQuery(
+        sql =
+            "SELECT ${if (downloaded) ARTIST_COLUMNS_DOWNLOADED else ARTIST_COLUMNS} " +
+                "${if (downloaded) ARTISTS_FILTER_DOWNLOADED else ARTISTS_FILTER} " +
+                "ORDER BY ${artistOrder(sort, descending, sortNameMode)}",
+        bindings =
+            mapOf(
+                "sourceId" to sourceId,
+                "starredFilter" to starredFilter,
+                "search" to search,
+            ),
+    )
+
+internal fun playlistsPageQuery(
+    sourceId: Long,
+    search: String,
+    sort: PlaylistSort,
+    descending: Boolean,
+    downloaded: Boolean,
+): RoomRawQuery =
+    rawQuery(
+        sql =
+            "SELECT ${if (downloaded) PLAYLISTS_COLUMNS_DOWNLOADED else "*"} " +
+                "${if (downloaded) PLAYLISTS_FILTER_DOWNLOADED else PLAYLISTS_FILTER} " +
+                "ORDER BY ${playlistOrder(sort, descending)}",
+        bindings =
+            mapOf(
+                "sourceId" to sourceId,
+                "search" to search,
+            ),
+    )
 
 internal fun rediscoverAlbumsQuery(
     sourceId: Long,
@@ -55,93 +169,126 @@ internal fun rediscoverAlbumsQuery(
     search: String,
     cutoff: Long,
 ): RoomRawQuery =
-    RoomRawQuery(
+    rawQuery(
-        "SELECT * $ALBUMS_FILTER_BASE AND played IS NOT NULL AND played < ? " +
+        sql =
-            "ORDER BY played ASC, sortName COLLATE NOCASE, id",
+            "SELECT * $ALBUMS_FILTER AND played IS NOT NULL AND played < :cutoff " +
-    ) { stmt ->
+                "ORDER BY played ASC, sortName COLLATE NOCASE, id",
-        stmt.bindAlbumFilters(sourceId, starredFilter, search)
+        bindings =
-        stmt.bindLong(13, cutoff)
+            mapOf(
-    }
+                "sourceId" to sourceId,
+                "starredFilter" to starredFilter,
+                "search" to search,
+                "cutoff" to cutoff,
+            ),
+    )
 
-private fun SQLiteStatement.bindAlbumFilters(
+// RoomRawQuery takes a positional bind function, but SQLite gives a repeated named parameter one
-    sourceId: Long,
+// index, so the SQL can keep its names and only the first-appearance order needs binding.
-    starredFilter: Int,
+internal fun rawQuery(
-    search: String,
+    sql: String,
+    bindings: Map<String, Any?>,
+): RoomRawQuery {
+    val values =
+        Regex(":(\\w+)")
+            .findAll(sql)
+            .map { it.groupValues[1] }
+            .distinct()
+            .map(bindings::getValue)
+            .toList()
+    return RoomRawQuery(sql) { statement ->
+        values.forEachIndexed { index, value -> statement.bind(index + 1, value) }
+    }
+}
+
+private fun SQLiteStatement.bind(
+    index: Int,
+    value: Any?,
 ) {
-    bindLong(1, sourceId)
+    when (value) {
-    bindInt(2, starredFilter)
+        null -> bindNull(index)
-    bindInt(3, starredFilter)
+        is Int -> bindLong(index, value.toLong())
-    bindInt(4, starredFilter)
+        is Long -> bindLong(index, value)
-    bindText(5, search)
+        is String -> bindText(index, value)
-    bindText(6, search)
+        else -> error("Unsupported SQL parameter: ${value::class.qualifiedName}")
-    bindText(7, search)
-    bindText(8, search)
-    bindText(9, search)
-    bindText(10, search)
-    bindText(11, search)
-    bindText(12, search)
-}
-
-internal fun artistsDefaultQuery(
-    sourceId: Long,
-    starredFilter: Int,
-    search: String,
-    sort: ArtistSort,
-    descending: Boolean,
-): RoomRawQuery {
-    val order = artistOrder(sort, descending)
-    return RoomRawQuery("SELECT $ARTIST_COLUMNS $ARTISTS_FILTER_BASE ORDER BY $order") { stmt ->
-        stmt.bindLong(1, sourceId)
-        stmt.bindInt(2, starredFilter)
-        stmt.bindInt(3, starredFilter)
-        stmt.bindInt(4, starredFilter)
-        stmt.bindText(5, search)
-        stmt.bindText(6, search)
-        stmt.bindText(7, search)
-        stmt.bindText(8, search)
-        stmt.bindText(9, search)
-        stmt.bindText(10, search)
     }
 }
 
-internal fun playlistsDefaultQuery(
+internal fun albumNameSortKey(mode: SortNameMode): String =
-    sourceId: Long,
+    when (mode) {
-    search: String,
+        SortNameMode.SortName -> "sortName COLLATE NOCASE"
-    sort: PlaylistSort,
+        SortNameMode.Name -> "name COLLATE NOCASE"
-    descending: Boolean,
+        SortNameMode.NonLatin -> "(CASE WHEN name GLOB '*[A-Za-z]*' THEN name ELSE sortName END) COLLATE NOCASE"
-): RoomRawQuery {
+    }
-    val order = playlistOrder(sort, descending)
+
-    return RoomRawQuery("SELECT * $PLAYLISTS_FILTER_BASE ORDER BY $order") { stmt ->
+internal fun albumArtistSortKey(mode: SortNameMode): String =
-        stmt.bindLong(1, sourceId)
+    when (mode) {
-        stmt.bindText(2, search)
+        SortNameMode.SortName -> {
-        stmt.bindText(3, search)
+            "albumArtistSort COLLATE NOCASE"
-        stmt.bindText(4, search)
+        }
-        stmt.bindText(5, search)
+
-        stmt.bindText(6, search)
+        SortNameMode.Name -> {
+            "albumArtist COLLATE NOCASE"
+        }
+
+        SortNameMode.NonLatin -> {
+            "(CASE WHEN albumArtist GLOB '*[A-Za-z]*' THEN albumArtist ELSE albumArtistSort END) COLLATE NOCASE"
+        }
+    }
+
+internal fun artistNameSortKey(mode: SortNameMode): String =
+    when (mode) {
+        SortNameMode.SortName -> "sortName COLLATE NOCASE"
+        SortNameMode.Name -> "name COLLATE NOCASE"
+        SortNameMode.NonLatin -> "(CASE WHEN name GLOB '*[A-Za-z]*' THEN name ELSE sortName END) COLLATE NOCASE"
     }
-}
 
 private fun albumOrder(
     sort: AlbumSort,
     descending: Boolean,
+    mode: SortNameMode,
 ): String =
     when (sort) {
-        AlbumSort.Name -> if (descending) ALBUM_ORDER_BY_NAME_REVERSED else ALBUM_ORDER_BY_NAME
+        AlbumSort.Name -> {
-        AlbumSort.Artist -> if (descending) ALBUM_ORDER_BY_ARTIST_REVERSED else ALBUM_ORDER_BY_ARTIST
+            val name = albumNameSortKey(mode)
-        AlbumSort.Year -> if (descending) ALBUM_ORDER_BY_YEAR_REVERSED else ALBUM_ORDER_BY_YEAR
+            if (descending) "$name DESC, id DESC" else "$name, id"
-        AlbumSort.Added -> if (descending) ALBUM_ORDER_BY_ADDED_REVERSED else ALBUM_ORDER_BY_ADDED
+        }
-        AlbumSort.Starred -> if (descending) ALBUM_ORDER_BY_STARRED_REVERSED else ALBUM_ORDER_BY_STARRED
+
-        AlbumSort.Frequent -> if (descending) ALBUM_ORDER_BY_FREQUENT_REVERSED else ALBUM_ORDER_BY_FREQUENT
+        AlbumSort.Artist -> {
-        AlbumSort.Recent -> if (descending) ALBUM_ORDER_BY_RECENT_REVERSED else ALBUM_ORDER_BY_RECENT
+            val artist = albumArtistSortKey(mode)
+            val name = albumNameSortKey(mode)
+            if (descending) "$artist DESC, year DESC, $name DESC, id DESC" else "$artist, year, $name, id"
+        }
+
+        AlbumSort.Year -> {
+            if (descending) ALBUM_ORDER_BY_YEAR_REVERSED else ALBUM_ORDER_BY_YEAR
+        }
+
+        AlbumSort.Added -> {
+            if (descending) ALBUM_ORDER_BY_ADDED_REVERSED else ALBUM_ORDER_BY_ADDED
+        }
+
+        AlbumSort.Starred -> {
+            if (descending) ALBUM_ORDER_BY_STARRED_REVERSED else ALBUM_ORDER_BY_STARRED
+        }
+
+        AlbumSort.Frequent -> {
+            if (descending) ALBUM_ORDER_BY_FREQUENT_REVERSED else ALBUM_ORDER_BY_FREQUENT
+        }
+
+        AlbumSort.Recent -> {
+            if (descending) ALBUM_ORDER_BY_RECENT_REVERSED else ALBUM_ORDER_BY_RECENT
+        }
     }
 
 private fun artistOrder(
     sort: ArtistSort,
     descending: Boolean,
+    mode: SortNameMode,
 ): String =
     when (sort) {
         ArtistSort.Name -> {
-            if (descending) ARTIST_ORDER_BY_NAME_REVERSED else ARTIST_ORDER_BY_NAME
+            val name = artistNameSortKey(mode)
+            if (descending) "$name DESC, id DESC" else "$name, id"
         }
 
         ArtistSort.AlbumCount -> {

app/src/main/kotlin/com/subtracks/data/db/Migrations.kt

@@ -695,6 +695,80 @@ private suspend fun createSearchIndex(
     connection.execSQL("INSERT INTO `$table`(`$table`) VALUES('rebuild')")
 }
 
+val MIGRATION_35_36 =
+    object : Migration(35, 36) {
+        override suspend fun migrate(connection: SQLiteConnection) {
+            connection.execSQL("ALTER TABLE `artists` ADD COLUMN `artistImageUrl` TEXT")
+            connection.execSQL("ALTER TABLE `artists` ADD COLUMN `coverArts` TEXT NOT NULL DEFAULT ''")
+            connection.execSQL("ALTER TABLE `artists` ADD COLUMN `downloadedCoverArts` TEXT NOT NULL DEFAULT ''")
+            optimizeArtistSearchTriggers(connection)
+            backfillArtistArt(connection)
+        }
+    }
+
+val MIGRATION_36_37 =
+    object : Migration(36, 37) {
+        override suspend fun migrate(connection: SQLiteConnection) {
+            connection.execSQL(
+                "CREATE INDEX IF NOT EXISTS `index_albums_name_plain` ON `albums` (`sourceId`, `name`, `id`)",
+            )
+            connection.execSQL(
+                "CREATE INDEX IF NOT EXISTS `index_albums_artist_plain` " +
+                    "ON `albums` (`sourceId`, `albumArtist`, `year`, `name`, `id`)",
+            )
+            connection.execSQL(
+                "CREATE INDEX IF NOT EXISTS `index_artists_name_plain` ON `artists` (`sourceId`, `name`, `id`)",
+            )
+        }
+    }
+
+val MIGRATION_37_38 =
+    object : Migration(37, 38) {
+        override suspend fun migrate(connection: SQLiteConnection) {
+            connection.execSQL("ALTER TABLE `playlists` ADD COLUMN `owner` TEXT")
+            connection.execSQL("ALTER TABLE `playlists` ADD COLUMN `shared` INTEGER NOT NULL DEFAULT 0")
+        }
+    }
+
+internal fun artistSearchTriggersOptimized(connection: SQLiteConnection): Boolean {
+    val triggers = mutableListOf<String>()
+    connection.prepare("SELECT sql FROM sqlite_master WHERE type = 'trigger' AND name IN (?, ?)").use { statement ->
+        statement.bindText(1, "room_fts_content_sync_artist_search_BEFORE_UPDATE")
+        statement.bindText(2, "room_fts_content_sync_artist_search_AFTER_UPDATE")
+        while (statement.step()) triggers += statement.getText(0)
+    }
+    return triggers.size == 2 && triggers.all { it.contains("UPDATE OF `name`, `sortName`") }
+}
+
+internal fun optimizeArtistSearchTriggers(connection: SQLiteConnection) {
+    connection.execSQL("DROP TRIGGER IF EXISTS room_fts_content_sync_artist_search_BEFORE_UPDATE")
+    connection.execSQL("DROP TRIGGER IF EXISTS room_fts_content_sync_artist_search_AFTER_UPDATE")
+    connection.execSQL(
+        "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_artist_search_BEFORE_UPDATE " +
+            "BEFORE UPDATE OF `name`, `sortName` ON `artists` BEGIN " +
+            "DELETE FROM `artist_search` WHERE `rowid`=OLD.`rowid`; END",
+    )
+    connection.execSQL(
+        "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_artist_search_AFTER_UPDATE " +
+            "AFTER UPDATE OF `name`, `sortName` ON `artists` BEGIN " +
+            "INSERT INTO `artist_search`(`rowid`, `name`, `sortName`) " +
+            "VALUES (NEW.`rowid`, NEW.`name`, NEW.`sortName`); END",
+    )
+}
+
+private suspend fun backfillArtistArt(connection: SQLiteConnection) {
+    val sourceIds = mutableListOf<Long>()
+    connection.prepare("SELECT id FROM sources").use { statement ->
+        while (statement.step()) sourceIds += statement.getLong(0)
+    }
+    sourceIds.forEach { sourceId ->
+        connection.prepare(ARTIST_ART_UPDATE_SQL).use { statement ->
+            statement.bindLong(1, sourceId)
+            statement.step()
+        }
+    }
+}
+
 val MIGRATIONS: Array<Migration> =
     arrayOf(
         MIGRATION_1_2,
@@ -731,4 +805,7 @@ val MIGRATIONS: Array<Migration> =
         MIGRATION_32_33,
         MIGRATION_33_34,
         MIGRATION_34_35,
+        MIGRATION_35_36,
+        MIGRATION_36_37,
+        MIGRATION_37_38,
     )

app/src/main/kotlin/com/subtracks/data/db/QueueDao.kt

@@ -214,14 +214,34 @@ interface QueueDao {
     ): List<String>
 
     @Query(
-        "SELECT songs.*, albums.coverArt AS coverArt FROM songs " +
+        "SELECT CASE WHEN EXISTS (SELECT 1 FROM songs WHERE sourceId = :sourceId AND albumId = :albumId AND id = :songId) " +
-            "LEFT JOIN albums ON albums.sourceId = songs.sourceId AND albums.id = songs.albumId " +
+            "THEN (SELECT COUNT(*) FROM songs ranked CROSS JOIN songs target " +
-            "WHERE songs.sourceId = :sourceId AND songs.id IN (:ids)",
+            "WHERE ranked.sourceId = :sourceId AND ranked.albumId = :albumId " +
+            "AND target.sourceId = :sourceId AND target.albumId = :albumId AND target.id = :songId " +
+            "AND ((ranked.disc IS NULL AND target.disc IS NOT NULL) OR ranked.disc < target.disc OR " +
+            "(ranked.disc IS target.disc AND ((ranked.track IS NULL AND target.track IS NOT NULL) OR ranked.track < target.track OR " +
+            "(ranked.track IS target.track AND ranked.id < target.id))))) END",
     )
-    suspend fun songsByIds(
+    suspend fun albumRank(
         sourceId: Long,
-        ids: List<String>,
+        albumId: String,
-    ): List<AlbumSongItem>
+        songId: String,
+    ): Long?
+
+    @Query(
+        "SELECT CASE WHEN firstPosition IS NULL THEN NULL ELSE " +
+            "(SELECT COUNT(*) - 1 FROM playlist_songs " +
+            "JOIN songs ON songs.sourceId = playlist_songs.sourceId AND songs.id = playlist_songs.songId " +
+            "WHERE playlist_songs.sourceId = :sourceId AND playlist_songs.playlistId = :playlistId AND position <= firstPosition) END " +
+            "FROM (SELECT MIN(position) AS firstPosition FROM playlist_songs " +
+            "JOIN songs ON songs.sourceId = playlist_songs.sourceId AND songs.id = playlist_songs.songId " +
+            "WHERE playlist_songs.sourceId = :sourceId AND playlist_songs.playlistId = :playlistId AND songId = :songId)",
+    )
+    suspend fun playlistRank(
+        sourceId: Long,
+        playlistId: String,
+        songId: String,
+    ): Long?
 
     @Query("SELECT COUNT(*) FROM song_genres WHERE sourceId = :sourceId AND genre = :genre")
     suspend fun genreLength(
@@ -243,17 +263,6 @@ interface QueueDao {
         limit: Int,
     ): List<AlbumSongItem>
 
-    @Query(
-        "SELECT songs.id FROM song_genres " +
-            "JOIN songs ON songs.sourceId = song_genres.sourceId AND songs.id = song_genres.songId " +
-            "WHERE song_genres.sourceId = :sourceId AND song_genres.genre = :genre " +
-            "ORDER BY songs.sortName COLLATE NOCASE, songs.id",
-    )
-    suspend fun genreSongIds(
-        sourceId: Long,
-        genre: String,
-    ): List<String>
-
     @Query("SELECT COUNT(*) FROM song_downloads WHERE sourceId = :sourceId AND status = 'Completed'")
     suspend fun downloadedLength(sourceId: Long): Long
 
@@ -272,12 +281,6 @@ interface QueueDao {
         limit: Int,
     ): List<AlbumSongItem>
 
-    @Query(
-        "SELECT songs.id FROM songs WHERE sourceId = :sourceId AND starred IS NOT NULL " +
-            "ORDER BY starred DESC, sortName COLLATE NOCASE, id",
-    )
-    suspend fun starredSongIds(sourceId: Long): List<String>
-
     @Query(
         "SELECT songs.*, albums.coverArt AS coverArt FROM song_downloads d " +
             "JOIN songs ON songs.sourceId = d.sourceId AND songs.id = d.songId " +
@@ -290,12 +293,4 @@ interface QueueDao {
         offset: Long,
         limit: Int,
     ): List<AlbumSongItem>
-
-    @Query(
-        "SELECT songs.id FROM song_downloads d " +
-            "JOIN songs ON songs.sourceId = d.sourceId AND songs.id = d.songId " +
-            "WHERE d.sourceId = :sourceId AND d.status = 'Completed' " +
-            "ORDER BY d.downloadedAt DESC, songs.sortName COLLATE NOCASE, songs.id",
-    )
-    suspend fun downloadedSongIds(sourceId: Long): List<String>
 }

app/src/main/kotlin/com/subtracks/data/db/SubtracksDatabase.kt

@@ -28,6 +28,7 @@ import com.subtracks.data.model.SongDownload
 import com.subtracks.data.model.SongGenre
 import com.subtracks.data.model.SongSearch
 import com.subtracks.data.model.Source
+import com.subtracks.data.model.StringListConverter
 import com.subtracks.data.model.SubsonicSource
 import com.subtracks.data.model.UpNextEntry
 
@@ -56,7 +57,7 @@ import com.subtracks.data.model.UpNextEntry
         SongDownload::class,
         PendingAction::class,
     ],
-    version = 35,
+    version = 38,
     exportSchema = true,
 )
 @ColumnTypeConverters(
@@ -65,6 +66,7 @@ import com.subtracks.data.model.UpNextEntry
     DownloadErrorConverter::class,
     PendingActionKindConverter::class,
     ArtistRefsConverter::class,
+    StringListConverter::class,
 )
 abstract class SubtracksDatabase : RoomDatabase() {
     abstract fun libraryDao(): LibraryDao

app/src/main/kotlin/com/subtracks/data/model/CoverArtRef.kt

@@ -10,3 +10,8 @@ fun coverArtKey(
     coverArt: String,
     thumbnail: Boolean,
 ): String = "$sourceId:$coverArt:$thumbnail"
+
+fun artistImageKey(
+    sourceId: Long,
+    artistId: String,
+): String = "$sourceId:artist-image:$artistId"

app/src/main/kotlin/com/subtracks/data/model/Download.kt

@@ -58,9 +58,14 @@ data class SongDownload(
     @ColumnInfo(defaultValue = "0") val downloadedAt: Long = 0,
 ) {
     val progress: Float?
-        get() = total.takeIf { it > 0 }?.let { (bytes.toFloat() / it).coerceIn(0f, 1f) }
+        get() = fractionOf(bytes, total)
 }
 
+internal fun fractionOf(
+    bytes: Long,
+    total: Long,
+): Float? = total.takeIf { it > 0 }?.let { (bytes.toFloat() / it).coerceIn(0f, 1f) }
+
 enum class DownloadList { Album, Playlist, Artist }
 
 enum class BulkDownloadAction { Download, Cancel, Delete }
@@ -99,17 +104,19 @@ data class DownloadedSong(
     val songSort: String = title,
 ) {
     val progress: Float?
-        get() = total.takeIf { it > 0 }?.let { (bytes.toFloat() / it).coerceIn(0f, 1f) }
+        get() = fractionOf(bytes, total)
 }
 
 data class DownloadArtwork(
     val sourceId: Long,
     val albumId: String?,
     val artistId: String?,
+    val albumArtistId: String?,
     val albumRow: String?,
     val artistRow: String?,
     val albumCoverArt: String?,
     val artistCoverArt: String?,
+    val albumArtistCoverArt: String?,
 ) {
     val hasMissingLibraryRow: Boolean
         get() = (albumId != null && albumRow == null) || (artistId != null && artistRow == null)

app/src/main/kotlin/com/subtracks/data/model/Models.kt

@@ -59,6 +59,7 @@ data class ArtistRef(
     indices = [
         Index("sourceId"),
         Index(name = "index_artists_name", value = ["sourceId", "sortName", "id"]),
+        Index(name = "index_artists_name_plain", value = ["sourceId", "name", "id"]),
         Index(
             name = "index_artists_albumCount",
             value = ["sourceId", "albumCount", "sortName", "id"],
@@ -88,6 +89,9 @@ data class Artist(
     val albumCount: Long,
     val starred: Long?,
     val coverArt: String? = null,
+    val artistImageUrl: String? = null,
+    @ColumnInfo(defaultValue = "''") val coverArts: List<String> = emptyList(),
+    @ColumnInfo(defaultValue = "''") val downloadedCoverArts: List<String> = emptyList(),
     @ColumnInfo(defaultValue = "0") val playCount: Long = 0,
     val played: Long? = null,
     @ColumnInfo(defaultValue = "0") val songCount: Long = 0,
@@ -128,7 +132,9 @@ data class ArtistBio(
         Index("sourceId"),
         Index("sourceId", "artistId"),
         Index(name = "index_albums_name", value = ["sourceId", "sortName", "id"]),
+        Index(name = "index_albums_name_plain", value = ["sourceId", "name", "id"]),
         Index(name = "index_albums_artist", value = ["sourceId", "albumArtistSort", "year", "sortName", "id"]),
+        Index(name = "index_albums_artist_plain", value = ["sourceId", "albumArtist", "year", "name", "id"]),
         Index(
             name = "index_albums_year",
             value = ["sourceId", "year", "sortName", "id"],
@@ -248,6 +254,8 @@ data class Playlist(
     val created: Long,
     @ColumnInfo(defaultValue = "0") val changed: Long = 0,
     @ColumnInfo(defaultValue = "0") val duration: Long = 0,
+    val owner: String? = null,
+    @ColumnInfo(defaultValue = "0") val shared: Boolean = false,
 )
 
 @Entity(
@@ -592,6 +600,16 @@ class ArtistRefsConverter {
     fun toArtistRefs(value: String): List<ArtistRef> = ArtistRefsCodec.decode(value)
 }
 
+class StringListConverter {
+    @ColumnTypeConverter
+    fun fromList(values: List<String>): String = values.joinToString(LIST_SEPARATOR)
+
+    @ColumnTypeConverter
+    fun toList(value: String): List<String> = if (value.isEmpty()) emptyList() else value.split(LIST_SEPARATOR)
+}
+
+private const val LIST_SEPARATOR = "\u001F"
+
 object ArtistRefsCodec {
     fun encode(refs: List<ArtistRef>): String =
         buildString {

app/src/main/kotlin/com/subtracks/data/prefs/UserPreferences.kt

@@ -16,6 +16,8 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.map
 
+enum class SortNameMode { SortName, Name, NonLatin }
+
 enum class AlbumSort { Name, Artist, Year, Added, Starred, Frequent, Recent }
 
 enum class ArtistSort { Name, AlbumCount, Starred, Frequent, Recent }
@@ -57,6 +59,8 @@ const val MAX_REPLAY_GAIN_PREAMP_DB = 15f
 
 enum class SyncMode { Off, WifiOnly, Always }
 
+enum class SongTapBehavior { InOrder, KeepShuffle, Shuffle }
+
 enum class ReplayGainMode { Off, Track, Album, Auto }
 
 data class ArtworkSeedValue(
@@ -127,6 +131,19 @@ class UserPreferences(
 
     private val syncModeKey = stringPreferencesKey("sync_mode")
 
+    fun songTapBehavior(): Flow<SongTapBehavior> =
+        store.data.map { prefs ->
+            prefs[songTapBehaviorKey]?.let { stored ->
+                SongTapBehavior.entries.firstOrNull { it.name == stored }
+            } ?: SongTapBehavior.InOrder
+        }
+
+    suspend fun setSongTapBehavior(behavior: SongTapBehavior) {
+        store.edit { prefs -> prefs[songTapBehaviorKey] = behavior.name }
+    }
+
+    private val songTapBehaviorKey = stringPreferencesKey("song_tap_behavior")
+
     fun lastSyncAt(): Flow<Long> = store.data.map { prefs -> prefs[lastSyncAtKey] ?: 0L }
 
     suspend fun setLastSyncAt(value: Long) {
@@ -182,6 +199,17 @@ class UserPreferences(
 
     private val keepScreenOnKey = booleanPreferencesKey("keep_screen_on")
 
+    fun sortNameMode(): Flow<SortNameMode> =
+        store.data.map { prefs ->
+            prefs[sortNameModeKey]?.let { stored -> SortNameMode.entries.firstOrNull { it.name == stored } } ?: SortNameMode.Name
+        }
+
+    suspend fun setSortNameMode(mode: SortNameMode) {
+        store.edit { prefs -> prefs[sortNameModeKey] = mode.name }
+    }
+
+    private val sortNameModeKey = stringPreferencesKey("sort_name_mode")
+
     fun offlineMode(): Flow<Boolean> = store.data.map { prefs -> prefs[offlineModeKey] ?: false }
 
     suspend fun setOfflineMode(enabled: Boolean) {

app/src/main/kotlin/com/subtracks/data/repo/DownloadRepository.kt

@@ -11,6 +11,7 @@ import com.subtracks.data.download.EngineDownload
 import com.subtracks.data.download.EngineRequest
 import com.subtracks.data.download.EngineStatus
 import com.subtracks.data.download.looksLikeAudio
+import com.subtracks.data.model.Artist
 import com.subtracks.data.model.ArtistBio
 import com.subtracks.data.model.BulkDownloadAction
 import com.subtracks.data.model.DownloadError
@@ -19,6 +20,7 @@ import com.subtracks.data.model.DownloadStatus
 import com.subtracks.data.model.DownloadedSong
 import com.subtracks.data.model.ListDownloadStatus
 import com.subtracks.data.model.SongDownload
+import com.subtracks.data.model.artistImageKey
 import com.subtracks.data.model.coverArtKey
 import com.subtracks.log.Log
 import kotlinx.coroutines.CancellationException
@@ -66,6 +68,7 @@ class DownloadRepository(
 
     private val statesFlow = MutableStateFlow<Map<String, SongDownload>>(emptyMap())
     private val attemptedBios = ConcurrentHashMap.newKeySet<Pair<Long, String>>()
+    private val failedArtistImages = ConcurrentHashMap.newKeySet<String>()
 
     fun start() {
         if (started) return
@@ -350,6 +353,9 @@ class DownloadRepository(
         rows.groupBy { it.sourceId }.forEach { (sourceId, group) ->
             group.forEach { file(sourceId, it.songId).delete() }
             group.map { it.songId }.chunked(DELETE_CHUNK).forEach { db.downloadDao().deleteSongs(sourceId, it) }
+            if (group.any { it.status == DownloadStatus.Completed }) {
+                refreshDownloadedArtistArt(sourceId, group.map { it.songId })
+            }
         }
         sweep(db.downloadDao().all())
     }
@@ -372,6 +378,7 @@ class DownloadRepository(
                     .mapNotNull { it.engineId }
                     .let(engine::cancel)
                 db.downloadDao().deleteSource(sourceId)
+                db.libraryDao().clearDownloadedArtistArt(sourceId)
                 dir(sourceId).deleteRecursively()
             }
         }
@@ -413,13 +420,14 @@ class DownloadRepository(
     ) {
         val song = db.libraryDao().songOnce(sourceId, songId)
         val album = song?.albumId?.let { db.libraryDao().albumOnce(sourceId, it) }
+        val songArtist = song?.artistId?.let { db.libraryDao().artistOnce(sourceId, it) }
+        val albumArtist = album?.artistId?.let { db.libraryDao().artistOnce(sourceId, it) }
         listOfNotNull(song?.artistId, album?.artistId).forEach(artistIds::add)
+        listOfNotNull(songArtist, albumArtist).forEach { storeArtistImage(sourceId, it) }
         val coverArt =
             (
-                listOfNotNull(
+                listOfNotNull(album?.coverArt) +
-                    album?.coverArt,
+                    db.downloadDao().playlistCoversForSong(sourceId, songId)
-                    song?.artistId?.let { db.libraryDao().artistOnce(sourceId, it)?.coverArt },
-                ) + db.downloadDao().playlistCoversForSong(sourceId, songId)
             ).distinct()
         coverArt.forEach { cover ->
             storeArtwork(sourceId, cover, thumbnail = false)
@@ -427,6 +435,37 @@ class DownloadRepository(
         }
     }
 
+    private suspend fun storeArtistImage(
+        sourceId: Long,
+        artist: Artist,
+    ) {
+        val imageUrl = artist.artistImageUrl
+        if (!imageUrl.isNullOrBlank()) {
+            val cacheKey = artistImageKey(sourceId, artist.id)
+            if (artworkStore.file(sourceId, cacheKey).exists()) return
+            val attemptKey = "$sourceId:${artist.id}:$imageUrl"
+            if (attemptKey !in failedArtistImages) {
+                val bytes =
+                    try {
+                        artworkFetcher.fetch(imageUrl)
+                    } catch (e: CancellationException) {
+                        throw e
+                    } catch (_: Exception) {
+                        null
+                    }
+                if (bytes != null && bytes.isNotEmpty()) {
+                    artworkStore.write(sourceId, cacheKey, bytes)
+                    return
+                }
+                failedArtistImages += attemptKey
+            }
+        }
+        artist.coverArt?.let {
+            storeArtwork(sourceId, it, thumbnail = false)
+            storeArtwork(sourceId, it, thumbnail = true)
+        }
+    }
+
     private suspend fun fetchArtistBio(
         sourceId: Long,
         artistId: String,
@@ -491,11 +530,15 @@ class DownloadRepository(
             .mapValues { (sourceId, rows) ->
                 if (rows.any { it.hasMissingLibraryRow }) return@mapValues null
                 val covers =
-                    rows.flatMap { row -> listOfNotNull(row.albumCoverArt, row.artistCoverArt) } +
+                    rows.flatMap { row ->
-                        playlistCovers[sourceId].orEmpty()
+                        listOfNotNull(row.albumCoverArt, row.artistCoverArt, row.albumArtistCoverArt)
-                covers
+                    } + playlistCovers[sourceId].orEmpty()
-                    .flatMap { cover -> listOf(false, true).map { thumbnail -> coverArtKey(sourceId, cover, thumbnail) } }
+                val artistImages = rows.flatMap { row -> listOfNotNull(row.artistId, row.albumArtistId) }
-                    .toSet()
+                (
+                    covers.flatMap { cover ->
+                        listOf(false, true).map { thumbnail -> coverArtKey(sourceId, cover, thumbnail) }
+                    } + artistImages.map { artistImageKey(sourceId, it) }
+                ).toSet()
             }
     }
 
@@ -545,6 +588,7 @@ class DownloadRepository(
         row.engineId?.let { engine.cancel(listOf(it)) }
         file(sourceId, songId).delete()
         db.downloadDao().delete(sourceId, songId)
+        if (row.status == DownloadStatus.Completed) refreshDownloadedArtistArt(sourceId, listOf(songId))
         return true
     }
 
@@ -625,6 +669,11 @@ class DownloadRepository(
                     },
             )
         if (updated != row) db.downloadDao().upsert(updated)
+        if (updated.status != row.status &&
+            (updated.status == DownloadStatus.Completed || row.status == DownloadStatus.Completed)
+        ) {
+            refreshDownloadedArtistArt(row.sourceId, listOf(row.songId))
+        }
         if (updated.status != row.status) {
             when (updated.status) {
                 DownloadStatus.Completed -> Log.i("download", "completed ${row.songId} (${updated.total} bytes)")
@@ -642,9 +691,22 @@ class DownloadRepository(
         row.engineId?.let { engine.cancel(listOf(it)) }
         file(row.sourceId, row.songId).delete()
         db.downloadDao().upsert(row.copy(status = DownloadStatus.Failed, engineId = null, error = error))
+        if (row.status == DownloadStatus.Completed) {
+            refreshDownloadedArtistArt(row.sourceId, listOf(row.songId))
+        }
         Log.w("download", "failed ${row.songId}: $error")
     }
 
+    private suspend fun refreshDownloadedArtistArt(
+        sourceId: Long,
+        songIds: Collection<String>,
+    ) {
+        songIds.chunked(500).forEach { songs ->
+            val artistIds = db.libraryDao().creditedArtistIdsForSongs(sourceId, songs).distinct()
+            artistIds.chunked(500).forEach { db.libraryDao().recomputeDownloadedArtistArt(sourceId, it) }
+        }
+    }
+
     private fun ensurePolling() {
         if (pollJob?.isActive == true) return
         pollJob =

app/src/main/kotlin/com/subtracks/data/repo/LibraryRepository.kt

@@ -7,9 +7,9 @@ import androidx.paging.PagingSource
 import com.subtracks.R
 import com.subtracks.UiMessage
 import com.subtracks.data.db.SubtracksDatabase
-import com.subtracks.data.db.albumsDefaultQuery
+import com.subtracks.data.db.albumsPageQuery
-import com.subtracks.data.db.artistsDefaultQuery
+import com.subtracks.data.db.artistsPageQuery
-import com.subtracks.data.db.playlistsDefaultQuery
+import com.subtracks.data.db.playlistsPageQuery
 import com.subtracks.data.db.rediscoverAlbumsQuery
 import com.subtracks.data.model.Album
 import com.subtracks.data.model.AlbumSongItem
@@ -24,27 +24,32 @@ import com.subtracks.data.prefs.AlbumSort
 import com.subtracks.data.prefs.ArtistSort
 import com.subtracks.data.prefs.PlaylistSort
 import com.subtracks.data.prefs.StarredFilter
+import com.subtracks.data.prefs.UserPreferences
 import com.subtracks.data.source.ServerActionSink
 import com.subtracks.data.source.StarType
 import com.subtracks.log.Log
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.NonCancellable
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
 
+@OptIn(ExperimentalCoroutinesApi::class)
 class LibraryRepository(
     private val db: SubtracksDatabase,
     private val sourceRepository: SourceRepository,
     private val serverActions: ServerActionSink,
+    private val userPreferences: UserPreferences,
     private val showMessage: (UiMessage) -> Unit = {},
     private val scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.IO),
 ) {
@@ -111,12 +116,18 @@ class LibraryRepository(
     fun searchAlbums(
         sourceId: Long,
         query: String,
-    ): Flow<List<Album>> = db.libraryDao().searchAlbums(sourceId, query, SEARCH_RESULT_LIMIT)
+    ): Flow<List<Album>> =
+        userPreferences.sortNameMode().flatMapLatest { mode ->
+            db.libraryDao().searchAlbums(sourceId, query, SEARCH_RESULT_LIMIT, mode.name)
+        }
 
     fun searchArtists(
         sourceId: Long,
         query: String,
-    ): Flow<List<Artist>> = db.libraryDao().searchArtists(sourceId, query, SEARCH_RESULT_LIMIT)
+    ): Flow<List<Artist>> =
+        userPreferences.sortNameMode().flatMapLatest { mode ->
+            db.libraryDao().searchArtists(sourceId, query, SEARCH_RESULT_LIMIT, mode.name)
+        }
 
     fun searchPlaylists(
         sourceId: Long,
@@ -126,7 +137,10 @@ class LibraryRepository(
     fun searchSongs(
         sourceId: Long,
         query: String,
-    ): Flow<List<AlbumSongItem>> = db.libraryDao().searchSongs(sourceId, query, SEARCH_RESULT_LIMIT)
+    ): Flow<List<AlbumSongItem>> =
+        userPreferences.sortNameMode().flatMapLatest { mode ->
+            db.libraryDao().searchSongs(sourceId, query, SEARCH_RESULT_LIMIT, mode.name)
+        }
 
     fun downloadedAlbumsPage(sourceId: Long): Flow<PagingData<Album>> = pager(40) { db.libraryDao().downloadedAlbums(sourceId) }
 
@@ -178,69 +192,20 @@ class LibraryRepository(
         search: String,
         downloaded: Boolean,
     ): Flow<PagingData<Album>> =
-        pager(40, enablePlaceholders = true) {
+        userPreferences.sortNameMode().flatMapLatest { mode ->
-            val dao = db.libraryDao()
+            pager(40, enablePlaceholders = true) {
-            if (!downloaded) {
+                val dao = db.libraryDao()
-                dao.albumsPaging(albumsDefaultQuery(sourceId, starred.ordinal, search, sort, descending))
+                val query =
-            } else {
+                    albumsPageQuery(
-                val downloadedFilter = 1
+                        sourceId = sourceId,
-                when (sort) {
+                        starredFilter = starred.ordinal,
-                    AlbumSort.Name -> {
+                        search = search,
-                        if (descending) {
+                        sort = sort,
-                            dao.albumsByNameReversed(sourceId, starred.ordinal, search, downloadedFilter)
+                        descending = descending,
-                        } else {
+                        downloaded = downloaded,
-                            dao.albumsByName(sourceId, starred.ordinal, search, downloadedFilter)
+                        sortNameMode = mode,
-                        }
+                    )
-                    }
+                if (downloaded) dao.downloadedAlbumsPaging(query) else dao.albumsPaging(query)
-
-                    AlbumSort.Artist -> {
-                        if (descending) {
-                            dao.albumsByArtistReversed(sourceId, starred.ordinal, search, downloadedFilter)
-                        } else {
-                            dao.albumsByArtist(sourceId, starred.ordinal, search, downloadedFilter)
-                        }
-                    }
-
-                    AlbumSort.Year -> {
-                        if (descending) {
-                            dao.albumsByYearReversed(sourceId, starred.ordinal, search, downloadedFilter)
-                        } else {
-                            dao.albumsByYear(sourceId, starred.ordinal, search, downloadedFilter)
-                        }
-                    }
-
-                    AlbumSort.Added -> {
-                        if (descending) {
-                            dao.albumsByRecentlyAddedReversed(sourceId, starred.ordinal, search, downloadedFilter)
-                        } else {
-                            dao.albumsByRecentlyAdded(sourceId, starred.ordinal, search, downloadedFilter)
-                        }
-                    }
-
-                    AlbumSort.Starred -> {
-                        if (descending) {
-                            dao.albumsByStarredReversed(sourceId, starred.ordinal, search, downloadedFilter)
-                        } else {
-                            dao.albumsByStarred(sourceId, starred.ordinal, search, downloadedFilter)
-                        }
-                    }
-
-                    AlbumSort.Frequent -> {
-                        if (descending) {
-                            dao.albumsByFrequentReversed(sourceId, starred.ordinal, search, downloadedFilter)
-                        } else {
-                            dao.albumsByFrequent(sourceId, starred.ordinal, search, downloadedFilter)
-                        }
-                    }
-
-                    AlbumSort.Recent -> {
-                        if (descending) {
-                            dao.albumsByRecentReversed(sourceId, starred.ordinal, search, downloadedFilter)
-                        } else {
-                            dao.albumsByRecent(sourceId, starred.ordinal, search, downloadedFilter)
-                        }
-                    }
-                }
             }
         }
 
@@ -252,53 +217,20 @@ class LibraryRepository(
         search: String,
         downloaded: Boolean,
     ): Flow<PagingData<Artist>> =
-        pager(60) {
+        userPreferences.sortNameMode().flatMapLatest { mode ->
-            val dao = db.libraryDao()
+            pager(60) {
-            if (!downloaded) {
+                val dao = db.libraryDao()
-                dao.artistsPaging(artistsDefaultQuery(sourceId, starred.ordinal, search, sort, descending))
+                val query =
-            } else {
+                    artistsPageQuery(
-                val downloadedFilter = 1
+                        sourceId = sourceId,
-                when (sort) {
+                        starredFilter = starred.ordinal,
-                    ArtistSort.Name -> {
+                        search = search,
-                        if (descending) {
+                        sort = sort,
-                            dao.artistsByNameReversed(sourceId, starred.ordinal, search, downloadedFilter)
+                        descending = descending,
-                        } else {
+                        downloaded = downloaded,
-                            dao.artistsByName(sourceId, starred.ordinal, search, downloadedFilter)
+                        sortNameMode = mode,
-                        }
+                    )
-                    }
+                if (downloaded) dao.downloadedArtistsPaging(query) else dao.artistsPaging(query)
-
-                    ArtistSort.AlbumCount -> {
-                        if (descending) {
-                            dao.artistsByAlbumCountReversed(sourceId, starred.ordinal, search, downloadedFilter)
-                        } else {
-                            dao.artistsByAlbumCount(sourceId, starred.ordinal, search, downloadedFilter)
-                        }
-                    }
-
-                    ArtistSort.Starred -> {
-                        if (descending) {
-                            dao.artistsByStarredReversed(sourceId, starred.ordinal, search, downloadedFilter)
-                        } else {
-                            dao.artistsByStarred(sourceId, starred.ordinal, search, downloadedFilter)
-                        }
-                    }
-
-                    ArtistSort.Frequent -> {
-                        if (descending) {
-                            dao.artistsByFrequentReversed(sourceId, starred.ordinal, search, downloadedFilter)
-                        } else {
-                            dao.artistsByFrequent(sourceId, starred.ordinal, search, downloadedFilter)
-                        }
-                    }
-
-                    ArtistSort.Recent -> {
-                        if (descending) {
-                            dao.artistsByRecentReversed(sourceId, starred.ordinal, search, downloadedFilter)
-                        } else {
-                            dao.artistsByRecent(sourceId, starred.ordinal, search, downloadedFilter)
-                        }
-                    }
-                }
             }
         }
 
@@ -311,36 +243,15 @@ class LibraryRepository(
     ): Flow<PagingData<Playlist>> =
         pager(40) {
             val dao = db.libraryDao()
-            if (!downloaded) {
+            val query =
-                dao.playlistsPaging(playlistsDefaultQuery(sourceId, search, sort, descending))
+                playlistsPageQuery(
-            } else {
+                    sourceId = sourceId,
-                val downloadedFilter = 1
+                    search = search,
-                when (sort) {
+                    sort = sort,
-                    PlaylistSort.Name -> {
+                    descending = descending,
-                        if (descending) {
+                    downloaded = downloaded,
-                            dao.playlistsByNameReversed(sourceId, search, downloadedFilter)
+                )
-                        } else {
+            if (downloaded) dao.downloadedPlaylistsPaging(query) else dao.playlistsPaging(query)
-                            dao.playlistsByName(sourceId, search, downloadedFilter)
-                        }
-                    }
-
-                    PlaylistSort.Added -> {
-                        if (descending) {
-                            dao.playlistsByAddedReversed(sourceId, search, downloadedFilter)
-                        } else {
-                            dao.playlistsByAdded(sourceId, search, downloadedFilter)
-                        }
-                    }
-
-                    PlaylistSort.Updated -> {
-                        if (descending) {
-                            dao.playlistsByUpdatedReversed(sourceId, search, downloadedFilter)
-                        } else {
-                            dao.playlistsByUpdated(sourceId, search, downloadedFilter)
-                        }
-                    }
-                }
-            }
         }
 
     fun album(
@@ -424,6 +335,11 @@ class LibraryRepository(
         }
     }
 
+    fun artistCoverArts(
+        sourceId: Long,
+        artistId: String,
+    ): Flow<List<String>> = db.libraryDao().artistCoverArts(sourceId, artistId)
+
     fun albumDiscs(
         sourceId: Long,
         albumId: String,
@@ -444,10 +360,7 @@ class LibraryRepository(
         sourceId: Long,
         albumId: String,
         songId: String,
-    ): Long {
+    ): Long = db.queueDao().albumRank(sourceId, albumId, songId) ?: 0L
-        val index = db.queueDao().albumSongIds(sourceId, albumId).indexOf(songId)
-        return if (index < 0) 0L else index.toLong()
-    }
 
     fun playlist(
         sourceId: Long,

app/src/main/kotlin/com/subtracks/data/repo/QueueRepository.kt

@@ -209,6 +209,202 @@ data class Reanchored(
     val changed: Boolean,
 )
 
+private interface QueueKindResolver {
+    fun supportsKeyset(key: OrderKey): Boolean = false
+
+    suspend fun length(
+        dao: com.subtracks.data.db.QueueDao,
+        entry: QueueEntry,
+    ): Long
+
+    suspend fun rows(
+        dao: com.subtracks.data.db.QueueDao,
+        entry: QueueEntry,
+        offset: Long,
+        limit: Int,
+    ): List<SongItem>
+
+    suspend fun rowsFrom(
+        dao: com.subtracks.data.db.QueueDao,
+        entry: QueueEntry,
+        key: OrderKey,
+        skip: Long,
+        limit: Int,
+    ): List<SongItem>? = null
+
+    suspend fun rowsBefore(
+        dao: com.subtracks.data.db.QueueDao,
+        entry: QueueEntry,
+        key: OrderKey,
+        skip: Long,
+        limit: Int,
+    ): List<SongItem>? = null
+
+    suspend fun rank(
+        dao: com.subtracks.data.db.QueueDao,
+        entry: QueueEntry,
+        songId: String,
+    ): Long? = null
+}
+
+private val queueKindResolvers =
+    mapOf<QueueKind, QueueKindResolver>(
+        QueueKind.Song to
+            object : QueueKindResolver {
+                override suspend fun length(
+                    dao: com.subtracks.data.db.QueueDao,
+                    entry: QueueEntry,
+                ) = dao.songLength(entry.sourceId, entry.refId)
+
+                override suspend fun rows(
+                    dao: com.subtracks.data.db.QueueDao,
+                    entry: QueueEntry,
+                    offset: Long,
+                    limit: Int,
+                ) = dao.song(entry.sourceId, entry.refId, offset, limit)
+
+                override suspend fun rank(
+                    dao: com.subtracks.data.db.QueueDao,
+                    entry: QueueEntry,
+                    songId: String,
+                ) = if (entry.refId == songId && length(dao, entry) > 0) 0L else null
+            },
+        QueueKind.Playlist to
+            object : QueueKindResolver {
+                override fun supportsKeyset(key: OrderKey) = key.position != null
+
+                override suspend fun length(
+                    dao: com.subtracks.data.db.QueueDao,
+                    entry: QueueEntry,
+                ) = dao.playlistLength(entry.sourceId, entry.refId)
+
+                override suspend fun rows(
+                    dao: com.subtracks.data.db.QueueDao,
+                    entry: QueueEntry,
+                    offset: Long,
+                    limit: Int,
+                ) = dao.playlistSongs(entry.sourceId, entry.refId, offset, limit)
+
+                override suspend fun rowsFrom(
+                    dao: com.subtracks.data.db.QueueDao,
+                    entry: QueueEntry,
+                    key: OrderKey,
+                    skip: Long,
+                    limit: Int,
+                ) = dao.playlistSongsFrom(entry.sourceId, entry.refId, key.position!!, skip, limit)
+
+                override suspend fun rowsBefore(
+                    dao: com.subtracks.data.db.QueueDao,
+                    entry: QueueEntry,
+                    key: OrderKey,
+                    skip: Long,
+                    limit: Int,
+                ) = dao.playlistSongsBefore(entry.sourceId, entry.refId, key.position!!, skip, limit)
+
+                override suspend fun rank(
+                    dao: com.subtracks.data.db.QueueDao,
+                    entry: QueueEntry,
+                    songId: String,
+                ) = dao.playlistRank(entry.sourceId, entry.refId, songId)
+            },
+        QueueKind.Album to
+            object : QueueKindResolver {
+                override fun supportsKeyset(key: OrderKey) = key.disc != null && key.track != null
+
+                override suspend fun length(
+                    dao: com.subtracks.data.db.QueueDao,
+                    entry: QueueEntry,
+                ) = dao.albumLength(entry.sourceId, entry.refId)
+
+                override suspend fun rows(
+                    dao: com.subtracks.data.db.QueueDao,
+                    entry: QueueEntry,
+                    offset: Long,
+                    limit: Int,
+                ) = dao.albumSongs(entry.sourceId, entry.refId, offset, limit)
+
+                override suspend fun rowsFrom(
+                    dao: com.subtracks.data.db.QueueDao,
+                    entry: QueueEntry,
+                    key: OrderKey,
+                    skip: Long,
+                    limit: Int,
+                ) = dao.albumSongsFrom(entry.sourceId, entry.refId, key.disc!!, key.track!!, key.id, skip, limit)
+
+                override suspend fun rowsBefore(
+                    dao: com.subtracks.data.db.QueueDao,
+                    entry: QueueEntry,
+                    key: OrderKey,
+                    skip: Long,
+                    limit: Int,
+                ) = dao.albumSongsBefore(entry.sourceId, entry.refId, key.disc!!, key.track!!, key.id, skip, limit)
+
+                override suspend fun rank(
+                    dao: com.subtracks.data.db.QueueDao,
+                    entry: QueueEntry,
+                    songId: String,
+                ) = dao.albumRank(entry.sourceId, entry.refId, songId)
+            },
+        QueueKind.Artist to
+            object : QueueKindResolver {
+                override suspend fun length(
+                    dao: com.subtracks.data.db.QueueDao,
+                    entry: QueueEntry,
+                ) = dao.artistLength(entry.sourceId, entry.refId)
+
+                override suspend fun rows(
+                    dao: com.subtracks.data.db.QueueDao,
+                    entry: QueueEntry,
+                    offset: Long,
+                    limit: Int,
+                ) = dao.artistSongs(entry.sourceId, entry.refId, offset, limit)
+            },
+        QueueKind.Genre to
+            object : QueueKindResolver {
+                override suspend fun length(
+                    dao: com.subtracks.data.db.QueueDao,
+                    entry: QueueEntry,
+                ) = dao.genreLength(entry.sourceId, entry.refId)
+
+                override suspend fun rows(
+                    dao: com.subtracks.data.db.QueueDao,
+                    entry: QueueEntry,
+                    offset: Long,
+                    limit: Int,
+                ) = dao.genreSongs(entry.sourceId, entry.refId, offset, limit)
+            },
+        QueueKind.Downloaded to
+            object : QueueKindResolver {
+                override suspend fun length(
+                    dao: com.subtracks.data.db.QueueDao,
+                    entry: QueueEntry,
+                ) = dao.downloadedLength(entry.sourceId)
+
+                override suspend fun rows(
+                    dao: com.subtracks.data.db.QueueDao,
+                    entry: QueueEntry,
+                    offset: Long,
+                    limit: Int,
+                ) = dao.downloadedSongs(entry.sourceId, offset, limit)
+            },
+        QueueKind.Starred to
+            object : QueueKindResolver {
+                override suspend fun length(
+                    dao: com.subtracks.data.db.QueueDao,
+                    entry: QueueEntry,
+                ) = dao.starredLength(entry.sourceId)
+
+                override suspend fun rows(
+                    dao: com.subtracks.data.db.QueueDao,
+                    entry: QueueEntry,
+                    offset: Long,
+                    limit: Int,
+                ) = dao.starredSongs(entry.sourceId, offset, limit)
+            },
+    )
+
+private fun resolverFor(kind: QueueKind): QueueKindResolver = queueKindResolvers.getValue(kind)
+
 class QueueRepository(
     private val db: SubtracksDatabase,
 ) {
@@ -216,12 +412,6 @@ class QueueRepository(
 
     private val queueVersion = AtomicLong()
 
-    @Volatile
-    private var cachedFlatIds: List<String>? = null
-
-    @Volatile
-    private var cachedFlatVersion = -1L
-
     @Volatile
     private var shuffleRemoved: ShuffleState? = null
 
@@ -235,6 +425,9 @@ class QueueRepository(
     internal var offsetSeeks = 0L
         private set
 
+    internal var resolvedRowCount = 0L
+        private set
+
     private val cursorMutex = Mutex()
 
     fun playlistEntry(
@@ -388,7 +581,6 @@ class QueueRepository(
     }
 
     fun invalidateLibraryCache() {
-        cachedFlatIds = null
         lengthCache.clear()
         keyCache.clear()
         shuffleRemoved = null
@@ -409,8 +601,8 @@ class QueueRepository(
         snapshot: QueueSnapshot,
         songId: String,
     ): Long? {
-        val upIndex = idsFor(snapshot.upNext).indexOf(songId)
+        val upIndex = flatIndexOf(snapshot.upNext, songId)
-        if (upIndex >= 0) return snapshot.anchorPlay + 1 + upIndex
+        if (upIndex != null) return snapshot.anchorPlay + 1 + upIndex
         return combinedContextIndexOf(snapshot, songId)
     }
 
@@ -418,9 +610,8 @@ class QueueRepository(
         snapshot: QueueSnapshot,
         songId: String,
     ): Long? {
-        val flat = flatIds(snapshot).indexOf(songId)
+        val flat = flatIndexOf(snapshot.entries, songId) ?: return null
-        if (flat < 0) return null
+        return snapshot.playContext(flat)?.let { snapshot.combined(it) }
-        return snapshot.playContext(flat.toLong())?.let { snapshot.combined(it) }
     }
 
     suspend fun range(
@@ -633,7 +824,6 @@ class QueueRepository(
             }
         }
         queueVersion.incrementAndGet()
-        cachedFlatIds = null
     }
 
     private suspend fun writeUpNext(entries: List<QueueEntry>) {
@@ -650,34 +840,40 @@ class QueueRepository(
         queueVersion.incrementAndGet()
     }
 
-    private suspend fun flatIds(snapshot: QueueSnapshot): List<String> {
+    private suspend fun flatIndexOf(
-        val cached = cachedFlatIds
+        entries: List<ResolvedQueueEntry>,
-        if (cached != null && cachedFlatVersion == snapshot.version && cached.size.toLong() == snapshot.contextSize) return cached
+        songId: String,
-        val ids = idsFor(snapshot.entries)
+    ): Long? {
-        cachedFlatIds = ids
+        var start = 0L
-        cachedFlatVersion = snapshot.version
+        for (resolved in entries) {
-        return ids
+            val entry = resolved.entry
+            val rank = resolverFor(entry.kind).rank(dao, entry, songId)
+            if (rank != null && rank >= entry.offset && rank < entry.offset + resolved.length) {
+                return start + rank - entry.offset
+            }
+            val fallback = fallbackRank(entry, resolved.length, songId)
+            if (fallback != null) return start + fallback - entry.offset
+            start += resolved.length
+        }
+        return null
     }
 
-    private suspend fun idsFor(resolved: List<ResolvedQueueEntry>): List<String> {
+    private suspend fun fallbackRank(
-        val ids = ArrayList<String>()
+        entry: QueueEntry,
-        for (entry in resolved) {
+        length: Long,
-            val ref = entry.entry
+        songId: String,
-            val entryIds =
+    ): Long? {
-                when (ref.kind) {
+        var offset = entry.offset
-                    QueueKind.Song -> listOf(ref.refId)
+        val end = entry.offset + length
-                    QueueKind.Album -> dao.albumSongIds(ref.sourceId, ref.refId)
+        while (offset < end) {
-                    QueueKind.Playlist -> dao.playlistSongIds(ref.sourceId, ref.refId)
+            val limit = minOf(QUEUE_CHUNK.toLong(), end - offset).toInt()
-                    QueueKind.Artist -> dao.artistSongIds(ref.sourceId, ref.refId)
+            val batch = rows(entry, offset, limit)
-                    QueueKind.Genre -> dao.genreSongIds(ref.sourceId, ref.refId)
+            val index = batch.indexOfFirst { it.song.id == songId }
-                    QueueKind.Downloaded -> dao.downloadedSongIds(ref.sourceId)
+            if (index >= 0) return offset + index
-                    QueueKind.Starred -> dao.starredSongIds(ref.sourceId)
+            if (batch.size < limit) return null
-                }
+            offset += batch.size
-            val from = ref.offset.toInt().coerceIn(0, entryIds.size)
-            val to = (ref.offset + entry.length).toInt().coerceIn(from, entryIds.size)
-            ids.addAll(entryIds.subList(from, to))
         }
-        return ids
+        return null
     }
 
     private suspend fun contextPlayRange(
@@ -688,21 +884,11 @@ class QueueRepository(
         if (first > last) return emptyList()
         val items = mutableListOf<QueueWindowItem>()
         if (snapshot.shuffled) {
-            val sourceId =
-                snapshot.entries
-                    .firstOrNull()
-                    ?.entry
-                    ?.sourceId ?: return emptyList()
-            val ids = flatIds(snapshot)
-            val requested = mutableListOf<Pair<Long, String>>()
             for (play in first..last) {
-                val flat = snapshot.flatContext(play) ?: continue
+                val located = snapshot.locateContext(play) ?: continue
-                val id = ids.getOrNull(flat.toInt()) ?: continue
+                val item = rows(located.first, located.first.offset + located.second, 1).firstOrNull() ?: continue
-                requested += play to id
+                items += QueueWindowItem(snapshot.combined(play), item, playlistPosition = item.playlistPosition)
             }
-            if (requested.isEmpty()) return emptyList()
-            val byId = dao.songsByIds(sourceId, requested.map { it.second }.distinct()).associateBy { it.song.id }
-            requested.forEach { (play, id) -> byId[id]?.let { items += QueueWindowItem(snapshot.combined(play), it) } }
             return items
         }
         var start = 0L
@@ -757,27 +943,20 @@ class QueueRepository(
     ): List<SongItem> {
         if (entry.kind == QueueKind.Song) {
             offsetSeeks++
-            return dao.song(entry.sourceId, entry.refId, offset, limit)
+            return resolverFor(entry.kind).rows(dao, entry, offset, limit).also { resolvedRowCount += it.size }
         }
         val ref = QueueRef(entry.kind, entry.sourceId, entry.refId)
         val anchored = keyCache[ref]?.let { keyedRows(entry, offset, limit, it) }
         if (anchored != null) {
             keysetSeeks++
             if (anchored.isNotEmpty()) remember(ref, offset, anchored)
+            resolvedRowCount += anchored.size
             return anchored
         }
         offsetSeeks++
-        val fresh =
+        val fresh = resolverFor(entry.kind).rows(dao, entry, offset, limit)
-            when (entry.kind) {
-                QueueKind.Playlist -> dao.playlistSongs(entry.sourceId, entry.refId, offset, limit)
-                QueueKind.Album -> dao.albumSongs(entry.sourceId, entry.refId, offset, limit)
-                QueueKind.Artist -> dao.artistSongs(entry.sourceId, entry.refId, offset, limit)
-                QueueKind.Genre -> dao.genreSongs(entry.sourceId, entry.refId, offset, limit)
-                QueueKind.Downloaded -> dao.downloadedSongs(entry.sourceId, offset, limit)
-                QueueKind.Starred -> dao.starredSongs(entry.sourceId, offset, limit)
-                QueueKind.Song -> emptyList()
-            }
         if (fresh.isNotEmpty()) remember(ref, offset, fresh)
+        resolvedRowCount += fresh.size
         return fresh
     }
 
@@ -810,7 +989,7 @@ class QueueRepository(
         limit: Int,
         cursor: KeyCursor,
     ): List<SongItem>? {
-        if (!cursor.key.seekable(entry.kind)) return null
+        if (!resolverFor(entry.kind).supportsKeyset(cursor.key)) return null
         val from = cursor.ordinal
         // A backward seek from a far cursor is not cheaper than the offset query: the album
         // predicate is not sargable (it has to include NULL disc/track), so it scans the partition
@@ -836,43 +1015,14 @@ class QueueRepository(
         key: OrderKey,
         skip: Long,
         limit: Int,
-    ): List<SongItem> =
+    ): List<SongItem> = resolverFor(entry.kind).rowsFrom(dao, entry, key, skip, limit) ?: emptyList()
-        when (entry.kind) {
-            QueueKind.Playlist -> dao.playlistSongsFrom(entry.sourceId, entry.refId, key.position!!, skip, limit)
-            QueueKind.Album -> dao.albumSongsFrom(entry.sourceId, entry.refId, key.disc!!, key.track!!, key.id, skip, limit)
-            QueueKind.Artist -> emptyList()
-            QueueKind.Genre -> emptyList()
-            QueueKind.Downloaded -> emptyList()
-            QueueKind.Starred -> emptyList()
-            QueueKind.Song -> emptyList()
-        }
 
     private suspend fun rowsBefore(
         entry: QueueEntry,
         key: OrderKey,
         skip: Long,
         limit: Int,
-    ): List<SongItem> =
+    ): List<SongItem> = resolverFor(entry.kind).rowsBefore(dao, entry, key, skip, limit) ?: emptyList()
-        when (entry.kind) {
-            QueueKind.Playlist -> dao.playlistSongsBefore(entry.sourceId, entry.refId, key.position!!, skip, limit)
-            QueueKind.Album -> dao.albumSongsBefore(entry.sourceId, entry.refId, key.disc!!, key.track!!, key.id, skip, limit)
-            QueueKind.Artist -> emptyList()
-            QueueKind.Genre -> emptyList()
-            QueueKind.Downloaded -> emptyList()
-            QueueKind.Starred -> emptyList()
-            QueueKind.Song -> emptyList()
-        }
-
-    private fun OrderKey.seekable(kind: QueueKind): Boolean =
-        when (kind) {
-            QueueKind.Playlist -> position != null
-            QueueKind.Album -> disc != null && track != null
-            QueueKind.Artist -> false
-            QueueKind.Genre -> false
-            QueueKind.Downloaded -> false
-            QueueKind.Starred -> false
-            QueueKind.Song -> false
-        }
 
     private suspend fun lengthOf(
         entry: QueueEntry,
@@ -897,36 +1047,7 @@ class QueueRepository(
         )
 
     private suspend fun QueueEntry.resolvedLength(): Long {
-        val total =
+        val total = resolverFor(kind).length(dao, this)
-            when (kind) {
-                QueueKind.Song -> {
-                    dao.songLength(sourceId, refId)
-                }
-
-                QueueKind.Playlist -> {
-                    dao.playlistLength(sourceId, refId)
-                }
-
-                QueueKind.Album -> {
-                    dao.albumLength(sourceId, refId)
-                }
-
-                QueueKind.Artist -> {
-                    dao.artistLength(sourceId, refId)
-                }
-
-                QueueKind.Genre -> {
-                    dao.genreLength(sourceId, refId)
-                }
-
-                QueueKind.Downloaded -> {
-                    dao.downloadedLength(sourceId)
-                }
-
-                QueueKind.Starred -> {
-                    dao.starredLength(sourceId)
-                }
-            }
         val available = (total - offset).coerceAtLeast(0)
         return count?.coerceAtMost(available) ?: available
     }

app/src/main/kotlin/com/subtracks/data/repo/SourceRepository.kt

@@ -9,6 +9,7 @@ import com.subtracks.data.model.CoverArtRef
 import com.subtracks.data.model.Source
 import com.subtracks.data.model.SubsonicConfig
 import com.subtracks.data.model.SubsonicSource
+import com.subtracks.data.model.artistImageKey
 import com.subtracks.data.model.coverArtKey
 import com.subtracks.data.net.NetworkMode
 import com.subtracks.data.prefs.StreamQuality
@@ -69,6 +70,9 @@ class SourceRepository(
     private val _offline = MutableStateFlow(false)
     val offline: StateFlow<Boolean> = _offline
 
+    private val _activeSource = MutableStateFlow<Long?>(null)
+    val activeSource: StateFlow<Long?> = _activeSource
+
     fun downloadsAllowedOverMetered(): Boolean = allowMeteredDownloads
 
     fun setOfflineMode(enabled: Boolean) {
@@ -109,6 +113,7 @@ class SourceRepository(
                     Log.i("net", "active source -> ${config?.name ?: "none"}")
                 }
                 active = config?.let { ActiveSource(it.id, it.toMusicSource(quality, concurrency)) }
+                _activeSource.value = config?.id
                 _quality.value = quality
                 if (sourceChanged && config != null && config.useTokenAuth && !_offline.value) {
                     scope.launch {
@@ -143,6 +148,18 @@ class SourceRepository(
         return CoverArtRef(url = url, cacheKey = cacheKey)
     }
 
+    fun artistImage(
+        artistId: String,
+        url: String?,
+    ): CoverArtRef? {
+        val current = active ?: return null
+        if (url.isNullOrBlank()) return null
+        val cacheKey = artistImageKey(current.id, artistId)
+        artworkStore.uri(current.id, cacheKey)?.let { return CoverArtRef(url = it, cacheKey = cacheKey) }
+        if (_offline.value) return null
+        return CoverArtRef(url = url, cacheKey = cacheKey)
+    }
+
     fun networkCoverArt(
         sourceId: Long,
         coverArt: String,

app/src/main/kotlin/com/subtracks/data/source/subsonic/SubsonicXml.kt

@@ -32,6 +32,7 @@ object SubsonicXml {
             albumCount = attrs.longAttr("albumCount") ?: 0L,
             starred = attrs.dateAttr("starred"),
             coverArt = attrs.attr("coverArt").ifEmpty { null },
+            artistImageUrl = attrs.attr("artistImageUrl").ifEmpty { null },
             sortName = attrs.attr("sortName").takeIf { it.isNotBlank() } ?: attrs.attr("name"),
         )
 
@@ -128,6 +129,8 @@ object SubsonicXml {
             created = attrs.dateAttr("created") ?: 0L,
             changed = attrs.dateAttr("changed") ?: 0L,
             duration = attrs.longAttr("duration") ?: 0L,
+            owner = attrs.attr("owner").ifEmpty { null },
+            shared = attrs.boolAttr("public"),
         )
 
     internal fun playlistSong(
@@ -364,6 +367,8 @@ internal fun Attributes.attr(name: String): String = getValue(name) ?: ""
 
 internal fun Attributes.longAttr(name: String): Long? = attr(name).takeIf { it.isNotEmpty() }?.toLongOrNull()
 
+internal fun Attributes.boolAttr(name: String): Boolean = attr(name).let { it == "1" || it.equals("true", ignoreCase = true) }
+
 internal fun Attributes.floatAttr(name: String): Float? = attr(name).takeIf { it.isNotEmpty() }?.toFloatOrNull()?.takeIf { it.isFinite() }
 
 internal fun Attributes.dateAttr(name: String): Long? = attr(name).takeIf { it.isNotEmpty() }?.let(IsoDate::parse)

app/src/main/kotlin/com/subtracks/data/sync/SyncService.kt

@@ -61,7 +61,7 @@ class SyncService(
         source.artists().collect { batch ->
             if (batch.isEmpty()) return@collect
             changed =
-                write("artists", artistColumns, primaryKey, batch, preserved = setOf("albumCount"), markStale = true) { it.values() } ||
+                write("artists", primaryKey, batch, preserved = setOf("albumCount"), markStale = true) { it.columns() } ||
                 changed
             batch.forEach { seen.add(idHash(it.id)) }
             artistsSynced += batch.size
@@ -137,7 +137,7 @@ class SyncService(
             connection.immediateTransaction {
                 val before = connection.totalChanges()
                 val resolved = connection.resolveSongSortNames(batch)
-                connection.upsertChanged("songs", songColumns, primaryKey, resolved) { it.values() }
+                connection.upsertChanged("songs", primaryKey, resolved) { it.columns() }
                 connection.usePrepared("DELETE FROM song_genres WHERE sourceId = ? AND songId = ? AND position >= ?") { statement ->
                     batch.forEach { song ->
                         statement.bind(1, song.sourceId)
@@ -148,7 +148,7 @@ class SyncService(
                         statement.clearBindings()
                     }
                 }
-                connection.upsertChanged("song_genres", songGenreColumns, songGenreKey, genres) { it.values() }
+                connection.upsertChanged("song_genres", songGenreKey, genres) { it.columns() }
                 connection.usePrepared("DELETE FROM song_artists WHERE sourceId = ? AND songId = ? AND position >= ?") { statement ->
                     batch.forEach { song ->
                         statement.bind(1, song.sourceId)
@@ -159,7 +159,7 @@ class SyncService(
                         statement.clearBindings()
                     }
                 }
-                connection.upsertChanged("song_artists", songArtistColumns, songArtistKey, artists) { it.values() }
+                connection.upsertChanged("song_artists", songArtistKey, artists) { it.columns() }
                 (connection.totalChanges() != before).also { changed ->
                     if (changed) connection.markCreditsStale(batch.first().sourceId)
                 }
@@ -256,7 +256,7 @@ class SyncService(
         val seen = HashedIds()
         source.playlists().collect { batch ->
             if (batch.isEmpty()) return@collect
-            write("playlists", playlistColumns, primaryKey, batch) { it.values() }
+            write("playlists", primaryKey, batch) { it.columns() }
             batch.forEach { seen.add(idHash(it.id)) }
             playlistsSynced += batch.size
         }
@@ -269,7 +269,7 @@ class SyncService(
         val counts = HashMap<String, Long>()
         source.playlistSongs(playlistIds).collect { batch ->
             if (batch.isEmpty()) return@collect
-            write("playlist_songs", playlistSongColumns, playlistSongKey, batch) { it.values() }
+            write("playlist_songs", playlistSongKey, batch) { it.columns() }
             batch.forEach { counts[it.playlistId] = (counts[it.playlistId] ?: 0L) + 1L }
             playlistSongsSynced += batch.size
         }
@@ -280,17 +280,16 @@ class SyncService(
     // One commit per batch, so Room notifies paged observers once per batch rather than per row.
     private suspend fun <T> write(
         table: String,
-        columns: List<String>,
         key: List<String>,
         rows: List<T>,
         preserved: Set<String> = emptySet(),
         markStale: Boolean = false,
-        values: (T) -> List<Any?>,
+        columns: (T) -> List<Pair<String, Any?>>,
     ): Boolean =
         db.useWriterConnection { connection ->
             connection.immediateTransaction {
                 val before = connection.totalChanges()
-                connection.upsertChanged(table, columns, key, rows, preserved, values)
+                connection.upsertChanged(table, key, rows, preserved, columns)
                 (connection.totalChanges() != before).also { changed ->
                     if (changed && markStale) connection.markCreditsStale(source.id)
                 }
@@ -309,8 +308,8 @@ class SyncService(
             connection.immediateTransaction {
                 val before = connection.totalChanges()
                 val resolved = connection.resolveAlbumSortNames(albums)
-                connection.upsertChanged("albums", albumColumns, primaryKey, resolved) { it.values() }
+                connection.upsertChanged("albums", primaryKey, resolved) { it.columns() }
-                connection.upsertChanged("discs", discColumns, discKey, discs) { it.values() }
+                connection.upsertChanged("discs", discKey, discs) { it.columns() }
                 connection.usePrepared("DELETE FROM album_artists WHERE sourceId = ? AND albumId = ? AND position >= ?") { statement ->
                     albums.forEach { album ->
                         statement.bind(1, album.sourceId)
@@ -321,7 +320,7 @@ class SyncService(
                         statement.clearBindings()
                     }
                 }
-                connection.upsertChanged("album_artists", albumArtistColumns, albumArtistKey, artists) { it.values() }
+                connection.upsertChanged("album_artists", albumArtistKey, artists) { it.columns() }
                 (connection.totalChanges() != before).also { changed ->
                     if (changed) connection.markCreditsStale(albums.first().sourceId)
                 }
@@ -438,57 +437,8 @@ private fun discHash(
 
 private val primaryKey = listOf("sourceId", "id")
 
-private val artistColumns = listOf("sourceId", "id", "name", "albumCount", "starred", "coverArt", "sortName")
-
-private val albumColumns =
-    listOf(
-        "sourceId",
-        "id",
-        "artistId",
-        "name",
-        "albumArtist",
-        "created",
-        "coverArt",
-        "genre",
-        "year",
-        "starred",
-        "songCount",
-        "artists",
-        "sortName",
-        "albumArtistSort",
-    )
-
 private val discKey = listOf("sourceId", "albumId", "disc")
 
-private val discColumns = listOf("sourceId", "albumId", "disc", "title")
-
-private val songColumns =
-    listOf(
-        "sourceId",
-        "id",
-        "albumId",
-        "artistId",
-        "title",
-        "album",
-        "artist",
-        "duration",
-        "track",
-        "disc",
-        "starred",
-        "created",
-        "playCount",
-        "played",
-        "trackGain",
-        "albumGain",
-        "trackPeak",
-        "albumPeak",
-        "artists",
-        "sortName",
-        "artistSort",
-    )
-
-private val playlistColumns = listOf("sourceId", "id", "name", "comment", "coverArt", "songCount", "created", "changed", "duration")
-
 private fun Song.genreNames(): List<String> =
     genres
         .flatMap { it.genreParts() }
@@ -499,71 +449,93 @@ private fun Song.genreNames(): List<String> =
 // Navidrome's default genre tag split (resources/mappings.yaml): semicolon, slash, comma.
 private fun String.genreParts(): List<String> = split(';', '/', ',').map { it.trim() }.filter { it.isNotEmpty() }
 
-private val songGenreColumns = listOf("sourceId", "songId", "position", "genre")
-
 private val songGenreKey = listOf("sourceId", "songId", "position")
 
-private val albumArtistColumns = listOf("sourceId", "albumId", "position", "artistId", "name")
-
 private val albumArtistKey = listOf("sourceId", "albumId", "position")
 
-private val songArtistColumns = listOf("sourceId", "songId", "position", "artistId", "name")
-
 private val songArtistKey = listOf("sourceId", "songId", "position")
 
-private val playlistSongColumns = listOf("sourceId", "playlistId", "songId", "position")
-
 private val playlistSongKey = listOf("sourceId", "playlistId", "position")
 
-private fun Artist.values() = listOf<Any?>(sourceId, id, name, albumCount, starred, coverArt, sortName)
+private fun Artist.columns(): List<Pair<String, Any?>> =
-
+    listOf(
-private fun Album.values() =
+        "sourceId" to sourceId,
-    listOf<Any?>(
+        "id" to id,
-        sourceId,
+        "name" to name,
-        id,
+        "albumCount" to albumCount,
-        artistId,
+        "starred" to starred,
-        name,
+        "coverArt" to coverArt,
-        albumArtist,
+        "artistImageUrl" to artistImageUrl,
-        created,
+        "sortName" to sortName,
-        coverArt,
-        genre,
-        year,
-        starred,
-        songCount,
-        ArtistRefsCodec.encode(artistRefs),
-        sortName,
-        albumArtistSort,
     )
 
-private fun AlbumArtistRef.values() = listOf<Any?>(sourceId, albumId, position, artistId, name)
+private fun Album.columns(): List<Pair<String, Any?>> =
+    listOf(
+        "sourceId" to sourceId,
+        "id" to id,
+        "artistId" to artistId,
+        "name" to name,
+        "albumArtist" to albumArtist,
+        "created" to created,
+        "coverArt" to coverArt,
+        "genre" to genre,
+        "year" to year,
+        "starred" to starred,
+        "songCount" to songCount,
+        "artists" to ArtistRefsCodec.encode(artistRefs),
+        "sortName" to sortName,
+        "albumArtistSort" to albumArtistSort,
+    )
 
-private fun SongArtistRef.values() = listOf<Any?>(sourceId, songId, position, artistId, name)
+private fun AlbumArtistRef.columns(): List<Pair<String, Any?>> =
+    listOf(
+        "sourceId" to sourceId,
+        "albumId" to albumId,
+        "position" to position,
+        "artistId" to artistId,
+        "name" to name,
+    )
 
-private fun Disc.values() = listOf<Any?>(sourceId, albumId, disc, title)
+private fun SongArtistRef.columns(): List<Pair<String, Any?>> =
+    listOf(
+        "sourceId" to sourceId,
+        "songId" to songId,
+        "position" to position,
+        "artistId" to artistId,
+        "name" to name,
+    )
 
-private fun Song.values() =
+private fun Disc.columns(): List<Pair<String, Any?>> =
-    listOf<Any?>(
+    listOf(
-        sourceId,
+        "sourceId" to sourceId,
-        id,
+        "albumId" to albumId,
-        albumId,
+        "disc" to disc,
-        artistId,
+        "title" to title,
-        title,
+    )
-        album,
+
-        artist,
+private fun Song.columns(): List<Pair<String, Any?>> =
-        duration,
+    listOf(
-        track,
+        "sourceId" to sourceId,
-        disc,
+        "id" to id,
-        starred,
+        "albumId" to albumId,
-        created,
+        "artistId" to artistId,
-        playCount,
+        "title" to title,
-        played,
+        "album" to album,
-        trackGain,
+        "artist" to artist,
-        albumGain,
+        "duration" to duration,
-        trackPeak,
+        "track" to track,
-        albumPeak,
+        "disc" to disc,
-        ArtistRefsCodec.encode(artistRefs),
+        "starred" to starred,
-        sortName,
+        "created" to created,
-        artistSort,
+        "playCount" to playCount,
+        "played" to played,
+        "trackGain" to trackGain,
+        "albumGain" to albumGain,
+        "trackPeak" to trackPeak,
+        "albumPeak" to albumPeak,
+        "artists" to ArtistRefsCodec.encode(artistRefs),
+        "sortName" to sortName,
+        "artistSort" to artistSort,
     )
 
 private fun List<ArtistRef>.positions(): List<Pair<Long, ArtistRef>> =
@@ -575,32 +547,56 @@ private fun Album.artistPositions(): List<Pair<Long, ArtistRef>> = artistRefs.po
 
 private fun Song.artistPositions(): List<Pair<Long, ArtistRef>> = artistRefs.positions()
 
-private fun SongGenre.values() = listOf<Any?>(sourceId, songId, position, genre)
+private fun SongGenre.columns(): List<Pair<String, Any?>> =
+    listOf(
+        "sourceId" to sourceId,
+        "songId" to songId,
+        "position" to position,
+        "genre" to genre,
+    )
 
-private fun Playlist.values() = listOf<Any?>(sourceId, id, name, comment, coverArt, songCount, created, changed, duration)
+private fun Playlist.columns(): List<Pair<String, Any?>> =
+    listOf(
+        "sourceId" to sourceId,
+        "id" to id,
+        "name" to name,
+        "comment" to comment,
+        "coverArt" to coverArt,
+        "songCount" to songCount,
+        "created" to created,
+        "changed" to changed,
+        "duration" to duration,
+        "owner" to owner,
+        "shared" to shared,
+    )
 
-private fun PlaylistSong.values() = listOf<Any?>(sourceId, playlistId, songId, position)
+private fun PlaylistSong.columns(): List<Pair<String, Any?>> =
+    listOf(
+        "sourceId" to sourceId,
+        "playlistId" to playlistId,
+        "songId" to songId,
+        "position" to position,
+    )
 
 private suspend fun <T> PooledConnection.upsertChanged(
     table: String,
-    columns: List<String>,
     key: List<String>,
     rows: List<T>,
     preserved: Set<String> = emptySet(),
-    values: (T) -> List<Any?>,
+    columns: (T) -> List<Pair<String, Any?>>,
 ) {
     if (rows.isEmpty()) return
-    check(values(rows.first()).size == columns.size) { "column/value mismatch for $table" }
+    val columnNames = columns(rows.first()).map { it.first }
-    val updates = columns.filterNot { it in key || it in preserved }
+    val updates = columnNames.filterNot { it in key || it in preserved }
     val sql =
-        "INSERT INTO $table (${columns.joinToString()}) VALUES (${columns.joinToString { "?" }}) " +
+        "INSERT INTO $table (${columnNames.joinToString()}) VALUES (${columnNames.joinToString { "?" }}) " +
             "ON CONFLICT(${key.joinToString()}) DO UPDATE SET " +
             updates.joinToString { "$it = excluded.$it" } +
             " WHERE " +
             updates.joinToString(" OR ") { "$table.$it COLLATE BINARY IS NOT excluded.$it" }
     usePrepared(sql) { statement ->
         rows.forEach { row ->
-            values(row).forEachIndexed { index, value -> statement.bind(index + 1, value) }
+            columns(row).forEachIndexed { index, (_, value) -> statement.bind(index + 1, value) }
             statement.step()
             statement.reset()
             statement.clearBindings()

app/src/main/kotlin/com/subtracks/di/AppModule.kt

@@ -96,7 +96,7 @@ fun appModule(
             scope = get(),
         )
     }
-    single { LibraryRepository(get(), get(), get(), toast, scope = get(named("io"))) }
+    single { LibraryRepository(get(), get(), get(), get(), toast, scope = get(named("io"))) }
     single<ArtworkSeedStore> { ArtworkSeedRepository(get()) }
     single { SyncManager(get(), get(), get(), get(), preferences = get(), showMessage = toast, scope = get()) }
     single {
@@ -128,7 +128,7 @@ fun appModule(
     single(createdAtStart = true) { DownloadNotifier(context.applicationContext, get(), scope = get()).also { it.start() } }
     single(createdAtStart = true) { SyncNotifier(context.applicationContext, get<SyncManager>().status, scope = get()).also { it.start() } }
     single<PlayerConnection> { MediaSessionConnection(context.applicationContext, get(), get()) }
-    single { PlaybackController(get(), get(), get(), get(), showMessage = toast, scope = get(named("playback"))) }
+    single { PlaybackController(get(), get(), get(), get(), get(), showMessage = toast, scope = get(named("playback"))) }
     single(createdAtStart = true) {
         val playback = get<PlaybackController>()
         Scrobbler(

app/src/main/kotlin/com/subtracks/playback/Media3PlayerHandle.kt

@@ -12,6 +12,8 @@ import androidx.media3.common.util.UnstableApi
 import androidx.media3.session.MediaController
 import com.subtracks.R
 import com.subtracks.UiMessage
+import com.subtracks.data.model.ArtistRef
+import com.subtracks.data.model.ArtistRefsCodec
 import com.subtracks.data.model.AudioEncoding
 import com.subtracks.data.repo.DownloadRepository
 import com.subtracks.data.repo.SourceRepository
@@ -229,6 +231,7 @@ class Media3PlayerHandle(
                     .orEmpty(),
             artist = mediaItem.mediaMetadata.artist?.toString(),
             album = mediaItem.mediaMetadata.albumTitle?.toString(),
+            artists = mediaItem.artistRefs(),
             coverArtId = mediaItem.mediaMetadata.extras?.getString(EXTRA_COVER_ART_ID),
             durationMs =
                 mediaItem.mediaMetadata.extras
@@ -238,7 +241,14 @@ class Media3PlayerHandle(
         )
 }
 
+internal fun MediaItem.artistRefs(): List<ArtistRef> =
+    mediaMetadata.extras
+        ?.getString(EXTRA_ARTISTS)
+        ?.let(ArtistRefsCodec::decode)
+        .orEmpty()
+
 private const val EXTRA_COVER_ART_ID = "coverArtId"
+private const val EXTRA_ARTISTS = "artists"
 private const val EXTRA_DURATION_MS = "durationMs"
 private const val EXTRA_REPLAY_GAIN_TRACK_GAIN = "replayGainTrackGain"
 private const val EXTRA_REPLAY_GAIN_ALBUM_GAIN = "replayGainAlbumGain"
@@ -286,6 +296,7 @@ internal fun queueMediaItem(
             .setExtras(
                 Bundle().apply {
                     putString(EXTRA_COVER_ART_ID, item.coverArtId)
+                    putString(EXTRA_ARTISTS, ArtistRefsCodec.encode(item.artists))
                     item.durationMs?.let { putLong(EXTRA_DURATION_MS, it) }
                     putGain(EXTRA_REPLAY_GAIN_TRACK_GAIN, item.replayGain.trackGain)
                     putGain(EXTRA_REPLAY_GAIN_ALBUM_GAIN, item.replayGain.albumGain)

app/src/main/kotlin/com/subtracks/playback/PlaybackController.kt

@@ -1,10 +1,13 @@
 package com.subtracks.playback
 
 import com.subtracks.UiMessage
+import com.subtracks.data.model.ArtistRef
 import com.subtracks.data.model.AudioEncoding
 import com.subtracks.data.model.CoverArtRef
 import com.subtracks.data.model.QueueEntry
 import com.subtracks.data.model.QueueKind
+import com.subtracks.data.prefs.SongTapBehavior
+import com.subtracks.data.prefs.UserPreferences
 import com.subtracks.data.repo.DownloadRepository
 import com.subtracks.data.repo.QueueRepository
 import com.subtracks.data.repo.QueueSnapshot
@@ -21,6 +24,7 @@ import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.drop
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
@@ -36,6 +40,7 @@ data class QueueItem(
     val durationMs: Long? = null,
     val replayGain: ReplayGain = ReplayGain(),
     val albumContext: Boolean = false,
+    val artists: List<ArtistRef> = emptyList(),
 )
 
 data class QueueContext(
@@ -102,9 +107,9 @@ private data class ReloadUndo(
 }
 
 private data class PendingPlay(
-    val entries: List<QueueEntry>,
+    val entry: QueueEntry,
     val position: Long,
-    val disableShuffle: Boolean,
+    val behavior: SongTapBehavior?,
 )
 
 class PlaybackController(
@@ -112,6 +117,7 @@ class PlaybackController(
     private val queueRepository: QueueRepository,
     private val connection: PlayerConnection,
     private val downloads: DownloadRepository,
+    private val preferences: UserPreferences,
     private val showMessage: (UiMessage) -> Unit = {},
     private val scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate),
 ) {
@@ -126,7 +132,7 @@ class PlaybackController(
     private var player: PlayerHandle? = null
     private var connecting = false
     private var pendingPlay: PendingPlay? = null
-    private var pendingShuffle: List<QueueEntry>? = null
+    private var pendingShuffle: QueueEntry? = null
     private var positionJob: Job? = null
     private var windowJob: Job? = null
     private var bufferingJob: Job? = null
@@ -189,7 +195,7 @@ class PlaybackController(
                     val shuffle = pendingShuffle
                     pendingShuffle = null
                     when {
-                        pending != null -> start(pending.entries, pending.position, pending.disableShuffle)
+                        pending != null -> startPending(pending)
                         shuffle != null -> startShuffled(shuffle)
                         else -> restore()
                     }
@@ -209,100 +215,85 @@ class PlaybackController(
         sourceId: Long,
         albumId: String,
         startOrdinal: Long,
-    ) = playContext(queueRepository.albumEntry(sourceId, albumId), startOrdinal)
+    ) = play(queueRepository.albumEntry(sourceId, albumId), startOrdinal)
 
     fun playSong(
         sourceId: Long,
         songId: String,
-    ) = playContext(queueRepository.songEntry(sourceId, songId), 0)
+    ) = play(queueRepository.songEntry(sourceId, songId), 0)
 
     fun playPlaylist(
         sourceId: Long,
         playlistId: String,
         startPosition: Long,
-    ) = playContext(queueRepository.playlistEntry(sourceId, playlistId), startPosition)
+    ) = play(queueRepository.playlistEntry(sourceId, playlistId), startPosition)
 
     fun playGenre(
         sourceId: Long,
         genre: String,
         startOrdinal: Long,
-    ) = playContext(queueRepository.genreEntry(sourceId, genre), startOrdinal)
+    ) = play(queueRepository.genreEntry(sourceId, genre), startOrdinal)
 
     fun playDownloaded(
         sourceId: Long,
         startOrdinal: Long,
-    ) = playContext(queueRepository.downloadedEntry(sourceId), startOrdinal)
+    ) = play(queueRepository.downloadedEntry(sourceId), startOrdinal)
 
     fun playStarred(
         sourceId: Long,
         startOrdinal: Long,
-    ) = playContext(queueRepository.starredEntry(sourceId), startOrdinal)
+    ) = play(queueRepository.starredEntry(sourceId), startOrdinal)
 
     fun playAlbumInOrder(
         sourceId: Long,
         albumId: String,
-    ) = playContext(queueRepository.albumEntry(sourceId, albumId), 0, disableShuffle = true)
+    ) = play(queueRepository.albumEntry(sourceId, albumId), 0, SongTapBehavior.InOrder)
 
     fun playPlaylistInOrder(
         sourceId: Long,
         playlistId: String,
-    ) = playContext(queueRepository.playlistEntry(sourceId, playlistId), 0, disableShuffle = true)
+    ) = play(queueRepository.playlistEntry(sourceId, playlistId), 0, SongTapBehavior.InOrder)
 
     fun shuffleAlbum(
         sourceId: Long,
         albumId: String,
-    ) = shuffleContext(queueRepository.albumEntry(sourceId, albumId))
+    ) = shufflePlay(queueRepository.albumEntry(sourceId, albumId))
 
     fun shufflePlaylist(
         sourceId: Long,
         playlistId: String,
-    ) = shuffleContext(queueRepository.playlistEntry(sourceId, playlistId))
+    ) = shufflePlay(queueRepository.playlistEntry(sourceId, playlistId))
 
     fun shuffleArtist(
         sourceId: Long,
         artistId: String,
-    ) = shuffleContext(queueRepository.artistEntry(sourceId, artistId))
+    ) = shufflePlay(queueRepository.artistEntry(sourceId, artistId))
 
     fun shuffleGenre(
         sourceId: Long,
         genre: String,
-    ) = shuffleContext(queueRepository.genreEntry(sourceId, genre))
+    ) = shufflePlay(queueRepository.genreEntry(sourceId, genre))
 
-    fun shuffleStarred(sourceId: Long) = shuffleContext(queueRepository.starredEntry(sourceId))
+    fun shuffleStarred(sourceId: Long) = shufflePlay(queueRepository.starredEntry(sourceId))
 
-    fun shuffleDownloaded(sourceId: Long) = shuffleContext(queueRepository.downloadedEntry(sourceId))
+    fun shuffleDownloaded(sourceId: Long) = shufflePlay(queueRepository.downloadedEntry(sourceId))
 
-    private fun playContext(
+    private fun shufflePlay(entry: QueueEntry) {
-        entry: QueueEntry,
-        start: Long,
-        disableShuffle: Boolean = false,
-    ) = play(listOf(entry), start, disableShuffle)
-
-    private fun shuffleContext(entry: QueueEntry) = shufflePlay(listOf(entry))
-
-    private fun shufflePlay(entries: List<QueueEntry>) {
         if (player == null) {
-            pendingShuffle = entries
+            pendingShuffle = entry
             connect()
             return
         }
-        scope.launch { startShuffled(entries) }
+        scope.launch { startShuffled(entry) }
     }
 
-    private suspend fun startShuffled(entries: List<QueueEntry>) =
+    private suspend fun startShuffled(entry: QueueEntry) =
         startLock.withLock {
-            val entry = entries.first()
-            windowJob?.cancel()
-            windowStart = 0
-            windowEnd = -1
-            lastEdit = null
-            endedHandled = false
             val previous = snapshot
             val previousEntry = previous?.entries?.firstOrNull()?.entry
             val same = previousEntry != null && previousEntry.kind == entry.kind && previousEntry.refId == entry.refId
             val avoid = if (same) currentPosition()?.let { previous.flatContext(previous.anchorContextPlay(it)) } else null
-            queueRepository.replace(entries)
+            var snap = resetQueue(entry)
-            var snap = queueRepository.snapshot()
             if (snap.contextSize == 0L) {
                 stopLocked()
                 return@withLock
@@ -317,6 +308,18 @@ class PlaybackController(
             loadWindow(0, autoplay = true)
         }
 
+    private suspend fun resetQueue(entry: QueueEntry): QueueSnapshot {
+        windowJob?.cancel()
+        windowStart = 0
+        windowEnd = -1
+        lastEdit = null
+        endedHandled = false
+        queueRepository.replace(listOf(entry))
+        val snapshot = queueRepository.snapshot()
+        this.snapshot = snapshot
+        return snapshot
+    }
+
     private fun randomIndex(
         size: Long,
         avoid: Long?,
@@ -978,43 +981,53 @@ class PlaybackController(
     }
 
     private fun play(
-        entries: List<QueueEntry>,
+        entry: QueueEntry,
         startPosition: Long,
-        disableShuffle: Boolean = false,
+        behavior: SongTapBehavior? = null,
     ) {
         if (player == null) {
-            pendingPlay = PendingPlay(entries, startPosition, disableShuffle)
+            pendingPlay = PendingPlay(entry, startPosition, behavior)
             connect()
             return
         }
-        scope.launch { start(entries, startPosition, disableShuffle) }
+        scope.launch {
+            startLock.withLock {
+                startLocked(entry, startPosition, behavior)
+            }
+        }
     }
 
-    private suspend fun start(
+    private suspend fun startPending(pending: PendingPlay) {
-        entries: List<QueueEntry>,
+        startLock.withLock {
+            startLocked(pending.entry, pending.position, pending.behavior)
+        }
+    }
+
+    private suspend fun startLocked(
+        entry: QueueEntry,
         startPosition: Long,
-        disableShuffle: Boolean = false,
+        behavior: SongTapBehavior?,
-    ) = startLock.withLock {
+    ) {
-        windowJob?.cancel()
+        val resolved = behavior ?: preferences.songTapBehavior().first()
-        windowStart = 0
-        windowEnd = -1
-        lastEdit = null
-        endedHandled = false
         val modes = queueRepository.modes()
-        shuffleEnabled = !disableShuffle && modes.shuffle
+        val shuffle =
+            when (resolved) {
+                SongTapBehavior.InOrder -> false
+                SongTapBehavior.KeepShuffle -> modes.shuffle
+                SongTapBehavior.Shuffle -> true
+            }
+        val snapshot = resetQueue(entry)
+        shuffleEnabled = shuffle
         repeatMode = modes.repeat.toRepeatMode()
         player?.setRepeatOne(repeatMode == RepeatMode.One)
-        queueRepository.replace(entries)
+        queueSourceId = entry.sourceId
-        val snapshot = queueRepository.snapshot()
-        this.snapshot = snapshot
-        queueSourceId = entries.firstOrNull()?.sourceId
         if (snapshot.size == 0L) {
             stopLocked()
-            return@withLock
+            return
         }
         val start = startPosition.coerceIn(0, snapshot.contextSize - 1)
         val position =
-            if (shuffleEnabled) {
+            if (shuffle) {
                 queueRepository.setShuffle(pinnedSeed(snapshot.contextSize, start))
                 0L
             } else {

app/src/main/kotlin/com/subtracks/playback/QueueItem.kt

@@ -1,5 +1,6 @@
 package com.subtracks.playback
 
+import com.subtracks.data.model.ArtistRef
 import com.subtracks.data.model.SongItem
 
 fun SongItem.toQueueItem(albumContext: Boolean = false) =
@@ -7,6 +8,7 @@ fun SongItem.toQueueItem(albumContext: Boolean = false) =
         id = song.id,
         title = song.title,
         artist = song.artist,
+        artists = song.artistRefs,
         album = song.album,
         coverArtId = coverArt,
         durationMs = song.duration?.let { it * 1000 },

app/src/main/kotlin/com/subtracks/ui/AppRoot.kt

@@ -61,14 +61,20 @@ import androidx.navigation.compose.currentBackStackEntryAsState
 import androidx.navigation.compose.rememberNavController
 import androidx.navigation.navArgument
 import com.subtracks.R
+import com.subtracks.data.model.ArtistRef
 import com.subtracks.data.model.Song
 import com.subtracks.data.repo.DownloadRepository
 import com.subtracks.data.repo.LibraryRepository
 import com.subtracks.data.repo.SourceRepository
 import com.subtracks.playback.PlaybackController
+import com.subtracks.ui.components.AlbumInfoDialog
+import com.subtracks.ui.components.ArtistChooserSheet
+import com.subtracks.ui.components.ArtistInfoDialog
 import com.subtracks.ui.components.ContextMenuHost
 import com.subtracks.ui.components.ItemContextMenu
 import com.subtracks.ui.components.LoadingState
+import com.subtracks.ui.components.MenuTarget
+import com.subtracks.ui.components.PlaylistInfoDialog
 import com.subtracks.ui.components.SongInfoDialog
 import com.subtracks.ui.components.statusBarScrim
 import com.subtracks.ui.downloads.DownloadsRoute
@@ -230,7 +236,8 @@ private fun MainNavigation() {
     var settleJob by remember { mutableStateOf<Job?>(null) }
     val scope = rememberCoroutineScope()
     val contextMenuHost = remember { ContextMenuHost() }
-    var infoSong by remember { mutableStateOf<Song?>(null) }
+    var infoTarget by remember { mutableStateOf<MenuTarget?>(null) }
+    var artistChooser by remember { mutableStateOf<List<ArtistRef>?>(null) }
 
     val activeSourceId by libraryRepository.activeSourceId.collectAsStateWithLifecycle(initialValue = null)
     var previousSourceId by rememberSaveable { mutableStateOf<Long?>(null) }
@@ -312,7 +319,8 @@ private fun MainNavigation() {
         nowPlayingLauncher.openNowPlaying.collect {
             focusManager.clearFocus()
             contextMenuHost.dismissTransients()
-            infoSong = null
+            infoTarget = null
+            artistChooser = null
             showingQueue = false
             if (navController.currentDestination?.route in DETAIL_ROUTES) {
                 navController.popBackStack(Routes.LIBRARY, inclusive = false)
@@ -375,7 +383,15 @@ private fun MainNavigation() {
                                 navigateDetail(Routes.ALBUM_DETAIL, "albumId", album.id, Routes.album(album.id, album.coverArt))
                             },
                             onArtistClick = { artist ->
-                                navigateDetail(Routes.ARTIST_DETAIL, "artistId", artist.id, Routes.artist(artist.id, artist.coverArt))
+                                navigateDetail(
+                                    Routes.ARTIST_DETAIL,
+                                    "artistId",
+                                    artist.id,
+                                    Routes.artist(
+                                        artist.id,
+                                        artist.coverArt ?: artist.coverArts.firstOrNull(),
+                                    ),
+                                )
                             },
                             onPlaylistClick = { playlist ->
                                 navigateDetail(Routes.PLAYLIST_DETAIL, "playlistId", playlist.id, Routes.playlist(playlist.id))
@@ -418,7 +434,15 @@ private fun MainNavigation() {
                                 navigateDetail(Routes.ALBUM_DETAIL, "albumId", album.id, Routes.album(album.id, album.coverArt))
                             },
                             onArtistClick = { artist ->
-                                navigateDetail(Routes.ARTIST_DETAIL, "artistId", artist.id, Routes.artist(artist.id, artist.coverArt))
+                                navigateDetail(
+                                    Routes.ARTIST_DETAIL,
+                                    "artistId",
+                                    artist.id,
+                                    Routes.artist(
+                                        artist.id,
+                                        artist.coverArt ?: artist.coverArts.firstOrNull(),
+                                    ),
+                                )
                             },
                             onPlaylistClick = { playlist ->
                                 navigateDetail(Routes.PLAYLIST_DETAIL, "playlistId", playlist.id, Routes.playlist(playlist.id))
@@ -514,7 +538,15 @@ private fun MainNavigation() {
                                 navigateDetail(Routes.ALBUM_DETAIL, "albumId", album.id, Routes.album(album.id, album.coverArt))
                             },
                             onArtistClick = { artist ->
-                                navigateDetail(Routes.ARTIST_DETAIL, "artistId", artist.id, Routes.artist(artist.id, artist.coverArt))
+                                navigateDetail(
+                                    Routes.ARTIST_DETAIL,
+                                    "artistId",
+                                    artist.id,
+                                    Routes.artist(
+                                        artist.id,
+                                        artist.coverArt ?: artist.coverArts.firstOrNull(),
+                                    ),
+                                )
                             },
                             onViewAlbum = { albumId -> navigateDetail(Routes.ALBUM_DETAIL, "albumId", albumId, Routes.album(albumId)) },
                             onViewArtist = { artistId ->
@@ -538,7 +570,15 @@ private fun MainNavigation() {
                                 navigateDetail(Routes.ALBUM_DETAIL, "albumId", album.id, Routes.album(album.id, album.coverArt))
                             },
                             onArtistClick = { artist ->
-                                navigateDetail(Routes.ARTIST_DETAIL, "artistId", artist.id, Routes.artist(artist.id, artist.coverArt))
+                                navigateDetail(
+                                    Routes.ARTIST_DETAIL,
+                                    "artistId",
+                                    artist.id,
+                                    Routes.artist(
+                                        artist.id,
+                                        artist.coverArt ?: artist.coverArts.firstOrNull(),
+                                    ),
+                                )
                             },
                             onViewAlbum = { albumId -> navigateDetail(Routes.ALBUM_DETAIL, "albumId", albumId, Routes.album(albumId)) },
                             onViewArtist = { artistId ->
@@ -562,7 +602,15 @@ private fun MainNavigation() {
                                 navigateDetail(Routes.ALBUM_DETAIL, "albumId", album.id, Routes.album(album.id, album.coverArt))
                             },
                             onArtistClick = { artist ->
-                                navigateDetail(Routes.ARTIST_DETAIL, "artistId", artist.id, Routes.artist(artist.id, artist.coverArt))
+                                navigateDetail(
+                                    Routes.ARTIST_DETAIL,
+                                    "artistId",
+                                    artist.id,
+                                    Routes.artist(
+                                        artist.id,
+                                        artist.coverArt ?: artist.coverArts.firstOrNull(),
+                                    ),
+                                )
                             },
                             onViewAlbum = { albumId -> navigateDetail(Routes.ALBUM_DETAIL, "albumId", albumId, Routes.album(albumId)) },
                             onViewArtist = { artistId ->
@@ -588,7 +636,15 @@ private fun MainNavigation() {
                                 navigateDetail(Routes.ALBUM_DETAIL, "albumId", album.id, Routes.album(album.id, album.coverArt))
                             },
                             onArtistClick = { artist ->
-                                navigateDetail(Routes.ARTIST_DETAIL, "artistId", artist.id, Routes.artist(artist.id, artist.coverArt))
+                                navigateDetail(
+                                    Routes.ARTIST_DETAIL,
+                                    "artistId",
+                                    artist.id,
+                                    Routes.artist(
+                                        artist.id,
+                                        artist.coverArt ?: artist.coverArts.firstOrNull(),
+                                    ),
+                                )
                             },
                             onPlaylistClick = { playlist ->
                                 navigateDetail(Routes.PLAYLIST_DETAIL, "playlistId", playlist.id, Routes.playlist(playlist.id))
@@ -725,23 +781,69 @@ private fun MainNavigation() {
                     target = target,
                     actions = contextMenuHost.actions,
                     onDismiss = { contextMenuHost.dismiss() },
-                    onInfo = { infoSong = it },
+                    onInfo = { infoTarget = it },
+                    onChooseArtists = { artistChooser = it },
                 )
             }
 
-            infoSong?.let { song ->
+            artistChooser?.let { artists ->
-                val genres by
+                ArtistChooserSheet(
-                    remember(song.sourceId, song.id) { libraryRepository.songGenres(song.sourceId, song.id) }
+                    artists = artists,
-                        .collectAsStateWithLifecycle(initialValue = emptyList())
+                    onArtistClick = { artist ->
-                SongInfoDialog(
+                        artistChooser = null
-                    song = song,
+                        navigateDetail(
-                    download = downloads[song.id],
+                            Routes.ARTIST_DETAIL,
-                    localFile = downloadRepository.localFile(song.id),
+                            "artistId",
-                    streamEncoding = playbackController.currentAudioEncoding().takeIf { playback.item?.id == song.id },
+                            artist.id,
-                    onDismiss = { infoSong = null },
+                            Routes.artist(artist.id),
-                    genres = genres,
+                        )
+                    },
+                    onDismiss = { artistChooser = null },
                 )
             }
+
+            when (val target = infoTarget) {
+                is MenuTarget.Song -> {
+                    val song = target.song
+                    val genres by
+                        remember(song.sourceId, song.id) { libraryRepository.songGenres(song.sourceId, song.id) }
+                            .collectAsStateWithLifecycle(initialValue = emptyList())
+                    SongInfoDialog(
+                        song = song,
+                        download = downloads[song.id],
+                        localFile = downloadRepository.localFile(song.id),
+                        streamEncoding = playbackController.currentAudioEncoding().takeIf { playback.item?.id == song.id },
+                        onDismiss = { infoTarget = null },
+                        genres = genres,
+                    )
+                }
+
+                is MenuTarget.Album -> {
+                    AlbumInfoDialog(
+                        album = target.album,
+                        download = target.download,
+                        onDismiss = { infoTarget = null },
+                    )
+                }
+
+                is MenuTarget.Artist -> {
+                    ArtistInfoDialog(
+                        artist = target.artist,
+                        onDismiss = { infoTarget = null },
+                    )
+                }
+
+                is MenuTarget.Playlist -> {
+                    PlaylistInfoDialog(
+                        playlist = target.playlist,
+                        onDismiss = { infoTarget = null },
+                    )
+                }
+
+                null -> {
+                    Unit
+                }
+            }
         }
     }
 

app/src/main/kotlin/com/subtracks/ui/components/ArtistArt.kt

@@ -0,0 +1,310 @@
+package com.subtracks.ui.components
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxWidth
+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.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.Outline
+import androidx.compose.ui.graphics.Path
+import androidx.compose.ui.graphics.Shape
+import androidx.compose.ui.unit.Density
+import androidx.compose.ui.unit.LayoutDirection
+import com.subtracks.data.model.Artist
+import com.subtracks.data.model.CoverArtRef
+import com.subtracks.data.repo.SourceRepository
+import kotlin.math.PI
+import kotlin.math.cos
+import kotlin.math.min
+import kotlin.math.sin
+
+data class ArtistArt(
+    val image: CoverArtRef? = null,
+    val thumbnail: CoverArtRef? = null,
+    val covers: List<CoverArtRef> = emptyList(),
+    val fallback: ArtistArt? = null,
+) {
+    val primary: CoverArtRef? get() = image ?: covers.firstOrNull()
+}
+
+fun SourceRepository.artistArt(
+    artist: Artist,
+    forIcon: Boolean = true,
+): ArtistArt =
+    resolveArtistArt(
+        artist = artist,
+        coverArt = this::coverArt,
+        artistImage = this::artistImage,
+        offline = offline.value,
+        forIcon = forIcon,
+    )
+
+internal fun resolveArtistArt(
+    artist: Artist,
+    coverArt: (String?, Boolean) -> CoverArtRef?,
+    artistImage: (String, String?) -> CoverArtRef?,
+    offline: Boolean,
+    forIcon: Boolean,
+): ArtistArt {
+    val coverIds = if (offline) artist.downloadedCoverArts else artist.coverArts
+    val grid =
+        ArtistArt(
+            thumbnail = coverIds.singleOrNull()?.let { coverArt(it, true) },
+            covers = coverIds.take(4).mapNotNull { coverArt(it, forIcon || coverIds.size > 1) },
+        )
+    val own =
+        artist.coverArt?.let { coverId ->
+            coverArt(coverId, forIcon)?.let { image ->
+                ArtistArt(
+                    image = image,
+                    thumbnail = if (forIcon) image else coverArt(coverId, true),
+                    fallback = grid,
+                )
+            }
+        }
+    return artist.artistImageUrl
+        ?.let { artistImage(artist.id, it) }
+        ?.let { ArtistArt(image = it, thumbnail = it, fallback = own ?: grid) }
+        ?: own
+        ?: grid
+}
+
+@Composable
+fun ArtistIcon(
+    artist: Artist,
+    art: ArtistArt,
+    modifier: Modifier = Modifier,
+) {
+    var shown by remember(artist.id, art) { mutableStateOf(art) }
+    val showFallback = {
+        shown.fallback?.let { shown = it } ?: run { shown = shown.copy(image = null) }
+    }
+    when {
+        shown.image != null -> {
+            CoverArt(
+                ref = shown.image,
+                name = artist.name,
+                modifier = modifier,
+                onError = showFallback,
+            )
+        }
+
+        shown.covers.size >= 2 -> {
+            ArtistArtGrid(covers = shown.covers, name = artist.name, modifier = modifier)
+        }
+
+        else -> {
+            CoverArt(ref = shown.covers.firstOrNull(), name = artist.name, modifier = modifier)
+        }
+    }
+}
+
+@Composable
+fun ArtistHeroArt(
+    art: ArtistArt,
+    name: String,
+    modifier: Modifier = Modifier,
+) {
+    var shown by remember(art) { mutableStateOf(art) }
+    val showFallback = {
+        shown.fallback?.let { shown = it } ?: run { shown = shown.copy(image = null) }
+    }
+    when {
+        shown.image != null -> {
+            CoverArt(
+                ref = shown.image,
+                name = name,
+                thumbnailRef = shown.thumbnail,
+                showPlaceholder = false,
+                modifier = modifier,
+                onError = showFallback,
+            )
+        }
+
+        shown.covers.isNotEmpty() -> {
+            ArtistArtGrid(
+                covers = shown.covers,
+                name = name,
+                singleThumbnail = shown.thumbnail,
+                modifier = modifier,
+            )
+        }
+
+        else -> {
+            CoverArt(ref = null, name = name, modifier = modifier)
+        }
+    }
+}
+
+@Composable
+fun ArtistArtGrid(
+    covers: List<CoverArtRef>,
+    name: String,
+    modifier: Modifier = Modifier,
+    singleThumbnail: CoverArtRef? = null,
+) {
+    when {
+        covers.size >= 4 -> {
+            Column(modifier) {
+                Row(Modifier.weight(1f).fillMaxWidth()) {
+                    covers.take(2).forEach { ref ->
+                        CoverArt(ref = ref, name = name, modifier = Modifier.weight(1f).fillMaxHeight())
+                    }
+                }
+                Row(Modifier.weight(1f).fillMaxWidth()) {
+                    covers.drop(2).take(2).forEach { ref ->
+                        CoverArt(ref = ref, name = name, modifier = Modifier.weight(1f).fillMaxHeight())
+                    }
+                }
+            }
+        }
+
+        covers.size == 3 -> {
+            Box(modifier) {
+                covers.forEachIndexed { index, ref ->
+                    CoverArt(
+                        ref = ref,
+                        name = name,
+                        modifier = Modifier.matchParentSize().clip(YRegionShape(index)),
+                    )
+                }
+            }
+        }
+
+        covers.size == 2 -> {
+            Row(modifier) {
+                covers.forEach { ref ->
+                    CoverArt(ref = ref, name = name, modifier = Modifier.weight(1f).fillMaxHeight())
+                }
+            }
+        }
+
+        covers.size == 1 -> {
+            CoverArt(
+                ref = covers.first(),
+                name = name,
+                thumbnailRef = singleThumbnail,
+                showPlaceholder = false,
+                modifier = modifier,
+            )
+        }
+    }
+}
+
+private class YRegionShape(
+    private val region: Int,
+) : Shape {
+    override fun createOutline(
+        size: Size,
+        layoutDirection: LayoutDirection,
+        density: Density,
+    ): Outline {
+        val center = Offset(size.width / 2f, size.height / 2f)
+        val left = rayPoint(size, 150.0)
+        val right = rayPoint(size, 30.0)
+        val top = Offset(size.width / 2f, 0f)
+        val path = Path()
+        when (region) {
+            0 -> {
+                path.moveTo(center.x, center.y)
+                path.lineTo(right.x, right.y)
+                addClockwise(path, size, right, left)
+            }
+
+            1 -> {
+                path.moveTo(center.x, center.y)
+                path.lineTo(left.x, left.y)
+                addClockwise(path, size, left, top)
+            }
+
+            else -> {
+                path.moveTo(center.x, center.y)
+                path.lineTo(top.x, top.y)
+                addClockwise(path, size, top, right)
+            }
+        }
+        path.lineTo(center.x, center.y)
+        path.close()
+        return Outline.Generic(path)
+    }
+}
+
+private fun rayPoint(
+    size: Size,
+    angleDegrees: Double,
+): Offset {
+    val cx = size.width / 2.0
+    val cy = size.height / 2.0
+    val radians = angleDegrees * PI / 180.0
+    val dx = cos(radians)
+    val dy = sin(radians)
+    val tx =
+        when {
+            dx > 0 -> (size.width - cx) / dx
+            dx < 0 -> -cx / dx
+            else -> Double.POSITIVE_INFINITY
+        }
+    val ty =
+        when {
+            dy > 0 -> (size.height - cy) / dy
+            dy < 0 -> -cy / dy
+            else -> Double.POSITIVE_INFINITY
+        }
+    val t = min(tx, ty)
+    return Offset((cx + dx * t).toFloat(), (cy + dy * t).toFloat())
+}
+
+private fun addClockwise(
+    path: Path,
+    size: Size,
+    from: Offset,
+    to: Offset,
+) {
+    val w = size.width
+    val h = size.height
+    val corners =
+        listOf(
+            Offset(0f, 0f),
+            Offset(w, 0f),
+            Offset(w, h),
+            Offset(0f, h),
+        )
+    val fromParam = perimeterParam(from, size)
+    val toParam = perimeterParam(to, size)
+    if (fromParam <= toParam) {
+        corners
+            .filter { perimeterParam(it, size) > fromParam && perimeterParam(it, size) < toParam }
+            .forEach { path.lineTo(it.x, it.y) }
+    } else {
+        corners
+            .filter { perimeterParam(it, size) > fromParam }
+            .forEach { path.lineTo(it.x, it.y) }
+        corners
+            .filter { perimeterParam(it, size) < toParam }
+            .forEach { path.lineTo(it.x, it.y) }
+    }
+    path.lineTo(to.x, to.y)
+}
+
+private fun perimeterParam(
+    point: Offset,
+    size: Size,
+): Float {
+    val w = size.width
+    val h = size.height
+    return when {
+        point.y <= 0f -> point.x
+        point.x >= w -> w + point.y
+        point.y >= h -> w + h + (w - point.x)
+        else -> 2f * w + h + (h - point.y)
+    }
+}

app/src/main/kotlin/com/subtracks/ui/components/Components.kt

@@ -85,12 +85,15 @@ fun CoverArt(
     square: Boolean = true,
     elevation: Dp = 0.dp,
     colorFilter: ColorFilter? = null,
+    onError: (() -> Unit)? = null,
 ) {
     val context = LocalPlatformContext.current
     val refKey = ref?.cacheKey
     val thumbnailKey = thumbnailRef?.cacheKey
+    val hasThumbnailFallback = thumbnailRef != null && thumbnailRef != ref
     var failed by remember(refKey, thumbnailKey) { mutableStateOf(false) }
     var thumbnailLoaded by remember(refKey, thumbnailKey) { mutableStateOf(false) }
+    var thumbnailFailed by remember(refKey, thumbnailKey) { mutableStateOf(false) }
     var thumbnailRatio by remember(refKey, thumbnailKey) { mutableStateOf(thumbnailKey?.let(ArtworkRatioCache::get)) }
     val letterScheme =
         if (showPlaceholder || (failed && !thumbnailLoaded)) {
@@ -115,6 +118,10 @@ fun CoverArt(
                 thumbnailLoaded = thumbnailLoaded,
                 onThumbnailLoaded = { thumbnailLoaded = true },
                 onThumbnailRatio = { thumbnailRatio = it },
+                onThumbnailError = {
+                    thumbnailFailed = true
+                    if (failed) onError?.invoke()
+                },
                 contentScale = ContentScale.Crop,
                 colorFilter = colorFilter,
                 placeholderContentColor = letterScheme?.onPrimaryContainer,
@@ -131,7 +138,10 @@ fun CoverArt(
                                 .ratioOrNull()
                                 ?.let { ArtworkRatioCache.put(ref.cacheKey, it) }
                         },
-                        onError = { failed = true },
+                        onError = {
+                            failed = true
+                            if (!hasThumbnailFallback || thumbnailFailed) onError?.invoke()
+                        },
                         modifier = Modifier.fillMaxSize(),
                     )
                 }
@@ -160,7 +170,10 @@ fun CoverArt(
                                 )
                             }
                         },
-                    onError = { failed = true },
+                    onError = {
+                        failed = true
+                        if (!hasThumbnailFallback || thumbnailFailed) onError?.invoke()
+                    },
                     contentScale = ContentScale.Fit,
                     filterQuality = FilterQuality.High,
                 )
@@ -179,6 +192,10 @@ fun CoverArt(
                     thumbnailLoaded = thumbnailLoaded,
                     onThumbnailLoaded = { thumbnailLoaded = true },
                     onThumbnailRatio = { thumbnailRatio = it },
+                    onThumbnailError = {
+                        thumbnailFailed = true
+                        if (failed) onError?.invoke()
+                    },
                     contentScale = ContentScale.Fit,
                     colorFilter = colorFilter,
                     placeholderContentColor = letterScheme?.onPrimaryContainer,
@@ -208,6 +225,7 @@ private fun BoxScope.CoverArtContent(
     thumbnailLoaded: Boolean,
     onThumbnailLoaded: () -> Unit,
     onThumbnailRatio: (Float) -> Unit,
+    onThumbnailError: () -> Unit,
     contentScale: ContentScale,
     colorFilter: ColorFilter?,
     placeholderContentColor: Color?,
@@ -246,6 +264,7 @@ private fun BoxScope.CoverArtContent(
                         ArtworkRatioCache.put(thumbnailRef.cacheKey, it)
                     }
             },
+            onError = { onThumbnailError() },
             modifier = Modifier.fillMaxSize(),
         )
     }

app/src/main/kotlin/com/subtracks/ui/components/DeleteDownloadsDialog.kt

@@ -6,10 +6,21 @@ import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.State
+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.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import com.subtracks.R
+import com.subtracks.data.model.BulkDownloadAction
 import com.subtracks.data.model.DownloadList
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.launch
 
 data class PendingDownloadDelete(
     val name: String,
@@ -18,6 +29,70 @@ data class PendingDownloadDelete(
     val bytes: Long,
 )
 
+class PendingDownloadDeleteController internal constructor(
+    private val scope: CoroutineScope,
+    private val downloadedBytes: State<suspend (DownloadList, String) -> Long>,
+) {
+    var pending by mutableStateOf<PendingDownloadDelete?>(null)
+        private set
+
+    fun onAction(
+        target: MenuTarget,
+        action: BulkDownloadAction,
+        onAction: (DownloadList, String, BulkDownloadAction) -> Unit,
+    ) {
+        val (list, refId) = target.bulkRef() ?: return
+        onAction(target.title, list, refId, action, onAction)
+    }
+
+    fun onAction(
+        name: String,
+        list: DownloadList,
+        refId: String,
+        action: BulkDownloadAction,
+        onAction: (DownloadList, String, BulkDownloadAction) -> Unit,
+    ) {
+        if (action == BulkDownloadAction.Delete) {
+            scope.launch {
+                pending = PendingDownloadDelete(name, list, refId, downloadedBytes.value(list, refId))
+            }
+        } else {
+            onAction(list, refId, action)
+        }
+    }
+
+    fun dismiss() {
+        pending = null
+    }
+}
+
+@Composable
+fun rememberPendingDownloadDelete(
+    dismissals: Flow<Unit>,
+    downloadedBytes: suspend (DownloadList, String) -> Long,
+): PendingDownloadDeleteController {
+    val scope = rememberCoroutineScope()
+    val currentDownloadedBytes = rememberUpdatedState(downloadedBytes)
+    val controller = remember(scope) { PendingDownloadDeleteController(scope, currentDownloadedBytes) }
+    DismissOnRequest(dismissals, controller::dismiss)
+    return controller
+}
+
+@Composable
+fun PendingDownloadDeleteConfirmation(
+    controller: PendingDownloadDeleteController,
+    onConfirm: (PendingDownloadDelete) -> Unit,
+) {
+    controller.pending?.let { pending ->
+        DeleteDownloadsDialog(
+            name = pending.name,
+            bytes = pending.bytes,
+            onConfirm = { onConfirm(pending) },
+            onDismiss = controller::dismiss,
+        )
+    }
+}
+
 @Composable
 fun DeleteDownloadsDialog(
     name: String,

app/src/main/kotlin/com/subtracks/ui/components/HeroDetailScaffold.kt

@@ -24,6 +24,7 @@ import androidx.compose.foundation.layout.statusBars
 import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.LazyListScope
+import androidx.compose.foundation.lazy.LazyListState
 import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.foundation.shape.RoundedCornerShape
@@ -47,12 +48,17 @@ import androidx.compose.material3.TopAppBar
 import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
+import androidx.compose.runtime.snapshotFlow
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
@@ -98,12 +104,13 @@ fun HeroDetailScaffold(
     header: @Composable (controlsModifier: Modifier, topInset: Dp) -> Unit,
     content: LazyListScope.(rowModifier: Modifier) -> Unit,
     modifier: Modifier = Modifier,
+    contentReady: Boolean = true,
 ) {
     val effectiveArtwork = artwork ?: baseArtworkColors()
     CompositionLocalProvider(LocalContentColor provides MaterialTheme.colorScheme.onBackground) {
         ArtworkTheme(effectiveArtwork) {
             BoxWithConstraints(modifier.fillMaxSize().background(MaterialTheme.colorScheme.background)) {
-                val listState = rememberLazyListState()
+                val listState = rememberRestorableLazyListState(contentReady)
                 val scope = rememberCoroutineScope()
                 val fill = rememberViewportFill(listState)
                 val density = LocalDensity.current
@@ -114,9 +121,9 @@ fun HeroDetailScaffold(
                 val barHeightPx = statusBarTop + with(density) { TopAppBarDefaults.TopAppBarExpandedHeight.toPx() }
                 val fadeDistancePx = with(density) { FADE_DISTANCE_DP.dp.toPx() }
 
-                var headerHeightPx by remember { mutableFloatStateOf(0f) }
+                var headerHeightPx by rememberSaveable { mutableFloatStateOf(0f) }
-                var rowHeightPx by remember { mutableFloatStateOf(0f) }
+                var rowHeightPx by rememberSaveable { mutableFloatStateOf(0f) }
-                var controlsTopPx by remember { mutableFloatStateOf(0f) }
+                var controlsTopPx by rememberSaveable { mutableFloatStateOf(0f) }
                 val scrollPx by remember {
                     derivedStateOf {
                         val index = listState.firstVisibleItemIndex
@@ -206,6 +213,31 @@ fun HeroDetailScaffold(
     }
 }
 
+@Composable
+private fun rememberRestorableLazyListState(contentReady: Boolean): LazyListState {
+    val state = rememberLazyListState()
+    var index by rememberSaveable { mutableIntStateOf(state.firstVisibleItemIndex) }
+    var offset by rememberSaveable { mutableIntStateOf(state.firstVisibleItemScrollOffset) }
+    var pending by remember { mutableStateOf(index > 0 || offset > 0) }
+    LaunchedEffect(contentReady) {
+        if (contentReady && pending) {
+            val target = index.coerceAtMost((state.layoutInfo.totalItemsCount - 1).coerceAtLeast(0))
+            state.scrollToItem(target, offset)
+            pending = false
+        }
+    }
+    LaunchedEffect(state) {
+        snapshotFlow { state.firstVisibleItemIndex to state.firstVisibleItemScrollOffset }
+            .collect { (currentIndex, currentOffset) ->
+                if (!pending) {
+                    index = currentIndex
+                    offset = currentOffset
+                }
+            }
+    }
+    return state
+}
+
 @Composable
 private fun HeroSubtitle(
     text: String,
@@ -291,7 +323,11 @@ fun HeroHeader(
                 modifier =
                     Modifier
                         .heightIn(min = 32.dp)
-                        .clickable(onClickLabel = stringResource(R.string.open_artist)) { onSubtitleClick() },
+                        .clickable(
+                            interactionSource = remember { MutableInteractionSource() },
+                            indication = null,
+                            onClickLabel = stringResource(R.string.open_artist),
+                        ) { onSubtitleClick() },
                 contentAlignment = Alignment.TopCenter,
             ) {
                 HeroSubtitle(subtitle, Modifier.padding(top = 4.dp))

app/src/main/kotlin/com/subtracks/ui/components/ItemContextMenu.kt

@@ -15,6 +15,7 @@ import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.foundation.verticalScroll
 import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.rounded.KeyboardArrowRight
 import androidx.compose.material.icons.automirrored.rounded.QueueMusic
 import androidx.compose.material.icons.rounded.Album
 import androidx.compose.material.icons.rounded.Cancel
@@ -50,6 +51,7 @@ import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import com.subtracks.R
+import com.subtracks.data.model.ArtistRef
 import com.subtracks.data.model.BulkDownloadAction
 import com.subtracks.data.model.CoverArtRef
 import com.subtracks.data.model.DownloadList
@@ -197,7 +199,8 @@ fun ItemContextMenu(
     target: MenuTarget,
     actions: ItemActions,
     onDismiss: () -> Unit,
-    onInfo: ((SongModel) -> Unit)? = null,
+    onInfo: ((MenuTarget) -> Unit)? = null,
+    onChooseArtists: ((List<ArtistRef>) -> Unit)? = null,
 ) {
     val sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = true)
     val scope = rememberCoroutineScope()
@@ -210,6 +213,11 @@ fun ItemContextMenu(
         }
     }
 
+    fun replaceWith(after: () -> Unit) {
+        onDismiss()
+        after()
+    }
+
     val queueRef = target.queueRef()
 
     @Composable
@@ -256,18 +264,9 @@ fun ItemContextMenu(
                             }
                         }
                     }
-                    target.song.artistRefs.forEach { artist ->
+                    ArtistItems(target.song.artistRefs, actions, onChooseArtists, ::dismiss, ::replaceWith)
-                        actions.viewArtist?.let { view ->
-                            MenuItem(
-                                Icons.Rounded.Person,
-                                artist.name.takeIf { it.isNotBlank() } ?: stringResource(R.string.resources_filter_artist),
-                            ) {
-                                dismiss { view(artist.id) }
-                            }
-                        }
-                    }
                     onInfo?.let { info ->
-                        MenuItem(Icons.Rounded.Info, stringResource(R.string.info)) { dismiss { info(target.song) } }
+                        MenuItem(Icons.Rounded.Info, stringResource(R.string.info)) { dismiss { info(target) } }
                     }
                 }
 
@@ -279,15 +278,9 @@ fun ItemContextMenu(
                         onSet = { starring -> actions.setStar(StarType.Album, target.album.id, starring) },
                         onDismiss = { dismiss() },
                     )
-                    target.album.artistRefs.forEach { artist ->
+                    ArtistItems(target.album.artistRefs, actions, onChooseArtists, ::dismiss, ::replaceWith)
-                        actions.viewArtist?.let { view ->
+                    onInfo?.let { info ->
-                            MenuItem(
+                        MenuItem(Icons.Rounded.Info, stringResource(R.string.info)) { dismiss { info(target) } }
-                                Icons.Rounded.Person,
-                                artist.name.takeIf { it.isNotBlank() } ?: stringResource(R.string.resources_filter_artist),
-                            ) {
-                                dismiss { view(artist.id) }
-                            }
-                        }
                     }
                 }
 
@@ -298,11 +291,17 @@ fun ItemContextMenu(
                         onSet = { starring -> actions.setStar(StarType.Artist, target.artist.id, starring) },
                         onDismiss = { dismiss() },
                     )
+                    onInfo?.let { info ->
+                        MenuItem(Icons.Rounded.Info, stringResource(R.string.info)) { dismiss { info(target) } }
+                    }
                 }
 
                 is MenuTarget.Playlist -> {
                     queueItems()
                     BulkDownloadItem(target, actions, ::dismiss)
+                    onInfo?.let { info ->
+                        MenuItem(Icons.Rounded.Info, stringResource(R.string.info)) { dismiss { info(target) } }
+                    }
                 }
             }
             Spacer(Modifier.height(16.dp))
@@ -342,6 +341,55 @@ private fun MenuHeader(target: MenuTarget) {
     }
 }
 
+@Composable
+private fun ArtistItems(
+    artists: List<ArtistRef>,
+    actions: ItemActions,
+    onChooseArtists: ((List<ArtistRef>) -> Unit)?,
+    dismiss: (() -> Unit) -> Unit,
+    replaceWith: (() -> Unit) -> Unit,
+) {
+    val view = actions.viewArtist ?: return
+    val distinct = artists.distinctBy { it.id }
+    when (distinct.size) {
+        0 -> {
+            Unit
+        }
+
+        1 -> {
+            val artist = distinct.first()
+            MenuItem(
+                Icons.Rounded.Person,
+                artist.name.takeIf { it.isNotBlank() } ?: stringResource(R.string.resources_filter_artist),
+            ) {
+                dismiss { view(artist.id) }
+            }
+        }
+
+        else -> {
+            if (onChooseArtists == null) {
+                distinct.forEach { artist ->
+                    MenuItem(
+                        Icons.Rounded.Person,
+                        artist.name.takeIf { it.isNotBlank() } ?: stringResource(R.string.resources_filter_artist),
+                    ) {
+                        dismiss { view(artist.id) }
+                    }
+                }
+            } else {
+                val fallback = stringResource(R.string.resources_filter_artist)
+                MenuItem(
+                    Icons.Rounded.Person,
+                    distinct.joinToString(" \u00B7 ") { it.name.ifBlank { fallback } },
+                    trailing = { Icon(Icons.AutoMirrored.Rounded.KeyboardArrowRight, contentDescription = null) },
+                ) {
+                    replaceWith { onChooseArtists(distinct) }
+                }
+            }
+        }
+    }
+}
+
 @Composable
 private fun DownloadItem(
     download: SongDownload?,
@@ -439,11 +487,19 @@ private fun MenuItem(
     icon: ImageVector,
     label: String,
     tint: Color? = null,
+    trailing: (@Composable () -> Unit)? = null,
     onClick: () -> Unit,
 ) {
     ListItem(
-        headlineContent = { Text(label) },
+        headlineContent = {
+            Text(
+                text = label,
+                maxLines = 1,
+                overflow = TextOverflow.Ellipsis,
+            )
+        },
         leadingContent = { Icon(icon, contentDescription = null, tint = tint ?: LocalContentColor.current) },
+        trailingContent = trailing,
         colors = ListItemDefaults.colors(containerColor = Color.Transparent),
         modifier = Modifier.clickable(onClick = onClick),
     )

app/src/main/kotlin/com/subtracks/ui/components/LibraryInfoDialog.kt

@@ -0,0 +1,160 @@
+package com.subtracks.ui.components
+
+import android.content.Context
+import android.text.format.DateUtils
+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.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import com.subtracks.R
+import com.subtracks.data.model.Album
+import com.subtracks.data.model.Artist
+import com.subtracks.data.model.ArtistRef
+import com.subtracks.data.model.ListDownloadStatus
+import com.subtracks.data.model.Playlist
+
+private const val ARTIST_SEPARATOR = " \u00B7 "
+
+@Composable
+fun AlbumInfoDialog(
+    album: Album,
+    download: ListDownloadStatus?,
+    onDismiss: () -> Unit,
+) {
+    val context = LocalContext.current
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(stringResource(R.string.info)) },
+        text = {
+            Column(verticalArrangement = Arrangement.spacedBy(6.dp)) {
+                InfoRow(stringResource(R.string.resources_sort_by_title), album.name)
+                InfoRow(stringResource(R.string.info_sort_title), album.sortName.takeIfDifferentFrom(album.name))
+                InfoRow(stringResource(R.string.info_album_artists), album.artistRefs.names())
+                InfoRow(stringResource(R.string.info_album_artist_sort), album.albumArtistSort.takeIfDifferentFrom(album.albumArtist))
+                InfoRow(stringResource(R.string.resources_sort_by_year), album.year?.takeIf { it > 0 }?.toString())
+                InfoRow(stringResource(R.string.resources_filter_genre), album.genre)
+                InfoRow(stringResource(R.string.info_songs), album.songCount.takeIf { it > 0 }?.toString())
+                download?.takeIf { it.total > 0 }?.let { status ->
+                    InfoRow(
+                        stringResource(R.string.status_downloaded),
+                        stringResource(R.string.info_downloaded_count, status.downloaded, status.total),
+                    )
+                }
+                InfoRow(stringResource(R.string.info_added), album.created.takeIf { it > 0 }?.let { formatDate(context, it) })
+                InfoRow(stringResource(R.string.info_last_played), album.played?.let { formatDate(context, it) })
+                InfoRow(stringResource(R.string.info_plays), album.playCount.takeIf { it > 0 }?.toString())
+                InfoRow(stringResource(R.string.info_starred), if (album.starred != null) stringResource(R.string.info_yes) else null)
+            }
+        },
+        confirmButton = { TextButton(onClick = onDismiss) { Text(stringResource(R.string.info_close)) } },
+    )
+}
+
+@Composable
+fun ArtistInfoDialog(
+    artist: Artist,
+    onDismiss: () -> Unit,
+) {
+    val context = LocalContext.current
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(stringResource(R.string.info)) },
+        text = {
+            Column(verticalArrangement = Arrangement.spacedBy(6.dp)) {
+                InfoRow(stringResource(R.string.resources_filter_artist), artist.name)
+                InfoRow(stringResource(R.string.info_sort_name), artist.sortName.takeIfDifferentFrom(artist.name))
+                InfoRow(stringResource(R.string.info_albums), artist.albumCount.takeIf { it > 0 }?.toString())
+                InfoRow(stringResource(R.string.info_songs), artist.songCount.takeIf { it > 0 }?.toString())
+                InfoRow(stringResource(R.string.info_plays), artist.playCount.takeIf { it > 0 }?.toString())
+                InfoRow(stringResource(R.string.info_last_played), artist.played?.let { formatDate(context, it) })
+                InfoRow(stringResource(R.string.info_starred), if (artist.starred != null) stringResource(R.string.info_yes) else null)
+            }
+        },
+        confirmButton = { TextButton(onClick = onDismiss) { Text(stringResource(R.string.info_close)) } },
+    )
+}
+
+@Composable
+fun PlaylistInfoDialog(
+    playlist: Playlist,
+    onDismiss: () -> Unit,
+) {
+    val context = LocalContext.current
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(stringResource(R.string.info)) },
+        text = {
+            Column(verticalArrangement = Arrangement.spacedBy(6.dp)) {
+                InfoRow(stringResource(R.string.resources_sort_by_title), playlist.name)
+                InfoRow(stringResource(R.string.info_owner), playlist.owner)
+                InfoRow(stringResource(R.string.info_shared), if (playlist.shared) stringResource(R.string.info_yes) else null)
+                InfoRow(stringResource(R.string.info_songs), playlist.songCount.takeIf { it > 0 }?.toString())
+                InfoRow(stringResource(R.string.info_length), playlist.duration.takeIf { it > 0 }?.let(DateUtils::formatElapsedTime))
+                InfoRow(stringResource(R.string.info_created), playlist.created.takeIf { it > 0 }?.let { formatDate(context, it) })
+                InfoRow(stringResource(R.string.info_updated), playlist.changed.takeIf { it > 0 }?.let { formatDate(context, it) })
+            }
+        },
+        confirmButton = { TextButton(onClick = onDismiss) { Text(stringResource(R.string.info_close)) } },
+    )
+}
+
+internal fun String?.takeIfDifferentFrom(regular: String?): String? =
+    this?.trim()?.takeIf { value -> value.isNotEmpty() && !value.equals(regular?.trim(), ignoreCase = true) }
+
+@Composable
+internal fun InfoRow(
+    label: String,
+    value: String?,
+) {
+    if (value.isNullOrBlank()) return
+    Row(
+        modifier = Modifier.fillMaxWidth().padding(vertical = 2.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Text(
+            text = label,
+            style = MaterialTheme.typography.bodySmall,
+            color = MaterialTheme.colorScheme.primary,
+            modifier = Modifier.width(INFO_LABEL_WIDTH),
+        )
+        Spacer(Modifier.width(INFO_LABEL_GAP))
+        Text(
+            text = value,
+            style = MaterialTheme.typography.bodyMedium,
+            modifier = Modifier.weight(1f),
+        )
+    }
+}
+
+private fun List<ArtistRef>.names(): String? =
+    map { it.name }
+        .filter { it.isNotBlank() }
+        .distinct()
+        .joinToString(ARTIST_SEPARATOR)
+        .takeIf { it.isNotEmpty() }
+
+private fun formatDate(
+    context: Context,
+    epochSeconds: Long,
+): String =
+    DateUtils.formatDateTime(
+        context,
+        epochSeconds * 1000,
+        DateUtils.FORMAT_SHOW_DATE or DateUtils.FORMAT_SHOW_YEAR,
+    )
+
+private val INFO_LABEL_WIDTH = 100.dp
+private val INFO_LABEL_GAP = 12.dp

app/src/main/kotlin/com/subtracks/ui/components/SongArtist.kt

@@ -1,12 +1,28 @@
 package com.subtracks.ui.components
 
+import com.subtracks.data.model.ArtistRef
 import com.subtracks.data.model.Song
 
 private const val ARTIST_SEPARATOR = " \u00B7 "
 
-internal fun Song.artistSubtitle(): String? {
+internal fun Song.artistSubtitle(): String? = artistSubtitle(artist, artists)
+
+internal fun Song.artistNames(): List<String> = artistNames(artist, artists)
+
+internal fun artistNames(
+    artist: String?,
+    artists: List<ArtistRef>,
+): List<String> {
     val names = artists.map { it.name }.filter { it.isNotBlank() }.distinct()
-    if (names.isEmpty()) return artist?.takeIf { it.isNotBlank() }
+    return names.ifEmpty { listOfNotNull(artist?.takeIf { it.isNotBlank() }) }
+}
+
+internal fun artistSubtitle(
+    artist: String?,
+    artists: List<ArtistRef>,
+): String? {
+    val names = artistNames(artist, artists)
+    if (names.isEmpty()) return null
     val primary = artist?.takeIf { it in names }
     return buildList {
         primary?.let(::add)

app/src/main/kotlin/com/subtracks/ui/components/SongInfoDialog.kt

@@ -4,12 +4,7 @@ import android.text.format.DateUtils
 import android.text.format.Formatter
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.width
 import androidx.compose.material3.AlertDialog
-import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
@@ -18,8 +13,6 @@ 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.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
@@ -53,8 +46,20 @@ fun SongInfoDialog(
         title = { Text(stringResource(R.string.info)) },
         text = {
             Column(verticalArrangement = Arrangement.spacedBy(6.dp)) {
+                val multipleArtists = song.artistNames().size > 1
+                val regularArtistSort = song.artist?.takeIf { it.isNotBlank() } ?: song.artistRefs.firstOrNull()?.name
                 InfoRow(stringResource(R.string.resources_sort_by_title), song.title)
-                InfoRow(stringResource(R.string.resources_filter_artist), song.artistSubtitle())
+                InfoRow(stringResource(R.string.info_sort_title), song.sortName.takeIfDifferentFrom(song.title))
+                InfoRow(
+                    stringResource(
+                        if (multipleArtists) R.string.info_artists else R.string.resources_filter_artist,
+                    ),
+                    song.artistSubtitle(),
+                )
+                InfoRow(
+                    stringResource(if (multipleArtists) R.string.info_artists_sort else R.string.info_artist_sort),
+                    song.artistSort.takeIfDifferentFrom(regularArtistSort),
+                )
                 InfoRow(stringResource(R.string.resources_filter_album), song.album)
                 InfoRow(stringResource(R.string.info_duration), song.duration?.let(DateUtils::formatElapsedTime))
                 InfoRow(
@@ -92,32 +97,6 @@ fun SongInfoDialog(
     )
 }
 
-@Composable
-private fun InfoRow(
-    label: String,
-    value: String?,
-) {
-    if (value.isNullOrBlank()) return
-    Row(
-        modifier = Modifier.fillMaxWidth().padding(vertical = 2.dp),
-        verticalAlignment = Alignment.CenterVertically,
-    ) {
-        Text(
-            text = label,
-            style = MaterialTheme.typography.bodySmall,
-            color = MaterialTheme.colorScheme.primary,
-            modifier = Modifier.width(INFO_LABEL_WIDTH),
-        )
-        Text(
-            text = value,
-            style = MaterialTheme.typography.bodyMedium,
-            modifier = Modifier.weight(1f),
-        )
-    }
-}
-
-private val INFO_LABEL_WIDTH = 80.dp
-
 @Composable
 private fun downloadStatus(status: DownloadStatus): String =
     when (status) {

app/src/main/kotlin/com/subtracks/ui/home/HomeListScreen.kt

@@ -57,6 +57,8 @@ import com.subtracks.data.model.Playlist
 import com.subtracks.data.model.Song
 import com.subtracks.data.source.StarType
 import com.subtracks.playback.PlaybackController
+import com.subtracks.ui.components.ArtistArt
+import com.subtracks.ui.components.ArtistIcon
 import com.subtracks.ui.components.ContextMenuHost
 import com.subtracks.ui.components.CoverArt
 import com.subtracks.ui.components.ItemActions
@@ -108,6 +110,7 @@ fun HomeListRoute(
         genres = genres,
         decades = decades,
         coverArt = viewModel::coverArt,
+        artistArt = { viewModel.artistArt(it) },
         playingSongId = playback.item?.id,
         onBack = onBack,
         onAlbumClick = onAlbumClick,
@@ -133,6 +136,7 @@ fun HomeListScreen(
     genres: List<String> = emptyList(),
     decades: List<Long> = emptyList(),
     coverArt: (String?, Boolean) -> CoverArtRef? = { _, _ -> null },
+    artistArt: (Artist) -> ArtistArt = { ArtistArt() },
     playingSongId: String? = null,
     onBack: () -> Unit = {},
     onAlbumClick: (Album) -> Unit = {},
@@ -191,7 +195,7 @@ fun HomeListScreen(
                 OfflineListKind.Artists -> {
                     ArtistsList(
                         artists = artists,
-                        coverArt = coverArt,
+                        artistArt = artistArt,
                         info = { artistListInfo(request, it, now, resources) },
                         onArtistClick = onArtistClick,
                         onLongClick = onLongClick,
@@ -245,7 +249,7 @@ fun HomeListScreen(
                 HomeSection.RecentlyPlayedArtists, HomeSection.MostPlayedArtists -> {
                     ArtistsList(
                         artists = artists,
-                        coverArt = coverArt,
+                        artistArt = artistArt,
                         info = { artistListInfo(request, it, now, resources) },
                         onArtistClick = onArtistClick,
                         onLongClick = onLongClick,
@@ -443,7 +447,7 @@ internal fun AlbumListRow(
 @Composable
 private fun ArtistsList(
     artists: LazyPagingItems<Artist>,
-    coverArt: (String?, Boolean) -> CoverArtRef?,
+    artistArt: (Artist) -> ArtistArt,
     info: (Artist) -> String?,
     onArtistClick: (Artist) -> Unit,
     onLongClick: (MenuTarget) -> Unit,
@@ -460,12 +464,13 @@ private fun ArtistsList(
         items(count = artists.itemCount, key = artists.itemKey { it.id }) { index ->
             val artist = artists[index]
             if (artist != null) {
+                val art = artistArt(artist)
                 ArtistListRow(
                     artist = artist,
-                    coverArt = coverArt,
+                    art = art,
                     info = info(artist),
                     onClick = { onArtistClick(artist) },
-                    onLongClick = { onLongClick(MenuTarget.Artist(artist, coverArt(artist.coverArt, true))) },
+                    onLongClick = { onLongClick(MenuTarget.Artist(artist, art.primary)) },
                 )
             }
         }
@@ -475,7 +480,7 @@ private fun ArtistsList(
 @Composable
 internal fun ArtistListRow(
     artist: Artist,
-    coverArt: (String?, Boolean) -> CoverArtRef?,
+    art: ArtistArt,
     info: String?,
     onClick: () -> Unit,
     onLongClick: () -> Unit,
@@ -488,9 +493,9 @@ internal fun ArtistListRow(
                 .padding(horizontal = 16.dp, vertical = 8.dp),
         verticalAlignment = Alignment.CenterVertically,
     ) {
-        CoverArt(
+        ArtistIcon(
-            ref = coverArt(artist.coverArt, true),
+            artist = artist,
-            name = artist.name,
+            art = art,
             modifier = Modifier.size(ALBUM_ROW_COVER).clip(CircleShape),
         )
         Spacer(Modifier.width(12.dp))

app/src/main/kotlin/com/subtracks/ui/home/HomeListViewModel.kt

@@ -16,6 +16,8 @@ import com.subtracks.data.prefs.PlaylistSort
 import com.subtracks.data.repo.LibraryRepository
 import com.subtracks.data.repo.SourceRepository
 import com.subtracks.playback.PlaybackController
+import com.subtracks.ui.components.ArtistArt
+import com.subtracks.ui.components.artistArt
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.SharingStarted
@@ -156,6 +158,11 @@ class HomeListViewModel(
         thumbnail: Boolean,
     ): CoverArtRef? = sourceRepository.coverArt(coverArt, thumbnail)
 
+    fun artistArt(
+        artist: Artist,
+        forIcon: Boolean = true,
+    ): ArtistArt = sourceRepository.artistArt(artist, forIcon)
+
     fun play(song: Song) {
         val genre = request.genre
         when {

app/src/main/kotlin/com/subtracks/ui/home/HomeScreen.kt

@@ -72,6 +72,8 @@ import com.subtracks.data.model.Playlist
 import com.subtracks.data.model.Song
 import com.subtracks.data.source.StarType
 import com.subtracks.playback.PlaybackController
+import com.subtracks.ui.components.ArtistArt
+import com.subtracks.ui.components.ArtistIcon
 import com.subtracks.ui.components.ContextMenuHost
 import com.subtracks.ui.components.CoverArt
 import com.subtracks.ui.components.EmptyState
@@ -137,6 +139,7 @@ fun HomeRoute(
             playlists = viewModel.downloadedPlaylists.collectAsLazyPagingItems(),
             songs = viewModel.downloadedSongs.collectAsStateWithLifecycle(initialValue = emptyList()).value,
             coverArt = viewModel::coverArt,
+            artistArt = { viewModel.artistArt(it) },
             playingSongId = playback.item?.id,
             topInset = topInset,
             bottomInset = bottomInset,
@@ -152,6 +155,7 @@ fun HomeRoute(
         HomeScreen(
             feed = feed,
             coverArt = viewModel::coverArt,
+            artistArt = { viewModel.artistArt(it) },
             playingSongId = playback.item?.id,
             topInset = topInset,
             bottomInset = bottomInset,
@@ -173,6 +177,7 @@ fun HomeScreen(
     coverArt: (String?, Boolean) -> CoverArtRef?,
     playingSongId: String?,
     modifier: Modifier = Modifier,
+    artistArt: (Artist) -> ArtistArt = { ArtistArt() },
     topInset: Dp = 0.dp,
     bottomInset: Dp = 0.dp,
     onAlbumClick: (Album) -> Unit = {},
@@ -215,6 +220,7 @@ fun HomeScreen(
                 HomeSection.RecentlyPlayedArtists,
                 feed.recentlyPlayedArtists,
                 coverArt,
+                artistArt,
                 onArtistClick,
                 onLongClick,
                 onMore,
@@ -249,6 +255,7 @@ fun HomeScreen(
                 HomeSection.MostPlayedArtists,
                 feed.mostPlayedArtists,
                 coverArt,
+                artistArt,
                 onArtistClick,
                 onLongClick,
                 onMore,
@@ -296,6 +303,7 @@ fun OfflineHomeScreen(
     coverArt: (String?, Boolean) -> CoverArtRef?,
     playingSongId: String?,
     modifier: Modifier = Modifier,
+    artistArt: (Artist) -> ArtistArt = { ArtistArt() },
     topInset: Dp = 0.dp,
     bottomInset: Dp = 0.dp,
     onAlbumClick: (Album) -> Unit = {},
@@ -312,7 +320,7 @@ fun OfflineHomeScreen(
         ) {
             homeTitle()
             downloadedAlbumRow(albums, coverArt, onAlbumClick, onLongClick) { onMore(OfflineListKind.Albums) }
-            downloadedArtistRow(artists, coverArt, onArtistClick, onLongClick) { onMore(OfflineListKind.Artists) }
+            downloadedArtistRow(artists, artistArt, onArtistClick, onLongClick) { onMore(OfflineListKind.Artists) }
             downloadedPlaylistRow(playlists, coverArt, onPlaylistClick, onLongClick) { onMore(OfflineListKind.Playlists) }
             songList(
                 key = "downloaded-songs",
@@ -364,7 +372,7 @@ private fun LazyListScope.downloadedAlbumRow(
 
 private fun LazyListScope.downloadedArtistRow(
     artists: LazyPagingItems<Artist>,
-    coverArt: (String?, Boolean) -> CoverArtRef?,
+    artistArt: (Artist) -> ArtistArt,
     onArtistClick: (Artist) -> Unit,
     onLongClick: (MenuTarget) -> Unit,
     onMore: () -> Unit,
@@ -382,12 +390,12 @@ private fun LazyListScope.downloadedArtistRow(
             items(count = artists.itemCount, key = artists.itemKey { it.id }) { index ->
                 val artist = artists[index]
                 if (artist != null) {
-                    val ref = coverArt(artist.coverArt, true)
+                    val art = artistArt(artist)
                     ArtistTile(
                         artist = artist,
-                        ref = ref,
+                        art = art,
                         onClick = { onArtistClick(artist) },
-                        onLongClick = { onLongClick(MenuTarget.Artist(artist, ref)) },
+                        onLongClick = { onLongClick(MenuTarget.Artist(artist, art.primary)) },
                     )
                 }
             }
@@ -607,6 +615,7 @@ private fun LazyListScope.artistRow(
     section: HomeSection,
     artists: List<Artist>,
     coverArt: (String?, Boolean) -> CoverArtRef?,
+    artistArt: (Artist) -> ArtistArt,
     onArtistClick: (Artist) -> Unit,
     onLongClick: (MenuTarget) -> Unit,
     onMore: (HomeSection) -> Unit,
@@ -625,12 +634,12 @@ private fun LazyListScope.artistRow(
             modifier = Modifier.padding(top = SECTION_CONTENT_TOP),
         ) {
             items(artists, key = { it.id }) { artist ->
-                val ref = coverArt(artist.coverArt, true)
+                val art = artistArt(artist)
                 ArtistTile(
                     artist = artist,
-                    ref = ref,
+                    art = art,
                     onClick = { onArtistClick(artist) },
-                    onLongClick = { onLongClick(MenuTarget.Artist(artist, ref)) },
+                    onLongClick = { onLongClick(MenuTarget.Artist(artist, art.primary)) },
                 )
             }
         }
@@ -779,7 +788,7 @@ private fun AlbumTile(
 @Composable
 private fun ArtistTile(
     artist: Artist,
-    ref: CoverArtRef?,
+    art: ArtistArt,
     onClick: () -> Unit,
     onLongClick: () -> Unit,
 ) {
@@ -787,9 +796,9 @@ private fun ArtistTile(
         modifier = Modifier.width(ARTIST_TILE_SIZE).combinedClickable(onClick = onClick, onLongClick = onLongClick),
         horizontalAlignment = Alignment.CenterHorizontally,
     ) {
-        CoverArt(
+        ArtistIcon(
-            ref = ref,
+            artist = artist,
-            name = artist.name,
+            art = art,
             modifier = Modifier.size(ARTIST_TILE_SIZE).clip(CircleShape),
         )
         Spacer(Modifier.height(6.dp))

app/src/main/kotlin/com/subtracks/ui/home/HomeViewModel.kt

@@ -17,6 +17,8 @@ import com.subtracks.data.repo.rediscoverCutoff
 import com.subtracks.data.sync.SyncManager
 import com.subtracks.data.sync.SyncStatus
 import com.subtracks.playback.PlaybackController
+import com.subtracks.ui.components.ArtistArt
+import com.subtracks.ui.components.artistArt
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.Flow
@@ -127,6 +129,11 @@ class HomeViewModel(
         thumbnail: Boolean,
     ): CoverArtRef? = sourceRepository.coverArt(coverArt, thumbnail)
 
+    fun artistArt(
+        artist: Artist,
+        forIcon: Boolean = true,
+    ): ArtistArt = sourceRepository.artistArt(artist, forIcon)
+
     fun playStarred(song: Song) {
         viewModelScope.playStarredList(libraryRepository, playbackController, song)
     }

app/src/main/kotlin/com/subtracks/ui/library/AlbumDetailScreen.kt

@@ -16,7 +16,6 @@ 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.Modifier
@@ -30,6 +29,7 @@ import com.subtracks.data.model.Album
 import com.subtracks.data.model.BulkDownloadAction
 import com.subtracks.data.model.CoverArtRef
 import com.subtracks.data.model.Disc
+import com.subtracks.data.model.DownloadList
 import com.subtracks.data.model.ListDownloadStatus
 import com.subtracks.data.model.QueueKind
 import com.subtracks.data.model.Song
@@ -39,16 +39,16 @@ import com.subtracks.playback.PlaybackController
 import com.subtracks.ui.components.ArtistChooserSheet
 import com.subtracks.ui.components.CloseWhenDownloadsGone
 import com.subtracks.ui.components.ContextMenuHost
-import com.subtracks.ui.components.DeleteDownloadsDialog
 import com.subtracks.ui.components.DismissOnRequest
 import com.subtracks.ui.components.HeroDetailScaffold
 import com.subtracks.ui.components.HeroHeader
 import com.subtracks.ui.components.ItemActions
 import com.subtracks.ui.components.MenuTarget
+import com.subtracks.ui.components.PendingDownloadDeleteConfirmation
+import com.subtracks.ui.components.rememberPendingDownloadDelete
 import com.subtracks.ui.theme.ArtworkColors
 import com.subtracks.ui.theme.rememberArtworkColors
 import kotlinx.coroutines.flow.emptyFlow
-import kotlinx.coroutines.launch
 import org.koin.compose.koinInject
 import org.koin.compose.viewmodel.koinViewModel
 import org.koin.core.parameter.parametersOf
@@ -67,28 +67,23 @@ fun AlbumDetailRoute(
     viewModel: AlbumDetailViewModel = koinViewModel(key = albumId) { parametersOf(albumId) },
     playbackController: PlaybackController = koinInject(),
 ) {
-    val album by viewModel.album.collectAsStateWithLifecycle(initialValue = null)
+    val album by viewModel.album.collectAsStateWithLifecycle()
-    val songs by viewModel.songs.collectAsStateWithLifecycle(initialValue = emptyList())
+    val songs by viewModel.songs.collectAsStateWithLifecycle()
-    val discs by viewModel.discs.collectAsStateWithLifecycle(initialValue = emptyList())
+    val discs by viewModel.discs.collectAsStateWithLifecycle()
     val downloads by viewModel.downloads.collectAsStateWithLifecycle()
     val downloadStatus by viewModel.downloadStatus.collectAsStateWithLifecycle()
     val offline by viewModel.offline.collectAsStateWithLifecycle()
     CloseWhenDownloadsGone(downloadStatus.downloaded, offline, onBack)
-    val scope = rememberCoroutineScope()
+    val dismissals = contextMenuHost?.dismissals ?: emptyFlow()
-    var pendingDelete by remember { mutableStateOf<Long?>(null) }
+    val pendingDelete = rememberPendingDownloadDelete(dismissals) { _, _ -> viewModel.downloadedBytes() }
     var showArtistChooser by remember { mutableStateOf(false) }
-    DismissOnRequest(contextMenuHost?.dismissals ?: emptyFlow()) {
+    DismissOnRequest(dismissals) { showArtistChooser = false }
-        pendingDelete = null
-        showArtistChooser = false
-    }
     val playback by playbackController.state.collectAsStateWithLifecycle()
     val context = playback.context
     val shortcutArt = remember(coverArtId) { coverArtId?.let { viewModel.coverArt(it, true) } }
     val requestDownloadAction: (BulkDownloadAction) -> Unit = { action ->
-        if (action == BulkDownloadAction.Delete) {
+        pendingDelete.onAction(album?.name.orEmpty(), DownloadList.Album, albumId, action) { _, _, requested ->
-            scope.launch { pendingDelete = viewModel.downloadedBytes() }
+            viewModel.onDownloadAction(requested)
-        } else {
-            viewModel.onDownloadAction(action)
         }
     }
     val actions =
@@ -141,13 +136,8 @@ fun AlbumDetailRoute(
         playingSongId = playback.item?.id.takeIf { context?.kind == QueueKind.Album && context.refId == albumId },
     )
 
-    pendingDelete?.let { bytes ->
+    PendingDownloadDeleteConfirmation(pendingDelete) {
-        DeleteDownloadsDialog(
+        viewModel.onDownloadAction(BulkDownloadAction.Delete)
-            name = album?.name.orEmpty(),
-            bytes = bytes,
-            onConfirm = { viewModel.onDownloadAction(BulkDownloadAction.Delete) },
-            onDismiss = { pendingDelete = null },
-        )
     }
 
     if (showArtistChooser) {
@@ -215,6 +205,7 @@ fun AlbumDetailScreen(
         artwork = artwork,
         title = album?.name.orEmpty(),
         onBack = onBack,
+        contentReady = songs.isNotEmpty(),
         header = { controlsModifier, topInset ->
             val artistName = album?.albumArtist?.takeIf { it.isNotBlank() }
             HeroHeader(

app/src/main/kotlin/com/subtracks/ui/library/AlbumDetailViewModel.kt

@@ -15,7 +15,6 @@ import com.subtracks.data.repo.LibraryRepository
 import com.subtracks.data.repo.SourceRepository
 import com.subtracks.playback.PlaybackController
 import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.combine
@@ -35,13 +34,20 @@ class AlbumDetailViewModel(
 ) : ViewModel() {
     private val sourceId = libraryRepository.activeSourceId.filterNotNull()
 
-    val album: Flow<Album?> = sourceId.flatMapLatest { libraryRepository.album(it, albumId) }
+    val album: StateFlow<Album?> =
+        sourceId
+            .flatMapLatest { libraryRepository.album(it, albumId) }
+            .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), null)
 
-    val songs: Flow<List<Song>> =
+    val songs: StateFlow<List<Song>> =
         combine(sourceId, sourceRepository.offline) { id, offline -> id to offline }
             .flatMapLatest { (id, offline) -> libraryRepository.albumSongs(id, albumId, offline) }
+            .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), emptyList())
 
-    val discs: Flow<List<Disc>> = sourceId.flatMapLatest { libraryRepository.albumDiscs(it, albumId) }
+    val discs: StateFlow<List<Disc>> =
+        sourceId
+            .flatMapLatest { libraryRepository.albumDiscs(it, albumId) }
+            .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), emptyList())
 
     val downloads: StateFlow<Map<String, SongDownload>> = downloadRepository.states()
 

app/src/main/kotlin/com/subtracks/ui/library/ArtistDetailScreen.kt

@@ -16,6 +16,7 @@ import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.WindowInsets
 import androidx.compose.foundation.layout.aspectRatio
 import androidx.compose.foundation.layout.defaultMinSize
+import androidx.compose.foundation.layout.fillMaxHeight
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
@@ -27,6 +28,7 @@ import androidx.compose.foundation.layout.statusBars
 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.LazyGridState
 import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
 import androidx.compose.foundation.lazy.grid.itemsIndexed
 import androidx.compose.foundation.lazy.grid.rememberLazyGridState
@@ -54,18 +56,24 @@ import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
+import androidx.compose.runtime.snapshotFlow
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Size
 import androidx.compose.ui.graphics.Brush
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Outline
+import androidx.compose.ui.graphics.Path
 import androidx.compose.ui.graphics.Shadow
+import androidx.compose.ui.graphics.Shape
 import androidx.compose.ui.graphics.graphicsLayer
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.layout.onSizeChanged
@@ -82,7 +90,9 @@ import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.rememberTextMeasurer
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.text.withStyle
+import androidx.compose.ui.unit.Density
 import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.LayoutDirection
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
@@ -95,16 +105,17 @@ import com.subtracks.data.model.CoverArtRef
 import com.subtracks.data.model.ListDownloadStatus
 import com.subtracks.data.source.StarType
 import com.subtracks.playback.PlaybackController
+import com.subtracks.ui.components.ArtistArt
+import com.subtracks.ui.components.ArtistHeroArt
 import com.subtracks.ui.components.CloseWhenDownloadsGone
 import com.subtracks.ui.components.ContextMenuHost
 import com.subtracks.ui.components.CoverArt
-import com.subtracks.ui.components.DeleteDownloadsDialog
 import com.subtracks.ui.components.DismissOnRequest
 import com.subtracks.ui.components.ItemActions
 import com.subtracks.ui.components.ListDownloadIndicator
 import com.subtracks.ui.components.MenuTarget
-import com.subtracks.ui.components.PendingDownloadDelete
+import com.subtracks.ui.components.PendingDownloadDeleteConfirmation
-import com.subtracks.ui.components.bulkRef
+import com.subtracks.ui.components.rememberPendingDownloadDelete
 import com.subtracks.ui.components.rememberViewportFill
 import com.subtracks.ui.components.statusBarScrim
 import com.subtracks.ui.theme.ArtworkColors
@@ -117,11 +128,14 @@ import com.subtracks.ui.theme.rememberArtworkColors
 import com.subtracks.ui.theme.rememberOverlaidNameBusy
 import kotlinx.coroutines.flow.emptyFlow
 import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.launch
 import org.koin.compose.koinInject
 import org.koin.compose.viewmodel.koinViewModel
 import org.koin.core.parameter.parametersOf
+import kotlin.math.PI
 import kotlin.math.ceil
+import kotlin.math.cos
+import kotlin.math.min
+import kotlin.math.sin
 
 private val ART_HEIGHT = 420.dp
 private val TITLE_INSET = 16.dp
@@ -134,8 +148,10 @@ private val SHUFFLE_RESERVE = 86.dp
 private val SHUFFLE_HANG = SHUFFLE_HEIGHT / 2
 private val BIO_ACTION_RESERVE = 104.dp
 private val BIO_ACTION_HEIGHT = 48.dp
-private val BIO_ACTION_OFFSET = 8.dp
+private val BIO_ACTION_OFFSET = 16.dp
+private val BIO_ACTION_END_OFFSET = 8.dp
 private val BIO_TOP_GAP = 8.dp
+private val BIO_BOTTOM_GAP = 8.dp
 
 internal fun estimateScrollPx(
     index: Int,
@@ -176,9 +192,9 @@ fun ArtistDetailRoute(
     viewModel: ArtistDetailViewModel = koinViewModel(key = artistId) { parametersOf(artistId) },
     playbackController: PlaybackController = koinInject(),
 ) {
-    val artist by viewModel.artist.collectAsStateWithLifecycle(initialValue = null)
+    val artist by viewModel.artist.collectAsStateWithLifecycle()
-    val artistName by viewModel.artistName.collectAsStateWithLifecycle(initialValue = null)
+    val artistName by viewModel.artistName.collectAsStateWithLifecycle()
-    val albums by viewModel.albums.collectAsStateWithLifecycle(initialValue = null)
+    val albums by viewModel.albums.collectAsStateWithLifecycle()
     val bioSnapshots =
         remember(viewModel) {
             viewModel.artistBio.map { BioSnapshot(known = true, present = it != null, biography = it?.biography) }
@@ -193,30 +209,18 @@ fun ArtistDetailRoute(
     LaunchedEffect(artistId) { viewModel.refreshBio() }
     val art by viewModel.art.collectAsStateWithLifecycle()
     val artThumbnail by viewModel.artThumbnail.collectAsStateWithLifecycle()
+    val heroArt by viewModel.heroArt.collectAsStateWithLifecycle()
     val downloadStatus by viewModel.downloadStatus.collectAsStateWithLifecycle()
     val offline by viewModel.offline.collectAsStateWithLifecycle()
     CloseWhenDownloadsGone(downloadStatus.downloaded, offline, onBack)
     val albumDownloads by viewModel.albumDownloads.collectAsStateWithLifecycle()
-    val scope = rememberCoroutineScope()
+    val pendingDelete = rememberPendingDownloadDelete(contextMenuHost?.dismissals ?: emptyFlow(), viewModel::downloadedBytes)
-    var pendingDelete by remember { mutableStateOf<PendingDownloadDelete?>(null) }
-    DismissOnRequest(contextMenuHost?.dismissals ?: emptyFlow()) { pendingDelete = null }
     val shortcutArt = remember(coverArtId) { coverArtId?.let { viewModel.coverArt(it, true) } }
     val actions =
         ItemActions(
             playNext = { playbackController.playNext(it.sourceId, it.kind, it.refId) },
             addToQueue = { playbackController.addToQueue(it.sourceId, it.kind, it.refId) },
-            bulkDownload = { target, action ->
+            bulkDownload = { target, action -> pendingDelete.onAction(target, action, viewModel::onDownloadAction) },
-                target.bulkRef()?.let { (list, refId) ->
-                    if (action == BulkDownloadAction.Delete) {
-                        scope.launch {
-                            pendingDelete =
-                                PendingDownloadDelete(target.title, list, refId, viewModel.downloadedBytes(list, refId))
-                        }
-                    } else {
-                        viewModel.onDownloadAction(list, refId, action)
-                    }
-                }
-            },
             setStar = setStar,
             viewAlbum = onViewAlbum,
         )
@@ -232,6 +236,7 @@ fun ArtistDetailRoute(
         bioExpanded = bioExpanded,
         art = art,
         artThumbnail = artThumbnail,
+        heroArt = heroArt,
         artwork = rememberArtworkColors(shortcutArt ?: artThumbnail ?: art, THEME_TRANSITION_MS, fallbackName = artistName),
         coverArt = viewModel::coverArt,
         onBack = onBack,
@@ -246,13 +251,8 @@ fun ArtistDetailRoute(
         onShuffle = viewModel::shuffle,
     )
 
-    pendingDelete?.let { pending ->
+    PendingDownloadDeleteConfirmation(pendingDelete) { pending ->
-        DeleteDownloadsDialog(
+        viewModel.onDownloadAction(pending.list, pending.refId, BulkDownloadAction.Delete)
-            name = pending.name,
-            bytes = pending.bytes,
-            onConfirm = { viewModel.onDownloadAction(pending.list, pending.refId, BulkDownloadAction.Delete) },
-            onDismiss = { pendingDelete = null },
-        )
     }
 }
 
@@ -271,6 +271,7 @@ fun ArtistDetailScreen(
     bioExpanded: Boolean = false,
     art: CoverArtRef?,
     artThumbnail: CoverArtRef? = null,
+    heroArt: ArtistArt? = null,
     artwork: ArtworkColors? = null,
     coverArt: (String?, Boolean) -> CoverArtRef?,
     onBack: () -> Unit,
@@ -284,7 +285,7 @@ fun ArtistDetailScreen(
     onCollapseBio: () -> Unit = {},
     onShuffle: () -> Unit = {},
 ) {
-    val listState = rememberLazyGridState()
+    val listState = rememberRestorableLazyGridState(albumsLoaded)
     val fill = rememberViewportFill(listState)
     val density = LocalDensity.current
     val lineHeight =
@@ -331,8 +332,8 @@ fun ArtistDetailScreen(
             }
         }
     }
-    var imageHeightPx by remember { mutableFloatStateOf(0f) }
+    var imageHeightPx by rememberSaveable { mutableFloatStateOf(0f) }
-    var albumHeightPx by remember { mutableFloatStateOf(0f) }
+    var albumHeightPx by rememberSaveable { mutableFloatStateOf(0f) }
     val albumRowGapPx = with(density) { ROW_GAP.toPx() }
     val scrollPx by remember {
         derivedStateOf {
@@ -388,11 +389,9 @@ fun ArtistDetailScreen(
                                 .onSizeChanged { imageHeightPx = it.height.toFloat() },
                         ) {
                             Box(Modifier.fillMaxWidth()) {
-                                CoverArt(
+                                ArtistHeroArt(
-                                    ref = art,
+                                    art = heroArt ?: ArtistArt(image = art, thumbnail = artThumbnail),
                                     name = displayName,
-                                    thumbnailRef = artThumbnail,
-                                    showPlaceholder = art == null,
                                     modifier = Modifier.fillMaxWidth().height(ART_HEIGHT),
                                 )
                                 if (nameScrimAlpha > 0f) {
@@ -470,7 +469,7 @@ fun ArtistDetailScreen(
                                     onCollapse = onCollapseBio,
                                     modifier =
                                         Modifier.padding(
-                                            bottom = if (hasBio && !bioCollapsed) 8.dp else 0.dp,
+                                            bottom = if (hasBio) BIO_BOTTOM_GAP else 0.dp,
                                         ),
                                 )
                             }
@@ -554,8 +553,32 @@ fun ArtistDetailScreen(
     }
 }
 
-// The expanded layout narrows only the lines that overlap the action buttons; later lines use the
+@Composable
-// full width.
+private fun rememberRestorableLazyGridState(contentReady: Boolean): LazyGridState {
+    val state = rememberLazyGridState()
+    var index by rememberSaveable { mutableIntStateOf(state.firstVisibleItemIndex) }
+    var offset by rememberSaveable { mutableIntStateOf(state.firstVisibleItemScrollOffset) }
+    var pending by remember { mutableStateOf(index > 0 || offset > 0) }
+    LaunchedEffect(contentReady) {
+        if (contentReady && pending) {
+            val target = index.coerceAtMost((state.layoutInfo.totalItemsCount - 1).coerceAtLeast(0))
+            state.scrollToItem(target, offset)
+            pending = false
+        }
+    }
+    LaunchedEffect(state) {
+        snapshotFlow { state.firstVisibleItemIndex to state.firstVisibleItemScrollOffset }
+            .collect { (currentIndex, currentOffset) ->
+                if (!pending) {
+                    index = currentIndex
+                    offset = currentOffset
+                }
+            }
+    }
+    return state
+}
+
+// Only the lines that overlap the action buttons are narrowed; later lines use the full width.
 @Composable
 private fun ArtistBio(
     text: String,
@@ -587,10 +610,28 @@ private fun ArtistBio(
                 .toInt()
                 .coerceAtLeast(1)
         val bioLines =
-            remember(text, fullWidth, reserve, reserveLines, collapsed, expanded, moreText, lessText) {
+            remember(
+                text,
+                fullWidth,
+                reserve,
+                reserveLines,
+                collapsed,
+                expanded,
+                moreText,
+                lessText,
+            ) {
                 when {
                     collapsed -> {
-                        splitBioCollapsed(measurer, text, style, fullWidth, reserve, reserveLines, moreText, maxLines = 3)
+                        splitBioCollapsed(
+                            measurer,
+                            text,
+                            style,
+                            fullWidth,
+                            reserve,
+                            reserveLines,
+                            moreText,
+                            maxLines = 3,
+                        )
                     }
 
                     expanded -> {
@@ -626,7 +667,11 @@ private fun ArtistBio(
                     )
                 }
             }
-            Row(Modifier.align(Alignment.TopEnd).offset(y = -BIO_ACTION_OFFSET)) {
+            Row(
+                Modifier
+                    .align(Alignment.TopEnd)
+                    .offset(x = BIO_ACTION_END_OFFSET, y = -BIO_ACTION_OFFSET),
+            ) {
                 ArtistActions(artist, starred, onToggleStar, onMore)
             }
         }

app/src/main/kotlin/com/subtracks/ui/library/ArtistDetailViewModel.kt

@@ -13,10 +13,10 @@ import com.subtracks.data.repo.DownloadRepository
 import com.subtracks.data.repo.LibraryRepository
 import com.subtracks.data.repo.SourceRepository
 import com.subtracks.playback.PlaybackController
+import com.subtracks.ui.components.ArtistArt
+import com.subtracks.ui.components.artistArt
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.Job
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
@@ -25,8 +25,6 @@ import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.filterNotNull
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.flatMapLatest
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.onStart
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 
@@ -40,23 +38,26 @@ class ArtistDetailViewModel(
 ) : ViewModel() {
     private val sourceId = libraryRepository.activeSourceId.filterNotNull()
 
-    val artist: Flow<Artist?> = sourceId.flatMapLatest { libraryRepository.artist(it, artistId) }
+    val artist: StateFlow<Artist?> =
+        sourceId
+            .flatMapLatest { libraryRepository.artist(it, artistId) }
+            .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), null)
 
-    val artistName: Flow<String?> =
+    val artistName: StateFlow<String?> =
-        sourceId.flatMapLatest { id ->
+        sourceId
-            combine(
+            .flatMapLatest { id ->
-                libraryRepository.artist(id, artistId),
+                combine(
-                libraryRepository.artistName(id, artistId),
+                    libraryRepository.artist(id, artistId),
-            ) { loaded, fromSongs -> loaded?.name?.takeIf { it.isNotBlank() } ?: fromSongs }
+                    libraryRepository.artistName(id, artistId),
-        }
+                ) { loaded, fromSongs -> loaded?.name?.takeIf { it.isNotBlank() } ?: fromSongs }
+            }.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), null)
 
     val offline: StateFlow<Boolean> = sourceRepository.offline
 
-    val albums: Flow<ArtistAlbums?> =
+    val albums: StateFlow<ArtistAlbums?> =
         combine(sourceId, sourceRepository.offline) { id, offline -> id to offline }
             .flatMapLatest { (id, offline) -> libraryRepository.artistAlbums(id, artistId, offline) }
-            .map<ArtistAlbums, ArtistAlbums?> { it }
+            .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), null)
-            .onStart { emit(null) }
 
     val downloadStatus: StateFlow<ListDownloadStatus> =
         sourceId
@@ -68,7 +69,10 @@ class ArtistDetailViewModel(
             .flatMapLatest { downloadRepository.statuses(it, DownloadList.Album) }
             .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), emptyMap())
 
-    val artistBio: Flow<ArtistBio?> = sourceId.flatMapLatest { libraryRepository.artistBio(it, artistId) }
+    val artistBio: StateFlow<ArtistBio?> =
+        sourceId
+            .flatMapLatest { libraryRepository.artistBio(it, artistId) }
+            .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), null)
 
     private val _bioLoading = MutableStateFlow(true)
     val bioLoading: StateFlow<Boolean> = _bioLoading
@@ -136,30 +140,36 @@ class ArtistDetailViewModel(
     private val _artThumbnail = MutableStateFlow<CoverArtRef?>(null)
     val artThumbnail: StateFlow<CoverArtRef?> = _artThumbnail
 
+    private val _heroArt = MutableStateFlow<ArtistArt?>(null)
+    val heroArt: StateFlow<ArtistArt?> = _heroArt
+
     init {
         viewModelScope.launch {
-            artist
+            sourceRepository.activeSource
                 .filterNotNull()
-                .collectLatest { loaded ->
+                .flatMapLatest { sourceId ->
-                    val (full, thumbnail) = resolveArt(loaded)
+                    combine(
-                    _art.value = full
+                        libraryRepository.artist(sourceId, artistId),
-                    _artThumbnail.value = thumbnail
+                        libraryRepository.artistCoverArts(sourceId, artistId),
+                        sourceRepository.offline,
+                    ) { loaded, covers, offline -> ArtistArtInput(loaded, artistId, offline, sourceId, covers) }
+                }.collectLatest { input ->
+                    val resolved = resolveArtistArtInput(input)
+                    if (resolved == null) {
+                        _art.value = null
+                        _artThumbnail.value = null
+                        _heroArt.value = null
+                        return@collectLatest
+                    }
+                    val hero = sourceRepository.artistArt(resolved, forIcon = false)
+                    val icon = sourceRepository.artistArt(resolved, forIcon = true)
+                    _art.value = hero.image ?: hero.covers.firstOrNull()
+                    _artThumbnail.value = icon.image ?: icon.covers.firstOrNull()
+                    _heroArt.value = hero
                 }
         }
     }
 
-    private suspend fun resolveArt(artist: Artist): Pair<CoverArtRef?, CoverArtRef?> {
-        if (artist.coverArt == null) return null to null
-        repeat(3) { attempt ->
-            val full = sourceRepository.coverArt(artist.coverArt)
-            if (full != null) {
-                return full to sourceRepository.coverArt(artist.coverArt, thumbnail = true)
-            }
-            if (attempt < 2) delay(300)
-        }
-        return null to null
-    }
-
     fun coverArt(
         coverArt: String?,
         thumbnail: Boolean,
@@ -171,3 +181,35 @@ class ArtistDetailViewModel(
         }
     }
 }
+
+internal data class ArtistArtInput(
+    val artist: Artist?,
+    val artistId: String,
+    val offline: Boolean,
+    val sourceId: Long,
+    val covers: List<String>,
+)
+
+internal fun resolveArtistArtInput(input: ArtistArtInput): Artist? {
+    val artist = input.artist
+    if (input.covers.isEmpty()) return artist
+    if (artist == null) {
+        return Artist(
+            sourceId = input.sourceId,
+            id = input.artistId,
+            name = "",
+            albumCount = 0,
+            starred = null,
+            coverArts = input.covers,
+            downloadedCoverArts = if (input.offline) input.covers else emptyList(),
+        )
+    }
+    return if (input.offline) {
+        artist.copy(
+            coverArts = input.covers,
+            downloadedCoverArts = artist.downloadedCoverArts.ifEmpty { input.covers },
+        )
+    } else {
+        artist.copy(coverArts = input.covers)
+    }
+}

app/src/main/kotlin/com/subtracks/ui/library/ArtistsContent.kt

@@ -29,7 +29,8 @@ import com.subtracks.R
 import com.subtracks.data.model.Artist
 import com.subtracks.data.model.CoverArtRef
 import com.subtracks.data.model.ListDownloadStatus
-import com.subtracks.ui.components.CoverArt
+import com.subtracks.ui.components.ArtistArt
+import com.subtracks.ui.components.ArtistIcon
 import com.subtracks.ui.components.EmptyState
 import com.subtracks.ui.components.FilteredEmptyState
 import com.subtracks.ui.components.ListDownloadIndicator
@@ -55,6 +56,7 @@ fun ArtistsContent(
     onSync: () -> Unit = {},
     downloadStatuses: Map<String, ListDownloadStatus> = emptyMap(),
     scrollToTopKey: Any? = null,
+    artistArt: (Artist) -> ArtistArt = { ArtistArt() },
 ) {
     when {
         items.itemCount == 0 && items.loadState.refresh is LoadState.Loading -> {
@@ -82,7 +84,8 @@ fun ArtistsContent(
                 items(count = items.itemCount, key = items.itemKey { it.id }) { index ->
                     val artist = items[index]
                     if (artist != null) {
-                        PrefetchArtworkSeeds(coverArt(artist.coverArt, true))
+                        val art = artistArt(artist)
+                        PrefetchArtworkSeeds(art.primary)
                         ListItem(
                             headlineContent = {
                                 Text(
@@ -104,9 +107,9 @@ fun ArtistsContent(
                                 )
                             },
                             leadingContent = {
-                                CoverArt(
+                                ArtistIcon(
-                                    ref = coverArt(artist.coverArt, true),
+                                    artist = artist,
-                                    name = artist.name,
+                                    art = art,
                                     modifier = Modifier.size(48.dp).clip(CircleShape),
                                 )
                             },
@@ -117,7 +120,7 @@ fun ArtistsContent(
                                 Modifier.combinedClickable(
                                     onClick = { onArtistClick(artist) },
                                     onLongClick = {
-                                        onLongClick(MenuTarget.Artist(artist, coverArt(artist.coverArt, true), downloadStatuses[artist.id]))
+                                        onLongClick(MenuTarget.Artist(artist, art.primary, downloadStatuses[artist.id]))
                                     },
                                 ),
                             colors = ListItemDefaults.colors(containerColor = Color.Transparent),

app/src/main/kotlin/com/subtracks/ui/library/LibraryScreen.kt

@@ -6,6 +6,7 @@ import androidx.compose.foundation.BorderStroke
 import androidx.compose.foundation.Canvas
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
+import androidx.compose.foundation.horizontalScroll
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
@@ -25,6 +26,7 @@ import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.pager.HorizontalPager
 import androidx.compose.foundation.pager.PagerState
 import androidx.compose.foundation.pager.rememberPagerState
+import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
@@ -43,6 +45,7 @@ import androidx.compose.material.icons.rounded.Search
 import androidx.compose.material.icons.rounded.Settings
 import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.FilledTonalIconButton
 import androidx.compose.material3.FilterChip
 import androidx.compose.material3.FilterChipDefaults
 import androidx.compose.material3.FloatingActionButton
@@ -65,13 +68,11 @@ import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateMapOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import androidx.compose.runtime.snapshotFlow
 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.draw.drawBehind
 import androidx.compose.ui.draw.drawWithContent
@@ -94,12 +95,14 @@ import androidx.compose.ui.layout.onGloballyPositioned
 import androidx.compose.ui.layout.onSizeChanged
 import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.platform.LocalFocusManager
+import androidx.compose.ui.platform.LocalLayoutDirection
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.clearAndSetSemantics
 import androidx.compose.ui.semantics.contentDescription
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.unit.Constraints
 import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.LayoutDirection
 import androidx.compose.ui.unit.dp
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.paging.PagingData
@@ -120,14 +123,14 @@ import com.subtracks.data.prefs.PlaylistSort
 import com.subtracks.data.prefs.StarredFilter
 import com.subtracks.data.source.StarType
 import com.subtracks.playback.PlaybackController
+import com.subtracks.ui.components.ArtistArt
 import com.subtracks.ui.components.ContextMenuHost
-import com.subtracks.ui.components.DeleteDownloadsDialog
 import com.subtracks.ui.components.DismissOnRequest
 import com.subtracks.ui.components.ItemActions
 import com.subtracks.ui.components.MenuTarget
-import com.subtracks.ui.components.PendingDownloadDelete
+import com.subtracks.ui.components.PendingDownloadDeleteConfirmation
 import com.subtracks.ui.components.SearchField
-import com.subtracks.ui.components.bulkRef
+import com.subtracks.ui.components.rememberPendingDownloadDelete
 import com.subtracks.ui.components.statusBarScrim
 import com.subtracks.ui.home.HomeRoute
 import com.subtracks.ui.home.HomeSection
@@ -138,7 +141,6 @@ import com.subtracks.ui.theme.playerSurfaceColor
 import com.subtracks.ui.theme.rememberArtworkColors
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.emptyFlow
-import kotlinx.coroutines.launch
 import org.koin.compose.koinInject
 import org.koin.compose.viewmodel.koinViewModel
 import kotlin.math.abs
@@ -273,26 +275,13 @@ fun LibraryRoute(
     val artwork = rememberArtworkColors(playbackController.coverArt(playback.item, thumbnail = true), fallbackName = playback.item?.title)
     val downloadsState = listTab?.let { viewModel.downloads(it).collectAsStateWithLifecycle() }
     val downloads = downloadsState?.value ?: emptyMap()
-    val scope = rememberCoroutineScope()
     val focusManager = LocalFocusManager.current
-    var pendingDelete by remember { mutableStateOf<PendingDownloadDelete?>(null) }
+    val pendingDelete = rememberPendingDownloadDelete(contextMenuHost?.dismissals ?: emptyFlow(), viewModel::downloadedBytes)
-    DismissOnRequest(contextMenuHost?.dismissals ?: emptyFlow()) { pendingDelete = null }
     val itemActions =
         ItemActions(
             playNext = { playbackController.playNext(it.sourceId, it.kind, it.refId) },
             addToQueue = { playbackController.addToQueue(it.sourceId, it.kind, it.refId) },
-            bulkDownload = { target, action ->
+            bulkDownload = { target, action -> pendingDelete.onAction(target, action, viewModel::onDownloadAction) },
-                target.bulkRef()?.let { (list, refId) ->
-                    if (action == BulkDownloadAction.Delete) {
-                        scope.launch {
-                            pendingDelete =
-                                PendingDownloadDelete(target.title, list, refId, viewModel.downloadedBytes(list, refId))
-                        }
-                    } else {
-                        viewModel.onDownloadAction(list, refId, action)
-                    }
-                }
-            },
             setStar = setStar,
             viewAlbum = onViewAlbum,
             viewArtist = onViewArtist,
@@ -308,6 +297,7 @@ fun LibraryRoute(
         artists = viewModel.artists,
         playlists = viewModel.playlists,
         coverArt = viewModel::coverArt,
+        artistArt = { viewModel.artistArt(it) },
         onAlbumClick = onAlbumClick,
         onArtistClick = onArtistClick,
         onPlaylistClick = onPlaylistClick,
@@ -371,13 +361,8 @@ fun LibraryRoute(
         },
     )
 
-    pendingDelete?.let { pending ->
+    PendingDownloadDeleteConfirmation(pendingDelete) { pending ->
-        DeleteDownloadsDialog(
+        viewModel.onDownloadAction(pending.list, pending.refId, BulkDownloadAction.Delete)
-            name = pending.name,
-            bytes = pending.bytes,
-            onConfirm = { viewModel.onDownloadAction(pending.list, pending.refId, BulkDownloadAction.Delete) },
-            onDismiss = { pendingDelete = null },
-        )
     }
 }
 
@@ -396,6 +381,7 @@ fun LibraryScreen(
     onSync: () -> Unit,
     onOpenSettings: () -> Unit,
     modifier: Modifier = Modifier,
+    artistArt: (Artist) -> ArtistArt = { ArtistArt() },
     onOpenSearch: () -> Unit = {},
     offline: Boolean = false,
     onExitOffline: () -> Unit = {},
@@ -539,6 +525,7 @@ fun LibraryScreen(
                             onSync = onSync,
                             downloadStatuses = artistDownloads,
                             scrollToTopKey = scrollToTopKey,
+                            artistArt = artistArt,
                         )
                     }
 
@@ -588,8 +575,6 @@ fun LibraryScreen(
                         if (tab == selectedTab) topRequest++ else onTabSelected(tab)
                     },
                     onOpenSettings = onOpenSettings,
-                    offline = offline,
-                    onExitOffline = onExitOffline,
                     artwork = artwork,
                     syncing = syncing,
                 )
@@ -611,11 +596,29 @@ fun LibraryScreen(
         }
 
         if (!searchActive) {
+            val fabContainerColor = artwork?.scheme?.primary ?: MaterialTheme.colorScheme.surfaceContainerHigh
+            val fabContentColor = artwork?.scheme?.onPrimary ?: MaterialTheme.colorScheme.onBackground
+            if (offline) {
+                FilledTonalIconButton(
+                    onClick = onExitOffline,
+                    modifier =
+                        Modifier
+                            .align(Alignment.BottomStart)
+                            .padding(start = 16.dp, bottom = tabBarHeight + 16.dp)
+                            .size(48.dp),
+                ) {
+                    Icon(
+                        imageVector = Icons.Rounded.CloudOff,
+                        contentDescription = stringResource(R.string.offline_mode_status),
+                        modifier = Modifier.size(24.dp).offset(y = (-0.75).dp),
+                    )
+                }
+            }
             val searchFab = selectedTab == LibraryTab.Home
             FloatingActionButton(
                 onClick = { if (searchFab) onOpenSearch() else showOptions = true },
-                containerColor = artwork?.scheme?.primary ?: MaterialTheme.colorScheme.surfaceContainerHigh,
+                containerColor = fabContainerColor,
-                contentColor = artwork?.scheme?.onPrimary ?: MaterialTheme.colorScheme.onBackground,
+                contentColor = fabContentColor,
                 elevation = FloatingActionButtonDefaults.elevation(defaultElevation = 12.dp),
                 modifier = Modifier.align(Alignment.BottomEnd).padding(end = 16.dp, bottom = tabBarHeight + 16.dp),
             ) {
@@ -634,11 +637,18 @@ fun LibraryScreen(
                                 modifier =
                                     Modifier
                                         .align(Alignment.TopEnd)
-                                        .offset(x = 4.dp, y = (-4).dp)
+                                        .offset(x = 1.dp, y = 2.5.dp)
-                                        .size(8.dp)
+                                        .size(11.dp)
-                                        .clip(CircleShape)
+                                        .background(fabContainerColor, CircleShape),
-                                        .background(artwork?.scheme?.onPrimary ?: MaterialTheme.colorScheme.primary),
+                                contentAlignment = Alignment.Center,
-                            )
+                            ) {
+                                Box(
+                                    modifier =
+                                        Modifier
+                                            .size(7.dp)
+                                            .background(fabContentColor, CircleShape),
+                                )
+                            }
                         }
                     }
                 }
@@ -698,7 +708,7 @@ private fun ListOptionsSheet(
             Row(
                 verticalAlignment = Alignment.CenterVertically,
                 horizontalArrangement = Arrangement.spacedBy(12.dp),
-                modifier = Modifier.padding(horizontal = 16.dp, vertical = 14.dp),
+                modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp),
             ) {
                 Icon(Icons.Rounded.Search, contentDescription = null, tint = MaterialTheme.colorScheme.onSurfaceVariant)
                 Text(stringResource(R.string.search_this_list), color = MaterialTheme.colorScheme.onSurfaceVariant)
@@ -820,6 +830,7 @@ private fun ListOptionsSheet(
 
 private val BOTTOM_CLEARANCE = 80.dp
 private val TAB_BAR_CONTENT_HEIGHT = 52.dp
+private val TAB_STRIP_LEADING_GAP = 8.dp
 private val TAB_ICON_SIZE = 24.dp
 private val TAB_VERTICAL_PADDING = 6.dp
 private val TOUCH_TARGET = 48.dp
@@ -852,13 +863,12 @@ internal fun LibraryTabs(
     pagerState: PagerState,
     onTabSelected: (LibraryTab) -> Unit,
     onOpenSettings: () -> Unit,
-    offline: Boolean = false,
-    onExitOffline: () -> Unit = {},
     artwork: ArtworkColors?,
     syncing: Boolean = false,
 ) {
     val indicatorStretch = 18.dp
     val density = LocalDensity.current
+    val layoutDirection = LocalLayoutDirection.current
     val bounds = remember { mutableStateMapOf<Int, Rect>() }
     val page = pagerState.currentPage
     val fraction = pagerState.currentPageOffsetFraction
@@ -890,79 +900,113 @@ internal fun LibraryTabs(
     val indicatorColor = artwork?.scheme?.primary ?: MaterialTheme.colorScheme.onBackground
     val tabContentHeightPx = with(density) { (TAB_ICON_SIZE + TAB_VERTICAL_PADDING * 2).toPx() }
 
+    val scrollState = rememberScrollState()
+    var viewportWidth by remember { mutableIntStateOf(0) }
+    var contentWidth by remember { mutableIntStateOf(0) }
+    var revealed by remember { mutableStateOf(false) }
+    val leadingGap = with(density) { TAB_STRIP_LEADING_GAP.toPx() }
+    LaunchedEffect(pagerState.settledPage, viewportWidth, contentWidth, layoutDirection, bounds[pagerState.settledPage]) {
+        if (viewportWidth == 0) return@LaunchedEffect
+        val settled = bounds[pagerState.settledPage] ?: return@LaunchedEffect
+        val start = if (layoutDirection == LayoutDirection.Rtl) contentWidth - settled.right else leadingGap + settled.left
+        val end = if (layoutDirection == LayoutDirection.Rtl) contentWidth - settled.left else leadingGap + settled.right
+        val target =
+            when {
+                start - leadingGap < scrollState.value -> start - leadingGap
+                end > scrollState.value + viewportWidth -> end - viewportWidth
+                else -> null
+            }
+        if (target != null) {
+            val offset = target.roundToInt().coerceIn(0, scrollState.maxValue)
+            if (revealed) scrollState.animateScrollTo(offset) else scrollState.scrollTo(offset)
+        }
+        revealed = true
+    }
+
     Box(Modifier.fillMaxWidth()) {
         Box(
             modifier =
                 Modifier
                     .fillMaxWidth()
                     .background(headerColor)
-                    .padding(horizontal = 8.dp, vertical = 2.dp),
+                    .padding(top = 2.dp, end = 8.dp, bottom = 2.dp),
         ) {
-            Box(
+            Row(
-                modifier =
+                modifier = Modifier.fillMaxWidth(),
-                    Modifier.drawBehind {
+                verticalAlignment = Alignment.CenterVertically,
-                        if (current != null && indicatorLeft != null && indicatorRight != null && indicatorRight > indicatorLeft) {
+                horizontalArrangement = Arrangement.spacedBy(4.dp),
-                            val height = tabContentHeightPx.coerceAtMost(current.height)
-                            drawRoundRect(
-                                color = indicatorColor,
-                                topLeft = Offset(indicatorLeft, current.top + (current.height - height) / 2f),
-                                size = Size(indicatorRight - indicatorLeft, height),
-                                cornerRadius = CornerRadius(8.dp.toPx()),
-                            )
-                        }
-                    },
             ) {
                 Row(
-                    modifier = Modifier.fillMaxWidth(),
+                    modifier =
+                        Modifier
+                            .weight(1f)
+                            .onSizeChanged { viewportWidth = it.width }
+                            .horizontalScroll(scrollState)
+                            .onSizeChanged { contentWidth = it.width },
                     verticalAlignment = Alignment.CenterVertically,
-                    horizontalArrangement = Arrangement.spacedBy(4.dp),
                 ) {
-                    LibraryTab.entries.forEachIndexed { index, tab ->
+                    Spacer(Modifier.width(TAB_STRIP_LEADING_GAP))
-                        TabButton(
+                    Box(
-                            tab = tab,
+                        modifier =
-                            artwork = artwork,
+                            Modifier
-                            progress =
+                                .drawBehind {
-                                when (index) {
+                                    if (current != null &&
-                                    page -> 1f - transition
+                                        indicatorLeft != null &&
-                                    page + (if (fraction >= 0f) 1 else -1) -> transition
+                                        indicatorRight != null &&
-                                    else -> 0f
+                                        indicatorRight > indicatorLeft
+                                    ) {
+                                        val height = tabContentHeightPx.coerceAtMost(current.height)
+                                        drawRoundRect(
+                                            color = indicatorColor,
+                                            topLeft = Offset(indicatorLeft, current.top + (current.height - height) / 2f),
+                                            size = Size(indicatorRight - indicatorLeft, height),
+                                            cornerRadius = CornerRadius(8.dp.toPx()),
+                                        )
+                                    }
                                 },
-                            indicatorLeft = indicatorLeft,
+                    ) {
-                            indicatorRight = indicatorRight,
+                        Row(
-                            onClick = { onTabSelected(tab) },
+                            verticalAlignment = Alignment.CenterVertically,
-                            modifier =
+                            horizontalArrangement = Arrangement.spacedBy(4.dp),
-                                Modifier.onGloballyPositioned { coordinates ->
+                        ) {
-                                    bounds[index] = coordinates.boundsInParent()
+                            LibraryTab.entries.forEachIndexed { index, tab ->
-                                },
+                                TabButton(
-                        )
+                                    tab = tab,
-                    }
+                                    artwork = artwork,
-                    Spacer(Modifier.weight(1f))
+                                    progress =
-                    if (offline) {
+                                        when (index) {
-                        IconButton(onClick = onExitOffline) {
+                                            page -> 1f - transition
-                            Icon(
+                                            page + (if (fraction >= 0f) 1 else -1) -> transition
-                                imageVector = Icons.Rounded.CloudOff,
+                                            else -> 0f
-                                contentDescription = stringResource(R.string.offline_mode_status),
+                                        },
-                                tint = MaterialTheme.colorScheme.onBackground,
+                                    indicatorLeft = indicatorLeft,
-                            )
+                                    indicatorRight = indicatorRight,
-                        }
+                                    onClick = { onTabSelected(tab) },
-                    }
+                                    modifier =
-                    IconButton(onClick = onOpenSettings) {
+                                        Modifier.onGloballyPositioned { coordinates ->
-                        Box(contentAlignment = Alignment.Center) {
+                                            bounds[index] = coordinates.boundsInParent()
-                            Icon(
+                                        },
-                                imageVector = Icons.Rounded.Settings,
-                                contentDescription = stringResource(R.string.navigation_tabs_settings),
-                                tint = MaterialTheme.colorScheme.onBackground,
-                            )
-                            if (syncing) {
-                                CircularProgressIndicator(
-                                    modifier = Modifier.size(32.dp),
-                                    strokeWidth = 2.dp,
-                                    color = MaterialTheme.colorScheme.primary,
                                 )
                             }
                         }
                     }
                 }
+                IconButton(onClick = onOpenSettings) {
+                    Box(contentAlignment = Alignment.Center) {
+                        Icon(
+                            imageVector = Icons.Rounded.Settings,
+                            contentDescription = stringResource(R.string.navigation_tabs_settings),
+                            tint = MaterialTheme.colorScheme.onBackground,
+                        )
+                        if (syncing) {
+                            CircularProgressIndicator(
+                                modifier = Modifier.size(32.dp),
+                                strokeWidth = 2.dp,
+                                color = MaterialTheme.colorScheme.primary,
+                            )
+                        }
+                    }
+                }
             }
         }
     }

app/src/main/kotlin/com/subtracks/ui/library/LibraryViewModel.kt

@@ -23,6 +23,8 @@ import com.subtracks.data.repo.SourceRepository
 import com.subtracks.data.sync.SyncManager
 import com.subtracks.data.sync.SyncStatus
 import com.subtracks.playback.PlaybackController
+import com.subtracks.ui.components.ArtistArt
+import com.subtracks.ui.components.artistArt
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -211,6 +213,11 @@ class LibraryViewModel(
         thumbnail: Boolean,
     ): CoverArtRef? = sourceRepository.coverArt(coverArt, thumbnail)
 
+    fun artistArt(
+        artist: Artist,
+        forIcon: Boolean = true,
+    ): ArtistArt = sourceRepository.artistArt(artist, forIcon)
+
     fun sync() {
         if (syncManager.status.value !is SyncStatus.Running) syncManager.requestSync()
     }

app/src/main/kotlin/com/subtracks/ui/library/PlaylistDetailScreen.kt

@@ -7,7 +7,6 @@ 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.Modifier
 import androidx.compose.ui.platform.LocalContext
@@ -18,6 +17,7 @@ import androidx.paging.compose.itemKey
 import com.subtracks.R
 import com.subtracks.data.model.BulkDownloadAction
 import com.subtracks.data.model.CoverArtRef
+import com.subtracks.data.model.DownloadList
 import com.subtracks.data.model.ListDownloadStatus
 import com.subtracks.data.model.Playlist
 import com.subtracks.data.model.PlaylistSongItem
@@ -27,16 +27,16 @@ import com.subtracks.data.source.StarType
 import com.subtracks.playback.PlaybackController
 import com.subtracks.ui.components.CloseWhenDownloadsGone
 import com.subtracks.ui.components.ContextMenuHost
-import com.subtracks.ui.components.DeleteDownloadsDialog
 import com.subtracks.ui.components.DismissOnRequest
 import com.subtracks.ui.components.HeroDetailScaffold
 import com.subtracks.ui.components.HeroHeader
 import com.subtracks.ui.components.ItemActions
 import com.subtracks.ui.components.MenuTarget
+import com.subtracks.ui.components.PendingDownloadDeleteConfirmation
+import com.subtracks.ui.components.rememberPendingDownloadDelete
 import com.subtracks.ui.theme.ArtworkColors
 import com.subtracks.ui.theme.rememberArtworkColors
 import kotlinx.coroutines.flow.emptyFlow
-import kotlinx.coroutines.launch
 import org.koin.compose.koinInject
 import org.koin.compose.viewmodel.koinViewModel
 import org.koin.core.parameter.parametersOf
@@ -55,21 +55,17 @@ fun PlaylistDetailRoute(
     viewModel: PlaylistDetailViewModel = koinViewModel(key = playlistId) { parametersOf(playlistId) },
     playbackController: PlaybackController = koinInject(),
 ) {
-    val playlist by viewModel.playlist.collectAsStateWithLifecycle(initialValue = null)
+    val playlist by viewModel.playlist.collectAsStateWithLifecycle()
     val downloads by viewModel.downloads.collectAsStateWithLifecycle()
     val downloadStatus by viewModel.downloadStatus.collectAsStateWithLifecycle()
     val offline by viewModel.offline.collectAsStateWithLifecycle()
     CloseWhenDownloadsGone(downloadStatus.downloaded, offline, onBack)
-    val scope = rememberCoroutineScope()
+    val pendingDelete = rememberPendingDownloadDelete(contextMenuHost?.dismissals ?: emptyFlow()) { _, _ -> viewModel.downloadedBytes() }
-    var pendingDelete by remember { mutableStateOf<Long?>(null) }
-    DismissOnRequest(contextMenuHost?.dismissals ?: emptyFlow()) { pendingDelete = null }
     val playback by playbackController.state.collectAsStateWithLifecycle()
     val context = playback.context
     val requestDownloadAction: (BulkDownloadAction) -> Unit = { action ->
-        if (action == BulkDownloadAction.Delete) {
+        pendingDelete.onAction(playlist?.name.orEmpty(), DownloadList.Playlist, playlistId, action) { _, _, requested ->
-            scope.launch { pendingDelete = viewModel.downloadedBytes() }
+            viewModel.onDownloadAction(requested)
-        } else {
-            viewModel.onDownloadAction(action)
         }
     }
     val actions =
@@ -104,13 +100,8 @@ fun PlaylistDetailRoute(
         playingSongId = playback.item?.id.takeIf { context?.kind == QueueKind.Playlist && context.refId == playlistId },
     )
 
-    pendingDelete?.let { bytes ->
+    PendingDownloadDeleteConfirmation(pendingDelete) {
-        DeleteDownloadsDialog(
+        viewModel.onDownloadAction(BulkDownloadAction.Delete)
-            name = playlist?.name.orEmpty(),
-            bytes = bytes,
-            onConfirm = { viewModel.onDownloadAction(BulkDownloadAction.Delete) },
-            onDismiss = { pendingDelete = null },
-        )
     }
 }
 
@@ -138,6 +129,7 @@ fun PlaylistDetailScreen(
         artwork = artwork,
         title = playlist?.name.orEmpty(),
         onBack = onBack,
+        contentReady = songs.itemCount > 0,
         header = { controlsModifier, topInset ->
             HeroHeader(
                 art = coverArt(playlist?.coverArt, false),

app/src/main/kotlin/com/subtracks/ui/library/PlaylistDetailViewModel.kt

@@ -37,7 +37,10 @@ class PlaylistDetailViewModel(
 ) : ViewModel() {
     private val sourceId = libraryRepository.activeSourceId.filterNotNull()
 
-    val playlist: Flow<Playlist?> = sourceId.flatMapLatest { libraryRepository.playlist(it, playlistId) }
+    val playlist: StateFlow<Playlist?> =
+        sourceId
+            .flatMapLatest { libraryRepository.playlist(it, playlistId) }
+            .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), null)
 
     val songs: Flow<PagingData<PlaylistSongItem>> =
         combine(sourceId, sourceRepository.offline) { id, offline -> id to offline }

app/src/main/kotlin/com/subtracks/ui/playback/MiniPlayer.kt

@@ -44,6 +44,7 @@ import com.subtracks.R
 import com.subtracks.data.model.CoverArtRef
 import com.subtracks.playback.PlaybackState
 import com.subtracks.ui.components.CoverArt
+import com.subtracks.ui.components.artistSubtitle
 import com.subtracks.ui.theme.ArtworkColors
 import com.subtracks.ui.theme.ArtworkTheme
 import com.subtracks.ui.theme.playerSurfaceColor
@@ -139,7 +140,7 @@ fun MiniPlayer(
                             modifier = Modifier.basicMarquee(),
                         )
                         Text(
-                            text = item.artist ?: item.album.orEmpty(),
+                            text = artistSubtitle(item.artist, item.artists) ?: item.album.orEmpty(),
                             style = MaterialTheme.typography.bodySmall,
                             color = MaterialTheme.colorScheme.onSurfaceVariant,
                             maxLines = 1,

app/src/main/kotlin/com/subtracks/ui/playback/NowPlayingScreen.kt

@@ -90,6 +90,7 @@ import com.subtracks.ui.components.ContextMenuHost
 import com.subtracks.ui.components.CoverArt
 import com.subtracks.ui.components.ItemActions
 import com.subtracks.ui.components.MenuTarget
+import com.subtracks.ui.components.artistSubtitle
 import com.subtracks.ui.components.prefetchArtworkRatio
 import com.subtracks.ui.theme.ArtworkColors
 import com.subtracks.ui.theme.ArtworkSeedCache
@@ -576,7 +577,10 @@ fun NowPlayingScreen(
                                 }
                                 Box(Modifier.height(subtitleHeight), contentAlignment = Alignment.CenterStart) {
                                     Text(
-                                        text = state.item?.artist.orEmpty(),
+                                        text =
+                                            state.item
+                                                ?.let { artistSubtitle(it.artist, it.artists) }
+                                                .orEmpty(),
                                         style = subtitleStyle,
                                         color = MaterialTheme.colorScheme.onSurfaceVariant,
                                         maxLines = 1,

app/src/main/kotlin/com/subtracks/ui/search/SearchScreen.kt

@@ -46,6 +46,7 @@ import com.subtracks.data.model.Playlist
 import com.subtracks.data.model.Song
 import com.subtracks.data.source.StarType
 import com.subtracks.playback.PlaybackController
+import com.subtracks.ui.components.ArtistArt
 import com.subtracks.ui.components.ContextMenuHost
 import com.subtracks.ui.components.EmptyState
 import com.subtracks.ui.components.ItemActions
@@ -106,6 +107,7 @@ fun SearchRoute(
             if (next != 0) filterMask = next
         },
         coverArt = viewModel::coverArt,
+        artistArt = { viewModel.artistArt(it) },
         playingSongId = playback.item?.id,
         onBack = onBack,
         onAlbumClick = {
@@ -146,6 +148,7 @@ fun SearchScreen(
     filters: Set<SearchFilter> = ALL_FILTERS,
     onToggleFilter: (SearchFilter) -> Unit = {},
     coverArt: (String?, Boolean) -> CoverArtRef? = { _, _ -> null },
+    artistArt: (Artist) -> ArtistArt = { ArtistArt() },
     playingSongId: String? = null,
     onBack: () -> Unit = {},
     onAlbumClick: (Album) -> Unit = {},
@@ -215,7 +218,7 @@ fun SearchScreen(
                     contentPadding = PaddingValues(bottom = 24.dp),
                 ) {
                     if (showPlaylists) playlistResults(results.playlists, playlistsLabel, coverArt, onPlaylistClick, onLongClick)
-                    if (showArtists) artistResults(results.artists, artistsLabel, coverArt, onArtistClick, onLongClick)
+                    if (showArtists) artistResults(results.artists, artistsLabel, artistArt, onArtistClick, onLongClick)
                     if (showAlbums) albumResults(results.albums, albumsLabel, coverArt, onAlbumClick, onLongClick)
                     if (showSongs) songResults(results.songs, songsLabel, coverArt, playingSongId, onSongClick, onLongClick)
                 }
@@ -308,19 +311,20 @@ private fun LazyListScope.albumResults(
 private fun LazyListScope.artistResults(
     artists: List<Artist>,
     header: String,
-    coverArt: (String?, Boolean) -> CoverArtRef?,
+    artistArt: (Artist) -> ArtistArt,
     onClick: (Artist) -> Unit,
     onLongClick: (MenuTarget) -> Unit,
 ) {
     if (artists.isEmpty()) return
     resultHeader(header)
     items(artists, key = { "artist-${it.id}" }) { artist ->
+        val art = artistArt(artist)
         ArtistListRow(
             artist = artist,
-            coverArt = coverArt,
+            art = art,
             info = null,
             onClick = { onClick(artist) },
-            onLongClick = { onLongClick(MenuTarget.Artist(artist, coverArt(artist.coverArt, true))) },
+            onLongClick = { onLongClick(MenuTarget.Artist(artist, art.primary)) },
         )
     }
 }

app/src/main/kotlin/com/subtracks/ui/search/SearchViewModel.kt

@@ -12,6 +12,8 @@ import com.subtracks.data.model.Song
 import com.subtracks.data.repo.LibraryRepository
 import com.subtracks.data.repo.SourceRepository
 import com.subtracks.playback.PlaybackController
+import com.subtracks.ui.components.ArtistArt
+import com.subtracks.ui.components.artistArt
 import com.subtracks.ui.home.playSongInContext
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -74,6 +76,11 @@ class SearchViewModel(
         thumbnail: Boolean,
     ): CoverArtRef? = sourceRepository.coverArt(coverArt, thumbnail)
 
+    fun artistArt(
+        artist: Artist,
+        forIcon: Boolean = true,
+    ): ArtistArt = sourceRepository.artistArt(artist, forIcon)
+
     fun play(song: Song) {
         viewModelScope.playSongInContext(libraryRepository, playbackController, song)
     }

app/src/main/kotlin/com/subtracks/ui/settings/SettingsScreen.kt

@@ -74,6 +74,8 @@ import com.subtracks.data.prefs.DEFAULT_SYNC_INTERVAL_MINUTES
 import com.subtracks.data.prefs.MAX_REPLAY_GAIN_PREAMP_DB
 import com.subtracks.data.prefs.MIN_REPLAY_GAIN_PREAMP_DB
 import com.subtracks.data.prefs.ReplayGainMode
+import com.subtracks.data.prefs.SongTapBehavior
+import com.subtracks.data.prefs.SortNameMode
 import com.subtracks.data.prefs.StreamQuality
 import com.subtracks.data.prefs.SyncMode
 import com.subtracks.log.Log
@@ -101,6 +103,8 @@ private enum class SettingsDialog {
     SyncMode,
     ReplayGain,
     ReplayGainPreamp,
+    SortNames,
+    SongTap,
 }
 
 @Composable
@@ -128,6 +132,8 @@ fun SettingsRoute(
     val verboseLogging by viewModel.verboseLogging.collectAsStateWithLifecycle()
     val replayGainMode by viewModel.replayGainMode.collectAsStateWithLifecycle()
     val replayGainPreamp by viewModel.replayGainPreamp.collectAsStateWithLifecycle()
+    val sortNameMode by viewModel.sortNameMode.collectAsStateWithLifecycle()
+    val songTapBehavior by viewModel.songTapBehavior.collectAsStateWithLifecycle()
     val context = LocalContext.current
     val scope = rememberCoroutineScope()
     SettingsScreen(
@@ -143,6 +149,8 @@ fun SettingsRoute(
         scrobbling = scrobbling,
         replayGainMode = replayGainMode,
         replayGainPreamp = replayGainPreamp,
+        sortNameMode = sortNameMode,
+        songTapBehavior = songTapBehavior,
         keepScreenOn = keepScreenOn,
         offline = offline,
         verboseLogging = verboseLogging,
@@ -158,6 +166,8 @@ fun SettingsRoute(
         onScrobblingChange = viewModel::setScrobbling,
         onReplayGainModeChange = viewModel::setReplayGainMode,
         onReplayGainPreampChange = viewModel::setReplayGainPreamp,
+        onSortNameModeChange = viewModel::setSortNameMode,
+        onSongTapBehaviorChange = viewModel::setSongTapBehavior,
         onKeepScreenOnChange = viewModel::setKeepScreenOn,
         onOfflineChange = viewModel::setOfflineMode,
         onVerboseLoggingChange = viewModel::setVerboseLogging,
@@ -205,6 +215,8 @@ fun SettingsScreen(
     syncInterval: Int = DEFAULT_SYNC_INTERVAL_MINUTES,
     replayGainMode: ReplayGainMode = ReplayGainMode.Auto,
     replayGainPreamp: Float = 0f,
+    sortNameMode: SortNameMode = SortNameMode.Name,
+    songTapBehavior: SongTapBehavior = SongTapBehavior.InOrder,
     onSelectSource: (Long) -> Unit,
     onEditServer: (Long) -> Unit,
     onWifiQualityChange: (StreamQuality) -> Unit,
@@ -217,6 +229,8 @@ fun SettingsScreen(
     onScrobblingChange: (Boolean) -> Unit,
     onReplayGainModeChange: (ReplayGainMode) -> Unit = {},
     onReplayGainPreampChange: (Float) -> Unit = {},
+    onSortNameModeChange: (SortNameMode) -> Unit = {},
+    onSongTapBehaviorChange: (SongTapBehavior) -> Unit = {},
     onKeepScreenOnChange: (Boolean) -> Unit = {},
     onOfflineChange: (Boolean) -> Unit = {},
     onVerboseLoggingChange: (Boolean) -> Unit = {},
@@ -348,6 +362,15 @@ fun SettingsScreen(
                     colors = ListItemDefaults.colors(containerColor = Color.Transparent),
                 )
             }
+            item { SectionHeader(stringResource(R.string.settings_library_name)) }
+            item {
+                ListItem(
+                    headlineContent = { Text(stringResource(R.string.settings_sort_names_title)) },
+                    supportingContent = { Text(sortNameModeLabel(LocalResources.current, sortNameMode)) },
+                    modifier = Modifier.clickable { dialog = SettingsDialog.SortNames },
+                    colors = ListItemDefaults.colors(containerColor = Color.Transparent),
+                )
+            }
             item { SectionHeader(stringResource(R.string.settings_music_name)) }
             item {
                 ListItem(
@@ -405,6 +428,14 @@ fun SettingsScreen(
                     colors = ListItemDefaults.colors(containerColor = Color.Transparent),
                 )
             }
+            item {
+                ListItem(
+                    headlineContent = { Text(stringResource(R.string.settings_music_options_song_tap_title)) },
+                    supportingContent = { Text(songTapBehaviorLabel(LocalResources.current, songTapBehavior)) },
+                    modifier = Modifier.clickable { dialog = SettingsDialog.SongTap },
+                    colors = ListItemDefaults.colors(containerColor = Color.Transparent),
+                )
+            }
             item { SectionHeader(stringResource(R.string.downloads_title)) }
             item {
                 ListItem(
@@ -603,6 +634,22 @@ fun SettingsScreen(
             )
         }
 
+        SettingsDialog.SortNames -> {
+            SortNameModeDialog(
+                selected = sortNameMode,
+                onSelect = onSortNameModeChange,
+                onDismiss = { dialog = null },
+            )
+        }
+
+        SettingsDialog.SongTap -> {
+            SongTapBehaviorDialog(
+                selected = songTapBehavior,
+                onSelect = onSongTapBehaviorChange,
+                onDismiss = { dialog = null },
+            )
+        }
+
         null -> {
             Unit
         }
@@ -756,6 +803,95 @@ private fun SyncModeDialog(
     )
 }
 
+private val sortNameModeOptions =
+    listOf(SortNameMode.Name, SortNameMode.SortName, SortNameMode.NonLatin)
+
+private fun sortNameModeLabel(
+    resources: Resources,
+    mode: SortNameMode,
+): String =
+    when (mode) {
+        SortNameMode.SortName -> resources.getString(R.string.sort_name_mode_sort_name)
+        SortNameMode.Name -> resources.getString(R.string.sort_name_mode_name)
+        SortNameMode.NonLatin -> resources.getString(R.string.sort_name_mode_non_latin)
+    }
+
+@Composable
+private fun SortNameModeDialog(
+    selected: SortNameMode,
+    onSelect: (SortNameMode) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    val resources = LocalResources.current
+    var draft by remember(selected) { mutableStateOf(selected) }
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(stringResource(R.string.settings_sort_names_title)) },
+        text = {
+            ChoiceGroup(
+                header = stringResource(R.string.settings_sort_names_prompt),
+                options = sortNameModeOptions.map { it to sortNameModeLabel(resources, it) },
+                selected = draft,
+                onSelect = { draft = it },
+            )
+        },
+        confirmButton = {
+            TextButton(
+                onClick = {
+                    onSelect(draft)
+                    onDismiss()
+                },
+            ) { Text(stringResource(R.string.action_done)) }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismiss) { Text(stringResource(R.string.actions_cancel)) }
+        },
+    )
+}
+
+private fun songTapBehaviorLabel(
+    resources: Resources,
+    behavior: SongTapBehavior,
+): String =
+    when (behavior) {
+        SongTapBehavior.InOrder -> resources.getString(R.string.settings_music_options_song_tap_in_order)
+        SongTapBehavior.KeepShuffle -> resources.getString(R.string.settings_music_options_song_tap_keep_shuffle)
+        SongTapBehavior.Shuffle -> resources.getString(R.string.settings_music_options_song_tap_shuffle)
+    }
+
+@Composable
+private fun SongTapBehaviorDialog(
+    selected: SongTapBehavior,
+    onSelect: (SongTapBehavior) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    val resources = LocalResources.current
+    var draft by remember(selected) { mutableStateOf(selected) }
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(stringResource(R.string.settings_music_options_song_tap_title)) },
+        text = {
+            ChoiceGroup(
+                header = stringResource(R.string.settings_music_options_song_tap_prompt),
+                options = SongTapBehavior.entries.map { it to songTapBehaviorLabel(resources, it) },
+                selected = draft,
+                onSelect = { draft = it },
+            )
+        },
+        confirmButton = {
+            TextButton(
+                onClick = {
+                    onSelect(draft)
+                    onDismiss()
+                },
+            ) { Text(stringResource(R.string.action_done)) }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismiss) { Text(stringResource(R.string.actions_cancel)) }
+        },
+    )
+}
+
 @Composable
 private fun ReplayGainModeDialog(
     selected: ReplayGainMode,

app/src/main/kotlin/com/subtracks/ui/settings/SettingsViewModel.kt

@@ -6,6 +6,8 @@ import com.subtracks.data.model.Source
 import com.subtracks.data.net.NetworkMode
 import com.subtracks.data.prefs.DEFAULT_SYNC_INTERVAL_MINUTES
 import com.subtracks.data.prefs.ReplayGainMode
+import com.subtracks.data.prefs.SongTapBehavior
+import com.subtracks.data.prefs.SortNameMode
 import com.subtracks.data.prefs.StreamQuality
 import com.subtracks.data.prefs.SyncMode
 import com.subtracks.data.prefs.UserPreferences
@@ -76,6 +78,16 @@ class SettingsViewModel(
             .replayGainPreampDb()
             .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), 0f)
 
+    val sortNameMode: StateFlow<SortNameMode> =
+        userPreferences
+            .sortNameMode()
+            .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), SortNameMode.Name)
+
+    val songTapBehavior: StateFlow<SongTapBehavior> =
+        userPreferences
+            .songTapBehavior()
+            .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), SongTapBehavior.InOrder)
+
     val keepScreenOn: StateFlow<Boolean> =
         userPreferences
             .keepScreenOn()
@@ -143,4 +155,12 @@ class SettingsViewModel(
     fun setKeepScreenOn(enabled: Boolean) {
         viewModelScope.launch { userPreferences.setKeepScreenOn(enabled) }
     }
+
+    fun setSortNameMode(mode: SortNameMode) {
+        viewModelScope.launch { userPreferences.setSortNameMode(mode) }
+    }
+
+    fun setSongTapBehavior(behavior: SongTapBehavior) {
+        viewModelScope.launch { userPreferences.setSongTapBehavior(behavior) }
+    }
 }

app/src/main/res/values/ic_launcher_background.xml

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
-    <color name="ic_launcher_background">#120C12</color>
+    <color name="ic_launcher_background">#2D1C2D</color>
 </resources>

app/src/main/res/values/strings.xml

@@ -79,9 +79,15 @@
     <string name="settings_about_verbose_logging">Verbose logging</string>
     <string name="settings_about_verbose_logging_description">Log extra detail for troubleshooting</string>
     <string name="settings_about_version">Version %1$s</string>
+    <string name="settings_library_name">Library</string>
     <string name="settings_music_name">Playback</string>
     <string name="settings_music_options_scrobble_description_on">Send now playing and play counts</string>
     <string name="settings_music_options_scrobble_title">Scrobble to server</string>
+    <string name="settings_music_options_song_tap_in_order">Play without shuffling</string>
+    <string name="settings_music_options_song_tap_keep_shuffle">Keep current shuffle mode</string>
+    <string name="settings_music_options_song_tap_prompt">When tapping a song in a list</string>
+    <string name="settings_music_options_song_tap_shuffle">Play and shuffle</string>
+    <string name="settings_music_options_song_tap_title">Song tap behavior</string>
     <string name="settings_replay_gain_mode_album">Album gain</string>
     <string name="settings_replay_gain_mode_auto">Auto</string>
     <string name="settings_replay_gain_mode_off">Off</string>
@@ -96,6 +102,11 @@
     <string name="settings_replay_gain_title">ReplayGain</string>
     <string name="settings_music_options_keep_screen_on_description">Keep the screen on while now playing is open</string>
     <string name="settings_music_options_keep_screen_on_title">Keep screen on</string>
+    <string name="settings_sort_names_title">Sort names</string>
+    <string name="settings_sort_names_prompt">Choose how names are ordered in album and artist lists.</string>
+    <string name="sort_name_mode_sort_name">Use sort names</string>
+    <string name="sort_name_mode_name">Use regular names</string>
+    <string name="sort_name_mode_non_latin">Non-Latin names only</string>
     <string name="settings_network_name">Network</string>
     <string name="settings_network_options_max_bitrate_mobile_title">Stream quality: Mobile</string>
     <string name="settings_network_options_max_bitrate_wifi_title">Stream quality: Wi-Fi</string>
@@ -191,6 +202,24 @@
     <string name="info_sample_rate_value">%1$d Hz</string>
     <string name="info_channels">Channels</string>
     <string name="info_close">Close</string>
+    <string name="info_artists">Artists</string>
+    <string name="info_artists_sort">Artists sort</string>
+    <string name="info_album_artists">Album artists</string>
+    <string name="info_album_artist_sort">Album artist sort</string>
+    <string name="info_sort_title">Sort title</string>
+    <string name="info_artist_sort">Artist sort</string>
+    <string name="info_sort_name">Sort name</string>
+    <string name="info_albums">Albums</string>
+    <string name="info_songs">Songs</string>
+    <string name="info_plays">Plays</string>
+    <string name="info_last_played">Last played</string>
+    <string name="info_added">Added</string>
+    <string name="info_created">Created</string>
+    <string name="info_updated">Updated</string>
+    <string name="info_owner">Owner</string>
+    <string name="info_shared">Shared</string>
+    <string name="info_length">Length</string>
+    <string name="info_downloaded_count">%1$d of %2$d</string>
 
     <string name="disc_header">Disc %1$d</string>
     <string name="disc_track">%1$s: Disc %2$d</string>

app/src/nightly/res/values/ic_launcher_background.xml

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
-    <color name="ic_launcher_background">#1A1200</color>
+    <color name="ic_launcher_background">#2E2000</color>
 </resources>

app/src/test/kotlin/com/subtracks/data/db/AlbumCreditsTest.kt

@@ -0,0 +1,58 @@
+package com.subtracks.data.db
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class AlbumCreditsTest {
+    @Test
+    fun everyVariantUsesAllFourCreditPaths() {
+        val variants =
+            listOf(
+                CREDITED_ALBUM_ROWS,
+                DOWNLOADED_ALBUM_ROWS,
+                DOWNLOADED_ALBUM_DETAILS_FOR_ARTIST,
+                DOWNLOADED_COVER_ALBUM_ROWS,
+                ARTIST_COVER_CREDITS,
+                ARTIST_COVER_CREDITS_FOR_ARTIST,
+                ALBUMS_FOR_ARTIST_DOWNLOADED,
+            )
+        variants.forEach { sql ->
+            assertEquals(sql, 1, sql.occurrences("FROM albums"))
+            assertEquals(sql, 1, sql.occurrences("FROM album_artists"))
+            assertEquals(sql, 1, sql.occurrences("FROM songs JOIN albums"))
+            assertEquals(sql, 1, sql.occurrences("FROM song_artists"))
+        }
+    }
+
+    @Test
+    fun variantsKeepTheirOwnFiltersAndDuplicateSemantics() {
+        assertFalse(CREDITED_ALBUM_ROWS.contains("coverArt IS NOT NULL"))
+        assertFalse(CREDITED_ALBUM_ROWS.contains("song_downloads"))
+        assertTrue(CREDITED_ALBUM_ROWS.contains(" UNION ALL "))
+        assertEquals(4, ARTIST_COVER_CREDITS.occurrences("coverArt IS NOT NULL"))
+        assertEquals(4, ARTIST_COVER_CREDITS_FOR_ARTIST.occurrences("= :artistId"))
+        assertEquals(4, DOWNLOADED_ALBUM_ROWS.occurrences("sd.status = 'Completed'"))
+        assertEquals(4, DOWNLOADED_ALBUM_DETAILS_FOR_ARTIST.occurrences("= :artistId"))
+        assertEquals(4, DOWNLOADED_COVER_ALBUM_ROWS.occurrences("coverArt IS NOT NULL"))
+        assertTrue(DOWNLOADED_ALBUM_ROWS.contains(" UNION "))
+        assertFalse(DOWNLOADED_ALBUM_ROWS.contains(" UNION ALL "))
+        assertFalse(DOWNLOADED_ALBUM_ROWS.contains("creditType"))
+    }
+
+    @Test
+    fun consumersEmbedTheSharedVariants() {
+        assertTrue(ALBUMS_FOR_ARTIST.contains(CREDITED_ALBUM_ROWS))
+        assertTrue(ALBUM_CREDIT_ALBUM_IDS.contains(CREDITED_ALBUM_ROWS))
+        assertTrue(ARTIST_AGGREGATES_SQL.contains(CREDITED_ALBUM_ROWS))
+        assertTrue(DOWNLOADED_ARTIST_ALBUMS.contains(DOWNLOADED_ALBUM_ROWS))
+        assertTrue(ALBUMS_FOR_ARTIST_DOWNLOADED.contains(DOWNLOADED_ALBUM_DETAILS_FOR_ARTIST))
+        assertTrue(ARTIST_COVER_ARTS_SQL.contains(ARTIST_COVER_CREDITS_FOR_ARTIST))
+        assertTrue(ARTIST_ART_UPDATE_SQL.contains(ARTIST_COVER_CREDITS))
+        assertTrue(ARTIST_ART_UPDATE_SQL.contains(DOWNLOADED_COVER_ALBUM_ROWS))
+        assertTrue(DOWNLOADED_ARTIST_ART_UPDATE_SQL.contains(DOWNLOADED_COVER_ALBUM_ROWS))
+    }
+
+    private fun String.occurrences(value: String): Int = split(value).size - 1
+}

app/src/test/kotlin/com/subtracks/data/db/ArtworkSeedDaoTest.kt

@@ -1,9 +1,5 @@
 package com.subtracks.data.db
 
-import android.content.Context
-import androidx.room3.Room
-import androidx.sqlite.driver.bundled.BundledSQLiteDriver
-import androidx.test.core.app.ApplicationProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import com.subtracks.data.model.ArtworkSeed
 import com.subtracks.data.model.Source
@@ -22,12 +18,7 @@ class ArtworkSeedDaoTest {
 
     @Before
     fun setUp() {
-        val context = ApplicationProvider.getApplicationContext<Context>()
+        db = createTestDatabase()
-        db =
-            Room
-                .inMemoryDatabaseBuilder(context, SubtracksDatabase::class.java)
-                .setDriver(BundledSQLiteDriver())
-                .build()
     }
 
     @After

app/src/test/kotlin/com/subtracks/data/db/LibraryHomeDaoTest.kt

@@ -1,11 +1,7 @@
 package com.subtracks.data.db
 
-import android.content.Context
 import androidx.paging.PagingSource
-import androidx.room3.Room
 import androidx.room3.useWriterConnection
-import androidx.sqlite.driver.bundled.BundledSQLiteDriver
-import androidx.test.core.app.ApplicationProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import com.subtracks.data.model.Album
 import com.subtracks.data.model.Artist
@@ -27,12 +23,7 @@ class LibraryHomeDaoTest {
 
     @Before
     fun setUp() {
-        val context = ApplicationProvider.getApplicationContext<Context>()
+        db = createTestDatabase()
-        db =
-            Room
-                .inMemoryDatabaseBuilder(context, SubtracksDatabase::class.java)
-                .setDriver(BundledSQLiteDriver())
-                .build()
     }
 
     @After

app/src/test/kotlin/com/subtracks/data/db/LibraryPagingTestSupport.kt

@@ -0,0 +1,109 @@
+package com.subtracks.data.db
+
+import androidx.paging.PagingSource
+import com.subtracks.data.model.Album
+import com.subtracks.data.model.Artist
+import com.subtracks.data.model.Playlist
+import com.subtracks.data.prefs.AlbumSort
+import com.subtracks.data.prefs.ArtistSort
+import com.subtracks.data.prefs.PlaylistSort
+import com.subtracks.data.prefs.SortNameMode
+
+internal fun LibraryDao.albumPages(
+    sourceId: Long,
+    starredFilter: Int = 0,
+    search: String = "",
+    sort: AlbumSort = AlbumSort.Name,
+    descending: Boolean = false,
+    downloaded: Boolean = false,
+    sortNameMode: SortNameMode = SortNameMode.SortName,
+): PagingSource<Int, Album> =
+    if (downloaded) {
+        downloadedAlbumsPaging(
+            albumsPageQuery(
+                sourceId = sourceId,
+                starredFilter = starredFilter,
+                search = search,
+                sort = sort,
+                descending = descending,
+                downloaded = true,
+                sortNameMode = sortNameMode,
+            ),
+        )
+    } else {
+        albumsPaging(
+            albumsPageQuery(
+                sourceId = sourceId,
+                starredFilter = starredFilter,
+                search = search,
+                sort = sort,
+                descending = descending,
+                downloaded = false,
+                sortNameMode = sortNameMode,
+            ),
+        )
+    }
+
+internal fun LibraryDao.artistPages(
+    sourceId: Long,
+    starredFilter: Int = 0,
+    search: String = "",
+    sort: ArtistSort = ArtistSort.Name,
+    descending: Boolean = false,
+    downloaded: Boolean = false,
+    sortNameMode: SortNameMode = SortNameMode.SortName,
+): PagingSource<Int, Artist> =
+    if (downloaded) {
+        downloadedArtistsPaging(
+            artistsPageQuery(
+                sourceId = sourceId,
+                starredFilter = starredFilter,
+                search = search,
+                sort = sort,
+                descending = descending,
+                downloaded = true,
+                sortNameMode = sortNameMode,
+            ),
+        )
+    } else {
+        artistsPaging(
+            artistsPageQuery(
+                sourceId = sourceId,
+                starredFilter = starredFilter,
+                search = search,
+                sort = sort,
+                descending = descending,
+                downloaded = false,
+                sortNameMode = sortNameMode,
+            ),
+        )
+    }
+
+internal fun LibraryDao.playlistPages(
+    sourceId: Long,
+    search: String = "",
+    sort: PlaylistSort = PlaylistSort.Name,
+    descending: Boolean = false,
+    downloaded: Boolean = false,
+): PagingSource<Int, Playlist> =
+    if (downloaded) {
+        downloadedPlaylistsPaging(
+            playlistsPageQuery(
+                sourceId = sourceId,
+                search = search,
+                sort = sort,
+                descending = descending,
+                downloaded = true,
+            ),
+        )
+    } else {
+        playlistsPaging(
+            playlistsPageQuery(
+                sourceId = sourceId,
+                search = search,
+                sort = sort,
+                descending = descending,
+                downloaded = false,
+            ),
+        )
+    }

app/src/test/kotlin/com/subtracks/data/db/MigrationsTest.kt

@@ -7,6 +7,7 @@ import androidx.test.ext.junit.runners.AndroidJUnit4
 import kotlinx.coroutines.test.runTest
 import org.json.JSONObject
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
 import org.junit.Test
 import org.junit.runner.RunWith
 import java.io.File
@@ -153,6 +154,111 @@ class MigrationsTest {
             }
         }
 
+    @Test
+    fun theArtistArtColumnsDefaultToEmptyAndAcceptValues() =
+        runTest {
+            driver.open(":memory:").use { migrated ->
+                applySchema(migrated, 35)
+                migrated.execSQL(
+                    "INSERT INTO sources (id, name, address, isActive, createdAt) VALUES (1, 's', 'http://x', 1, 0)",
+                )
+                migrated.execSQL(
+                    "INSERT INTO artists (sourceId, id, name, albumCount, starred) " +
+                        "VALUES (1, 'ar1', 'Artist', 0, NULL)",
+                )
+
+                MIGRATION_35_36.migrate(migrated)
+
+                assertEquals(1L, long(migrated, "SELECT artistImageUrl IS NULL FROM artists WHERE id = 'ar1'"))
+                assertEquals("", text(migrated, "SELECT coverArts FROM artists WHERE id = 'ar1'"))
+                assertEquals("", text(migrated, "SELECT downloadedCoverArts FROM artists WHERE id = 'ar1'"))
+                migrated.execSQL(
+                    "UPDATE artists SET artistImageUrl = 'http://img', coverArts = 'a\u001fb', " +
+                        "downloadedCoverArts = 'c' WHERE id = 'ar1'",
+                )
+                assertEquals("http://img", text(migrated, "SELECT artistImageUrl FROM artists WHERE id = 'ar1'"))
+                assertEquals("a\u001fb", text(migrated, "SELECT coverArts FROM artists WHERE id = 'ar1'"))
+                assertEquals("c", text(migrated, "SELECT downloadedCoverArts FROM artists WHERE id = 'ar1'"))
+            }
+        }
+
+    @Test
+    fun theArtistArtMigrationBackfillsExistingLibraries() =
+        runTest {
+            driver.open(":memory:").use { migrated ->
+                applySchema(migrated, 35)
+                migrated.execSQL(
+                    "INSERT INTO sources (id, name, address, isActive, createdAt) VALUES (1, 's', 'http://x', 1, 0)",
+                )
+                migrated.execSQL(
+                    "INSERT INTO artists (sourceId, id, name, albumCount, starred) " +
+                        "VALUES (1, 'ar1', 'Artist', 3, NULL)",
+                )
+                migrated.execSQL(
+                    "INSERT INTO albums (sourceId, id, artistId, name, albumArtist, created, coverArt, genre, " +
+                        "year, starred, songCount) VALUES " +
+                        "(1, 'al1', 'ar1', 'Shared', 'Artist', 0, 'shared', NULL, 2020, NULL, 1), " +
+                        "(1, 'al2', 'ar1', 'Shared Newer', 'Artist', 0, 'shared', NULL, 2021, NULL, 1), " +
+                        "(1, 'al3', 'ar1', 'Other', 'Artist', 0, 'other', NULL, 2019, NULL, 1)",
+                )
+                migrated.execSQL(
+                    "INSERT INTO songs (sourceId, id, albumId, artistId, title) VALUES " +
+                        "(1, 's1', 'al1', 'ar1', 'One'), (1, 's2', 'al2', 'ar1', 'Two'), " +
+                        "(1, 's3', 'al3', 'ar1', 'Three')",
+                )
+                migrated.execSQL(
+                    "INSERT INTO song_downloads (sourceId, songId, status, bytes, total) VALUES " +
+                        "(1, 's1', 'Completed', 1, 1), (1, 's2', 'Completed', 1, 1)",
+                )
+
+                MIGRATION_35_36.migrate(migrated)
+
+                assertEquals("shared\u001fother", text(migrated, "SELECT coverArts FROM artists WHERE id = 'ar1'"))
+                assertEquals("shared", text(migrated, "SELECT downloadedCoverArts FROM artists WHERE id = 'ar1'"))
+            }
+        }
+
+    @Test
+    fun theArtistSearchTriggersIgnoreArtOnlyUpdates() =
+        runTest {
+            driver.open(":memory:").use { migrated ->
+                applySchema(migrated, 35)
+                MIGRATION_35_36.migrate(migrated)
+
+                assertTrue(artistSearchTriggersOptimized(migrated))
+                assertTrue(
+                    triggerSql(migrated, "room_fts_content_sync_artist_search_BEFORE_UPDATE")
+                        .contains("UPDATE OF `name`, `sortName`"),
+                )
+                assertTrue(
+                    triggerSql(migrated, "room_fts_content_sync_artist_search_AFTER_UPDATE")
+                        .contains("UPDATE OF `name`, `sortName`"),
+                )
+            }
+        }
+
+    @Test
+    fun theFreshDatabaseCallbackOptimizesTheArtistSearchTriggers() =
+        runTest {
+            driver.open(":memory:").use { connection ->
+                applySchema(connection, 36)
+                connection.execSQL(
+                    "INSERT INTO sources (id, name, address, isActive, createdAt) VALUES (1, 's', 'http://x', 1, 0)",
+                )
+                connection.execSQL(
+                    "INSERT INTO artists (sourceId, id, name, albumCount, starred) " +
+                        "VALUES (1, 'ar1', 'Artist', 0, NULL)",
+                )
+
+                ArtistSearchTriggerOptimization.onOpen(connection)
+                assertTrue(artistSearchTriggersOptimized(connection))
+                val before = long(connection, "SELECT total_changes()")
+                connection.execSQL("UPDATE artists SET coverArts = 'a' WHERE id = 'ar1'")
+
+                assertEquals(before + 1, long(connection, "SELECT total_changes()"))
+            }
+        }
+
     @Test
     fun theGenreBackfillTrimsAndSkipsBlankSingularGenres() =
         runTest {
@@ -395,6 +501,16 @@ class MigrationsTest {
             statement.getLong(0)
         }
 
+    private fun triggerSql(
+        connection: SQLiteConnection,
+        trigger: String,
+    ): String =
+        connection.prepare("SELECT sql FROM sqlite_master WHERE type = 'trigger' AND name = ?").use { statement ->
+            statement.bindText(1, trigger)
+            check(statement.step()) { "No trigger $trigger" }
+            statement.getText(0)
+        }
+
     private fun indexColumn(
         connection: SQLiteConnection,
         index: String,
@@ -428,6 +544,10 @@ class MigrationsTest {
             for (i in 0 until indices.length()) {
                 connection.execSQL(indices.getJSONObject(i).getString("createSql").replace("\${TABLE_NAME}", name))
             }
+            val triggers = entity.optJSONArray("contentSyncTriggers") ?: continue
+            for (i in 0 until triggers.length()) {
+                connection.execSQL(triggers.getString(i))
+            }
         }
     }
 

app/src/test/kotlin/com/subtracks/data/db/QueryTimingMeasurementTest.kt

@@ -1,12 +1,9 @@
 package com.subtracks.data.db
 
-import android.content.Context
 import androidx.paging.PagingSource
-import androidx.room3.Room
 import androidx.room3.immediateTransaction
 import androidx.room3.useWriterConnection
 import androidx.sqlite.driver.bundled.BundledSQLiteDriver
-import androidx.test.core.app.ApplicationProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import com.subtracks.data.model.Album
 import com.subtracks.data.model.Artist
@@ -14,6 +11,9 @@ import com.subtracks.data.model.Playlist
 import com.subtracks.data.model.PlaylistSong
 import com.subtracks.data.model.Song
 import com.subtracks.data.model.Source
+import com.subtracks.data.prefs.AlbumSort
+import com.subtracks.data.prefs.ArtistSort
+import com.subtracks.data.prefs.PlaylistSort
 import com.subtracks.data.source.MusicSource
 import com.subtracks.data.source.StarType
 import com.subtracks.data.sync.SyncService
@@ -37,9 +37,8 @@ class QueryTimingMeasurementTest {
 
     @Before
     fun setUp() {
-        val context = ApplicationProvider.getApplicationContext<Context>()
         val driver = LoggingSQLiteDriver(BundledSQLiteDriver()) { executions += it }
-        db = Room.inMemoryDatabaseBuilder(context, SubtracksDatabase::class.java).setDriver(driver).build()
+        db = createTestDatabase(driver)
     }
 
     @After
@@ -105,28 +104,37 @@ class QueryTimingMeasurementTest {
 
     private suspend fun measureReads() {
         val dao = db.libraryDao()
-        timed("albums first page (name)") { dao.albumsByName(1, 0, "").firstPage() }
+        timed("albums first page (name)") { dao.albumPages(1, 0, "", sort = AlbumSort.Name).firstPage() }
-        timed("albums first page (artist)") { dao.albumsByArtist(1, 0, "").firstPage() }
+        timed("albums first page (name, downloaded)") {
-        timed("albums first page (year)") { dao.albumsByYear(1, 0, "").firstPage() }
+            dao.albumPages(1, 0, "", sort = AlbumSort.Name, downloaded = true).firstPage()
-        timed("albums first page (added)") { dao.albumsByRecentlyAdded(1, 0, "").firstPage() }
+        }
-        timed("albums first page (starred)") { dao.albumsByStarred(1, 0, "").firstPage() }
+        timed("albums first page (artist)") { dao.albumPages(1, 0, "", sort = AlbumSort.Artist).firstPage() }
-        timed("albums first page (frequent)") { dao.albumsByFrequent(1, 0, "").firstPage() }
+        timed("albums first page (year)") { dao.albumPages(1, 0, "", sort = AlbumSort.Year).firstPage() }
-        timed("albums first page (recent)") { dao.albumsByRecent(1, 0, "").firstPage() }
+        timed("albums first page (added)") { dao.albumPages(1, 0, "", sort = AlbumSort.Added).firstPage() }
-        timed("artists first page (name)") { dao.artistsByName(1, 0, "").firstPage() }
+        timed("albums first page (starred)") { dao.albumPages(1, 0, "", sort = AlbumSort.Starred).firstPage() }
-        timed("artists first page (frequent)") { dao.artistsByFrequent(1, 0, "").firstPage() }
+        timed("albums first page (frequent)") { dao.albumPages(1, 0, "", sort = AlbumSort.Frequent).firstPage() }
+        timed("albums first page (recent)") { dao.albumPages(1, 0, "", sort = AlbumSort.Recent).firstPage() }
+        timed("artists first page (name)") { dao.artistPages(1, 0, "", sort = ArtistSort.Name).firstPage() }
+        timed("artists first page (name, downloaded)") {
+            dao.artistPages(1, 0, "", sort = ArtistSort.Name, downloaded = true).firstPage()
+        }
+        timed("artists first page (frequent)") { dao.artistPages(1, 0, "", sort = ArtistSort.Frequent).firstPage() }
         timed("artist albums") { dao.albumsForArtist(1, "ar0").first() }
         timed("artist name") { dao.artistName(1, "ar0").first() }
         timed("artist songs") { db.queueDao().artistSongs(1, "ar0", 0, 100) }
         timed("artist length") { db.queueDao().artistLength(1, "ar0") }
         timed("artist song ids") { db.queueDao().artistSongIds(1, "ar0") }
         timed("downloaded artists") { dao.downloadedArtists(1).firstPage() }
-        timed("artists downloaded filter") { dao.artistsByName(1, 0, "", downloadedFilter = 1).firstPage() }
+        timed("artists downloaded filter") { dao.artistPages(1, 0, "", downloaded = true).firstPage() }
         timed("artist statuses") { db.downloadDao().artistStatuses(1).first() }
         timed("artist status") { db.downloadDao().artistStatus(1, "ar0").first() }
-        timed("playlists first page (name)") { dao.playlistsByName(1, "").firstPage() }
+        timed("playlists first page (name)") { dao.playlistPages(1, "", sort = PlaylistSort.Name).firstPage() }
-        timed("albums deep page") { dao.albumsByName(1, 0, "").deepPage(1000) }
+        timed("playlists first page (name, downloaded)") {
-        timed("albums search FTS") { dao.albumsByName(1, 0, "Album 1").firstPage() }
+            dao.playlistPages(1, "", sort = PlaylistSort.Name, downloaded = true).firstPage()
-        timed("albums search short") { dao.albumsByName(1, 0, "al").firstPage() }
+        }
+        timed("albums deep page") { dao.albumPages(1, 0, "", sort = AlbumSort.Name).deepPage(1000) }
+        timed("albums search FTS") { dao.albumPages(1, 0, "Album 1", sort = AlbumSort.Name).firstPage() }
+        timed("albums search short") { dao.albumPages(1, 0, "al", sort = AlbumSort.Name).firstPage() }
         timed("songs search FTS") { dao.searchSongs(1, "Song", 50).first() }
         timed("home recently played") { dao.recentlyPlayedAlbums(1, 20).first() }
         timed("home most played") { dao.mostPlayedAlbums(1, 20).first() }

app/src/test/kotlin/com/subtracks/data/db/TestDatabase.kt

@@ -0,0 +1,16 @@
+package com.subtracks.data.db
+
+import android.content.Context
+import androidx.room3.Room
+import androidx.sqlite.SQLiteDriver
+import androidx.sqlite.driver.bundled.BundledSQLiteDriver
+import androidx.test.core.app.ApplicationProvider
+
+fun createTestDatabase(driver: SQLiteDriver = BundledSQLiteDriver()): SubtracksDatabase {
+    val context = ApplicationProvider.getApplicationContext<Context>()
+    return Room
+        .inMemoryDatabaseBuilder(context, SubtracksDatabase::class.java)
+        .setDriver(driver)
+        .addSubtracksDatabaseCallbacks()
+        .build()
+}

app/src/test/kotlin/com/subtracks/data/prefs/UserPreferencesTest.kt

@@ -51,6 +51,42 @@ class UserPreferencesTest {
             file.delete()
         }
 
+    @Test
+    fun theSortNameModeRoundTrips() =
+        runTest {
+            val file = File.createTempFile("user-prefs", ".preferences_pb").apply { delete() }
+            val store = PreferenceDataStoreFactory.create(scope = backgroundScope) { file }
+            val prefs = UserPreferences(store)
+
+            assertEquals(SortNameMode.Name, prefs.sortNameMode().first())
+
+            prefs.setSortNameMode(SortNameMode.NonLatin)
+
+            assertEquals(SortNameMode.NonLatin, prefs.sortNameMode().first())
+
+            file.delete()
+        }
+
+    @Test
+    fun songTapBehaviorDefaultsToInOrderAndRoundTrips() =
+        runTest {
+            val file = File.createTempFile("user-prefs", ".preferences_pb").apply { delete() }
+            val store = PreferenceDataStoreFactory.create(scope = backgroundScope) { file }
+            val prefs = UserPreferences(store)
+
+            assertEquals(SongTapBehavior.InOrder, prefs.songTapBehavior().first())
+
+            prefs.setSongTapBehavior(SongTapBehavior.Shuffle)
+
+            assertEquals(SongTapBehavior.Shuffle, prefs.songTapBehavior().first())
+
+            store.edit { it[stringPreferencesKey("song_tap_behavior")] = "Bogus" }
+
+            assertEquals(SongTapBehavior.InOrder, prefs.songTapBehavior().first())
+
+            file.delete()
+        }
+
     @Test
     fun theSelectedLibraryTabRoundTrips() =
         runTest {

app/src/test/kotlin/com/subtracks/data/repo/DownloadRepositoryTest.kt

@@ -3,13 +3,12 @@ package com.subtracks.data.repo
 import android.content.Context
 import android.content.res.Resources
 import android.net.Uri
-import androidx.room3.Room
-import androidx.sqlite.driver.bundled.BundledSQLiteDriver
 import androidx.test.core.app.ApplicationProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import com.subtracks.awaitUntil
 import com.subtracks.cancelAndJoinBlocking
 import com.subtracks.data.db.SubtracksDatabase
+import com.subtracks.data.db.createTestDatabase
 import com.subtracks.data.download.ArtworkFetcher
 import com.subtracks.data.download.ArtworkStore
 import com.subtracks.data.download.FakeDownloadEngine
@@ -26,6 +25,7 @@ import com.subtracks.data.model.Song
 import com.subtracks.data.model.SongDownload
 import com.subtracks.data.model.Source
 import com.subtracks.data.model.SubsonicSource
+import com.subtracks.data.model.artistImageKey
 import com.subtracks.data.model.coverArtKey
 import com.subtracks.data.prefs.fakeUserPreferences
 import kotlinx.coroutines.CoroutineScope
@@ -70,11 +70,12 @@ class DownloadRepositoryTest {
     private val requestedArt = CopyOnWriteArrayList<String>()
     private val artFetchedAfterTheEngineRequest = CopyOnWriteArrayList<Boolean>()
     private var failArtworkFetch = false
+    private val failingArtUrls = CopyOnWriteArrayList<String>()
     private val fetcher =
         ArtworkFetcher { url ->
             requestedArt += url
             artFetchedAfterTheEngineRequest += engine.requests.isNotEmpty()
-            if (failArtworkFetch) throw IOException("boom")
+            if (failArtworkFetch || url in failingArtUrls) throw IOException("boom")
             byteArrayOf(1, 2, 3)
         }
 
@@ -82,11 +83,7 @@ class DownloadRepositoryTest {
     fun setUp() {
         val context = ApplicationProvider.getApplicationContext<Context>()
         resources = context.resources
-        db =
+        db = createTestDatabase()
-            Room
-                .inMemoryDatabaseBuilder(context, SubtracksDatabase::class.java)
-                .setDriver(BundledSQLiteDriver())
-                .build()
         artwork = ArtworkStore(File(context.cacheDir, "art-${System.nanoTime()}"))
         scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
         sources = SourceRepository(db, OkHttpClient(), prefs, artwork, scope = scope)
@@ -344,7 +341,10 @@ class DownloadRepositoryTest {
         runTest {
             seedLibrary()
             writeFile(1, "s1", "audio")
-            runBlocking { repository.download(1, "s1") }
+            runBlocking {
+                repository.download(1, "s1")
+                db.libraryDao().upsertArtists(listOf(artist(ARTIST_ART).copy(downloadedCoverArts = listOf(ALBUM_ART))))
+            }
             val id = engine.requests.single().first
 
             runBlocking { repository.removeSource(1) }
@@ -352,6 +352,13 @@ class DownloadRepositoryTest {
             assertTrue(engine.cancelled.contains(id))
             assertFalse(file(1, "s1").exists())
             assertTrue(allRows().isEmpty())
+            assertTrue(
+                db
+                    .libraryDao()
+                    .artistOnce(1, "ar1")!!
+                    .downloadedCoverArts
+                    .isEmpty(),
+            )
         }
 
     @Test
@@ -381,6 +388,95 @@ class DownloadRepositoryTest {
             }
         }
 
+    @Test
+    fun startingADownloadStoresTheProviderArtistImageAndKeepsItUntilTheDownloadGoes() =
+        runTest {
+            seedLibrary()
+            runBlocking {
+                db.libraryDao().upsertArtists(listOf(artist(ARTIST_ART, artistImageUrl = "https://img.example/ar1.jpg")))
+            }
+
+            runBlocking { repository.download(1, "s1") }
+
+            assertTrue(requestedArt.contains("https://img.example/ar1.jpg"))
+            val key = artistImageKey(1, "ar1")
+            assertNotNull(artwork.uri(1, key))
+
+            runBlocking { repository.reconcile() }
+            assertNotNull(artwork.uri(1, key))
+
+            runBlocking { repository.remove(1, "s1") }
+            assertNull(artwork.uri(1, key))
+        }
+
+    @Test
+    fun providerArtworkForTheAlbumArtistSurvivesASweepAndGoesWithTheDownload() =
+        runTest {
+            seedLibrary()
+            runBlocking {
+                db.libraryDao().upsertArtists(
+                    listOf(
+                        artist(ARTIST_ART, "https://img.example/track.jpg").copy(id = "ar-track"),
+                        artist(ARTIST_ART, "https://img.example/album.jpg").copy(id = "ar-album"),
+                    ),
+                )
+                db.libraryDao().upsertAlbums(listOf(album(ALBUM_ART).copy(artistId = "ar-album")))
+                db.libraryDao().upsertSongs(listOf(db.libraryDao().songOnce(1, "s1")!!.copy(artistId = "ar-track")))
+            }
+
+            runBlocking { repository.download(1, "s1") }
+            val trackKey = artistImageKey(1, "ar-track")
+            val albumKey = artistImageKey(1, "ar-album")
+            assertNotNull(artwork.uri(1, trackKey))
+            assertNotNull(artwork.uri(1, albumKey))
+
+            runBlocking { repository.reconcile() }
+            assertNotNull(artwork.uri(1, trackKey))
+            assertNotNull(artwork.uri(1, albumKey))
+
+            runBlocking { repository.remove(1, "s1") }
+            assertNull(artwork.uri(1, trackKey))
+            assertNull(artwork.uri(1, albumKey))
+        }
+
+    @Test
+    fun aFailedProviderImageFetchCachesTheArtistCoverFallback() =
+        runTest {
+            seedLibrary()
+            runBlocking {
+                db.libraryDao().upsertArtists(listOf(artist(ARTIST_ART, artistImageUrl = "https://img.example/ar1.jpg")))
+            }
+            failingArtUrls += "https://img.example/ar1.jpg"
+
+            runBlocking { repository.download(1, "s1") }
+
+            assertNull(artwork.uri(1, artistImageKey(1, "ar1")))
+            assertNotNull(artwork.uri(1, coverArtKey(1, ARTIST_ART, false)))
+            assertNotNull(artwork.uri(1, coverArtKey(1, ARTIST_ART, true)))
+        }
+
+    @Test
+    fun completingADownloadMaterializesOnlyItsAlbumForOfflineArtistArt() =
+        runTest {
+            seedLibrary()
+            repository.start()
+            runBlocking { repository.download(1, "s1") }
+            val id = engine.requests.single().first
+
+            engine.complete(id, total = 100)
+            writeFile(1, "s1", "audio")
+            runBlocking { repository.reconcile() }
+
+            await { row(1, "s1")?.status == DownloadStatus.Completed }
+            assertEquals(
+                listOf(ALBUM_ART),
+                db.libraryDao().artistOnce(1, "ar1")!!.downloadedCoverArts,
+            )
+
+            runBlocking { repository.remove(1, "s1") }
+            assertEquals(emptyList<String>(), db.libraryDao().artistOnce(1, "ar1")!!.downloadedCoverArts)
+        }
+
     @Test
     fun downloadingASongAlsoStoresTheArtworkOfPlaylistsThatContainIt() =
         runTest {
@@ -1282,8 +1378,19 @@ class DownloadRepositoryTest {
             songCount = 2,
         )
 
-    private fun artist(coverArt: String?) =
+    private fun artist(
-        Artist(sourceId = 1, id = "ar1", name = "Artist", albumCount = 1, starred = null, coverArt = coverArt, songCount = 2)
+        coverArt: String?,
+        artistImageUrl: String? = null,
+    ) = Artist(
+        sourceId = 1,
+        id = "ar1",
+        name = "Artist",
+        albumCount = 1,
+        starred = null,
+        coverArt = coverArt,
+        artistImageUrl = artistImageUrl,
+        songCount = 2,
+    )
 
     private fun seedLibrary(address: String = "http://localhost:4533/") {
         runBlocking {

app/src/test/kotlin/com/subtracks/data/repo/LibraryRepositoryTest.kt

@@ -4,12 +4,11 @@ import android.content.Context
 import android.content.res.Resources
 import androidx.paging.PagingDataEvent
 import androidx.paging.PagingDataPresenter
-import androidx.room3.Room
-import androidx.sqlite.driver.bundled.BundledSQLiteDriver
 import androidx.test.core.app.ApplicationProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import com.subtracks.cancelAndJoinBlocking
 import com.subtracks.data.db.SubtracksDatabase
+import com.subtracks.data.db.createTestDatabase
 import com.subtracks.data.download.ArtworkStore
 import com.subtracks.data.model.Album
 import com.subtracks.data.model.ArtistBio
@@ -63,11 +62,7 @@ class LibraryRepositoryTest {
     fun setUp() {
         val context = ApplicationProvider.getApplicationContext<Context>()
         resources = context.resources
-        db =
+        db = createTestDatabase()
-            Room
-                .inMemoryDatabaseBuilder(context, SubtracksDatabase::class.java)
-                .setDriver(BundledSQLiteDriver())
-                .build()
         scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
         sourceRepository =
             SourceRepository(db, OkHttpClient(), fakeUserPreferences(), ArtworkStore(File(context.cacheDir, "art")), scope = scope)
@@ -76,6 +71,7 @@ class LibraryRepositoryTest {
                 db,
                 sourceRepository,
                 NetworkServerActionSink(sourceRepository),
+                fakeUserPreferences(),
                 showMessage = { messages += it.resolve(resources) },
                 scope = scope,
             )
@@ -207,6 +203,42 @@ class LibraryRepositoryTest {
             }
         }
 
+    @Test
+    fun theDownloadedAlbumGridOnlyPresentsDownloadedRows() =
+        runBlocking {
+            val sourceId = sourceRepository.addSource("nav", "http://localhost/", "u", "p", false)
+            db.libraryDao().upsertAlbums(listOf(seedAlbum(sourceId, 1), seedAlbum(sourceId, 2)))
+            db.libraryDao().upsertSongs(
+                listOf(
+                    seedSong(sourceId).copy(id = "s1", albumId = "al-0001"),
+                    seedSong(sourceId).copy(id = "s2", albumId = "al-0002"),
+                ),
+            )
+            db.downloadDao().upsert(SongDownload(sourceId, "s1", DownloadStatus.Completed))
+
+            val presenterDispatcher = Executors.newSingleThreadExecutor().asCoroutineDispatcher()
+            val presenter = RecordingPresenter(presenterDispatcher)
+            val job =
+                launch {
+                    repository
+                        .albums(
+                            sourceId = sourceId,
+                            sort = AlbumSort.Name,
+                            descending = false,
+                            starred = StarredFilter.Any,
+                            search = "",
+                            downloaded = true,
+                        ).collect { presenter.collectFrom(it) }
+                }
+            try {
+                awaitRefreshes(presenter, 1)
+                assertEquals(1, presented(presenter, presenterDispatcher))
+            } finally {
+                job.cancelAndJoin()
+                presenterDispatcher.close()
+            }
+        }
+
     @Test
     fun artistAlbumsSeparatesAlbumCreditsFromTrackAppearances() =
         runBlocking {

app/src/test/kotlin/com/subtracks/data/repo/PendingServerActionSinkTest.kt

@@ -1,13 +1,10 @@
 package com.subtracks.data.repo
 
-import android.content.Context
-import androidx.room3.Room
-import androidx.sqlite.driver.bundled.BundledSQLiteDriver
-import androidx.test.core.app.ApplicationProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import com.subtracks.awaitUntil
 import com.subtracks.cancelAndJoinBlocking
 import com.subtracks.data.db.SubtracksDatabase
+import com.subtracks.data.db.createTestDatabase
 import com.subtracks.data.model.PendingActionKind
 import com.subtracks.data.model.Source
 import com.subtracks.data.source.ServerActionSink
@@ -82,12 +79,7 @@ class PendingServerActionSinkTest {
 
     @Before
     fun setUp() {
-        val context = ApplicationProvider.getApplicationContext<Context>()
+        db = createTestDatabase()
-        db =
-            Room
-                .inMemoryDatabaseBuilder(context, SubtracksDatabase::class.java)
-                .setDriver(BundledSQLiteDriver())
-                .build()
         scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
         sourceId = runBlocking { db.sourcesDao().insertSource(Source(name = "server", address = "http://x/", createdAt = 0)) }
         delegate = RecordingSink()