fix(search): drop the open article when the query is cleared

Measure-pass defect in compose ui 1.12.0: layoutChildrenBlock clobbered
the isPlacingForAlignment flag of child nodes during alignment
placement, so sheet anchors were recalculated from a stale content size.

compose ui 1.12.1 preserves and restores child placement flags, so the
anchor is computed from a consistent content size on the first frame.

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 OneWay
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -29,7 +29,7 @@ The app stores dictionaries as DictZip files and builds compact binary indexes f
 - Random-access article loading from DictZip dictionaries.
 - Background processing with progress shown in Settings and notifications.
 - Dictionary management with enable, disable, update, and delete actions.
-- Material 3 interface with light, dark, and system themes.
+- Material 3 interface with dynamic color, light, dark, and system themes.
 - English and Russian localization.
 - About screen with open source license information.
 
@@ -95,15 +95,15 @@ The main search screen remains usable as long as at least one indexed dictionary
 ## Tech Stack
 
 - Kotlin 2.4.10
-- Jetpack Compose (BOM 2026.06.01)
+- Jetpack Compose (BOM 2026.08.00)
 - Material 3
 - Coroutines and Flow 1.11.0
 - DataStore Preferences 1.2.1
-- Paging 3.5.0
+- Paging 3.5.1
 - OkHttp 5.4.0
 - kotlinx.serialization 1.11.0
 - AboutLibraries 15.0.4 metadata generation
-- Android Gradle Plugin 9.3.0
+- Android Gradle Plugin 9.3.1
 
 ## Build
 
@@ -115,4 +115,4 @@ The release APK targets `arm64-v8a`. English and Russian resources are packaged
 
 ## License
 
-MIT
+[MIT](LICENSE)

app/build.gradle.kts

@@ -92,8 +92,8 @@ android {
         applicationId = "com.example.research"
         minSdk = project.property("minSdk").toString().toInt()
         targetSdk = project.property("targetSdk").toString().toInt()
-        versionCode = 5
-        versionName = "1.2.1"
+        versionCode = 8
+        versionName = "1.5.0"
 
         vectorDrawables {
             useSupportLibrary = true

app/src/main/java/com/example/research/DictionaryStatus.kt

@@ -1,5 +1,8 @@
 package com.example.research
 
+import androidx.compose.runtime.Immutable
+
+@Immutable
 sealed interface DictionaryStatus {
     data object Unknown : DictionaryStatus
     data object Checking : DictionaryStatus

app/src/main/java/com/example/research/MainActivity.kt

@@ -26,6 +26,7 @@ import com.example.research.common.ui.AppLocaleProvider
 import com.example.research.common.ui.BackgroundTextMeasurementProvider
 import com.example.research.common.ui.theme.ReSearchTheme
 import com.example.research.core.domain.model.AppTheme
+import com.example.research.data.local.preferences.SectionExpansionStates
 import com.example.research.feature.search.SearchAction
 import com.example.research.feature.search.SearchViewModel
 import com.example.research.ui.navigation.AppNavigation
@@ -51,6 +52,8 @@ class MainActivity : ComponentActivity() {
         }
     }
 
+    private var initialSectionExpansion: SectionExpansionStates? = null
+
     private val settingsViewModel: SettingsViewModel by viewModels {
         val app = application as ReSearchApplication
         val versionName = try {
@@ -69,6 +72,11 @@ class MainActivity : ComponentActivity() {
                     app.dictionaryImportManager,
                     app.dictionaryProgressStateHolder,
                     versionName,
+                    initialSectionExpansion ?: SectionExpansionStates(
+                        isThemeExpanded = false,
+                        isLanguageExpanded = false,
+                        isDictionariesExpanded = true,
+                    ),
                 )
             }
         }
@@ -83,6 +91,8 @@ class MainActivity : ComponentActivity() {
         val app = application as ReSearchApplication
         val initialTheme = loadInitialTheme(app)
         val initialLanguage = loadInitialLanguage(app)
+        val initialHadNoDictionaries = loadInitialHadNoDictionaries(app)
+        initialSectionExpansion = loadInitialSectionExpansion(app)
 
         handleIntent(intent)
         setContent {
@@ -104,7 +114,8 @@ class MainActivity : ComponentActivity() {
                         ) {
                             AppNavigation(
                                 searchViewModel = searchViewModel,
-                                settingsViewModel = settingsViewModel
+                                settingsViewModel = settingsViewModel,
+                                seedNoDictionaries = initialHadNoDictionaries
                             )
                         }
                     }
@@ -165,6 +176,31 @@ class MainActivity : ComponentActivity() {
         }
     }
 
+    private fun loadInitialHadNoDictionaries(app: ReSearchApplication): Boolean {
+        return try {
+            runBlocking {
+                app.preferencesManager.hadNoDictionaries.first()
+            }
+        } catch (e: Exception) {
+            true
+        }
+    }
+
+    private fun loadInitialSectionExpansion(app: ReSearchApplication): SectionExpansionStates {
+        return try {
+            runBlocking {
+                app.preferencesManager.sectionExpansionStates()
+            }
+        } catch (e: Exception) {
+            android.util.Log.e("MainActivity", "Failed to load section expansion states: ${e.message}")
+            SectionExpansionStates(
+                isThemeExpanded = false,
+                isLanguageExpanded = false,
+                isDictionariesExpanded = true,
+            )
+        }
+    }
+
     override fun onNewIntent(intent: Intent) {
         super.onNewIntent(intent)
         handleIntent(intent)

app/src/main/java/com/example/research/ReSearchApplication.kt

@@ -2,6 +2,7 @@ package com.example.research
 
 import android.app.Application
 import com.example.research.common.progress.DictionaryProgressStateHolder
+import com.example.research.common.util.NotificationHelper
 import com.example.research.data.local.preferences.PreferencesManager
 import com.example.research.data.repository.LocalDictionaryRepository
 import com.example.research.feature.download.DownloadManager
@@ -36,11 +37,18 @@ class ReSearchApplication : Application() {
         private set
     lateinit var dictionaryProgressStateHolder: DictionaryProgressStateHolder
         private set
+    lateinit var dictionaryProgressPresenter: com.example.research.common.progress.DictionaryProgressPresenter
+        private set
+    lateinit var dictionaryPipelineCoordinator: com.example.research.common.progress.DictionaryPipelineCoordinator
+        private set
     private val applicationScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
 
     override fun onCreate() {
         super.onCreate()
 
+        val notificationHelper = NotificationHelper(this)
+        notificationHelper.cancelProgressNotification()
+
         preferencesManager = PreferencesManager(this)
         applicationScope.launch(Dispatchers.IO) {
             preferencesManager.sanitizeDictionarySources()
@@ -62,7 +70,8 @@ class ReSearchApplication : Application() {
 
         downloadManager = DownloadManager(
             dictionaryRepository = downloadDictionaryRepository,
-            unknownErrorMessage = getString(R.string.unknown_error)
+            unknownErrorMessage = getString(R.string.unknown_error),
+            sourceUnavailableMessage = getString(R.string.download_file_not_found)
         )
 
         dictionaryImportManager = DictionaryImportManager(
@@ -76,6 +85,40 @@ class ReSearchApplication : Application() {
             localDictionaryRepository = localDictionaryRepository,
         )
 
+        dictionaryProgressPresenter = com.example.research.common.progress.DictionaryProgressPresenter(
+            scope = applicationScope,
+            progressSnapshot = dictionaryProgressStateHolder.progressSnapshot,
+            notifications = notificationHelper,
+        )
+
+        dictionaryPipelineCoordinator = com.example.research.common.progress.DictionaryPipelineCoordinator(
+            scope = applicationScope,
+            steps = com.example.research.common.progress.DefaultReindexingSteps(
+                localDictionaryRepository = localDictionaryRepository,
+                downloadDictionaryRepository = downloadDictionaryRepository,
+            ),
+            importOperations = dictionaryImportManager,
+            ui = dictionaryProgressPresenter,
+            dictionaryPath = { preferencesManager.dictionaryPath },
+            finishService = {
+                val intent = android.content.Intent(
+                    this,
+                    com.example.research.feature.download.service.DictionaryForegroundService::class.java
+                ).apply {
+                    action = com.example.research.feature.download.service.DictionaryForegroundService.ACTION_FINISH
+                }
+                try {
+                    startService(intent)
+                } catch (_: Exception) {
+                }
+            },
+        )
+
+        dictionaryImportManager.onFlowStarted = { dictionaryProgressPresenter.beginFlow() }
+        dictionaryImportManager.onTerminal = dictionaryPipelineCoordinator::onImportTerminal
+        downloadManager.onFlowStarted = { dictionaryProgressPresenter.beginFlow() }
+        downloadManager.onDownloadSuccess = dictionaryPipelineCoordinator::onDownloadSuccess
+        downloadManager.onTerminal = dictionaryPipelineCoordinator::onDownloadTerminal
     }
 
     override fun onTrimMemory(level: Int) {

app/src/main/java/com/example/research/common/progress/DictionaryPipelineCoordinator.kt

@@ -0,0 +1,151 @@
+package com.example.research.common.progress
+
+import com.example.research.core.util.OperationResult
+import com.example.research.feature.download.model.DownloadState
+import com.example.research.ui.settings.ImportState
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import java.io.File
+import kotlin.time.Duration.Companion.seconds
+
+class DictionaryPipelineCoordinator(
+    private val scope: CoroutineScope,
+    private val steps: ReindexingSteps,
+    private val importOperations: ImportFlowOperations,
+    private val ui: PipelineTerminalUi,
+    private val dictionaryPath: () -> String,
+    private val finishService: () -> Unit,
+    private val launchDispatcher: CoroutineDispatcher = Dispatchers.Main,
+    private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO,
+) {
+    private var pipelineJob: Job? = null
+
+    fun onImportTerminal(state: ImportState) {
+        when (state) {
+            is ImportState.Success -> runPipeline(isImport = true)
+            is ImportState.Error -> {
+                ui.showError()
+                finishService()
+            }
+            else -> {}
+        }
+    }
+
+    fun onDownloadSuccess() = runPipeline(isImport = false)
+
+    fun onDownloadTerminal(state: DownloadState) {
+        when (state) {
+            is DownloadState.Error -> {
+                ui.showError()
+                finishService()
+            }
+            is DownloadState.Cancelled -> {
+                ui.cancelProgress()
+                finishService()
+            }
+            else -> {}
+        }
+    }
+
+    fun cancelPipeline() {
+        pipelineJob?.cancel()
+        pipelineJob = null
+    }
+
+    private fun runPipeline(isImport: Boolean) {
+        pipelineJob?.cancel()
+        pipelineJob = scope.launch(launchDispatcher) {
+            val dir = File(dictionaryPath())
+            val filesBeforeReindex = dir?.listFiles()?.map { it.name }?.toSet() ?: emptySet()
+            try {
+                triggerReindexing(isImport)
+                if (isImport) {
+                    importOperations.getAndClearImportedFiles()
+                    importOperations.clearImportState()
+                    ui.showImportSuccess()
+                } else {
+                    ui.showDownloadSuccess()
+                }
+            } catch (e: CancellationException) {
+                if (isImport) {
+                    val filesToCleanup = importOperations.getAndClearImportedFiles()
+                    filesToCleanup.forEach { file ->
+                        try {
+                            if (file.exists()) file.delete()
+                        } catch (_: Exception) {
+                        }
+                    }
+                    cleanupNewFiles(dir, filesBeforeReindex)
+                }
+                cleanupOrphanedFiles(dir)
+                throw e
+            } catch (e: Exception) {
+                ui.showError()
+            } finally {
+                finishService()
+            }
+        }
+    }
+
+    private suspend fun triggerReindexing(isImport: Boolean) = withContext(ioDispatcher) {
+        steps.waitForIndexingCompletion()
+        delay(1.seconds)
+
+        val path = dictionaryPath()
+        if (isImport) {
+            importOperations.updateExtractionProgress(0f)
+        }
+        steps.extractArchives(onProgress = { progress ->
+            if (isImport) {
+                importOperations.updateExtractionProgress(progress)
+            }
+        })
+        val result = steps.scanDirectory(path)
+        if (result is OperationResult.Success && result.data > 0) {
+            steps.warmupIndexes()
+            steps.performAllCleanup()
+        }
+        if (isImport) {
+            importOperations.markImportPipelineSuccess()
+        }
+    }
+
+    private fun cleanupOrphanedFiles(dir: File?) {
+        try {
+            dir?.listFiles()?.forEach { file ->
+                val n = file.name.lowercase()
+                val isRawDsl = n.endsWith(".dsl") && !n.endsWith(".dsl.dz") && !n.endsWith(".dsl.gz")
+                val isBareDz = n.endsWith(".dz") && !n.endsWith(".dsl.dz")
+                val orphaned = when {
+                    isBareDz -> true
+                    isRawDsl -> !File(file.parent, file.name + ".dz").exists()
+                    else -> false
+                }
+                if (orphaned) {
+                    try { file.delete() } catch (_: Exception) {}
+                }
+            }
+        } catch (_: Exception) {
+        }
+    }
+
+    private fun cleanupNewFiles(dir: File?, filesBeforeSnapshot: Set<String>) {
+        try {
+            dir?.listFiles()?.forEach { file ->
+                if (file.name !in filesBeforeSnapshot) {
+                    try {
+                        file.delete()
+                    } catch (_: Exception) {
+                    }
+                }
+            }
+        } catch (_: Exception) {
+        }
+    }
+}

app/src/main/java/com/example/research/common/progress/DictionaryProgressPresenter.kt

@@ -0,0 +1,56 @@
+package com.example.research.common.progress
+
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.launch
+
+class DictionaryProgressPresenter(
+    private val scope: CoroutineScope,
+    private val progressSnapshot: StateFlow<DictionaryProgressModel.Snapshot?>,
+    private val notifications: NotificationPort,
+    mainDispatcher: CoroutineDispatcher = Dispatchers.Main,
+) : PipelineTerminalUi {
+    @Volatile
+    private var terminalActive = false
+
+    init {
+        scope.launch(mainDispatcher) {
+            progressSnapshot.collect { snapshot ->
+                when {
+                    snapshot == null -> {
+                        if (!terminalActive && notifications.hasActiveProgressNotification()) {
+                            notifications.cancelProgressNotification()
+                        }
+                    }
+                    !terminalActive -> notifications.showProgress(snapshot.percent, snapshot.titleRes)
+                }
+            }
+        }
+    }
+
+    fun beginFlow() {
+        terminalActive = false
+    }
+
+    override fun showImportSuccess() {
+        notifications.showImportSuccess()
+        terminalActive = true
+    }
+
+    override fun showDownloadSuccess() {
+        notifications.showDownloadSuccess()
+        terminalActive = true
+    }
+
+    override fun showError() {
+        notifications.showError()
+        terminalActive = true
+    }
+
+    override fun cancelProgress() {
+        terminalActive = false
+        notifications.cancelProgressNotification()
+    }
+}

app/src/main/java/com/example/research/common/progress/NotificationPort.kt

@@ -0,0 +1,10 @@
+package com.example.research.common.progress
+
+interface NotificationPort {
+    fun showProgress(percent: Int, titleRes: Int)
+    fun showImportSuccess()
+    fun showDownloadSuccess()
+    fun showError()
+    fun cancelProgressNotification()
+    fun hasActiveProgressNotification(): Boolean
+}

app/src/main/java/com/example/research/common/progress/PipelineContracts.kt

@@ -0,0 +1,65 @@
+package com.example.research.common.progress
+
+import com.example.research.core.util.OperationResult
+import com.example.research.data.repository.LocalDictionaryRepository
+import com.example.research.feature.download.repository.DictionaryRepository
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.first
+import java.io.File
+import kotlin.time.Duration.Companion.milliseconds
+
+interface PipelineTerminalUi {
+    fun showImportSuccess()
+    fun showDownloadSuccess()
+    fun showError()
+    fun cancelProgress()
+}
+
+interface ImportFlowOperations {
+    fun updateExtractionProgress(progress: Float)
+    fun markImportPipelineSuccess()
+    fun clearImportState()
+    fun getAndClearImportedFiles(): List<File>
+}
+
+interface ReindexingSteps {
+    suspend fun waitForIndexingCompletion(): Boolean
+    suspend fun extractArchives(onProgress: (Float) -> Unit)
+    suspend fun scanDirectory(path: String): OperationResult<Int>
+    suspend fun warmupIndexes()
+    suspend fun performAllCleanup()
+}
+
+class DefaultReindexingSteps(
+    private val localDictionaryRepository: LocalDictionaryRepository,
+    private val downloadDictionaryRepository: DictionaryRepository,
+) : ReindexingSteps {
+
+    override suspend fun waitForIndexingCompletion(): Boolean {
+        if (!localDictionaryRepository.indexingProgress.first().isIndexing) return true
+        var waitCount = 0
+        while (localDictionaryRepository.indexingProgress.first().isIndexing && waitCount < MAX_POLL) {
+            delay(POLL_INTERVAL)
+            waitCount++
+        }
+        return waitCount < MAX_POLL
+    }
+
+    override suspend fun extractArchives(onProgress: (Float) -> Unit) {
+        downloadDictionaryRepository.extractArchives(onProgress = onProgress)
+    }
+
+    override suspend fun scanDirectory(path: String): OperationResult<Int> =
+        localDictionaryRepository.scanDirectory(path)
+
+    override suspend fun warmupIndexes() = localDictionaryRepository.warmupIndexes()
+
+    override suspend fun performAllCleanup() {
+        downloadDictionaryRepository.performAllCleanup()
+    }
+
+    private companion object {
+        const val MAX_POLL = 100
+        val POLL_INTERVAL = 200.milliseconds
+    }
+}

app/src/main/java/com/example/research/common/util/NotificationHelper.kt

@@ -7,8 +7,9 @@ import androidx.core.app.*
 import androidx.core.content.ContextCompat
 import com.example.research.MainActivity
 import com.example.research.R
+import com.example.research.common.progress.NotificationPort
 import com.example.research.feature.download.receiver.DownloadCancelReceiver
-class NotificationHelper(private val context: Context) {
+class NotificationHelper(private val context: Context) : NotificationPort {
     companion object {
         const val CHANNEL_ID = "download_progress_channel"
         const val NOTIFICATION_ID = 1
@@ -64,6 +65,22 @@ class NotificationHelper(private val context: Context) {
             android.Manifest.permission.POST_NOTIFICATIONS
         ) == android.content.pm.PackageManager.PERMISSION_GRANTED
     }
+    override fun showProgress(percent: Int, titleRes: Int) {
+        showUnifiedProgressNotification(
+            title = context.getString(titleRes),
+            contentText = "$percent%",
+            progressPercent = percent,
+        )
+    }
+
+    override fun showDownloadSuccess() = showSuccessNotification()
+
+    override fun showImportSuccess() = showImportSuccessNotification()
+
+    override fun showError() = showErrorNotification()
+
+    override fun cancelProgressNotification() = cancelNotification()
+
     fun showSuccessNotification() {
         if (!canShowNotification()) return
         lastNotificationKey = 0
@@ -93,6 +110,8 @@ class NotificationHelper(private val context: Context) {
         notificationManager.cancel(NOTIFICATION_ID)
     }
 
+    override fun hasActiveProgressNotification(): Boolean = lastNotificationKey != 0
+
     fun showUnifiedProgressNotification(
         title: String,
         contentText: String,

app/src/main/java/com/example/research/core/domain/model/IndexingProgress.kt

@@ -1,42 +1,16 @@
 package com.example.research.core.domain.model
-import kotlin.math.roundToInt
+
+import androidx.compose.runtime.Immutable
 
 /**
  * Snapshot of an ongoing indexing operation.
  *
- * [progress] is the authoritative [0f, 1f] completion value and is O(1) to
- * compute: the repository's internal `ProgressTracker` maintains a running
- * sum across files incrementally and stores it in [aggregateSum], avoiding
- * an O(n) walk over [perFileProgress] on every read.
- * [perFileProgress] is kept for diagnostics; callers should prefer
- * [progress] / [progressPercent].
+ * [progress] is the authoritative [0f, 1f] completion value: the repository
+ * aggregates a file-size-weighted sum across files incrementally while
+ * indexing, so reading it is O(1).
  */
+@Immutable
 data class IndexingProgress(
-    val currentFile: String = "",
-    val currentIndex: Int = 0,
-    val totalFiles: Int = 0,
     val isIndexing: Boolean = false,
-    val currentFileProgress: Float = 0f,
-    val label: String = "",
-    val perFileProgress: Map<String, Float> = emptyMap(),
-    /** Pre-aggregated sum in [0f, totalFiles] supplied by the producer; -1f = unknown. */
-    val aggregateSum: Float = -1f,
-) {
-    val progress: Float
-        get() = if (totalFiles > 0) {
-            when {
-                aggregateSum >= 0f -> (aggregateSum / totalFiles).coerceIn(0f, 1f)
-                perFileProgress.isNotEmpty() -> {
-                    val totalProgress = perFileProgress.values.sum()
-                    (totalProgress / totalFiles).coerceIn(0f, 1f)
-                }
-                else -> {
-                    val completedFiles = (currentIndex - 1).coerceAtLeast(0)
-                    ((completedFiles + currentFileProgress) / totalFiles).coerceIn(0f, 1f)
-                }
-            }
-        } else 0f
-
-    val progressPercent: Int
-        get() = (progress * 100).roundToInt().coerceIn(0, 100)
-}
+    val progress: Float = 0f,
+)

app/src/main/java/com/example/research/core/domain/usecase/DictionarySourceFileMatcher.kt

@@ -0,0 +1,27 @@
+package com.example.research.core.domain.usecase
+
+import com.example.research.core.domain.model.Dictionary
+import com.example.research.core.domain.model.DictionarySource
+import java.io.File
+
+object DictionarySourceFileMatcher {
+    fun matches(source: DictionarySource, fileName: String): Boolean =
+        DictionarySource.matchesDictionaryFile(source.urlTemplate, fileName)
+
+    fun matches(source: DictionarySource, dictionary: Dictionary): Boolean =
+        matches(source, File(dictionary.path).name)
+
+    fun installedSources(
+        sources: List<DictionarySource>,
+        dictionaries: List<Dictionary>,
+    ): List<DictionarySource> = sources.filter { source ->
+        dictionaries.any { dictionary -> matches(source, dictionary) }
+    }
+
+    fun installedSourcesForFileNames(
+        sources: List<DictionarySource>,
+        fileNames: Collection<String>,
+    ): List<DictionarySource> = sources.filter { source ->
+        fileNames.any { fileName -> matches(source, fileName) }
+    }
+}

app/src/main/java/com/example/research/core/domain/usecase/DictionarySourceValidator.kt

@@ -43,12 +43,4 @@ class DictionarySourceValidator {
         return ValidationResult.Valid
     }
 
-    fun findMatchingSourceWithPrecomputedPrefixes(
-        dictionaryPrefix: String,
-        sourcesWithPrefixes: List<Pair<DictionarySource, String?>>
-    ): DictionarySource? {
-        return sourcesWithPrefixes.find { (_, sourcePrefix) ->
-            sourcePrefix != null && dictionaryPrefix.equals(sourcePrefix, ignoreCase = true)
-        }?.first
-    }
 }

app/src/main/java/com/example/research/core/domain/usecase/ManageDictionarySourcesUseCase.kt

@@ -30,18 +30,24 @@ class ManageDictionarySourcesUseCase(
         preferencesManager.removeDictionarySource(sourceId)
     }
 
-    suspend fun removeSourceForDictionary(dictionary: Dictionary) {
-        val dictionaryPrefix = dictionary.name
-        val sources = preferencesManager.dictionarySources.first()
-        val sourcesWithPrefixes = sources.map { source ->
-            source to DictionarySource.extractPrefix(source.urlTemplate)
-        }
+    suspend fun removeSourceForDictionary(
+        dictionary: Dictionary,
+        remainingDictionaryFileNames: Collection<String>?,
+    ) {
+        if (remainingDictionaryFileNames == null) return
 
-        val matchingSource = validator.findMatchingSourceWithPrecomputedPrefixes(dictionaryPrefix, sourcesWithPrefixes)
-        if (matchingSource != null) {
-            preferencesManager.removeDictionarySource(matchingSource.id)
+        val sources = preferencesManager.dictionarySources.first()
+        val sourceIdsToRemove = sources
+            .filter { source ->
+                DictionarySourceFileMatcher.matches(source, dictionary) &&
+                    remainingDictionaryFileNames.none { fileName ->
+                        DictionarySourceFileMatcher.matches(source, fileName)
                     }
             }
+            .map(DictionarySource::id)
+
+        preferencesManager.removeDictionarySources(sourceIdsToRemove)
+    }
 
     sealed class AddSourceResult {
         object Success : AddSourceResult()

app/src/main/java/com/example/research/core/util/NetworkErrorExtensions.kt

@@ -40,6 +40,10 @@ fun Throwable.isNetworkError(): Boolean {
     if (isSslHandshakeError()) return true
 
     return when (this) {
+        is java.net.UnknownHostException,
+        is java.net.ConnectException,
+        is java.net.NoRouteToHostException,
+        is java.net.BindException -> true
         is java.io.IOException -> {
             val message = message ?: ""
             message.contains("connection", ignoreCase = true) ||
@@ -49,9 +53,14 @@ fun Throwable.isNetworkError(): Boolean {
             message.contains("unreachable", ignoreCase = true) ||
             message.contains("no route", ignoreCase = true) ||
             message.contains("broken pipe", ignoreCase = true) ||
+            message.contains("resolve host", ignoreCase = true) ||
+            message.contains("unexpected end of stream", ignoreCase = true) ||
+            message.contains("socket closed", ignoreCase = true) ||
             message.contains("ECONNRESET", ignoreCase = true) ||
             message.contains("ECONNREFUSED", ignoreCase = true) ||
-            message.contains("ENETUNREACH", ignoreCase = true)
+            message.contains("ECONNABORTED", ignoreCase = true) ||
+            message.contains("ENETUNREACH", ignoreCase = true) ||
+            message.contains("EHOSTUNREACH", ignoreCase = true)
         }
         else -> false
     }

app/src/main/java/com/example/research/data/local/preferences/PreferencesManager.kt

@@ -10,12 +10,19 @@ import androidx.datastore.preferences.core.stringSetPreferencesKey
 import androidx.datastore.preferences.preferencesDataStore
 import com.example.research.core.domain.model.DictionarySource
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.map
 import kotlinx.serialization.json.Json
 import java.io.File
 
 private val Context.dataStore: DataStore<Preferences> by preferencesDataStore(name = "settings")
 
+data class SectionExpansionStates(
+    val isThemeExpanded: Boolean,
+    val isLanguageExpanded: Boolean,
+    val isDictionariesExpanded: Boolean,
+)
+
 class PreferencesManager(private val context: Context) {
     private object PreferencesKeys {
         val THEME_MODE = stringPreferencesKey("theme_mode")
@@ -25,6 +32,8 @@ class PreferencesManager(private val context: Context) {
         val IS_LANGUAGE_EXPANDED = booleanPreferencesKey("is_language_expanded")
         val IS_DICTIONARIES_EXPANDED = booleanPreferencesKey("is_dictionaries_expanded")
         val DISABLED_DICTIONARY_PATHS = stringSetPreferencesKey("disabled_dictionary_paths")
+        val HAD_NO_DICTIONARIES = booleanPreferencesKey("had_no_dictionaries")
+        val DICTIONARY_STATUS = stringPreferencesKey("dictionary_status")
     }
 
     private val json = Json { ignoreUnknownKeys = true }
@@ -67,6 +76,35 @@ class PreferencesManager(private val context: Context) {
             preferences[PreferencesKeys.DISABLED_DICTIONARY_PATHS] ?: emptySet()
         }
 
+    val hadNoDictionaries: Flow<Boolean> = context.dataStore.data
+        .map { preferences ->
+            preferences[PreferencesKeys.HAD_NO_DICTIONARIES] ?: true
+        }
+
+    suspend fun setHadNoDictionaries(value: Boolean) {
+        context.dataStore.edit { preferences ->
+            preferences[PreferencesKeys.HAD_NO_DICTIONARIES] = value
+        }
+    }
+
+    suspend fun dictionaryStatus(): String? =
+        context.dataStore.data.first()[PreferencesKeys.DICTIONARY_STATUS]
+
+    suspend fun saveDictionaryStatus(status: String) {
+        context.dataStore.edit { preferences ->
+            preferences[PreferencesKeys.DICTIONARY_STATUS] = status
+        }
+    }
+
+    suspend fun sectionExpansionStates(): SectionExpansionStates =
+        context.dataStore.data.first().let { preferences ->
+            SectionExpansionStates(
+                isThemeExpanded = preferences[PreferencesKeys.IS_THEME_EXPANDED] ?: false,
+                isLanguageExpanded = preferences[PreferencesKeys.IS_LANGUAGE_EXPANDED] ?: false,
+                isDictionariesExpanded = preferences[PreferencesKeys.IS_DICTIONARIES_EXPANDED] ?: true,
+            )
+        }
+
     suspend fun setDictionaryActive(path: String, isActive: Boolean) {
         context.dataStore.edit { preferences ->
             val disabledPaths = preferences[PreferencesKeys.DISABLED_DICTIONARY_PATHS]

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

@@ -46,9 +46,8 @@ class IndexEntryPagingSource(
 
     private data class EmittedKey(
         val dictPosition: Int,
-        val originalWord: String,
-        val offset: Long,
-        val length: Int
+        val word: String,
+        val offset: Long
     )
 
     private val emittedArticles = HashSet<EmittedKey>()
@@ -103,6 +102,7 @@ class IndexEntryPagingSource(
                 val normalizedQuery = query.sanitizeQuery().lowercase().trim()
                 val ranked = rawResults.map { it.second }
                     .rankBySearchRelevance(SearchRankingContext(normalizedQuery))
+                    .distinctBy { Triple(it.dictionaryPath, it.word, it.offset.value) }
 
                 rawResults.forEach { (position, entry) -> emittedArticles.add(entry.emittedKey(position)) }
 
@@ -184,7 +184,7 @@ class IndexEntryPagingSource(
     }
 
     private fun IndexEntry.emittedKey(dictPosition: Int) =
-        EmittedKey(dictPosition, originalWord, offset.value, length.value)
+        EmittedKey(dictPosition, word, offset.value)
 
     override fun getRefreshKey(state: PagingState<TailKey, IndexEntry>): TailKey? {
         return null

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

@@ -180,14 +180,19 @@ internal fun parseDslArticleContent(rawContent: String): String {
 
     while (i < len) {
         val lineStart = i
-        while (i < len && rawContent[i] != '\n') i++
+        while (i < len && rawContent[i] != '\n' && rawContent[i] != '\r') i++
         val lineEnd = i
+        if (i < len && rawContent[i] == '\r') {
+            i++
             if (i < len && rawContent[i] == '\n') i++
+        } else if (i < len && rawContent[i] == '\n') {
+            i++
+        }
 
         if (lineStart == lineEnd && i >= len) break
 
         val line = rawContent.substring(lineStart, lineEnd)
-        val trimmed = line.trimEnd()
+        val trimmed = line.trim()
         if (trimmed.isEmpty()) continue
 
         if (skippingHeadwords) {

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

@@ -24,10 +24,11 @@ object DslHeadwordParser {
         }
 
         if (trimmed.indexOf('{') == -1 && trimmed.indexOf('[') == -1) {
+            val unescaped = unescape(trimmed)
             return ParsedHeadword(
-                simplified = trimmed,
-                displayText = trimmed,
-                searchableText = trimmed.lowercase()
+                simplified = unescaped,
+                displayText = unescaped,
+                searchableText = unescaped.lowercase()
             )
         }
 
@@ -60,9 +61,9 @@ object DslHeadwordParser {
         val searchableText = createSearchableText(trimmed)
 
         return ParsedHeadword(
-            simplified = simplified,
-            displayText = displayText,
-            searchableText = searchableText
+            simplified = unescape(simplified),
+            displayText = unescape(displayText),
+            searchableText = unescape(searchableText)
         )
     }
 
@@ -129,8 +130,17 @@ object DslHeadwordParser {
         if (value.indexOf('{') == -1 && value.indexOf('}') == -1) return value
 
         return buildString(value.length) {
-            value.forEach { char ->
+            var index = 0
+            while (index < value.length) {
+                val char = value[index]
+                if (char == '\\' && index + 1 < value.length) {
+                    append(char)
+                    append(value[index + 1])
+                    index += 2
+                } else {
                     if (char != '{' && char != '}') append(char)
+                    index++
+                }
             }
         }
     }
@@ -138,6 +148,10 @@ object DslHeadwordParser {
     private fun firstFormattingTagIndex(value: String): Int {
         var index = 0
         while (index < value.length) {
+            if (value[index] == '\\' && index + 1 < value.length) {
+                index += 2
+                continue
+            }
             if (value[index] == '[' && formattingTagEnd(value, index) > index) {
                 return index
             }
@@ -149,8 +163,12 @@ object DslHeadwordParser {
     private fun firstCurlyContent(value: String): String? {
         var index = 0
         while (index < value.length) {
+            if (value[index] == '\\' && index + 1 < value.length) {
+                index += 2
+                continue
+            }
             if (value[index] == '{') {
-                val end = value.indexOf('}', startIndex = index + 1)
+                val end = matchingCurlyEnd(value, index + 1)
                 if (end > index + 1) {
                     return value.substring(index + 1, end)
                 }
@@ -161,7 +179,7 @@ object DslHeadwordParser {
     }
 
     private fun substringBeforeFirstBracket(value: String): String {
-        val bracketIndex = value.indexOf('[')
+        val bracketIndex = indexOfUnescaped(value, '[')
         return if (bracketIndex >= 0) value.substring(0, bracketIndex) else value
     }
 
@@ -171,8 +189,12 @@ object DslHeadwordParser {
         var index = 0
 
         while (index < value.length) {
+            if (value[index] == '\\' && index + 1 < value.length) {
+                index += 2
+                continue
+            }
             if (value[index] == '{') {
-                val end = value.indexOf('}', startIndex = index + 1)
+                val end = matchingCurlyEnd(value, index + 1)
                 if (end >= 0 && (removeEmpty || end > index + 1)) {
                     if (builder == null) {
                         builder = StringBuilder(value.length)
@@ -197,6 +219,10 @@ object DslHeadwordParser {
         var index = 0
 
         while (index < value.length) {
+            if (value[index] == '\\' && index + 1 < value.length) {
+                index += 2
+                continue
+            }
             if (value[index] == '[') {
                 val tagEnd = formattingTagEnd(value, index)
                 if (tagEnd > index) {
@@ -217,6 +243,56 @@ object DslHeadwordParser {
         }?.toString() ?: value
     }
 
+    private fun matchingCurlyEnd(value: String, startIndex: Int): Int {
+        var index = startIndex
+        while (index < value.length) {
+            when {
+                value[index] == '\\' && index + 1 < value.length -> index += 2
+                value[index] == '{' -> return -1
+                value[index] == '}' -> return index
+                else -> index++
+            }
+        }
+        return -1
+    }
+
+    private fun indexOfUnescaped(
+        value: String,
+        target: Char,
+        startIndex: Int = 0,
+    ): Int {
+        var index = startIndex.coerceAtLeast(0)
+        while (index < value.length) {
+            if (value[index] == '\\' && index + 1 < value.length) {
+                index += 2
+            } else if (value[index] == target) {
+                return index
+            } else {
+                index++
+            }
+        }
+        return -1
+    }
+
+    private fun unescape(value: String): String {
+        val firstEscape = value.indexOf('\\')
+        if (firstEscape < 0) return value
+
+        return buildString(value.length) {
+            append(value, 0, firstEscape)
+            var index = firstEscape
+            while (index < value.length) {
+                if (value[index] == '\\' && index + 1 < value.length) {
+                    append(value[index + 1])
+                    index += 2
+                } else {
+                    append(value[index])
+                    index++
+                }
+            }
+        }
+    }
+
     private fun formattingTagEnd(value: String, openBracketIndex: Int): Int {
         val tokenStart = openBracketIndex + 1
         if (tokenStart >= value.length) return -1

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

@@ -45,12 +45,6 @@ class IndexSearcher(private val context: Context) {
         val dataStartOffset: Long
     )
 
-    data class IndexComparisonSummary(
-        val expectedCount: Int,
-        val actualCount: Int,
-        val comparedCount: Int
-    )
-
     data class RangeCursor(
         val rangeQuery: String,
         val absoluteIndex: Int,
@@ -72,8 +66,6 @@ class IndexSearcher(private val context: Context) {
         val cursorAfter: RangeCursor?
     )
 
-    class IndexComparisonException(message: String) : IllegalStateException(message)
-
     suspend fun findFirstEntry(pathOrUri: String, query: String): IndexEntry? = withContext(Dispatchers.Default) {
         val normalizedQuery = query.sanitizeQuery().lowercase().trim()
         try {
@@ -244,99 +236,6 @@ class IndexSearcher(private val context: Context) {
         }
     }
 
-    suspend fun compareEntryGroups(
-        expectedIndexPath: String,
-        actualIndexPath: String,
-        onGroup: suspend (word: String, expected: List<IndexEntry>, actual: List<IndexEntry>) -> Unit
-    ): IndexComparisonSummary = withContext(Dispatchers.IO) {
-        val expectedMetadata = loadMetadata(expectedIndexPath)
-        val actualMetadata = loadMetadata(actualIndexPath)
-
-        if (expectedMetadata.totalCount != actualMetadata.totalCount) {
-            throw IndexComparisonException(
-                "Index entry count differs: expected=${expectedMetadata.totalCount}, " +
-                    "actual=${actualMetadata.totalCount}"
-            )
-        }
-
-        openSource(expectedIndexPath).use { expectedSource ->
-            openSource(actualIndexPath).use { actualSource ->
-                expectedSource.seek(expectedMetadata.dataStartOffset)
-                actualSource.seek(actualMetadata.dataStartOffset)
-
-                var expectedNext = readEntryOrNull(expectedSource, expectedMetadata, expectedMetadata.totalCount > 0)
-                var actualNext = readEntryOrNull(actualSource, actualMetadata, actualMetadata.totalCount > 0)
-                var comparedCount = 0
-
-                while (expectedNext != null && actualNext != null) {
-                    if (expectedNext.word != actualNext.word) {
-                        throw IndexComparisonException(
-                            "Index words differ at entry $comparedCount: " +
-                                "expected=${expectedNext.word}, actual=${actualNext.word}"
-                        )
-                    }
-
-                    val word = expectedNext.word
-                    val expectedGroup = mutableListOf<IndexEntry>()
-                    val actualGroup = mutableListOf<IndexEntry>()
-
-                    while (true) {
-                        val current = expectedNext ?: break
-                        if (current.word != word) break
-                        expectedGroup.add(current)
-                        comparedCount++
-                        expectedNext = readEntryOrNull(
-                            expectedSource,
-                            expectedMetadata,
-                            comparedCount < expectedMetadata.totalCount
-                        )
-                    }
-
-                    var actualReadCount = comparedCount - expectedGroup.size
-                    while (true) {
-                        val current = actualNext ?: break
-                        if (current.word != word) break
-                        actualGroup.add(current)
-                        actualReadCount++
-                        actualNext = readEntryOrNull(
-                            actualSource,
-                            actualMetadata,
-                            actualReadCount < actualMetadata.totalCount
-                        )
-                    }
-
-                    if (expectedGroup.size != actualGroup.size) {
-                        throw IndexComparisonException(
-                            "Headword multiplicity differs for '$word': " +
-                                "expected=${expectedGroup.size}, actual=${actualGroup.size}"
-                        )
-                    }
-
-                    onGroup(word, expectedGroup, actualGroup)
-                    if (comparedCount % 10_000 == 0) yield()
-                }
-
-                if (expectedNext != null || actualNext != null) {
-                    throw IndexComparisonException(
-                        "One index ended before the other at entry $comparedCount"
-                    )
-                }
-
-                IndexComparisonSummary(
-                    expectedCount = expectedMetadata.totalCount,
-                    actualCount = actualMetadata.totalCount,
-                    comparedCount = comparedCount
-                )
-            }
-        }
-    }
-
-    private fun readEntryOrNull(
-        source: RandomAccessSource,
-        metadata: IndexMetadata,
-        shouldRead: Boolean
-    ): IndexEntry? = if (shouldRead) readEntry(source, metadata) else null
-
     fun trimMemory(level: Int) {
         metadataCache.trim(level)
         resultsCache.trim(level)

app/src/main/java/com/example/research/data/repository/LocalDictionaryRepository.kt

@@ -27,9 +27,9 @@ import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.ensureActive
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.update
-import kotlinx.coroutines.launch
 import kotlinx.coroutines.supervisorScope
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.Semaphore
@@ -70,13 +70,9 @@ private class ProgressTracker(files: List<LocalDictionaryRepository.DiscoveredFi
         aggregateWeightedMicros.addAndGet(newMicros - prevMicros)
     }
 
-    /**
-     * Current weighted sum mapped back to [0f, totalFiles] so the existing
-     * IndexingProgress model can keep deriving progress as aggregate/total.
-     */
-    fun aggregateSum(): Float {
+    fun progress(): Float {
         val weightedProgress = aggregateWeightedMicros.get().toDouble() / (totalWeight.toDouble() * 1_000_000.0)
-        return (weightedProgress.coerceIn(0.0, 1.0) * totalFiles).toFloat()
+        return weightedProgress.coerceIn(0.0, 1.0).toFloat()
     }
 
     fun reset() {
@@ -95,12 +91,10 @@ class LocalDictionaryRepository(
     override val coroutineContext = Job() + ioDispatcher
 
     private val mutableDictionaries = MutableStateFlow<List<Dictionary>>(emptyList())
-    val dictionaries: StateFlow<List<Dictionary>>
-        get() = mutableDictionaries
+    val dictionaries: StateFlow<List<Dictionary>> = mutableDictionaries.asStateFlow()
 
     private val mutableIndexingProgress = MutableStateFlow(IndexingProgress())
-    val indexingProgress: StateFlow<IndexingProgress>
-        get() = mutableIndexingProgress
+    val indexingProgress: StateFlow<IndexingProgress> = mutableIndexingProgress.asStateFlow()
 
     private val indexingMutex = Mutex()
     private val indexingSemaphore = Semaphore(1)
@@ -123,6 +117,24 @@ class LocalDictionaryRepository(
 
     fun isIndexingInProgress(): Boolean = currentIndexingJob?.isActive == true
 
+    suspend fun listDictionaryPayloadFileNames(path: String): List<String>? =
+        withContext(ioDispatcher) {
+            try {
+                val directory = File(path)
+                when {
+                    !directory.exists() -> {
+                        if (directory.parentFile?.isDirectory == true) emptyList() else null
+                    }
+                    !directory.isDirectory -> null
+                    else -> directory.listFiles { file -> isDictionaryPayloadFile(file) }
+                        ?.map(File::getName)
+                }
+            } catch (e: SecurityException) {
+                Log.w(TAG, "Failed to list dictionary files: ${e.message}")
+                null
+            }
+        }
+
     suspend fun scanDirectory(pathOrUri: String): OperationResult<Int> = withContext(ioDispatcher) {
         if (isIndexingInProgress()) {
             return@withContext OperationResult.Error(
@@ -176,61 +188,59 @@ class LocalDictionaryRepository(
                 mutableIndexingProgress.emit(
                     IndexingProgress(
                         isIndexing = true,
-                        currentFile = context.getString(R.string.indexing_label),
-                        totalFiles = filesToScan.size,
-                        currentIndex = filesToScan.size - filesToIndex.size,
-                        aggregateSum = progressTracker?.aggregateSum() ?: -1f,
+                        progress = progressTracker?.progress() ?: 0f,
                     )
                 )
 
                 val lastEmittedPercent = AtomicInteger(-1)
                 val lastProgressEmitMs = AtomicLong(0L)
 
+                val publishCurrentProgress = {
+                    val tracker = progressTracker
+                    if (tracker != null) {
+                        val progress = tracker.progress()
+                        lastEmittedPercent.set((progress * 100f).toInt().coerceIn(0, 100))
+                        lastProgressEmitMs.set(SystemClock.elapsedRealtime())
+                        mutableIndexingProgress.update { p ->
+                            p.copy(progress = progress)
+                        }
+                    }
+                }
+
                 supervisorScope {
-                    filesToIndex.mapIndexed { index, file ->
+                    filesToIndex.map { file ->
                         async {
                             indexingSemaphore.withPermit {
                                 coroutineContext.ensureActive()
                                 yield()
 
-                                val res = indexDictionary(file) { _, op, prog ->
+                                val res = indexDictionary(file) { _, _, prog ->
                                     if (prog >= 0f) {
                                         progressTracker?.updateFileProgress(file.name, prog)
                                     }
 
-                                    val tracker = progressTracker
-                                    val aggregate = tracker?.aggregateSum() ?: -1f
-                                    val newPercent = if (filesToScan.isNotEmpty() && aggregate >= 0f) {
-                                        ((aggregate / filesToScan.size) * 100f).toInt().coerceIn(0, 100)
-                                    } else -1
+                                    val progress = progressTracker?.progress() ?: 0f
+                                    val newPercent = (progress * 100f).toInt().coerceIn(0, 100)
 
-                                    val currentIdx = filesToScan.size - filesToIndex.size + index + 1
-                                    val previous = mutableIndexingProgress.value
                                     val now = SystemClock.elapsedRealtime()
-                                    val percentChanged = newPercent >= 0 && newPercent != lastEmittedPercent.get()
-                                    val fileChanged = previous.currentFile != file.name
+                                    val percentChanged = newPercent != lastEmittedPercent.get()
                                     val completed = newPercent >= 100 || prog >= 1f
                                     val intervalElapsed =
                                         now - lastProgressEmitMs.get() >= MIN_PROGRESS_EMIT_INTERVAL_MS
-                                    val shouldEmit = fileChanged || completed || (percentChanged && intervalElapsed)
+                                    val shouldEmit = completed || (percentChanged && intervalElapsed)
 
                                     if (shouldEmit) {
-                                        if (newPercent >= 0) lastEmittedPercent.set(newPercent)
+                                        lastEmittedPercent.set(newPercent)
                                         lastProgressEmitMs.set(now)
                                         mutableIndexingProgress.update { p ->
-                                            p.copy(
-                                                currentFile = file.name,
-                                                currentIndex = currentIdx,
-                                                currentFileProgress = prog,
-                                                label = op.ifEmpty { p.label },
-                                                aggregateSum = aggregate,
-                                            )
+                                            p.copy(progress = progress)
                                         }
                                     }
                                 }
 
                                 if (res is OperationResult.Success) {
                                     progressTracker?.updateFileProgress(file.name, 1.0f)
+                                    publishCurrentProgress()
                                     totalArticlesIndexed.addAndGet(res.data.articleCount)
                                     val dictionary = res.data
                                     addDictionary(dictionary)
@@ -371,9 +381,7 @@ class LocalDictionaryRepository(
         val dir = File(path)
         if (!dir.exists() || !dir.isDirectory) return emptyList()
 
-        return dir.listFiles { f ->
-            f.isFile && (f.name.endsWith(".dsl") || f.name.endsWith(".dsl.dz") || f.name.endsWith(".dsl.gz"))
-        }?.map { file ->
+        return dir.listFiles { file -> isDictionaryPayloadFile(file) }?.map { file ->
              DiscoveredFile(
                  name = file.name,
                  localPath = file.absolutePath,
@@ -382,6 +390,16 @@ class LocalDictionaryRepository(
         } ?: emptyList()
     }
 
+    private fun isDictionaryPayloadFile(file: File): Boolean {
+        if (!file.isFile) return false
+        val n = file.name.lowercase()
+        if (n.endsWith(".dsl.dz") || n.endsWith(".dsl.gz")) return true
+        if (n.endsWith(".dsl")) {
+            return File(file.parent, file.name + ".dz").exists()
+        }
+        return false
+    }
+
     suspend fun search(query: String): OperationResult<List<IndexEntry>> = withContext(defaultDispatcher) {
         if (query.isBlank()) return@withContext OperationResult.Success(emptyList())
 
@@ -460,20 +478,17 @@ class LocalDictionaryRepository(
     }
 
     suspend fun deleteDictionary(dictionary: Dictionary): OperationResult<Unit> {
-        try {
-            dictionaryStateMutex.withLock { removeDictionaryFromState(dictionary.path) }
-
-            launch(ioDispatcher) {
-                try {
-                    val deleteErrors = mutableListOf<String>()
-
+        return try {
+            val (failure, cleanupErrors) = withContext(ioDispatcher) {
                 val dictFile = File(dictionary.path)
-                    if (dictFile.exists()) {
-                        if (!dictFile.delete()) {
-                            deleteErrors.add("Failed to delete dictionary file: ${dictFile.absolutePath}")
-                        }
+                if (dictFile.exists() && !dictFile.delete()) {
+                    return@withContext Pair(
+                        "Failed to delete dictionary file: ${dictFile.absolutePath}",
+                        emptyList(),
+                    )
                 }
 
+                val deleteErrors = mutableListOf<String>()
                 val indexFile = if (dictionary.indexPath.endsWith(".idx", ignoreCase = true)) {
                     File(dictionary.indexPath)
                 } else {
@@ -481,12 +496,20 @@ class LocalDictionaryRepository(
                 }
 
                 deleteIndexFiles(indexFile, deleteErrors)
-
-                    if (!dictFile.exists()) {
-                        dictionaryStateMutex.withLock {
-                            preferencesManager.removeDictionaryActiveState(dictionary.path)
-                            removeDictionaryFromState(dictionary.path)
+                Pair<String?, List<String>>(null, deleteErrors)
             }
+
+            if (failure != null) {
+                return OperationResult.Error(failure)
+            }
+
+            dictionaryStateMutex.withLock {
+                try {
+                    preferencesManager.removeDictionaryActiveState(dictionary.path)
+                } catch (e: Exception) {
+                    Log.w(TAG, "Failed to clear dictionary active state: ${e.message}")
+                }
+                removeDictionaryFromState(dictionary.path)
             }
 
             try {
@@ -495,18 +518,16 @@ class LocalDictionaryRepository(
                 Log.w(TAG, "Failed to trim memory after deletion: ${e.message}")
             }
 
-                    if (deleteErrors.isNotEmpty()) {
-                        val message = deleteErrors.joinToString("; ")
-                        Log.w(TAG, "Dictionary deletion completed with errors: $message")
-                    }
-                } catch (e: Exception) {
-                    Log.e(TAG, "Background deletion failed: ${e.message}", e)
-                }
+            if (cleanupErrors.isNotEmpty()) {
+                Log.w(
+                    TAG,
+                    "Dictionary deletion completed with errors: ${cleanupErrors.joinToString("; ")}"
+                )
             }
 
-            return OperationResult.Success(Unit)
+            OperationResult.Success(Unit)
         } catch (e: Exception) {
-            return OperationResult.Error("Failed to delete dictionary", e)
+            OperationResult.Error("Failed to delete dictionary", e)
         }
     }
 

app/src/main/java/com/example/research/feature/download/DownloadManager.kt

@@ -12,6 +12,7 @@ import kotlin.time.Duration.Companion.seconds
 class DownloadManager(
     private val dictionaryRepository: DictionaryRepository,
     private val unknownErrorMessage: String,
+    private val sourceUnavailableMessage: String,
     dispatcher: CoroutineDispatcher = Dispatchers.IO,
     externalScope: CoroutineScope? = null
 ) {
@@ -40,31 +41,51 @@ class DownloadManager(
         val clampedProgress = progress.coerceIn(0f, 1f)
         mutableDownloadProgressState.value = DownloadProgressState(state, clampedProgress)
         mutableDownloadState.value = state
+        if (state is DownloadState.Success) {
+            onDownloadSuccess?.invoke()
+        } else if (state is DownloadState.Error || state is DownloadState.Cancelled) {
+            onTerminal?.invoke(state)
         }
+    }
+
+    var onFlowStarted: (() -> Unit)? = null
+    var onDownloadSuccess: (() -> Unit)? = null
+    var onTerminal: ((DownloadState) -> Unit)? = null
 
     fun startDownload() {
         if (downloadState.value is DownloadState.Loading) return
         if (!downloadScope.isActive) return
+        onFlowStarted?.invoke()
         cancelCleanupJob = null
         downloadJob = downloadScope.launch {
             mutex.withLock {
                 try {
-                    updateDownloadProgressState(DownloadState.Loading, 0f)
-
-                    val hasEnabledSources = try {
-                        dictionaryRepository.hasEnabledSources()
+                    val enabledSources = try {
+                        dictionaryRepository.getEnabledSources()
                     } catch (_: Exception) {
-                        false
+                        emptyList()
                     }
 
-                    if (!hasEnabledSources) {
+                    if (enabledSources.isEmpty()) {
                         dictionaryRepository.performAllCleanup()
-                        updateDownloadProgressState(DownloadState.Success, 1f)
+                        updateDownloadProgressState(DownloadState.Idle, 0f)
                         return@withLock
                     }
+
+                    val downloadableSources =
+                        dictionaryRepository.filterServerAvailableSources(enabledSources)
+                    if (downloadableSources.isEmpty()) {
+                        updateDownloadProgressState(
+                            DownloadState.Error(sourceUnavailableMessage), 0f
+                        )
+                        return@withLock
+                    }
+
+                    updateDownloadProgressState(DownloadState.Loading, 0f)
+
                     var lastReportedProgressBucket = -1
                     val result = ReSearchTrace.asyncSection(ReSearchTrace.DICTIONARY_DOWNLOAD) {
-                        dictionaryRepository.downloadDictionaries { progress ->
+                        dictionaryRepository.downloadSources(downloadableSources) { progress ->
                             val progressBucket = progressBucket(progress, DOWNLOAD_PROGRESS_STEP_PERCENT)
                             if (progressBucket != lastReportedProgressBucket) {
                                 lastReportedProgressBucket = progressBucket
@@ -126,20 +147,41 @@ class DownloadManager(
     fun startDownloadForSources(sourceUrls: List<String>) {
         if (downloadState.value is DownloadState.Loading) return
         if (!downloadScope.isActive) return
+        onFlowStarted?.invoke()
         cancelCleanupJob = null
         downloadJob = downloadScope.launch {
             mutex.withLock {
                 try {
-                    updateDownloadProgressState(DownloadState.Loading, 0f)
-
                     if (sourceUrls.isEmpty()) {
-                        updateDownloadProgressState(DownloadState.Success, 1f)
+                        updateDownloadProgressState(DownloadState.Idle, 0f)
                         return@withLock
                     }
 
+                    val sources = try {
+                        dictionaryRepository.getEnabledSources(sourceUrls)
+                    } catch (_: Exception) {
+                        emptyList()
+                    }
+
+                    if (sources.isEmpty()) {
+                        updateDownloadProgressState(DownloadState.Idle, 0f)
+                        return@withLock
+                    }
+
+                    val downloadableSources =
+                        dictionaryRepository.filterServerAvailableSources(sources)
+                    if (downloadableSources.isEmpty()) {
+                        updateDownloadProgressState(
+                            DownloadState.Error(sourceUnavailableMessage), 0f
+                        )
+                        return@withLock
+                    }
+
+                    updateDownloadProgressState(DownloadState.Loading, 0f)
+
                     var lastReportedProgressBucket = -1
                     val result = ReSearchTrace.asyncSection(ReSearchTrace.DICTIONARY_DOWNLOAD) {
-                        dictionaryRepository.downloadSpecificSources(sourceUrls) { progress ->
+                        dictionaryRepository.downloadSources(downloadableSources) { progress ->
                             val progressBucket = progressBucket(progress, DOWNLOAD_PROGRESS_STEP_PERCENT)
                             if (progressBucket != lastReportedProgressBucket) {
                                 lastReportedProgressBucket = progressBucket

app/src/main/java/com/example/research/feature/download/model/DownloadState.kt

@@ -1,4 +1,8 @@
 package com.example.research.feature.download.model
+
+import androidx.compose.runtime.Immutable
+
+@Immutable
 sealed class DownloadState {
     data object Idle : DownloadState()
     data object Loading : DownloadState()
@@ -7,3 +11,6 @@ sealed class DownloadState {
     data class Error(val message: String) : DownloadState()
     data object Cancelled : DownloadState()
 }
+
+val DownloadState.isActive: Boolean
+    get() = this is DownloadState.Loading || this is DownloadState.Extracting || this is DownloadState.Success

app/src/main/java/com/example/research/feature/download/repository/DictionaryChecker.kt

@@ -12,6 +12,12 @@ import kotlinx.coroutines.withContext
 import okhttp3.OkHttpClient
 import okhttp3.Request
 
+enum class SourceAvailability {
+    AVAILABLE,
+    NOT_FOUND,
+    UNKNOWN
+}
+
 class DictionaryChecker(
     private val fileStorageManager: FileStorageManager,
     private val client: OkHttpClient
@@ -85,7 +91,26 @@ class DictionaryChecker(
         }
     }
 
-    private fun isSourceAvailableOnServer(source: DictionarySource, date: String): Boolean {
+    suspend fun checkSourceAvailability(source: DictionarySource): SourceAvailability =
+        withContext(Dispatchers.IO) {
+            val currentDate = DateUtils.getCurrentDateString()
+            when (probeSource(source, currentDate)) {
+                SourceAvailability.AVAILABLE -> SourceAvailability.AVAILABLE
+                SourceAvailability.UNKNOWN -> SourceAvailability.UNKNOWN
+                SourceAvailability.NOT_FOUND -> {
+                    if (DictionarySource.hasDatePlaceholder(source.urlTemplate)) {
+                        probeSource(source, DateUtils.getPreviousDateString())
+                    } else {
+                        SourceAvailability.NOT_FOUND
+                    }
+                }
+            }
+        }
+
+    private fun isSourceAvailableOnServer(source: DictionarySource, date: String): Boolean =
+        probeSource(source, date) == SourceAvailability.AVAILABLE
+
+    private fun probeSource(source: DictionarySource, date: String): SourceAvailability {
         return try {
             val url = DictionarySource.buildUrl(source.urlTemplate, date)
             val request = Request.Builder()
@@ -94,12 +119,17 @@ class DictionaryChecker(
                 .build()
 
             client.newCall(request).execute().use { response ->
-                response.isSuccessful &&
+                if (response.isSuccessful &&
                     response.header("Content-Type")?.startsWith("text/html") != true
+                ) {
+                    SourceAvailability.AVAILABLE
+                } else {
+                    SourceAvailability.NOT_FOUND
+                }
             }
         } catch (e: Exception) {
             Log.w(TAG, "Failed to check source availability for ${source.urlTemplate}: ${e.message}")
-            false
+            SourceAvailability.UNKNOWN
         }
     }
 

app/src/main/java/com/example/research/feature/download/repository/DictionaryDownloader.kt

@@ -15,8 +15,11 @@ import com.example.research.feature.download.config.DictionaryConfig
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.async
 import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.NonCancellable
+import kotlinx.coroutines.currentCoroutineContext
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.ensureActive
+import kotlinx.coroutines.isActive
 import kotlinx.coroutines.suspendCancellableCoroutine
 import kotlinx.coroutines.withContext
 import kotlinx.coroutines.yield
@@ -58,6 +61,7 @@ class DictionaryDownloader(
     ) {
         if (fileUri == null) return
 
+        withContext(NonCancellable) {
             runCatching {
                 val fileToDelete = fileStorageManager.getDocumentFile(fileUri)
                 if (fileToDelete != null && fileToDelete.exists()) {
@@ -75,6 +79,7 @@ class DictionaryDownloader(
                 }
             }
         }
+    }
     suspend fun downloadDictionaries(
         folderUri: Uri,
         sources: List<DictionarySource>,
@@ -169,7 +174,7 @@ class DictionaryDownloader(
     }
 
     private suspend fun deletePartialFileIfExists(folderUri: Uri, fileName: String) {
-        withContext(Dispatchers.IO) {
+        withContext(Dispatchers.IO + NonCancellable) {
             runCatching {
                 val existingFile = fileStorageManager.findFile(folderUri, fileName)
                 if (existingFile != null && existingFile.exists()) {
@@ -313,7 +318,7 @@ class DictionaryDownloader(
             call?.cancel()
             response?.close()
             outputStream?.close()
-            if (e is CancellationException) {
+            if (e is CancellationException || !currentCoroutineContext().isActive) {
                 deletePartialFileIfExists(folderUri, fileName)
                 deletePartialFileSafely(fileUri, folderUri, fileName)
                 throw e
@@ -343,6 +348,8 @@ class DictionaryDownloader(
                     context.getString(R.string.download_connection_reset)
                 e is SecurityException ->
                     context.getString(R.string.download_no_write_permission)
+                e.isNetworkError() ->
+                    context.getString(R.string.download_network_failed)
                 else ->
                     context.getString(R.string.download_error)
             }

app/src/main/java/com/example/research/feature/download/repository/DictionaryExtractor.kt

@@ -9,7 +9,9 @@ import com.example.research.common.util.FileStorageManager
 import com.example.research.data.dictzip.DictZipRandomAccessFile
 import com.example.research.data.dictzip.DictZipWriter
 import com.example.research.feature.download.config.DictionaryConfig
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.NonCancellable
 import kotlinx.coroutines.withContext
 
 class DictionaryExtractor(
@@ -138,11 +140,39 @@ class DictionaryExtractor(
 
             onProgress?.invoke(1f)
             Result.success(Unit)
+        } catch (e: CancellationException) {
+            deleteOrphanedFiles(folderUri)
+            throw e
         } catch (e: Exception) {
             Result.failure(e)
         }
     }
 
+    private suspend fun deleteOrphanedFiles(folderUri: Uri) {
+        try {
+            withContext(Dispatchers.IO + NonCancellable) {
+                val files = fileStorageManager.listFilesInFolder(folderUri)
+                for (file in files) {
+                    val n = file.name.lowercase()
+                    val isRawDsl = n.endsWith(DictionaryConfig.DSL_EXTENSION) &&
+                        !n.endsWith(DictionaryConfig.DICTZIP_EXTENSION) &&
+                        !n.endsWith(".dsl.gz")
+                    val isBareDz = n.endsWith(".dz") && !n.endsWith(DictionaryConfig.DICTZIP_EXTENSION)
+                    when {
+                        isBareDz -> ArchiveUtils.deleteFile(context, file.uri)
+                        isRawDsl -> {
+                            val pair = fileStorageManager.findFile(folderUri, file.name + ".dz")
+                            if (pair == null || !pair.exists()) {
+                                ArchiveUtils.deleteFile(context, file.uri)
+                            }
+                        }
+                    }
+                }
+            }
+        } catch (_: Exception) {
+        }
+    }
+
     private suspend fun ensureDslDictZip(
         dslUri: Uri,
         dslFileName: String,

app/src/main/java/com/example/research/feature/download/repository/DictionaryRepository.kt

@@ -8,6 +8,8 @@ import com.example.research.core.domain.model.DictionarySource
 import com.example.research.data.local.preferences.PreferencesManager
 import com.example.research.common.util.FileStorageManager
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.withContext
 import okhttp3.OkHttpClient
@@ -40,74 +42,58 @@ class DictionaryRepository(
         checker.areDictionariesUpToDate(uri, sourcesToCheck, files)
     }
 
-    suspend fun hasEnabledSources(): Boolean = withContext(Dispatchers.IO) {
-        preferencesManager.dictionarySources.first().any { it.isEnabled }
+    suspend fun getEnabledSources(sourceUrls: List<String>? = null): List<DictionarySource> =
+        withContext(Dispatchers.IO) {
+            val enabledSources = preferencesManager.dictionarySources.first()
+                .filter { it.isEnabled }
+            if (sourceUrls == null) {
+                return@withContext enabledSources
             }
-
-    suspend fun downloadDictionaries(
-        onProgress: (Float) -> Unit
-    ): Result<Unit> = withContext(Dispatchers.IO) {
-        val folderUri = preferencesManager.dictionaryPath
-        val uri = Uri.fromFile(File(folderUri))
-        val files = fileStorageManager.listFilesInFolder(uri)
-        cleaner.deleteCorruptedArchives(uri, files)
-
-        synchronized(filesBeforeDownload) {
-            filesBeforeDownload = files.map { it.name }.toMutableSet()
-        }
-
-        val sources = preferencesManager.dictionarySources.first()
-        val enabledSources = sources.filter { it.isEnabled }
-
-        synchronized(downloadedPrefixes) {
-            downloadedPrefixes = enabledSources.mapNotNull {
-                DictionarySource.extractPrefix(it.urlTemplate)
-            }.toMutableSet()
-        }
-
-        downloader.downloadDictionaries(
-            folderUri = uri,
-            sources = enabledSources,
-            onProgress = onProgress
-        )
-    }
-
-    suspend fun downloadSpecificSources(
-        sourceUrls: List<String>,
-        onProgress: (Float) -> Unit
-    ): Result<Unit> = withContext(Dispatchers.IO) {
-        val folderUri = preferencesManager.dictionaryPath
-        val uri = Uri.fromFile(File(folderUri))
-        val files = fileStorageManager.listFilesInFolder(uri)
-        cleaner.deleteCorruptedArchives(uri, files)
-
-        synchronized(filesBeforeDownload) {
-            filesBeforeDownload = files.map { it.name }.toMutableSet()
-        }
-
-        val allSources = preferencesManager.dictionarySources.first()
             val sourceKeys = sourceUrls.mapTo(mutableSetOf(), DictionarySource::identityKey)
-        val sourcesToDownload = allSources.mapNotNull { source ->
-            if (!source.isEnabled || DictionarySource.identityKey(source.urlTemplate) !in sourceKeys) {
+            enabledSources.mapNotNull { source ->
+                if (DictionarySource.identityKey(source.urlTemplate) !in sourceKeys) {
                     null
                 } else {
                     source.copy(urlTemplate = DictionarySource.normalizeTemplate(source.urlTemplate))
                 }
             }
+        }
 
-        if (sourcesToDownload.isEmpty()) {
-            return@withContext Result.success(Unit)
+    suspend fun filterServerAvailableSources(
+        sources: List<DictionarySource>
+    ): List<DictionarySource> = withContext(Dispatchers.IO) {
+        if (sources.isEmpty()) {
+            return@withContext emptyList()
+        }
+        sources
+            .map { source -> async { source to checker.checkSourceAvailability(source) } }
+            .awaitAll()
+            .filter { (_, availability) -> availability != SourceAvailability.NOT_FOUND }
+            .map { (source, _) -> source }
+    }
+
+    suspend fun downloadSources(
+        sources: List<DictionarySource>,
+        onProgress: (Float) -> Unit
+    ): Result<Unit> = withContext(Dispatchers.IO) {
+        val folderUri = preferencesManager.dictionaryPath
+        val uri = Uri.fromFile(File(folderUri))
+        val files = fileStorageManager.listFilesInFolder(uri)
+        cleaner.deleteCorruptedArchives(uri, files)
+
+        synchronized(filesBeforeDownload) {
+            filesBeforeDownload = files.map { it.name }.toMutableSet()
         }
 
         synchronized(downloadedPrefixes) {
-            downloadedPrefixes = sourcesToDownload.mapNotNull {
+            downloadedPrefixes = sources.mapNotNull {
                 DictionarySource.extractPrefix(it.urlTemplate)
             }.toMutableSet()
         }
 
         downloader.downloadDictionaries(
             folderUri = uri,
-            sources = sourcesToDownload,
+            sources = sources,
             onProgress = onProgress
         )
     }

app/src/main/java/com/example/research/feature/download/service/DictionaryForegroundService.kt

@@ -3,19 +3,19 @@ package com.example.research.feature.download.service
 import android.app.Service
 import android.content.Intent
 import android.os.IBinder
-import android.util.Log
 import androidx.core.app.ServiceCompat
 import com.example.research.ReSearchApplication
-import com.example.research.common.progress.renderTitle
+import com.example.research.common.progress.DictionaryPipelineCoordinator
+import com.example.research.common.progress.DictionaryProgressPresenter
 import com.example.research.common.util.NotificationHelper
-import com.example.research.core.util.OperationResult
 import com.example.research.data.repository.LocalDictionaryRepository
 import com.example.research.feature.download.DownloadManager
-import com.example.research.feature.download.model.DownloadState
-import kotlinx.coroutines.*
-import kotlinx.coroutines.flow.*
-import kotlin.time.Duration.Companion.milliseconds
-import kotlin.time.Duration.Companion.seconds
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.cancelChildren
+import kotlinx.coroutines.Job
 
 class DictionaryForegroundService : Service() {
 
@@ -23,21 +23,21 @@ class DictionaryForegroundService : Service() {
         const val ACTION_START = "com.example.research.START_DOWNLOAD"
         const val ACTION_STOP = "com.example.research.STOP_DOWNLOAD"
         const val ACTION_IMPORT = "com.example.research.START_IMPORT"
+        const val ACTION_FINISH = "com.example.research.FINISH_PIPELINE"
         private const val NOTIFICATION_ID = NotificationHelper.NOTIFICATION_ID
     }
 
     private lateinit var downloadManager: DownloadManager
     private lateinit var localDictionaryRepository: LocalDictionaryRepository
     private lateinit var dictionaryImportManager: com.example.research.feature.import.DictionaryImportManager
-    private lateinit var progressStateHolder: com.example.research.common.progress.DictionaryProgressStateHolder
+    private lateinit var pipelineCoordinator: DictionaryPipelineCoordinator
+    private lateinit var presenter: DictionaryProgressPresenter
     private val notificationHelper by lazy {
         NotificationHelper(this)
     }
 
     private val serviceScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
     @Volatile
-    private var isHandlingSuccess = false
-    @Volatile
     private var latestStartId = 0
 
     override fun onCreate() {
@@ -47,164 +47,8 @@ class DictionaryForegroundService : Service() {
         downloadManager = app.downloadManager
         localDictionaryRepository = app.localDictionaryRepository
         dictionaryImportManager = app.dictionaryImportManager
-        progressStateHolder = app.dictionaryProgressStateHolder
-        observeDownloadState()
-        observeImportState()
-        observeUnifiedProgress()
-    }
-
-    private fun observeDownloadState() {
-        serviceScope.launch {
-            downloadManager.downloadState.collect { state ->
-                when (state) {
-                    is DownloadState.Success -> handleSuccess()
-                    is DownloadState.Error -> {
-                        notificationHelper.showErrorNotification()
-                        stopForegroundService(removeNotification = false)
-                    }
-                    is DownloadState.Cancelled -> {
-                        notificationHelper.cancelNotification()
-                        stopForegroundService()
-                    }
-                    else -> {}
-                }
-            }
-        }
-    }
-
-    private fun observeImportState() {
-        serviceScope.launch {
-            dictionaryImportManager.importState.collect { state ->
-                when (state) {
-                    is com.example.research.ui.settings.ImportState.Success -> handleSuccess()
-                    is com.example.research.ui.settings.ImportState.Error -> {
-                        notificationHelper.showErrorNotification()
-                        stopForegroundService(removeNotification = false)
-                    }
-                    else -> {}
-                }
-            }
-        }
-    }
-
-    private fun observeUnifiedProgress() {
-        serviceScope.launch {
-            progressStateHolder.progressSnapshot
-                .collect { snapshot ->
-                    if (snapshot != null) {
-                        notificationHelper.showUnifiedProgressNotification(
-                            title = snapshot.renderTitle(this@DictionaryForegroundService),
-                            contentText = "${snapshot.percent}%",
-                            progressPercent = snapshot.percent,
-                        )
-                    }
-                }
-        }
-    }
-
-    private suspend fun triggerReindexing(isImportFlow: Boolean) = withContext(Dispatchers.IO) {
-        try {
-            waitForIndexingCompletion()
-            delay(1.seconds)
-
-            val app = application as? ReSearchApplication
-                ?: return@withContext
-            val path = app.preferencesManager.dictionaryPath
-            if (isImportFlow) {
-                dictionaryImportManager.updateExtractionProgress(0f)
-            }
-            app.downloadDictionaryRepository.extractArchives(onProgress = { progress ->
-                if (isImportFlow) {
-                    dictionaryImportManager.updateExtractionProgress(progress)
-                }
-            })
-            val result = localDictionaryRepository.scanDirectory(path)
-            if (result is OperationResult.Success && result.data > 0) {
-                localDictionaryRepository.warmupIndexes()
-                app.downloadDictionaryRepository.performAllCleanup()
-            }
-            if (isImportFlow) {
-                dictionaryImportManager.markImportPipelineSuccess()
-            }
-        } catch (e: CancellationException) {
-            throw e
-        } catch (e: Exception) {
-            Log.e("DictionaryForegroundService", "triggerReindexing() failed: ${e.message}", e)
-        }
-    }
-
-    private suspend fun waitForIndexingCompletion(): Boolean {
-        val isIndexing = localDictionaryRepository.indexingProgress.first().isIndexing
-
-        if (!isIndexing) {
-            return true
-        }
-
-        var waitCount = 0
-        while (localDictionaryRepository.indexingProgress.first().isIndexing && waitCount < 100) {
-            delay(200.milliseconds)
-            waitCount++
-        }
-
-        return waitCount < 100
-    }
-
-    private fun handleSuccess() {
-        if (isHandlingSuccess) return
-        isHandlingSuccess = true
-        serviceScope.launch {
-            try {
-                val isImportFlow = dictionaryImportManager.importState.value !is com.example.research.ui.settings.ImportState.Idle
-
-                if (isImportFlow) {
-                    val app = application as? ReSearchApplication
-                    val path = app?.preferencesManager?.dictionaryPath
-                    val dictionariesDir = path?.let { java.io.File(it) }
-                    val filesBeforeReindex = dictionariesDir?.listFiles()?.map { it.name }?.toSet() ?: emptySet()
-
-                    try {
-                        triggerReindexing(true)
-                        dictionaryImportManager.getAndClearImportedFiles()
-                    } catch (e: CancellationException) {
-                        val filesToCleanup = dictionaryImportManager.getAndClearImportedFiles()
-                        filesToCleanup.forEach { file ->
-                            try { if (file.exists()) file.delete() } catch (_: Exception) { /* Ignore cleanup failure */ }
-                        }
-                        if (dictionariesDir != null) {
-                            cleanupNewFiles(dictionariesDir, filesBeforeReindex)
-                        }
-                        throw e
-                    }
-                } else {
-                    triggerReindexing(false)
-                }
-
-                if (isImportFlow) {
-                    notificationHelper.showImportSuccessNotification()
-                    dictionaryImportManager.clearImportState()
-                } else {
-                    notificationHelper.showSuccessNotification()
-                }
-            } catch (e: Exception) {
-                if (e !is CancellationException) {
-                    Log.e("DownloadForegroundService", "handleSuccess() failed: ${e.message}", e)
-                    notificationHelper.showErrorNotification()
-                }
-            } finally {
-                isHandlingSuccess = false
-                stopForegroundService(removeNotification = false)
-            }
-        }
-    }
-
-    private fun cleanupNewFiles(dir: java.io.File, filesBeforeSnapshot: Set<String>) {
-        try {
-            dir.listFiles()?.forEach { file ->
-                if (file.name !in filesBeforeSnapshot) {
-                    try { file.delete() } catch (_: Exception) { /* Ignore delete failure */ }
-                }
-            }
-        } catch (_: Exception) { /* Ignore directory listing failure */ }
+        pipelineCoordinator = app.dictionaryPipelineCoordinator
+        presenter = app.dictionaryProgressPresenter
     }
 
     private fun startForegroundService() {
@@ -249,15 +93,20 @@ class DictionaryForegroundService : Service() {
     }
 
     private fun stopForTimeout(startId: Int) {
+        cancelAllWork()
+        ServiceCompat.stopForeground(this, ServiceCompat.STOP_FOREGROUND_REMOVE)
+        stopSelfResult(startId)
+    }
+
+    private fun cancelAllWork() {
         serviceScope.coroutineContext[Job]?.cancelChildren()
+        pipelineCoordinator.cancelPipeline()
         if (localDictionaryRepository.isIndexingInProgress()) {
             localDictionaryRepository.cancelIndexing()
         }
         downloadManager.cancelDownload()
         dictionaryImportManager.cancelImport()
-        notificationHelper.cancelNotification()
-        ServiceCompat.stopForeground(this, ServiceCompat.STOP_FOREGROUND_REMOVE)
-        stopSelfResult(startId)
+        presenter.cancelProgress()
     }
 
     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
@@ -275,21 +124,16 @@ class DictionaryForegroundService : Service() {
             ACTION_IMPORT -> {
                 startForegroundService()
             }
+            ACTION_FINISH -> {
+                stopForegroundService(removeNotification = false)
+            }
             ACTION_STOP -> {
                 try {
                     startForegroundService()
                 } catch (_: Exception) {
                     // Service may already be stopped
                 }
-                serviceScope.coroutineContext[Job]?.cancelChildren()
-
-                if (localDictionaryRepository.isIndexingInProgress()) {
-                    localDictionaryRepository.cancelIndexing()
-                }
-
-                downloadManager.cancelDownload()
-                dictionaryImportManager.cancelImport()
-                notificationHelper.cancelNotification()
+                cancelAllWork()
                 stopForegroundService()
             }
         }

app/src/main/java/com/example/research/feature/import/DictionaryImportManager.kt

@@ -3,6 +3,7 @@ package com.example.research.feature.import
 import android.app.Application
 import android.net.Uri
 import com.example.research.R
+import com.example.research.common.progress.ImportFlowOperations
 import com.example.research.common.util.SafeFileName
 import com.example.research.core.performance.ReSearchTrace
 import com.example.research.ui.settings.ImportState
@@ -14,16 +15,19 @@ import java.util.Collections
 
 class DictionaryImportManager(
     private val application: Application
-) {
+) : ImportFlowOperations {
     private val mutableImportState = MutableStateFlow<ImportState>(ImportState.Idle)
     val importState: StateFlow<ImportState> = mutableImportState.asStateFlow()
 
     private val managerScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
     private var importJob: Job? = null
     private val importedFiles = Collections.synchronizedList(mutableListOf<File>())
+    var onFlowStarted: (() -> Unit)? = null
+    var onTerminal: ((ImportState) -> Unit)? = null
 
     fun importDictionaries(uris: List<Uri>) {
         importJob?.cancel()
+        onFlowStarted?.invoke()
         importJob = managerScope.launch {
             mutableImportState.value = ImportState.Idle
             performImport(uris)
@@ -36,6 +40,8 @@ class DictionaryImportManager(
         val dictionariesDir = File(context.getExternalFilesDir(null), "dictionaries")
         val totalFiles = uris.size.coerceAtLeast(1)
         importedFiles.clear()
+        val skippedNames = mutableListOf<String>()
+        val deferredErrors = mutableListOf<String>()
 
         if (!dictionariesDir.exists()) {
             dictionariesDir.mkdirs()
@@ -46,9 +52,7 @@ class DictionaryImportManager(
                 currentCoroutineContext().ensureActive()
                 val fileName = getFileName(uri) ?: continue
                 if (SafeFileName.validate(fileName) == null) {
-                    mutableImportState.value = ImportState.Error(
-                        context.getString(R.string.import_invalid_file_name, fileName)
-                    )
+                    deferredErrors += context.getString(R.string.import_invalid_file_name, fileName)
                     continue
                 }
                 val lowerFileName = fileName.lowercase()
@@ -65,9 +69,7 @@ class DictionaryImportManager(
                 val destFile = File(dictionariesDir, fileName)
 
                 if (destFile.exists()) {
-                    mutableImportState.value = ImportState.Error(
-                        context.getString(R.string.import_file_exists, fileName)
-                    )
+                    skippedNames += fileName
                     continue
                 }
 
@@ -115,16 +117,30 @@ class DictionaryImportManager(
 
             currentCoroutineContext().ensureActive()
 
-            mutableImportState.value = ImportState.Success
+            val terminalState = resolveImportOutcome(
+                importedCount = importedFiles.size,
+                skippedNames = skippedNames,
+                deferredErrors = deferredErrors,
+            ).toImportState(
+                existsMessage = { names ->
+                    context.getString(R.string.import_file_exists, names.joinToString(separator = ", "))
+                },
+                invalidMessage = { message -> message },
+                nothingImportedMessage = { context.getString(R.string.import_nothing_imported) },
+            )
+            mutableImportState.value = terminalState
+            onTerminal?.invoke(terminalState)
 
         } catch (e: CancellationException) {
             cleanupImportedFiles()
             mutableImportState.value = ImportState.Idle
             throw e
         } catch (e: Exception) {
-            mutableImportState.value = ImportState.Error(
+            val errorState = ImportState.Error(
                 context.getString(R.string.import_error, e.message ?: "Unknown error")
             )
+            mutableImportState.value = errorState
+            onTerminal?.invoke(errorState)
         }
         }
 
@@ -154,18 +170,18 @@ class DictionaryImportManager(
         return size
     }
 
-    fun clearImportState() {
+    override fun clearImportState() {
         mutableImportState.value = ImportState.Idle
     }
 
-    fun updateExtractionProgress(progress: Float) {
+    override fun updateExtractionProgress(progress: Float) {
         mutableImportState.update { current ->
             if (current is ImportState.Idle || current is ImportState.Error) current
             else ImportState.Extracting(progress.coerceIn(0f, 1f))
         }
     }
 
-    fun markImportPipelineSuccess() {
+    override fun markImportPipelineSuccess() {
         mutableImportState.update { current ->
             if (current is ImportState.Idle || current is ImportState.Error) current
             else ImportState.Success
@@ -179,7 +195,7 @@ class DictionaryImportManager(
         mutableImportState.value = ImportState.Idle
     }
 
-    fun getAndClearImportedFiles(): List<File> {
+    override fun getAndClearImportedFiles(): List<File> {
         val files = importedFiles.toList()
         importedFiles.clear()
         return files

app/src/main/java/com/example/research/feature/import/ImportOutcome.kt

@@ -0,0 +1,32 @@
+package com.example.research.feature.import
+
+import com.example.research.ui.settings.ImportState
+
+internal sealed interface ImportOutcome {
+    data object Imported : ImportOutcome
+    data class AlreadyExists(val names: List<String>) : ImportOutcome
+    data class InvalidFile(val message: String) : ImportOutcome
+    data object NothingImported : ImportOutcome
+}
+
+internal fun resolveImportOutcome(
+    importedCount: Int,
+    skippedNames: List<String>,
+    deferredErrors: List<String>,
+): ImportOutcome = when {
+    importedCount > 0 -> ImportOutcome.Imported
+    skippedNames.isNotEmpty() -> ImportOutcome.AlreadyExists(skippedNames)
+    deferredErrors.isNotEmpty() -> ImportOutcome.InvalidFile(deferredErrors.first())
+    else -> ImportOutcome.NothingImported
+}
+
+internal fun ImportOutcome.toImportState(
+    existsMessage: (List<String>) -> String,
+    invalidMessage: (String) -> String,
+    nothingImportedMessage: () -> String,
+): ImportState = when (this) {
+    ImportOutcome.Imported -> ImportState.Success
+    is ImportOutcome.AlreadyExists -> ImportState.Error(existsMessage(names))
+    is ImportOutcome.InvalidFile -> ImportState.Error(invalidMessage(message))
+    ImportOutcome.NothingImported -> ImportState.Error(nothingImportedMessage())
+}

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

@@ -85,7 +85,12 @@ class SearchViewModel(
 
     @OptIn(FlowPreview::class, ExperimentalCoroutinesApi::class)
     val searchResults: Flow<PagingData<IndexEntry>> = combine(
-        searchQuery.debounce(300.milliseconds).distinctUntilChanged(),
+        searchQuery
+            .map { it to it.isBlank() }
+            .distinctUntilChangedBy { it.first }
+            .flatMapLatest { (query, isBlank) ->
+                if (isBlank) flowOf(query) else flowOf(query).debounce(300.milliseconds)
+            },
         activeDictionaries
     ) { query, dictionaries ->
         query to dictionaries
@@ -117,6 +122,7 @@ class SearchViewModel(
             SearchAction.ClearQuery -> {
                 mutableSearchQuery.value = ""
                 savedStateHandle[KEY_SEARCH_QUERY] = ""
+                clearArticle()
             }
             is SearchAction.ArticleClicked -> {
                 articleHistory.clear()
@@ -131,6 +137,9 @@ class SearchViewModel(
     fun onSearchQueryChanged(query: String) {
         val sanitized = query.sanitizeQuery().trim()
         mutableSearchQuery.value = sanitized
+        if (sanitized.isBlank()) {
+            clearArticle()
+        }
         // Debounce SavedStateHandle writes to reduce disk I/O
         debounceSaveQueryJob?.cancel()
         debounceSaveQueryJob = viewModelScope.launch {

app/src/main/java/com/example/research/ui/about/AboutLibrariesData.kt

@@ -78,6 +78,4 @@ internal object AboutLibrariesParser {
         context.resources.openRawResource(resourceId)
             .bufferedReader()
             .use { reader -> json.decodeFromString(reader.readText()) }
-
-    fun decode(source: String): AboutLibrariesData = json.decodeFromString(source)
 }

app/src/main/java/com/example/research/ui/about/AboutScreen.kt

@@ -1,19 +1,25 @@
 package com.example.research.ui.about
 
-import androidx.compose.animation.animateContentSize
+import androidx.compose.animation.animateColorAsState
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.animation.core.tween
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.ExperimentalLayoutApi
 import androidx.compose.foundation.layout.FlowRow
 import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.heightIn
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.items
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.verticalScroll
-import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.AlertDialogDefaults
+import androidx.compose.material3.BasicAlertDialog
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
@@ -25,12 +31,17 @@ import androidx.compose.material3.TextButton
 import androidx.compose.material3.TopAppBar
 import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.produceState
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
+import androidx.compose.runtime.snapshotFlow
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.platform.LocalConfiguration
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalUriHandler
 import androidx.compose.ui.platform.testTag
@@ -43,6 +54,9 @@ import androidx.compose.ui.unit.dp
 import com.example.research.R
 import com.example.research.common.ui.components.OutlinedChoiceButton
 import com.example.research.ui.theme.AppWindowInsets
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.withContext
 
 @OptIn(ExperimentalMaterial3Api::class, ExperimentalLayoutApi::class)
 @Composable
@@ -57,11 +71,22 @@ fun AboutScreen(
     }
     val versionName = packageInfo?.versionName ?: stringResource(R.string.version_unknown)
     val uriHandler = LocalUriHandler.current
-    val librariesData = remember(context) {
+    val librariesData by produceState<AboutLibrariesData?>(initialValue = null, context) {
+        value = withContext(Dispatchers.IO) {
             AboutLibrariesParser.read(context, R.raw.aboutlibraries)
         }
+    }
     var expandedLibraryId by remember { mutableStateOf<String?>(null) }
     var dialogLicense by remember { mutableStateOf<AboutLicense?>(null) }
+    val onToggleLibrary = remember {
+        { uniqueId: String ->
+            expandedLibraryId = if (expandedLibraryId == uniqueId) {
+                null
+            } else {
+                uniqueId
+            }
+        }
+    }
 
     Scaffold(
         topBar = {
@@ -89,24 +114,20 @@ fun AboutScreen(
                 .semantics { testTagsAsResourceId = true }
                 .padding(padding)
         ) {
-            item(key = "about_header") {
+            item(key = "about_header", contentType = "about_header") {
                 AboutHeader(versionName = versionName)
             }
             items(
-                items = librariesData.libraries,
+                items = librariesData?.libraries.orEmpty(),
                 key = AboutLibrary::uniqueId,
+                contentType = { "about_library" },
             ) { library ->
                 AboutLibraryRow(
+                    modifier = Modifier.animateItem(fadeInSpec = tween(150)),
                     library = library,
-                    licenses = librariesData.licenses,
+                    licenses = librariesData?.licenses.orEmpty(),
                     expanded = expandedLibraryId == library.uniqueId,
-                    onToggle = {
-                        expandedLibraryId = if (expandedLibraryId == library.uniqueId) {
-                            null
-                        } else {
-                            library.uniqueId
-                        }
-                    },
+                    onToggle = onToggleLibrary,
                     onLicenseClick = { dialogLicense = it },
                 )
             }
@@ -167,32 +188,37 @@ private fun AboutHeader(versionName: String) {
 @OptIn(ExperimentalLayoutApi::class)
 @Composable
 private fun AboutLibraryRow(
+    modifier: Modifier = Modifier,
     library: AboutLibrary,
     licenses: Map<String, AboutLicense>,
     expanded: Boolean,
-    onToggle: () -> Unit,
+    onToggle: (String) -> Unit,
     onLicenseClick: (AboutLicense) -> Unit,
 ) {
     val uriHandler = LocalUriHandler.current
     val website = library.website?.takeIf(String::isNotBlank)
     val source = library.scm?.url?.takeIf(String::isNotBlank)
 
-    Surface(
-        modifier = Modifier
-            .fillMaxWidth()
-            .testTag("about_library_row")
-            .semantics { testTagsAsResourceId = true },
-        color = if (expanded) {
+    val background by animateColorAsState(
+        targetValue = if (expanded) {
             MaterialTheme.colorScheme.surfaceContainerHighest
         } else {
             MaterialTheme.colorScheme.surface
         },
-        onClick = onToggle
+        label = "aboutLibraryRowBackground",
+    )
+
+    Surface(
+        modifier = modifier
+            .fillMaxWidth()
+            .testTag("about_library_row")
+            .semantics { testTagsAsResourceId = true },
+        color = background,
+        onClick = { onToggle(library.uniqueId) }
     ) {
         Column(
             modifier = Modifier
-                .padding(horizontal = 16.dp, vertical = 12.dp)
-                .animateContentSize(),
+                .padding(horizontal = 16.dp, vertical = 12.dp),
             verticalArrangement = Arrangement.spacedBy(5.dp)
         ) {
             Row(
@@ -288,32 +314,79 @@ private fun AboutLibraryRow(
     }
 }
 
+@OptIn(ExperimentalMaterial3Api::class)
 @Composable
 private fun LicenseDialog(
     license: AboutLicense,
     onDismiss: () -> Unit,
     onOpenWebsite: (String) -> Unit,
 ) {
-    AlertDialog(
-        onDismissRequest = onDismiss,
-        title = { Text(license.name) },
-        text = {
+    var open by remember { mutableStateOf(false) }
+    var wasOpen by remember { mutableStateOf(false) }
+    LaunchedEffect(Unit) { open = true }
+    val scale by animateFloatAsState(
+        targetValue = if (open) 1f else 0.92f,
+        animationSpec = tween(180),
+        label = "licenseDialogScale",
+    )
+    val alpha by animateFloatAsState(
+        targetValue = if (open) 1f else 0f,
+        animationSpec = tween(180),
+        label = "licenseDialogAlpha",
+    )
+    LaunchedEffect(open) {
+        if (open) {
+            wasOpen = true
+        } else if (wasOpen) {
+            snapshotFlow { alpha }.first { it == 0f }
+            onDismiss()
+        }
+    }
+
+    BasicAlertDialog(
+        onDismissRequest = { open = false },
+        modifier = Modifier.graphicsLayer {
+            scaleX = scale
+            scaleY = scale
+            this.alpha = alpha
+        }
+    ) {
+        val maxHeight = LocalConfiguration.current.screenHeightDp.dp - 96.dp
+        Surface(
+            shape = AlertDialogDefaults.shape,
+            color = AlertDialogDefaults.containerColor,
+            tonalElevation = AlertDialogDefaults.TonalElevation,
+        ) {
+            Column(modifier = Modifier.padding(24.dp).heightIn(max = maxHeight)) {
+                Text(
+                    text = license.name,
+                    style = MaterialTheme.typography.headlineSmall,
+                    color = MaterialTheme.colorScheme.onSurface
+                )
+                Spacer(modifier = Modifier.height(16.dp))
                 Text(
                     text = license.content ?: stringResource(R.string.license_text_unavailable),
-                modifier = Modifier.verticalScroll(rememberScrollState())
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    modifier = Modifier
+                        .weight(1f, fill = false)
+                        .verticalScroll(rememberScrollState())
                 )
-        },
-        confirmButton = {
-            TextButton(onClick = onDismiss) {
-                Text(stringResource(R.string.action_close))
-            }
-        },
-        dismissButton = {
+                Spacer(modifier = Modifier.height(24.dp))
+                Row(
+                    modifier = Modifier.fillMaxWidth(),
+                    horizontalArrangement = Arrangement.spacedBy(8.dp, Alignment.End)
+                ) {
                     license.url?.takeIf(String::isNotBlank)?.let { url ->
                         TextButton(onClick = { onOpenWebsite(url) }) {
                             Text(stringResource(R.string.website))
                         }
                     }
+                    TextButton(onClick = { open = false }) {
+                        Text(stringResource(R.string.action_close))
+                    }
+                }
+            }
+        }
     }
-    )
 }

app/src/main/java/com/example/research/ui/article/ArticleScreen.kt

@@ -125,6 +125,7 @@ fun ArticleContent(
 
             LazyColumn(
                 state = listState,
+                contentPadding = PaddingValues(top = Spacing.listItemVertical),
                 modifier = modifier
                     .fillMaxSize()
                     .onSizeChanged { viewportSize = it }
@@ -149,7 +150,7 @@ fun ArticleContent(
                         Box(
                             modifier = Modifier
                                 .padding(
-                                    start = Spacing.iconStart + indentStep * block.indent
+                                    start = Spacing.contentStart + indentStep * block.indent
                                 )
                                 .padding(bottom = if (followedByContinuation) 0.dp else 8.dp)
                         ) {
@@ -196,16 +197,7 @@ fun ArticleContent(
             }
         }
         null -> {
-            Column(
-                modifier = modifier.fillMaxSize(),
-                horizontalAlignment = Alignment.CenterHorizontally,
-                verticalArrangement = Arrangement.Center
-            ) {
-                Text(
-                    text = stringResource(R.string.article_no_selected),
-                    style = MaterialTheme.typography.bodyLarge
-                )
-            }
+            Box(modifier = modifier.fillMaxSize())
         }
     }
 }
@@ -221,7 +213,7 @@ fun ArticleTitleBar(
         is ArticleState.Loading -> articleState.title
         is ArticleState.Success -> articleState.title
         is ArticleState.Error -> articleState.title
-        null -> stringResource(R.string.article_no_selected)
+        null -> ""
     }
 
     val backIcon = painterResource(R.drawable.ic_arrow_back)
@@ -230,20 +222,19 @@ fun ArticleTitleBar(
         color = MaterialTheme.colorScheme.surface,
         modifier = modifier.fillMaxWidth()
     ) {
-        Box(
+        Row(
             modifier = Modifier
                 .fillMaxWidth()
                 .windowInsetsPadding(AppWindowInsets.topAndHorizontalSafeDrawing)
                 .padding(
-                    top = Spacing.topBarPadding,
-                    bottom = Spacing.topBarPadding
-                )
-                .height(Spacing.topBarHeight)
+                    top = Spacing.listItemVertical,
+                    bottom = Spacing.listItemVertical
+                ),
+            verticalAlignment = Alignment.CenterVertically
         ) {
             if (showBackButton) {
                 Box(
                     modifier = Modifier
-                        .align(Alignment.CenterStart)
                         .padding(start = Spacing.iconStart)
                         .size(24.dp)
                         .clickable(onClick = onNavigateBack),
@@ -264,8 +255,7 @@ fun ArticleTitleBar(
                 maxLines = 1,
                 overflow = TextOverflow.Ellipsis,
                 modifier = Modifier
-                    .align(Alignment.CenterStart)
-                    .padding(start = if (showBackButton) Spacing.searchTextStart else 16.dp)
+                    .padding(start = if (showBackButton) Spacing.searchTextStart - Spacing.iconStart - 24.dp else 16.dp)
                     .testTag("article_title")
                     .semantics { testTagsAsResourceId = true }
             )

app/src/main/java/com/example/research/ui/article/DslAnnotatedParser.kt

@@ -23,7 +23,40 @@ object DslAnnotatedParser {
         "br", "p", "b", "i", "c", "t", "m", "m0", "m1", "m2", "m3", "m4", "m5",
         "ref", "ex", "e", "trn", "com", "lang", "sup", "'"
     )
-    private val ESCAPED_CHARS = setOf('[', ']', '(', ')')
+
+    private val DSL_NAMED_COLORS = mapOf(
+        "black" to Color(0xFF000000),
+        "silver" to Color(0xFFC0C0C0),
+        "gray" to Color(0xFF808080),
+        "grey" to Color(0xFF808080),
+        "lightgray" to Color(0xFFD3D3D3),
+        "lightgrey" to Color(0xFFD3D3D3),
+        "darkgray" to Color(0xFFA9A9A9),
+        "darkgrey" to Color(0xFFA9A9A9),
+        "white" to Color(0xFFFFFFFF),
+        "maroon" to Color(0xFF800000),
+        "red" to Color(0xFFFF0000),
+        "darkred" to Color(0xFF8B0000),
+        "crimson" to Color(0xFFDC143C),
+        "brown" to Color(0xFFA52A2A),
+        "orange" to Color(0xFFFFA500),
+        "pink" to Color(0xFFFFC0CB),
+        "purple" to Color(0xFF800080),
+        "violet" to Color(0xFFEE82EE),
+        "fuchsia" to Color(0xFFFF00FF),
+        "magenta" to Color(0xFFFF00FF),
+        "olive" to Color(0xFF808000),
+        "yellow" to Color(0xFFFFFF00),
+        "green" to Color(0xFF008000),
+        "darkgreen" to Color(0xFF006400),
+        "lime" to Color(0xFF00FF00),
+        "teal" to Color(0xFF008080),
+        "aqua" to Color(0xFF00FFFF),
+        "cyan" to Color(0xFF00FFFF),
+        "navy" to Color(0xFF000080),
+        "blue" to Color(0xFF0000FF),
+        "darkblue" to Color(0xFF00008B),
+    )
 
     data class ColorScheme(
         val secondaryText: Color,
@@ -55,9 +88,9 @@ object DslAnnotatedParser {
         val stack = ArrayDeque<SpanStyle>()
         val refStack = ArrayDeque<Pair<Int, StringBuilder>>()
         val lazyRefs = mutableListOf<LazyRef>()
-        var lastChar: Char? = null
         var accentNext = false
         var currentIndent = 0
+        var mClosedPendingBreak = false
         val exampleStyle = SpanStyle(color = colorScheme.secondaryText)
         val labelStyle = SpanStyle(color = colorScheme.labelText)
         val linkStyle = SpanStyle(color = colorScheme.linkText, textDecoration = TextDecoration.Underline)
@@ -85,6 +118,20 @@ object DslAnnotatedParser {
                 stack.forEach { builder.pushStyle(it) }
                 lazyRefs.clear()
             }
+            mClosedPendingBreak = false
+        }
+
+        fun appendChar(char: Char) {
+            if (mClosedPendingBreak) {
+                mClosedPendingBreak = false
+                if (refStack.isEmpty() && !char.isWhitespace()) {
+                    flushBlock()
+                }
+            }
+            builder.append(char)
+            if (refStack.isNotEmpty()) {
+                refStack.last().second.append(char)
+            }
         }
 
         fun marginIndent(tagName: String): Int {
@@ -100,26 +147,15 @@ object DslAnnotatedParser {
             when (val char = dsl[i]) {
                 '\\' -> {
                     if (i + 1 < length) {
-                        val next = dsl[i + 1]
-                        if (next in ESCAPED_CHARS) {
-                            builder.append(next)
-                            if (refStack.isNotEmpty()) {
-                                refStack.last().second.append(next)
-                            }
-                            lastChar = next
+                        appendChar(dsl[i + 1])
                         i += 2
                         continue
                     }
-                    }
-                    builder.append(char)
-                    if (refStack.isNotEmpty()) {
-                        refStack.last().second.append(char)
-                    }
-                    lastChar = char
+                    appendChar(char)
                     i++
                 }
                 '[' -> {
-                    val end = dsl.indexOf(']', i + 1)
+                    val end = tagCloseIndex(dsl, i + 1)
                     if (end != -1) {
                         val tagStart = i + 1
                         var tagEnd = end
@@ -151,6 +187,9 @@ object DslAnnotatedParser {
                                 } else if (tagName == "'") {
                                     accentNext = false
                                 }
+                                if (tagName.startsWith("m")) {
+                                    mClosedPendingBreak = true
+                                }
                                 pop()
                             } else {
                                 when (tagName) {
@@ -164,17 +203,15 @@ object DslAnnotatedParser {
                                         } else {
                                             builder.append("\n")
                                         }
-                                        lastChar = '\n'
                                     }
                                     "p" -> {
                                         push(labelStyle)
                                     }
                                     "b" -> push(SpanStyle(fontWeight = FontWeight.Bold))
                                     "m", "m0", "m1", "m2", "m3", "m4", "m5" -> {
-                                        if (lastChar != '\n' && lastChar != null) {
+                                        if (builder.length > 0) {
                                             if (refStack.isEmpty()) flushBlock() else builder.append("\n")
                                         }
-                                        lastChar = '\n'
                                         currentIndent = marginIndent(tagName)
                                         push(exampleStyle)
                                     }
@@ -184,7 +221,18 @@ object DslAnnotatedParser {
                                         refStack.addLast(builder.length to StringBuilder())
                                     }
                                     "ex", "e" -> push(exampleStyle)
-                                    "c", "t", "trn", "lang", "sup" -> push(SpanStyle())
+                                    "c" -> {
+                                        val colorName = if (spaceIdx >= 0) {
+                                            tagWithParams.substring(spaceIdx + 1).trim().lowercase()
+                                        } else {
+                                            null
+                                        }
+                                        push(when {
+                                            colorName == null -> labelStyle
+                                            else -> DSL_NAMED_COLORS[colorName]?.let { SpanStyle(color = it) } ?: SpanStyle()
+                                        })
+                                    }
+                                    "t", "trn", "lang", "sup" -> push(SpanStyle())
                                     "com" -> push(SpanStyle(fontStyle = FontStyle.Italic, color = colorScheme.labelText))
                                 }
                             }
@@ -192,18 +240,11 @@ object DslAnnotatedParser {
                             continue
                         }
                     }
-                    builder.append(char)
-                    if (refStack.isNotEmpty()) {
-                        refStack.last().second.append(char)
-                    }
-                    lastChar = char
+                    appendChar(char)
                     i++
                 }
                 else -> {
-                    builder.append(char)
-                    if (refStack.isNotEmpty()) {
-                        refStack.last().second.append(char)
-                    }
+                    appendChar(char)
 
                     if (accentNext) {
                         builder.append('\u0301')
@@ -213,7 +254,6 @@ object DslAnnotatedParser {
                         accentNext = false
                     }
 
-                    lastChar = char
                     i++
                 }
             }
@@ -228,6 +268,19 @@ object DslAnnotatedParser {
         splitOversizedBlocks(result)
     }
 
+    private fun tagCloseIndex(value: String, startIndex: Int): Int {
+        var index = startIndex
+        while (index < value.length) {
+            when {
+                value[index] == '\\' && index + 1 < value.length -> index += 2
+                value[index] == '[' -> return -1
+                value[index] == ']' -> return index
+                else -> index++
+            }
+        }
+        return -1
+    }
+
     private fun splitOversizedBlocks(blocks: List<DslBlock>): List<DslBlock> {
         if (blocks.none { it.text.length > MAX_BLOCK_TEXT_LENGTH }) return blocks
         return blocks.flatMap { block ->

app/src/main/java/com/example/research/ui/main/AdaptiveMainScreen.kt

@@ -13,6 +13,7 @@ import com.example.research.ui.article.ArticleContent
 import com.example.research.ui.article.ArticleTitleBar
 import com.example.research.ui.article.ArticleState
 import com.example.research.ui.main.components.MainTopBar
+import com.example.research.ui.theme.Spacing
 
 @OptIn(ExperimentalMaterial3AdaptiveApi::class)
 @Composable
@@ -84,7 +85,7 @@ fun AdaptiveMainScreen(
                         .windowInsetsPadding(
                             WindowInsets.safeDrawing.only(WindowInsetsSides.Horizontal)
                         )
-                        .padding(start = 32.dp, end = listEndPadding),
+                        .padding(start = Spacing.contentStart, end = listEndPadding),
                     listModifier = Modifier.windowInsetsPadding(WindowInsets.navigationBars),
                 )
             },
@@ -96,7 +97,7 @@ fun AdaptiveMainScreen(
                 ) {
                     ArticleTitleBar(
                         articleState = articleState,
-                        showBackButton = isShowingDetail,
+                        showBackButton = isShowingDetail && articleState != null,
                         onNavigateBack = onNavigateBackFromArticle,
                         modifier = Modifier.windowInsetsPadding(
                             WindowInsets.safeDrawing.only(WindowInsetsSides.Top)
@@ -112,8 +113,13 @@ fun AdaptiveMainScreen(
         )
     }
 
-    LaunchedEffect(articleState, isQueryEmpty) {
+    LaunchedEffect(articleState, isQueryEmpty, isLandscape) {
         val targetValue = when {
+            isLandscape -> ThreePaneScaffoldValue(
+                primary = PaneAdaptedValue.Expanded,
+                secondary = PaneAdaptedValue.Expanded,
+                tertiary = PaneAdaptedValue.Hidden,
+            )
             articleState == null -> ThreePaneScaffoldValue(
                 primary = PaneAdaptedValue.Hidden,
                 secondary = PaneAdaptedValue.Expanded,

app/src/main/java/com/example/research/ui/main/MainScreen.kt

@@ -14,6 +14,7 @@ import androidx.compose.foundation.text.input.TextFieldState
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.dp
 import com.example.research.ui.theme.AppWindowInsets
+import com.example.research.ui.theme.Spacing
 import androidx.paging.compose.LazyPagingItems
 import androidx.paging.compose.collectAsLazyPagingItems
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
@@ -169,7 +170,7 @@ internal fun MainScreen(
                 .padding(paddingValues)
                 .consumeWindowInsets(paddingValues)
                 .windowInsetsPadding(AppWindowInsets.horizontalSafeDrawing)
-                .padding(start = 32.dp, end = 16.dp),
+                .padding(start = Spacing.contentStart, end = 16.dp),
         )
     }
 }

app/src/main/java/com/example/research/ui/main/components/MainTopBar.kt

@@ -4,6 +4,7 @@ import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.offset
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.windowInsetsPadding
@@ -135,7 +136,9 @@ private fun SearchField(
             Icon(
                 painter = searchIcon,
                 contentDescription = null,
-                modifier = Modifier.size(24.dp)
+                modifier = Modifier
+                    .offset(x = 4.dp)
+                    .size(24.dp)
             )
         },
         trailingIcon = if (searchState.text.isNotEmpty()) {
@@ -146,6 +149,7 @@ private fun SearchField(
                         onClearQuery()
                     },
                     modifier = Modifier
+                        .padding(end = 12.dp)
                         .testTag("clear_search")
                         .semantics { testTagsAsResourceId = true }
                 ) {

app/src/main/java/com/example/research/ui/main/components/SearchResultsList.kt

@@ -1,5 +1,6 @@
 package com.example.research.ui.main.components
 
+import androidx.compose.animation.core.tween
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.lazy.*
@@ -41,9 +42,17 @@ fun SearchResultsList(
     ) {
         items(
             count = results.itemCount,
+            key = results.itemKey { "${it.dictionaryPath}:${it.offset.value}:${it.word}" },
             contentType = results.itemContentType { "search_result" }
         ) { index ->
             results[index]?.let { entry ->
+                Box(
+                    modifier = Modifier.animateItem(
+                        fadeInSpec = if (index < 8) tween(150) else null,
+                        placementSpec = null,
+                        fadeOutSpec = null
+                    )
+                ) {
                     SearchResultItem(
                         entry = entry,
                         resultIndex = index,
@@ -52,6 +61,7 @@ fun SearchResultsList(
                     )
                 }
             }
+        }
 
         when (results.loadState.append) {
             is LoadState.Error -> {

app/src/main/java/com/example/research/ui/navigation/AppNavigation.kt

@@ -1,23 +1,26 @@
 package com.example.research.ui.navigation
 
 import androidx.activity.compose.BackHandler
+import androidx.compose.animation.AnimatedContent
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.slideInHorizontally
+import androidx.compose.animation.slideOutHorizontally
+import androidx.compose.animation.togetherWith
+import androidx.compose.animation.core.tween
 import androidx.compose.material3.adaptive.ExperimentalMaterial3AdaptiveApi
-import androidx.compose.material3.adaptive.currentWindowAdaptiveInfo
+import androidx.compose.material3.adaptive.currentWindowAdaptiveInfoV2
 import androidx.compose.runtime.*
 import androidx.compose.runtime.saveable.*
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.window.core.layout.WindowSizeClass.Companion.WIDTH_DP_MEDIUM_LOWER_BOUND
 import com.example.research.feature.search.SearchAction
 import com.example.research.feature.search.SearchViewModel
-import com.example.research.feature.download.model.DownloadState
 import com.example.research.ui.about.AboutScreen
 import com.example.research.ui.article.ArticleRoute
 import com.example.research.ui.main.MainRoute
-import com.example.research.ui.settings.ImportState
 import com.example.research.ui.settings.SettingsRoute
 import com.example.research.ui.settings.SettingsViewModel
-import kotlinx.coroutines.delay
-import kotlin.time.Duration.Companion.milliseconds
 
 private data class NavigationState(
     val shouldShowSettings: Boolean,
@@ -33,7 +36,8 @@ enum class Screen {
 @Composable
 fun AppNavigation(
     searchViewModel: SearchViewModel,
-    settingsViewModel: SettingsViewModel
+    settingsViewModel: SettingsViewModel,
+    seedNoDictionaries: Boolean = false
 ) {
     val screenStack = rememberSaveable(
         saver = listSaver(
@@ -53,39 +57,15 @@ fun AppNavigation(
     val currentScreen = screenStack.lastOrNull() ?: Screen.Home
 
     val settingsState by settingsViewModel.uiState.collectAsStateWithLifecycle()
-    val progressSnapshot by settingsViewModel.progressSnapshot.collectAsStateWithLifecycle()
-    val isPipelineActiveByState = remember(
-        progressSnapshot,
-        settingsState.indexingProgress.isIndexing,
-        settingsState.downloadState,
-        settingsState.importState,
-    ) {
-        progressSnapshot != null ||
-            settingsState.indexingProgress.isIndexing ||
-            settingsState.downloadState is DownloadState.Loading ||
-            settingsState.downloadState is DownloadState.Extracting ||
-            settingsState.downloadState is DownloadState.Success ||
-            settingsState.importState is ImportState.Importing ||
-            settingsState.importState is ImportState.Extracting ||
-            settingsState.importState is ImportState.Success
-    }
-    var stickyPipelineActive by rememberSaveable { mutableStateOf(false) }
-    LaunchedEffect(isPipelineActiveByState) {
-        if (isPipelineActiveByState) {
-            stickyPipelineActive = true
-        } else {
-            delay(1500.milliseconds)
-            stickyPipelineActive = false
-        }
-    }
 
     val navState by remember {
         derivedStateOf {
-            val isOperationActive = stickyPipelineActive
+            val isOperationActive = !settingsState.pipelineIdle
             val hasConfirmedNoDictionaries =
                 settingsState.hasCompletedStartupScan && settingsState.dictionaries.isEmpty()
+            val hasSeededNoDictionaries = seedNoDictionaries && !settingsState.hasCompletedStartupScan
             NavigationState(
-                shouldShowSettings = hasConfirmedNoDictionaries || isOperationActive,
+                shouldShowSettings = hasConfirmedNoDictionaries || hasSeededNoDictionaries || isOperationActive,
                 showBackButtonInSettings = settingsState.dictionaries.isNotEmpty() && !isOperationActive,
                 isOperationActive = isOperationActive,
             )
@@ -95,10 +75,16 @@ fun AppNavigation(
     val shouldShowSettings = navState.shouldShowSettings
     val showBackButtonInSettings = navState.showBackButtonInSettings
     val isOperationActive = navState.isOperationActive
-    val isWideScreen = currentWindowAdaptiveInfo()
+    val isWideScreen = currentWindowAdaptiveInfoV2()
         .windowSizeClass
         .isWidthAtLeastBreakpoint(WIDTH_DP_MEDIUM_LOWER_BOUND)
 
+    LaunchedEffect(isWideScreen) {
+        if (isWideScreen) {
+            screenStack.removeAll { it == Screen.Article }
+        }
+    }
+
     BackHandler(enabled = screenStack.size > 1 && !(currentScreen == Screen.Settings && isOperationActive)) {
         if (currentScreen == Screen.Article) {
             if (searchViewModel.navigateBackFromArticle()) {
@@ -119,7 +105,21 @@ fun AppNavigation(
         shouldShowSettings -> Screen.Settings
         else -> currentScreen
     }
-    when (effectiveScreen) {
+    AnimatedContent(
+        targetState = effectiveScreen,
+        transitionSpec = {
+            val forward = initialState.ordinal < targetState.ordinal
+            (
+                fadeIn(tween(180)) +
+                    slideInHorizontally(tween(180)) { if (forward) it / 3 else -it / 3 }
+                ).togetherWith(
+                fadeOut(tween(180)) +
+                    slideOutHorizontally(tween(180)) { if (forward) -it / 3 else it / 3 }
+            )
+        },
+        label = "screenTransition",
+    ) { screen ->
+        when (screen) {
         Screen.Home -> {
             MainRoute(
                 searchViewModel = searchViewModel,
@@ -171,3 +171,4 @@ fun AppNavigation(
         }
         }
     }
+}

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

@@ -1,5 +1,8 @@
 package com.example.research.ui.settings
 
+import androidx.compose.runtime.Immutable
+
+@Immutable
 sealed interface ImportState {
     data object Idle : ImportState
     data class Importing(val progress: Float) : ImportState
@@ -7,3 +10,6 @@ sealed interface ImportState {
     data object Success : ImportState
     data class Error(val message: String) : ImportState
 }
+
+val ImportState.isActive: Boolean
+    get() = this is ImportState.Importing || this is ImportState.Extracting || this is ImportState.Success

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

@@ -3,6 +3,11 @@ package com.example.research.ui.settings
 import android.net.Uri
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.expandVertically
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.shrinkVertically
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
@@ -266,7 +271,11 @@ private fun CollapsibleSettingsSection(
                 testTag = testTag
             )
 
-            if (isExpanded) {
+            AnimatedVisibility(
+                visible = isExpanded,
+                enter = expandVertically() + fadeIn(),
+                exit = shrinkVertically() + fadeOut(),
+            ) {
                 Column(
                     modifier = Modifier
                         .fillMaxWidth()

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

@@ -1,6 +1,7 @@
 package com.example.research.ui.settings
 
 import android.net.Uri
+import androidx.compose.runtime.Immutable
 import com.example.research.core.domain.model.AppTheme
 import com.example.research.core.domain.model.Dictionary
 import com.example.research.core.domain.model.DictionarySource
@@ -8,6 +9,7 @@ import com.example.research.core.domain.model.IndexingProgress
 import com.example.research.DictionaryStatus
 import com.example.research.feature.download.model.DownloadState
 
+@Immutable
 data class SettingsUiState(
     val theme: AppTheme = AppTheme.SYSTEM,
     val language: String = "system",
@@ -21,6 +23,7 @@ data class SettingsUiState(
     val importState: ImportState = ImportState.Idle,
     val dictionarySources: List<DictionarySource> = emptyList(),
     val hasCompletedStartupScan: Boolean = false,
+    val pipelineIdle: Boolean = true,
     val appVersion: String = "1.0",
 )
 

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

@@ -7,17 +7,21 @@ import androidx.lifecycle.viewModelScope
 import com.example.research.DictionaryStatus
 import com.example.research.R
 import com.example.research.common.progress.DictionaryProgressStateHolder
+import com.example.research.common.util.DateUtils
 import com.example.research.core.domain.model.AppTheme
 import com.example.research.core.domain.model.Dictionary
 import com.example.research.core.domain.model.DictionarySource
 import com.example.research.core.domain.model.IndexingProgress
+import com.example.research.core.domain.usecase.DictionarySourceFileMatcher
 import com.example.research.core.domain.usecase.DictionarySourceValidator
 import com.example.research.core.domain.usecase.ManageDictionarySourcesUseCase
 import com.example.research.core.util.OperationResult
 import com.example.research.data.local.preferences.PreferencesManager
+import com.example.research.data.local.preferences.SectionExpansionStates
 import com.example.research.data.repository.LocalDictionaryRepository
 import com.example.research.feature.download.DownloadManager
 import com.example.research.feature.download.model.DownloadState
+import com.example.research.feature.download.model.isActive
 import com.example.research.feature.download.repository.DictionaryRepository
 import com.example.research.feature.import.DictionaryImportManager
 import kotlinx.coroutines.Dispatchers
@@ -30,7 +34,7 @@ import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.receiveAsFlow
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
-import java.io.File
+import java.util.concurrent.ConcurrentHashMap
 
 private data class DictionaryStateInputs(
     val theme: AppTheme,
@@ -59,6 +63,7 @@ class SettingsViewModel(
     private val dictionaryImportManager: DictionaryImportManager,
     progressStateHolder: DictionaryProgressStateHolder,
     appVersion: String,
+    initialSectionExpansion: SectionExpansionStates,
 ) : AndroidViewModel(application) {
 
     private val manageDictionarySourcesUseCase = ManageDictionarySourcesUseCase(
@@ -66,7 +71,14 @@ class SettingsViewModel(
         validator = DictionarySourceValidator(),
     )
 
-    private val _uiState = MutableStateFlow(SettingsUiState(appVersion = appVersion))
+    private val _uiState = MutableStateFlow(
+        SettingsUiState(
+            appVersion = appVersion,
+            isThemeExpanded = initialSectionExpansion.isThemeExpanded,
+            isLanguageExpanded = initialSectionExpansion.isLanguageExpanded,
+            isDictionariesExpanded = initialSectionExpansion.isDictionariesExpanded,
+        )
+    )
     val uiState: StateFlow<SettingsUiState> = _uiState.asStateFlow()
 
     val progressSnapshot = progressStateHolder.progressSnapshot
@@ -79,16 +91,46 @@ class SettingsViewModel(
     private val language = MutableStateFlow("system")
     private val hasCompletedStartupScan = MutableStateFlow(false)
 
-    private val pendingSourceUrls = mutableSetOf<String>()
+    private val pendingSourceUrls = ConcurrentHashMap.newKeySet<String>()
     private var isDownloadInProgress = false
 
     private var cancelRefreshPending = false
+    private var errorStateHandled = false
+    private var statusBeforeDownload: DictionaryStatus = DictionaryStatus.Unknown
 
     init {
         setupStateObservation()
+        observeDictionariesForSeedFlag()
+        persistDictionaryStatus()
         initialize()
     }
 
+    private fun persistDictionaryStatus() {
+        viewModelScope.launch {
+            dictionaryStatus.collect { status ->
+                val persistedName = when (status) {
+                    DictionaryStatus.UpToDate -> "UpToDate"
+                    DictionaryStatus.NeedsUpdate -> "NeedsUpdate"
+                    DictionaryStatus.Empty -> "Empty"
+                    else -> null
+                }
+                if (persistedName != null) {
+                    preferencesManager.saveDictionaryStatus("$persistedName|${DateUtils.getCurrentDateString()}")
+                }
+            }
+        }
+    }
+
+    private fun observeDictionariesForSeedFlag() {
+        viewModelScope.launch {
+            localDictionaryRepository.dictionaries.collect { dictionaries ->
+                if (hasCompletedStartupScan.value) {
+                    preferencesManager.setHadNoDictionaries(dictionaries.isEmpty())
+                }
+            }
+        }
+    }
+
     private fun setupStateObservation() {
         viewModelScope.launch {
             var wasIndexing = false
@@ -137,7 +179,9 @@ class SettingsViewModel(
                 if (wasIndexing && !isIndexing) {
                     if (isDownloadInProgress) {
                         isDownloadInProgress = false
-                        dictionaryStatus.value = DictionaryStatus.UpToDate
+                        dictionaryStatus.value = withContext(Dispatchers.IO) {
+                            evaluateDictionaryStatus()
+                        }
                     }
                 }
                 wasIndexing = isIndexing
@@ -146,31 +190,30 @@ class SettingsViewModel(
                     is DownloadState.Loading, is DownloadState.Extracting -> {
                         isDownloadInProgress = true
                         cancelRefreshPending = false
+                        errorStateHandled = false
                     }
                     is DownloadState.Success -> {
                         pendingSourceUrls.clear()
                     }
                     is DownloadState.Error -> {
                         isDownloadInProgress = false
+                        if (!errorStateHandled) {
+                            errorStateHandled = true
                             dictionaryStatus.value = if (dictionaryState.dictionaries.isEmpty()) {
                                 DictionaryStatus.Empty
-                        } else {
-                            DictionaryStatus.UpToDate
+                            } else when (statusBeforeDownload) {
+                                DictionaryStatus.Unknown, DictionaryStatus.Checking -> DictionaryStatus.UpToDate
+                                else -> statusBeforeDownload
                             }
                             if (pendingSourceUrls.isNotEmpty()) {
-
                                 pendingSourceUrls.forEach { urlTemplate ->
                                     val source = dictionaryState.dictionarySources.find {
                                         it.urlTemplate == urlTemplate
                                     }
                                     if (source != null) {
-                                    val hasDictionary = dictionaryState.dictionaries.any { dict ->
-                                        DictionarySource.matchesDictionaryFile(
-                                            urlTemplate,
-                                            File(dict.path).name
-                                        )
+                                        val hasDictionary = dictionaryState.dictionaries.any { dictionary ->
+                                            DictionarySourceFileMatcher.matches(source, dictionary)
                                         }
-
                                         if (!hasDictionary) {
                                             manageDictionarySourcesUseCase.removeSource(source.id)
                                         }
@@ -179,6 +222,7 @@ class SettingsViewModel(
                                 pendingSourceUrls.clear()
                             }
                         }
+                    }
                     is DownloadState.Cancelled -> {
                         isDownloadInProgress = false
                         cancelRefreshPending = true
@@ -211,6 +255,9 @@ class SettingsViewModel(
                     importState = operationState.importState,
                     dictionaryStatus = operationState.dictionaryStatus,
                     hasCompletedStartupScan = operationState.hasCompletedStartupScan,
+                    pipelineIdle = !isIndexing &&
+                        !operationState.downloadState.isActive &&
+                        !operationState.importState.isActive,
                     isThemeExpanded = operationState.isThemeExpanded,
                     isLanguageExpanded = operationState.isLanguageExpanded,
                     isDictionariesExpanded = operationState.isDictionariesExpanded,
@@ -242,6 +289,9 @@ class SettingsViewModel(
                     android.util.Log.w("SettingsViewModel", "Failed to load language preference: ${e.message}")
                 }
                 hasCompletedStartupScan.value = true
+                preferencesManager.setHadNoDictionaries(
+                    localDictionaryRepository.dictionaries.value.isEmpty()
+                )
             }
         }
     }
@@ -264,18 +314,21 @@ class SettingsViewModel(
     private suspend fun evaluateDictionaryStatus(): DictionaryStatus {
         return try {
             val actualDictionaries = localDictionaryRepository.dictionaries.first()
-            val hasDictionaries = actualDictionaries.isNotEmpty()
-
-            if (!hasDictionaries) {
-                return DictionaryStatus.Empty
-            }
-
             var sources = preferencesManager.dictionarySources.first()
-            if (downloadManager.downloadState.value !is DownloadState.Loading &&
+            if (pendingSourceUrls.isEmpty() &&
+                downloadManager.downloadState.value !is DownloadState.Loading &&
                 downloadManager.downloadState.value !is DownloadState.Extracting
             ) {
-                val installedSources = installedSources(sources, actualDictionaries)
-                val installedSourceIds = installedSources.mapTo(mutableSetOf(), DictionarySource::id)
+                val dictionaryFileNames = localDictionaryRepository.listDictionaryPayloadFileNames(
+                    preferencesManager.dictionaryPath
+                )
+                if (dictionaryFileNames != null) {
+                    val installedSources = DictionarySourceFileMatcher.installedSourcesForFileNames(
+                        sources,
+                        dictionaryFileNames,
+                    )
+                    val installedSourceIds = installedSources
+                        .mapTo(mutableSetOf(), DictionarySource::id)
                     val staleSourceIds = sources
                         .filterNot { it.id in installedSourceIds }
                         .map(DictionarySource::id)
@@ -284,6 +337,12 @@ class SettingsViewModel(
                         sources = installedSources
                     }
                 }
+            }
+
+            if (actualDictionaries.isEmpty()) {
+                return DictionaryStatus.Empty
+            }
+
             val enabledSources = installedEnabledSources(sources, actualDictionaries)
 
             if (enabledSources.isEmpty()) {
@@ -338,21 +397,31 @@ class SettingsViewModel(
 
     private fun deleteDictionary(dictionary: Dictionary) {
         viewModelScope.launch {
-            localDictionaryRepository.deleteDictionary(dictionary)
-
-            manageDictionarySourcesUseCase.removeSourceForDictionary(dictionary)
-
-            val remainingDictionaries = localDictionaryRepository.dictionaries.first()
-
-            if (remainingDictionaries.isEmpty()) {
-                dictionaryStatus.value = DictionaryStatus.Empty
+            when (localDictionaryRepository.deleteDictionary(dictionary)) {
+                is OperationResult.Success -> {
+                    val remainingDictionaryFileNames =
+                        localDictionaryRepository.listDictionaryPayloadFileNames(
+                            preferencesManager.dictionaryPath
+                        )
+                    manageDictionarySourcesUseCase.removeSourceForDictionary(
+                        dictionary = dictionary,
+                        remainingDictionaryFileNames = remainingDictionaryFileNames,
+                    )
+                    dictionaryStatus.value = withContext(Dispatchers.IO) {
+                        evaluateDictionaryStatus()
+                    }
+                }
+                is OperationResult.Error -> {
+                    effectChannel.send(
+                        getApplication<Application>().getString(R.string.error_delete_dictionary)
+                    )
+                }
             }
         }
     }
 
     private fun addDictionarySources(urlTemplates: List<String>) {
         viewModelScope.launch {
-            try {
             val validUrls = mutableListOf<String>()
 
             urlTemplates.forEach { urlTemplate ->
@@ -361,23 +430,30 @@ class SettingsViewModel(
                     return@forEach
                 }
 
+                val normalizedUrl = DictionarySource.normalizeTemplate(trimmed)
+                if (!pendingSourceUrls.add(normalizedUrl)) {
+                    return@forEach
+                }
+
+                try {
                     when (manageDictionarySourcesUseCase.addSource(trimmed)) {
                         is ManageDictionarySourcesUseCase.AddSourceResult.Success -> {
-                            pendingSourceUrls.add(DictionarySource.normalizeTemplate(trimmed))
                             validUrls.add(trimmed)
                         }
                         is ManageDictionarySourcesUseCase.AddSourceResult.ValidationFailed -> {
+                            pendingSourceUrls.remove(normalizedUrl)
                             // Validation failed, skip this source
                         }
                     }
+                } catch (e: Exception) {
+                    pendingSourceUrls.remove(normalizedUrl)
+                    android.util.Log.e("SettingsViewModel", "Error adding dictionary source", e)
+                }
             }
 
             if (validUrls.isNotEmpty()) {
                 startDownloadForSources(validUrls)
             }
-            } catch (e: Exception) {
-                android.util.Log.e("SettingsViewModel", "Error adding dictionary sources", e)
-            }
         }
     }
 
@@ -390,6 +466,7 @@ class SettingsViewModel(
                 return@launch
             }
 
+            statusBeforeDownload = dictionaryStatus.value
             dictionaryStatus.value = DictionaryStatus.Checking
             isDownloadInProgress = true
 
@@ -413,6 +490,7 @@ class SettingsViewModel(
                 return@launch
             }
 
+            statusBeforeDownload = dictionaryStatus.value
             dictionaryStatus.value = DictionaryStatus.Checking
 
             val installedSources = installedEnabledSources(
@@ -448,14 +526,8 @@ class SettingsViewModel(
     private fun installedSources(
         sources: List<DictionarySource>,
         dictionaries: List<Dictionary>
-    ): List<DictionarySource> {
-        val installedFileNames = dictionaries.map { File(it.path).name }
-        return sources.filter { source ->
-            installedFileNames.any { fileName ->
-                DictionarySource.matchesDictionaryFile(source.urlTemplate, fileName)
-            }
-        }
-    }
+    ): List<DictionarySource> =
+        DictionarySourceFileMatcher.installedSources(sources, dictionaries)
 
     private fun cancelDownload() {
         // Cancel the ViewModel-side scan job so no further status recomputes
@@ -501,12 +573,24 @@ class SettingsViewModel(
             is OperationResult.Success -> {
                 val dictionaries = localDictionaryRepository.dictionaries.first()
                 if (dictionaries.isEmpty()) {
-                    dictionaryStatus.value = DictionaryStatus.Empty
+                    dictionaryStatus.value = withContext(Dispatchers.IO) {
+                        evaluateDictionaryStatus()
+                    }
                     isDownloadInProgress = false
-                } else {
-                    if (isDownloadInProgress) {
+                } else if (isDownloadInProgress) {
                     dictionaryStatus.value = DictionaryStatus.UpToDate
                     isDownloadInProgress = false
+                } else {
+                    val savedStatus = preferencesManager.dictionaryStatus()
+                    val savedStatusName = savedStatus?.substringBefore('|')
+                    val savedStatusDate = savedStatus?.substringAfter('|', "")
+                    val restoredStatus = when (savedStatusName) {
+                        "UpToDate" -> DictionaryStatus.UpToDate
+                        "NeedsUpdate" -> DictionaryStatus.NeedsUpdate
+                        else -> null
+                    }
+                    if (restoredStatus != null && savedStatusDate == DateUtils.getCurrentDateString()) {
+                        dictionaryStatus.value = restoredStatus
                     } else {
                         dictionaryStatus.value = DictionaryStatus.Checking
                         val status = withContext(Dispatchers.IO) { evaluateDictionaryStatus() }

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

@@ -28,8 +28,10 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.rememberUpdatedState
 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.clipToBounds
 import androidx.compose.ui.draw.scale
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.graphicsLayer
@@ -81,7 +83,8 @@ fun DictionaryListItem(
     dictionary: Dictionary,
     onToggle: () -> Unit,
     onDelete: () -> Unit,
-    modifier: Modifier = Modifier
+    modifier: Modifier = Modifier,
+    isDeleteBlocked: () -> Boolean = { false }
 ) {
     val haptic = LocalHapticFeedback.current
     val density = LocalDensity.current
@@ -93,7 +96,10 @@ fun DictionaryListItem(
     val offsetAnim = remember { Animatable(0f) }
 
     var rawOffset by remember { mutableFloatStateOf(0f) }
-    val isDeleteRevealed by remember { derivedStateOf { rawOffset <= -swipeThresholdPx } }
+    val isDeleteBlockedCurrent by rememberUpdatedState(isDeleteBlocked)
+    val isDeleteRevealed by remember {
+        derivedStateOf { !isDeleteBlockedCurrent() && rawOffset <= -swipeThresholdPx }
+    }
 
     LaunchedEffect(isDeleteRevealed) {
         if (isDeleteRevealed) {
@@ -101,6 +107,16 @@ fun DictionaryListItem(
         }
     }
 
+    LaunchedEffect(Unit) {
+        snapshotFlow { isDeleteBlockedCurrent() }
+            .collect { blocked ->
+                if (blocked) {
+                    offsetAnim.snapTo(0f)
+                    rawOffset = 0f
+                }
+            }
+    }
+
     val currentOnDelete by rememberUpdatedState(onDelete)
     val currentOnToggle by rememberUpdatedState(onToggle)
 
@@ -121,6 +137,8 @@ fun DictionaryListItem(
     Box(
         modifier = modifier
             .fillMaxWidth()
+            .height(DictionaryItemHeight)
+            .clipToBounds()
             .testTag("dictionary_item")
     ) {
         Row(
@@ -132,12 +150,15 @@ fun DictionaryListItem(
                 .pointerInput(maxSwipePx, swipeThresholdPx) {
                     detectHorizontalDragGestures(
                         onDragStart = {
+                            if (isDeleteBlockedCurrent()) return@detectHorizontalDragGestures
                             haptic.performHapticFeedback(HapticFeedbackType.TextHandleMove)
                         },
                         onDragEnd = {
+                            if (isDeleteBlockedCurrent()) return@detectHorizontalDragGestures
                             val target = if (rawOffset <= -swipeThresholdPx) -maxSwipePx else 0f
                             rawOffset = target
                             scope.launch {
+                                if (isDeleteBlockedCurrent()) return@launch
                                 offsetAnim.animateTo(
                                     target,
                                     animationSpec = spring(stiffness = Spring.StiffnessMedium)
@@ -145,9 +166,11 @@ fun DictionaryListItem(
                             }
                         },
                         onDragCancel = {
+                            if (isDeleteBlockedCurrent()) return@detectHorizontalDragGestures
                             val target = if (rawOffset <= -swipeThresholdPx) -maxSwipePx else 0f
                             rawOffset = target
                             scope.launch {
+                                if (isDeleteBlockedCurrent()) return@launch
                                 offsetAnim.animateTo(
                                     target,
                                     animationSpec = spring(stiffness = Spring.StiffnessMedium)
@@ -155,9 +178,13 @@ fun DictionaryListItem(
                             }
                         },
                         onHorizontalDrag = { _, dragAmount ->
+                            if (isDeleteBlockedCurrent()) return@detectHorizontalDragGestures
                             val newOffset = (rawOffset + dragAmount).coerceIn(-maxSwipePx, 0f)
                             rawOffset = newOffset
-                            scope.launch { offsetAnim.snapTo(newOffset) }
+                            scope.launch {
+                                if (isDeleteBlockedCurrent()) return@launch
+                                offsetAnim.snapTo(newOffset)
+                            }
                         }
                     )
                 },
@@ -222,25 +249,11 @@ fun DictionaryListItem(
             }
 
             if (isDeleteRevealed) {
-                IconButton(
-                    onClick = {
-                        haptic.performHapticFeedback(HapticFeedbackType.TextHandleMove)
-                        currentOnDelete()
-                        scope.launch { offsetAnim.snapTo(0f) }
-                        rawOffset = 0f
-                    },
+                Box(
                     modifier = Modifier
                         .padding(end = ItemHorizontalPadding)
-                        .graphicsLayer { translationX = -offsetAnim.value }
                         .size(IconButtonSize)
-                ) {
-                    Icon(
-                        painter = painterResource(R.drawable.ic_delete),
-                        contentDescription = stringResource(R.string.dictionary_delete),
-                        tint = DeleteIconColor,
-                        modifier = Modifier.size(IconSize)
                 )
-                }
             } else {
                 Switch(
                     checked = dictionary.isActive,
@@ -257,5 +270,29 @@ fun DictionaryListItem(
                 )
             }
         }
+
+        if (isDeleteRevealed) {
+            IconButton(
+                onClick = {
+                    haptic.performHapticFeedback(HapticFeedbackType.TextHandleMove)
+                    currentOnDelete()
+                    scope.launch {
+                        offsetAnim.snapTo(0f)
+                        rawOffset = 0f
+                    }
+                },
+                modifier = Modifier
+                    .align(Alignment.CenterEnd)
+                    .padding(end = ItemHorizontalPadding)
+                    .size(IconButtonSize)
+            ) {
+                Icon(
+                    painter = painterResource(R.drawable.ic_delete),
+                    contentDescription = stringResource(R.string.dictionary_delete),
+                    tint = DeleteIconColor,
+                    modifier = Modifier.size(IconSize)
+                )
+            }
+        }
     }
 }

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

@@ -1,6 +1,9 @@
 package com.example.research.ui.settings.components
 
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.animation.core.tween
 import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
@@ -11,16 +14,21 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.key
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.hapticfeedback.HapticFeedbackType
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalFocusManager
 import androidx.compose.ui.platform.LocalHapticFeedback
 import androidx.compose.ui.res.pluralStringResource
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.invisibleToUser
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.unit.dp
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
@@ -75,6 +83,13 @@ fun DictionaryManagement(
         derivedStateOf { importState is ImportState.Importing || importState is ImportState.Extracting }
     }
     val hasEnabledSources by remember(sources) { derivedStateOf { sources.any { it.isEnabled } } }
+    val isBlockingMutations = isInProgress
+
+    // Invariant: the mutation-block flag is read only at state-read/gesture time (derivedStateOf,
+    // snapshotFlow, pointerInput callbacks), never at row composition time. A composition-time read
+    // (e.g. Modifier.alpha(if (isDeleteBlocked()) ...)) would invalidate every row on each flip.
+    val isMutationsBlockedState = rememberUpdatedState(isBlockingMutations)
+    val isDeleteBlocked = remember { { isMutationsBlockedState.value } }
 
     SectionCard(
         modifier = modifier
@@ -125,13 +140,13 @@ fun DictionaryManagement(
 
                     // Disable accessibility on background content during import to improve performance.
                     // The progress dialog remains accessible for cancellation.
-                    val backgroundModifier = if (isInProgress) {
-                        Modifier.semantics(mergeDescendants = true) { }
+                    val backgroundModifier = if (isBlockingMutations) {
+                        Modifier.semantics { invisibleToUser() }
                     } else {
                         Modifier
                     }
 
-                    if (dictionaries.isEmpty() && !isInProgress) {
+                    if (dictionaries.isEmpty() && !isBlockingMutations) {
                         Column(
                             modifier = backgroundModifier
                                 .fillMaxWidth()
@@ -153,7 +168,7 @@ fun DictionaryManagement(
                             )
                         }
                     } else {
-                        if (dictionaryStatus is DictionaryStatus.NeedsUpdate && !isInProgress && hasEnabledSources) {
+                        if (dictionaryStatus is DictionaryStatus.NeedsUpdate && !isBlockingMutations && hasEnabledSources) {
                             DictionaryUpdateCard(
                                 onStartDownload = onStartDownload,
                                 modifier = backgroundModifier
@@ -166,10 +181,11 @@ fun DictionaryManagement(
                             onDeleteDictionary = onDeleteDictionary,
                             modifier = Modifier
                                 .fillMaxWidth()
-                                .then(backgroundModifier)
+                                .then(backgroundModifier),
+                            isDeleteBlocked = isDeleteBlocked
                         )
 
-                        if (!isInProgress) {
+                        if (!isBlockingMutations) {
                             DictionaryActionButtons(
                                 onAddSource = {
                                     haptic.performHapticFeedback(HapticFeedbackType.TextHandleMove)
@@ -246,18 +262,38 @@ private fun DictionaryListSection(
     dictionaries: List<Dictionary>,
     onToggleDictionary: (String) -> Unit,
     onDeleteDictionary: (Dictionary) -> Unit,
-    modifier: Modifier = Modifier
+    modifier: Modifier = Modifier,
+    isDeleteBlocked: () -> Boolean = { false }
 ) {
+    var appearedPaths by remember { mutableStateOf(emptySet<String>()) }
+    LaunchedEffect(dictionaries) {
+        val visiblePaths = dictionaries.mapTo(mutableSetOf(), Dictionary::path)
+        appearedPaths = appearedPaths intersect visiblePaths
+    }
     Column(
         modifier = modifier,
         verticalArrangement = Arrangement.spacedBy(4.dp)
     ) {
         dictionaries.forEach { dictionary ->
+            key(dictionary.path) {
+                val hasAppeared = dictionary.path in appearedPaths
+                val rowAlpha by animateFloatAsState(
+                    targetValue = if (hasAppeared) 1f else 0f,
+                    animationSpec = tween(150),
+                    label = "dictionaryRowAppear",
+                )
+                LaunchedEffect(dictionary.path) {
+                    appearedPaths = appearedPaths + dictionary.path
+                }
+                Box(modifier = Modifier.alpha(rowAlpha)) {
                     DictionaryListItem(
                         dictionary = dictionary,
                         onToggle = { onToggleDictionary(dictionary.path) },
-                onDelete = { onDeleteDictionary(dictionary) }
+                        onDelete = { onDeleteDictionary(dictionary) },
+                        isDeleteBlocked = isDeleteBlocked
                     )
                 }
             }
         }
+    }
+}

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

@@ -1,8 +1,8 @@
 package com.example.research.ui.settings.components
 
 import androidx.compose.animation.AnimatedVisibility
-import androidx.compose.animation.core.FastOutSlowInEasing
-import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.animation.core.Animatable
+import androidx.compose.animation.core.LinearEasing
 import androidx.compose.animation.core.tween
 import androidx.compose.animation.expandVertically
 import androidx.compose.animation.fadeIn
@@ -19,6 +19,10 @@ import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import com.example.research.R
 
+private const val MILLIS_PER_PROGRESS_UNIT = 10_000
+private const val MIN_PROGRESS_MOTION_MS = 50
+private const val MAX_PROGRESS_MOTION_MS = 650
+
 @Composable
 fun DictionaryProgressSection(
     visible: Boolean,
@@ -41,6 +45,11 @@ fun DictionaryProgressSection(
         var displayedPercent by remember { mutableIntStateOf(percent) }
         var displayedTestTag by remember { mutableStateOf(testTag) }
 
+        LaunchedEffect(visible) {
+            if (visible) {
+                monotonicTargetProgress = targetProgress
+            }
+        }
         LaunchedEffect(visible, targetProgress) {
             if (visible) {
                 monotonicTargetProgress = maxOf(monotonicTargetProgress, targetProgress)
@@ -53,11 +62,21 @@ fun DictionaryProgressSection(
                 displayedTestTag = testTag
             }
         }
-        val animatedProgress by animateFloatAsState(
+        val animatedState = remember { Animatable(0f) }
+        LaunchedEffect(monotonicTargetProgress) {
+            val delta = monotonicTargetProgress - animatedState.value
+            if (delta > 0f) {
+                animatedState.animateTo(
                     targetValue = monotonicTargetProgress,
-            animationSpec = tween(durationMillis = 650, easing = FastOutSlowInEasing),
-            label = "dictionary-progress"
+                    animationSpec = tween(
+                        durationMillis = (delta * MILLIS_PER_PROGRESS_UNIT).toInt()
+                            .coerceIn(MIN_PROGRESS_MOTION_MS, MAX_PROGRESS_MOTION_MS),
+                        easing = LinearEasing,
+                    ),
                 )
+            }
+        }
+        val animatedProgress = animatedState.value
 
         Column(modifier = Modifier.testTag(displayedTestTag)) {
             Row(

app/src/main/java/com/example/research/ui/theme/Spacing.kt

@@ -9,4 +9,6 @@ object Spacing {
     val iconStart = 32.dp
     val searchTextStart = 68.dp
     val listItemVertical = 8.dp
+
+    val contentStart = 32.dp
 }

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

@@ -7,13 +7,12 @@
     <string name="button_cancel_download">Отмена</string>
     <string name="action_ok">ОК</string>
     <string name="download_error">Ошибка загрузки словарей</string>
+    <string name="download_network_failed">Нет связи с сервером словарей. Проверьте сеть и попробуйте снова</string>
     <string name="language">Язык</string>
     <string name="language_english">Английский</string>
     <string name="language_russian">Русский</string>
     <string name="language_system">Системный</string>
-    <string name="indexing_label">Индексация словарей</string>
     <string name="clear_search">Очистить поиск</string>
-    <string name="article_no_selected">Статья не выбрана</string>
     <string name="article_return_to_search">Вернуться к поиску</string>
     <string name="error_checking_dictionaries">Не удалось проверить статус словарей</string>
     <string name="error_loading_article">Ошибка загрузки: %1$s</string>
@@ -67,8 +66,9 @@
     <string name="dictionary_management_title">Словари</string>
     <string name="import_dictionary_button">Выбрать файлы</string>
     <string name="import_error">Не удалось импортировать словарь: %1$s</string>
-    <string name="import_file_exists">Файл уже существует: %1$s</string>
+    <string name="import_file_exists">Словарь уже добавлен: %1$s</string>
     <string name="import_invalid_file_name">Недопустимое имя файла: %1$s</string>
+    <string name="import_nothing_imported">В выбранном нет поддерживаемых файлов словарей</string>
     <string name="dictionary_source_url_hint">URL</string>
     <string name="dictionary_source_add_button">Добавить источник</string>
     <string name="dictionary_source_duplicate">Этот URL уже существует</string>
@@ -95,6 +95,7 @@
     </plurals>
     <string name="dictionary_not_indexed">• Не индексирован</string>
     <string name="dictionary_delete">Удалить словарь</string>
+    <string name="error_delete_dictionary">Не удалось удалить словарь</string>
     <string name="dictionaries_tap_to_update">Нажмите для обновления</string>
     <string name="notification_import_title">Импорт словарей</string>
     <string name="notification_import_success_title">Импорт завершён</string>

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

@@ -7,13 +7,12 @@
     <string name="button_cancel_download">Cancel</string>
     <string name="action_ok">OK</string>
     <string name="download_error">Dictionary download failed</string>
+    <string name="download_network_failed">No connection to the dictionary server. Check your network and try again</string>
     <string name="language">Language</string>
     <string name="language_english">English</string>
     <string name="language_russian">Russian</string>
     <string name="language_system">System</string>
-    <string name="indexing_label">Indexing dictionaries</string>
     <string name="clear_search">Clear search</string>
-    <string name="article_no_selected">No article selected</string>
     <string name="article_return_to_search">Return to search</string>
     <string name="error_checking_dictionaries">Failed to check dictionary status</string>
     <string name="error_loading_article">Loading error: %1$s</string>
@@ -65,8 +64,9 @@
     <string name="dictionary_management_title">Dictionaries</string>
     <string name="import_dictionary_button">Select files</string>
     <string name="import_error">Failed to import dictionary: %1$s</string>
-    <string name="import_file_exists">File already exists: %1$s</string>
+    <string name="import_file_exists">Dictionary already added: %1$s</string>
     <string name="import_invalid_file_name">Invalid file name: %1$s</string>
+    <string name="import_nothing_imported">No supported dictionary files were found in the selection</string>
     <string name="dictionary_source_url_hint">URL</string>
     <string name="dictionary_source_add_button">Add source</string>
     <string name="dictionary_source_duplicate">This URL already exists</string>
@@ -91,6 +91,7 @@
     </plurals>
     <string name="dictionary_not_indexed">• Not indexed</string>
     <string name="dictionary_delete">Delete dictionary</string>
+    <string name="error_delete_dictionary">Failed to delete dictionary</string>
     <string name="dictionaries_tap_to_update">Tap to update all dictionaries</string>
     <string name="notification_import_title">Importing dictionaries</string>
     <string name="notification_import_success_title">Import completed</string>

app/src/release/keepRules/strip-logs.keep

@@ -0,0 +1,9 @@
+# Strip android.util.Log warnings/errors from release builds.
+# Debug builds keep full logging for diagnostics.
+-assumenosideeffects class android.util.Log {
+    public static int w(java.lang.String, java.lang.String);
+    public static int w(java.lang.String, java.lang.String, java.lang.Throwable);
+    public static int w(java.lang.String, java.lang.Throwable);
+    public static int e(java.lang.String, java.lang.String);
+    public static int e(java.lang.String, java.lang.String, java.lang.Throwable);
+}

fastlane/metadata/android/en-US/changelogs/6.txt

@@ -0,0 +1,2 @@
+- Dictionaries can no longer be deleted while an update is running, which used to lose their update source
+- Fixed the dictionary icon sliding outside the row while swiping to delete

fastlane/metadata/android/en-US/changelogs/7.txt

@@ -0,0 +1 @@
+- Fixed matching source URLs to installed dictionary files, so deleted dictionaries can be downloaded again from the same URL

fastlane/metadata/android/en-US/changelogs/8.txt

@@ -0,0 +1,3 @@
+- The dictionary update card now returns after a failed download
+- Fixed headwords and articles with escaped characters being displayed incorrectly
+- Fixed slow rendering of articles containing many bracket characters

fastlane/metadata/android/en-US/changelogs/9.txt

@@ -0,0 +1,7 @@
+- The app starts faster
+- Smooth screen transition animations
+- Dictionary downloads retry automatically when the network switches
+- Download progress notifications are more reliable
+- Search results clear instantly when the query is erased
+- Leftover files from cancelled downloads are now removed automatically
+- Updated build tooling and documentation

fastlane/metadata/android/en-US/full_description.txt

@@ -9,6 +9,6 @@ Features:
 - Automatic indexing with binary index files for instant search
 - Multi-charset support — UTF-8, UTF-16 LE/BE auto-detection
 - Adaptive three-pane layout for tablets and large screens
-- Light, dark, and system-follow themes
+- Material 3 UI with dynamic color, plus light, dark, and system-follow themes
 - English and Russian localization
 - No tracking, no ads, fully open source

fastlane/metadata/android/ru-RU/changelogs/6.txt

@@ -0,0 +1,2 @@
+- Словари больше нельзя удалить во время обновления — раньше при этом терялся источник обновления
+- Исправлен выход иконки словаря за границы строки при свайпе

fastlane/metadata/android/ru-RU/changelogs/7.txt

@@ -0,0 +1 @@
+- Исправлено сопоставление URL-источников с установленными файлами — удалённый словарь теперь можно повторно скачать по тому же URL

fastlane/metadata/android/ru-RU/changelogs/8.txt

@@ -0,0 +1,3 @@
+- Карточка обновления словарей теперь появляется снова после неудачной загрузки
+- Исправлено отображение заголовков и статей с экранированными символами
+- Исправлено медленное отображение статей с большим количеством скобок

fastlane/metadata/android/ru-RU/changelogs/9.txt

@@ -0,0 +1,7 @@
+- Приложение запускается быстрее
+- Плавные анимации переходов между экранами
+- Загрузка словарей автоматически повторяется при переключении сети
+- Уведомления о прогрессе загрузки стали надёжнее
+- Результаты поиска очищаются мгновенно при стирании запроса
+- Остаточные файлы после отменённых загрузок удаляются автоматически
+- Обновлены тулинг сборки и документация

fastlane/metadata/android/ru-RU/full_description.txt

@@ -9,6 +9,6 @@ ReSearch — быстрое приложение для чтения слова
 - Автоматическая индексация с бинарными индексными файлами для мгновенного поиска
 - Поддержка нескольких кодировок — автоопределение UTF-8, UTF-16 LE/BE
 - Адаптивный трёхпанельный интерфейс для планшетов и больших экранов
-- Светлая, тёмная и системная темы
+- Material 3 с динамическими цветами, светлая, тёмная и системная темы
 - Локализация на английский и русский языки
 - Без трекеров, без рекламы, полностью открытый исходный код

gradle/libs.versions.toml

@@ -1,15 +1,15 @@
 [versions]
-aboutlibraries = "15.0.4"
+aboutlibraries = "15.2.0"
 activity_compose = "1.13.0"
 agp = "9.3.1"
-compose_bom = "2026.06.01"
+compose_bom = "2026.09.00"
 core = "1.19.0"
 datastore_preferences = "1.2.1"
 documentfile = "1.1.0"
 kotlin = "2.4.10"
 lifecycle_runtime_ktx = "2.11.0"
-okhttp = "5.4.0"
-paging = "3.5.0"
+okhttp = "5.5.0"
+paging = "3.5.1"
 profileinstaller = "1.4.1"
 kotlinx_coroutines = "1.11.0"
 kotlinx_serialization = "1.11.0"