Fallback to ~ instead of / everywhere

- Unified two duplicate path-resolution functions (`resolvePathWithFallback` in `app-status-store.ts` and `resolveValidPath` in `path-navigation.ts`) into one
- The startup version had an inconsistent fallback order (parents → `/` → `~`), now matches the runtime version (parents → `~` → `/`)
- `resolveValidPath` now accepts optional `{ pathExistsFn, timeoutMs }` for startup use (no timeout, injected checker)
- Added 5 new tests covering the new options
- Updated `navigation/CLAUDE.md`

Author: vdavid

apps/desktop/src/lib/app-status-store.ts

@@ -5,10 +5,10 @@ import type { Store } from '@tauri-apps/plugin-store'
 import type { SortColumn } from './file-explorer/types'
 import { defaultSortOrders } from './file-explorer/types'
 import type { PersistedTab, PersistedPaneTabs } from './file-explorer/tabs/tab-types'
+import { resolveValidPath } from './file-explorer/navigation/path-navigation'
 
 const STORE_NAME = 'app-status.json'
 const DEFAULT_PATH = '~'
-const ROOT_PATH = '/'
 const DEFAULT_VOLUME_ID = 'root'
 const DEFAULT_SORT_BY: SortColumn = 'name'
 
@@ -53,31 +53,12 @@ async function getStore(): Promise<Store> {
 }
 
 /**
- * Resolves a path with fallback logic.
- * If the path doesn't exist, tries parent directories up to root.
- * Falls back to home (~) if nothing exists.
+ * Resolves a persisted path, falling back to ~ if nothing exists.
+ * Uses resolveValidPath with no timeout (startup paths are local, no hung-mount risk at load time)
+ * and the caller's pathExistsFn (which may be mocked in tests).
  */
-async function resolvePathWithFallback(path: string, pathExists: (p: string) => Promise<boolean>): Promise<string> {
-    // Start with the saved path
-    let currentPath = path
-
-    // Try the path and its parents
-    while (currentPath && currentPath !== ROOT_PATH) {
-        if (await pathExists(currentPath)) {
-            return currentPath
-        }
-        // Try parent directory
-        const parentPath = currentPath.substring(0, currentPath.lastIndexOf('/')) || ROOT_PATH
-        currentPath = parentPath === currentPath ? ROOT_PATH : parentPath
-    }
-
-    // Check if root exists
-    if (await pathExists(ROOT_PATH)) {
-        return ROOT_PATH
-    }
-
-    // Ultimate fallback to home
-    return DEFAULT_PATH
+async function resolvePersistedPath(path: string, pathExistsFn: (p: string) => Promise<boolean>): Promise<string> {
+    return (await resolveValidPath(path, { pathExistsFn, timeoutMs: 0 })) ?? DEFAULT_PATH
 }
 
 function parseViewMode(raw: unknown): ViewMode {
@@ -116,9 +97,9 @@ export async function loadAppStatus(pathExists: (p: string) => Promise<boolean>)
 
         // Resolve paths with fallback - skip for virtual 'network' volume
         const resolvedLeftPath =
-            leftVolumeId === 'network' ? leftPath : await resolvePathWithFallback(leftPath, pathExists)
+            leftVolumeId === 'network' ? leftPath : await resolvePersistedPath(leftPath, pathExists)
         const resolvedRightPath =
-            rightVolumeId === 'network' ? rightPath : await resolvePathWithFallback(rightPath, pathExists)
+            rightVolumeId === 'network' ? rightPath : await resolvePersistedPath(rightPath, pathExists)
 
         return {
             leftPath: resolvedLeftPath,
@@ -351,7 +332,7 @@ export async function loadPaneTabs(
             const validatedTabs = await Promise.all(
                 raw.tabs.map(async (tab) => {
                     if (tab.volumeId === 'network') return tab
-                    const resolvedPath = await resolvePathWithFallback(tab.path, pathExistsFn)
+                    const resolvedPath = await resolvePersistedPath(tab.path, pathExistsFn)
                     return { ...tab, path: resolvedPath }
                 }),
             )
@@ -364,7 +345,7 @@ export async function loadPaneTabs(
         const volumeId = ((await store.get(`${side}VolumeId`)) as string) || DEFAULT_VOLUME_ID
         const sortBy = parseSortColumn(await store.get(`${side}SortBy`))
         const viewMode = parseViewMode(await store.get(`${side}ViewMode`))
-        const resolvedPath = volumeId === 'network' ? path : await resolvePathWithFallback(path, pathExistsFn)
+        const resolvedPath = volumeId === 'network' ? path : await resolvePersistedPath(path, pathExistsFn)
 
         const tab: PersistedTab = {
             id: crypto.randomUUID(),

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

@@ -44,8 +44,10 @@ Runs checks **in parallel** with 500ms frontend timeouts per check. Priority:
 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. Each step has a **1-second
-frontend timeout**. Fallback chain: parent dirs → `~` → `/` → `null` (volume unmounted).
+`resolveValidPath(targetPath, options?)` — walks parent tree until an existing directory is found. Accepts optional
+`{ pathExistsFn, timeoutMs }` — defaults to Tauri `pathExists` with 1s timeout per step. Used both at runtime (with
+timeouts) and at startup via `app-status-store.ts`'s `resolvePersistedPath` wrapper (no timeout, injected
+`pathExistsFn`). Fallback chain: parent dirs → `~` → `/` → `null` (volume unmounted).
 
 `withTimeout(promise, ms, fallback)` — imported from `$lib/utils/timing` and re-exported. Races a promise against a
 timeout, returning the fallback on expiry. Used by both functions above, and also by `VolumeBreadcrumb.svelte` (wraps

apps/desktop/src/lib/file-explorer/navigation/path-navigation.test.ts

@@ -272,4 +272,66 @@ describe('resolveValidPath', () => {
         expect(result).toBe('/Users/test')
         expect(callCount).toBe(2)
     })
+
+    it('uses custom pathExistsFn when provided', async () => {
+        const customPathExists = vi.fn((p: string) => Promise.resolve(p === '/custom/path'))
+
+        const result = await resolveValidPath('/custom/path/child', { pathExistsFn: customPathExists })
+
+        expect(result).toBe('/custom/path')
+        expect(customPathExists).toHaveBeenCalledWith('/custom/path/child')
+        expect(customPathExists).toHaveBeenCalledWith('/custom/path')
+        // The global mock should NOT have been called
+        expect(mockPathExists).not.toHaveBeenCalled()
+    })
+
+    it('uses custom timeoutMs when provided', async () => {
+        // First call hangs, second call resolves
+        let callCount = 0
+        mockPathExists.mockImplementation((): Promise<boolean> => {
+            callCount++
+            if (callCount === 1) return new Promise<boolean>(() => {}) // hangs
+            return Promise.resolve(true)
+        })
+
+        const resultPromise = resolveValidPath('/Users/test/slow', { timeoutMs: 2000 })
+        // At 1000ms the default timeout would have fired, but our custom 2000ms shouldn't yet
+        await vi.advanceTimersByTimeAsync(1000)
+        expect(callCount).toBe(1) // still waiting on first call
+        // At 2000ms it should time out and try parent
+        await vi.advanceTimersByTimeAsync(1000)
+        await vi.advanceTimersByTimeAsync(100) // let microtasks settle
+        const result = await resultPromise
+
+        expect(result).toBe('/Users/test')
+        expect(callCount).toBe(2)
+    })
+
+    it('skips timeout when timeoutMs is 0 (no timeout wrapping)', async () => {
+        const customPathExists = vi.fn((p: string) => Promise.resolve(p === '/exists'))
+
+        const result = await resolveValidPath('/exists/child', { pathExistsFn: customPathExists, timeoutMs: 0 })
+
+        expect(result).toBe('/exists')
+        expect(customPathExists).toHaveBeenCalledWith('/exists/child')
+        expect(customPathExists).toHaveBeenCalledWith('/exists')
+    })
+
+    it('with custom pathExistsFn still falls back to ~ then / then null', async () => {
+        const customPathExists = vi.fn(() => Promise.resolve(false))
+
+        const result = await resolveValidPath('/gone/path', { pathExistsFn: customPathExists, timeoutMs: 0 })
+
+        expect(result).toBeNull()
+        expect(customPathExists).toHaveBeenCalledWith('~')
+        expect(customPathExists).toHaveBeenCalledWith('/')
+    })
+
+    it('with custom pathExistsFn falls back to ~ when parents are gone', async () => {
+        const customPathExists = vi.fn((p: string) => Promise.resolve(p === '~'))
+
+        const result = await resolveValidPath('/gone/deep/path', { pathExistsFn: customPathExists, timeoutMs: 0 })
+
+        expect(result).toBe('~')
+    })
 })

apps/desktop/src/lib/file-explorer/navigation/path-navigation.ts

@@ -57,30 +57,41 @@ export async function determineNavigationPath(
     return volumeId === DEFAULT_VOLUME_ID ? '~' : volumePath
 }
 
+export interface ResolveValidPathOptions {
+    /** Custom path-existence checker. Defaults to the Tauri `pathExists` command. */
+    pathExistsFn?: (path: string) => Promise<boolean>
+    /** Timeout per step in ms. Set to 0 to skip timeout wrapping. Defaults to 1000. */
+    timeoutMs?: number
+}
+
 /**
  * Resolves a path to a valid existing path by walking up the parent tree.
- * Each step has a 1-second timeout to prevent hanging on dead mounts.
+ * Each step has a timeout to prevent hanging on dead mounts (default 1s).
  * Fallback chain: parent tree → user home (~) → filesystem root (/).
  * Returns null if even the root doesn't exist (volume unmounted).
  */
-export async function resolveValidPath(targetPath: string): Promise<string | null> {
-    const stepTimeoutMs = 1000
+export async function resolveValidPath(targetPath: string, options?: ResolveValidPathOptions): Promise<string | null> {
+    const checkFn = options?.pathExistsFn ?? pathExists
+    const timeoutMs = options?.timeoutMs ?? 1000
+
+    const check = (p: string): Promise<boolean> =>
+        timeoutMs > 0 ? withTimeout(checkFn(p), timeoutMs, false) : checkFn(p)
 
     let path = targetPath
     while (path !== '/' && path !== '') {
-        if (await withTimeout(pathExists(path), stepTimeoutMs, false)) {
+        if (await check(path)) {
             return path
         }
         // Go to parent
         const lastSlash = path.lastIndexOf('/')
         path = lastSlash > 0 ? path.substring(0, lastSlash) : '/'
     }
     // Try user home before falling back to root (~ is expanded by the backend)
-    if (await withTimeout(pathExists('~'), stepTimeoutMs, false)) {
+    if (await check('~')) {
         return '~'
     }
     // Check root
-    if (await withTimeout(pathExists('/'), stepTimeoutMs, false)) {
+    if (await check('/')) {
         return '/'
     }
     return null