Bugfix: Cache volumes to prevent timeout at start

During init the frontend calls `list_locations()` 5× within milliseconds(1× `listVolumes` + 4× `findContainingVolume`). Each call does expensive NSFileManager enumeration + icon fetching via `spawn_blocking`, easily exceeding the 2-second backend timeout under concurrent load.

- Add a 5-second TTL cache around `list_locations()` in `volumes/mod.rs`
- Invalidate the cache on volume mount/unmount in `watcher.rs`

Author: vdavid

apps/desktop/src-tauri/src/volumes/mod.rs

@@ -12,6 +12,8 @@ pub mod watcher;
 use serde::{Deserialize, Serialize};
 use std::collections::HashSet;
 use std::path::Path;
+use std::sync::Mutex;
+use std::time::Instant;
 
 /// Category of a location item.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
@@ -88,8 +90,30 @@ fn get_fs_type(path: &str) -> Option<String> {
     String::from_utf8(name_bytes).ok()
 }
 
+/// Short-lived cache for `list_locations()`. During app init the frontend calls
+/// `list_volumes` + `find_containing_volume` × N tabs within milliseconds — each
+/// one calling `list_locations()` which does expensive NSFileManager + icon work.
+/// Caching the result for a few seconds collapses all of those into a single real call.
+static LOCATIONS_CACHE: Mutex<Option<(Instant, Vec<LocationInfo>)>> = Mutex::new(None);
+const LOCATIONS_CACHE_TTL_SECS: u64 = 5;
+
+/// Invalidate the locations cache. Called by the volume watcher on mount/unmount.
+pub fn invalidate_locations_cache() {
+    *LOCATIONS_CACHE.lock().unwrap() = None;
+}
+
 /// Get all locations organized by category, deduplicated.
 pub fn list_locations() -> Vec<LocationInfo> {
+    if let Some((ts, cached)) = LOCATIONS_CACHE.lock().unwrap().as_ref()
+        && ts.elapsed().as_secs() < LOCATIONS_CACHE_TTL_SECS {
+            return cached.clone();
+        }
+    let result = list_locations_uncached();
+    *LOCATIONS_CACHE.lock().unwrap() = Some((Instant::now(), result.clone()));
+    result
+}
+
+fn list_locations_uncached() -> Vec<LocationInfo> {
     let mut locations = Vec::new();
     let mut seen_paths: HashSet<String> = HashSet::new();
 

apps/desktop/src-tauri/src/volumes/watcher.rs

@@ -114,14 +114,19 @@ fn check_for_volume_changes() {
         Err(_) => return,
     };
 
-    // Find newly mounted volumes
-    for path in current_volumes.difference(&known_guard) {
+    let mounted: Vec<_> = current_volumes.difference(&known_guard).cloned().collect();
+    let unmounted: Vec<_> = known_guard.difference(&current_volumes).cloned().collect();
+
+    if !mounted.is_empty() || !unmounted.is_empty() {
+        super::invalidate_locations_cache();
+    }
+
+    for path in &mounted {
         debug!("Volume mounted: {}", path);
         emit_volume_mounted(path);
     }
 
-    // Find unmounted volumes
-    for path in known_guard.difference(&current_volumes) {
+    for path in &unmounted {
         debug!("Volume unmounted: {}", path);
         emit_volume_unmounted(path);
     }