flea-qml 0.0.0-stage → 0.1.0

package/ui/js/GridNames.js

@@ -0,0 +1,153 @@
+.pragma library
+.import "Format.js" as Format
+.import "Match.js" as Match
+
+// Grid-only captions; GridTile loads this, Row and ColumnRow never do.
+// Sample input: gridCaption("screenshot-2026-08-30-final-review-for-gm-after-the-bench-v3.png", 16, 2) answers "screenshot-2026-\n…he-bench-v3.png".
+
+// A caption break stays behind a separator, so a word is never split when a break fits.
+var CAPTION_BREAKS = " -_."
+
+function isBreakAfter(ch) {
+    return CAPTION_BREAKS.indexOf(ch) >= 0
+}
+
+// Cells of the caption's last line, so a mark sits past the glyphs it follows.
+// Sample input: lastLineCells("ab\nc🎉") is 3.
+function lastLineCells(text) {
+    var s = String(text)
+    if (Format.isFastText(s)) return s.length - s.lastIndexOf("\n") - 1
+    return cellsOf(Format.charsOf(s.split("\n").pop()))
+}
+
+// The extension is the last dot's tail, so the last line can keep it whole; a leading dot names a dotfile, not an extension.
+function extensionLength(chars) {
+    var dot = -1
+    for (var i = chars.length - 1; i > 0; i--) {
+        if (chars[i] === ".") {
+            dot = i
+            break
+        }
+    }
+    if (dot < 0 || dot === chars.length - 1)
+        return 0
+    return chars.length - dot
+}
+
+// Elides a char array down to this many cells, keeping a one-line extension whole on the tail.
+function elideChars(chars, capacity, perLine) {
+    return elideCore(Format.storeOf(chars), capacity, perLine)
+}
+
+// The head and tail an elide keeps: the head takes the odd cell, the tail keeps a one-line extension.
+function elideSplit(capacity, ext, extCells, perLine) {
+    var head = Math.ceil((capacity - 1) / 2), tail = Math.floor((capacity - 1) / 2)
+    // An extension longer than one line, or with no room for the mark beside it, cannot stay whole.
+    if (ext > 0 && extCells <= perLine && extCells + 1 <= capacity) {
+        tail = Math.max(extCells, tail)
+        head = capacity - 1 - tail
+    }
+    return [head, tail]
+}
+
+// One elide for both stores: elements for the wrap behind an array, pieces for the join behind a string.
+function elideCore(st, capacity, perLine) {
+    if (capacity <= 1) return ["…"]
+    if (Format.rangeCells(st, 0, st.n) <= capacity) return st.widths === null ? [st.seq] : st.seq.slice(0)
+    var ext = extensionLength(st.seq)
+    var split = elideSplit(capacity, ext, ext > 0 ? Format.rangeCells(st, st.n - ext, st.n) : 0, perLine)
+    var h = Format.spanFrom(st, 0, split[0]), t = Format.tailSpan(st, split[1])
+    if (st.widths === null) return [Format.pieceOf(st, 0, h), "…", Format.pieceOf(st, st.n - t, st.n)]
+    return st.seq.slice(0, h).concat(["…"], st.seq.slice(st.n - t))
+}
+
+// Wraps a char array into at most count lines of perLine cells, breaking after the last separator that still leaves the rest fitting.
+function wrapChars(chars, perLine, count) {
+    return wrapCore(Format.storeOf(chars), perLine, count)
+}
+
+// The break a line takes: the last separator whose rest still fits, the extension dot losing to any earlier one.
+function breakCut(st, far, pos, left, perLine, extDot) {
+    var cut = -1, extCut = -1
+    for (var i = far - 1; i > pos; i--) {
+        if (!isBreakAfter(st.seq[i]) || Format.rangeCells(st, i + 1, st.n) > (left - 1) * perLine) continue
+        if (i === extDot) { extCut = i + 1; continue }
+        cut = i + 1; break
+    }
+    return cut >= 0 ? cut : (extCut >= 0 ? extCut : far)
+}
+
+// One wrap for both stores: lines of pieces, every range counted once off the layout.
+function wrapCore(st, perLine, count) {
+    var out = [], pos = 0
+    // The extension's own dot, so a break there never wins while an earlier separator fits.
+    var extDot = st.n - extensionLength(st.seq)
+    for (var ln = 0; ln < count && pos < st.n; ln++) {
+        var left = count - ln
+        if (Format.rangeCells(st, pos, st.n) <= perLine) { out.push(Format.pieceOf(st, pos, st.n)); break }
+        if (ln === count - 1) { out.push(Format.pieceOf(st, pos, pos + Format.spanFrom(st, pos, perLine))); break }
+        var far = pos + Format.spanFrom(st, pos, perLine)
+        if (far <= pos) far = pos + 1
+        var cut = breakCut(st, far, pos, left, perLine, extDot)
+        out.push(Format.pieceOf(st, pos, cut))
+        pos = cut
+    }
+    return out
+}
+
+// The caption Flea hands to Text already holds its line breaks, so Qt never wraps.
+// Sample input: gridCaption("screenshot-2026-08-30-final-review-for-gm-after-the-bench-v3.png", 16, 2) answers "screenshot-2026-\n…he-bench-v3.png".
+function gridCaption(name, perLine, lines) {
+    var text = String(name), per = Math.floor(perLine), count = Math.floor(lines)
+    // A dead or non-finite width budgets nothing: hand Qt the whole name and let ElideRight say so.
+    if (!isFinite(per) || !isFinite(count) || !(per >= 1) || !(count >= 1)) return text
+    // One scan serves the fit check and the store below, so a fitting fast name builds nothing.
+    var isFast = Format.isFastText(text)
+    var capacity = per * count
+    // A fast name counts one cell a char, so one fitting line needs no elide and no wrap.
+    // A one-cell caption still elides below, so the early return keeps that mark.
+    if (isFast && capacity > 1 && text.length <= per) return text
+    var st = isFast ? Format.fastStoreOf(text) : Format.storeOf(Format.charsOf(text))
+    if (st.n === 0) return text
+    // A wide glyph never straddles a line and wastes a cell, so elide until Flea's own wrap holds every char.
+    if (st.widths === null) {
+        var fast = elideCore(st, capacity, per).join("")
+        while (capacity > 1 && wrapCore(Format.fastStoreOf(fast), per, count).join("") !== fast)
+            fast = elideCore(st, --capacity, per).join("")
+        return wrapCore(Format.fastStoreOf(fast), per, count).join("\n")
+    }
+    var shown = elideCore(st, capacity, per)
+    while (capacity > 1 && wrapCore(Format.storeOf(shown), per, count).join("") !== shown.join(""))
+        shown = elideCore(st, --capacity, per)
+    return wrapCore(Format.storeOf(shown), per, count).join("\n")
+}
+
+// The match run per drawn caption line, picked by Match.run in the caption without its breaks; trailing blanks lie past the width Qt centres a line by, so they take no mark.
+// Sample input: captionMarks("appl\nication.log", "PLIC") answers [{line: 0, before: "ap", run: "pl", centred: "appl"}, {line: 1, before: "", run: "ic", centred: "ication.log"}].
+function captionMarks(caption, query) {
+    var lines = String(caption).split("\n"), out = []
+    var run = Match.run(lines.join(""), query)
+    for (var i = 0, pos = 0; run.start >= 0 && i < lines.length; pos += lines[i].length, i++) {
+        var centred = lines[i].replace(/\s+$/, "")
+        var from = Math.max(run.start, pos) - pos, to = Math.min(run.start + run.length, pos + centred.length) - pos
+        if (from < to)
+            out.push({ line: i, before: centred.substring(0, from), run: centred.substring(from, to), centred: centred })
+    }
+    return out
+}
+
+// Array-cell helpers over the common store, kept beside the Grid fits that read them.
+// Cells a char array paints.
+function cellsOf(chars) {
+    return Format.rangeCells(Format.storeOf(chars), 0, chars.length)
+}
+
+// A head that fits in this many cells, never splitting a code point.
+function headByCells(chars, budget) {
+    return chars.slice(0, Format.spanFrom(Format.storeOf(chars), 0, budget))
+}
+
+// A tail that fits in this many cells, never splitting a code point.
+function tailByCells(chars, budget) {
+    return chars.slice(chars.length - Format.tailSpan(Format.storeOf(chars), budget))
+}

package/ui/js/GvfsBridge.js

@@ -0,0 +1,200 @@
+.pragma library
+
+.import "Format.js" as Format
+
+// Phones and shares open through the GVFS FUSE bridge, and Flea starts it the way gvfsd
+// does when the folder is not serving yet. The QML service owns the processes and the three
+// timers; this module owns every decision, so tests/js/gvfsbridge.js pins each one with no
+// process and no clock. An action is what the service executes next: check (test -d the
+// folder), checkFile (test -e it), start (run gvfsd-fuse once, detached), classify (test -d
+// it once it is served), ready (open the folder, or hand a file to the opener), show (the
+// Starting line), fail (the board's error line) or refuse (busy).
+//
+// The start is detached: closing the rail or the chooser never takes gvfsd-fuse down with it,
+// so no exit status ever reaches the board and the folder poll's own deadline is the failure
+// signal. The check stays a helper process rather than a backend peek, an order of magnitude
+// slower per check in one headless sample (sub-millisecond both) but bounded: a wedged FUSE
+// path hangs a helper the deadline kills and nothing else. A served path is classified by
+// the kernel too, so a file under a live bridge is ready without any start (I-3) and a
+// directory costs the one check it always did.
+
+// Whole sentences with "%1" for the device or share and "%2" for the reason; the Starting mark follows ui/Pane.qml's stickyStarting signal, never this text.
+var WORDS = {
+    starting: "Opening %1",
+    failed: "%1 could not be opened because a system service did not start · %2"
+}
+
+// The Starting line stands until the service's own 250 ms timer fires, so a bridge that is
+// already coming up never flashes it.
+var STARTING_MS = 250
+// A test costs about half a millisecond, so this bounds the open behind a starting bridge.
+var POLL_MS = 150
+// One deadline for the whole ensure, checking, file-checking, waiting and classifying: a hung
+// helper and a bridge that never serves are the same wait to the watcher, and both end in the
+// board's failure line through onTimeout, once.
+var ENSURE_MS = 15000
+
+function create() {
+    return { phase: "idle", waiter: null, starts: 0 }
+}
+
+// Sample input: "/run/user/1000" answers "/run/user/1000/gvfs", and "" answers the board's
+// own "/run/user/1000/gvfs", because XDG_RUNTIME_DIR is always set in a systemd session.
+function bridgeDir(runtimeDir) {
+    var dir = String(runtimeDir || "")
+    return dir.length > 0 ? dir + "/gvfs" : "/run/user/1000/gvfs"
+}
+
+// Sample input: "/run/user/1000/gvfs/mtp:host=X" needs it, "/home/gm" and the portal's
+// "/run/user/1000/doc/1/file.pdf" do not. The bridge root itself counts, because with the
+// bridge down even it is unserved.
+function needsBridge(path, dir) {
+    var text = String(path || "")
+    var root = String(dir || "")
+    return root.length > 0 && (text === root || text.indexOf(root + "/") === 0)
+}
+
+// Sample input: "Pixel 8" answers "Opening Pixel 8".
+function startingLine(name) {
+    return Format.fill(WORDS.starting, name)
+}
+
+// Sample input: ("Pixel 8", "waiting for the folder timed out") answers the board's
+// failure line word for word.
+function failedLine(name, reason) {
+    return Format.fill(WORDS.failed, name, reason)
+}
+
+// Sample input: ("Pixel 8") answers the reason a wait that outlived ENSURE_MS carries.
+function timeoutReason() {
+    return "waiting for the folder timed out"
+}
+
+// The openShare guard's own refusal, reused so two waiters never start two bridges.
+function busyReason() {
+    return "Another network location is still opening. Try again when it opens"
+}
+
+// Sample input: "" with "/run/user/1000/gvfs/mtp:host=X" answers that leaf.
+function displayName(label, path) {
+    var name = String(label || "")
+    if (name.length > 0)
+        return name
+    var text = String(path || "")
+    var cut = text.lastIndexOf("/")
+    return cut < 0 ? text : text.substring(cut + 1)
+}
+
+// Sample input: "" answers "/usr/lib/gvfsd-fuse", the binary gvfsd spawns on Arch.
+function fuseBin(env) {
+    var bin = String(env || "")
+    return bin.length > 0 ? bin : "/usr/lib/gvfsd-fuse"
+}
+
+// Sample input: ("/usr/lib/gvfsd-fuse", "/run/user/1000/gvfs") answers gvfsd's own spawn,
+// "/usr/lib/gvfsd-fuse /run/user/1000/gvfs -f", measured on minipc.
+function fuseArgv(bin, dir) {
+    return [bin, dir, "-f"]
+}
+
+// Sample input: a ready waiter with isDir true opens the folder, with false hands the
+// file to the opener, so a typed network URL naming a file is never listed as a folder.
+function readyFor(waiter, isDir) {
+    return [{ op: "ready", path: waiter.path, origin: waiter.origin, isDir: isDir !== false }]
+}
+
+function reset(st) {
+    st.phase = "idle"
+    st.waiter = null
+}
+
+// A local folder opens at once and starts nothing; a gvfs folder is checked first.
+function ensure(st, req) {
+    if (!needsBridge(req.path, req.bridgeDir))
+        return readyFor({ path: req.path, origin: req.origin }, true)
+    if (st.phase !== "idle") {
+        if (st.waiter && st.waiter.path === req.path)
+            return []
+        return [{ op: "refuse", text: busyReason(), origin: req.origin }]
+    }
+    st.phase = "checking"
+    st.waiter = { path: req.path, label: displayName(req.label, req.path), origin: req.origin,
+        bridgeDir: req.bridgeDir, fuseBin: fuseBin(req.fuseBin), shown: false }
+    return [{ op: "check", path: req.path }]
+}
+
+// The check answered for a directory: a served one opens, anything else is file-checked
+// before anything starts, because test -d fails for a file under a live bridge too.
+function onChecked(st, dirServed) {
+    if (st.phase !== "checking" || !st.waiter)
+        return []
+    if (dirServed) {
+        var done = readyFor(st.waiter, true)
+        reset(st)
+        return done
+    }
+    st.phase = "checkingFile"
+    return [{ op: "checkFile", path: st.waiter.path }]
+}
+
+// The file check answered: a served file is ready without any start, and only a path that is
+// neither a directory nor anything at all starts the bridge, exactly once per wait.
+function onCheckedFile(st, exists) {
+    if (st.phase !== "checkingFile" || !st.waiter)
+        return []
+    if (exists) {
+        var done = readyFor(st.waiter, false)
+        reset(st)
+        return done
+    }
+    st.phase = "waiting"
+    st.starts += 1
+    return [{ op: "start", argv: fuseArgv(st.waiter.fuseBin, st.waiter.bridgeDir) }]
+}
+
+// The 250 ms timer fired: the Starting line appears only now, and only while waiting.
+function onElapsed(st) {
+    if (st.phase !== "waiting" || !st.waiter || st.waiter.shown)
+        return []
+    st.waiter.shown = true
+    return [{ op: "show", text: startingLine(st.waiter.label), origin: st.waiter.origin }]
+}
+
+// A poll answered: the folder landing is classified before it opens, anything else waits
+// on. The classify is one test -d, so a file the wait started for still lands as a file.
+function onPolled(st, served) {
+    if (st.phase !== "waiting" || !st.waiter)
+        return []
+    if (!served)
+        return []
+    st.phase = "classifying"
+    return [{ op: "classify", path: st.waiter.path }]
+}
+
+// The classify answered for a served path: directories open, files go to the opener.
+function onClassified(st, isDir) {
+    if (st.phase !== "classifying" || !st.waiter)
+        return []
+    var done = readyFor(st.waiter, isDir)
+    reset(st)
+    return done
+}
+
+// The whole-ensure deadline fired: whatever leg was still running ends here, in the board's
+// failure line. The service kills its helper beside this and swallows that helper's own exit,
+// so the line answers once however the race landed.
+function onTimeout(st) {
+    if ((st.phase !== "checking" && st.phase !== "checkingFile" && st.phase !== "waiting"
+            && st.phase !== "classifying") || !st.waiter)
+        return []
+    var failed = [{ op: "fail", text: failedLine(st.waiter.label, timeoutReason()),
+        origin: st.waiter.origin }]
+    reset(st)
+    return failed
+}
+
+// A cancelled wait answers nothing and starts nothing; the caller clears its own line.
+function cancel(st) {
+    reset(st)
+    return []
+}

package/ui/js/HostClipboard.js

@@ -0,0 +1,29 @@
+.pragma library
+
+// All panes share this queue. Clipboard payloads are opaque POSIX-quoted text,
+// including the pair of empty double quotes at each end of a cut, on every OS.
+var queue = Promise.resolve()
+function handle(root, qs, message) {
+    function read() {
+        return qs.readClipboardText ? qs.readClipboardText({ strict: true }) : qs.clipboardText
+    }
+    function write(text) {
+        if (qs.writeClipboardText) return qs.writeClipboardText(text)
+        qs.clipboardText = text
+    }
+    queue = queue.then(function() {
+        if (message.op === "read") return Promise.resolve(read()).then(function(text) { return { text: text } })
+        if (typeof message.text !== "string") throw new Error("Invalid clipboard text")
+        if (message.op === "write") return Promise.resolve(write(message.text)).then(function() { return {} })
+        if (message.op === "clear") return Promise.resolve(read()).then(function(text) {
+            if (text !== message.text) return { cleared: false }
+            return Promise.resolve(write("")).then(function() { return { cleared: true } })
+        })
+        throw new Error("Unknown clipboard operation")
+    }).then(function(answer) {
+        root.send(Object.assign({ c: "clipHostReply", id: message.id, ok: true }, answer))
+    }, function(error) {
+        root.send({ c: "clipHostReply", id: message.id, ok: false, error: String(error.message || error) })
+    }).catch(function(error) { console.warn("Clipboard reply failed: " + error) })
+    return queue
+}

package/ui/js/Icons.js

@@ -0,0 +1,218 @@
+.pragma library
+
+.import "Format.js" as Format
+
+// The backend sends a freedesktop icon name per row; this is the only place Flea maps one to a mark.
+// Counts re-derived 2026-08-31 from /usr/share/mime/generic-icons on this box, see AGENTS.md "Icons in the row":
+// x-office-document 106, package-x-generic 89, application-x-executable 57, text-x-generic 46,
+// image-x-generic 40, x-office-spreadsheet 38, text-x-script 36, font-x-generic 23, x-office-presentation 21,
+// video-x-generic 15, text-html 11, then a tail of five or fewer each.
+var GLYPHS = {
+    "folder": "folder",
+    "inode-directory": "folder",
+    "text-x-generic": "file-text",
+    "text-plain": "file-text",
+    // text-x-script, text-html and application-xml are 49 types a generic file mark would hide.
+    "text-x-script": "code",
+    "text-html": "code",
+    "application-xml": "code",
+    "image-x-generic": "image",
+    "video-x-generic": "film",
+    "audio-x-generic": "music",
+    "package-x-generic": "archive",
+    "font-x-generic": "type",
+    "application-x-executable": "terminal",
+    "application-x-generic": "file",
+    "x-office-document": "file-text",
+    "x-office-spreadsheet": "table",
+    "x-office-presentation": "presentation"
+}
+
+var FALLBACK = "file"
+
+// flea-qml's backend sends an emoji as the row's icon instead of a freedesktop name. Every mark name
+// here is ASCII, so a name holding anything else is an emoji, drawn as itself by Glyph.qml. A keycap
+// such as #️⃣ starts with an ASCII "#", so the whole name is checked, not its first character.
+function isEmoji(name) {
+    return /[^\x00-\x7f]/.test(String(name))
+}
+
+function glyphFor(iconName) {
+    if (isEmoji(iconName))
+        return String(iconName)
+    var g = GLYPHS[String(iconName)]
+    return g ? g : FALLBACK
+}
+
+// A row's mark. The backend resolves a symlink's icon to its target's, so a link to a directory
+// arrives as "folder"; every board draws such a row with the link mark instead, so the mode decides
+// here and the icon name only answers for what the row really is. An emoji already says link or
+// broken link itself.
+function glyphForRow(iconName, mode) {
+    if (isEmoji(iconName))
+        return String(iconName)
+    if (Format.isSymlink(mode))
+        return "symlink"
+    return glyphFor(iconName)
+}
+
+// The sidebar's own set, keyed on the favourite's label (Places.js leaf() or bookmark label),
+// the operator's overnight ask; any bookmark outside this set draws the plain folder mark.
+var SIDEBAR_GLYPHS = {
+    "Home": "house",
+    "Downloads": "download",
+    "Documents": "file-text",
+    "Pictures": "image",
+    "Videos": "film",
+    "Music": "music",
+    "Projects": "folder-git-2"
+}
+
+var SIDEBAR_FALLBACK = "folder"
+
+function sidebarGlyphFor(label) {
+    var g = SIDEBAR_GLYPHS[String(label)]
+    return g ? g : SIDEBAR_FALLBACK
+}
+
+// Lucide-static 1.38.0 geometry, ISC licence, https://github.com/lucide-icons/lucide, one "d"
+// per mark on its native 24 unit grid, recut to the Omarchy edge: baked rounded corners became
+// hard corners, real curves stayed; see AGENTS.md "Lucide path data", "The Omarchy cut".
+var PATHS = {
+    "info": "M12 11v6 M12 7h.01 M22 12a10 10 0 1 1-20 0a10 10 0 1 1 20 0",
+    "shelf": "M21 21H3V3h18v14H7V7h10v6h-6",
+    "pin": "M9 3h6v6l3 3v2H6v-2l3-3z M12 14v7",
+    "star": "M12 2l2.9 6.6 7.1.6-5.4 4.7 1.6 7L12 17.3l-6.2 3.6 1.6-7L2 9.2l7.1-.6z",
+    "globe": "M2 12h20 M12 2a15 15 0 0 1 0 20 M12 2a15 15 0 0 0 0 20 M22 12a10 10 0 1 1-20 0a10 10 0 1 1 20 0",
+
+    "file": "M4 22V2h10l6 6v14H4z M14 2v6h6",
+    "folder": "M2 20V3h6l2 3h12v14H2z",
+    "folders-first": "M2 12V4h6l2 2h12v6H2z M2 17h20 M2 21h20",
+    "file-text": "M4 22V2h10l6 6v14H4z M14 2v6h6 M8 9h2 M8 13h8 M8 17h8",
+    // LanguageMarks' Markdown mark, Flea's cut of dcurtis/markdown-mark (CC0): the frame, the M and the down arrow in one stroke.
+    "markdown": "M2 5h20v14H2z M5.5 15V9l3 3.5 3-3.5v6 M17 9v6 M14.5 12.5 17 15l2.5-2.5",
+    "html": "M4 2h16l-1.5 17L12 22l-6.5-3z M15.5 6.5h-7V11h7v5L12 17.5 8.5 16",
+    "code": "M16 18l6-6-6-6 M8 6l-6 6 6 6",
+    "image": "M3 3h18v18H3z M7 9A2 2 0 1 0 11 9A2 2 0 1 0 7 9Z M21 15l-3-3L6 21",
+    "film": "M3 3h18v18H3z M7 3v18 M3 7.5h4 M3 12h18 M3 16.5h4 M17 3v18 M17 7.5h4 M17 16.5h4",
+    // Note heads squared instead of lucide's circles: the set's brand tell.
+    "music": "M9 18V5l12-2v13 M3 15h6v6H3z M15 13h6v6h-6z",
+    "archive": "M2 3h20v5H2z M4 8v13h16V8 M10 12h4",
+    "type": "M12 4v16 M4 7V4h16v3 M9 20h6",
+    "terminal": "M12 19h8 M4 17l6-6-6-6",
+    "table": "M3 3h18v18H3z M12 3v18 M3 9h18 M3 15h18",
+    "presentation": "M2 3h20 M3 3v13h18V3 M7 21l5-5 5 5",
+    "house": "M3 21V10l9-7 9 7v11h-6v-8H9v8H3z",
+    "download": "M12 15V3 M7 10l5 5 5-5 M3 15v6h18v-6",
+    "folder-git-2": "M18 19a5 5 0 0 1-5-5v8 M9 20H2V3h6l2 2h12v5 M11 12A2 2 0 1 0 15 12A2 2 0 1 0 11 12Z M18 19A2 2 0 1 0 22 19A2 2 0 1 0 18 19Z",
+    // The two near-zero-length lines are lucide's own technique for the rack unit's LED dots; SquareCap draws them as square dots, matching the cut.
+    "server": "M2 2h20v8H2z M2 14h20v8H2z M6 6L6.01 6 M6 18L6.01 18",
+    // The Network group's add mark, replacing a Text "+" the operator read as a Christian cross.
+    "plus": "M5 12h14 M12 5v14",
+    // The picker rail's Recent mark, lucide rotate-ccw, the one SendPicker.html itself draws; the
+    // circle is a real curve and stays, and the arrow head is already square on lucide's own grid.
+    "history": "M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8 M3 3v5h5",
+    // Lucide's hard-drive with its four baked 2 unit corner arcs cut square, which lands the body on
+    // (6,4) (18,4) (22,12) (22,20) (2,20) (2,12); the divider and the two LED dots are lucide's own.
+    "drive": "M6 4h12l4 8v8H2v-8z M2 12h20 M6 16L6.01 16 M10 16L10.01 16",
+    // The DEVICES rail's phone mark, lucide's smartphone with its rx=2 body rect cut square the way
+    // drive's arcs were; the home-button dot is lucide's own near-zero line, drawn as server's are.
+    "smartphone": "M5 2h14v20H5z M12 18L12.01 18",
+    // Its GPhoto2 sibling, per the PhoneMark board: lucide's camera with the four a2 2 body arcs cut
+    // to (2,7) (22,7) (22,20) (2,20), the pentaprism kept, and the lens a genuine circle, cut rule 4.
+    "camera": "M14.5 4h-5L7 7H2v13h20V7h-5z M15 13a3 3 0 1 1-6 0a3 3 0 1 1 6 0",
+    // The rail menu's release mark, the shelf's "for: unmount": lucide's triangle corner arcs
+    // extend to (12, 2.09) (22.32, 13) (1.68, 13) and snap to grid, its rx=1 bar rect squares off.
+    "eject": "M12 2 22 13H2z M3 17h18v4H3z",
+    // Task 22's transport strip, recut sharp like the rest of the set.
+    "play": "M6 4l14 8-14 8z",
+    "pause": "M14 3h5v18h-5z M5 3h5v18H5z",
+    // The search strip's mark; the lens is a real curve, so it stays a circle under the cut.
+    "search": "M16.7 16.7 21 21 M3 11A8 8 0 1 0 19 11A8 8 0 1 0 3 11Z",
+    // The filter strip's mark, the funnel the icon spec already shelves and the Main board draws.
+    "filter": "M3 4h18l-7 8v7l-4 2v-9z",
+    // The context menu's own seven marks, added with the operations surface that draws them.
+    // The canvas's own open folder, which keeps the closed folder's back panel byte for byte.
+    "folder-open": "M2 20V3h6l2 3h12v3 M22 11l-2.5 9H2l2.5-9z",
+    // OpenWith.html draws this window for the Open with row, its tail row and an app the theme cannot name.
+    "app-window": "M3 4h18v16H3z M3 9h18 M6 6.5h.01 M9 6.5h.01",
+    "undo": "M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8 M3 3v5h5",
+    "rename": "M3 21l1-4L17 4l3 3L7 20l-4 1z M14 7l3 3",
+    "file-plus": "M6 22V2h8l4 4v16H6z M14 2v4h4 M12 11v6 M9 14h6",
+    // lucide's own folder-plus is the folder body byte for byte plus these two strokes, so the recut
+    // body is reused verbatim and only the plus is new; the specimen sheet's 5 unit plus is not it.
+    "folder-plus": "M2 20V3h6l2 3h12v14H2z M12 10v6 M9 13h6",
+    "trash": "M3 6h18 M8 6V3h8v3 M6 6l1.2 15h9.6L18 6 M10 10v7 M14 10v7",
+    // A diamond eye with a square pupil: lucide's own eye is two arcs meeting at points, which the cut squares off.
+    "eye": "M12 5 22 12 12 19 2 12z M10 10h4v4h-4z",
+    "eye-off": "M12 5 22 12 12 19 2 12z M10 10h4v4h-4z M4 4l16 16",
+    // Replaces the "▸" Text the menu used to draw, so it stops mixing a font dingbat into a path language.
+    "chevron-right": "M9 18l6-6-6-6",
+    "chevron-down": "M6 9l6 6 6-6",
+    "chevron-left": "M15 18l-6-6 6-6",
+    // The window chrome's own five marks, added with the bar that draws them.
+    "arrow-left": "M19 12H5 M12 19l-7-7 7-7",
+    "arrow-up": "M12 19V5 M5 12l7-7 7 7",
+    // The bullets are lucide's own zero-length-line technique, which SquareCap draws as square dots.
+    "list": "M8 6h13 M8 12h13 M8 18h13 M3 6L3.01 6 M3 12L3.01 12 M3 18L3.01 18",
+    "columns": "M3 3h18v18H3z M9 3v18 M15 3v18",
+    "preview": "M3 3h18v18H3z M15 3v18",
+    "dual": "M3 4h8v16H3z M13 4h8v16h-8z",
+    "grid": "M3 3h8v8H3z M13 3h8v8h-8z M3 13h8v8H3z M13 13h8v8h-8z",
+    // The preview column's own two, taken from the canvas's icon table rather than recut from lucide.
+    "symlink": "M7 17L17 7 M8 7h9v9",
+    // The dot is the zero-length-line technique again, which SquareCap draws square.
+    "alert": "M12 2 23 21H1z M12 10v4 M12 18L12.01 18",
+    // The Locked pane state draws this beside it: the shackle is a real curve so it stays an arc, and the keyhole is the same dot technique.
+    "lock": "M4 11h16v10H4z M8 11V7a4 4 0 0 1 8 0v4 M12 15h.01",
+    // The compress submenu's With-password row: a bow ring, a shaft and two teeth; the bow is a true circle under the cut.
+    "key": "M3 7a4 4 0 1 0 8 0a4 4 0 1 0-8 0 M10.5 10.5l8 8 M16 16l2.5-2.5 M18.5 18.5l1.5-1.5",
+    // The operations rows the archive and convert subsystems draw, from the spec's own glyph shelf.
+    "archive-out": "M2 3h20v5H2z M4 8v13h16V8 M12 18v-6 M9 15l3-3 3 3",
+    // The Move to Dropbox row, which the canvas draws with the network mark.
+    "network": "M9 2h6v6H9z M2 16h6v6H2z M16 16h6v6h-6z M12 8v4 M5 16v-4h14v4",
+    // The convert popup's checkbox mark.
+    "check": "M4 12l6 6L20 6",
+    // The Tags row's mark: a square-cornered price tag with its hole as a SquareCap dot.
+    "tag": "M3 3h7l11 11-7 7L3 10z M7.5 7.5L7.51 7.5",
+    // The PDF viewer's own three, recut sharp like the rest of the set; "maximize" is lucide's
+    // name for the mark the canvas calls expand.
+    "minus": "M5 12h14",
+    "maximize": "M8 3H3v5 M16 3h5v5 M8 21H3v-5 M16 21h5v-5",
+    "x": "M6 6l12 12 M18 6 6 18",
+    "sliders": "M4 21v-7 M4 10V3 M12 21v-9 M12 8V3 M20 21v-5 M20 12V3 M2 14h4 M10 8h4 M18 16h4",
+    // Grid zoom's own mark, the SettingsGrammar board's arrows, lucide's move-horizontal recut sharp.
+    "move-horizontal": "M4 12h16 M8 8l-4 4 4 4 M16 8l4 4-4 4",
+    // The background menu's Sort by row, Menus.html's own geometry: three rules shortening to the
+    // right of a bare down arrow. IconSets.html names this mark when it caps the corner radius.
+    "sort": "M11 5h10 M11 9h7 M11 13h4 M7 5v14 M7 19l-3-3 M7 19l3-3",
+    // MediaMute rule 2: lucide's speaker polygon is already hard-cornered, and the two waves are
+    // genuine arcs that stay arcs under cut rule 4; the cross is two lines.
+    "volume": "M11 5L6 9H2v6h4l5 4z M15.5 8.5a5 5 0 0 1 0 7 M19 5a10 10 0 0 1 0 14",
+    "volume-x": "M11 5L6 9H2v6h4l5 4z M22 9l-6 6 M16 9l6 6",
+    // The three basic clipboard rows the context menu grew with its visibility settings. Lucide's
+    // scissors and clipboard both carry arcs; these are the cut's own square handles and square tray.
+    "scissors": "M5 3l14 14 M19 3L5 17 M2 17h5v5H2z M17 17h5v5h-5z",
+    "copy": "M9 8h12v13H9z M4 16V3h13",
+    "clipboard": "M9 2h6v4H9z M6 4H3v18h18V4h-3 M8 12h8 M8 16h5",
+    // The Keys section's rail mark: the key caps are the same zero-length-line dots the list mark uses.
+    "keyboard": "M2 6h20v12H2z M6 10L6.01 10 M10 10L10.01 10 M14 10L14.01 10 M18 10L18.01 10 M8 14h8",
+    // Invert selection's mark, lucide's contrast, its outer ring kept a true curve.
+    "contrast": "M12 2a10 10 0 1 0 0 20a10 10 0 1 0 0-20 M12 18a6 6 0 0 0 0-12v12z",
+    // Settings > Click and refresh's Open items with mark: the arrow head and its tail, as Icons040 cuts it.
+    "pointer": "M4 4l16 6.5-7 2-2 7z M13 13l6 6"
+}
+
+// The sub-paths a mark fills as well as strokes, by name; ui/Glyph.qml draws them in the mark's own ink.
+var FILLED = {
+    // MenuAdditions040: Invert selection's right half disc is solid, lucide's contrast.
+    "contrast": "M12 18a6 6 0 0 0 0-12v12z"
+}
+
+function filledPathFor(name) {
+    return FILLED[name] || ""
+}
+
+function pathFor(name) {
+    return PATHS[name] || PATHS[FALLBACK]
+}

package/ui/js/Input.js

@@ -0,0 +1,50 @@
+.pragma library
+
+// Delete carries DEL through libxkbcommon; retain SheetQuery's single-character semantics.
+function isPrintable(text) {
+    var s = String(text || "")
+    return s.length === 1 && s >= " " && s !== "\u007f"
+}
+
+// Issue 287's paste chords, matched on the four real modifiers the way ui/js/Keymap.js matches keys.
+function isPasteKey(event) {
+    var mods = event.modifiers & (Qt.ControlModifier | Qt.ShiftModifier | Qt.AltModifier | Qt.MetaModifier)
+    return (event.key === Qt.Key_V && mods === Qt.ControlModifier)
+        || (event.key === Qt.Key_Insert && mods === Qt.ShiftModifier)
+}
+
+// The clipboard's first line, keeping printable characters and whole surrogate pairs only.
+function cleanPaste(text) {
+    var line = String(text || "").split(/\r\n|[\r\n]/)[0]
+    var out = ""
+    for (var i = 0; i < line.length; i++) {
+        var code = line.charCodeAt(i)
+        var low = i + 1 < line.length ? line.charCodeAt(i + 1) : 0
+        if (code >= 0xd800 && code <= 0xdbff && low >= 0xdc00 && low <= 0xdfff) {
+            out += line.substr(i, 2)
+            i++
+        } else if ((code < 0xd800 || code > 0xdfff) && isPrintable(line.charAt(i))) {
+            out += line.charAt(i)
+        }
+    }
+    return out
+}
+
+// Hands a query line's paste to its own typing route; the chord is consumed even when nothing is left to type.
+function pasteInto(host, typeText) {
+    var type = function (value) {
+        var pasted = cleanPaste(value)
+        if (pasted.length > 0)
+            typeText(pasted)
+    }
+    // flea-qml: a Promise where the runtime reads its clipboard asynchronously (buninu-browser).
+    var failed = function (error) { console.warn("Clipboard read failed: " + String(error)) }
+    try {
+        var text = host.clipboardText()
+        if (text && typeof text.then === "function")
+            Promise.resolve(text).then(type).catch(failed)
+        else
+            type(text)
+    } catch (error) { failed(error) }
+    return true
+}