flea-qml 0.0.0-stage → 0.2.0

package/ui/js/RailMenu.js

@@ -0,0 +1,133 @@
+.pragma library
+
+.import "Menu.js" as Menu
+.import "Mounts.js" as Mounts
+.import "PlaceMenu.js" as PlaceMenu
+
+// The rail's own menu: which one a row opens, what a chosen row does, and the Edit that rewrites a
+// saved place. Split out of ui/js/Mounts.js, which parses and identifies rail rows and nothing more.
+
+// Which menu a rail row opens, and with which handle: the trash and a favourite carry their own,
+// every other row is a mount or a share and ui/js/Menu.js never sees it. Split out of ui/Sidebar.qml,
+// which sits at its recorded line count, and this file already decides what a row offers.
+function railMenuFor(sidebar, entry, scenePosition, hidden) {
+    if (entry.kind === "trash") {
+        sidebar.menu.openForRail("trash", Menu.trashEntries(sidebar.trashCount, false), scenePosition)
+        return
+    }
+    // MenuAdditions rule 3: a Places or Favorites row opens the folder menu for its path while that
+    // Extras row is on, and with it off a favourite keeps the one Remove it has offered since 0.2.1.
+    if (entry.kind === "favourite" || entry.kind === "home") {
+        var index = entry.kind === "favourite" ? entry.favouriteIndex : -1
+        var rows = PlaceMenu.entries(entry, index, hidden)
+        if (rows.length > 0) {
+            sidebar.menu.openForRail(PlaceMenu.key(entry, index), rows, scenePosition)
+            return
+        }
+        if (entry.kind !== "favourite")
+            return
+        // The Places menu is off: the one row is INVENTORY's own Remove from Favorites, never a bare Remove.
+        sidebar.menu.openForRail("favourite:" + entry.favouriteIndex + ":" + JSON.stringify(entry.original),
+            Menu.railEntries({ group: "favourite", kind: "favourite" }), scenePosition)
+        return
+    }
+    sidebar.menu.openForRail(Mounts.railKey(entry), Mounts.rowMenu(entry), scenePosition)
+}
+
+// Issue 21: Edit opens D11's dialog over the saved place, and the address that finally mounts is
+// written back over that place's own line, so a share gio could not reach is corrected where it sits.
+function editPlace(sidebar, share) {
+    var entry = sidebar.networkEntries[share]
+    if (!entry)
+        return
+    sidebar.editingPlace = Mounts.normalize(entry.uri)
+    sidebar.editingRequest = ""
+    sidebar.editRequested(entry.uri, entry.label, "", "Edit this address, then connect and save.", false, sidebar.navigationPane)
+}
+
+// Each attempt this dialog makes, so a mount that was already in flight when the rail armed cannot
+// answer for the edit: a refusal only re-binds, because the next attempt is the one that counts.
+function placeSubmitted(sidebar, requestId) {
+    if (sidebar.editingPlace.length > 0)
+        sidebar.editingRequest = requestId
+}
+
+// The answer to that edit: a refused connect keeps the arm, because correcting an address gio could
+// not reach is what the dialog stays open for; ui/shell.qml disarms it when that dialog closes.
+function placeSaved(sidebar, mounts, requestId, uri, success) {
+    if (!success || sidebar.editingPlace.length === 0 || requestId !== sidebar.editingRequest)
+        return
+    var was = sidebar.editingPlace
+    sidebar.editingPlace = ""
+    sidebar.editingRequest = ""
+    if (Mounts.normalize(uri) !== was)
+        mounts.replacePlace(was)
+}
+
+// The rail menu's chosen row, handed the row's key rather than its position: the rail rebuilds on
+// a five second poll, so the index the menu opened over can name a different row by now. A key
+// that no longer names a row does nothing, because the row it named has left the rail already.
+// Both Services re-check the kind themselves; this only resolves which row was meant, and the rail
+// itself owns the two rows that need no mount at all.
+function release(action, key, devices, mounts, sidebar) {
+    // Flash image hands the pane the volume's whole disk to match against its own drive list.
+    if (action === "flashImage") {
+        var at = Mounts.rowByKey(sidebar.deviceEntries, key)
+        if (at >= 0 && sidebar.navigationPane)
+            sidebar.navigationPane.openFlashDrive(sidebar.deviceEntries[at].device)
+        return
+    }
+    if (action === "eject") {
+        var volume = Mounts.rowByKey(sidebar.deviceEntries, key)
+        if (volume >= 0)
+            devices.eject(volume)
+        return
+    }
+    // RailAdditions rule 2: Mount and Open are the row's own activation, which mounts when it has to
+    // and opens either way, so the menu row and Enter cannot drift apart.
+    if (action === "mountVolume" || action === "unmountVolume" || action === "unlockVolume") {
+        var row = Mounts.rowByKey(sidebar.deviceEntries, key)
+        if (row < 0)
+            return
+        if (action === "unmountVolume") devices.unmount(row)
+        else devices.activate(row)
+        return
+    }
+    // Open is the row's own click: a volume or phone mounts and opens, a share resolves and opens.
+    if (action === "open") {
+        var volume = Mounts.rowByKey(sidebar.deviceEntries, key)
+        if (volume >= 0) {
+            devices.activate(volume)
+            return
+        }
+        var at = Mounts.rowByKey(sidebar.networkEntries, key)
+        if (at >= 0) {
+            mounts.activate(at, sidebar.navigationPane)
+            return
+        }
+        sidebar.openPhone(key)
+        return
+    }
+    // The phone Service is the sidebar's own child, so the sidebar resolves the key against it; a
+    // phone unmounts rather than ejects, because gvfs answers can_eject=0 for the MTP monitor.
+    if (action === "unmountPhone") {
+        sidebar.releasePhone(key)
+        return
+    }
+    // Mount is the row's own activation, which mounts when it has to and opens either way.
+    if (action === "mountPhone") {
+        sidebar.openPhone(key)
+        return
+    }
+    var share = Mounts.rowByKey(sidebar.networkEntries, key)
+    if (share < 0)
+        return
+    if (action === "unmount")
+        mounts.unmount(share)
+    else if (action === "editPlace")
+        editPlace(sidebar, share)
+    else if (action === "rename")
+        sidebar.startRename(sidebar.placesEntries.length + share)
+    else if (action === "remove")
+        mounts.forget(sidebar.networkEntries[share].uri)
+}

package/ui/js/Recent.js

@@ -0,0 +1,135 @@
+.pragma library
+.import "Format.js" as Format
+
+// The desktop's own history, read and never written; every bookmark is untrusted input.
+
+// The freedesktop recent file, and where XDG_DATA_HOME defaults to when the session did not set it.
+var HISTORY_LEAF = "recently-used.xbel"
+var DEFAULT_DATA_HOME = "/.local/share"
+
+// The output loop stops here and hands the rail the newest LIMIT paths.
+var LIMIT = 500
+
+// Sample input: ("/home/gm/.local/share", "/home/gm") and ("", "/home/gm"); an XDG_DATA_HOME that
+// is not an absolute path is not a data home, so the default answers for it too.
+function historyPath(dataHome, home) {
+    var root = String(dataHome || "")
+    if (root.charAt(0) !== "/") {
+        root = String(home || "") + DEFAULT_DATA_HOME
+    }
+    return root.replace(/\/+$/, "") + "/" + HISTORY_LEAF
+}
+
+// Sample input: "file:///home/gm/a%20b.png" becomes "/home/gm/a b.png".
+// Refuses non-file schemes, foreign authorities, bad escapes and control characters.
+function pathOf(href) {
+    var raw = String(href || "")
+    if (raw.substring(0, 7).toLowerCase() !== "file://") {
+        return ""
+    }
+    var rest = raw.substring(7)
+    // The authority is everything before the path's own leading slash.
+    var cut = rest.indexOf("/")
+    if (cut < 0) {
+        return ""
+    }
+    var authority = rest.substring(0, cut).toLowerCase()
+    if (authority.length > 0 && authority !== "localhost") {
+        return ""
+    }
+    var decoded = ""
+    try {
+        decoded = decodeURIComponent(rest.substring(cut))
+    } catch (e) {
+        return ""
+    }
+    if (decoded.charAt(0) !== "/" || decoded === "/") {
+        return ""
+    }
+    // A control character cannot appear in a path this window will draw or send back as a URI.
+    if (/[\x00-\x1f\x7f]/.test(decoded)) {
+        return ""
+    }
+    return decoded
+}
+
+// Sample bookmarks: [{ href: "file:///home/gm/a.txt", stamp: "2026-08-30T11:32:04Z" }].
+// Newest first with the stamps kept, so the Used column draws the visit, not the mtime.
+function entries(bookmarks) {
+    var rows = []
+    for (var i = 0; i < bookmarks.length; i++) {
+        var path = pathOf(bookmarks[i].href)
+        if (path.length === 0) {
+            continue
+        }
+        rows.push({ path: path, stamp: String(bookmarks[i].stamp || ""), at: rows.length })
+    }
+    // The file's own order is the tie-break, so two bookmarks sharing a stamp never swap between reads.
+    rows.sort(function (a, b) {
+        if (a.stamp === b.stamp) {
+            return a.at - b.at
+        }
+        return a.stamp < b.stamp ? 1 : -1
+    })
+    var out = []
+    var seen = {}
+    for (var j = 0; j < rows.length && out.length < LIMIT; j++) {
+        if (seen[rows[j].path]) {
+            continue
+        }
+        seen[rows[j].path] = true
+        out.push({ path: rows[j].path, stamp: rows[j].stamp })
+    }
+    return out
+}
+
+// Sample input: "/home/gm/a.txt" names "a.txt" in "/home/gm".
+// The leaf draws as the name and its parent as the caption beside it.
+function nameOf(path) {
+    var text = String(path || "")
+    var cut = text.lastIndexOf("/")
+    return cut < 0 ? text : text.substring(cut + 1)
+}
+
+// Sample input: "home/gm/a.txt" sits in "/home/gm", and "a.txt" in "/".
+function locationOf(path) {
+    var text = String(path || "")
+    if (text.length === 0) {
+        return ""
+    }
+    var cut = text.lastIndexOf("/")
+    if (cut <= 0) {
+        return "/"
+    }
+    var parent = text.substring(0, cut)
+    return parent.charAt(0) === "/" ? parent : "/" + parent
+}
+
+// Sample input: "home/gm/Documents/claude/a.md" under "/home/gm" is "Documents/claude", a file in home "~", outside it absolute.
+function locationUnder(path, home) {
+    var shown = Format.tilde(locationOf(path), String(home || ""))
+    if (shown.indexOf("~/") === 0) {
+        return shown.substring(2)
+    }
+    return shown
+}
+
+// One bounded lookup accompanies the entries; no file stat or extra history read.
+function visits(entries) {
+    var out = {}
+    for (var i = 0; i < entries.length; i++) {
+        var seconds = Date.parse(entries[i].stamp) / 1000
+        out[entries[i].path] = isFinite(seconds) ? seconds : null
+    }
+    return out
+}
+
+// Each asker waits once, and null, the rail pane itself, joins like any other.
+function joinRequesters(current, requester) {
+    var asker = requester || null
+    var seen = current || []
+    if (seen.indexOf(asker) >= 0) {
+        return seen
+    }
+    return seen.concat([asker])
+}

package/ui/js/RecentMode.js

@@ -0,0 +1,156 @@
+.pragma library
+
+.import "BackReturn.js" as BackReturn
+.import "DirSizes.js" as DirSizes
+.import "Nav.js" as Nav
+.import "Search.js" as Search
+.import "Thumbs.js" as Thumbs
+
+// Recent lists the history's paths under "/", newest first via mtime desc.
+var OFF = ""
+var RESULTS = "results"
+
+// One refusal for both paste routes: the menu reaches past key dispatch, so it shares this.
+function refusePaste(pane) {
+    if (pane.recentMode.length > 0) {
+        pane.message((pane.recentMode === "trash" ? "Trash" : "Recent") + " is a collection. Open a folder before pasting", false)
+        return true
+    }
+    return false
+}
+
+// Open keeps where the pane stood and asks the history's paths after the bounded jump; spanning mounts leaves fsinfo unknown.
+function run(pane, paths, visits, mode) {
+    // The history takes the place of a listing out; its answer is dropped by the folder it names, see ui/js/Swap.js onListed.
+    if (pane.listInFlight) {
+        pane.swap.stopWaiting()
+        BackReturn.dropOwed(pane)
+    }
+    // The standing order is kept for the way back, not the mtime it replaces.
+    if (pane.recentMode.length === 0 && pane.backend) {
+        pane.recentSortBy = pane.backend.sortBy
+        pane.recentSortDesc = pane.backend.sortDesc === true
+    }
+    if (pane.recentFrom.length === 0) {
+        pane.recentFrom = Nav.place(pane)
+    }
+    // A history replaces the standing listing, so a live session closes first.
+    Search.leaveWalk(pane)
+    // The paths this listing stands on, so a refresh with the rail hidden still re-asks them.
+    pane.recentPaths = paths || []
+    pane.recentVisits = visits || ({})
+    pane.listInFlight = true
+    pane.listedSeen = false
+    pane.path = "/"
+    pane.recentMode = mode || RESULTS
+    pane.listingPath = "/"
+    pane.storageClass = ""
+    // Recent rows span filesystems, so the Tags row stays and the backend refuses each filesystem that cannot hold tags by name.
+    pane.canTag = true
+    pane.fsName = ""
+    pane.fsFree = 0
+    // Recent asks for no figures, so its empty slot is an answer.
+    pane.fsAnswered = true
+    var ask = {}
+    // A walk closed above keeps its rows and its strip until the history lands.
+    if (pane.searchLeaving === true) ask.holdWalk = true
+    Nav.holdOrForget(pane, ask)
+    pane.appliedListingPreferences = pane.listingPreferences
+    if (pane.recentMode === "trash") pane.backend.send({c:"listtrash",first:pane.windowSize})
+    else pane.backend.listPaths(pane.recentPaths, pane.windowSize)
+    // A deep anchored refresh asks its window only after the history's listpaths request.
+    var anchor = pane.wire ? pane.wire.anchor : null
+    if (anchor && anchor.path === pane.path && anchor.start > 0)
+        pane.backend.window(anchor.start, pane.windowSize)
+    pane.backend.sortBy = "mtime"
+    pane.backend.sortDesc = true
+}
+
+// Leaving Recent re-lists the folder it was opened over, pushing no history entry.
+function close(pane) {
+    var back = pane.recentFrom.length > 0 ? pane.recentFrom : "/"
+    leave(pane)
+    pane.openWithoutHistory(back, { supersede: true })
+}
+
+// The order run() replaced, handed back before the folder re-lists.
+function restoreSort(pane) {
+    if (pane.backend && typeof pane.recentSortBy === "string" && pane.recentSortBy.length > 0) {
+        pane.backend.sortBy = pane.recentSortBy
+        pane.backend.sortDesc = pane.recentSortDesc === true
+    }
+    pane.recentSortBy = ""
+    pane.recentSortDesc = false
+}
+
+// Every way out of Recent, a plain hop, Escape, a tab switch and reveal, leaves through this one step, so each restores the same order.
+function leave(pane) {
+    if (pane.recentMode.length > 0) {
+        restoreSort(pane)
+    }
+    pane.recentMode = OFF
+    pane.recentFrom = ""
+    pane.recentPaths = []
+    pane.recentVisits = ({})
+}
+
+// Refresh re-reads history after an operation, never re-listing "/" over it; an unloaded sidebar re-asks the standing paths.
+function refresh(pane, selectPath) {
+    // A re-ask of the history is no navigation, so it never takes the place of a listing out.
+    if (pane.listInFlight) {
+        pane.message("A directory is already loading.", false)
+        return
+    }
+    pane.pendingSelect = selectPath ? selectPath : ""
+    pane.pendingMenu = false
+    if (pane.recentMode === "trash") { run(pane, [], {}, "trash"); return }
+    if (pane.sidebar) {
+        pane.sidebar.readRecent(pane)
+        return
+    }
+    run(pane, pane.recentPaths || [], pane.recentVisits)
+}
+
+// Only the held viewport rows gain a Used stamp; filesystem metadata remains intact.
+function stampRows(pane, rows) {
+    if (pane.recentMode !== RESULTS) return rows
+    return rows.map(function (row) {
+        var visit = (pane.recentVisits || {})[pane.join(pane.path, row.n)]
+        return Object.assign({}, row, { used: visit === undefined ? null : visit })
+    })
+}
+
+// The folder a tab records on a history, "" elsewhere, so it lands where it stood.
+function restingPath(pane) {
+    return pane.recentMode.length > 0 && pane.recentFrom.length > 0 ? pane.recentFrom : ""
+}
+
+// A tab switch drops the mode and says whether it dropped one.
+function dropOverlay(pane) {
+    if (pane.recentMode.length === 0) {
+        return false
+    }
+    leave(pane)
+    return true
+}
+
+// o opens the row's own folder; Enter opens the file itself, so the two cannot disagree.
+function reveal(pane) {
+    if (pane.listInFlight) {
+        pane.message("A directory is already loading.", false)
+        return
+    }
+    var row = pane.rowFor(pane.cursorIndex)
+    if (!row) {
+        return
+    }
+    var full = pane.join(pane.path, row.n)
+    var cut = full.lastIndexOf("/")
+    if (cut < 0) {
+        return
+    }
+    var dir = cut === 0 ? "/" : full.substring(0, cut)
+    leave(pane)
+    pane.pendingSelect = full
+    pane.openWithoutHistory(dir)
+}

package/ui/js/Reload.js

@@ -0,0 +1,60 @@
+.pragma library
+
+.import "Anchor.js" as Anchor
+.import "Format.js" as Format
+.import "Nav.js" as Nav
+.import "Swap.js" as Swap
+
+// The status line a reload answers with, one whole sentence per count, each filled by Format.fill.
+var WORDS = {
+    one: "Reloaded · 1 row changed",
+    many: "Reloaded · %1 rows changed"
+}
+
+// Sample input: 2 is "Reloaded · 2 rows changed", 1 is "Reloaded · 1 row changed".
+function line(changed) {
+    return changed === 1 ? WORDS.one : Format.fill(WORDS.many, Format.count(changed))
+}
+
+// A listing out refuses itself and a search owns its header, so both go quiet.
+function begin(pane, wire) {
+    if (Nav.loading(pane)) {
+        pane.message(Swap.LOADING, false)
+        return false
+    }
+    if (pane.searchMode.length > 0)
+        return false
+    // A reload past the wait retries the folder waited on, which a first listing has not yet made the pane's path.
+    var waitedOn = pane.listingState === "waiting" ? Nav.trimSlash(pane.listingPath || "") : ""
+    // A reload that lists lets a waiting listing go first, the way ui/Pane.qml openWithoutHistory does.
+    Anchor.clearWaiting(pane)
+    // Recent re-reads its history rather than re-listing its base, which is the root.
+    if (pane.recentMode.length > 0) {
+        pane.refresh("")
+    } else {
+        if (waitedOn.length > 0 && waitedOn !== pane.path) {
+            pane.openWithoutHistory(waitedOn)
+            return true
+        }
+        wire.anchor = Anchor.watched(pane, true, pane.anchorRowHeight)
+    }
+    // Set after the anchored re-read above, because opening the listing clears it first.
+    pane.reloadFrom = pane.total
+    pane.reloadChanged = -1
+    return true
+}
+
+// Runs on every rows reply; only a manual reload owes a notice, said whenever rows changed.
+function landed(pane) {
+    if (pane.reloadFrom < 0)
+        return ""
+    // The backend counts added plus removed on a same-path re-list; a missing one falls back to net delta.
+    var changed = pane.reloadChanged >= 0 ? pane.reloadChanged : Math.abs(pane.total - pane.reloadFrom)
+    pane.reloadFrom = -1
+    pane.reloadChanged = -1
+    if (changed === 0)
+        return ""
+    var text = line(changed)
+    pane.message(text, false)
+    return text
+}

package/ui/js/Renderer.js

@@ -0,0 +1,9 @@
+.pragma library
+
+// Only src/gui.rs's own implicit Vulkan choice may retry, and the argv is what it relaunches Flea with.
+// Sample input: ("vulkan", "1", "/usr/bin/flea"), and ("opengl", "1", "/usr/bin/flea") for a launch that may not.
+function fallbackCommand(backend, automatic, bin) {
+    if (backend !== "vulkan" || automatic !== "1")
+        return null
+    return ["/usr/bin/env", "QSG_RHI_BACKEND=opengl", bin || "flea", "--gui"]
+}

package/ui/js/RunFile.js

@@ -0,0 +1,143 @@
+.pragma library
+
+.import "Format.js" as Format
+.import "Anchor.js" as Anchor
+.import "Icons.js" as Icons
+
+// The run card's own decisions, the way ui/js/Collide.js holds its card's: which buttons a kind draws, where the ring opens, and how the keys walk them.
+
+var LABELS = { cancel: "Cancel", text: "Open as text", run: "Run", terminal: "Run in terminal" }
+// Run in terminal is the default because it shows the output; a desktop handler, where one is named, is offered first and takes it instead.
+var START = "terminal"
+var KINDS = ["script", "elf", "appimage"]
+var KIND_LABELS = { script: "Shell script", elf: "Program", appimage: "AppImage application bundle" }
+
+// The board's own default: the handler where the desktop names one for an AppImage, Run in terminal everywhere else, and the primary frame sits there.
+function defaultButton(kind, hasHandler) {
+    if (kind === "appimage" && hasHandler === true)
+        return "handler"
+    return START
+}
+
+// Left to right, the board's own order, text a script's alone since a binary is not text; the board's tweak focus = terminal | run | text | cancel names the opening ring.
+function buttonsFor(kind, hasHandler) {
+    var out = ["cancel"]
+    if (kind === "script")
+        out.push("text")
+    if (kind === "appimage" && hasHandler === true)
+        out.push("handler")
+    return out.concat(["run", "terminal"])
+}
+
+// A tweak naming a button the card did not draw falls back to the default, never to nothing.
+function startFocus(buttons, tweak) {
+    if (buttons.indexOf(tweak) >= 0)
+        return tweak
+    var fallback = defaultButton(buttons.indexOf("handler") >= 0 ? "appimage" : "script", buttons.indexOf("handler") >= 0)
+    return buttons.indexOf(fallback) >= 0 ? fallback : buttons[0]
+}
+
+// h and l stop at the ends like TrashConfirm's pair; Tab and Backtab come round.
+function moved(buttons, focus, key, modifiers) {
+    var at = buttons.indexOf(focus)
+    if (at < 0)
+        at = buttons.indexOf(defaultButton(buttons.indexOf("handler") >= 0 ? "appimage" : "script", buttons.indexOf("handler") >= 0))
+    if (at < 0)
+        at = 0
+    var last = buttons.length - 1
+    if (key === Qt.Key_H || key === Qt.Key_Left)
+        return buttons[Math.max(0, at - 1)]
+    if (key === Qt.Key_L || key === Qt.Key_Right)
+        return buttons[Math.min(last, at + 1)]
+    // Shift+Tab reaches a Keys handler as Backtab or as Tab with Shift held, depending on the input path.
+    if (key === Qt.Key_Backtab || key === Qt.Key_Tab && (modifiers & Qt.ShiftModifier))
+        return buttons[(at + last) % buttons.length]
+    if (key === Qt.Key_Tab)
+        return buttons[(at + 1) % buttons.length]
+    return buttons[at]
+}
+
+// The handler button is the application's own Name= from its desktop entry, one whole string.
+function labelFor(button, handlerName) {
+    return button === "handler" ? String(handlerName) : LABELS[button]
+}
+
+function activates(key) {
+    return key === Qt.Key_Return || key === Qt.Key_Enter || key === Qt.Key_Space
+}
+
+// The name row's own mark: the board draws the code glyph beside a script, and a binary takes the mark its listed row draws.
+var KIND_GLYPHS = { script: "code", elf: "terminal", appimage: "app-window" }
+
+function glyphFor(kind, listed) {
+    if (kind !== "script" && listed)
+        return listed
+    return KIND_GLYPHS[kind] || KIND_GLYPHS.elf
+}
+
+// The mark the listing draws for the row the ask was opened from, or "" when no listed row names that path.
+function listedGlyph(pane, path) {
+    if (!pane || !pane.rows || typeof pane.rowFor !== "function")
+        return ""
+    var at = Anchor.matchListed(pane, path)
+    var row = at >= 0 ? pane.rowFor(at) : null
+    return row ? Icons.glyphForRow(row.i, row.p) : ""
+}
+
+// Every user-facing string is one whole template filled by Format.fill, never fragments joined with +.
+
+// The card's title names the program; the name row carries its kind and its size.
+var TITLE_PROGRAM = "%1 is a program"
+function titleFor(name) {
+    return Format.fill(TITLE_PROGRAM, escapeName(name))
+}
+
+// R4: control and bidi characters are shown escaped, never raw, and a clean name passes through byte for byte.
+var SPOOFED = /[\0-\x1F\x7F-\x9F\u061C\u200E\u200F\u2028\u2029\u202A-\u202E\u2066-\u2069\uFEFF]/g
+function escapeName(name) {
+    return String(name).replace(SPOOFED, function (ch) {
+        var point = ch.codePointAt(0).toString(16).toUpperCase()
+        return "<U+" + ("0000" + point).slice(-4) + ">"
+    })
+}
+
+var SUBTITLE_PROGRAM = "%1 · %2"
+function subtitleFor(kind, bytes) {
+    return Format.fill(SUBTITLE_PROGRAM, KIND_LABELS[kind] || KIND_LABELS.elf, Format.size(bytes))
+}
+
+function leafOf(path) {
+    var text = String(path)
+    var cut = text.lastIndexOf("/")
+    return cut < 0 ? text : text.substring(cut + 1)
+}
+
+// Sample input: {"ask":"run","kind":"script","size":9420,"handlerId":"","handlerName":"","dev":"8","ino":"9","mtimeS":11,"mtimeNs":12,"target":"/real/tool.sh"}.
+function parseAsk(text) {
+    var message = null
+    try {
+        message = JSON.parse(String(text))
+    } catch (e) {
+        return null
+    }
+    if (!message || message.ask !== "run" || KINDS.indexOf(message.kind) < 0)
+        return null
+    if (typeof message.dev !== "string" || typeof message.ino !== "string" || typeof message.target !== "string")
+        return null
+    var handlerId = typeof message.handlerId === "string" ? message.handlerId : ""
+    var handlerName = typeof message.handlerName === "string" ? message.handlerName : ""
+    return { kind: message.kind, size: Number(message.size) || 0,
+             handlerId: handlerId, handlerName: handlerName,
+             hasHandler: handlerId.length > 0 && handlerName.trim().length > 0,
+             dev: message.dev, ino: message.ino,
+             mtimeS: Number(message.mtimeS) || 0, mtimeNs: Number(message.mtimeNs) || 0,
+             target: message.target }
+}
+
+// The card's choice on the path it asked about, carrying the R3 identity the ask named, and the handler the id the card drew.
+function choose(pane, card, choice) {
+    if (choice === "run") card.run(card.path, card.dev, card.ino, card.size, card.mtimeS, card.mtimeNs)
+    else if (choice === "terminal") card.runTerminal(card.path, card.dev, card.ino, card.size, card.mtimeS, card.mtimeNs)
+    else if (choice === "text") card.openText(card.path, pane)
+    else if (choice === "handler") card.openHandler(card.path, card.handlerId, card.dev, card.ino, card.size, card.mtimeS, card.mtimeNs)
+}

package/ui/js/Scripts.js

@@ -0,0 +1,28 @@
+.pragma library
+
+.import "Format.js" as Format
+
+// Whole sentences with "%1" for a value, filled by fill so each translates as one.
+var WORDS = {
+    exited: "%1 exited with status %2"
+}
+
+// MenuAdditions rule 2's own reading: what find printed becomes the submenu's rows, sorted by name,
+// each label the file name without its extension. Sample input, one name a line:
+//   convert-to-webp
+//   ocr.sh
+function parse(text, directory) {
+    var names = String(text || "").split("\n").filter(function (name) { return name.trim().length > 0 })
+    names.sort()
+    return names.map(function (name) {
+        var trimmed = name.trim()
+        var dot = trimmed.lastIndexOf(".")
+        return { id: trimmed, label: dot > 0 ? trimmed.substring(0, dot) : trimmed, path: directory + "/" + trimmed }
+    })
+}
+
+// The script's own report: its last stderr line, or the status it exited with when it said nothing.
+function failure(name, stderr, code) {
+    var lines = String(stderr || "").split("\n").filter(function (line) { return line.trim().length > 0 })
+    return lines.length > 0 ? name + " · " + lines[lines.length - 1].trim() : Format.fill(WORDS.exited, name, code)
+}