Release 1.5.0

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

README.md

@@ -94,16 +94,16 @@ The main search screen remains usable as long as at least one indexed dictionary
 
 ## Tech Stack
 
-- Kotlin 2.4.0
+- Kotlin 2.4.10
-- Jetpack Compose (BOM 2026.06.01)
+- Jetpack Compose (BOM 2026.08.00)
 - Material 3
 - Coroutines and Flow 1.11.0
 - DataStore Preferences 1.2.1
-- Paging 3.5.0
+- Paging 3.5.1
 - OkHttp 5.4.0
 - kotlinx.serialization 1.11.0
-- AboutLibraries 15.0.3 metadata generation
+- AboutLibraries 15.0.4 metadata generation
-- Android Gradle Plugin 9.2.1
+- Android Gradle Plugin 9.3.1
 
 ## Build
 

app/build.gradle.kts

@@ -92,14 +92,8 @@ android {
         applicationId = "com.example.research"
         minSdk = project.property("minSdk").toString().toInt()
         targetSdk = project.property("targetSdk").toString().toInt()
-        versionCode = 2
+        versionCode = 8
-        versionName = "1.1.0"
+        versionName = "1.5.0"
-
-        val isFdroid = project.hasProperty("fdroid")
-        if (isFdroid) {
-            applicationIdSuffix = ".fdroid"
-            versionNameSuffix = "-fdroid"
-        }
 
         vectorDrawables {
             useSupportLibrary = true
@@ -120,12 +114,9 @@ android {
                 abiFilters += "arm64-v8a"
             }
 
-            isMinifyEnabled = true
+            optimization {
-            isShrinkResources = true
+                enable = true
-            proguardFiles(
+            }
-                getDefaultProguardFile("proguard-android-optimize.txt"),
-                "proguard-rules.pro"
-            )
         }
 
     }

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

@@ -0,0 +1,45 @@
+package com.example.research.core.performance
+
+import android.os.Trace
+import java.util.concurrent.atomic.AtomicInteger
+
+object ReSearchTrace {
+    const val SEARCH_PAGING = "ReSearch/Search/Paging"
+    const val SEARCH_DIRECT = "ReSearch/Search/Direct"
+    const val ARTICLE_PARSE = "ReSearch/Article/Parse"
+    const val ARTICLE_READ = "ReSearch/Article/Read"
+    const val ARTICLE_PRE_MEASURE = "ReSearch/Article/PreMeasure"
+    const val DICTIONARY_DOWNLOAD = "ReSearch/Dictionary/Download"
+    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()
+
+    @PublishedApi
+    internal val isAndroidRuntime = System.getProperty("java.vm.name") == "Dalvik"
+
+    inline fun <T> section(name: String, block: () -> T): T {
+        if (!isAndroidRuntime) return block()
+        Trace.beginSection(name)
+        return try {
+            block()
+        } finally {
+            Trace.endSection()
+        }
+    }
+
+    suspend fun <T> asyncSection(name: String, block: suspend () -> T): T {
+        if (!isAndroidRuntime) return block()
+        val cookie = nextCookie.incrementAndGet()
+        Trace.beginAsyncSection(name, cookie)
+        return try {
+            block()
+        } finally {
+            Trace.endAsyncSection(name, cookie)
+        }
+    }
+}

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

@@ -45,7 +45,7 @@ class ReSearchApplication : Application() {
         applicationScope.launch(Dispatchers.IO) {
             preferencesManager.sanitizeDictionarySources()
         }
-        localDictionaryRepository = LocalDictionaryRepository(this)
+        localDictionaryRepository = LocalDictionaryRepository(this, preferencesManager = preferencesManager)
 
         okHttpClient = OkHttpClient.Builder()
             .protocols(listOf(Protocol.HTTP_1_1))

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

@@ -1,6 +1,7 @@
 package com.example.research.common.ui.theme
 
 import androidx.compose.material3.Typography
+import androidx.compose.ui.text.PlatformTextStyle
 import androidx.compose.ui.text.TextStyle
 import androidx.compose.ui.text.font.FontFamily
 import androidx.compose.ui.text.font.FontWeight
@@ -85,3 +86,8 @@ val Typography = Typography(
         letterSpacing = 0.5.sp
     )
 )
+
+val Typography.dictionaryTitleLarge: TextStyle
+    get() = titleLarge.copy(
+        platformStyle = PlatformTextStyle(includeFontPadding = true)
+    )

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

@@ -13,7 +13,7 @@ object DateUtils {
         return dateFormat.format(calendar.time)
     }
     fun extractDateFromFileName(fileName: String): String? {
-        val regex = Regex("""_(\d{6})\.(gz|dsl|idx|dsl\.dz|dsl\.idx|dsl\.gz)$""")
+        val regex = Regex("""_(\d{6})\.(gz|dsl|idx|idx\.fold|dsl\.dz|dsl\.idx|dsl\.idx\.fold|dsl\.gz)$""")
         return regex.find(fileName)?.groupValues?.get(1)
     }
     fun isDateBefore(date1: String, date2: String): Boolean {

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

@@ -13,7 +13,8 @@ data class IndexEntry(
     val offset: ArticleOffset = ArticleOffset.ZERO,
     val length: ArticleLength = ArticleLength.ZERO,
     val dictionaryName: String = "",
-    val dictionaryPath: String = ""
+    val dictionaryPath: String = "",
+    val isAlias: Boolean = false
 ) : Comparable<IndexEntry> {
     init {
         require(word.isNotBlank()) { "Word cannot be blank" }

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

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

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

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

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

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

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

@@ -9,6 +9,32 @@ fun String.sanitizeQuery(): String {
         .take(MAX_QUERY_LENGTH)
 }
 
+fun String.foldLatinDiacritics(): String {
+    val decomposed = java.text.Normalizer.normalize(this, java.text.Normalizer.Form.NFD)
+    val folded = StringBuilder(decomposed.length)
+    var followsLatinBase = false
+    var index = 0
+
+    while (index < decomposed.length) {
+        val codePoint = decomposed.codePointAt(index)
+        val type = Character.getType(codePoint)
+        val isMark = type == Character.NON_SPACING_MARK.toInt() ||
+            type == Character.COMBINING_SPACING_MARK.toInt() ||
+            type == Character.ENCLOSING_MARK.toInt()
+
+        if (!(isMark && followsLatinBase)) {
+            folded.appendCodePoint(codePoint)
+        }
+
+        if (!isMark) {
+            followsLatinBase = Character.UnicodeScript.of(codePoint) == Character.UnicodeScript.LATIN
+        }
+        index += Character.charCount(codePoint)
+    }
+
+    return java.text.Normalizer.normalize(folded, java.text.Normalizer.Form.NFC)
+}
+
 fun String.sanitizeCacheKey(): String {
     return this.replace(":", "_").replace("\n", "_").replace("\t", "_")
 }

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

@@ -6,6 +6,7 @@ import androidx.datastore.preferences.core.Preferences
 import androidx.datastore.preferences.core.edit
 import androidx.datastore.preferences.core.booleanPreferencesKey
 import androidx.datastore.preferences.core.stringPreferencesKey
+import androidx.datastore.preferences.core.stringSetPreferencesKey
 import androidx.datastore.preferences.preferencesDataStore
 import com.example.research.core.domain.model.DictionarySource
 import kotlinx.coroutines.flow.Flow
@@ -23,6 +24,7 @@ class PreferencesManager(private val context: Context) {
         val IS_THEME_EXPANDED = booleanPreferencesKey("is_theme_expanded")
         val IS_LANGUAGE_EXPANDED = booleanPreferencesKey("is_language_expanded")
         val IS_DICTIONARIES_EXPANDED = booleanPreferencesKey("is_dictionaries_expanded")
+        val DISABLED_DICTIONARY_PATHS = stringSetPreferencesKey("disabled_dictionary_paths")
     }
 
     private val json = Json { ignoreUnknownKeys = true }
@@ -60,6 +62,33 @@ class PreferencesManager(private val context: Context) {
             }
         }
 
+    val disabledDictionaryPaths: Flow<Set<String>> = context.dataStore.data
+        .map { preferences ->
+            preferences[PreferencesKeys.DISABLED_DICTIONARY_PATHS] ?: emptySet()
+        }
+
+    suspend fun setDictionaryActive(path: String, isActive: Boolean) {
+        context.dataStore.edit { preferences ->
+            val disabledPaths = preferences[PreferencesKeys.DISABLED_DICTIONARY_PATHS]
+                .orEmpty()
+                .toMutableSet()
+            if (isActive) {
+                disabledPaths.remove(path)
+            } else {
+                disabledPaths.add(path)
+            }
+            if (disabledPaths.isEmpty()) {
+                preferences.remove(PreferencesKeys.DISABLED_DICTIONARY_PATHS)
+            } else {
+                preferences[PreferencesKeys.DISABLED_DICTIONARY_PATHS] = disabledPaths
+            }
+        }
+    }
+
+    suspend fun removeDictionaryActiveState(path: String) {
+        setDictionaryActive(path, true)
+    }
+
     suspend fun saveThemeMode(theme: String) {
         context.dataStore.edit { preferences ->
             preferences[PreferencesKeys.THEME_MODE] = theme

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

@@ -15,85 +15,180 @@ 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>,
     private val query: String
-) : PagingSource<Int, IndexEntry>() {
+) : PagingSource<IndexEntryPagingSource.TailKey, IndexEntry>() {
 
-    private var searchResults: List<IndexEntry>? = null
+    data class StreamCursor(
+        val dictPosition: Int,
+        val cursor: IndexSearcher.RangeCursor
+    )
 
-    override val jumpingSupported: Boolean = true
+    data class TailKey(val streams: List<StreamCursor>)
 
-    override suspend fun load(params: LoadParams<Int>): LoadResult<Int, IndexEntry> {
+    private data class EmittedKey(
-        val offset = params.key ?: 0
+        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> {
         return try {
-            val allResults = searchResults ?: ReSearchTrace.asyncSection(ReSearchTrace.SEARCH_PAGING) {
+            val key = params.key
-                coroutineScope {
+            if (key == null) loadHead() else loadTail(key, params.loadSize)
-                    val rawResults = dictionaries
-                        .filter { it.isActive }
-                        .map { dict ->
-                            async {
-                                val indexFile = File(dict.indexPath)
-                                if (!indexFile.exists()) return@async emptyList()
-
-                                try {
-                                    val results = indexSearcher.search(
-                                        pathOrUri = indexFile.absolutePath,
-                                        query = query,
-                                        includeSubstringMatches = false
-                                    )
-                                    results.map {
-                                        it.withDictionary(
-                                            dict.metadata.name.ifBlank { dict.name },
-                                            dict.path
-                                        )
-                                    }
-                                } catch (e: CancellationException) {
-                                    throw e
-                                } catch (_: Exception) {
-                                    emptyList()
-                                }
-                            }
-                        }
-                        .awaitAll()
-                        .flatten()
-
-                    // Precompute sorting keys to optimize comparator performance.
-                    // entry.word is already lowercase from indexing.
-                    val normalizedQuery = query.sanitizeQuery().lowercase().trim()
-
-                    rawResults.rankBySearchRelevance(
-                        SearchRankingContext(normalizedQuery)
-                    )
-                }
-            }.also { searchResults = it }
-            
-            val totalSize = allResults.size
-            val startIndex = offset.coerceAtLeast(0).coerceAtMost(totalSize)
-            val endIndex = (startIndex + params.loadSize).coerceAtMost(totalSize)
-            val pageItems = allResults.subList(startIndex, endIndex)
-            val hasMore = endIndex < totalSize
-            val nextKey = if (hasMore) endIndex else null
-            val prevKey = if (offset == 0) null else (offset - params.loadSize).coerceAtLeast(0)
-            
-            LoadResult.Page(
-                data = pageItems,
-                prevKey = prevKey,
-                nextKey = nextKey
-            )
         } catch (e: CancellationException) {
             throw e
         } catch (e: Exception) {
             LoadResult.Error(e)
         }
     }
-    
+
-    override fun getRefreshKey(state: PagingState<Int, IndexEntry>): Int? {
+    private suspend fun loadHead(): LoadResult<TailKey, IndexEntry> =
-        return state.anchorPosition?.let { anchorPosition ->
+        ReSearchTrace.asyncSection(ReSearchTrace.SEARCH_PAGING) {
-            state.closestPageToPosition(anchorPosition)?.prevKey?.plus(state.config.pageSize)
+            coroutineScope {
-                ?: state.closestPageToPosition(anchorPosition)?.nextKey?.minus(state.config.pageSize)
+                val perDictionary = activeDictionaries
+                    .map { (position, dict) ->
+                        async {
+                            val indexFile = File(dict.indexPath)
+                            if (!indexFile.exists()) return@async null
+
+                            try {
+                                val result = indexSearcher.searchWithCursors(
+                                    pathOrUri = indexFile.absolutePath,
+                                    query = query
+                                )
+                                Triple(position, dict, result)
+                            } catch (e: CancellationException) {
+                                throw e
+                            } catch (_: Exception) {
+                                null
+                            }
+                        }
+                    }
+                    .awaitAll()
+                    .filterNotNull()
+
+                val rawResults = perDictionary.flatMap { (position, dict, result) ->
+                    result.entries.map { entry ->
+                        position to 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))
+
+                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)
+                )
+            }
+        }
+
+    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? {
+        return null
+    }
 }
+
+private const val MIN_CHUNK = 48

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

@@ -58,17 +58,23 @@ object DslCharsetDetector {
     private fun looksLikeUtf8(inputStream: java.io.InputStream): Boolean {
         if (!inputStream.markSupported()) return false
         inputStream.mark(8192)
-        return try {
+        try {
             val sample = ByteArray(8192)
             val read = inputStream.read(sample)
             if (read <= 0) return false
             val decoder = Charsets.UTF_8.newDecoder()
                 .onMalformedInput(java.nio.charset.CodingErrorAction.REPORT)
                 .onUnmappableCharacter(java.nio.charset.CodingErrorAction.REPORT)
-            decoder.decode(java.nio.ByteBuffer.wrap(sample, 0, read))
+            val byteBuffer = java.nio.ByteBuffer.wrap(sample, 0, read)
-            true
+            val charBuffer = java.nio.CharBuffer.allocate(8192)
+            while (true) {
+                val result = decoder.decode(byteBuffer, charBuffer, false)
+                if (result.isError) return false
+                if (result.isUnderflow) return true
+                charBuffer.clear()
+            }
         } catch (_: Exception) {
-            false
+            return false
         } finally {
             inputStream.reset()
         }

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

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

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

@@ -4,6 +4,7 @@ import android.util.Log
 import com.example.research.core.domain.model.ArticleLength
 import com.example.research.core.domain.model.ArticleOffset
 import com.example.research.core.domain.model.IndexEntry
+import com.example.research.core.util.foldLatinDiacritics
 import com.example.research.core.util.removeAccentTagsForIndexing
 import kotlinx.coroutines.Deferred
 import kotlinx.coroutines.Dispatchers
@@ -23,7 +24,7 @@ class DslIndexer(context: Context? = null) {
 
     companion object {
         private const val TAG = "DslIndexer"
-        const val INDEX_VERSION = 4
+        const val INDEX_VERSION = 6
         const val BUFFER_SIZE = 1048576
         const val BATCH_BUFFER_SIZE = 524288
         private const val INDEX_SORT_PARALLELISM = 1
@@ -40,6 +41,9 @@ class DslIndexer(context: Context? = null) {
         private const val IN_MEMORY_SORT_MAX_ENTRIES = 140_000
         private const val ESTIMATED_IN_MEMORY_ENTRY_BYTES = 768L
         private const val IN_MEMORY_SORT_HEAP_RESERVE_BYTES = 96L * 1024L * 1024L
+
+        fun foldedIndexFile(indexFile: File): File =
+            File(indexFile.parent ?: ".", "${indexFile.name}.fold")
     }
 
     suspend fun createIndex(
@@ -56,21 +60,25 @@ class DslIndexer(context: Context? = null) {
             java.io.BufferedInputStream(dslInputStream)
         }
         val tempFile = File(indexFile.parent, "${indexFile.name}.tmp")
-        val entryCount: Int
+        val counts: ParsedCounts
         try {
+            try { foldedIndexFile(indexFile).delete() } catch (_: Throwable) { /* Legacy v5 leftover */ }
             onOperationChange("Parsing file")
             onFileProgress(0.0f)
-            entryCount = parseDslToTempFile(bufferedStream, tempFile,
+            counts = parseDslToTempFile(bufferedStream, tempFile,
                 onProgress, onFileProgress, onCharsetDetected)
             onFileProgress(0.5f)
             onOperationChange("Sorting index")
-            sortAndWriteIndexFile(tempFile, indexFile, entryCount, onOperationChange, onFileProgress)
+            sortAndWriteIndexFile(tempFile, indexFile, counts, onOperationChange, onFileProgress)
+            onFileProgress(1f)
         } finally {
             try { tempFile.delete() } catch (_: Throwable) { /* Ignore cleanup failure */ }
         }
-        try { onProgress(entryCount) } catch (_: Throwable) { /* Ignore progress callback failure */ }
+        try { onProgress(counts.articleCount) } catch (_: Throwable) { /* Ignore progress callback failure */ }
-        return entryCount
+        return counts.articleCount
     }
+
+    private data class ParsedCounts(val articleCount: Int, val totalEntries: Int)
     // Blocking file I/O is safe across this file: every suspend fun here is reached only
     // from createIndex(), which the sole caller (KotlinDictionaryEngine) runs inside
     // withContext(Dispatchers.IO). The dispatcher is invisible across the suspend-call
@@ -83,7 +91,7 @@ class DslIndexer(context: Context? = null) {
         onProgress: (Int) -> Unit,
         onFileProgress: (Float) -> Unit = {},
         onCharsetDetected: (DslCharsetDetector.DetectedCharset) -> Unit = {}
-    ): Int {
+    ): ParsedCounts {
         val detectedCharset = DslCharsetDetector.detect(inputStream)
         onCharsetDetected(detectedCharset)
 
@@ -98,6 +106,7 @@ class DslIndexer(context: Context? = null) {
             )
 
         var entryCount = 0
+        var aliasCount = 0
         var lineCount = 0
         var headwordLineCount = 0
         var bodyLineCount = 0
@@ -127,9 +136,10 @@ class DslIndexer(context: Context? = null) {
         fun normalizeSearchableWord(searchableText: String, fallback: String): String {
             // Parser already lowercases and strips accent tags for non-empty results;
             // only the raw-headword fallback still needs normalization.
-            return searchableText.ifEmpty {
+            val normalized = searchableText.ifEmpty {
                 fallback.removeAccentTagsForIndexing().lowercase()
             }
+            return java.text.Normalizer.normalize(normalized, java.text.Normalizer.Form.NFC)
         }
 
         DataOutputStream(BufferedOutputStream(FileOutputStream(tempFile), BUFFER_SIZE)).use { output ->
@@ -144,12 +154,23 @@ class DslIndexer(context: Context? = null) {
                     return
                 }
                 val length = (groupEndOffset - groupStartOffset).coerceAtLeast(0L).toInt()
-                for (idx in groupSearchable.indices) {
+                fun writeTempEntry(word: String, display: String, isAlias: Boolean) {
-                    writer.write(groupSearchable[idx])
+                    writer.write(word)
-                    writer.write(groupDisplay[idx])
+                    writer.write(display)
                     output.writeLong(groupStartOffset)
                     output.writeInt(length)
+                    output.writeByte(if (isAlias) ENTRY_FLAG_ALIAS else 0)
+                }
+                for (idx in groupSearchable.indices) {
+                    val searchableWord = groupSearchable[idx]
+                    val displayWord = groupDisplay[idx]
+                    writeTempEntry(searchableWord, displayWord, isAlias = false)
                     entryCount++
+                    val foldedWord = searchableWord.foldLatinDiacritics()
+                    if (foldedWord != searchableWord) {
+                        writeTempEntry(foldedWord, displayWord, isAlias = true)
+                        aliasCount++
+                    }
                 }
                 groupSearchable.clear()
                 groupDisplay.clear()
@@ -230,26 +251,28 @@ class DslIndexer(context: Context? = null) {
             try { onProgress(entryCount) } catch (_: Throwable) { /* Ignore progress callback failure */ }
         }
         onFileProgress(0.5f)
-        return entryCount
+        return ParsedCounts(articleCount = entryCount, totalEntries = entryCount + aliasCount)
     }
     // Blocking file I/O safe: reached only from createIndex() (runs on Dispatchers.IO). See parseDslToTempFile().
     @Suppress("BlockingMethodInNonBlockingContext")
-    private suspend fun sortAndWriteIndexFile(tempFile: File, indexFile: File, entryCount: Int, onOperationChange: (String) -> Unit = {}, onFileProgress: (Float) -> Unit = {}) {
+    private suspend fun sortAndWriteIndexFile(tempFile: File, indexFile: File, counts: ParsedCounts, onOperationChange: (String) -> Unit = {}, onFileProgress: (Float) -> Unit = {}) {
-        if (entryCount == 0) {
+        if (counts.totalEntries == 0) {
             DataOutputStream(BufferedOutputStream(FileOutputStream(indexFile))).use { output ->
                 output.writeInt(INDEX_VERSION)
                 output.writeInt(0)
                 output.writeInt(0)
+                output.writeInt(0)
             }
             return
         }
-        if (shouldUseInMemorySort(entryCount)) {
+        if (shouldUseInMemorySort(counts.totalEntries)) {
-            inMemorySortAndWrite(tempFile, indexFile, entryCount)
+            inMemorySortAndWrite(tempFile, indexFile, counts)
             onFileProgress(FINAL_INDEX_DONE_PROGRESS)
         } else {
-            externalSortAndWrite(tempFile, indexFile, entryCount, onOperationChange, onFileProgress)
+            externalSortAndWrite(tempFile, indexFile, counts, onOperationChange, onFileProgress)
         }
     }
+
     private fun shouldUseInMemorySort(entryCount: Int): Boolean {
         if (entryCount <= IN_MEMORY_SORT_ALWAYS_ENTRIES) return true
         if (entryCount > IN_MEMORY_SORT_MAX_ENTRIES) return false
@@ -264,30 +287,22 @@ class DslIndexer(context: Context? = null) {
     }
     // Blocking file I/O safe: reached only from createIndex() (runs on Dispatchers.IO). See parseDslToTempFile().
     @Suppress("BlockingMethodInNonBlockingContext")
-    private suspend fun inMemorySortAndWrite(tempFile: File, indexFile: File, entryCount: Int) {
+    private suspend fun inMemorySortAndWrite(tempFile: File, indexFile: File, counts: ParsedCounts) {
-        val entries = ArrayList<IndexEntry>(entryCount)
+        val entries = ArrayList<IndexEntry>(counts.totalEntries)
         java.io.DataInputStream(java.io.BufferedInputStream(java.io.FileInputStream(tempFile), BATCH_BUFFER_SIZE)).use { input ->
-            repeat(entryCount) {
+            repeat(counts.totalEntries) {
-                val word = input.readUtf8String()
+                entries.add(input.readTempEntry())
-                val originalWord = input.readUtf8String()
-                val offset = input.readLong()
-                val length = input.readInt()
-                entries.add(IndexEntry(
-                    word = word,
-                    originalWord = originalWord,
-                    offset = ArticleOffset(offset),
-                    length = ArticleLength(length)
-                ))
                 if (entries.size % 5000 == 0) {
                     try { yield() } catch (_: Throwable) { /* Ignore yield failure */ }
                 }
             }
         }
         entries.sort()
-        writeIndexFile(indexFile, entries)
+        writeIndexFile(indexFile, entries, counts.articleCount)
         entries.clear()
     }
-    private suspend fun externalSortAndWrite(tempFile: File, indexFile: File, entryCount: Int, onOperationChange: (String) -> Unit, onFileProgress: (Float) -> Unit) {
+    private suspend fun externalSortAndWrite(tempFile: File, indexFile: File, counts: ParsedCounts, onOperationChange: (String) -> Unit, onFileProgress: (Float) -> Unit) {
+        val entryCount = counts.totalEntries
         val adaptiveConfig = resourceManager?.calculateAdaptiveConfig(estimatedEntryCount = entryCount.toLong())
             ?: ResourceManager.AdaptiveConfig(
                 batchSize = 100_000,
@@ -317,16 +332,7 @@ class DslIndexer(context: Context? = null) {
                         val batch = ArrayList<IndexEntry>(currentBatchSize)
                         val batchEnd = minOf(processed + currentBatchSize, entryCount)
                         while (processed < batchEnd) {
-                            val word = input.readUtf8String()
+                            batch.add(input.readTempEntry())
-                            val originalWord = input.readUtf8String()
-                            val offset = input.readLong()
-                            val length = input.readInt()
-                            batch.add(IndexEntry(
-                                word = word,
-                                originalWord = originalWord,
-                                offset = ArticleOffset(offset),
-                                length = ArticleLength(length)
-                            ))
                             processed++
                         }
 
@@ -422,7 +428,7 @@ class DslIndexer(context: Context? = null) {
 
             onFileProgress(MERGE_START_PROGRESS)
             onOperationChange("Merging ${sortedBatches.size} batches")
-            mergeSortedBatches(sortedBatches, indexFile, entryCount, onOperationChange, onFileProgress)
+            mergeSortedBatches(sortedBatches, indexFile, counts, onOperationChange, onFileProgress)
             onFileProgress(FINAL_INDEX_DONE_PROGRESS)
         } finally {
             sortedBatches.forEach { try { it.delete() } catch (_: Throwable) { /* Ignore cleanup failure */ } }
@@ -443,6 +449,7 @@ class DslIndexer(context: Context? = null) {
                     writer.write(entry.originalWord)
                     output.writeLong(entry.offset.value)
                     output.writeInt(entry.length.value)
+                    output.writeByte(if (entry.isAlias) ENTRY_FLAG_ALIAS else 0)
                 }
             }
         }
@@ -453,15 +460,16 @@ class DslIndexer(context: Context? = null) {
     private suspend fun mergeSortedBatches(
         batchFiles: List<File>,
         indexFile: File,
-        totalEntries: Int,
+        counts: ParsedCounts,
         onOperationChange: (String) -> Unit = {},
         onFileProgress: (Float) -> Unit,
     ) {
         if (batchFiles.isEmpty()) return
 
+        val totalEntries = counts.totalEntries
         val sparsePoints = mutableListOf<SparsePoint>()
         val prefixCounts = HashMap<String, Int>(minOf(totalEntries / 10, 100_000))
-        val headerSize = 4 + 4 + 4
+        val headerSize = 4 + 4 + 4 + 4
         val dataScratchFile = File(indexFile.parent, "${indexFile.name}.data")
 
         val pq = PriorityQueue<BatchReader>()
@@ -508,7 +516,8 @@ class DslIndexer(context: Context? = null) {
                     val origSize = writer.write(entry.originalWord)
                     dataOutput.writeLong(entry.offset.value)
                     dataOutput.writeInt(entry.length.value)
-                    currentByteOffset += 2 + wordSize + 2 + origSize + 8 + 4
+                    dataOutput.writeByte(if (entry.isAlias) ENTRY_FLAG_ALIAS else 0)
+                    currentByteOffset += 2 + wordSize + 2 + origSize + 8 + 4 + 1
 
                     entryIndex++
 
@@ -542,6 +551,7 @@ class DslIndexer(context: Context? = null) {
             DataOutputStream(BufferedOutputStream(FileOutputStream(indexFile), BUFFER_SIZE)).use { output ->
                 output.writeInt(INDEX_VERSION)
                 output.writeInt(totalEntries)
+                output.writeInt(counts.articleCount)
                 output.writeInt(sparsePoints.size)
 
                 sparsePoints.forEachIndexed { idx, point ->
@@ -632,18 +642,14 @@ class DslIndexer(context: Context? = null) {
     }
     private fun readNextEntry(input: java.io.DataInputStream): IndexEntry? {
         return try {
-            val word = input.readUtf8String()
+            input.readTempEntry()
-            val originalWord = input.readUtf8String()
-            val offset = ArticleOffset(input.readLong())
-            val length = ArticleLength(input.readInt())
-            IndexEntry(word, originalWord, offset, length)
         } catch (_: java.io.EOFException) {
             null
         }
     }
-    private fun writeIndexFile(indexFile: File, entries: List<IndexEntry>) {
+    private fun writeIndexFile(indexFile: File, entries: List<IndexEntry>, articleCount: Int) {
         val sparseData = buildAdaptiveSparseIndex(entries)
-        val headerSize = 4 + 4 + 4
+        val headerSize = 4 + 4 + 4 + 4
 
         // Cache sparse table bytes to avoid redundant conversions
         val sparseTableBytes = sparseData.map { CachedBytes.from(it.word) }
@@ -657,13 +663,14 @@ class DslIndexer(context: Context? = null) {
             // Calculate sizes without allocating byte arrays
             val wordSize = utf8ByteSize(entry.word)
             val origSize = utf8ByteSize(entry.originalWord)
-            currentByteOffset += 2 + wordSize + 2 + origSize + 8 + 4
+            currentByteOffset += 2 + wordSize + 2 + origSize + 8 + 4 + 1
         }
 
         DataOutputStream(BufferedOutputStream(FileOutputStream(indexFile))).use { output ->
             val writer = Utf8Writer(output)
             output.writeInt(INDEX_VERSION)
             output.writeInt(entries.size)
+            output.writeInt(articleCount)
             output.writeInt(sparseData.size)
 
             sparseData.forEach { point ->
@@ -677,6 +684,7 @@ class DslIndexer(context: Context? = null) {
                 writer.write(entry.originalWord)
                 output.writeLong(entry.offset.value)
                 output.writeInt(entry.length.value)
+                output.writeByte(if (entry.isAlias) ENTRY_FLAG_ALIAS else 0)
             }
         }
     }
@@ -707,7 +715,7 @@ class DslIndexer(context: Context? = null) {
             // Calculate sizes without allocating byte arrays
             val wordSize = utf8ByteSize(entry.word)
             val origSize = utf8ByteSize(entry.originalWord)
-            currentByteOffset += 2 + wordSize + 2 + origSize + 8 + 4
+            currentByteOffset += 2 + wordSize + 2 + origSize + 8 + 4 + 1
         }
 
         return sparsePoints
@@ -824,6 +832,24 @@ private fun java.io.DataInputStream.readUtf8String(): String {
     readFully(bytes)
     return String(bytes, Charsets.UTF_8)
 }
+
+internal const val ENTRY_FLAG_ALIAS = 1
+
+private fun java.io.DataInputStream.readTempEntry(): IndexEntry {
+    val word = readUtf8String()
+    val originalWord = readUtf8String()
+    val offset = readLong()
+    val length = readInt()
+    val flags = readUnsignedByte()
+    return IndexEntry(
+        word = word,
+        originalWord = originalWord,
+        offset = ArticleOffset(offset),
+        length = ArticleLength(length),
+        isAlias = flags and ENTRY_FLAG_ALIAS != 0
+    )
+}
+
 private enum class LineKind {
     HEADWORD,
     BODY,

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

@@ -5,6 +5,7 @@ import com.example.research.R
 import com.example.research.core.domain.model.ArticleLength
 import com.example.research.core.domain.model.ArticleOffset
 import com.example.research.core.domain.model.IndexEntry
+import com.example.research.core.util.foldLatinDiacritics
 import com.example.research.core.util.DictionaryError
 import com.example.research.core.util.sanitizeCacheKey
 import com.example.research.core.util.sanitizeQuery
@@ -23,7 +24,8 @@ import java.io.RandomAccessFile
 
 class IndexSearcher(private val context: Context) {
     private val metadataCache = MetadataLruCache(maxBytes = 64L * 1024L * 1024L)
-    private val resultsCache = ResultsLruCache(maxEntries = 20)
+    private val resultsCache = ResultsLruCache<List<IndexEntry>>(maxEntries = 20)
+    private val cursorResultsCache = ResultsLruCache<CursorSearchResult>(maxEntries = 20)
 
     /**
      * Pre-allocated reusable buffer for readEntry() to reduce allocations.
@@ -49,6 +51,27 @@ class IndexSearcher(private val context: Context) {
         val comparedCount: Int
     )
 
+    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?
+    )
+
     class IndexComparisonException(message: String) : IllegalStateException(message)
 
     suspend fun findFirstEntry(pathOrUri: String, query: String): IndexEntry? = withContext(Dispatchers.Default) {
@@ -66,7 +89,7 @@ class IndexSearcher(private val context: Context) {
                     var iterationCount = 0
                     while (currentIdx < count) {
                         if (iterationCount % 1000 == 0) yield()
-                        val nextEntry = readEntry(source)
+                        val nextEntry = readEntry(source, metadata)
                         val nextWordLower = nextEntry.word.lowercase()
                         if (!nextWordLower.startsWith(normalizedQuery)) break
                         if (nextWordLower == normalizedQuery) return@withContext nextEntry.copy(word = nextWordLower)
@@ -93,6 +116,7 @@ class IndexSearcher(private val context: Context) {
             return@withContext emptyList()
         }
         val normalizedQuery = query.sanitizeQuery().lowercase().trim()
+        val foldedQuery = normalizedQuery.foldLatinDiacritics()
         val cacheKey = "$pathOrUri:${normalizedQuery.sanitizeCacheKey()}"
         resultsCache.get(cacheKey)?.let {
             return@withContext it
@@ -102,33 +126,34 @@ class IndexSearcher(private val context: Context) {
             val count = metadata.totalCount
             if (count == 0) return@withContext emptyList()
             val results = openSource(pathOrUri).use { source ->
-                val prefixMatches = mutableListOf<IndexEntry>()
+                val prefixMatches = readPrefixMatches(source, metadata, normalizedQuery).entries.toMutableList()
-                val substringMatches = mutableListOf<IndexEntry>()
+                if (foldedQuery != normalizedQuery) {
-                val firstMatch = findFirstMatch(source, metadata, normalizedQuery)
+                    prefixMatches.addAll(readPrefixMatches(source, metadata, foldedQuery).entries)
-                if (firstMatch != null) {
-                    prefixMatches.addAll(readMatchingEntries(source, count, firstMatch, normalizedQuery))
                 }
+
+                val substringMatches = mutableListOf<IndexEntry>()
+                val seenArticles = prefixMatches.mapTo(HashSet()) { it.articleKey() }
                 if (includeSubstringMatches &&
                     count <= SUBSTRING_SCAN_MAX_ENTRIES &&
-                    prefixMatches.size < 100 &&
+                    seenArticles.size < MAX_SUBSTRING_RESULTS &&
                     normalizedQuery.length >= 2
                 ) {
-                    val prefixMatchWords = prefixMatches.map { it.word }.toSet()
                     source.seek(metadata.dataStartOffset)
                     for (i in 0 until count) {
                         if (i % 1000 == 0) yield()
-                        if (substringMatches.size >= 100) break
+                        if (substringMatches.size >= MAX_SUBSTRING_RESULTS) break
-                        val entry = readEntry(source)
+                        val entry = readEntry(source, metadata)
                         val entryWordLower = entry.word.lowercase()
-                        if (entryWordLower.contains(normalizedQuery) && entryWordLower !in prefixMatchWords) {
+                        if (entryWordLower.contains(normalizedQuery) &&
+                            seenArticles.add(entry.articleKey())
+                        ) {
                             substringMatches.add(entry.copy(word = entryWordLower))
                         }
                     }
                 }
-                val combinedResults = prefixMatches + substringMatches
+                (prefixMatches + substringMatches)
-                combinedResults.rankBySearchRelevance(
+                    .rankBySearchRelevance(SearchRankingContext(normalizedQuery, foldedQuery))
-                    SearchRankingContext(normalizedQuery)
+                    .distinctBy { it.articleKey() }
-                )
             }
             resultsCache.put(cacheKey, results)
             results
@@ -148,6 +173,77 @@ 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
+        }
+    }
+
     suspend fun compareEntryGroups(
         expectedIndexPath: String,
         actualIndexPath: String,
@@ -168,8 +264,8 @@ class IndexSearcher(private val context: Context) {
                 expectedSource.seek(expectedMetadata.dataStartOffset)
                 actualSource.seek(actualMetadata.dataStartOffset)
 
-                var expectedNext = readEntryOrNull(expectedSource, expectedMetadata.totalCount > 0)
+                var expectedNext = readEntryOrNull(expectedSource, expectedMetadata, expectedMetadata.totalCount > 0)
-                var actualNext = readEntryOrNull(actualSource, actualMetadata.totalCount > 0)
+                var actualNext = readEntryOrNull(actualSource, actualMetadata, actualMetadata.totalCount > 0)
                 var comparedCount = 0
 
                 while (expectedNext != null && actualNext != null) {
@@ -191,6 +287,7 @@ class IndexSearcher(private val context: Context) {
                         comparedCount++
                         expectedNext = readEntryOrNull(
                             expectedSource,
+                            expectedMetadata,
                             comparedCount < expectedMetadata.totalCount
                         )
                     }
@@ -203,6 +300,7 @@ class IndexSearcher(private val context: Context) {
                         actualReadCount++
                         actualNext = readEntryOrNull(
                             actualSource,
+                            actualMetadata,
                             actualReadCount < actualMetadata.totalCount
                         )
                     }
@@ -233,14 +331,18 @@ class IndexSearcher(private val context: Context) {
         }
     }
 
-    private fun readEntryOrNull(source: RandomAccessSource, shouldRead: Boolean): IndexEntry? =
+    private fun readEntryOrNull(
-        if (shouldRead) readEntry(source) else null
+        source: RandomAccessSource,
+        metadata: IndexMetadata,
+        shouldRead: Boolean
+    ): IndexEntry? = if (shouldRead) readEntry(source, metadata) else null
 
     fun trimMemory(level: Int) {
         metadataCache.trim(level)
         resultsCache.trim(level)
+        cursorResultsCache.trim(level)
     }
-    
+
     suspend fun isMetadataLoaded(pathOrUri: String): Boolean {
         return metadataCache.contains(pathOrUri)
     }
@@ -252,7 +354,13 @@ class IndexSearcher(private val context: Context) {
                     val count = input.readInt()
 
                     return@withContext if (version >= 2) {
-                        loadMetadataV2(input, version, count)
+                        val headerBase = if (version >= 6) {
+                            input.readInt()
+                            12L
+                        } else {
+                            8L
+                        }
+                        loadMetadataV2(input, version, count, headerBase)
                     } else {
                         loadMetadataV1(input, version, count)
                     }
@@ -272,13 +380,13 @@ class IndexSearcher(private val context: Context) {
     // runs inside withContext(Dispatchers.IO). The dispatcher is not visible across the
     // suspend-call boundary, so the inspection is suppressed deliberately.
     @Suppress("BlockingMethodInNonBlockingContext")
-    private suspend fun loadMetadataV2(input: DataInputStream, version: Int, count: Int): IndexMetadata {
+    private suspend fun loadMetadataV2(input: DataInputStream, version: Int, count: Int, headerBase: Long): IndexMetadata {
         val sparseCount = input.readInt()
         val sparseIndices = IntArray(sparseCount)
         val sparseOffsets = LongArray(sparseCount)
         val sparseWords = Array(sparseCount) { "" }
 
-        var headerSize = 4 + 4 + 4L
+        var headerSize = headerBase + 4L
 
         for (i in 0 until sparseCount) {
             if (i % 1000 == 0) yield()
@@ -337,6 +445,17 @@ class IndexSearcher(private val context: Context) {
             dataStartOffset = 8L
         )
     }
+
+    private suspend fun readPrefixMatches(
+        source: RandomAccessSource,
+        metadata: IndexMetadata,
+        query: String
+    ): RangeScanResult {
+        val firstMatch = findFirstMatch(source, metadata, query)
+            ?: return RangeScanResult(emptyList(), null)
+        return readMatchingEntries(source, metadata, firstMatch, query)
+    }
+
     private suspend fun findFirstMatch(source: RandomAccessSource, metadata: IndexMetadata, query: String): Pair<Int, IndexEntry>? {
         val sparseIndices = metadata.sparseIndices
         val sparseOffsets = metadata.sparseOffsets
@@ -359,7 +478,7 @@ class IndexSearcher(private val context: Context) {
 
         while (currentAbsoluteIdx < metadata.totalCount) {
             if (iterationCount % 1000 == 0) yield()
-            val entry = readEntry(source)
+            val entry = readEntry(source, metadata)
             val entryWordLower = entry.word.lowercase()
             if (entryWordLower >= query) {
                 return if (entryWordLower.startsWith(query)) Pair(currentAbsoluteIdx, entry.copy(word = entryWordLower)) else null
@@ -394,53 +513,64 @@ class IndexSearcher(private val context: Context) {
     }
     private suspend fun readMatchingEntries(
         source: RandomAccessSource,
-        totalCount: Int,
+        metadata: IndexMetadata,
         firstMatch: Pair<Int, IndexEntry>,
         query: String
-    ): List<IndexEntry> {
+    ): RangeScanResult {
         val results = mutableListOf<IndexEntry>()
         results.add(firstMatch.second)
+        val uniqueArticles = hashSetOf(firstMatch.second.articleKey())
         var currentIdx = firstMatch.first + 1
         var iterationCount = 0
-        while (currentIdx < totalCount && results.size < 100) {
+        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)
+            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 results
+        return RangeScanResult(results, null)
     }
 
-    private fun readEntry(source: RandomAccessSource): IndexEntry {
+    private fun readPooledString(source: RandomAccessSource, length: Int): String {
-        val wordLen = source.readUnsignedShort()
+        return if (length <= 4096) {
-        val word = if (wordLen <= 4096) {
             val buffer = entryBuffer.get() ?: throw IllegalStateException("Entry buffer pool exhausted")
-            source.readFully(buffer, 0, wordLen)
+            source.readFully(buffer, 0, length)
-            String(buffer, 0, wordLen, Charsets.UTF_8)
+            String(buffer, 0, length, Charsets.UTF_8)
         } else {
-            val bytes = ByteArray(wordLen)
+            val bytes = ByteArray(length)
-            source.readFully(bytes)
-            String(bytes, Charsets.UTF_8)
-        }
-
-        val origLen = source.readUnsignedShort()
-        val originalWord = if (origLen <= 4096) {
-            val buffer = entryBuffer.get() ?: throw IllegalStateException("Entry buffer pool exhausted")
-            source.readFully(buffer, 0, origLen)
-            String(buffer, 0, origLen, Charsets.UTF_8)
-        } else {
-            val bytes = ByteArray(origLen)
             source.readFully(bytes)
             String(bytes, Charsets.UTF_8)
         }
+    }
 
+    private fun readEntry(source: RandomAccessSource, metadata: IndexMetadata): IndexEntry {
+        val word = readPooledString(source, source.readUnsignedShort())
+        val originalWord = readPooledString(source, source.readUnsignedShort())
         val offset = ArticleOffset(source.readLong())
         val length = ArticleLength(source.readInt())
-        return IndexEntry(word, originalWord, offset, length)
+        val isAlias = if (metadata.version >= 6) {
+            source.readUnsignedByte() and ENTRY_FLAG_ALIAS != 0
+        } else {
+            false
+        }
+        return IndexEntry(word, originalWord, offset, length, isAlias = isAlias)
     }
+
+    private data class ArticleKey(
+        val originalWord: String,
+        val offset: Long,
+        val length: Int
+    )
+
+    private fun IndexEntry.articleKey() = ArticleKey(originalWord, offset.value, length.value)
+
     private fun openSource(pathOrUri: String): RandomAccessSource {
         val file = File(pathOrUri)
         if (!file.exists()) throw DictionaryError.FileSystemError.NotFound(pathOrUri)
@@ -455,20 +585,22 @@ 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
     }
 }
-private class ResultsLruCache(private val maxEntries: Int) {
+private class ResultsLruCache<V : Any>(private val maxEntries: Int) {
     private val mutex = Mutex()
-    private val map = object : LinkedHashMap<String, List<IndexEntry>>(maxEntries, 0.75f, true) {
+    private val map = object : LinkedHashMap<String, V>(maxEntries, 0.75f, true) {
-        override fun removeEldestEntry(eldest: MutableMap.MutableEntry<String, List<IndexEntry>>): Boolean {
+        override fun removeEldestEntry(eldest: MutableMap.MutableEntry<String, V>): Boolean {
             return size > maxEntries
         }
     }
 
-    suspend fun get(key: String): List<IndexEntry>? = mutex.withLock {
+    suspend fun get(key: String): V? = mutex.withLock {
         map[key]
     }
-    suspend fun put(key: String, value: List<IndexEntry>) = mutex.withLock {
+    suspend fun put(key: String, value: V) = mutex.withLock {
         map[key] = value
     }
     fun trim(level: Int) {
@@ -548,6 +680,8 @@ private class MetadataLruCache(private val maxBytes: Long) {
 }
 interface RandomAccessSource : Closeable {
     fun seek(pos: Long)
+    fun position(): Long
+    fun readUnsignedByte(): Int
     fun readUnsignedShort(): Int
     fun readInt(): Int
     fun readLong(): Long
@@ -561,6 +695,10 @@ class FileSource(file: File) : RandomAccessSource {
         raf.seek(pos)
     }
 
+    override fun position(): Long = raf.filePointer
+
+    override fun readUnsignedByte(): Int = raf.readUnsignedByte()
+
     override fun readUnsignedShort(): Int = raf.readUnsignedShort()
 
     override fun readInt(): Int = raf.readInt()

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

@@ -1,15 +1,17 @@
 package com.example.research.data.parser
 
 import com.example.research.core.domain.model.IndexEntry
+import com.example.research.core.util.foldLatinDiacritics
 
 internal data class SearchRankingContext(
     val normalizedQuery: String,
+    val foldedQuery: String = normalizedQuery.foldLatinDiacritics(),
 )
 
 private data class SortKey(
-    val charCount: Int,
+    val matchTier: Int,
     val exactMatch: Int,
-    val startsWithMatch: Int,
+    val charCount: Int,
     val word: String,
     val entry: IndexEntry,
 )
@@ -26,13 +28,18 @@ internal fun List<IndexEntry>.rankBySearchRelevance(
             .ifEmpty { entry.word.trim() }
 
         SortKey(
-            charCount = displayKey.codePointCount(0, displayKey.length),
+            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,
-            startsWithMatch = if (word.startsWith(ranking.normalizedQuery)) 0 else 1,
+            charCount = displayKey.codePointCount(0, displayKey.length),
             word = word,
             entry = entry,
         )
     }
-        .sortedWith(compareBy({ it.charCount }, { it.exactMatch }, { it.startsWithMatch }, { it.word }))
+        .sortedWith(compareBy({ it.matchTier }, { it.exactMatch }, { it.charCount }, { it.word }))
         .map { it.entry }
 }

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

@@ -14,6 +14,7 @@ import com.example.research.core.util.extractDictionaryPrefix
 import com.example.research.core.util.sanitizeQuery
 import com.example.research.core.util.toDictionaryError
 import com.example.research.data.dictzip.DictZipRandomAccessFile
+import com.example.research.data.local.preferences.PreferencesManager
 import com.example.research.data.parser.DslCharsetDetector
 import com.example.research.data.parser.DslHeaderParser
 import com.example.research.data.parser.DslIndexer
@@ -26,6 +27,7 @@ import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.ensureActive
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.supervisorScope
@@ -85,15 +87,11 @@ private class ProgressTracker(files: List<LocalDictionaryRepository.DiscoveredFi
 
 class LocalDictionaryRepository(
     private val context: Context,
-    private val engine: KotlinDictionaryEngine,
+    private val engine: KotlinDictionaryEngine = KotlinDictionaryEngine(context),
     private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO,
     private val defaultDispatcher: CoroutineDispatcher = Dispatchers.Default,
+    private val preferencesManager: PreferencesManager = PreferencesManager(context),
 ) : CoroutineScope {
-    constructor(context: Context) : this(
-        context,
-        KotlinDictionaryEngine(context)
-    )
-
     override val coroutineContext = Job() + ioDispatcher
 
     private val mutableDictionaries = MutableStateFlow<List<Dictionary>>(emptyList())
@@ -107,6 +105,7 @@ class LocalDictionaryRepository(
     private val indexingMutex = Mutex()
     private val indexingSemaphore = Semaphore(1)
     private val warmupMutex = Mutex()
+    private val dictionaryStateMutex = Mutex()
 
     @Volatile
     private var currentIndexingJob: Job? = null
@@ -124,6 +123,24 @@ class LocalDictionaryRepository(
 
     fun isIndexingInProgress(): Boolean = currentIndexingJob?.isActive == true
 
+    suspend fun listDictionaryPayloadFileNames(path: String): List<String>? =
+        withContext(ioDispatcher) {
+            try {
+                val directory = File(path)
+                when {
+                    !directory.exists() -> {
+                        if (directory.parentFile?.isDirectory == true) emptyList() else null
+                    }
+                    !directory.isDirectory -> null
+                    else -> directory.listFiles { file -> isDictionaryPayloadFile(file) }
+                        ?.map(File::getName)
+                }
+            } catch (e: SecurityException) {
+                Log.w(TAG, "Failed to list dictionary files: ${e.message}")
+                null
+            }
+        }
+
     suspend fun scanDirectory(pathOrUri: String): OperationResult<Int> = withContext(ioDispatcher) {
         if (isIndexingInProgress()) {
             return@withContext OperationResult.Error(
@@ -140,7 +157,7 @@ class LocalDictionaryRepository(
                 val filesToScan = scanLocalDirectory(pathOrUri)
 
                 if (filesToScan.isEmpty()) {
-                    mutableDictionaries.value = emptyList()
+                    replaceDictionaries(emptyList())
                     mutableIndexingProgress.value = IndexingProgress(isIndexing = false)
                     return@withContext OperationResult.Success(0)
                 }
@@ -159,12 +176,12 @@ class LocalDictionaryRepository(
                 }
 
                 if (filesToIndex.isEmpty()) {
-                    mutableDictionaries.value = existingDictionaries.sortedBy { it.name }
+                    replaceDictionaries(existingDictionaries)
                     engine.getIndexSearcher().trimMemory(80)
                     return@withContext OperationResult.Success(existingDictionaries.size)
                 }
 
-                mutableDictionaries.value = existingDictionaries.sortedBy { it.name }
+                replaceDictionaries(existingDictionaries)
 
                 val totalArticlesIndexed = AtomicInteger(existingDictionaries.sumOf { it.articleCount })
                 
@@ -233,12 +250,9 @@ class LocalDictionaryRepository(
                                 if (res is OperationResult.Success) {
                                     progressTracker?.updateFileProgress(file.name, 1.0f)
                                     totalArticlesIndexed.addAndGet(res.data.articleCount)
-                                    mutableDictionaries.update { current ->
+                                    val dictionary = res.data
-                                        (current + res.data)
+                                    addDictionary(dictionary)
-                                            .distinctBy { it.path }
+                                    dictionary
-                                            .sortedBy { it.name }
-                                    }
-                                    res.data
                                 } else null
                             }
                         }
@@ -266,17 +280,37 @@ class LocalDictionaryRepository(
         }
     }
 
+    private suspend fun replaceDictionaries(dictionaries: List<Dictionary>) {
+        dictionaryStateMutex.withLock { applyDictionaries(dictionaries) }
+    }
+
+    private suspend fun addDictionary(dictionary: Dictionary) {
+        dictionaryStateMutex.withLock {
+            applyDictionaries((mutableDictionaries.value + dictionary).distinctBy { it.path })
+        }
+    }
+
+    private suspend fun applyDictionaries(dictionaries: List<Dictionary>) {
+        val disabledPaths = preferencesManager.disabledDictionaryPaths.first()
+        mutableDictionaries.value = dictionaries
+            .map { it.withActiveStatus(it.path !in disabledPaths) }
+            .sortedBy { it.name }
+    }
+
     private suspend fun tryLoadExistingIndex(file: DiscoveredFile): Dictionary? {
         val dictFile = File(file.localPath)
         val indexFile = File(file.indexPath)
 
-        if (!indexFile.exists() || indexFile.length() == 0L) return null
+        if (!indexFile.exists() || indexFile.length() == 0L) {
+            deleteIndexFiles(indexFile)
+            return null
+        }
         if (!dictFile.exists()) return null
 
         val header = readIndexHeader(indexFile)
 
         if (header == null || header.version != DslIndexer.INDEX_VERSION) {
-            try { indexFile.delete() } catch (_: Exception) {}
+            deleteIndexFiles(indexFile)
             return null
         }
 
@@ -326,23 +360,36 @@ class LocalDictionaryRepository(
                  )
                  OperationResult.Success(dict)
              } else {
-                 indexFile.delete()
+                 deleteIndexFiles(indexFile)
                  OperationResult.Error(result.errorMsg, null)
              }
          } catch(e: Exception) {
-             indexFile.delete()
+             deleteIndexFiles(indexFile)
              if (e is CancellationException) throw e
              OperationResult.Error(e.message ?: context.getString(R.string.error_indexing), e)
          }
     }
 
+    private fun deleteIndexFiles(indexFile: File, errors: MutableList<String>? = null) {
+        deleteFileTracked(indexFile, "index file", errors)
+        deleteFileTracked(DslIndexer.foldedIndexFile(indexFile), "legacy folded index file", errors)
+    }
+
+    private fun deleteFileTracked(file: File, label: String, errors: MutableList<String>?) {
+        try {
+            if (file.exists() && !file.delete()) {
+                errors?.add("Failed to delete $label: ${file.absolutePath}")
+            }
+        } catch (e: Exception) {
+            errors?.add("Failed to delete $label: ${file.absolutePath} (${e.message})")
+        }
+    }
+
     private fun scanLocalDirectory(path: String): List<DiscoveredFile> {
         val dir = File(path)
         if (!dir.exists() || !dir.isDirectory) return emptyList()
 
-        return dir.listFiles { f ->
+        return dir.listFiles { file -> isDictionaryPayloadFile(file) }?.map { file ->
-            f.isFile && (f.name.endsWith(".dsl") || f.name.endsWith(".dsl.dz") || f.name.endsWith(".dsl.gz"))
-        }?.map { file ->
              DiscoveredFile(
                  name = file.name,
                  localPath = file.absolutePath,
@@ -351,10 +398,17 @@ 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")
+            )
+
     suspend fun search(query: String): OperationResult<List<IndexEntry>> = withContext(defaultDispatcher) {
         if (query.isBlank()) return@withContext OperationResult.Success(emptyList())
 
-        val activeDicts = mutableDictionaries.value
+        val activeDicts = mutableDictionaries.value.filter { it.isActive }
         val sanitizedQuery = query.sanitizeQuery()
 
         ReSearchTrace.asyncSection(ReSearchTrace.SEARCH_DIRECT) {
@@ -404,65 +458,81 @@ class LocalDictionaryRepository(
         return engine.getIndexSearcher()
     }
 
-    fun toggleDictionaryActive(dictionaryPath: String) {
+    suspend fun toggleDictionaryActive(dictionaryPath: String) {
-        mutableDictionaries.update { currentList ->
+        dictionaryStateMutex.withLock {
-            currentList.map { dict ->
+            val isActive = mutableDictionaries.value
-                if (dict.path == dictionaryPath) {
+                .firstOrNull { it.path == dictionaryPath }
-                    dict.withActiveStatus(!dict.isActive)
+                ?.isActive
-                } else {
+                ?.not()
-                    dict
+                ?: return
+            preferencesManager.setDictionaryActive(dictionaryPath, isActive)
+            mutableDictionaries.update { currentList ->
+                currentList.map { dict ->
+                    if (dict.path == dictionaryPath) {
+                        dict.withActiveStatus(isActive)
+                    } else {
+                        dict
+                    }
                 }
             }
         }
     }
 
-    fun deleteDictionary(dictionary: Dictionary): OperationResult<Unit> {
+    private fun removeDictionaryFromState(path: String) {
-        try {
+        mutableDictionaries.update { current -> current.filter { it.path != path } }
-            mutableDictionaries.update { current ->
+    }
-                current.filter { it.path != dictionary.path }
-            }
 
-            launch(ioDispatcher) {
+    suspend fun deleteDictionary(dictionary: Dictionary): OperationResult<Unit> {
-                try {
+        return try {
-                    val deleteErrors = mutableListOf<String>()
+            val (failure, cleanupErrors) = withContext(ioDispatcher) {
-
+                val dictFile = File(dictionary.path)
-                    val dictFile = File(dictionary.path)
+                if (dictFile.exists() && !dictFile.delete()) {
-                    if (dictFile.exists()) {
+                    return@withContext Pair(
-                        if (!dictFile.delete()) {
+                        "Failed to delete dictionary file: ${dictFile.absolutePath}",
-                            deleteErrors.add("Failed to delete dictionary file: ${dictFile.absolutePath}")
+                        emptyList<String>(),
-                        }
+                    )
-                    }
-
-                    val indexFile = if (dictionary.indexPath.endsWith(".idx", ignoreCase = true)) {
-                        File(dictionary.indexPath)
-                    } else {
-                        File("${dictionary.indexPath}.idx")
-                    }
-
-                    if (indexFile.exists()) {
-                        if (!indexFile.delete()) {
-                            deleteErrors.add("Failed to delete index file: ${indexFile.absolutePath}")
-                        }
-                    }
-
-                    try {
-                        engine.getIndexSearcher().trimMemory(80)
-                    } catch (e: Exception) {
-                        Log.w(TAG, "Failed to trim memory after deletion: ${e.message}")
-                    }
-
-                    if (deleteErrors.isNotEmpty()) {
-                        val message = deleteErrors.joinToString("; ")
-                        Log.w(TAG, "Dictionary deletion completed with errors: $message")
-                    }
-                } catch (e: Exception) {
-                    Log.e(TAG, "Background deletion failed: ${e.message}", e)
                 }
+
+                val deleteErrors = mutableListOf<String>()
+                val indexFile = if (dictionary.indexPath.endsWith(".idx", ignoreCase = true)) {
+                    File(dictionary.indexPath)
+                } else {
+                    File("${dictionary.indexPath}.idx")
+                }
+
+                deleteIndexFiles(indexFile, deleteErrors)
+                Pair<String?, List<String>>(null, deleteErrors)
             }
 
-            return OperationResult.Success(Unit)
+            if (failure != null) {
+                return OperationResult.Error(failure)
+            }
+
+            dictionaryStateMutex.withLock {
+                try {
+                    preferencesManager.removeDictionaryActiveState(dictionary.path)
+                } catch (e: Exception) {
+                    Log.w(TAG, "Failed to clear dictionary active state: ${e.message}")
+                }
+                removeDictionaryFromState(dictionary.path)
+            }
+
+            try {
+                engine.getIndexSearcher().trimMemory(80)
+            } catch (e: Exception) {
+                Log.w(TAG, "Failed to trim memory after deletion: ${e.message}")
+            }
+
+            if (cleanupErrors.isNotEmpty()) {
+                Log.w(
+                    TAG,
+                    "Dictionary deletion completed with errors: ${cleanupErrors.joinToString("; ")}"
+                )
+            }
+
+            OperationResult.Success(Unit)
         } catch (e: Exception) {
-            return OperationResult.Error("Failed to delete dictionary", e)
+            OperationResult.Error("Failed to delete dictionary", e)
         }
     }
 
@@ -507,13 +577,22 @@ class LocalDictionaryRepository(
 
                     if (count < 0) return null
 
+                    var articleCount = count
+                    if (version >= 6) {
+                        if (indexFile.length() < INDEX_V6_HEADER_BYTES) return null
+                        articleCount = dataInput.readInt()
+                        if (articleCount < 0) return null
+                    }
+
                     if (version >= 2) {
-                        if (indexFile.length() < INDEX_V2_HEADER_BYTES) return null
+                        val fixedHeaderBytes =
+                            if (version >= 6) INDEX_V6_HEADER_BYTES else INDEX_V2_HEADER_BYTES
+                        if (indexFile.length() < fixedHeaderBytes) return null
 
                         val sparseCount = dataInput.readInt()
                         if (sparseCount < 0) return null
 
-                        var headerBytes = INDEX_V2_HEADER_BYTES
+                        var headerBytes = fixedHeaderBytes
                         repeat(sparseCount) {
                             dataInput.readInt()
                             dataInput.readLong()
@@ -524,7 +603,7 @@ class LocalDictionaryRepository(
                         }
                     }
 
-                    IndexHeader(version, count)
+                    IndexHeader(version, articleCount)
                 }
             }
         } catch (e: Exception) {
@@ -602,6 +681,7 @@ class LocalDictionaryRepository(
         const val MIN_PROGRESS_EMIT_INTERVAL_MS = 200L
         const val LEGACY_INDEX_HEADER_BYTES = 8L
         const val INDEX_V2_HEADER_BYTES = 12
+        const val INDEX_V6_HEADER_BYTES = 16
         const val SPARSE_ENTRY_FIXED_BYTES = 14
     }
 }

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

@@ -24,10 +24,11 @@ class DownloadManager(
         mutableDownloadProgressState.asStateFlow()
     private val mutex = Mutex()
     private var downloadJob: Job? = null
+    private var cancelCleanupJob: Job? = null
 
     companion object {
         private const val TAG = "DownloadManager"
-        private const val DOWNLOAD_PROGRESS_STEP_PERCENT = 3
+        private const val DOWNLOAD_PROGRESS_STEP_PERCENT = 1
         private const val EXTRACT_PROGRESS_STEP_PERCENT = 5
         private val TERMINAL_STATE_DURATION = 2.seconds
     }
@@ -44,6 +45,7 @@ class DownloadManager(
     fun startDownload() {
         if (downloadState.value is DownloadState.Loading) return
         if (!downloadScope.isActive) return
+        cancelCleanupJob = null
         downloadJob = downloadScope.launch {
             mutex.withLock {
                 try {
@@ -94,7 +96,7 @@ class DownloadManager(
                 } catch (e: Exception) {
                     if (e is CancellationException) {
                         updateDownloadProgressState(DownloadState.Cancelled, 0f)
-                        downloadScope.launch {
+                        cancelCleanupJob = downloadScope.launch {
                             try {
                                 dictionaryRepository.deleteUnprocessedFiles()
                             } catch (cleanupException: Exception) {
@@ -124,6 +126,7 @@ class DownloadManager(
     fun startDownloadForSources(sourceUrls: List<String>) {
         if (downloadState.value is DownloadState.Loading) return
         if (!downloadScope.isActive) return
+        cancelCleanupJob = null
         downloadJob = downloadScope.launch {
             mutex.withLock {
                 try {
@@ -168,7 +171,7 @@ class DownloadManager(
                 } catch (e: Exception) {
                     if (e is CancellationException) {
                         updateDownloadProgressState(DownloadState.Cancelled, 0f)
-                        downloadScope.launch {
+                        cancelCleanupJob = downloadScope.launch {
                             try {
                                 dictionaryRepository.deleteUnprocessedFiles()
                             } catch (cleanupException: Exception) {
@@ -195,10 +198,12 @@ class DownloadManager(
         }
     }
     fun cancelDownload() {
-        downloadJob?.cancel()
+        val jobToCancel = downloadJob
+        jobToCancel?.cancel()
         updateDownloadProgressState(DownloadState.Cancelled, 0f)
         downloadScope.launch {
-            delay(TERMINAL_STATE_DURATION)
+            jobToCancel?.join()
+            cancelCleanupJob?.join()
             if (downloadState.value == DownloadState.Cancelled) {
                 updateDownloadProgressState(DownloadState.Idle, 0f)
             }

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

@@ -59,11 +59,11 @@ class DictionaryCleaner(
                     toDelete.add(item.name)
                     continue
                 }
-                if ((item.ext == "idx" || item.ext == "dsl.idx") && item.date != latestDsl) {
+                if (item.ext in indexExtensions && item.date != latestDsl) {
                     toDelete.add(item.name)
                     continue
                 }
-                if ((item.ext == "idx" || item.ext == "dsl.idx") && item.date !in dslDates) {
+                if (item.ext in indexExtensions && item.date !in dslDates) {
                     toDelete.add(item.name)
                 }
             }
@@ -76,10 +76,13 @@ class DictionaryCleaner(
         val date: String,
         val ext: String,
     )
-    private val validExtensions = setOf("dsl", "dsl.dz", "dsl.gz", "gz", "idx", "dsl.idx")
+    private val indexExtensions = setOf("idx", "dsl.idx", "idx.fold", "dsl.idx.fold")
+    private val validExtensions = setOf("dsl", "dsl.dz", "dsl.gz", "gz") + indexExtensions
 
     private fun parseManagedName(name: String, prefixes: Set<String>): ManagedFileName? {
         val ext = when {
+            name.endsWith(".dsl.idx.fold") -> "dsl.idx.fold"
+            name.endsWith(".idx.fold") -> "idx.fold"
             name.endsWith(".dsl.dz") -> "dsl.dz"
             name.endsWith(".dsl.gz") -> "dsl.gz"
             name.endsWith(".dsl.idx") -> "dsl.idx"

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

@@ -343,6 +343,8 @@ class DictionaryDownloader(
                     context.getString(R.string.download_connection_reset)
                 e is SecurityException ->
                     context.getString(R.string.download_no_write_permission)
+                e.isNetworkError() ->
+                    context.getString(R.string.download_network_failed)
                 else ->
                     context.getString(R.string.download_error)
             }

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

@@ -98,8 +98,7 @@ class SearchViewModel(
                     pageSize = 12,
                     prefetchDistance = 1,
                     enablePlaceholders = false,
-                    initialLoadSize = 12,
+                    initialLoadSize = 12
-                    jumpThreshold = 1
                 ),
                 pagingSourceFactory = {
                     IndexEntryPagingSource(

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

@@ -22,6 +22,7 @@ import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.IntSize
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.example.research.R
+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
@@ -258,7 +259,7 @@ fun ArticleTitleBar(
 
             Text(
                 text = title,
-                style = MaterialTheme.typography.titleLarge,
+                style = MaterialTheme.typography.dictionaryTitleLarge,
                 color = MaterialTheme.colorScheme.onSurface,
                 maxLines = 1,
                 overflow = TextOverflow.Ellipsis,

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

@@ -23,7 +23,6 @@ object DslAnnotatedParser {
         "br", "p", "b", "i", "c", "t", "m", "m0", "m1", "m2", "m3", "m4", "m5",
         "ref", "ex", "e", "trn", "com", "lang", "sup", "'"
     )
-    private val ESCAPED_CHARS = setOf('[', ']', '(', ')')
 
     data class ColorScheme(
         val secondaryText: Color,
@@ -101,15 +100,13 @@ object DslAnnotatedParser {
                 '\\' -> {
                     if (i + 1 < length) {
                         val next = dsl[i + 1]
-                        if (next in ESCAPED_CHARS) {
+                        builder.append(next)
-                            builder.append(next)
+                        if (refStack.isNotEmpty()) {
-                            if (refStack.isNotEmpty()) {
+                            refStack.last().second.append(next)
-                                refStack.last().second.append(next)
-                            }
-                            lastChar = next
-                            i += 2
-                            continue
                         }
+                        lastChar = next
+                        i += 2
+                        continue
                     }
                     builder.append(char)
                     if (refStack.isNotEmpty()) {
@@ -119,7 +116,7 @@ object DslAnnotatedParser {
                     i++
                 }
                 '[' -> {
-                    val end = dsl.indexOf(']', i + 1)
+                    val end = tagCloseIndex(dsl, i + 1)
                     if (end != -1) {
                         val tagStart = i + 1
                         var tagEnd = end
@@ -228,6 +225,19 @@ object DslAnnotatedParser {
         splitOversizedBlocks(result)
     }
 
+    private fun tagCloseIndex(value: String, startIndex: Int): Int {
+        var index = startIndex
+        while (index < value.length) {
+            when {
+                value[index] == '\\' && index + 1 < value.length -> index += 2
+                value[index] == '[' -> return -1
+                value[index] == ']' -> return index
+                else -> index++
+            }
+        }
+        return -1
+    }
+
     private fun splitOversizedBlocks(blocks: List<DslBlock>): List<DslBlock> {
         if (blocks.none { it.text.length > MAX_BLOCK_TEXT_LENGTH }) return blocks
         return blocks.flatMap { block ->

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

@@ -1,24 +1,26 @@
 package com.example.research.ui.main.components
 
 import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.offset
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.windowInsetsPadding
 import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.foundation.text.BasicTextField
 import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.foundation.text.input.TextFieldLineLimits
 import androidx.compose.foundation.text.input.TextFieldState
+import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.FilledIconButton
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.IconButtonDefaults
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Surface
+import androidx.compose.material3.TextField
+import androidx.compose.material3.TextFieldDefaults
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
@@ -27,7 +29,7 @@ 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.SolidColor
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.testTag
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
@@ -36,9 +38,11 @@ import androidx.compose.ui.semantics.testTagsAsResourceId
 import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.unit.dp
 import com.example.research.R
+import com.example.research.common.ui.theme.dictionaryTitleLarge
 import kotlinx.coroutines.flow.distinctUntilChanged
+import com.example.research.ui.theme.Spacing
 
-private val TopBarHeight = 56.dp
+private val TopBarHeight = Spacing.topBarHeight
 private val TopBarShape = RoundedCornerShape(28.dp)
 
 @Composable
@@ -99,6 +103,7 @@ fun MainTopBar(
 }
 
 @Composable
+@OptIn(ExperimentalMaterial3Api::class)
 private fun SearchField(
     searchState: TextFieldState,
     enabled: Boolean,
@@ -110,8 +115,6 @@ private fun SearchField(
     modifier: Modifier = Modifier
 ) {
     val containerColor = MaterialTheme.colorScheme.surfaceContainerHighest
-    val contentColor = MaterialTheme.colorScheme.onSurface
-    val placeholderColor = MaterialTheme.colorScheme.onSurfaceVariant
 
     val currentOnQueryChange by rememberUpdatedState(onQueryChange)
 
@@ -123,57 +126,60 @@ private fun SearchField(
             }
     }
 
-    Surface(
+    TextField(
-        modifier = modifier.height(TopBarHeight),
+        state = searchState,
-        color = containerColor,
+        enabled = enabled,
-        shape = TopBarShape
+        textStyle = MaterialTheme.typography.dictionaryTitleLarge,
-    ) {
+        keyboardOptions = KeyboardOptions(imeAction = ImeAction.Search),
-        Row(
+        lineLimits = TextFieldLineLimits.SingleLine,
-            modifier = Modifier.padding(horizontal = 16.dp),
+        leadingIcon = {
-            verticalAlignment = Alignment.CenterVertically
-        ) {
             Icon(
                 painter = searchIcon,
                 contentDescription = null,
-                tint = placeholderColor,
-                modifier = Modifier.size(24.dp)
-            )
-
-            BasicTextField(
-                state = searchState,
-                enabled = enabled,
-                textStyle = MaterialTheme.typography.titleLarge.copy(color = contentColor),
-                cursorBrush = SolidColor(MaterialTheme.colorScheme.primary),
-                keyboardOptions = KeyboardOptions(imeAction = ImeAction.Search),
-                lineLimits = TextFieldLineLimits.SingleLine,
                 modifier = Modifier
-                    .weight(1f)
+                    .offset(x = 4.dp)
-                    .padding(horizontal = 12.dp)
+                    .size(24.dp)
-                    .testTag("search_field")
-                    .semantics { testTagsAsResourceId = true }
             )
-
+        },
-            if (searchState.text.isNotEmpty()) {
+        trailingIcon = if (searchState.text.isNotEmpty()) {
+            {
                 IconButton(
                     onClick = {
                         searchState.edit { replace(0, length, "") }
                         onClearQuery()
                     },
                     modifier = Modifier
-                        .size(40.dp)
+                        .padding(end = 12.dp)
                         .testTag("clear_search")
                         .semantics { testTagsAsResourceId = true }
                 ) {
                     Icon(
                         painter = closeIcon,
                         contentDescription = clearLabel,
-                        tint = placeholderColor,
                         modifier = Modifier.size(24.dp)
                     )
                 }
-            } else {
-                Box(modifier = Modifier.size(40.dp))
             }
-        }
+        } else {
-    }
+            null
+        },
+        shape = TopBarShape,
+        contentPadding = TextFieldDefaults.contentPaddingWithoutLabel(
+            top = 8.dp,
+            bottom = 8.dp
+        ),
+        colors = TextFieldDefaults.colors(
+            focusedContainerColor = containerColor,
+            unfocusedContainerColor = containerColor,
+            disabledContainerColor = containerColor,
+            cursorColor = MaterialTheme.colorScheme.primary,
+            focusedIndicatorColor = Color.Transparent,
+            unfocusedIndicatorColor = Color.Transparent,
+            disabledIndicatorColor = Color.Transparent
+        ),
+        modifier = modifier
+            .height(TopBarHeight)
+            .testTag("search_field")
+            .semantics { testTagsAsResourceId = true }
+    )
 }

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

@@ -17,6 +17,7 @@ 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
 import com.example.research.ui.theme.Spacing
@@ -40,7 +41,6 @@ fun SearchResultsList(
     ) {
         items(
             count = results.itemCount,
-            key = results.itemKey { entry -> "${entry.dictionaryPath}_${entry.offset.value}_${entry.word}" },
             contentType = results.itemContentType { "search_result" }
         ) { index ->
             results[index]?.let { entry ->
@@ -83,7 +83,7 @@ private fun SearchResultItem(
     showDictionaryName: Boolean = true
 ) {
     // Cache text styles to avoid recreation on every composition
-    val titleStyle = MaterialTheme.typography.titleLarge
+    val titleStyle = MaterialTheme.typography.dictionaryTitleLarge
     val subtitleStyle = MaterialTheme.typography.bodySmall
     val subtitleColor = MaterialTheme.colorScheme.onSurfaceVariant
 

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

@@ -11,6 +11,7 @@ import com.example.research.core.domain.model.AppTheme
 import com.example.research.core.domain.model.Dictionary
 import com.example.research.core.domain.model.DictionarySource
 import com.example.research.core.domain.model.IndexingProgress
+import com.example.research.core.domain.usecase.DictionarySourceFileMatcher
 import com.example.research.core.domain.usecase.DictionarySourceValidator
 import com.example.research.core.domain.usecase.ManageDictionarySourcesUseCase
 import com.example.research.core.util.OperationResult
@@ -30,7 +31,7 @@ import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.receiveAsFlow
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
-import java.io.File
+import java.util.concurrent.ConcurrentHashMap
 
 private data class DictionaryStateInputs(
     val theme: AppTheme,
@@ -79,9 +80,13 @@ class SettingsViewModel(
     private val language = MutableStateFlow("system")
     private val hasCompletedStartupScan = MutableStateFlow(false)
 
-    private val pendingSourceUrls = mutableSetOf<String>()
+    private val pendingSourceUrls = ConcurrentHashMap.newKeySet<String>()
     private var isDownloadInProgress = false
 
+    private var cancelRefreshPending = false
+    private var errorStateHandled = false
+    private var statusBeforeDownload: DictionaryStatus = DictionaryStatus.Unknown
+
     init {
         setupStateObservation()
         initialize()
@@ -143,46 +148,43 @@ class SettingsViewModel(
                 when (operationState.downloadState) {
                     is DownloadState.Loading, is DownloadState.Extracting -> {
                         isDownloadInProgress = true
+                        cancelRefreshPending = false
+                        errorStateHandled = false
                     }
                     is DownloadState.Success -> {
                         pendingSourceUrls.clear()
                     }
                     is DownloadState.Error -> {
                         isDownloadInProgress = false
-                        dictionaryStatus.value = if (dictionaryState.dictionaries.isEmpty()) {
+                        if (!errorStateHandled) {
-                            DictionaryStatus.Empty
+                            errorStateHandled = true
-                        } else {
+                            dictionaryStatus.value = if (dictionaryState.dictionaries.isEmpty()) {
-                            DictionaryStatus.UpToDate
+                                DictionaryStatus.Empty
-                        }
+                            } else when (statusBeforeDownload) {
-                        if (pendingSourceUrls.isNotEmpty()) {
+                                DictionaryStatus.Unknown, DictionaryStatus.Checking -> DictionaryStatus.UpToDate
-
+                                else -> statusBeforeDownload
-                            pendingSourceUrls.forEach { urlTemplate ->
+                            }
-                                val source = dictionaryState.dictionarySources.find {
+                            if (pendingSourceUrls.isNotEmpty()) {
-                                    it.urlTemplate == urlTemplate
+                                pendingSourceUrls.forEach { urlTemplate ->
-                                }
+                                    val source = dictionaryState.dictionarySources.find {
-                                if (source != null) {
+                                        it.urlTemplate == urlTemplate
-                                    val hasDictionary = dictionaryState.dictionaries.any { dict ->
-                                        DictionarySource.matchesDictionaryFile(
-                                            urlTemplate,
-                                            File(dict.path).name
-                                        )
                                     }
-
+                                    if (source != null) {
-                                    if (!hasDictionary) {
+                                        val hasDictionary = dictionaryState.dictionaries.any { dictionary ->
-                                        manageDictionarySourcesUseCase.removeSource(source.id)
+                                            DictionarySourceFileMatcher.matches(source, dictionary)
+                                        }
+                                        if (!hasDictionary) {
+                                            manageDictionarySourcesUseCase.removeSource(source.id)
+                                        }
                                     }
                                 }
+                                pendingSourceUrls.clear()
                             }
-                            pendingSourceUrls.clear()
                         }
                     }
                     is DownloadState.Cancelled -> {
                         isDownloadInProgress = false
-                        dictionaryStatus.value = if (dictionaryState.dictionaries.isEmpty()) {
+                        cancelRefreshPending = true
-                            DictionaryStatus.Empty
-                        } else {
-                            DictionaryStatus.UpToDate
-                        }
                         if (pendingSourceUrls.isNotEmpty()) {
                             pendingSourceUrls.forEach { urlTemplate ->
                                 val source = dictionaryState.dictionarySources.find {
@@ -193,6 +195,12 @@ class SettingsViewModel(
                             pendingSourceUrls.clear()
                         }
                     }
+                    is DownloadState.Idle -> {
+                        if (cancelRefreshPending) {
+                            cancelRefreshPending = false
+                            refreshDictionaryStatus()
+                        }
+                    }
                     else -> {}
                 }
 
@@ -259,26 +267,35 @@ class SettingsViewModel(
     private suspend fun evaluateDictionaryStatus(): DictionaryStatus {
         return try {
             val actualDictionaries = localDictionaryRepository.dictionaries.first()
-            val hasDictionaries = actualDictionaries.isNotEmpty()
+            var sources = preferencesManager.dictionarySources.first()
+            if (pendingSourceUrls.isEmpty() &&
+                downloadManager.downloadState.value !is DownloadState.Loading &&
+                downloadManager.downloadState.value !is DownloadState.Extracting
+            ) {
+                val dictionaryFileNames = localDictionaryRepository.listDictionaryPayloadFileNames(
+                    preferencesManager.dictionaryPath
+                )
+                if (dictionaryFileNames != null) {
+                    val installedSources = DictionarySourceFileMatcher.installedSourcesForFileNames(
+                        sources,
+                        dictionaryFileNames,
+                    )
+                    val installedSourceIds = installedSources
+                        .mapTo(mutableSetOf(), DictionarySource::id)
+                    val staleSourceIds = sources
+                        .filterNot { it.id in installedSourceIds }
+                        .map(DictionarySource::id)
+                    if (staleSourceIds.isNotEmpty()) {
+                        preferencesManager.removeDictionarySources(staleSourceIds)
+                        sources = installedSources
+                    }
+                }
+            }
 
-            if (!hasDictionaries) {
+            if (actualDictionaries.isEmpty()) {
                 return DictionaryStatus.Empty
             }
 
-            var sources = preferencesManager.dictionarySources.first()
-            if (downloadManager.downloadState.value !is DownloadState.Loading &&
-                downloadManager.downloadState.value !is DownloadState.Extracting
-            ) {
-                val installedSources = installedSources(sources, actualDictionaries)
-                val installedSourceIds = installedSources.mapTo(mutableSetOf(), DictionarySource::id)
-                val staleSourceIds = sources
-                    .filterNot { it.id in installedSourceIds }
-                    .map(DictionarySource::id)
-                if (staleSourceIds.isNotEmpty()) {
-                    preferencesManager.removeDictionarySources(staleSourceIds)
-                    sources = installedSources
-                }
-            }
             val enabledSources = installedEnabledSources(sources, actualDictionaries)
 
             if (enabledSources.isEmpty()) {
@@ -326,50 +343,69 @@ class SettingsViewModel(
     }
 
     private fun toggleDictionaryActive(dictionaryPath: String) {
-        localDictionaryRepository.toggleDictionaryActive(dictionaryPath)
+        viewModelScope.launch {
+            localDictionaryRepository.toggleDictionaryActive(dictionaryPath)
+        }
     }
 
     private fun deleteDictionary(dictionary: Dictionary) {
         viewModelScope.launch {
-            localDictionaryRepository.deleteDictionary(dictionary)
+            when (localDictionaryRepository.deleteDictionary(dictionary)) {
-
+                is OperationResult.Success -> {
-            manageDictionarySourcesUseCase.removeSourceForDictionary(dictionary)
+                    val remainingDictionaryFileNames =
-
+                        localDictionaryRepository.listDictionaryPayloadFileNames(
-            val remainingDictionaries = localDictionaryRepository.dictionaries.first()
+                            preferencesManager.dictionaryPath
-
+                        )
-            if (remainingDictionaries.isEmpty()) {
+                    manageDictionarySourcesUseCase.removeSourceForDictionary(
-                dictionaryStatus.value = DictionaryStatus.Empty
+                        dictionary = dictionary,
+                        remainingDictionaryFileNames = remainingDictionaryFileNames,
+                    )
+                    dictionaryStatus.value = withContext(Dispatchers.IO) {
+                        evaluateDictionaryStatus()
+                    }
+                }
+                is OperationResult.Error -> {
+                    effectChannel.send(
+                        getApplication<Application>().getString(R.string.error_delete_dictionary)
+                    )
+                }
             }
         }
     }
 
     private fun addDictionarySources(urlTemplates: List<String>) {
         viewModelScope.launch {
-            try {
+            val validUrls = mutableListOf<String>()
-                val validUrls = mutableListOf<String>()
 
-                urlTemplates.forEach { urlTemplate ->
+            urlTemplates.forEach { urlTemplate ->
-                    val trimmed = urlTemplate.trim()
+                val trimmed = urlTemplate.trim()
-                    if (trimmed.isEmpty() || trimmed.length > 2048) {
+                if (trimmed.isEmpty() || trimmed.length > 2048) {
-                        return@forEach
+                    return@forEach
-                    }
+                }
 
+                val normalizedUrl = DictionarySource.normalizeTemplate(trimmed)
+                if (!pendingSourceUrls.add(normalizedUrl)) {
+                    return@forEach
+                }
+
+                try {
                     when (manageDictionarySourcesUseCase.addSource(trimmed)) {
                         is ManageDictionarySourcesUseCase.AddSourceResult.Success -> {
-                            pendingSourceUrls.add(DictionarySource.normalizeTemplate(trimmed))
                             validUrls.add(trimmed)
                         }
                         is ManageDictionarySourcesUseCase.AddSourceResult.ValidationFailed -> {
+                            pendingSourceUrls.remove(normalizedUrl)
                             // Validation failed, skip this source
                         }
                     }
+                } catch (e: Exception) {
+                    pendingSourceUrls.remove(normalizedUrl)
+                    android.util.Log.e("SettingsViewModel", "Error adding dictionary source", e)
                 }
+            }
 
-                if (validUrls.isNotEmpty()) {
+            if (validUrls.isNotEmpty()) {
-                    startDownloadForSources(validUrls)
+                startDownloadForSources(validUrls)
-                }
-            } catch (e: Exception) {
-                android.util.Log.e("SettingsViewModel", "Error adding dictionary sources", e)
             }
         }
     }
@@ -383,6 +419,7 @@ class SettingsViewModel(
                 return@launch
             }
 
+            statusBeforeDownload = dictionaryStatus.value
             dictionaryStatus.value = DictionaryStatus.Checking
             isDownloadInProgress = true
 
@@ -406,11 +443,8 @@ class SettingsViewModel(
                 return@launch
             }
 
+            statusBeforeDownload = dictionaryStatus.value
             dictionaryStatus.value = DictionaryStatus.Checking
-            val status = withContext(Dispatchers.IO) { evaluateDictionaryStatus() }
-            dictionaryStatus.value = status
-
-            if (status !is DictionaryStatus.NeedsUpdate) return@launch
 
             val installedSources = installedEnabledSources(
                 preferencesManager.dictionarySources.first(),
@@ -445,14 +479,8 @@ class SettingsViewModel(
     private fun installedSources(
         sources: List<DictionarySource>,
         dictionaries: List<Dictionary>
-    ): List<DictionarySource> {
+    ): List<DictionarySource> =
-        val installedFileNames = dictionaries.map { File(it.path).name }
+        DictionarySourceFileMatcher.installedSources(sources, dictionaries)
-        return sources.filter { source ->
-            installedFileNames.any { fileName ->
-                DictionarySource.matchesDictionaryFile(source.urlTemplate, fileName)
-            }
-        }
-    }
 
     private fun cancelDownload() {
         // Cancel the ViewModel-side scan job so no further status recomputes
@@ -481,13 +509,12 @@ class SettingsViewModel(
             getApplication<Application>().stopService(stopIntent)
         }
 
+    }
+
+    private fun refreshDictionaryStatus() {
         viewModelScope.launch {
-            val dictionaries = localDictionaryRepository.dictionaries.first()
+            dictionaryStatus.value = DictionaryStatus.Checking
-            dictionaryStatus.value = if (dictionaries.isNotEmpty()) {
+            dictionaryStatus.value = withContext(Dispatchers.IO) { evaluateDictionaryStatus() }
-                DictionaryStatus.UpToDate
-            } else {
-                DictionaryStatus.Empty
-            }
         }
     }
 
@@ -499,17 +526,17 @@ class SettingsViewModel(
             is OperationResult.Success -> {
                 val dictionaries = localDictionaryRepository.dictionaries.first()
                 if (dictionaries.isEmpty()) {
-                    dictionaryStatus.value = DictionaryStatus.Empty
+                    dictionaryStatus.value = withContext(Dispatchers.IO) {
+                        evaluateDictionaryStatus()
+                    }
+                    isDownloadInProgress = false
+                } else if (isDownloadInProgress) {
+                    dictionaryStatus.value = DictionaryStatus.UpToDate
                     isDownloadInProgress = false
                 } else {
-                    if (isDownloadInProgress) {
+                    dictionaryStatus.value = DictionaryStatus.Checking
-                        dictionaryStatus.value = DictionaryStatus.UpToDate
+                    val status = withContext(Dispatchers.IO) { evaluateDictionaryStatus() }
-                        isDownloadInProgress = false
+                    dictionaryStatus.value = status
-                    } else {
-                        dictionaryStatus.value = DictionaryStatus.Checking
-                        val status = withContext(Dispatchers.IO) { evaluateDictionaryStatus() }
-                        dictionaryStatus.value = status
-                    }
                 }
 
                 if (result.data > 0) {

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

@@ -30,6 +30,7 @@ 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.clipToBounds
 import androidx.compose.ui.draw.scale
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.graphicsLayer
@@ -81,7 +82,8 @@ fun DictionaryListItem(
     dictionary: Dictionary,
     onToggle: () -> Unit,
     onDelete: () -> Unit,
-    modifier: Modifier = Modifier
+    modifier: Modifier = Modifier,
+    canDelete: Boolean = true
 ) {
     val haptic = LocalHapticFeedback.current
     val density = LocalDensity.current
@@ -93,7 +95,9 @@ fun DictionaryListItem(
     val offsetAnim = remember { Animatable(0f) }
 
     var rawOffset by remember { mutableFloatStateOf(0f) }
-    val isDeleteRevealed by remember { derivedStateOf { rawOffset <= -swipeThresholdPx } }
+    val isDeleteRevealed by remember(canDelete) {
+        derivedStateOf { canDelete && rawOffset <= -swipeThresholdPx }
+    }
 
     LaunchedEffect(isDeleteRevealed) {
         if (isDeleteRevealed) {
@@ -101,6 +105,13 @@ fun DictionaryListItem(
         }
     }
 
+    LaunchedEffect(canDelete) {
+        if (!canDelete) {
+            rawOffset = 0f
+            offsetAnim.snapTo(0f)
+        }
+    }
+
     val currentOnDelete by rememberUpdatedState(onDelete)
     val currentOnToggle by rememberUpdatedState(onToggle)
 
@@ -121,6 +132,8 @@ fun DictionaryListItem(
     Box(
         modifier = modifier
             .fillMaxWidth()
+            .height(DictionaryItemHeight)
+            .clipToBounds()
             .testTag("dictionary_item")
     ) {
         Row(
@@ -129,7 +142,8 @@ fun DictionaryListItem(
                 .height(DictionaryItemHeight)
                 .background(MaterialTheme.colorScheme.surfaceVariant)
                 .graphicsLayer { translationX = offsetAnim.value }
-                .pointerInput(maxSwipePx, swipeThresholdPx) {
+                .pointerInput(canDelete, maxSwipePx, swipeThresholdPx) {
+                    if (!canDelete) return@pointerInput
                     detectHorizontalDragGestures(
                         onDragStart = {
                             haptic.performHapticFeedback(HapticFeedbackType.TextHandleMove)
@@ -222,25 +236,11 @@ fun DictionaryListItem(
             }
 
             if (isDeleteRevealed) {
-                IconButton(
+                Box(
-                    onClick = {
-                        haptic.performHapticFeedback(HapticFeedbackType.TextHandleMove)
-                        currentOnDelete()
-                        scope.launch { offsetAnim.snapTo(0f) }
-                        rawOffset = 0f
-                    },
                     modifier = Modifier
                         .padding(end = ItemHorizontalPadding)
-                        .graphicsLayer { translationX = -offsetAnim.value }
                         .size(IconButtonSize)
-                ) {
+                )
-                    Icon(
-                        painter = painterResource(R.drawable.ic_delete),
-                        contentDescription = stringResource(R.string.dictionary_delete),
-                        tint = DeleteIconColor,
-                        modifier = Modifier.size(IconSize)
-                    )
-                }
             } else {
                 Switch(
                     checked = dictionary.isActive,
@@ -257,5 +257,27 @@ fun DictionaryListItem(
                 )
             }
         }
+
+        if (isDeleteRevealed) {
+            IconButton(
+                onClick = {
+                    haptic.performHapticFeedback(HapticFeedbackType.TextHandleMove)
+                    currentOnDelete()
+                    scope.launch { offsetAnim.snapTo(0f) }
+                    rawOffset = 0f
+                },
+                modifier = Modifier
+                    .align(Alignment.CenterEnd)
+                    .padding(end = ItemHorizontalPadding)
+                    .size(IconButtonSize)
+            ) {
+                Icon(
+                    painter = painterResource(R.drawable.ic_delete),
+                    contentDescription = stringResource(R.string.dictionary_delete),
+                    tint = DeleteIconColor,
+                    modifier = Modifier.size(IconSize)
+                )
+            }
+        }
     }
 }

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

@@ -166,7 +166,8 @@ fun DictionaryManagement(
                             onDeleteDictionary = onDeleteDictionary,
                             modifier = Modifier
                                 .fillMaxWidth()
-                                .then(backgroundModifier)
+                                .then(backgroundModifier),
+                            canDelete = !isInProgress
                         )
 
                         if (!isInProgress) {
@@ -246,7 +247,8 @@ private fun DictionaryListSection(
     dictionaries: List<Dictionary>,
     onToggleDictionary: (String) -> Unit,
     onDeleteDictionary: (Dictionary) -> Unit,
-    modifier: Modifier = Modifier
+    modifier: Modifier = Modifier,
+    canDelete: Boolean = true
 ) {
     Column(
         modifier = modifier,
@@ -256,7 +258,8 @@ private fun DictionaryListSection(
             DictionaryListItem(
                 dictionary = dictionary,
                 onToggle = { onToggleDictionary(dictionary.path) },
-                onDelete = { onDeleteDictionary(dictionary) }
+                onDelete = { onDeleteDictionary(dictionary) },
+                canDelete = canDelete
             )
         }
     }

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

@@ -7,6 +7,7 @@
     <string name="button_cancel_download">Отмена</string>
     <string name="action_ok">ОК</string>
     <string name="download_error">Ошибка загрузки словарей</string>
+    <string name="download_network_failed">Нет связи с сервером словарей. Проверьте сеть и попробуйте снова</string>
     <string name="language">Язык</string>
     <string name="language_english">Английский</string>
     <string name="language_russian">Русский</string>
@@ -95,6 +96,7 @@
     </plurals>
     <string name="dictionary_not_indexed">• Не индексирован</string>
     <string name="dictionary_delete">Удалить словарь</string>
+    <string name="error_delete_dictionary">Не удалось удалить словарь</string>
     <string name="dictionaries_tap_to_update">Нажмите для обновления</string>
     <string name="notification_import_title">Импорт словарей</string>
     <string name="notification_import_success_title">Импорт завершён</string>

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

@@ -7,6 +7,7 @@
     <string name="button_cancel_download">Cancel</string>
     <string name="action_ok">OK</string>
     <string name="download_error">Dictionary download failed</string>
+    <string name="download_network_failed">No connection to the dictionary server. Check your network and try again</string>
     <string name="language">Language</string>
     <string name="language_english">English</string>
     <string name="language_russian">Russian</string>
@@ -91,6 +92,7 @@
     </plurals>
     <string name="dictionary_not_indexed">• Not indexed</string>
     <string name="dictionary_delete">Delete dictionary</string>
+    <string name="error_delete_dictionary">Failed to delete dictionary</string>
     <string name="dictionaries_tap_to_update">Tap to update all dictionaries</string>
     <string name="notification_import_title">Importing dictionaries</string>
     <string name="notification_import_success_title">Import completed</string>

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

@@ -0,0 +1,3 @@
+- Fixed the dictionary update card after starting or cancelling a download
+- Fixed download progress staying at 0% for too long
+- Rebuilt the search field on Material 3 and aligned dictionary title typography

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

@@ -0,0 +1,4 @@
+- Fixed a crash and lost dictionary state around search results
+- Added diacritic-insensitive search, so accented and plain spellings match each other
+- Fixed indexing failures on dictionaries with dense non-Latin text
+- Search results now keep loading as you scroll instead of stopping early

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

@@ -0,0 +1 @@
+- Fixed the dictionary update card taking too long to reappear after cancelling a download

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

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

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

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

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

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

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

@@ -0,0 +1,3 @@
+- Исправлена карточка обновления словаря после запуска и отмены загрузки
+- Исправлено зависание индикатора прогресса загрузки на 0%
+- Строка поиска переведена на Material 3; выровнена типографика заголовков словаря

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

@@ -0,0 +1,4 @@
+- Исправлен сбой и потеря состояния словаря в результатах поиска
+- Добавлен поиск без учёта диакритических знаков — совпадают варианты с акцентами и без
+- Исправлена ошибка индексации словарей с плотным нелатинским текстом
+- Результаты поиска теперь полностью подгружаются при прокрутке, а не обрываются на первых совпадениях

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

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

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

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

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

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

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

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

gradle/libs.versions.toml

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

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.0-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.6.1-bin.zip
 networkTimeout=10000
 retries=0
 retryBackOffMs=500