flea-qml 0.0.0-stage → 0.2.0

package/test/office-preview.test.js

@@ -0,0 +1,154 @@
+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 { deflateRawSync } from 'node:zlib';
+import { officeKind, officePreview } from '../src/office.js';
+import { html, previewHtml } from '../src/html.js';
+import { code } from '../src/code.js';
+
+const dir = mkdtempSync(join(tmpdir(), 'flea-office-'));
+afterAll(() => rmSync(dir, { recursive: true, force: true }));
+
+// A zip of the given members, deflated unless `store`; CRCs are zero because nothing here checks them.
+function zip(members, store = false) {
+  const locals = [], centrals = [];
+  let offset = 0;
+  for (const [name, content] of Object.entries(members)) {
+    const raw = Buffer.from(content), data = store ? raw : deflateRawSync(raw), id = Buffer.from(name);
+    const local = Buffer.alloc(30);
+    local.writeUInt32LE(0x04034b50, 0); local.writeUInt16LE(20, 4); local.writeUInt16LE(store ? 0 : 8, 8);
+    local.writeUInt32LE(data.length, 18); local.writeUInt32LE(raw.length, 22); local.writeUInt16LE(id.length, 26);
+    const central = Buffer.alloc(46);
+    central.writeUInt32LE(0x02014b50, 0); central.writeUInt16LE(20, 4); central.writeUInt16LE(20, 6);
+    central.writeUInt16LE(store ? 0 : 8, 10); central.writeUInt32LE(data.length, 20); central.writeUInt32LE(raw.length, 24);
+    central.writeUInt16LE(id.length, 28); central.writeUInt32LE(offset, 42);
+    locals.push(local, id, data); centrals.push(central, id);
+    offset += 30 + id.length + data.length;
+  }
+  const directory = Buffer.concat(centrals), end = Buffer.alloc(22);
+  end.writeUInt32LE(0x06054b50, 0); end.writeUInt16LE(Object.keys(members).length, 8); end.writeUInt16LE(Object.keys(members).length, 10);
+  end.writeUInt32LE(directory.length, 12); end.writeUInt32LE(offset, 16);
+  return Buffer.concat([...locals, directory, end]);
+}
+const file = (name, bytes) => { const path = join(dir, name); writeFileSync(path, bytes); return path; };
+
+const W = 'xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"';
+const docx = {
+  'word/styles.xml': `<w:styles ${W}><w:style w:type="paragraph" w:styleId="Kop1"><w:name w:val="heading 1"/></w:style><w:style w:type="paragraph" w:styleId="T"><w:name w:val="Title"/></w:style></w:styles>`,
+  'word/numbering.xml': `<w:numbering ${W}><w:abstractNum w:abstractNumId="0"><w:lvl w:ilvl="0"><w:numFmt w:val="bullet"/></w:lvl></w:abstractNum><w:abstractNum w:abstractNumId="1"><w:lvl w:ilvl="0"><w:numFmt w:val="decimal"/></w:lvl></w:abstractNum><w:num w:numId="1"><w:abstractNumId w:val="0"/></w:num><w:num w:numId="2"><w:abstractNumId w:val="1"/></w:num></w:numbering>`,
+  'word/document.xml': `<?xml version="1.0"?><w:document ${W}><w:body>
+    <w:p><w:pPr><w:pStyle w:val="Kop1"/><w:rPr><w:b/></w:rPr></w:pPr><w:r><w:t>Report &amp; plan</w:t></w:r></w:p>
+    <w:p><w:r><w:t xml:space="preserve">Plain </w:t></w:r><w:r><w:rPr><w:b/><w:i w:val="0"/></w:rPr><w:t>bold</w:t></w:r><w:r><w:rPr><w:i/><w:u w:val="single"/></w:rPr><w:t> a&lt;b</w:t></w:r><w:r><w:rPr><w:vertAlign w:val="superscript"/></w:rPr><w:t>2</w:t></w:r></w:p>
+    <w:p><w:pPr><w:numPr><w:ilvl w:val="0"/><w:numId w:val="1"/></w:numPr></w:pPr><w:r><w:t>one</w:t></w:r></w:p>
+    <w:p><w:pPr><w:numPr><w:ilvl w:val="0"/><w:numId w:val="1"/></w:numPr></w:pPr><w:r><w:t>two</w:t></w:r></w:p>
+    <w:p><w:pPr><w:numPr><w:ilvl w:val="0"/><w:numId w:val="2"/></w:numPr></w:pPr><w:r><w:t>first</w:t></w:r></w:p>
+    <w:tbl><w:tr><w:tc><w:p><w:r><w:t>A1</w:t></w:r></w:p><w:p><w:r><w:t>line</w:t></w:r></w:p></w:tc><w:tc><w:p><w:r><w:t>B1</w:t></w:r></w:p></w:tc></w:tr></w:tbl>
+    <w:p><w:r><w:t>kept</w:t></w:r><w:del><w:r><w:delText>removed</w:delText></w:r></w:del><w:r><w:instrText>PAGE</w:instrText></w:r><w:r><w:br/><w:t>next</w:t><w:tab/><w:t>col</w:t></w:r></w:p>
+    <w:p/>
+  </w:body></w:document>`,
+};
+
+test('office names are told apart by extension', () => {
+  expect(['a.DOCX', 'b.odt', 'c.pptx', 'd.odp', 'e.xlsx', 'f.ods', 'g.doc', 'h.zip', 'docx'].map(officeKind))
+    .toEqual(['document', 'document', 'slides', 'slides', 'sheet', 'sheet', '', '', '']);
+});
+
+test('DOCX becomes headings, emphasis, lists and tables in the fixed tags', () => {
+  const preview = officePreview(file('rich.docx', zip(docx)));
+  expect(preview.listed).toBe(false);
+  expect(preview.html).toBe('<h1>Report &amp; plan</h1><p>Plain <b>bold</b><u><i> a&lt;b</i></u><sup>2</sup></p>'
+    + '<ul><li>one</li><li>two</li></ul><ol><li>first</li></ol>'
+    + '<table><tr><td>A1<br>line</td><td>B1</td></tr></table>'
+    + '<p>kept<br>next&nbsp;&nbsp;&nbsp;&nbsp;col</p>');
+  // The fragment survives the HTML preview's own rebuild unchanged, so every tag is one it keeps.
+  expect(previewHtml(preview.html)).toBe(preview.html);
+  expect(preview.text).toBe('Report & plan\nPlain bold a<b2\none\ntwo\nfirst\nA1\nline\tB1\n\nkept\nnext    col\n');
+});
+
+test('the html and code requests answer a DOCX from its text, stored or deflated', async () => {
+  const path = file('stored.docx', zip(docx, true));
+  expect(await html({ path, token: 3, slot: 'column' })).toMatchObject({ state: 'ready', token: 3, total: 9, html: officePreview(path).html });
+  const reply = await code({ path, first: 1, count: 2 });
+  expect(reply).toMatchObject({ state: 'plain', total: 10, lines: [[0, 'Report & plan'], [0, 'Plain bold a<b2']] });
+});
+
+test('PPTX slides follow the presentation order, with titles and tables', () => {
+  const slide = (title, body) => `<p:sld><p:sp><p:nvSpPr><p:nvPr><p:ph type="title"/></p:nvPr></p:nvSpPr><p:txBody><a:p><a:r><a:t>${title}</a:t></a:r></a:p></p:txBody></p:sp>`
+    + `<p:sp><p:nvSpPr><p:nvPr><p:ph idx="1"/></p:nvPr></p:nvSpPr><p:txBody><a:p><a:r><a:rPr b="1"/><a:t>${body}</a:t></a:r><a:br/><a:r><a:t>more</a:t></a:r></a:p></p:txBody></p:sp></p:sld>`;
+  const preview = officePreview(file('deck.pptx', zip({
+    'ppt/presentation.xml': '<p:presentation><p:sldIdLst><p:sldId id="1" r:id="rId2"/><p:sldId id="2" r:id="rId1"/></p:sldIdLst></p:presentation>',
+    'ppt/_rels/presentation.xml.rels': '<Relationships><Relationship Id="rId1" Target="slides/slide1.xml"/><Relationship Id="rId2" Target="slides/slide2.xml"/></Relationships>',
+    'ppt/slides/slide1.xml': slide('Second', 'b'),
+    'ppt/slides/slide2.xml': slide('First', 'a'),
+  })));
+  expect(preview.html).toBe('<h2>Slide 1</h2><h3>First</h3><p><b>a</b><br>more</p><h2>Slide 2</h2><h3>Second</h3><p><b>b</b><br>more</p>');
+});
+
+test('ODT reads headings, styled spans, lists and tables, without tracked changes or notes', () => {
+  const preview = officePreview(file('text.odt', zip({ 'content.xml': `<office:document-content>
+    <office:automatic-styles><style:style style:name="T1" style:family="text"><style:text-properties fo:font-weight="bold" fo:font-style="italic"/></style:style></office:automatic-styles>
+    <office:body><office:text><text:tracked-changes><text:p>gone</text:p></text:tracked-changes>
+    <text:h text:outline-level="2">Head</text:h>
+    <text:p>a<text:span text:style-name="T1">b</text:span><text:s text:c="2"/>c<text:note><text:p>foot</text:p></text:note><text:line-break/>d</text:p>
+    <text:list><text:list-item><text:p>x</text:p></text:list-item><text:list-item><text:p>y</text:p></text:list-item></text:list>
+    <table:table><table:table-row><table:table-cell><text:p>1</text:p></table:table-cell><table:table-cell><text:p>2</text:p></table:table-cell></table:table-row></table:table>
+    </office:text></office:body></office:document-content>` })));
+  expect(preview.html).toBe('<h2>Head</h2><p>a<i><b>b</b></i>&nbsp;&nbsp;c<br>d</p><ul><li>x</li><li>y</li></ul><table><tr><td>1</td><td>2</td></tr></table>');
+});
+
+test('XLSX answers its first sheet as CSV: shared strings, dates, booleans, gaps and quoting', async () => {
+  const path = file('book.xlsx', zip({
+    'xl/workbook.xml': '<workbook><sheets><sheet name="Second" sheetId="2" r:id="rId2"/><sheet name="Other" sheetId="1" r:id="rId1"/></sheets></workbook>',
+    'xl/_rels/workbook.xml.rels': '<Relationships><Relationship Id="rId1" Target="worksheets/sheet1.xml"/><Relationship Id="rId2" Target="/xl/worksheets/sheet2.xml"/></Relationships>',
+    'xl/sharedStrings.xml': '<sst><si><t>Name</t></si><si><r><t>Say </t></r><r><t>"hi", ok</t></r><rPh><t>skip</t></rPh></si></sst>',
+    'xl/styles.xml': '<styleSheet><numFmts><numFmt numFmtId="164" formatCode="yyyy\\-mm\\-dd"/></numFmts><cellStyleXfs><xf numFmtId="14"/></cellStyleXfs><cellXfs><xf numFmtId="0"/><xf numFmtId="164"/><xf numFmtId="20"/></cellXfs></styleSheet>',
+    'xl/worksheets/sheet1.xml': '<worksheet><sheetData><row r="1"><c r="A1"><v>wrong sheet</v></c></row></sheetData></worksheet>',
+    'xl/worksheets/sheet2.xml': '<worksheet><sheetData>'
+      + '<row r="1"><c r="A1" t="s"><v>0</v></c><c r="C1" t="inlineStr"><is><t>When</t></is></c></row>'
+      + '<row r="2"><c r="A2" t="s"><v>1</v></c><c r="B2"><v>1.50</v></c><c r="C2" s="1"><v>45000</v></c><c r="D2" t="b"><v>1</v></c><c r="E2" s="2"><v>0.5</v></c></row>'
+      + '<row r="4"><c r="B4" t="str"><f>A1</f><v>calc</v></c></row>'
+      + '</sheetData></worksheet>',
+  }));
+  const preview = officePreview(path);
+  expect(preview.csv).toBe('Name,,When\n"Say ""hi"", ok",1.5,2023-03-15,TRUE,12:00:00\n\n,calc\n[Sheet 1 of 2: Second. The other sheets are not shown.]\n');
+  // The table asks by record; the quoted record and the count come back whole.
+  expect(await code({ path, raw: true, csv: ',', record: 2, count: 1 })).toMatchObject({ first: 2, records: 5, firstRecord: 2, lines: [[0, '"Say ""hi"", ok",1.5,2023-03-15,TRUE,12:00:00']] });
+});
+
+test('ODS repeats filled cells and ignores the padding to the sheet edge', () => {
+  const preview = officePreview(file('sheet.ods', zip({ 'content.xml': `<office:document-content><office:body><office:spreadsheet>
+    <table:table table:name="S"><table:table-row><table:table-cell table:number-columns-repeated="2"><text:p>x</text:p></table:table-cell><table:table-cell table:number-columns-repeated="16382"/></table:table-row>
+    <table:table-row table:number-rows-repeated="2"><table:table-cell/></table:table-row>
+    <table:table-row><table:table-cell/><table:table-cell><text:p>a, b</text:p><text:p>c</text:p></table:table-cell></table:table-row>
+    <table:table-row table:number-rows-repeated="1048570"><table:table-cell table:number-columns-repeated="16384"/></table:table-row></table:table>
+    </office:spreadsheet></office:body></office:document-content>` })));
+  expect(preview.csv).toBe('x,x\n\n\n,"a, b\nc"\n');
+});
+
+test('a container with no readable content lists its members, and a non-zip is refused', async () => {
+  const empty = officePreview(file('empty.docx', zip({ '[Content_Types].xml': '<Types/>', 'word/other.xml': '<x/>' })));
+  expect(empty).toMatchObject({ listed: true, html: '<p>No readable text in this document. It contains:</p><ul><li>[Content_Types].xml</li><li>word/other.xml</li></ul>' });
+  const sheet = officePreview(file('empty.xlsx', zip({ 'a&b.bin': 'xyz' })));
+  expect(sheet).toMatchObject({ listed: true, csv: 'Member,Bytes\na&b.bin,3\n' });
+  const legacy = file('legacy.docx', Buffer.from('\xd0\xcf\x11\xe0 not a zip', 'latin1'));
+  expect(() => officePreview(legacy)).toThrow();
+  expect((await html({ path: legacy, token: 1, slot: 'x' })).state).toBe('failed');
+  expect((await code({ path: legacy })).state).toBe('failed');
+});
+
+test('hostile XML is neither expanded nor passed through', () => {
+  const bomb = officePreview(file('bomb.docx', zip({ 'word/document.xml': '<!DOCTYPE d [<!ENTITY a "aaaa">]><w:document><w:body><w:p><w:r><w:t>&a;</w:t></w:r></w:p></w:body></w:document>' })));
+  expect(bomb.listed).toBe(true);
+  const markup = officePreview(file('markup.docx', zip({ 'word/document.xml': '<w:document><w:body><w:p><w:r><w:t>&lt;script&gt;x&lt;/script&gt; &#60;img&#62; &amp;amp;</w:t></w:r></w:p></w:body></w:document>' })));
+  expect(markup.html).toBe('<p>&lt;script&gt;x&lt;/script&gt; &lt;img&gt; &amp;amp;</p>');
+  expect(previewHtml(markup.html)).toBe(markup.html);
+});
+
+test('a long document stops at the output limit with balanced tags', () => {
+  const paragraph = `<w:p><w:r><w:t>${'word '.repeat(200)}</w:t></w:r></w:p>`;
+  const preview = officePreview(file('long.docx', zip({ 'word/document.xml': `<w:document><w:body>${paragraph.repeat(2000)}</w:body></w:document>` })));
+  expect(preview.html.length).toBeLessThan(1 << 20);
+  expect(preview.html.endsWith('<p>[Preview truncated]</p>')).toBe(true);
+  expect(previewHtml(preview.html)).toBe(preview.html);
+});

package/test/pele-parity.test.js

@@ -0,0 +1,28 @@
+import {expect, test} from 'bun:test';
+import {mermaidToSvg} from '../src/pele-wrapper.js';
+import fixtures from './fixtures/pele-parity.json';
+
+// Baseline: the former Flea bundle (SHA-256
+// 6030688a4dc97db8eee282af325343a8de1ae300f862a6f5c9d9175d40c8b765).
+// Store only inputs and output hashes, not a second copy of the renderer.
+// 33 inputs come from Flea's tests/fixtures/markdown-mermaid at 5da918109:
+// Flea/Pele/Mermaid MIT examples; see THIRD-PARTY-NOTICES.md.
+for (const entry of fixtures.cases) {
+  test(`Pele preserves legacy output: ${entry.name}`, () => {
+    for (const [index, theme] of fixtures.themes.entries()) {
+      const expected = entry.results[index];
+      if (expected.error) {
+        let error;
+        try {mermaidToSvg(entry.source, theme);} catch (e) {error = e.message;}
+        expect(error).toBe(expected.error);
+      } else {
+        const svg = mermaidToSvg(entry.source, theme);
+        expect(new Bun.CryptoHasher('sha256').update(svg).digest('hex')).toBe(expected.sha256);
+      }
+    }
+  });
+}
+test('Pele is the unmodified official 1.6.0 ESM distribution', async () => {
+  const bytes = await Bun.file(new URL('../src/vendor/pele.js', import.meta.url)).arrayBuffer();
+  expect(new Bun.CryptoHasher('sha256').update(bytes).digest('hex')).toBe('d1ebc1889f3069d7759fe5db34c4ad4b4823285edbee2b537d0ef3d505a76d8d');
+});

package/test/places.test.js

@@ -0,0 +1,134 @@
+import { test, expect, beforeEach, afterEach } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, posix, win32 } from "node:path";
+import { appPackage, places, probePlaces, rootNames, userDirs } from "../src/places.js";
+
+let root, home;
+// Nothing of the machine running the tests is read: every source is named here.
+const quiet = (extra = {}) => ({ home, env: {}, android: false, temps: [], roots: [], mounts: [], ...extra });
+const folder = (...parts) => {
+  const path = join(root, ...parts);
+  mkdirSync(path, { recursive: true });
+  return path;
+};
+const file = (...parts) => {
+  folder(...parts.slice(0, -1));
+  writeFileSync(join(root, ...parts), "x");
+};
+const labels = (rows) => rows.map((row) => row.label);
+
+beforeEach(() => {
+  root = mkdtempSync(join(tmpdir(), "flea-places-"));
+  home = folder("home");
+});
+afterEach(() => rmSync(root, { recursive: true, force: true }));
+
+test("user-dirs.dirs names a role's folder, the last valid line winning", () => {
+  const dirs = userDirs(
+    ['XDG_DOWNLOAD_DIR="$HOME/Old"', ' XDG_DOWNLOAD_DIR = "$HOME/下載" # inbox', 'XDG_MUSIC_DIR="/srv/music/"', 'XDG_PICTURES_DIR="relative"', 'XDG_VIDEOS_DIR="$HOME/a\\"b"', "XDG_DESKTOP_DIR=$HOME/Desktop"].join("\n"),
+    "/home/a",
+  );
+  expect(Object.fromEntries(dirs)).toEqual({ DOWNLOAD: "/home/a/下載", MUSIC: "/srv/music", VIDEOS: '/home/a/a"b' });
+});
+
+test("an Android app is read off the temporary directory inside its private folder", () => {
+  expect(appPackage("/data/data/com.termux/files/usr/tmp")).toEqual({ name: "com.termux", dir: "/data/data/com.termux" });
+  expect(appPackage("/data/user/0/org.example.app_2/cache")).toEqual({ name: "org.example.app_2", dir: "/data/user/0/org.example.app_2" });
+  expect(appPackage("/data/user/10/a.b")).toEqual({ name: "a.b", dir: "/data/user/10/a.b" });
+  for (const other of ["/tmp", "/data/local/tmp", "/data/data/nodots/tmp", "/data/user/x/com.a.b/tmp", "/data/data/com.1a/tmp", "/sdcard/data/data/com.a.b", "", undefined])
+    expect(appPackage(other)).toBeNull();
+});
+
+test("the roots are / where paths are POSIX and the drive letters where they are not", () => {
+  expect(rootNames(posix)).toEqual(["/"]);
+  const letters = rootNames(win32);
+  expect(letters).toContain("C:\\");
+  expect(letters.filter((name) => /^[A-Z]:\\$/.test(name)).length).toBe(26);
+  expect(letters).not.toContain("/");
+});
+
+test("a folder is a place only once it directly holds a regular file", async () => {
+  file("home", "Documents", "note.txt");
+  file("home", "Downloads", "setup.bin");
+  folder("home", "Music");
+  folder("home", "Pictures", "Album");
+  file("home", "Pictures", "Album", "deep.jpg");
+  folder("home", "Videos");
+  symlinkSync(join(home, "Documents", "note.txt"), join(home, "Videos", "link.txt"));
+  const found = await probePlaces(quiet());
+  expect(found.places).toEqual([
+    { path: join(home, "Downloads"), label: "Downloads", glyph: "download" },
+    { path: join(home, "Documents"), label: "Documents", glyph: "file-text" },
+  ]);
+  expect(found.volumes).toEqual([]);
+  // The first file to land makes the row, and the folder's own change is what is noticed.
+  writeFileSync(join(home, "Music", "song.ogg"), "x");
+  expect(labels((await probePlaces(quiet())).places)).toEqual(["Downloads", "Documents", "Music"]);
+});
+
+test("user-dirs.dirs is tried before the names, and one folder is one row", async () => {
+  file("home", "文件", "a.txt");
+  file("home", "Documents", "b.txt");
+  file("home", "Movies", "c.mkv");
+  file("home", "Shared", "d.txt");
+  symlinkSync(join(home, "Movies"), join(home, "Videos"));
+  folder("home", ".config");
+  writeFileSync(join(home, ".config", "user-dirs.dirs"), 'XDG_DOCUMENTS_DIR="$HOME/文件"\nXDG_PUBLICSHARE_DIR="$HOME/Shared"\nXDG_TEMPLATES_DIR="$HOME"\n');
+  const found = await probePlaces(quiet());
+  expect(found.places).toEqual([
+    { path: join(home, "文件"), label: "文件", glyph: "file-text" },
+    { path: join(home, "Videos"), label: "Videos", glyph: "film" },
+    { path: join(home, "Shared"), label: "Shared", glyph: "folder" },
+  ]);
+});
+
+test("temporary folders are probed and named once each", async () => {
+  const a = folder("tmp-a"),
+    b = folder("tmp-b");
+  symlinkSync(a, join(root, "tmp-link"));
+  const found = await probePlaces(quiet({ temps: [a, undefined, join(root, "tmp-link"), join(root, "missing"), "relative", b] }));
+  expect(found.places).toEqual([
+    { path: a, label: "Temp", glyph: "folder" },
+    { path: b, label: b, glyph: "folder" },
+  ]);
+});
+
+test("Android always has its shared storage and Download, and the app's own two folders", async () => {
+  const shared = join(root, "shared");
+  file("shared", "DCIM", "Camera", "IMG_1.jpg");
+  file("shared", "DCIM", "stray.jpg");
+  file("shared", "Pictures", "Screenshots", "s.png");
+  folder("shared", "Documents");
+  const app = folder("data", "data", "com.example.app");
+  const found = await probePlaces(quiet({ android: true, shared, temps: ["/data/user/0/com.example.app/cache"] }));
+  expect(found.places).toEqual([
+    { path: shared, label: "Internal storage", glyph: "smartphone" },
+    { path: join(shared, "Download"), label: "Download", glyph: "download" },
+    { path: join(shared, "DCIM", "Camera"), label: "Camera", glyph: "camera" },
+    { path: join(shared, "Pictures", "Screenshots"), label: "Screenshots", glyph: "image" },
+    { path: join(shared, "Android", "media", "com.example.app"), label: "App media", glyph: "folder" },
+  ]);
+  expect(existsSync(join(shared, "Android", "media", "com.example.app"))).toBe(true);
+  expect(existsSync(app)).toBe(true);
+  // Without a camera folder holding files, DCIM itself is the camera's row.
+  rmSync(join(shared, "DCIM", "Camera"), { recursive: true });
+  expect(labels((await probePlaces(quiet({ android: true, shared }))).places)).toEqual(["Internal storage", "Download", "DCIM", "Screenshots"]);
+});
+
+test("a root that can be listed is a volume with its size, and one that cannot is not", async () => {
+  const found = await probePlaces(quiet({ roots: [root, join(root, "gone"), root + "/"] }));
+  expect(found.volumes.length).toBe(1);
+  expect(found.volumes[0]).toMatchObject({ path: root, label: root, glyph: "drive" });
+  expect(found.volumes[0].size).toBeGreaterThan(0);
+});
+
+test("the places request answers when asked, and a watch is ended by its own word", async () => {
+  file("home", "Documents", "note.txt");
+  const lines = [];
+  await places({}, (line) => lines.push(line), quiet());
+  await places({ watch: true }, (line) => lines.push(line), quiet());
+  await places({ watch: false }, (line) => lines.push(line), quiet());
+  expect(lines.length).toBe(2);
+  expect(lines[0]).toEqual({ t: "places", places: [{ path: join(home, "Documents"), label: "Documents", glyph: "file-text" }], volumes: [] });
+});

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");
+});