Feature: Three-backend viewer architecture with virtual scrolling

Replace the simple read_file_content approach with a session-based three-backend
architecture that handles files of any size:

- FullLoadBackend: files ≤ 1 MB, instant random access in RAM
- ByteSeekBackend: instant open for large files, byte-offset seeking
- LineIndexBackend: sparse line index (every 256 lines), built in background

ViewerSession orchestrator picks the right backend and transparently upgrades
from ByteSeek to LineIndex once the background scan completes.

Frontend uses virtual scrolling (only renders visible lines + 50-line buffer)
with on-demand line fetching from the backend. Search runs server-side with
cancellation support and progress reporting.

64 new Rust tests covering all backends and orchestrator. Old client-side
search utilities removed.

Author: claude

apps/desktop/src-tauri/Cargo.lock

@@ -60,6 +60,7 @@ futures-util = "0.3"
 tower-http = { version = "0.6", features = ["cors"] }
 tauri-plugin-updater = "2"
 tauri-plugin-process = "2"
+memchr = "2"
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2"

apps/desktop/src-tauri/Cargo.toml

@@ -561,70 +561,6 @@ pub fn start_selection_drag(
     Err("Drag operation is not yet supported on this platform".to_string())
 }
 
-// ============================================================================
-// File viewer
-// ============================================================================
-
-/// Result of reading a file's content for the viewer.
-#[derive(Debug, serde::Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct FileContentResult {
-    /// The text content of the file (UTF-8 lossy decoded).
-    pub content: String,
-    /// Total number of lines.
-    pub line_count: usize,
-    /// File size in bytes.
-    pub size: u64,
-    /// The file name (last component of the path).
-    pub file_name: String,
-}
-
-/// Reads a file's content as text for the file viewer.
-///
-/// Returns the full file content as a UTF-8 string (lossy — invalid bytes become replacement chars).
-/// Not optimized for huge files; intended for reasonably-sized text files.
-///
-/// # Arguments
-/// * `path` - Absolute path to the file. Supports tilde expansion (~).
-#[tauri::command]
-pub fn read_file_content(path: String) -> Result<FileContentResult, String> {
-    let expanded = expand_tilde(&path);
-    let file_path = PathBuf::from(&expanded);
-
-    if !file_path.exists() {
-        return Err(format!("File not found: {}", path));
-    }
-    if file_path.is_dir() {
-        return Err("Cannot view a directory".to_string());
-    }
-
-    let metadata = std::fs::metadata(&file_path).map_err(|e| match e.kind() {
-        std::io::ErrorKind::PermissionDenied => format!("Permission denied: {}", path),
-        _ => format!("Cannot read file metadata: {}", e),
-    })?;
-
-    let size = metadata.len();
-    let bytes = std::fs::read(&file_path).map_err(|e| match e.kind() {
-        std::io::ErrorKind::PermissionDenied => format!("Permission denied: {}", path),
-        _ => format!("Failed to read file: {}", e),
-    })?;
-
-    let content = String::from_utf8_lossy(&bytes).into_owned();
-    let line_count = content.lines().count().max(1);
-
-    let file_name = file_path
-        .file_name()
-        .map(|n| n.to_string_lossy().into_owned())
-        .unwrap_or_else(|| path.clone());
-
-    Ok(FileContentResult {
-        content,
-        line_count,
-        size,
-        file_name,
-    })
-}
-
 /// Expands tilde (~) to the user's home directory.
 fn expand_tilde(path: &str) -> String {
     if (path.starts_with("~/") || path == "~")
@@ -724,83 +660,4 @@ mod tests {
         let result = create_directory("/nonexistent_path_12345".to_string(), "test".to_string());
         assert!(result.is_err());
     }
-
-    // ========================================================================
-    // read_file_content tests
-    // ========================================================================
-
-    #[test]
-    fn test_read_file_content_success() {
-        let tmp = create_test_dir("read_content_ok");
-        let file_path = tmp.join("hello.txt");
-        fs::write(&file_path, "line 1\nline 2\nline 3\n").unwrap();
-
-        let result = read_file_content(file_path.to_string_lossy().to_string());
-        assert!(result.is_ok());
-        let res = result.unwrap();
-        assert_eq!(res.file_name, "hello.txt");
-        assert_eq!(res.line_count, 3);
-        assert!(res.content.starts_with("line 1"));
-        assert_eq!(res.size, 21);
-        cleanup_test_dir(&tmp);
-    }
-
-    #[test]
-    fn test_read_file_content_empty_file() {
-        let tmp = create_test_dir("read_content_empty");
-        let file_path = tmp.join("empty.txt");
-        fs::write(&file_path, "").unwrap();
-
-        let result = read_file_content(file_path.to_string_lossy().to_string());
-        assert!(result.is_ok());
-        let res = result.unwrap();
-        assert_eq!(res.content, "");
-        assert_eq!(res.line_count, 1); // At least 1
-        assert_eq!(res.size, 0);
-        cleanup_test_dir(&tmp);
-    }
-
-    #[test]
-    fn test_read_file_content_not_found() {
-        let result = read_file_content("/nonexistent_file_12345.txt".to_string());
-        assert!(result.is_err());
-        assert!(result.unwrap_err().contains("File not found"));
-    }
-
-    #[test]
-    fn test_read_file_content_directory() {
-        let tmp = create_test_dir("read_content_dir");
-        let result = read_file_content(tmp.to_string_lossy().to_string());
-        assert!(result.is_err());
-        assert!(result.unwrap_err().contains("Cannot view a directory"));
-        cleanup_test_dir(&tmp);
-    }
-
-    #[test]
-    fn test_read_file_content_binary() {
-        let tmp = create_test_dir("read_content_binary");
-        let file_path = tmp.join("binary.bin");
-        fs::write(&file_path, b"\x00\x01\x02\xff\xfe").unwrap();
-
-        let result = read_file_content(file_path.to_string_lossy().to_string());
-        assert!(result.is_ok());
-        // Binary content is lossy-decoded, should contain replacement characters
-        let res = result.unwrap();
-        assert!(res.content.contains('\u{FFFD}'));
-        cleanup_test_dir(&tmp);
-    }
-
-    #[test]
-    fn test_read_file_content_single_line_no_newline() {
-        let tmp = create_test_dir("read_content_single");
-        let file_path = tmp.join("single.txt");
-        fs::write(&file_path, "hello world").unwrap();
-
-        let result = read_file_content(file_path.to_string_lossy().to_string());
-        assert!(result.is_ok());
-        let res = result.unwrap();
-        assert_eq!(res.line_count, 1);
-        assert_eq!(res.content, "hello world");
-        cleanup_test_dir(&tmp);
-    }
 }

apps/desktop/src-tauri/src/commands/file_system.rs

@@ -0,0 +1,66 @@
+//! Tauri commands for the file viewer.
+
+use crate::file_viewer::{self, LineChunk, SearchPollResult, SeekTarget, ViewerOpenResult};
+
+/// Opens a viewer session for the given file.
+/// Returns session metadata + initial lines from the start of the file.
+#[tauri::command]
+pub fn viewer_open(path: String) -> Result<ViewerOpenResult, String> {
+    file_viewer::open_session(&path).map_err(|e| e.to_string())
+}
+
+/// Fetches a range of lines from a viewer session.
+///
+/// # Arguments
+/// * `session_id` - The session ID from `viewer_open`.
+/// * `target_type` - One of "line", "byte", or "fraction".
+/// * `target_value` - The seek value (line number, byte offset, or fraction 0.0-1.0).
+/// * `count` - Number of lines to fetch.
+#[tauri::command]
+pub fn viewer_get_lines(
+    session_id: String,
+    target_type: String,
+    target_value: f64,
+    count: usize,
+) -> Result<LineChunk, String> {
+    let target = match target_type.as_str() {
+        "line" => SeekTarget::Line(target_value as usize),
+        "byte" => SeekTarget::ByteOffset(target_value as u64),
+        "fraction" => SeekTarget::Fraction(target_value),
+        other => {
+            return Err(format!(
+                "Unknown target type: {}. Use 'line', 'byte', or 'fraction'.",
+                other
+            ));
+        }
+    };
+    file_viewer::get_lines(&session_id, target, count).map_err(|e| e.to_string())
+}
+
+/// Starts a background search in the viewer session.
+/// Poll with `viewer_search_poll` to get results.
+#[tauri::command]
+pub fn viewer_search_start(session_id: String, query: String) -> Result<(), String> {
+    if query.is_empty() {
+        return Err("Search query cannot be empty".to_string());
+    }
+    file_viewer::search_start(&session_id, query).map_err(|e| e.to_string())
+}
+
+/// Polls search progress and current matches.
+#[tauri::command]
+pub fn viewer_search_poll(session_id: String) -> Result<SearchPollResult, String> {
+    file_viewer::search_poll(&session_id).map_err(|e| e.to_string())
+}
+
+/// Cancels an ongoing search.
+#[tauri::command]
+pub fn viewer_search_cancel(session_id: String) -> Result<(), String> {
+    file_viewer::search_cancel(&session_id).map_err(|e| e.to_string())
+}
+
+/// Closes a viewer session and frees resources.
+#[tauri::command]
+pub fn viewer_close(session_id: String) -> Result<(), String> {
+    file_viewer::close_session(&session_id).map_err(|e| e.to_string())
+}

apps/desktop/src-tauri/src/commands/file_viewer.rs

@@ -1,6 +1,7 @@
 //! Tauri commands module.
 
 pub mod file_system;
+pub mod file_viewer;
 pub mod font_metrics;
 pub mod icons;
 pub mod licensing;