flea-qml 0.0.0-stage → 0.2.0

package/src/trash-record.js

@@ -0,0 +1,41 @@
+// Metadata follows real file operations, never the original (restoration) path.
+import {lstatSync,readFileSync,unlinkSync,writeFileSync,renameSync} from 'node:fs';
+import {basename,dirname,join,resolve} from 'node:path';
+import {homeTrash,knownTrashes,trashInfoOriginal,trashInfoPath} from './trash.js';
+const identity=st=>`${st.dev}:${st.ino}:${st.mode}:${st.birthtimeMs}`;
+export function trashRecord(path) {
+  const files=dirname(resolve(path)),root=dirname(files);
+  if(basename(files)!=='files')return null;
+  const known=[homeTrash(),...knownTrashes()].map(resolvePath=>resolve(resolvePath));
+  if(!known.includes(root) && !/^\.Trash-\d+$/.test(basename(root)) && basename(dirname(root))!=='.Trash')return null;
+  try {
+    for(const dir of [root,files,join(root,'info')]) {
+      const st=lstatSync(dir);
+      if(!st.isDirectory() || (process.getuid && (st.uid!==process.getuid() || (st.mode&0o077))))return null;
+    }
+    const info=join(root,'info',basename(path)+'.trashinfo'),st=lstatSync(info);
+    if(!st.isFile()||st.size>1024*1024)return null;
+    return {path:resolve(path),info,text:readFileSync(info,'utf8'),identity:identity(st),root};
+  }catch{return null}
+}
+export function forgetTrashRecord(record) {
+  if(!record)return;
+  try {lstatSync(record.path);return} catch(e){if(e.code!=='ENOENT')return}
+  try {
+    if(identity(lstatSync(record.info))===record.identity && readFileSync(record.info,'utf8')===record.text)unlinkSync(record.info);
+  }catch(e){if(e.code!=='ENOENT')throw e}
+}
+// Reserve the new metadata name before moving; refuse collisions rather than overwrite.
+export function renameWithTrashRecord(source,destination) {
+  try {lstatSync(destination);throw Error('An item with that name already exists')}catch(e){if(e.code!=='ENOENT')throw e}
+  const record=trashRecord(source);
+  if(!record){renameSync(source,destination);return}
+  if(dirname(resolve(destination))!==dirname(record.path))throw Error('Rename must stay in the same directory');
+  const top=record.root===resolve(homeTrash())?'':basename(dirname(record.root))==='.Trash'?dirname(dirname(record.root)):dirname(record.root);
+  const original=trashInfoOriginal((/^Path=(.*)$/m.exec(record.text)?.[1]??'').trim(),top);
+  const text=original?record.text.replace(/^Path=.*$/m,()=> 'Path='+trashInfoPath(join(dirname(original),basename(destination)),top)):record.text;
+  const info=join(record.root,'info',basename(destination)+'.trashinfo');
+  writeFileSync(info,text,{flag:'wx',mode:0o600});
+  try {renameSync(source,destination)}catch(e){unlinkSync(info);throw e}
+  forgetTrashRecord(record);
+}

package/src/trash.js

@@ -0,0 +1,210 @@
+// The `trash` request (docs/protocol.md "trash"): each path moves into the freedesktop Trash.
+// Upstream runs `gio trash`; flea-qml runs no outside program, so this follows the FreeDesktop.org
+// Trash specification 1.0 itself: the item is renamed into `files/`, after a `.trashinfo` record
+// naming its original path is created exclusively in `info/`, which also reserves the name.
+//
+// Which Trash: the home Trash ($XDG_DATA_HOME/Trash) for an item on the same filesystem; otherwise
+// the top directory's `.Trash/$uid` when that `.Trash` is a real, sticky folder, else
+// `.Trash-$uid`, made if missing. An item is never copied between filesystems: a drive with no
+// usable Trash fails that item and leaves it in place. Every system keeps this same Trash,
+// Windows included: flea's Trash is this folder, not the Recycle Bin.
+import { appendFileSync, closeSync, constants, lstatSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeSync } from "node:fs";
+import { homedir } from "node:os";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { storePaths } from "./uistore.js";
+import { basename, dirname, join, resolve, sep, isAbsolute } from "node:path";
+
+const NAME_TRIES = 1000;
+
+export const homeTrash = () => join(process.env.XDG_DATA_HOME || join(homedir(), ".local", "share"), "Trash");
+
+// Path= as the specification asks: the item's path in URI form, through Bun's pathToFileURL on
+// every system, so a Windows drive letter is written /C:/... like any other path. In a per-drive
+// Trash it is relative to the drive's top: the same conversion, with the top's own part cut off.
+// Sample: /media/usb/照片/x.jpg under /media/usb gives %E7%85%A7%E7%89%87/x.jpg.
+export function trashInfoPath(full, base) {
+  const url = pathToFileURL(full),
+    path = url.host ? `//${url.host}${url.pathname}` : url.pathname;
+  if (!base) return path;
+  const top = pathToFileURL(base.endsWith(sep) ? base : base + sep).pathname;
+  return url.pathname.startsWith(top) ? url.pathname.slice(top.length) : path;
+}
+
+// Decode relative paths as filesystem paths, not URL schemes (a name may contain ':').
+// Invalid metadata cannot supply a restore destination outside its declared volume.
+export function trashInfoOriginal(path, base) {
+  if (!path) return "";
+  try {
+    if (path.startsWith("/")) return fileURLToPath(path.startsWith("//") ? `file:${path}` : `file://${path}`);
+    if (!base) return "";
+    const decoded = decodeURIComponent(path);
+    if (decoded.includes("\0") || isAbsolute(decoded)) return "";
+    const top = resolve(base), full = resolve(top, decoded);
+    return full !== top && full.startsWith(top.endsWith(sep) ? top : top + sep) ? full : "";
+  } catch { return ""; }
+}
+
+// Local time without a zone, YYYY-MM-DDThh:mm:ss, as the specification's DeletionDate.
+function deletionDate(now = new Date()) {
+  const two = (n) => String(n).padStart(2, "0");
+  return `${now.getFullYear()}-${two(now.getMonth() + 1)}-${two(now.getDate())}T${two(now.getHours())}:${two(now.getMinutes())}:${two(now.getSeconds())}`;
+}
+
+// The highest folder above `path` still on its device: the mount's top directory.
+function topDirectory(path, dev) {
+  let top = dirname(path);
+  for (;;) {
+    const up = dirname(top);
+    if (up === top) return top;
+    try {
+      if (statSync(up).dev !== dev) return top;
+    } catch {
+      return top;
+    }
+    top = up;
+  }
+}
+
+export function usableTrash(trash) {
+  // Never follow a pre-existing symlink for a user-owned Trash or its children.
+  for (const path of [trash, join(trash, "files"), join(trash, "info")]) {
+    try { mkdirSync(path, { mode: 0o700 }); }
+    catch (error) { if (error.code !== "EEXIST") throw error; }
+    const st = lstatSync(path);
+    if (!st.isDirectory() || (process.getuid && (st.uid !== process.getuid() || (st.mode & 0o077))))
+      throw Object.assign(new Error("Trash directory is not private and owned by this user"), {code: "EUNSAFETRASH"});
+  }
+  return trash;
+}
+
+// Every per-drive Trash flea has written into, one path a line beside ui.json, so the Trash view
+// finds them again on any system, whether or not that system has a mount table to read.
+export const knownTrashesFile = () => join(dirname(storePaths().file), "trash-folders");
+export function knownTrashes() {
+  try {
+    return readFileSync(knownTrashesFile(), "utf8").split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function remember(trash) {
+  if (knownTrashes().includes(trash)) return;
+  try {
+    mkdirSync(dirname(knownTrashesFile()), { recursive: true });
+    appendFileSync(knownTrashesFile(), `${trash}\n`);
+  } catch {}
+}
+
+// { trash, base } for an item: base is what Path= is relative to ("" for the home Trash).
+function trashFor(path, st) {
+  // The home Trash is made first, so its own device is what the item is compared with; on Windows
+  // ~/.local/share does not exist until flea makes it.
+  try {
+    const destination = homeTrash();
+    mkdirSync(dirname(destination), {recursive: true, mode: 0o700});
+    const home = usableTrash(destination);
+    if (statSync(home).dev === st.dev) return { trash: home, base: "" };
+  } catch (error) { if (error.code === "EUNSAFETRASH") throw error; }
+  // Windows has no uid; one user per profile, so the per-drive folder is .Trash-0 there.
+  const uid = process.getuid?.() ?? 0,
+    top = topDirectory(path, st.dev);
+  // $topdir/.Trash/$uid only when .Trash is a real folder with the sticky bit, never a link.
+  try {
+    const shared = lstatSync(join(top, ".Trash"));
+    if (shared.isDirectory() && shared.mode & constants.S_ISVTX) {
+      const trash = usableTrash(join(top, ".Trash", String(uid)));
+      remember(trash);
+      return { trash, base: top };
+    }
+  } catch {}
+  const trash = usableTrash(join(top, `.Trash-${uid}`));
+  remember(trash);
+  return { trash, base: top };
+}
+
+// Reserves a name in the Trash by creating its .trashinfo exclusively, then writes the record.
+function reserve(trash, name, record) {
+  for (let n = 1; n <= NAME_TRIES; n++) {
+    const candidate = n === 1 ? name : `${name}.${n}`;
+    let fd;
+    try {
+      fd = openSync(join(trash, "info", `${candidate}.trashinfo`), "wx", 0o600);
+    } catch (e) {
+      if (e.code === "EEXIST") continue;
+      throw e;
+    }
+    const info = join(trash, "info", `${candidate}.trashinfo`);
+    try {
+      const bytes = Buffer.from(record);
+      for (let offset = 0; offset < bytes.length;) {
+        const written = writeSync(fd, bytes, offset, bytes.length - offset);
+        if (!written) throw new Error("Could not write Trash metadata");
+        offset += written;
+      }
+    } catch (error) {
+      try { unlinkSync(info); } catch {}
+      throw error;
+    } finally { closeSync(fd); }
+    // An orphan file still owns its name. Only ENOENT means it is free.
+    let exists = false;
+    try { lstatSync(join(trash, "files", candidate)); exists = true; }
+    catch (error) {
+      if (error.code !== "ENOENT") { unlinkSync(info); throw error; }
+    }
+    if (exists) { unlinkSync(info); continue; }
+    return candidate;
+  }
+  throw new Error("every Trash name for this item is taken");
+}
+
+// Moves one item to the Trash and answers where it went, { file, info }; throws with a sentence when it cannot.
+export function trashOne(path) {
+  if (!isAbsolute(path) || resolve(path) === dirname(resolve(path))) throw new Error("Refusing to trash a filesystem root or relative path");
+  const full = resolve(path),
+    st = lstatSync(full);
+  let where;
+  try {
+    where = trashFor(full, st);
+  } catch {
+    throw new Error("This drive has no Trash that could be used, so the item was left in place");
+  }
+  if (full === where.trash || full.startsWith(where.trash + sep) || where.trash.startsWith(full + sep)) throw new Error("That item is already in the Trash");
+  const record = `[Trash Info]\nPath=${trashInfoPath(full, where.base)}\nDeletionDate=${deletionDate()}\n`;
+  const name = reserve(where.trash, basename(full), record);
+  try {
+    const current = lstatSync(full);
+    if (current.dev !== st.dev || current.ino !== st.ino || (current.mode & constants.S_IFMT) !== (st.mode & constants.S_IFMT))
+      throw new Error("Selected item changed; try again");
+    renameSync(full, join(where.trash, "files", name));
+  } catch (e) {
+    unlinkSync(join(where.trash, "info", `${name}.trashinfo`));
+    throw e.code === "EXDEV" ? new Error("This drive has no Trash that could be used, so the item was left in place") : e;
+  }
+  return { file: join(where.trash, "files", name), info: join(where.trash, "info", `${name}.trashinfo`) };
+}
+
+const reason = (e) =>
+  ({ EACCES: "permission denied", EPERM: "permission denied", ENOENT: "it no longer exists", EROFS: "the drive is read-only", EBUSY: "the item is in use" })[e?.code] ??
+  String(e?.message ?? e);
+
+// The whole request: trashstarted, then one trashed line, then changed for each folder touched.
+export function trash(request, send, named) {
+  const id = request.id ?? 0,
+    paths = named.paths;
+  send({ t: "trashstarted", id, n: paths.length, cancellable: false });
+  const moved = [],
+    folders = new Set();
+  let firstError = "";
+  for (const path of paths) {
+    try {
+      trashOne(path);
+      moved.push(path);
+      folders.add(dirname(path));
+    } catch (e) {
+      firstError ||= reason(e);
+    }
+  }
+  const failed = paths.length - moved.length;
+  send({ t: "trashed", id, ok: moved.length, failed, moved, ...(failed ? { err: firstError } : {}) });
+  for (const path of folders) send({ t: "changed", path });
+}

package/src/trashbrowse.js

@@ -0,0 +1,327 @@
+// Reading the Trash back: the sidebar's count (a `trashcount` line from the backend) and the Trash view's
+// `trashbrowse` requests (list, window, select, summary, prepare, check, cancel, restore, delete).
+// Upstream asks `gio`; flea-qml reads the same FreeDesktop.org Trash that src/trash.js writes:
+// every `info/<name>.trashinfo` whose `files/<name>` is still there is one item.
+//
+// The Trash folders read are the home Trash, each mount's `.Trash/$uid` and `.Trash-$uid` when a
+// mount table can be read, and every per-drive Trash flea has written into: the same on every system.
+import { lstatSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, unlinkSync, watch } from "node:fs";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { describeKind } from "./kinds.js";
+import { homeTrash, knownTrashes, trashInfoOriginal, usableTrash } from "./trash.js";
+
+import { reviewTrees } from "./menu.js";
+
+const identity = (st) => `${st.dev}:${st.ino}:${st.mode & 0o170000}`;
+
+// Every Trash folder that exists now: [{ trash, top }], top "" for the home Trash.
+export function trashFolders() {
+  const out = [],
+    seen = new Set();
+  const add = (trash, top) => {
+    const key = resolve(trash);
+    if (seen.has(key)) return;
+    try {
+      if (top && basename(dirname(trash)) === ".Trash") {
+        const shared = lstatSync(dirname(trash));
+        if (!shared.isDirectory() || !(shared.mode & 0o1000)) return;
+      }
+      for (const path of [trash, join(trash, "info"), join(trash, "files")]) {
+        const st = lstatSync(path);
+        if (!st.isDirectory() || (process.getuid && (st.uid !== process.getuid() || (st.mode & 0o077)))) return;
+      }
+    } catch {
+      return;
+    }
+    seen.add(key);
+    out.push({ trash: key, top });
+  };
+  add(homeTrash(), "");
+  // Every system takes the same three sources: the home Trash, each mount's Trash when a mount
+  // table can be read (Linux and Android have one; elsewhere the read fails and adds nothing), and
+  // every per-drive Trash flea itself has written into.
+  let mounts = "";
+  try {
+    mounts = readFileSync("/proc/self/mountinfo", "utf8");
+  } catch {}
+  const uid = process.getuid?.() ?? 0;
+  for (const line of mounts.split("\n")) {
+    // Field 5 is the mount point, with spaces and the like written as octal escapes.
+    const top = line.split(" ")[4]?.replace(/\\([0-7]{3})/g, (_, o) => String.fromCharCode(parseInt(o, 8)));
+    if (!top || !isAbsolute(top)) continue;
+    add(join(top, ".Trash", String(uid)), top);
+    add(join(top, `.Trash-${uid}`), top);
+  }
+  // A per-drive Trash's Path= is relative to the drive's top, the folder that holds the Trash.
+  for (const trash of knownTrashes()) add(trash, basename(dirname(trash)) === ".Trash" ? dirname(dirname(trash)) : dirname(trash));
+  return out;
+}
+
+// Every item now in the Trash, newest first.
+export function readTrash() {
+  const items = [];
+  for (const { trash, top } of trashFolders()) {
+    let names = [];
+    try {
+      names = readdirSync(join(trash, "info"));
+    } catch {
+      continue;
+    }
+    for (const entry of names) {
+      if (!entry.endsWith(".trashinfo") || entry === ".trashinfo" || entry === "..trashinfo" || entry === "...trashinfo") continue;
+      const name = entry.slice(0, -".trashinfo".length),
+        file = join(trash, "files", name);
+      let st, text;
+      try {
+        const metadata = lstatSync(join(trash, "info", entry));
+        if (!metadata.isFile() || metadata.size > 1024 * 1024) continue;
+        st = lstatSync(file);
+        text = readFileSync(join(trash, "info", entry), "utf8");
+      } catch {
+        continue;
+      }
+      const original = trashInfoOriginal((/^Path=(.*)$/m.exec(text)?.[1] ?? "").trim(), top);
+      const deleted = /^DeletionDate=(.*)$/m.exec(text)?.[1]?.trim() ?? "";
+      const directory = st.isDirectory();
+      items.push({
+        uri: file,
+        name,
+        original,
+        deleted,
+        directory,
+        icon: describeKind(original.split(/[\\/]/).pop() || name, directory, st.mode, undefined).icon,
+        identity: `${identity(st)}:${JSON.stringify(text)}`,
+        fileIdentity: identity(st),
+        file,
+        info: join(trash, "info", entry),
+      });
+    }
+  }
+  return items.sort((a, b) => (a.deleted < b.deleted ? 1 : a.deleted > b.deleted ? -1 : 0));
+}
+
+// ---- the Trash count the backend reports: once at start, then on every change ----
+
+// Calls onCount with the item count now and whenever a Trash folder changes. Runs inside the
+// backend, so it lives exactly as long as the interface and adds no process of its own.
+export function watchTrashCount(onCount) {
+  let last = "",
+    timer = null;
+  const report = () => {
+    timer = null;
+    const items = readTrash();
+    const signature = JSON.stringify(items.map(item => [item.uri, item.identity]));
+    if (signature !== last) {
+      last = signature;
+      onCount(items.length);
+    }
+  };
+  const watched = new Map();
+  const schedule = () => {
+    timer ??= setTimeout(report, 120);
+    timer.unref?.();
+  };
+  const arm = () => {
+    const dirs = new Set(trashFolders().flatMap(({trash}) => [join(trash, "files"), join(trash, "info")]));
+    for (const [dir, watcher] of watched) {
+      if (!dirs.has(dir)) { watcher.close(); watched.delete(dir); }
+    }
+    for (const { trash } of trashFolders())
+      for (const sub of ["files", "info"]) {
+        const dir = join(trash, sub);
+        if (watched.has(dir)) continue;
+        try {
+          const watcher = watch(dir, { persistent: false }, schedule);
+          watcher.on("error", () => { watcher.close(); watched.delete(dir); schedule(); });
+          watched.set(dir, watcher);
+        } catch {}
+      }
+  };
+  // The home Trash is made first, as the specification allows, so there is a folder to watch
+  // before anything has ever been trashed.
+  try {
+    usableTrash(homeTrash());
+  } catch {}
+  arm();
+  report();
+  // A drive mounted later, with a Trash of its own, is picked up within a few seconds.
+  const interval = setInterval(() => {
+    arm();
+    schedule();
+  }, 5000);
+  interval.unref?.();
+  return () => { clearInterval(interval); clearTimeout(timer); for (const watcher of watched.values()) watcher.close(); watched.clear(); };
+}
+
+// ---- the Trash view ----
+
+let snapshot = [],
+  selection = null,
+  selectionTokens = 0,
+  review = null,
+  reviewTokens = 0;
+
+const rowOf = (item) => ({
+  uri: item.uri,
+  name: item.name,
+  original: item.original,
+  deleted: item.deleted,
+  directory: item.directory,
+  icon: item.icon,
+  identity: item.identity,
+  ...(selection?.has(item.uri) ? { bulkSelected: true } : {}),
+});
+
+// The items a restore or delete names: all of them, the bulk selection minus exclusions, or URIs,
+// each still holding the identity the client saw.
+function chosen(request, items) {
+  const byUri = new Map(items.map((item) => [item.uri, item]));
+  if (request.all) return { items };
+  const exclude = new Set(request.exclude ?? []);
+  let picked = [];
+  if (request.selectionToken) {
+    if (!selection || selection.token !== request.selectionToken) return { stale: true };
+    picked = [...selection.keys()].filter((uri) => !exclude.has(uri)).map((uri) => {
+      const item = byUri.get(uri);
+      return item?.identity === selection.get(uri) ? item : null;
+    });
+  } else {
+    picked = (request.uris ?? []).map((uri, i) => {
+      const item = byUri.get(uri);
+      const want = request.identities?.[i];
+      return item && (!want || want === item.identity) ? item : null;
+    });
+  }
+  if (picked.some((item) => !item)) return { stale: true };
+  return { items: picked };
+}
+
+function removeItem(item) {
+  rmSync(item.file, { recursive: true, force: false });
+  try {
+    unlinkSync(item.info);
+  } catch {}
+}
+
+function restoreItem(item) {
+  if (!item.original || !isAbsolute(item.original)) throw new Error("the Trash does not say where it came from");
+  try {
+    lstatSync(item.original);
+    throw Object.assign(new Error("an item with that name is already there"), { taken: true });
+  } catch (e) {
+    if (e.taken || e.code !== "ENOENT") throw e;
+  }
+  mkdirSync(dirname(item.original), { recursive: true });
+  renameSync(item.file, item.original);
+  try {
+    unlinkSync(item.info);
+  } catch {}
+}
+
+const reason = (e) =>
+  ({ EACCES: "permission denied", EPERM: "permission denied", EXDEV: "it would have to cross drives", EROFS: "the drive is read-only" })[e?.code] ??
+  String(e?.message ?? e);
+
+export function trashbrowse(request, send) {
+  try { return handleTrashBrowse(request, send); }
+  catch (error) { send({t: "trashbrowse", op: request.op ?? "", id: request.id ?? 0, ok: false, error: reason(error)}); }
+}
+
+function validReview() {
+  if (!review) return false;
+  const now = new Map(readTrash().map(item => [item.uri, item.identity]));
+  if (!review.items.every(item => now.get(item.uri) === item.identity)) return false;
+  try { return JSON.stringify(reviewTrees(review.items.map(item => item.file)).rows) === JSON.stringify(review.tree.rows); }
+  catch { return false; }
+}
+
+function handleTrashBrowse(request, send) {
+  const id = request.id ?? 0,
+    op = request.op ?? "",
+    answer = (fields) => send({ t: "trashbrowse", op, id, ok: true, ...fields });
+  const windowOf = (start, count) => {
+    const from = Math.max(0, Math.min(start | 0, snapshot.length));
+    return snapshot.slice(from, from + Math.max(0, count | 0)).map(rowOf);
+  };
+  const selectionFields = () => (selection ? { selectionToken: selection.token, selectionCount: selection.size, selectionStale: false } : {});
+  if (op === "list") {
+    snapshot = readTrash();
+    if (selection) for (const uri of [...selection.keys()]) if (!snapshot.some((item) => item.uri === uri)) selection.delete(uri);
+    const present = new Set(snapshot.map((item) => item.uri));
+    return answer({
+      total: snapshot.length,
+      start: request.start ?? 0,
+      rows: windowOf(request.start ?? 0, request.count ?? 0),
+      present: (request.uris ?? []).filter((uri) => present.has(uri)),
+      recoveredCount: 0,
+      recoveryErrors: [],
+      ...selectionFields(),
+    });
+  }
+  if (op === "window") return answer({ total: snapshot.length, start: request.start ?? 0, rows: windowOf(request.start ?? 0, request.count ?? 0), ...selectionFields() });
+  if (op === "select") {
+    selection = new Map(snapshot.map((item) => [item.uri, item.identity]));
+    selection.token = ++selectionTokens;
+    return answer({ selectionToken: selection.token, selectionCount: selection.size });
+  }
+  if (op === "cancel") {
+    review = null;
+    if (request.clearSelection) selection = null;
+    return answer({});
+  }
+  if (op === "summary") return answer({ bytes: reviewTrees(snapshot.map(item => item.file)).bytes, partial: false });
+  if (op === "prepare") {
+    review = null;
+    const picked = chosen(request, readTrash());
+    if (picked.stale) return send({ t: "trashbrowse", op, id, ok: false, stale: true, error: "The Trash changed; review it again." });
+    const tree = reviewTrees(picked.items.map(item => item.file));
+    review = { token: ++reviewTokens, items: picked.items.map((item) => ({ ...item })), tree };
+    return answer({
+      token: review.token,
+      all: request.emptyTrash === true || request.all === true,
+      count: review.items.length,
+      name: review.items.length === 1 ? (review.items[0].original.split(/[\\/]/).pop() || review.items[0].name) : "",
+      bytes: tree.bytes,
+      partial: false,
+    });
+  }
+  if (op === "check") {
+    const valid = !!review && review.token === request.token && validReview();
+    return answer({ valid });
+  }
+  if (op === "delete" || op === "restore") {
+    let items;
+    if (op === "delete") {
+      // Only the reviewed snapshot deletes, once.
+      if (!review || review.token !== request.token || !validReview()) return send({ t: "trashbrowse", op, id, ok: false, stale: true, error: "The Trash changed; review it again." });
+      items = review.items;
+      review = null;
+    } else {
+      const picked = chosen(request, readTrash());
+      if (picked.stale) return send({ t: "trashbrowse", op, id, ok: false, stale: true, error: "The Trash changed; select the items again." });
+      items = picked.items;
+    }
+    let done = 0;
+    const failures = [],
+      folders = new Set();
+    for (const item of items) {
+      try {
+        // Checked again just before acting, so an item swapped since it was seen is left alone.
+        if (identity(lstatSync(item.file)) !== item.fileIdentity) throw new Error("it changed in the Trash");
+        if (op === "delete") removeItem(item);
+        else {
+          restoreItem(item);
+          folders.add(dirname(item.original));
+        }
+        done++;
+      } catch (e) {
+        failures.push({ uri: item.uri, name: item.original.split(/[\\/]/).pop() || item.name, error: reason(e), identity: item.identity });
+      }
+    }
+    selection = null;
+    answer({ done, failed: failures.length, failures });
+    for (const path of folders) send({ t: "changed", path });
+    return;
+  }
+  send({ t: "trashbrowse", op, id, ok: false, error: `${op || "That Trash action"} is not ported to flea-qml yet.` });
+}