flea-qml 0.0.0-stage → 0.1.0

package/test/preview-keys.test.js

@@ -0,0 +1,60 @@
+import { test, expect } from 'bun:test';
+async function load(name, names, deps = {}) {
+    const source = (await Bun.file(new URL('../ui/js/' + name + '.js', import.meta.url)).text())
+        .replace(/^\.(?:pragma|import).*$/gm, '');
+    return new Function(...Object.keys(deps), source + '; return {' + names + '};')(...Object.values(deps));
+}
+const Scroll = await load('Scroll', 'limitsY,stopTail,tailState');
+const keys = await load('PreviewKeys', 'act,pdfAction,columnPdfAction,pageDirection,pageViewport', { Scroll });
+test('page actions scroll Quick Look without changing the selected file', () => {
+    const calls = [];
+    const root = { preview: { revealStrip() {}, pageBy: n => calls.push(n) } };
+    for (const action of ['pageDown', 'pageUp', 'previewPageForward', 'previewPageBack']) keys.act(action, root);
+    expect(calls).toEqual([1, -1, 1, -1]);
+});
+test('both PDF key routes handle every page alias', () => {
+    for (const handler of [keys.pdfAction, keys.columnPdfAction]) {
+        const calls = [];
+        const viewer = { pageBy: n => calls.push(n) };
+        for (const action of ['pageDown', 'pageUp', 'previewPageForward', 'previewPageBack']) handler(action, viewer);
+        expect(calls).toEqual([1, -1, 1, -1]);
+    }
+});
+test('viewport paging respects origin, margins, bounds, and stops wheel momentum', () => {
+    let cancelled = 0, layouts = 0;
+    const view = { originY: 100, topMargin: 10, bottomMargin: 20, height: 200,
+        contentHeight: 700, contentY: 90, cancelFlick() { cancelled++; }, forceLayout() { layouts++; } };
+    const tail = Scroll.tailState(view, true); tail.active = true; tail.vy = 2;
+    keys.pageViewport(view, 1); expect(view.contentY).toBe(290);
+    keys.pageViewport(view, 1); keys.pageViewport(view, 1); expect(view.contentY).toBe(620);
+    for (let i = 0; i < 5; i++) keys.pageViewport(view, -1);
+    expect(view.contentY).toBe(90);
+    expect(tail.active).toBe(false); expect(tail.vy).toBe(0);
+    expect(cancelled).toBe(8); expect(layouts).toBe(8);
+    view.contentHeight = 20; keys.pageViewport(view, 1); expect(view.contentY).toBe(90);
+    keys.pageViewport(null, 1);
+});
+test('Ctrl-Tab returns from Quick Look like Escape', () => {
+    let closed = 0;
+    keys.act('focusPreview', { preview: { revealStrip() {}, close() { closed++; } } });
+    expect(closed).toBe(1);
+});
+test('HTML Quick Look arrows follow adjacent files, including media, rather than scrolling HTML', async () => {
+    const followed = [], moved = [];
+    const rows = [{n:'1.html',i:1,s:110,k:0},{n:'1.mp3',i:2,s:200,k:1}];
+    const root = {cursorIndex:0,kindNames:['HTML','Audio'],join:(base,name)=>base+'/'+name,
+        rowFor:i=>rows[i],preview:{isHtml:true,isCompare:false,
+            markdownShown:{shownView:'rendered',scrollBy(){throw Error('Arrow must change file');}},
+            revealStrip(){},follow:(...args)=>followed.push(args)}};
+    const actions=await load('PreviewKeys','act',{
+        Filter:{moveCursor(r,n){r.cursorIndex+=n;moved.push(n);},cursorShown:()=>true},
+        Marks:{follow(){}},Search:{baseOf:()=>'/test'},Scroll,
+    });
+    actions.act('cursorDown',root);
+    expect(followed[0].slice(0,4)).toEqual(['/test/1.mp3',2,200,'Audio']);
+    actions.act('cursorUp',root);
+    expect(followed[1][0]).toBe('/test/1.html');
+    root.preview.isCompare=true;
+    actions.act('cursorDown',root);
+    expect(moved).toEqual([1,-1]);
+});

package/test/preview-language.test.js

@@ -0,0 +1,22 @@
+import {test,expect} from 'bun:test';
+import {previewLanguage} from '../src/preview-language.js';
+import {code} from '../src/code.js';
+const hint=(text,path='main.v')=>previewLanguage(path,Buffer.from(text));
+test('V declarations distinguish .v source without stealing Verilog',()=>{
+ expect(hint('module main\nfn main() { println("hello") }')).toBe('v');
+ expect(hint('pub fn (a App) run() {}')).toBe('v');
+ expect(hint('fn map[T](x T) T { return x }')).toBe('v');
+ expect(hint('module main;\nendmodule')).toBeNull();
+ expect(hint('// fn main() {}\nmodule main;\nendmodule')).toBeNull();
+ expect(hint('/* fn main() {} */')).toBeNull();
+ expect(hint('"fn main() {}"')).toBeNull();
+ expect(hint('module main')).toBeNull();
+ expect(hint('fn main() {}','main.txt')).toBeNull();
+});
+test('V and Verilog both retain source text and colour through the real preview launcher',async()=>{
+ for(const text of ['module main\nfn main() { println("hello") }\n','module counter(input clk);\nreg value;\nendmodule\n']) {
+  const reply=await code({name:'main.v',text});
+  expect(reply.state).toBe('styled');
+  expect(reply.lines.map(r=>r.filter((_,i)=>i%2).join('')).join('\n')).toBe(text.trimEnd());
+ }
+});

package/test/status-filename.test.js

@@ -0,0 +1,20 @@
+import {test,expect} from 'bun:test';
+async function load(name,names,deps={}) {
+ const source=(await Bun.file(new URL('../ui/js/'+name+'.js',import.meta.url)).text()).replace(/^\.(?:pragma|import).*$/gm,'');
+ return new Function(...Object.keys(deps),source+';return {'+names+'};')(...Object.values(deps));
+}
+const Match=await load('Match','rowName');
+const Status=await load('Status','fileName',{Match});
+const rows=[{n:'folder/完整的 very long file name.txt'},{n:'Trash/files/name.2',trash:{name:'Original.txt'}},{n:'other.txt'}];
+function pane(selected=[],cursorIndex=0){return {selection:{indices:()=>selected},cursorIndex,shown:null,rowFor:i=>rows[i]??null};}
+test('status names a single selection, or the current row without marks',()=>{
+ expect(Status.fileName(pane())).toBe('完整的 very long file name.txt');
+ expect(Status.fileName(pane([1]))).toBe('Original.txt');
+ expect(Status.fileName(pane([0,1],2))).toBe('other.txt');
+});
+test('status clears absent, filtered or stale cursor names',()=>{
+ expect(Status.fileName(null)).toBe('');
+ expect(Status.fileName(pane([],50))).toBe('');
+ expect(Status.fileName({...pane(),shown:[]})).toBe('');
+ expect(Status.fileName({...pane(),listInFlight:true})).toBe('');
+});

package/test/transfer-replace-merge.test.js

@@ -0,0 +1,187 @@
+import { test, expect, afterAll, beforeAll } from "bun:test";
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, readdirSync, rmSync, existsSync, symlinkSync, renameSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// Paste's Replace and Merge (docs/protocol.md "transfer", "collisions", "mergecollisions"): the
+// item already there goes to flea's Trash, a folder on a folder folds in, and only the names the
+// questions saw are ever answered.
+const root = mkdtempSync(join(tmpdir(), "flea-replace-"));
+const saved = process.env.XDG_DATA_HOME;
+process.env.XDG_DATA_HOME = join(root, "data");
+const { collisions, mergeCollisions, transfer } = await import("../src/transfer.js");
+afterAll(() => {
+  if (saved === undefined) delete process.env.XDG_DATA_HOME;
+  else process.env.XDG_DATA_HOME = saved;
+  rmSync(root, { recursive: true, force: true });
+});
+const trashFiles = () => { try { return readdirSync(join(root, "data", "Trash", "files")); } catch { return []; } };
+
+let serial = 0;
+function place() {
+  const at = join(root, String(++serial)), src = join(at, "src"), dest = join(at, "dest");
+  mkdirSync(src, { recursive: true });
+  mkdirSync(dest, { recursive: true });
+  const messages = [];
+  return { src, dest, messages, send: (m) => messages.push(m) };
+}
+async function run(p, request) {
+  const from = p.messages.length;
+  transfer(request, p.send, null, 0);
+  for (let i = 0; i < 400; i++) {
+    const done = p.messages.slice(from).find((m) => m.t === "transferdone");
+    if (done) return { done, items: p.messages.slice(from).filter((m) => m.t === "transferitem") };
+    await Bun.sleep(5);
+  }
+  throw Error("no transferdone: " + JSON.stringify(p.messages));
+}
+const ask = (p, id, paths) => { collisions({ id, paths, dest: p.dest }, p.send, null, 0); return p.messages.at(-1); };
+const askMerge = (p, id, paths) => { mergeCollisions({ id, paths, dest: p.dest }, p.send, null, 0); return p.messages.at(-1); };
+
+test("Replace sends the item already there to the Trash and lands the incoming one", async () => {
+  const p = place(), before = trashFiles().length;
+  writeFileSync(join(p.src, "a.txt"), "new");
+  writeFileSync(join(p.dest, "a.txt"), "old");
+  expect(ask(p, 1, [join(p.src, "a.txt")])).toMatchObject({ t: "collisions", total: 1, mergeable: false });
+  const { done } = await run(p, { op: "copy", paths: [join(p.src, "a.txt")], dest: p.dest, collide: "replace", collideId: 1 });
+  expect(done).toMatchObject({ ok: 1, failed: 0 });
+  expect(done.into).toBeUndefined();
+  expect(readFileSync(join(p.dest, "a.txt"), "utf8")).toBe("new");
+  expect(trashFiles().length).toBe(before + 1);
+});
+
+test("Replace covers only what the question saw: a name swapped since is refused", async () => {
+  const p = place();
+  writeFileSync(join(p.src, "a.txt"), "new");
+  writeFileSync(join(p.dest, "a.txt"), "old");
+  ask(p, 2, [join(p.src, "a.txt")]);
+  renameSync(join(p.dest, "a.txt"), join(p.dest, "gone"));
+  writeFileSync(join(p.dest, "a.txt"), "swapped in");
+  const { done, items } = await run(p, { op: "copy", paths: [join(p.src, "a.txt")], dest: p.dest, collide: "replace", collideId: 2 });
+  expect(done.failed).toBe(1);
+  expect(items[0].err).toBe("an item with that name is already there");
+  expect(readFileSync(join(p.dest, "a.txt"), "utf8")).toBe("swapped in");
+});
+
+test("Replace refuses an item already there that holds the one moving in, and a link to itself", async () => {
+  const p = place();
+  // Moving dest/box/inner over dest-side "box" would trash its own source.
+  mkdirSync(join(p.dest, "box"));
+  mkdirSync(join(p.src, "box"));
+  writeFileSync(join(p.dest, "box", "box"), "x");
+  const nested = join(p.dest, "box", "box");
+  const q = ask(p, 3, [nested]);
+  // nested lives in dest/box, not dest, so it collides with dest/box itself.
+  expect(q.total).toBe(1);
+  const first = await run(p, { op: "move", paths: [nested], dest: p.dest, collide: "replace", collideId: 3 });
+  expect(first.items[0].err).toBe("the item already there holds the one being moved in, so it was not replaced");
+  expect(existsSync(nested)).toBe(true);
+  if (process.platform === "win32") return;
+  writeFileSync(join(p.dest, "t.txt"), "target");
+  symlinkSync(join(p.dest, "t.txt"), join(p.src, "t.txt"));
+  ask(p, 4, [join(p.src, "t.txt")]);
+  const second = await run(p, { op: "copy", paths: [join(p.src, "t.txt")], dest: p.dest, collide: "replace", collideId: 4 });
+  expect(second.items[0].err).toBe("the incoming link points at the item already there, so it was not replaced");
+  expect(readFileSync(join(p.dest, "t.txt"), "utf8")).toBe("target");
+});
+
+test("a failed replace puts the item it trashed straight back", async () => {
+  if (process.platform === "win32" || process.getuid?.() === 0) return;
+  const p = place();
+  mkdirSync(join(p.src, "d"));
+  writeFileSync(join(p.src, "d", "secret"), "s");
+  const { chmodSync } = await import("node:fs");
+  chmodSync(join(p.src, "d"), 0o000);
+  writeFileSync(join(p.dest, "d"), "old file");
+  ask(p, 5, [join(p.src, "d")]);
+  const { done, items } = await run(p, { op: "copy", paths: [join(p.src, "d")], dest: p.dest, collide: "replace", collideId: 5 });
+  chmodSync(join(p.src, "d"), 0o755);
+  expect(done.failed).toBe(1);
+  expect(items[0].err).not.toContain("still in the Trash");
+  expect(readFileSync(join(p.dest, "d"), "utf8")).toBe("old file");
+});
+
+function tree(p) {
+  mkdirSync(join(p.src, "trip", "day1"), { recursive: true });
+  mkdirSync(join(p.dest, "trip", "day1"), { recursive: true });
+  writeFileSync(join(p.src, "trip", "new.jpg"), "new");
+  writeFileSync(join(p.src, "trip", "day1", "same.jpg"), "incoming");
+  writeFileSync(join(p.src, "trip", "day1", "fresh.jpg"), "fresh");
+  writeFileSync(join(p.dest, "trip", "day1", "same.jpg"), "already");
+  writeFileSync(join(p.dest, "trip", "keep.jpg"), "untouched");
+  return [join(p.src, "trip")];
+}
+
+test("Merge is offered for a folder on a folder, and its walk lists the names both hold", () => {
+  const p = place(), paths = tree(p);
+  expect(ask(p, 10, paths)).toMatchObject({ total: 1, mergeable: true, names: [{ n: "trip", d: true }] });
+  expect(askMerge(p, 10, paths)).toMatchObject({ t: "mergecollisions", id: 10, total: 1, names: [{ n: "same.jpg", d: false }] });
+});
+
+for (const [inner, expected, keptBoth] of [["keep", "already", 1], ["replace", "incoming", 0], ["skip", "already", 0]]) {
+  test(`Merge folds the folders together, and "${inner}" answers the names both hold`, async () => {
+    const p = place(), paths = tree(p);
+    ask(p, 11, paths);
+    askMerge(p, 11, paths);
+    const { done } = await run(p, { op: "copy", paths, dest: p.dest, collide: "merge", collideId: 11, inner });
+    expect(done).toMatchObject({ ok: 1, failed: 0, into: "trip", keptBoth, merged: 2 + keptBoth + (inner === "replace" ? 1 : 0) });
+    const day1 = join(p.dest, "trip", "day1");
+    expect(readFileSync(join(day1, "same.jpg"), "utf8")).toBe(expected);
+    expect(readFileSync(join(day1, "fresh.jpg"), "utf8")).toBe("fresh");
+    expect(readFileSync(join(p.dest, "trip", "new.jpg"), "utf8")).toBe("new");
+    expect(readFileSync(join(p.dest, "trip", "keep.jpg"), "utf8")).toBe("untouched");
+    if (inner === "keep") expect(readFileSync(join(day1, "same copy.jpg"), "utf8")).toBe("incoming");
+    expect(existsSync(join(p.src, "trip", "day1", "same.jpg"))).toBe(true);
+  });
+}
+
+test("a merging move removes the folders it emptied and leaves what it skipped", async () => {
+  const p = place(), paths = tree(p);
+  ask(p, 12, paths);
+  askMerge(p, 12, paths);
+  const { done } = await run(p, { op: "move", paths, dest: p.dest, collide: "merge", collideId: 12, inner: "skip" });
+  expect(done).toMatchObject({ ok: 1, failed: 0, merged: 2 });
+  expect(readdirSync(join(p.src, "trip"))).toEqual(["day1"]);
+  expect(readdirSync(join(p.src, "trip", "day1"))).toEqual(["same.jpg"]);
+  expect(readFileSync(join(p.dest, "trip", "day1", "fresh.jpg"), "utf8")).toBe("fresh");
+});
+
+test("a name that appears inside after the walk is refused whatever the inner answer", async () => {
+  const p = place(), paths = tree(p);
+  ask(p, 13, paths);
+  askMerge(p, 13, paths);
+  writeFileSync(join(p.dest, "trip", "new.jpg"), "late");
+  const { done, items } = await run(p, { op: "copy", paths, dest: p.dest, collide: "merge", collideId: 13, inner: "replace" });
+  expect(done.failed).toBe(1);
+  expect(items[0].err).toBe("trip/new.jpg could not be copied: an item with that name is already there".replaceAll("/", join("a", "b")[1]));
+  expect(readFileSync(join(p.dest, "trip", "new.jpg"), "utf8")).toBe("late");
+  expect(readFileSync(join(p.dest, "trip", "day1", "same.jpg"), "utf8")).toBe("incoming");
+});
+
+test("merge without the walk folds nothing that both hold, and a bad inner word is refused", async () => {
+  const p = place(), paths = tree(p);
+  ask(p, 14, paths);
+  // The second question was never asked: the transfer still merges, but same.jpg is refused.
+  const { done } = await run(p, { op: "copy", paths, dest: p.dest, collide: "merge", collideId: 14, inner: "replace" });
+  expect(done.failed).toBe(1);
+  expect(readFileSync(join(p.dest, "trip", "day1", "same.jpg"), "utf8")).toBe("already");
+  transfer({ op: "copy", paths, dest: p.dest, collide: "merge", collideId: 14, inner: "merge" }, p.send, null, 0);
+  expect(p.messages.at(-1)).toMatchObject({ t: "error", where: "transfer" });
+});
+
+test("into names the merging folder only when it was the transfer's one item", async () => {
+  const p = place(), paths = tree(p);
+  writeFileSync(join(p.src, "a.txt"), "new");
+  writeFileSync(join(p.dest, "a.txt"), "old");
+  const both = [...paths, join(p.src, "a.txt")];
+  ask(p, 15, both);
+  askMerge(p, 15, both);
+  const { done } = await run(p, { op: "copy", paths: both, dest: p.dest, collide: "merge", collideId: 15, inner: "keep" });
+  expect(done.into).toBe("dest");
+  const { readFileSync: read } = await import("node:fs");
+  const source = read(new URL("../ui/js/Collide.js", import.meta.url), "utf8").replace(/^\.(?:pragma|import).*$/gm, "");
+  const { mergeDest } = new Function("Format", "Ops", "Status", "Swap", source + ";return {mergeDest};")({}, {}, {}, {});
+  const request = { dest: "/d" };
+  expect(mergeDest(request, [{ n: "trip", d: true }], 1)).toBe("/d/trip");
+  expect(mergeDest(request, [{ n: "trip", d: true }, { n: "a.txt", d: false }], 2)).toBe("/d");
+});

package/test/trash-address.test.js

@@ -0,0 +1,23 @@
+import {test,expect} from 'bun:test';
+async function load(name,names,deps={}) {
+ const source=(await Bun.file(new URL('../ui/js/'+name+'.js',import.meta.url)).text()).replace(/^\.(?:pragma|import).*$/gm,'');
+ return new Function(...Object.keys(deps),source+';return {'+names+'};')(...Object.values(deps));
+}
+const PathBar=await load('PathBar','isTrashRoot,addressTarget,editLine,shouldNavigate',{Format:{}});
+const Crumbs=await load('Crumbs','crumbs');
+test('Trash root aliases canonicalize only at the address input boundary',()=>{
+ for(const value of ['trash:/','trash://','trash:///',' TRASH:/// ']) {
+  expect(PathBar.isTrashRoot(value)).toBe(true);
+  expect(PathBar.addressTarget(value,'/home/test','/home/test')).toBe('trash:///');
+ }
+ for(const value of ['trash:','trash:////','trash://host/','trash:///file','/tmp/trash:','trash'])expect(PathBar.isTrashRoot(value)).toBe(false);
+ expect(PathBar.addressTarget('/tmp','trash:///','/home/test')).toBe('/tmp');
+ expect(PathBar.addressTarget('~','trash:///','/home/test')).toBe('/home/test');
+ expect(PathBar.addressTarget('tmp','trash:///','/home/test')).toBe('/tmp');
+});
+test('Trash root remains a single breadcrumb and does not gain a fourth slash',()=>{
+ expect(PathBar.editLine('trash:///')).toBe('trash:///');
+ expect(PathBar.editLine('/tmp')).toBe('/tmp/');
+ expect(Crumbs.crumbs('trash:///','/home/test',null)).toEqual([{text:'trash:///',path:'trash:///',last:true}]);
+ expect(PathBar.shouldNavigate('trash:///','trash:///',false)).toBe(false);
+});

package/test/trash-view.test.js

@@ -0,0 +1,37 @@
+import {test,expect} from 'bun:test';
+async function load(name,names,deps={}) {
+ const source=(await Bun.file(new URL('../ui/js/'+name+'.js',import.meta.url)).text()).replace(/^\.(?:pragma|import).*$/gm,'');
+ return new Function(...Object.keys(deps),source+';return {'+names+'};')(...Object.values(deps));
+}
+test('Back from a trashed directory restores its collection and cursor, not filesystem root',async()=>{
+ const Back=await load('BackReturn','capture,travel');
+ const pane={path:'/',recentMode:'trash',recentFrom:'/home/test',cursorIndex:3,rowFor:()=>({n:'tmp/Trash/files/folder'})};
+ const entry=Back.capture(pane);
+ let opened=0;
+ Object.assign(pane,{path:'/tmp/Trash/files/folder',recentMode:'',history:[entry],forwardHistory:[],
+  trash:{open(){opened++}},join:(base,name)=>base+name,
+  openWithoutHistory(){throw Error('must not navigate to /')}});
+ Back.travel(pane,'history','forwardHistory');
+ expect(opened).toBe(1);expect(pane.recentFrom).toBe('/home/test');expect(pane.pendingSelect).toBe('/tmp/Trash/files/folder');
+ expect(pane.forwardHistory[0].path).toBe('/tmp/Trash/files/folder');
+});
+test('Trash Filter uses the visible original name, not its collision-safe storage name',async()=>{
+ const Match=await load('Match','run,base,rowName');
+ const Filter=await load('Filter','shown',{Match});
+ const rows=[{n:'tmp/Trash/files/report.2',trash:{original:'/docs/report'}},{n:'tmp/Trash/files/elsewhere',trash:{original:'/docs/notes'}}];
+ expect(Filter.shown(rows,10,'report')).toEqual([10]);
+ expect(Filter.shown(rows,10,'report.2')).toEqual([]);
+});
+test('Find in the virtual Trash cannot silently search the previous directory',async()=>{
+ const Search=await load('Search','start');let message='';
+ const pane={recentMode:'trash',path:'/',recentFrom:'/private',message:m=>message=m};
+ Search.start(pane);
+ expect(pane.path).toBe('/');expect(pane.recentMode).toBe('trash');expect(message).toContain('filters');
+});
+
+test('Trash captions share original basenames in list, grid and columns',async()=>{
+ const Match=await load('Match','rowName');
+ expect(Match.rowName({n:'tmp/Trash/files/report.2',trash:{original:'/docs/report'}},false)).toBe('report');
+ expect(Match.rowName({n:'C:/Trash/files/report.2',trash:{original:'C:\\docs\\report',name:'report'}},true)).toBe('report');
+ expect(Match.rowName({n:'sub/file.txt'},false)).toBe('sub/file.txt');
+});

package/test/trashbrowse.test.js

@@ -0,0 +1,135 @@
+import {test, expect, beforeEach, afterEach} from 'bun:test';
+import {mkdtempSync,mkdirSync,writeFileSync,readFileSync,renameSync,symlinkSync,existsSync,rmSync} from 'node:fs';
+import {join,dirname} from 'node:path';
+import {tmpdir} from 'node:os';
+import {trashOne,homeTrash,trashInfoPath,trashInfoOriginal} from '../src/trash.js';
+import {trashbrowse,readTrash,watchTrashCount} from '../src/trashbrowse.js';
+let root,saved,stop;
+const call=(op,fields={})=>{const replies=[];trashbrowse({op,id:1,...fields},m=>replies.push(m));return replies.find(m=>m.t==='trashbrowse');};
+beforeEach(()=>{root=mkdtempSync(join(tmpdir(),'flea-trashbrowse-'));saved=process.env.XDG_DATA_HOME;process.env.XDG_DATA_HOME=join(root,'data');mkdirSync(process.env.XDG_DATA_HOME);call('cancel',{clearSelection:true});});
+afterEach(()=>{stop?.();stop=null;if(saved===undefined)delete process.env.XDG_DATA_HOME;else process.env.XDG_DATA_HOME=saved;rmSync(root,{recursive:true,force:true});});
+function item(name='sample',directory=false){const path=join(root,name);if(directory){mkdirSync(path);writeFileSync(join(path,'keep'),'keep');}else writeFileSync(path,'payload');trashOne(path);return readTrash().find(i=>i.original===path);}
+test('Trash list, restore, collisions and single-use deletion',()=>{
+ const a=item('a');expect(call('list',{count:20}).rows.some(r=>r.uri===a.uri)).toBe(true);
+ 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]});
+ 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',()=>{
+ const a=item();let {token}=call('prepare',{uris:[a.uri]});call('cancel');expect(call('delete',{token}).ok).toBe(false);
+ ({token}=call('prepare',{uris:[a.uri]}));expect(call('prepare',{uris:['missing']}).ok).toBe(false);
+ expect(call('delete',{token}).ok).toBe(false);expect(existsSync(a.file)).toBe(true);
+});
+test('new descendants invalidate the whole deletion review',()=>{
+ const a=item('folder',true),{token}=call('prepare',{uris:[a.uri]});
+ writeFileSync(join(a.file,'new'),'new');expect(call('check',{token}).valid).toBe(false);
+ expect(call('delete',{token}).stale).toBe(true);expect(existsSync(join(a.file,'keep'))).toBe(true);
+});
+test('bulk selection refuses replaced files and metadata',()=>{
+ const a=item();call('list',{count:20});const {selectionToken}=call('select');
+ renameSync(a.file,a.file+'.old');writeFileSync(a.file,'replacement');
+ expect(call('restore',{selectionToken}).stale).toBe(true);
+ call('list',{count:20});const selected=call('select');writeFileSync(a.info,'[Trash Info]\nPath=/another-place\n');
+ expect(call('prepare',{selectionToken:selected.selectionToken}).stale).toBe(true);
+});
+test('Trash ignores symlink directories and dot metadata names',()=>{
+ const a=item();writeFileSync(join(homeTrash(),'info','...trashinfo'),'[Trash Info]\nPath=/bad\n');
+ expect(readTrash().some(i=>i.name==='..')).toBe(false);
+ const files=join(homeTrash(),'files');renameSync(files,files+'.old');symlinkSync(files+'.old',files);
+ expect(readTrash().some(i=>i.uri===a.uri)).toBe(false);
+});
+test('metadata round trips punctuation and rejects escaping relative paths',()=>{
+ const path=join(root,'a:b #中文 % x');expect(trashInfoOriginal(trashInfoPath(path), '')).toBe(path);
+ expect(trashInfoOriginal(trashInfoPath(path,root),root)).toBe(path);
+ for(const bad of ['../outside','%2e%2e/outside','%2foutside','bad%00name','%ZZ',''])expect(trashInfoOriginal(bad,root)).toBe('');
+});
+test('count watcher reports same-count replacements and disposes',async()=>{
+ const a=item();let reports=0;stop=watchTrashCount(()=>reports++);expect(reports).toBe(1);
+ renameSync(a.file,a.file+'.old');writeFileSync(a.file,'replacement');
+ const deadline=Date.now()+3000;while(reports<2 && Date.now()<deadline)await Bun.sleep(20);
+ expect(reports).toBeGreaterThan(1);stop();stop=null;
+});
+test('backend routes Trash requests and exits cleanly',()=>{
+ const result=Bun.spawnSync([process.execPath,new URL('../src/flea.js',import.meta.url).pathname,'--backend'],{
+  env:{...process.env},stdin:Buffer.from('{"c":"trashbrowse","op":"list","id":27,"count":10}\n{"c":"quit"}\n'),stdout:'pipe',stderr:'pipe'});
+ expect(result.exitCode).toBe(0);
+ const messages=result.stdout.toString().trim().split('\n').map(line=>JSON.parse(line));
+ expect(messages.some(m=>m.t==='trashcount' && typeof m.revision==='number')).toBe(true);
+ expect(messages.some(m=>m.t==='trashbrowse' && m.id===27 && m.ok===true)).toBe(true);
+});
+
+test('Trash collection uses ordinary rows, real paths and metadata; stale row actions are refused',()=>{
+ const a=item('preview 中文.txt');
+ const input=[{c:'listtrash',first:10000},{c:'trashbrowse',op:'restore',id:31,rows:[0],listing:-1},{c:'quit'}].map(x=>JSON.stringify(x)).join('\n')+'\n';
+ const result=Bun.spawnSync([process.execPath,new URL('../src/flea.js',import.meta.url).pathname,'--backend'],{env:{...process.env},stdin:Buffer.from(input),stdout:'pipe',stderr:'pipe'});
+ expect(result.exitCode).toBe(0);expect(result.stderr.toString()).toBe('');
+ const messages=result.stdout.toString().trim().split('\n').map(JSON.parse);
+ const rows=messages.find(x=>x.t==='rows');const row=rows.rows.find(x=>x.trash?.original===a.original);
+ expect(join('/',row.n)).toBe(a.file);expect(row.s).toBe(7);expect(row.d).toBe(false);
+ expect(messages.find(x=>x.id===31).stale).toBe(true);expect(existsSync(a.file)).toBe(true);
+});
+
+test('renaming a Trash entry preserves restore metadata and refuses destination collisions',async()=>{
+ const {renameWithTrashRecord}=await import('../src/trash-record.js');
+ const a=item('original.txt'),dst=join(dirname(a.file),'renamed.txt');
+ renameWithTrashRecord(a.file,dst);
+ expect(existsSync(a.file)).toBe(false);expect(existsSync(a.info)).toBe(false);
+ const moved=readTrash().find(x=>x.file===dst);expect(moved.original).toBe(join(root,'renamed.txt'));
+ writeFileSync(join(dirname(dst),'occupied'),'keep');
+ expect(()=>renameWithTrashRecord(dst,join(dirname(dst),'occupied'))).toThrow('already exists');
+ expect(readFileSync(dst,'utf8')).toBe('payload');
+ expect(call('restore',{uris:[moved.uri],identities:[moved.identity]}).done).toBe(1);
+ expect(readFileSync(join(root,'renamed.txt'),'utf8')).toBe('payload');
+});
+
+test('moving out cleans only the captured Trash record; copy keeps its source metadata',async()=>{
+ const {transfer}=await import('../src/transfer.js');
+ const a=item('move-me.txt');const dest=join(root,'destination');mkdirSync(dest);
+ const run=moving=>new Promise(resolve=>transfer({id:40,paths:[a.file],dest,op:moving?'move':'copy'},m=>{if(m.t==='transferdone')resolve(m)},null,0));
+ const copied=await run(false);expect(copied.ok).toBe(1);expect(existsSync(a.info)).toBe(true);
+ rmSync(join(dest,'move-me.txt'));
+ const moved=await run(true);expect(moved.ok).toBe(1);expect(existsSync(a.info)).toBe(false);
+ expect(readFileSync(join(dest,'move-me.txt'),'utf8')).toBe('payload');
+});
+
+test('Trash rename preserves literal replacement tokens in file names',async()=>{
+ const {renameWithTrashRecord}=await import('../src/trash-record.js');
+ for (const name of ['$&.txt', '$$.txt', "$'.txt", '$`.txt']) {
+  const a=item('old-'+name),dst=join(dirname(a.file),name);
+  renameWithTrashRecord(a.file,dst);
+  const moved=readTrash().find(x=>x.file===dst);
+  expect(moved.original).toBe(join(root,name));
+  expect(call('restore',{uris:[moved.uri],identities:[moved.identity]}).done).toBe(1);
+  expect(readFileSync(join(root,name),'utf8')).toBe('payload');
+ }
+});
+
+test('Trash menu restores its captured item after sort, not the replacement cursor',()=>{
+ const a=item('menu-a.txt'),b=item('menu-b.txt');
+ const commands=[{c:'listtrash',first:10000},
+  {c:'menuaction',op:'snapshot',id:93,paths:[a.file],cursorPath:a.file},
+  {c:'sort',by:'name',desc:true},
+  {c:'trashbrowse',op:'restore',id:94,menuId:93,rows:[0],listing:-1},
+  {c:'trashbrowse',op:'restore',id:95,menuId:999,rows:[0]},
+  {c:'quit'}];
+ const result=Bun.spawnSync([process.execPath,new URL('../src/flea.js',import.meta.url).pathname,'--backend'],{
+  env:{...process.env},stdin:Buffer.from(commands.map(JSON.stringify).join('\n')+'\n'),stdout:'pipe',stderr:'pipe'});
+ expect(result.exitCode).toBe(0);
+ const messages=result.stdout.toString().trim().split('\n').map(JSON.parse);
+ expect(messages.find(x=>x.id===94).done).toBe(1);
+ expect(messages.find(x=>x.id===95).stale).toBe(true);
+ expect(existsSync(a.original)).toBe(true);expect(existsSync(b.file)).toBe(true);
+});
+
+test('Trash collision suffixes do not change visible names or media classification',async()=>{
+ const {Listing}=await import('../src/listing.js');
+ for(const name of ['image.png','music.mp3','video.mp4','source.js','Dockerfile']) {
+  item(name);item(name);const a=readTrash().find(x=>x.original===join(root,name) && x.file.endsWith('.2'));
+  expect(a.file.endsWith('.2')).toBe(true);
+  const row=new Listing('/',[{name:a.file.slice(1),dir:false,trash:a}]).window(0,1).rows[0];
+  const original=new Listing(root,[{name,dir:false}]).window(0,1).rows[0];
+  expect(row.i).toBe(original.i);expect(row.trash.name).toBe(name);
+ }
+});

package/ui/AboutFacts.qml

@@ -0,0 +1,78 @@
+import QtQuick
+import Quickshell
+import Quickshell.Io
+import "js/SettingsAbout.js" as About
+
+// Installed facts are read only when About is shown; each failed query keeps an explicit unknown.
+QtObject {
+    id: root
+    property bool active: false
+    property bool loaded: false
+    property var known: ({})
+    // What ui/js/SettingsAbout.js reads: the installed facts, with the updater's status and the default's claim beside them.
+    readonly property var facts: Object.assign({ update: UpdateCheck.status, handler: DefaultClaim.handler, claim: DefaultClaim.claim }, root.known)
+    readonly property string binary: Quickshell.env("FLEA_BIN") || "flea"
+
+    function setFact(key, value) {
+        var next = Object.assign({}, root.known)
+        next[key] = value
+        root.known = next
+    }
+
+    onActiveChanged: {
+        // About opening is one of the updater's two automatic triggers; ui/js/Update.js decides whether the last answer stands.
+        if (root.active) UpdateCheck.checkIfDue()
+        if (!root.active || root.loaded) return
+        root.loaded = true
+        version.running = true
+        owner.running = true
+        DefaultClaim.read()
+    }
+
+    property var versionQuery: Process {
+        id: version
+        command: [root.binary, "--version"]
+        property string answer: ""
+        stdout: StdioCollector { onStreamFinished: version.answer = this.text.trim() }
+        // Sample output: "0.2.0". src/main.rs prints CARGO_PKG_VERSION and nothing else, so the
+        // name is tolerated rather than required: demanding it left the Version row reading
+        // "Not reported" on every build Flea has ever shipped.
+        onExited: function (code) {
+            if (code !== 0) return
+            var text = version.answer.indexOf("flea ") === 0 ? version.answer.substring(5) : version.answer
+            if (text.length > 0) root.setFact("version", text)
+        }
+    }
+    property var ownerQuery: Process {
+        id: owner
+        command: ["pacman", "-Qqo", root.binary]
+        property string answer: ""
+        stdout: StdioCollector { onStreamFinished: owner.answer = this.text.trim() }
+        // Sample output: flea
+        onExited: function (code) {
+            if (code !== 0 || owner.answer.length === 0) {
+                root.setFact("source", About.installedFrom("", false))
+                root.setFact("package", "Not owned by a package")
+                return
+            }
+            packageVersion.command = ["pacman", "-Qi", owner.answer]
+            packageVersion.running = true
+        }
+    }
+    // -Qi rather than -Q: the same query carries the build date, and the Built row had nothing
+    // setting it at all, so every box read "Not recorded in this build" whatever it was running.
+    // Its Validated By line is the signature src/update.rs tells OPR's flea from a local build by.
+    property var packageQuery: Process {
+        id: packageVersion
+        environment: ({ LC_ALL: "C" })
+        property string answer: ""
+        stdout: StdioCollector { onStreamFinished: packageVersion.answer = this.text }
+        onExited: function (code) {
+            // A package pacman cannot describe reads as unsigned, the way src/update.rs reads it.
+            var facts = About.packageFacts(code === 0 ? packageVersion.answer : "")
+            root.setFact("source", About.installedFrom(owner.answer, facts.signed))
+            if (facts.package.length > 0) root.setFact("package", facts.package)
+            if (facts.built.length > 0) root.setFact("built", facts.built)
+        }
+    }
+}

package/ui/ArchiveCards.qml

@@ -0,0 +1,68 @@
+import QtQuick
+import "js/ArchiveCard.js" as ArchiveCard
+import "js/ArchiveOps.js" as ArchiveOps
+
+// The two password cards, built on their first open and kept like every overlay, so a launch that never opens one pays nothing.
+Item {
+    id: root
+
+    property var compressOwner: null
+    property var extractOwner: null
+    readonly property var compressItem: compressDialog.item
+    readonly property var extractItem: extractDialog.item
+
+    function askCompressPassword(pane, paths, menuId) {
+        if (paths) ArchiveOps.compressPasswordResolved(root, pane, paths, menuId)
+        else ArchiveOps.openCompressPassword(pane, menuId, root)
+    }
+
+    // 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)
+            return false
+        holder.message(ArchiveCard.CARD_BUSY, true)
+        return true
+    }
+
+    function openCompressDialog(source, parentLeaf, holder) {
+        if (cardBusy(holder)) return
+        compressOwner = holder
+        compressDialog.active = true
+        compressDialog.item.open(source, parentLeaf, holder)
+    }
+
+    function openExtractPassword(source, holder, err) {
+        if (cardBusy(holder)) return
+        extractOwner = holder
+        extractDialog.active = true
+        extractDialog.item.open(source, holder, err)
+    }
+
+    anchors.fill: parent
+
+    Loader {
+        id: compressDialog
+        anchors.fill: parent
+        active: false
+        source: "ArchiveCompressDialog.qml"
+        readonly property bool opened: item !== null && item.opened
+    }
+    Connections {
+        target: compressDialog.item
+        function onAccepted(source, format, name, password, encryptNames) {
+            ArchiveOps.submitCompressPassword(root.compressOwner, source, format, name, password, encryptNames)
+        }
+    }
+
+    Loader {
+        id: extractDialog
+        anchors.fill: parent
+        active: false
+        source: "ArchivePasswordDialog.qml"
+        readonly property bool opened: item !== null && item.opened
+    }
+    Connections {
+        target: extractDialog.item
+        function onAccepted(source, password) { ArchiveOps.submitExtractPassword(root.extractOwner, source, password) }
+    }
+}