flea-qml 0.0.0-stage → 0.2.0

package/ui/js/Format.js

@@ -0,0 +1,314 @@
+.pragma library
+
+// SI, because a file's size on disk has no power-of-two basis; GLib's own rule and the whole GUI group.
+var BYTES_PER_UNIT = 1000
+var UNITS = ["B", "kB", "MB", "GB", "TB"]
+// GNOME renders a narrow no-break space before the unit, and Flea's neighbours are GLib-formatted.
+var UNIT_SPACE = " "
+
+// Below one kilobyte a fraction is noise, so bytes print whole.
+// Counts reach six figures on a real directory, so they are grouped the way the canvas draws them.
+function count(n) {
+    var digits = String(n)
+    var out = ""
+    for (var i = 0; i < digits.length; i++) {
+        if (i > 0 && (digits.length - i) % 3 === 0)
+            out += ","
+        out += digits.charAt(i)
+    }
+    return out
+}
+
+function size(bytes) {
+    if (bytes < BYTES_PER_UNIT) {
+        return bytes + UNIT_SPACE + UNITS[0]
+    }
+    var value = bytes
+    var unit = 0
+    while (value >= BYTES_PER_UNIT && unit < UNITS.length - 1) {
+        value = value / BYTES_PER_UNIT
+        unit += 1
+    }
+    return value.toFixed(1) + UNIT_SPACE + UNITS[unit]
+}
+
+// Fills %1 to %9 in one pass: a value prints as given, a dollar sign or placeholder in it included; an unfilled one stays.
+function fill(template) {
+    var values = arguments
+    return String(template).replace(/%([1-9])/g, function (token, at) { return at < values.length ? String(values[at]) : token })
+}
+
+function pad(n) {
+    return n < 10 ? "0" + n : "" + n
+}
+
+// "2026-09-12 15:29", the one form every surface prints, in the machine's local wall clock.
+function stamp(d) {
+    return d.getFullYear() + "-" + pad(d.getMonth() + 1) + "-" + pad(d.getDate())
+        + " " + pad(d.getHours()) + ":" + pad(d.getMinutes())
+}
+
+// One form, sortable and unambiguous, so no surface has to invent a relative word for a time.
+function date(mtime) {
+    return stamp(new Date(mtime * 1000))
+}
+
+// The send picker's column is SendPicker.html's 80 and not the window's 125, which holds about ten
+// characters: the one place the full stamp does not fit. It drops the time and keeps the date, so it
+// is still sortable and still unambiguous. Preview board, "One function, four surfaces".
+function compactDate(mtime) {
+    var d = new Date(mtime * 1000)
+    return d.getFullYear() + "-" + pad(d.getMonth() + 1) + "-" + pad(d.getDate())
+}
+
+// The low nine bits of st_mode, read three at a time.
+var PERMISSION_BITS = 9
+var TRIAD = "rwx"
+
+function permissions(mode) {
+    var out = ""
+    for (var i = 0; i < PERMISSION_BITS; i++) {
+        var bit = 1 << (PERMISSION_BITS - 1 - i)
+        out += (mode & bit) ? TRIAD[i % TRIAD.length] : "-"
+    }
+    return out
+}
+
+// The file type lives in the top four bits of st_mode, as S_IFMT masks it.
+var S_IFMT = 0o170000
+var S_IFREG = 0o100000
+var S_IFDIR = 0o040000
+// The owner execute bit, the one Make executable adds.
+var S_IXUSR = 0o100
+var S_IFLNK = 0o120000
+var ANY_EXECUTE_BIT = 0o111
+
+function isSymlink(mode) {
+    return (mode & S_IFMT) === S_IFLNK
+}
+
+function isExecutable(mode) {
+    return (mode & ANY_EXECUTE_BIT) !== 0
+}
+
+// Shared by Row.qml's iconSource and PreviewMedia.qml's player source: encodeURI leaves # and ?
+// literal, which Qt then reads as a URL fragment or query rather than path bytes.
+function fileUri(path) {
+    path = String(path)
+    // Only Windows paths use backslashes as separators; POSIX filenames may contain them.
+    var drive = /^[A-Za-z]:[\\/]/.test(path)
+    var unc = /^\\\\[^\\]/.test(path)
+    if (drive || unc) path = path.replace(/\\/g, "/")
+    var parts = path.split("/")
+    for (var i = 0; i < parts.length; i++) {
+        if (!(drive && i === 0)) parts[i] = encodeURIComponent(parts[i])
+    }
+    return (drive ? "file:///" : path.indexOf("//") === 0 ? "file:" : "file://") + parts.join("/")
+}
+
+// "3:05", or "1:03:05" once an hour is on the clock; mm/ss are always two digits, matching a media player's own clock rather than Format.date's prose.
+function duration(ms) {
+    var totalSeconds = Math.max(0, Math.floor(ms / 1000))
+    var hours = Math.floor(totalSeconds / 3600)
+    var minutes = Math.floor((totalSeconds % 3600) / 60)
+    var seconds = totalSeconds % 60
+    if (hours > 0) {
+        return hours + ":" + pad(minutes) + ":" + pad(seconds)
+    }
+    return minutes + ":" + pad(seconds)
+}
+
+// The scope reads as the user writes it, so the home prefix comes back as a tilde. Both the search
+// strip and the window chrome draw a path through this, so the rule has one definition.
+// Issue 95, nixfred: a bare prefix made /home/gmx into "~x", a sibling wearing home's name. The test
+// is home itself or home and a separator, the one ui/js/Nav.js crumbs and Search.scopeRoot both make.
+function tilde(path, home) {
+    var text = String(path)
+    if (home.length > 0 && (text === home || text.indexOf(home + "/") === 0)) {
+        return "~" + text.substring(home.length)
+    }
+    return text
+}
+
+// A tab is named after the directory it is standing in, so the label is the path's last segment.
+function leafPart(display) {
+    var text = String(display)
+    var cut = text.lastIndexOf("/")
+    if (cut < 0) {
+        return text
+    }
+    // "/" itself has no leaf, and its own separator is the whole label.
+    return cut === text.length - 1 ? text : text.substring(cut + 1)
+}
+
+// "44.1 kHz", the way the canvas writes an audio row's Rate; a zero is not a rate and reads empty.
+function sampleRate(hz) {
+    var n = Number(hz)
+    if (!n || n <= 0) {
+        return ""
+    }
+    var khz = n / 1000
+    // A whole number of kilohertz reads without a decimal, so 48000 is "48 kHz" and not "48.0 kHz".
+    return (khz === Math.round(khz) ? khz : khz.toFixed(1)) + " kHz"
+}
+
+// Issue 67, jesedv: a yanked path is quoted unless a shell reads every character of it as itself.
+function shellQuoted(path) {
+    var text = String(path)
+    if (/^[A-Za-z0-9_@%+=:,.\/-]+$/.test(text)) {
+        return text
+    }
+    return "'" + text.split("'").join("'\\''") + "'"
+}
+
+// One window-level day boundary, so no Date is built and no timer ticks per row.
+
+// Sample input: Date.now() on the board date, 2026-09-23 11:40 local.
+var DAY_MS = 24 * 60 * 60 * 1000
+// The midnight timer's minute step, so a suspend still lands the day within a minute of resume.
+var MINUTE_MS = 60 * 1000
+
+// Local midnight starting the day nowMs falls in, in ms since the epoch.
+function dayStart(nowMs) {
+    var now = new Date(nowMs)
+    return new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime()
+}
+
+// True when the stamp is on or after today's local midnight.
+function isRecent(mtimeSec, todayStartMs) {
+    if (typeof mtimeSec !== "number" || !isFinite(mtimeSec))
+        return false
+    return mtimeSec * 1000 >= todayStartMs
+}
+
+// Built from components, so a daylight-saving night still lands on midnight.
+function msUntilMidnight(nowMs) {
+    var now = new Date(nowMs)
+    return new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1).getTime() - nowMs
+}
+
+// Elides in the middle so the extension stays visible; truncation costs a slice, never a relayout.
+// Sample input: "screenshot-2026-08-30-final-review-for-gm-after-the-bench-v3.png", 49.
+
+// The walk pairs surrogates by hand, so a cut never splits a code point.
+function charsOf(text) {
+    var out = []
+    for (var i = 0; i < text.length; i++) {
+        var lead = text.charCodeAt(i)
+        if (lead >= 0xD800 && lead <= 0xDBFF && i + 1 < text.length) {
+            var trail = text.charCodeAt(i + 1)
+            if (trail >= 0xDC00 && trail <= 0xDFFF) {
+                out.push(text.substring(i, i + 2))
+                i += 1
+                continue
+            }
+        }
+        // A combining mark rides with the char before it, so an NFD accent never orphans.
+        if (lead >= 0x0300 && lead <= 0x036F && out.length > 0) {
+            out[out.length - 1] += text.charAt(i)
+            continue
+        }
+        out.push(text.charAt(i))
+    }
+    return out
+}
+
+// Every fast unit sits below U+0300, so a fast name holds no surrogate, no combining mark and no wide glyph.
+var FAST_LIMIT = 0x0300
+
+// True when every UTF-16 unit is fast: each char paints one cell and slices never split a point.
+function isFastText(text) {
+    for (var i = 0; i < text.length; i++)
+        if (text.charCodeAt(i) >= FAST_LIMIT) return false
+    return true
+}
+
+function middleElide(name, maxCells) {
+    var text = String(name), max = Math.max(0, Math.floor(maxCells))
+    // A non-finite budget names no width, so the name goes through untouched.
+    if (!isFinite(max)) return text
+    // One scan serves the fit check and the store below, so a fitting fast name builds nothing.
+    var fast = isFastText(text)
+    // A fast name counts one cell a char, so a short one already fits untouched.
+    if (fast && text.length <= max) return text
+    var st = fast ? fastStoreOf(text) : storeOf(charsOf(text))
+    if (rangeCells(st, 0, st.n) <= max) return text
+    // The head takes the odd cell, so a 49-wide board keeps 24 and 24.
+    var h = spanFrom(st, 0, Math.ceil((max - 1) / 2)), t = tailSpan(st, Math.floor((max - 1) / 2))
+    return pieceOf(st, 0, h) + "…" + pieceOf(st, st.n - t, st.n)
+}
+
+// Display cells: East Asian Wide and Fullwidth paint two columns, emoji paint two, all else one.
+// Sample input: cellWidthOf("🎉") is 2, cellWidthOf("A") is 1.
+var WIDE_RANGES = [[0x1100, 0x115F], [0x2E80, 0x303E], [0x3041, 0x33FF], [0x3400, 0x4DBF], [0x4E00, 0xA4CF], [0xAC00, 0xD7A3], [0xF900, 0xFAFF], [0xFE10, 0xFE19], [0xFE30, 0xFE4F], [0xFF00, 0xFF60], [0xFFE0, 0xFFE6], [0x20000, 0x3FFFD]]
+var EMOJI_RANGES = [[0x2600, 0x26FF], [0x2700, 0x27BF], [0x2B00, 0x2BFF], [0x1F000, 0x1FAFF]]
+
+// True when a code point paints two columns rather than one.
+function isWideCode(cp) {
+    // Every wide range starts at U+1100, so a smaller code point never scans.
+    if (cp < 0x1100) return false
+    for (var i = 0; i < WIDE_RANGES.length; i++)
+        if (cp >= WIDE_RANGES[i][0] && cp <= WIDE_RANGES[i][1]) return true
+    for (var j = 0; j < EMOJI_RANGES.length; j++)
+        if (cp >= EMOJI_RANGES[j][0] && cp <= EMOJI_RANGES[j][1]) return true
+    return false
+}
+
+// The code point one charsOf element starts with, read without wrapping it in a string.
+// Sample input: codeOf("🎉") is 0x1F389, codeOf("A") is 0x41.
+function codeOf(ch) {
+    var s = String(ch), lead = s.charCodeAt(0)
+    if (lead >= 0xD800 && lead <= 0xDBFF && s.length > 1) {
+        var trail = s.charCodeAt(1)
+        if (trail >= 0xDC00 && trail <= 0xDFFF) return 0x10000 + ((lead - 0xD800) << 10) + (trail - 0xDC00)
+    }
+    return lead
+}
+
+// Cells one char paints: 2 for a wide code point, 1 for all else.
+function cellWidthOf(ch) {
+    return isWideCode(codeOf(ch)) ? 2 : 1
+}
+
+// One layout per call: widths plus prefix sums, so every range below is one subtraction.
+// Sample input: storeOf(["a", "🎉"]) carries widths [1, 2].
+function storeOf(chars) {
+    var widths = new Array(chars.length), prefix = new Array(chars.length + 1)
+    prefix[0] = 0
+    for (var i = 0; i < chars.length; i++) {
+        widths[i] = isWideCode(codeOf(chars[i])) ? 2 : 1
+        prefix[i + 1] = prefix[i] + widths[i]
+    }
+    return { seq: chars, widths: widths, prefix: prefix, n: chars.length }
+}
+
+// The same layout over a fast string: no arrays, every range counts chars as cells.
+function fastStoreOf(text) {
+    return { seq: text, widths: null, prefix: null, n: text.length }
+}
+
+// Cells of elements [a..b).
+function rangeCells(st, a, b) {
+    return st.widths === null ? b - a : st.prefix[b] - st.prefix[a]
+}
+
+// Elements from pos fitting in this many cells.
+function spanFrom(st, pos, budget) {
+    if (st.widths === null) return Math.min(Math.max(budget, 0), st.n - pos)
+    var used = 0, i = pos
+    while (i < st.widths.length && used + st.widths[i] <= budget) { used += st.widths[i]; i += 1 }
+    return i - pos
+}
+
+// Trailing elements fitting in this many cells.
+function tailSpan(st, budget) {
+    if (st.widths === null) return Math.min(Math.max(budget, 0), st.n)
+    var used = 0, i = st.widths.length
+    while (i > 0 && used + st.widths[i - 1] <= budget) { used += st.widths[i - 1]; i -= 1 }
+    return st.widths.length - i
+}
+
+// Text of elements [a..b): a slice for a fast string, a join for a char array.
+function pieceOf(st, a, b) {
+    return st.widths === null ? st.seq.slice(a, b) : st.seq.slice(a, b).join("")
+}

package/ui/js/Fuzzy.js

@@ -0,0 +1,141 @@
+.pragma library
+
+// src/backend/fuzzy.rs ported, weight for weight, so the path bar's jump and search agree on what matched
+// and where. Pure; tests/js/jump.js holds it to the Rust tests' own table of exact scores.
+var BONUS_CONSECUTIVE = 8
+var BONUS_BOUNDARY = 6
+var BONUS_BASENAME = 4
+var PENALTY_GAP = 1
+var MAX_STARTS = 16
+
+function isSeparator(c) {
+    return c === "/" || c === "-" || c === "_" || c === "." || c === " "
+}
+
+// corner: a character whose lowercase form is longer keeps its first unit, the corner fuzzy.rs documents,
+// and a character outside the basic plane counts as two here where Rust counts one, which moves only a gap charge.
+function fold(text) {
+    var out = []
+    for (var i = 0; i < text.length; i++) {
+        var c = text.charAt(i)
+        var lower = c.toLowerCase().charAt(0)
+        out.push({ lower: lower, upper: lower !== c })
+    }
+    return out
+}
+
+function baseStart(hay) {
+    var start = 0
+    for (var i = 0; i < hay.length; i++) {
+        if (hay[i].lower === "/") {
+            start = i + 1
+        }
+    }
+    return start
+}
+
+function startsAWord(hay, at) {
+    if (at === 0) {
+        return true
+    }
+    var before = hay[at - 1]
+    return isSeparator(before.lower) || (hay[at].upper && !before.upper)
+}
+
+// What one matched character is worth: a run, a boundary and the base name each add, and the
+// characters skipped to reach it are charged back.
+function characterScore(hay, at, base, previous) {
+    var score = 0
+    if (previous >= 0) {
+        score += at === previous + 1 ? BONUS_CONSECUTIVE : -PENALTY_GAP * (at - previous - 1)
+    }
+    if (startsAWord(hay, at)) {
+        score += BONUS_BOUNDARY
+    }
+    if (at >= base) {
+        score += BONUS_BASENAME
+    }
+    return score
+}
+
+// Greedy from one start: every query character takes the next candidate character that matches it.
+function alignFrom(hay, needle, start, base) {
+    var total = 0
+    var at = start
+    var previous = -1
+    var positions = []
+    for (var k = 0; k < needle.length; k++) {
+        if (k > 0) {
+            at++
+            while (at < hay.length && hay[at].lower !== needle.charAt(k)) {
+                at++
+            }
+            if (at === hay.length) {
+                return null
+            }
+        }
+        total += characterScore(hay, at, base, previous)
+        positions.push(at)
+        previous = at
+    }
+    return { score: total, positions: positions }
+}
+
+// null when the query is not a subsequence of the candidate; otherwise the best alignment's score and
+// the positions it matched, which is what the wash is drawn from. The needle is the query lowered once
+// by the caller; the hay is folded once per open by ui/js/Jump.js prepare, never per keystroke.
+function matchFolded(hay, base, needle) {
+    if (needle.length === 0) {
+        return { score: 0, positions: [] }
+    }
+    var best = null
+    var starts = 0
+    for (var i = 0; i < hay.length; i++) {
+        if (hay[i].lower !== needle.charAt(0)) {
+            continue
+        }
+        var found = alignFrom(hay, needle, i, base)
+        // A start that cannot finish means no later start can either, the greedy scan's own guarantee.
+        if (found === null) {
+            return best
+        }
+        if (best === null || found.score > best.score) {
+            best = found
+        }
+        starts++
+        if (starts === MAX_STARTS) {
+            break
+        }
+    }
+    return best
+}
+
+// null when the query is not a subsequence of the candidate; otherwise the best alignment's score and
+// the positions it matched, which is what the wash is drawn from.
+function match(candidate, query) {
+    var needle = String(query).toLowerCase()
+    if (needle.length === 0) {
+        return { score: 0, positions: [] }
+    }
+    var hay = fold(String(candidate))
+    var base = baseStart(hay)
+    return matchFolded(hay, base, needle)
+}
+
+// The one run the row washes: the longest stretch of consecutive matched positions, the first on a tie.
+function run(positions) {
+    var best = { start: -1, length: 0 }
+    var i = 0
+    while (i < positions.length) {
+        var j = i
+        while (j + 1 < positions.length && positions[j + 1] === positions[j] + 1) {
+            j++
+        }
+        if (j - i + 1 > best.length) {
+            best = { start: positions[i], length: j - i + 1 }
+        }
+        i = j + 1
+    }
+    return best
+}
+

package/ui/js/GlassTag.js

@@ -0,0 +1,72 @@
+.pragma library
+
+// The Hyprland tag Omarchy's transparency hotkey sets; Omarchy's own rule then draws the window at its Transparent opacity.
+var TAG = "transparent"
+// Hyprland addresses are lowercase hex with a 0x prefix; nothing else reaches a dispatch.
+var ADDRESS = /^0x[0-9a-f]+$/
+// Prints "address opacity inactive" for each address argument, read from Hyprland's own window properties.
+var PROBE = 'for a in "$@"; do printf "%s %s %s\\n" "$a" "$(hyprctl getprop "address:$a" opacity)" "$(hyprctl getprop "address:$a" opacity_inactive)"; done'
+// Applies "address tag" argument pairs with the Lua dispatcher, else the classic one, as omarchy-hyprland-window-pop does.
+var DISPATCH = 'while [ "$#" -ge 2 ]; do hyprctl dispatch "hl.dsp.window.tag({ window = \\"address:$1\\", tag = \\"$2\\" })" >/dev/null 2>&1 || hyprctl dispatch tagwindow "$2" "address:$1" >/dev/null; shift 2; done'
+
+// Sample input: hyprctl clients -j, '[{"address":"0x55bacb0a1f80","pid":4211,"class":"com.thisisgm.flea"}]'.
+function ownAddresses(json, pid) {
+    var list
+    try {
+        list = JSON.parse(json)
+    } catch (e) {
+        return []
+    }
+    if (!Array.isArray(list))
+        return []
+    var out = []
+    for (var i = 0; i < list.length; i++) {
+        var c = list[i]
+        if (c && c.pid === pid && ADDRESS.test(String(c.address)))
+            out.push(String(c.address))
+    }
+    return out
+}
+
+// Sample input, one PROBE line: "0x55bacb0a1f80 0.985 0.96".
+function parseProps(line) {
+    var f = String(line).trim().split(/\s+/)
+    if (f.length !== 3 || !ADDRESS.test(f[0]))
+        return null
+    return {address: f[0], opacity: Number(f[1]), inactive: Number(f[2])}
+}
+
+// "add", "remove" or "keep" for one Flea window: the tag goes only where Omarchy draws Transparent and Hyprland leaves the window at 1.
+function decide(mode, usesDefault, opacity, inactive, taggedByFlea) {
+    var wanted = mode === "transparent" && usesDefault
+    // The hotkey's own test, which also re-tags a window that reuses a closed one's address: a window Hyprland already draws
+    // below 1, as stable Omarchy draws every window, keeps its rule.
+    if (wanted && opacity === 1 && inactive === 1)
+        return "add"
+    return taggedByFlea && !wanted ? "remove" : "keep"
+}
+
+// The dispatch pairs for PROBE's output, and the set Flea has tagged once they run; a closed window's record drops out.
+function plan(text, mode, usesDefault, tagged) {
+    var next = {}
+    var pairs = []
+    var lines = String(text).split("\n")
+    for (var i = 0; i < lines.length; i++) {
+        var w = parseProps(lines[i])
+        if (!w)
+            continue
+        var mine = tagged[w.address] === true
+        if (mine)
+            next[w.address] = true
+        var act = decide(mode, usesDefault, w.opacity, w.inactive, mine)
+        if (act === "add") {
+            pairs.push(w.address, "+" + TAG)
+            next[w.address] = true
+        }
+        if (act === "remove") {
+            pairs.push(w.address, "-" + TAG)
+            delete next[w.address]
+        }
+    }
+    return {pairs: pairs, tagged: next}
+}

package/ui/js/Grid.js

@@ -0,0 +1,33 @@
+.pragma library
+
+.import "Filter.js" as Filter
+.import "Marks.js" as Marks
+
+// The grid's own geometry: which cell a key means when the rows are tiles rather than lines. Split
+// out of ui/js/Focus.js, which holds the key map and the actions every view shares.
+
+// Which way a key steps across a row of tiles, the arrow and the letter the presets spell it with.
+function sideways(event) {
+    return event.key === Qt.Key_Left || event.text === "h" ? -1
+         : event.key === Qt.Key_Right || event.text === "l" ? 1 : 0
+}
+
+// Arrow and letter actions share visual cells; absent neighbours clamp even when list navigation wraps.
+function arrow(event, action, root) {
+    if (root.viewMode !== "grid") return false
+    var columns = root.cursorStride
+    var across = sideways(event)
+    var delta = (action === "cursorDown" || action === "extendDown") ? columns
+              : (action === "cursorUp" || action === "extendUp") ? -columns
+              : across < 0 && action === "cursorLeft" ? -1
+              : across > 0 && action === "cursorRight" ? 1 : 0
+    if (!delta) return false
+    var index = Filter.viewOf(root.shown, root.cursorIndex)
+    var nextIndex = index + delta
+    if (nextIndex < 0 || nextIndex >= root.shownTotal
+            || (across < 0 && index % columns === 0)
+            || (across > 0 && nextIndex % columns === 0)) return true
+    if (action === "extendDown" || action === "extendUp") root.extendSelection(delta)
+    else { Filter.moveCursor(root, delta); Marks.follow(root) }
+    return true
+}

package/ui/js/GridGeometry.js

@@ -0,0 +1,90 @@
+.pragma library
+
+// The grid's tile maths, split out of ui/GridArea.qml so tests/js/gridgeometry.js can pin it.
+
+// Width less one gap and the scroll lane, so no tile sits under the bar.
+// Sample input: columnsFor(800, 146, 96, 7, 8) is 5, five tiles across an 800 px grid.
+function columnsFor(width, minCellWidth, tilePixels, rowPaddingX, gap, lane) {
+    var cell = Math.max(minCellWidth, tilePixels + 2 * rowPaddingX)
+    return Math.max(1, Math.floor((width - gap - (Number(lane) || 0)) / cell))
+}
+
+// Sample input: cellWidthFor(800, 5, 8) is 158, five cells filling the 792 beside the gap.
+function cellWidthFor(width, columns, gap, lane) {
+    return Math.max(1, Math.floor((width - gap - (Number(lane) || 0)) / Math.max(1, columns)))
+}
+
+// A cell is its slot plus the name gap plus two caption lines plus the pad above and below.
+// Sample input: cellHeightFor(128, 9, 33, 14) is 198, the board tile.
+function cellHeightFor(thumbPixels, gap, captionHeight, padY) {
+    return Math.max(1, thumbPixels + gap + captionHeight + 2 * padY)
+}
+
+// Tile rows the view keeps built beyond its edge, the one number ui/GridArea.qml's cacheBuffer and a landing's ask both count.
+var cacheRows = 2
+
+// The window a grid holds, in whole tile rows: the list's context in pixels (bufferRows of rowHeight each side) rebuilt in tiles, so a screen of tiles keeps the room a screen of rows keeps.
+// Sample input: windowFor(18, 11, 150, 26, 124, 25) is {columns: 18, visible: 11, buffer: 576, size: 1350, margin: 36}, 32 tile rows each side of 11, and a margin of two tile rows.
+function windowFor(columns, visibleTileRows, bufferRows, rowHeight, cellHeight, refetchMargin) {
+    var across = Math.max(1, columns)
+    var rows = Math.max(1, Math.ceil(bufferRows * rowHeight / Math.max(1, cellHeight)))
+    var visible = Math.max(1, visibleTileRows)
+    return { columns: across, visible: visible, buffer: across * rows, size: across * (visible + 2 * rows), margin: Math.max(refetchMargin, 2 * across) }
+}
+
+// The window the visible items owe the backend once they come within the margin of an edge the held rows have a further side to, or when none are held.
+// Sample input: driftAsk({buffer: 576, size: 1350, margin: 36}, 1000, 1330, 0, 1350, 2000) is {start: 424, count: 1350}, and null at 1000 to 1200.
+function driftAsk(plan, first, last, held, length, total) {
+    var end = held + length
+    var behind = held > 0 && first - held < plan.margin
+    var ahead = end < total && end - last < plan.margin
+    return length === 0 || behind || ahead ? { start: Math.max(0, first - plan.buffer), count: plan.size } : null
+}
+
+// The window a far cursor landing owes the backend before the view moves, or null for a step or a landing the held rows reach.
+// Sample input: landingAsk(plan, 1999, 0, 2000, 0, 352) with the plan above is {start: 1746, count: 254}, the tail of the listing; with 1500 rows held from 700 it is null.
+function landingAsk(plan, cursorIndex, firstIndex, total, held, heldLength) {
+    var row = Math.floor(cursorIndex / plan.columns)
+    var seen = Math.floor(firstIndex / plan.columns)
+    if (Math.abs(row - seen) <= plan.visible)
+        return null
+    var before = row > seen ? plan.visible + 1 : cacheRows + 1
+    var after = row > seen ? cacheRows + 1 : plan.visible + 1
+    var start = Math.max(0, (row - before) * plan.columns - plan.margin)
+    var end = Math.min(total, (row + after) * plan.columns + plan.margin)
+    if (start >= held && end <= held + heldLength)
+        return null
+    return { start: start, count: end - start }
+}
+
+// Whether two rows draw the same tile: every field equal, so a reply that repeats a row hands its tile nothing to redraw.
+// Sample input: sameRow({n: "a", tg: [2]}, {n: "a", tg: [2]}) is true, sameRow({n: "a"}, null) is false.
+function sameRow(a, b) {
+    if (a === b)
+        return true
+    if (a === null || b === null || a === undefined || b === undefined)
+        return false
+    var keys = Object.keys(a)
+    if (keys.length !== Object.keys(b).length)
+        return false
+    for (var i = 0; i < keys.length; i++) {
+        var x = a[keys[i]], y = b[keys[i]]
+        if (x !== y && (typeof x !== "object" || typeof y !== "object" || JSON.stringify(x) !== JSON.stringify(y)))
+            return false
+    }
+    return true
+}
+
+// The row a tile draws from the held snapshot {start, rows, listing}: the held row, else the row it kept at this index on the same listing, else null; memo is the tile's own {row, index, listing}.
+// Sample input: heldRow({row: null, index: -1, listing: 0}, {start: 10, rows: [a, b], listing: 1}, 11) is b, and a tile at 5 afterwards keeps what it drew at 5.
+function heldRow(memo, held, index) {
+    var offset = index - held.start
+    var next = offset >= 0 && offset < held.rows.length ? held.rows[offset] : null
+    var kept = next === null ? memo.index === index && memo.listing === held.listing : sameRow(memo.row, next)
+    memo.index = index
+    memo.listing = held.listing
+    if (kept)
+        return memo.row
+    memo.row = next
+    return next
+}