refactor(prefs): create the settings store through DataStore.Builder

The store is now built through DataStore.Builder instead of the
preferencesDataStore delegate.

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

@@ -1,11 +1,10 @@
 <h1 align="center">ReSearch</h1>
 
-<h4 align="center">A fast Android dictionary reader for DSL-format dictionaries.</h4>
+<h4 align="center">An Android dictionary reader for DSL-format dictionaries.</h4>
 
 <p align="center">
   <a href="#screenshots">Screenshots</a> &bull;
   <a href="#features">Features</a> &bull;
-  <a href="#architecture">Architecture</a> &bull;
   <a href="#dictionary-pipeline">Pipeline</a> &bull;
   <a href="#build">Build</a>
 </p>
@@ -16,38 +15,30 @@ The app stores dictionaries as DictZip files and builds compact binary indexes f
 
 ## Screenshots
 
-[<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/1.png" width="160" alt="ReSearch search screen">](fastlane/metadata/android/en-US/images/phoneScreenshots/1.png)
-[<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/2.png" width="160" alt="ReSearch article screen">](fastlane/metadata/android/en-US/images/phoneScreenshots/2.png)
+[<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/1.png" width="160" alt="ReSearch search results screen">](fastlane/metadata/android/en-US/images/phoneScreenshots/1.png)
+[<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/2.png" width="160" alt="ReSearch search history sheet">](fastlane/metadata/android/en-US/images/phoneScreenshots/2.png)
+[<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/3.png" width="160" alt="ReSearch settings screen">](fastlane/metadata/android/en-US/images/phoneScreenshots/3.png)
 
 ## Features
 
 - Fast headword search across multiple DSL dictionaries.
+- Search history in a bottom sheet: recent queries with per-entry removal and clear-all.
+- Look up selected text from other apps via the selection menu.
 - Import local `.dsl`, `.dsl.gz`, and `.dsl.dz` dictionary files.
-- Download dictionaries from configured URLs.
+- Download dictionaries from configured URLs, with an optional `{DATE}` placeholder for dated releases.
+- Multiple dictionary source URLs can be added in one list.
 - Automatic extraction, DictZip compression, and indexing.
+- Faithful article rendering with DSL indentation, margins, and named colors.
 - Offline search after dictionaries are indexed.
 - 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.
+- Background processing with progress shown in Settings and notifications; downloads are cancelled with a button on the progress notification.
+- Dictionary management with enable, disable, and update actions; deleting a dictionary is done with a swipe.
+- Search bar placement at the top or bottom of the screen.
+- Adaptive two-pane layout for tablets and large screens.
 - Material 3 interface with dynamic color, light, dark, and system themes.
 - English and Russian localization.
 - About screen with open source license information.
 
-## Architecture
-
-ReSearch is an Android app written in Kotlin and Jetpack Compose.
-
-```text
-com.example.research/
-├── common/   # shared progress, UI, file, archive, notification utilities
-├── core/     # domain models, source validation, operation results
-├── data/     # DictZip, DSL parsing, indexing, paging, repositories
-├── feature/  # search, dictionary download, local import workflows
-└── ui/       # Compose screens, article view, settings, navigation
-```
-
-State is exposed through Kotlin Flow and collected by Compose screens. Long-running work uses coroutines and foreground services where Android requires visible progress.
-
 ## Dictionary Pipeline
 
 ReSearch supports both downloaded and locally imported dictionaries.
@@ -94,16 +85,16 @@ The main search screen remains usable as long as at least one indexed dictionary
 
 ## Tech Stack
 
-- Kotlin 2.4.10
-- Jetpack Compose (BOM 2026.08.00)
-- Material 3
+- Kotlin 2.4.21
+- Jetpack Compose (BOM 2026.09.00)
+- Material 3 1.5.0-beta01
 - Coroutines and Flow 1.11.0
-- DataStore Preferences 1.2.1
-- Paging 3.5.1
-- OkHttp 5.4.0
-- kotlinx.serialization 1.11.0
-- AboutLibraries 15.0.4 metadata generation
-- Android Gradle Plugin 9.3.1
+- DataStore Preferences 1.3.0
+- Paging 3.5.3
+- OkHttp 5.5.0
+- kotlinx.serialization 1.12.0
+- AboutLibraries 15.3.0 metadata generation
+- Android Gradle Plugin 9.4.1
 
 ## Build
 
@@ -111,8 +102,8 @@ The main search screen remains usable as long as at least one indexed dictionary
 ./gradlew :app:assembleRelease
 ```
 
-The release APK targets `arm64-v8a`. English and Russian resources are packaged together.
+The release APK targets `arm64-v8a`.
 
 ## 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 = 8
-        versionName = "1.5.0"
+        versionCode = 12
+        versionName = "1.8.0"
 
         vectorDrawables {
             useSupportLibrary = true
@@ -164,26 +164,17 @@ dependencies {
     implementation(libs.androidx.lifecycle.runtime.compose)
     implementation(libs.androidx.activity.compose)
     implementation(libs.androidx.documentfile)
-
     val composeBom = platform(libs.androidx.compose.bom)
     implementation(composeBom)
     implementation(libs.bundles.compose)
     implementation(libs.androidx.compose.material3.adaptive.layout)
     debugImplementation(libs.androidx.compose.runtime.tracing)
-
-
     implementation(libs.androidx.paging.runtime)
     implementation(libs.androidx.paging.compose)
     implementation(libs.androidx.profileinstaller)
-
     debugImplementation(libs.androidx.compose.ui.tooling)
-
     implementation(libs.androidx.datastore.preferences)
-
     implementation(libs.okhttp)
-
-    // Coroutines with Android-optimized dispatchers
     implementation(libs.kotlinx.coroutines.android)
-
     implementation(libs.kotlinx.serialization.json)
 }

app/src/debug/java/com/example/research/core/performance/ReSearchTrace.kt

@@ -13,9 +13,6 @@ object ReSearchTrace {
     const val DICTIONARY_EXTRACT = "ReSearch/Dictionary/Extract"
     const val DICTIONARY_INDEX = "ReSearch/Dictionary/Index"
     const val DICTIONARY_IMPORT = "ReSearch/Dictionary/Import"
-    const val FLOW_UPDATE_CARD_APPEAR = "ReSearch/Flow/UpdateCardAppear"
-    const val FLOW_UPDATING = "ReSearch/Flow/Updating"
-    const val FLOW_PROGRESS_DISAPPEAR = "ReSearch/Flow/ProgressDisappear"
 
     private val nextCookie = AtomicInteger()
 

app/src/main/baseline-prof.txt

@@ -1,54 +1,48 @@
-# Seeded from the measured ReSearch startup, search, scrolling, and article-opening hot paths.
-# Keep this profile checked in: release builders, including F-Droid, only compile it.
-# Updated 2026-06-25: Added optimized cache paths from performance optimization stages 1-4
+HSPLcom/example/research/ReSearchApplication**->**(**)**
+HSPLcom/example/research/MainActivity**->**(**)**
+HSPLcom/example/research/InitialLaunch**->**(**)**
+HSPLcom/example/research/DictionaryStatus**->**(**)**
+HSPLcom/example/research/core/**->**(**)**
+HSPLcom/example/research/common/ui/**->**(**)**
+HSPLcom/example/research/ui/theme/**->**(**)**
+HSPLcom/example/research/ui/navigation/**->**(**)**
+HSPLcom/example/research/data/local/preferences/**->**(**)**
+HSPLcom/example/research/data/parser/ResourceManager**->**(**)**
+HSPLcom/example/research/common/util/FileStorageManager**->**(**)**
+HSPLcom/example/research/common/util/DateUtils**->**(**)**
 
-HSPLcom/example/research/ReSearchApplication;->**(**)**
-HSPLcom/example/research/MainActivity;->**(**)**
-
-HSPLcom/example/research/common/ui/AppLocaleProviderKt**->**(**)**
-HSPLcom/example/research/common/ui/theme/ThemeKt**->**(**)**
-HSPLcom/example/research/ui/navigation/AppNavigationKt**->**(**)**
-
-HSPLcom/example/research/ui/main/MainScreenKt**->**(**)**
-HSPLcom/example/research/ui/main/AdaptiveMainScreenKt**->**(**)**
-HSPLcom/example/research/ui/main/components/MainTopBarKt**->**(**)**
-HSPLcom/example/research/ui/main/components/SearchResultsListKt**->**(**)**
-
-HSPLcom/example/research/feature/search/SearchViewModel**->**(**)**
-HSPLcom/example/research/data/paging/IndexEntryPagingSource**->**(**)**
+HSPLcom/example/research/ui/main/**->**(**)**
+HSPLandroidx/paging/**->**(**)**
+HSPLcom/example/research/feature/search/**->**(**)**
+HSPLcom/example/research/data/paging/**->**(**)**
 HSPLcom/example/research/data/parser/IndexSearcher**->**(**)**
-HSPLcom/example/research/data/parser/SearchRankingKt**->**(**)**
+HSPLcom/example/research/data/parser/FileSource**->**(**)**
+HSPLcom/example/research/data/parser/ResultsLruCache**->**(**)**
+HSPLcom/example/research/data/parser/MetadataLruCache**->**(**)**
+HSPLcom/example/research/data/parser/SearchRanking**->**(**)**
+HSPLcom/example/research/data/parser/SortKey**->**(**)**
 
-HSPLcom/example/research/data/repository/LocalDictionaryRepository**->**(**)**
-HSPLcom/example/research/data/repository/KotlinDictionaryEngine**->**(**)**
+HSPLcom/example/research/data/repository/**->**(**)**
+HSPLcom/example/research/data/dictzip/DictZipInputStream**->**(**)**
+HSPLcom/example/research/data/dictzip/DictZipRandomAccessFile**->**(**)**
+HSPLcom/example/research/data/dictzip/DictZipHeader**->**(**)**
 HSPLcom/example/research/data/parser/DslArticleReader**->**(**)**
-HSPLcom/example/research/ui/article/DslAnnotatedParser**->**(**)**
-HSPLcom/example/research/ui/article/ArticleScreenKt**->**(**)**
+HSPLcom/example/research/data/parser/LruCharsetCache**->**(**)**
+HSPLcom/example/research/ui/article/**->**(**)**
 
-# Hot paths for optimized article rendering (Stage 1)
-HSPLcom/example/research/ui/article/ArticleLinkText**->**(**)**
-HSPLcom/example/research/ui/article/ArticleState**->**(**)**
+HSPLcom/example/research/data/parser/Dsl**->**(**)**
+HSPLcom/example/research/data/parser/LineKind**->**(**)**
+HSPLcom/example/research/data/parser/ByteTrackingLineReader**->**(**)**
+HSPLcom/example/research/data/parser/Utf8Writer**->**(**)**
+
+HSPLcom/example/research/ui/settings/**->**(**)**
+HSPLcom/example/research/common/progress/**->**(**)**
+HSPLcom/example/research/feature/download/**->**(**)**
 
-# About screen (bonus optimization)
 HSPLcom/example/research/ui/about/AboutScreenKt**->**(**)**
 
-# Updated 2026-07-11: cover the settings/dictionary flow and the Compose framework.
-
-# Settings + dictionary management flow
-HSPLcom/example/research/ui/settings/**->**(**)**
-Lcom/example/research/ui/settings/**
-HSPLcom/example/research/common/ui/components/**->**(**)**
-Lcom/example/research/common/ui/components/**
-HSPLcom/example/research/common/progress/**->**(**)**
-Lcom/example/research/common/progress/**
-HSPLcom/example/research/feature/download/**->**(**)**
-Lcom/example/research/feature/download/**
-
-# Pre-verify the app classes already covered by method rules above
 Lcom/example/research/**
 
-# Compose framework: the alpha AARs ship near-empty baseline profiles, so first
-# compositions run interpreted without these rules.
 HSPLandroidx/compose/runtime/**->**(**)**
 Landroidx/compose/runtime/**
 HSPLandroidx/compose/ui/**->**(**)**
@@ -61,12 +55,10 @@ HSPLandroidx/compose/animation/**->**(**)**
 Landroidx/compose/animation/**
 HSPLandroidx/compose/material/**->**(**)**
 Landroidx/compose/material/**
-
-# Support libraries on the same cold path
 HSPLandroidx/lifecycle/**->**(**)**
 Landroidx/lifecycle/**
 HSPLandroidx/activity/compose/**->**(**)**
 Landroidx/activity/compose/**
 HSPLkotlinx/coroutines/**->**(**)**
 Lkotlinx/coroutines/**
-
+Landroidx/paging/**

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

@@ -7,7 +7,7 @@ sealed interface DictionaryStatus {
     data object Unknown : DictionaryStatus
     data object Checking : DictionaryStatus
     data object UpToDate : DictionaryStatus
-    data object NeedsUpdate : DictionaryStatus
+    data class NeedsUpdate(val sourceIds: Set<String>) : DictionaryStatus
     data object Empty : DictionaryStatus
     data class Error(val message: String) : DictionaryStatus
 }

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

@@ -26,12 +26,12 @@ 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.core.domain.model.SearchBarPosition
+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
 import com.example.research.ui.settings.SettingsViewModel
-import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.runBlocking
 
 class MainActivity : ComponentActivity() {
     companion object {
@@ -46,7 +46,7 @@ class MainActivity : ComponentActivity() {
         val app = application as ReSearchApplication
         viewModelFactory {
             initializer {
-                SearchViewModel(application, app.localDictionaryRepository, createSavedStateHandle())
+                SearchViewModel(application, app.localDictionaryRepository, app.preferencesManager, createSavedStateHandle())
             }
         }
     }
@@ -69,6 +69,8 @@ class MainActivity : ComponentActivity() {
                     app.dictionaryImportManager,
                     app.dictionaryProgressStateHolder,
                     versionName,
+                    app.initialLaunch.value?.sectionExpansion ?: SectionExpansionStates(),
+                    app.initialLaunch.value?.searchBarPosition ?: SearchBarPosition.TOP,
                 )
             }
         }
@@ -79,17 +81,16 @@ class MainActivity : ComponentActivity() {
         super.onCreate(savedInstanceState)
         requestNotificationPermissionIfNeeded()
 
-        // Load theme and language synchronously before setContent to prevent flashing
         val app = application as ReSearchApplication
-        val initialTheme = loadInitialTheme(app)
-        val initialLanguage = loadInitialLanguage(app)
-
         handleIntent(intent)
         setContent {
+            val initialLaunch by app.initialLaunch.collectAsStateWithLifecycle()
+            val launch = initialLaunch ?: return@setContent
+
             val settingsState by settingsViewModel.uiState.collectAsStateWithLifecycle()
             // Use loaded values initially, then switch to state values when ready
-            val theme = settingsState.theme.takeIf { it != AppTheme.SYSTEM } ?: initialTheme
-            val language = settingsState.language.takeIf { it != "system" } ?: initialLanguage
+            val theme = settingsState.theme.takeIf { it != AppTheme.SYSTEM } ?: launch.theme
+            val language = settingsState.language.takeIf { it != "system" } ?: launch.language
             val darkTheme = when (theme) {
                 AppTheme.LIGHT -> false
                 AppTheme.DARK -> true
@@ -104,7 +105,8 @@ class MainActivity : ComponentActivity() {
                         ) {
                             AppNavigation(
                                 searchViewModel = searchViewModel,
-                                settingsViewModel = settingsViewModel
+                                settingsViewModel = settingsViewModel,
+                                seedNoDictionaries = launch.seedNoDictionaries
                             )
                         }
                     }
@@ -127,44 +129,6 @@ class MainActivity : ComponentActivity() {
         }
     }
 
-    /**
-     * Load initial theme synchronously from DataStore to prevent theme flashing.
-     * This is called before setContent to ensure the correct theme is applied immediately.
-     * Uses runBlocking to synchronously read from DataStore.
-     */
-    private fun loadInitialTheme(app: ReSearchApplication): AppTheme {
-        return try {
-            runBlocking {
-                val themeString = app.preferencesManager.themeMode.first()
-                try {
-                    AppTheme.valueOf(themeString)
-                } catch (_: Exception) {
-                    android.util.Log.w("MainActivity", "Invalid theme value: $themeString, using SYSTEM")
-                    AppTheme.SYSTEM
-                }
-            }
-        } catch (e: Exception) {
-            android.util.Log.e("MainActivity", "Failed to load theme preference: ${e.message}")
-            AppTheme.SYSTEM
-        }
-    }
-
-    /**
-     * Load initial language synchronously from DataStore to prevent language flashing.
-     * This is called before setContent to ensure the correct language is applied immediately.
-     * Uses runBlocking to synchronously read from DataStore.
-     */
-    private fun loadInitialLanguage(app: ReSearchApplication): String {
-        return try {
-            runBlocking {
-                app.preferencesManager.language.first()
-            }
-        } catch (e: Exception) {
-            android.util.Log.e("MainActivity", "Failed to load language preference: ${e.message}")
-            "system"
-        }
-    }
-
     override fun onNewIntent(intent: Intent) {
         super.onNewIntent(intent)
         handleIntent(intent)
@@ -180,7 +144,7 @@ class MainActivity : ComponentActivity() {
             val text = intent.getCharSequenceExtra(Intent.EXTRA_PROCESS_TEXT)
                 ?: intent.getCharSequenceExtra(Intent.EXTRA_PROCESS_TEXT_READONLY)
             text?.toString()?.let {
-                searchViewModel.onAction(SearchAction.HandleExternalSearch(it))
+                searchViewModel.onAction(SearchAction.QueryChanged(it))
             }
         }
     }

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

@@ -3,7 +3,10 @@ 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.core.domain.model.AppTheme
+import com.example.research.core.domain.model.SearchBarPosition
 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.repository.DictionaryRepository
@@ -12,10 +15,26 @@ import com.example.research.feature.import.DictionaryImportManager
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import okhttp3.OkHttpClient
 import okhttp3.Protocol
 
+/**
+ * Values a cold start needs before the first composed frame: the initial
+ * theme, locale, empty-library navigation seed, and settings expansion state.
+ */
+data class InitialLaunch(
+    val theme: AppTheme,
+    val language: String,
+    val searchBarPosition: SearchBarPosition,
+    val seedNoDictionaries: Boolean,
+    val sectionExpansion: SectionExpansionStates,
+)
+
 class ReSearchApplication : Application() {
 
     lateinit var preferencesManager: PreferencesManager
@@ -37,17 +56,28 @@ 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)
 
+    private val _initialLaunch = MutableStateFlow<InitialLaunch?>(null)
+    val initialLaunch: StateFlow<InitialLaunch?> = _initialLaunch.asStateFlow()
+
     override fun onCreate() {
         super.onCreate()
 
-        NotificationHelper(this).cancelNotification()
+        val notificationHelper = NotificationHelper(this)
+        notificationHelper.cancelProgressNotification()
 
         preferencesManager = PreferencesManager(this)
         applicationScope.launch(Dispatchers.IO) {
             preferencesManager.sanitizeDictionarySources()
         }
+        applicationScope.launch(Dispatchers.IO) {
+            _initialLaunch.value = loadInitialLaunch()
+        }
         localDictionaryRepository = LocalDictionaryRepository(this, preferencesManager = preferencesManager)
 
         okHttpClient = OkHttpClient.Builder()
@@ -80,6 +110,54 @@ 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
+    }
+
+    private suspend fun loadInitialLaunch(): InitialLaunch {
+        return InitialLaunch(
+            theme = runCatching { AppTheme.valueOf(preferencesManager.themeMode.first()) }
+                .getOrDefault(AppTheme.SYSTEM),
+            language = runCatching { preferencesManager.language.first() }.getOrDefault("system"),
+            searchBarPosition = runCatching { preferencesManager.searchBarPosition.first() }
+                .getOrDefault(SearchBarPosition.TOP),
+            seedNoDictionaries = runCatching { preferencesManager.hadNoDictionaries.first() }
+                .getOrDefault(true),
+            sectionExpansion = runCatching { preferencesManager.sectionExpansionStates() }
+                .getOrDefault(SectionExpansionStates()),
+        )
     }
 
     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 (_: 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/DictionaryProgressModel.kt

@@ -21,14 +21,16 @@ object DictionaryProgressModel {
         val progress: Float,
         val percent: Int,
         @param:StringRes val titleRes: Int,
+        val indeterminate: Boolean = false,
     ) {
         override fun equals(other: Any?): Boolean {
             if (this === other) return true
             if (other !is Snapshot) return false
-            return percent == other.percent && titleRes == other.titleRes
+            return percent == other.percent && titleRes == other.titleRes &&
+                indeterminate == other.indeterminate
         }
         override fun hashCode(): Int {
-            return 31 * percent + titleRes
+            return 31 * (31 * percent + titleRes) + indeterminate.hashCode()
         }
     }
     fun computeProgressSnapshot(
@@ -92,6 +94,7 @@ object DictionaryProgressModel {
             progress = p,
             percent = pct,
             titleRes = R.string.notification_download_title,
+            indeterminate = dl <= 0f,
         )
     }
 
@@ -109,7 +112,7 @@ object DictionaryProgressModel {
         return Snapshot(
             progress = p,
             percent = (p * 100f).toInt().coerceIn(0, 100),
-            titleRes = R.string.notification_indexing_title,
+            titleRes = R.string.notification_preparing_indexing_title,
         )
     }
 
@@ -120,7 +123,7 @@ object DictionaryProgressModel {
         } else {
             DOWNLOAD_WEIGHT + EXTRACT_WEIGHT + idx * INDEX_WEIGHT
         }
-        val pct = (p * 100f).toInt().coerceIn(0, 100)
+        val pct = (p * 100f).toInt().coerceIn(0, 99)
 
         return Snapshot(
             progress = p,

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

@@ -0,0 +1,107 @@
+package com.example.research.common.progress
+
+import android.os.SystemClock
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.launch
+import kotlin.time.Duration.Companion.milliseconds
+
+class DictionaryProgressPresenter(
+    private val scope: CoroutineScope,
+    private val progressSnapshot: StateFlow<DictionaryProgressModel.Snapshot?>,
+    private val notifications: NotificationPort,
+    private val mainDispatcher: CoroutineDispatcher = Dispatchers.Main,
+) : PipelineTerminalUi {
+
+    private companion object {
+        val MIN_NOTIFICATION_INTERVAL = 500.milliseconds
+    }
+
+    @Volatile
+    private var terminalActive = false
+
+    private var lastShownTitleRes: Int = 0
+    private var lastEmitMs: Long = 0L
+    private var pendingSnapshot: DictionaryProgressModel.Snapshot? = null
+    private var flushJob: Job? = null
+
+    init {
+        scope.launch(mainDispatcher) {
+            progressSnapshot.collect { snapshot ->
+                when {
+                    snapshot == null -> {
+                        resetThrottle()
+                        if (!terminalActive && notifications.hasActiveProgressNotification()) {
+                            notifications.cancelProgressNotification()
+                        }
+                    }
+                    !terminalActive -> emitThrottled(snapshot)
+                }
+            }
+        }
+    }
+
+    private fun emitThrottled(snapshot: DictionaryProgressModel.Snapshot) {
+        val now = SystemClock.elapsedRealtime()
+        val stageChanged = snapshot.titleRes != lastShownTitleRes
+        if (stageChanged || (now - lastEmitMs).milliseconds >= MIN_NOTIFICATION_INTERVAL) {
+            flushJob?.cancel()
+            pendingSnapshot = null
+            publish(snapshot, now)
+        } else {
+            pendingSnapshot = snapshot
+            if (flushJob?.isActive != true) {
+                flushJob = scope.launch(mainDispatcher) {
+                    delay(MIN_NOTIFICATION_INTERVAL - (now - lastEmitMs).milliseconds)
+                    pendingSnapshot?.let { publish(it, SystemClock.elapsedRealtime()) }
+                    pendingSnapshot = null
+                }
+            }
+        }
+    }
+
+    private fun publish(snapshot: DictionaryProgressModel.Snapshot, now: Long) {
+        if (terminalActive) return
+        lastShownTitleRes = snapshot.titleRes
+        lastEmitMs = now
+        notifications.showProgress(snapshot.percent, snapshot.titleRes)
+    }
+
+    private fun resetThrottle() {
+        flushJob?.cancel()
+        pendingSnapshot = null
+        lastShownTitleRes = 0
+        lastEmitMs = 0L
+    }
+
+    fun beginFlow() {
+        terminalActive = false
+        resetThrottle()
+        notifications.cancelTerminalNotification()
+    }
+
+    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
+        resetThrottle()
+        notifications.cancelProgressNotification()
+    }
+}

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

@@ -0,0 +1,11 @@
+package com.example.research.common.progress
+
+interface NotificationPort {
+    fun showProgress(percent: Int, titleRes: Int)
+    fun showImportSuccess()
+    fun showDownloadSuccess()
+    fun showError()
+    fun cancelProgressNotification()
+    fun cancelTerminalNotification()
+    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/ui/AppBackButton.kt

@@ -0,0 +1,25 @@
+package com.example.research.common.ui
+
+import androidx.compose.foundation.layout.size
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import com.example.research.R
+
+@Composable
+fun AppBackButton(
+    onClick: () -> Unit,
+    modifier: Modifier = Modifier
+) {
+    IconButton(onClick = onClick, modifier = modifier.size(48.dp)) {
+        Icon(
+            painter = painterResource(R.drawable.ic_arrow_back),
+            contentDescription = stringResource(R.string.action_back),
+            modifier = Modifier.size(28.dp)
+        )
+    }
+}

app/src/main/java/com/example/research/common/ui/ModifierExtensions.kt

@@ -1,13 +1,17 @@
 package com.example.research.common.ui
 
 import androidx.compose.foundation.clickable
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.material3.ripple
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.hapticfeedback.HapticFeedbackType
 import androidx.compose.ui.platform.LocalHapticFeedback
 import androidx.compose.ui.platform.testTag
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.semantics.testTagsAsResourceId
+import androidx.compose.ui.unit.dp
 
 fun Modifier.appTestTag(tag: String): Modifier = this
     .testTag(tag)
@@ -24,3 +28,14 @@ fun Modifier.clickableWithHaptics(
         onClick()
     }
 }
+
+@Composable
+fun Modifier.iconClickable(
+    enabled: Boolean = true,
+    onClick: () -> Unit
+): Modifier = this.clickable(
+    interactionSource = remember { MutableInteractionSource() },
+    indication = ripple(bounded = false, radius = 20.dp),
+    enabled = enabled,
+    onClick = onClick
+)

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

@@ -0,0 +1,46 @@
+package com.example.research.common.ui.components
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.offset
+import androidx.compose.foundation.layout.size
+import androidx.compose.material3.Badge
+import androidx.compose.material3.Icon
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.painter.Painter
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+
+private val BadgeOutset = 4.dp
+
+@Composable
+fun BadgedIcon(
+    painter: Painter,
+    tint: Color,
+    size: Dp,
+    badgeDescription: String?,
+    modifier: Modifier = Modifier,
+) {
+    Box(modifier = modifier.size(size)) {
+        Icon(
+            painter = painter,
+            contentDescription = null,
+            tint = tint,
+            modifier = Modifier.size(size)
+        )
+        if (badgeDescription != null) {
+            Badge(
+                modifier = Modifier
+                    .align(Alignment.TopEnd)
+                    .offset(x = BadgeOutset, y = -BadgeOutset)
+                    .testTag("badge")
+                    .semantics { contentDescription = badgeDescription }
+            )
+        }
+    }
+}

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

@@ -5,7 +5,6 @@ import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
@@ -29,7 +28,8 @@ fun CollapsibleHeader(
     onToggle: () -> Unit,
     modifier: Modifier = Modifier,
     subtitle: String? = null,
-    testTag: String? = null
+    testTag: String? = null,
+    badgeDescription: String? = null,
 ) {
     Row(
         modifier = modifier
@@ -43,11 +43,11 @@ fun CollapsibleHeader(
         verticalAlignment = Alignment.CenterVertically,
         horizontalArrangement = Arrangement.spacedBy(12.dp)
     ) {
-        Icon(
+        BadgedIcon(
             painter = painterResource(iconRes),
-            contentDescription = null,
             tint = MaterialTheme.colorScheme.primary,
-            modifier = Modifier.size(24.dp)
+            size = 24.dp,
+            badgeDescription = badgeDescription,
         )
 
         Column(

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

@@ -19,6 +19,8 @@ class FileStorageManager {
         private const val DELETE_WAIT_INTERVAL = 50L
         private const val MAX_DELETE_WAIT_COUNT = 10
         private const val DEFAULT_MAX_RETRIES = 5
+        private const val CREATE_RETRY_DELAY = 100L
+        private const val MAX_CREATE_RETRIES = 3
         private const val TAG = "FileStorageManager"
     }
 
@@ -87,6 +89,7 @@ class FileStorageManager {
                         Log.e(TAG, "Could not delete existing file: $fileName")
                         return@withContext null
                     }
+                    awaitGone(targetFile::exists)
                 } else {
                     return@withContext Uri.fromFile(targetFile)
                 }
@@ -95,7 +98,18 @@ class FileStorageManager {
             if (tempBinFile.exists()) {
                 tempBinFile.delete()
             }
-            if (targetFile.createNewFile()) {
+            var created = targetFile.createNewFile()
+            var createAttempt = 0
+            while (!created && createAttempt < MAX_CREATE_RETRIES) {
+                delay(CREATE_RETRY_DELAY.milliseconds)
+                if (targetFile.exists()) {
+                    targetFile.delete()
+                    awaitGone(targetFile::exists)
+                }
+                created = targetFile.createNewFile()
+                createAttempt++
+            }
+            if (created) {
                 Uri.fromFile(targetFile)
             } else {
                 Log.e(TAG, "Failed to create file: $fileName")
@@ -116,7 +130,7 @@ class FileStorageManager {
         for (attempt in 1..maxRetries) {
             try {
                 if (file.delete()) {
-                    waitForFileDeletion(file)
+                    awaitGone(file::exists)
                     if (!file.exists()) {
                         return@withContext true
                     }
@@ -141,9 +155,10 @@ class FileStorageManager {
         }
     }
 
-    private suspend fun waitForFileDeletion(file: DocumentFile) {
+    // FUSE-backed storage keeps a just-deleted file visible to stat/open for a short window
+    private suspend fun awaitGone(exists: () -> Boolean) {
         var waitCount = 0
-        while (file.exists() && waitCount < MAX_DELETE_WAIT_COUNT) {
+        while (exists() && waitCount < MAX_DELETE_WAIT_COUNT) {
             delay(DELETE_WAIT_INTERVAL.milliseconds)
             waitCount++
         }

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

@@ -7,11 +7,13 @@ 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
+        const val TERMINAL_NOTIFICATION_ID = 2
     }
     private val notificationManager = NotificationManagerCompat.from(context)
     private var lastNotificationKey: Int = 0
@@ -57,13 +59,28 @@ class NotificationHelper(private val context: Context) {
         val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as? NotificationManager
         manager?.createNotificationChannel(channel)
     }
-    private fun canShowNotification(): Boolean {
-        if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.TIRAMISU) return true
-        return ContextCompat.checkSelfPermission(
-            context,
-            android.Manifest.permission.POST_NOTIFICATIONS
-        ) == android.content.pm.PackageManager.PERMISSION_GRANTED
+    private fun canShowNotification(): Boolean =
+        android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.TIRAMISU ||
+            ContextCompat.checkSelfPermission(
+                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
@@ -74,7 +91,7 @@ class NotificationHelper(private val context: Context) {
             .setContentIntent(mainActivityPendingIntent)
             .setAutoCancel(true)
             .build()
-        safeNotify(notification)
+        safeNotifyTerminal(notification)
     }
     fun showErrorNotification() {
         if (!canShowNotification()) return
@@ -86,13 +103,19 @@ class NotificationHelper(private val context: Context) {
             .setContentIntent(mainActivityPendingIntent)
             .setAutoCancel(true)
             .build()
-        safeNotify(notification)
+        safeNotifyTerminal(notification)
     }
     fun cancelNotification() {
         lastNotificationKey = 0
         notificationManager.cancel(NOTIFICATION_ID)
     }
 
+    override fun cancelTerminalNotification() {
+        notificationManager.cancel(TERMINAL_NOTIFICATION_ID)
+    }
+
+    override fun hasActiveProgressNotification(): Boolean = lastNotificationKey != 0
+
     fun showUnifiedProgressNotification(
         title: String,
         contentText: String,
@@ -142,6 +165,14 @@ class NotificationHelper(private val context: Context) {
             // Notification permission denied or security policy blocked
         }
     }
+
+    @SuppressLint("MissingPermission")
+    private fun safeNotifyTerminal(notification: Notification) {
+        try {
+            notificationManager.notify(TERMINAL_NOTIFICATION_ID, notification)
+        } catch (_: SecurityException) {
+        }
+    }
     fun showImportSuccessNotification() {
         if (!canShowNotification()) return
         lastNotificationKey = 0
@@ -152,7 +183,7 @@ class NotificationHelper(private val context: Context) {
             .setContentIntent(mainActivityPendingIntent)
             .setAutoCancel(true)
             .build()
-        safeNotify(notification)
+        safeNotifyTerminal(notification)
     }
     fun createForegroundNotification(): Notification {
         val notification = NotificationCompat.Builder(context, CHANNEL_ID)

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

@@ -102,12 +102,15 @@ data class DictionarySource(
 
         fun validateTemplate(template: String): ValidationResult {
             val trimmed = template.trim()
+            val lowerTemplate = trimmed.lowercase()
             return when {
                 trimmed.isBlank() -> ValidationResult.Error(ValidationError.EMPTY)
                 trimmed.length > 2048 -> ValidationResult.Error(ValidationError.TOO_LONG)
-                !trimmed.startsWith("http://") && !trimmed.startsWith("https://") ->
+                !trimmed.startsWith("https://") ->
                     ValidationResult.Error(ValidationError.INVALID_PROTOCOL)
-                !trimmed.endsWith(".gz") && !trimmed.endsWith(".dsl") && !trimmed.endsWith(".dz") ->
+                !lowerTemplate.endsWith(".gz") &&
+                    !lowerTemplate.endsWith(".dsl") &&
+                    !lowerTemplate.endsWith(".dsl.dz") ->
                     ValidationResult.Error(ValidationError.INVALID_EXTENSION)
                 !isValidUrlStructure(trimmed) ->
                     ValidationResult.Error(ValidationError.INVALID_URL_STRUCTURE)
@@ -132,8 +135,15 @@ data class DictionarySource(
                 val parts = afterProtocol.split("/")
                 if (parts.size < 2) return false
                 
-                val domain = parts[0]
-                if (domain.isEmpty()) return false
+                val hostWithPort = parts[0]
+                if (hostWithPort.isEmpty()) return false
+
+                val colonIndex = hostWithPort.lastIndexOf(':')
+                if (colonIndex >= 0) {
+                    val port = hostWithPort.substring(colonIndex + 1).toIntOrNull()
+                    if (port == null || port !in 1..65535) return false
+                }
+                val domain = if (colonIndex >= 0) hostWithPort.substring(0, colonIndex) else hostWithPort
                 if (domain != "localhost" && !domain.contains(".")) return false
                 
                 val filename = parts.last()

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

@@ -1,45 +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/model/SearchBarPosition.kt

@@ -0,0 +1,11 @@
+package com.example.research.core.domain.model
+
+enum class SearchBarPosition {
+    TOP,
+    BOTTOM;
+
+    companion object {
+        fun fromStorage(value: String?): SearchBarPosition =
+            entries.firstOrNull { it.name == value } ?: TOP
+    }
+}

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

@@ -0,0 +1,128 @@
+package com.example.research.core.util
+
+val NaturalStringComparator: Comparator<String> = Comparator { a, b -> compareNatural(a, b) }
+
+private const val NUMERAL_CAP = 1_000_000_000_000_000_000L
+
+private fun digitOf(c: Char): Int = when (c) {
+    '〇', '零' -> 0
+    '一', '壹', '壱', '弌' -> 1
+    '二', '貳', '贰', '弐', '弍', '兩', '两' -> 2
+    '三', '叁', '參', '参', '弎' -> 3
+    '四', '肆' -> 4
+    '五', '伍' -> 5
+    '六', '陸', '陆' -> 6
+    '七', '柒' -> 7
+    '八', '捌' -> 8
+    '九', '玖' -> 9
+    else -> Character.digit(c, 10)
+}
+
+private fun smallUnitOf(c: Char): Long = when (c) {
+    '十', '拾' -> 10L
+    '百', '佰' -> 100L
+    '千', '仟' -> 1000L
+    else -> 0L
+}
+
+private fun fixedTensOf(c: Char): Long = when (c) {
+    '廿' -> 20L
+    '卅' -> 30L
+    '卌' -> 40L
+    else -> 0L
+}
+
+private fun bigUnitOf(c: Char): Long = when (c) {
+    '万', '萬' -> 10_000L
+    '億', '亿' -> 100_000_000L
+    '兆' -> 1_000_000_000_000L
+    '京' -> 10_000_000_000_000_000L
+    else -> 0L
+}
+
+private fun isNumeralChar(c: Char): Boolean =
+    digitOf(c) >= 0 || smallUnitOf(c) > 0L || fixedTensOf(c) > 0L || bigUnitOf(c) > 0L
+
+private fun satMul(a: Long, b: Long): Long =
+    if (a != 0L && b > NUMERAL_CAP / a) NUMERAL_CAP else minOf(a * b, NUMERAL_CAP)
+
+private fun satAdd(a: Long, b: Long): Long = minOf(a + b, NUMERAL_CAP)
+
+private fun numeralValue(s: String, start: Int, end: Int): Long {
+    var total = 0L
+    var section = 0L
+    var pending = -1L
+    for (k in start until end) {
+        val c = s[k]
+        val digit = digitOf(c)
+        if (digit >= 0) {
+            pending = if (pending < 0) digit.toLong() else satAdd(satMul(pending, 10L), digit.toLong())
+            continue
+        }
+        val small = smallUnitOf(c)
+        if (small > 0L) {
+            section = satAdd(section, satMul(if (pending < 0) 1L else pending, small))
+            pending = -1
+            continue
+        }
+        val fixed = fixedTensOf(c)
+        if (fixed > 0L) {
+            section = satAdd(section, fixed)
+            pending = -1
+            continue
+        }
+        val base = satAdd(section, maxOf(pending, 0L))
+        total = satAdd(total, satMul(if (base == 0L) 1L else base, bigUnitOf(c)))
+        section = 0L
+        pending = -1
+    }
+    return satAdd(total, satAdd(section, maxOf(pending, 0L)))
+}
+
+private fun compareNatural(a: String, b: String): Int {
+    var i = 0
+    var j = 0
+    while (i < a.length && j < b.length) {
+        val ca = a[i]
+        val cb = b[j]
+        val asciiA = ca in '0'..'9'
+        val asciiB = cb in '0'..'9'
+        when {
+            !asciiA && !asciiB && isNumeralChar(ca) && isNumeralChar(cb) -> {
+                var endA = i
+                while (endA < a.length && isNumeralChar(a[endA])) endA++
+                var endB = j
+                while (endB < b.length && isNumeralChar(b[endB])) endB++
+                val diff = numeralValue(a, i, endA).compareTo(numeralValue(b, j, endB))
+                if (diff != 0) return diff
+                i = endA
+                j = endB
+            }
+            asciiA && asciiB -> {
+                var endA = i
+                while (endA < a.length && a[endA] in '0'..'9') endA++
+                var endB = j
+                while (endB < b.length && b[endB] in '0'..'9') endB++
+                var startA = i
+                while (startA < endA - 1 && a[startA] == '0') startA++
+                var startB = j
+                while (startB < endB - 1 && b[startB] == '0') startB++
+                val lengthA = endA - startA
+                val lengthB = endB - startB
+                if (lengthA != lengthB) return lengthA.compareTo(lengthB)
+                for (k in 0 until lengthA) {
+                    val diff = a[startA + k].compareTo(b[startB + k])
+                    if (diff != 0) return diff
+                }
+                i = endA
+                j = endB
+            }
+            else -> {
+                if (ca != cb) return ca.compareTo(cb)
+                i++
+                j++
+            }
+        }
+    }
+    return (a.length - i).compareTo(b.length - j)
+}

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

@@ -60,7 +60,10 @@ fun String.extractDictionaryPrefix(): String {
 }
 
 
-fun String.removeAccentTagsForIndexing(): String {
+fun String.removeAccentTagsForIndexing(): String =
+    rewriteAccentTags { builder, from, to -> builder.append(this, from, to) }
+
+internal inline fun String.rewriteAccentTags(appendInner: (StringBuilder, Int, Int) -> Unit): String {
     val firstOpen = indexOf("[']")
     if (firstOpen < 0) return this
 
@@ -80,7 +83,7 @@ fun String.removeAccentTagsForIndexing(): String {
                     builder = StringBuilder(length)
                 }
                 builder.append(this, appendStart, index)
-                builder.append(this, index + 3, scan)
+                appendInner(builder, index + 3, scan)
                 index = scan + 4
                 appendStart = index
                 continue
@@ -94,7 +97,7 @@ fun String.removeAccentTagsForIndexing(): String {
     }?.toString() ?: this
 }
 
-private fun String.startsWithAt(start: Int, literal: String): Boolean {
+internal fun String.startsWithAt(start: Int, literal: String): Boolean {
     if (start < 0 || start + literal.length > length) return false
     for (i in literal.indices) {
         if (this[start + i] != literal[i]) return false

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

@@ -2,29 +2,70 @@ package com.example.research.data.local.preferences
 
 import android.content.Context
 import androidx.datastore.core.DataStore
+import androidx.datastore.core.FileStorage
+import androidx.datastore.core.handlers.ReplaceFileCorruptionHandler
 import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.PreferencesFileSerializer
 import androidx.datastore.preferences.core.edit
 import androidx.datastore.preferences.core.booleanPreferencesKey
+import androidx.datastore.preferences.core.emptyPreferences
 import androidx.datastore.preferences.core.stringPreferencesKey
 import androidx.datastore.preferences.core.stringSetPreferencesKey
-import androidx.datastore.preferences.preferencesDataStore
+import androidx.datastore.preferences.preferencesDataStoreFile
 import com.example.research.core.domain.model.DictionarySource
+import com.example.research.core.domain.model.SearchBarPosition
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.distinctUntilChanged
+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")
+private const val SETTINGS_STORE_NAME = "settings"
+
+private val storeLock = Any()
+
+@Volatile
+private var settingsStore: DataStore<Preferences>? = null
+
+private val Context.dataStore: DataStore<Preferences>
+    get() = settingsStore ?: synchronized(storeLock) {
+        settingsStore ?: DataStore.Builder(
+            storage = FileStorage(PreferencesFileSerializer) {
+                applicationContext.preferencesDataStoreFile(SETTINGS_STORE_NAME)
+            },
+            context = Dispatchers.IO + SupervisorJob(),
+        ).setCorruptionHandler(ReplaceFileCorruptionHandler { emptyPreferences() }).build()
+            .also { settingsStore = it }
+    }
+
+data class SectionExpansionStates(
+    val isThemeExpanded: Boolean = false,
+    val isLanguageExpanded: Boolean = false,
+    val isSearchBarExpanded: Boolean = false,
+    val isDictionariesExpanded: Boolean = true,
+)
 
 class PreferencesManager(private val context: Context) {
     private object PreferencesKeys {
         val THEME_MODE = stringPreferencesKey("theme_mode")
         val DICTIONARY_SOURCES = stringPreferencesKey("dictionary_sources")
         val LANGUAGE = stringPreferencesKey("language")
+        val SEARCH_BAR_POSITION = stringPreferencesKey("search_bar_position")
         val IS_THEME_EXPANDED = booleanPreferencesKey("is_theme_expanded")
         val IS_LANGUAGE_EXPANDED = booleanPreferencesKey("is_language_expanded")
+        val IS_SEARCH_BAR_EXPANDED = booleanPreferencesKey("is_search_bar_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")
+        val SEARCH_HISTORY = stringPreferencesKey("search_history")
+    }
+
+    private companion object {
+        const val MAX_SEARCH_HISTORY_ENTRIES = 100
     }
 
     private val json = Json { ignoreUnknownKeys = true }
@@ -48,6 +89,17 @@ class PreferencesManager(private val context: Context) {
         }
     }
 
+    val searchBarPosition: Flow<SearchBarPosition> = context.dataStore.data
+        .map { preferences ->
+            SearchBarPosition.fromStorage(preferences[PreferencesKeys.SEARCH_BAR_POSITION])
+        }
+
+    suspend fun saveSearchBarPosition(position: SearchBarPosition) {
+        context.dataStore.edit { preferences ->
+            preferences[PreferencesKeys.SEARCH_BAR_POSITION] = position.name
+        }
+    }
+
     val dictionarySources: Flow<List<DictionarySource>> = context.dataStore.data
         .map { preferences ->
             val sourcesJson = preferences[PreferencesKeys.DICTIONARY_SOURCES]
@@ -67,6 +119,36 @@ 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,
+                isSearchBarExpanded = preferences[PreferencesKeys.IS_SEARCH_BAR_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]
@@ -105,6 +187,11 @@ class PreferencesManager(private val context: Context) {
             preferences[PreferencesKeys.IS_LANGUAGE_EXPANDED] ?: false
         }
 
+    val isSearchBarExpanded: Flow<Boolean> = context.dataStore.data
+        .map { preferences ->
+            preferences[PreferencesKeys.IS_SEARCH_BAR_EXPANDED] ?: false
+        }
+
     val isDictionariesExpanded: Flow<Boolean> = context.dataStore.data
         .map { preferences ->
             preferences[PreferencesKeys.IS_DICTIONARIES_EXPANDED] ?: true
@@ -115,6 +202,7 @@ class PreferencesManager(private val context: Context) {
             when (key) {
                 "theme" -> preferences[PreferencesKeys.IS_THEME_EXPANDED] = isExpanded
                 "language" -> preferences[PreferencesKeys.IS_LANGUAGE_EXPANDED] = isExpanded
+                "search_bar" -> preferences[PreferencesKeys.IS_SEARCH_BAR_EXPANDED] = isExpanded
                 "dictionaries" -> preferences[PreferencesKeys.IS_DICTIONARIES_EXPANDED] = isExpanded
             }
         }
@@ -161,6 +249,51 @@ class PreferencesManager(private val context: Context) {
         }
     }
 
+    val searchHistory: Flow<List<String>> = context.dataStore.data
+        .map { preferences -> preferences[PreferencesKeys.SEARCH_HISTORY] }
+        .distinctUntilChanged()
+        .map(::decodeSearchHistory)
+
+    suspend fun addSearchHistoryEntry(query: String) {
+        context.dataStore.edit { preferences ->
+            val current = decodeSearchHistory(preferences[PreferencesKeys.SEARCH_HISTORY])
+                .toMutableList()
+            current.removeAll { it.equals(query, ignoreCase = true) }
+            current.add(0, query)
+            preferences[PreferencesKeys.SEARCH_HISTORY] =
+                json.encodeToString(current.take(MAX_SEARCH_HISTORY_ENTRIES))
+        }
+    }
+
+    suspend fun removeSearchHistoryEntry(query: String) {
+        context.dataStore.edit { preferences ->
+            val current = decodeSearchHistory(preferences[PreferencesKeys.SEARCH_HISTORY])
+                .toMutableList()
+            if (current.removeAll { it == query }) {
+                if (current.isEmpty()) {
+                    preferences.remove(PreferencesKeys.SEARCH_HISTORY)
+                } else {
+                    preferences[PreferencesKeys.SEARCH_HISTORY] = json.encodeToString(current)
+                }
+            }
+        }
+    }
+
+    suspend fun clearSearchHistory() {
+        context.dataStore.edit { preferences ->
+            preferences.remove(PreferencesKeys.SEARCH_HISTORY)
+        }
+    }
+
+    private fun decodeSearchHistory(value: String?): List<String> {
+        if (value == null) return emptyList()
+        return try {
+            json.decodeFromString<List<String>>(value)
+        } catch (_: Exception) {
+            emptyList()
+        }
+    }
+
     suspend fun sanitizeDictionarySources() {
         context.dataStore.edit { preferences ->
             val currentSources = decodeSources(

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

@@ -5,60 +5,26 @@ import androidx.paging.PagingState
 import com.example.research.core.domain.model.Dictionary
 import com.example.research.core.domain.model.IndexEntry
 import com.example.research.core.performance.ReSearchTrace
-import com.example.research.core.util.sanitizeQuery
 import com.example.research.data.parser.IndexSearcher
-import com.example.research.data.parser.SearchRankingContext
-import com.example.research.data.parser.rankBySearchRelevance
+import com.example.research.data.parser.sortByCharCountThenNatural
+
 import kotlinx.coroutines.async
 import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.CancellationException
 import java.io.File
 
-/**
- * Two-phase search paging.
- *
- * Page one (key = null) is the ranked head: the capped, relevance-ordered result the
- * search screen has always shown, merged across active dictionaries. Every range scan
- * that hit its cap hands back a [IndexSearcher.RangeCursor]; those become the tail key.
- *
- * Tail pages continue the unfinished range scans directly from the index files and
- * merge them alphabetically (k-way, by index word), so scrolling eventually surfaces
- * every prefix match in every active dictionary. Articles already shown -- by the head
- * or by an earlier tail page, including diacritic alias duplicates -- are filtered
- * through [emittedArticles], which grows only as far as the user actually scrolls.
- *
- * A new query builds a new PagingSource (see SearchViewModel's flatMapLatest), so an
- * in-flight head or tail load is cancelled by Paging when the user keeps typing.
- */
 class IndexEntryPagingSource(
     private val indexSearcher: IndexSearcher,
-    private val dictionaries: List<Dictionary>,
+    dictionaries: List<Dictionary>,
     private val query: String
-) : PagingSource<IndexEntryPagingSource.TailKey, IndexEntry>() {
+) : PagingSource<Int, IndexEntry>() {
 
-    data class StreamCursor(
-        val dictPosition: Int,
-        val cursor: IndexSearcher.RangeCursor
-    )
+    private val activeDictionaries = dictionaries.filter { it.isActive }
 
-    data class TailKey(val streams: List<StreamCursor>)
-
-    private data class EmittedKey(
-        val dictPosition: Int,
-        val originalWord: String,
-        val offset: Long,
-        val length: Int
-    )
-
-    private val emittedArticles = HashSet<EmittedKey>()
-
-    private val activeDictionaries = dictionaries.withIndex().filter { it.value.isActive }
-
-    override suspend fun load(params: LoadParams<TailKey>): LoadResult<TailKey, IndexEntry> {
+    override suspend fun load(params: LoadParams<Int>): LoadResult<Int, IndexEntry> {
         return try {
-            val key = params.key
-            if (key == null) loadHead() else loadTail(key, params.loadSize)
+            loadAll()
         } catch (e: CancellationException) {
             throw e
         } catch (e: Exception) {
@@ -66,21 +32,22 @@ class IndexEntryPagingSource(
         }
     }
 
-    private suspend fun loadHead(): LoadResult<TailKey, IndexEntry> =
+    private suspend fun loadAll(): LoadResult<Int, IndexEntry> =
         ReSearchTrace.asyncSection(ReSearchTrace.SEARCH_PAGING) {
             coroutineScope {
                 val perDictionary = activeDictionaries
-                    .map { (position, dict) ->
+                    .map { dict ->
                         async {
                             val indexFile = File(dict.indexPath)
                             if (!indexFile.exists()) return@async null
 
                             try {
-                                val result = indexSearcher.searchWithCursors(
+                                val entries = indexSearcher.search(
                                     pathOrUri = indexFile.absolutePath,
-                                    query = query
+                                    query = query,
+                                    includeSubstringMatches = false
                                 )
-                                Triple(position, dict, result)
+                                dict to entries
                             } catch (e: CancellationException) {
                                 throw e
                             } catch (_: Exception) {
@@ -91,104 +58,28 @@ class IndexEntryPagingSource(
                     .awaitAll()
                     .filterNotNull()
 
-                val rawResults = perDictionary.flatMap { (position, dict, result) ->
-                    result.entries.map { entry ->
-                        position to entry.withDictionary(
+                val rawResults = perDictionary.flatMap { (dict, entries) ->
+                    entries.map { entry ->
+                        entry.withDictionary(
                             dict.metadata.name.ifBlank { dict.name },
                             dict.path
                         )
                     }
                 }
 
-                val normalizedQuery = query.sanitizeQuery().lowercase().trim()
-                val ranked = rawResults.map { it.second }
-                    .rankBySearchRelevance(SearchRankingContext(normalizedQuery))
+                val ranked = rawResults
+                    .sortByCharCountThenNatural()
+                    .distinctBy { Triple(it.dictionaryPath, it.word, it.offset.value) }
 
-                rawResults.forEach { (position, entry) -> emittedArticles.add(entry.emittedKey(position)) }
-
-                val streams = perDictionary.flatMap { (position, _, result) ->
-                    result.cursors.map { StreamCursor(position, it) }
-                }
                 LoadResult.Page(
                     data = ranked,
                     prevKey = null,
-                    nextKey = if (streams.isEmpty()) null else TailKey(streams)
+                    nextKey = null
                 )
             }
         }
 
-    private suspend fun loadTail(key: TailKey, loadSize: Int): LoadResult<TailKey, IndexEntry> {
-        val streams = key.streams.map { TailStream(it.dictPosition, it.cursor) }
-        val page = ArrayList<IndexEntry>(loadSize)
-        val pageKeys = HashSet<EmittedKey>()
-        val chunkSize = maxOf(loadSize, MIN_CHUNK)
-
-        while (page.size < loadSize) {
-            streams.forEach { it.ensureBuffered(chunkSize) }
-            val next = streams
-                .filter { it.hasBuffered }
-                .minByOrNull { it.peekWord }
-                ?: break
-
-            val scanned = next.consume()
-            val dict = dictionaries[next.dictPosition]
-            val entry = scanned.entry.withDictionary(
-                dict.metadata.name.ifBlank { dict.name },
-                dict.path
-            )
-            val emittedKey = entry.emittedKey(next.dictPosition)
-            if (emittedKey !in emittedArticles && pageKeys.add(emittedKey)) {
-                page.add(entry)
-            }
-        }
-
-        emittedArticles.addAll(pageKeys)
-
-        val remaining = streams.mapNotNull { stream ->
-            stream.nextCursor?.let { StreamCursor(stream.dictPosition, it) }
-        }
-        return LoadResult.Page(
-            data = page,
-            prevKey = null,
-            nextKey = if (remaining.isEmpty()) null else TailKey(remaining)
-        )
-    }
-
-    private inner class TailStream(
-        val dictPosition: Int,
-        initialCursor: IndexSearcher.RangeCursor
-    ) {
-        var nextCursor: IndexSearcher.RangeCursor? = initialCursor
-            private set
-        private var buffer: List<IndexSearcher.ScannedEntry> = emptyList()
-        private var position = 0
-
-        val hasBuffered: Boolean get() = position < buffer.size
-        val peekWord: String get() = buffer[position].entry.word
-
-        suspend fun ensureBuffered(chunkSize: Int) {
-            if (hasBuffered) return
-            val cursor = nextCursor ?: return
-            val indexPath = File(dictionaries[dictPosition].indexPath).absolutePath
-            buffer = indexSearcher.scanTailChunk(indexPath, cursor, chunkSize)
-            position = 0
-            if (buffer.isEmpty()) nextCursor = null
-        }
-
-        fun consume(): IndexSearcher.ScannedEntry {
-            val scanned = buffer[position]
-            position++
-            nextCursor = scanned.cursorAfter
-            return scanned
-        }
-    }
-
-    private fun IndexEntry.emittedKey(dictPosition: Int) =
-        EmittedKey(dictPosition, originalWord, offset.value, length.value)
-
-    override fun getRefreshKey(state: PagingState<TailKey, IndexEntry>): TailKey? {
+    override fun getRefreshKey(state: PagingState<Int, IndexEntry>): Int? {
         return null
     }
 }
-
-private const val MIN_CHUNK = 48

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] == '\n') 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

@@ -1,5 +1,8 @@
 package com.example.research.data.parser
 
+import com.example.research.core.util.rewriteAccentTags
+import com.example.research.core.util.startsWithAt
+
 object DslHeadwordParser {
 
     private val FORMATTING_LITERAL_TAGS = arrayOf(
@@ -117,12 +120,12 @@ object DslHeadwordParser {
     }
 
     private fun reconstructDisplayPrefix(value: String): String {
-        val reconstructed = removeCurlyBraceDelimiters(value)
-        val formattingTagIndex = firstFormattingTagIndex(reconstructed)
-        return if (formattingTagIndex >= 0) {
-            reconstructed.substring(0, formattingTagIndex).trim()
-        } else {
-            reconstructed.trim()
+        return removeFormattingTags(removeCurlyBraceDelimiters(value).applyAccentMarks()).trim()
+    }
+
+    private fun String.applyAccentMarks(): String = rewriteAccentTags { builder, from, to ->
+        if (to > from) {
+            builder.append(this[from]).append('\u0301').append(this, from + 1, to)
         }
     }
 
@@ -145,21 +148,6 @@ 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
-            }
-            index++
-        }
-        return -1
-    }
-
     private fun firstCurlyContent(value: String): String? {
         var index = 0
         while (index < value.length) {
@@ -346,14 +334,6 @@ object DslHeadwordParser {
         return if (index < value.length && value[index] == ']') index + 1 else -1
     }
 
-    private fun String.startsWithAt(start: Int, literal: String): Boolean {
-        if (start < 0 || start + literal.length > length) return false
-        for (i in literal.indices) {
-            if (this[start + i] != literal[i]) return false
-        }
-        return true
-    }
-
     private fun Char.isTagWhitespace(): Boolean {
         return this == ' ' ||
             this == '\t' ||

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

@@ -24,7 +24,7 @@ class DslIndexer(context: Context? = null) {
 
     companion object {
         private const val TAG = "DslIndexer"
-        const val INDEX_VERSION = 6
+        const val INDEX_VERSION = 7
         const val BUFFER_SIZE = 1048576
         const val BATCH_BUFFER_SIZE = 524288
         private const val INDEX_SORT_PARALLELISM = 1
@@ -49,6 +49,7 @@ class DslIndexer(context: Context? = null) {
     suspend fun createIndex(
         dslInputStream: java.io.InputStream,
         indexFile: File,
+        totalInputBytes: Long = -1L,
         onProgress: (Int) -> Unit = {},
         onOperationChange: (String) -> Unit = {},
         onFileProgress: (Float) -> Unit = {},
@@ -65,7 +66,7 @@ class DslIndexer(context: Context? = null) {
             try { foldedIndexFile(indexFile).delete() } catch (_: Throwable) { /* Legacy v5 leftover */ }
             onOperationChange("Parsing file")
             onFileProgress(0.0f)
-            counts = parseDslToTempFile(bufferedStream, tempFile,
+            counts = parseDslToTempFile(bufferedStream, tempFile, totalInputBytes,
                 onProgress, onFileProgress, onCharsetDetected)
             onFileProgress(0.5f)
             onOperationChange("Sorting index")
@@ -88,6 +89,7 @@ class DslIndexer(context: Context? = null) {
     private suspend fun parseDslToTempFile(
         inputStream: java.io.InputStream,
         tempFile: File,
+        totalInputBytes: Long,
         onProgress: (Int) -> Unit,
         onFileProgress: (Float) -> Unit = {},
         onCharsetDetected: (DslCharsetDetector.DetectedCharset) -> Unit = {}
@@ -230,8 +232,12 @@ class DslIndexer(context: Context? = null) {
                     val yieldThreshold = adaptiveConfig.yieldInterval
                     if (yieldCounter >= yieldThreshold) {
                         onProgress(entryCount)
-                        val estimatedProgress = (lineCount * 10).toFloat() / (Int.MAX_VALUE / 1000)
-                        onFileProgress(estimatedProgress.coerceIn(0f, 0.4f))
+                        val parseProgress = if (totalInputBytes > 0L) {
+                            (reader.position.toFloat() / totalInputBytes.toFloat())
+                        } else {
+                            (lineCount * 10).toFloat() / (Int.MAX_VALUE / 1000)
+                        }
+                        onFileProgress(parseProgress.coerceIn(0f, 0.4f))
 
                         if (resourceManager != null) {
                             if (resourceManager.shouldYield(adaptiveConfig)) {

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

@@ -18,6 +18,7 @@ import kotlinx.coroutines.yield
 import java.io.BufferedInputStream
 import java.io.Closeable
 import java.io.DataInputStream
+import java.io.EOFException
 import java.io.File
 import java.io.FileInputStream
 import java.io.RandomAccessFile
@@ -25,7 +26,6 @@ import java.io.RandomAccessFile
 class IndexSearcher(private val context: Context) {
     private val metadataCache = MetadataLruCache(maxBytes = 64L * 1024L * 1024L)
     private val resultsCache = ResultsLruCache<List<IndexEntry>>(maxEntries = 20)
-    private val cursorResultsCache = ResultsLruCache<CursorSearchResult>(maxEntries = 20)
 
     /**
      * Pre-allocated reusable buffer for readEntry() to reduce allocations.
@@ -45,27 +45,6 @@ class IndexSearcher(private val context: Context) {
         val dataStartOffset: Long
     )
 
-    data class RangeCursor(
-        val rangeQuery: String,
-        val absoluteIndex: Int,
-        val fileOffset: Long
-    )
-
-    internal class RangeScanResult(
-        val entries: List<IndexEntry>,
-        val nextCursor: RangeCursor?
-    )
-
-    class CursorSearchResult(
-        val entries: List<IndexEntry>,
-        val cursors: List<RangeCursor>
-    )
-
-    class ScannedEntry(
-        val entry: IndexEntry,
-        val cursorAfter: RangeCursor?
-    )
-
     suspend fun findFirstEntry(pathOrUri: String, query: String): IndexEntry? = withContext(Dispatchers.Default) {
         val normalizedQuery = query.sanitizeQuery().lowercase().trim()
         try {
@@ -109,7 +88,7 @@ class IndexSearcher(private val context: Context) {
         }
         val normalizedQuery = query.sanitizeQuery().lowercase().trim()
         val foldedQuery = normalizedQuery.foldLatinDiacritics()
-        val cacheKey = "$pathOrUri:${normalizedQuery.sanitizeCacheKey()}"
+        val cacheKey = "$pathOrUri:$includeSubstringMatches:${normalizedQuery.sanitizeCacheKey()}"
         resultsCache.get(cacheKey)?.let {
             return@withContext it
         }
@@ -118,9 +97,9 @@ class IndexSearcher(private val context: Context) {
             val count = metadata.totalCount
             if (count == 0) return@withContext emptyList()
             val results = openSource(pathOrUri).use { source ->
-                val prefixMatches = readPrefixMatches(source, metadata, normalizedQuery).entries.toMutableList()
+                val prefixMatches = readPrefixMatches(source, metadata, normalizedQuery).toMutableList()
                 if (foldedQuery != normalizedQuery) {
-                    prefixMatches.addAll(readPrefixMatches(source, metadata, foldedQuery).entries)
+                    prefixMatches.addAll(readPrefixMatches(source, metadata, foldedQuery))
                 }
 
                 val substringMatches = mutableListOf<IndexEntry>()
@@ -143,9 +122,7 @@ class IndexSearcher(private val context: Context) {
                         }
                     }
                 }
-                (prefixMatches + substringMatches)
-                    .rankBySearchRelevance(SearchRankingContext(normalizedQuery, foldedQuery))
-                    .distinctBy { it.articleKey() }
+                (prefixMatches + substringMatches).distinctBy { it.articleKey() }
             }
             resultsCache.put(cacheKey, results)
             results
@@ -165,81 +142,9 @@ class IndexSearcher(private val context: Context) {
         metadataCache.getOrPut(pathOrUri) { loadMetadata(pathOrUri) }
     }
 
-    suspend fun searchWithCursors(
-        pathOrUri: String,
-        query: String
-    ): CursorSearchResult = withContext(Dispatchers.Default) {
-        if (query.isBlank()) {
-            return@withContext CursorSearchResult(emptyList(), emptyList())
-        }
-        val normalizedQuery = query.sanitizeQuery().lowercase().trim()
-        val foldedQuery = normalizedQuery.foldLatinDiacritics()
-        val cacheKey = "$pathOrUri:${normalizedQuery.sanitizeCacheKey()}"
-        cursorResultsCache.get(cacheKey)?.let {
-            return@withContext it
-        }
-        try {
-            val metadata = metadataCache.getOrPut(pathOrUri) { loadMetadata(pathOrUri) }
-            if (metadata.totalCount == 0) {
-                return@withContext CursorSearchResult(emptyList(), emptyList())
-            }
-            val result = openSource(pathOrUri).use { source ->
-                val scans = buildList {
-                    add(readPrefixMatches(source, metadata, normalizedQuery))
-                    if (foldedQuery != normalizedQuery) {
-                        add(readPrefixMatches(source, metadata, foldedQuery))
-                    }
-                }
-                val entries = scans.flatMap { it.entries }
-                    .rankBySearchRelevance(SearchRankingContext(normalizedQuery, foldedQuery))
-                    .distinctBy { it.articleKey() }
-                CursorSearchResult(entries, scans.mapNotNull { it.nextCursor })
-            }
-            cursorResultsCache.put(cacheKey, result)
-            result
-        } catch (e: CancellationException) {
-            throw e
-        } catch (e: Exception) {
-            Log.e(TAG, "searchWithCursors() - error: ${e.message}", e)
-            if (e is DictionaryError) throw e
-            throw DictionaryError.SearchError.QueryFailed(context.getString(R.string.error_search_failed, query.take(20), pathOrUri.take(20)), e)
-        }
-    }
-
-    suspend fun scanTailChunk(
-        pathOrUri: String,
-        cursor: RangeCursor,
-        maxEntries: Int
-    ): List<ScannedEntry> = withContext(Dispatchers.Default) {
-        val metadata = metadataCache.getOrPut(pathOrUri) { loadMetadata(pathOrUri) }
-        if (cursor.absoluteIndex >= metadata.totalCount) return@withContext emptyList()
-        openSource(pathOrUri).use { source ->
-            source.seek(cursor.fileOffset)
-            val out = ArrayList<ScannedEntry>(maxEntries)
-            var currentIdx = cursor.absoluteIndex
-            var iterationCount = 0
-            while (currentIdx < metadata.totalCount && out.size < maxEntries) {
-                if (iterationCount % 1000 == 0) yield()
-                val entry = readEntry(source, metadata)
-                val entryWordLower = entry.word.lowercase()
-                if (!entryWordLower.startsWith(cursor.rangeQuery)) break
-                currentIdx++
-                iterationCount++
-                val cursorAfter = if (currentIdx < metadata.totalCount) {
-                    RangeCursor(cursor.rangeQuery, currentIdx, source.position())
-                } else {
-                    null
-                }
-                out.add(ScannedEntry(entry.copy(word = entryWordLower), cursorAfter))
-            }
-            out
-        }
-    }
-
     fun trimMemory(level: Int) {
         metadataCache.trim(level)
         resultsCache.trim(level)
-        cursorResultsCache.trim(level)
     }
 
     suspend fun isMetadataLoaded(pathOrUri: String): Boolean {
@@ -349,9 +254,9 @@ class IndexSearcher(private val context: Context) {
         source: RandomAccessSource,
         metadata: IndexMetadata,
         query: String
-    ): RangeScanResult {
+    ): List<IndexEntry> {
         val firstMatch = findFirstMatch(source, metadata, query)
-            ?: return RangeScanResult(emptyList(), null)
+            ?: return emptyList()
         return readMatchingEntries(source, metadata, firstMatch, query)
     }
 
@@ -415,26 +320,21 @@ class IndexSearcher(private val context: Context) {
         metadata: IndexMetadata,
         firstMatch: Pair<Int, IndexEntry>,
         query: String
-    ): RangeScanResult {
+    ): List<IndexEntry> {
         val results = mutableListOf<IndexEntry>()
         results.add(firstMatch.second)
-        val uniqueArticles = hashSetOf(firstMatch.second.articleKey())
         var currentIdx = firstMatch.first + 1
         var iterationCount = 0
         while (currentIdx < metadata.totalCount) {
-            if (uniqueArticles.size >= MAX_PREFIX_RESULTS) {
-                return RangeScanResult(results, RangeCursor(query, currentIdx, source.position()))
-            }
             if (iterationCount % 1000 == 0) yield()
             val entry = readEntry(source, metadata)
             val entryWordLower = entry.word.lowercase()
             if (!entryWordLower.startsWith(query)) break
-            uniqueArticles.add(entry.articleKey())
             results.add(entry.copy(word = entryWordLower))
             currentIdx++
             iterationCount++
         }
-        return RangeScanResult(results, null)
+        return results
     }
 
     private fun readPooledString(source: RandomAccessSource, length: Int): String {
@@ -454,11 +354,7 @@ class IndexSearcher(private val context: Context) {
         val originalWord = readPooledString(source, source.readUnsignedShort())
         val offset = ArticleOffset(source.readLong())
         val length = ArticleLength(source.readInt())
-        val isAlias = if (metadata.version >= 6) {
-            source.readUnsignedByte() and ENTRY_FLAG_ALIAS != 0
-        } else {
-            false
-        }
+        val isAlias = metadata.version >= 6 && source.readUnsignedByte() and ENTRY_FLAG_ALIAS != 0
         return IndexEntry(word, originalWord, offset, length, isAlias = isAlias)
     }
 
@@ -472,8 +368,11 @@ class IndexSearcher(private val context: Context) {
 
     private fun openSource(pathOrUri: String): RandomAccessSource {
         val file = File(pathOrUri)
-        if (!file.exists()) throw DictionaryError.FileSystemError.NotFound(pathOrUri)
-        return FileSource(file)
+        return if (file.exists()) {
+            FileSource(file)
+        } else {
+            throw DictionaryError.FileSystemError.NotFound(pathOrUri)
+        }
     }
     private fun openInputStream(pathOrUri: String): java.io.InputStream {
         val file = File(pathOrUri)
@@ -484,7 +383,6 @@ class IndexSearcher(private val context: Context) {
         private const val TAG = "IndexSearcher"
         private const val SUBSTRING_SCAN_MAX_ENTRIES = 200_000
         private const val SPARSE_INTERVAL_V1 = 128
-        private const val MAX_PREFIX_RESULTS = 200
         private const val MAX_SUBSTRING_RESULTS = 100
     }
 }
@@ -589,30 +487,89 @@ interface RandomAccessSource : Closeable {
 }
 class FileSource(file: File) : RandomAccessSource {
     private val raf = RandomAccessFile(file, "r")
+    private val buffer = ByteArray(BUFFER_SIZE)
+    private var bufferStart = 0L
+    private var bufferEnd = 0L
+    private var pos = 0L
 
     override fun seek(pos: Long) {
-        raf.seek(pos)
+        this.pos = pos
     }
 
-    override fun position(): Long = raf.filePointer
+    override fun position(): Long = pos
 
-    override fun readUnsignedByte(): Int = raf.readUnsignedByte()
+    private fun refill(minNeeded: Int): Boolean {
+        if (bufferEnd - pos >= minNeeded) return true
+        bufferStart = pos
+        raf.seek(pos)
+        val read = raf.read(buffer)
+        bufferEnd = bufferStart + maxOf(read, 0)
+        return bufferEnd - pos >= minNeeded
+    }
 
-    override fun readUnsignedShort(): Int = raf.readUnsignedShort()
+    override fun readUnsignedByte(): Int {
+        if (!refill(1)) throw EOFException()
+        return buffer[(pos++ - bufferStart).toInt()].toInt() and 0xFF
+    }
 
-    override fun readInt(): Int = raf.readInt()
+    override fun readUnsignedShort(): Int {
+        if (!refill(2)) throw EOFException()
+        val i = (pos - bufferStart).toInt()
+        pos += 2
+        return (buffer[i].toInt() and 0xFF shl 8) or (buffer[i + 1].toInt() and 0xFF)
+    }
 
-    override fun readLong(): Long = raf.readLong()
+    override fun readInt(): Int {
+        if (!refill(4)) throw EOFException()
+        val i = (pos - bufferStart).toInt()
+        pos += 4
+        return (buffer[i].toInt() shl 24) or
+            (buffer[i + 1].toInt() and 0xFF shl 16) or
+            (buffer[i + 2].toInt() and 0xFF shl 8) or
+            (buffer[i + 3].toInt() and 0xFF)
+    }
+
+    override fun readLong(): Long {
+        if (!refill(8)) throw EOFException()
+        val i = (pos - bufferStart).toInt()
+        pos += 8
+        var value = 0L
+        for (k in 0 until 8) {
+            value = (value shl 8) or (buffer[i + k].toLong() and 0xFF)
+        }
+        return value
+    }
 
     override fun readFully(b: ByteArray) {
-        raf.readFully(b)
+        readFully(b, 0, b.size)
     }
 
     override fun readFully(b: ByteArray, off: Int, len: Int) {
-        raf.readFully(b, off, len)
+        if (len > BUFFER_SIZE / 2) {
+            raf.seek(pos)
+            raf.readFully(b, off, len)
+            pos += len
+            bufferEnd = bufferStart
+            return
+        }
+        var remaining = len
+        var dst = off
+        while (remaining > 0) {
+            if (!refill(1)) throw EOFException()
+            val i = (pos - bufferStart).toInt()
+            val chunk = minOf(remaining, (bufferEnd - pos).toInt())
+            System.arraycopy(buffer, i, b, dst, chunk)
+            pos += chunk
+            dst += chunk
+            remaining -= chunk
+        }
     }
 
     override fun close() {
         raf.close()
     }
+
+    private companion object {
+        private const val BUFFER_SIZE = 64 * 1024
+    }
 }

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

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

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

@@ -22,6 +22,7 @@ import java.io.BufferedInputStream
 import java.io.File
 import java.io.FileInputStream
 import java.io.InputStream
+import java.io.RandomAccessFile
 import java.util.concurrent.CancellationException
 import java.util.zip.GZIPInputStream
 
@@ -51,12 +52,14 @@ class KotlinDictionaryEngine(private val context: Context) : ProgressIndexingEng
 
             val indexFile = File(indexPath)
             val metadata = readMetadata(dictPath)
+            val totalInputBytes = uncompressedInputLength(dictFile)
 
             val articleCount = withContext(Dispatchers.IO) {
                 openDslInputStream(dictPath).use { inputStream ->
                     dslIndexer.createIndex(
                         dslInputStream = inputStream,
                         indexFile = indexFile,
+                        totalInputBytes = totalInputBytes,
                         onProgress = { count ->
                             onArticlesIndexed(count)
                         },
@@ -112,20 +115,20 @@ class KotlinDictionaryEngine(private val context: Context) : ProgressIndexingEng
         maxResults: Int
     ): List<IndexEntry> = withContext(Dispatchers.IO) {
         val allResults = mutableListOf<IndexEntry>()
-        for (dict in dictionaries) {
+        for ((name, path, indexPath, _, _, metadata) in dictionaries) {
             try {
-                val indexPath = resolveIndexPath(dict.indexPath)
-                val entry = indexSearcher.findFirstEntry(indexPath, query)
+                val resolvedIndexPath = resolveIndexPath(indexPath)
+                val entry = indexSearcher.findFirstEntry(resolvedIndexPath, query)
                 if (entry != null) {
-                    allResults.add(entry.withDictionary(dict.metadata.name.ifBlank { dict.name }, dict.path))
+                    allResults.add(entry.withDictionary(metadata.name.ifBlank { name }, path))
                 }
                 if (allResults.size >= maxResults) break
             } catch (e: OutOfMemoryError) {
-                Log.e(TAG, "search() - OOM for ${dict.indexPath}", e)
+                Log.e(TAG, "search() - OOM for $indexPath", e)
                 trimMemory(80)
                 break
             } catch (e: Exception) {
-                Log.w(TAG, "search() - error for ${dict.indexPath}: ${e.message}")
+                Log.w(TAG, "search() - error for $indexPath: ${e.message}")
             }
         }
         allResults
@@ -207,6 +210,30 @@ class KotlinDictionaryEngine(private val context: Context) : ProgressIndexingEng
         }
     }
 
+    private fun uncompressedInputLength(file: File): Long {
+        val name = file.name.lowercase()
+        if (!name.endsWith(".dz") && !name.endsWith(".gz")) return file.length()
+        return readGzipUncompressedLength(file).takeIf { it > 0L } ?: file.length()
+    }
+
+    private fun readGzipUncompressedLength(file: File): Long = try {
+        RandomAccessFile(file, "r").use { raf ->
+            val fileLength = raf.length()
+            if (fileLength < 18L) {
+                -1L
+            } else {
+                raf.seek(fileLength - 4L)
+                val b0 = raf.readUnsignedByte()
+                val b1 = raf.readUnsignedByte()
+                val b2 = raf.readUnsignedByte()
+                val b3 = raf.readUnsignedByte()
+                (b0 or (b1 shl 8) or (b2 shl 16) or (b3 shl 24)).toLong() and 0xFFFFFFFFL
+            }
+        }
+    } catch (_: Exception) {
+        -1L
+    }
+
     private fun resolveIndexPath(indexArg: String): String {
         val candidate = File(indexArg)
         if (candidate.exists()) return candidate.absolutePath

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

@@ -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() {
@@ -186,67 +182,65 @@ class LocalDictionaryRepository(
                 progressTracker = ProgressTracker(filesToScan)
 
                 existingDictionaries.forEach { dict ->
-                    progressTracker?.updateFileProgress(dict.name, 1.0f)
+                    progressTracker?.updateFileProgress(File(dict.path).name, 1.0f)
                 }
 
                 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)
@@ -396,12 +390,15 @@ class LocalDictionaryRepository(
         } ?: emptyList()
     }
 
-    private fun isDictionaryPayloadFile(file: File): Boolean =
-        file.isFile && (
-            file.name.endsWith(".dsl") ||
-                file.name.endsWith(".dsl.dz") ||
-                file.name.endsWith(".dsl.gz")
-            )
+    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())
@@ -541,12 +538,12 @@ class LocalDictionaryRepository(
             val dictionaries = mutableDictionaries.value
             if (dictionaries.isEmpty()) return@withContext
 
-            for (dict in dictionaries) {
+            for ((_, _, indexPath) in dictionaries) {
                 try {
-                    val indexPath = resolveIndexPath(dict.indexPath)
+                    val resolvedIndexPath = resolveIndexPath(indexPath)
                     val indexSearcher = engine.getIndexSearcher()
-                    if (!indexSearcher.isMetadataLoaded(indexPath)) {
-                        engine.preloadIndexMetadata(indexPath)
+                    if (!indexSearcher.isMetadataLoaded(resolvedIndexPath)) {
+                        engine.preloadIndexMetadata(resolvedIndexPath)
                     }
                     yield()
                 } catch (_: Exception) { /* Ignore preload failure */ }

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

@@ -41,12 +41,30 @@ 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
+
+    private suspend fun expireErrorStateToIdle() {
+        delay(TERMINAL_STATE_DURATION)
+        if (downloadState.value is DownloadState.Error) {
+            updateDownloadProgressState(DownloadState.Idle, 0f)
+        }
     }
 
     fun startDownload() {
         if (downloadState.value is DownloadState.Loading) return
         if (!downloadScope.isActive) return
+        onFlowStarted?.invoke()
         cancelCleanupJob = null
+        updateDownloadProgressState(DownloadState.Loading, 0f)
         downloadJob = downloadScope.launch {
             mutex.withLock {
                 try {
@@ -68,11 +86,10 @@ class DownloadManager(
                         updateDownloadProgressState(
                             DownloadState.Error(sourceUnavailableMessage), 0f
                         )
+                        expireErrorStateToIdle()
                         return@withLock
                     }
 
-                    updateDownloadProgressState(DownloadState.Loading, 0f)
-
                     var lastReportedProgressBucket = -1
                     val result = ReSearchTrace.asyncSection(ReSearchTrace.DICTIONARY_DOWNLOAD) {
                         dictionaryRepository.downloadSources(downloadableSources) { progress ->
@@ -126,6 +143,7 @@ class DownloadManager(
                             }
 
                         }
+                        expireErrorStateToIdle()
                     }
                 } finally {
                     downloadJob = null
@@ -137,7 +155,9 @@ class DownloadManager(
     fun startDownloadForSources(sourceUrls: List<String>) {
         if (downloadState.value is DownloadState.Loading) return
         if (!downloadScope.isActive) return
+        onFlowStarted?.invoke()
         cancelCleanupJob = null
+        updateDownloadProgressState(DownloadState.Loading, 0f)
         downloadJob = downloadScope.launch {
             mutex.withLock {
                 try {
@@ -163,11 +183,10 @@ class DownloadManager(
                         updateDownloadProgressState(
                             DownloadState.Error(sourceUnavailableMessage), 0f
                         )
+                        expireErrorStateToIdle()
                         return@withLock
                     }
 
-                    updateDownloadProgressState(DownloadState.Loading, 0f)
-
                     var lastReportedProgressBucket = -1
                     val result = ReSearchTrace.asyncSection(ReSearchTrace.DICTIONARY_DOWNLOAD) {
                         dictionaryRepository.downloadSources(downloadableSources) { progress ->
@@ -221,6 +240,7 @@ class DownloadManager(
                             }
 
                         }
+                        expireErrorStateToIdle()
                     }
                 } finally {
                     downloadJob = null

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

@@ -11,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

@@ -7,6 +7,7 @@ import com.example.research.common.util.FileStorageManager
 import com.example.research.common.util.DocumentFileInfo
 import com.example.research.core.domain.model.DictionarySource
 import com.example.research.feature.download.config.DictionaryConfig
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import okhttp3.OkHttpClient
@@ -49,45 +50,36 @@ class DictionaryChecker(
         }
     }
 
-    suspend fun areDictionariesUpToDate(
+    suspend fun sourcesWithUpdates(
         folderUri: Uri,
         sources: List<DictionarySource>,
         files: List<DocumentFileInfo>? = null
-    ): Boolean = withContext(Dispatchers.IO) {
+    ): Set<String> = withContext(Dispatchers.IO) {
         try {
-            val enabledSources = sources.filter { it.isEnabled }
-            if (enabledSources.isEmpty()) {
-                return@withContext true
-            }
-
             val currentDate = DateUtils.getCurrentDateString()
             val previousDate = DateUtils.getPreviousDateString()
             val dictFiles = getDictFiles(folderUri, files)
-
-            val allHaveToday = enabledSources.all { source ->
-                dictFiles.hasFileForSource(source, currentDate)
-            }
-
-            if (allHaveToday) {
-                return@withContext true
-            }
-
-            val allHaveYesterday = enabledSources.all { source ->
-                dictFiles.hasFileForSource(source, previousDate)
-            }
-
-            if (allHaveYesterday) {
-                val serverHasToday = enabledSources.any { source ->
-                    isSourceAvailableOnServer(source, currentDate)
+            sources
+                .filter { it.isEnabled && DictionarySource.hasDatePlaceholder(it.urlTemplate) }
+                .filter { source ->
+                    when {
+                        dictFiles.hasFileForSource(source, currentDate) -> false
+                        dictFiles.hasFileForSource(source, previousDate) ->
+                            isSourceAvailableOnServer(source, currentDate)
+                        else -> when (probeSource(source, currentDate)) {
+                            SourceAvailability.AVAILABLE -> true
+                            SourceAvailability.NOT_FOUND ->
+                                probeSource(source, previousDate) == SourceAvailability.AVAILABLE
+                            SourceAvailability.UNKNOWN -> false
+                        }
+                    }
                 }
-
-                return@withContext !serverHasToday
-            }
-
-            false
+                .mapTo(mutableSetOf(), DictionarySource::id)
+        } catch (e: CancellationException) {
+            throw e
         } catch (e: Exception) {
             Log.e(TAG, "Error checking currency: ${e.message}", e)
-            false
+            emptySet()
         }
     }
 

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

@@ -54,17 +54,17 @@ class DictionaryCleaner(
         for ((prefix, items) in parsedByPrefix) {
             val latestDsl = latestDslDateByPrefix[prefix] ?: continue
             val dslDates = dslDatesByPrefix[prefix].orEmpty()
-            for (item in items) {
-                if (DateUtils.isDateBefore(item.date, latestDsl)) {
-                    toDelete.add(item.name)
+            for ((name, _, date, ext) in items) {
+                if (DateUtils.isDateBefore(date, latestDsl)) {
+                    toDelete.add(name)
                     continue
                 }
-                if (item.ext in indexExtensions && item.date != latestDsl) {
-                    toDelete.add(item.name)
+                if (ext in indexExtensions && date != latestDsl) {
+                    toDelete.add(name)
                     continue
                 }
-                if (item.ext in indexExtensions && item.date !in dslDates) {
-                    toDelete.add(item.name)
+                if (ext in indexExtensions && date !in dslDates) {
+                    toDelete.add(name)
                 }
             }
         }

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,20 +61,22 @@ class DictionaryDownloader(
     ) {
         if (fileUri == null) return
 
-        runCatching {
-            val fileToDelete = fileStorageManager.getDocumentFile(fileUri)
-            if (fileToDelete != null && fileToDelete.exists()) {
-                val deleted = fileStorageManager.forceDeleteFile(fileToDelete, fileName)
-                if (!deleted) {
-                    fileStorageManager.forceDeleteFileByName(folderUri, fileName)
-                }
-            }
-        }.onFailure { e ->
-            Log.e(TAG, "Failed to delete partial file: $fileUri", e)
+        withContext(NonCancellable) {
             runCatching {
-                fileStorageManager.forceDeleteFileByName(folderUri, fileName)
-            }.onFailure { deleteError ->
-                Log.e(TAG, "Failed to delete file by name: $fileName", deleteError)
+                val fileToDelete = fileStorageManager.getDocumentFile(fileUri)
+                if (fileToDelete != null && fileToDelete.exists()) {
+                    val deleted = fileStorageManager.forceDeleteFile(fileToDelete, fileName)
+                    if (!deleted) {
+                        fileStorageManager.forceDeleteFileByName(folderUri, fileName)
+                    }
+                }
+            }.onFailure { e ->
+                Log.e(TAG, "Failed to delete partial file: $fileUri", e)
+                runCatching {
+                    fileStorageManager.forceDeleteFileByName(folderUri, fileName)
+                }.onFailure { deleteError ->
+                    Log.e(TAG, "Failed to delete file by name: $fileName", deleteError)
+                }
             }
         }
     }
@@ -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

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(
@@ -44,14 +46,13 @@ class DictionaryExtractor(
                 reportProgress(processedIndex.toFloat() / totalFiles)
             }
 
-            for (file in gzFiles) {
-                val fileName = file.name
+            for ((fileName, uri) in gzFiles) {
                 val baseName = fileName.dropLast(DictionaryConfig.GZ_EXTENSION.length)
                 val lowerBaseName = baseName.lowercase()
                 if (baseName.isBlank() ||
                     lowerBaseName.endsWith(DictionaryConfig.GZ_EXTENSION) ||
                     lowerBaseName.endsWith(".txt")) {
-                    ArchiveUtils.deleteFile(context, file.uri)
+                    ArchiveUtils.deleteFile(context, uri)
                     markFileProcessed()
                     continue
                 }
@@ -63,19 +64,19 @@ class DictionaryExtractor(
                 val dslFileName = "$dslBaseName${DictionaryConfig.DSL_EXTENSION}"
                 val existingDslFile = fileStorageManager.findFile(folderUri, dslFileName)
                 if (existingDslFile != null && existingDslFile.exists()) {
-                    ArchiveUtils.deleteFile(context, file.uri)
+                    ArchiveUtils.deleteFile(context, uri)
                     markFileProcessed()
                     continue
                 }
                 val dslUri = fileStorageManager.createFileInFolder(folderUri, dslFileName, overwrite = false)
                     ?: continue
-                val extractResult = ArchiveUtils.extractGzWithBom(context, file.uri, dslUri)
+                val extractResult = ArchiveUtils.extractGzWithBom(context, uri, dslUri)
                 if (extractResult.isSuccess) {
                     val extractedFile = fileStorageManager.getDocumentFile(dslUri)
                     if (extractedFile != null && extractedFile.exists()) {
                         if (extractedFile.length() == 0L) {
                             ArchiveUtils.deleteFile(context, dslUri)
-                            ArchiveUtils.deleteFile(context, file.uri)
+                            ArchiveUtils.deleteFile(context, uri)
                             markFileProcessed()
                             continue
                         }
@@ -90,7 +91,7 @@ class DictionaryExtractor(
                             ArchiveUtils.deleteFile(context, dslUri)
                         }
                     }
-                    ArchiveUtils.deleteFile(context, file.uri)
+                    ArchiveUtils.deleteFile(context, uri)
                 } else {
                     Log.e("DictionaryExtractor", "File extraction error: $fileName")
                     ArchiveUtils.deleteFile(context, dslUri)
@@ -98,12 +99,11 @@ class DictionaryExtractor(
                 markFileProcessed()
             }
 
-            for (file in rawDslFiles) {
-                val dslFileName = file.name
+            for ((dslFileName, uri) in rawDslFiles) {
                 val dzFileName = "$dslFileName.dz"
                 val existingDz = fileStorageManager.findFile(folderUri, dzFileName)
                 if (existingDz != null && existingDz.exists()) {
-                    ArchiveUtils.deleteFile(context, file.uri)
+                    ArchiveUtils.deleteFile(context, uri)
                     markFileProcessed()
                     continue
                 }
@@ -111,11 +111,11 @@ class DictionaryExtractor(
                 val fileBaseProgress = processedIndex.toFloat() / totalFiles
                 val fileProgressWeight = 1f / totalFiles
                 reportProgress(fileBaseProgress)
-                val compressResult = ensureDslDictZip(file.uri, dslFileName, folderUri) { compressProgress ->
+                val compressResult = ensureDslDictZip(uri, dslFileName, folderUri) { compressProgress ->
                     reportProgress(fileBaseProgress + (compressProgress * fileProgressWeight))
                 }
                 if (compressResult.isSuccess) {
-                    ArchiveUtils.deleteFile(context, file.uri)
+                    ArchiveUtils.deleteFile(context, uri)
                 }
                 markFileProcessed()
             }
@@ -128,21 +128,48 @@ class DictionaryExtractor(
                     !lowerName.endsWith(DictionaryConfig.DICTZIP_EXTENSION) &&
                     !lowerName.endsWith(".dsl.gz")
             }
-            for (file in remainingRawDslFiles) {
-                val dslFileName = file.name
-                val compressResult = ensureDslDictZip(file.uri, dslFileName, folderUri, onProgress = null)
+            for ((dslFileName, uri) in remainingRawDslFiles) {
+                val compressResult = ensureDslDictZip(uri, dslFileName, folderUri, onProgress = null)
                 if (compressResult.isSuccess) {
-                    ArchiveUtils.deleteFile(context, file.uri)
+                    ArchiveUtils.deleteFile(context, uri)
                 }
             }
 
             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 ((name, uri) in files) {
+                    val n = 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, uri)
+                        isRawDsl -> {
+                            val pair = fileStorageManager.findFile(folderUri, "$name.dz")
+                            if (pair == null || !pair.exists()) {
+                                ArchiveUtils.deleteFile(context, uri)
+                            }
+                        }
+                    }
+                }
+            }
+        } catch (_: Exception) {
+        }
+    }
+
     private suspend fun ensureDslDictZip(
         dslUri: Uri,
         dslFileName: String,

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

@@ -25,21 +25,20 @@ class DictionaryRepository(
     private val extractor = DictionaryExtractor(context, fileStorageManager)
     private val cleaner = DictionaryCleaner(context, fileStorageManager)
 
-    private var filesBeforeDownload = mutableSetOf<String>()
-    private var downloadedPrefixes = mutableSetOf<String>()
+    private class DownloadSession(val filesBefore: Set<String>, val prefixes: Set<String>)
+
+    @Volatile
+    private var session: DownloadSession? = null
 
     companion object {
         private const val TAG = "DictionaryRepository"
     }
 
-    suspend fun areDictionariesUpToDate(
-        sources: List<DictionarySource>? = null
-    ): Boolean = withContext(Dispatchers.IO) {
-        val folderUri = preferencesManager.dictionaryPath
-        val uri = Uri.fromFile(File(folderUri))
-        val files = fileStorageManager.listFilesInFolder(uri)
-        val sourcesToCheck = sources ?: preferencesManager.dictionarySources.first()
-        checker.areDictionariesUpToDate(uri, sourcesToCheck, files)
+    suspend fun sourcesWithUpdates(
+        sources: List<DictionarySource>
+    ): Set<String> = withContext(Dispatchers.IO) {
+        val uri = Uri.fromFile(File(preferencesManager.dictionaryPath))
+        checker.sourcesWithUpdates(uri, sources, fileStorageManager.listFilesInFolder(uri))
     }
 
     suspend fun getEnabledSources(sourceUrls: List<String>? = null): List<DictionarySource> =
@@ -81,15 +80,10 @@ class DictionaryRepository(
         val files = fileStorageManager.listFilesInFolder(uri)
         cleaner.deleteCorruptedArchives(uri, files)
 
-        synchronized(filesBeforeDownload) {
-            filesBeforeDownload = files.map { it.name }.toMutableSet()
-        }
-
-        synchronized(downloadedPrefixes) {
-            downloadedPrefixes = sources.mapNotNull {
-                DictionarySource.extractPrefix(it.urlTemplate)
-            }.toMutableSet()
-        }
+        session = DownloadSession(
+            filesBefore = files.mapTo(mutableSetOf()) { it.name },
+            prefixes = sources.mapNotNullTo(mutableSetOf()) { DictionarySource.extractPrefix(it.urlTemplate) },
+        )
 
         downloader.downloadDictionaries(
             folderUri = uri,
@@ -114,64 +108,22 @@ class DictionaryRepository(
 
         cleaner.deleteUnprocessedFiles(uri, files)
 
-        val filesAfterStandardCleanup = fileStorageManager.listFilesInFolder(uri)
+        val current = session ?: return@withContext Result.success(Unit)
+        session = null
 
-        val existingFiles = synchronized(filesBeforeDownload) {
-            filesBeforeDownload.toSet()
-        }
-
-        val prefixes = synchronized(downloadedPrefixes) {
-            downloadedPrefixes.toSet()
-        }
-
-        val finalPrefixes = prefixes.ifEmpty {
-            val sources = preferencesManager.dictionarySources.first()
-            sources.mapNotNull { DictionarySource.extractPrefix(it.urlTemplate) }.toSet()
-        }
-
-        val filesToDelete = if (existingFiles.isEmpty()) {
-            filesAfterStandardCleanup.filter { file ->
-                val fileName = file.name
-                finalPrefixes.any { prefix -> fileName.startsWith("${prefix}_") }
+        fileStorageManager.listFilesInFolder(uri)
+            .filter { file ->
+                file.name !in current.filesBefore &&
+                    current.prefixes.any { prefix -> file.name.startsWith("${prefix}_") }
             }
-        } else {
-            filesAfterStandardCleanup.filter { file ->
-                file.name !in existingFiles &&
-                finalPrefixes.any { prefix -> file.name.startsWith("${prefix}_") }
-            }
-        }
-
-        if (filesToDelete.isNotEmpty()) {
-            var deletedCount = 0
-
-            for (file in filesToDelete) {
-                val fileName = file.name
-                val docFile = fileStorageManager.getDocumentFile(file.uri)
-                if (docFile != null && docFile.exists()) {
-                    val deleted = docFile.delete()
-                    if (deleted) {
-                        deletedCount++
-                    } else {
-                        val forceDeleted = fileStorageManager.forceDeleteFile(docFile, fileName)
-                        if (!forceDeleted) {
-                            Log.e(TAG, "deleteUnprocessedFiles() - force delete failed for: $fileName")
-                        } else {
-                            deletedCount++
-                        }
-                    }
+            .forEach { (fileName, fileUri) ->
+                val docFile = fileStorageManager.getDocumentFile(fileUri)
+                if (docFile != null && docFile.exists() && !docFile.delete() &&
+                    !fileStorageManager.forceDeleteFile(docFile, fileName)
+                ) {
+                    Log.e(TAG, "deleteUnprocessedFiles() - force delete failed for: $fileName")
                 }
             }
-        }
-
-        synchronized(filesBeforeDownload) {
-            if (filesBeforeDownload.isNotEmpty()) {
-                filesBeforeDownload.clear()
-            }
-        }
-
-        synchronized(downloadedPrefixes) {
-            downloadedPrefixes.clear()
-        }
 
         Result.success(Unit)
     }
@@ -184,15 +136,7 @@ class DictionaryRepository(
         val prefixes = sources.mapNotNull { DictionarySource.extractPrefix(it.urlTemplate) }.toSet()
         
         val result = cleaner.performAllCleanup(uri, prefixes, files)
-
-        synchronized(filesBeforeDownload) {
-            filesBeforeDownload.clear()
-        }
-
-        synchronized(downloadedPrefixes) {
-            downloadedPrefixes.clear()
-        }
-
+        session = null
         result
     }
 }

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() {
@@ -244,20 +88,31 @@ class DictionaryForegroundService : Service() {
         stopForTimeout(startId)
     }
 
+    override fun onTaskRemoved(rootIntent: Intent?) {
+        cancelAllWork()
+        ServiceCompat.stopForeground(this, ServiceCompat.STOP_FOREGROUND_REMOVE)
+        stopSelf()
+    }
+
     override fun onTimeout(startId: Int, fgsType: Int) {
         stopForTimeout(startId)
     }
 
     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 +130,16 @@ class DictionaryForegroundService : Service() {
             ACTION_IMPORT -> {
                 startForegroundService()
             }
+            ACTION_FINISH -> {
+                stopForegroundService(removeNotification = true)
+            }
             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

@@ -10,11 +10,13 @@ import com.example.research.core.util.onError
 import com.example.research.core.util.onSuccess
 import com.example.research.core.util.sanitizeQuery
 import com.example.research.data.paging.IndexEntryPagingSource
+import com.example.research.data.local.preferences.PreferencesManager
 import com.example.research.data.repository.LocalDictionaryRepository
 import com.example.research.ui.article.ArticleState
 import com.example.research.ui.article.ArticleTextWarmUp
-import com.example.research.ui.article.DslBlock
 import com.example.research.ui.article.DslAnnotatedParser
+import com.example.research.ui.article.HEAVY_ARTICLE_BLOCK_COUNT
+import com.example.research.ui.article.mergeDslBlocks
 import com.example.research.R
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.*
@@ -28,12 +30,12 @@ sealed interface SearchAction {
     data class ArticleClicked(val entry: IndexEntry) : SearchAction
     data object ClearArticle : SearchAction
     data class SearchAndLoadArticle(val word: String) : SearchAction
-    data class HandleExternalSearch(val text: String) : SearchAction
 }
 
 class SearchViewModel(
     application: Application,
     private val repository: LocalDictionaryRepository,
+    private val preferencesManager: PreferencesManager,
     private val savedStateHandle: SavedStateHandle
 ) : AndroidViewModel(application) {
 
@@ -51,20 +53,29 @@ class SearchViewModel(
     private val mutableErrorMessage = MutableStateFlow<String?>(null)
     val errorMessage: StateFlow<String?> = mutableErrorMessage.asStateFlow()
 
+    val searchHistory: StateFlow<List<String>> = preferencesManager.searchHistory
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5000),
+            initialValue = emptyList()
+        )
+
     private val indexSearcher by lazy { repository.getIndexSearcher() }
     private var indexWarmupJob: Job? = null
     private var debounceSaveQueryJob: Job? = null
 
-    private val parseCache = java.util.LinkedHashMap<String, List<DslBlock>>(PARSE_CACHE_SIZE, 0.75f, true)
+    private val parseCache = java.util.LinkedHashMap<String, ArticleState.Success>(PARSE_CACHE_SIZE, 0.75f, true)
     private val articleHistory = ArrayDeque<ArticleState.Success>()
 
     private val activeDictionaries: StateFlow<List<com.example.research.core.domain.model.Dictionary>> =
         repository.dictionaries.map { dictList ->
             dictList.filter { it.isActive }
+        }.distinctUntilChanged { previous, current ->
+            previous.map { it.indexPath } == current.map { it.indexPath }
         }.stateIn(
             scope = viewModelScope,
             started = SharingStarted.WhileSubscribed(5000),
-            initialValue = emptyList()
+            initialValue = repository.dictionaries.value.filter { it.isActive }
         )
 
     init {
@@ -101,9 +112,7 @@ class SearchViewModel(
             Pager(
                 config = PagingConfig(
                     pageSize = 12,
-                    prefetchDistance = 1,
-                    enablePlaceholders = false,
-                    initialLoadSize = 12
+                    enablePlaceholders = false
                 ),
                 pagingSourceFactory = {
                     IndexEntryPagingSource(
@@ -122,20 +131,24 @@ class SearchViewModel(
             SearchAction.ClearQuery -> {
                 mutableSearchQuery.value = ""
                 savedStateHandle[KEY_SEARCH_QUERY] = ""
+                clearArticle()
             }
             is SearchAction.ArticleClicked -> {
                 articleHistory.clear()
+                recordSearchHistory(action.entry.originalWord)
                 loadArticle(action.entry)
             }
             SearchAction.ClearArticle -> clearArticle()
             is SearchAction.SearchAndLoadArticle -> searchAndLoadArticle(action.word)
-            is SearchAction.HandleExternalSearch -> handleExternalSearch(action.text)
         }
     }
 
     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 {
@@ -155,6 +168,27 @@ class SearchViewModel(
         mutableErrorMessage.value = null
     }
 
+    fun removeSearchHistoryEntry(query: String) {
+        viewModelScope.launch {
+            preferencesManager.removeSearchHistoryEntry(query)
+        }
+    }
+
+    fun clearSearchHistory() {
+        viewModelScope.launch {
+            preferencesManager.clearSearchHistory()
+        }
+    }
+
+    private fun recordSearchHistory(query: String) {
+        val trimmed = query.trim()
+        if (trimmed.isBlank()) return
+        if (searchHistory.value.firstOrNull() == trimmed) return
+        viewModelScope.launch {
+            preferencesManager.addSearchHistoryEntry(trimmed)
+        }
+    }
+
     fun saveScrollPosition(index: Int, offset: Int) {
         mutableScrollPosition.value = index to offset
     }
@@ -176,12 +210,7 @@ class SearchViewModel(
             val cached = synchronized(parseCache) { parseCache[cacheKey] }
             if (cached != null) {
                 mutableSelectedArticle.update {
-                    ArticleState.Success(
-                        title = entry.originalWord,
-                        dslContent = cached,
-                        dictionaryName = entry.dictionaryName,
-                        dictionaryPath = entry.dictionaryPath,
-                    )
+                    cached.copy(title = entry.originalWord, dictionaryName = entry.dictionaryName)
                 }
                 return@launch
             }
@@ -193,6 +222,13 @@ class SearchViewModel(
                             colorScheme = DslAnnotatedParser.ARTICLE_COLOR_SCHEME,
                         )
                     }
+                    val article = ArticleState.Success(
+                        title = entry.originalWord,
+                        dslContent = mergeDslBlocks(annotatedStringList),
+                        dictionaryName = entry.dictionaryName,
+                        dictionaryPath = entry.dictionaryPath,
+                        isHeavy = annotatedStringList.size > HEAVY_ARTICLE_BLOCK_COUNT,
+                    )
                     synchronized(parseCache) {
                         if (parseCache.size >= PARSE_CACHE_SIZE) {
                             val iterator = parseCache.entries.iterator()
@@ -200,19 +236,12 @@ class SearchViewModel(
                                 iterator.next().run { iterator.remove() }
                             }
                         }
-                        parseCache[cacheKey] = annotatedStringList
+                        parseCache[cacheKey] = article
                     }
                     viewModelScope.launch(Dispatchers.Default) {
-                        ArticleTextWarmUp.warmUp(getApplication(), annotatedStringList)
-                    }
-                    mutableSelectedArticle.update {
-                        ArticleState.Success(
-                            title = entry.originalWord,
-                            dslContent = annotatedStringList,
-                            dictionaryName = entry.dictionaryName,
-                            dictionaryPath = entry.dictionaryPath,
-                        )
+                        ArticleTextWarmUp.warmUp(getApplication(), article.dslContent)
                     }
+                    mutableSelectedArticle.update { article }
                 }
                 .onError { message, exception ->
                     Log.e(TAG, "loadArticle() - error: $message", exception)
@@ -277,6 +306,7 @@ class SearchViewModel(
                 }
                 entry?.let {
                     currentArticle?.let(articleHistory::addLast)
+                    recordSearchHistory(sanitizedWord)
                     loadArticle(it)
                 }
             }.onError { message, exception ->
@@ -285,21 +315,9 @@ class SearchViewModel(
         }
     }
 
-    fun handleExternalSearch(text: String) {
-        viewModelScope.launch {
-            val sanitizedText = text.sanitizeQuery()
-            mutableSearchQuery.value = sanitizedText
-            searchAndLoadArticle(sanitizedText)
-        }
-    }
-
     companion object {
         private const val TAG = "SearchViewModel"
 
-        // Parse cache: stores parsed DslBlock lists to avoid re-parsing articles
-        // Size: 50 articles - typical user navigation depth in a session
-        // Memory estimate: ~50KB per article average (text + formatting)
-        // Total: ~2.5MB worst case
         private const val PARSE_CACHE_SIZE = 50
 
         private const val KEY_SEARCH_QUERY = "search_query"

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

@@ -2,9 +2,11 @@ package com.example.research.ui.about
 
 import android.content.Context
 import androidx.annotation.RawRes
+import kotlinx.serialization.ExperimentalSerializationApi
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.decodeFromStream
 
 @Serializable
 internal data class AboutLibrariesData(
@@ -74,8 +76,8 @@ internal object AboutLibrariesParser {
         ignoreUnknownKeys = true
     }
 
+    @OptIn(ExperimentalSerializationApi::class)
     fun read(context: Context, @RawRes resourceId: Int): AboutLibrariesData =
         context.resources.openRawResource(resourceId)
-            .bufferedReader()
-            .use { reader -> json.decodeFromString(reader.readText()) }
+            .use { stream -> json.decodeFromStream(stream) }
 }

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

@@ -1,22 +1,24 @@
 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.ExperimentalMaterial3Api
-import androidx.compose.material3.Icon
-import androidx.compose.material3.IconButton
+import androidx.compose.material3.AlertDialogDefaults
+import androidx.compose.material3.BasicAlertDialog
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.Surface
@@ -25,26 +27,34 @@ 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.LocalContext
+import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.platform.LocalUriHandler
+import androidx.compose.ui.platform.LocalWindowInfo
 import androidx.compose.ui.platform.testTag
-import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.semantics.testTagsAsResourceId
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import com.example.research.R
+import com.example.research.common.ui.AppBackButton
 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
 fun AboutScreen(
     onNavigateBack: () -> Unit
@@ -57,23 +67,32 @@ fun AboutScreen(
     }
     val versionName = packageInfo?.versionName ?: stringResource(R.string.version_unknown)
     val uriHandler = LocalUriHandler.current
-    val librariesData = remember(context) {
-        AboutLibrariesParser.read(context, R.raw.aboutlibraries)
+    val librariesData by produceState<AboutLibrariesData?>(initialValue = null, context) {
+        value = withContext(Dispatchers.IO) {
+            runCatching { AboutLibrariesParser.read(context, R.raw.aboutlibraries) }.getOrNull()
+        }
     }
     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 = {
             TopAppBar(
                 title = { Text(stringResource(R.string.about_app_title)) },
                 navigationIcon = {
-                    IconButton(onClick = onNavigateBack) {
-                        Icon(
-                            painter = painterResource(R.drawable.ic_arrow_back),
-                            contentDescription = stringResource(R.string.action_back)
-                        )
-                    }
+                    AppBackButton(
+                        onClick = onNavigateBack,
+                        modifier = Modifier.padding(start = 6.dp)
+                    )
                 },
                 colors = TopAppBarDefaults.topAppBarColors(
                     containerColor = MaterialTheme.colorScheme.surface
@@ -89,24 +108,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 },
                 )
             }
@@ -139,13 +154,14 @@ private fun AboutHeader(versionName: String) {
             Text(
                 text = stringResource(R.string.app_name),
                 style = MaterialTheme.typography.headlineMedium,
-                color = MaterialTheme.colorScheme.onSurface
+                color = MaterialTheme.colorScheme.onSurface,
+                modifier = Modifier.alignByBaseline()
             )
             Text(
-                text = stringResource(R.string.version_format, versionName),
+                text = versionName,
                 style = MaterialTheme.typography.titleMedium,
                 color = MaterialTheme.colorScheme.onSurfaceVariant,
-                modifier = Modifier.padding(bottom = 2.dp)
+                modifier = Modifier.alignByBaseline()
             )
         }
 
@@ -164,35 +180,39 @@ 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(
@@ -294,26 +314,74 @@ private fun LicenseDialog(
     onDismiss: () -> Unit,
     onOpenWebsite: (String) -> Unit,
 ) {
-    AlertDialog(
-        onDismissRequest = onDismiss,
-        title = { Text(license.name) },
-        text = {
-            Text(
-                text = license.content ?: stringResource(R.string.license_text_unavailable),
-                modifier = Modifier.verticalScroll(rememberScrollState())
-            )
-        },
-        confirmButton = {
-            TextButton(onClick = onDismiss) {
-                Text(stringResource(R.string.action_close))
-            }
-        },
-        dismissButton = {
-            license.url?.takeIf(String::isNotBlank)?.let { url ->
-                TextButton(onClick = { onOpenWebsite(url) }) {
-                    Text(stringResource(R.string.website))
+    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 = with(LocalDensity.current) {
+            LocalWindowInfo.current.containerSize.height.toDp()
+        } - 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),
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    modifier = Modifier
+                        .weight(1f, fill = false)
+                        .verticalScroll(rememberScrollState())
+                )
+                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/ArticleLinkText.kt

@@ -196,9 +196,7 @@ private suspend fun PointerInputScope.detectReferenceTaps(
             if (change == null) {
                 break
             }
-            if (change.isConsumed ||
-                (change.position - downPosition).getDistance() > viewConfiguration.touchSlop
-            ) {
+            if ((change.position - downPosition).getDistance() > viewConfiguration.touchSlop) {
                 canceled = true
             }
             if (!change.pressed) {

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

@@ -1,52 +1,58 @@
 package com.example.research.ui.article
 
 import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.text.selection.SelectionContainer
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.offset
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.windowInsetsPadding
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.itemsIndexed
 import androidx.compose.foundation.lazy.rememberLazyListState
-import androidx.compose.material3.*
-import androidx.compose.runtime.*
+import androidx.compose.foundation.text.selection.SelectionContainer
+import androidx.compose.material3.Button
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.key
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.snapshotFlow
+import androidx.compose.runtime.withFrameNanos
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.luminance
 import androidx.compose.ui.layout.onSizeChanged
+import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.platform.testTag
-import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.semantics.testTagsAsResourceId
-import androidx.compose.ui.unit.dp
+import androidx.compose.ui.text.style.LineHeightStyle
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.IntSize
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.compose.ui.unit.dp
 import com.example.research.R
+import com.example.research.common.ui.AppBackButton
 import com.example.research.common.ui.theme.dictionaryTitleLarge
-import com.example.research.feature.search.SearchAction
-import com.example.research.ui.theme.Spacing
 import com.example.research.ui.theme.AppWindowInsets
-import com.example.research.feature.search.SearchViewModel
-import androidx.compose.runtime.getValue
-
-@Composable
-fun ArticleRoute(
-    searchViewModel: SearchViewModel,
-    onNavigateBack: () -> Unit
-) {
-    val articleState by searchViewModel.selectedArticle.collectAsStateWithLifecycle()
-
-    ArticleScreen(
-        articleState = articleState,
-        onNavigateBack = onNavigateBack,
-        onRefClick = { word ->
-            searchViewModel.onAction(SearchAction.SearchAndLoadArticle(word))
-        },
-        onScrollPositionChanged = { index, offset ->
-            searchViewModel.updateArticleScrollPosition(index, offset)
-        },
-    )
-}
+import com.example.research.ui.theme.Spacing
 
 @Composable
 fun ArticleContent(
@@ -62,9 +68,17 @@ fun ArticleContent(
         }
         is ArticleState.Success -> {
             val articleSaveKey = "${articleState.dictionaryPath}:${articleState.title}"
-            val baseTextStyle = MaterialTheme.typography.bodyLarge.copy(
-                color = MaterialTheme.colorScheme.onSurface
-            )
+            val colorScheme = MaterialTheme.colorScheme
+            val typography = MaterialTheme.typography
+            val baseTextStyle = remember(colorScheme, typography) {
+                typography.bodyLarge.copy(
+                    color = colorScheme.onSurface,
+                    lineHeightStyle = LineHeightStyle(
+                        alignment = LineHeightStyle.Alignment.Proportional,
+                        trim = LineHeightStyle.Trim.Both,
+                    ),
+                )
+            }
             val indentStep = 16.dp
 
             // Use scroll position from ArticleState if available (for back navigation)
@@ -120,38 +134,42 @@ fun ArticleContent(
                 }
             }
 
-            val isHeavyArticle =
-                articleState.dslContent.size > HEAVY_ARTICLE_BLOCK_COUNT
+            val isHeavyArticle = articleState.isHeavy
 
-            LazyColumn(
-                state = listState,
-                modifier = modifier
-                    .fillMaxSize()
-                    .onSizeChanged { viewportSize = it }
-                    .windowInsetsPadding(AppWindowInsets.horizontalSafeDrawing)
-                    .padding(end = 16.dp)
-                    .testTag("article_content")
-                    .semantics {
-                        testTagsAsResourceId = true
-                    }
+            val darkTheme = MaterialTheme.colorScheme.background.luminance() < 0.5f
+            val displayBlocks = remember(
+                articleState.dslContent,
+                baseTextStyle,
+                darkTheme
             ) {
-                itemsIndexed(
-                    items = articleState.dslContent,
-                    key = { index, _ ->
-                        // Use stable key combining article save key and index
-                        "$articleSaveKey:$index"
-                    },
-                    contentType = { _, _ -> "article_block" }
-                ) { index, block ->
-                    val followedByContinuation =
-                        articleState.dslContent.getOrNull(index + 1)?.continuesPrevious == true
-                    val textContent = @Composable {
+                if (darkTheme) {
+                    articleState.dslContent.map {
+                        it.copy(text = DslAnnotatedParser.remapForDarkTheme(it.text))
+                    }
+                } else {
+                    articleState.dslContent
+                }
+            }
+            val articleList: @Composable (Modifier) -> Unit = { listModifier ->
+                LazyColumn(
+                    state = listState,
+                    contentPadding = PaddingValues(top = Spacing.listItemVertical),
+                    modifier = listModifier
+                        .testTag("article_content")
+                        .semantics {
+                            testTagsAsResourceId = true
+                        }
+                ) {
+                    itemsIndexed(
+                        items = displayBlocks,
+                        key = { index, _ ->
+                            "$articleSaveKey:$index"
+                        },
+                        contentType = { _, _ -> "article_block" }
+                    ) { index, block ->
                         Box(
                             modifier = Modifier
-                                .padding(
-                                    start = Spacing.iconStart + indentStep * block.indent
-                                )
-                                .padding(bottom = if (followedByContinuation) 0.dp else 8.dp)
+                                .padding(start = Spacing.contentStart + indentStep * block.indent)
                         ) {
                             ArticleLinkText(
                                 block = block,
@@ -168,13 +186,18 @@ fun ArticleContent(
                             )
                         }
                     }
-                    if (isHeavyArticle) {
-                        textContent()
-                    } else {
-                        SelectionContainer { textContent() }
-                    }
                 }
             }
+            val articleListModifier = modifier
+                .fillMaxSize()
+                .onSizeChanged { viewportSize = it }
+                .windowInsetsPadding(AppWindowInsets.horizontalSafeDrawing)
+                .padding(end = 16.dp)
+            if (isHeavyArticle) {
+                articleList(articleListModifier)
+            } else {
+                SelectionContainer { articleList(articleListModifier) }
+            }
         }
         is ArticleState.Error -> {
             Column(
@@ -196,16 +219,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())
         }
     }
 }
@@ -215,65 +229,73 @@ fun ArticleTitleBar(
     articleState: ArticleState?,
     showBackButton: Boolean,
     onNavigateBack: () -> Unit,
-    modifier: Modifier = Modifier
+    modifier: Modifier = Modifier,
+    compact: Boolean = false,
+    selectionReset: Int = 0,
 ) {
     val title = when (articleState) {
         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)
+    val backButtonOffset = if (compact) {
+        val titleLineHeight = with(LocalDensity.current) {
+            MaterialTheme.typography.dictionaryTitleLarge.lineHeight.toDp()
+        }
+        Modifier.offset(y = (titleLineHeight - 48.dp) / 2 + 3.dp)
+    } else {
+        Modifier
+    }
 
     Surface(
         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)
+                .then(
+                    if (compact) {
+                        Modifier.padding(vertical = Spacing.listItemVertical)
+                    } else {
+                        Modifier
+                            .padding(top = Spacing.topBarPadding, bottom = Spacing.topBarPadding)
+                            .height(Spacing.topBarHeight)
+                    }
+                ),
+            verticalAlignment = if (compact) Alignment.Top else Alignment.CenterVertically
         ) {
             if (showBackButton) {
-                Box(
+                AppBackButton(
+                    onClick = onNavigateBack,
                     modifier = Modifier
-                        .align(Alignment.CenterStart)
-                        .padding(start = Spacing.iconStart)
-                        .size(24.dp)
-                        .clickable(onClick = onNavigateBack),
-                    contentAlignment = Alignment.Center
-                ) {
-                    Icon(
-                        painter = backIcon,
-                        contentDescription = stringResource(R.string.action_back),
-                        modifier = Modifier.size(24.dp)
+                        .padding(start = 10.dp)
+                        .then(backButtonOffset)
+                )
+            }
+
+            key(selectionReset) {
+                SelectionContainer {
+                    Text(
+                        text = title,
+                        style = MaterialTheme.typography.dictionaryTitleLarge,
+                        color = MaterialTheme.colorScheme.onSurface,
+                        maxLines = 1,
+                        overflow = TextOverflow.Ellipsis,
+                        modifier = Modifier
+                            .padding(start = if (showBackButton) 0.dp else 16.dp)
+                            .testTag("article_title")
+                            .semantics { testTagsAsResourceId = true }
                     )
                 }
             }
-
-            Text(
-                text = title,
-                style = MaterialTheme.typography.dictionaryTitleLarge,
-                color = MaterialTheme.colorScheme.onSurface,
-                maxLines = 1,
-                overflow = TextOverflow.Ellipsis,
-                modifier = Modifier
-                    .align(Alignment.CenterStart)
-                    .padding(start = if (showBackButton) Spacing.searchTextStart else 16.dp)
-                    .testTag("article_title")
-                    .semantics { testTagsAsResourceId = true }
-            )
         }
     }
 }
 
-@OptIn(ExperimentalMaterial3Api::class)
 @Composable
 internal fun ArticleScreen(
     articleState: ArticleState?,
@@ -281,22 +303,31 @@ internal fun ArticleScreen(
     onRefClick: ((String) -> Unit)? = null,
     onScrollPositionChanged: ((Int, Int) -> Unit)? = null,
 ) {
-    Scaffold(
-        topBar = {
-            ArticleTitleBar(
+    val titleSelectionReset = remember { mutableIntStateOf(0) }
+    Box(
+        modifier = Modifier.clickable(
+            interactionSource = remember { MutableInteractionSource() },
+            indication = null
+        ) { titleSelectionReset.intValue++ }
+    ) {
+        Scaffold(
+            topBar = {
+                ArticleTitleBar(
+                    articleState = articleState,
+                    showBackButton = true,
+                    onNavigateBack = onNavigateBack,
+                    selectionReset = titleSelectionReset.intValue
+                )
+            },
+            contentWindowInsets = AppWindowInsets.contentWithNavigation
+        ) { padding ->
+            ArticleContent(
                 articleState = articleState,
-                showBackButton = true,
-                onNavigateBack = onNavigateBack
+                onNavigateBack = onNavigateBack,
+                onRefClick = onRefClick,
+                onScrollPositionChanged = onScrollPositionChanged,
+                modifier = Modifier.padding(padding)
             )
-        },
-        contentWindowInsets = AppWindowInsets.contentWithNavigation
-    ) { padding ->
-        ArticleContent(
-            articleState = articleState,
-            onNavigateBack = onNavigateBack,
-            onRefClick = onRefClick,
-            onScrollPositionChanged = onScrollPositionChanged,
-            modifier = Modifier.padding(padding)
-        )
+        }
     }
 }

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

@@ -37,6 +37,7 @@ sealed class ArticleState {
         val dictionaryPath: String = "",
         val scrollIndex: Int = 0,
         val scrollOffset: Int = 0,
+        val isHeavy: Boolean = false,
     ) : ArticleState()
     @Immutable
     data class Error(

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

@@ -13,11 +13,14 @@ import kotlinx.coroutines.currentCoroutineContext
 import kotlinx.coroutines.ensureActive
 
 internal const val HEAVY_ARTICLE_BLOCK_COUNT = 100
+internal const val HEAVY_ARTICLE_TOTAL_CHARS = 1_500
 
 object ArticleTextWarmUp {
 
     suspend fun warmUp(context: Context, blocks: List<DslBlock>) {
-        if (blocks.size <= HEAVY_ARTICLE_BLOCK_COUNT) return
+        if (blocks.size <= HEAVY_ARTICLE_BLOCK_COUNT &&
+            blocks.sumOf { it.text.length } <= HEAVY_ARTICLE_TOTAL_CHARS
+        ) return
         val density = Density(context)
         val measurer = TextMeasurer(
             defaultFontFamilyResolver = createFontFamilyResolver(context),

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

@@ -24,6 +24,40 @@ object DslAnnotatedParser {
         "ref", "ex", "e", "trn", "com", "lang", "sup", "'"
     )
 
+    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,
         val labelText: Color,
@@ -36,11 +70,6 @@ object DslAnnotatedParser {
         val endIndex: Int
     )
 
-    // Cache for applyLazyRefs results to avoid recreating AnnotatedString with links
-    // Size: 32 blocks - covers typical visible + prefetch range in LazyColumn
-    // Memory estimate: ~20KB per block average (AnnotatedString with LinkAnnotations)
-    // Total: ~640KB worst case
-    // LRU eviction automatic via LruCache
     private val refCache = object : androidx.collection.LruCache<Pair<DslBlock, Int>, AnnotatedString>(32) {
         override fun sizeOf(key: Pair<DslBlock, Int>, value: AnnotatedString): Int = 1
     }
@@ -54,9 +83,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 lastAppended: Char? = null
         val exampleStyle = SpanStyle(color = colorScheme.secondaryText)
         val labelStyle = SpanStyle(color = colorScheme.labelText)
         val linkStyle = SpanStyle(color = colorScheme.linkText, textDecoration = TextDecoration.Underline)
@@ -74,16 +103,38 @@ object DslAnnotatedParser {
         }
 
         fun flushBlock() {
-            if (builder.length > 0) {
+            val text = builder.toAnnotatedString()
+            if (text.any { !it.isWhitespace() }) {
                 result.add(DslBlock(
-                    text = builder.toAnnotatedString(),
+                    text = text,
                     indent = currentIndent,
                     lazyRefs = lazyRefs.toList()
                 ))
-                builder = AnnotatedString.Builder()
-                stack.forEach { builder.pushStyle(it) }
-                lazyRefs.clear()
             }
+            builder = AnnotatedString.Builder()
+            stack.forEach { builder.pushStyle(it) }
+            lazyRefs.clear()
+            lastAppended = null
+        }
+
+        fun appendChar(char: Char, hard: Boolean = false) {
+            if (char == ' ' && !hard) {
+                if (lastAppended == null || lastAppended == ' ') return
+            }
+            lastAppended = char
+            builder.append(char)
+            if (refStack.isNotEmpty()) {
+                refStack.last().second.append(char)
+            }
+        }
+
+        fun appendText(value: String) {
+            if (value.isEmpty()) return
+            builder.append(value)
+            if (refStack.isNotEmpty()) {
+                refStack.last().second.append(value)
+            }
+            lastAppended = value.last()
         }
 
         fun marginIndent(tagName: String): Int {
@@ -99,20 +150,11 @@ object DslAnnotatedParser {
             when (val char = dsl[i]) {
                 '\\' -> {
                     if (i + 1 < length) {
-                        val next = dsl[i + 1]
-                        builder.append(next)
-                        if (refStack.isNotEmpty()) {
-                            refStack.last().second.append(next)
-                        }
-                        lastChar = next
+                        appendChar(dsl[i + 1], hard = true)
                         i += 2
                         continue
                     }
-                    builder.append(char)
-                    if (refStack.isNotEmpty()) {
-                        refStack.last().second.append(char)
-                    }
-                    lastChar = char
+                    appendChar(char)
                     i++
                 }
                 '[' -> {
@@ -149,6 +191,10 @@ object DslAnnotatedParser {
                                     accentNext = false
                                 }
                                 pop()
+                                if (tagName.startsWith("m")) {
+                                    flushBlock()
+                                    currentIndent = 0
+                                }
                             } else {
                                 when (tagName) {
                                     "'" -> {
@@ -161,17 +207,15 @@ object DslAnnotatedParser {
                                         } else {
                                             builder.append("\n")
                                         }
-                                        lastChar = '\n'
                                     }
                                     "p" -> {
-                                        push(labelStyle)
+                                        push(labelStyle.copy(fontStyle = FontStyle.Italic))
                                     }
                                     "b" -> push(SpanStyle(fontWeight = FontWeight.Bold))
                                     "m", "m0", "m1", "m2", "m3", "m4", "m5" -> {
-                                        if (lastChar != '\n' && lastChar != null) {
-                                            if (refStack.isEmpty()) flushBlock() else builder.append("\n")
+                                        if (lastAppended != null && !lastAppended!!.isWhitespace()) {
+                                            flushBlock()
                                         }
-                                        lastChar = '\n'
                                         currentIndent = marginIndent(tagName)
                                         push(exampleStyle)
                                     }
@@ -181,7 +225,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))
                                 }
                             }
@@ -189,18 +244,23 @@ object DslAnnotatedParser {
                             continue
                         }
                     }
-                    builder.append(char)
-                    if (refStack.isNotEmpty()) {
-                        refStack.last().second.append(char)
+                    appendChar(char)
+                    i++
+                }
+                '\n' -> {
+                    if (refStack.isEmpty()) {
+                        flushBlock()
+                    } else {
+                        appendChar(char)
                     }
-                    lastChar = char
+                    i++
+                }
+                '\t' -> {
+                    appendText("\u2002")
                     i++
                 }
                 else -> {
-                    builder.append(char)
-                    if (refStack.isNotEmpty()) {
-                        refStack.last().second.append(char)
-                    }
+                    appendChar(char)
 
                     if (accentNext) {
                         builder.append('\u0301')
@@ -210,7 +270,6 @@ object DslAnnotatedParser {
                         accentNext = false
                     }
 
-                    lastChar = char
                     i++
                 }
             }
@@ -352,6 +411,35 @@ object DslAnnotatedParser {
         linkText = Color(0xFF1E88E5),
     )
 
+    private val DARK_THEME_COLORS: Map<Color, Color> = mapOf(
+        Color(0xFF000000) to Color(0xFFE8E6E3),
+        Color(0xFF000080) to Color(0xFF8FA8E0),
+        Color(0xFF00008B) to Color(0xFF8FA8E0),
+        Color(0xFF0000FF) to Color(0xFF7C9CE8),
+        Color(0xFF006400) to Color(0xFF66BB6A),
+        Color(0xFF008000) to Color(0xFF66BB6A),
+        Color(0xFF8B0000) to Color(0xFFE57373),
+        Color(0xFF800000) to Color(0xFFE57373),
+        Color(0xFF800080) to Color(0xFFBA68C8),
+        Color(0xFFA52A2A) to Color(0xFFBCAAA4),
+        Color(0xFF008080) to Color(0xFF4DB6AC),
+        Color(0xFF808000) to Color(0xFFC0CA33),
+    )
+
+    fun remapForDarkTheme(text: AnnotatedString): AnnotatedString {
+        if (text.spanStyles.none { it.item.color in DARK_THEME_COLORS }) return text
+        val builder = AnnotatedString.Builder(text.text)
+        text.spanStyles.forEach { range ->
+            val style = DARK_THEME_COLORS[range.item.color]
+                ?.let { range.item.copy(color = it) } ?: range.item
+            builder.addStyle(style, range.start, range.end)
+        }
+        text.paragraphStyles.forEach { range ->
+            builder.addStyle(range.item, range.start, range.end)
+        }
+        return builder.toAnnotatedString()
+    }
+
     // Allow external cache clearing (e.g., when dictionaries change)
     fun clearRefCache() {
         refCache.evictAll()

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

@@ -0,0 +1,51 @@
+package com.example.research.ui.article
+
+import androidx.compose.ui.text.AnnotatedString
+
+private const val MERGED_BLOCK_MAX_CHARS = 1500
+private const val MERGED_BLOCK_MAX_ITEMS = 12
+
+internal fun mergeDslBlocks(blocks: List<DslBlock>): List<DslBlock> {
+    if (blocks.size <= MERGED_BLOCK_MAX_ITEMS) return blocks
+    val merged = ArrayList<DslBlock>(blocks.size / 4)
+    var i = 0
+    while (i < blocks.size) {
+        val builder = AnnotatedString.Builder()
+        val refs = ArrayList<DslAnnotatedParser.LazyRef>()
+        var j = i
+        while (j < blocks.size) {
+            val block = blocks[j]
+            repeat(block.indent) { builder.append(' ') }
+            val paraStart = builder.length
+            builder.append(block.text)
+            block.lazyRefs.forEach { ref ->
+                refs.add(
+                    ref.copy(
+                        startIndex = ref.startIndex + paraStart,
+                        endIndex = ref.endIndex + paraStart
+                    )
+                )
+            }
+            val more = j + 1 < blocks.size &&
+                (j + 1 - i) < MERGED_BLOCK_MAX_ITEMS &&
+                builder.length < MERGED_BLOCK_MAX_CHARS
+            if (more) {
+                builder.append('\n')
+            }
+            j++
+            if (!more) {
+                break
+            }
+        }
+        merged.add(
+            DslBlock(
+                text = builder.toAnnotatedString(),
+                indent = 0,
+                lazyRefs = refs,
+                continuesPrevious = blocks[i].continuesPrevious
+            )
+        )
+        i = j
+    }
+    return merged
+}

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

@@ -1,5 +1,7 @@
 package com.example.research.ui.main
 
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.layout.*
 import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
@@ -12,7 +14,8 @@ import com.example.research.core.domain.model.IndexEntry
 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.AppWindowInsets
+import com.example.research.ui.theme.Spacing
 
 @OptIn(ExperimentalMaterial3AdaptiveApi::class)
 @Composable
@@ -20,9 +23,11 @@ fun AdaptiveMainScreen(
     searchState: TextFieldState,
     canSearch: Boolean,
     isLandscape: Boolean,
+    isSearchBarAtBottom: Boolean,
     results: LazyPagingItems<IndexEntry>,
     errorMessage: String?,
     showDictionaryName: Boolean,
+    searchHistory: List<String>,
     articleState: ArticleState?,
     scrollPosition: Pair<Int, Int>,
     onAction: (MainAction) -> Unit,
@@ -43,21 +48,37 @@ fun AdaptiveMainScreen(
         )
     }
 
-    val isQueryEmpty = searchState.text.isEmpty()
     val isShowingDetail = scaffoldState.targetState.primary == PaneAdaptedValue.Expanded
     val isTwoPane =
         scaffoldState.targetState.primary == PaneAdaptedValue.Expanded &&
             scaffoldState.targetState.secondary == PaneAdaptedValue.Expanded
     val listEndPadding = if (isTwoPane) 8.dp else 16.dp
 
-    Column(modifier = Modifier.fillMaxSize()) {
-        MainTopBar(
+    val searchBar: @Composable () -> Unit = {
+        MainSearchBar(
             searchState = searchState,
-            enabled = canSearch,
-            onQueryChange = { onAction(MainAction.QueryChanged(it)) },
-            onClearQuery = { onAction(MainAction.ClearQuery) },
-            onNavigateToSettings = onNavigateToSettings
+            canSearch = canSearch,
+            isSearchBarAtBottom = isSearchBarAtBottom,
+            searchHistory = searchHistory,
+            onAction = onAction,
+            onNavigateToSettings = onNavigateToSettings,
         )
+    }
+
+    Column(
+        modifier = Modifier
+            .fillMaxSize()
+            .then(
+                if (isSearchBarAtBottom) {
+                    Modifier.windowInsetsPadding(AppWindowInsets.statusBarsAndIme)
+                } else {
+                    Modifier
+                }
+            )
+    ) {
+        if (!isSearchBarAtBottom) {
+            searchBar()
+        }
 
         ListDetailPaneScaffold(
             directive = PaneScaffoldDirective.Default.copy(
@@ -84,20 +105,28 @@ 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),
+                    alignFirstResultWithTitleBar = isSearchBarAtBottom,
                 )
             },
             detailPane = {
+                val titleSelectionReset = remember { mutableIntStateOf(0) }
                 Column(
                     modifier = Modifier
                         .fillMaxSize()
+                        .clickable(
+                            interactionSource = remember { MutableInteractionSource() },
+                            indication = null
+                        ) { titleSelectionReset.intValue++ }
                         .padding(bottom = 16.dp)
                 ) {
                     ArticleTitleBar(
                         articleState = articleState,
-                        showBackButton = isShowingDetail,
+                        showBackButton = isShowingDetail && articleState != null,
                         onNavigateBack = onNavigateBackFromArticle,
+                        compact = !isSearchBarAtBottom,
+                        selectionReset = titleSelectionReset.intValue,
                         modifier = Modifier.windowInsetsPadding(
                             WindowInsets.safeDrawing.only(WindowInsetsSides.Top)
                         )
@@ -110,21 +139,21 @@ fun AdaptiveMainScreen(
                 }
             },
         )
+
+        if (isSearchBarAtBottom) {
+            searchBar()
+        }
     }
 
-    LaunchedEffect(articleState, isQueryEmpty) {
-        val targetValue = when {
-            articleState == null -> ThreePaneScaffoldValue(
+    LaunchedEffect(articleState) {
+        val targetValue = if (articleState == null) {
+            ThreePaneScaffoldValue(
                 primary = PaneAdaptedValue.Hidden,
                 secondary = PaneAdaptedValue.Expanded,
                 tertiary = PaneAdaptedValue.Hidden,
             )
-            isQueryEmpty -> ThreePaneScaffoldValue(
-                primary = PaneAdaptedValue.Expanded,
-                secondary = PaneAdaptedValue.Hidden,
-                tertiary = PaneAdaptedValue.Hidden,
-            )
-            else -> ThreePaneScaffoldValue(
+        } else {
+            ThreePaneScaffoldValue(
                 primary = PaneAdaptedValue.Expanded,
                 secondary = PaneAdaptedValue.Expanded,
                 tertiary = PaneAdaptedValue.Hidden,

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

@@ -5,4 +5,7 @@ sealed interface MainAction {
     data object ClearQuery : MainAction
     data object ClearError : MainAction
     data class SaveScrollPosition(val index: Int, val offset: Int) : MainAction
+    data class HistoryEntryClicked(val query: String) : MainAction
+    data class RemoveHistoryEntry(val query: String) : MainAction
+    data object ClearHistory : MainAction
 }

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

@@ -1,7 +1,9 @@
 package com.example.research.ui.main
 
 import androidx.compose.foundation.layout.BoxWithConstraints
+import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.consumeWindowInsets
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.windowInsetsPadding
@@ -14,11 +16,13 @@ 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
 import com.example.research.core.domain.model.IndexEntry
 import com.example.research.feature.download.config.DictionaryConfig
+import com.example.research.core.domain.model.SearchBarPosition
 import com.example.research.feature.download.model.DownloadState
 import com.example.research.feature.search.SearchAction
 import com.example.research.feature.search.SearchViewModel
@@ -36,9 +40,11 @@ fun MainRoute(
     val results = searchViewModel.searchResults.collectAsLazyPagingItems()
     val errorMessage by searchViewModel.errorMessage.collectAsStateWithLifecycle()
     val articleState by searchViewModel.selectedArticle.collectAsStateWithLifecycle()
+    val searchHistory by searchViewModel.searchHistory.collectAsStateWithLifecycle()
 
     val settingsState by settingsViewModel.uiState.collectAsStateWithLifecycle()
     val searchQuery by searchViewModel.searchQuery.collectAsStateWithLifecycle()
+    val isSearchBarAtBottom = settingsState.searchBarPosition == SearchBarPosition.BOTTOM
 
     val scrollPosition = remember(searchViewModel) {
         searchViewModel.scrollPosition.value
@@ -46,17 +52,6 @@ fun MainRoute(
     val searchState = remember(searchViewModel) {
         TextFieldState(initialText = searchViewModel.searchQuery.value)
     }
-    val onMainAction = remember(searchViewModel) {
-        { action: MainAction ->
-            when (action) {
-                is MainAction.QueryChanged -> searchViewModel.onSearchQueryChanged(action.query)
-                MainAction.ClearQuery -> searchViewModel.onAction(SearchAction.ClearQuery)
-                MainAction.ClearError -> searchViewModel.clearError()
-                is MainAction.SaveScrollPosition ->
-                    searchViewModel.saveScrollPosition(action.index, action.offset)
-            }
-        }
-    }
 
     LaunchedEffect(searchState, searchQuery) {
         if (searchState.text.toString() != searchQuery) {
@@ -69,7 +64,11 @@ fun MainRoute(
             dictionary.isActive && dictionary.articleCount > 0
         }
 
-        settingsState.downloadState is DownloadState.Idle &&
+        val downloadSettled = settingsState.downloadState.let { state ->
+            state is DownloadState.Idle || state is DownloadState.Error
+        }
+
+        downloadSettled &&
             !settingsState.indexingProgress.isIndexing &&
             settingsState.importState !is ImportState.Importing &&
             settingsState.importState !is ImportState.Extracting &&
@@ -78,13 +77,9 @@ fun MainRoute(
 
     val showDictionaryName = remember(settingsState) {
         val activeDictionaries = settingsState.dictionaries.filter { it.isActive }
-        if (activeDictionaries.isEmpty()) {
-            false
-        } else {
-            activeDictionaries.any { dict ->
-                val fileName = dict.path.substringAfterLast("/")
-                !DictionaryConfig.isDabkrsDictionary(fileName)
-            }
+        activeDictionaries.any { dict ->
+            val fileName = dict.path.substringAfterLast("/")
+            !DictionaryConfig.isDabkrsDictionary(fileName)
         }
     }
 
@@ -92,14 +87,38 @@ fun MainRoute(
         val isWide = maxWidth >= 600.dp
         val isLandscape = maxWidth > maxHeight
 
+        val onMainAction = remember(searchViewModel, isWide) {
+            { action: MainAction ->
+                when (action) {
+                    is MainAction.QueryChanged -> searchViewModel.onSearchQueryChanged(action.query)
+                    MainAction.ClearQuery -> searchViewModel.onAction(SearchAction.ClearQuery)
+                    MainAction.ClearError -> searchViewModel.clearError()
+                    is MainAction.SaveScrollPosition ->
+                        searchViewModel.saveScrollPosition(action.index, action.offset)
+                    is MainAction.HistoryEntryClicked ->
+                        if (isWide) {
+                            searchViewModel.onSearchQueryChanged(action.query)
+                            searchViewModel.onAction(SearchAction.SearchAndLoadArticle(action.query))
+                        } else {
+                            searchViewModel.onSearchQueryChanged(action.query)
+                        }
+                    is MainAction.RemoveHistoryEntry ->
+                        searchViewModel.removeSearchHistoryEntry(action.query)
+                    MainAction.ClearHistory -> searchViewModel.clearSearchHistory()
+                }
+            }
+        }
+
         if (isWide) {
             AdaptiveMainScreen(
                 searchState = searchState,
                 canSearch = canSearch,
                 isLandscape = isLandscape,
+                isSearchBarAtBottom = isSearchBarAtBottom,
                 results = results,
                 errorMessage = errorMessage,
                 showDictionaryName = showDictionaryName,
+                searchHistory = searchHistory,
                 articleState = articleState,
                 scrollPosition = scrollPosition,
                 onAction = onMainAction,
@@ -120,9 +139,11 @@ fun MainRoute(
             MainScreen(
                 searchState = searchState,
                 canSearch = canSearch,
+                isSearchBarAtBottom = isSearchBarAtBottom,
                 results = results,
                 errorMessage = errorMessage,
                 showDictionaryName = showDictionaryName,
+                searchHistory = searchHistory,
                 scrollPosition = scrollPosition,
                 onAction = onMainAction,
                 onArticleClick = onArticleClick,
@@ -132,28 +153,82 @@ fun MainRoute(
     }
 }
 
+@Composable
+internal fun MainSearchBar(
+    searchState: TextFieldState,
+    canSearch: Boolean,
+    isSearchBarAtBottom: Boolean,
+    searchHistory: List<String>,
+    onAction: (MainAction) -> Unit,
+    onNavigateToSettings: () -> Unit,
+) {
+    MainTopBar(
+        searchState = searchState,
+        enabled = canSearch,
+        isSearchBarAtBottom = isSearchBarAtBottom,
+        onQueryChange = { onAction(MainAction.QueryChanged(it)) },
+        onClearQuery = { onAction(MainAction.ClearQuery) },
+        searchHistory = searchHistory,
+        onHistoryEntryClick = { onAction(MainAction.HistoryEntryClicked(it)) },
+        onHistoryEntryRemove = { onAction(MainAction.RemoveHistoryEntry(it)) },
+        onClearHistory = { onAction(MainAction.ClearHistory) },
+        onNavigateToSettings = onNavigateToSettings
+    )
+}
+
 @Composable
 internal fun MainScreen(
     searchState: TextFieldState,
     canSearch: Boolean,
+    isSearchBarAtBottom: Boolean,
     results: LazyPagingItems<IndexEntry>,
     errorMessage: String?,
     showDictionaryName: Boolean,
+    searchHistory: List<String>,
     scrollPosition: Pair<Int, Int>,
     onAction: (MainAction) -> Unit,
     onArticleClick: (IndexEntry) -> Unit,
     onNavigateToSettings: () -> Unit
 ) {
-    Scaffold(
-        topBar = {
-            MainTopBar(
+    val searchBar: @Composable () -> Unit = {
+        MainSearchBar(
+            searchState = searchState,
+            canSearch = canSearch,
+            isSearchBarAtBottom = isSearchBarAtBottom,
+            searchHistory = searchHistory,
+            onAction = onAction,
+            onNavigateToSettings = onNavigateToSettings,
+        )
+    }
+
+    if (isSearchBarAtBottom) {
+        Column(
+            modifier = Modifier
+                .fillMaxSize()
+                .windowInsetsPadding(AppWindowInsets.statusBarsAndIme)
+        ) {
+            SearchResultsPane(
                 searchState = searchState,
-                enabled = canSearch,
-                onQueryChange = { onAction(MainAction.QueryChanged(it)) },
-                onClearQuery = { onAction(MainAction.ClearQuery) },
-                onNavigateToSettings = onNavigateToSettings
+                results = results,
+                errorMessage = errorMessage,
+                showDictionaryName = showDictionaryName,
+                scrollPosition = scrollPosition,
+                onAction = onAction,
+                onArticleClick = onArticleClick,
+                modifier = Modifier
+                    .weight(1f)
+                    .fillMaxWidth()
+                    .windowInsetsPadding(AppWindowInsets.horizontalSafeDrawing)
+                    .padding(start = Spacing.contentStart, end = 16.dp),
+                alignFirstResultWithTitleBar = true,
             )
-        },
+            searchBar()
+        }
+        return
+    }
+
+    Scaffold(
+        topBar = { searchBar() },
         contentWindowInsets = AppWindowInsets.navigationOnly
     ) { paddingValues ->
         SearchResultsPane(
@@ -169,7 +244,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/SearchResultsPane.kt

@@ -8,6 +8,7 @@ import androidx.compose.foundation.layout.ime
 import androidx.compose.foundation.text.input.TextFieldState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.SideEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
@@ -15,7 +16,12 @@ import androidx.compose.runtime.setValue
 import androidx.compose.runtime.snapshotFlow
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.ui.text.rememberTextMeasurer
+import com.example.research.common.ui.theme.dictionaryTitleLarge
+import com.example.research.ui.theme.Spacing
 import androidx.paging.LoadState
 import androidx.paging.compose.LazyPagingItems
 import com.example.research.core.domain.model.IndexEntry
@@ -42,6 +48,7 @@ internal fun SearchResultsPane(
     onArticleClick: (IndexEntry) -> Unit,
     modifier: Modifier = Modifier,
     listModifier: Modifier = Modifier,
+    alignFirstResultWithTitleBar: Boolean = false,
 ) {
     val listState = rememberLazyListState(
         initialFirstVisibleItemIndex = scrollPosition.first,
@@ -50,9 +57,11 @@ internal fun SearchResultsPane(
     var restoredScrollPosition by remember { mutableStateOf(false) }
     var pendingScrollToTop by remember { mutableStateOf(false) }
     var sawRefreshForPendingScroll by remember { mutableStateOf(false) }
+    var staleEntries by remember { mutableStateOf(emptyList<IndexEntry>()) }
     val imeBottomPadding = with(LocalDensity.current) {
         WindowInsets.ime.getBottom(this).toDp()
     }
+    val topPadding = if (alignFirstResultWithTitleBar) titleBarAlignedTopPadding() else 0.dp
 
     LaunchedEffect(listState) {
         snapshotFlow {
@@ -72,9 +81,22 @@ internal fun SearchResultsPane(
                 restoredScrollPosition = true
                 pendingScrollToTop = query.isNotBlank()
                 sawRefreshForPendingScroll = false
+                if (query.isBlank()) {
+                    staleEntries = emptyList()
+                }
             }
     }
 
+    SideEffect {
+        val loaded = results.itemSnapshotList.items
+        if (results.loadState.refresh is LoadState.NotLoading && loaded.isNotEmpty()) {
+            staleEntries = loaded
+        }
+    }
+    val pendingReload = results.itemCount == 0 &&
+        results.loadState.refresh is LoadState.Loading
+    val shownStale = if (pendingReload && searchState.text.isNotBlank()) staleEntries else emptyList()
+
     LaunchedEffect(results.loadState.refresh, pendingScrollToTop) {
         if (pendingScrollToTop && results.loadState.refresh is LoadState.Loading) {
             sawRefreshForPendingScroll = true
@@ -124,7 +146,21 @@ internal fun SearchResultsPane(
             modifier = listModifier.weight(1f),
             listState = listState,
             showDictionaryName = showDictionaryName,
-            contentPadding = PaddingValues(bottom = imeBottomPadding),
+            contentPadding = PaddingValues(top = topPadding, bottom = imeBottomPadding),
+            staleEntries = shownStale,
         )
     }
 }
+
+@Composable
+private fun titleBarAlignedTopPadding(): Dp {
+    val textMeasurer = rememberTextMeasurer(cacheSize = 0)
+    val style = MaterialTheme.typography.dictionaryTitleLarge
+    val density = LocalDensity.current
+    return remember(textMeasurer, style, density) {
+        val titleHeight = with(density) {
+            textMeasurer.measure(text = "A", style = style, maxLines = 1).size.height.toDp()
+        }
+        (Spacing.topBarCenter - Spacing.listItemVertical - titleHeight / 2).coerceAtLeast(0.dp)
+    }
+}

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

@@ -1,9 +1,15 @@
 package com.example.research.ui.main.components
 
+
 import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.WindowInsets
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.ime
+import androidx.compose.foundation.layout.navigationBars
 import androidx.compose.foundation.layout.offset
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
@@ -17,55 +23,108 @@ import androidx.compose.material3.FilledIconButton
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.IconButtonDefaults
+import androidx.compose.material3.LocalContentColor
 import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.ModalBottomSheet
 import androidx.compose.material3.Surface
 import androidx.compose.material3.TextField
 import androidx.compose.material3.TextFieldDefaults
+import androidx.compose.material3.SheetValue
+import androidx.compose.material3.rememberBottomSheetState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.runtime.setValue
 import androidx.compose.runtime.snapshotFlow
-import com.example.research.ui.theme.AppWindowInsets
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.painter.Painter
+import androidx.compose.ui.layout.boundsInWindow
+import androidx.compose.ui.layout.onGloballyPositioned
+import androidx.compose.ui.platform.LocalWindowInfo
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.platform.LocalFocusManager
 import androidx.compose.ui.platform.testTag
-import androidx.compose.ui.res.painterResource
-import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.semantics.testTagsAsResourceId
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.unit.dp
 import com.example.research.R
+import com.example.research.common.ui.appTestTag
+import com.example.research.common.ui.iconClickable
 import com.example.research.common.ui.theme.dictionaryTitleLarge
-import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.withTimeoutOrNull
+import com.example.research.ui.theme.AppWindowInsets
 import com.example.research.ui.theme.Spacing
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.launch
+import kotlin.math.roundToInt
+import kotlin.time.Duration.Companion.milliseconds
 
 private val TopBarHeight = Spacing.topBarHeight
 private val TopBarShape = RoundedCornerShape(28.dp)
+private val HistorySheetChrome = 64.dp
+private val HistorySheetMinHeight = 300.dp
+private val HistorySheetBottomPadding = 16.dp
 
 @Composable
 fun MainTopBar(
     searchState: TextFieldState,
     enabled: Boolean,
+    isSearchBarAtBottom: Boolean = false,
     onQueryChange: (String) -> Unit,
     onClearQuery: () -> Unit,
+    searchHistory: List<String>,
+    onHistoryEntryClick: (String) -> Unit,
+    onHistoryEntryRemove: (String) -> Unit,
+    onClearHistory: () -> Unit,
     onNavigateToSettings: () -> Unit
 ) {
-    val searchIcon = painterResource(R.drawable.ic_search)
     val closeIcon = painterResource(R.drawable.ic_close)
+    val historyIcon = painterResource(R.drawable.ic_manage_search)
     val settingsIcon = painterResource(R.drawable.ic_settings)
     val clearLabel = stringResource(R.string.clear_search)
+    val historyLabel = stringResource(R.string.recent_searches)
+    val focusManager = LocalFocusManager.current
+
+    var showHistorySheet by remember { mutableStateOf(false) }
+    var topBarBottomPx by remember { mutableIntStateOf(0) }
+    val coroutineScope = rememberCoroutineScope()
+    val density = LocalDensity.current
+    val imeInsets = WindowInsets.ime
 
     Surface(
         color = MaterialTheme.colorScheme.surface,
-        modifier = Modifier.fillMaxWidth()
+        modifier = Modifier
+            .fillMaxWidth()
+            .onGloballyPositioned { topBarBottomPx = it.boundsInWindow().bottom.roundToInt() }
     ) {
         Row(
             modifier = Modifier
                 .fillMaxWidth()
-                .windowInsetsPadding(AppWindowInsets.topAndHorizontalSafeDrawing)
+                .windowInsetsPadding(
+                    if (isSearchBarAtBottom) {
+                        AppWindowInsets.horizontalSafeDrawing
+                    } else {
+                        AppWindowInsets.topAndHorizontalSafeDrawing
+                    }
+                )
+                .then(
+                    if (isSearchBarAtBottom) {
+                        Modifier.windowInsetsPadding(AppWindowInsets.bottomNavigation)
+                    } else {
+                        Modifier
+                    }
+                )
                 .padding(start = 16.dp, top = 8.dp, bottom = 8.dp, end = 16.dp),
             horizontalArrangement = Arrangement.spacedBy(8.dp),
             verticalAlignment = Alignment.CenterVertically
@@ -75,9 +134,21 @@ fun MainTopBar(
                 enabled = enabled,
                 onQueryChange = onQueryChange,
                 onClearQuery = onClearQuery,
-                searchIcon = searchIcon,
                 closeIcon = closeIcon,
                 clearLabel = clearLabel,
+                historyIcon = historyIcon,
+                historyLabel = historyLabel,
+                historyEnabled = searchHistory.isNotEmpty(),
+                onShowHistory = {
+                    focusManager.clearFocus(force = true)
+                    coroutineScope.launch {
+                        withTimeoutOrNull(350.milliseconds) {
+                            snapshotFlow { imeInsets.getBottom(density) > 0 }
+                                .first { visible -> !visible }
+                        }
+                        showHistorySheet = !showHistorySheet
+                    }
+                },
                 modifier = Modifier.weight(1f)
             )
 
@@ -100,18 +171,39 @@ fun MainTopBar(
             }
         }
     }
+
+    if (showHistorySheet && searchHistory.isNotEmpty()) {
+        SearchHistorySheet(
+            history = searchHistory,
+            isSearchBarAtBottom = isSearchBarAtBottom,
+            topBarBottomPx = topBarBottomPx,
+            onDismiss = { showHistorySheet = false },
+            onEntryClick = { entry ->
+                focusManager.clearFocus(force = true)
+                showHistorySheet = false
+                onHistoryEntryClick(entry)
+            },
+            onEntryRemove = onHistoryEntryRemove,
+            onClearAll = {
+                showHistorySheet = false
+                onClearHistory()
+            }
+        )
+    }
 }
 
 @Composable
-@OptIn(ExperimentalMaterial3Api::class)
 private fun SearchField(
     searchState: TextFieldState,
     enabled: Boolean,
     onQueryChange: (String) -> Unit,
     onClearQuery: () -> Unit,
-    searchIcon: androidx.compose.ui.graphics.painter.Painter,
-    closeIcon: androidx.compose.ui.graphics.painter.Painter,
+    closeIcon: Painter,
     clearLabel: String,
+    historyIcon: Painter,
+    historyLabel: String,
+    historyEnabled: Boolean,
+    onShowHistory: () -> Unit,
     modifier: Modifier = Modifier
 ) {
     val containerColor = MaterialTheme.colorScheme.surfaceContainerHighest
@@ -134,11 +226,16 @@ private fun SearchField(
         lineLimits = TextFieldLineLimits.SingleLine,
         leadingIcon = {
             Icon(
-                painter = searchIcon,
-                contentDescription = null,
+                painter = historyIcon,
+                contentDescription = historyLabel,
+                tint = LocalContentColor.current.copy(
+                    alpha = if (historyEnabled) 1f else 0.38f
+                ),
                 modifier = Modifier
                     .offset(x = 4.dp)
-                    .size(24.dp)
+                    .size(28.dp)
+                    .appTestTag("history_button")
+                    .iconClickable(enabled = historyEnabled, onClick = onShowHistory)
             )
         },
         trailingIcon = if (searchState.text.isNotEmpty()) {
@@ -183,3 +280,52 @@ private fun SearchField(
             .semantics { testTagsAsResourceId = true }
     )
 }
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun SearchHistorySheet(
+    history: List<String>,
+    isSearchBarAtBottom: Boolean,
+    topBarBottomPx: Int,
+    onDismiss: () -> Unit,
+    onEntryClick: (String) -> Unit,
+    onEntryRemove: (String) -> Unit,
+    onClearAll: () -> Unit
+) {
+    val sheetState = rememberBottomSheetState(
+        initialValue = SheetValue.Hidden,
+        enabledValues = setOf(SheetValue.Hidden, SheetValue.Expanded),
+    )
+    val density = LocalDensity.current
+    val windowHeightPx = LocalWindowInfo.current.containerSize.height
+    val navigationBarsBottom = WindowInsets.navigationBars.getBottom(density)
+    val maxContentHeight = remember {
+        with(density) {
+            val screenHeight = windowHeightPx.toDp()
+            if (isSearchBarAtBottom) {
+                screenHeight - HistorySheetChrome - navigationBarsBottom.toDp()
+            } else {
+                screenHeight - topBarBottomPx.toDp()
+            }
+        }
+    }
+
+    ModalBottomSheet(
+        onDismissRequest = onDismiss,
+        sheetState = sheetState,
+        contentWindowInsets = { WindowInsets(0, 0, 0, 0) },
+        modifier = Modifier.testTag("search_history_sheet")
+    ) {
+        SearchHistoryList(
+            history = history,
+            onEntryClick = onEntryClick,
+            onEntryRemove = onEntryRemove,
+            onClearAll = onClearAll,
+            contentPadding = PaddingValues(bottom = HistorySheetBottomPadding),
+            modifier = Modifier
+                .fillMaxWidth()
+                .heightIn(min = HistorySheetMinHeight, max = maxContentHeight)
+                .padding(horizontal = 24.dp)
+        )
+    }
+}

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

@@ -0,0 +1,138 @@
+package com.example.research.ui.main.components
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.LazyListState
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import com.example.research.R
+import com.example.research.common.ui.appTestTag
+import com.example.research.common.ui.iconClickable
+import com.example.research.common.ui.theme.dictionaryTitleLarge
+import com.example.research.ui.theme.Spacing
+
+@Composable
+fun SearchHistoryList(
+    history: List<String>,
+    onEntryClick: (String) -> Unit,
+    onEntryRemove: (String) -> Unit,
+    onClearAll: () -> Unit,
+    modifier: Modifier = Modifier,
+    listState: LazyListState = rememberLazyListState(),
+    contentPadding: PaddingValues = PaddingValues(),
+) {
+    LazyColumn(
+        modifier = modifier
+            .appTestTag("search_history"),
+        state = listState,
+        contentPadding = contentPadding,
+        verticalArrangement = Arrangement.spacedBy(4.dp)
+    ) {
+        item(key = "history_header", contentType = "history_header") {
+            Row(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(vertical = Spacing.listItemVertical),
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                Text(
+                    text = stringResource(R.string.recent_searches),
+                    style = MaterialTheme.typography.titleSmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    modifier = Modifier.weight(1f)
+                )
+                Text(
+                    text = stringResource(R.string.clear_search_history),
+                    style = MaterialTheme.typography.titleSmall,
+                    color = MaterialTheme.colorScheme.primary,
+                    softWrap = false,
+                    modifier = Modifier
+                        .padding(end = 18.dp)
+                        .clip(CircleShape)
+                        .background(MaterialTheme.colorScheme.surfaceContainerHighest)
+                        .appTestTag("clear_history")
+                        .clickable { onClearAll() }
+                        .padding(horizontal = 12.dp, vertical = 6.dp)
+                )
+            }
+        }
+        items(
+            items = history,
+            key = { it },
+            contentType = { "history_entry" }
+        ) { entry ->
+            SearchHistoryItem(
+                entry = entry,
+                onEntryClick = onEntryClick,
+                onEntryRemove = onEntryRemove
+            )
+        }
+    }
+}
+
+@Composable
+private fun SearchHistoryItem(
+    entry: String,
+    onEntryClick: (String) -> Unit,
+    onEntryRemove: (String) -> Unit
+) {
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .appTestTag("search_history_entry")
+            .clickable { onEntryClick(entry) }
+            .padding(vertical = Spacing.listItemVertical),
+        verticalAlignment = Alignment.CenterVertically
+    ) {
+        Icon(
+            painter = painterResource(R.drawable.ic_history),
+            contentDescription = null,
+            tint = MaterialTheme.colorScheme.onSurfaceVariant,
+            modifier = Modifier
+                .padding(end = 16.dp)
+                .size(20.dp)
+        )
+        Text(
+            text = entry,
+            style = MaterialTheme.typography.dictionaryTitleLarge,
+            maxLines = 1,
+            overflow = TextOverflow.Ellipsis,
+            modifier = Modifier.weight(1f)
+        )
+        Box(
+            contentAlignment = Alignment.Center,
+            modifier = Modifier.width(Spacing.topBarHeight)
+        ) {
+            Icon(
+                painter = painterResource(R.drawable.ic_close),
+                contentDescription = stringResource(R.string.remove_search_history_entry),
+                tint = MaterialTheme.colorScheme.onSurfaceVariant,
+                modifier = Modifier
+                    .appTestTag("remove_history_entry")
+                    .iconClickable { onEntryRemove(entry) }
+                    .size(20.dp)
+            )
+        }
+    }
+}

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

@@ -6,17 +6,13 @@ import androidx.compose.foundation.lazy.*
 import androidx.compose.material3.*
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
-import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.testTag
-import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.semantics.testTagsAsResourceId
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
-import androidx.paging.LoadState
 import androidx.paging.compose.*
-import com.example.research.R
 import com.example.research.common.ui.theme.dictionaryTitleLarge
 import com.example.research.core.domain.model.IndexEntry
 import com.example.research.core.util.removeDictionarySuffixes
@@ -29,8 +25,11 @@ fun SearchResultsList(
     modifier: Modifier = Modifier,
     listState: LazyListState = rememberLazyListState(),
     showDictionaryName: Boolean = true,
-    contentPadding: PaddingValues = PaddingValues()
+    contentPadding: PaddingValues = PaddingValues(),
+    staleEntries: List<IndexEntry> = emptyList(),
 ) {
+    val showStale = staleEntries.isNotEmpty() && results.itemCount == 0
+    val rowCount = if (showStale) staleEntries.size else results.itemCount
     LazyColumn(
         modifier = modifier
             .testTag("search_results")
@@ -40,10 +39,18 @@ fun SearchResultsList(
         verticalArrangement = Arrangement.spacedBy(4.dp)
     ) {
         items(
-            count = results.itemCount,
-            contentType = results.itemContentType { "search_result" }
+            count = rowCount,
+            key = { index ->
+                val entry = if (showStale) staleEntries.getOrNull(index)
+                else if (index in 0 until results.itemCount) results.peek(index) else null
+                entry?.let { "${it.dictionaryPath}:${it.offset.value}:${it.word}" }
+                    ?: "search_result_$index"
+            },
+            contentType = { "search_result" }
         ) { index ->
-            results[index]?.let { entry ->
+            val entry = if (showStale) staleEntries.getOrNull(index)
+            else if (index in 0 until results.itemCount) results[index] else null
+            if (entry != null) {
                 SearchResultItem(
                     entry = entry,
                     resultIndex = index,
@@ -52,26 +59,6 @@ fun SearchResultsList(
                 )
             }
         }
-
-        when (results.loadState.append) {
-            is LoadState.Error -> {
-                item {
-                    Box(
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .padding(16.dp),
-                        contentAlignment = Alignment.Center
-                    ) {
-                        Text(
-                            text = stringResource(R.string.error_loading_more),
-                            style = MaterialTheme.typography.bodyMedium,
-                            color = MaterialTheme.colorScheme.error
-                        )
-                    }
-                }
-            }
-            else -> {}
-        }
     }
 }
 

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

@@ -1,23 +1,32 @@
 package com.example.research.ui.navigation
 
 import androidx.activity.compose.BackHandler
-import androidx.compose.material3.adaptive.ExperimentalMaterial3AdaptiveApi
+import androidx.compose.animation.AnimatedContent
+import androidx.compose.animation.AnimatedVisibility
+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.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
 import androidx.compose.material3.adaptive.currentWindowAdaptiveInfoV2
 import androidx.compose.runtime.*
 import androidx.compose.runtime.saveable.*
+import androidx.compose.ui.Modifier
 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.article.ArticleScreen
+import com.example.research.ui.article.ArticleState
 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,
@@ -29,11 +38,11 @@ enum class Screen {
     Home, Settings, Article, About
 }
 
-@OptIn(ExperimentalMaterial3AdaptiveApi::class)
 @Composable
 fun AppNavigation(
     searchViewModel: SearchViewModel,
-    settingsViewModel: SettingsViewModel
+    settingsViewModel: SettingsViewModel,
+    seedNoDictionaries: Boolean = false
 ) {
     val screenStack = rememberSaveable(
         saver = listSaver(
@@ -53,39 +62,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,
             )
@@ -99,6 +84,12 @@ fun AppNavigation(
         .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()) {
@@ -112,14 +103,33 @@ fun AppNavigation(
     }
 
     val articleState by searchViewModel.selectedArticle.collectAsStateWithLifecycle()
+    var lastShownArticle by remember { mutableStateOf<ArticleState?>(null) }
+    LaunchedEffect(articleState) {
+        if (articleState != null) lastShownArticle = articleState
+    }
 
     val effectiveScreen = when {
         currentScreen == Screen.About -> Screen.About
-        currentScreen == Screen.Article && articleState == null -> if (shouldShowSettings) Screen.Settings else Screen.Home
         shouldShowSettings -> Screen.Settings
-        else -> currentScreen
+        currentScreen == Screen.Settings -> Screen.Settings
+        else -> Screen.Home
     }
-    when (effectiveScreen) {
+    Box {
+    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,
@@ -150,18 +160,6 @@ fun AppNavigation(
                 onNavigateToAbout = { screenStack.add(Screen.About) }
             )
         }
-        Screen.Article -> {
-            ArticleRoute(
-                searchViewModel = searchViewModel,
-                onNavigateBack = {
-                    if (searchViewModel.navigateBackFromArticle()) {
-                        return@ArticleRoute
-                    }
-                    searchViewModel.onAction(SearchAction.ClearArticle)
-                    if (screenStack.size > 1) screenStack.removeAt(screenStack.lastIndex)
-                }
-            )
-        }
         Screen.About -> {
             AboutScreen(
                 onNavigateBack = {
@@ -169,5 +167,36 @@ fun AppNavigation(
                 }
             )
         }
+        Screen.Article -> {}
+        }
+    }
+
+    AnimatedVisibility(
+        visible = currentScreen == Screen.Article && articleState != null,
+        enter = fadeIn(tween(180)) + slideInHorizontally(tween(180)) { it / 3 },
+        exit = fadeOut(tween(180)) + slideOutHorizontally(tween(180)) { it / 3 },
+        label = "articleOverlay",
+    ) {
+        Surface(
+            modifier = Modifier.fillMaxSize(),
+            color = MaterialTheme.colorScheme.surface
+        ) {
+            ArticleScreen(
+                articleState = articleState ?: lastShownArticle,
+                onNavigateBack = {
+                    if (!searchViewModel.navigateBackFromArticle()) {
+                        searchViewModel.onAction(SearchAction.ClearArticle)
+                        if (screenStack.size > 1) screenStack.removeAt(screenStack.lastIndex)
+                    }
+                },
+                onRefClick = { word ->
+                    searchViewModel.onAction(SearchAction.SearchAndLoadArticle(word))
+                },
+                onScrollPositionChanged = { index, offset ->
+                    searchViewModel.updateArticleScrollPosition(index, offset)
+                },
+            )
+        }
+    }
     }
 }

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

@@ -10,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
@@ -14,9 +19,7 @@ import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.Icon
-import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.SnackbarHost
@@ -41,17 +44,18 @@ import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.lifecycle.repeatOnLifecycle
 import com.example.research.R
+import com.example.research.common.ui.AppBackButton
 import com.example.research.common.ui.appTestTag
 import com.example.research.common.ui.components.CollapsibleHeader
 import com.example.research.common.ui.components.SectionCard
 import com.example.research.ui.settings.components.DictionaryManagement
 import com.example.research.ui.settings.components.LanguageSelectionSection
+import com.example.research.ui.settings.components.SearchBarPositionSection
 import com.example.research.ui.settings.components.ThemeSelectionSection
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 
-@OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun SettingsRoute(
     viewModel: SettingsViewModel,
@@ -99,7 +103,6 @@ fun SettingsRoute(
     )
 }
 
-@OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun SettingsScreen(
     uiState: SettingsUiState,
@@ -121,12 +124,10 @@ fun SettingsScreen(
                 title = { Text(stringResource(R.string.settings_title)) },
                 navigationIcon = {
                     if (showBackButton) {
-                        IconButton(onClick = onNavigateBack) {
-                            Icon(
-                                painter = painterResource(R.drawable.ic_arrow_back),
-                                contentDescription = stringResource(R.string.action_back)
-                            )
-                        }
+                        AppBackButton(
+                            onClick = onNavigateBack,
+                            modifier = Modifier.padding(start = 6.dp)
+                        )
                     }
                 },
                 colors = TopAppBarDefaults.topAppBarColors(
@@ -235,6 +236,24 @@ fun SettingsScreen(
             }
             }
 
+            item(key = "search_bar", contentType = "settings-section") {
+                CollapsibleSettingsSection(
+                title = stringResource(R.string.search_bar_position),
+                iconRes = R.drawable.ic_search,
+                testTag = "search_bar_section",
+                isExpanded = uiState.isSearchBarExpanded,
+                onToggleExpanded = { onEvent(SettingsUiEvent.SectionToggled("search_bar", !uiState.isSearchBarExpanded)) },
+            ) {
+                SearchBarPositionSection(
+                    currentPosition = uiState.searchBarPosition,
+                    onPositionChanged = { position ->
+                        haptic.performHapticFeedback(HapticFeedbackType.TextHandleMove)
+                        onEvent(SettingsUiEvent.SearchBarPositionChanged(position))
+                    }
+                )
+            }
+            }
+
             item(key = "bottom-spacer", contentType = "spacer") {
                 Spacer(modifier = Modifier.height(32.dp))
             }
@@ -266,7 +285,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

@@ -3,6 +3,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.SearchBarPosition
 import com.example.research.core.domain.model.Dictionary
 import com.example.research.core.domain.model.DictionarySource
 import com.example.research.core.domain.model.IndexingProgress
@@ -13,8 +14,10 @@ import com.example.research.feature.download.model.DownloadState
 data class SettingsUiState(
     val theme: AppTheme = AppTheme.SYSTEM,
     val language: String = "system",
+    val searchBarPosition: SearchBarPosition = SearchBarPosition.TOP,
     val isThemeExpanded: Boolean = false,
     val isLanguageExpanded: Boolean = false,
+    val isSearchBarExpanded: Boolean = false,
     val isDictionariesExpanded: Boolean = true,
     val dictionaries: List<Dictionary> = emptyList(),
     val dictionaryStatus: DictionaryStatus = DictionaryStatus.Unknown,
@@ -23,12 +26,14 @@ 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",
 )
 
 sealed interface SettingsUiEvent {
     data class ThemeChanged(val theme: AppTheme) : SettingsUiEvent
     data class LanguageChanged(val language: String) : SettingsUiEvent
+    data class SearchBarPositionChanged(val position: SearchBarPosition) : SettingsUiEvent
     data class SectionToggled(val key: String, val isExpanded: Boolean) : SettingsUiEvent
     data class DictionaryToggled(val path: String) : SettingsUiEvent
     data class DictionaryDeleted(val dictionary: Dictionary) : SettingsUiEvent

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

@@ -7,7 +7,9 @@ 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.SearchBarPosition
 import com.example.research.core.domain.model.Dictionary
 import com.example.research.core.domain.model.DictionarySource
 import com.example.research.core.domain.model.IndexingProgress
@@ -16,9 +18,11 @@ 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
@@ -33,6 +37,16 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import java.util.concurrent.ConcurrentHashMap
 
+private const val STATUS_UP_TO_DATE = "UpToDate"
+private const val STATUS_NEEDS_UPDATE = "NeedsUpdate"
+private const val STATUS_EMPTY = "Empty"
+
+private data class PersistedDictionaryStatus(
+    val name: String,
+    val date: String,
+    val sourceIds: Set<String>,
+)
+
 private data class DictionaryStateInputs(
     val theme: AppTheme,
     val dictionarySources: List<DictionarySource>,
@@ -43,11 +57,13 @@ private data class DictionaryStateInputs(
 private data class OperationStateInputs(
     val downloadState: DownloadState,
     val language: String,
+    val searchBarPosition: SearchBarPosition,
     val importState: ImportState,
     val dictionaryStatus: DictionaryStatus,
     val hasCompletedStartupScan: Boolean,
     val isThemeExpanded: Boolean,
     val isLanguageExpanded: Boolean,
+    val isSearchBarExpanded: Boolean,
     val isDictionariesExpanded: Boolean,
 )
 
@@ -60,6 +76,8 @@ class SettingsViewModel(
     private val dictionaryImportManager: DictionaryImportManager,
     progressStateHolder: DictionaryProgressStateHolder,
     appVersion: String,
+    initialSectionExpansion: SectionExpansionStates,
+    initialSearchBarPosition: SearchBarPosition,
 ) : AndroidViewModel(application) {
 
     private val manageDictionarySourcesUseCase = ManageDictionarySourcesUseCase(
@@ -67,7 +85,16 @@ class SettingsViewModel(
         validator = DictionarySourceValidator(),
     )
 
-    private val _uiState = MutableStateFlow(SettingsUiState(appVersion = appVersion))
+    private val _uiState = MutableStateFlow(
+        SettingsUiState(
+            appVersion = appVersion,
+            isThemeExpanded = initialSectionExpansion.isThemeExpanded,
+            isLanguageExpanded = initialSectionExpansion.isLanguageExpanded,
+            isSearchBarExpanded = initialSectionExpansion.isSearchBarExpanded,
+            isDictionariesExpanded = initialSectionExpansion.isDictionariesExpanded,
+            searchBarPosition = initialSearchBarPosition,
+        )
+    )
     val uiState: StateFlow<SettingsUiState> = _uiState.asStateFlow()
 
     val progressSnapshot = progressStateHolder.progressSnapshot
@@ -85,17 +112,48 @@ class SettingsViewModel(
 
     private var cancelRefreshPending = false
     private var errorStateHandled = false
+    private var successStateHandled = false
     private var statusBeforeDownload: DictionaryStatus = DictionaryStatus.Unknown
 
     init {
         setupStateObservation()
+        observeDictionariesForSeedFlag()
+        persistDictionaryStatus()
         initialize()
     }
 
+    private fun persistDictionaryStatus() {
+        viewModelScope.launch {
+            dictionaryStatus.collect { status ->
+                val persisted = when (status) {
+                    DictionaryStatus.UpToDate ->
+                        "$STATUS_UP_TO_DATE|${DateUtils.getCurrentDateString()}"
+                    is DictionaryStatus.NeedsUpdate ->
+                        "$STATUS_NEEDS_UPDATE|${DateUtils.getCurrentDateString()}|" +
+                            status.sourceIds.joinToString(",")
+                    DictionaryStatus.Empty ->
+                        "$STATUS_EMPTY|${DateUtils.getCurrentDateString()}"
+                    else -> null
+                }
+                if (persisted != null) {
+                    preferencesManager.saveDictionaryStatus(persisted)
+                }
+            }
+        }
+    }
+
+    private fun observeDictionariesForSeedFlag() {
+        viewModelScope.launch {
+            localDictionaryRepository.dictionaries.collect { dictionaries ->
+                if (hasCompletedStartupScan.value) {
+                    preferencesManager.setHadNoDictionaries(dictionaries.isEmpty())
+                }
+            }
+        }
+    }
+
     private fun setupStateObservation() {
         viewModelScope.launch {
-            var wasIndexing = false
-
             val dictionaryStateInputs = combine(
                 preferencesManager.themeMode.map { mode ->
                     try { AppTheme.valueOf(mode) } catch (_: Exception) { AppTheme.SYSTEM }
@@ -114,55 +172,65 @@ class SettingsViewModel(
             val operationStateInputs = combine(
                 downloadManager.downloadState,
                 language,
+                preferencesManager.searchBarPosition,
                 dictionaryImportManager.importState,
                 dictionaryStatus,
                 hasCompletedStartupScan,
                 preferencesManager.isThemeExpanded,
                 preferencesManager.isLanguageExpanded,
+                preferencesManager.isSearchBarExpanded,
                 preferencesManager.isDictionariesExpanded,
             ) { params: Array<Any> ->
                 @Suppress("UNCHECKED_CAST")
                 OperationStateInputs(
                     downloadState = params[0] as DownloadState,
                     language = params[1] as String,
-                    importState = params[2] as ImportState,
-                    dictionaryStatus = params[3] as DictionaryStatus,
-                    hasCompletedStartupScan = params[4] as Boolean,
-                    isThemeExpanded = params[5] as Boolean,
-                    isLanguageExpanded = params[6] as Boolean,
-                    isDictionariesExpanded = params[7] as Boolean,
+                    searchBarPosition = params[2] as SearchBarPosition,
+                    importState = params[3] as ImportState,
+                    dictionaryStatus = params[4] as DictionaryStatus,
+                    hasCompletedStartupScan = params[5] as Boolean,
+                    isThemeExpanded = params[6] as Boolean,
+                    isLanguageExpanded = params[7] as Boolean,
+                    isSearchBarExpanded = params[8] as Boolean,
+                    isDictionariesExpanded = params[9] as Boolean,
                 )
             }
 
             combine(dictionaryStateInputs, operationStateInputs) { dictionaryState, operationState ->
-                // Handle indexing completion side effect
                 val isIndexing = dictionaryState.indexingProgress.isIndexing
-                if (wasIndexing && !isIndexing) {
-                    if (isDownloadInProgress) {
-                        isDownloadInProgress = false
-                        dictionaryStatus.value = DictionaryStatus.UpToDate
-                    }
-                }
-                wasIndexing = isIndexing
-
                 when (operationState.downloadState) {
                     is DownloadState.Loading, is DownloadState.Extracting -> {
                         isDownloadInProgress = true
                         cancelRefreshPending = false
                         errorStateHandled = false
+                        successStateHandled = false
                     }
                     is DownloadState.Success -> {
                         pendingSourceUrls.clear()
+                        isDownloadInProgress = false
+                        if (!successStateHandled) {
+                            successStateHandled = true
+                            dictionaryStatus.value = withContext(Dispatchers.IO) {
+                                evaluateDictionaryStatus()
+                            }
+                        }
                     }
                     is DownloadState.Error -> {
+                        val startedHere = statusBeforeDownload != DictionaryStatus.Unknown ||
+                            isDownloadInProgress
                         isDownloadInProgress = false
                         if (!errorStateHandled) {
                             errorStateHandled = true
-                            dictionaryStatus.value = if (dictionaryState.dictionaries.isEmpty()) {
-                                DictionaryStatus.Empty
-                            } else when (statusBeforeDownload) {
-                                DictionaryStatus.Unknown, DictionaryStatus.Checking -> DictionaryStatus.UpToDate
-                                else -> statusBeforeDownload
+                            if (dictionaryState.dictionaries.isEmpty()) {
+                                dictionaryStatus.value = DictionaryStatus.Empty
+                            } else if (startedHere) {
+                                when (statusBeforeDownload) {
+                                    DictionaryStatus.Unknown, DictionaryStatus.Checking ->
+                                        viewModelScope.launch {
+                                            restoreOrEvaluateDictionaryStatus()
+                                        }
+                                    else -> dictionaryStatus.value = statusBeforeDownload
+                                }
                             }
                             if (pendingSourceUrls.isNotEmpty()) {
                                 pendingSourceUrls.forEach { urlTemplate ->
@@ -201,7 +269,6 @@ class SettingsViewModel(
                             refreshDictionaryStatus()
                         }
                     }
-                    else -> {}
                 }
 
                 SettingsUiState(
@@ -211,11 +278,16 @@ class SettingsViewModel(
                     indexingProgress = IndexingProgress(isIndexing = isIndexing),
                     downloadState = operationState.downloadState,
                     language = operationState.language,
+                    searchBarPosition = operationState.searchBarPosition,
                     importState = operationState.importState,
                     dictionaryStatus = operationState.dictionaryStatus,
                     hasCompletedStartupScan = operationState.hasCompletedStartupScan,
+                    pipelineIdle = !isIndexing &&
+                        !operationState.downloadState.isActive &&
+                        !operationState.importState.isActive,
                     isThemeExpanded = operationState.isThemeExpanded,
                     isLanguageExpanded = operationState.isLanguageExpanded,
+                    isSearchBarExpanded = operationState.isSearchBarExpanded,
                     isDictionariesExpanded = operationState.isDictionariesExpanded,
                     appVersion = _uiState.value.appVersion,
                 )
@@ -226,9 +298,15 @@ class SettingsViewModel(
     }
 
     private fun initialize() {
+        var scanCompleted = false
         viewModelScope.launch {
             try {
-                scanDirectoryInternal(preferencesManager.dictionaryPath)
+                scanCompleted = if (localDictionaryRepository.dictionaries.value.isEmpty()) {
+                    scanDirectoryInternal(preferencesManager.dictionaryPath) is OperationResult.Success
+                } else {
+                    restoreOrEvaluateDictionaryStatus()
+                    false
+                }
             } catch (e: Exception) {
                 android.util.Log.e("SettingsViewModel", "Initial scan failed", e)
                 dictionaryStatus.value = if (localDictionaryRepository.dictionaries.value.isEmpty()) {
@@ -245,6 +323,11 @@ class SettingsViewModel(
                     android.util.Log.w("SettingsViewModel", "Failed to load language preference: ${e.message}")
                 }
                 hasCompletedStartupScan.value = true
+                if (scanCompleted) {
+                    preferencesManager.setHadNoDictionaries(
+                        localDictionaryRepository.dictionaries.value.isEmpty()
+                    )
+                }
             }
         }
     }
@@ -253,6 +336,7 @@ class SettingsViewModel(
         when (event) {
             is SettingsUiEvent.ThemeChanged -> setTheme(event.theme)
             is SettingsUiEvent.LanguageChanged -> saveLanguage(event.language)
+            is SettingsUiEvent.SearchBarPositionChanged -> saveSearchBarPosition(event.position)
             is SettingsUiEvent.SectionToggled -> saveSectionExpanded(event.key, event.isExpanded)
             is SettingsUiEvent.DictionaryToggled -> toggleDictionaryActive(event.path)
             is SettingsUiEvent.DictionaryDeleted -> deleteDictionary(event.dictionary)
@@ -302,8 +386,8 @@ class SettingsViewModel(
                 return DictionaryStatus.UpToDate
             }
 
-            val upToDate = dictionaryRepository.areDictionariesUpToDate(enabledSources)
-            return if (upToDate) DictionaryStatus.UpToDate else DictionaryStatus.NeedsUpdate
+            val updatable = dictionaryRepository.sourcesWithUpdates(enabledSources)
+            return if (updatable.isEmpty()) DictionaryStatus.UpToDate else DictionaryStatus.NeedsUpdate(updatable)
         } catch (e: Exception) {
             android.util.Log.e("SettingsViewModel", "evaluateDictionaryStatus: Error", e)
             if (localDictionaryRepository.dictionaries.value.isNotEmpty()) {
@@ -325,6 +409,12 @@ class SettingsViewModel(
         }
     }
 
+    private fun saveSearchBarPosition(position: SearchBarPosition) {
+        viewModelScope.launch {
+            preferencesManager.saveSearchBarPosition(position)
+        }
+    }
+
     private fun saveLanguage(languageCode: String) {
         viewModelScope.launch {
             preferencesManager.saveLanguage(languageCode)
@@ -482,6 +572,86 @@ class SettingsViewModel(
     ): List<DictionarySource> =
         DictionarySourceFileMatcher.installedSources(sources, dictionaries)
 
+    private suspend fun restoreOrEvaluateDictionaryStatus() {
+        val restored = restorePersistedDictionaryStatus()
+        if (restored != null) {
+            dictionaryStatus.value = restored
+            return
+        }
+        dictionaryStatus.value = DictionaryStatus.Checking
+        dictionaryStatus.value = withContext(Dispatchers.IO) { evaluateDictionaryStatus() }
+    }
+
+    private suspend fun restorePersistedDictionaryStatus(): DictionaryStatus? {
+        val persisted = readPersistedDictionaryStatus() ?: return null
+        if (persisted.date != DateUtils.getCurrentDateString()) return null
+        return when (persisted.name) {
+            STATUS_UP_TO_DATE ->
+                if (withContext(Dispatchers.IO) { installedDictionariesAreCurrent() }) {
+                    DictionaryStatus.UpToDate
+                } else {
+                    null
+                }
+            STATUS_NEEDS_UPDATE -> {
+                val updatableIds = withContext(Dispatchers.IO) { sourcesMissingTodaysFile() }
+                val restorableIds = persisted.sourceIds intersect updatableIds
+                if (restorableIds.isNotEmpty()) DictionaryStatus.NeedsUpdate(restorableIds) else null
+            }
+            else -> null
+        }
+    }
+
+    private suspend fun readPersistedDictionaryStatus(): PersistedDictionaryStatus? {
+        val raw = preferencesManager.dictionaryStatus() ?: return null
+        val parts = raw.split('|')
+        if (parts.isEmpty() || parts.first().isEmpty()) return null
+        return PersistedDictionaryStatus(
+            name = parts.first(),
+            date = parts.getOrElse(1) { "" },
+            sourceIds = parts.getOrElse(2) { "" }
+                .split(',')
+                .map(String::trim)
+                .filter(String::isNotEmpty)
+                .toSet(),
+        )
+    }
+
+    private suspend fun sourcesMissingTodaysFile(): Set<String> {
+        val sources = preferencesManager.dictionarySources.first()
+        val dictionaries = localDictionaryRepository.dictionaries.first()
+        val datedEnabledSources = installedEnabledSources(sources, dictionaries)
+            .filter { DictionarySource.hasDatePlaceholder(it.urlTemplate) }
+        if (datedEnabledSources.isEmpty()) return emptySet()
+        val fileNames = localDictionaryRepository.listDictionaryPayloadFileNames(
+            preferencesManager.dictionaryPath
+        ) ?: return emptySet()
+        val today = DateUtils.getCurrentDateString()
+        return datedEnabledSources
+            .filterNot { source -> fileNames.any { it.startsWith(fileBaseNameFor(source, today)) } }
+            .mapTo(mutableSetOf(), DictionarySource::id)
+    }
+
+    private fun fileBaseNameFor(source: DictionarySource, date: String): String =
+        DictionarySource.extractFileName(source.urlTemplate, date)
+            .removeSuffix(".gz")
+            .removeSuffix(".dsl")
+            .removeSuffix(".dz")
+
+    private suspend fun installedDictionariesAreCurrent(): Boolean {
+        val sources = preferencesManager.dictionarySources.first()
+        val dictionaries = localDictionaryRepository.dictionaries.first()
+        val datedEnabledSources = installedEnabledSources(sources, dictionaries)
+            .filter { DictionarySource.hasDatePlaceholder(it.urlTemplate) }
+        if (datedEnabledSources.isEmpty()) return true
+        val fileNames = localDictionaryRepository.listDictionaryPayloadFileNames(
+            preferencesManager.dictionaryPath
+        ) ?: return true
+        val today = DateUtils.getCurrentDateString()
+        return datedEnabledSources.all { source ->
+            fileNames.any { it.startsWith(fileBaseNameFor(source, today)) }
+        }
+    }
+
     private fun cancelDownload() {
         // Cancel the ViewModel-side scan job so no further status recomputes
         localDictionaryRepository.cancelIndexing()
@@ -534,9 +704,7 @@ class SettingsViewModel(
                     dictionaryStatus.value = DictionaryStatus.UpToDate
                     isDownloadInProgress = false
                 } else {
-                    dictionaryStatus.value = DictionaryStatus.Checking
-                    val status = withContext(Dispatchers.IO) { evaluateDictionaryStatus() }
-                    dictionaryStatus.value = status
+                    restoreOrEvaluateDictionaryStatus()
                 }
 
                 if (result.data > 0) {

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

@@ -50,6 +50,7 @@ import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
 import com.example.research.R
+import com.example.research.common.ui.components.BadgedIcon
 import com.example.research.core.domain.model.Dictionary
 import kotlinx.coroutines.launch
 
@@ -84,7 +85,8 @@ fun DictionaryListItem(
     onToggle: () -> Unit,
     onDelete: () -> Unit,
     modifier: Modifier = Modifier,
-    isDeleteBlocked: () -> Boolean = { false }
+    isDeleteBlocked: () -> Boolean = { false },
+    hasUpdate: Boolean = false,
 ) {
     val haptic = LocalHapticFeedback.current
     val density = LocalDensity.current
@@ -195,11 +197,15 @@ fun DictionaryListItem(
                 modifier = Modifier.size(IconButtonSize),
                 contentAlignment = Alignment.Center
             ) {
-                Icon(
+                BadgedIcon(
                     painter = painterResource(R.drawable.ic_book),
-                    contentDescription = null,
                     tint = MaterialTheme.colorScheme.primary,
-                    modifier = Modifier.size(IconSize)
+                    size = IconSize,
+                    badgeDescription = if (hasUpdate) {
+                        stringResource(R.string.dictionary_update_available)
+                    } else {
+                        null
+                    },
                 )
             }
 

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

@@ -1,12 +1,23 @@
 package com.example.research.ui.settings.components
 
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.animation.core.tween
+import androidx.compose.animation.expandVertically
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.shrinkVertically
 import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.statusBars
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.ModalBottomSheet
-import androidx.compose.material3.rememberModalBottomSheetState
+import androidx.compose.material3.SheetValue
+import androidx.compose.material3.rememberBottomSheetState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.derivedStateOf
@@ -15,15 +26,17 @@ 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.hideFromAccessibility
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.unit.dp
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
@@ -35,6 +48,7 @@ import com.example.research.common.ui.components.CollapsibleHeader
 import com.example.research.common.ui.components.EmptyState
 import com.example.research.common.ui.components.SectionCard
 import com.example.research.core.domain.model.Dictionary
+import com.example.research.core.domain.usecase.DictionarySourceFileMatcher
 import com.example.research.core.domain.model.DictionarySource
 import com.example.research.feature.download.model.DownloadState
 import com.example.research.ui.settings.ImportState
@@ -63,7 +77,10 @@ fun DictionaryManagement(
 ) {
     val (showUrlBottomSheet, setShowUrlBottomSheet) = remember { mutableStateOf(false) }
 
-    val sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = true)
+    val sheetState = rememberBottomSheetState(
+        initialValue = SheetValue.Hidden,
+        enabledValues = setOf(SheetValue.Hidden, SheetValue.Expanded),
+    )
     val haptic = LocalHapticFeedback.current
     val focusManager = LocalFocusManager.current
 
@@ -78,12 +95,26 @@ fun DictionaryManagement(
         derivedStateOf { importState is ImportState.Importing || importState is ImportState.Extracting }
     }
     val hasEnabledSources by remember(sources) { derivedStateOf { sources.any { it.isEnabled } } }
-    val isBlockingMutations = isInProgress
+    val isUpdateAvailable = dictionaryStatus is DictionaryStatus.NeedsUpdate &&
+        !isInProgress && hasEnabledSources && dictionaries.isNotEmpty()
+    val updatablePaths = remember(dictionaryStatus, sources, dictionaries, isUpdateAvailable) {
+        val ids = (dictionaryStatus as? DictionaryStatus.NeedsUpdate)?.sourceIds
+        if (!isUpdateAvailable || ids.isNullOrEmpty()) {
+            emptySet()
+        } else {
+            val updatableSources = sources.filter { it.id in ids }
+            dictionaries
+                .filter { dictionary ->
+                    updatableSources.any { DictionarySourceFileMatcher.matches(it, dictionary) }
+                }
+                .mapTo(mutableSetOf(), Dictionary::path)
+        }
+    }
 
     // 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 isMutationsBlockedState = rememberUpdatedState(isInProgress)
     val isDeleteBlocked = remember { { isMutationsBlockedState.value } }
 
     SectionCard(
@@ -107,10 +138,19 @@ fun DictionaryManagement(
                 isExpanded = isExpanded,
                 onToggle = onToggleExpanded,
                 subtitle = headerSubtitle,
-                testTag = "dictionary_header"
+                testTag = "dictionary_header",
+                badgeDescription = if (isUpdateAvailable && !isExpanded) {
+                    stringResource(R.string.dictionaries_update_available)
+                } else {
+                    null
+                },
             )
 
-            if (isExpanded) {
+            AnimatedVisibility(
+                visible = isExpanded,
+                enter = expandVertically(animationSpec = tween(250)) + fadeIn(tween(250)),
+                exit = shrinkVertically(animationSpec = tween(200)) + fadeOut(tween(200)),
+            ) {
                  Column(
                     modifier = Modifier
                         .fillMaxWidth()
@@ -135,13 +175,13 @@ fun DictionaryManagement(
 
                     // Disable accessibility on background content during import to improve performance.
                     // The progress dialog remains accessible for cancellation.
-                    val backgroundModifier = if (isBlockingMutations) {
-                        Modifier.semantics { invisibleToUser() }
+                    val backgroundModifier = if (isInProgress) {
+                        Modifier.semantics { hideFromAccessibility() }
                     } else {
                         Modifier
                     }
 
-                    if (dictionaries.isEmpty() && !isBlockingMutations) {
+                    if (dictionaries.isEmpty() && !isInProgress) {
                         Column(
                             modifier = backgroundModifier
                                 .fillMaxWidth()
@@ -163,7 +203,7 @@ fun DictionaryManagement(
                             )
                         }
                     } else {
-                        if (dictionaryStatus is DictionaryStatus.NeedsUpdate && !isBlockingMutations && hasEnabledSources) {
+                        if (isUpdateAvailable) {
                             DictionaryUpdateCard(
                                 onStartDownload = onStartDownload,
                                 modifier = backgroundModifier
@@ -177,10 +217,11 @@ fun DictionaryManagement(
                             modifier = Modifier
                                 .fillMaxWidth()
                                 .then(backgroundModifier),
-                            isDeleteBlocked = isDeleteBlocked
+                            isDeleteBlocked = isDeleteBlocked,
+                            updatablePaths = updatablePaths,
                         )
 
-                        if (!isBlockingMutations) {
+                        if (!isInProgress) {
                             DictionaryActionButtons(
                                 onAddSource = {
                                     haptic.performHapticFeedback(HapticFeedbackType.TextHandleMove)
@@ -205,7 +246,8 @@ fun DictionaryManagement(
                 focusManager.clearFocus(force = true)
                 setShowUrlBottomSheet(false)
             },
-            sheetState = sheetState
+            sheetState = sheetState,
+            contentWindowInsets = { WindowInsets.statusBars }
         ) {
             DictionaryUrlInputContent(
                 existingSources = sources,
@@ -248,6 +290,7 @@ private fun DictionaryProgressSectionHost(
         label = label,
         onCancel = onCancel,
         percent = progressSnapshot?.percent ?: 0,
+        indeterminate = progressSnapshot?.indeterminate ?: false,
         testTag = progressTestTag,
     )
 }
@@ -258,20 +301,38 @@ private fun DictionaryListSection(
     onToggleDictionary: (String) -> Unit,
     onDeleteDictionary: (Dictionary) -> Unit,
     modifier: Modifier = Modifier,
-    isDeleteBlocked: () -> Boolean = { false }
+    isDeleteBlocked: () -> Boolean = { false },
+    updatablePaths: Set<String> = emptySet(),
 ) {
+    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) {
-                DictionaryListItem(
-                    dictionary = dictionary,
-                    onToggle = { onToggleDictionary(dictionary.path) },
-                    onDelete = { onDeleteDictionary(dictionary) },
-                    isDeleteBlocked = isDeleteBlocked
+                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) },
+                        isDeleteBlocked = isDeleteBlocked,
+                        hasUpdate = dictionary.path in updatablePaths,
+                    )
+                }
             }
         }
     }

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
@@ -12,6 +12,7 @@ import androidx.compose.foundation.layout.*
 import androidx.compose.ui.res.painterResource
 import androidx.compose.material3.*
 import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.platform.testTag
@@ -19,6 +20,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,
@@ -27,6 +32,7 @@ fun DictionaryProgressSection(
     onCancel: () -> Unit,
     modifier: Modifier = Modifier,
     percent: Int,
+    indeterminate: Boolean,
     testTag: String,
 ) {
     AnimatedVisibility(
@@ -40,6 +46,7 @@ fun DictionaryProgressSection(
         var displayedLabel by remember { mutableStateOf(label) }
         var displayedPercent by remember { mutableIntStateOf(percent) }
         var displayedTestTag by remember { mutableStateOf(testTag) }
+        var displayedIndeterminate by remember { mutableStateOf(indeterminate) }
 
         LaunchedEffect(visible) {
             if (visible) {
@@ -56,13 +63,24 @@ fun DictionaryProgressSection(
                 displayedLabel = label
                 displayedPercent = percent
                 displayedTestTag = testTag
+                displayedIndeterminate = indeterminate
             }
         }
-        val animatedProgress by animateFloatAsState(
-            targetValue = monotonicTargetProgress,
-            animationSpec = tween(durationMillis = 650, easing = FastOutSlowInEasing),
-            label = "dictionary-progress"
-        )
+        val animatedState = remember { Animatable(0f) }
+        LaunchedEffect(monotonicTargetProgress) {
+            val delta = monotonicTargetProgress - animatedState.value
+            if (delta > 0f) {
+                animatedState.animateTo(
+                    targetValue = monotonicTargetProgress,
+                    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(
@@ -74,21 +92,33 @@ fun DictionaryProgressSection(
                     style = MaterialTheme.typography.bodySmall,
                     color = MaterialTheme.colorScheme.primary
                 )
-                Text(
-                    text = "$displayedPercent%",
-                    style = MaterialTheme.typography.bodySmall,
-                    color = MaterialTheme.colorScheme.primary
-                )
+                if (!displayedIndeterminate) {
+                    Text(
+                        text = "$displayedPercent%",
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.primary
+                    )
+                }
             }
-            Spacer(Modifier.height(8.dp))
-            LinearProgressIndicator(
-                progress = { animatedProgress },
+            Box(
                 modifier = Modifier
                     .fillMaxWidth()
-                    .height(4.dp)
-                    .clip(MaterialTheme.shapes.small),
-            )
-            Spacer(Modifier.height(8.dp))
+                    .height(WavyProgressIndicatorDefaults.LinearContainerHeight),
+                contentAlignment = Alignment.Center,
+            ) {
+                if (displayedIndeterminate) {
+                    LinearWavyProgressIndicator(modifier = Modifier.fillMaxWidth())
+                } else {
+                    LinearProgressIndicator(
+                        progress = { animatedProgress },
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .height(4.dp)
+                            .clip(MaterialTheme.shapes.small),
+                    )
+                }
+            }
+            Spacer(Modifier.height(4.dp))
             OutlinedButton(
                 onClick = onCancel,
                 modifier = Modifier.fillMaxWidth(),

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

@@ -3,6 +3,9 @@ package com.example.research.ui.settings.components
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.foundation.text.input.InputTransformation
+import androidx.compose.foundation.text.input.TextFieldLineLimits
+import androidx.compose.foundation.text.input.TextFieldState
 import androidx.compose.foundation.verticalScroll
 import androidx.compose.ui.res.painterResource
 import androidx.compose.material3.*
@@ -16,7 +19,6 @@ import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.semantics.testTagsAsResourceId
 import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.text.input.KeyboardType
-import androidx.compose.ui.text.input.TextFieldValue
 import androidx.compose.ui.unit.dp
 import com.example.research.R
 import com.example.research.core.domain.model.DictionarySource
@@ -64,6 +66,29 @@ private fun validateDictionaryUrl(context: UrlValidationContext): String? {
     }
 }
 
+private val urlSplitRegex = Regex("[\\s,;]+")
+
+private fun splitPastedUrls(text: String): List<String>? =
+    text.split(urlSplitRegex).filter { it.isNotEmpty() }.takeIf { tokens ->
+        tokens.size > 1 && tokens.all {
+            DictionarySource.validateTemplate(it) is DictionarySource.ValidationResult.Valid
+        }
+    }
+
+private val urlInputTransformation = InputTransformation {
+    val text = toString()
+    val filtered = text
+        .take(2048)
+        .filter { char ->
+            !char.isISOControl() &&
+                char != '\u0000' &&
+                char.code !in 128..<160
+        }
+    if (filtered != text) {
+        replace(0, length, filtered)
+    }
+}
+
 @Composable
 fun DictionaryUrlInputContent(
     existingSources: List<DictionarySource>,
@@ -71,11 +96,22 @@ fun DictionaryUrlInputContent(
     onCancel: () -> Unit,
     modifier: Modifier = Modifier
 ) {
-    val urls = remember { mutableStateListOf(TextFieldValue("")) }
+    val urls = remember { mutableStateListOf(TextFieldState("")) }
     val validationErrors = remember { mutableStateMapOf<Int, String>() }
     val scrollState = rememberScrollState()
     val focusManager = LocalFocusManager.current
 
+    LaunchedEffect(Unit) {
+        snapshotFlow { urls.map { it.text.toString() } }.collect { texts ->
+            val (index, tokens) = texts.withIndex().firstNotNullOfOrNull { (i, text) ->
+                splitPastedUrls(text)?.let { i to it }
+            } ?: return@collect
+            urls[index].edit { replace(0, length, tokens.first()) }
+            urls.addAll(index + 1, tokens.subList(1, tokens.size).map { TextFieldState(it) })
+            validationErrors.clear()
+        }
+    }
+
     val errorMessages = ErrorMessages(
         empty = stringResource(R.string.dictionary_source_url_empty),
         duplicateInForm = stringResource(R.string.dictionary_source_duplicate_in_form),
@@ -96,8 +132,8 @@ fun DictionaryUrlInputContent(
     // Cache prefixes for all input URLs to avoid repeated extraction during recomposition
     val inputUrlPrefixes = remember {
         derivedStateOf {
-            urls.associate { urlValue ->
-                val urlString = urlValue.text.trim()
+            urls.associate { urlState ->
+                val urlString = urlState.trimmedText()
                 urlString to if (urlString.isNotEmpty()) {
                     DictionarySource.extractPrefix(urlString)
                 } else null
@@ -119,10 +155,10 @@ fun DictionaryUrlInputContent(
             style = MaterialTheme.typography.headlineSmall
         )
 
-        urls.forEachIndexed { index, urlValue ->
+        urls.forEachIndexed { index, urlState ->
             val isLastItem = index == urls.lastIndex
-            
-            val urlString = urlValue.text.trim()
+
+            val urlString = urlState.trimmedText()
             val cachedPrefix = inputUrlPrefixes.value[urlString]
             val realtimeError = remember(urlString, existingPrefixes, urls.size, cachedPrefix) {
                 validateDictionaryUrl(
@@ -130,7 +166,7 @@ fun DictionaryUrlInputContent(
                         url = urlString,
                         existingSources = existingSources,
                         existingPrefixes = existingPrefixes,
-                        urlsInForm = urls.map { it.text.trim() },
+                        urlsInForm = urls.map { it.trimmedText() },
                         urlPrefix = cachedPrefix,
                         errorMessages = errorMessages
                     )
@@ -140,20 +176,8 @@ fun DictionaryUrlInputContent(
             val displayError = validationErrors[index] ?: realtimeError
 
             OutlinedTextField(
-                value = urlValue,
-                onValueChange = { newValue ->
-                    val filtered = newValue.copy(
-                        text = newValue.text
-                            .take(2048)
-                            .filter { char -> 
-                                !char.isISOControl() && 
-                                char != '\u0000' &&
-                                        char.code !in 128..<160
-                            }
-                    )
-                    urls[index] = filtered
-                    validationErrors.remove(index)
-                },
+                state = urlState,
+                inputTransformation = urlInputTransformation,
                 label = { Text(if (index == 0) stringResource(R.string.dictionary_source_url_hint) else "URL ${index + 1}") },
                 isError = displayError != null,
                 supportingText = displayError?.let { { Text(it) } },
@@ -168,7 +192,7 @@ fun DictionaryUrlInputContent(
                             Modifier
                         }
                     ),
-                singleLine = true,
+                lineLimits = TextFieldLineLimits.SingleLine,
                 keyboardOptions = KeyboardOptions(
                     keyboardType = KeyboardType.Uri,
                     imeAction = if (isLastItem) ImeAction.Done else ImeAction.Next
@@ -188,7 +212,7 @@ fun DictionaryUrlInputContent(
 
         TextButton(
             onClick = {
-                urls.add(TextFieldValue(""))
+                urls.add(TextFieldState(""))
             },
             modifier = Modifier
                 .align(Alignment.Start)
@@ -224,8 +248,8 @@ fun DictionaryUrlInputContent(
                     val validUrls = mutableListOf<String>()
                     val seenUrls = mutableSetOf<String>()
 
-                    urls.forEachIndexed { index, urlValue ->
-                        val urlString = urlValue.text.trim()
+                    urls.forEachIndexed { index, urlState ->
+                        val urlString = urlState.trimmedText()
                         if (urlString.isBlank()) {
                             if (urls.size == 1) {
                                 validationErrors[index] = errorMessages.empty
@@ -263,9 +287,9 @@ fun DictionaryUrlInputContent(
                     .weight(1f)
                     .testTag("add_confirm_button")
                     .semantics { testTagsAsResourceId = true },
-                enabled = urls.any { it.text.trim().isNotBlank() } &&
-                         urls.none { urlValue ->
-                             val urlString = urlValue.text.trim()
+                enabled = urls.any { it.trimmedText().isNotBlank() } &&
+                         urls.none { urlState ->
+                             val urlString = urlState.trimmedText()
                              if (urlString.isEmpty()) {
                                  false
                              } else {
@@ -275,7 +299,7 @@ fun DictionaryUrlInputContent(
                                          url = urlString,
                                          existingSources = existingSources,
                                          existingPrefixes = existingPrefixes,
-                                         urlsInForm = urls.map { it.text.trim() },
+                                         urlsInForm = urls.map { it.trimmedText() },
                                          urlPrefix = urlPrefix,
                                          errorMessages = errorMessages
                                      )
@@ -289,3 +313,5 @@ fun DictionaryUrlInputContent(
         Spacer(modifier = Modifier.height(8.dp))
     }
 }
+
+private fun TextFieldState.trimmedText(): String = text.trim().toString()

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

@@ -0,0 +1,40 @@
+package com.example.research.ui.settings.components
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.unit.dp
+import com.example.research.R
+import com.example.research.common.ui.components.OutlinedChoiceButton
+import com.example.research.core.domain.model.SearchBarPosition
+
+@Composable
+fun SearchBarPositionSection(
+    currentPosition: SearchBarPosition,
+    onPositionChanged: (SearchBarPosition) -> Unit,
+    modifier: Modifier = Modifier
+) {
+    Row(
+        modifier = modifier.fillMaxWidth(),
+        horizontalArrangement = Arrangement.spacedBy(4.dp)
+    ) {
+        SearchBarPosition.entries.forEach { position ->
+            val isSelected = currentPosition == position
+            OutlinedChoiceButton(
+                text = when (position) {
+                    SearchBarPosition.TOP -> stringResource(R.string.search_bar_position_top)
+                    SearchBarPosition.BOTTOM -> stringResource(R.string.search_bar_position_bottom)
+                },
+                onClick = { onPositionChanged(position) },
+                modifier = Modifier
+                    .weight(1f)
+                    .testTag("search_bar_${position.name}"),
+                selected = isSelected
+            )
+        }
+    }
+}

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

@@ -6,7 +6,8 @@ object Spacing {
     // Semantic spacing constants for specific UI elements
     val topBarPadding = 8.dp
     val topBarHeight = 56.dp
-    val iconStart = 32.dp
-    val searchTextStart = 68.dp
+    val topBarCenter = topBarPadding + topBarHeight / 2
     val listItemVertical = 8.dp
+
+    val contentStart = 32.dp
 }

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

@@ -24,12 +24,20 @@ object AppWindowInsets {
         @Composable
         get() = WindowInsets.navigationBars.union(WindowInsets.ime)
 
+    val statusBarsAndIme: WindowInsets
+        @Composable
+        get() = WindowInsets.statusBars.union(WindowInsets.ime)
+
     val fullScreen: WindowInsets
         @Composable
         get() = WindowInsets.statusBars
             .union(WindowInsets.navigationBars)
             .union(WindowInsets.displayCutout)
 
+    val bottomNavigation: WindowInsets
+        @Composable
+        get() = WindowInsets.navigationBars.only(WindowInsetsSides.Bottom)
+
     val navigationOnly: WindowInsets
         @Composable
         get() = WindowInsets.navigationBars

app/src/main/res/drawable/ic_history.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M13,3A9,9 0 0,0 4,12H1L4.89,15.89L4.96,16.03L9,12H6A7,7 0 0,1 13,5A7,7 0 0,1 20,12A7,7 0 0,1 13,19C11.07,19 9.32,18.21 8.06,16.94L6.64,18.36C8.27,19.99 10.51,21 13,21A9,9 0 0,0 22,12A9,9 0 0,0 13,3M12,8V13L16.28,15.54L17,14.33L13.5,12.25V8H12Z" />
+</vector>

app/src/main/res/drawable/ic_manage_search.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M7,9H2V7h5v2zM7,12H2v2h5v-2zM20.59,19l-3.83,-3.83c-0.8,0.52 -1.74,0.83 -2.76,0.83 -2.76,0 -5,-2.24 -5,-5s2.24,-5 5,-5 5,2.24 5,5c0,1.02 -0.31,1.96 -0.83,2.75L22,17.59 20.59,19zM17,11c0,-1.65 -1.35,-3 -3,-3s-3,1.35 -3,3 1.35,3 3,3 3,-1.35 3,-3zM2,19h10v-2H2v2z" />
+</vector>

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

@@ -2,7 +2,6 @@
     <string name="app_name">ReSearch</string>
     <string name="settings_title">Настройки</string>
     <string name="action_back">Назад</string>
-    <string name="version_format">v%1$s</string>
     <string name="version_unknown">неизвестно</string>
     <string name="button_cancel_download">Отмена</string>
     <string name="action_ok">ОК</string>
@@ -12,9 +11,13 @@
     <string name="language_english">Английский</string>
     <string name="language_russian">Русский</string>
     <string name="language_system">Системный</string>
-    <string name="indexing_label">Индексация словарей</string>
+    <string name="search_bar_position">Строка поиска</string>
+    <string name="search_bar_position_top">Наверху</string>
+    <string name="search_bar_position_bottom">Внизу</string>
     <string name="clear_search">Очистить поиск</string>
-    <string name="article_no_selected">Статья не выбрана</string>
+    <string name="recent_searches">История поиска</string>
+    <string name="clear_search_history">Очистить</string>
+    <string name="remove_search_history_entry">Удалить из истории</string>
     <string name="article_return_to_search">Вернуться к поиску</string>
     <string name="error_checking_dictionaries">Не удалось проверить статус словарей</string>
     <string name="error_loading_article">Ошибка загрузки: %1$s</string>
@@ -49,6 +52,7 @@
     <string name="notification_download_error_title">Ошибка загрузки</string>
     <string name="notification_download_error_text">Не удалось скачать словари</string>
     <string name="notification_indexing_title">Индексация словарей</string>
+    <string name="notification_preparing_indexing_title">Подготовка словарей к индексации</string>
     <string name="archive_failed_open_source_file">Не удалось открыть исходный файл</string>
     <string name="archive_failed_create_output_file">Не удалось создать выходной файл</string>
     <string name="archive_failed_delete_file">Не удалось удалить файл: %1$s</string>
@@ -58,7 +62,6 @@
     <string name="error_scan_directory_failed">Не удалось просканировать папку со словарями</string>
     <string name="error_search_failed">Ошибка поиска запроса \'%1$s\' в %2$s</string>
     <string name="error_failed_load_index_metadata">Не удалось загрузить метаданные индекса: %1$s</string>
-    <string name="error_loading_more">Ошибка загрузки</string>
     <plurals name="active_dictionaries_count">
         <item quantity="one">%1$d активный словарь</item>
         <item quantity="few">%1$d активных словаря</item>
@@ -68,21 +71,23 @@
     <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>
     <string name="dictionary_source_duplicate_in_form">Дублирующийся URL в форме</string>
     <string name="dictionary_source_duplicate_prefix">Этот словарь уже существует (одинаковый префикс)</string>
     <string name="dictionary_source_url_empty">URL не может быть пустым</string>
-    <string name="dictionary_source_invalid_protocol">Должен начинаться с http:// или https://</string>
-    <string name="dictionary_source_invalid_extension">Должен заканчиваться на .gz, .dsl или .dz</string>
+    <string name="dictionary_source_invalid_protocol">Должен начинаться с https://</string>
+    <string name="dictionary_source_invalid_extension">Должен заканчиваться на .gz, .dsl или .dsl.dz</string>
     <string name="dictionary_source_too_long">URL слишком длинный (максимум 2048 символов)</string>
     <string name="dictionary_source_invalid_url">Неверный формат URL</string>
     <string name="dictionary_source_suspicious_characters">URL содержит недопустимые символы</string>
     <string name="dictionaries_not_downloaded">Словари еще не загружены</string>
     <string name="dictionaries_update_available">Доступны обновления словарей</string>
+    <string name="dictionary_update_available">Доступно обновление</string>
     <string name="action_cancel">Отмена</string>
     <string name="action_add">Добавить</string>
     <string name="action_add_another_url">Добавить ещё URL</string>

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

@@ -2,7 +2,6 @@
     <string name="app_name">ReSearch</string>
     <string name="settings_title">Settings</string>
     <string name="action_back">Back</string>
-    <string name="version_format">v%1$s</string>
     <string name="version_unknown">unknown</string>
     <string name="button_cancel_download">Cancel</string>
     <string name="action_ok">OK</string>
@@ -12,9 +11,13 @@
     <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="search_bar_position">Search bar</string>
+    <string name="search_bar_position_top">Top</string>
+    <string name="search_bar_position_bottom">Bottom</string>
     <string name="clear_search">Clear search</string>
-    <string name="article_no_selected">No article selected</string>
+    <string name="recent_searches">Search history</string>
+    <string name="clear_search_history">Clear</string>
+    <string name="remove_search_history_entry">Remove from history</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>
@@ -49,6 +52,7 @@
     <string name="notification_download_error_title">Download error</string>
     <string name="notification_download_error_text">Failed to download dictionaries</string>
     <string name="notification_indexing_title">Indexing dictionaries</string>
+    <string name="notification_preparing_indexing_title">Preparing dictionaries for indexing</string>
     <string name="archive_failed_open_source_file">Failed to open source file</string>
     <string name="archive_failed_create_output_file">Failed to create output file</string>
     <string name="archive_failed_delete_file">Failed to delete file: %1$s</string>
@@ -58,7 +62,6 @@
     <string name="error_scan_directory_failed">Failed to scan dictionary folder</string>
     <string name="error_search_failed">Search failed for query \'%1$s\' in %2$s</string>
     <string name="error_failed_load_index_metadata">Failed to load index metadata: %1$s</string>
-    <string name="error_loading_more">Loading error</string>
     <plurals name="active_dictionaries_count">
         <item quantity="one">%1$d active dictionary</item>
         <item quantity="other">%1$d active dictionaries</item>
@@ -66,21 +69,23 @@
     <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>
     <string name="dictionary_source_duplicate_in_form">Duplicate URL in the form</string>
     <string name="dictionary_source_duplicate_prefix">This dictionary already exists</string>
     <string name="dictionary_source_url_empty">URL cannot be empty</string>
-    <string name="dictionary_source_invalid_protocol">Must start with http:// or https://</string>
-    <string name="dictionary_source_invalid_extension">Must end with .gz, .dsl, or .dz</string>
+    <string name="dictionary_source_invalid_protocol">Must start with https://</string>
+    <string name="dictionary_source_invalid_extension">Must end with .gz, .dsl, or .dsl.dz</string>
     <string name="dictionary_source_too_long">URL is too long (max 2048 characters)</string>
     <string name="dictionary_source_invalid_url">Invalid URL format</string>
     <string name="dictionary_source_suspicious_characters">URL contains invalid characters</string>
     <string name="dictionaries_not_downloaded">No dictionaries downloaded yet</string>
     <string name="dictionaries_update_available">Dictionary updates available</string>
+    <string name="dictionary_update_available">Update available</string>
     <string name="action_cancel">Cancel</string>
     <string name="action_add">Add</string>
     <string name="action_add_another_url">Add another URL</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);
+}

build.gradle.kts

@@ -2,7 +2,7 @@ plugins {
     alias(libs.plugins.aboutlibraries) apply false
     alias(libs.plugins.android.application) apply false
     alias(libs.plugins.kotlin.compose) apply false
-    id("com.github.ben-manes.versions") version "0.54.0"
+    id("com.github.ben-manes.versions") version "0.65.0"
 }
 tasks.register("assembleDebug") {
     dependsOn(":app:assembleDebug")

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

@@ -1 +1 @@
-- Initial F-Droid release
+- Initial release

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

@@ -0,0 +1,6 @@
+- Added search history
+- The search bar can be placed at the top or bottom of the screen
+- Fixed headwords with stress marks displaying truncated in search results
+- Improved download, indexing and navigation stability
+- The About screen opens faster
+- Updated build tooling and code cleanup

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

@@ -0,0 +1,6 @@
+- Search loads all prefix matches; broad prefix searches are much faster
+- Fixed indexing progress freezing on large dictionaries
+- Large articles open faster
+- Numbered results sort in numeric order
+- UI improvements
+- Updated libraries and build tooling

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

@@ -0,0 +1,16 @@
+- The app starts faster
+- Faster dictionary indexing
+- Improved app stability
+- Smooth screen transition animations
+- Articles render DSL line breaks, indentation and named colors correctly
+- Tabs and extra spaces inside articles no longer break the layout
+- The article title can be copied, tapping the article clears the selection
+- Source URLs accept host:port addresses
+- 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
+- Long link-heavy articles no longer freeze while scrolling
+- Large search result lists render faster
+- Dark article colors are readable in the dark theme
+- Updated build tooling and documentation

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

@@ -1,4 +1,4 @@
-ReSearch is a fast Android dictionary reader for DSL-format dictionaries. Download, import, and search multiple dictionaries with instant article retrieval via DictZip random-access compression.
+ReSearch is an Android dictionary reader for DSL-format dictionaries. Download, import, and search multiple dictionaries with instant article retrieval via DictZip random-access compression.
 
 Features:
 
@@ -8,7 +8,7 @@ Features:
 - Import .dsl and .dsl.dz files from device storage
 - 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
+- Adaptive two-pane layout for tablets and large screens
 - 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/1.txt

@@ -1 +1 @@
-- Первый релиз для F-Droid
+- Первый релиз

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

@@ -0,0 +1,6 @@
+- Добавлена история поиска
+- Поисковую строку можно расположить сверху или снизу экрана
+- Исправлено усечение заголовков со знаками ударения в результатах поиска
+- Повышена стабильность загрузки, индексации и навигации
+- Экран «О приложении» открывается быстрее
+- Обновлён инструментарий сборки, проведена чистка кода

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

@@ -0,0 +1,6 @@
+- Поиск загружает все совпадения по префиксу и стал значительно быстрее
+- Исправлено зависание прогресса индексации больших словарей
+- Большие статьи открываются быстрее
+- Нумерованные результаты идут по порядку номеров
+- Улучшения интерфейса
+- Обновлены библиотеки и инструментарий сборки

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

@@ -0,0 +1,16 @@
+- Приложение запускается быстрее
+- Ускорена индексация словарей
+- Повышена стабильность приложения
+- Плавные анимации переходов между экранами
+- Статьи корректно отображают переносы строк, отступы и цвета из DSL-разметки
+- Табуляции и лишние пробелы в статьях больше не ломают вёрстку
+- Заголовок статьи можно скопировать, тап по статье сбрасывает выделение
+- Адреса источников принимают формат host:port
+- Загрузка словарей автоматически повторяется при переключении сети
+- Уведомления о прогрессе загрузки стали надёжнее
+- Результаты поиска очищаются мгновенно при стирании запроса
+- Остаточные файлы после отменённых загрузок удаляются автоматически
+- Длинные статьи со ссылками больше не подвисают при прокрутке
+- Большие списки результатов поиска отображаются быстрее
+- Тёмные цвета статей читаемы в тёмной теме
+- Обновлены инструменты сборки и документация

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

@@ -1,4 +1,4 @@
-ReSearch — быстрое приложение для чтения словарей в формате DSL. Скачивайте, импортируйте и ищите в нескольких словарях с мгновенным получением статей благодаря сжатию DictZip.
+ReSearch — приложение для чтения словарей в формате DSL. Скачивайте, импортируйте и ищите в нескольких словарях с мгновенным получением статей благодаря сжатию DictZip.
 
 Возможности:
 
@@ -8,7 +8,7 @@ ReSearch — быстрое приложение для чтения слова
 - Импорт файлов .dsl и .dsl.dz из хранилища устройства
 - Автоматическая индексация с бинарными индексными файлами для мгновенного поиска
 - Поддержка нескольких кодировок — автоопределение UTF-8, UTF-16 LE/BE
-- Адаптивный трёхпанельный интерфейс для планшетов и больших экранов
+- Адаптивный двухпанельный интерфейс для планшетов и больших экранов
 - Material 3 с динамическими цветами, светлая, тёмная и системная темы
 - Локализация на английский и русский языки
 - Без трекеров, без рекламы, полностью открытый исходный код

gradle/libs.versions.toml

@@ -1,23 +1,24 @@
 [versions]
-aboutlibraries = "15.0.4"
+aboutlibraries = "15.3.0"
 activity_compose = "1.13.0"
-agp = "9.3.1"
-compose_bom = "2026.08.00"
-core = "1.19.0"
-datastore_preferences = "1.2.1"
+agp = "9.4.1"
+compose_bom = "2026.09.00"
+core = "1.19.1"
+datastore_preferences = "1.3.0"
 documentfile = "1.1.0"
-kotlin = "2.4.10"
+kotlin = "2.4.21"
 lifecycle_runtime_ktx = "2.11.0"
+material3 = "1.5.0-beta01"
 okhttp = "5.5.0"
-paging = "3.5.1"
+paging = "3.5.3"
 profileinstaller = "1.4.1"
 kotlinx_coroutines = "1.11.0"
-kotlinx_serialization = "1.11.0"
+kotlinx_serialization = "1.12.0"
 
 [libraries]
 androidx-activity-compose = { module = "androidx.activity:activity-compose", version.ref = "activity_compose" }
 androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "compose_bom" }
-androidx-compose-material3 = { group = "androidx.compose.material3", name = "material3" }
+androidx-compose-material3 = { group = "androidx.compose.material3", name = "material3", version.ref = "material3" }
 androidx-compose-material3-adaptive-layout = { group = "androidx.compose.material3.adaptive", name = "adaptive-layout" }
 androidx-compose-runtime-tracing = { module = "androidx.compose.runtime:runtime-tracing" }
 androidx-compose-ui = { group = "androidx.compose.ui", name = "ui" }

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-9.6.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.8.2-bin.zip
 networkTimeout=10000
 retries=0
 retryBackOffMs=500

gradlew

@@ -20,7 +20,7 @@
 
 ##############################################################################
 #
-#   Gradle start up script for POSIX generated by Gradle.
+#   gradlew start up script for POSIX generated by Gradle.
 #
 #   Important for running:
 #
@@ -29,7 +29,7 @@
 #       bash, then to run this script, type that shell name before the whole
 #       command line, like:
 #
-#           ksh Gradle
+#           ksh gradlew
 #
 #       Busybox and similar reduced shells will NOT work, because this script
 #       requires all of these POSIX shell features:

gradlew.bat

@@ -19,13 +19,40 @@
 @if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
 @rem
-@rem  Gradle startup script for Windows
+@rem  gradlew startup script for Windows
 @rem
 @rem ##########################################################################
 
 @rem Set local scope for the variables, and ensure extensions are enabled
 setlocal EnableExtensions
 
+@rem Catch executions from older scripts and ensure they exit cleanly.
+@rem This can be removed once we can be reasonably confident that few people
+@rem will be migrating directly to this new wrapper.
+goto afterSafetyNet
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+goto exitWithErrorLevel
+:afterSafetyNet
+
 set DIRNAME=%~dp0
 if "%DIRNAME%"=="" set DIRNAME=.
 @rem This is normally unused
@@ -45,13 +72,14 @@ set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
 if %ERRORLEVEL% equ 0 goto execute
 
-echo. 1>&2
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
-echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation. 1>&2
+1>&2 echo.
+1>&2 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+1>&2 echo.
+1>&2 echo Please set the JAVA_HOME variable in your environment to match the
+1>&2 echo location of your Java installation.
 
 "%COMSPEC%" /c exit 1
+goto exitWithErrorLevel
 
 :findJavaFromJavaHome
 set JAVA_HOME=%JAVA_HOME:"=%
@@ -59,24 +87,26 @@ set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
 if exist "%JAVA_EXE%" goto execute
 
-echo. 1>&2
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
-echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation. 1>&2
+1>&2 echo.
+1>&2 echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+1>&2 echo.
+1>&2 echo Please set the JAVA_HOME variable in your environment to match the
+1>&2 echo location of your Java installation.
 
 "%COMSPEC%" /c exit 1
+goto exitWithErrorLevel
 
 :execute
 @rem Setup the command line
 
 
 
-@rem Execute Gradle
+@rem Execute gradlew
 @rem endlocal doesn't take effect until after the line is parsed and variables are expanded
 @rem which allows us to clear the local environment before executing the java command
-endlocal & "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %* & call :exitWithErrorLevel
+endlocal & "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %* & call :exitWithErrorLevel & goto exitWithErrorLevel
 
+@rem This label must not be changed. We rely on old scripts being able to jump to this point.
 :exitWithErrorLevel
 @rem Use "%COMSPEC%" /c exit to allow operators to work properly in scripts
 "%COMSPEC%" /c exit %ERRORLEVEL%