flea-qml 0.1.0 → 0.2.0

package/test/manual-terminal-navigation.mjs

@@ -0,0 +1,48 @@
+// bun test/manual-terminal-ui.mjs (requires the sibling buninu-browser checkout).
+import {mkdtempSync,mkdirSync,rmSync} from 'node:fs';
+import {join} from 'node:path';
+import {tmpdir} from 'node:os';
+import assert from 'node:assert/strict';
+const repo=Bun.fileURLToPath(new URL('../',import.meta.url));
+const dir=mkdtempSync(join(tmpdir(),'flea-terminal-ui-'));
+process.env.XDG_DATA_HOME=join(dir,'data');process.env.XDG_CONFIG_HOME=join(dir,'config');process.env.XDG_CACHE_HOME=join(dir,'cache');process.env.FLEA_PATH=dir;process.env.BUNINU_BUN=process.execPath;
+for(const p of ['data','config','cache'])mkdirSync(join(dir,p));
+const {createBrowser}=await import('../../buninu-browser/lib/headless-shell.js');
+const file=join(repo,'ui/boot/.terminal-check-'+process.pid+'.qml');
+await Bun.write(file,`import QtQuick\nimport Quickshell\nimport ".." as Flea\nimport "../js/Tabs.js" as Tabs\nFloatingWindow { id: win; width:900; height:600; Loader {anchors.fill:parent; source:"../WindowBody.qml";onLoaded:{item.host=win;globalThis.testTabs=Tabs;globalThis.testBody=item;globalThis.terminalService=Flea.TerminalService}} }`);
+const browser=await createBrowser({spareRenderer:false});
+const run=s=>browser.context.evaluate(s);
+const until=async(s)=>{for(let i=0;i<200;i++){if(await run(s))return;await Bun.sleep(100);}throw Error('UI timeout '+s+' '+await run('document.body.innerText.slice(-2500)'));};
+try {
+ await browser.context.navigate(Bun.pathToFileURL(file).href);
+ await until('!!globalThis.testBody && !testBody.currentPane.listInFlight');
+ await run('testBody.currentPane.openTerminal()');
+ await until('!!testBody.currentPane.terminalId');
+ await until('Object.values(terminalService.tabs).some(t=>t.url?.includes("reconnect-token"))');
+ const one=await run('Object.values(terminalService.tabs)[0].url');
+
+
+
+ await until('!!document.querySelector("canvas")');
+ await browser.context.click(400,100);
+ await run('testTabs.selectAt(testBody.currentPane,0)');
+ await Bun.sleep(100);
+ console.log('ordinary focus',await run('({focus:testBody.currentPane.activeFocus,active:document.activeElement.tagName,id:testBody.currentPane.terminalId})'));
+ const cursor=await run('testBody.currentPane.cursorIndex');
+ await browser.context.press('ArrowDown');
+ assert.equal(await run('testBody.currentPane.cursorIndex'),cursor+1,'ArrowDown must reach the ordinary list');
+ await browser.context.press('ArrowUp');
+ assert.equal(await run('testBody.currentPane.cursorIndex'),cursor);
+ await browser.context.press('t');
+ assert.equal(await run('testBody.currentPane.tabs.items.length'),3,'ordinary t must work after terminal switch');
+ await browser.context.press('t',{modifiers:2,code:'KeyT'});
+ assert.equal(await run('testBody.currentPane.tabs.items.length'),4,'Ctrl+T must open another terminal');
+ console.log('PASS terminal -> ordinary -> arrows -> t -> Ctrl+T');
+ await run('testTabs.closeAt(testBody.currentPane,testBody.currentPane.tabs.index)');
+ await Bun.sleep(100);
+ assert.equal(await run('testBody.currentPane.activeFocus'),true,'closing terminal returns focus');
+ await browser.context.press('t',{modifiers:2,code:'KeyT'});
+ assert.equal(await run('testBody.currentPane.tabs.items.length'),4);
+ console.log('PASS close terminal -> ordinary -> Ctrl+T');
+
+}finally{await browser.close();rmSync(file,{force:true});rmSync(dir,{recursive:true,force:true});}

package/test/manual-terminal-ui.mjs

@@ -0,0 +1,47 @@
+// bun test/manual-terminal-ui.mjs (requires the sibling buninu-browser checkout).
+import {mkdtempSync,mkdirSync,rmSync} from 'node:fs';
+import {join} from 'node:path';
+import {tmpdir} from 'node:os';
+import assert from 'node:assert/strict';
+const repo=Bun.fileURLToPath(new URL('../',import.meta.url));
+const dir=mkdtempSync(join(tmpdir(),'flea-terminal-ui-'));
+process.env.XDG_DATA_HOME=join(dir,'data');process.env.XDG_CONFIG_HOME=join(dir,'config');process.env.XDG_CACHE_HOME=join(dir,'cache');process.env.FLEA_PATH=dir;process.env.BUNINU_BUN=process.execPath;
+for(const p of ['data','config','cache'])mkdirSync(join(dir,p));
+const {createBrowser}=await import('../../buninu-browser/lib/headless-shell.js');
+const file=join(repo,'ui/boot/.terminal-check-'+process.pid+'.qml');
+await Bun.write(file,`import QtQuick\nimport Quickshell\nimport ".." as Flea\nFloatingWindow { id: win; width:900; height:600; Loader {anchors.fill:parent; source:"../WindowBody.qml";onLoaded:{item.host=win;globalThis.testBody=item;globalThis.terminalService=Flea.TerminalService}} }`);
+const browser=await createBrowser({spareRenderer:false});
+const run=s=>browser.context.evaluate(s);
+const until=async(s)=>{for(let i=0;i<200;i++){if(await run(s))return;await Bun.sleep(100);}throw Error('UI timeout '+s+' '+await run('document.body.innerText.slice(-2500)'));};
+try {
+ await browser.context.navigate(Bun.pathToFileURL(file).href);
+ await until('!!globalThis.testBody && !testBody.currentPane.listInFlight');
+ await run('testBody.currentPane.openTerminal()');
+ await until('!!testBody.currentPane.terminalId');
+ await until('Object.values(terminalService.tabs).some(t=>t.url?.includes("reconnect-token"))');
+ const one=await run('Object.values(terminalService.tabs)[0].url');
+ await run('testBody.currentPane.openTerminal()');
+ await until('Object.values(terminalService.tabs).length===2 && Object.values(terminalService.tabs).every(t=>t.url?.includes("reconnect-token"))');
+ const urls=await run('Object.values(terminalService.tabs).map(t=>t.url)');
+ assert.equal(new URL(urls[0]).host,new URL(urls[1]).host);assert.notEqual(urls[0],urls[1]);
+ assert.equal(await run('testBody.currentPane.tabs.items.length'),3);
+ console.log('PASS two terminal tabs, shared listener, distinct sessions',new URL(one).port);
+ // Child frame text confirms scripts load; input/PTY tested separately by the wire test.
+ await Bun.sleep(12000);
+ const target=new URL(urls[1]);
+ const monitor=new WebSocket(target.origin+target.pathname.replace(/\/$/,'/ws').replace(/^http/,'ws'),'webtty');
+ let output='';
+ monitor.onopen=()=>monitor.send(JSON.stringify({AuthToken:'',ReadOnly:true,ReconnectToken:target.searchParams.get('reconnect-token')}));
+ monitor.onmessage=e=>{const data=String(e.data);if(data[0]==='1')output+=Buffer.from(data.slice(1),'base64').toString();};
+ await Bun.sleep(200);
+ assert.equal(await run('document.activeElement.tagName'),'TEXTAREA','new terminal must own keyboard without a click');
+ for(const key of "printf '%s%s\\n' FLEA_ QTWEB_OK")await browser.context.press(key);
+ await browser.context.press('Enter');
+ for(let i=0;i<100&&!output.includes('FLEA_QTWEB_OK');i++)await Bun.sleep(100);
+ monitor.close();
+ assert(output.includes('FLEA_QTWEB_OK'),'Keyboard did not reach terminal: '+output);
+ console.log('PASS keyboard traverses QML WebEngineView to its PTY');
+ await Bun.write('/tmp/flea-terminal-tabs.png',Buffer.from(await browser.context.screenshot({format:'png'}),'base64')); 
+ console.log('canvas',await run('[...document.querySelectorAll("canvas")].map(c=>({w:c.width,h:c.height,box:c.getBoundingClientRect().toJSON()}))'));
+ console.log('frames',await run('[...document.querySelectorAll("iframe")].map(f=>({src:f.src,text:f.contentDocument?.body?.innerText?.slice(-500)}))'));
+}finally{await browser.close();rmSync(file,{force:true});rmSync(dir,{recursive:true,force:true});}

package/test/trashbrowse.test.js

@@ -14,7 +14,7 @@ test('Trash list, restore, collisions and single-use deletion',()=>{
  writeFileSync(a.original,'new');expect(call('restore',{uris:[a.uri],identities:[a.identity]}).failed).toBe(1);
  expect(readFileSync(a.original,'utf8')).toBe('new');rmSync(a.original);
  expect(call('restore',{uris:[a.uri],identities:[a.identity]}).done).toBe(1);expect(readFileSync(a.original,'utf8')).toBe('payload');
- const b=item('b');const {token}=call('prepare',{uris:[b.uri],identities:[b.identity]});
+ const b=item('b');const prepared=call('prepare',{uris:[b.uri],identities:[b.identity]});expect(prepared.name).toBe('b');const {token}=prepared;
  expect(call('check',{token}).valid).toBe(true);expect(call('delete',{token}).done).toBe(1);expect(call('delete',{token}).ok).toBe(false);
 });
 test('cancel and failed replacement reviews invalidate deletion tokens',()=>{

package/ui/ArchiveCards.qml

@@ -18,7 +18,7 @@ Item {
 
     // One card at a time: a second request is answered with a sentence and never dropped silently.
     function cardBusy(holder) {
-        if (!compressDialog.opened && !extractDialog.opened)
+        if (!compressDialog.opened && !extractDialog.opened && !hereDialog.opened)
             return false
         holder.message(ArchiveCard.CARD_BUSY, true)
         return true
@@ -38,6 +38,33 @@ Item {
         extractDialog.item.open(source, holder, err)
     }
 
+    function askExtractHere(holder, path, entries) {
+        if (cardBusy(holder)) return
+        var dest = path.substring(0, path.lastIndexOf("/") + 1)
+        if (entries >= 0 && entries <= 5) {
+            holder.backend.extractHere(path, dest, false)
+            return
+        }
+        hereDialog.active = true
+        hereDialog.item.open({ path: path, dest: dest, entries: entries, holder: holder, focusItem: holder.preview && holder.preview.active ? holder.preview : holder })
+    }
+
+    Loader {
+        id: hereDialog
+        anchors.fill: parent
+        active: false
+        source: "ArchiveHereConfirm.qml"
+        readonly property bool opened: item !== null && item.opened
+    }
+    Connections {
+        target: hereDialog.item
+        function onConfirmed(source) {
+            source.holder.backend.extractHere(source.path, source.dest, true)
+            source.focusItem.forceActiveFocus()
+        }
+        function onCancelled() { if (hereDialog.item.snapshot.focusItem) hereDialog.item.snapshot.focusItem.forceActiveFocus() }
+    }
+
     anchors.fill: parent
 
     Loader {

package/ui/ArchiveHereConfirm.qml

@@ -0,0 +1,127 @@
+import QtQuick
+import qs.Commons
+import "." as Flea
+
+// Bulk extraction is deliberate: Enter defaults to Cancel, as in permanent deletion.
+FocusScope {
+    id: root
+    anchors.fill: parent
+    visible: opened || opacity > 0
+    // Closed means no input, even while the fade-out is still drawn.
+    enabled: opened
+    opacity: 0
+    property bool opened: false
+    property var snapshot: ({})
+    property bool destructiveFocus: false
+    readonly property real referenceScale: Theme.font.bodySmall / 13
+    readonly property real cardPadding: Math.round(16 * referenceScale)
+    readonly property real cardBottomPadding: Theme.spacing.rowPaddingX
+    signal confirmed(var source)
+    signal cancelled()
+    readonly property var cardItem: card
+    readonly property var cancelItem: cancelButton
+    readonly property var dangerItem: dangerButton
+    readonly property string titleText: title.text
+    readonly property string bodyText: bodyLabel.text
+    function open(value) { snapshot = value; destructiveFocus = false; body.contentY = 0; opened = true; forceActiveFocus() }
+    function close() { opened = false }
+    function cancel() { close(); cancelled() }
+    function activate() {
+        if (!destructiveFocus) { cancel(); return }
+        var source = snapshot
+        close()
+        confirmed(source)
+    }
+    Flea.Reveal { target: root; shown: root.opened; lift: card }
+    Keys.onPressed: function(event) {
+        if (event.key === Qt.Key_Escape) root.cancel()
+        else if (event.modifiers & (Qt.ControlModifier | Qt.AltModifier | Qt.MetaModifier)) { event.accepted = true; return }
+        else if (event.key === Qt.Key_Tab || event.key === Qt.Key_Backtab) root.destructiveFocus = !root.destructiveFocus
+        else if (event.key === Qt.Key_L || event.key === Qt.Key_Right) root.destructiveFocus = true
+        else if (event.key === Qt.Key_H || event.key === Qt.Key_Left) root.destructiveFocus = false
+        else if (event.key === Qt.Key_Return || event.key === Qt.Key_Enter || event.key === Qt.Key_Space) root.activate()
+        if (root.opened) body.reveal(root.destructiveFocus ? dangerButton : cancelButton)
+        event.accepted = true
+    }
+    Rectangle {
+        anchors.fill: parent
+        color: Theme.color.background
+        opacity: 0.5
+        MouseArea {
+            anchors.fill: parent
+            hoverEnabled: true
+            acceptedButtons: Qt.LeftButton | Qt.RightButton
+            onClicked: root.cancel()
+            onWheel: function(wheel) { wheel.accepted = true }
+        }
+    }
+    Rectangle {
+        id: card
+        x: Theme.cardOrigin(root.width, width)
+        y: Theme.cardOrigin(root.height, height)
+        // TrashSidebar's 340px content width excludes its two 16px paddings and hairlines.
+        width: Theme.cardSpan(Math.round(340 * root.referenceScale * Theme.dialogWidthRatio) + 2 * root.cardPadding + 2 * Theme.spacing.hairline, root.width - 2 * Theme.spacing.gap)
+        height: Theme.cardSpan(body.wanted + root.cardPadding + root.cardBottomPadding + 2 * Theme.spacing.hairline, root.height - 2 * Theme.spacing.gap)
+        color: Theme.color.surface
+        border.color: Theme.color.mutedFrame
+        border.width: Theme.spacing.hairline
+        radius: Style.cornerRadius
+        MouseArea {
+            anchors.fill: parent
+            hoverEnabled: true
+            acceptedButtons: Qt.LeftButton | Qt.RightButton
+            onWheel: function(wheel) { wheel.accepted = true }
+        }
+        Flea.CardFrame {
+            id: body
+            bleed: Theme.focusClearance
+            anchors.fill: parent
+            anchors.leftMargin: root.cardPadding + Theme.spacing.hairline - Theme.focusClearance
+            anchors.rightMargin: root.cardPadding + Theme.spacing.hairline - Theme.focusClearance
+            anchors.topMargin: root.cardPadding + Theme.spacing.hairline - Theme.focusClearance
+            anchors.bottomMargin: root.cardBottomPadding + Theme.spacing.hairline - Theme.focusClearance
+            title: Row {
+                width: parent.width
+                spacing: Theme.spacing.gap
+                Flea.Glyph { id: alertMark; width: Theme.font.bodySmall * 1.3; height: title.height; name: "alert"; color: Theme.color.error }
+                Text {
+                    id: title
+                    width: parent.width - alertMark.width - parent.spacing
+                    text: "Extract here?"
+                    textFormat: Text.PlainText
+                    wrapMode: Text.Wrap
+                    color: Theme.color.foreground
+                    font { family: Theme.font.family; pixelSize: Theme.font.body; bold: true }
+                }
+            }
+            buttons: Flow {
+                width: Math.min(parent.width, cancelButton.implicitWidth + dangerButton.implicitWidth + spacing)
+                anchors.right: parent.right
+                spacing: Theme.spacing.gap
+                Flea.DialogButton {
+                    id: cancelButton
+                    label: "Cancel"
+                    primary: true
+                    focused: !root.destructiveFocus
+                    onActivated: root.cancel()
+                }
+                Flea.DialogButton {
+                    id: dangerButton
+                    label: "Extract here"
+                    destructive: true
+                    focused: root.destructiveFocus
+                    onActivated: { root.destructiveFocus = true; root.activate() }
+                }
+            }
+            Text {
+                id: bodyLabel
+                width: parent.width
+                text: (root.snapshot.entries >= 0 ? root.snapshot.entries + " top-level items" : "This archive") + " will be extracted into:\n" + root.snapshot.dest + "\n\nExisting names will get a copy suffix. Continue?"
+                textFormat: Text.PlainText
+                wrapMode: Text.Wrap
+                color: Theme.color.foreground
+                font { family: Theme.font.family; pixelSize: Theme.font.body }
+            }
+        }
+    }
+}

package/ui/Backend.qml

@@ -121,7 +121,7 @@ Item {
     property int compareToken: 0
     // One counter numbers every PDF fetch, so two viewers never share an id.
     property int pdfCopySeq: 0
-    signal meta(int row, int w, int h, int orient, real durationMs, int sampleRate, int entries, real unpacked, bool archiveFailed, var names, real lines, bool partial, bool linesFailed, string target, bool targetDir, string owner)
+    signal meta(int row, int w, int h, int orient, real durationMs, int sampleRate, int entries, real unpacked, bool archiveFailed, var names, real lines, bool partial, bool linesFailed, string target, bool targetDir, string owner, int topEntries)
     signal shebang(string path, bool hasShebang, int id)
     // A PDF fetched into a session-private copy under a deadline; err names the refusal, stalled is the wait that ran out.
     signal pdfCopied(int id, string path, string err, bool stalled)
@@ -566,6 +566,10 @@ Item {
                     password: password, encryptNames: encryptNames === true, menuId: menuId || 0 })
     }
 
+    function extractHere(path, dest, confirmed) {
+        root.send({ c: "archive", op: "extract", path: path, dest: dest, here: true, confirmed: confirmed === true })
+    }
+
     function extract(path, dest, menuId) {
         root.send({ c: "archive", op: "extract", path: path, dest: dest, menuId: menuId || 0 })
     }

package/ui/ColumnPane.qml

@@ -286,6 +286,8 @@ Item {
 
     ListView {
         id: view
+        // The shared pane owns selection and arrow navigation, including after rename.
+        keyNavigationEnabled: false
         anchors.top: columnHeader.bottom
         anchors.left: parent.left
         anchors.right: parent.right

package/ui/Opener.qml

@@ -2,38 +2,24 @@ import Quickshell
 import Quickshell.Io
 import QtQuick
 
-// The one component that runs Flea's own opening modes, so the huge page corner has one owner; see AGENTS.md "Opening a file".
+// Open files through xdg-open on PATH on every platform, including Windows.
 Item {
     id: root
 
     signal failed(string path)
-    signal isDirectory(string path)
     signal terminalFailed(string path)
     // Raised where the two single-flight guards below drop a request, so a swallowed press says so.
     signal busy(string path)
     signal terminalBusy(string path)
-    // flea --open answers 4 with the run card's own ask line on stdout, and 5 where no application claims the file.
-    signal askRunRaw(string path, string text)
-    signal askOpenWith(string path)
-
-    // The status src/open.rs returns for a directory, which the caller navigates to instead.
-    readonly property int isDirectoryStatus: 3
-    // The two statuses src/runfile.rs added beside it: ask the card, or ask Open with.
-    readonly property int askRunStatus: 4
-    readonly property int askOpenWithStatus: 5
-
     property string current: ""
     // The terminal launch's own path: open() and openTerminal() run on separate
     // Processes guarded only against themselves, so sharing current let whichever
     // started second rewrite the path the first one's onExited still reports.
     property string terminalCurrent: ""
-    // One open at a time: pending is the launch with no exit yet, and the stream arrives before the exit.
+    // One open at a time until xdg-open exits.
     property bool pending: false
-    property string askText: ""
+    property int openSerial: 0
 
-    // flea --open waits for gio open and not for the application it starts, and that wait is 11 to 15 ms
-    // for an Exec= handler but 0.32 to 0.75 s for a DBusActivatable one, which is what this box's
-    // twenty-five archive types default to, so this guard drops a second Enter for that long and says so.
     function open(path) {
         if (child.running || root.pending) {
             root.busy(path)
@@ -41,38 +27,32 @@ Item {
         }
         root.current = path
         root.pending = true
-        root.askText = ""
-        child.command = [Quickshell.env("FLEA_BIN") || "flea", "--open", path]
+        root.openSerial++
+        child.command = ["xdg-open", path]
         child.running = true
     }
 
     Process {
         id: child
-        stdout: StdioCollector {
-            waitForEnd: true
-            onStreamFinished: root.askText = this.text
-        }
-
-        // An ask status without its line is a launch that died mid-answer, so it says the plain failure and opens no card.
+        // xdg-open's nonzero exit codes are failures, not Flea's private statuses.
         onExited: function (exitCode, exitStatus) {
             root.pending = false
-            if (exitCode === 0)
-                return
-            if (exitCode === root.isDirectoryStatus)
-                root.isDirectory(root.current)
-            else if (exitCode === root.askRunStatus && root.askText !== "")
-                root.askRunRaw(root.current, root.askText)
-            else if (exitCode === root.askOpenWithStatus)
-                root.askOpenWith(root.current)
-            else
+            if (exitCode !== 0 || exitStatus !== 0)
                 root.failed(root.current)
         }
         // A program that never started reports no exit, only running turning false.
         onRunningChanged: {
             if (child.running || !root.pending)
                 return
-            root.pending = false
-            root.failed(root.current)
+            // running may change before onExited. Let that signal settle first;
+            // a deferred failure must not apply to a later open request.
+            var serial = root.openSerial
+            Qt.callLater(function () {
+                if (root.pending && !child.running && root.openSerial === serial) {
+                    root.pending = false
+                    root.failed(root.current)
+                }
+            })
         }
     }
 

package/ui/Pane.qml

@@ -271,6 +271,7 @@ FocusScope {
     // Archives040: the password compress resolves through the cards host, which Focus reaches
     // through this signal so Focus takes no new first-frame import.
     signal compressPasswordRequested(var paths, int menuId)
+    signal extractHereRequested(string path, int entries)
     signal extractPasswordRequested(string path, string dest, string err)
     signal permissionsRequested(string path)
     // MenuAdditions040: the whole selection's paths for the multi-row card.
@@ -449,6 +450,18 @@ FocusScope {
     property var history: []
     property var forwardHistory: []
     property var tabs: null
+    property string terminalId: ""
+    onTerminalIdChanged: {
+        if (!terminalId) Qt.callLater(function() {
+            // A hidden WebEngineView no longer owns input. Wait until tab visibility
+            // settles, then return focus to the file list (not the old scope child).
+            if (!root.terminalId) {
+                root.focusView = Focus.LIST
+                root.listArea.forceActiveFocus()
+            }
+        })
+    }
+    readonly property var terminalHost: terminalLoader.item
     property int tabCountNotice: -1
     readonly property bool canGoBack: trashHost.opened || root.recentMode.length > 0 || root.history.length > 0
     readonly property bool canGoUp: root.path.length > 1 || root.recentMode.length > 0 || Nav.climbsFromListing(root)
@@ -851,7 +864,18 @@ FocusScope {
     function openFile(path) { wire.opener.open(path) }
 
     // A terminal in the caller's place or the directory being shown, through flea --terminal.
-    function openTerminal(path) { wire.opener.openTerminal(path || root.path) }
+    function openTerminal(path) {
+        terminalLoader.active = true
+        Tabs.openTerminal(root, path || root.path)
+    }
+    Loader {
+        id: terminalLoader
+        active: false
+        anchors { top: parent.top; left: railHost.right; right: parent.right; bottom: parent.bottom }
+        z: 1
+        source: "TerminalTabs.qml"
+        onLoaded: item.pane = root
+    }
 
     function newWindow() { Quickshell.execDetached(Tabs.freshLaunch([Quickshell.env("FLEA_BIN") || "flea", root.path])) }
 

package/ui/PaneRail.qml

@@ -33,12 +33,38 @@ Item {
     function focusPress(p) {
         var pane = root.pane
         if (p.x < 0 || p.y < 0 || p.x >= pane.width || p.y >= pane.height) return
+        // Preserve an input caret when the press is inside that very editor.
+        var focused = pane.Window.window ? pane.Window.window.activeFocusItem : null
+        if (focused && focused.cursorPosition !== undefined && focused.mapFromItem) {
+            var caret = focused.mapFromItem(pane, p.x, p.y)
+            if (caret.x >= 0 && caret.y >= 0 && caret.x < focused.width && caret.y < focused.height) return
+        }
         // The shown Sidebar can extend past its zero-width overlay host.
         var sidebar = root.item
         var r = sidebar ? sidebar.mapFromItem(pane, p.x, p.y) : null
         if (!root.hidden && r && r.x >= 0 && r.y >= 0 && r.x < sidebar.width && r.y < sidebar.height) {
-            if (root.overlay) pane.railPane.focusView = Focus.RAIL
-        } else { pane.focusView = Focus.LIST; pane.focusRequested() }
+            pane.railPane.focusView = Focus.RAIL
+            if (!sidebar.renameEditor()) sidebar.forceActiveFocus()
+        } else {
+            if (pane.terminalId) return
+            var preview = pane.previewColumnItem
+            if (preview && preview.visible) {
+                var at = preview.mapFromItem(pane, p.x, p.y)
+                if (at.x >= 0 && at.y >= 0 && at.x < preview.width && at.y < preview.height) {
+                    preview.forceActiveFocus()
+                    return
+                }
+            }
+            var list = pane.listArea
+            if (!list || !list.visible) return
+            var local = list.mapFromItem(pane, p.x, p.y)
+            if (local.x < 0 || local.y < 0 || local.x >= list.width || local.y >= list.height) return
+            // Keep a live rename's caret and click-away commit semantics.
+            if (pane.renameEditor()) return
+            pane.focusView = Focus.LIST
+            pane.focusRequested()
+            list.forceActiveFocus()
+        }
     }
 
     // Long enough that crossing the edge on the way somewhere else does not flash the rail, and that
@@ -161,7 +187,10 @@ Item {
             menu: root.pane.railPane.contextMenu()
             onRenameFinished: root.pane.railPane.listArea.forceActiveFocus()
             // The pane's own PointHandler never sees a press a row grabs, so an overlay rail claims the keyboard itself; a docked rail leaves it.
-            onPressed: if (root.overlay) root.pane.railPane.focusView = Focus.RAIL
+            onPressed: {
+                root.pane.railPane.focusView = Focus.RAIL
+                if (!sidebar.renameEditor()) sidebar.forceActiveFocus()
+            }
             onReleasingChanged: root.holdRelease(sidebar.releasing)
         }
         // Disabled with the Sidebar, so an unload under the pointer clears it; a handler inside the Sidebar dies without reporting.

package/ui/PaneWire.qml

@@ -79,14 +79,10 @@ Item {
         id: opener
         // A dropped request is the app being busy, not a failure, so it takes the plain role.
         onBusy: function (path) { pane.message("Still opening the last file; try again in a moment.", false) }
-        // canonicalize proved the path before every failure src/open.rs and src/terminal.rs report under their one status, so neither sentence below names a cause.
-        onFailed: function (path) { pane.message("No application on this system opened that file.", true) }
-        onIsDirectory: function (path) { pane.open(path) }
+        onFailed: function (path) { pane.message("xdg-open could not open that file. Make sure xdg-open is available on PATH.", true) }
         onTerminalBusy: function (path) { pane.message("Still opening the last terminal; try again in a moment.", false) }
         onTerminalFailed: function (path) { pane.message("No terminal on this system opened that folder.", true) }
-        // The run card's own answers: a program asks once on its raw ask line, and a file no application claims asks Open with.
-        onAskRunRaw: function (path, text) { pane.askRunCard({ path: path, raw: text }) }
-        onAskOpenWith: function (path) { pane.showOpenWith(path) }
+
     }
 
     Flea.ShareLink {

package/ui/Preview.qml

@@ -641,9 +641,9 @@ Item {
 
     Connections {
         target: root.pane ? root.pane.backend : null
-        function onMeta(row, w, h, orient, durationMs, sampleRate, entries, unpacked, archiveFailed, names, lines, partial, linesFailed, target, targetDir, owner) {
+        function onMeta(row, w, h, orient, durationMs, sampleRate, entries, unpacked, archiveFailed, names, lines, partial, linesFailed, target, targetDir, owner, topEntries) {
             if (root.isArchive && row === root.archiveRow)
-                root.archiveMeta = { entries: entries, unpacked: unpacked, archiveFailed: archiveFailed, names: names }
+                root.archiveMeta = { topEntries: typeof topEntries === "number" ? topEntries : -1, entries: entries, unpacked: unpacked, archiveFailed: archiveFailed, names: names }
             if (root.isMedia && row === root.mediaRow)
                 root.mediaRate = sampleRate
             if (root.isImage && !root.isRawFile && row === root.imageRow && root.imageRowShown()) {
@@ -916,6 +916,7 @@ Item {
                 visible: root.isArchive && root.archiveMeta !== null && !root.archiveFailed
                 path: root.path
                 meta: root.archiveMeta
+                pane: root.pane
             }
 
             // Declined, or an archive whose index could not be read: a mark over the sentence, never a bare surface.

package/ui/PreviewArchive.qml

@@ -3,6 +3,7 @@ import qs.Commons
 import "." as Flea
 import "js/Facts.js" as Facts
 import "js/Format.js" as Format
+import "js/Archive.js" as Archive
 
 // The Archive tile's frame: the entries the wire carried, as many as the frame has room for, and the
 // count it could not name. One row per line box, less the "+ N more" line, which always has to be
@@ -12,12 +13,36 @@ Item {
 
     // The meta answer for the archive row, or null before one has arrived.
     property var meta: null
+    property string path: ""
+    property var pane: null
+    readonly property bool extractable: pane !== null && /\.(zip|tar|tar\.gz|tgz|tar\.zst|tzst)$/i.test(path) && meta !== null && !meta.archiveFailed
+
+    Flow {
+        id: actions
+        width: parent.width
+        spacing: Theme.spacing.gap
+        visible: root.extractable
+        Flea.DialogButton {
+            label: "Extract to Folder"
+            tabStop: true
+            onActivated: {
+                var base = root.path.substring(0, root.path.lastIndexOf("/") + 1)
+                root.pane.backend.extract(root.path, base + Archive.extractDir(root.path.substring(base.length)), 0)
+            }
+        }
+        Flea.DialogButton {
+            label: "Extract here"
+            tabStop: true
+            onActivated: root.pane.extractHereRequested(root.path, root.meta && typeof root.meta.topEntries === "number" ? root.meta.topEntries : -1)
+        }
+    }
 
     readonly property real lineHeight: Math.round(Theme.font.caption * Theme.lineBoxRatio)
-    readonly property int shown: Math.max(0, Math.floor(height / lineHeight) - 1)
+    readonly property int shown: Math.max(0, Math.floor((height - (actions.visible ? actions.height + Theme.spacing.gap : 0)) / lineHeight) - 1)
 
     Column {
         anchors.fill: parent
+        anchors.topMargin: actions.visible ? actions.height + Theme.spacing.gap : 0
         clip: true
         spacing: 0
 

package/ui/PreviewColumn.qml

@@ -327,6 +327,8 @@ Item {
                 anchors.margins: Theme.spacing.gap
                 visible: root.previewState === Facts.ARCHIVE && root.meta !== null
                 meta: root.meta
+                path: root.path
+                pane: root.pane
             }
 
             Flea.LoadingState {

package/ui/QuickLookArchive.qml

@@ -9,6 +9,7 @@ Column {
     spacing: Theme.spacing.gap
     property string path: ""
     property var meta: null
+    property var pane: null
 
     // corner: a filename is arbitrary text, so PlainText, the same rule every name on this surface follows.
     Text {
@@ -34,5 +35,7 @@ Column {
         width: parent.width
         height: parent.height - y
         meta: root.meta
+        path: root.path
+        pane: root.pane
     }
 }

package/ui/SelectionPreview.qml

@@ -360,7 +360,7 @@ Flea.PreviewColumn {
                     || root.loadedIdentity !== root.identity(root.pane.rowFor(root.loadedIndex))) return
             root.pendingToken = 0
             root.meta = { w: message.w, h: message.h, durationMs: message.ms, sampleRate: message.rate,
-                entries: message.entries, unpacked: message.unpacked, archiveFailed: message.afailed,
+                topEntries: typeof message.topEntries === "number" ? message.topEntries : -1, entries: message.entries, unpacked: message.unpacked, archiveFailed: message.afailed,
                 names: message.names, lines: message.lines, partial: message.partial,
                 linesFailed: message.lfailed, target: message.target, targetDir: message.targetdir,
                 owner: message.owner || "", orient: message.orient || 1, frames: message.frames || 0, photo: message.photo || null }

package/ui/Sidebar.qml

@@ -713,15 +713,11 @@ Item {
         rest -= root.networkEntries.length
         return devRepeater.itemAt(rest)
     }
-    // Above the Flickable and every row, because a PointHandler under their exclusive press grab is never given the press; a passive handler leaves the press to the row.
-    Item {
-        anchors.fill: parent
-        z: 1
-        PointHandler {
-            acceptedButtons: Qt.AllButtons
-            // After pressed(), which can hand an overlay rail the keyboard, so the press that claimed it still hides the frame.
-            onActiveChanged: if (active) { root.pressed(); if (root.focused) root.pointerFocus = true }
-        }
+    // Observe the whole sidebar, including its empty background. A sibling
+    // overlay does not receive DOM events dispatched to rows beneath it.
+    PointHandler {
+        acceptedButtons: Qt.AllButtons
+        onActiveChanged: if (active) { root.pressed(); if (root.focused) root.pointerFocus = true }
     }
     // The rail edge, one Divider shared with the column edges.
     Flea.Divider {