flea-qml 0.0.0-stage → 0.2.0

package/ui/js/MenuRefresh.js

@@ -0,0 +1,74 @@
+.pragma library
+.import "MenuContext.js" as MenuContext
+
+// What a provider refresh does to an open menu: the answers it draws, whether a rebuild changes anything, where the cursor lands.
+
+// The provider inputs off ui/ContextMenu.qml's own properties; the peers are the service's, not gated by the row.
+function live(menu) {
+    return MenuContext.live(menu)
+}
+
+// A finished refresh's answer, which the menu keeps drawing while the next refresh runs behind it.
+function settle(answer) {
+    return MenuContext.settle(answer)
+}
+
+// A kept answer for the same install state stands in while a refresh runs, e.g. now { refreshing: true, taildropPeers: [], dropboxPath: "", ... }.
+function providerView(known, now) {
+    return MenuContext.providerView(known, now)
+}
+
+// Whether a rebuilt inventory is exactly what is drawn, so an answer that changed nothing resets no row.
+function unchanged(previous, next) {
+    return JSON.stringify(previous) === JSON.stringify(next)
+}
+
+// Release or flyout close schedules the rebuild after tapped dispatch, so the original handler can finish choosing.
+function pressChanged(menu, pressed) {
+    if (!pressed && menu.refreshOwed)
+        Qt.callLater(function() { if (menu.refreshOwed) menu.refreshProviderRows() })
+}
+
+// Only live delegates can hold a refresh; a destroyed pressed row leaves no state behind. A null flyout is a closed one, whose held rows only fade.
+function anyPressed(main, flyout) {
+    var repeaters = flyout === null ? [main] : [main, flyout]
+    for (var group = 0; group < repeaters.length; group++) {
+        var rows = repeaters[group]
+        for (var i = 0; i < rows.count; i++) {
+            var row = rows.itemAt(i)
+            if (row && row.pressed) return true
+        }
+    }
+    return false
+}
+
+// Preserve action and peer identity when refreshed capabilities change the inventory beneath the keyboard cursor.
+function refreshedCursor(previous, next, cursor, submenuRow, submenuCursor) {
+    var action = previous[cursor] ? previous[cursor].action : ""
+    var selected = action ? next.findIndex(function(entry) { return entry.action === action }) : -1
+    if (selected < 0) {
+        selected = Math.min(Math.max(0, cursor), next.length - 1)
+        while (selected < next.length && selected >= 0 && (next[selected].separator || next[selected].disabled)) selected++
+        if (selected === next.length) {
+            selected--
+            while (selected >= 0 && (next[selected].separator || next[selected].disabled)) selected--
+        }
+    }
+    var oldSubmenu = previous[submenuRow]
+    var subRow = oldSubmenu ? next.findIndex(function(entry) { return entry.action === oldSubmenu.action }) : -1
+    var sub = subRow >= 0 ? next[subRow] : null
+    var oldTarget = oldSubmenu && oldSubmenu.submenu ? oldSubmenu.submenu[submenuCursor] : null
+    var target = sub && !sub.disabled && oldTarget ? (sub.submenu || []).findIndex(function(entry) { return entry.id === oldTarget.id && !entry.disabled }) : -1
+    return { cursor: selected, submenuRow: target >= 0 ? subRow : -1, submenuCursor: Math.max(0, target) }
+}
+
+// A changed answer replaces an open menu's rows; cursor and flyout follow their actions, the flyout inside the build hold so it reads its rows once.
+function apply(menu, next) {
+    var selection = refreshedCursor(menu.entries, next, menu.cursor, menu.openSubmenuRow, menu.submenuCursor)
+    // A lone flyout's leaves come from Menu.flyoutEntries, which no provider answer changes, so it keeps its row and highlight.
+    var lone = menu.loneFlyoutAction.length > 0
+    menu.setEntries(next, lone ? undefined : selection.submenuRow)
+    menu.cursor = selection.cursor
+    if (!lone)
+        menu.submenuCursor = selection.submenuCursor
+}

package/ui/js/MenuWheel.js

@@ -0,0 +1,35 @@
+.pragma library
+
+// A menu's wheel answer in raw angleDelta units: highlight steps, content follows through reveal().
+
+// One discrete notch in raw angleDelta units, Qt's own convention for a wheel click.
+var NOTCH_UNITS = 120
+
+// Folds raw angleDelta into whole notches (remainder kept, dropped on flip, reset on open).
+function notchSteps(accum, angleDelta) {
+    var a = Number(accum) || 0
+    var d = Number(angleDelta) || 0
+    if (d === 0)
+        return { steps: 0, rest: a }
+    if (a !== 0 && ((a < 0) !== (d < 0)))
+        a = 0
+    var total = a + d
+    var notches = total > 0 ? Math.floor(total / NOTCH_UNITS) : Math.ceil(total / NOTCH_UNITS)
+    return { steps: -notches, rest: total - notches * NOTCH_UNITS }
+}
+
+// Folds gained travel into whole rows at rowHeight px (leftover kept, reset on ScrollBegin, no tail).
+function touchSteps(accum, gained, rowHeight) {
+    var row = Math.max(1, Number(rowHeight) || 0)
+    var total = (Number(accum) || 0) + (Number(gained) || 0)
+    var steps = 0
+    while (total <= -row) {
+        steps += 1
+        total += row
+    }
+    while (total >= row) {
+        steps -= 1
+        total -= row
+    }
+    return { steps: steps, rest: total }
+}

package/ui/js/Messages.js

@@ -0,0 +1,186 @@
+.pragma library
+
+.import "DropDev.js" as DropDev
+.import "Menu.js" as Menu
+
+// Every line the backend sends, turned into the signal the front end listens for. Split out of
+// ui/Backend.qml, which owns the socket, the requests and the signals themselves: the routing is a
+// long table and a table is not a socket's business. The sample lines live with the signals there.
+function route(root, message) {
+    if (message.t === "listed") {
+        root.dirDev = message.v || 0
+        root.dirWritable = message.w !== false
+        root.listed(message.n, message.read, message.sort, message.path || "", message.changed, message.gen || 0)
+    } else if (message.t === "rows") {
+        var landed = sized(message)
+        root.rows(message.start, landed, message.ms, message.kinds || [], message.listing || 0, message.gen || 0)
+    } else if (message.t === "error") {
+        // The backend names an empty clipboard by code, so the one sentence lives in Menu.EMPTY_CLIPBOARD.
+        root.failed(message.where, message.path, message.code === "emptyclipboard" ? Menu.EMPTY_CLIPBOARD : message.msg, message.mode || 0)
+    } else if (message.t === "localsendpeers") {
+        root.localSendPeers(message.peers || [], message.reason || "")
+    } else if (message.t === "localsendsent") {
+        root.localSendSent(message.ok === true, message.reason || "")
+    } else if (message.t === "thumbed") {
+        root.thumbed(message.row, message.file)
+    } else if (message.t === "dirsized") {
+        root.dirSized(message.row, message.bytes, message.partial)
+    } else if (message.t === "dirsizedone") {
+        root.dirSizeDone(message.cancelled === true)
+    } else if (message.t === "settagged") {
+        root.settagged(message)
+    } else if (message.t === "tagstates") {
+        root.tagStatesResult(message)
+    } else if (message.t === "searching") {
+        root.searching(message.n, message.scanned, message.ms)
+    } else if (message.t === "searched") {
+        root.searched(message.n, message.scanned, message.ms, message.cancelled, message.gen || 0, message.walking === true)
+    } else if (message.t === "transferstarted") {
+        root.transferStarted(message.id, message.n, message.moving, false)
+    } else if (message.t === "extractstarted") {
+        root.transferStarted(message.id, 1, false, true)
+    } else if (message.t === "transferprogress") {
+        root.transferProgress(message.id, message.index, message.name, message.bytes, message.total, message.scanned || 0,
+                              message.phase || "", message.drive || "")
+    } else if (message.t === "transferitem") {
+        // err rides only on a failure, so an ok item has no field to read here.
+        root.transferItem(message.id, message.index, message.name, message.ok, message.err || "")
+    } else if (message.t === "transferdone") {
+        // durable stays unread until a "written to the drive" sentence exists; note already
+        // has one, the verdict's own, which ui/js/Ops.js draws ahead of the undo hint.
+        root.transferDone(message.id, message.ok, message.failed, message.skipped, message.cancelled, message.retryPaths || [],
+                          message.durable === true, message.note || "", message.merged || 0, message.keptBoth || 0, message.into || "")
+    } else if (message.t === "collisions") {
+        root.collisions(message.id, message.total, message.names || [], message.mergeable === true)
+    } else if (message.t === "mergecollisions") {
+        root.mergeCollisions(message.id, message.total, message.names || [])
+    } else if (message.t === "fatnames") {
+        root.fatnames(message.id || 0, message.renames || [], message.fstype || "", message.volume || "")
+    // MenuAdditions040: Paste as links answers one line per request, and one
+    // journal entry, so one undo removes every link it created.
+    } else if (message.t === "linked") {
+        root.linked(message.ok || 0, message.failed || 0, message.skipped || 0, message.note || "")
+    // MenuAdditions040: Show original reveals the link's target in its own folder.
+    } else if (message.t === "linktarget") {
+        root.linkTarget(message.path || "", message.directory || "", message.name || "", message.id || 0)
+    } else if (message.t === "trashed") {
+        root.trashed(message.ok, message.failed, message.err || "")
+    } else if (message.t === "renamed") {
+        root.renamed(message.ok, message.path)
+    } else if (message.t === "slow") {
+        // A remote write past its deadline: information first, the reply itself later.
+        root.slowOp(message.op || "", message.path || "", message.msg || "")
+    } else if (message.t === "bulkrenamed") {
+        root.bulkRenamed(message.ok || 0, message.unchanged || 0)
+    } else if (message.t === "made") {
+        root.made(message.ok, message.path)
+    } else if (message.t === "duplicated") {
+        root.duplicated(message.ok, message.path)
+    } else if (message.t === "undone") {
+        root.undone(message.op, message.ok)
+    } else if (message.t === "redone") {
+        root.redone(message.op, message.ok)
+    } else if (message.t === "redostarted") {
+        root.redoStarted(message.id, message.n, message.op)
+    } else if (message.t === "paths") {
+        root.paths(message.paths || [])
+    } else if (message.t === "located") {
+        root.located(message)
+    // flea-qml: the command Find spawns, named once at start; null when nothing can run it.
+    } else if (message.t === "findcommand") {
+        root.findArgv = Array.isArray(message.argv) && message.argv.length > 0 ? message.argv : null
+        root.grepArgv = Array.isArray(message.grep) && message.grep.length > 0 ? message.grep : null
+    // flea-qml: the backend's Trash count, sent at start and whenever it changes.
+    } else if (message.t === "trashcount") {
+        root.trashCount = message.count
+        root.trashRevision = message.revision || 0
+    // flea-qml: the folders and drives the backend found by looking, sent at start, when a rail
+    // asks and whenever they change.
+    } else if (message.t === "places") {
+        root.placesFound(Array.isArray(message.places) ? message.places : [], Array.isArray(message.volumes) ? message.volumes : [])
+    } else if (message.t === "trashbrowse") {
+        root.trashResult(message)
+    } else if (message.t === "permissions") {
+        root.permissionsResult(message)
+    } else if (message.t === "picker") {
+        root.pickerResult(message)
+    } else if (message.t === "menuaction") {
+        root.menuResult(message)
+    } else if (message.t === "pdfcopied") {
+        root.pdfCopied(message.id || 0, message.path || "", message.err || "", message.stalled === true)
+    } else if (message.t === "fontlooked") {
+        root.fontLooked(message)
+    } else if (message.t === "meta") {
+        root.metaResult(message)
+        root.meta(message.row, message.w, message.h, message.orient || 1, message.ms, message.rate, message.entries, message.unpacked, message.afailed, message.names, message.lines, message.partial, message.lfailed === true, message.target, message.targetdir, message.owner || "", typeof message.topEntries === "number" ? message.topEntries : -1)
+    } else if (message.t === "code") {
+        root.codeResult(message)
+    } else if (message.t === "html") {
+        root.htmlResult(message)
+    } else if (message.t === "markdownhtml") {
+        root.markdownHtmlResult(message)
+    } else if (message.t === "figure") {
+        root.figureResult(message)
+    } else if (message.t === "compare") {
+        root.compareResult(message)
+    } else if (message.t === "shebang") {
+        root.shebang(message.path || "", message.hasShebang === true, message.id || 0)
+    } else if (message.t === "clip") {
+        root.clipResult(message)
+    } else if (message.t === "fsinfo") {
+        root.fsInfo(message.fs, message.free, message.path || "", message.class || "", message.tagable === true, message.system === true)
+    } else if (message.t === "changed") {
+        root.changed(message.path || "")
+    } else if (message.t === "unmounted") {
+        root.unmounted(message.path || "", message.parent || "")
+    } else if (message.t === "jumped") {
+        root.jumped(message.id || 0, message.favourites || [], message.zoxide || [], message.recent || [], message.frecency || {})
+    } else if (message.t === "devs") {
+        if (message.id > 0) root.metaResult(message)
+        else root.pathDevs = DropDev.merged(root.pathDevs, message.devs)
+    } else if (message.t === "peeked") {
+        root.peeked(message.path, message.hidden === true, message.n, message.rows || [], message.failed === true, message.mode || 0, message.hiddenLast === true, message.first || 0, message.v || 0, message.w !== false, message.by || "", message.desc === true)
+    } else if (message.t === "formats") {
+        root.archiveFormats = message.archive || []
+        root.canConvert = message.convert === true
+        root.extraction = message.extract || ({archive: false, sevenZip: false})
+        root.providers = message.providers || ({})
+        root.formatsResult(message)
+    } else if (message.t === "archivestarted") {
+        root.archiveStarted(message.id)
+    } else if (message.t === "archivedone") {
+        root.archiveDone(message.id, message.ok, message.verified !== false, message.err || "", message.path || "", message.dest || "")
+    } else if (message.t === "convertchecked") {
+        root.convertChecked(message)
+    } else if (message.t === "convertstarted") {
+        root.convertStarted(message.id, message.requestId || 0, message.source || "")
+    } else if (message.t === "convertdone") {
+        root.convertDone(message.id, message.ok, message.path || "", message.err || "", message.requestId || 0,
+                         message.source || "", message.collision === true)
+    } else if (message.t === "flashimage") {
+        root.flashImageResult(message)
+    } else if (message.t === "flashtargets") {
+        root.flashTargetsResult(message)
+    } else if (message.t === "flashstarted") {
+        root.flashStartedLine(message.id, message.total || 0, message.known === true)
+    } else if (message.t === "flashprogress") {
+        root.flashProgressLine(message.id, message.phase || "", message.bytes || 0,
+                               message.total || 0, message.permille || 0)
+    } else if (message.t === "flashdone") {
+        root.flashDoneLine(message)
+    } else if (message.t === "flasheject") {
+        root.flashEjectLine(message)
+    }
+}
+
+// A live answer's rows line names the folder sizes the backend already knows; each one rides on its own row.
+// Sample input: {"t":"rows","start":20,"rows":[{"n":"c","d":true,"s":4096,"m":1787790423,"p":16877,"i":"folder","t":false,"k":0,"v":2049}],"kinds":["Folder"],"ms":0.410,"listing":5,"gen":3,"z":[[20,96]]} gives row "c" z 96.
+function sized(message) {
+    var z = message.z || []
+    for (var i = 0; i < z.length; i++) {
+        var row = message.rows[z[i][0] - message.start]
+        if (row)
+            row.z = z[i][1]
+    }
+    return message.rows
+}

package/ui/js/Motion.js

@@ -0,0 +1,16 @@
+.pragma library
+
+// The structural transitions use OutCubic, 180 ms to reveal and 140 ms to hide.
+
+var durMs = {
+    // A reveal reads slower than a hide.
+    open: 180,
+    close: 140
+}
+
+// Open rises into place from this far below its resting position; close does not translate,
+// opacity only (see the Preview/ShareBrowser/NetworkDialog verticalCenterOffset/y bindings).
+var translateUpPx = 10
+
+// How long the pointer rests at the left edge before the auto-hidden rail opens; the OEM bar holds its centre peek 120 ms (Bar.qml:834).
+var dwellMs = 120

package/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/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()
+}