flea-qml 0.0.0-stage → 0.2.0

package/ui/js/PropertyFacts.js

@@ -0,0 +1,144 @@
+.pragma library
+.import "Format.js" as Format
+.import "Facts.js" as Facts
+
+// The Properties card's Size and Contains lines for a folder: the walk's floor while it counts, the whole once it is done.
+var TAIL = " · counting…"
+var SIZE = {exact: "%1 (%2 bytes)", floor: "> %1 (%2 bytes)"}
+var CONTAINS = {exact: ["%1 item", "%1 items"], floor: ["> %1 item", "> %1 items"]}
+
+// Sample input: {bytes: 4096} from the properties reply; the walk's first floor is the folder's own entry.
+function begin(facts) {
+    return {bytes: facts.bytes, items: 0, partial: false, done: false}
+}
+
+// A progress or final reply folded into the walk; a cancelled or refused walk ends as the floor already counted, so the card never counts forever.
+function next(walk, reply) {
+    if (reply.cancelled)
+        return walk.done ? walk : {bytes: walk.bytes, items: walk.items, partial: true, done: true}
+    if (!reply.ok)
+        return {bytes: walk.bytes, items: walk.items, partial: true, done: true}
+    return {bytes: reply.bytes, items: reply.items, partial: reply.partial === true, done: reply.done === true}
+}
+
+// Sample input: size(13, null) is a file's own; size(0, walk) reads the walk. A partial walk stays a floor when done.
+function size(bytes, walk) {
+    var shown = walk ? walk.bytes : bytes
+    var template = walk && (!walk.done || walk.partial) ? SIZE.floor : SIZE.exact
+    return {value: template.arg(Format.size(shown)).arg(String(shown)), tail: walk && !walk.done ? TAIL : ""}
+}
+
+function contains(walk) {
+    if (!walk)
+        return null
+    var forms = !walk.done || walk.partial ? CONTAINS.floor : CONTAINS.exact
+    return {value: forms[walk.items === 1 ? 0 : 1].arg(Format.count(walk.items)), tail: walk.done ? "" : TAIL}
+}
+
+function escape(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")
+}
+
+// StyledText: the value in the Text's own colour and only the tail in `muted`, on the value's line.
+function styled(line, muted) {
+    if (!line.tail)
+        return escape(line.value)
+    return "%1<font color=\"%2\">%3</font>".arg(escape(line.value)).arg(muted).arg(escape(line.tail))
+}
+
+// The names ffprobe prints for the codecs a card is likely to meet; one it does not know is shown upper-cased, as ffprobe says it.
+var CODECS = {h264: "H.264", hevc: "H.265", vp8: "VP8", vp9: "VP9", av1: "AV1", mpeg4: "MPEG-4", mpeg2video: "MPEG-2", mpeg1video: "MPEG-1",
+              aac: "AAC", mp3: "MP3", opus: "Opus", vorbis: "Vorbis", flac: "FLAC", ac3: "AC-3", eac3: "E-AC-3", dts: "DTS", alac: "ALAC"}
+
+function codecName(name) {
+    if (!name)
+        return ""
+    if (name.indexOf("pcm_") === 0)
+        return "PCM"
+    return CODECS[name] || name.toUpperCase()
+}
+
+// Sample input: codecs("h264", "aac") reads "H.264 · AAC"; a file with one stream names that one.
+function codecs(video, audio) {
+    return [codecName(video), codecName(audio)].filter(function (name) { return name !== "" }).join(" · ")
+}
+
+// Sample input: 8100000 reads "8.1 Mb/s"; ffprobe's bits per second, decimal prefixes, whole kb/s below a megabit.
+function bitRate(bps) {
+    if (!(bps > 0))
+        return ""
+    if (bps < 1000)
+        return Math.round(bps) + " b/s"
+    var kilo = Math.round(bps / 1000)
+    return kilo < 1000 ? kilo + " kb/s" : (bps / 1000000).toFixed(1) + " Mb/s"
+}
+
+// A camera writes the make's first word into the model on its own (Canon EOS R6, NIKON CORPORATION and NIKON Z 6) or not (SONY, ILCE-7M4).
+function camera(make, model) {
+    if (!make || !model)
+        return model || make || ""
+    var brand = make.toLowerCase().split(/\s+/)[0]
+    return model.toLowerCase().indexOf(brand) === 0 ? model : make + " " + model
+}
+
+// A rational as [numerator, denominator], zero when the file named none or a zero denominator.
+function ratio(pair) {
+    return pair && pair[0] > 0 && pair[1] > 0 ? pair[0] / pair[1] : 0
+}
+
+// Sample input: [1, 250] reads "1/250 s", [10, 600] "1/60 s", [6, 10] "0.6 s", [13, 10] "1.3 s"; a fraction whose numerator divides its denominator stays a 1/n.
+function shutterText(pair, seconds) {
+    var num = pair[0], den = pair[1], tenths = Math.round(seconds * 10)
+    // A shutter that rounds to a whole second reads like one, so 0.96 s and 1 s both read "1 s".
+    if (tenths >= 10)
+        return String(tenths / 10) + " s"
+    if (den % num === 0 || num === 1)
+        return "1/" + (num === 1 ? den : den / num) + " s"
+    return tenths > 0 ? (tenths / 10).toFixed(1) + " s" : "1/" + Math.round(1 / seconds) + " s"
+}
+
+// Sample input: ([1, 250], [28, 10], 400) reads "1/250 s · f/2.8 · ISO 400"; a part the file lacks is left out.
+function exposure(shutter, fnumber, iso) {
+    var seconds = ratio(shutter), stop = ratio(fnumber), parts = []
+    if (seconds > 0)
+        parts.push(shutterText(shutter, seconds))
+    if (stop > 0)
+        parts.push("f/" + String(Math.round(stop * 10) / 10))
+    if (iso > 0)
+        parts.push("ISO " + iso)
+    return parts.join(" · ")
+}
+
+// Sample input: "2026:09:12 18:31:07", EXIF's own stamp, reads "2026-09-12 18:31" like every other date on the card.
+function taken(stamp) {
+    var m = /^(\d{4}):(\d{2}):(\d{2}) (\d{2}):(\d{2}):\d{2}/.exec(stamp || "")
+    return m && m[1] !== "0000" ? m[1] + "-" + m[2] + "-" + m[3] + " " + m[4] + ":" + m[5] : ""
+}
+
+// Empty strings, zero ISO and zero rationals are absent; present deferred EXIF fields win a disagreement.
+function mergePhoto(photo, reply) {
+    var p = photo || {}, r = reply || {}
+    return {
+        make: r.make || p.make || "",
+        model: r.model || p.model || "",
+        lens: r.lens || p.lens || "",
+        shutter: ratio(r.shutter) > 0 ? r.shutter : p.exp,
+        fnumber: ratio(r.fnumber) > 0 ? r.fnumber : p.fnum,
+        iso: r.iso > 0 ? r.iso : p.iso,
+        taken: r.taken || p.taken || ""
+    }
+}
+
+// One merged photo, formatted once in the existing card language; codecs and bit rate stay with the facts reply.
+function extraPairs(reply, photo) {
+    if (!reply || !reply.ok)
+        return []
+    var merged = mergePhoto(photo, reply)
+    var shown = photo ? Facts.photoFacts(Object.assign({}, merged, {exp: merged.shutter, fnum: merged.fnumber})) : {
+        camera: camera(merged.make, merged.model), lens: merged.lens,
+        exposure: exposure(merged.shutter, merged.fnumber, merged.iso), taken: taken(merged.taken)
+    }
+    return [["Codecs", codecs(reply.vcodec, reply.acodec)], ["Bit rate", bitRate(reply.bps)],
+            ["Camera", shown.camera], ["Lens", shown.lens], ["Exposure", shown.exposure], ["Taken", shown.taken]]
+        .filter(function (pair) { return pair[1] !== "" })
+}

package/ui/js/Protocols.js

@@ -0,0 +1,296 @@
+.pragma library
+
+// The Add-network-place form is a form over a gvfs URI, never a second mount system: a protocol
+// picks the scheme, prefills the port and swaps the field set, and the Mounts-as line always shows
+// the exact URI the dialog will hand to gio mount.
+
+// The five the canvas draws, in the order it draws them.
+var PROTOCOLS = ["SMB", "SFTP", "FTPS", "WebDAV", "NFS"]
+
+// Which fields each protocol asks for. "path" is the label the canvas gives that row, which differs
+// per protocol because the thing it names differs: a share, a remote path, an export.
+var FIELDS = {
+    "SMB": { pathLabel: "Share",  credentials: true,  domain: true,  tls: false },
+    "SFTP":   { pathLabel: "Path",   credentials: true,  domain: false, tls: false },
+    "FTPS":   { pathLabel: "Path",   credentials: true,  domain: false, tls: true },
+    "WebDAV": { pathLabel: "Path",   credentials: true,  domain: false, tls: true },
+    // NFS has no credentials at all: the export is authorised by the server, not by a password.
+    "NFS": { pathLabel: "Export", credentials: false, domain: false, tls: false }
+}
+
+// The TLS box flips two schemes and defaults on, which is what the canvas draws ticked.
+function scheme(protocol, tls) {
+    switch (protocol) {
+    case "SMB": return "smb"
+    case "SFTP": return "sftp"
+    case "FTPS": return tls ? "ftps" : "ftp"
+    case "WebDAV": return tls ? "davs" : "dav"
+    case "NFS": return "nfs"
+    }
+    return ""
+}
+
+function fieldsFor(protocol) {
+    return FIELDS[protocol] || FIELDS["SMB"]
+}
+
+// The port the form prefills. It belongs to the scheme, never to the protocol: WebDAV builds two
+// schemes and SCHEME_PORTS below is the one table both this and the rail's dedup read it out of.
+function defaultPort(protocol, tls) {
+    return defaultPortFor(scheme(protocol, tls))
+}
+
+// The exact URI gio mount will be handed. Empty when there is not enough to build one, so the
+// Mounts-as line shows nothing rather than a half-formed address.
+function uri(form) {
+    var host = String(form.host || "").trim()
+    var port = String(form.port || "").trim()
+    if (!validHost(host) || !validPort(port)) {
+        return ""
+    }
+    var spec = fieldsFor(form.protocol)
+    var head = scheme(form.protocol, form.tls) + "://"
+    if (spec.credentials) {
+        head += userPart(form, spec)
+    }
+    head += host
+    // Keep canvas defaults in the form, but omit them because GVFS NFS rejects an explicit :2049.
+    if (port.length > 0 && Number(port) !== defaultPort(form.protocol, form.tls)) {
+        head += ":" + port
+    }
+    return head + pathPart(form.path)
+}
+
+function validHost(host) {
+    return /^\[[0-9A-Fa-f:.]+\]$/.test(host) || /^[A-Za-z0-9._-]+$/.test(host)
+}
+
+function validPort(port) {
+    if (port.length === 0) {
+        return true
+    }
+    if (!/^[0-9]+$/.test(port)) {
+        return false
+    }
+    var number = Number(port)
+    return number >= 1 && number <= 65535
+}
+
+// smb://DOMAIN;user@host/share is the form a domain takes; without one it is just user@host.
+function userPart(form, spec) {
+    var user = String(form.user || "").trim()
+    if (user.length === 0) {
+        return ""
+    }
+    var domain = spec.domain ? String(form.domain || "").trim() : ""
+    return (domain.length > 0 ? encodeURIComponent(domain) + ";" : "")
+        + encodeURIComponent(user) + "@"
+}
+
+function pathPart(path) {
+    var text = String(path || "").trim()
+    if (text.length === 0) {
+        return "/"
+    }
+    var parts = text.split("/")
+    for (var i = 0; i < parts.length; i++) {
+        parts[i] = encodeURIComponent(parts[i])
+    }
+    var encoded = parts.join("/")
+    return encoded.charAt(0) === "/" ? encoded : "/" + encoded
+}
+
+// The label the sidebar row will carry: what the operator typed, or the last part of the path.
+function label(form) {
+    var given = String(form.label || "").trim()
+    if (given.length > 0) {
+        return given
+    }
+    var path = String(form.path || "").replace(/\/+$/, "")
+    var cut = path.lastIndexOf("/")
+    var leaf = cut >= 0 ? path.substring(cut + 1) : path
+    return leaf.length > 0 ? leaf : String(form.host || "").trim()
+}
+
+// A form with nothing to mount cannot be saved, which is what greys the Save row out.
+function complete(form) {
+    var host = String(form.host || "").trim()
+    var port = String(form.port || "").trim()
+    return validHost(host) && validPort(port)
+}
+
+// The port each scheme drops, which is a property of the scheme and not of the protocol the form
+// picked: WebDAV builds two schemes whose ports differ, and one number for both stripped a real
+// ":443" off "dav://" and left its real ":80" on, the duplicate rail row this exists to remove.
+// Measured on this box against gvfs 1.60.2 and glib2 2.88.3 by round-tripping each spelling through
+// Gio.File, the uri mapper "gio mount -l" prints through: gio drops smb 445, sftp 22, ftp 21,
+// ftps 21 (not IANA's 990), dav 80 and davs 443, and keeps every other port it is given, ftps 990
+// and dav 443 included. It drops no nfs port at all, so 2049 is here for the other half of the job:
+// the port an nfs client uses when the line omits one, so two spellings of one export make one row.
+var SCHEME_PORTS = {
+    "smb": 445, "sftp": 22, "ftp": 21, "ftps": 21, "dav": 80, "davs": 443, "nfs": 2049
+}
+
+// A bookmarks line is arbitrary text, so an inherited Object member must never answer as a port.
+function defaultPortFor(uriScheme) {
+    var want = String(uriScheme || "").toLowerCase()
+    return SCHEME_PORTS.hasOwnProperty(want) ? SCHEME_PORTS[want] : 0
+}
+
+// "gio mount -l" never reports a scheme's default port and the add form spells out the one it
+// prefilled, so the same share arrives spelled two ways and must resolve to one rail row. The port
+// is found in the authority alone: a ":" or an "@" further along belongs to the path.
+function stripDefaultPort(uri) {
+    var text = String(uri || "")
+    var auth = authority(text)
+    var tail = ":" + defaultPortFor(schemeOf(text))
+    // A bracketed IPv6 literal ends in "]", so its own trailing digits can never match this tail.
+    if (auth.length === 0 || tail === ":0" || auth.substring(auth.length - tail.length) !== tail)
+        return text
+    var mark = text.indexOf("://") + 3
+    return text.substring(0, mark) + auth.substring(0, auth.length - tail.length)
+        + text.substring(mark + auth.length)
+}
+
+// The scheme a built or bookmarked URI carries, lowercased; "" when the text is not a URI at all.
+function schemeOf(uri) {
+    var text = String(uri || "")
+    var mark = text.indexOf("://")
+    return mark < 0 ? "" : text.substring(0, mark).toLowerCase()
+}
+
+// Everything between "://" and the next "/", which is the only place a userinfo, a host or a port
+// can live: a scan over the whole URI would read a "@" or a ":" inside the path as one of those.
+function authority(uri) {
+    var text = String(uri || "")
+    var mark = text.indexOf("://")
+    if (mark < 0)
+        return ""
+    var rest = text.substring(mark + 3)
+    var slash = rest.indexOf("/")
+    return slash < 0 ? rest : rest.substring(0, slash)
+}
+
+// The host alone: userinfo dropped at the authority's own last "@", a bracketed IPv6 literal kept
+// whole because its colons are not a port separator, and any real port dropped.
+function hostOf(uri) {
+    var auth = authority(uri)
+    var at = auth.lastIndexOf("@")
+    var hostPort = at < 0 ? auth : auth.substring(at + 1)
+    if (hostPort.charAt(0) === "[") {
+        var close = hostPort.indexOf("]")
+        return close < 0 ? hostPort : hostPort.substring(0, close + 1)
+    }
+    var colon = hostPort.indexOf(":")
+    return colon < 0 ? hostPort : hostPort.substring(0, colon)
+}
+
+// gvfsd renders a network mount as "<share> <word> <host>" and translates that word, so issue #36's
+// rule reads the URI instead: the tail that gets cut is this URI's own host, in any language, and a
+// label that does not end in it is left exactly as gio gave it.
+function shareName(rawLabel, uri) {
+    var text = String(rawLabel || "")
+    var host = hostOf(uri)
+    var head = text.substring(0, text.length - host.length)
+    if (host.length === 0 || head.length === 0 || text.substring(head.length) !== host)
+        return text
+    // The one assumption left after the host check: gvfsd's connector is a single whitespace-delimited
+    // word in whatever language it renders. A translation using two would leave one of them on the
+    // name, a wrong label and never a wrong destination; a head this does not shorten is left whole.
+    var name = head.replace(/\s+\S+\s+$/, "")
+    return name.length > 0 && name !== head ? name : text
+}
+
+// Sample input: smb://dan@192.168.1.75/test, the reporter's share, and its FUSE folder
+// /run/user/1000/gvfs/smb-share:server=192.168.1.75,share=test,user=dan. A FUSE path for
+// another user, another share or another server must never open as this share's listing:
+// a mount problem answers as one instead of reading like an unreadable directory.
+function decodeSegment(raw) {
+    try { return decodeURIComponent(String(raw)) } catch (e) { return String(raw) }
+}
+
+// The smb:// request as gio sees it: the user past any DOMAIN; prefix, the host without
+// a port, and the share as the first path segment. Null when not an smb:// URI at all.
+function smbParts(uri) {
+    if (schemeOf(uri) !== "smb") return null
+    var auth = authority(uri)
+    if (auth.length === 0) return null
+    var at = auth.lastIndexOf("@")
+    var info = at < 0 ? "" : auth.substring(0, at)
+    var semi = info.indexOf(";")
+    var user = semi < 0 ? info : info.substring(semi + 1)
+    var mark = String(uri).indexOf("://") + 3
+    var rest = String(uri).substring(mark + auth.length)
+    if (rest.charAt(0) === "/") rest = rest.substring(1)
+    var cut = rest.indexOf("/")
+    var share = cut < 0 ? rest : rest.substring(0, cut)
+    return { user: decodeSegment(user), host: hostOf(uri).toLowerCase(), share: decodeSegment(share) }
+}
+
+// The smb-share: FUSE directory gio info prints a local path for, or null when the path
+// is no smb FUSE directory at all. Null is undecided, never a mismatch: an unknown shape
+// opens exactly as before rather than refusing a mount over a format this never learned.
+function fuseSmbParts(path) {
+    var m = String(path || "").match(/smb-share:server=([^,\/]+),share=([^,\/]+)(?:,user=([^,\/]+))?/)
+    if (!m) return null
+    return { host: String(m[1]).toLowerCase(), share: m[2], user: m[3] || "" }
+}
+
+// Whether gio info's answer belongs to the smb:// request that asked for it. True for any
+// non-smb URI and whenever either side will not parse; false only on a parsed mismatch, a
+// user the answer drops or changes above all, so that answer is refused as a mount failure.
+function smbFuseMatches(uri, fusePath) {
+    if (schemeOf(uri) !== "smb") return true
+    var want = smbParts(uri)
+    var got = fuseSmbParts(fusePath)
+    if (!want || !got) return true
+    var wantUser = String(want.user || "")
+    var gotUser = String(got.user || "")
+    var semi = gotUser.indexOf(";")
+    if (semi >= 0) gotUser = gotUser.substring(semi + 1)
+    return want.host === got.host
+        && String(want.share).toLowerCase() === String(got.share).toLowerCase()
+        && wantUser.toLowerCase() === gotUser.toLowerCase()
+}
+
+// Sample input: uri smb://dan@192.168.1.75/test with gio info printing the path without
+// ,user=dan while only the user=dan folder exists. Answers the entry whose user the URI
+// names; with no user the single share match wins, several prefer the desktop login.
+function smbResolve(uri, fusePaths, login) {
+    var found = { path: "", users: [] }
+    var want = smbParts(uri)
+    if (!want) return found
+    var hits = []
+    var list = fusePaths || []
+    for (var i = 0; i < list.length; i++) {
+        var got = fuseSmbParts(list[i])
+        if (!got || got.host !== want.host) continue
+        if (String(got.share).toLowerCase() !== String(want.share).toLowerCase()) continue
+        hits.push({ path: list[i], user: String(got.user || "") })
+    }
+    if (String(want.user || "").length > 0) {
+        for (var j = 0; j < hits.length; j++) {
+            if (hits[j].user.toLowerCase() === String(want.user).toLowerCase()) {
+                found.path = hits[j].path
+                return found
+            }
+        }
+        return found
+    }
+    if (hits.length === 1) {
+        found.path = hits[0].path
+        return found
+    }
+    if (hits.length > 1) {
+        for (var k = 0; k < hits.length; k++) {
+            if (hits[k].user.toLowerCase() === String(login || "").toLowerCase()) {
+                found.path = hits[k].path
+                return found
+            }
+        }
+        for (var m = 0; m < hits.length; m++) {
+            if (found.users.indexOf(hits[m].user) < 0) found.users.push(hits[m].user)
+        }
+    }
+    return found
+}

package/ui/js/QuickLookKinds.js

@@ -0,0 +1,27 @@
+.pragma library
+
+.import "Kinds.js" as Kinds
+
+// Which compilation unit Quick Look opens a row's content from, for ui/QuickLookWarm.qml to hold compiled before the first Space.
+var MARKDOWN = "MarkdownPane.qml"
+var PDF = "PdfViewer.qml"
+var MEDIA = "PreviewMedia.qml"
+var IMAGE = "PreviewImage.qml"
+var TEXT = "PreviewText.qml"
+
+// Sample input: { n: "a.pdf", i: "x-office-document" } answers "PdfViewer.qml", { n: "a.mp4", i: "video-x-generic" } "PreviewMedia.qml", { n: "a.png", i: "image-x-generic" } "PreviewImage.qml", { n: "a.md", i: "text-x-generic" } "MarkdownPane.qml".
+// A folder, an archive, an unsupported file and null answer "" because no unit of their own is compiled for them.
+function unitOf(row) {
+    if (row === null || row === undefined || row.d === true)
+        return ""
+    if (Kinds.isMarkdown(row.n))
+        return MARKDOWN
+    switch (Kinds.quickLookKind(row.i, row.n, row.t === true)) {
+    case Kinds.PDF: return PDF
+    case Kinds.VIDEO:
+    case Kinds.AUDIO: return MEDIA
+    case Kinds.IMAGE: return IMAGE
+    case Kinds.TEXT: return TEXT
+    }
+    return ""
+}

package/ui/js/QuickLookRect.js

@@ -0,0 +1,24 @@
+.pragma library
+
+// Sample input: surface({ kind: "pdf", known: true, w: 595, h: 842, orient: 1 }, 1200, 760, false, { fraction: 0.82, edge: 24, bar: 27 }) is { w: 484.06, h: 712 }.
+// The want before Theme.cardSpan rounds it. A shape is the kind plus its one fact: a PDF's page 1 size or an image's pixels and EXIF orientation, known false while unasked or unanswered.
+function surface(shape, winW, winH, expanded, tokens) {
+    var today = { w: winW * tokens.fraction, h: winH * tokens.fraction }
+    if (expanded)
+        return { w: winW, h: winH }
+    var tallH = winH - 2 * tokens.edge
+    var seen = shape.known === true && shape.w > 0 && shape.h > 0
+    if (shape.kind === "text" || shape.kind === "archive")
+        return { w: today.w, h: tallH }
+    if (shape.kind === "pdf" && seen)
+        return { w: Math.min(today.w, (tallH - tokens.bar) * shape.w / shape.h), h: tallH }
+    if (shape.kind === "image" && seen) {
+        var turned = shape.orient >= 5
+        var ow = turned ? shape.h : shape.w
+        var oh = turned ? shape.w : shape.h
+        // A portrait shorter than the tall rect keeps today's frame rather than being stretched to it.
+        if (oh > ow && oh >= tallH)
+            return { w: Math.min(today.w, tallH * ow / oh), h: tallH }
+    }
+    return today
+}

package/ui/js/RailDrop.js

@@ -0,0 +1,51 @@
+.pragma library
+
+.import "Drag.js" as Drag
+.import "DragOut.js" as DragOut
+.import "DropDev.js" as DropDev
+
+var sequence = 0
+
+// Sample input: a mounted volume at "/run/media/u/USB/" names "/run/media/u/USB"; a phone root names nothing.
+function destination(entry, marker, urls, shelf, plain) {
+    if (!entry || entry.kind === "recent" || entry.kind === "trash" || entry.kind === "tag"
+            || entry.kind === "phone" || entry.mounted === false) return ""
+    var path = DropDev.normalize(entry.path)
+    if (path.charAt(0) !== "/" || /^\/run\/user\/[0-9]+\/gvfs\/(mtp|gphoto2|afc):[^/]+$/i.test(path)) return ""
+    if (marker && !Drag.markerFields(marker)) return ""
+    var paths = DragOut.sources(urls, plain, marker, shelf)
+    if (paths.length === 0 || DragOut.refusal(paths, path, marker, shelf) !== "") return ""
+    return path
+}
+
+// The rail's existing rows supply geometry, including the scroller's offset; headings name no row.
+function rowAt(sidebar, x, y) {
+    for (var i = 0; i < sidebar.entries.length; i++) {
+        var row = sidebar.railItemFor(i)
+        if (!row || !row.visible) continue
+        var at = row.mapFromItem(sidebar, x, y)
+        if (at.x >= 0 && at.y >= 0 && at.x < row.width && at.y < row.height) return i
+    }
+    return -1
+}
+
+// A new hover never borrows cached device facts from an earlier mount or gesture.
+function pending(path) {
+    sequence += 1
+    return { path: path, id: sequence, dev: 0 }
+}
+
+// Sample input: answer({path:"/usb",id:7,dev:0}, 7, {"/usb":42}) names device 42; a superseded id leaves it unknown.
+function answer(held, id, devs) {
+    if (!held || held.id !== id || !Object.prototype.hasOwnProperty.call(devs || {}, held.path)) return held
+    return { path: held.path, id: held.id, dev: DropDev.devFor(devs, held.path) }
+}
+
+// The ordinary folder transfer asks the collision host first, which owns the card and the undo path.
+function drop(pane, entry, held, marker, urls, shelf, plain, proposed, ctrl, shift) {
+    if (!pane || !pane.backend || pane.listInFlight) return false
+    var path = destination(entry, marker, urls, shelf, plain)
+    if (!path) return false
+    return Drag.dropInto(pane, marker, urls, path, held && held.path === path ? held.dev : 0,
+                         shelf, plain, proposed, ctrl, shift)
+}

package/ui/js/RailKeys.js

@@ -0,0 +1,87 @@
+.pragma library
+
+.import "Eject.js" as Eject
+.import "Mounts.js" as Mounts
+.import "Nav.js" as Nav
+
+// What the rail does with a key, split out of Focus.js at its 300-line hard cap the same way
+// ui/js/PreviewKeys.js was: Focus.js decides which surface owns a key, and this is the surface.
+
+// A mount-first Enter's open has landed in root: focus follows it into the folder unless the user already left the rail.
+function landed(root, sidebar) {
+    if (!sidebar || !sidebar.focusOnOpen) return
+    sidebar.focusOnOpen = false
+    if (root.focusView === "rail") root.focusView = "list"
+}
+
+// A Sidebar open (opened or networkOpened): the pane that asked opens it, and a waiting claim lands; no pane spends the claim.
+function openFrom(pane, path, sidebar) {
+    if (!pane) { if (sidebar) sidebar.focusOnOpen = false; return }
+    Nav.openPlace(pane, path)
+    if (sidebar) landed(pane, sidebar)
+}
+
+// A mount that failed has no open to land, so its focus claim goes with the error.
+function messaged(sidebar, isError) {
+    if (isError && sidebar) sidebar.focusOnOpen = false
+}
+
+// The keyboard cursor takes the rail's highlight only while the keyboard holds it, never under an open rail menu or after a pointer press until a rail key.
+function cursorDrawn(focused, menuOpen, pointerFocus) {
+    return Boolean(focused && !menuOpen && !pointerFocus)
+}
+
+// Right Arrow from a row whose mark releases moves the keyboard onto that mark, read raw because the table resolves Right to opening the row in every preset.
+function markKey(event, root, sidebar) {
+    if (event && (event.modifiers & (Qt.ControlModifier | Qt.AltModifier | Qt.MetaModifier)) !== 0) return false
+    var key = event ? event.key : 0
+    if (!sidebar.markFocused) {
+        if (key !== Qt.Key_Right || !Eject.releasable(sidebar.entries[sidebar.cursorIndex])) return false
+        sidebar.markFocused = true
+        return true
+    }
+    if (key === Qt.Key_Left || key === Qt.Key_Escape) sidebar.markFocused = false
+    else if (key === Qt.Key_Return || key === Qt.Key_Enter || key === Qt.Key_Space) {
+        sidebar.markFocused = false
+        Eject.release(root, sidebar, true)
+    } else if (key !== Qt.Key_Right) return false
+    return true
+}
+
+// The rail answers ten of the key table's action names and ignores the rest while it has focus; event is the key itself, for the ones the table does not name.
+function act(action, root, sidebar, event) {
+    // Any other rail key ends a mount-first open's claim on focus and restores the keyboard highlight a pointer press hid.
+    sidebar.focusOnOpen = false
+    sidebar.pointerFocus = false
+    if (markKey(event, root, sidebar)) return
+    // A cursor key leaves the mark for the rows, even on the first or last row where the cursor stays.
+    if (action.indexOf("cursor") === 0) sidebar.markFocused = false
+    switch (action) {
+    case "cursorDown": sidebar.cursorIndex = Math.min(sidebar.entries.length - 1, sidebar.cursorIndex + 1); return
+    case "cursorUp": sidebar.cursorIndex = Math.max(0, sidebar.cursorIndex - 1); return
+    // The sheet advertises g and G as first and last row, and the rail is a cursored list too, so
+    // they answered nothing here while every other cursor key worked.
+    case "cursorFirst": sidebar.cursorIndex = 0; return
+    case "cursorLast": sidebar.cursorIndex = Math.max(0, sidebar.entries.length - 1); return
+    // activate(), not opened(path), so a Network entry mounts first and focus follows the open into the folder.
+    case "open":
+        if (sidebar.entries.length === 0) return
+        // Focus follows the open only when it lands (ui/PaneRail.qml), since a mount or a share's gio info can take long or never answer.
+        sidebar.focusOnOpen = true
+        sidebar.activate(sidebar.cursorIndex)
+        return
+    // Focus.LIST's own value, written out because importing Focus.js back would be a cycle.
+    case "escape":
+        if (root.statusBar && root.statusBar.escapePressed()) return
+        root.focusView = "list"; return
+    case "addNetwork": sidebar.addRequested(); return
+    // Favorites are not offered: Sidebar.startRename ignores an index outside the Network group.
+    case "rename": sidebar.startRename(sidebar.cursorIndex); return
+    // Eject and Unmount are menu rows, so this opens the menu rather than inventing a second route.
+    case "menu":
+        if (sidebar.entries[sidebar.cursorIndex] && sidebar.entries[sidebar.cursorIndex].kind === "trash") sidebar.openCursorMenu()
+        else Mounts.raiseMenu(root, sidebar)
+        return
+    case "eject": Eject.release(root, sidebar, true); return
+    }
+}