Bugfix: Fix 3 bugs found by new unit tests

- Fix `LineIndexBackend::search()` using byte offsets instead of UTF-16 code units for `SearchMatch.column` and `.length` — search highlights after emoji/CJK landed in wrong positions
- Fix `parse_smbutil_output()` using `split_whitespace()` which broke share names with spaces (like "Time Machine", "My Documents" common on Synology/QNAP). Now uses keyword-based column detection via `rfind`
- Fix race condition in `manual_servers.rs` where concurrent `add_manual_server()` calls could silently lose entries. Added `STORE_LOCK` mutex to protect read-modify-write cycle
- Add 46 unit tests across 5 areas: file viewer UTF-8 (17), listing stats (7), smbutil parser (10), indexing lifecycle (5), concurrent writes (7)
- Update `network/CLAUDE.md` with concurrency strategy for persistence stores

Author: vdavid

apps/desktop/src-tauri/src/file_system/listing/mod.rs

@@ -41,3 +41,5 @@ mod hidden_files_test;
 mod operations_test;
 #[cfg(test)]
 mod sorting_test;
+#[cfg(test)]
+mod stats_test;

apps/desktop/src-tauri/src/file_system/listing/stats_test.rs

@@ -0,0 +1,217 @@
+//! Tests for `get_listing_stats()` — total/visible counts, sizes, and selection sums.
+
+use super::caching::{CachedListing, LISTING_CACHE};
+use super::operations::{get_listing_stats, list_directory_end};
+use super::sorting::DirectorySortMode;
+use super::{FileEntry, SortColumn, SortOrder};
+
+/// Creates a test entry with configurable sizes.
+fn make_entry(name: &str, is_dir: bool, size: Option<u64>, physical_size: Option<u64>) -> FileEntry {
+    let mut entry = FileEntry {
+        size: if is_dir { None } else { size },
+        physical_size: if is_dir { None } else { physical_size },
+        recursive_size: if is_dir { size } else { None },
+        recursive_physical_size: if is_dir { physical_size } else { None },
+        modified_at: Some(1_700_000_000),
+        created_at: Some(1_700_000_000),
+        permissions: if is_dir { 0o755 } else { 0o644 },
+        owner: "testuser".to_string(),
+        group: "staff".to_string(),
+        extended_metadata_loaded: true,
+        ..FileEntry::new(name.to_string(), format!("/{}", name), is_dir, false)
+    };
+    // Ensure directories don't have file-level size and vice versa
+    if is_dir {
+        entry.size = None;
+        entry.physical_size = None;
+    } else {
+        entry.recursive_size = None;
+        entry.recursive_physical_size = None;
+    }
+    entry
+}
+
+/// Inserts entries into the listing cache and returns the listing ID.
+fn insert_test_listing(id: &str, entries: Vec<FileEntry>) -> String {
+    let listing_id = id.to_string();
+    let mut cache = LISTING_CACHE.write().unwrap();
+    cache.insert(
+        listing_id.clone(),
+        CachedListing {
+            volume_id: "test".to_string(),
+            path: std::path::PathBuf::from("/"),
+            entries,
+            sort_by: SortColumn::Name,
+            sort_order: SortOrder::Ascending,
+            directory_sort_mode: DirectorySortMode::LikeFiles,
+            sequence: std::sync::atomic::AtomicU64::new(0),
+        },
+    );
+    listing_id
+}
+
+// ============================================================================
+// Basic stats
+// ============================================================================
+
+#[test]
+fn test_stats_mixed_files_and_dirs() {
+    let entries = vec![
+        make_entry("Documents", true, Some(50_000), Some(52_000)),
+        make_entry("Photos", true, Some(100_000), Some(104_000)),
+        make_entry("notes.txt", false, Some(1_024), Some(4_096)),
+        make_entry("report.pdf", false, Some(2_048), Some(4_096)),
+        make_entry("tiny.log", false, Some(10), Some(4_096)),
+    ];
+    let listing_id = insert_test_listing("test-stats-mixed", entries);
+
+    let stats = get_listing_stats(&listing_id, true, None).unwrap();
+
+    list_directory_end(&listing_id);
+
+    assert_eq!(stats.total_dirs, 2);
+    assert_eq!(stats.total_files, 3);
+    assert_eq!(stats.total_size, 50_000 + 100_000 + 1_024 + 2_048 + 10);
+    assert_eq!(stats.total_physical_size, 52_000 + 104_000 + 4_096 + 4_096 + 4_096);
+    assert!(stats.selected_files.is_none());
+    assert!(stats.selected_dirs.is_none());
+    assert!(stats.selected_size.is_none());
+    assert!(stats.selected_physical_size.is_none());
+}
+
+// ============================================================================
+// Hidden file filtering
+// ============================================================================
+
+#[test]
+fn test_stats_hidden_files_excluded() {
+    let entries = vec![
+        make_entry(".config", true, Some(5_000), Some(8_192)),
+        make_entry(".bashrc", false, Some(512), Some(4_096)),
+        make_entry("Documents", true, Some(50_000), Some(52_000)),
+        make_entry("readme.md", false, Some(1_024), Some(4_096)),
+    ];
+    let listing_id = insert_test_listing("test-stats-hidden-excluded", entries);
+
+    let stats_all = get_listing_stats(&listing_id, true, None).unwrap();
+    let stats_visible = get_listing_stats(&listing_id, false, None).unwrap();
+
+    list_directory_end(&listing_id);
+
+    // With hidden: all 4 entries
+    assert_eq!(stats_all.total_dirs, 2);
+    assert_eq!(stats_all.total_files, 2);
+    assert_eq!(stats_all.total_size, 5_000 + 512 + 50_000 + 1_024);
+
+    // Without hidden: only Documents + readme.md
+    assert_eq!(stats_visible.total_dirs, 1);
+    assert_eq!(stats_visible.total_files, 1);
+    assert_eq!(stats_visible.total_size, 50_000 + 1_024);
+    assert_eq!(stats_visible.total_physical_size, 52_000 + 4_096);
+}
+
+// ============================================================================
+// Selection stats
+// ============================================================================
+
+#[test]
+fn test_stats_with_selection() {
+    let entries = vec![
+        make_entry("Documents", true, Some(50_000), Some(52_000)),
+        make_entry("Photos", true, Some(100_000), Some(104_000)),
+        make_entry("notes.txt", false, Some(1_024), Some(4_096)),
+        make_entry("report.pdf", false, Some(2_048), Some(4_096)),
+    ];
+    let listing_id = insert_test_listing("test-stats-selection", entries);
+
+    // Select indices 0 (Documents) and 2 (notes.txt)
+    let stats = get_listing_stats(&listing_id, true, Some(&[0, 2])).unwrap();
+
+    list_directory_end(&listing_id);
+
+    // Totals cover all entries
+    assert_eq!(stats.total_dirs, 2);
+    assert_eq!(stats.total_files, 2);
+
+    // Selection covers only the two selected entries
+    assert_eq!(stats.selected_dirs, Some(1));
+    assert_eq!(stats.selected_files, Some(1));
+    assert_eq!(stats.selected_size, Some(50_000 + 1_024));
+    assert_eq!(stats.selected_physical_size, Some(52_000 + 4_096));
+}
+
+// ============================================================================
+// Edge cases
+// ============================================================================
+
+#[test]
+fn test_stats_empty_directory() {
+    let listing_id = insert_test_listing("test-stats-empty", vec![]);
+
+    let stats = get_listing_stats(&listing_id, true, None).unwrap();
+
+    list_directory_end(&listing_id);
+
+    assert_eq!(stats.total_dirs, 0);
+    assert_eq!(stats.total_files, 0);
+    assert_eq!(stats.total_size, 0);
+    assert_eq!(stats.total_physical_size, 0);
+    assert!(stats.selected_files.is_none());
+}
+
+#[test]
+fn test_stats_all_hidden_without_hidden_flag() {
+    let entries = vec![
+        make_entry(".git", true, Some(200_000), Some(204_800)),
+        make_entry(".gitignore", false, Some(256), Some(4_096)),
+        make_entry(".env", false, Some(128), Some(4_096)),
+    ];
+    let listing_id = insert_test_listing("test-stats-all-hidden", entries);
+
+    let stats = get_listing_stats(&listing_id, false, None).unwrap();
+
+    list_directory_end(&listing_id);
+
+    // Everything is hidden, so visible stats are all zero
+    assert_eq!(stats.total_dirs, 0);
+    assert_eq!(stats.total_files, 0);
+    assert_eq!(stats.total_size, 0);
+    assert_eq!(stats.total_physical_size, 0);
+}
+
+#[test]
+fn test_stats_selection_with_out_of_bounds_index_is_ignored() {
+    let entries = vec![make_entry("file.txt", false, Some(1_000), Some(4_096))];
+    let listing_id = insert_test_listing("test-stats-oob-selection", entries);
+
+    // Index 0 is valid, index 99 is out of bounds
+    let stats = get_listing_stats(&listing_id, true, Some(&[0, 99])).unwrap();
+
+    list_directory_end(&listing_id);
+
+    // Only the valid index should be counted
+    assert_eq!(stats.selected_files, Some(1));
+    assert_eq!(stats.selected_dirs, Some(0));
+    assert_eq!(stats.selected_size, Some(1_000));
+}
+
+#[test]
+fn test_stats_entries_without_sizes() {
+    // Entries where size is None (e.g., network volumes that don't report sizes)
+    let entries = vec![
+        make_entry("remote_dir", true, None, None),
+        make_entry("unknown.dat", false, None, None),
+    ];
+    let listing_id = insert_test_listing("test-stats-no-sizes", entries);
+
+    let stats = get_listing_stats(&listing_id, true, Some(&[0, 1])).unwrap();
+
+    list_directory_end(&listing_id);
+
+    assert_eq!(stats.total_dirs, 1);
+    assert_eq!(stats.total_files, 1);
+    assert_eq!(stats.total_size, 0);
+    assert_eq!(stats.total_physical_size, 0);
+    assert_eq!(stats.selected_size, Some(0));
+    assert_eq!(stats.selected_physical_size, Some(0));
+}

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

@@ -368,3 +368,145 @@ fn search_caps_at_match_limit() {
 
     cleanup(&dir);
 }
+
+// ─── Multi-byte UTF-8 tests ────────────────────────────────────────────
+
+#[test]
+fn seek_mid_multibyte_char_snaps_to_line_start() {
+    let dir = create_test_dir("mid_utf8");
+    // "café\n" = 6 bytes (c=1, a=1, f=1, é=2, \n=1). Byte 4 lands inside 'é'.
+    let file = write_test_file(&dir, "test.txt", "café\nplain\n");
+
+    let backend = ByteSeekBackend::open(&file).unwrap();
+    let chunk = backend.get_lines(&SeekTarget::ByteOffset(4), 2).unwrap();
+
+    // Should backward-scan to byte 0 (start of "café") since byte 4 is mid-char inside first line
+    assert_eq!(chunk.byte_offset, 0);
+    assert_eq!(chunk.lines[0], "café");
+
+    cleanup(&dir);
+}
+
+#[test]
+fn seek_mid_emoji_snaps_to_line_start() {
+    let dir = create_test_dir("mid_emoji");
+    // "🦀go\n" = 7 bytes (🦀=4, g=1, o=1, \n=1). Byte 2 lands inside the emoji.
+    let file = write_test_file(&dir, "test.txt", "🦀go\nnext\n");
+
+    let backend = ByteSeekBackend::open(&file).unwrap();
+    let chunk = backend.get_lines(&SeekTarget::ByteOffset(2), 2).unwrap();
+
+    assert_eq!(chunk.byte_offset, 0);
+    assert_eq!(chunk.lines[0], "🦀go");
+
+    cleanup(&dir);
+}
+
+#[test]
+fn seek_mid_cjk_char_snaps_to_line_start() {
+    let dir = create_test_dir("mid_cjk");
+    // '漢' = 3 bytes in UTF-8. "漢字\n" = 7 bytes. Byte 1 lands mid-character.
+    let file = write_test_file(&dir, "test.txt", "漢字\nnext\n");
+
+    let backend = ByteSeekBackend::open(&file).unwrap();
+    let chunk = backend.get_lines(&SeekTarget::ByteOffset(1), 2).unwrap();
+
+    assert_eq!(chunk.byte_offset, 0);
+    assert_eq!(chunk.lines[0], "漢字");
+
+    cleanup(&dir);
+}
+
+#[test]
+fn read_lines_with_mixed_scripts() {
+    let dir = create_test_dir("mixed_scripts");
+    let content = "hello café\n漢字テスト\n🎉🦀🌍\nplain\n";
+    let file = write_test_file(&dir, "test.txt", content);
+
+    let backend = ByteSeekBackend::open(&file).unwrap();
+    let chunk = backend.get_lines(&SeekTarget::ByteOffset(0), 10).unwrap();
+
+    assert_eq!(chunk.lines.len(), 4);
+    assert_eq!(chunk.lines[0], "hello café");
+    assert_eq!(chunk.lines[1], "漢字テスト");
+    assert_eq!(chunk.lines[2], "🎉🦀🌍");
+    assert_eq!(chunk.lines[3], "plain");
+
+    cleanup(&dir);
+}
+
+#[test]
+fn search_emoji_utf16_column() {
+    let dir = create_test_dir("search_emoji");
+    // '🦀' = 4 bytes UTF-8, 2 UTF-16 code units
+    let file = write_test_file(&dir, "test.txt", "🦀rust is great\n");
+
+    let backend = ByteSeekBackend::open(&file).unwrap();
+    let cancel = AtomicBool::new(false);
+    let results: Mutex<Vec<SearchMatch>> = Mutex::new(Vec::new());
+    let progress: Mutex<u64> = Mutex::new(0);
+
+    backend.search("rust", &cancel, &results, &progress).unwrap();
+    let matches = results.lock().unwrap();
+
+    assert_eq!(matches.len(), 1);
+    assert_eq!(matches[0].column, 2); // 🦀 = 2 UTF-16 code units
+    assert_eq!(matches[0].length, 4); // "rust" = 4 ASCII chars = 4 UTF-16 units
+
+    cleanup(&dir);
+}
+
+#[test]
+fn search_cjk_utf16_column() {
+    let dir = create_test_dir("search_cjk");
+    // CJK chars are 3 bytes UTF-8 but 1 UTF-16 code unit each
+    let file = write_test_file(&dir, "test.txt", "漢字test\n");
+
+    let backend = ByteSeekBackend::open(&file).unwrap();
+    let cancel = AtomicBool::new(false);
+    let results: Mutex<Vec<SearchMatch>> = Mutex::new(Vec::new());
+    let progress: Mutex<u64> = Mutex::new(0);
+
+    backend.search("test", &cancel, &results, &progress).unwrap();
+    let matches = results.lock().unwrap();
+
+    assert_eq!(matches.len(), 1);
+    assert_eq!(matches[0].column, 2); // 2 CJK chars = 2 UTF-16 code units
+    assert_eq!(matches[0].length, 4);
+
+    cleanup(&dir);
+}
+
+#[test]
+fn read_emoji_only_lines() {
+    let dir = create_test_dir("emoji_only");
+    let file = write_test_file(&dir, "test.txt", "🎉🎊🎈\n🦀🦞🦐\n");
+
+    let backend = ByteSeekBackend::open(&file).unwrap();
+    let chunk = backend.get_lines(&SeekTarget::ByteOffset(0), 10).unwrap();
+
+    assert_eq!(chunk.lines[0], "🎉🎊🎈");
+    assert_eq!(chunk.lines[1], "🦀🦞🦐");
+
+    cleanup(&dir);
+}
+
+#[test]
+fn read_file_starting_with_bom() {
+    let dir = create_test_dir("bom");
+    // UTF-8 BOM is EF BB BF (3 bytes), rendered as U+FEFF
+    let mut content = vec![0xEF, 0xBB, 0xBF];
+    content.extend_from_slice("hello\nworld\n".as_bytes());
+    let file = dir.join("bom.txt");
+    fs::write(&file, &content).unwrap();
+
+    let backend = ByteSeekBackend::open(&file).unwrap();
+    let chunk = backend.get_lines(&SeekTarget::ByteOffset(0), 10).unwrap();
+
+    // BOM should appear as U+FEFF at start of first line
+    assert!(chunk.lines[0].starts_with('\u{FEFF}'));
+    assert!(chunk.lines[0].ends_with("hello"));
+    assert_eq!(chunk.lines[1], "world");
+
+    cleanup(&dir);
+}