flea-qml 0.0.0-stage → 0.1.0

package/test/dirsize.test.js

@@ -0,0 +1,138 @@
+import { test, expect, afterAll } from "bun:test";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, chmodSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { dirsize, dirsizeCancel, dirsizeInit, forgetSizes, keptSize } from "../src/dirsize.js";
+import { duCommand } from "../src/find.js";
+import { Listing } from "../src/listing.js";
+
+// Folder sizes only when asked (src/dirsize.js): du streams each folder's size, the answers are
+// kept by path and ride later rows as z, and a change forgets a folder and those above it only.
+const root = mkdtempSync(join(tmpdir(), "flea-dirsize-"));
+afterAll(() => { try { chmodSync(join(root, "w", "c", "locked"), 0o755); } catch {} rmSync(root, { recursive: true, force: true }); });
+const work = join(root, "w");
+mkdirSync(join(work, "a", "deep"), { recursive: true });
+mkdirSync(join(work, "b"));
+mkdirSync(join(work, "-dash"));
+mkdirSync(join(work, "c", "locked"), { recursive: true });
+writeFileSync(join(work, "a", "one"), Buffer.alloc(1000));
+writeFileSync(join(work, "a", "deep", "two"), Buffer.alloc(2500));
+writeFileSync(join(work, "b", "three"), Buffer.alloc(7));
+writeFileSync(join(work, "-dash", "x"), Buffer.alloc(11));
+writeFileSync(join(work, "c", "locked", "hid"), Buffer.alloc(5));
+writeFileSync(join(work, "file.txt"), "not a folder");
+
+let listing = Listing.scan(work, false);
+listing.sort({ by: "name", desc: false, foldersFirst: true, groupByKind: false, hiddenLast: false });
+const messages = [];
+dirsizeInit((m) => messages.push(m), () => listing);
+const until = async (done) => {
+  for (let i = 0; i < 400 && !done(); i++) await Bun.sleep(10);
+  if (!done()) throw Error("timed out: " + JSON.stringify(messages));
+};
+const rowOf = (name) => listing.indexOfName(name);
+const sizes = () => Object.fromEntries(messages.filter((m) => m.t === "dirsized").map((m) => [listing.rows[m.row].name, [m.bytes, m.partial]]));
+
+test("du is looked for in Find's order: bunmsh first", () => {
+  expect(duCommand().slice(-2)).toEqual(["builtin", "du"]);
+});
+
+test("nothing is measured until asked; one row asks for that folder alone", async () => {
+  expect(listing.window(0, 10).rows.some((row) => row.z !== undefined)).toBe(false);
+  dirsize({ rows: [rowOf("a"), rowOf("file.txt")] });
+  await until(() => messages.some((m) => m.t === "dirsizedone"));
+  expect(sizes()).toEqual({ a: [3500, false] });
+  expect(keptSize(join(work, "a"))).toEqual({ bytes: 3500, partial: false });
+});
+
+test("all measures every folder, a name with a leading dash included, and an unreadable one is a floor", async () => {
+  if (process.getuid?.() !== 0 && process.platform !== "win32") chmodSync(join(work, "c", "locked"), 0);
+  messages.length = 0;
+  dirsize({ all: true });
+  await until(() => messages.some((m) => m.t === "dirsizedone"));
+  const got = sizes();
+  expect(got.a).toEqual([3500, false]);
+  expect(got.b).toEqual([7, false]);
+  expect(got["-dash"]).toEqual([11, false]);
+  if (process.getuid?.() !== 0 && process.platform !== "win32") expect(got.c[1]).toBe(true);
+  expect(got["file.txt"]).toBeUndefined();
+  chmodSync(join(work, "c", "locked"), 0o755);
+});
+
+test("kept sizes ride later rows, follow a sort, and a change forgets only its own line upward", () => {
+  listing = Listing.scan(work, false);
+  listing.sort({ by: "name", desc: true, foldersFirst: true, groupByKind: false, hiddenLast: false });
+  const rows = Object.fromEntries(listing.window(0, 10).rows.map((row) => [row.n, row]));
+  expect(rows.a.z).toBe(3500);
+  expect(rows.b.z).toBe(7);
+  expect(rows["file.txt"].z).toBeUndefined();
+  // A write inside a/deep: a (and everything above) is no longer known, b still is.
+  forgetSizes(join(work, "a", "deep"));
+  expect(keptSize(join(work, "a"))).toBeUndefined();
+  expect(keptSize(join(work, "b"))).toEqual({ bytes: 7, partial: false });
+  forgetSizes(join(work, "b", "three-sibling-dir-does-not-exist"));
+  expect(keptSize(join(work, "b"))).toBeUndefined();
+  expect(keptSize(join(work, "-dash"))).toEqual({ bytes: 11, partial: false });
+});
+
+test("a cancel stops the run and says so", async () => {
+  messages.length = 0;
+  dirsize({ all: true });
+  dirsizeCancel();
+  await until(() => messages.some((m) => m.t === "dirsizedone"));
+  expect(messages.find((m) => m.t === "dirsizedone").cancelled).toBe(true);
+});
+
+// The cell side (ui/js/DirSizes.js): ⚖️ until measured, … while a walk is out, then the size.
+async function loadJs(name, names, deps = {}) {
+  const s = (await Bun.file(new URL("../ui/js/" + name + ".js", import.meta.url)).text()).replace(/^\.(?:pragma|import).*$/gm, "");
+  return new Function(...Object.keys(deps), s + ";return {" + names + "};")(...Object.values(deps));
+}
+const Format = { size: (n) => `${n} B` };
+const D = await loadJs("DirSizes", "empty,cellFor,known,folderText,asking,askingAll,remember,settled,UNMEASURED,MEASURING", { Format });
+
+test("a folder's Size cell reads ⚖️, then … while asked, then its size; a row's z stands in after a sort", () => {
+  let state = D.empty();
+  const row = { d: true };
+  expect(D.folderText(D.cellFor(state, 4), row)).toBe("⚖️");
+  state = D.asking(state, [4]);
+  expect(D.folderText(D.cellFor(state, 4), row)).toBe("…");
+  expect(D.folderText(D.cellFor(state, 5), row)).toBe("⚖️");
+  state = D.remember(state, 4, 2048, false, 100);
+  expect(D.folderText(D.cellFor(state, 4), row)).toBe("\u2696\ufe0f 2048 B");
+  expect(D.folderText(D.cellFor(D.empty(), 4), { d: true, z: 9, zp: true })).toBe("\u2696\ufe0f >9 B");
+});
+
+test("the header's ⚖️ makes every folder wait until its answer or the run's end", () => {
+  let state = D.askingAll(D.empty());
+  expect(D.cellFor(state, 900)).toEqual({ waiting: true });
+  state = D.remember(state, 3, 10, false, 100);
+  expect(D.cellFor(state, 3)).toEqual({ bytes: 10, partial: false });
+  expect(D.cellFor(state, 7)).toEqual({ waiting: true });
+  state = D.settled(state);
+  expect(D.cellFor(state, 7)).toBe(null);
+  expect(D.cellFor(state, 3)).toEqual({ bytes: 10, partial: false });
+});
+
+test("a size order uses measured folders' sizes and puts unmeasured folders after them, measuring nothing", () => {
+  // a and b were forgotten above; -dash (11) and c (a floor) are still measured.
+  const fresh = Listing.scan(work, false);
+  fresh.sort({ by: "name", desc: false, foldersFirst: true, groupByKind: false, hiddenLast: false });
+  fresh.sort({ by: "size", desc: true, foldersFirst: true, groupByKind: false, hiddenLast: false });
+  expect(fresh.rows.filter((r) => r.dir).map((r) => r.name)).toEqual(["-dash", "c", "a", "b"]);
+  expect(messages.filter((m) => m.t === "dirsized").length).toBe(0);
+});
+
+test("= measures the selection or the cursor's folder, Alt+= every folder", async () => {
+  // Every Qt.Key_* the table names gets a distinct number; the modifiers are Qt's own.
+  let next = 1000;
+  const named = { AltModifier: 0x08000000, ControlModifier: 0x04000000, ShiftModifier: 0x02000000, MetaModifier: 0x10000000, Key_Equal: 0x3d };
+  const Qt = new Proxy(named, { get: (t, k) => (k in t ? t[k] : (t[k] = next++)) });
+  const Keymap = await loadJs("Keymap", "lookup", { Qt });
+  expect(Keymap.lookup(0x3d, "=", 0)).toBe("measureDirs");
+  expect(Keymap.lookup(0x3d, "=", named.AltModifier)).toBe("measureAllDirs");
+  // Ctrl+= stays the text size.
+  expect(Keymap.lookup(0x3d, "=", named.ControlModifier)).toBe("textSizeUp");
+  const focus = await Bun.file(new URL("../ui/js/Focus.js", import.meta.url)).text();
+  expect(focus).toContain('case "measureDirs": root.measureDirs(root.selectionCount() > 0 ? root.selectedIndices() : [root.cursorIndex])');
+});

package/test/file-ops.test.js

@@ -0,0 +1,241 @@
+import { test, expect, afterAll } from 'bun:test';
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync, readdirSync, lstatSync, readlinkSync, symlinkSync, statSync, chmodSync, existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { mkdir, newfile, duplicate } from '../src/create.js';
+import { bulkrename } from '../src/bulkrename.js';
+import { permissions, permissionsBatch, parseMode } from '../src/permissions.js';
+import { archive, archiveCancel, formats, freeName } from '../src/archiveops.js';
+import { listArchive } from '../src/archive.js';
+import { openSync, closeSync } from 'node:fs';
+
+const root = mkdtempSync(join(tmpdir(), 'flea-ops-'));
+afterAll(() => rmSync(root, { recursive: true, force: true }));
+let n = 0;
+const fresh = () => { const dir = join(root, `case-${++n}`); mkdirSync(dir); return dir; };
+// PRoot resolves links itself, so an exclusive create there follows a dangling link; the kernel never does.
+const exclusiveRefusesLinks = (() => {
+  const dir = mkdtempSync(join(tmpdir(), 'flea-excl-'));
+  try {
+    symlinkSync(join(dir, 'absent'), join(dir, 'link'));
+    try { closeSync(openSync(join(dir, 'link'), 'wx')); return false; } catch { return true; }
+  } finally { rmSync(dir, { recursive: true, force: true }); }
+})();
+const umask = process.umask();
+const collector = () => { const lines = []; const send = (line) => lines.push(line); return { lines, send }; };
+// Resolves with the first line `pick` accepts, waiting for the asynchronous operations.
+async function until(lines, pick, ms = 10000) {
+  const end = Date.now() + ms;
+  for (;;) {
+    const found = lines.find(pick);
+    if (found) return found;
+    if (Date.now() > end) throw Error(`no line arrived: ${JSON.stringify(lines)}`);
+    await Bun.sleep(10);
+  }
+}
+
+test('mkdir takes the first free New Folder and refuses a typed name already taken', () => {
+  const dir = fresh(), { lines, send } = collector();
+  mkdir({ path: dir }, send);
+  mkdir({ path: dir }, send);
+  expect(lines.filter((l) => l.t === 'made').map((l) => l.path)).toEqual([join(dir, 'New Folder'), join(dir, 'New Folder 2')]);
+  writeFileSync(join(dir, '報告'), '');
+  mkdir({ path: dir, name: '報告' }, send);
+  expect(lines.at(-1)).toMatchObject({ t: 'error', where: 'mkdir', msg: 'a folder or file with that name already exists' });
+  mkdir({ path: dir, name: '../x' }, send);
+  expect(lines.at(-1)).toMatchObject({ t: 'error', where: 'mkdir' });
+  mkdir({ path: 'relative' }, send);
+  expect(lines.at(-1).t).toBe('error');
+});
+
+test('mkdir with a request id adds the creation receipt', () => {
+  const dir = fresh(), { lines, send } = collector();
+  mkdir({ path: dir, name: 'a', request: 4 }, send);
+  expect(lines[0]).toMatchObject({ t: 'made', ok: true, request: 4 });
+  expect(lines[1]).toEqual({ t: 'menuaction', op: 'creation', id: 4, kind: 'made', ok: true, path: join(dir, 'a') });
+});
+
+test('newfile creates an empty file exclusively and never follows a dangling link', () => {
+  const dir = fresh(), { lines, send } = collector();
+  newfile({ id: 3, path: dir, name: 'New File 🙂' }, send);
+  expect(lines[0]).toEqual({ t: 'menuaction', id: 3, op: 'newFile', ok: true, path: join(dir, 'New File 🙂') });
+  expect(statSync(join(dir, 'New File 🙂')).size).toBe(0);
+  newfile({ id: 3, path: dir, name: 'New File 🙂' }, send);
+  expect(lines.at(-1)).toMatchObject({ op: 'newFile', ok: false });
+  if (exclusiveRefusesLinks) {
+    symlinkSync(join(dir, 'absent'), join(dir, 'link'));
+    newfile({ id: 3, path: dir, name: 'link' }, send);
+    expect(lines.at(-1).ok).toBe(false);
+    expect(existsSync(join(dir, 'absent'))).toBe(false);
+  }
+  newfile({ id: 3, path: dir, name: 'a/b' }, send);
+  expect(lines.at(-1).ok).toBe(false);
+});
+
+test('duplicate copies a file and a tree to free copy names', async () => {
+  const dir = fresh(), { lines, send } = collector();
+  writeFileSync(join(dir, 'backup.tar.zst'), 'x');
+  mkdirSync(join(dir, 'tree/inner'), { recursive: true });
+  writeFileSync(join(dir, 'tree/inner/f'), 'deep');
+  duplicate({ path: join(dir, 'backup.tar.zst') }, send);
+  duplicate({ path: join(dir, 'backup.tar.zst') }, send);
+  duplicate({ path: join(dir, 'tree') }, send);
+  await until(lines, (l) => l.t === 'duplicated' && l.path.endsWith('tree copy'));
+  expect(lines.filter((l) => l.t === 'duplicated').map((l) => l.path)).toEqual(
+    [join(dir, 'backup.tar copy.zst'), join(dir, 'backup.tar copy 2.zst'), join(dir, 'tree copy')]);
+  expect(readFileSync(join(dir, 'tree copy/inner/f'), 'utf8')).toBe('deep');
+});
+
+test('bulkrename swaps names through temporary names and refuses a bad batch whole', () => {
+  const dir = fresh(), { lines, send } = collector();
+  writeFileSync(join(dir, 'a'), 'A');
+  writeFileSync(join(dir, 'b'), 'B');
+  writeFileSync(join(dir, 'c'), 'C');
+  bulkrename({ paths: [join(dir, 'a'), join(dir, 'b'), join(dir, 'c')], names: ['b', 'a', 'c'] }, send);
+  expect(lines[0]).toEqual({ t: 'bulkrenamed', ok: 2, unchanged: 1 });
+  expect(readFileSync(join(dir, 'a'), 'utf8')).toBe('B');
+  expect(readFileSync(join(dir, 'b'), 'utf8')).toBe('A');
+  for (const names of [['x', 'x', 'y'], ['c', 'q'], ['ok', 'a/b', 'z'], ['', 'm', 'n']]) {
+    bulkrename({ paths: [join(dir, 'a'), join(dir, 'b'), join(dir, 'c')].slice(0, names.length), names }, send);
+    expect(lines.at(-1)).toMatchObject({ t: 'error', where: 'bulkrename' });
+  }
+  expect(readdirSync(dir).sort()).toEqual(['a', 'b', 'c']);
+});
+
+test('permissions inspects, applies and refuses a replaced item', () => {
+  if (process.platform === 'win32') return;
+  const dir = fresh(), path = join(dir, 'f'), { lines, send } = collector();
+  writeFileSync(path, '');
+  chmodSync(path, 0o644);
+  permissions({ op: 'inspect', id: 1, path }, send);
+  expect(lines[0]).toMatchObject({ t: 'permissions', id: 1, op: 'inspect', ok: true, mode: '0644', directory: false, reason: '' });
+  permissions({ op: 'apply', id: 1, mode: '600' }, send);
+  expect(lines.at(-1)).toEqual({ t: 'permissions', id: 1, op: 'apply', ok: true, mode: '0600' });
+  expect(statSync(path).mode & 0o777).toBe(0o600);
+  permissions({ op: 'apply', id: 1, mode: '9' }, send);
+  expect(lines.at(-1).error).toMatch(/octal/);
+  rmSync(path);
+  writeFileSync(path, '');
+  permissions({ op: 'apply', id: 1, mode: '644' }, send);
+  expect(lines.at(-1)).toMatchObject({ ok: false, error: 'Selected item changed; reopen Permissions.' });
+  expect(() => parseMode('1644')).toThrow();
+  expect(parseMode('0755')).toBe(0o755);
+});
+
+test('permissionsBatch changes every item or none, and u+x adds the owner execute bit', () => {
+  if (process.platform === 'win32') return;
+  const dir = fresh(), a = join(dir, 'a'), b = join(dir, 'b'), { lines, send } = collector();
+  writeFileSync(a, '');
+  writeFileSync(b, '');
+  chmodSync(a, 0o644);
+  chmodSync(b, 0o640);
+  permissionsBatch({ id: 7, paths: [a, b], modes: ['u+x', 'u+x'] }, send);
+  expect(lines.at(-1)).toMatchObject({ op: 'applyMany', ok: true });
+  expect([statSync(a).mode & 0o777, statSync(b).mode & 0o777]).toEqual([0o744, 0o740]);
+  permissionsBatch({ id: 8, paths: [a, join(dir, 'gone')], modes: ['600', '600'] }, send);
+  expect(lines.at(-1)).toMatchObject({ op: 'applyMany', ok: false });
+  expect(statSync(a).mode & 0o777).toBe(0o744);
+});
+
+test('formats names what this port writes and reads, and no password', () => {
+  const { lines, send } = collector();
+  formats({ id: 2 }, send);
+  expect(lines[0]).toMatchObject({ t: 'formats', archive: ['zip', 'tar', 'tar.gz', 'tar.zst'], convert: false,
+    extract: { archive: true, sevenZip: false, zip: true } });
+});
+
+test('free archive names keep the format tail', () => {
+  expect(freeName('/a/pack.tar.gz', 'tar.gz', 1)).toBe('/a/pack copy.tar.gz');
+  expect(freeName('/a/pack.tar.gz', 'tar.gz', 2)).toBe('/a/pack copy 2.tar.gz');
+  expect(freeName('/a/folder', null, 1)).toBe('/a/folder copy');
+});
+
+// A tree with Chinese and emoji names, a long path, a symlink, an empty folder and a non-default mode.
+function sampleTree(dir) {
+  const top = join(dir, '專案 📦');
+  const long = join(top, 'd'.repeat(60), 'e'.repeat(60));
+  mkdirSync(long, { recursive: true });
+  mkdirSync(join(top, 'empty'));
+  writeFileSync(join(top, '說明.txt'), '你好 👋\n');
+  writeFileSync(join(long, 'f'.repeat(90) + '.bin'), Buffer.alloc(300000, 7));
+  writeFileSync(join(top, 'run.sh'), '#!/bin/sh\n');
+  chmodSync(join(top, 'run.sh'), 0o755);
+  symlinkSync('說明.txt', join(top, 'readme'));
+  return top;
+}
+// Extracted modes pass through the umask, as bsdtar's do for anyone but root.
+function expectSameTree(a, b) {
+  const walk = (base, rel = '', mask = 0) => readdirSync(join(base, rel)).sort().flatMap((name) => {
+    const path = join(base, rel, name), st = lstatSync(path), key = join(rel, name);
+    if (st.isSymbolicLink()) return [[key, 'link', readlinkSync(path)]];
+    if (st.isDirectory()) return [[key, 'dir'], ...walk(base, key, mask)];
+    return [[key, (st.mode & 0o777 & ~mask).toString(8), readFileSync(path).toString('base64')]];
+  });
+  expect(walk(b)).toEqual(walk(a, '', umask));
+}
+
+for (const format of ['zip', 'tar', 'tar.gz', 'tar.zst']) {
+  test(`compress to .${format} and extract it back to the same tree`, async () => {
+    const dir = fresh(), top = sampleTree(dir), { lines, send } = collector();
+    archive({ op: 'compress', paths: [top], dest: join(dir, `專案 📦.${format}`), format }, send);
+    const done = await until(lines, (l) => l.t === 'archivedone');
+    expect(done).toMatchObject({ ok: true, err: '', path: join(dir, `專案 📦.${format}`) });
+    // The preview's own reader lists what was written.
+    const names = [];
+    await listArchive(done.path, done.path, (entry) => names.push(entry.name));
+    expect(names).toContain('專案 📦/說明.txt');
+    expect(names.some((name) => name.endsWith('f'.repeat(90) + '.bin'))).toBe(true);
+    const out = join(dir, 'out');
+    archive({ op: 'extract', path: done.path, dest: out }, send);
+    const extracted = await until(lines, (l) => l.t === 'archivedone' && l.dest);
+    expect(extracted).toMatchObject({ ok: true, dest: out });
+    expect(lines.some((l) => l.t === 'extractstarted')).toBe(true);
+    expectSameTree(top, join(out, '專案 📦'));
+    // A second compress of the same name lands under its copy name.
+    archive({ op: 'compress', paths: [top], dest: join(dir, `專案 📦.${format}`), format }, send);
+    const again = await until(lines, (l) => l.t === 'archivedone' && l.path?.includes('copy'));
+    expect(again.path).toBe(join(dir, `專案 📦 copy.${format}`));
+    expect(readdirSync(dir).filter((name) => name.startsWith('.flea-work'))).toEqual([]);
+  });
+}
+
+test('an archive that names a path outside its folder extracts nothing', async () => {
+  const dir = fresh(), { lines, send } = collector();
+  // A tar whose only member is ../escape.
+  const header = Buffer.alloc(512);
+  header.write('../escape', 0);
+  header.write('0000644\0', 100); header.write('0000000\0', 108); header.write('0000000\0', 116);
+  header.write('00000000003\0', 124); header.write('00000000000\0', 136);
+  header.fill(0x20, 148, 156); header[156] = 0x30; header.write('ustar\0', 257); header.write('00', 263);
+  let sum = 0; for (const byte of header) sum += byte;
+  header.write(sum.toString(8).padStart(6, '0') + '\0 ', 148);
+  const data = Buffer.alloc(512); data.write('bad');
+  writeFileSync(join(dir, 'evil.tar'), Buffer.concat([header, data, Buffer.alloc(1024)]));
+  archive({ op: 'extract', path: join(dir, 'evil.tar'), dest: join(dir, 'evil') }, send);
+  const done = await until(lines, (l) => l.t === 'archivedone');
+  expect(done.ok).toBe(false);
+  expect(done.err).toMatch(/outside its folder/);
+  expect(readdirSync(dir).sort()).toEqual(['evil.tar']);
+  expect(existsSync(join(root, 'escape'))).toBe(false);
+});
+
+test('a password, a format it cannot read and a disk image are refused without starting', () => {
+  const { lines, send } = collector();
+  archive({ op: 'extract', path: '/x/a.zip', dest: '/x/a', password: 'p' }, send);
+  archive({ op: 'extract', path: '/x/a.7z', dest: '/x/a' }, send);
+  archive({ op: 'extract', path: '/x/a.iso', dest: '/x/a' }, send);
+  expect(lines.every((l) => l.t === 'archivedone' && l.ok === false)).toBe(true);
+  expect(lines.length).toBe(3);
+});
+
+test('cancelling a compress removes its staging file', async () => {
+  const dir = fresh(), { lines, send } = collector();
+  mkdirSync(join(dir, 'big'));
+  for (let i = 0; i < 20; i++) writeFileSync(join(dir, 'big', `f${i}`), Buffer.alloc(2 << 20, i));
+  archive({ op: 'compress', paths: [join(dir, 'big')], dest: join(dir, 'big.zip'), format: 'zip' }, send);
+  const started = await until(lines, (l) => l.t === 'archivestarted');
+  expect(archiveCancel(started.id)).toBe(true);
+  const done = await until(lines, (l) => l.t === 'archivedone');
+  expect(done).toMatchObject({ ok: false, err: 'cancelled' });
+  expect(readdirSync(dir)).toEqual(['big']);
+});

package/test/find-contents.test.js

@@ -0,0 +1,161 @@
+import { test, expect, afterAll } from "bun:test";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { grepCommand } from "../src/find.js";
+import { matchOf, MATCH_TEXT_LIMIT } from "../src/backend.js";
+import { Listing } from "../src/listing.js";
+
+// Ctrl+G's content search: ui/js/Find.js builds grep's arguments and reads its lines, ui/js/Search.js
+// opens and turns the mode, and the backend carries each row's matched line as `g`.
+async function load(name, names, deps = {}) {
+  const s = (await Bun.file(new URL("../ui/js/" + name + ".js", import.meta.url)).text()).replace(/^\.(?:pragma|import).*$/gm, "");
+  return new Function(...Object.keys(deps), s + ";return {" + names + "};")(...Object.values(deps));
+}
+const Find = await load("Find", "grepArguments,grepLine,snippet,CONTEXT,SNIPPET_LIMIT");
+const Qt = { Key_Return: 16777220, Key_Enter: 16777221, Key_Escape: 16777216, Key_Backspace: 16777219,
+  Key_Tab: 16777217, Key_Backtab: 16777218, Key_G: 71, ControlModifier: 0x04000000, AltModifier: 0x08000000, MetaModifier: 0x10000000 };
+const Search = await load("Search", "start,contents,commit,rescope,abort,typeKey,placeholder,sendQuery,TYPING,RESULTS",
+  { Qt, Input: { isPasteKey: () => false }, Format: {} });
+
+const root = mkdtempSync(join(tmpdir(), "flea-grep-"));
+afterAll(() => rmSync(root, { recursive: true, force: true }));
+
+test("grep runs over the scope with the query as literal text, hidden names skipped unless shown", () => {
+  const off = Find.grepArguments("a.b*(c)", false);
+  expect(off).toEqual(["-r", "-n", "-o", "-a", "-i", "-m", "1", "-Z", "--line-buffered", "-E",
+    "--exclude=.*", "--exclude-dir=.*", "-e", ".{0,80}a\\.b\\*\\(c\\).{0,80}"]);
+  // No path operand: grep walks "." and the bare "." is never excluded.
+  expect(off.some((arg) => arg === "." || arg === "./")).toBe(false);
+  expect(Find.grepArguments("x", true)).not.toContain("--exclude=.*");
+});
+
+test("a grep line parses into its file, line number and a clean bounded snippet", () => {
+  expect(Find.grepLine("dir/a: b.txt\u000012:  let x\t= 1")).toEqual({ path: "dir/a: b.txt", line: 12, text: "let x = 1" });
+  // A binary's control bytes become dots; the text is cut at SNIPPET_LIMIT.
+  expect(Find.grepLine("bin.dat\u00003:ab\u0000\u0001cd").text).toBe("ab··cd");
+  expect(Find.grepLine("long\u00001:" + "y".repeat(5000)).text.length).toBe(Find.SNIPPET_LIMIT);
+  for (const junk of ["", "no separator", "\u00001:starts with nul", "a\u0000not a number"]) expect(Find.grepLine(junk)).toBe(null);
+});
+
+for (const [label, argv] of [["bunmsh's grep", grepCommand()], ["the system grep", Bun.which("grep") ? [Bun.which("grep")] : null]]) {
+  test(`${label} answers the arguments: binary files match, hidden ones follow the setting, long lines stay short`, async () => {
+    if (!argv) return;
+    const scope = mkdtempSync(join(root, "scope-"));
+    mkdirSync(join(scope, "sub"));
+    mkdirSync(join(scope, ".hid"));
+    writeFileSync(join(scope, "sub", "notes:1.txt"), "first\nSecond Needle here\nneedle again\n");
+    writeFileSync(join(scope, "image.bin"), Buffer.from([0, 1, 2, ...Buffer.from("xxNEEDLExx"), 0, 255]));
+    writeFileSync(join(scope, "min.js"), "a".repeat(200000) + "needle" + "b".repeat(200000));
+    writeFileSync(join(scope, ".hidden.txt"), "needle\n");
+    writeFileSync(join(scope, ".hid", "in.txt"), "needle\n");
+    writeFileSync(join(scope, "none.txt"), "nothing\n");
+    const run = async (hidden) => {
+      const child = Bun.spawn([...argv, ...Find.grepArguments("needle", hidden)], { cwd: scope, stdout: "pipe", stderr: "pipe" });
+      const out = await new Response(child.stdout).text();
+      await child.exited;
+      const rows = new Map();
+      for (const line of out.split("\n")) {
+        if (line.length > 2 * Find.CONTEXT + "needle".length + 400) throw new Error(`an output line of ${line.length} characters`);
+        const hit = Find.grepLine(line);
+        if (hit && !rows.has(hit.path)) rows.set(hit.path, hit);
+      }
+      return rows;
+    };
+    const shown = await run(false);
+    expect([...shown.keys()].sort()).toEqual(["image.bin", "min.js", "sub/notes:1.txt"]);
+    expect(shown.get("sub/notes:1.txt")).toMatchObject({ line: 2, text: "Second Needle here" });
+    expect(shown.get("image.bin").text).toContain("NEEDLE");
+    expect(shown.get("min.js").text).toBe("a".repeat(Find.CONTEXT) + "needle" + "b".repeat(Find.CONTEXT));
+    expect([...(await run(true)).keys()].sort()).toEqual([".hid/in.txt", ".hidden.txt", "image.bin", "min.js", "sub/notes:1.txt"]);
+  }, 30000);
+}
+
+test("the backend keeps a checked, bounded match and hands it out as the row's g", () => {
+  expect(matchOf({ l: 4, t: "x" })).toEqual({ l: 4, t: "x" });
+  expect(matchOf({ l: 2, t: "z".repeat(MATCH_TEXT_LIMIT + 50) }).t.length).toBe(MATCH_TEXT_LIMIT);
+  for (const bad of [null, "x", { l: 0, t: "x" }, { l: 1.5, t: "x" }, { l: 3 }]) expect(matchOf(bad)).toBe(null);
+  const dir = mkdtempSync(join(root, "rows-"));
+  writeFileSync(join(dir, "a.txt"), "x");
+  writeFileSync(join(dir, "b.txt"), "x");
+  const listing = new Listing(dir, [{ name: "a.txt", dir: false, link: false, match: { l: 3, t: "hit" } }, { name: "b.txt", dir: false, link: false }]);
+  const { rows } = listing.window(0, 2);
+  expect(rows[0].g).toEqual({ l: 3, t: "hit" });
+  expect(rows[1].g).toBeUndefined();
+});
+
+// A pane as Search.js reads it, recording what it asks the backend.
+function pane(extra = {}) {
+  const calls = [];
+  const root = {
+    calls, recentMode: "", searchMode: "", searchQuery: "", searchSent: "", searchGen: 0, searchStep: 0,
+    path: "/work", home: "/home/u", showHidden: false, windowSize: 40, sizeWish: false, cursorIndex: 0,
+    rowFor: () => null, join: (a, b) => a + "/" + b,
+    backend: {
+      searchOpen: (scope, folder, hidden) => calls.push(["open", scope]),
+      searchQuery: (query, gen, count, sizes, contents) => calls.push(["query", query, contents]),
+      searchCancel: () => calls.push(["cancel"]), searchClose: () => calls.push(["close"]),
+    },
+    openWithoutHistory: (path) => calls.push(["relist", path]),
+    ...extra,
+  };
+  return root;
+}
+const key = (code, modifiers = 0) => ({ key: code, modifiers, text: "" });
+
+test("Ctrl+G opens a content search that waits for Enter, as f opens a name search", () => {
+  const root = pane();
+  Search.contents(root);
+  expect(root.searchMode).toBe(Search.TYPING);
+  expect(root.searchContents).toBe(true);
+  expect(root.calls).toEqual([["open", "/work"]]);
+  expect(Search.placeholder(root.path, root.home, root.searchStep, true)).toBe("grep -ri ");
+  root.searchQuery = "needle";
+  Search.typeKey(key(Qt.Key_Return), root);
+  expect(root.calls.at(-1)).toEqual(["query", "needle", true]);
+  expect(root.searchMode).toBe(Search.RESULTS);
+  // f starts a name search afresh.
+  const named = pane();
+  Search.start(named);
+  expect(named.searchContents).toBe(false);
+  expect(Search.placeholder(named.path, named.home, 0, false)).toBe("find . -iname ");
+});
+
+test("Ctrl+G inside Find only turns the mode; the query runs at the next Enter", () => {
+  const root = pane();
+  Search.start(root);
+  root.searchQuery = "draft";
+  Search.typeKey(key(Qt.Key_G, Qt.ControlModifier), root);
+  expect(root.searchContents).toBe(true);
+  expect(root.calls.filter((c) => c[0] === "query")).toEqual([]);
+  Search.typeKey(key(Qt.Key_Return), root);
+  expect(root.calls.at(-1)).toEqual(["query", "draft", true]);
+  expect(root.searchMode).toBe(Search.RESULTS);
+  // From the results (a query already run) it still waits, back on the query line.
+  const sent = root.calls.length;
+  Search.contents(root);
+  expect(root.searchContents).toBe(false);
+  expect(root.searchMode).toBe(Search.TYPING);
+  expect(root.calls.length).toBe(sent);
+  root.searchEnterAt = 0;
+  Search.typeKey(key(Qt.Key_Return), root);
+  expect(root.calls.at(-1)).toEqual(["query", "draft", false]);
+});
+
+test("Tab, Enter and Esc keep their meanings in a content search", () => {
+  const root = pane();
+  Search.contents(root);
+  root.searchQuery = "needle";
+  Search.typeKey(key(Qt.Key_Return), root);
+  // Tab turns the scope and reruns, still over contents.
+  Search.typeKey(key(Qt.Key_Tab), root);
+  expect(root.calls.slice(-2)).toEqual([["open", "/home/u"], ["query", "needle", true]]);
+  // Esc while the walk runs stops it and keeps the results; the next Esc leaves.
+  root.searchRunning = true;
+  Search.typeKey(key(Qt.Key_Escape), root);
+  expect(root.calls.at(-1)).toEqual(["cancel"]);
+  expect(root.searchMode).not.toBe("");
+  root.searchRunning = false;
+  Search.typeKey(key(Qt.Key_Escape), root);
+  expect(root.calls.slice(-2)).toEqual([["close"], ["relist", "/work"]]);
+});

package/test/find-input.test.js

@@ -0,0 +1,66 @@
+import {test,expect} from 'bun:test';
+async function load(name,names,deps={}) {
+ const s=(await Bun.file(new URL('../ui/js/'+name+'.js',import.meta.url)).text()).replace(/^\.(?:pragma|import).*$/gm,'');
+ return new Function(...Object.keys(deps),s+';return {'+names+'};')(...Object.values(deps));
+}
+const Find=await load('Find','expression');
+test('Find uses path matching for forward slashes, without rewriting Windows queries',()=>{
+ expect(Find.expression('ReadMe',true)).toEqual(['-iname','*ReadMe*']);
+ expect(Find.expression('src/ReadMe',true)).toEqual(['-ipath','*src/ReadMe*']);
+ expect(Find.expression('*/src/*.js',true)).toEqual(['-ipath','*/src/*.js']);
+ expect(Find.expression('src/File',false)).toEqual(['-mindepth','1','-name','.*','-prune','-o','-ipath','*src/File*','-print']);
+});
+test('focused Find owns Escape; focused Filter and listing close Filter first',async()=>{
+ const calls=[];
+ const Focus=await load('Focus','handleKey',{
+  Qt:{Key_Escape:27},Status:{NO_TRASH:''},
+  Filter:{close:r=>{calls.push('filter');r.filterTyping=false;r.filterQuery='';}},
+  Search:{abort:r=>{calls.push('find');r.searchMode='';},TYPING:'typing'},
+  shareBrowserHere:()=>false
+ });
+ const root={selectionBand:null,renameEditor:()=>null,filterTyping:true,filterQuery:'test',searchMode:'typing'};
+ Focus.handleKey({key:27},root,null,'find');
+ expect(calls).toEqual(['find']);expect(root.filterQuery).toBe('test');
+ root.searchMode='typing';
+ Focus.handleKey({key:27},root,null,'filter');
+ expect(calls).toEqual(['find','filter']);expect(root.searchMode).toBe('typing');
+ root.filterQuery='again';
+ Focus.handleKey({key:27},root,null);
+ expect(calls).toEqual(['find','filter','filter']);expect(root.searchMode).toBe('typing');
+});
+
+test('leaving Find preserves Filter through the directory relist',async()=>{
+ const Search=await load('Search','abort');
+ let options;
+ const root={searchMode:'results',searchQuery:'item',searchGen:2,searchOpenedGen:1,
+  searchFrom:'/tmp/files',path:'/tmp/files',filterQuery:'00',backend:{searchClose(){}},
+  openWithoutHistory:(path,ask)=>{expect(path).toBe('/tmp/files');options=ask;}};
+ Search.abort(root);
+ expect(options).toEqual({holdWalk:true,relist:true,keptQuery:'00'});
+});
+
+test('focused Find Escape stops a running search, then closes only Find',async()=>{
+ const Search=await load('Search','abort');
+ const calls=[];
+ const Focus=await load('Focus','handleKey',{
+  Qt:{Key_Escape:27},Status:{NO_TRASH:''},Search,
+  Filter:{close:()=>{throw Error('Find Escape must not close Filter')}},
+  shareBrowserHere:()=>false
+ });
+ const root={selectionBand:null,renameEditor:()=>null,
+  searchMode:'typing',searchQuery:'x',searchRunning:true,searchGen:1,searchOpenedGen:0,
+  path:'/tmp',filterQuery:'keep',backend:{searchCancel:()=>calls.push('cancel'),searchClose:()=>calls.push('close')},
+  openWithoutHistory:(path,ask)=>calls.push(ask.keptQuery)};
+ Focus.handleKey({key:27},root,null,'find');
+ expect(calls).toEqual(['cancel']);
+ expect(root.searchMode).toBe('typing');
+ expect(root.searchQuery).toBe('x');
+ expect(root.searchLeaving).not.toBe(true);
+ expect(root.filterQuery).toBe('keep');
+ // The backend's cancellation reply marks the search stopped.
+ root.searchRunning=false;
+ Focus.handleKey({key:27},root,null,'find');
+ expect(root.searchLeaving).toBe(true);
+ expect(root.filterQuery).toBe('keep');
+ expect(calls).toEqual(['cancel','close','keep']);
+});