Improve perf: Non-blocking navi on slow/dead SMBs

- Rust: 2s timeout on path_exists via blocking_with_timeout helper
- Frontend: optimistic volume switch (immediate UI, background resolve)
- determineNavigationPath: parallel checks with 500ms timeouts
- resolveValidPath: 1s timeout per parent-walk step
- ESC cancel navigates to ~ instantly (no resolveValidPath)
- Back/forward navigates immediately, error handler resolves
- 3 Rust + 16 TypeScript unit tests

Author: vdavid

apps/desktop/src-tauri/src/commands/CLAUDE.md

@@ -26,6 +26,7 @@ immediately to business-logic modules. No significant logic lives here.
 
 - **No business logic here.** If you find yourself adding branching or data transformation, move it to the relevant subsystem module.
 - **`spawn_blocking` for filesystem I/O.** All blocking operations in async commands are wrapped in `tokio::task::spawn_blocking`.
+- **`blocking_with_timeout` for potentially slow I/O.** `path_exists` uses `blocking_with_timeout(2s, false, ...)` to prevent hung network mounts from blocking the async runtime. The helper wraps `spawn_blocking` + `tokio::time::timeout` and returns a fallback value on timeout or `JoinError`.
 - **`expand_tilde`** is applied conditionally: for `list_directory` it's gated on `volume_id == "root"`, but for write operations (copy, move, delete, scan preview) it's always applied. MTP and network volume paths must never be tilde-expanded.
 - **AI commands** are registered directly from `ai::manager` and `ai::suggestions` — there is no `commands/ai.rs` file.
 - **Platform gates.** `mtp`, `network`, and `volumes` modules are macOS-only at the `mod.rs` level. Individual functions also use `#[cfg]` where behaviour differs (e.g., `sync_status`).

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

@@ -25,6 +25,22 @@ use std::path::{Path, PathBuf};
 use std::sync::mpsc::channel;
 #[cfg(target_os = "macos")]
 use tauri::Manager;
+use tokio::time::Duration;
+
+const PATH_EXISTS_TIMEOUT: Duration = Duration::from_secs(2);
+
+/// Runs a blocking closure on the blocking thread pool with a timeout.
+/// Returns the fallback value if the closure doesn't complete in time.
+async fn blocking_with_timeout<T: Send + 'static>(
+    timeout_duration: Duration,
+    fallback: T,
+    f: impl FnOnce() -> T + Send + 'static,
+) -> T {
+    match tokio::time::timeout(timeout_duration, tokio::task::spawn_blocking(f)).await {
+        Ok(Ok(result)) => result,
+        _ => fallback, // Timeout or JoinError
+    }
+}
 
 #[tauri::command]
 pub async fn path_exists(volume_id: Option<String>, path: String) -> bool {
@@ -36,15 +52,15 @@ pub async fn path_exists(volume_id: Option<String>, path: String) -> bool {
     // Try to use Volume abstraction
     if let Some(volume) = get_volume_manager().get(&volume_id) {
         let path_for_check = expanded_path.clone();
-        // Use spawn_blocking for MTP volumes which need tokio runtime context
-        return tokio::task::spawn_blocking(move || volume.exists(Path::new(&path_for_check)))
-            .await
-            .unwrap_or(false);
+        return blocking_with_timeout(PATH_EXISTS_TIMEOUT, false, move || {
+            volume.exists(Path::new(&path_for_check))
+        })
+        .await;
     }
 
     // Fallback for unknown volumes (shouldn't happen in practice)
     let path_buf = PathBuf::from(expanded_path);
-    path_buf.exists()
+    blocking_with_timeout(PATH_EXISTS_TIMEOUT, false, move || path_buf.exists()).await
 }
 
 #[tauri::command]
@@ -662,4 +678,30 @@ mod tests {
         let result = create_directory(None, "/nonexistent_path_12345".to_string(), "test".to_string()).await;
         assert!(result.is_err());
     }
+
+    #[tokio::test]
+    async fn test_blocking_with_timeout_fast_closure_returns_value() {
+        let result = blocking_with_timeout(Duration::from_secs(2), false, || true).await;
+        assert!(result);
+    }
+
+    #[tokio::test]
+    async fn test_blocking_with_timeout_slow_closure_returns_fallback() {
+        let result = blocking_with_timeout(Duration::from_millis(50), false, || {
+            std::thread::sleep(Duration::from_secs(2));
+            true
+        })
+        .await;
+        assert!(!result);
+    }
+
+    #[tokio::test]
+    async fn test_blocking_with_timeout_returns_custom_fallback() {
+        let result = blocking_with_timeout(Duration::from_millis(50), 42, || {
+            std::thread::sleep(Duration::from_secs(2));
+            99
+        })
+        .await;
+        assert_eq!(result, 42);
+    }
 }

apps/desktop/src/lib/file-explorer/navigation/CLAUDE.md

@@ -11,6 +11,7 @@ Browser-style back/forward history, path resolution, paged keyboard shortcuts, a
 | `keyboard-shortcuts.ts`      | Home/End/PageUp/PageDown handling for file lists |
 | `VolumeBreadcrumb.svelte`    | Clickable volume label + grouped dropdown        |
 | `navigation-history.test.ts` | Full unit test coverage of history functions     |
+| `path-navigation.test.ts`    | Unit tests for path resolution and timeouts      |
 | `keyboard-shortcuts.test.ts` | Unit tests for shortcut calculations             |
 
 ## `navigation-history.ts`
@@ -34,15 +35,34 @@ Entries carry full `volumeId` — navigating back can cross volume boundaries (e
 ## `path-navigation.ts`
 
 `determineNavigationPath(volumeId, volumePath, targetPath, otherPane)` — picks best initial path when switching volumes.
-Priority:
+Runs checks **in parallel** with 500ms frontend timeouts per check. Priority:
 
 1. Favorite path (when `targetPath !== volumePath`)
 2. Other pane's path (if same volume and path exists)
 3. Stored `lastUsedPath` for this volume
 4. Default: `~` for `DEFAULT_VOLUME_ID`, else volume root
 
-`resolveValidPath(targetPath)` — walks parent tree until an existing directory is found. Fallback chain: parent dirs →
-`~` → `/` → `null` (volume unmounted).
+`resolveValidPath(targetPath)` — walks parent tree until an existing directory is found. Each step has a **1-second
+frontend timeout**. Fallback chain: parent dirs → `~` → `/` → `null` (volume unmounted).
+
+`withTimeout(promise, ms, fallback)` — races a promise against a timeout, returning the fallback on expiry. Used by both
+functions above.
+
+### Non-blocking navigation pattern
+
+All `pathExists` calls are guarded by two timeout layers:
+
+- **Rust-side**: `blocking_with_timeout` wraps filesystem syscalls in `tokio::time::timeout` (2 seconds). Prevents
+  kernel syscalls on hung network mounts from blocking the Tauri async runtime.
+- **Frontend-side**: `withTimeout` races each `pathExists` IPC call (500ms for `determineNavigationPath`, 1s for
+  `resolveValidPath`). The faster timeout wins.
+
+`handleVolumeChange` in `DualPaneExplorer.svelte` uses **optimistic navigation**: it updates pane state immediately
+(showing the loading spinner), then resolves the "best" path in the background. A `volumeChangeGeneration` counter
+guards against stale corrections when the user navigates away before resolution completes.
+
+`handleCancelLoading` navigates to `~` immediately on ESC (no `resolveValidPath` call). `handleNavigationAction`
+(back/forward) navigates immediately; FilePane's listing error handler resolves upward if the path is gone.
 
 ## `keyboard-shortcuts.ts`