flea-qml 0.0.0-stage → 0.1.0

package/ui/js/Tabs.js

@@ -0,0 +1,736 @@
+.pragma library
+
+.import "Filter.js" as Filter
+.import "Format.js" as Format
+.import "Nav.js" as Nav
+.import "RecentMode.js" as RecentMode
+.import "Search.js" as Search
+.import "Sort.js" as Sort
+.import "Startup.js" as Startup
+.import "TabMove.js" as TabMove
+
+// The sentence a digit key answers with when no tab sits there, filled by Format.fill.
+var WORDS = {
+    noTab: "No tab %1",
+    lastTab: "The last tab cannot be closed"
+}
+
+// Hidden tabs are snapshots, so the pane and backend still own only one listing.
+// The nine-tab cap matches TUI's direct digit selection; GUI shortcuts cycle through the same state.
+
+var MAX = 9
+
+// Where a snapshotted tab reopens: the folder a search or a history was opened over, else the path.
+function restingPath(pane) {
+    if (pane.searchMode === "results" && (pane.searchFrom || "").length > 0)
+        return pane.searchFrom
+    return RecentMode.restingPath(pane) || Nav.place(pane)
+}
+
+var nextTabIdentity = 0
+
+// Only the held cursor row can name a file; a search's row never belongs to its resting folder.
+function cursorFile(pane) {
+    var row = pane.rowFor && pane.cursorIndex >= 0 ? pane.rowFor(pane.cursorIndex) : null
+    return row && typeof row.n === "string" ? row.n : ""
+}
+
+function snapshot(pane, path, identity, dropped) {
+    var where = path === undefined ? restingPath(pane) : path
+    // A cursor and a selection read off a search's own listing name nothing in the directory the
+    // tab records, so a tab stepping back out of a search starts at its first row with none.
+    var elsewhere = where !== pane.path || Search.live(pane) || dropped === true
+    return {
+        tabIdentity: identity || ++nextTabIdentity,
+        path: where,
+        history: pane.history.slice(),
+        forwardHistory: (pane.forwardHistory || []).slice(),
+        cursorIndex: elsewhere ? 0 : pane.cursorIndex,
+        cursorName: elsewhere ? "" : cursorFile(pane),
+        viewMode: pane.viewMode,
+        showHidden: pane.showHidden,
+        selected: elsewhere ? [] : pane.selectedIndices().slice(),
+        // A lone row restores with only(), so a tab switch never re-arms the row a tap left behind.
+        follows: elsewhere ? false : pane.selection.follows(),
+        sortBy: pane.backend.sortBy,
+        sortDesc: pane.backend.sortDesc,
+        // Issue 94, nixfred: the counter every list bumps, so a selection only returns to its own rows.
+        listRequests: pane.backend.listRequests,
+        // The directory's filesystem, so a drop on this tab while another shows decides move against copy.
+        dev: elsewhere ? 0 : pane.backend.dirDev
+    }
+}
+
+// keep is the tabs object whose landing the current tab still owes, for a pack that leaves the current tab's listing out.
+function pack(items, index, keep) {
+    var tabs = {
+        items: items,
+        index: index,
+        pendingCursor: -1,
+        pendingCursorName: null,
+        pendingLocatePath: "",
+        pendingSortBy: "",
+        pendingSortDesc: false
+    }
+    if (keep) {
+        tabs.pendingCursor = keep.pendingCursor
+        tabs.pendingCursorName = keep.pendingCursorName
+        tabs.pendingLocatePath = keep.pendingLocatePath
+        tabs.pendingSortBy = keep.pendingSortBy
+        tabs.pendingSortDesc = keep.pendingSortDesc
+    }
+    return tabs
+}
+
+function label(path, home) {
+    if (!path || path === "/")
+        return "/"
+    if (home && path === home)
+        return "Home"
+    var leaf = Format.leafPart(Format.tilde(path, home || ""))
+    return leaf.length > 0 ? leaf : path
+}
+
+// The current tab's path lives on the pane, not in the snapshot, so a navigate does not wait for a switch.
+function labelAt(pane, i) {
+    return label(pathAt(pane.tabs, currentIndex(pane), i, pane.path), pane.home)
+}
+
+// The path tab i draws: the live pane path for the current tab, the snapshot's for a hidden one.
+// Takes the values rather than the pane so ui/TabBar.qml's binding can read each one by name.
+function pathAt(tabs, index, i, currentPath) {
+    if (i === index)
+        return currentPath
+    return tabs && tabs.items && tabs.items[i] ? tabs.items[i].path : ""
+}
+
+// The tab's filesystem the same way, 0 when unknown, which ui/js/Drag.js verbFor reads as copy.
+function devAt(tabs, index, i, currentDev) {
+    if (i === index)
+        return currentDev
+    return tabs && tabs.items && tabs.items[i] ? Number(tabs.items[i].dev) || 0 : 0
+}
+
+function labels(pane) {
+    var n = count(pane)
+    var out = []
+    for (var i = 0; i < n; i++)
+        out.push(labelAt(pane, i))
+    return out
+}
+
+function count(pane) {
+    return pane.tabs && pane.tabs.items && pane.tabs.items.length > 0 ? pane.tabs.items.length : 1
+}
+
+function currentIndex(pane) {
+    return pane.tabs ? pane.tabs.index : 0
+}
+
+// Search and Recent replace the listing; Trash only covers it, so closing Trash alone needs no re-list.
+function dropOverlay(pane) {
+    var dropped = Search.live(pane) || Search.owesRelist(pane) || RecentMode.dropOverlay(pane)
+    if (pane.trash) pane.trash.close()
+    Search.leaveWalk(pane)
+    Filter.close(pane)
+    return dropped
+}
+
+function closePreview(pane) {
+    if (pane.preview && pane.preview.active)
+        pane.preview.close()
+}
+
+// The mark names a standing notice's serial, never its sentence; a count change withdraws it.
+function sayCount(pane, text) {
+    pane.message(text, false)
+    pane.tabCountNotice = pane.statusBar ? pane.statusBar.noticeSerial : -1
+}
+// Any other verdict from here replaces a standing count one, so no later change withdraws it.
+function sayPlain(pane, text) {
+    pane.tabCountNotice = -1
+    pane.message(text, false)
+}
+// The count changed under a standing count verdict, so it is withdrawn; anything else stands.
+function dropCount(pane) {
+    if (pane.tabCountNotice !== -1 && pane.statusBar) pane.statusBar.withdraw(pane.tabCountNotice)
+    pane.tabCountNotice = -1
+}
+
+// Only ever called for a switch that re-listed nothing; the clamp is the belt on top of that, since
+// an index past the end would select a row that is not there at all.
+function restoreSelection(pane, selected, follows) {
+    pane.clearSelection()
+    if (!selected || selected.length === 0)
+        return
+    if (follows === true && selected.length === 1 && selected[0] < pane.total) {
+        pane.selection.only(selected[0])
+        pane.selectionVersion++
+        return
+    }
+    var kept = 0
+    for (var i = 0; i < selected.length; i++) {
+        if (selected[i] < pane.total) {
+            pane.selection.toggle(selected[i])
+            kept++
+        }
+    }
+    if (kept > 0)
+        pane.selectionVersion++
+}
+
+function apply(pane, item, dropped, cursor) {
+    // Issue 93: rows from a search dropped onto its scope, or a listing still out, are not the rows this tab left.
+    var same = pane.path === item.path && pane.showHidden === item.showHidden && dropped !== true && cursor === undefined && !pane.listInFlight
+    if (pane.tabs) pane.tabs.pendingCursorName = cursor === undefined ? null : cursor
+    var shown = pane.viewMode
+    pane.history = item.history.slice()
+    pane.forwardHistory = (item.forwardHistory || []).slice()
+    pane.viewMode = item.viewMode
+    // A tab's view becomes the standing one unless its folder keeps its own; ui/Pane.qml adoptView decides.
+    if (pane.adoptView)
+        pane.adoptView(item.path, item.viewMode)
+    pane.showHidden = item.showHidden
+    if (same) {
+        if (pane.backend && (pane.backend.sortBy !== item.sortBy || pane.backend.sortDesc !== item.sortDesc)) {
+            // Issue 94: the one reset a reorder takes, ui/js/Sort.js's, which this branch half repeated.
+            Sort.resort(pane, item.sortBy, item.sortDesc)
+            pane.tabs.pendingCursor = item.cursorIndex
+            return
+        }
+        // The switch that re-reads nothing, unless something else did: the watch and a write both list.
+        pane.setCursor(item.cursorIndex)
+        if (pane.backend && item.listRequests === pane.backend.listRequests) {
+            restoreSelection(pane, item.selected, item.follows)
+            return
+        }
+        pane.clearSelection()
+        return
+    }
+    // The listing keeps the tab's own dotfile answer restored above; a tab in another view clears at once, as its rows were never listed there.
+    pane.openWithoutHistory(item.path, { keepHidden: true, clearAtOnce: pane.viewMode !== shown, supersede: true })
+    // After the request: letting a listing go clears what an earlier switch owed, and this one is owed to the listing just asked for.
+    pane.tabs.pendingCursorName = cursor === undefined ? null : cursor
+    pane.tabs.pendingCursor = cursor === undefined ? item.cursorIndex : 0
+    pane.tabs.pendingSortBy = item.sortBy
+    pane.tabs.pendingSortDesc = item.sortDesc
+}
+
+function applyPending(pane) {
+    if (!pane.tabs)
+        return
+    var t = pane.tabs
+    // Issue 91, nixfred: spent on the first reply either way, or an order already in force never was.
+    if (t.pendingSortBy && t.pendingSortBy.length > 0 && pane.backend) {
+        var by = t.pendingSortBy
+        var desc = t.pendingSortDesc
+        t.pendingSortBy = ""
+        if (pane.backend.sortBy !== by || pane.backend.sortDesc !== desc) {
+            pane.backend.sort(by, desc)
+            pane.backend.sortBy = by
+            pane.backend.sortDesc = desc
+            pane.backend.window(0, pane.windowSize)
+            return
+        }
+    }
+    if (t.pendingCursorName) {
+        var name = t.pendingCursorName
+        t.pendingCursorName = null
+        var first = pane.held || 0
+        var end = Math.min(pane.total, first + (pane.rows ? pane.rows.length : pane.windowSize))
+        var found = false
+        for (var i = first; i < end; i++) {
+            var row = pane.rowFor(i)
+            if (row && row.n === name) {
+                t.pendingCursor = i
+                found = true
+                break
+            }
+        }
+        if (!found && pane.total > 0 && pane.backend && pane.backend.send) {
+            t.pendingLocatePath = (pane.path === "/" ? "/" : pane.path + "/") + name
+            t.pendingCursor = -1
+            pane.backend.send({ c: "locate", path: t.pendingLocatePath })
+            return
+        }
+    }
+    if (t.pendingCursor >= 0) {
+        var last = pane.total > 0 ? pane.total - 1 : 0
+        pane.setCursor(Math.min(t.pendingCursor, last))
+        t.pendingCursor = -1
+    }
+}
+
+// A fresh receiver index comes from its own name-only listing, never from the source window.
+function locatedCursor(pane, message) {
+    var t = pane.tabs
+    if (!t || !t.pendingLocatePath || message.path !== t.pendingLocatePath || message.directory !== pane.path)
+        return
+    t.pendingLocatePath = ""
+    if (pane.listInFlight) return
+    var index = message.index >= 0 && message.index < pane.total ? message.index : 0
+    pane.setCursor(index)
+    if (pane.total > 0 && !pane.rowFor(index)) pane.backend.window(index, pane.windowSize)
+}
+
+// The desktop launch carries the same filename through the existing environment seam.
+function prepareCursor(pane, cursor) {
+    if (!cursor) return
+    if (!pane.tabs) pane.tabs = pack([snapshot(pane)], 0)
+    pane.tabs.pendingCursor = 0
+    pane.tabs.pendingCursorName = cursor
+    pane.tabs.pendingLocatePath = ""
+}
+
+function currentItems(pane, here) {
+    if (pane.tabs && pane.tabs.items && pane.tabs.items.length > 0)
+        return pane.tabs.items.slice()
+    return [snapshot(pane, here)]
+}
+
+// A caller may name where the new tab lands, which is what the Places row menu's own row does;
+// without one it is Settings, View, Opening that decides, and that still defaults to this folder.
+function openNew(pane, where) {
+    // Before the preview and the search go: a refused tenth tab must cost the user nothing.
+    if (count(pane) >= MAX) {
+        sayCount(pane, "Nine tabs is the most.")
+        return
+    }
+    var here = restingPath(pane)
+    closePreview(pane)
+    var dropped = dropOverlay(pane)
+    // Settings > View > Opening decides where the new tab lands; it cloned the current folder before
+    // 0.2.1 and that is still the default. The tab the operator leaves keeps the path it was on.
+    var target = where || Startup.newTabPath(pane.uiState, here, pane.home)
+    var items = currentItems(pane, here)
+    var index = currentIndex(pane)
+    items[index] = snapshot(pane, here, items[index].tabIdentity, dropped)
+    items.push(snapshot(pane, target, undefined, dropped))
+    pane.tabs = pack(items, items.length - 1)
+    dropCount(pane)
+    // dropOverlay clears the search while its rows still stand, and a listing still out belongs to the tab being left, so both list the target again, the one out let go.
+    if (pane.path !== target || dropped || pane.listInFlight)
+        pane.openWithoutHistory(target, { supersede: true })
+}
+
+// Ctrl+Return on the cursor row, the keyboard twin of Tap.tappedTab's middle
+// click: that directory in a new tab, leaving the cursor and selection alone.
+function openCursorTab(pane) {
+    var row = pane.rowFor ? pane.rowFor(pane.cursorIndex) : null
+    if (!row || !row.d || typeof row.n !== "string") {
+        sayPlain(pane, "Only a folder opens in a new tab.")
+        return
+    }
+    var base = Search.baseOf(pane)
+    openNew(pane, base === "/" ? "/" + row.n : base + "/" + row.n)
+}
+
+function selectAt(pane, i) {
+    var here = restingPath(pane)
+    var items = currentItems(pane, here)
+    if (i < 0 || i >= items.length) {
+        sayCount(pane, Format.fill(WORDS.noTab, i + 1))
+        return
+    }
+    var index = currentIndex(pane)
+    if (i === index)
+        return
+    closePreview(pane)
+    var dropped = dropOverlay(pane)
+    items[index] = snapshot(pane, here, items[index].tabIdentity, dropped)
+    pane.tabs = pack(items, i)
+    apply(pane, items[i], dropped)
+}
+
+function closeAt(pane, i) {
+    var items = currentItems(pane)
+    if (items.length <= 1) {
+        sayCount(pane, WORDS.lastTab)
+        return
+    }
+    if (i < 0 || i >= items.length) {
+        sayCount(pane, Format.fill(WORDS.noTab, i + 1))
+        return
+    }
+    var index = currentIndex(pane)
+    items.splice(i, 1)
+    var next = index
+    if (i < index)
+        next = index - 1
+    else if (i === index)
+        next = Math.min(i, items.length - 1)
+    if (i === index) {
+        closePreview(pane)
+        var dropped = dropOverlay(pane)
+        pane.tabs = pack(items, next)
+        apply(pane, items[next], dropped)
+    } else {
+        pane.tabs = pack(items, next, pane.tabs)
+    }
+    dropCount(pane)
+}
+
+// A move lists nothing, so the listing out lands for the tab it belongs to and that tab keeps what the landing owes.
+function move(pane, from, to) {
+    var items = currentItems(pane)
+    if (items.length < 2)
+        return
+    var index = currentIndex(pane)
+    items[index] = snapshot(pane, restingPath(pane), items[index].tabIdentity)
+    pane.tabs = pack(items, TabMove.reorder(items, from, to, index), pane.tabs)
+}
+
+// Tabs040 callout 1: { and } move the current tab with no re-list.
+function moveCurrent(pane, delta) {
+    var total = count(pane)
+    if (total < 2)
+        return
+    var from = currentIndex(pane)
+    move(pane, from, TabMove.step(from, delta, total))
+}
+
+function act(action, pane) {
+    if (action === "tabMoveLeft" || action === "tabMoveRight") {
+        moveCurrent(pane, action === "tabMoveRight" ? 1 : -1)
+        return
+    }
+    if (action === "tabNext" || action === "tabPrevious") {
+        var total = count(pane)
+        var direction = action === "tabNext" ? 1 : -1
+        selectAt(pane, (currentIndex(pane) + total + direction) % total)
+        return
+    }
+    if (action === "tabNew") {
+        openNew(pane)
+        return
+    }
+    if (action === "tabClose") {
+        closeAt(pane, currentIndex(pane))
+        return
+    }
+    if (action.length === 4 && action.indexOf("tab") === 0 && action.charAt(3) >= "1" && action.charAt(3) <= "9")
+        selectAt(pane, parseInt(action.charAt(3), 10) - 1)
+}
+
+// Last folder reopens every tab; a missing folder stays for the listing error to name.
+function remembered(pane) {
+    // The write lands before the pane moves, so the current tab reads dropPath.
+    var here = restingPath(pane)
+    if (here === pane.path && pane.dropPath)
+        here = pane.dropPath
+    var items = pane.tabs && pane.tabs.items && pane.tabs.items.length > 0 ? pane.tabs.items : null
+    if (!items)
+        return { paths: [here], index: 0 }
+    var index = currentIndex(pane)
+    var out = []
+    for (var i = 0; i < items.length; i++)
+        out.push(i === index ? here : String((items[i] || {}).path || ""))
+    return { paths: out, index: index }
+}
+
+// Without a Last-folder strip or with a named path there is no plan.
+function restorePlan(state, argvPath) {
+    if (argvPath && String(argvPath).length > 0)
+        return null
+    var data = state || {}
+    if ((data.startIn || "home") !== "last")
+        return null
+    var stored = data.lastTabs || null
+    var kept = stored && Array.isArray(stored.paths) ? stored.paths : []
+    for (var i = 0; i < kept.length; i++) {
+        if (typeof kept[i] !== "string" || kept[i].length === 0)
+            return null
+    }
+    var paths = []
+    for (var j = 0; j < kept.length && paths.length < MAX; j++)
+        paths.push(kept[j])
+    if (paths.length === 0)
+        return null
+    var index = stored && stored.index === Math.floor(stored.index) ? stored.index : 0
+    if (index < 0 || index >= paths.length)
+        index = Math.min(Math.max(index, 0), paths.length - 1)
+    return { paths: paths, index: index }
+}
+
+// A restored tab snapshots like a fresh tab, so view, sort and hidden come from the pane.
+function restoreItems(pane, paths) {
+    var out = []
+    for (var i = 0; i < paths.length; i++)
+        out.push(snapshot(pane, String(paths[i])))
+    return out
+}
+
+// A lift offers only private tab MIME; JSON preserves folder paths and cursor names verbatim.
+var TAB_MIME = "application/x-flea-tab"
+
+var TAB_VIEWS = ["list", "grid", "columns"]
+
+// An unset process id never owns a tab drag.
+var ownPid = ""
+
+function setOwnPid(pid) {
+    ownPid = String(pid || "")
+}
+
+// One lift's token: the pid names the window, the token names the lift inside it.
+var TOKEN_RANDOM_RANGE = 1000000000 // Spread simultaneous lifts across a billion random suffixes.
+function newToken() {
+    return String(Date.now()) + "-" + String(Math.floor(Math.random() * TOKEN_RANDOM_RANGE))
+}
+
+// The hand-off a tear-off gives the one window it starts; src/tearoff.rs drops the same names for Rust launches.
+var TEAR_OFF_ENV = ["FLEA_TAB_SOURCE_PID", "FLEA_TAB_CURSOR", "FLEA_TAB_TOKEN"]
+
+// Sample input: ["flea", "/tmp"] gives ["env", "-u", "FLEA_TAB_SOURCE_PID", "-u", "FLEA_TAB_CURSOR", "-u", "FLEA_TAB_TOKEN", "flea", "/tmp"].
+function freshLaunch(argv) {
+    var unset = ["env"]
+    for (var i = 0; i < TEAR_OFF_ENV.length; i++)
+        unset.push("-u", TEAR_OFF_ENV[i])
+    return unset.concat(argv)
+}
+
+// A lift names the live current tab or stored hidden tab, with the cursor name when available; null if absent.
+function tabInfo(pane, index) {
+    if (!pane)
+        return null
+    var total = count(pane)
+    if (index < 0 || index >= total)
+        return null
+    var here = restingPath(pane)
+    var current = currentIndex(pane)
+    var path, view, cursor
+    cursor = ""
+    if (index === current) {
+        path = here
+        view = pane.viewMode
+        if (here === pane.path) cursor = cursorFile(pane)
+    } else {
+        var items = currentItems(pane, here)
+        var item = items[index] || {}
+        path = String(item.path || "")
+        view = String(item.viewMode || "")
+        if (typeof item.cursorName === "string")
+            cursor = item.cursorName
+    }
+    if (!path || path.charAt(0) !== "/")
+        return null
+    return { path: path, view: view, cursor: cursor }
+}
+
+// JSON carries every path byte, including CR and LF.
+function tabPayload(pane, index, pid, token) {
+    var info = tabInfo(pane, index)
+    if (!info)
+        return ""
+    var who = pid === undefined ? ownPid : pid
+    var lift = token === undefined ? "" : token
+    return JSON.stringify([String(who), String(lift), String(info.path), String(info.view), String(info.cursor)])
+}
+
+// A tab drag offers only the private tab MIME.
+function tabDragMime(pane, index, pid, token) {
+    var payload = tabPayload(pane, index, pid, token)
+    if (!payload)
+        return {}
+    var mime = {}
+    mime[TAB_MIME] = payload
+    return mime
+}
+
+// Sample input: ["111","lift-1","/tmp/folder","list","note.txt"].
+function parseTabMime(payload) {
+    var fields = null
+    try {
+        fields = JSON.parse(String(payload))
+    } catch (error) {
+        return null
+    }
+    if (!Array.isArray(fields) || fields.length !== 5)
+        return null
+    var pid = String(fields[0] || "")
+    var token = String(fields[1] || "")
+    var path = String(fields[2] || "")
+    if (!/^[0-9]+$/.test(pid))
+        return null
+    if (token.length === 0 || /[\x00-\x1f\x7f]/.test(token))
+        return null
+    if (path.length === 0 || path.charAt(0) !== "/" || path.indexOf("\u0000") >= 0)
+        return null
+    return { pid: pid, token: token, path: path,
+             view: String(fields[3] || ""), cursor: String(fields[4] || "") }
+}
+
+// An own-window drag belongs to reorder and must not duplicate its tab.
+function isOwnTab(info, pid) {
+    var self = pid === undefined ? ownPid : String(pid)
+    return !!info && self.length > 0 && info.pid === self
+}
+
+function hasTabFormat(formats) {
+    return !!formats && formats.indexOf(TAB_MIME) >= 0
+}
+
+function enterAccepts(formats, payload, selfPid, canRecv, outActive) {
+    var text = String(payload || "")
+    if (text.length === 0)
+        return hasTabFormat(formats) && canRecv === true
+    var info = parseTabMime(text)
+    if (!info)
+        return false
+    var self = selfPid === undefined ? ownPid : String(selfPid)
+    if (self.length > 0 && info.pid === self)
+        return outActive === true
+    return canRecv === true
+}
+
+// Return the on-strip slot under x; off-strip drops never reach this helper, and the caller passes -1.
+function dropIndexAt(x, tabWidth, tabCount) {
+    return TabMove.insertionAt(x, tabWidth, tabCount)
+}
+
+// A catcher must compare the drop's global coordinates with the source window before tearing off.
+function catcherOutcome(rect, strip, x, y, tabWidth, tabCount) {
+    if (!rect || !(rect.width > 0) || !(rect.height > 0) || !isFinite(x) || !isFinite(y))
+        return { outcome: "cancel", at: -1 }
+    var localX = x - rect.x, localY = y - rect.y
+    if (localX < 0 || localY < 0 || localX >= rect.width || localY >= rect.height)
+        return { outcome: "tearoff", at: -1 }
+    if (strip && localX >= strip.x && localX < strip.x + strip.width
+            && localY >= strip.y && localY < strip.y + strip.height)
+        return { outcome: "return", at: dropIndexAt(localX - strip.x, tabWidth, tabCount) }
+    return { outcome: "cancel", at: -1 }
+}
+
+// A full strip refuses incoming tabs; a listing out is let go by the tab received.
+function canReceive(pane) {
+    if (!pane)
+        return false
+    return count(pane) < MAX
+}
+
+// A received foreign tab opens at the requested drop position.
+function receiveTab(pane, payload, at) {
+    if (!pane)
+        return false
+    var info = parseTabMime(payload)
+    if (!info || isOwnTab(info))
+        return false
+    if (count(pane) >= MAX) {
+        sayCount(pane, "Nine tabs is the most.")
+        return false
+    }
+    closePreview(pane)
+    var dropped = dropOverlay(pane)
+    var here = restingPath(pane)
+    var items = currentItems(pane, here)
+    var index = currentIndex(pane)
+    items[index] = snapshot(pane, here, items[index].tabIdentity, dropped)
+    var snap = snapshot(pane, info.path, undefined, dropped)
+    if (TAB_VIEWS.indexOf(info.view) >= 0)
+        snap.viewMode = info.view
+    if (info.cursor.length > 0)
+        snap.cursorName = info.cursor
+    var place = at >= 0 && at <= items.length ? at : items.length
+    items.splice(place, 0, snap)
+    pane.tabs = pack(items, place)
+    dropCount(pane)
+    apply(pane, snap, dropped, info.cursor)
+    return true
+}
+
+// A window's lone tab cannot be lifted out of its hidden strip.
+function canLift(pane) {
+    return count(pane) >= 2
+}
+
+// Only the outstanding lift's token may acknowledge that lift.
+function takeToken(stored, token) {
+    return !!stored && stored.length > 0 && stored === String(token || "")
+}
+
+// An unacknowledged lift expires after one network leg's 15 s bound (ui/NetworkMounts.qml mountTimeout).
+var ACK_WAIT_MS = 15000
+
+function ackCloses(stored, token, liftedAt, now) {
+    if (!takeToken(stored, token))
+        return false
+    if (liftedAt > 0 && now - liftedAt > ACK_WAIT_MS)
+        return false
+    return true
+}
+
+// B's synchronous take decision at drop time; the async peek may still refuse, and then no ack goes out.
+var DROP_TAKE = "move"
+var DROP_IGNORE = "ignore"
+function dropDecision(info, selfPid, outActive, canRecv) {
+    if (!info)
+        return DROP_IGNORE
+    if (isOwnTab(info, selfPid))
+        return outActive === true ? DROP_TAKE : DROP_IGNORE
+    return canRecv === true ? DROP_TAKE : DROP_IGNORE
+}
+
+// Moving a tab must never close the window's only remaining tab.
+function closeTabAfterMove(pane, index) {
+    if (!pane)
+        return "kept"
+    var total = count(pane)
+    if (index < 0 || index >= total)
+        return "kept"
+    if (total <= 1)
+        return "kept"
+    closeAt(pane, index)
+    return "closed"
+}
+
+// A rename editor prevents its tab from leaving the window.
+function tearRefusal(pane) {
+    if (!pane)
+        return ""
+    if (pane.listInFlight)
+        return "A directory is already loading."
+    if (pane.renamePending === true)
+        return "Finish the rename before dragging a tab out."
+    if (typeof pane.renameEditor === "function" && pane.renameEditor())
+        return "Finish the rename before dragging a tab out."
+    return ""
+}
+
+// Tab lookup uses the live path for the current tab and stored paths for hidden tabs.
+function indexOfPath(pane, path) {
+    if (!pane || !path)
+        return -1
+    var here = restingPath(pane)
+    var items = currentItems(pane, here)
+    var current = currentIndex(pane)
+    for (var i = 0; i < items.length; i++) {
+        var named = i === current ? here : String((items[i] || {}).path || "")
+        if (named === path)
+            return i
+    }
+    return -1
+}
+
+// A lift captures pane and identity; indices and paths may change while its ack travels.
+function captureLift(pane, index, token, now) {
+    var items = currentItems(pane)
+    if (index < 0 || index >= items.length) return null
+    for (var i = 0; i < items.length; i++)
+        if (!items[i].tabIdentity) items[i].tabIdentity = ++nextTabIdentity
+    if (!pane.tabs) pane.tabs = pack(items, 0)
+    return { token: token, pane: pane, identity: items[index].tabIdentity, liftedAt: now, taken: false }
+}
+
+function resolveMovedTab(pane, identity) {
+    if (!pane || !pane.tabs || !identity) return -1
+    var items = pane.tabs.items
+    for (var i = 0; i < items.length; i++)
+        if (items[i].tabIdentity === identity) return i
+    return -1
+}
+
+function liftFor(lifts, token) {
+    for (var i = 0; i < lifts.length; i++)
+        if (takeToken(lifts[i].token, token)) return lifts[i]
+    return null
+}