@kecan0406/ttheme 0.1.2 → 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.2",
+  version: "0.1.4",
   type: "module",
   bin: {
     ttheme: "bin/ttheme.js"
@@ -6804,6 +6807,42 @@ var CONFIG_SETTINGS = {
   TTHEME_SORT: {
     doc: "# series and palettes in ttheme and preview: abc sorts them by name, series keeps the order they were added (default abc)",
     default: "abc"
+  },
+  TTHEME_FIND_RATING: {
+    doc: "# the ratings find lists, any of safe, questionable and explicit, each booru read in its own rating vocabulary (default safe)",
+    default: "safe"
+  },
+  TTHEME_FIND_BLOCK: {
+    doc: '# the posts find drops by tag: nudity, underwear, both, or none to keep them all (default "nudity underwear")',
+    default: "nudity underwear"
+  },
+  TTHEME_FIND_POSTS: {
+    doc: "# what find lists first: all is every post of the character, cutouts are the transparent ones (default all)",
+    default: "all"
+  },
+  TTHEME_FIND_CUTOUTS: {
+    doc: '# the tags find calls a transparent cutout, per site as key=tag,tag pairs — e.g. "safebooru=transparent_background yande=transparent_png,vector" (default the built-in tags)',
+    default: ""
+  },
+  TTHEME_FIND_ORDER: {
+    doc: "# the order find lists posts in: newest or score (default newest)",
+    default: "newest"
+  },
+  TTHEME_FIND_SETS: {
+    doc: "# runs of the same picture at the same size from one uploader: fold shows them as one tile, show lists each (default fold)",
+    default: "fold"
+  },
+  TTHEME_FIND_REMOVE_BG: {
+    doc: "# an opaque picture tried on in find: on cuts the character out with macOS Vision, off leaves it as it is (default on)",
+    default: "on"
+  },
+  TTHEME_FIND_UNBLOCK: {
+    doc: "# when a network blocks a booru by name, 1 sends find through a local proxy that splits the TLS handshake (default 0)",
+    default: "0"
+  },
+  TTHEME_FIND_HOSTS: {
+    doc: '# send a find site somewhere else, as key=https://host pairs — e.g. "konachan=https://konachan.com danbooru=https://danbooru.donmai.us" (default none)',
+    default: ""
   }
 };
 function settingLine(name, value) {
@@ -6831,6 +6870,17 @@ ${settingLine(name, s.default)}`);
 `)}
 `;
 }
+function withSetting(content, name, value) {
+  const line = settingLine(name, value);
+  const pattern = settingPattern(name);
+  if (pattern.test(content)) {
+    return content.replace(pattern, line);
+  }
+  return `${content.replace(/\n*$/, `
+`)}
+${line}
+`;
+}
 function configFile(content) {
   if (content === "") {
     return configTemplate();
@@ -6848,7 +6898,7 @@ import = ["${themePath}"]` : "";
 // src/emit/shell.ts
 function palettesZsh(palettes) {
   for (const p of palettes) {
-    for (const field of [p.name, p.group, p.native ?? "", p.ansiSource, p.booru ?? ""]) {
+    for (const field of [p.name, p.group, p.native ?? "", p.ansiSource]) {
       if (/["$`\\]/.test(field)) {
         throw new Error(`${p.name}: "${field}" contains a character that breaks zsh quoting`);
       }
@@ -6890,11 +6940,6 @@ function palettesZsh(palettes) {
     "typeset -gA TTHEME_SRC=(",
     ...palettes.map((p) => entry(p, p.ansiSource)),
     ")",
-    "",
-    "# the safebooru tag preview searches when a palette has no background yet",
-    "typeset -gA TTHEME_BOORU=(",
-    ...palettes.filter((p) => p.booru).map((p) => entry(p, p.booru ?? "")),
-    ")",
     ""
   ].join(`
 `);
@@ -6999,12 +7044,13 @@ ${themes.length} themes (${rotation(themes).length} in the new-tab rotation) ->
 }
 
 // src/find.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync4, mkdtempSync, readFileSync as readFileSync4, rmSync as rmSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { spawn as spawn2 } from "node:child_process";
+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
@@ -7023,12 +7069,21 @@ function decodePng(bytes) {
   const png = import_pngjs.PNG.sync.read(Buffer.from(bytes));
   return { width: png.width, height: png.height, data: new Uint8Array(png.data) };
 }
-function decodeImage(bytes) {
+function decodeImage(bytes, limit) {
   if (isPng(bytes)) {
+    const head = pngHead(bytes);
+    if (head && head.width * head.height > limit) {
+      throw new Error(`${head.width}×${head.height} is over ${limit / 1e6} megapixels`);
+    }
     return decodePng(bytes);
   }
   if (bytes[0] === 255 && bytes[1] === 216) {
-    const jpeg = import_jpeg_js.decode(bytes, { useTArray: true, formatAsRGBA: true, maxMemoryUsageInMB: 1024 });
+    const jpeg = import_jpeg_js.decode(bytes, {
+      useTArray: true,
+      formatAsRGBA: true,
+      maxResolutionInMP: limit / 1e6,
+      maxMemoryUsageInMB: 1024
+    });
     return { width: jpeg.width, height: jpeg.height, data: jpeg.data };
   }
   throw new Error("not a PNG or JPEG image");
@@ -7060,9 +7115,8 @@ function pngHead(bytes) {
   if (bytes[25] === 4 || bytes[25] === 6) {
     return { width, height, alpha: true };
   }
-  const trns = find(bytes, "tRNS");
   const idat = find(bytes, "IDAT");
-  return { width, height, alpha: trns !== -1 && (idat === -1 || trns < idat) };
+  return { width, height, alpha: find(idat === -1 ? bytes : bytes.subarray(0, idat), "tRNS") !== -1 };
 }
 function alphaBox(image, threshold = CLEAR) {
   let x0 = image.width;
@@ -7180,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);
@@ -7270,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 };
@@ -7291,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",
@@ -7322,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);
@@ -7355,23 +7575,49 @@ 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 SAFE = new Set(["safe", "general", "s", "g"]);
+var MAX_PIXELS = 25000000;
+var CACHE_BYTES = 512 * 1024 * 1024;
+var RATINGS = ["safe", "questionable", "explicit"];
+var BLOCKS = ["nudity", "underwear"];
+var EXPOSED = {
+  nudity: new Set(["nude", "naked", "topless", "bottomless", "nipples", "naked_towel", "undressing"]),
+  underwear: new Set(["underwear", "panties", "pantsu", "bra", "lingerie", "pantyshot"])
+};
+var MOEBOORU = { safe: "s", questionable: "q", explicit: "e" };
 var MIRRORS = new Set(["danbooru", "gelbooru", "konachan", "yande.re", "sankaku"]);
 var HEAD = 8191;
 var TIMEOUT = 20000;
+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;
 }
@@ -7384,26 +7630,45 @@ function records(text) {
     return [];
   }
   const raw = JSON.parse(body);
-  return Array.isArray(raw) ? raw : [];
+  if (Array.isArray(raw)) {
+    return raw;
+  }
+  const posts = raw.posts;
+  return Array.isArray(posts) ? posts : [];
+}
+function tagTypes(text) {
+  const body = text.trim();
+  const raw = body ? JSON.parse(body) : {};
+  const tags = raw.tags ?? {};
+  return new Map(Object.entries(tags).map(([name, type]) => [name, String(type)]));
 }
-function post(p, file, ext, owner, md5) {
-  const preview = absolute(String(p.preview_url ?? ""));
-  if (!file || !preview || !Number(p.id)) {
+function version(url, width, height) {
+  const file = absolute(String(url ?? ""));
+  return { file, width: Number(width) || 0, height: Number(height) || 0, ext: extension(file) };
+}
+function post(p, raw) {
+  const preview = absolute(String(raw.preview ?? ""));
+  if (!raw.file || !preview || !Number(p.id)) {
     return [];
   }
+  const width = Number(p.width ?? p.image_width) || 0;
+  const height = Number(p.height ?? p.image_height) || 0;
   return [
     {
       id: Number(p.id),
-      width: Number(p.width) || 0,
-      height: Number(p.height) || 0,
-      file,
+      width,
+      height,
+      file: raw.file,
       preview,
-      ext,
-      owner: String(owner ?? ""),
+      ext: raw.ext,
+      owner: String(raw.owner ?? ""),
+      artist: raw.artist,
+      score: Number(p.score) || 0,
       rating: String(p.rating ?? ""),
-      md5: String(md5 ?? ""),
+      md5: String(raw.md5 ?? ""),
       source: String(p.source ?? ""),
-      tags: String(p.tags ?? "").split(/\s+/).filter(Boolean)
+      tags: raw.tags.split(/\s+/).filter(Boolean),
+      smaller: raw.versions.filter((v) => v.file && v.width > 0 && v.height > 0 && v.width * v.height < width * height)
     }
   ];
 }
@@ -7411,54 +7676,239 @@ function parseGelbooru(text, origin = "https://safebooru.org") {
   return records(text).flatMap((p) => {
     const stored = p.directory && p.image ? `${origin}/images/${p.directory}/${p.image}` : "";
     const file = absolute(String(p.file_url || stored));
-    return post(p, file, extension(file), p.owner, p.hash ?? p.md5);
+    return post(p, {
+      preview: p.preview_url,
+      file,
+      ext: extension(file),
+      owner: p.owner,
+      artist: "",
+      md5: p.hash ?? p.md5,
+      tags: String(p.tags ?? ""),
+      versions: [version(p.sample_url, p.sample_width, p.sample_height)]
+    });
   });
 }
 function parseMoebooru(text) {
+  const types = tagTypes(text);
+  return records(text).flatMap((p) => {
+    const file = absolute(String(p.file_url ?? ""));
+    const tags = String(p.tags ?? "");
+    return post(p, {
+      preview: p.preview_url,
+      file,
+      ext: String(p.file_ext || extension(file)).toLowerCase(),
+      owner: p.author,
+      artist: tags.split(/\s+/).find((tag) => types.get(tag) === "artist") ?? "",
+      md5: p.md5,
+      tags,
+      versions: [
+        version(p.jpeg_url, p.jpeg_width, p.jpeg_height),
+        version(p.sample_url, p.sample_width, p.sample_height)
+      ]
+    });
+  });
+}
+function parseDanbooru(text) {
   return records(text).flatMap((p) => {
     const file = absolute(String(p.file_url ?? ""));
-    return post(p, file, String(p.file_ext || extension(file)).toLowerCase(), p.author, p.md5);
+    const asset = p.media_asset ?? {};
+    return post(p, {
+      preview: p.preview_file_url,
+      file,
+      ext: String(p.file_ext || extension(file)).toLowerCase(),
+      owner: "",
+      artist: String(p.tag_string_artist ?? "").split(/\s+/)[0] ?? "",
+      md5: p.md5,
+      tags: String(p.tag_string ?? ""),
+      versions: (asset.variants ?? []).map((v) => version(v.url, v.width, v.height)).filter((v) => v.ext === "jpg" || v.ext === "png").sort((a, b) => b.width * b.height - a.width * a.height)
+    });
   });
 }
 function parseCount(xml) {
   return Number(/count="(\d+)"/.exec(xml)?.[1] ?? 0);
 }
-function gelbooru(key, name, origin, cutouts, vouched, ansi) {
-  const api = (params) => `${origin}/index.php?${new URLSearchParams({ page: "dapi", s: "post", q: "index", ...params })}`;
+function parseCounts(text) {
+  const raw = text.trim() ? JSON.parse(text) : {};
+  return Number(raw.counts?.posts) || 0;
+}
+function cutoutMap(spec) {
+  const cutouts = new Map;
+  for (const entry of (spec ?? "").split(/\s+/).filter(Boolean)) {
+    const at2 = entry.indexOf("=");
+    if (at2 > 0) {
+      cutouts.set(entry.slice(0, at2), entry.slice(at2 + 1).split(",").filter(Boolean));
+    }
+  }
+  return cutouts;
+}
+function hostMap(spec) {
+  const hosts = new Map;
+  for (const entry of (spec ?? "").split(/[\s,]+/).filter(Boolean)) {
+    const at2 = entry.indexOf("=");
+    const key = entry.slice(0, at2);
+    try {
+      const url = new URL(entry.slice(at2 + 1));
+      if (key && url.protocol === "https:") {
+        hosts.set(key, url.origin);
+      }
+    } catch {}
+  }
+  return hosts;
+}
+function chosen(value, all, fallback, none) {
+  const words = (value ?? "").split(/\s+/);
+  if (none !== undefined && words.includes(none)) {
+    return [];
+  }
+  const picked = all.filter((item) => words.includes(item));
+  return picked.length > 0 ? picked : [...fallback];
+}
+function ratingSet(value) {
+  return chosen(value, RATINGS, ["safe"]);
+}
+function blockSet(value) {
+  return chosen(value, BLOCKS, BLOCKS, "none");
+}
+function tiers(safe, questionable, explicit) {
+  return { safe: new Set(safe), questionable: new Set(questionable), explicit: new Set(explicit) };
+}
+function based(spec) {
+  const origin = HOSTS.get(spec.key);
+  const cutouts = CUTOUTS.get(spec.key);
   return {
-    key,
-    name,
-    origin,
-    cutouts,
-    vouched,
-    ansi,
+    ...spec,
+    origin: origin ?? spec.origin,
+    moved: origin !== undefined && origin !== spec.origin,
+    cutouts: cutouts ?? spec.cutouts,
+    vouched: spec.vouched && cutouts === undefined
+  };
+}
+function anyOf(tags, grouped) {
+  if (tags.length < 2) {
+    return tags.join("");
+  }
+  return grouped ? `( ${tags.join(" ~ ")} )` : tags.map((tag) => `~${tag}`).join(" ");
+}
+function gelbooru(raw) {
+  const spec = based(raw);
+  const api = (params) => `${spec.origin}/index.php?${new URLSearchParams({ page: "dapi", s: "post", q: "index", ...params })}`;
+  return {
+    ...spec,
+    cutouts: anyOf(spec.cutouts, true),
+    ratings: tiers(["safe", "general"], ["questionable"], ["explicit"]),
+    rate: () => "",
+    best: "sort:score:desc",
+    tagBudget: Number.POSITIVE_INFINITY,
     postsUrl: (tags, page) => api({ json: "1", limit: String(PAGE), pid: String(page), tags }),
     countUrl: (tags) => api({ limit: "0", tags }),
     postUrl: (id) => api({ json: "1", id: String(id) }),
-    pageUrl: (id) => `${origin}/index.php?page=post&s=view&id=${id}`,
-    parse: (text) => parseGelbooru(text, origin)
+    pageUrl: (id) => `${spec.origin}/index.php?page=post&s=view&id=${id}`,
+    parse: (text) => parseGelbooru(text, spec.origin),
+    count: parseCount
   };
 }
-function moebooru(key, name, origin, cutouts, vouched, ansi) {
-  const safe = (tags) => `${tags} rating:s`;
+function moebooru(raw) {
+  const spec = based(raw);
+  const params = (rest) => new URLSearchParams({ api_version: "2", include_tags: "1", ...rest });
   return {
-    key,
-    name,
-    origin,
-    cutouts,
-    vouched,
-    ansi,
-    postsUrl: (tags, page) => `${origin}/post.json?${new URLSearchParams({ limit: String(PAGE), page: String(page + 1), tags: safe(tags) })}`,
-    countUrl: (tags) => `${origin}/post.xml?${new URLSearchParams({ limit: "1", tags: safe(tags) })}`,
-    postUrl: (id) => `${origin}/post.json?${new URLSearchParams({ tags: `id:${id}` })}`,
-    pageUrl: (id) => `${origin}/post/show/${id}`,
-    parse: parseMoebooru
+    ...spec,
+    cutouts: anyOf(spec.cutouts, false),
+    ratings: tiers([MOEBOORU.safe], [MOEBOORU.questionable], [MOEBOORU.explicit]),
+    rate: (levels) => {
+      const [only] = levels;
+      if (levels.length === 1 && only) {
+        return `rating:${MOEBOORU[only]}`;
+      }
+      const missing = RATINGS.filter((level) => !levels.includes(level));
+      const [left] = missing;
+      return missing.length === 1 && left ? `-rating:${MOEBOORU[left]}` : "";
+    },
+    best: "order:score",
+    tagBudget: Number.POSITIVE_INFINITY,
+    postsUrl: (tags, page) => `${spec.origin}/post.json?${params({ limit: String(PAGE), page: String(page + 1), tags })}`,
+    countUrl: (tags) => `${spec.origin}/post.xml?${new URLSearchParams({ limit: "1", tags })}`,
+    postUrl: (id) => `${spec.origin}/post.json?${params({ tags: `id:${id}` })}`,
+    pageUrl: (id) => `${spec.origin}/post/show/${id}`,
+    parse: parseMoebooru,
+    count: parseCount
+  };
+}
+function danbooru(raw) {
+  const spec = based(raw);
+  return {
+    ...spec,
+    cutouts: anyOf(spec.cutouts, false),
+    ratings: tiers(["g"], ["s", "q"], ["e"]),
+    rate: () => "",
+    best: "order:score",
+    tagBudget: 2,
+    postsUrl: (tags, page) => `${spec.origin}/posts.json?${new URLSearchParams({ limit: String(PAGE), page: String(page + 1), tags })}`,
+    countUrl: (tags) => `${spec.origin}/counts/posts.json?${new URLSearchParams({ tags })}`,
+    postUrl: (id) => `${spec.origin}/posts.json?${new URLSearchParams({ limit: "1", tags: `id:${id}` })}`,
+    pageUrl: (id) => `${spec.origin}/posts/${id}`,
+    parse: parseDanbooru,
+    count: parseCounts
   };
 }
+function siteNamed(name) {
+  return SITES.find((site) => site.key === name || site.name === name || new URL(site.origin).host === name);
+}
+function tagsOf(query) {
+  return query.split(/\s+/).filter(Boolean).length;
+}
+function postRef(text, fallback) {
+  const query = text.trim();
+  if (/^\d+$/.test(query)) {
+    return { site: fallback, id: Number(query) };
+  }
+  const named = /^([\w.]+):(\d+)$/.exec(query);
+  if (named) {
+    const site2 = SITES.find((s) => s.key === named[1] || s.name === named[1]);
+    return site2 && { site: site2, id: Number(named[2]) };
+  }
+  let url;
+  try {
+    url = new URL(query);
+  } catch {
+    return;
+  }
+  const site = siteNamed(url.host);
+  const id = Number(url.searchParams.get("id") ?? url.pathname.split("/").filter(Boolean).at(-1));
+  return site && id > 0 ? { site, id } : undefined;
+}
 var SITES = [
-  gelbooru("safebooru", "safebooru", "https://safebooru.org", "( transparent_background ~ vector_trace )", false, 4),
-  moebooru("yande", "yande.re", "https://yande.re", "transparent_png", true, 5),
-  moebooru("konachan", "konachan", "https://konachan.net", "~transparent ~vector", false, 6)
+  gelbooru({
+    key: "safebooru",
+    name: "safebooru",
+    origin: "https://safebooru.org",
+    cutouts: ["transparent_background", "vector_trace"],
+    vouched: false,
+    ansi: 4
+  }),
+  moebooru({
+    key: "yande",
+    name: "yande.re",
+    origin: "https://yande.re",
+    cutouts: ["transparent_png"],
+    vouched: true,
+    ansi: 5
+  }),
+  moebooru({
+    key: "konachan",
+    name: "konachan",
+    origin: "https://konachan.net",
+    cutouts: ["transparent", "vector"],
+    vouched: false,
+    ansi: 6
+  }),
+  danbooru({
+    key: "danbooru",
+    name: "danbooru",
+    origin: "https://safebooru.donmai.us",
+    cutouts: ["transparent_background"],
+    vouched: false,
+    ansi: 2
+  })
 ];
 function originHost(source) {
   let host;
@@ -7469,8 +7919,17 @@ function originHost(source) {
   }
   return host.split(".").slice(-2).join(".");
 }
-function safe(post2) {
-  return SAFE.has(post2.rating);
+function exposed(post2, blocks = BLOCKS) {
+  return post2.tags.filter((tag) => blocks.some((block2) => EXPOSED[block2].has(tag)));
+}
+function rated(site, post2, levels = ["safe"]) {
+  return levels.some((level) => site.ratings[level].has(post2.rating));
+}
+function rendition(post2) {
+  return [post2, ...post2.smaller].find((v) => v.width * v.height <= MAX_PIXELS);
+}
+function mirrored(owner) {
+  return MIRRORS.has(owner);
 }
 function mates(owners) {
   const byOwner = new Map;
@@ -7482,24 +7941,83 @@ 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)) {
+    return Number(value) * 1000;
+  }
+  const at2 = value === null ? Number.NaN : Date.parse(value);
+  return Number.isNaN(at2) ? MAX_WAIT : Math.max(0, at2 - now);
+}
+function pausedUntil(site) {
+  return paused.get(site.key) ?? 0;
+}
+function challenged(response) {
+  return (response.headers.get("server") ?? "").startsWith("cloudflare") && response.headers.get("cf-mitigated") === "challenge";
 }
 async function get(site, url, signal, headers = {}, timeout = TIMEOUT) {
-  const response = await fetch(url, {
-    headers: { "User-Agent": AGENT, Referer: `${site.origin}/`, ...headers },
-    signal: timeout ? AbortSignal.any([signal, AbortSignal.timeout(timeout)]) : signal
-  });
-  if (!response.ok) {
-    throw new Error(`${site.name} answered ${response.status}`);
+  for (let tries = 1;; tries++) {
+    const wait = pausedUntil(site) - Date.now();
+    if (wait > 0) {
+      await sleep(wait, undefined, { signal });
+    }
+    const response = await fetch(url, {
+      headers: { "User-Agent": AGENT, Referer: `${site.origin}/`, ...headers },
+      signal: timeout ? AbortSignal.any([signal, AbortSignal.timeout(timeout)]) : signal
+    });
+    if (response.status === 429 && tries < TRIES) {
+      await response.body?.cancel();
+      const delay = retryAfter(response.headers.get("retry-after"), Date.now());
+      if (delay > MAX_WAIT) {
+        throw new Error(`${site.name} asks to wait ${Math.ceil(delay / 1000)}s`);
+      }
+      paused.set(site.key, Math.max(pausedUntil(site), Date.now() + delay));
+      continue;
+    }
+    if (!response.ok) {
+      await response.body?.cancel();
+      throw new Error(challenged(response) ? `${site.name} is behind a Cloudflare challenge` : `${site.name} answered ${response.status}`);
+    }
+    return response;
   }
-  return response;
 }
 async function fetchPosts(site, tags, page, signal) {
   return site.parse(await (await get(site, site.postsUrl(tags, page), signal)).text());
 }
 async function fetchCount(site, tags, signal) {
-  return parseCount(await (await get(site, site.countUrl(tags), signal)).text());
+  return site.count(await (await get(site, site.countUrl(tags), signal)).text());
 }
 async function fetchPost(site, id, signal) {
   const [found] = site.parse(await (await get(site, site.postUrl(id), signal)).text());
@@ -7537,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) {
@@ -7554,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;
@@ -7614,8 +8132,61 @@ function search(palettes, query) {
   return palettes.filter((p) => [p.name, p.group, p.native ?? "", p.ansiSource].some((field) => field.toLowerCase().includes(needle)));
 }
 
+// src/cutout.ts
+import { spawn } from "node:child_process";
+var TIMEOUT2 = 30000;
+var LEAST = 3;
+var MOST = 97;
+var SCRIPT = `ObjC.import('Vision')
+ObjC.import('CoreImage')
+ObjC.import('CoreGraphics')
+function run(argv) {
+  const error = Ref()
+  const image = $.CIImage.imageWithContentsOfURL($.NSURL.fileURLWithPath(argv[0]))
+  if (!image) throw new Error('unreadable image')
+  const handler = $.VNImageRequestHandler.alloc.initWithCIImageOptions(image, $({}))
+  const request = $.VNGenerateForegroundInstanceMaskRequest.alloc.init
+  if (!handler.performRequestsError($([request]), error)) throw new Error('vision failed')
+  if (request.results.count === 0) throw new Error('no foreground')
+  const found = request.results.objectAtIndex(0)
+  const buffer = found.generateMaskedImageOfInstancesFromRequestHandlerCroppedToInstancesExtentError(
+    found.allInstances, handler, false, error)
+  if (!buffer) throw new Error('mask failed')
+  const written = $.CIContext.context.writePNGRepresentationOfImageToURLFormatColorSpaceOptionsError(
+    $.CIImage.imageWithCVPixelBuffer(buffer), $.NSURL.fileURLWithPath(argv[1]), $.kCIFormatRGBA8,
+    $.CGColorSpaceCreateWithName($.kCGColorSpaceSRGB), $({}), error)
+  if (!written) throw new Error('write failed')
+}`;
+function canRemoveBackground() {
+  return process.platform === "darwin";
+}
+function keepable(clear) {
+  return clear >= LEAST && clear <= MOST;
+}
+function removeBackground(input, output, signal) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("osascript", ["-l", "JavaScript", "-e", SCRIPT, input, output], {
+      stdio: ["ignore", "ignore", "pipe"],
+      signal: AbortSignal.any([signal, AbortSignal.timeout(TIMEOUT2)])
+    });
+    let failure = "";
+    child.stderr.on("data", (chunk) => {
+      failure += chunk;
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(failure.trim().split(`
+`).at(-1) || `osascript exited ${code}`));
+    });
+  });
+}
+
 // src/find-screen.ts
-var TILE = { pitch: 25, cols: 22, rows: 9, height: 12 };
+var TILE = { pitch: 25, cols: 22, rows: 9, height: 13 };
 var MIN = { cols: 25, rows: 16 };
 var TRY_ID = 2 ** 31;
 var BELOW_BG = -1073741826;
@@ -7652,14 +8223,14 @@ function decodeKeys(input) {
       if (m) {
         keys.push(CSI[`${m[1] ?? ""}${m[2] ?? m[3] ?? ""}`] ?? "nop");
         i += 1 + m[0].length;
-      } else {
-        keys.push("esc");
-        i++;
+        continue;
       }
+      keys.push("esc");
+      i++;
       continue;
     }
     keys.push(c === "\r" || c === `
-` ? "enter" : c === "\t" ? "tab" : c === "\x03" ? "ctrl-c" : c);
+` ? "enter" : c === "\t" ? "tab" : c === "\x03" ? "ctrl-c" : c === "" || c === "\b" ? "backspace" : c);
     i++;
   }
   return keys;
@@ -7730,8 +8301,14 @@ function progress(got, size) {
   }
   return size >= 1e6 ? `${(got / 1e6).toFixed(1)}/${(size / 1e6).toFixed(1)} MB` : `${Math.round(got / 1000)}/${Math.round(size / 1000)} KB`;
 }
+function plain(artist) {
+  return artist.replace(/_\([^)]*\)?$/, "");
+}
 function dims(tile) {
-  return [`${tile.width}×${tile.height}`, Math.max(tile.width, tile.height) < SMALL ? YELLOW : D];
+  return [
+    `${tile.reduced ? "↓" : ""}${tile.width}×${tile.height}`,
+    Math.max(tile.width, tile.height) < SMALL ? YELLOW : D
+  ];
 }
 function foot(line, cols, accent, spec) {
   const keys = [...spec.keys ?? []];
@@ -7854,23 +8431,61 @@ function frameBox(lines, r0, c0, h, w, sgr) {
   }
   lines[r0 + h - 1]?.put(c0, `╰${"─".repeat(w - 2)}╯`, sgr);
 }
-function badge(view) {
-  return [` ${view.site} `, `\x1B[7;${30 + view.siteAnsi}m`];
+function badge(view, label = view.site) {
+  return [` ${label} `, `\x1B[7;${30 + view.siteAnsi}m`];
+}
+function tabs(line, cols, view) {
+  const strip = SITES.flatMap((site, i) => {
+    const label = `${site.name}${site.moved ? "*" : ""}`;
+    const tab = site.name === view.site ? badge(view, label) : [` ${label} `, D];
+    return i ? [[" ", ""], tab] : [tab];
+  });
+  const fits = strip.reduce((n, [text]) => n + width(text), 0) <= cols;
+  line.run(0, fits ? strip : [badge(view)]);
 }
 function query(line, cols, view, accent) {
+  if (view.editing !== undefined) {
+    const c2 = line.run(0, [
+      ["⌕ ", accent],
+      [view.editing, ""],
+      ["█", accent]
+    ]);
+    line.put(c2, view.editing ? "  enter searches" : `  a tag, a post url or an id — ${view.tag || "esc leaves"}`, D);
+    return;
+  }
   const c = line.run(0, [
     ["⌕ ", accent],
-    [view.tag, ""]
+    [view.tag || "nothing yet — / searches", view.tag ? "" : D]
   ]);
-  line.put(c, `  ${view.preset}`, D);
+  const allowed = BLOCKS.filter((block2) => !view.block.includes(block2));
+  const state = [
+    view.preset,
+    view.order,
+    ...view.rating.join("+") === "safe" ? [] : [view.rating.join("+")],
+    ...allowed.length > 0 ? [`allows ${allowed.join("+")}`] : [],
+    ...view.unblocked ? ["unblock"] : []
+  ];
+  line.put(c, `  ${state.join("  ")}`, D);
   if (view.total > 0 || !view.searching) {
-    const counter = [badge(view), [`  ${view.tiles.length}/${view.checked}`, ""]];
+    const counter = [[`${view.tiles.length}/${view.checked}`, ""]];
     if (view.checked < view.total) {
       counter.push([` of ${view.total}`, D]);
     }
     line.right(cols, counter);
   }
 }
+function transparent(shown) {
+  if (shown.cut === "on") {
+    return [[`cut out · ${shown.clear}% transparent`, GREEN]];
+  }
+  if (shown.cut === "off") {
+    return [["opaque · x cuts out", YELLOW]];
+  }
+  if (shown.cut === "failed") {
+    return [["opaque · no cut-out", YELLOW]];
+  }
+  return [shown.clear > 0 ? [`${shown.clear}% transparent`, GREEN] : ["opaque", YELLOW]];
+}
 function status(view) {
   if (view.installing !== undefined) {
     return [`installing ${view.palette} ← ${view.site} ${view.installing}`, YELLOW];
@@ -7878,18 +8493,27 @@ function status(view) {
   if (view.error) {
     return [view.error, YELLOW];
   }
+  if (view.waiting !== undefined) {
+    return [`${view.site} asked to slow down · ${view.waiting}s`, YELLOW];
+  }
   if (view.fetching) {
     return [`fetching ${view.fetching.id} · ${progress(view.fetching.got, view.fetching.size)}`, YELLOW];
   }
+  if (view.cutting !== undefined) {
+    return [`cutting out ${view.cutting}`, YELLOW];
+  }
   if (view.preparing !== undefined) {
     return [`preparing ${view.preparing}`, YELLOW];
   }
+  if (view.note) {
+    return [view.note, D];
+  }
   return;
 }
 function grid(lines, images, cols, rows, view, accent) {
   const { perRow, rowsVis } = gridShape(cols, rows);
   query(lines[0], cols, view, accent);
-  lines[1]?.put(0, "─".repeat(Math.min(48, cols)), D);
+  tabs(lines[1], cols, view);
   for (let k = 0;k < perRow * rowsVis; k++) {
     const i = view.top * perRow + k;
     const tile = view.tiles[i];
@@ -7909,6 +8533,20 @@ function grid(lines, images, cols, rows, view, accent) {
     if (tile.mates.length > 0) {
       lines[r0 + 10]?.put(c0 + TILE.cols, "≈", accent);
     }
+    const credit = tile.artist ? plain(tile.artist) : tile.owner && `@${tile.owner}`;
+    if (credit) {
+      lines[r0 + 11]?.put(c0 + 1, credit.slice(0, TILE.cols - 8), D);
+    }
+    const marks = [];
+    if (tile.score > 0) {
+      marks.push([`★${tile.score}`, D]);
+    }
+    if (tile.variants > 1) {
+      marks.push([` ×${tile.variants}`, accent]);
+    }
+    if (marks.length > 0) {
+      lines[r0 + 11]?.right(c0 + TILE.cols + 1, marks);
+    }
   }
   const above = view.top * perRow;
   const below = view.tiles.length - (view.top + rowsVis) * perRow;
@@ -7917,7 +8555,7 @@ function grid(lines, images, cols, rows, view, accent) {
     lines[rows - 2]?.put(0, scroll.join("   "), D);
   }
   if (!view.searching && view.tiles.length === 0 && !view.error) {
-    lines[3]?.put(0, view.preset === "cutouts" ? `no transparent cutouts of ${view.tag} on ${view.site} — tab searches every post, p tries ${view.nextSite}` : `no posts of ${view.tag} on ${view.site} — p tries ${view.nextSite}`, D);
+    lines[3]?.put(0, view.preset === "cutouts" ? `no transparent cutouts of ${view.tag} on ${view.site} — c searches every post, tab tries ${view.nextSite}` : `no posts of ${view.tag} on ${view.site} — tab tries ${view.nextSite}`, D);
   }
   const line = lines[rows - 1];
   const lead = status(view);
@@ -7935,8 +8573,9 @@ function grid(lines, images, cols, rows, view, accent) {
     keys: [
       ["←↑↓→", "move"],
       ["enter", "try on"],
-      ["tab", view.preset === "cutouts" ? "all" : "cutouts"],
-      ["p", view.nextSite],
+      ["tab", "site"],
+      ["s", "settings"],
+      ["/", "search"],
       ["?", "keys"]
     ],
     right: ["esc", "back"]
@@ -7949,6 +8588,12 @@ function trial(lines, images, cols, rows, view, accent) {
   }
   const shown = view.shown?.id === tile.id ? view.shown : undefined;
   const meta2 = [badge(view), ["  ", ""], [String(tile.id), B], ["  ", ""], dims(tile)];
+  if (tile.artist) {
+    meta2.push([` · ${plain(tile.artist)}`, ""]);
+  }
+  if (tile.score > 0) {
+    meta2.push([` · ★${tile.score}`, D]);
+  }
   if (shown) {
     meta2.push([` · ${megabytes(shown.bytes)}`, D]);
   }
@@ -7957,7 +8602,7 @@ function trial(lines, images, cols, rows, view, accent) {
     meta2.push([` · ${tile.origin}`, D]);
   }
   if (shown) {
-    meta2.push(["  ", ""], shown.clear > 0 ? [`${shown.clear}% transparent`, GREEN] : ["opaque", YELLOW]);
+    meta2.push(["  ", ""], ...transparent(shown));
   }
   lines[0]?.run(0, meta2);
   if (tile.mates.length > 0) {
@@ -7977,6 +8622,7 @@ function trial(lines, images, cols, rows, view, accent) {
     keys: view.installing === undefined ? [
       ["←→", "browse"],
       ["enter", "install"],
+      ...view.shown?.cut === "on" || view.shown?.cut === "off" ? [["x", "cut out"]] : [],
       ["?", "keys"]
     ] : [],
     right: view.installing === undefined ? ["esc", "grid"] : undefined
@@ -7986,18 +8632,60 @@ var KEYS = {
   grid: [
     ["move", "←↑↓→  home  end  pgup  pgdn"],
     ["try on", "enter"],
-    ["posts", "tab  cutouts or every post"],
-    ["site", `p  ${SITES.map((site) => site.name).join(", ")}`],
+    ["site", `tab  ${SITES.map((site) => site.name).join(", ")}`],
+    ["posts", "c  cutouts or every post"],
+    ["search", "/  a tag, a post url or an id"],
+    ["unfold", "space  a set of ×N"],
+    ["open", "o  the post page in a browser"],
+    ["settings", "s  rating, block, posts, order, sets, remove bg"],
     ["back", "esc returns to preview"],
     ["close", "?  esc"]
   ],
   try: [
     ["browse", "←→"],
     ["install", "enter"],
+    ["cut out", "x  the background off or on, on an opaque picture"],
+    ["open", "o  the post page in a browser"],
     ["grid", "esc"],
     ["close", "?  esc"]
   ]
 };
+function panel(lines, cols, rows, view, accent) {
+  const at2 = view.panel ?? 0;
+  const label = Math.max(...view.settings.map((row) => row.label.length));
+  const widest = Math.max(...view.settings.map((row) => row.choices.reduce((n, c) => n + c.length + (row.multi ? 6 : 3), 0)));
+  const w = Math.min(cols - 2, Math.max(28, label + widest + 8));
+  const h = view.settings.length + 4;
+  const x = Math.floor((cols - w) / 2);
+  const y = Math.max(2, Math.floor((rows - h) / 2));
+  lines[y]?.put(x, `╭─ settings ${"─".repeat(Math.max(0, w - 13))}╮`);
+  for (let r = y + 1;r < y + h - 1; r++) {
+    lines[r]?.put(x, `│${" ".repeat(w - 2)}│`);
+  }
+  view.settings.forEach((row, i) => {
+    const line = lines[y + 2 + i];
+    line.put(x + 3, row.label, i === at2 ? B : D);
+    let c = x + 5 + label;
+    const on = row.value.split(" ");
+    row.choices.forEach((choice, k) => {
+      const lit = on.includes(choice);
+      const under = row.multi && i === at2 && k === row.cursor ? "4;" : "";
+      const text = row.multi ? ` ${lit ? "[x]" : "[ ]"} ${choice} ` : ` ${choice} `;
+      c = line.put(c, text, lit ? `\x1B[${under}7;${30 + view.siteAnsi}m` : under ? `\x1B[4m${D}` : D) + 1;
+    });
+  });
+  lines[y + h - 1]?.put(x, `╰${"─".repeat(w - 2)}╯`);
+  foot(lines[rows - 1], cols, accent, {
+    badge: "SET",
+    keys: [
+      ["↑↓", "setting"],
+      ["←→", "value"],
+      ["space", "toggle"],
+      ["enter", "save"]
+    ],
+    right: ["esc", "undo"]
+  });
+}
 function help(lines, cols, rows, view, accent) {
   const keys = KEYS[view.mode];
   const w = Math.min(cols - 2, 50);
@@ -8030,19 +8718,23 @@ function renderFind(view, cols, rows) {
   } else {
     grid(lines, images, cols, rows, view, accent);
   }
-  if (view.help) {
+  if (view.help || view.panel !== undefined) {
     const keep = view.mode === "try" ? images : [];
     for (let r = 0;r < rows; r++) {
       lines[r] = new Line(cols);
     }
-    help(lines, cols, rows, view, accent);
+    if (view.help) {
+      help(lines, cols, rows, view, accent);
+    } else {
+      panel(lines, cols, rows, view, accent);
+    }
     return { lines: lines.map((l) => l.render()), images: keep };
   }
   return { lines: lines.map((l) => l.render()), images };
 }
 
 // src/palettes.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync3, 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 };
@@ -8057,7 +8749,7 @@ function readInstalled(configHome2) {
   if (!existsSync2(path2)) {
     throw new Error(`nothing installed yet at ${path2} — run \`ttheme init\` first`);
   }
-  const doc = JSON.parse(readFileSync3(path2, "utf8"));
+  const doc = JSON.parse(readFileSync4(path2, "utf8"));
   if (!Array.isArray(doc?.palettes) || !Array.isArray(doc.terminals)) {
     throw new Error(`${path2} has no palettes or terminals`);
   }
@@ -8152,7 +8844,7 @@ function sync(configHome2, catalog, state) {
       }
     }
     const { file, body } = blockFor(terminal, configHome2, startup);
-    const current = existsSync2(file) ? readFileSync3(file, "utf8") : "";
+    const current = existsSync2(file) ? readFileSync4(file, "utf8") : "";
     if (terminal === "alacritty" && current !== "" && !current.includes("# ttheme begin")) {
       continue;
     }
@@ -8170,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);
         }
       }
@@ -8179,32 +8871,310 @@ function forget(configHome2, catalog, terminals, names) {
   return removed;
 }
 
-// src/find.ts
-var WORKERS = 4;
-var SETTLE = 150;
-var TRY_WIDTH = 1280;
-var LOOKAHEAD = 1;
-function describe(error) {
-  if (!(error instanceof Error)) {
-    return String(error);
+// 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 (error instanceof AggregateError && error.errors[0]) {
-    return describe(error.errors[0]);
+  if (task.job === "thumb") {
+    mkdirSync4(dirname3(task.to), { recursive: true });
+    writeFileSync4(task.to, encodePng(contain(image, task.width, task.height)));
+    return 0;
   }
-  if (error.cause) {
-    return describe(error.cause);
+  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();
   }
-  const code = error.code;
-  return typeof code === "string" ? code : error.message || error.name;
 }
-function reason(site, error) {
-  return `${site.name}: ${describe(error)}`;
+
+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();
+  }
 }
-function tick() {
-  return new Promise((resolve2) => setImmediate(resolve2));
+if (!isMainThread && parentPort) {
+  serveRenders(parentPort);
 }
 
-class Finder {
+// src/unblock.ts
+import { connect, createServer } from "node:net";
+var SPLIT = 20;
+var HANDSHAKE = 22;
+function joined(parts) {
+  const out = new Uint8Array(parts.reduce((n, part) => n + part.length, 0));
+  let at2 = 0;
+  for (const part of parts) {
+    out.set(part, at2);
+    at2 += part.length;
+  }
+  return out;
+}
+function reframe(record, at2 = SPLIT) {
+  const body = record.subarray(5);
+  if (record[0] !== HANDSHAKE || body.length < 2) {
+    return [record];
+  }
+  const cut = Math.max(1, Math.min(at2, body.length - 1));
+  const framed = (part) => joined([
+    Uint8Array.from([
+      record[0],
+      record[1],
+      record[2],
+      part.length >> 8,
+      part.length & 255
+    ]),
+    part
+  ]);
+  return [framed(body.subarray(0, cut)), framed(body.subarray(cut))];
+}
+function tunnelTo(client, host, port, rest) {
+  const upstream = connect(port, host, () => {
+    upstream.setNoDelay(true);
+    client.write(`HTTP/1.1 200 Connection Established\r
+\r
+`);
+    let held = rest;
+    let framed = false;
+    const forward = (chunk) => {
+      if (framed) {
+        upstream.write(chunk);
+        return;
+      }
+      held = joined([held, chunk]);
+      if (held.length < 5) {
+        return;
+      }
+      const length = held[3] * 256 + held[4];
+      if (held[0] !== HANDSHAKE) {
+        framed = true;
+        upstream.write(held);
+        return;
+      }
+      if (held.length < 5 + length) {
+        return;
+      }
+      framed = true;
+      const [first, second] = reframe(held.subarray(0, 5 + length));
+      upstream.write(first);
+      setTimeout(() => {
+        if (second) {
+          upstream.write(second);
+        }
+        upstream.write(held.subarray(5 + length));
+      }, 10);
+    };
+    client.on("data", forward);
+    if (held.length > 0) {
+      const pending = held;
+      held = new Uint8Array(0);
+      forward(pending);
+    }
+    upstream.pipe(client);
+  });
+  upstream.on("error", () => client.destroy());
+  client.on("error", () => upstream.destroy());
+}
+function serve(client) {
+  client.setNoDelay(true);
+  let head = new Uint8Array(0);
+  const onData = (chunk) => {
+    head = joined([head, chunk]);
+    const text = Buffer.from(head).toString("latin1");
+    const end = text.indexOf(`\r
+\r
+`);
+    if (end === -1) {
+      return;
+    }
+    client.off("data", onData);
+    const target = /^CONNECT ([^ :]+):(\d+)/.exec(text);
+    if (!target) {
+      client.end(`HTTP/1.1 405 Method Not Allowed\r
+\r
+`);
+      return;
+    }
+    tunnelTo(client, target[1], Number(target[2]), head.subarray(end + 4));
+  };
+  client.on("data", onData);
+  client.on("error", () => client.destroy());
+}
+function tunnel() {
+  const server = createServer(serve);
+  return new Promise((resolve2, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      resolve2({
+        port: server.address().port,
+        close: () => {
+          server.close();
+          server.unref();
+        }
+      });
+    });
+  });
+}
+
+// src/find.ts
+var SETTINGS = [
+  { name: "TTHEME_FIND_RATING", label: "rating", choices: RATINGS, multi: { read: ratingSet } },
+  { name: "TTHEME_FIND_BLOCK", label: "block", choices: BLOCKS, multi: { read: blockSet, none: "none" } },
+  { name: "TTHEME_FIND_POSTS", label: "posts", choices: ["all", "cutouts"] },
+  { name: "TTHEME_FIND_ORDER", label: "order", choices: ["newest", "score"] },
+  { name: "TTHEME_FIND_SETS", label: "sets", choices: ["fold", "show"] },
+  ...canRemoveBackground() ? [{ name: "TTHEME_FIND_REMOVE_BG", label: "remove bg", choices: ["on", "off"] }] : []
+];
+function initial(setting, raw) {
+  if (setting.multi) {
+    return setting.multi.read(raw).join(" ") || setting.multi.none;
+  }
+  return setting.choices.find((choice) => choice === raw) ?? setting.choices[0];
+}
+var PROBE = 12;
+var THUMB = 12;
+var PRELOAD = 2;
+var SETTLE = 150;
+var ESCAPE = 30;
+var TRY_WIDTH = 1280;
+var LOOKAHEAD = 2;
+function blank(key, searching) {
+  return {
+    key,
+    groups: [],
+    sources: [],
+    queue: [],
+    seen: new Set,
+    checked: 0,
+    total: 0,
+    focus: 0,
+    top: 0,
+    searching
+  };
+}
+function describe(error) {
+  if (!(error instanceof Error)) {
+    return String(error);
+  }
+  if (error instanceof AggregateError && error.errors[0]) {
+    return describe(error.errors[0]);
+  }
+  if (error.cause) {
+    return describe(error.cause);
+  }
+  const code = error.code;
+  if (typeof code === "string") {
+    return code;
+  }
+  const first = (error.message || error.name).split(".")[0] ?? "";
+  return first.length > 56 ? `${first.slice(0, 55)}…` : first;
+}
+function reason(site, error) {
+  return `${site.name}: ${describe(error)}`;
+}
+function incomplete(input) {
+  const at2 = input.lastIndexOf("\x1B");
+  return at2 !== -1 && /^\[?[0-9;]*$/.test(input.slice(at2 + 1));
+}
+function readCache(site, name) {
+  try {
+    return JSON.parse(readFileSync6(join7(cacheDir(site), name), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeCache(site, name, data) {
+  mkdirSync5(cacheDir(site), { recursive: true });
+  writeFileSync5(join7(cacheDir(site), name), `${JSON.stringify(data)}
+`);
+}
+
+class Finder {
   view;
   tone;
   session = new AbortController;
@@ -8213,19 +9183,28 @@ class Finder {
   rows = process.stdout.rows || 24;
   gen = 0;
   pumping = 0;
-  sources = [];
-  queue = [];
-  seen = new Set;
+  boards = new Map;
+  board;
   posts = new Map;
+  thumbPath = new Map;
   siteIndex = 0;
+  values = new Map(SETTINGS.map((setting) => [setting.name, initial(setting, process.env[setting.name])]));
+  direction = 1;
+  prefetching = 0;
+  inflight = new Map;
   owners = new Map;
+  probed = new Map;
+  unsaved = new Set;
   thumbQueue = [];
   thumbing = 0;
+  clarity = new Map;
+  renders = new Renderer;
   sent = new Map;
   placed = new Map;
   current;
   fetch;
   settle;
+  partial;
   input = "";
   probeWait;
   done;
@@ -8245,17 +9224,32 @@ class Finder {
       site: this.site.name,
       siteAnsi: this.site.ansi,
       nextSite: this.nextSite.name,
-      preset: "cutouts",
+      preset: this.setting("TTHEME_FIND_POSTS") === "all" ? "all" : "cutouts",
+      order: this.setting("TTHEME_FIND_ORDER") === "score" ? "score" : "newest",
+      rating: ratingSet(this.setting("TTHEME_FIND_RATING")),
+      block: blockSet(this.setting("TTHEME_FIND_BLOCK")),
+      sets: this.setting("TTHEME_FIND_SETS") === "show" ? "show" : "fold",
+      unblocked: process.env.TTHEME_FIND_PROXY !== undefined,
+      settings: SETTINGS.map((setting) => ({
+        label: setting.label,
+        choices: [...setting.choices],
+        value: this.setting(setting.name),
+        multi: setting.multi && { none: setting.multi.none },
+        cursor: 0
+      })),
       colors: { cursor: entry.cursor, selection: entry.selection, ansi: entry.ansi },
       tiles: [],
       checked: 0,
       total: 0,
-      searching: true,
+      searching: tag !== "",
       focus: 0,
       top: 0,
       mode: "grid",
-      help: false
+      help: false,
+      editing: tag === "" ? "" : undefined
     };
+    this.board = blank(this.boardKey, tag !== "");
+    this.boards.set(this.board.key, this.board);
   }
   get signal() {
     return this.session.signal;
@@ -8266,6 +9260,52 @@ class Finder {
   get nextSite() {
     return SITES[(this.siteIndex + 1) % SITES.length];
   }
+  setting(name) {
+    return this.values.get(name);
+  }
+  get boardKey() {
+    return `${this.site.key}|${this.view.preset}|${this.view.order}`;
+  }
+  mark(site, id) {
+    return `${site.key}:${id}`;
+  }
+  origPath(site, id, ext) {
+    return join7(cacheDir(site), "orig", `${id}.${ext}`);
+  }
+  tileOf(site, post2, variants) {
+    const version2 = rendition(post2) ?? post2;
+    return {
+      id: post2.id,
+      width: version2.width,
+      height: version2.height,
+      reduced: version2 !== post2,
+      owner: mirrored(post2.owner) ? "" : post2.owner,
+      artist: post2.artist,
+      score: post2.score,
+      variants,
+      origin: originHost(post2.source),
+      mates: this.owners.get(site.key)?.get(post2.owner) ?? [],
+      thumb: this.thumbPath.get(this.mark(site, post2.id))
+    };
+  }
+  show() {
+    const site = this.site;
+    const view = this.view;
+    const board = this.board;
+    view.tiles = board.groups.flatMap((group) => group.open ? group.posts.map((post2) => this.tileOf(site, post2, 0)) : [this.tileOf(site, group.posts[0], group.posts.length)]);
+    view.checked = board.checked;
+    view.total = board.total;
+    view.searching = board.searching;
+    view.note = board.note;
+    view.focus = Math.max(0, Math.min(board.focus, view.tiles.length - 1));
+    view.top = board.top;
+  }
+  syncSite() {
+    const view = this.view;
+    view.site = this.site.name;
+    view.siteAnsi = this.site.ansi;
+    view.nextSite = this.nextSite.name;
+  }
   async run() {
     const { stdin, stdout } = process;
     stdin.setRawMode(true);
@@ -8276,10 +9316,13 @@ class Finder {
     const exit = new Promise((resolve2) => {
       this.done = resolve2;
     });
+    const clock = setInterval(this.onClock, 250);
     const cell = await this.probe();
     if (cell) {
       this.cell = cell;
-      this.search();
+      if (this.view.tag) {
+        this.search();
+      }
     } else {
       this.view.searching = false;
       this.view.error = "this terminal does not report its cell size — find needs kitty graphics";
@@ -8289,12 +9332,17 @@ class Finder {
     this.session.abort();
     this.fetch?.abort();
     clearTimeout(this.settle);
+    clearTimeout(this.partial);
+    clearInterval(clock);
     stdin.off("data", this.onData);
     stdout.off("resize", this.onResize);
     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) {
@@ -8328,18 +9376,34 @@ class Finder {
       this.input = this.input.slice(0, at2) + this.input.slice(at2 + 1 + m[0].length);
       this.probeWait({ h: Number(m[1]), w: Number(m[2]) });
     }
+    clearTimeout(this.partial);
+    if (incomplete(this.input)) {
+      this.partial = setTimeout(this.flushKeys, ESCAPE);
+      return;
+    }
+    this.flushKeys();
+  };
+  flushKeys = () => {
     const keys = decodeKeys(this.input);
     this.input = "";
     for (const key of keys) {
       this.key(key);
     }
   };
+  onClock = () => {
+    const left = Math.ceil((pausedUntil(this.site) - Date.now()) / 1000);
+    const waiting = left > 0 ? left : undefined;
+    if (waiting !== this.view.waiting) {
+      this.view.waiting = waiting;
+      this.draw();
+    }
+  };
   onResize = () => {
     this.cols = process.stdout.columns || this.cols;
     this.rows = process.stdout.rows || this.rows;
     this.scroll();
     if (this.view.mode === "try" && this.current) {
-      this.present();
+      this.reveal();
     }
     this.pump();
     this.draw();
@@ -8353,6 +9417,14 @@ class Finder {
     if (view.installing !== undefined) {
       return;
     }
+    if (view.editing !== undefined) {
+      this.editKey(key);
+      return;
+    }
+    if (view.panel !== undefined) {
+      this.panelKey(key);
+      return;
+    }
     if (view.help) {
       if (key === "?" || key === "esc") {
         view.help = false;
@@ -8401,29 +9473,265 @@ class Finder {
       this.select();
       return;
     }
-    if (key === "tab") {
+    if (key === "c") {
       view.preset = view.preset === "cutouts" ? "all" : "cutouts";
-      this.search();
+      this.turn();
       return;
     }
-    if (key === "p") {
+    if (key === "tab") {
       this.siteIndex = (this.siteIndex + 1) % SITES.length;
-      this.current = undefined;
-      view.shown = undefined;
-      view.site = this.site.name;
-      view.siteAnsi = this.site.ansi;
-      view.nextSite = this.nextSite.name;
-      this.search();
+      this.syncSite();
+      this.turn();
+      return;
+    }
+    if (key === "/") {
+      view.editing = "";
+      this.draw();
+      return;
+    }
+    if (key === " ") {
+      this.unfold();
+      return;
+    }
+    if (key === "o") {
+      this.openPage();
+      return;
+    }
+    if (key === "s") {
+      view.panel = 0;
+      this.draw();
       return;
     }
     if (key === "esc") {
       this.finish(2);
     }
   }
+  panelKey(key) {
+    const view = this.view;
+    const at2 = view.panel ?? 0;
+    const row = view.settings[at2];
+    if (key === "up" || key === "down") {
+      view.panel = Math.max(0, Math.min(view.settings.length - 1, at2 + (key === "up" ? -1 : 1)));
+      this.draw();
+      return;
+    }
+    if ((key === "left" || key === "right") && row) {
+      const step = key === "left" ? -1 : 1;
+      if (row.multi) {
+        row.cursor = (row.cursor + step + row.choices.length) % row.choices.length;
+      } else {
+        const index = row.choices.indexOf(row.value);
+        row.value = row.choices[(index + step + row.choices.length) % row.choices.length];
+      }
+      this.draw();
+      return;
+    }
+    if (key === " " && row?.multi) {
+      const on = row.value.split(" ");
+      const next = row.choices.filter((choice, k) => k === row.cursor ? !on.includes(choice) : on.includes(choice));
+      const empty = row.multi.none;
+      if (next.length > 0 || empty !== undefined) {
+        row.value = next.length > 0 ? next.join(" ") : empty;
+        this.draw();
+      }
+      return;
+    }
+    if (key === "esc") {
+      view.settings.forEach((setting, i) => {
+        setting.value = this.setting(SETTINGS[i]?.name ?? "");
+      });
+      view.panel = undefined;
+      this.draw();
+      return;
+    }
+    if (key === "enter" || key === "alt-c") {
+      view.panel = undefined;
+      this.adopt();
+    }
+  }
+  adopt() {
+    const view = this.view;
+    const before = SETTINGS.map((setting) => this.setting(setting.name));
+    view.settings.forEach((row, i) => {
+      const setting = SETTINGS[i];
+      if (setting) {
+        this.values.set(setting.name, row.value);
+      }
+    });
+    const changed = SETTINGS.filter((setting, i) => this.setting(setting.name) !== before[i]);
+    if (changed.length === 0) {
+      this.draw();
+      return;
+    }
+    this.save(changed);
+    view.rating = ratingSet(this.setting("TTHEME_FIND_RATING"));
+    view.block = blockSet(this.setting("TTHEME_FIND_BLOCK"));
+    view.sets = this.setting("TTHEME_FIND_SETS") === "show" ? "show" : "fold";
+    view.preset = this.setting("TTHEME_FIND_POSTS") === "all" ? "all" : "cutouts";
+    view.order = this.setting("TTHEME_FIND_ORDER") === "score" ? "score" : "newest";
+    this.boards.clear();
+    this.current = undefined;
+    view.shown = undefined;
+    view.mode = "grid";
+    this.search();
+  }
+  save(changed) {
+    const path2 = join7(this.home, "ttheme", "config.zsh");
+    try {
+      const before = existsSync3(path2) ? readFileSync6(path2, "utf8") : "";
+      const after = changed.reduce((text, setting) => withSetting(text, setting.name, this.setting(setting.name)), before);
+      writeFileSync5(path2, after);
+    } catch (error) {
+      this.view.error = error instanceof Error ? error.message : String(error);
+    }
+  }
+  editKey(key) {
+    const view = this.view;
+    const text = view.editing ?? "";
+    if (key === "esc") {
+      view.editing = undefined;
+      if (view.tag === "") {
+        this.finish(2);
+        return;
+      }
+      this.draw();
+      return;
+    }
+    if (key === "enter") {
+      view.editing = undefined;
+      if (text.trim()) {
+        this.commit(text.trim());
+        return;
+      }
+      if (view.tag === "") {
+        this.finish(2);
+        return;
+      }
+      this.draw();
+      return;
+    }
+    if (key === "backspace") {
+      view.editing = text.slice(0, -1);
+      this.draw();
+      return;
+    }
+    if (key.length === 1 && key >= " ") {
+      view.editing = text + key;
+      this.draw();
+    }
+  }
+  async commit(text) {
+    const ref = postRef(text, this.site);
+    if (ref) {
+      await this.jump(ref.site, ref.id);
+      return;
+    }
+    this.view.tag = text;
+    this.boards.clear();
+    await this.search();
+  }
+  async jump(site, id) {
+    const gen = ++this.gen;
+    this.siteIndex = SITES.indexOf(site);
+    this.syncSite();
+    this.current = undefined;
+    this.view.shown = undefined;
+    this.view.error = undefined;
+    const board = blank(`${site.key}|post:${id}`, true);
+    this.board = board;
+    this.boards.set(board.key, board);
+    this.show();
+    this.draw();
+    try {
+      const post2 = await fetchPost(site, id, this.signal);
+      if (gen !== this.gen) {
+        return;
+      }
+      board.searching = false;
+      if (!post2) {
+        board.error = `${site.name} has no post ${id}`;
+        this.view.error = board.error;
+      } else {
+        this.posts.set(this.mark(site, post2.id), post2);
+        board.groups = [{ posts: [post2], open: false }];
+        board.checked = 1;
+        board.total = 1;
+        this.thumbQueue.push({ site, post: post2 });
+        this.thumbs();
+        this.view.mode = "try";
+      }
+      this.show();
+      if (post2) {
+        this.select();
+      }
+      this.draw();
+    } catch (error) {
+      this.fail(gen, error);
+    }
+  }
+  async turn() {
+    this.current = undefined;
+    this.view.shown = undefined;
+    const known = this.boards.get(this.boardKey);
+    if (!known) {
+      await this.search();
+      return;
+    }
+    this.gen++;
+    this.board = known;
+    this.view.error = known.error;
+    this.show();
+    this.draw();
+    await this.pump();
+  }
+  unfold() {
+    const view = this.view;
+    let index = 0;
+    for (const group of this.board.groups) {
+      const size = group.open ? group.posts.length : 1;
+      if (view.focus < index + size) {
+        if (group.posts.length < 2) {
+          return;
+        }
+        group.open = !group.open;
+        this.board.focus = index;
+        for (const post2 of group.posts) {
+          if (!this.thumbPath.has(this.mark(this.site, post2.id))) {
+            this.thumbQueue.push({ site: this.site, post: post2 });
+          }
+        }
+        this.thumbs();
+        this.show();
+        this.scroll();
+        this.draw();
+        return;
+      }
+      index += size;
+    }
+  }
+  openPage() {
+    const tile = this.view.tiles[this.view.focus];
+    if (!tile) {
+      return;
+    }
+    const opener = process.platform === "darwin" ? "open" : "xdg-open";
+    try {
+      spawn2(opener, [this.site.pageUrl(tile.id)], { stdio: "ignore", detached: true }).unref();
+    } catch {}
+  }
   tryKey(key) {
     const view = this.view;
     if (key === "left" || key === "right") {
-      this.focus(view.focus + (key === "left" ? -1 : 1));
+      this.direction = key === "left" ? -1 : 1;
+      this.focus(view.focus + this.direction);
+      return;
+    }
+    if (key === "o") {
+      this.openPage();
+      return;
+    }
+    if (key === "x") {
+      this.swap();
       return;
     }
     if (key === "enter") {
@@ -8449,6 +9757,7 @@ class Finder {
       return;
     }
     view.focus = next;
+    this.board.focus = next;
     this.scroll();
     this.pump();
     if (view.mode === "try") {
@@ -8466,135 +9775,217 @@ class Finder {
     if (row > view.top + rowsVis - 1) {
       view.top = row - rowsVis + 1;
     }
+    this.board.top = view.top;
+  }
+  query(site) {
+    const view = this.view;
+    const wanted = [
+      view.tag,
+      site.rate(this.view.rating),
+      view.preset === "cutouts" ? site.cutouts : "",
+      view.order === "score" ? site.best : ""
+    ].filter(Boolean);
+    const kept = [];
+    const dropped = [];
+    for (const part of wanted) {
+      if (tagsOf([...kept, part].join(" ")) <= site.tagBudget) {
+        kept.push(part);
+      } else {
+        dropped.push(part);
+      }
+    }
+    this.board.note = dropped.length > 0 ? `${site.name} takes ${site.tagBudget} tags — ${dropped.join(" ")} left out` : undefined;
+    return kept.join(" ");
   }
   async search() {
     const gen = ++this.gen;
-    const view = this.view;
-    Object.assign(view, { tiles: [], checked: 0, total: 0, searching: true, focus: 0, top: 0, error: undefined });
-    this.seen.clear();
-    this.queue = [];
-    this.sources = [];
-    this.thumbQueue = [];
-    this.draw();
     const site = this.site;
-    const tags = view.preset === "cutouts" ? `${view.tag} ${site.cutouts}` : view.tag;
+    const board = blank(this.boardKey, true);
+    this.board = board;
+    this.boards.set(board.key, board);
+    this.view.error = undefined;
+    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;
       }
-      view.total = total;
-      this.sources = [
-        ...[...owners.keys()].map((owner) => ({ tags: `${tags} user:${owner}`, page: 0, done: false })),
+      const room = tagsOf(tags) + 1 <= site.tagBudget;
+      board.sources = [
+        ...room ? [...owners.keys()].map((owner) => ({ tags: `${tags} user:${owner}`, page: 0, done: false })) : [],
         { tags, page: 0, done: false }
       ];
+      this.show();
       this.draw();
       await this.pump();
     } catch (error) {
       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;
     }
-    this.view.error = reason(this.site, error);
-    this.view.searching = false;
+    this.board.error = reason(this.site, error);
+    this.board.searching = false;
+    this.view.error = this.board.error;
+    this.show();
     this.draw();
   }
   wants() {
-    const view = this.view;
-    if (view.checked < Math.min(view.total, PAGE)) {
-      return true;
-    }
     const { perRow, rowsVis } = gridShape(this.cols, this.rows);
-    return view.tiles.length < (view.top + rowsVis + LOOKAHEAD) * perRow;
+    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;
-    if (this.pumping === gen || this.sources.length === 0) {
+    const board = this.board;
+    if (this.pumping === gen || board.sources.length === 0) {
       return;
     }
     this.pumping = gen;
-    const view = this.view;
+    const site = this.site;
+    const flight = [];
+    let page;
     try {
-      view.searching = true;
-      while (gen === this.gen && this.wants()) {
-        if (this.queue.length === 0) {
-          const source = this.sources.find((s) => !s.done);
-          if (!source) {
-            break;
-          }
-          const posts = await fetchPosts(this.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 (!this.seen.has(post2.id)) {
-              this.seen.add(post2.id);
-              this.queue.push(post2);
+      board.searching = true;
+      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 = this.queue.splice(0, WORKERS);
-        const passed = await Promise.all(batch.map((post2) => this.passes(post2)));
+        const passed = await head.passed;
         if (gen !== this.gen) {
           return;
         }
-        batch.forEach((post2, i) => {
-          view.checked++;
-          if (passed[i]) {
-            this.admit(post2);
-          }
-        });
+        board.checked++;
+        if (passed) {
+          this.admit(site, head.post);
+        }
+        this.show();
         this.draw();
       }
       if (gen === this.gen) {
-        view.searching = false;
+        board.searching = false;
+        this.show();
         this.draw();
       }
     } catch (error) {
       this.fail(gen, error);
     } finally {
+      this.saveProbes();
       if (this.pumping === gen) {
         this.pumping = 0;
       }
     }
   }
-  async passes(post2) {
-    if (!safe(post2)) {
+  async passes(site, post2) {
+    const version2 = rendition(post2);
+    if (!rated(site, post2, this.view.rating) || exposed(post2, this.view.block).length > 0 || !version2) {
       return false;
     }
     if (this.view.preset === "all") {
-      return ["png", "jpg", "jpeg"].includes(post2.ext);
+      return ["png", "jpg", "jpeg"].includes(version2.ext);
     }
     if (post2.ext !== "png") {
       return false;
     }
-    if (this.site.vouched) {
-      return true;
+    return site.vouched || this.transparent(site, post2);
+  }
+  probes(site) {
+    let known = this.probed.get(site.key);
+    if (!known) {
+      known = readCache(site, "probes.json");
+      this.probed.set(site.key, known);
+    }
+    return known;
+  }
+  async transparent(site, post2) {
+    const known = this.probes(site);
+    const cached = known[post2.id];
+    if (cached !== undefined) {
+      return cached;
     }
     try {
-      return (await headOf(this.site, post2.file, this.signal))?.alpha === true;
+      const alpha = (await headOf(site, post2.file, this.signal))?.alpha === true;
+      known[post2.id] = alpha;
+      this.unsaved.add(site.key);
+      return alpha;
     } catch {
       return false;
     }
   }
-  admit(post2) {
-    const tile = {
-      id: post2.id,
-      width: post2.width,
-      height: post2.height,
-      owner: post2.owner,
-      origin: originHost(post2.source),
-      mates: this.owners.get(this.site.key)?.get(post2.owner) ?? []
-    };
-    this.posts.set(post2.id, post2);
-    this.view.tiles.push(tile);
-    this.thumbQueue.push(tile);
+  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);
+    const last = this.view.sets === "fold" ? this.board.groups.at(-1) : undefined;
+    const head = last?.posts[0];
+    const credit = post2.owner || post2.artist;
+    if (last && head && credit && (head.owner || head.artist) === credit && head.width === post2.width && head.height === post2.height) {
+      last.posts.push(post2);
+      if (last.open) {
+        this.thumbQueue.push({ site, post: post2 });
+        this.thumbs();
+      }
+      return;
+    }
+    this.board.groups.push({ posts: [post2], open: false });
+    this.thumbQueue.push({ site, post: post2 });
     this.thumbs();
   }
   async mateOwners(site) {
@@ -8603,70 +9994,76 @@ class Finder {
       return cached;
     }
     const found = origins(this.home);
-    const cachePath = join7(cacheDir(site), "owners.json");
-    let known = {};
-    try {
-      known = JSON.parse(readFileSync4(cachePath, "utf8"));
-    } catch {}
-    const byPalette = new Map;
-    for (const sibling of this.catalog.palettes) {
+    const known = readCache(site, "owners.json");
+    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);
     }
-    mkdirSync4(dirname3(cachePath), { recursive: true });
-    writeFileSync4(cachePath, `${JSON.stringify(known)}
-`);
+    writeCache(site, "owners.json", known);
     const owners = mates(byPalette);
     this.owners.set(site.key, owners);
     return owners;
   }
-  async cached(site, path2, url) {
+  async cached(site, path2, url, progress2) {
     if (existsSync3(path2)) {
-      return new Uint8Array(readFileSync4(path2));
+      return statSync3(path2).size;
+    }
+    const running = this.inflight.get(path2);
+    if (running) {
+      return running;
+    }
+    const job = (async () => {
+      const bytes = await fetchBytes(site, url, this.signal, progress2);
+      mkdirSync5(dirname4(path2), { recursive: true });
+      writeFileSync5(path2, bytes);
+      return bytes.length;
+    })();
+    this.inflight.set(path2, job);
+    try {
+      return await job;
+    } finally {
+      this.inflight.delete(path2);
     }
-    const bytes = await fetchBytes(site, url, this.signal);
-    mkdirSync4(dirname3(path2), { recursive: true });
-    writeFileSync4(path2, bytes);
-    return bytes;
   }
   thumbs() {
-    while (this.thumbing < WORKERS && this.thumbQueue.length > 0) {
-      const tile = this.thumbQueue.shift();
+    while (this.thumbing < THUMB && this.thumbQueue.length > 0) {
+      const { site, post: post2 } = this.thumbQueue.shift();
       this.thumbing++;
-      this.thumb(tile).catch(() => {}).finally(() => {
+      this.thumb(site, post2).catch(() => {}).finally(() => {
         this.thumbing--;
         this.thumbs();
       });
     }
   }
-  async thumb(tile) {
-    const post2 = this.posts.get(tile.id);
-    const site = this.site;
-    if (!post2) {
-      return;
-    }
+  async thumb(site, post2) {
     const w = TILE.cols * this.cell.w;
     const h = TILE.rows * this.cell.h;
-    const path2 = join7(cacheDir(site), "tile", `${tile.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", `${tile.id}.${extension(post2.preview)}`);
-      const bytes = await this.cached(site, thumb, post2.preview);
-      mkdirSync4(dirname3(path2), { recursive: true });
-      writeFileSync4(path2, encodePng(contain(decodeImage(bytes), w, h)));
+      const thumb = join7(cacheDir(site), "thumb", `${post2.id}.${extension(post2.preview)}`);
+      await this.cached(site, thumb, post2.preview);
+      await this.renders.run({ job: "thumb", from: thumb, to: path2, width: w, height: h });
     }
-    tile.thumb = path2;
+    this.thumbPath.set(this.mark(site, post2.id), path2);
+    this.show();
     this.draw();
   }
   select() {
@@ -8679,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);
@@ -8688,46 +10084,74 @@ class Finder {
   }
   async load(tile) {
     const view = this.view;
-    const post2 = this.posts.get(tile.id);
-    if (!post2) {
+    const post2 = this.posts.get(this.mark(this.site, tile.id));
+    const version2 = post2 && rendition(post2);
+    if (!version2) {
       return;
     }
     const site = this.site;
     const control = new AbortController;
     this.fetch = control;
-    const signal = AbortSignal.any([this.signal, control.signal]);
     try {
-      const path2 = join7(cacheDir(site), "orig", `${tile.id}.${post2.ext}`);
-      let bytes;
-      if (existsSync3(path2)) {
-        bytes = new Uint8Array(readFileSync4(path2));
-      } else {
+      const path2 = this.origPath(site, tile.id, version2.ext);
+      if (!existsSync3(path2)) {
         view.fetching = { id: tile.id, got: 0, size: 0 };
         this.draw();
-        bytes = await fetchBytes(site, post2.file, signal, (got, size) => {
-          if (view.fetching?.id === tile.id) {
-            view.fetching = { id: tile.id, got, size };
-            this.draw();
-          }
-        });
-        mkdirSync4(dirname3(path2), { recursive: true });
-        writeFileSync4(path2, bytes);
       }
+      const size = await this.cached(site, path2, version2.file, (got, total) => {
+        if (view.fetching?.id === tile.id) {
+          view.fetching = { id: tile.id, got, size: total };
+          this.draw();
+        }
+      });
       if (control.signal.aborted) {
         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);
-      if (site !== this.site) {
+      const plain2 = await this.render(current, "plain");
+      if (control.signal.aborted || site !== this.site) {
         return;
       }
-      this.current = { site, id: tile.id, image, bytes, ext: post2.ext, clear: transparency(image) };
+      if (plain2.clear === 0 && canRemoveBackground() && this.setting("TTHEME_FIND_REMOVE_BG") !== "off") {
+        view.preparing = undefined;
+        view.cutting = tile.id;
+        this.flush();
+        current.cut = await this.cutOut(site, tile.id, path2, control.signal);
+        if (control.signal.aborted || site !== this.site) {
+          return;
+        }
+        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) {
       if (!control.signal.aborted && !this.signal.aborted) {
         view.error = reason(site, error);
@@ -8739,23 +10163,110 @@ class Finder {
       if (view.preparing === tile.id) {
         view.preparing = undefined;
       }
+      if (view.cutting === tile.id) {
+        view.cutting = undefined;
+      }
       this.draw();
     }
   }
-  present() {
+  async cutOut(site, id, path2, signal) {
+    const out = join7(cacheDir(site), "cut", `${id}.png`);
+    if (existsSync3(out)) {
+      return out;
+    }
+    try {
+      mkdirSync5(dirname4(out), { recursive: true });
+      await removeBackground(path2, out, signal);
+      return out;
+    } catch {
+      rmSync5(out, { force: true });
+      return;
+    }
+  }
+  swap() {
     const current = this.current;
-    if (!current) {
+    if (!current?.cut || this.view.shown?.id !== current.id) {
+      return;
+    }
+    current.using = current.using === "cut" ? "plain" : "cut";
+    this.reveal();
+  }
+  preload() {
+    const view = this.view;
+    if (view.mode !== "try") {
       return;
     }
+    const site = this.site;
+    for (const index of [view.focus + this.direction, view.focus - this.direction]) {
+      if (this.prefetching >= PRELOAD) {
+        return;
+      }
+      const tile = view.tiles[index];
+      const post2 = tile && this.posts.get(this.mark(site, tile.id));
+      const version2 = post2 && rendition(post2);
+      if (!version2) {
+        continue;
+      }
+      const path2 = this.origPath(site, post2.id, version2.ext);
+      this.prefetching++;
+      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--;
+      });
+    }
+  }
+  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 path2 = join7(this.scratch, `${current.id}-${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 };
+    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;
@@ -8767,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);
@@ -8825,17 +10345,64 @@ class Finder {
     this.write(`${out}\x1B[?2026l`);
   }
 }
+function routable() {
+  if (process.versions.bun) {
+    return true;
+  }
+  const [major = 0, minor = 0] = process.versions.node.split(".").map(Number);
+  return major > 22 || major === 22 && minor >= 21;
+}
+async function relaunch() {
+  if (!routable()) {
+    process.stderr.write(`unblock needs node 22.21 or newer — this is ${process.versions.node}
+`);
+    return 1;
+  }
+  const proxy = await tunnel();
+  const child = spawn2(process.execPath, process.argv.slice(1), {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      NODE_USE_ENV_PROXY: "1",
+      NODE_NO_WARNINGS: "1",
+      HTTPS_PROXY: `http://127.0.0.1:${proxy.port}`,
+      TTHEME_FIND_PROXY: String(proxy.port)
+    }
+  });
+  const code = await new Promise((resolve2) => child.on("exit", (status2) => resolve2(status2 ?? 1)));
+  proxy.close();
+  return code;
+}
 async function runFind(name) {
+  if (process.env.TTHEME_FIND_UNBLOCK === "1" && !process.env.TTHEME_FIND_PROXY) {
+    return relaunch();
+  }
   const home = configHome();
   const catalog = readCatalog(home);
   const entry = find2(catalog.palettes, name);
-  if (!entry.booru) {
-    throw new Error(`${name} has no booru tag to search for`);
-  }
   if (!process.stdin.isTTY || !process.stdout.isTTY) {
     throw new Error("ttheme find needs a terminal");
   }
-  return new Finder(home, catalog, entry, entry.booru).run();
+  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
@@ -8843,14 +10410,14 @@ import {
   chmodSync,
   copyFileSync,
   existsSync as existsSync5,
-  mkdirSync as mkdirSync5,
-  readdirSync as readdirSync3,
-  readFileSync as readFileSync5,
-  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";
@@ -10789,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(readFileSync5(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");
@@ -10810,7 +12377,7 @@ function planInit(opts, paths) {
   const configPath = join8(home, "config.zsh");
   const settings2 = {
     file: configPath,
-    content: configFile(existsSync5(configPath) ? readFileSync5(configPath, "utf8") : "")
+    content: configFile(existsSync5(configPath) ? readFileSync7(configPath, "utf8") : "")
   };
   const notes = [];
   if (opts.terminals.includes("ghostty")) {
@@ -10818,7 +12385,7 @@ function planInit(opts, paths) {
   }
   if (opts.terminals.includes("alacritty")) {
     const config = join8(paths.configHome, "alacritty", "alacritty.toml");
-    if (existsSync5(config) && !readFileSync5(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");
     }
   }
@@ -10828,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) ? readFileSync5(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) {
@@ -10866,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) => !readFileSync5(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:
@@ -10991,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;
 }
@@ -11009,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);
+}