buninu-browser 0.3.0 → 0.5.0

package/test/fixtures/qml/flea-theme/ui/js/Mounts.js

@@ -0,0 +1,320 @@
+.pragma library
+
+.import "Format.js" as Format
+.import "Protocols.js" as Protocols
+.import "Menu.js" as Menu
+
+// Whole sentences with "%1" for a value, filled by fill so each translates as one; replace would read "$$" in a label as a pattern.
+var WORDS = {
+    nothingToRelease: "%1 has nothing to eject or unmount",
+    stillEjecting: "Still ejecting %1; wait for its result",
+    stillUnmounting: "Still unmounting %1; wait for its result",
+    anotherMounting: "Another drive is still mounting. Try again when it finishes",
+    stillUnmountingTryAgain: "%1 is still unmounting. Try again when it finishes",
+    ejecting: "Ejecting %1. Do not unplug it yet.",
+    noFolder: "%1 was mounted, but Flea could not find its folder.",
+    ejectUnfinished: "%1 did not finish ejecting and is still mounted.",
+    mountFailed: "%1 could not be mounted.",
+    damaged: "%1 could not be mounted: its file system is damaged or not supported.",
+    unmountFailed: "%1 could not be unmounted.",
+    ejectFailed: "%1 could not be ejected.",
+    busy: "%1 is busy; close what is using it and try again.",
+    mountRefused: "%1 was not mounted: you do not have permission.",
+    unmountRefused: "%1 was not unmounted: you do not have permission.",
+    ejectRefused: "%1 was not ejected: you do not have permission.",
+    noDisc: "%1 has no disc or card in it.",
+    notMountable: "%1 cannot be mounted on this computer.",
+    anotherOpening: "Another network location is still opening. Try again when it opens",
+    notSaved: "%1 is not saved, and stays in the sidebar until it is unmounted",
+    forgottenStays: "%1 is forgotten, and stays in the sidebar until it is unmounted",
+    forgotten: "%1 is forgotten",
+    unmountedLine: "Unmounted %1",
+    bridgeMissing: "Could not open %1 because part of Flea did not load. Reinstall Flea.",
+    transferUsing: "%1 could not be unmounted. A transfer may still be using it."
+}
+
+// Sample input, captured live on the box with one network share mounted (2026-08-31):
+// Drive(0): KBG40ZNS256G NVMe KIOXIA 256GB
+//   Type: GProxyDrive (GProxyVolumeMonitorUDisks2)
+// Mount(0): isos on 192.168.1.10 -> smb://192.168.1.10/isos/
+//   Type: GDaemonMount
+// Only Mount() lines matter here; Drive() and every indented "Type:" line are noise for the rail.
+function parseMounts(output) {
+    var out = []
+    var mounts = mountLines(output)
+    for (var i = 0; i < mounts.length; i++) {
+        var uri = mounts[i].uri
+        // corner: a local device mount (file://) is Favorites territory, not Network; Places.js skips the inverse.
+        if (uri.indexOf("file://") === 0)
+            continue
+        // A phone is DEVICES territory the same way: its row is ui/js/Phones.js's, built from the
+        // volume block, and this line is gio's shadow GDaemonMount printed beside it. afc is the
+        // iPhone's own, whose root mount prints here rather than inside its volume block.
+        if (/^(mtp|gphoto2|afc):\/\//i.test(uri))
+            continue
+        out.push({ label: Protocols.shareName(mounts[i].name, uri), uri: uri })
+    }
+    return out
+}
+
+// Sample input: "Mount(2): isos on 192.168.1.10 -> smb://192.168.1.10/isos/" answers { name: "isos on 192.168.1.10", uri: "smb://192.168.1.10/isos/" }.
+// Every top-level "Mount(N): name -> uri" line of gio mount -l; the one owner of that line's grammar.
+function mountLines(output) {
+    var out = []
+    var lines = String(output || "").split("\n")
+    for (var i = 0; i < lines.length; i++) {
+        var m = lines[i].match(/^Mount\(\d+\):\s*(.+?)\s*->\s*(\S+)\s*$/)
+        if (m)
+            out.push({ name: m[1], uri: m[2] })
+    }
+    return out
+}
+
+// Sample input: "Mount(0): photos -> file:///mnt/kmount-photos" answers { path: "/mnt/kmount-photos", label: "photos", uri: "file:///mnt/kmount-photos" }.
+// Issue #257: what gio adds to a kernel row, matched by path; a non-file line adds nothing, an unlisted mount keeps its leaf label.
+function gioKernelMounts(gioText) {
+    var out = []
+    var mounts = mountLines(gioText)
+    for (var i = 0; i < mounts.length; i++) {
+        var m = mounts[i]
+        if (m.uri.indexOf("file://") !== 0)
+            continue
+        var path = decodePath(m.uri.substring("file://".length)).replace(/\/+$/, "")
+        out.push({ path: path.length > 0 ? path : "/", label: Protocols.shareName(m.name, m.uri), uri: m.uri })
+    }
+    return out
+}
+
+// Sample input, "gio info" under the C locale ui/NetworkMounts.qml pins on every gio call:
+// uri: smb://192.168.1.10/isos/
+// local path: /run/user/1000/gvfs/smb-share:server=192.168.1.10,share=isos
+// Only a location GVFS exposes through its FUSE mount prints that line, so "" means there is no
+// browsable folder. One resolver, so the product and tests/js/network.js read the same wording.
+function localPath(body) {
+    var lines = String(body || "").split("\n")
+    for (var i = 0; i < lines.length; i++) {
+        if (lines[i].indexOf("local path: ") === 0)
+            return lines[i].substring("local path: ".length).trim()
+    }
+    return ""
+}
+
+// Issue 133 (mfilm77): no GVFS backend implements trash, so gio trash refuses every path under its FUSE folder.
+// Sample input: /run/user/1000/gvfs/smb-share:server=192.168.21.25,share=data/photos, where "smb-share:" names the mount.
+// A read-only folder has no trash either: the listed line's own writability rides along, so iso9660
+// and a root-owned stick root offer Delete permanently instead of a Trash row that only fails.
+function trashable(path, writable) {
+    if (writable === false)
+        return false
+    return !underGvfs(path)
+}
+
+// A path inside the GVFS FUSE root /run/user/<uid>/gvfs, where the "scheme:" segment names the mount; a folder named gvfs elsewhere is plain.
+function underGvfs(path) {
+    return /^\/run\/user\/[^/]+\/gvfs\/[A-Za-z0-9-]+:/.test(String(path || ""))
+}
+
+// Sample input: the operator's real bookmarks file, ui/js/Places.js "bookmarks" reads the same lines.
+// file:///home/gm/Downloads Downloads
+// smb://192.168.1.10/ NAS
+// Places.bookmarks() keeps the file:// line and drops the smb:// one; this is the exact mirror.
+function nonFileBookmarks(body) {
+    var out = []
+    var lines = String(body || "").split("\n")
+    for (var i = 0; i < lines.length; i++) {
+        var line = lines[i].trim()
+        if (line.length === 0 || line.indexOf("file://") === 0)
+            continue
+        var space = line.indexOf(" ")
+        var uri = space < 0 ? line : line.substring(0, space)
+        // corner: a line with no scheme at all is not a bookmark, not just not a file:// one.
+        if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(uri))
+            continue
+        var label = space < 0 ? "" : line.substring(space + 1).trim()
+        out.push({ uri: uri, label: label.length > 0 ? label : leaf(uri) })
+    }
+    return out
+}
+
+// The bare-root form (smb://host/) has no path leaf, so this falls back to the host itself.
+function leaf(uri) {
+    var stripped = String(uri).replace(/^[a-z][a-z0-9+.-]*:\/\//i, "").replace(/\/+$/, "")
+    var slash = stripped.lastIndexOf("/")
+    var tail = slash < 0 ? stripped : stripped.substring(slash + 1)
+    return tail.length > 0 ? tail : stripped
+}
+
+// decodeURIComponent throws on a malformed escape, and a bookmarks line is arbitrary text, so a
+// failure answers the raw path rather than taking the whole rail rebuild with it.
+function decodePath(raw) {
+    try {
+        return decodeURIComponent(String(raw))
+    } catch (e) {
+        return String(raw)
+    }
+}
+
+// One canonical form: every trailing slash stripped except a bare host root, which keeps one, and
+// a port the scheme would have used anyway dropped, because gio's own listing never reports one.
+function normalize(uri) {
+    var stripped = Protocols.stripDefaultPort(String(uri || "").replace(/\/+$/, ""))
+    var bareRoot = /^[a-z][a-z0-9+.-]*:\/\/[^\/]+$/i.test(stripped)
+    return bareRoot ? stripped + "/" : stripped
+}
+
+// NETWORK shows on its discoveries, DEVICES on those plus its own; the deadline shows whatever each has.
+function railGroupsReady(networkDone, devicesDone, elapsedMs, deadlineMs) {
+    if (elapsedMs >= deadlineMs)
+        return { showNetwork: true, showDevices: true }
+    var showNetwork = networkDone === true
+    return { showNetwork: showNetwork, showDevices: showNetwork && devicesDone === true }
+}
+
+// A password may be given to any scheme here whose authority names a user.
+function credentialed(uri) {
+    return /^(smb|sftp|ftp|ftps|dav|davs):\/\/[^\/]*@/i.test(String(uri || ""))
+}
+
+// Try sftp keys before asking for a password.
+function keyless(uri) {
+    return /^sftp:\/\//i.test(String(uri || ""))
+}
+
+// PR #21: a live mount wins the rail row, and the operator's own bookmark label wins its name, or a
+// rename typed on a mounted share is written to the file and never drawn. Matched the way rebuild dedups.
+function railLabel(mount, marks) {
+    for (var i = 0; i < marks.length; i++) {
+        if (normalize(marks[i].uri) === normalize(mount.uri)) return marks[i].label
+    }
+    return mount.label
+}
+
+// Sample input: two arrays of rail entries as ui/NetworkMounts.qml and ui/DeviceMounts.qml build
+// them, [{path:"", label:"NAS", group:"network", kind:"share", uri:"smb://example.com/data",
+// mounted:false, glyph:"server"}]. A poll that found no change must not assign a fresh array: the
+// Repeater rebinds every rail row on the assignment, and a rebound row is a row whose editor lost
+// what was typed into it. Both builders are covered, so every field either one writes is compared.
+function sameEntries(a, b) {
+    if (!a || !b || a.length !== b.length)
+        return false
+    for (var i = 0; i < a.length; i++) {
+        if (!sameEntry(a[i], b[i]))
+            return false
+    }
+    return true
+}
+
+// The two shapes differ only in uri against device, and an absent field is undefined on both sides.
+function sameEntry(x, y) {
+    return x.path === y.path && x.label === y.label && x.group === y.group && x.kind === y.kind
+        && x.uri === y.uri && x.device === y.device && x.mounted === y.mounted && x.glyph === y.glyph
+        && x.size === y.size && x.editable === y.editable && x.removable === y.removable
+        && x.fstype === y.fstype && x.fsver === y.fsver && x.mediaRemovable === y.mediaRemovable && x.readOnly === y.readOnly
+        && (x.locked || false) === (y.locked || false) && x.loop === y.loop
+}
+
+// Sample input: one rail entry as ui/DeviceMounts.qml and ui/NetworkMounts.qml build them,
+// {label:"128GB", group:"device", kind:"volume", device:"/dev/sda1", mounted:true, removable:true}.
+// Rows come from ui/js/Menu.js kind R; gio's -f is offered nowhere, since forcing an unmount over an open write loses data.
+function railMenu(entry) {
+    if (!entry)
+        return []
+    return Menu.railEntries(entry)
+}
+
+// A root-only remote mount covers its saved addressable paths; SMB shares remain path-specific.
+function addressMountCovers(liveUri, savedUri) {
+    var live = normalize(liveUri)
+    var saved = normalize(savedUri)
+    return /^(sftp|ftp|ftps|dav|davs):\/\/[^\/]+\/$/i.test(live)
+        && saved.length > live.length && saved.indexOf(live) === 0
+}
+
+// The rail's right click opens railMenu's rows; ui/js/Eject.js reads railMenu too, so Ctrl+E refuses an unmounted row.
+function rowMenu(entry) {
+    return railMenu(entry)
+}
+
+// The handle a chosen menu row carries back: a volume's device node, a share's uri, "" for a row
+// with no release. The rail rebuilds on a five second poll, so an index taken when the menu opened
+// can name a different row by the time a row inside it is chosen; a key cannot.
+function railKey(entry) {
+    if (!entry)
+        return ""
+    if (entry.group === "device" && entry.kind === "volume")
+        return String(entry.device || "")
+    if (entry.group === "device" && entry.kind === "phone")
+        return String(entry.uri || "")
+    if (entry.group === "network" && entry.kind === "share")
+        return String(entry.uri || "")
+    return ""
+}
+
+// Where that key resolves back to a position in the group's own list, or -1 when the row is gone.
+// An empty key matches nothing: a row that carries no key must never resolve to whatever is at 0.
+function rowByKey(entries, key) {
+    if (String(key || "").length === 0)
+        return -1
+    var list = entries || []
+    for (var i = 0; i < list.length; i++) {
+        if (railKey(list[i]) === key)
+            return i
+    }
+    return -1
+}
+
+// The device or network row with a release whose path holds the directory, or null; a favourite never names a volume.
+function holding(entries, dir) {
+    var list = entries || []
+    var path = String(dir || "")
+    for (var i = 0; i < list.length; i++) {
+        var e = list[i]
+        if (!e.path || (e.group !== "device" && e.group !== "network") || railMenu(e).length === 0)
+            continue
+        if (inside(path, e.path))
+            return e
+    }
+    return null
+}
+
+// Whether dir is root itself or lies under it; ui/js/Places.js heldBy asks the rail the same question.
+function inside(dir, root) {
+    return dir === root || dir.indexOf(root + "/") === 0
+}
+
+// The keyboard's route into the rail menu, and where a rail row without one is answered: the sheet
+// advertises m, so a key that silently did nothing on a favourite would read as a broken one.
+function raiseMenu(pane, sidebar) {
+    var entry = sidebar.entries[sidebar.cursorIndex]
+    if (!entry)
+        return
+    if (rowMenu(entry).length > 0)
+        sidebar.openCursorMenu()
+    else
+        pane.message(Format.fill(WORDS.nothingToRelease, entry.label), false)
+}
+
+// Sample input: (true, "a", "a", "b", "b") answers "skip", while (true, "a", "x", "b", "b") answers "rebuild".
+function pollDecision(listedOnce, polledListing, lastListing, mountinfoText, lastMountinfo) {
+    if (!listedOnce) return "none"
+    if (polledListing === lastListing && mountinfoText === lastMountinfo) return "skip"
+    return "rebuild"
+}
+
+// Sample input: the operator's own bookmarks file, favourites and network places in one list.
+// smb://192.168.1.10/isos NAS isos
+// Read off the trimmed line the way nonFileBookmarks reads it, or an indented line is a rail row
+// nothing removes, and normalized the way Places.relabel matches; a kept line is pushed back raw.
+function removeBookmark(body, uri) {
+    var target = normalize(uri)
+    var lines = String(body || "").split("\n")
+    var out = []
+    for (var i = 0; i < lines.length; i++) {
+        var trimmed = lines[i].trim(), space = trimmed.indexOf(" ")
+        var one = space < 0 ? trimmed : trimmed.substring(0, space)
+        if (target.length > 0 && one.length > 0 && normalize(one) === target)
+            continue
+        out.push(lines[i])
+    }
+    return out.join("\n")
+}

package/test/fixtures/qml/flea-theme/ui/js/MouseNav.js

@@ -0,0 +1,13 @@
+.pragma library
+
+// The mouse's side buttons: Nav.js mouseBack takes refused, WindowBody.qml takes both after refusing its own overlays.
+
+// No navigation closes the pane's context menu or the collision card, so a press behind one would act on another directory's rows.
+function refused(pane) {
+    return pane.menuVisible || !!(pane.collide && pane.collide.opened)
+}
+
+// Forward takes pane.goForward, the key's own entry, so Trash and Recent refuse it as they refuse the key.
+function forward(pane) {
+    if (!refused(pane)) pane.goForward()
+}

package/test/fixtures/qml/flea-theme/ui/js/Nav.js

@@ -0,0 +1,328 @@
+.pragma library
+
+.import "DirSizes.js" as DirSizes
+.import "Filter.js" as Filter
+.import "Kinds.js" as Kinds
+.import "Thumbs.js" as Thumbs
+.import "Search.js" as Search
+.import "ColumnMenu.js" as ColumnMenu
+.import "BackReturn.js" as BackReturn
+.import "Anchor.js" as Anchor
+.import "MouseNav.js" as MouseNav
+.import "Swap.js" as Swap
+
+// Where the pane has been and how it gets back, taking ui/Pane.qml's root the way Search.js and
+// Ops.js do: the pane holds the state, this holds what the state does.
+
+// A listing inside its deadline refuses a row action; a waiting one is let go by the navigation itself, see ui/Pane.qml openWithoutHistory.
+function loading(pane) { return pane.listInFlight && pane.listingState !== "waiting" }
+
+// While a listing is out, the folder it asked for is the pane's current place for every navigation, and the drawn path only until its answer lands.
+function place(pane) { return pane.listInFlight && !!pane.listingPath ? pane.listingPath : pane.path }
+
+// A new destination discards the forward branch and pushes the drawn place unless the listing out already did; a re-read keeps both.
+function open(pane, newPath) {
+    if (place(pane).length > 0 && newPath !== place(pane)) {
+        if (!BackReturn.pending(pane))
+            pane.history = pane.history.concat([BackReturn.capture(pane)])
+        // A Back out pushed the drawn place onto the forward branch cleared below, so history takes it instead.
+        else if (BackReturn.pushedOnto(pane) === "forwardHistory")
+            pane.history = pane.history.concat([BackReturn.drawn(pane)])
+        pane.forwardHistory = []
+    }
+    pane.openWithoutHistory(newPath, { supersede: true })
+}
+
+function back(pane) {
+    if (pane.history.length === 0) {
+        return
+    }
+    BackReturn.travel(pane, "history", "forwardHistory")
+}
+
+function forward(pane) {
+    if (!pane.forwardHistory || pane.forwardHistory.length === 0) return
+    BackReturn.travel(pane, "forwardHistory", "history")
+}
+
+// The mouse back button follows history, or climbs when no history exists.
+function mouseBack(pane) {
+    if (MouseNav.refused(pane)) {
+        return
+    }
+    if (pane.history.length > 0) {
+        back(pane)
+        return
+    }
+    parent(pane)
+}
+
+// Every listing the pane asks for; of options, ui/Pane.qml reads keepHidden and ui/js/Swap.js begin() the rest.
+// A walk owns the rows until this lands, so leaving it is the shared step with the tabs:
+// tab switches, Back, Up, rail clicks and jumps all funnel through here.
+function openWithoutHistory(pane, newPath, options) {
+    Anchor.clearWaiting(pane)
+    var ask = options || {}
+    if (pane.listInFlight) {
+        // Only a navigation takes the place of a listing out; a re-list of the folder shown must not undo it.
+        if (ask.supersede !== true) {
+            pane.message("A directory is already loading.", false)
+            return
+        }
+        // The listing let go answers into nothing: its listed line names another folder and its rows follow it, see ui/js/Swap.js onListed.
+        pane.swap.stopWaiting()
+        BackReturn.dropOwed(pane)
+    }
+    // A hop elsewhere drops a waiting background menu, while the armed hop keeps its own request.
+    if (pane.pendingBackground && pane.pendingBackground.length > 0 && !ColumnMenu.samePath(newPath, pane.pendingBackground))
+        clearPendingBackground(pane)
+    Search.leaveWalk(pane)
+    pane.listInFlight = true
+    pane.listedSeen = false
+    // A hop into another view clears at once like a tab switch, so held rows never draw in a view they were not listed in.
+    var shown = pane.viewMode
+    if (pane.restoreView)
+        pane.restoreView(newPath)
+    // A manual reload's notice belongs to its own re-read: a navigation that lands first spends it.
+    pane.reloadFrom = -1
+    // The path is not written here. A refused listing never answers a listed line, so leaving the
+    // pane's own path alone is what keeps a refused hop from moving the breadcrumb onto a directory
+    // nobody could read; ui/PaneSwap.qml applyListed takes it from the answer instead. The directory
+    // asked for is recorded, because a drop landing while the reply is out means that one and not
+    // the directory being left; ui/Pane.qml dropPath reads it and only while this listing is out.
+    if (newPath !== pane.path) pane.linkTargetPendingId = 0 // A waiting Show original belongs to the listing being left, so leaving it drops the reveal.
+    pane.listingPath = newPath
+    // Verdicts stay the left directory's until fsinfo answers, so re-read keeps them.
+    if (newPath !== pane.path) { pane.storageClass = ""; pane.storageKnown = false; pane.fsAnswered = false; pane.systemVolume = false; pane.canTag = false }
+    if (pane.viewMode !== shown) ask.clearAtOnce = true
+    // A walk closed above keeps its rows and its strip until this listing lands.
+    if (pane.searchLeaving === true) ask.holdWalk = true
+    // A filter line held with its rows gives up the caret, so keys typed meanwhile meet the gate, not a query the swap forgets.
+    if (holdOrForget(pane, ask, ask.keptQuery) && pane.filterTyping)
+        Filter.commit(pane)
+    pane.appliedListingPreferences = pane.listingPreferences
+    // leaveWalk above has closed or is closing any search, so the armed row is this listing's to find; a path in another folder names none.
+    pane.backend.list(newPath, pane.windowSize, pane.showHidden, ask.wantChanged === true, pane.pendingSelect)
+    // One statfs per directory, not per row: the bar's right half only changes when the pane moves.
+    pane.backend.askFsInfo()
+}
+
+// A settled listing stays drawn until the new rows land, see AGENTS.md "The listing swap"; true when held, else forgotten at once, and a fallen-back loading mark stays through the newest request.
+function holdOrForget(pane, ask, keptQuery) {
+    var fell = pane.swap.fellBack === true
+    var held = pane.swap.hold(ask)
+    if (!held) {
+        forget(pane, keptQuery)
+        if (fell) pane.swap.phase = Swap.expired(pane.swap.phase)
+    }
+    return held
+}
+
+// Everything a fresh listing forgets, written once: at the request, or by ui/PaneSwap.qml when held rows go.
+function forget(pane, keptQuery) {
+    // An exit landing clears the drawn search state in the same turn its rows do.
+    if (pane.searchLeaving === true) Search.closeLeaving(pane)
+    // The editor row and the held sort belong to the replaced listing, so both go with it, before the count drops.
+    pane.pendingSort = null
+    pane.renamingIndex = -1
+    pane.total = 0
+    pane.held = 0
+    pane.rows = []
+    pane.kindNames = []
+    pane.thumbState = Thumbs.empty()
+    pane.dirSizeState = DirSizes.empty()
+    pane.cursorIndex = 0
+    pane.trashArmedAt = 0
+    // A re-list puts a different file at that index, so the tap record goes with the rename.
+    if (pane.cancelSlowClick) pane.cancelSlowClick()
+    // A filter narrows the rows already listed, so a new listing forgets it unless ui/js/Anchor.js hands it back.
+    Filter.close(pane)
+    if (keptQuery)
+        pane.filterQuery = keptQuery
+    pane.listingState = "loading"
+    pane.stateMessage = ""
+    pane.lockedMode = 0
+    pane.clearSelection()
+    pane.listArea.primeSettle()
+}
+
+// Which row the listing re-reveals after a rename. A rename the pointer committed keeps the row the
+// pointer chose instead, because re-selecting the renamed one would undo the click a round trip
+// after it landed. One shot: the next rename reveals again.
+function renameRefreshTarget(pane, path) {
+    if (!pane.renameKeepsPointerRow) {
+        return path
+    }
+    pane.renameKeepsPointerRow = false
+    return ""
+}
+
+// An operation changed the directory under the listing, so it is read again. Passing the path the
+// operation produced re-selects that row through pendingSelect instead of dropping the cursor to the
+// top. It is not a navigation, so it never touches the history.
+function refresh(pane, selectPath, keepSelection) {
+    pane.pendingSelect = selectPath ? selectPath : ""
+    pane.pendingMenu = false
+    clearPendingBackground(pane)
+    // A search keeps its rows and numbering, so one window ask re-stats the held rows; marks and cursor stay.
+    if (keepSelection === true && pane.searchMode === Search.RESULTS) {
+        pane.backend.window(pane.held, pane.windowSize)
+        return
+    }
+    if (keepSelection === true) {
+        // Metadata-only writes use the watcher's identity anchor and interaction debt.
+        pane.wire.stale = true
+        pane.wire.reread()
+        return
+    }
+    pane.openWithoutHistory(pane.path, { inPlace: true })
+}
+
+// The list request names the target, so its first rows answer alone looks for it at any depth, by listed name (NFC finds NFD).
+function applyPendingSelect(pane) {
+    // A search arms its return while the query stands, so its own landings skip it until Esc.
+    if (pane.pendingSelect.length === 0 || (pane.searchMode || "").length > 0) {
+        return
+    }
+    var target = pane.pendingSelect
+    pane.pendingSelect = ""
+    var at = Anchor.selectMatch(pane.rows, target, pane.path)
+    if (at >= 0) {
+        var index = pane.held + at
+        pane.setCursor(index)
+        pane.selection.only(index, true)
+        pane.selectionAnchor = index
+        pane.selectionVersion++
+        if (pane.pendingMenu) {
+            pane.pendingMenu = false
+            pane.openCursorMenu()
+        }
+        return
+    }
+    // The row is not in this listing, so the intent behind it must not fire on some later match.
+    pane.pendingMenu = false
+}
+
+// A failed listing drops the deferred background menu, so no later rows open it.
+function clearPendingBackground(pane) { ColumnMenu.clearPendingBackground(pane) }
+
+// The deferred neighbour background, consumed on every landing by identity.
+function applyPendingBackground(pane) { ColumnMenu.applyPendingBackground(pane) }
+
+// The cursor row once Enter's three guards pass, else null with the reason shown; the in-flight guard stops a second Enter queueing a second listing.
+function openableRow(pane) {
+    if (loading(pane)) {
+        pane.message("A directory is already loading.", false)
+        return null
+    }
+    var row = pane.rowFor(pane.cursorIndex)
+    if (!row) {
+        pane.message("That row has not loaded yet.", false)
+        return null
+    }
+    if (!Filter.cursorShown(pane)) {
+        pane.message("That row is hidden by the filter.", false)
+        return null
+    }
+    return row
+}
+
+// Enter on the cursor row: a directory navigates, an archive opens Flea's own view, anything else goes to the opener.
+function openCursor(pane, opener) {
+    var row = openableRow(pane)
+    if (!row) return
+    var path = pane.join(Search.baseOf(pane), row.n)
+    if (row.d) {
+        pane.open(path)
+        return
+    }
+    // Handing an archive on opens another file manager, and this is ui/Preview.qml's own classifier; an AppImage is a program first, so it asks on the run card.
+    if (Kinds.quickLookKind(row.i, path) === Kinds.ARCHIVE && !/\.appimage$/i.test(row.n)) {
+        pane.quickLook().open(path, row.i, row.s, pane.kindNames[row.k] || "",
+            pane.thumbState && pane.thumbState.file ? Thumbs.fileFor(pane.thumbState, pane.cursorIndex) : "")
+        return
+    }
+    opener.open(path)
+}
+
+// The run card's entrances always reach the opener, so Run asks through flea --open like Enter does.
+function runCursor(pane, opener, verb) {
+    var row = openableRow(pane)
+    if (!row) return
+    var path = pane.join(Search.baseOf(pane), row.n)
+    if (verb === "open") opener.open(path)
+    else pane.runText(path)
+}
+
+// The folder the Locked tile names, for its own menu and every row that menu offers: the
+// directory asked for while its tile is up, which is the parent's own path when the folder
+// failed on its own re-read. "" while no Locked tile is drawn, so the background menu stands.
+function lockedTarget(pane) {
+    if (pane.listingState !== "locked") return ""
+    var asked = pane.listingPath || ""
+    return asked.length > 0 ? trimSlash(asked) : pane.path
+}
+
+// The path helpers the columns view needs. A root has no parent and no leaf of its own.
+function trimSlash(path) {
+    // A bookmark can carry one trailing slash, which no row name ever has; "/" alone keeps its own.
+    var text = String(path)
+    return text.length > 1 && text.charAt(text.length - 1) === "/" ? text.substring(0, text.length - 1) : text
+}
+
+function parentOf(path) {
+    var text = trimSlash(path)
+    var cut = text.lastIndexOf("/")
+    return cut <= 0 ? "/" : text.substring(0, cut)
+}
+
+function leafOf(path) {
+    var text = String(path)
+    var cut = text.lastIndexOf("/")
+    return cut < 0 || cut === text.length - 1 ? text : text.substring(cut + 1)
+}
+
+// Issue 193: a hop that is out, refused or waiting climbs from the folder it asked for; ui/Pane.qml canGoUp reads it too.
+function climbsFromListing(pane) {
+    return (pane.listInFlight || pane.listingState === "locked" || pane.listingState === "waiting") && !!pane.listingPath && pane.listingPath !== pane.path
+}
+
+// Backspace, h and the chrome's up arrow, stopping at the root; the parent lands on the directory left, at any depth.
+function parent(pane) {
+    if (climbsFromListing(pane)) {
+        pane.pendingSelect = trimSlash(pane.listingPath)
+        pane.open(parentOf(pane.listingPath))
+        return
+    }
+    if (pane.path === "/") {
+        return
+    }
+    var here = pane.path
+    var cut = here.lastIndexOf("/")
+    pane.pendingSelect = here
+    pane.open(cut <= 0 ? "/" : here.substring(0, cut))
+}
+
+// A click on the folder already shown is a no-op, so the rail and columns routes land here.
+function showing(pane, path) {
+    if (trimSlash(path) !== pane.path) return false
+    if (pane.listInFlight) return false
+    if ((pane.searchMode || "").length > 0) return false
+    if (!pane.trash || pane.trash.opened) return false
+    return pane.listingState === "ready" || pane.listingState === "empty"
+}
+
+// Same-path Enter re-lists only a failed or locked listing; Trash, search and in-flight stay a no-op.
+function pathFailed(pane) {
+    if (!pane || pane.listInFlight) return false
+    if ((pane.searchMode || "").length > 0) return false
+    if (!pane.trash || pane.trash.opened) return false
+    return pane.listingState === "error" || pane.listingState === "locked"
+}
+
+// The rail's and the columns view's route in: the shown folder returns false and lists nothing.
+function openPlace(pane, path) {
+    if (showing(pane, path)) return false
+    pane.open(path)
+    return true
+}