From ae66ddaf4a617f390ac58e3c5999c021083a003e Mon Sep 17 00:00:00 2001
From: Elie Gambache <elyahou.hadass@gmail.com>
Date: Mon, 2 Feb 2026 23:22:03 +0200
Subject: [PATCH] feat(highlights): implement position-based text highlighting

- Add character offset tracking for precise highlight positioning
- Preserve highlight position when toggling nikud/taamim visibility
- Improve highlight color picker UI in context menu
- Use proper menu item colors for icons and text
---
 .run/SeforimApp [run].run.xml                 |   1 -
 .../composeResources/values/strings.xml       |   1 +
 .../seforimapp/core/HighlightStore.kt         | 147 +++++++++++++
 .../seforimapp/core/LineTextRegistry.kt       | 202 ++++++++++++++++++
 .../seforimapp/core/TextSelectionStore.kt     |  24 +++
 .../core/presentation/text/HebrewSearch.kt    |  79 ++++++-
 .../core/presentation/text/Highlighting.kt    |  58 +++++
 .../features/bookcontent/BookContentScreen.kt | 181 ++++++++++++++++
 .../bookcontent/views/BookContentView.kt      | 121 ++++++++++-
 .../resources/icons/lucide_text_search.svg    |  12 +-
 SeforimLibrary                                |   2 +-
 gradle/libs.versions.toml                     |   2 +-
 12 files changed, 816 insertions(+), 14 deletions(-)
 create mode 100644 SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/HighlightStore.kt
 create mode 100644 SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/LineTextRegistry.kt

diff --git a/.run/SeforimApp [run].run.xml b/.run/SeforimApp [run].run.xml
index 3b8b74cb..058c9f76 100644
--- a/.run/SeforimApp [run].run.xml	
+++ b/.run/SeforimApp [run].run.xml	
@@ -3,7 +3,6 @@
     <ExternalSystemSettings>
       <option name="env">
         <map>
-          <entry key="SEFORIMAPP_DATABASE_PATH" value="$PROJECT_DIR$/SeforimLibrary/build/seforim.db" />
           <entry key="SEFORIMAPP_LOGGING" value="true" />
           <entry key="SEFORIMAPP_REPOSITORY_LOGGIN" value="true" />
         </map>
diff --git a/SeforimApp/src/commonMain/composeResources/values/strings.xml b/SeforimApp/src/commonMain/composeResources/values/strings.xml
index ebe2acce..09528dc9 100644
--- a/SeforimApp/src/commonMain/composeResources/values/strings.xml
+++ b/SeforimApp/src/commonMain/composeResources/values/strings.xml
@@ -107,6 +107,7 @@
     <string name="context_menu_search_selected_text">חפש במאגר</string>
     <string name="context_menu_find_in_page">חפש בעמוד</string>
     <string name="context_menu_copy_without_nikud">העתק ללא ניקוד</string>
+    <string name="context_menu_highlight">סמן</string>
 
     <!-- Book Content Screen - End Vertical Bar -->
     <string name="tools">כלים</string>
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/HighlightStore.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/HighlightStore.kt
new file mode 100644
index 00000000..6fe4ae1c
--- /dev/null
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/HighlightStore.kt
@@ -0,0 +1,147 @@
+package io.github.kdroidfilter.seforimapp.core
+
+import androidx.compose.runtime.Stable
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.TextRange
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+
+/**
+ * Represents a single user highlight with position information.
+ * Highlights are stored per line with character offsets for precise positioning.
+ *
+ * @property lineId The ID of the line containing this highlight
+ * @property startOffset The starting character offset within the line's text
+ * @property endOffset The ending character offset within the line's text
+ * @property color The highlight color
+ */
+@Stable
+data class UserHighlight(
+    val lineId: Long,
+    val startOffset: Int,
+    val endOffset: Int,
+    val color: Color,
+) {
+    /** Returns the text range of this highlight */
+    val textRange: TextRange get() = TextRange(startOffset, endOffset)
+}
+
+/**
+ * Available highlight colors for the user to choose from.
+ */
+object HighlightColors {
+    val Yellow = Color(0xFFFFEB3B)
+    val Green = Color(0xFF4CAF50)
+    val Blue = Color(0xFF2196F3)
+    val Pink = Color(0xFFE91E63)
+    val Orange = Color(0xFFFF9800)
+    val Transparent = Color.Transparent
+
+    val all = listOf(Yellow, Green, Blue, Pink, Orange)
+    val allWithClear = listOf(Yellow, Green, Blue, Pink, Orange, Transparent)
+}
+
+/**
+ * In-memory store for user highlights.
+ * Highlights are stored per book with position information (lineId + offsets).
+ * Will be lost when the application closes.
+ */
+object HighlightStore {
+    // Map of bookId to list of highlights for that book
+    private val _highlightsByBook = MutableStateFlow<Map<Long, List<UserHighlight>>>(emptyMap())
+    val highlightsByBook: StateFlow<Map<Long, List<UserHighlight>>> = _highlightsByBook.asStateFlow()
+
+    /**
+     * Adds a new highlight for the specified book and line.
+     * If an overlapping highlight exists on the same line, it merges or updates.
+     */
+    fun addHighlight(
+        bookId: Long,
+        lineId: Long,
+        startOffset: Int,
+        endOffset: Int,
+        color: Color,
+    ) {
+        if (startOffset >= endOffset) return
+
+        _highlightsByBook.update { current ->
+            val bookHighlights = current[bookId].orEmpty().toMutableList()
+
+            // Find existing highlight on the same line that overlaps
+            val existingIndex =
+                bookHighlights.indexOfFirst { hl ->
+                    hl.lineId == lineId && rangesOverlap(hl.startOffset, hl.endOffset, startOffset, endOffset)
+                }
+
+            if (existingIndex >= 0) {
+                // Update existing highlight (replace with new range/color)
+                bookHighlights[existingIndex] = UserHighlight(lineId, startOffset, endOffset, color)
+            } else {
+                // Add new highlight
+                bookHighlights.add(UserHighlight(lineId, startOffset, endOffset, color))
+            }
+
+            current + (bookId to bookHighlights)
+        }
+    }
+
+    /**
+     * Removes highlights that overlap with the specified range on the given line.
+     */
+    fun removeHighlight(
+        bookId: Long,
+        lineId: Long,
+        startOffset: Int,
+        endOffset: Int,
+    ) {
+        _highlightsByBook.update { current ->
+            val bookHighlights =
+                current[bookId].orEmpty().filter { hl ->
+                    !(hl.lineId == lineId && rangesOverlap(hl.startOffset, hl.endOffset, startOffset, endOffset))
+                }
+            if (bookHighlights.isEmpty()) {
+                current - bookId
+            } else {
+                current + (bookId to bookHighlights)
+            }
+        }
+    }
+
+    /**
+     * Gets all highlights for a specific book.
+     */
+    fun getHighlightsForBook(bookId: Long): List<UserHighlight> = _highlightsByBook.value[bookId].orEmpty()
+
+    /**
+     * Gets all highlights for a specific line in a book.
+     */
+    fun getHighlightsForLine(
+        bookId: Long,
+        lineId: Long,
+    ): List<UserHighlight> = _highlightsByBook.value[bookId].orEmpty().filter { it.lineId == lineId }
+
+    /**
+     * Clears all highlights for a specific book.
+     */
+    fun clearHighlightsForBook(bookId: Long) {
+        _highlightsByBook.update { current ->
+            current - bookId
+        }
+    }
+
+    /**
+     * Clears all highlights.
+     */
+    fun clearAll() {
+        _highlightsByBook.value = emptyMap()
+    }
+
+    private fun rangesOverlap(
+        start1: Int,
+        end1: Int,
+        start2: Int,
+        end2: Int,
+    ): Boolean = start1 < end2 && start2 < end1
+}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/LineTextRegistry.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/LineTextRegistry.kt
new file mode 100644
index 00000000..074046cf
--- /dev/null
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/LineTextRegistry.kt
@@ -0,0 +1,202 @@
+package io.github.kdroidfilter.seforimapp.core
+
+import androidx.compose.runtime.Stable
+import io.github.kdroidfilter.seforimapp.core.presentation.text.findAllMatchesOriginal
+
+/**
+ * Represents a match found in a line.
+ *
+ * @property lineId The ID of the line containing the match
+ * @property startOffset The starting character offset within the line's plain text
+ * @property endOffset The ending character offset within the line's plain text
+ */
+@Stable
+data class LineMatch(
+    val lineId: Long,
+    val startOffset: Int,
+    val endOffset: Int,
+)
+
+/**
+ * Registry that tracks the plain text content of lines for a book.
+ * Used to find which line(s) contain selected text.
+ *
+ * Thread-safe for concurrent access.
+ */
+class LineTextRegistry {
+    // Map of lineId to plain text content
+    private val lineTexts = mutableMapOf<Long, String>()
+
+    /**
+     * Registers or updates the plain text for a line.
+     */
+    @Synchronized
+    fun registerLine(
+        lineId: Long,
+        plainText: String,
+    ) {
+        lineTexts[lineId] = plainText
+    }
+
+    /**
+     * Unregisters a line (e.g., when it's no longer visible).
+     */
+    @Synchronized
+    fun unregisterLine(lineId: Long) {
+        lineTexts.remove(lineId)
+    }
+
+    /**
+     * Clears all registered lines.
+     */
+    @Synchronized
+    fun clear() {
+        lineTexts.clear()
+    }
+
+    /**
+     * Finds all lines that contain the given text.
+     * Uses diacritic-insensitive matching for Hebrew text.
+     *
+     * @param selectedText The text to search for
+     * @return List of matches with line IDs and offsets
+     */
+    @Synchronized
+    fun findMatches(selectedText: String): List<LineMatch> {
+        val trimmed = selectedText.trim()
+        if (trimmed.isEmpty()) return emptyList()
+
+        val matches = mutableListOf<LineMatch>()
+        for ((lineId, text) in lineTexts) {
+            val ranges = findAllMatchesOriginal(text, trimmed)
+            for (range in ranges) {
+                matches.add(
+                    LineMatch(
+                        lineId = lineId,
+                        startOffset = range.first,
+                        endOffset = range.last + 1,
+                    ),
+                )
+            }
+        }
+        return matches
+    }
+
+    /**
+     * Finds a match in a specific line, closest to the given character offset.
+     * Use this when you know which line and approximate position the user is interacting with.
+     *
+     * @param selectedText The text to search for
+     * @param lineId The specific line to search in
+     * @param nearOffset Optional character offset to find the closest match to
+     * @return The match in that line closest to the offset, or null if not found
+     */
+    @Synchronized
+    fun findMatchInLine(
+        selectedText: String,
+        lineId: Long,
+        nearOffset: Int? = null,
+    ): LineMatch? {
+        val trimmed = selectedText.trim()
+        if (trimmed.isEmpty()) return null
+
+        val text = lineTexts[lineId] ?: return null
+        val ranges = findAllMatchesOriginal(text, trimmed)
+        if (ranges.isEmpty()) return null
+
+        // If no offset hint, return first match
+        if (nearOffset == null) {
+            val range = ranges.first()
+            return LineMatch(
+                lineId = lineId,
+                startOffset = range.first,
+                endOffset = range.last + 1,
+            )
+        }
+
+        // Find the match closest to the given offset
+        val closestRange =
+            ranges.minByOrNull { range ->
+                minOf(
+                    kotlin.math.abs(range.first - nearOffset),
+                    kotlin.math.abs(range.last - nearOffset),
+                )
+            } ?: ranges.first()
+
+        return LineMatch(
+            lineId = lineId,
+            startOffset = closestRange.first,
+            endOffset = closestRange.last + 1,
+        )
+    }
+
+    /**
+     * Finds the first line that contains the given text.
+     * Searches lines in sorted order by lineId for deterministic results.
+     * Falls back to this when no specific line is known.
+     *
+     * @param selectedText The text to search for
+     * @return The first match (by lineId order), or null if not found
+     */
+    @Synchronized
+    fun findFirstMatch(selectedText: String): LineMatch? {
+        val trimmed = selectedText.trim()
+        if (trimmed.isEmpty()) return null
+
+        // Sort by lineId for deterministic iteration order
+        for ((lineId, text) in lineTexts.entries.sortedBy { it.key }) {
+            val ranges = findAllMatchesOriginal(text, trimmed)
+            if (ranges.isNotEmpty()) {
+                val range = ranges.first()
+                return LineMatch(
+                    lineId = lineId,
+                    startOffset = range.first,
+                    endOffset = range.last + 1,
+                )
+            }
+        }
+        return null
+    }
+
+    /**
+     * Gets the plain text for a specific line.
+     */
+    @Synchronized
+    fun getLineText(lineId: Long): String? = lineTexts[lineId]
+
+    /**
+     * Gets the number of registered lines.
+     */
+    @Synchronized
+    fun size(): Int = lineTexts.size
+}
+
+/**
+ * Global registry instance for the current book view.
+ * In a multi-tab scenario, each tab should have its own registry.
+ */
+object GlobalLineTextRegistry {
+    private val registries = mutableMapOf<String, LineTextRegistry>()
+
+    /**
+     * Gets or creates a registry for the given tab.
+     */
+    @Synchronized
+    fun getForTab(tabId: String): LineTextRegistry = registries.getOrPut(tabId) { LineTextRegistry() }
+
+    /**
+     * Removes the registry for the given tab.
+     */
+    @Synchronized
+    fun removeForTab(tabId: String) {
+        registries.remove(tabId)
+    }
+
+    /**
+     * Clears all registries.
+     */
+    @Synchronized
+    fun clearAll() {
+        registries.clear()
+    }
+}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/TextSelectionStore.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/TextSelectionStore.kt
index 995851f0..1844c620 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/TextSelectionStore.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/TextSelectionStore.kt
@@ -12,11 +12,35 @@ object TextSelectionStore {
     private val _selectedText = MutableStateFlow("")
     val selectedText: StateFlow<String> = _selectedText.asStateFlow()
 
+    // Track the line ID and approximate character offset where user is interacting
+    private val _activeLineId = MutableStateFlow<Long?>(null)
+    val activeLineId: StateFlow<Long?> = _activeLineId.asStateFlow()
+
+    private val _activeCharOffset = MutableStateFlow<Int?>(null)
+    val activeCharOffset: StateFlow<Int?> = _activeCharOffset.asStateFlow()
+
     fun updateSelection(text: String) {
         _selectedText.value = text
     }
 
+    fun updateActiveLineId(lineId: Long) {
+        _activeLineId.value = lineId
+    }
+
+    fun updateActivePosition(
+        lineId: Long,
+        charOffset: Int,
+    ) {
+        _activeLineId.value = lineId
+        _activeCharOffset.value = charOffset
+    }
+
     fun clear() {
         _selectedText.value = ""
     }
+
+    fun clearActiveLineId() {
+        _activeLineId.value = null
+        _activeCharOffset.value = null
+    }
 }
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/text/HebrewSearch.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/text/HebrewSearch.kt
index fcf20b19..51e1a44b 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/text/HebrewSearch.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/text/HebrewSearch.kt
@@ -10,7 +10,7 @@ package io.github.kdroidfilter.seforimapp.core.presentation.text
 /**
  * Returns the string without nikud+teamim and an index map from plain index -> original index.
  */
-internal fun stripDiacriticsWithMap(src: String): Pair<String, IntArray> {
+fun stripDiacriticsWithMap(src: String): Pair<String, IntArray> {
     val nikudOrTeamim: (Char) -> Boolean = { c ->
         (c.code in 0x0591..0x05AF) ||
             // teamim
@@ -70,6 +70,83 @@ internal fun mapToOrigIndex(
     return mapToOrig[idx]
 }
 
+/**
+ * Creates a mapping from original text indices (with diacritics) to stripped text indices (without diacritics).
+ * Returns an IntArray where originalToStripped[origIndex] = strippedIndex, or -1 if that character was stripped.
+ */
+fun createOriginalToStrippedMap(src: String): IntArray {
+    val nikudOrTeamim: (Char) -> Boolean = { c ->
+        (c.code in 0x0591..0x05AF) ||
+            (c.code in 0x05B0..0x05BD) ||
+            (c == '\u05C1') ||
+            (c == '\u05C2') ||
+            (c == '\u05C7')
+    }
+    val result = IntArray(src.length) { -1 }
+    var strippedIndex = 0
+    for (i in src.indices) {
+        val ch = src[i]
+        if (!nikudOrTeamim(ch) && ch != '\u05F4' && ch != '\u05F3') {
+            result[i] = strippedIndex
+            strippedIndex++
+        }
+    }
+    return result
+}
+
+/**
+ * Maps an offset from original text (with diacritics) to stripped text (without diacritics).
+ * If the original offset points to a diacritic, finds the nearest valid position.
+ */
+fun mapOriginalToStripped(
+    originalOffset: Int,
+    originalToStrippedMap: IntArray,
+): Int {
+    if (originalToStrippedMap.isEmpty()) return originalOffset
+    val safeOffset = originalOffset.coerceIn(0, originalToStrippedMap.size)
+
+    // If pointing past the end, return length of stripped text
+    if (safeOffset >= originalToStrippedMap.size) {
+        // Count non-diacritic chars
+        return originalToStrippedMap.count { it >= 0 }
+    }
+
+    // If this position maps directly, use it
+    if (originalToStrippedMap[safeOffset] >= 0) {
+        return originalToStrippedMap[safeOffset]
+    }
+
+    // Otherwise find the next valid position going forward
+    for (i in safeOffset until originalToStrippedMap.size) {
+        if (originalToStrippedMap[i] >= 0) {
+            return originalToStrippedMap[i]
+        }
+    }
+
+    // If no forward position found, return length
+    return originalToStrippedMap.count { it >= 0 }
+}
+
+/**
+ * Maps an offset from stripped text (without diacritics) back to original text (with diacritics).
+ * Uses the mapping created by stripDiacriticsWithMap.
+ */
+fun mapStrippedToOriginal(
+    strippedOffset: Int,
+    strippedToOriginalMap: IntArray,
+): Int {
+    if (strippedToOriginalMap.isEmpty()) return strippedOffset
+    if (strippedOffset >= strippedToOriginalMap.size) {
+        // Return past-the-end position
+        return if (strippedToOriginalMap.isNotEmpty()) {
+            strippedToOriginalMap.last() + 1
+        } else {
+            strippedOffset
+        }
+    }
+    return strippedToOriginalMap[strippedOffset.coerceAtLeast(0)]
+}
+
 /**
  * Find all diacritic-insensitive matches of [query] in [text], returning original
  * character index ranges [start, end) suitable for highlighting.
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/text/Highlighting.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/text/Highlighting.kt
index 6fe6674b..c1df817c 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/text/Highlighting.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/core/presentation/text/Highlighting.kt
@@ -3,6 +3,7 @@ package io.github.kdroidfilter.seforimapp.core.presentation.text
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.text.AnnotatedString
 import androidx.compose.ui.text.SpanStyle
+import io.github.kdroidfilter.seforimapp.core.UserHighlight
 
 /**
  * Returns a copy of [annotated] with background highlight applied to all
@@ -107,3 +108,60 @@ fun highlightAnnotatedWithTerms(
     }
     return builder.toAnnotatedString()
 }
+
+/**
+ * Applies user highlights to an annotated string for a specific line.
+ * Only highlights that belong to this line are applied.
+ * Each highlight uses its stored offsets for precise positioning.
+ *
+ * Highlights are stored with offsets relative to the original text (with diacritics).
+ * When displaying without diacritics, the offsets are mapped to the stripped text positions.
+ *
+ * @param annotated The annotated string to apply highlights to
+ * @param highlights List of highlights for this specific line
+ * @param originalText The original text with diacritics (for offset mapping)
+ * @param showDiacritics Whether diacritics are currently shown
+ * @param highlightAlpha The alpha value for highlight colors (default 0.4)
+ */
+fun applyUserHighlights(
+    annotated: AnnotatedString,
+    highlights: List<UserHighlight>,
+    originalText: String? = null,
+    showDiacritics: Boolean = true,
+    highlightAlpha: Float = 0.4f,
+): AnnotatedString {
+    if (highlights.isEmpty()) return annotated
+
+    val builder = AnnotatedString.Builder()
+    builder.append(annotated)
+
+    // Create mapping from original to stripped if diacritics are hidden
+    val originalToStrippedMap =
+        if (!showDiacritics && originalText != null) {
+            createOriginalToStrippedMap(originalText)
+        } else {
+            null
+        }
+
+    for (highlight in highlights) {
+        // Map offsets if diacritics are hidden
+        val (start, end) =
+            if (originalToStrippedMap != null) {
+                val mappedStart = mapOriginalToStripped(highlight.startOffset, originalToStrippedMap)
+                val mappedEnd = mapOriginalToStripped(highlight.endOffset, originalToStrippedMap)
+                mappedStart to mappedEnd
+            } else {
+                highlight.startOffset to highlight.endOffset
+            }
+
+        val clampedStart = start.coerceIn(0, annotated.length)
+        val clampedEnd = end.coerceAtMost(annotated.length)
+        val color = highlight.color.copy(alpha = highlightAlpha)
+
+        if (clampedEnd > clampedStart) {
+            builder.addStyle(SpanStyle(background = color), clampedStart, clampedEnd)
+        }
+    }
+
+    return builder.toAnnotatedString()
+}
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/BookContentScreen.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/BookContentScreen.kt
index f7663749..577d8c6b 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/BookContentScreen.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/BookContentScreen.kt
@@ -5,14 +5,24 @@ import androidx.compose.foundation.ContextMenuItem
 import androidx.compose.foundation.ContextMenuState
 import androidx.compose.foundation.ExperimentalFoundationApi
 import androidx.compose.foundation.LocalContextMenuRepresentation
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.foundation.text.LocalTextContextMenu
 import androidx.compose.foundation.text.TextContextMenu
 import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
 import androidx.compose.ui.focus.FocusDirection
 import androidx.compose.ui.focus.FocusManager
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.input.InputMode
 import androidx.compose.ui.input.InputModeManager
 import androidx.compose.ui.input.key.Key
@@ -26,8 +36,14 @@ import androidx.compose.ui.input.key.key
 import androidx.compose.ui.input.key.nativeKeyCode
 import androidx.compose.ui.input.key.onPreviewKeyEvent
 import androidx.compose.ui.input.key.type
+import androidx.compose.ui.input.pointer.PointerEventType
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.unit.dp
 import com.dokar.sonner.ToastType
 import com.dokar.sonner.rememberToasterState
+import io.github.kdroidfilter.seforimapp.core.GlobalLineTextRegistry
+import io.github.kdroidfilter.seforimapp.core.HighlightColors
+import io.github.kdroidfilter.seforimapp.core.HighlightStore
 import io.github.kdroidfilter.seforimapp.core.TextSelectionStore
 import io.github.kdroidfilter.seforimapp.core.presentation.components.AppToaster
 import io.github.kdroidfilter.seforimapp.core.settings.AppSettings
@@ -42,6 +58,7 @@ import io.github.kdroidfilter.seforimapp.features.bookcontent.ui.panels.bookcont
 import io.github.kdroidfilter.seforimapp.features.bookcontent.ui.panels.booktoc.BookTocPanel
 import io.github.kdroidfilter.seforimapp.features.bookcontent.ui.panels.categorytree.CategoryTreePanel
 import io.github.kdroidfilter.seforimapp.features.search.SearchHomeUiState
+import io.github.kdroidfilter.seforimapp.icons.Ink_pen
 import io.github.kdroidfilter.seforimlibrary.core.text.HebrewTextUtils
 import kotlinx.coroutines.FlowPreview
 import kotlinx.coroutines.flow.debounce
@@ -55,6 +72,7 @@ import org.jetbrains.jewel.foundation.InternalJewelApi
 import org.jetbrains.jewel.foundation.theme.JewelTheme
 import org.jetbrains.jewel.ui.component.ContextMenuItemOption
 import org.jetbrains.jewel.ui.component.DefaultMenuController
+import org.jetbrains.jewel.ui.component.Icon
 import org.jetbrains.jewel.ui.component.LocalMenuController
 import org.jetbrains.jewel.ui.component.MenuContent
 import org.jetbrains.jewel.ui.component.MenuController
@@ -70,6 +88,7 @@ import org.jetbrains.skiko.hostOs
 import seforimapp.seforimapp.generated.resources.Res
 import seforimapp.seforimapp.generated.resources.context_menu_copy_without_nikud
 import seforimapp.seforimapp.generated.resources.context_menu_find_in_page
+import seforimapp.seforimapp.generated.resources.context_menu_highlight
 import seforimapp.seforimapp.generated.resources.context_menu_search_selected_text
 import seforimapp.seforimapp.generated.resources.max_commentators_limit
 import java.awt.Toolkit
@@ -89,6 +108,15 @@ private class ContextMenuItemOptionWithKeybinding(
     action: () -> Unit,
 ) : ContextMenuItem(label, action)
 
+/**
+ * Custom context menu item that displays a row of highlight color swatches.
+ */
+private class ContextMenuHighlightColorPicker(
+    val colors: List<Color>,
+    val onColorSelected: (Color) -> Unit,
+    val onDismiss: () -> Unit,
+) : ContextMenuItem("highlight", {})
+
 @OptIn(InternalJewelApi::class)
 private object BookContentContextMenuRepresentationWithKeybindings : ComposeContextMenuRepresentation {
     @Composable
@@ -162,6 +190,18 @@ private fun MenuScope.contextItems(items: List<ContextMenuItem>) {
         when (item) {
             is org.jetbrains.jewel.ui.component.ContextMenuDivider -> separator()
             is org.jetbrains.jewel.ui.component.ContextSubmenu -> submenu(submenu = { contextItems(item.submenu()) }) { Text(item.label) }
+            is ContextMenuHighlightColorPicker -> {
+                separator()
+                passiveItem {
+                    HighlightColorPickerRow(
+                        colors = item.colors,
+                        onSelect = { color ->
+                            item.onColorSelected(color)
+                            item.onDismiss()
+                        },
+                    )
+                }
+            }
             is ContextMenuItemOptionWithKeybinding ->
                 selectableItem(
                     selected = false,
@@ -189,6 +229,97 @@ private fun MenuScope.contextItems(items: List<ContextMenuItem>) {
     }
 }
 
+/**
+ * A row of color swatches for highlighting text.
+ */
+@Composable
+private fun HighlightColorPickerRow(
+    colors: List<Color>,
+    onSelect: (Color) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val highlightLabel = stringResource(Res.string.context_menu_highlight)
+    // Use menu item content color directly since passiveItem doesn't set up LocalContentColor
+    val contentColor = JewelTheme.menuStyle.colors.itemColors.content
+
+    Row(
+        modifier =
+            modifier
+                .fillMaxWidth()
+                .padding(horizontal = 12.dp, vertical = 4.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Icon(
+            imageVector = Ink_pen,
+            contentDescription = null,
+            tint = contentColor,
+            modifier = Modifier.size(16.dp),
+        )
+        Text(
+            text = highlightLabel,
+            color = contentColor,
+            modifier = Modifier.padding(end = 8.dp),
+        )
+        colors.forEach { color ->
+            HighlightColorSwatch(
+                color = color,
+                onClick = { onSelect(color) },
+            )
+        }
+    }
+}
+
+/**
+ * A single color swatch with hover effect matching Jewel menu items.
+ */
+@Composable
+private fun HighlightColorSwatch(
+    color: Color,
+    onClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    var isHovered by remember { mutableStateOf(false) }
+    val hoverBackground = JewelTheme.menuStyle.colors.itemColors.backgroundHovered
+    val isTransparent = color == Color.Transparent
+
+    Box(
+        modifier =
+            modifier
+                .clip(RoundedCornerShape(4.dp))
+                .background(if (isHovered) hoverBackground else Color.Transparent)
+                .pointerInput(Unit) {
+                    awaitPointerEventScope {
+                        while (true) {
+                            val event = awaitPointerEvent()
+                            isHovered = event.type == PointerEventType.Enter ||
+                                (event.type == PointerEventType.Move && event.changes.any { it.pressed.not() })
+                            if (event.type == PointerEventType.Exit) {
+                                isHovered = false
+                            }
+                        }
+                    }
+                }.clickable { onClick() }
+                .padding(6.dp),
+        contentAlignment = Alignment.Center,
+    ) {
+        if (isTransparent) {
+            Icon(
+                key = AllIconsKeys.Windows.Close,
+                contentDescription = null,
+                modifier = Modifier.size(16.dp),
+            )
+        } else {
+            Box(
+                modifier =
+                    Modifier
+                        .size(18.dp)
+                        .clip(RoundedCornerShape(4.dp))
+                        .background(color),
+            )
+        }
+    }
+}
+
 private fun handlePopupMenuOnKeyEvent(
     keyEvent: KeyEvent,
     focusManager: FocusManager,
@@ -271,6 +402,9 @@ fun BookContentScreen(
     val selectedBook = uiState.navigation.selectedBook
     val bookHasDiacritics = selectedBook?.hasNekudot == true || selectedBook?.hasTeamim == true
 
+    // Get the book ID for highlight storage
+    val bookId = selectedBook?.id ?: 0L
+
     val textContextMenu =
         remember(
             baseTextContextMenu,
@@ -281,6 +415,7 @@ fun BookContentScreen(
             copyWithoutNikudLabel,
             showDiacritics,
             bookHasDiacritics,
+            bookId,
         ) {
             object : TextContextMenu {
                 @OptIn(ExperimentalFoundationApi::class)
@@ -350,6 +485,52 @@ fun BookContentScreen(
                                         AppSettings.openFindBar(tabId)
                                     },
                                 )
+                                // Highlight color picker - at the end of the menu
+                                if (selectedText.isNotBlank() && bookId > 0) {
+                                    val lineTextRegistry = GlobalLineTextRegistry.getForTab(tabId)
+                                    // Try to find match in the active line first (where user is interacting)
+                                    val activeLineId = TextSelectionStore.activeLineId.value
+                                    val activeCharOffset = TextSelectionStore.activeCharOffset.value
+                                    val match =
+                                        if (activeLineId != null) {
+                                            lineTextRegistry.findMatchInLine(
+                                                selectedText,
+                                                activeLineId,
+                                                activeCharOffset,
+                                            ) ?: lineTextRegistry.findFirstMatch(selectedText)
+                                        } else {
+                                            lineTextRegistry.findFirstMatch(selectedText)
+                                        }
+
+                                    if (match != null) {
+                                        add(
+                                            ContextMenuHighlightColorPicker(
+                                                colors = HighlightColors.allWithClear,
+                                                onColorSelected = { color ->
+                                                    if (color == Color.Transparent) {
+                                                        HighlightStore.removeHighlight(
+                                                            bookId,
+                                                            match.lineId,
+                                                            match.startOffset,
+                                                            match.endOffset,
+                                                        )
+                                                    } else {
+                                                        HighlightStore.addHighlight(
+                                                            bookId,
+                                                            match.lineId,
+                                                            match.startOffset,
+                                                            match.endOffset,
+                                                            color,
+                                                        )
+                                                    }
+                                                },
+                                                onDismiss = {
+                                                    state.status = ContextMenuState.Status.Closed
+                                                },
+                                            ),
+                                        )
+                                    }
+                                }
                             }
                         },
                     ) {
diff --git a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/BookContentView.kt b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/BookContentView.kt
index ffefb0ac..8b5eb2d8 100644
--- a/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/BookContentView.kt
+++ b/SeforimApp/src/jvmMain/kotlin/io/github/kdroidfilter/seforimapp/features/bookcontent/ui/panels/bookcontent/views/BookContentView.kt
@@ -31,6 +31,7 @@ import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.graphicsLayer
 import androidx.compose.ui.input.key.*
 import androidx.compose.ui.input.pointer.PointerEventPass
+import androidx.compose.ui.input.pointer.PointerEventType
 import androidx.compose.ui.input.pointer.isCtrlPressed
 import androidx.compose.ui.input.pointer.isMetaPressed
 import androidx.compose.ui.input.pointer.isPrimaryPressed
@@ -38,6 +39,7 @@ import androidx.compose.ui.input.pointer.isShiftPressed
 import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.layout.layout
 import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.TextLayoutResult
 import androidx.compose.ui.text.font.FontFamily
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
@@ -47,9 +49,17 @@ import androidx.paging.LoadState
 import androidx.paging.compose.LazyPagingItems
 import androidx.paging.compose.itemKey
 import io.github.kdroidfilter.seforim.htmlparser.buildAnnotatedFromHtml
+import io.github.kdroidfilter.seforimapp.core.GlobalLineTextRegistry
+import io.github.kdroidfilter.seforimapp.core.HighlightStore
+import io.github.kdroidfilter.seforimapp.core.LineTextRegistry
+import io.github.kdroidfilter.seforimapp.core.TextSelectionStore
+import io.github.kdroidfilter.seforimapp.core.UserHighlight
 import io.github.kdroidfilter.seforimapp.core.presentation.components.CountBadge
 import io.github.kdroidfilter.seforimapp.core.presentation.components.FindInPageBar
+import io.github.kdroidfilter.seforimapp.core.presentation.text.applyUserHighlights
 import io.github.kdroidfilter.seforimapp.core.presentation.text.findAllMatchesOriginal
+import io.github.kdroidfilter.seforimapp.core.presentation.text.mapStrippedToOriginal
+import io.github.kdroidfilter.seforimapp.core.presentation.text.stripDiacriticsWithMap
 import io.github.kdroidfilter.seforimapp.core.presentation.typography.FontCatalog
 import io.github.kdroidfilter.seforimapp.core.settings.AppSettings
 import io.github.kdroidfilter.seforimapp.features.bookcontent.BookContentEvent
@@ -413,6 +423,20 @@ fun BookContentView(
         }
     }
 
+    // Collect user highlights for this book
+    val highlightsByBook by HighlightStore.highlightsByBook.collectAsState()
+    val allHighlights = highlightsByBook[bookId].orEmpty()
+
+    // Get the line text registry for this tab (for highlight position lookup)
+    val lineTextRegistry = remember(tabId) { GlobalLineTextRegistry.getForTab(tabId) }
+
+    // Clean up registry when component is disposed
+    DisposableEffect(tabId) {
+        onDispose {
+            lineTextRegistry.clear()
+        }
+    }
+
     var currentHitLineIndex by remember { mutableIntStateOf(-1) }
     var currentMatchLineId by remember { mutableStateOf<Long?>(null) }
     var currentMatchStart by remember { mutableIntStateOf(-1) }
@@ -593,6 +617,12 @@ fun BookContentView(
                                             onClick = { onLineSelect(line, false) },
                                         )
                                     }
+                                    // Filter highlights for this specific line
+                                    val lineHighlights =
+                                        remember(allHighlights, line.id) {
+                                            allHighlights.filter { it.lineId == line.id }
+                                        }
+
                                     LineItem(
                                         lineId = line.id,
                                         lineContent = line.content,
@@ -610,6 +640,8 @@ fun BookContentView(
                                             if (showFind && currentMatchLineId == line.id) currentMatchStart else null,
                                         annotatedCache = stableAnnotatedCache,
                                         showDiacritics = showDiacritics,
+                                        userHighlights = lineHighlights,
+                                        lineTextRegistry = lineTextRegistry,
                                     )
                                 }
                             }
@@ -807,6 +839,8 @@ private fun LineItem(
     currentMatchStart: Int? = null,
     annotatedCache: StableAnnotatedCache? = null,
     showDiacritics: Boolean = true,
+    userHighlights: List<UserHighlight> = emptyList(),
+    lineTextRegistry: LineTextRegistry? = null,
 ) {
     // Process content: remove diacritics if setting is disabled
     val processedContent =
@@ -839,6 +873,19 @@ private fun LineItem(
             )
         }
 
+    // Get the original plain text (with diacritics) from the original lineContent for highlight mapping
+    val originalPlainText =
+        remember(lineContent) {
+            // Strip HTML to get plain text, keeping diacritics
+            buildAnnotatedFromHtml(lineContent, baseTextSize, boldScale = 1f).text
+        }
+
+    // Register the ORIGINAL text (with diacritics) with the registry for highlight position lookup
+    // This ensures highlight offsets are always relative to the original text
+    LaunchedEffect(lineId, originalPlainText, lineTextRegistry) {
+        lineTextRegistry?.registerLine(lineId, originalPlainText)
+    }
+
     // Build highlighted text when a query is active (>= 2 chars)
     val baseHl =
         JewelTheme.globalColors.outlines.focused
@@ -846,12 +893,33 @@ private fun LineItem(
     val currentHl =
         JewelTheme.globalColors.outlines.focused
             .copy(alpha = 0.42f)
+
     val displayText: AnnotatedString =
-        remember(annotated, highlightQuery, highlightTerms, currentMatchStart, baseHl, currentHl) {
+        remember(
+            annotated,
+            highlightQuery,
+            highlightTerms,
+            currentMatchStart,
+            baseHl,
+            currentHl,
+            userHighlights,
+            showDiacritics,
+            originalPlainText,
+        ) {
+            // First apply user highlights with offset mapping for diacritics mode
+            val withUserHighlights =
+                applyUserHighlights(
+                    annotated = annotated,
+                    highlights = userHighlights,
+                    originalText = originalPlainText,
+                    showDiacritics = showDiacritics,
+                )
+
+            // Then apply search highlights on top
             if (!highlightTerms.isNullOrEmpty()) {
                 // Smart mode: highlight multiple terms from dictionary expansion
                 io.github.kdroidfilter.seforimapp.core.presentation.text.highlightAnnotatedWithTerms(
-                    annotated = annotated,
+                    annotated = withUserHighlights,
                     terms = highlightTerms,
                     currentStart = currentMatchStart?.takeIf { it >= 0 },
                     baseColor = baseHl,
@@ -860,7 +928,7 @@ private fun LineItem(
             } else {
                 // Normal mode: highlight single query
                 io.github.kdroidfilter.seforimapp.core.presentation.text.highlightAnnotatedWithCurrent(
-                    annotated = annotated,
+                    annotated = withUserHighlights,
                     query = highlightQuery,
                     currentStart = currentMatchStart?.takeIf { it >= 0 },
                     currentLength = highlightQuery?.length,
@@ -883,11 +951,55 @@ private fun LineItem(
         }
     }
 
+    // Track TextLayoutResult to convert pointer position to character offset
+    var textLayoutResult by remember { mutableStateOf<TextLayoutResult?>(null) }
+
+    // Pre-compute mapping from stripped to original indices if diacritics are hidden
+    val strippedToOriginalMap =
+        remember(originalPlainText, showDiacritics) {
+            if (!showDiacritics) {
+                val (_, map) = stripDiacriticsWithMap(originalPlainText)
+                map
+            } else {
+                null
+            }
+        }
+
     val textModifier =
         remember {
             Modifier.fillMaxWidth()
         }.bringIntoViewRequester(bringRequester)
-            .pointerInput(lineId) {
+            .pointerInput(lineId, textLayoutResult, strippedToOriginalMap) {
+                awaitPointerEventScope {
+                    while (true) {
+                        val event = awaitPointerEvent()
+                        // Track when pointer enters or presses this line for highlight positioning
+                        if (event.type == PointerEventType.Enter ||
+                            event.type == PointerEventType.Press
+                        ) {
+                            val position = event.changes.firstOrNull()?.position
+                            val displayedOffset =
+                                if (position != null && textLayoutResult != null) {
+                                    textLayoutResult!!.getOffsetForPosition(position)
+                                } else {
+                                    null
+                                }
+                            // Map displayed offset to original text offset if diacritics are hidden
+                            val charOffset =
+                                if (displayedOffset != null && strippedToOriginalMap != null) {
+                                    mapStrippedToOriginal(displayedOffset, strippedToOriginalMap)
+                                } else {
+                                    displayedOffset
+                                }
+                            if (charOffset != null) {
+                                TextSelectionStore.updateActivePosition(lineId, charOffset)
+                            } else {
+                                TextSelectionStore.updateActiveLineId(lineId)
+                            }
+                        }
+                    }
+                }
+            }.pointerInput(lineId) {
                 awaitEachGesture {
                     // Wait for press and capture keyboard modifiers from the event
                     val downEvent = awaitPointerEvent(PointerEventPass.Main)
@@ -907,6 +1019,7 @@ private fun LineItem(
         fontFamily = fontFamily,
         lineHeight = (baseTextSize * lineHeight).sp,
         modifier = textModifier,
+        onTextLayout = { textLayoutResult = it },
     )
 }
 
diff --git a/SeforimApp/src/jvmMain/resources/icons/lucide_text_search.svg b/SeforimApp/src/jvmMain/resources/icons/lucide_text_search.svg
index 5366ac24..3a03982f 100644
--- a/SeforimApp/src/jvmMain/resources/icons/lucide_text_search.svg
+++ b/SeforimApp/src/jvmMain/resources/icons/lucide_text_search.svg
@@ -1,7 +1,7 @@
-<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
-  <path d="M21 5H3" stroke="#6C707E" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
-  <path d="M10 12H3" stroke="#6C707E" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
-  <path d="M10 19H3" stroke="#6C707E" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
-  <circle cx="17" cy="15" r="3" stroke="#6C707E" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
-  <path d="M21 19L19.1 17.1" stroke="#6C707E" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path d="M14 3H2" stroke="#6E6E6E" stroke-linecap="round" stroke-linejoin="round"/>
+  <path d="M7 8H2" stroke="#6E6E6E" stroke-linecap="round" stroke-linejoin="round"/>
+  <path d="M7 13H2" stroke="#6E6E6E" stroke-linecap="round" stroke-linejoin="round"/>
+  <circle cx="11" cy="10" r="2.5" stroke="#6E6E6E" stroke-linecap="round" stroke-linejoin="round"/>
+  <path d="M14 13L12.5 11.5" stroke="#6E6E6E" stroke-linecap="round" stroke-linejoin="round"/>
 </svg>
diff --git a/SeforimLibrary b/SeforimLibrary
index 580a561f..83687fac 160000
--- a/SeforimLibrary
+++ b/SeforimLibrary
@@ -1 +1 @@
-Subproject commit 580a561fc7a62dd95f8a3d549240dc740b4d2982
+Subproject commit 83687facc26f7ccd616809fa49640cd443f944fe
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 0207c6d5..6166caaa 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -29,7 +29,7 @@ jewel = "0.33.0-253.29795"
 jna = "5.18.1"
 oshiCore = "6.9.3"
 paging = "3.4.0"
-platformtools = "0.7.4"
+platformtools = "0.7.5"
 composenativetray = "1.0.4"
 kotlinx-coroutines = "1.10.2"
 reorderable = "3.0.0"