flea-qml 0.0.0-stage → 0.2.0

package/test/archive.test.js

@@ -0,0 +1,80 @@
+import { test, expect, afterAll } from 'bun:test';
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { gzipSync } from 'node:zlib';
+import { listArchive } from '../src/archive.js';
+const dir = mkdtempSync(join(tmpdir(), 'flea-archive-'));
+afterAll(() => rmSync(dir, { recursive: true, force: true }));
+function header(name, size, type='0') {
+  const b=Buffer.alloc(512); b.write(name); b.write(String(size),124,12); b.write(type,156);
+  b.fill(32,148,156); const sum=b.reduce((a,v)=>a+v,0);
+  b.write(sum.toString(8).padStart(6,'0')+'\0 ',148); return b;
+}
+async function read(bytes, ext='tar') {
+  const path=join(dir, `${crypto.randomUUID()}.${ext}`); writeFileSync(path,bytes);
+  const rows=[]; await listArchive(path,path,r=>rows.push(r)); return rows;
+}
+const valid=Buffer.concat([header('hello.txt','3'),Buffer.from('hey'),Buffer.alloc(509),Buffer.alloc(1024)]);
+for (const format of ['tar','tgz','tzst']) test(`list ${format}`,async()=>{
+  const bytes=format==='tar'?valid:format==='tgz'?gzipSync(valid):Bun.zstdCompressSync(valid);
+  expect(await read(bytes,format)).toEqual([{name:'hello.txt',size:3,dir:false}]);
+});
+for (const size of ['-1000','77777777777']) test(`reject invalid or truncated tar size ${size}`,async()=>{
+  await expect(read(header('bad',size))).rejects.toThrow();
+});
+test('reject truncated compressed member',async()=>{
+  await expect(read(gzipSync(header('bad','1000')),'tgz')).rejects.toThrow();
+});
+test('cap extended metadata before allocation',async()=>{
+  await expect(read(gzipSync(header('extended','10000000','x')),'tgz')).rejects.toThrow('too large');
+});
+test('reject partial trailing block',async()=>{await expect(read(Buffer.concat([valid,Buffer.from('bad')]))).rejects.toThrow();});
+// One stored member: its local header and bytes, then the central directory and its end record.
+const ZIP_CENTRAL=30+'hello'.length+3;
+function zip(name='hello',size=3) {
+  const l=Buffer.alloc(30); l.writeUInt32LE(0x04034b50); l.writeUInt32LE(size,18); l.writeUInt32LE(size,22); l.writeUInt16LE(name.length,26);
+  const local=Buffer.concat([l,Buffer.from(name),Buffer.alloc(size,0x61)]);
+  const h=Buffer.alloc(46); h.writeUInt32LE(0x02014b50); h.writeUInt32LE(size,20); h.writeUInt32LE(size,24); h.writeUInt16LE(name.length,28);
+  const c=Buffer.concat([h,Buffer.from(name)]), e=Buffer.alloc(22);
+  e.writeUInt32LE(0x06054b50);e.writeUInt16LE(1,8);e.writeUInt16LE(1,10);e.writeUInt32LE(c.length,12);e.writeUInt32LE(local.length,16);
+  return Buffer.concat([local,c,e]);
+}
+test('zip central listing',async()=>{expect(await read(zip(),'zip')).toEqual([{name:'hello',size:3,dir:false}]);});
+test('reject oversized central directory before allocation',async()=>{
+  const b=zip(); b.writeUInt32LE(0xffffffff,b.length-10);
+  await expect(read(b,'zip')).rejects.toThrow();
+});
+test('reject truncated central entry name',async()=>{
+  const b=zip();b.writeUInt16LE(65000,ZIP_CENTRAL+28);await expect(read(b,'zip')).rejects.toThrow();
+});
+test('reject a split archive and a member outside the archive',async()=>{
+  const split=zip();split.writeUInt16LE(1,split.length-18);await expect(read(split,'zip')).rejects.toThrow('split');
+  const outside=zip();outside.writeUInt32LE(1000,ZIP_CENTRAL+42);await expect(read(outside,'zip')).rejects.toThrow('range');
+  const wide=zip();wide.writeUInt32LE(0xffffffff,ZIP_CENTRAL+24);await expect(read(wide,'zip')).rejects.toThrow('zip64');
+});
+test('reject corrupt later tar header instead of partial success',async()=>{
+  await expect(read(Buffer.concat([valid,Buffer.alloc(512,42)]))).rejects.toThrow();
+});
+function pax(key,value) {
+ const body=` ${key}=${value}\n`;let n=body.length+1;
+ while(String(n).length+body.length!==n)n=String(n).length+body.length;
+ return Buffer.from(String(n)+body);
+}
+function member(name,body,type='0') {
+ return Buffer.concat([header(name,body.length.toString(8),type),body,Buffer.alloc((512-body.length%512)%512)]);
+}
+test('pax metadata controls following file, including global headers',async()=>{
+ const b=Buffer.concat([member('global',pax('path','global-name'),'g'),member('file',Buffer.from('a'))]);
+ expect((await read(b))[0].name).toBe('global-name');
+});
+test('negative pax size is rejected for raw and compressed tar',async()=>{
+ const b=Buffer.concat([member('pax',pax('size','-512'),'x'),header('file','0')]);
+ await expect(read(b)).rejects.toThrow('size');await expect(read(gzipSync(b),'tgz')).rejects.toThrow('size');
+});
+test('meta never reports a corrupt partial listing as complete',async()=>{
+ const {meta}=await import('../src/meta.js');const name='corrupt.tar';
+ writeFileSync(join(dir,name),Buffer.concat([valid,Buffer.alloc(512,42)]));
+ const result=await meta({path:dir,rows:[{name}]},{row:0,archive:true,token:42});
+ expect(result.afailed).toBe(true);expect(result.entries).toBe(0);expect(result.names).toEqual([]);expect(result.token).toBe(42);
+});

package/test/bench-markdown-scroll.mjs

@@ -0,0 +1,190 @@
+// bun test/bench-markdown-scroll.mjs [--steps=40] [--doc=readme,long,maths] [--mode=html,qml]
+// Compares two ways to preview Markdown in buninu-browser's QML runtime, at 640x480:
+//   html: Bun.markdown.html, formulas through src/mathml.js, shown by WebEngineView.loadHtml
+//         (a sandboxed iframe the browser lays out once and scrolls itself);
+//   qml:  ui/PreviewMarkdown.qml with the real backend (one delegate per block, built lazily).
+// Each scroll step is one 120px wheel at the pane's centre followed by a 1x1 PNG capture,
+// which waits for that frame's layout and paint; the times are wall clock, frame pacing
+// excluded. No threshold is a test gate.
+import { mkdtemp, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { readdirSync, readFileSync, rmSync } from "node:fs";
+import { createBrowser } from "../../buninu-browser/lib/headless-shell.js";
+import { texToMathML } from "../src/mathml.js";
+
+const repo = Bun.fileURLToPath(new URL("../", import.meta.url));
+const option = (name, fallback) => process.argv.find((arg) => arg.startsWith(`--${name}=`))?.slice(name.length + 3) ?? fallback;
+const steps = Number(option("steps", 40));
+const onlyDocs = option("doc", "readme,long,maths").split(",");
+const modes = option("mode", "html,qml").split(",");
+
+// ---- resource guard ----
+// The browser's renderer, the QML document's flea backend and that backend's highlighter
+// processes are all descendants of this process. A watchdog totals their memory every
+// half second and kills the whole tree past the limits, and so does any exit, signal or
+// stuck call: nothing this benchmark starts may outlive it or take the device down.
+const RSS_LIMIT_MB = Number(option("rss-mb", 1200));
+const PROCESS_LIMIT = Number(option("processes", 8));
+const CALL_TIMEOUT_MS = 20000;
+function descendants() {
+  const children = new Map();
+  for (const name of readdirSync("/proc")) {
+    if (!/^\d+$/.test(name)) continue;
+    try {
+      const stat = readFileSync(`/proc/${name}/stat`, "utf8");
+      // The command name is in parentheses and may hold spaces; the parent pid follows it.
+      const parent = Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[1]);
+      if (!children.has(parent)) children.set(parent, []);
+      children.get(parent).push(Number(name));
+    } catch {}
+  }
+  const found = [], queue = [process.pid];
+  while (queue.length) for (const child of children.get(queue.shift()) ?? []) { found.push(child); queue.push(child); }
+  return found;
+}
+const rssMb = (pid) => {
+  try { return Number(/VmRSS:\s+(\d+)/.exec(readFileSync(`/proc/${pid}/status`, "utf8"))?.[1] ?? 0) / 1024; } catch { return 0; }
+};
+function killTree(reason) {
+  const pids = descendants();
+  for (const pid of pids.reverse()) { try { process.kill(pid, "SIGKILL"); } catch {} }
+  if (reason) console.error(`bench: stopped (${reason}); killed ${pids.length} process(es)`);
+}
+// Each process's memory and a short command line, so a report names what grew.
+const commandOf = (pid) => {
+  try { return readFileSync(`/proc/${pid}/cmdline`, "utf8").split("\0").filter(Boolean).map((part) => part.split("/").pop()).join(" ").slice(0, 70); } catch { return "?"; }
+};
+const breakdown = (pids) => [process.pid, ...pids].map((pid) => `${pid} ${Math.round(rssMb(pid))} MB ${commandOf(pid)}`).join("\n  ");
+let samples = 0;
+const watchdog = setInterval(() => {
+  const pids = descendants();
+  const total = pids.reduce((sum, pid) => sum + rssMb(pid), 0) + rssMb(process.pid);
+  if (++samples % 4 === 0) console.error(`bench: memory ${Math.round(total)} MB in ${pids.length + 1} processes`);
+  if (total > RSS_LIMIT_MB || pids.length > PROCESS_LIMIT) {
+    console.error(`bench: over the limits:\n  ${breakdown(pids)}`);
+    killTree(`${Math.round(total)} MB in ${pids.length + 1} processes, limits ${RSS_LIMIT_MB} MB / ${PROCESS_LIMIT}`);
+    process.exit(2);
+  }
+}, 500);
+for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) process.on(signal, () => { killTree(signal); process.exit(130); });
+// On any exit, also remove the wrapper documents this run wrote beside ui/boot/shell.qml.
+process.on("exit", () => {
+  killTree(null);
+  try { for (const name of readdirSync(join(repo, "ui/boot"))) if (name.startsWith(".bench-")) rmSync(join(repo, "ui/boot", name), { force: true }); } catch {}
+});
+// Every browser call has a deadline; a renderer that stops answering ends the run.
+const deadline = (promise, what) => Promise.race([promise, new Promise((_, reject) =>
+  setTimeout(() => reject(new Error(`${what} took longer than ${CALL_TIMEOUT_MS} ms`)), CALL_TIMEOUT_MS).unref?.())]);
+process.env.BUNINU_BUN = process.execPath;
+
+// ---- documents ----
+const words = (n, seed) => Array.from({ length: n }, (_, i) => ["preview", "markdown", "scroll", "layout", "flea", "text", "render", "paint", "block", "line"][(i * 7 + seed) % 10]).join(" ");
+const readme = [
+  "# Project title", "", words(40, 1), "",
+  ...Array.from({ length: 12 }, (_, s) => [
+    `## Section ${s + 1}`, "", words(60, s), "", `- ${words(8, s)}`, `- ${words(9, s + 1)}`, `- **bold** and *italic* and \`code\``, "",
+    "```js", `const value${s} = ${s} * 2;`, "console.log(value" + s + ");", "```", "",
+    "| a | b | c |", "|---|---|---|", `| ${s} | ${s * 2} | ${s * 3} |`, "| x | y | z |", "",
+  ].join("\n")),
+].join("\n");
+const long = Array.from({ length: 600 }, (_, i) => (i % 25 === 0 ? `## Part ${i / 25 + 1}\n\n` : "") + `${i + 1}. ${words(30, i)}`).join("\n\n");
+const maths = [
+  "# Formulas", "",
+  ...Array.from({ length: 60 }, (_, i) => [
+    `Paragraph ${i + 1} has inline $x_${i % 9}^2 + \\frac{a}{b}$ and $\\sqrt{${i}}$ in it, ${words(20, i)}.`, "",
+    i % 2 ? "$$\\sum_{k=1}^{n} k^2 = \\frac{n(n+1)(2n+1)}{6}$$" : "$$\\begin{pmatrix}a & b \\\\ c & d\\end{pmatrix} \\int_0^1 x\\,dx$$", "",
+    i % 5 === 0 ? "| n | n² |\n|---|---|\n| 1 | 1 |\n| 2 | 4 |\n" : "",
+  ].join("\n")),
+].join("\n");
+const documents = { readme, long, maths };
+// --md=path adds one document of your own, run alone.
+const own = option("md", "");
+if (own) { for (const key of Object.keys(documents)) delete documents[key]; documents[own.split("/").pop().replace(/\.md$/, "")] = readFileSync(own, "utf8"); onlyDocs.push(own.split("/").pop().replace(/\.md$/, "")); }
+
+// ---- the HTML variant ----
+// Formulas are set aside before Markdown runs, so its emphasis rules never touch TeX. The
+// markers are private-use characters: Markdown replaces NUL with U+FFFD, so NUL would not survive.
+function markdownHtml(source) {
+  const formulas = [];
+  const hold = (tex, display) => `\uE000${formulas.push({ tex, display }) - 1}\uE001`;
+  const marked = source
+    .replace(/\$\$([\s\S]+?)\$\$/g, (_, tex) => hold(tex, true))
+    .replace(/\$([^$\n]+?)\$/g, (_, tex) => hold(tex, false));
+  const html = Bun.markdown.html(marked, { tables: true, strikethrough: true, tasklists: true, noHtmlBlocks: true, noHtmlSpans: true });
+  return html.replace(/\uE000(\d+)\uE001/g, (_, index) => {
+    const { tex, display } = formulas[Number(index)];
+    try { return texToMathML(tex, display); } catch { return `<code>${Bun.escapeHTML(tex)}</code>`; }
+  });
+}
+const STYLE = "body{margin:12px 16px;font:14px sans-serif;color:#d8dee9;background:#171b22;line-height:1.45}" +
+  "pre,code{background:#232833;font-family:monospace}pre{padding:8px 12px}table{border-collapse:collapse}" +
+  "td,th{border:1px solid #444;padding:2px 8px}h1{font-size:20px}h2{font-size:16px}math[display=block]{margin:6px 0}";
+
+// ---- measuring ----
+async function measure(browser, qmlPath, ready) {
+  const started = performance.now();
+  const context = browser.context;
+  // The QML host keeps its global object across documents: clear what the last one set.
+  await deadline(context.evaluate(`globalThis.benchReady = null; globalThis.preview = null; true`), "evaluate").catch(() => {});
+  await deadline(context.navigate(Bun.pathToFileURL(qmlPath).href), "navigate");
+  let isReady = false;
+  for (let i = 0; i < 400 && !(isReady = await deadline(context.evaluate(ready), "evaluate")); i++) await Bun.sleep(50);
+  if (!isReady) throw new Error("the preview never became ready");
+  await deadline(context.screenshot({ format: "png", clip: { x: 0, y: 0, width: 1, height: 1, scale: 1 } }), "screenshot");
+  const openMs = performance.now() - started;
+  const hash = async () => Bun.hash(await deadline(context.screenshot({ format: "png", clip: { x: 200, y: 140, width: 240, height: 200, scale: 1 } }), "screenshot")).toString();
+  const before = await hash();
+  const times = [];
+  for (let step = 0; step < steps; step++) {
+    const begin = performance.now();
+    await deadline(context.scroll(0, 120, { x: 320, y: 240 }), "scroll");
+    await deadline(context.screenshot({ format: "png", clip: { x: 0, y: 0, width: 1, height: 1, scale: 1 } }), "screenshot");
+    times.push(performance.now() - begin);
+  }
+  const moved = (await hash()) !== before;
+  const sorted = [...times].sort((a, b) => a - b);
+  const at = (q) => sorted[Math.min(sorted.length - 1, Math.floor(q * sorted.length))];
+  return { openMs: Math.round(openMs), medianMs: +at(0.5).toFixed(1), p95Ms: +at(0.95).toFixed(1), maxMs: +sorted.at(-1).toFixed(1), moved };
+}
+
+const dir = await mkdtemp(join(tmpdir(), "flea-md-bench-"));
+const browser = await createBrowser({ spareRenderer: false });
+const results = [];
+try {
+  await browser.context.resize(640, 480, 1);
+  const report = (result) => { results.push(result); console.log("RESULT " + JSON.stringify(result)); };
+  for (const [name, source] of Object.entries(documents)) {
+    if (!onlyDocs.includes(name)) continue;
+    const md = join(dir, `${name}.md`);
+    await Bun.write(md, source);
+    if (modes.includes("html")) {
+    // html: the page is built here, as the backend would build it.
+    const buildStart = performance.now();
+    const html = `<!doctype html><meta charset=utf-8><style>${STYLE}</style>${markdownHtml(source)}`;
+    const buildMs = Math.round(performance.now() - buildStart);
+    const htmlQml = join(repo, `ui/boot/.bench-html-${process.pid}.qml`);
+    await Bun.write(htmlQml, `import QtQuick\nimport Quickshell\nimport QtWebEngine\nFloatingWindow {width:640;height:480;color:"#171b22"\n WebEngineView {anchors.fill:parent;settings.javascriptEnabled:false\n  onLoadingChanged:function(info){if(info.status===WebEngineView.LoadSucceededStatus)globalThis.benchReady=${JSON.stringify(name)}}\n  Component.onCompleted:loadHtml(${JSON.stringify(html)})}}`);
+    // Each document answers its own name, so a flag left by the previous one never counts.
+    const htmlResult = await measure(browser, htmlQml, `globalThis.benchReady===${JSON.stringify(name)}`);
+    await rm(htmlQml, { force: true });
+    report({ document: name, mode: "html (iframe)", bytes: source.length, buildMs, ...htmlResult });
+    }
+    if (modes.includes("qml")) {
+    // qml: the existing preview, with its own backend reading the file.
+    const qmlQml = join(repo, `ui/boot/.bench-qml-${process.pid}.qml`);
+    await Bun.write(qmlQml, `import QtQuick\nimport Quickshell\nimport ".." as Flea\nFloatingWindow {width:640;height:480;color:"#171b22";Flea.Backend{id:backend}\n Loader {anchors.fill:parent;Component.onCompleted:setSource("${Bun.pathToFileURL(join(repo, "ui/PreviewMarkdown.qml")).href}")\n  onLoaded:{item.backend=backend;item.size=${Buffer.byteLength(source)};item.path=${JSON.stringify(md)};item.active=true;globalThis.preview=item}}}`);
+    const qmlResult = await measure(browser, qmlQml, "!!globalThis.preview && preview.loadedText.length>0 && preview.viewport.count>0");
+    await rm(qmlQml, { force: true });
+    report({ document: name, mode: "qml (rich text blocks)", bytes: source.length, buildMs: 0, ...qmlResult });
+    }
+  }
+} finally {
+  clearInterval(watchdog);
+  await deadline(browser.close(), "close").catch(() => {});
+  killTree(null);
+  await rm(dir, { recursive: true, force: true });
+  for (const name of readdirSync(join(repo, "ui/boot"))) if (name.startsWith(".bench-")) await rm(join(repo, "ui/boot", name), { force: true });
+}
+console.table(results);
+console.log(JSON.stringify(results));

package/test/clip-host.test.js

@@ -0,0 +1,113 @@
+import { test, expect } from 'bun:test';
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { HostClipboard, clipHostReply } from '../src/clip-host.js';
+import { clipText, parseClipText } from '../src/clip.js';
+
+const source = (await Bun.file(new URL('../ui/js/HostClipboard.js', import.meta.url)).text()).replace(/^\.pragma.*$/gm, '');
+const makeHandler = () => new Function(source + ';return handle')();
+const none = { clip: 'none', paths: [], token: '', skipped: 0 };
+function fixture() {
+  let text = '', reads = 0, failRead = false, failWrite = false;
+  const writes = [], handle = makeHandler();
+  const qs = {
+    async readClipboardText(options) { expect(options.strict).toBe(true); reads++; if(failRead)throw Error('read denied'); return text; },
+    async writeClipboardText(value) { if(failWrite)throw Error('write denied'); writes.push(value);text=value; },
+  };
+  const send = message => handle({send: clipHostReply}, qs, message);
+  const dc = new HostClipboard(send, { clipText, parseClipText, none });
+  return { dc, writes, get text(){return text}, set text(v){text=v}, get reads(){return reads},
+    failRead(v){failRead=v},failWrite(v){failWrite=v},
+    second:()=>new HostClipboard(send,{clipText,parseClipText,none}) };
+}
+function files() {
+  const dir = mkdtempSync(join(tmpdir(), 'flea-clip-'));
+  const paths = [join(dir, "a 'quoted' 中文\nline"),join(dir,'back\\slash $` name')];
+  for(const path of paths)writeFileSync(path,'test');
+  return {paths,cleanup:()=>rmSync(dir,{recursive:true,force:true})};
+}
+
+test('QS fallback preserves POSIX copy/cut bytes and fresh cross-window paste', async()=>{
+  const f=files(),h=fixture();
+  try {
+    await h.dc.set(null,{op:'copy',paths:f.paths,token:'a'});
+    expect(h.text).toBe(clipText('copy',f.paths));expect(h.reads).toBe(0);
+    expect((await h.dc.snapshot()).paths).toEqual(f.paths);
+    await h.dc.set(null,{op:'cut',paths:f.paths,token:'b'});
+    expect(h.text).toBe('""'+clipText('copy',f.paths)+'""');
+    expect(await h.second().snapshot()).toEqual({clip:'cut',paths:f.paths,token:'',skipped:0});
+    h.text='a newer Android clipboard';
+    expect(await h.dc.snapshot()).toEqual(none);
+    expect(await h.dc.clearIf({token:'b'})).toBe(false);
+    expect(h.text).toBe('a newer Android clipboard');
+  } finally {f.cleanup()}
+});
+test('spent cut clears only identical text, even after its files moved',async()=>{
+  const f=files(),h=fixture();
+  await h.dc.set(null,{op:'cut',paths:f.paths,token:'old'});
+  f.cleanup();
+  expect(await h.dc.clearIf({token:'wrong'})).toBe(false);
+  expect(await h.dc.clearIf({token:'old'})).toBe(true);expect(h.text).toBe('');
+  h.text=clipText('cut',f.paths);
+  expect(await h.second().clearIf({cut:f.paths})).toBe(true);
+  h.text=clipText('copy',f.paths);
+  expect(await h.dc.clearIf({cut:f.paths})).toBe(false);
+});
+test('read/write failure is not a cached success and later operations recover',async()=>{
+  const h=fixture();h.failWrite(true);
+  await expect(h.dc.set(null,{op:'text',paths:['bad'],token:''})).rejects.toThrow('write denied');
+  expect(h.dc.owned).toBe(null);h.failWrite(false);
+  await h.dc.set(null,{op:'text',paths:['good'],token:''});expect(h.text).toBe('good');
+  h.failRead(true);await expect(h.dc.snapshot()).rejects.toThrow('read denied');
+  h.failRead(false);expect(await h.dc.snapshot()).toEqual(none);
+});
+test('overlapping operations are ordered; native QS property fallback uses identical text',async()=>{
+  const h=fixture();
+  await Promise.all(['one','two','three'].map(x=>h.dc.set(null,{op:'text',paths:[x],token:''})));
+  expect(h.writes).toEqual(['one','two','three']);
+  const handle=makeHandler(),qs={clipboardText:''},replies=[];
+  const text='""\'C:/has space/a\'\'\\\'\'b\'""';
+  await handle({send:m=>replies.push(m)},qs,{id:1,op:'write',text});
+  await handle({send:m=>replies.push(m)},qs,{id:2,op:'read'});
+  expect(qs.clipboardText).toBe(text);expect(replies[1].text).toBe(text);
+});
+
+test('real backend negotiates missing-Wayland fallback and exchanges QS clipboard replies',async()=>{
+  const f=files(),dir=mkdtempSync(join(tmpdir(),'flea-no-wayland-'));
+  const child=Bun.spawn([process.execPath,new URL('../src/flea.js',import.meta.url).pathname,'--backend'],{
+    env:{...process.env,WAYLAND_DISPLAY:join(dir,'missing'),XDG_RUNTIME_DIR:dir},stdin:'pipe',stdout:'pipe',stderr:'pipe'});
+  const errors=new Response(child.stderr).text(),lines=[],waiters=[];
+  let text='';const qs={readClipboardText:async()=>text,writeClipboardText:async t=>{text=t}};
+  const send=m=>{child.stdin.write(JSON.stringify(m)+'\n');child.stdin.flush()},handle=makeHandler();
+  const reading=(async()=>{
+    let tail='';const decoder=new TextDecoder();
+    for await(const chunk of child.stdout){tail+=decoder.decode(chunk,{stream:true});let index;
+      while((index=tail.indexOf('\n'))>=0){const line=tail.slice(0,index);tail=tail.slice(index+1);if(!line)continue;
+        const m=JSON.parse(line);
+        if(m.t==='clipHost'){void handle({send},qs,m);continue;}
+        lines.push(m);for(const notify of [...waiters])notify();
+      }
+    }
+  })();
+  async function next(op,action){
+    const start=lines.length;
+    const promise=new Promise((resolve,reject)=>{
+      const timer=setTimeout(()=>{waiters.splice(waiters.indexOf(check),1);reject(Error('reply timeout '+op))},5000);
+      const check=()=>{const found=lines.slice(start).find(m=>m.t==='clip'&&m.op===op);if(found){clearTimeout(timer);waiters.splice(waiters.indexOf(check),1);resolve(found)}};
+      waiters.push(check);
+    });action();return promise;
+  }
+  try {
+    const watch=await next('changed',()=>send({c:'clipWatch',hostText:true}));expect(watch.error).toContain('read on demand');
+    const set=await next('set',()=>send({c:'clipSet',op:'cut',paths:f.paths}));expect(set.ok).toBe(true);
+    expect(text).toBe(clipText('cut',f.paths));
+    const get=await next('get',()=>send({c:'clipGet'}));expect(get.paths).toEqual(f.paths);expect(get.clip).toBe('cut');
+    expect(get.token).toBe(set.token);
+    text='new Android text';
+    const clear=await next('clear',()=>send({c:'clipClear',token:set.token}));expect(clear.cleared).toBe(false);
+    const fresh=await next('get',()=>send({c:'clipGet'}));expect(fresh.clip).toBe('none');
+    send({c:'quit'});expect(await child.exited).toBe(0);await reading;
+    expect(await errors).toBe('');
+  } finally {child.kill();await child.exited;f.cleanup();rmSync(dir,{recursive:true,force:true})}
+},15000);

package/test/code-preview.test.js

@@ -0,0 +1,35 @@
+import {test,expect} from 'bun:test';
+import {mkdtempSync,writeFileSync,openSync,ftruncateSync,closeSync,rmSync} from 'node:fs';
+import {tmpdir} from 'node:os';
+import {join} from 'node:path';
+import {code} from '../src/code.js';
+const text=reply=>reply.lines.map(r=>r.filter((_,i)=>i%2).join('')).join('\n');
+test('unknown binary files remain viewable with visible control characters',async()=>{
+ const r=await code({text:'first\0second\x1b[31m\nlast',raw:true});
+ expect(r.state).toBe('plain');expect(text(r)).toBe('first␀second␛[31m\nlast');
+});
+test('large sparse files read only their prefix and split pathological lines',async()=>{
+ const dir=mkdtempSync(join(tmpdir(),'flea-preview-'));
+ try {
+  const path=join(dir,'large.unknown');writeFileSync(path,'start\n');
+  const fd=openSync(path,'r+');try{ftruncateSync(fd,1024*1024*1024);}finally{closeSync(fd);}
+  const r=await code({path,count:400});
+  expect(r.state).toBe('plain');expect(r.lines[0]).toEqual([0,'start']);
+  expect(r.total).toBeLessThan(400);
+  expect(text(r)).toContain('[Preview truncated: first 1 MiB]');
+  expect(text(r)).toContain('[Long lines split for preview]');
+  expect(r.lines.every(line=>line.length<3 && (line[1]?.length??0)<=4096)).toBe(true);
+ } finally {rmSync(dir,{recursive:true,force:true});}
+});
+test('prefix windows stay addressable and empty files remain empty',async()=>{
+ expect((await code({text:'',raw:true})).total).toBe(0);
+ const r=await code({text:'one\ntwo\nthree\n',first:2,count:1,raw:true});
+ expect(r.total).toBe(3);expect(text(r)).toBe('two');
+});
+test('unrecognized types reach text preview while media keeps its own viewer',async()=>{
+ const source=(await Bun.file(new URL('../ui/js/Kinds.js',import.meta.url)).text()).replace(/^\.(?:pragma|import).*$/gm,'');
+ const kinds=new Function('Archive','Format',source+';return {kindState,quickLookKind};')({isArchive:()=>false},{});
+ expect(kinds.kindState('unknown-format')).toBe('text');
+ expect(kinds.quickLookKind('💾','data.bin',false)).toBe('text');
+ expect(kinds.quickLookKind('🎬','movie.mp4',false)).toBe('video');
+});

package/test/compare-ui-paths.test.js

@@ -0,0 +1,24 @@
+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 Lists=await load('Lists','isList');
+const Format=await load('Format','S_IFMT,S_IFREG');
+const Menu=await load('Menu','canCompare',{Lists,Format});
+const Ops=await load('Ops','open',{Menu,Search:{baseOf:p=>p.path}});
+test('Compare menu accepts POSIX, Windows drive and UNC paths, preserves listing order',()=>{
+ for(const base of ['/tmp/','C:/dir/','C:\\dir\\','\\\\server\\share\\']){
+  const calls=[],rows=[{n:'a.txt',p:33188},{n:'b.txt',p:33188}];
+  const pane={path:base,selectedIndices:()=>[1,0],rowFor:i=>rows[i],
+   join:(a,b)=>a+b,quickLook:()=>({openCompare:(...args)=>calls.push(args)})};
+  Ops.open(pane);
+  expect(calls[0]?.slice(0,2)).toEqual([base+'a.txt',base+'b.txt']);
+  calls.length=0;
+  Ops.open(pane,[base+'b.txt',base+'a.txt']);
+  expect(calls[0]?.slice(0,2)).toEqual([base+'a.txt',base+'b.txt']);
+  for(const bad of ['relative.txt','C:relative.txt','https://example.com/a']){
+   calls.length=0;Ops.open(pane,[bad,base+'a.txt']);expect(calls).toEqual([]);
+  }
+ }
+});

package/test/compare.test.js

@@ -0,0 +1,54 @@
+import {test,expect} from 'bun:test';
+import {mkdtempSync,writeFileSync,rmSync} from 'node:fs';
+import {join} from 'node:path';import {tmpdir} from 'node:os';
+import {compare,diffCommands} from '../src/compare.js';
+test('diff searches sibling bunmsh, PATH bunmsh, then system using -cc builtin',()=>{
+ expect(diffCommands({which:n=>'/bin/'+n,exists:()=>true,beside:'/src/bunmsh/index.js'})).toEqual([
+ ['/bin/bun','/src/bunmsh/index.js','-cc','builtin','diff'],['/bin/bunmsh','-cc','builtin','diff'],['/bin/diff']]);
+ expect(diffCommands({which:n=>n==='diff'?'/bin/diff':null,exists:()=>false})).toEqual([['/bin/diff']]);
+});
+test('Compare emits unified patches and all terminal states, falls back and cancels',async()=>{
+ const dir=mkdtempSync(join(tmpdir(),'flea-compare-'));const a=join(dir,"a 中文 ' $.txt"),b=join(dir,'b.txt');
+ const ask={a,b,token:42};
+ try {
+  writeFileSync(a,'first\nold\n');writeFileSync(b,'first\nnew\n');
+  const r=await compare(ask);expect(r.state).toBe('diff');expect(r.patch).toContain('-old\n+new\n');expect(r.token).toBe(42);
+  expect((await compare({...ask,b:a})).state).toBe('identical');
+  expect((await compare({...ask,b:dir})).state).toBe('failed');
+  expect((await compare({...ask,b:b+'missing'})).state).toBe('failed');
+  writeFileSync(b,'x\0y');expect((await compare(ask)).state).toBe('binary');
+  writeFileSync(b,'x'.repeat(1048577));expect((await compare(ask)).state).toBe('over');
+  writeFileSync(b,'other\n');
+  expect((await compare(ask,{commands:[[process.execPath,'-e','process.exit(2)'],...diffCommands()]})).state).toBe('diff');
+  expect((await compare(ask,{commands:[[process.execPath,'-e','setInterval(()=>{},1000)']],timeout:100})).state).toBe('failed');
+  const control=new AbortController();control.abort();expect(await compare(ask,{signal:control.signal})).toBe(null);
+ }finally{rmSync(dir,{recursive:true,force:true})}
+},15000);
+
+test('timeout and in-flight abort kill a provider that ignores SIGTERM',async()=>{
+ const dir=mkdtempSync(join(tmpdir(),'flea-compare-cancel-'));
+ const a=join(dir,'a'),b=join(dir,'b'),ready=join(dir,'ready');
+ writeFileSync(a,'a');writeFileSync(b,'b');
+ const provider=join(dir,'provider.js');
+ // Self-exit bounds a regression without leaving a test process alive.
+ writeFileSync(provider,`process.on('SIGTERM',()=>{});await Bun.write(${JSON.stringify(ready)},String(process.pid));setTimeout(()=>process.exit(0),6000);`);
+ try{
+  for(const abort of [false,true]){
+   rmSync(ready,{force:true});
+   const control=new AbortController();
+   const start=performance.now();
+   const pending=compare({a,b},{commands:[[process.execPath,provider]],signal:control.signal,timeout:abort?10000:1000});
+   let pid;
+   for(let i=0;i<100;i++){
+    if(await Bun.file(ready).exists()){pid=Number(await Bun.file(ready).text());break}
+    await Bun.sleep(20);
+   }
+   expect(pid).toBeGreaterThan(0);
+   if(abort)control.abort();
+   const result=await pending;
+   expect(performance.now()-start).toBeLessThan(3000);
+   if(abort)expect(result).toBe(null);else expect(result.state).toBe('failed');
+   expect(()=>process.kill(pid,0)).toThrow();
+  }
+ }finally{rmSync(dir,{recursive:true,force:true})}
+},15000);

package/test/delete-trash.test.js

@@ -0,0 +1,67 @@
+import {test,expect,afterAll} from 'bun:test';
+import {mkdtempSync,mkdirSync,writeFileSync,readFileSync,existsSync,renameSync,symlinkSync,lstatSync,rmSync,readdirSync} from 'node:fs';
+import {tmpdir} from 'node:os';
+import {join,basename} from 'node:path';
+import {menuaction} from '../src/menu.js';
+import {trashOne,trash} from '../src/trash.js';
+const root=mkdtempSync(join(tmpdir(),'flea-mutations-'));
+const original=process.env.XDG_DATA_HOME;
+process.env.XDG_DATA_HOME=join(root,'data');
+afterAll(()=>{if(original===undefined)delete process.env.XDG_DATA_HOME;else process.env.XDG_DATA_HOME=original;rmSync(root,{recursive:true,force:true});});
+let next=1000;
+function fixture() {
+ const id=++next,path=join(root,String(id));mkdirSync(path);writeFileSync(join(path,'file'),'hello');
+ const messages=[],send=m=>messages.push(m);
+ const call=(op,rest={})=>{menuaction({op,id,...rest},send,null,0);return messages.at(-1)};
+ call('snapshot',{paths:[path]});return {path,call};
+}
+test('permanent delete requires a prepared token and deletes reviewed tree once',()=>{
+ const {path,call}=fixture();expect(call('checkDelete').valid).toBe(false);expect(call('delete').ok).toBe(false);
+ const prepared=call('prepareDelete');expect(prepared.name).toBe(basename(path));const {token}=prepared;expect(call('checkDelete',{token}).valid).toBe(true);
+ call('delete',{token});expect(existsSync(path)).toBe(false);expect(call('delete',{token}).ok).toBe(false);
+});
+test('new descendants invalidate confirmation before any removal',()=>{
+ const {path,call}=fixture(),{token}=call('prepareDelete');writeFileSync(join(path,'new'),'new');
+ expect(call('checkDelete',{token}).valid).toBe(false);expect(call('delete',{token}).stale).toBe(true);expect(existsSync(join(path,'file'))).toBe(true);
+});
+test('refresh captures replacement identity and updates the cursor',()=>{
+ const {path,call}=fixture(),old=call('prepareDelete').token;
+ renameSync(path,path+'.old');mkdirSync(path);writeFileSync(join(path,'new'),'new');
+ const {token}=call('refreshDelete');expect(token).not.toBe(old);expect(call('checkDelete',{token}).valid).toBe(true);
+ call('delete',{token});expect(existsSync(path)).toBe(false);expect(existsSync(path+'.old/file')).toBe(true);
+});
+test('review and deletion do not follow symbolic links',()=>{
+ const {path,call}=fixture(),outside=join(root,'outside');mkdirSync(outside);writeFileSync(join(outside,'keep'),'keep');symlinkSync(outside,join(path,'link'));
+ const {token}=call('prepareDelete');call('delete',{token});expect(readFileSync(join(outside,'keep'),'utf8')).toBe('keep');
+});
+test('root deletion is refused without traversing it',()=>{
+ const id=++next, messages=[],send=m=>messages.push(m);
+ menuaction({op:'snapshot',id,paths:['/']},send,null,0);menuaction({op:'prepareDelete',id},send,null,0);
+ expect(messages.at(-1).ok).toBe(false);
+});
+test('trash moves files, preserves content and encodes metadata',()=>{
+ const path=join(root,'space 中文.txt');writeFileSync(path,'payload');trashOne(path);
+ const dir=join(process.env.XDG_DATA_HOME,'Trash');expect(existsSync(path)).toBe(false);
+ expect(readFileSync(join(dir,'files','space 中文.txt'),'utf8')).toBe('payload');
+ const info=readFileSync(join(dir,'info','space 中文.txt.trashinfo'),'utf8');expect(info).toContain('%20');expect(info).toContain('%E4%B8%AD');expect(info).toContain('DeletionDate=');
+});
+test('trash does not overwrite an orphan or a prior trashed name',()=>{
+ const path=join(root,'same');writeFileSync(path,'first');trashOne(path);writeFileSync(path,'second');trashOne(path);
+ const files=join(process.env.XDG_DATA_HOME,'Trash/files');writeFileSync(join(files,'orphan'),'old');
+ const other=join(root,'orphan');writeFileSync(other,'new');trashOne(other);
+ expect(readFileSync(join(files,'same'),'utf8')).toBe('first');expect(readFileSync(join(files,'same.2'),'utf8')).toBe('second');
+ expect(readFileSync(join(files,'orphan'),'utf8')).toBe('old');expect(readFileSync(join(files,'orphan.2'),'utf8')).toBe('new');
+});
+test('trash keeps symlink as a symlink and reports per-item failures',()=>{
+ const path=join(root,'link');symlinkSync(join(root,'missing-target'),path);
+ const events=[];trash({id:1},m=>events.push(m),{paths:[path,join(root,'absent')]});
+ expect(lstatSync(join(process.env.XDG_DATA_HOME,'Trash/files/link')).isSymbolicLink()).toBe(true);
+ const result=events.find(m=>m.t==='trashed');expect(result.ok).toBe(1);expect(result.failed).toBe(1);
+});
+test('unsafe symlink Trash is refused without moving the source',()=>{
+ const saved=process.env.XDG_DATA_HOME,dir=join(root,'unsafe'),outside=join(root,'unrelated');mkdirSync(dir);mkdirSync(outside);
+ symlinkSync(outside,join(dir,'Trash'));process.env.XDG_DATA_HOME=dir;
+ const path=join(root,'keep');writeFileSync(path,'keep');
+ try {expect(()=>trashOne(path)).toThrow();expect(existsSync(path)).toBe(true);expect(readdirSync(outside)).toEqual([]);}
+ finally{process.env.XDG_DATA_HOME=saved;}
+});