src/state.rs (1)

2318-2359: ⚠️ Potential issue | 🔴 Critical

Fix UTF‑8 index handling in search/selection slices.

Selection and cursor positions are documented as character indices, but find_next_occurrence and get_primary_selection_text slice strings using those indices and mix them with search_text.len() (bytes). This can panic on non‑ASCII input and return incorrect ranges. Convert char indices to byte indices (and back) or standardize on byte indices throughout.

#!/bin/bash
# Verify call sites and index semantics for find_next_occurrence.
rg -n "find_next_occurrence\\(" -g '!**/target/**'
rg -n "Selection::cursor\\(|Selection::new\\(|cursor_char_index" src/state.rs

🐛 Suggested fix (char → byte conversion)

     pub fn find_next_occurrence(
         &self,
         search_text: &str,
         after_pos: usize
     ) -> Option<(usize, usize)> {
         if search_text.is_empty() {
             return None;
         }
+
+        let to_byte = |char_idx: usize| {
+            self.content
+                .char_indices()
+                .nth(char_idx)
+                .map(|(i, _)| i)
+                .unwrap_or(self.content.len())
+        };
+        let after_byte = to_byte(after_pos);

         // Search from after_pos to end
-        if let Some(rel_pos) = self.content[after_pos..].find(search_text) {
-            let start = after_pos + rel_pos;
-            let end = start + search_text.len();
-            return Some((start, end));
+        if let Some(rel_byte) = self.content[after_byte..].find(search_text) {
+            let start_byte = after_byte + rel_byte;
+            let end_byte = start_byte + search_text.len();
+            let start = self.content[..start_byte].chars().count();
+            let end = self.content[..end_byte].chars().count();
+            return Some((start, end));
         }

         // Wrap around: search from beginning to after_pos
-        if let Some(rel_pos) = self.content[..after_pos].find(search_text) {
-            let end = rel_pos + search_text.len();
-            return Some((rel_pos, end));
+        if let Some(rel_byte) = self.content[..after_byte].find(search_text) {
+            let end_byte = rel_byte + search_text.len();
+            let start = self.content[..rel_byte].chars().count();
+            let end = self.content[..end_byte].chars().count();
+            return Some((start, end));
         }

         None
     }
@@
     pub fn get_primary_selection_text(&self) -> Option<String> {
         let primary = self.cursors.primary();

         if primary.is_selection() {
             // Return selected text
             let (start, end) = primary.range();
-            if end <= self.content.len() {
-                return Some(self.content[start..end].to_string());
-            }
+            let to_byte = |char_idx: usize| {
+                self.content
+                    .char_indices()
+                    .nth(char_idx)
+                    .map(|(i, _)| i)
+                    .unwrap_or(self.content.len())
+            };
+            let start_byte = to_byte(start);
+            let end_byte = to_byte(end);
+            if let Some(slice) = self.content.get(start_byte..end_byte) {
+                return Some(slice.to_string());
+            }
         } else {
             // No selection: find word at cursor
             return self.word_at_position(primary.head);
         }

         None
     }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/state.rs` around lines 2318 - 2359, find_next_occurrence and
get_primary_selection_text treat cursor/selection values as char indices but use
them to slice by bytes, which breaks on UTF‑8; convert char indices to byte
offsets before slicing or searching. Specifically: in find_next_occurrence
convert after_pos (char index) to a byte_offset (e.g. sum of
.chars().take(after_pos).map(|c| c.len_utf8())) and use that byte_offset when
slicing self.content[..] and when computing start/end bytes; compute end bytes
as start_byte + search_text.len() (bytes). In get_primary_selection_text convert
primary.range() (start_char,end_char) and primary.head (char index) to byte
offsets before slicing or passing into word_at_position, and update
word_at_position/Selection handling if it currently assumes byte indices so all
callers are consistent; ensure all bounds checks compare against
self.content.len() (bytes).