chore(deps): bump aboutlibraries to 15.3.0

A download error stayed in the state flow forever: the dictionaries
section replayed it as a snackbar on every recomposition and screens
created later picked it up long after the failure, even while a newer
download was already running. Error states now decay to idle after the
same grace period as success, unless a newer state has replaced them.

README.md

@@ -90,10 +90,10 @@ The main search screen remains usable as long as at least one indexed dictionary
 - Material 3 1.5.0-beta01
 - Coroutines and Flow 1.11.0
 - DataStore Preferences 1.2.1
-- Paging 3.5.2
+- Paging 3.5.3
 - OkHttp 5.5.0
 - kotlinx.serialization 1.11.0
-- AboutLibraries 15.2.0 metadata generation
+- AboutLibraries 15.3.0 metadata generation
 - Android Gradle Plugin 9.4.1
 
 ## Build

app/src/main/java/com/example/research/data/paging/IndexEntryPagingSource.kt

@@ -5,10 +5,9 @@ import androidx.paging.PagingState
 import com.example.research.core.domain.model.Dictionary
 import com.example.research.core.domain.model.IndexEntry
 import com.example.research.core.performance.ReSearchTrace
-import com.example.research.core.util.sanitizeQuery
 import com.example.research.data.parser.IndexSearcher
-import com.example.research.data.parser.SearchRankingContext
-import com.example.research.data.parser.rankBySearchRelevance
+import com.example.research.data.parser.sortByCharCountThenNatural
+
 import kotlinx.coroutines.async
 import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.coroutineScope
@@ -68,9 +67,8 @@ class IndexEntryPagingSource(
                     }
                 }
 
-                val normalizedQuery = query.sanitizeQuery().lowercase().trim()
                 val ranked = rawResults
-                    .rankBySearchRelevance(SearchRankingContext(normalizedQuery))
+                    .sortByCharCountThenNatural()
                     .distinctBy { Triple(it.dictionaryPath, it.word, it.offset.value) }
 
                 LoadResult.Page(

app/src/main/java/com/example/research/data/parser/IndexSearcher.kt

@@ -122,9 +122,7 @@ class IndexSearcher(private val context: Context) {
                         }
                     }
                 }
-                (prefixMatches + substringMatches)
-                    .rankBySearchRelevance(SearchRankingContext(normalizedQuery, foldedQuery))
-                    .distinctBy { it.articleKey() }
+                (prefixMatches + substringMatches).distinctBy { it.articleKey() }
             }
             resultsCache.put(cacheKey, results)
             results

app/src/main/java/com/example/research/data/parser/SearchRanking.kt

@@ -2,50 +2,37 @@ package com.example.research.data.parser
 
 import com.example.research.core.domain.model.IndexEntry
 import com.example.research.core.util.NaturalStringComparator
-import com.example.research.core.util.foldLatinDiacritics
 
-internal data class SearchRankingContext(
-    val normalizedQuery: String,
-    val foldedQuery: String = normalizedQuery.foldLatinDiacritics(),
-)
-
-private data class SortKey(
-    val matchTier: Int,
-    val exactMatch: Int,
-    val charCount: Int,
-    val word: String,
-    val entry: IndexEntry,
-)
-
-internal fun List<IndexEntry>.rankBySearchRelevance(
-    ranking: SearchRankingContext
-): List<IndexEntry> {
+internal fun List<IndexEntry>.sortByCharCountThenNatural(): List<IndexEntry> {
     if (size < 2) return this
 
-    return map { entry ->
-        val word = entry.word
+    val charCounts = IntArray(size)
+    var minCount = Int.MAX_VALUE
+    var maxCount = Int.MIN_VALUE
+    for (i in indices) {
+        val entry = this[i]
         val displayKey = entry.originalWord
             .trim()
             .ifEmpty { entry.word.trim() }
-
-        SortKey(
-            matchTier = when {
-                !entry.isAlias && word.startsWith(ranking.normalizedQuery) -> 0
-                entry.isAlias && word.startsWith(ranking.foldedQuery) -> 1
-                !entry.isAlias && word.foldLatinDiacritics().startsWith(ranking.foldedQuery) -> 1
-                else -> 2
-            },
-            exactMatch = if (word == ranking.normalizedQuery) 0 else 1,
-            charCount = displayKey.codePointCount(0, displayKey.length),
-            word = word,
-            entry = entry,
-        )
+        val count = displayKey.codePointCount(0, displayKey.length)
+        charCounts[i] = count
+        if (count < minCount) minCount = count
+        if (count > maxCount) maxCount = count
     }
-        .sortedWith(
-            compareBy<SortKey> { it.matchTier }
-                .thenBy { it.exactMatch }
-                .thenBy { it.charCount }
-                .thenBy(NaturalStringComparator) { it.word }
-        )
-        .map { it.entry }
+
+    val buckets = arrayOfNulls<ArrayList<IndexEntry>>(maxCount - minCount + 1)
+    for (i in indices) {
+        val bucketIndex = charCounts[i] - minCount
+        (buckets[bucketIndex] ?: ArrayList<IndexEntry>().also { buckets[bucketIndex] = it })
+            .add(this[i])
+    }
+
+    val naturalOrder = compareBy<IndexEntry, String>(NaturalStringComparator) { it.word }
+    val result = ArrayList<IndexEntry>(size)
+    for (bucket in buckets) {
+        if (bucket == null) continue
+        if (bucket.size > 1) bucket.sortWith(naturalOrder)
+        result.addAll(bucket)
+    }
+    return result
 }

app/src/main/java/com/example/research/feature/search/SearchViewModel.kt

@@ -112,9 +112,7 @@ class SearchViewModel(
             Pager(
                 config = PagingConfig(
                     pageSize = 12,
-                    prefetchDistance = 1,
-                    enablePlaceholders = false,
-                    initialLoadSize = 12
+                    enablePlaceholders = false
                 ),
                 pagingSourceFactory = {
                     IndexEntryPagingSource(

app/src/main/java/com/example/research/ui/settings/SettingsViewModel.kt

@@ -37,6 +37,16 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import java.util.concurrent.ConcurrentHashMap
 
+private const val STATUS_UP_TO_DATE = "UpToDate"
+private const val STATUS_NEEDS_UPDATE = "NeedsUpdate"
+private const val STATUS_EMPTY = "Empty"
+
+private data class PersistedDictionaryStatus(
+    val name: String,
+    val date: String,
+    val sourceIds: Set<String>,
+)
+
 private data class DictionaryStateInputs(
     val theme: AppTheme,
     val dictionarySources: List<DictionarySource>,
@@ -115,14 +125,18 @@ class SettingsViewModel(
     private fun persistDictionaryStatus() {
         viewModelScope.launch {
             dictionaryStatus.collect { status ->
-                val persistedName = when (status) {
-                    DictionaryStatus.UpToDate -> "UpToDate"
-                    is DictionaryStatus.NeedsUpdate -> "NeedsUpdate"
-                    DictionaryStatus.Empty -> "Empty"
+                val persisted = when (status) {
+                    DictionaryStatus.UpToDate ->
+                        "$STATUS_UP_TO_DATE|${DateUtils.getCurrentDateString()}"
+                    is DictionaryStatus.NeedsUpdate ->
+                        "$STATUS_NEEDS_UPDATE|${DateUtils.getCurrentDateString()}|" +
+                            status.sourceIds.joinToString(",")
+                    DictionaryStatus.Empty ->
+                        "$STATUS_EMPTY|${DateUtils.getCurrentDateString()}"
                     else -> null
                 }
-                if (persistedName != null) {
-                    preferencesManager.saveDictionaryStatus("$persistedName|${DateUtils.getCurrentDateString()}")
+                if (persisted != null) {
+                    preferencesManager.saveDictionaryStatus(persisted)
                 }
             }
         }
@@ -202,14 +216,21 @@ class SettingsViewModel(
                         }
                     }
                     is DownloadState.Error -> {
+                        val startedHere = statusBeforeDownload != DictionaryStatus.Unknown ||
+                            isDownloadInProgress
                         isDownloadInProgress = false
                         if (!errorStateHandled) {
                             errorStateHandled = true
-                            dictionaryStatus.value = if (dictionaryState.dictionaries.isEmpty()) {
-                                DictionaryStatus.Empty
-                            } else when (statusBeforeDownload) {
-                                DictionaryStatus.Unknown, DictionaryStatus.Checking -> DictionaryStatus.UpToDate
-                                else -> statusBeforeDownload
+                            if (dictionaryState.dictionaries.isEmpty()) {
+                                dictionaryStatus.value = DictionaryStatus.Empty
+                            } else if (startedHere) {
+                                when (statusBeforeDownload) {
+                                    DictionaryStatus.Unknown, DictionaryStatus.Checking ->
+                                        viewModelScope.launch {
+                                            restoreOrEvaluateDictionaryStatus()
+                                        }
+                                    else -> dictionaryStatus.value = statusBeforeDownload
+                                }
                             }
                             if (pendingSourceUrls.isNotEmpty()) {
                                 pendingSourceUrls.forEach { urlTemplate ->
@@ -283,7 +304,7 @@ class SettingsViewModel(
                 scanCompleted = if (localDictionaryRepository.dictionaries.value.isEmpty()) {
                     scanDirectoryInternal(preferencesManager.dictionaryPath) is OperationResult.Success
                 } else {
-                    dictionaryStatus.value = DictionaryStatus.UpToDate
+                    restoreOrEvaluateDictionaryStatus()
                     false
                 }
             } catch (e: Exception) {
@@ -551,6 +572,71 @@ class SettingsViewModel(
     ): List<DictionarySource> =
         DictionarySourceFileMatcher.installedSources(sources, dictionaries)
 
+    private suspend fun restoreOrEvaluateDictionaryStatus() {
+        val restored = restorePersistedDictionaryStatus()
+        if (restored != null) {
+            dictionaryStatus.value = restored
+            return
+        }
+        dictionaryStatus.value = DictionaryStatus.Checking
+        dictionaryStatus.value = withContext(Dispatchers.IO) { evaluateDictionaryStatus() }
+    }
+
+    private suspend fun restorePersistedDictionaryStatus(): DictionaryStatus? {
+        val persisted = readPersistedDictionaryStatus() ?: return null
+        if (persisted.date != DateUtils.getCurrentDateString()) return null
+        return when (persisted.name) {
+            STATUS_UP_TO_DATE ->
+                if (withContext(Dispatchers.IO) { installedDictionariesAreCurrent() }) {
+                    DictionaryStatus.UpToDate
+                } else {
+                    null
+                }
+            STATUS_NEEDS_UPDATE -> {
+                val updatableIds = withContext(Dispatchers.IO) { sourcesMissingTodaysFile() }
+                val restorableIds = persisted.sourceIds intersect updatableIds
+                if (restorableIds.isNotEmpty()) DictionaryStatus.NeedsUpdate(restorableIds) else null
+            }
+            else -> null
+        }
+    }
+
+    private suspend fun readPersistedDictionaryStatus(): PersistedDictionaryStatus? {
+        val raw = preferencesManager.dictionaryStatus() ?: return null
+        val parts = raw.split('|')
+        if (parts.isEmpty() || parts.first().isEmpty()) return null
+        return PersistedDictionaryStatus(
+            name = parts.first(),
+            date = parts.getOrElse(1) { "" },
+            sourceIds = parts.getOrElse(2) { "" }
+                .split(',')
+                .map(String::trim)
+                .filter(String::isNotEmpty)
+                .toSet(),
+        )
+    }
+
+    private suspend fun sourcesMissingTodaysFile(): Set<String> {
+        val sources = preferencesManager.dictionarySources.first()
+        val dictionaries = localDictionaryRepository.dictionaries.first()
+        val datedEnabledSources = installedEnabledSources(sources, dictionaries)
+            .filter { DictionarySource.hasDatePlaceholder(it.urlTemplate) }
+        if (datedEnabledSources.isEmpty()) return emptySet()
+        val fileNames = localDictionaryRepository.listDictionaryPayloadFileNames(
+            preferencesManager.dictionaryPath
+        ) ?: return emptySet()
+        val today = DateUtils.getCurrentDateString()
+        return datedEnabledSources
+            .filterNot { source -> fileNames.any { it.startsWith(fileBaseNameFor(source, today)) } }
+            .mapTo(mutableSetOf(), DictionarySource::id)
+    }
+
+    private fun fileBaseNameFor(source: DictionarySource, date: String): String =
+        DictionarySource.extractFileName(source.urlTemplate, date)
+            .removeSuffix(".gz")
+            .removeSuffix(".dsl")
+            .removeSuffix(".dz")
+
     private suspend fun installedDictionariesAreCurrent(): Boolean {
         val sources = preferencesManager.dictionarySources.first()
         val dictionaries = localDictionaryRepository.dictionaries.first()
@@ -562,11 +648,7 @@ class SettingsViewModel(
         ) ?: return true
         val today = DateUtils.getCurrentDateString()
         return datedEnabledSources.all { source ->
-            val baseName = DictionarySource.extractFileName(source.urlTemplate, today)
-                .removeSuffix(".gz")
-                .removeSuffix(".dsl")
-                .removeSuffix(".dz")
-            fileNames.any { it.startsWith(baseName) }
+            fileNames.any { it.startsWith(fileBaseNameFor(source, today)) }
         }
     }
 
@@ -622,20 +704,7 @@ class SettingsViewModel(
                     dictionaryStatus.value = DictionaryStatus.UpToDate
                     isDownloadInProgress = false
                 } else {
-                    val savedStatus = preferencesManager.dictionaryStatus()
-                    val savedStatusName = savedStatus?.substringBefore('|')
-                    val savedStatusDate = savedStatus?.substringAfter('|', "")
-                    val restoredStatus = if (savedStatusName == "UpToDate") DictionaryStatus.UpToDate else null
-                    if (restoredStatus != null &&
-                        savedStatusDate == DateUtils.getCurrentDateString() &&
-                        withContext(Dispatchers.IO) { installedDictionariesAreCurrent() }
-                    ) {
-                        dictionaryStatus.value = restoredStatus
-                    } else {
-                        dictionaryStatus.value = DictionaryStatus.Checking
-                        val status = withContext(Dispatchers.IO) { evaluateDictionaryStatus() }
-                        dictionaryStatus.value = status
-                    }
+                    restoreOrEvaluateDictionaryStatus()
                 }
 
                 if (result.data > 0) {

gradle/libs.versions.toml

@@ -1,5 +1,5 @@
 [versions]
-aboutlibraries = "15.2.0"
+aboutlibraries = "15.3.0"
 activity_compose = "1.13.0"
 agp = "9.4.1"
 compose_bom = "2026.09.00"
@@ -10,7 +10,7 @@ kotlin = "2.4.21"
 lifecycle_runtime_ktx = "2.11.0"
 material3 = "1.5.0-beta01"
 okhttp = "5.5.0"
-paging = "3.5.2"
+paging = "3.5.3"
 profileinstaller = "1.4.1"
 kotlinx_coroutines = "1.11.0"
 kotlinx_serialization = "1.11.0"