Fix cancel-loading to return to previous folder

- Instead of always navigating to ~ when cancelling a large directory load, return to the folder the user was in before
- Compares cancelled path with history to handle two cases: listing completed (go back in history) vs listing still loading (reload current history entry via navigateToPath)
- Falls back to resolveValidPath on the parent when a tab was opened directly at the cancelled path (no history)

Author: vdavid

apps/desktop/src/lib/file-explorer/pane/DualPaneExplorer.svelte

@@ -38,7 +38,7 @@
     } from '../types'
     import { defaultSortOrders } from '../types'
     import { ensureFontMetricsLoaded } from '$lib/font-metrics'
-    import { determineNavigationPath } from '../navigation/path-navigation'
+    import { determineNavigationPath, resolveValidPath } from '../navigation/path-navigation'
     import {
         createHistory,
         push,
@@ -551,8 +551,9 @@
         containerElement?.focus()
     }
 
-    function handleCancelLoading(pane: 'left' | 'right') {
-        const entry = getCurrentEntry(getPaneHistory(pane))
+    function handleCancelLoading(pane: 'left' | 'right', cancelledPath: string, selectName?: string) {
+        const history = getPaneHistory(pane)
+        const entry = getCurrentEntry(history)
         const paneRef = getPaneRef(pane)
 
         if (entry.volumeId === 'network') {
@@ -561,13 +562,36 @@
             saveAppStatus({ [paneKey(pane, 'volumeId')]: 'network', [paneKey(pane, 'path')]: entry.path })
             // eslint-disable-next-line @typescript-eslint/no-unsafe-call
             paneRef?.setNetworkHost?.(entry.networkHost ?? null)
-        } else {
-            // Immediately navigate to a known-safe local path — the user pressed ESC, they want out
-            setPanePath(pane, '~')
-            setPaneVolumeId(pane, DEFAULT_VOLUME_ID)
-            saveAppStatus({ [paneKey(pane, 'path')]: '~', [paneKey(pane, 'volumeId')]: DEFAULT_VOLUME_ID })
+            saveTabsForPaneSide(pane)
+            containerElement?.focus()
+            return
         }
-        saveTabsForPaneSide(pane)
+
+        if (entry.path === cancelledPath) {
+            // Listing completed before cancel — history has the cancelled path pushed. Go back.
+            if (canGoBack(history)) {
+                const newHistory = back(history)
+                const target = getCurrentEntry(newHistory)
+                updatePaneAfterHistoryNavigation(pane, newHistory, target.path)
+                return
+            }
+
+            // Edge case: tab opened directly at this path, no history. Walk up to nearest valid parent.
+            const parentPath = entry.path.substring(0, Math.max(1, entry.path.lastIndexOf('/')))
+            void resolveValidPath(parentPath).then((validPath) => {
+                const target = validPath ?? '~'
+                setPanePath(pane, target)
+                saveAppStatus({ [paneKey(pane, 'path')]: target })
+                saveTabsForPaneSide(pane)
+                containerElement?.focus()
+            })
+            return
+        }
+
+        // Listing didn't complete — history still points at the previous folder (correct destination).
+        // setPanePath won't trigger FilePane's $effect (path unchanged), so call navigateToPath directly.
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        paneRef?.navigateToPath?.(entry.path, selectName)
         containerElement?.focus()
     }
 
@@ -1977,8 +2001,8 @@
                 onNetworkHostChange={(host: NetworkHost | null) => {
                     handleNetworkHostChange(paneId, host)
                 }}
-                onCancelLoading={() => {
-                    handleCancelLoading(paneId)
+                onCancelLoading={(cancelledPath: string, selectName?: string) => {
+                    handleCancelLoading(paneId, cancelledPath, selectName)
                 }}
                 onMtpFatalError={(msg: string) => handleMtpFatalError(paneId, msg)}
             />

apps/desktop/src/lib/file-explorer/pane/FilePane.svelte

@@ -98,8 +98,8 @@
         onRequestFocus?: () => void
         /** Called when active network host changes (for history tracking) */
         onNetworkHostChange?: (host: NetworkHost | null) => void
-        /** Called when user cancels loading (ESC key) - parent should reload previous folder, optionally selecting the folder we tried to enter */
-        onCancelLoading?: (selectName?: string) => void
+        /** Called when user cancels loading (ESC key) - parent navigates back to previous folder */
+        onCancelLoading?: (cancelledPath: string, selectName?: string) => void
         /** Called when MTP connection fails fatally (device disconnected, timeout) - parent should fall back to previous volume */
         onMtpFatalError?: (error: string) => void
     }
@@ -852,8 +852,8 @@
         // Extract the folder name we were trying to enter, so parent can select it when reloading
         const folderName = currentPath.split('/').pop()
 
-        // Reload previous folder via callback (parent will set the path, triggering our effect)
-        onCancelLoading?.(folderName)
+        // Tell parent to navigate back — passes the path we were loading so parent can decide where to go
+        onCancelLoading?.(currentPath, folderName)
     }
 
     // Navigate to a specific path with optional item selection (used when cancelling navigation)