@kecan0406/ttheme 0.1.3 → 0.1.4

package/bin/ttheme.js

@@ -4098,6 +4098,9 @@ var require_src = __commonJS((exports, module) => {
   module.exports = { cursor, scroll, erase, beep };
 });
 
+// src/bin.ts
+import { isMainThread as isMainThread2 } from "node:worker_threads";
+
 // node_modules/commander/lib/error.js
 class CommanderError extends Error {
   constructor(exitCode, code, message) {
@@ -6144,7 +6147,7 @@ var program = new Command;
 // package.json
 var package_default = {
   name: "@kecan0406/ttheme",
-  version: "0.1.3",
+  version: "0.1.4",
   type: "module",
   bin: {
     ttheme: "bin/ttheme.js"
@@ -7042,12 +7045,12 @@ ${themes.length} themes (${rotation(themes).length} in the new-tab rotation) ->
 
 // src/find.ts
 import { spawn as spawn2 } from "node:child_process";
-import { existsSync as existsSync3, mkdirSync as mkdirSync4, mkdtempSync, readFileSync as readFileSync5, rmSync as rmSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync5, mkdtempSync, readFileSync as readFileSync6, rmSync as rmSync5, statSync as statSync3, writeFileSync as writeFileSync5 } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname as dirname3, join as join7 } from "node:path";
+import { dirname as dirname4, join as join7 } from "node:path";
 
 // src/backdrop.ts
-import { mkdirSync, readdirSync as readdirSync2, rmSync as rmSync2, statSync, writeFileSync } from "node:fs";
+import { mkdirSync, readdirSync as readdirSync2, readFileSync as readFileSync2, renameSync, rmSync as rmSync2, statSync, utimesSync, writeFileSync } from "node:fs";
 import { join as join3 } from "node:path";
 
 // src/png.ts
@@ -7231,7 +7234,11 @@ var FILL = { width: 2560, height: 1550 };
 var FIGURE = 2560;
 var FAINT = 0.1;
 var HEADROOM = 0.15;
+var KEEP = 0.55;
+var PLACE = 0.65;
+var STANDS = 3;
 var PEAK = luminance(mix("#19161e", "#9b86c8", 0.2));
+var SHELF = "shelf";
 function mix(a, b, t) {
   const from = rgb(a);
   const to = rgb(b);
@@ -7321,11 +7328,14 @@ function figureBox(image) {
 function headAnchor(box) {
   return Math.min(0.5, (HEADROOM + 0.5) * (box.w * FILL.height / FILL.width / box.h));
 }
+function band(box, h, anchor) {
+  const top = Math.min(Math.max(0, anchor * box.h - h / 2), box.h - h);
+  return { x: box.x, y: box.y + top, w: box.w, h };
+}
 function fillBox(box, width, height, anchor) {
   const h = box.w * height / width;
   if (h <= box.h) {
-    const top = Math.min(Math.max(0, anchor * box.h - h / 2), box.h - h);
-    return { x: box.x, y: box.y + top, w: box.w, h };
+    return band(box, h, anchor);
   }
   const w = box.h * width / height;
   return { x: box.x + (box.w - w) / 2, y: box.y, w, h: box.h };
@@ -7342,20 +7352,66 @@ function figure(image, box) {
   const k = Math.min(1, FIGURE / Math.max(box.w, box.h));
   return resample(image, box, Math.round(box.w * k), Math.round(box.h * k));
 }
-function fill(image, box, anchor) {
-  return resample(image, fillBox(box, FILL.width, FILL.height, anchor), FILL.width, FILL.height);
+function fillFrame(box, width, height, anchor, clear) {
+  const keep = KEEP * box.h;
+  const span = box.w * height / width;
+  if (clear < STANDS || span > keep) {
+    return { crop: fillBox(box, width, height, anchor), at: { x: 0, y: 0, w: width, h: height }, inset: false };
+  }
+  const short = 1 - span / keep;
+  const h = height * (1 - HEADROOM * short);
+  const w = box.w * h / keep;
+  return {
+    crop: band(box, keep, anchor),
+    at: { x: (width - w) * PLACE, y: height - h, w, h },
+    inset: true
+  };
+}
+function paint(image, frame, width, height) {
+  const w = Math.max(1, Math.round(frame.at.w));
+  const h = Math.max(1, Math.round(frame.at.h));
+  const cut = resample(image, frame.crop, w, h);
+  const out = new Uint8Array(width * height * 4);
+  const ox = Math.round(frame.at.x);
+  const oy = Math.round(frame.at.y);
+  for (let y = 0;y < h; y++) {
+    const ty = oy + y;
+    const from = Math.max(0, -ox);
+    const to = Math.min(w, width - ox);
+    if (ty < 0 || ty >= height || to <= from) {
+      continue;
+    }
+    out.set(cut.data.subarray((y * w + from) * 4, (y * w + to) * 4), (ty * width + ox + from) * 4);
+  }
+  return { width, height, data: out };
+}
+function fill(image, box, anchor, clear) {
+  const frame = fillFrame(box, FILL.width, FILL.height, anchor, clear);
+  return frame.inset ? paint(image, frame, FILL.width, FILL.height) : resample(image, frame.crop, FILL.width, FILL.height);
 }
-function tryOn(image, colors, tone, width, height) {
+function tryOn(image, colors, tone, width, height, clear) {
   const box = figureBox(image);
-  const view = coverBox(fillBox(box, FILL.width, FILL.height, headAnchor(box)), width, height);
-  return composite(tint(resample(image, view, width, height), colors.background, tone.color), colors.background, tone.opacity);
+  const frame = fillFrame(box, FILL.width, FILL.height, headAnchor(box), clear);
+  let shown;
+  if (frame.inset) {
+    const view = coverBox({ x: 0, y: 0, w: FILL.width, h: FILL.height }, width, height);
+    const k = width / view.w;
+    shown = paint(image, {
+      ...frame,
+      at: { x: (frame.at.x - view.x) * k, y: (frame.at.y - view.y) * k, w: frame.at.w * k, h: frame.at.h * k }
+    }, width, height);
+  } else {
+    shown = resample(image, coverBox(frame.crop, width, height), width, height);
+  }
+  return composite(tint(shown, colors.background, tone.color), colors.background, tone.opacity);
 }
 function backgroundsDir(configHome) {
   return join3(configHome, "ttheme", "backgrounds");
 }
-function backdropConf(name, fillPath, opacity, from) {
+function backdropConf(name, fillPath, opacity, from, key) {
   return [
     ...from ? [`# from ${from}`] : [],
+    ...key ? [`# image ${key}`] : [],
     `background-image = ${fillPath}`,
     "background-image-fit = cover",
     "background-image-position = center",
@@ -7373,26 +7429,139 @@ function clearBackdrop(dir, name) {
     }
   }
 }
+function imageKey(origin) {
+  return `${origin.site}_${origin.id}`;
+}
+function shelfDir(dir, name) {
+  return join3(dir, SHELF, name);
+}
+function belongs(file, name) {
+  const rest = file.slice(name.length);
+  return file.startsWith(name) && (rest === ".png" || rest === ".conf" || /^@fill-\d+\.png$/.test(rest));
+}
+function activeKey(dir, name) {
+  try {
+    return /^# image (\S+)$/m.exec(readFileSync2(join3(dir, `${name}.conf`), "utf8"))?.[1];
+  } catch {
+    return;
+  }
+}
+function shelved(dir, name) {
+  try {
+    return readdirSync2(shelfDir(dir, name));
+  } catch {
+    return [];
+  }
+}
+function imageKeys(dir, name) {
+  const active = activeKey(dir, name);
+  return [...active ? [active] : [], ...shelved(dir, name)].sort();
+}
+function shelve(dir, name) {
+  const key = activeKey(dir, name);
+  if (!key) {
+    return;
+  }
+  const to = join3(shelfDir(dir, name), key);
+  rmSync2(to, { recursive: true, force: true });
+  mkdirSync(to, { recursive: true });
+  for (const file of readdirSync2(dir)) {
+    if (belongs(file, name)) {
+      renameSync(join3(dir, file), join3(to, file.slice(name.length)));
+    }
+  }
+  clearBackdrop(dir, name);
+}
+function unshelve(dir, name, key) {
+  const from = join3(shelfDir(dir, name), key);
+  for (const file of readdirSync2(from)) {
+    renameSync(join3(from, file), join3(dir, `${name}${file}`));
+  }
+  rmSync2(from, { recursive: true });
+}
+function originalOf(dir, name, key) {
+  try {
+    return readdirSync2(join3(dir, "originals")).find((file) => file.startsWith(`${name}-${key}.`));
+  } catch {
+    return;
+  }
+}
+function newest(dir, name, key) {
+  const file = originalOf(dir, name, key);
+  if (file) {
+    const now = new Date;
+    utimesSync(join3(dir, "originals", file), now, now);
+  }
+}
+function switchImage(configHome, name, step) {
+  const dir = backgroundsDir(configHome);
+  const keys = imageKeys(dir, name);
+  const now = activeKey(dir, name);
+  if (!now || keys.length < 2) {
+    throw new Error(`${name} has no other image`);
+  }
+  const at2 = (keys.indexOf(now) + step + keys.length) % keys.length;
+  const key = keys[at2];
+  shelve(dir, name);
+  unshelve(dir, name, key);
+  newest(dir, name, key);
+  return { key, at: at2 + 1, of: keys.length };
+}
+function dropImage(configHome, name) {
+  const dir = backgroundsDir(configHome);
+  const files = readdirSync2(dir).filter((file) => belongs(file, name));
+  if (files.length === 0) {
+    throw new Error(`${name} has no image`);
+  }
+  const keys = imageKeys(dir, name);
+  const now = activeKey(dir, name);
+  const original = now && originalOf(dir, name, now);
+  if (original) {
+    rmSync2(join3(dir, "originals", original));
+  }
+  for (const file of files) {
+    rmSync2(join3(dir, file));
+  }
+  clearBackdrop(dir, name);
+  const rest = keys.filter((key) => key !== now);
+  const next = rest[(now ? keys.indexOf(now) : 0) % rest.length];
+  if (next) {
+    unshelve(dir, name, next);
+    newest(dir, name, next);
+  }
+  return { key: now, left: rest.length };
+}
+function retire(dir, name, key) {
+  if (activeKey(dir, name) !== key) {
+    shelve(dir, name);
+  }
+  if (key) {
+    rmSync2(join3(shelfDir(dir, name), key), { recursive: true, force: true });
+  }
+  clearBackdrop(dir, name);
+}
 function installBackdrop(configHome, colors, tone, image, original) {
   const dir = backgroundsDir(configHome);
   const name = colors.name;
+  const key = imageKey(original);
   mkdirSync(join3(dir, "originals"), { recursive: true });
-  clearBackdrop(dir, name);
+  retire(dir, name, key);
   const box = figureBox(image);
   const anchor = headAnchor(box);
+  const clear = transparency(image);
   const whole = join3(dir, `${name}.png`);
   const fillPath = join3(dir, `${name}@fill-${Math.round(anchor * 100)}.png`);
   const conf = join3(dir, `${name}.conf`);
   const source = join3(dir, "originals", `${name}-${original.site}_${original.id}.${original.ext}`);
   writeFileSync(whole, encodePng(tint(figure(image, box), colors.background, tone.color)));
-  writeFileSync(fillPath, encodePng(tint(fill(image, box, anchor), colors.background, tone.color)));
-  writeFileSync(conf, backdropConf(name, fillPath, tone.opacity, original.from));
+  writeFileSync(fillPath, encodePng(tint(fill(image, box, anchor, clear), colors.background, tone.color)));
+  writeFileSync(conf, backdropConf(name, fillPath, tone.opacity, original.from, key));
   writeFileSync(source, original.bytes);
   return [whole, fillPath, conf, source];
 }
 function origins(configHome) {
   const dir = join3(backgroundsDir(configHome), "originals");
-  const newest = new Map;
+  const newest2 = new Map;
   let files;
   try {
     files = readdirSync2(dir);
@@ -7406,21 +7575,23 @@ function origins(configHome) {
       continue;
     }
     const at2 = statSync(join3(dir, file)).mtimeMs;
-    const known = newest.get(name);
+    const known = newest2.get(name);
     if (!known || at2 > known.at) {
-      newest.set(name, { site, id: Number(id), at: at2 });
+      newest2.set(name, { site, id: Number(id), at: at2 });
     }
   }
-  return new Map([...newest].map(([name, { site, id }]) => [name, { site, id }]));
+  return new Map([...newest2].map(([name, { site, id }]) => [name, { site, id }]));
 }
 
 // src/booru.ts
+import { readdirSync as readdirSync3, rmSync as rmSync3, statSync as statSync2 } from "node:fs";
 import { setDefaultAutoSelectFamilyAttemptTimeout } from "node:net";
 import { homedir } from "node:os";
 import { join as join4 } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 var PAGE = 100;
 var MAX_PIXELS = 25000000;
+var CACHE_BYTES = 512 * 1024 * 1024;
 var RATINGS = ["safe", "questionable", "explicit"];
 var BLOCKS = ["nudity", "underwear"];
 var EXPOSED = {
@@ -7435,10 +7606,18 @@ var CONNECT = 3000;
 var MAX_WAIT = 60000;
 var TRIES = 3;
 var AGENT = `ttheme/${package_default.version} (+${package_default.homepage})`;
+var HELD = ["orig", "tile", "thumb", "cut"];
 var paused = new Map;
 var HOSTS = hostMap(process.env.TTHEME_FIND_HOSTS);
 var CUTOUTS = cutoutMap(process.env.TTHEME_FIND_CUTOUTS);
 setDefaultAutoSelectFamilyAttemptTimeout(CONNECT);
+function listing(dir) {
+  try {
+    return readdirSync3(dir);
+  } catch {
+    return [];
+  }
+}
 function absolute(url) {
   return url.startsWith("//") ? `https:${url}` : url;
 }
@@ -7762,8 +7941,38 @@ function mates(owners) {
   }
   return byOwner;
 }
+function cacheRoot() {
+  return join4(process.env.XDG_CACHE_HOME ?? join4(homedir(), ".cache"), "ttheme");
+}
 function cacheDir(site) {
-  return join4(process.env.XDG_CACHE_HOME ?? join4(homedir(), ".cache"), "ttheme", site.key);
+  return join4(cacheRoot(), site.key);
+}
+function sweepCache(limit = CACHE_BYTES, root2 = cacheRoot()) {
+  const files = [];
+  let total = 0;
+  for (const site of listing(root2)) {
+    for (const kind of HELD) {
+      const dir = join4(root2, site, kind);
+      for (const name of listing(dir)) {
+        const path2 = join4(dir, name);
+        try {
+          const { size, mtimeMs } = statSync2(path2);
+          files.push({ path: path2, size, at: mtimeMs });
+          total += size;
+        } catch {}
+      }
+    }
+  }
+  files.sort((a, b) => a.at - b.at);
+  for (const file of files) {
+    if (total <= limit) {
+      return;
+    }
+    try {
+      rmSync3(file.path, { force: true });
+      total -= file.size;
+    } catch {}
+  }
 }
 function retryAfter(value, now) {
   if (value !== null && /^\s*\d+\s*$/.test(value)) {
@@ -7846,7 +8055,7 @@ async function fetchBytes(site, url, signal, progress) {
 }
 
 // src/catalog.ts
-import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
 import { dirname, join as join5 } from "node:path";
 var REGISTRY_URL = "https://kecan0406.github.io/ttheme/manifest.json";
 function catalogPath(configHome) {
@@ -7863,7 +8072,7 @@ function readCatalog(configHome) {
   if (!existsSync(path2)) {
     throw new Error(`no catalog at ${path2} — run \`ttheme init\` first`);
   }
-  return parseCatalog(readFileSync2(path2, "utf8"));
+  return parseCatalog(readFileSync3(path2, "utf8"));
 }
 function parseCatalog(source) {
   let doc;
@@ -7925,7 +8134,6 @@ function search(palettes, query) {
 
 // src/cutout.ts
 import { spawn } from "node:child_process";
-import { readFileSync as readFileSync3 } from "node:fs";
 var TIMEOUT2 = 30000;
 var LEAST = 3;
 var MOST = 97;
@@ -7967,16 +8175,12 @@ function removeBackground(input, output, signal) {
     });
     child.on("error", reject);
     child.on("close", (code) => {
-      if (code !== 0) {
-        reject(new Error(failure.trim().split(`
-`).at(-1) || `osascript exited ${code}`));
+      if (code === 0) {
+        resolve();
         return;
       }
-      try {
-        resolve(decodePng(new Uint8Array(readFileSync3(output))));
-      } catch (error) {
-        reject(error);
-      }
+      reject(new Error(failure.trim().split(`
+`).at(-1) || `osascript exited ${code}`));
     });
   });
 }
@@ -8530,7 +8734,7 @@ function renderFind(view, cols, rows) {
 }
 
 // src/palettes.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync4, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync4, rmSync as rmSync4, writeFileSync as writeFileSync3 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { dirname as dirname2, join as join6 } from "node:path";
 var EMITTERS = { ghostty, kitty, alacritty };
@@ -8658,7 +8862,7 @@ function forget(configHome2, catalog, terminals, names) {
       for (const { file } of themeFiles(terminal, toTheme(entry, catalog))) {
         const path2 = join6(configHome2, terminal, "themes", file);
         if (existsSync2(path2)) {
-          rmSync3(path2, { force: true });
+          rmSync4(path2, { force: true });
           removed.push(path2);
         }
       }
@@ -8667,6 +8871,117 @@ function forget(configHome2, catalog, terminals, names) {
   return removed;
 }
 
+// src/render.ts
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname3 } from "node:path";
+import { isMainThread, parentPort, Worker } from "node:worker_threads";
+var LANES = { thumb: "tile", show: "view", backdrop: "view" };
+function work(task) {
+  const image = decodeImage(new Uint8Array(readFileSync5(task.from)), MAX_PIXELS);
+  if (task.job === "backdrop") {
+    installBackdrop(task.home, task.colors, task.tone, image, {
+      ...task.origin,
+      bytes: new Uint8Array(readFileSync5(task.source))
+    });
+    return 0;
+  }
+  if (task.job === "thumb") {
+    mkdirSync4(dirname3(task.to), { recursive: true });
+    writeFileSync4(task.to, encodePng(contain(image, task.width, task.height)));
+    return 0;
+  }
+  const clear = transparency(image);
+  mkdirSync4(dirname3(task.to), { recursive: true });
+  writeFileSync4(task.to, encodePng(tryOn(image, task.colors, task.tone, task.width, task.height, clear)));
+  return clear;
+}
+function serveRenders(port) {
+  port.on("message", (task) => {
+    try {
+      port.postMessage({ id: task.id, value: work(task) });
+    } catch (error) {
+      port.postMessage({ id: task.id, error: error instanceof Error ? error.message : String(error) });
+    }
+  });
+}
+
+class Line2 {
+  worker;
+  next = 1;
+  waiting = new Map;
+  send(task) {
+    const id = this.next++;
+    return new Promise((ok, no) => {
+      const worker = this.open();
+      this.waiting.set(id, { ok, no });
+      worker.ref();
+      worker.postMessage({ ...task, id });
+    });
+  }
+  close() {
+    this.worker?.terminate();
+    this.worker = undefined;
+    this.drop(new Error("renderer closed"));
+  }
+  open() {
+    if (this.worker) {
+      return this.worker;
+    }
+    const worker = new Worker(import.meta.filename);
+    worker.unref();
+    worker.on("message", ({ id, value, error }) => {
+      const held = this.waiting.get(id);
+      this.waiting.delete(id);
+      if (this.waiting.size === 0) {
+        worker.unref();
+      }
+      if (error !== undefined) {
+        held?.no(new Error(error));
+      } else {
+        held?.ok(value);
+      }
+    });
+    const lost = (error) => {
+      if (this.worker === worker) {
+        this.worker = undefined;
+      }
+      this.drop(error instanceof Error ? error : new Error("renderer stopped"));
+    };
+    worker.on("error", lost);
+    worker.on("exit", () => lost(undefined));
+    this.worker = worker;
+    return worker;
+  }
+  drop(error) {
+    for (const held of this.waiting.values()) {
+      held.no(error);
+    }
+    this.waiting.clear();
+  }
+}
+
+class Renderer {
+  lines = new Map;
+  run(task) {
+    const lane = LANES[task.job];
+    let line = this.lines.get(lane);
+    if (!line) {
+      line = new Line2;
+      this.lines.set(lane, line);
+    }
+    return line.send(task);
+  }
+  close() {
+    for (const line of this.lines.values()) {
+      line.close();
+    }
+    this.lines.clear();
+  }
+}
+if (!isMainThread && parentPort) {
+  serveRenders(parentPort);
+}
+
 // src/unblock.ts
 import { connect, createServer } from "node:net";
 var SPLIT = 20;
@@ -8801,12 +9116,13 @@ function initial(setting, raw) {
   }
   return setting.choices.find((choice) => choice === raw) ?? setting.choices[0];
 }
-var WORKERS = 4;
+var PROBE = 12;
+var THUMB = 12;
 var PRELOAD = 2;
 var SETTLE = 150;
 var ESCAPE = 30;
 var TRY_WIDTH = 1280;
-var LOOKAHEAD = 1;
+var LOOKAHEAD = 2;
 function blank(key, searching) {
   return {
     key,
@@ -8845,19 +9161,16 @@ function incomplete(input) {
   const at2 = input.lastIndexOf("\x1B");
   return at2 !== -1 && /^\[?[0-9;]*$/.test(input.slice(at2 + 1));
 }
-function tick() {
-  return new Promise((resolve2) => setImmediate(resolve2));
-}
 function readCache(site, name) {
   try {
-    return JSON.parse(readFileSync5(join7(cacheDir(site), name), "utf8"));
+    return JSON.parse(readFileSync6(join7(cacheDir(site), name), "utf8"));
   } catch {
     return {};
   }
 }
 function writeCache(site, name, data) {
-  mkdirSync4(cacheDir(site), { recursive: true });
-  writeFileSync4(join7(cacheDir(site), name), `${JSON.stringify(data)}
+  mkdirSync5(cacheDir(site), { recursive: true });
+  writeFileSync5(join7(cacheDir(site), name), `${JSON.stringify(data)}
 `);
 }
 
@@ -8884,6 +9197,8 @@ class Finder {
   unsaved = new Set;
   thumbQueue = [];
   thumbing = 0;
+  clarity = new Map;
+  renders = new Renderer;
   sent = new Map;
   placed = new Map;
   current;
@@ -8955,7 +9270,7 @@ class Finder {
     return `${site.key}:${id}`;
   }
   origPath(site, id, ext) {
-    return join7(this.scratch, "orig", `${site.key}-${id}.${ext}`);
+    return join7(cacheDir(site), "orig", `${id}.${ext}`);
   }
   tileOf(site, post2, variants) {
     const version2 = rendition(post2) ?? post2;
@@ -9024,7 +9339,10 @@ class Finder {
     this.write("\x1B_Ga=d,d=A,q=2\x1B\\\x1B[H\x1B[J");
     stdin.setRawMode(false);
     stdin.pause();
-    rmSync4(this.scratch, { recursive: true, force: true });
+    this.saveProbes();
+    this.renders.close();
+    rmSync5(this.scratch, { recursive: true, force: true });
+    sweepCache();
     return code;
   }
   write(text) {
@@ -9085,7 +9403,7 @@ class Finder {
     this.rows = process.stdout.rows || this.rows;
     this.scroll();
     if (this.view.mode === "try" && this.current) {
-      this.present();
+      this.reveal();
     }
     this.pump();
     this.draw();
@@ -9260,9 +9578,9 @@ class Finder {
   save(changed) {
     const path2 = join7(this.home, "ttheme", "config.zsh");
     try {
-      const before = existsSync3(path2) ? readFileSync5(path2, "utf8") : "";
+      const before = existsSync3(path2) ? readFileSync6(path2, "utf8") : "";
       const after = changed.reduce((text, setting) => withSetting(text, setting.name, this.setting(setting.name)), before);
-      writeFileSync4(path2, after);
+      writeFileSync5(path2, after);
     } catch (error) {
       this.view.error = error instanceof Error ? error.message : String(error);
     }
@@ -9489,12 +9807,12 @@ class Finder {
     this.show();
     this.draw();
     const tags = this.query(site);
+    this.tally(gen, site, board, tags);
     try {
-      const [total, owners] = await Promise.all([fetchCount(site, tags, this.signal), this.mateOwners(site)]);
+      const owners = await this.mateOwners(site);
       if (gen !== this.gen) {
         return;
       }
-      board.total = total;
       const room = tagsOf(tags) + 1 <= site.tagBudget;
       board.sources = [
         ...room ? [...owners.keys()].map((owner) => ({ tags: `${tags} user:${owner}`, page: 0, done: false })) : [],
@@ -9507,6 +9825,16 @@ class Finder {
       this.fail(gen, error);
     }
   }
+  async tally(gen, site, board, tags) {
+    try {
+      const total = await fetchCount(site, tags, this.signal);
+      if (gen === this.gen) {
+        board.total = total;
+        this.show();
+        this.draw();
+      }
+    } catch {}
+  }
   fail(gen, error) {
     if (gen !== this.gen || this.signal.aborted) {
       return;
@@ -9521,6 +9849,24 @@ class Finder {
     const { perRow, rowsVis } = gridShape(this.cols, this.rows);
     return this.view.tiles.length < (this.board.top + rowsVis + LOOKAHEAD) * perRow;
   }
+  async nextPage(site, board, gen) {
+    const source = board.sources.find((s) => !s.done);
+    if (!source) {
+      return;
+    }
+    const posts = await fetchPosts(site, source.tags, source.page, this.signal);
+    if (gen !== this.gen) {
+      return;
+    }
+    source.page++;
+    source.done = posts.length < PAGE;
+    for (const post2 of posts) {
+      if (!board.seen.has(post2.id)) {
+        board.seen.add(post2.id);
+        board.queue.push(post2);
+      }
+    }
+  }
   async pump() {
     const gen = this.gen;
     const board = this.board;
@@ -9529,40 +9875,40 @@ class Finder {
     }
     this.pumping = gen;
     const site = this.site;
+    const flight = [];
+    let page;
     try {
       board.searching = true;
-      while (gen === this.gen && this.wants()) {
-        if (board.queue.length === 0) {
-          const source = board.sources.find((s) => !s.done);
-          if (!source) {
-            break;
-          }
-          const posts = await fetchPosts(site, source.tags, source.page, this.signal);
-          if (gen !== this.gen) {
-            return;
-          }
-          source.page++;
-          source.done = posts.length < PAGE;
-          for (const post2 of posts) {
-            if (!board.seen.has(post2.id)) {
-              board.seen.add(post2.id);
-              board.queue.push(post2);
+      while (gen === this.gen) {
+        while (flight.length < PROBE && board.queue.length > 0 && this.wants()) {
+          const post2 = board.queue.shift();
+          flight.push({ post: post2, passed: this.passes(site, post2) });
+        }
+        if (!page && board.queue.length < PROBE && board.sources.some((s) => !s.done) && this.wants()) {
+          const job = this.nextPage(site, board, gen).then(() => {
+            if (page === job) {
+              page = undefined;
             }
+          });
+          job.catch(() => {});
+          page = job;
+        }
+        const head = flight.shift();
+        if (!head) {
+          if (!page) {
+            break;
           }
+          await page;
           continue;
         }
-        const batch = board.queue.splice(0, WORKERS);
-        const passed = await Promise.all(batch.map((post2) => this.passes(site, post2)));
-        this.saveProbes(site);
+        const passed = await head.passed;
         if (gen !== this.gen) {
           return;
         }
-        batch.forEach((post2, i) => {
-          board.checked++;
-          if (passed[i]) {
-            this.admit(site, post2);
-          }
-        });
+        board.checked++;
+        if (passed) {
+          this.admit(site, head.post);
+        }
         this.show();
         this.draw();
       }
@@ -9574,6 +9920,7 @@ class Finder {
     } catch (error) {
       this.fail(gen, error);
     } finally {
+      this.saveProbes();
       if (this.pumping === gen) {
         this.pumping = 0;
       }
@@ -9615,10 +9962,14 @@ class Finder {
       return false;
     }
   }
-  saveProbes(site) {
-    if (this.unsaved.delete(site.key)) {
-      writeCache(site, "probes.json", this.probes(site));
+  saveProbes() {
+    for (const key of this.unsaved) {
+      const site = SITES.find((s) => s.key === key);
+      if (site) {
+        writeCache(site, "probes.json", this.probes(site));
+      }
     }
+    this.unsaved.clear();
   }
   admit(site, post2) {
     this.posts.set(this.mark(site, post2.id), post2);
@@ -9644,22 +9995,27 @@ class Finder {
     }
     const found = origins(this.home);
     const known = readCache(site, "owners.json");
-    const byPalette = new Map;
-    for (const sibling of this.catalog.palettes) {
+    const siblings = this.catalog.palettes.flatMap((sibling) => {
       const origin = found.get(sibling.name);
-      if (sibling.group !== this.entry.group || sibling.name === this.entry.name || origin?.site !== site.key) {
-        continue;
+      return sibling.group === this.entry.group && sibling.name !== this.entry.name && origin?.site === site.key ? [{ name: sibling.name, id: origin.id }] : [];
+    });
+    const asked = await Promise.all(siblings.map(async (sibling) => {
+      const owner = known[sibling.id];
+      if (owner !== undefined) {
+        return { ...sibling, owner };
       }
-      let owner = known[origin.id];
-      if (owner === undefined) {
-        try {
-          owner = (await fetchPost(site, origin.id, this.signal))?.owner ?? "";
-          known[origin.id] = owner;
-        } catch {
-          continue;
-        }
+      try {
+        return { ...sibling, owner: (await fetchPost(site, sibling.id, this.signal))?.owner ?? "" };
+      } catch {
+        return;
+      }
+    }));
+    const byPalette = new Map;
+    for (const sibling of asked) {
+      if (sibling) {
+        known[sibling.id] = sibling.owner;
+        byPalette.set(sibling.name, sibling.owner);
       }
-      byPalette.set(sibling.name, owner);
     }
     writeCache(site, "owners.json", known);
     const owners = mates(byPalette);
@@ -9668,7 +10024,7 @@ class Finder {
   }
   async cached(site, path2, url, progress2) {
     if (existsSync3(path2)) {
-      return new Uint8Array(readFileSync5(path2));
+      return statSync3(path2).size;
     }
     const running = this.inflight.get(path2);
     if (running) {
@@ -9676,9 +10032,9 @@ class Finder {
     }
     const job = (async () => {
       const bytes = await fetchBytes(site, url, this.signal, progress2);
-      mkdirSync4(dirname3(path2), { recursive: true });
-      writeFileSync4(path2, bytes);
-      return bytes;
+      mkdirSync5(dirname4(path2), { recursive: true });
+      writeFileSync5(path2, bytes);
+      return bytes.length;
     })();
     this.inflight.set(path2, job);
     try {
@@ -9688,7 +10044,7 @@ class Finder {
     }
   }
   thumbs() {
-    while (this.thumbing < WORKERS && this.thumbQueue.length > 0) {
+    while (this.thumbing < THUMB && this.thumbQueue.length > 0) {
       const { site, post: post2 } = this.thumbQueue.shift();
       this.thumbing++;
       this.thumb(site, post2).catch(() => {}).finally(() => {
@@ -9700,12 +10056,11 @@ class Finder {
   async thumb(site, post2) {
     const w = TILE.cols * this.cell.w;
     const h = TILE.rows * this.cell.h;
-    const path2 = join7(this.scratch, "tile", `${site.key}-${post2.id}-${w}x${h}.png`);
+    const path2 = join7(cacheDir(site), "tile", `${post2.id}-${w}x${h}.png`);
     if (!existsSync3(path2)) {
       const thumb = join7(cacheDir(site), "thumb", `${post2.id}.${extension(post2.preview)}`);
-      const bytes = await this.cached(site, thumb, post2.preview);
-      mkdirSync4(dirname3(path2), { recursive: true });
-      writeFileSync4(path2, encodePng(contain(decodeImage(bytes, MAX_PIXELS), w, h)));
+      await this.cached(site, thumb, post2.preview);
+      await this.renders.run({ job: "thumb", from: thumb, to: path2, width: w, height: h });
     }
     this.thumbPath.set(this.mark(site, post2.id), path2);
     this.show();
@@ -9721,8 +10076,7 @@ class Finder {
       return;
     }
     if (this.current?.id === tile.id) {
-      this.present();
-      this.draw();
+      this.reveal();
       return;
     }
     this.settle = setTimeout(() => void this.load(tile), SETTLE);
@@ -9744,9 +10098,9 @@ class Finder {
         view.fetching = { id: tile.id, got: 0, size: 0 };
         this.draw();
       }
-      const bytes = await this.cached(site, path2, version2.file, (got, size) => {
+      const size = await this.cached(site, path2, version2.file, (got, total) => {
         if (view.fetching?.id === tile.id) {
-          view.fetching = { id: tile.id, got, size };
+          view.fetching = { id: tile.id, got, size: total };
           this.draw();
         }
       });
@@ -9754,42 +10108,48 @@ class Finder {
         return;
       }
       view.fetching = undefined;
+      if (site !== this.site) {
+        return;
+      }
+      const current = { site, id: tile.id, path: path2, ext: version2.ext, size, using: "plain", failed: false };
       view.preparing = tile.id;
       this.flush();
-      await tick();
-      const image = decodeImage(bytes, MAX_PIXELS);
-      if (site !== this.site) {
+      const plain2 = await this.render(current, "plain");
+      if (control.signal.aborted || site !== this.site) {
         return;
       }
-      const current = {
-        site,
-        id: tile.id,
-        image,
-        plain: image,
-        failed: false,
-        bytes,
-        ext: version2.ext,
-        clear: transparency(image)
-      };
-      if (current.clear === 0 && canRemoveBackground() && this.setting("TTHEME_FIND_REMOVE_BG") !== "off") {
+      if (plain2.clear === 0 && canRemoveBackground() && this.setting("TTHEME_FIND_REMOVE_BG") !== "off") {
         view.preparing = undefined;
         view.cutting = tile.id;
         this.flush();
-        const cut = await this.cutOut(site, tile.id, path2, control.signal);
+        current.cut = await this.cutOut(site, tile.id, path2, control.signal);
         if (control.signal.aborted || site !== this.site) {
           return;
         }
-        if (cut) {
-          current.cut = cut;
-          current.image = cut;
-          current.clear = transparency(cut);
+        view.cutting = undefined;
+        if (current.cut) {
+          view.preparing = tile.id;
+          this.flush();
+          const made = await this.render(current, "cut").catch(() => {
+            return;
+          });
+          if (control.signal.aborted || site !== this.site) {
+            return;
+          }
+          if (made && keepable(made.clear)) {
+            current.using = "cut";
+          } else {
+            rmSync5(current.cut, { force: true });
+            current.cut = undefined;
+            current.failed = true;
+          }
         } else {
           current.failed = true;
         }
       }
       this.current = current;
       if (view.tiles[view.focus]?.id === tile.id) {
-        this.present();
+        await this.present();
       }
       this.preload();
     } catch (error) {
@@ -9810,13 +10170,16 @@ class Finder {
     }
   }
   async cutOut(site, id, path2, signal) {
-    const out = join7(this.scratch, "cut", `${site.key}-${id}.png`);
+    const out = join7(cacheDir(site), "cut", `${id}.png`);
+    if (existsSync3(out)) {
+      return out;
+    }
     try {
-      mkdirSync4(dirname3(out), { recursive: true });
-      const cut = existsSync3(out) ? decodeImage(new Uint8Array(readFileSync5(out)), MAX_PIXELS) : await removeBackground(path2, out, signal);
-      return keepable(transparency(cut)) ? cut : undefined;
+      mkdirSync5(dirname4(out), { recursive: true });
+      await removeBackground(path2, out, signal);
+      return out;
     } catch {
-      rmSync4(out, { force: true });
+      rmSync5(out, { force: true });
       return;
     }
   }
@@ -9825,10 +10188,8 @@ class Finder {
     if (!current?.cut || this.view.shown?.id !== current.id) {
       return;
     }
-    current.image = current.image === current.cut ? current.plain : current.cut;
-    current.clear = transparency(current.image);
-    this.present();
-    this.draw();
+    current.using = current.using === "cut" ? "plain" : "cut";
+    this.reveal();
   }
   preload() {
     const view = this.view;
@@ -9847,30 +10208,65 @@ class Finder {
         continue;
       }
       const path2 = this.origPath(site, post2.id, version2.ext);
-      if (existsSync3(path2)) {
-        continue;
-      }
       this.prefetching++;
-      this.cached(site, path2, version2.file).catch(() => {}).finally(() => {
+      this.cached(site, path2, version2.file).then(() => this.render({ site, id: post2.id, path: path2, ext: version2.ext, size: 0, using: "plain", failed: false }, "plain")).catch(() => {}).finally(() => {
         this.prefetching--;
       });
     }
   }
-  present() {
-    const current = this.current;
-    if (!current) {
-      return;
-    }
+  async render(current, using) {
     const W = this.cols * this.cell.w;
     const H = this.rows * this.cell.h;
     const width2 = Math.min(W, TRY_WIDTH);
     const height = Math.max(1, Math.round(H * width2 / W));
-    const cut = current.cut ? current.image === current.cut ? "on" : "off" : current.failed ? "failed" : "none";
-    const path2 = join7(this.scratch, `${current.id}${cut === "on" ? "c" : ""}-${width2}x${height}.png`);
-    if (!existsSync3(path2)) {
-      writeFileSync4(path2, encodePng(tryOn(current.image, this.entry, this.tone, width2, height)));
+    const path2 = join7(this.scratch, `${current.site.key}-${current.id}${using === "cut" ? "c" : ""}-${width2}x${height}.png`);
+    const key = `${current.site.key}:${current.id}:${using}`;
+    const known = this.clarity.get(key);
+    if (known !== undefined && existsSync3(path2)) {
+      return { clear: known, path: path2 };
+    }
+    const clear = await this.renders.run({
+      job: "show",
+      from: using === "cut" ? current.cut : current.path,
+      to: path2,
+      width: width2,
+      height,
+      colors: this.entry,
+      tone: this.tone
+    });
+    this.clarity.set(key, clear);
+    return { clear, path: path2 };
+  }
+  async present() {
+    const current = this.current;
+    if (!current) {
+      return;
+    }
+    const using = current.using;
+    const { clear, path: path2 } = await this.render(current, using);
+    if (this.current !== current || current.using !== using) {
+      return;
     }
-    this.view.shown = { id: current.id, clear: current.clear, bytes: current.bytes.length, path: path2, cut };
+    this.view.shown = {
+      id: current.id,
+      clear,
+      bytes: current.size,
+      path: path2,
+      cut: current.cut ? using === "cut" ? "on" : "off" : current.failed ? "failed" : "none"
+    };
+  }
+  reveal() {
+    const view = this.view;
+    view.preparing = this.current?.id;
+    this.flush();
+    this.present().catch((error) => {
+      view.error = error instanceof Error ? error.message : String(error);
+    }).finally(() => {
+      if (view.preparing === this.current?.id) {
+        view.preparing = undefined;
+      }
+      this.draw();
+    });
   }
   async install() {
     const view = this.view;
@@ -9882,15 +10278,24 @@ class Finder {
     view.installing = tile.id;
     view.error = undefined;
     this.flush();
-    await tick();
     try {
-      installBackdrop(this.home, this.entry, this.tone, current.image, {
-        site: current.site.key,
-        id: current.id,
-        ext: current.ext,
-        bytes: current.bytes,
-        from: `${current.site.name} ${current.id} ${current.site.pageUrl(current.id)}`
+      await this.renders.run({
+        job: "backdrop",
+        from: current.using === "cut" ? current.cut : current.path,
+        source: current.path,
+        home: this.home,
+        colors: this.entry,
+        tone: this.tone,
+        origin: {
+          site: current.site.key,
+          id: current.id,
+          ext: current.ext,
+          from: `${current.site.name} ${current.id} ${current.site.pageUrl(current.id)}`
+        }
       });
+      const known = readCache(current.site, "owners.json");
+      known[current.id] = this.posts.get(this.mark(current.site, current.id))?.owner ?? "";
+      writeCache(current.site, "owners.json", known);
       process.stderr.write(`background · ${this.entry.name} ← ${current.site.name} ${current.id}
 `);
       this.finish(0);
@@ -9981,19 +10386,38 @@ async function runFind(name) {
   return new Finder(home, catalog, entry, entry.booru ?? "").run();
 }
 
+// src/images.ts
+function runImage(name, action) {
+  const home = configHome();
+  find2(readCatalog(home).palettes, name);
+  if (action === "next" || action === "prev") {
+    const { key, at: at2, of } = switchImage(home, name, action === "next" ? 1 : -1);
+    process.stderr.write(`background · ${name} ${at2}/${of} ${key}
+`);
+    return 0;
+  }
+  if (action === "drop") {
+    const { key, left } = dropImage(home, name);
+    process.stderr.write(`background · ${name} removed ${key ?? "the picture"} · ${left} left
+`);
+    return 0;
+  }
+  throw new Error(`unknown image action ${action} — next, prev or drop`);
+}
+
 // src/init.ts
 import {
   chmodSync,
   copyFileSync,
   existsSync as existsSync5,
-  mkdirSync as mkdirSync5,
-  readdirSync as readdirSync3,
-  readFileSync as readFileSync6,
-  rmSync as rmSync5,
-  writeFileSync as writeFileSync5
+  mkdirSync as mkdirSync6,
+  readdirSync as readdirSync4,
+  readFileSync as readFileSync7,
+  rmSync as rmSync6,
+  writeFileSync as writeFileSync6
 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { dirname as dirname4, join as join8 } from "node:path";
+import { dirname as dirname5, join as join8 } from "node:path";
 
 // node_modules/@clack/core/dist/index.mjs
 import { styleText } from "node:util";
@@ -11932,12 +12356,12 @@ async function runBrowse() {
 
 // src/init.ts
 function copyDir(copies, from, to) {
-  for (const f2 of readdirSync3(from)) {
+  for (const f2 of readdirSync4(from)) {
     copies.push({ from: join8(from, f2), to: join8(to, f2) });
   }
 }
 function loadManifest(root2) {
-  return JSON.parse(readFileSync6(join8(root2, "dist", "manifest.json"), "utf8"));
+  return JSON.parse(readFileSync7(join8(root2, "dist", "manifest.json"), "utf8"));
 }
 function planInit(opts, paths) {
   const dist = join8(paths.root, "dist");
@@ -11953,7 +12377,7 @@ function planInit(opts, paths) {
   const configPath = join8(home, "config.zsh");
   const settings2 = {
     file: configPath,
-    content: configFile(existsSync5(configPath) ? readFileSync6(configPath, "utf8") : "")
+    content: configFile(existsSync5(configPath) ? readFileSync7(configPath, "utf8") : "")
   };
   const notes = [];
   if (opts.terminals.includes("ghostty")) {
@@ -11961,7 +12385,7 @@ function planInit(opts, paths) {
   }
   if (opts.terminals.includes("alacritty")) {
     const config = join8(paths.configHome, "alacritty", "alacritty.toml");
-    if (existsSync5(config) && !readFileSync6(config, "utf8").includes("# ttheme begin")) {
+    if (existsSync5(config) && !readFileSync7(config, "utf8").includes("# ttheme begin")) {
       notes.push("alacritty.toml already exists — ttheme left it alone; add its themes/ import yourself");
     }
   }
@@ -11971,23 +12395,23 @@ function planInit(opts, paths) {
 }
 function applyInit(plan) {
   for (const c2 of plan.copies) {
-    mkdirSync5(dirname4(c2.to), { recursive: true });
-    rmSync5(c2.to, { force: true });
+    mkdirSync6(dirname5(c2.to), { recursive: true });
+    rmSync6(c2.to, { force: true });
     copyFileSync(c2.from, c2.to);
     if (c2.executable) {
       chmodSync(c2.to, 493);
     }
   }
-  mkdirSync5(dirname4(plan.settings.file), { recursive: true });
-  writeFileSync5(plan.settings.file, plan.settings.content);
-  const configHome2 = dirname4(dirname4(plan.settings.file));
+  mkdirSync6(dirname5(plan.settings.file), { recursive: true });
+  writeFileSync6(plan.settings.file, plan.settings.content);
+  const configHome2 = dirname5(dirname5(plan.settings.file));
   writeCatalog(configHome2, plan.catalog);
   writeInstalled(configHome2, plan.installed);
   sync(configHome2, plan.catalog, plan.installed);
   for (const e of plan.edits) {
-    mkdirSync5(dirname4(e.file), { recursive: true });
-    const current = existsSync5(e.file) ? readFileSync6(e.file, "utf8") : "";
-    writeFileSync5(e.file, upsertBlock(current, e.block));
+    mkdirSync6(dirname5(e.file), { recursive: true });
+    const current = existsSync5(e.file) ? readFileSync7(e.file, "utf8") : "";
+    writeFileSync6(e.file, upsertBlock(current, e.block));
   }
 }
 function accepted(value) {
@@ -12009,7 +12433,7 @@ function verify(plan) {
   const missing = [
     ...plan.copies.filter((c2) => !existsSync5(c2.to)).map((c2) => c2.to),
     ...existsSync5(plan.settings.file) ? [] : [plan.settings.file],
-    ...plan.edits.filter((e) => !readFileSync6(e.file, "utf8").includes("# ttheme begin")).map((e) => e.file)
+    ...plan.edits.filter((e) => !readFileSync7(e.file, "utf8").includes("# ttheme begin")).map((e) => e.file)
   ];
   if (missing.length > 0) {
     throw new Error(`init left gaps:
@@ -12134,6 +12558,9 @@ function createProgram() {
   program2.command("find", { hidden: true }).argument("<palette>").description("pick a safebooru background for a palette — preview opens this on tab").action(async (name) => {
     process.exitCode = await runFind(name);
   });
+  program2.command("image", { hidden: true }).argument("<palette>").argument("<action>", "next, prev or drop").description("switch a palette between its saved backgrounds, or remove the one shown — preview calls this").action((name, action) => {
+    process.exitCode = runImage(name, action);
+  });
   program2.command("update").description("refresh the catalog from the registry").action(() => runUpdate());
   return program2;
 }
@@ -12152,4 +12579,6 @@ ${error instanceof Error ? error.message : String(error)}`);
 }
 
 // src/bin.ts
-process.exitCode = await runCli(process.argv);
+if (isMainThread2) {
+  process.exitCode = await runCli(process.argv);
+}

package/dist/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.3",
+  "version": "0.1.4",
   "gate": [
     {
       "rule": "foreground",

package/dist/shell/palettes.zsh

@@ -1,7 +1,7 @@
 # Generated by `mise run build` — do not edit.
 # Source of truth: themes/*.toml in the ttheme repo.
 
-typeset -g TTHEME_VERSION=0.1.3
+typeset -g TTHEME_VERSION=0.1.4
 
 # seed for `ttheme config` when no config.zsh exists yet
 typeset -g TTHEME_CONFIG_TEMPLATE='# ttheme settings — exported variables win over this file

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kecan0406/ttheme",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "type": "module",
   "bin": {
     "ttheme": "bin/ttheme.js"

package/shell/adapters/_osc.zsh

@@ -30,6 +30,10 @@ __tt_pv_bg_findable() { return 1 }
 
 __tt_pv_bg_find() { return 1 }
 
+__tt_pv_bg_images() { REPLY=1 }
+
+__tt_pv_bg_image() { : }
+
 __tt_pv_bg_panel() { : }
 
 __tt_pv_bg_close() { : }

package/shell/adapters/ghostty.zsh

@@ -420,6 +420,32 @@ __tt_pv_bg_find() {
   return 0
 }
 
+__tt_pv_bg_images() {
+  local -a shelf=(${TTHEME_CONFIG:h}/backgrounds/shelf/$1/*(N/))
+  REPLY=$(( ${#shelf} + 1 ))
+}
+
+__tt_pv_bg_image() {
+  local name=$tune act=$1 err REPLY
+  local -i rc
+  if [[ $act != drop ]]; then
+    __tt_pv_bg_images $name
+    (( REPLY > 1 )) || { msg="$name has one image" msgt=200; return 0 }
+  fi
+  __tt_pv_untune
+  __tt_pv_bg_close
+  err=$(__tt_cli image $name $act 2>&1)
+  rc=$?
+  err=${${err//$'\n'/ }## #}
+  resized=1 bgname="" bgshown="" bgsent=() bgdim=()
+  unset "bgsrc[$name]"
+  __tt_bg_load $name
+  bgload[$name]="" bgedit[$name]=1
+  msg=${err:-"background · $name"} msgt=$(( rc ? 300 : 200 ))
+  [[ -r ${TTHEME_CONFIG:h}/backgrounds/$name.conf ]] || return 0
+  tune=$name tf=1 tsnap="${bgsize[$name]} ${bgpos[$name]} ${bgop[$name]} ${bgoff[$name]}"
+}
+
 __tt_pv_bg_panel() {
   local name=$1 z=$'\e[0m' b=$'\e[1m' d=$'\e[2m' c=$ac val sty REPLY
   local -a labs=(size position opacity) at=(0 3 6)

package/shell/ttheme.zsh

@@ -618,6 +618,8 @@ __tt_pv_foot() {
     kk+=(space '=' enter)
     if (( bgoff[$tune] )); then kl+=(show default keep); else kl+=(hide default keep); fi
     __tt_pv_bg_findable $tune && { kk+=(f); kl+=(find) }
+    __tt_pv_bg_images $tune
+    (( REPLY > 1 )) && { kk+=(', .' D); kl+=("image ×$REPLY" remove) }
     right=$b"esc"$z$d" undo"$z
   elif (( conf )); then
     badge=CONFIG kk=(↑↓ ←→ enter) kl=(setting value save)
@@ -700,8 +702,8 @@ __tt_pv_help() {
     "enter  ·  esc restores $back"
   )
   if (( bgcw )); then
-    hk+=("tune bg" "" "" "")
-    hv+=("tab  ·  finds one on the boorus if none" "↑↓ field  ←→ step  ⇧←→ ×10  1-9 place" "space hides  ·  = default  ·  f replaces" "enter keeps  ·  esc undoes")
+    hk+=("tune bg" "" "" "" "")
+    hv+=("tab  ·  finds one on the boorus if none" "↑↓ field  ←→ step  ⇧←→ ×10  1-9 place" "space hides  ·  = default  ·  f adds one" "enter keeps  ·  esc undoes" ",  .  other saved images  ·  D removes this one")
   fi
   hk+=(config "")
   hv+=("alt-c  ·  ↑↓ setting  ←→ value" "enter saves  ·  esc undoes")
@@ -782,6 +784,9 @@ __tt_pv_tune() {
       ;;
     ' ') __tt_pv_bg_adjust on ;;
     '=') __tt_pv_bg_adjust def ;;
+    ',') __tt_pv_bg_image prev ;;
+    '.') __tt_pv_bg_image next ;;
+    D) __tt_pv_bg_image drop ;;
     f)
       __tt_pv_bg_findable $tune || return 0
       name=$tune