@kaynooo/cli-docker 0.5.0 → 0.6.0

package/dist/dx-cli.js

@@ -1,14 +1,14 @@
-#!/usr/bin/env bun
+#!/usr/bin/env -S bun --no-env-file
 // @bun
 
 // src/dx-cli.ts
-import process11 from "process";
+import process16 from "process";
 // ../kit/src/args.ts
-import process4 from "process";
+import process7 from "process";
 import { parseArgs } from "util";
 
 // ../kit/src/style.ts
-import process2 from "process";
+import process5 from "process";
 
 // ../../node_modules/.bun/@kaynooo+utils@2.31.2+d0769e28dc4dad16/node_modules/@kaynooo/utils/dist/chunk-mtetydvc.js
 function x(s) {
@@ -271,21 +271,209 @@ function le(i = {}) {
 }
 var t = le();
 
+// ../kit/src/theme.ts
+import { existsSync as existsSync2, readFileSync, statSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3, resolve as resolve2 } from "path";
+import process4 from "process";
+
+// ../kit/src/config.ts
+import { existsSync } from "fs";
+import { dirname, join, resolve } from "path";
+import process2 from "process";
+function findUp(names, from = process2.cwd(), stop = () => false) {
+  const wanted = typeof names === "string" ? [names] : names;
+  for (let dir = resolve(from);; dir = dirname(dir)) {
+    const found = wanted.map((name) => join(dir, name)).find((path) => existsSync(path));
+    if (found !== undefined)
+      return found;
+    if (stop(dir) || dirname(dir) === dir)
+      return;
+  }
+}
+
+// ../kit/src/user-config.ts
+import { homedir } from "os";
+import { join as join2 } from "path";
+import process3 from "process";
+function configBase(where = {}) {
+  const xdg = where.xdg ?? (where.home === undefined ? process3.env.XDG_CONFIG_HOME : undefined);
+  return xdg !== undefined && xdg !== "" ? xdg : join2(where.home ?? homedir(), ".config");
+}
+function userConfigPath(bin, where = {}) {
+  return join2(configBase(where), "kaynooo-cli", `${bin}.json`);
+}
+
+// ../kit/src/theme.ts
+var DEFAULT = {
+  colors: { accent: "cyan", id: "yellow", path: "blue", label: "dim", value: "bold", ok: "green", warn: "yellow", problem: "red", note: "dim", passed: "green", failed: "red", running: "cyan", queued: "yellow", skipped: "dim" },
+  glyphs: { ok: "\u2713", warn: "\u25B2", problem: "\u2717", note: "\u203A", passed: "\u2713", failed: "\u2717", running: "\u25CF", queued: "\u25CB", skipped: "-", bar: "\u2501" },
+  accents: ["cyan", "magenta", "green", "blue", "yellow", "redBright"],
+  bins: {}
+};
+var BRIGHT = { accent: "cyanBright", id: "yellowBright", path: "blueBright", label: "white", value: "bold whiteBright", ok: "greenBright", warn: "yellowBright", problem: "redBright", note: "white", passed: "greenBright", failed: "redBright", running: "cyanBright", queued: "yellowBright", skipped: "white" };
+var MONO = { accent: "bold", id: "bold", path: "underline", label: "dim", value: "bold", ok: "bold", warn: "bold", problem: "bold", note: "dim", passed: "bold", failed: "bold", running: "bold", queued: "dim", skipped: "dim" };
+var ASCII = { ok: "+", warn: "!", problem: "x", note: ">", passed: "+", failed: "x", running: "*", queued: "o", skipped: "-", bar: "#" };
+var PRESETS = {
+  default: {},
+  "high-contrast": { colors: BRIGHT, accents: ["cyanBright", "magentaBright", "greenBright", "blueBright", "yellowBright", "redBright"] },
+  mono: { colors: MONO, accents: ["bold"] },
+  ascii: { glyphs: ASCII }
+};
+var STYLES = new Set(["bold", "dim", "italic", "underline", "inverse", "strikethrough", "black", "red", "green", "yellow", "blue", "magenta", "cyan", "white", "gray", "grey", "blackBright", "redBright", "greenBright", "yellowBright", "blueBright", "magentaBright", "cyanBright", "whiteBright"]);
+var HEX = /^#[0-9a-f]{6}$/i;
+var CONTROL = /\p{Cc}/u;
+var MAX_FILE_BYTES = 64 * 1024;
+var SPACES = /\s+/;
+function isColorSpec(spec) {
+  if (typeof spec === "number")
+    return Number.isInteger(spec) && spec >= 0 && spec <= 255;
+  return typeof spec === "string" && spec.trim() !== "" && spec.trim().split(SPACES).every((token) => STYLES.has(token) || HEX.test(token));
+}
+function tinted(colors, spec) {
+  if (typeof spec === "number")
+    return colors.ansi256(spec);
+  return spec.trim().split(SPACES).reduce((chain, token) => HEX.test(token) ? chain.hex(token) : chain[token] ?? chain, colors);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readThemeFile(path, warn) {
+  try {
+    const stat = statSync(path, { throwIfNoEntry: false });
+    if (stat === undefined)
+      return;
+    if (!stat.isFile() || stat.size > MAX_FILE_BYTES) {
+      warn(`${path} is not a regular file under ${MAX_FILE_BYTES / 1024} KiB, theme ignored`);
+      return;
+    }
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (isRecord(parsed))
+      return parsed;
+    warn(`${path} is not a JSON object, theme ignored`);
+  } catch (error) {
+    warn(`${path} does not parse (${error instanceof Error ? error.message : String(error)}), theme ignored`);
+  }
+  return;
+}
+function applyPreset(theme, name, warn, where) {
+  if (name === undefined)
+    return;
+  if (typeof name !== "string" || !Object.hasOwn(PRESETS, name)) {
+    warn(`${where}: no preset ${String(name)}, one of ${Object.keys(PRESETS).join(", ")}`);
+    return;
+  }
+  const preset = PRESETS[name];
+  Object.assign(theme.colors, preset.colors);
+  Object.assign(theme.glyphs, preset.glyphs);
+  if (preset.accents !== undefined)
+    theme.accents = [...preset.accents];
+  return name;
+}
+function applyFile(theme, file, where, warn) {
+  if (isRecord(file.colors)) {
+    for (const [key, value] of Object.entries(file.colors)) {
+      if (!Object.hasOwn(DEFAULT.colors, key))
+        warn(`${where}: no colour ${key}, one of ${Object.keys(DEFAULT.colors).join(", ")}`);
+      else if (!isColorSpec(value))
+        warn(`${where}: colour ${key} is not an ANSI name, \`#rrggbb\` or a number up to 255`);
+      else
+        theme.colors[key] = value;
+    }
+  }
+  if (isRecord(file.glyphs)) {
+    for (const [key, value] of Object.entries(file.glyphs)) {
+      if (!Object.hasOwn(DEFAULT.glyphs, key))
+        warn(`${where}: no glyph ${key}, one of ${Object.keys(DEFAULT.glyphs).join(", ")}`);
+      else if (typeof value !== "string" || CONTROL.test(value) || Bun.stringWidth(value) !== 1)
+        warn(`${where}: glyph ${key} must be one visible character wide, with no control character`);
+      else
+        theme.glyphs[key] = value;
+    }
+  }
+  if (Array.isArray(file.accents) && file.accents.length > 0 && file.accents.every(isColorSpec))
+    theme.accents = [...file.accents];
+  else if (file.accents !== undefined)
+    warn(`${where}: accents must be a non-empty list of colours`);
+  if (isRecord(file.bins)) {
+    for (const [bin, value] of Object.entries(file.bins)) {
+      if (isColorSpec(value))
+        theme.bins[bin] = value;
+      else
+        warn(`${where}: bin ${bin} has no valid colour`);
+    }
+  }
+}
+function endsWalk(home) {
+  return (dir) => dir === resolve2(home) || existsSync2(join3(dir, ".git"));
+}
+var warned = new Set;
+function warnOnce(message) {
+  if (warned.has(message))
+    return;
+  warned.add(message);
+  console.error(`warning: theme ${message}`);
+}
+function isPath(chosen) {
+  return chosen.includes("/") || chosen.endsWith(".json");
+}
+function loadTheme({ env = process4.env, from = process4.cwd(), home = homedir2(), warn = warnOnce } = {}) {
+  const theme = { colors: { ...DEFAULT.colors }, glyphs: { ...DEFAULT.glyphs }, accents: [...DEFAULT.accents], bins: Object.create(null) };
+  const sources = [];
+  const chosen = env.KIT_THEME ?? "";
+  const wanted = chosen === "" ? [userConfigPath("theme", { home, xdg: env.XDG_CONFIG_HOME }), findUp(join3(".kaynooo", "theme.json"), from, endsWalk(home))] : [];
+  if (isPath(chosen))
+    wanted.push(resolve2(from, chosen));
+  const files = [];
+  for (const path of wanted) {
+    const file = path === undefined ? undefined : readThemeFile(path, warn);
+    if (path !== undefined && file !== undefined)
+      files.push({ path, file });
+  }
+  let preset = "default";
+  if (chosen !== "" && !isPath(chosen)) {
+    preset = applyPreset(theme, chosen, warn, "KIT_THEME") ?? preset;
+  } else {
+    const named = files.findLast(({ file }) => file.preset !== undefined);
+    if (named !== undefined)
+      preset = applyPreset(theme, named.file.preset, warn, named.path) ?? preset;
+  }
+  for (const { path, file } of files) {
+    applyFile(theme, file, path, warn);
+    sources.push(path);
+  }
+  return { theme, sources, preset };
+}
+var current;
+var currentKey = "";
+function activeTheme() {
+  const key = `${process4.cwd()}\x00${process4.env.KIT_THEME ?? ""}\x00${process4.env.XDG_CONFIG_HOME ?? ""}`;
+  if (current === undefined || key !== currentKey) {
+    current = loadTheme();
+    currentKey = key;
+  }
+  return current;
+}
+
 // ../kit/src/style.ts
-function takesControlCodes(stream, env = process2.env) {
+function takesControlCodes(stream, env = process5.env) {
   return stream.isTTY === true && env.NO_COLOR === undefined && env.NODE_DISABLE_COLORS === undefined && env.TERM !== "dumb";
 }
-function paint(stream, env = process2.env) {
+function paint(stream, env = process5.env) {
   return le({ stream: { isTTY: takesControlCodes(stream, env) }, env });
 }
-var STATUSES = {
-  passed: { symbol: "\u2713", words: ["passed", "success", "succeeded", "ok"], paint: (colors) => colors.green },
-  failed: { symbol: "\u2717", words: ["failed", "failure", "error", "errored"], paint: (colors) => colors.red },
-  running: { symbol: "\u25CF", words: ["running", "in_progress", "started"], paint: (colors) => colors.cyan },
-  queued: { symbol: "\u25CB", words: ["queued", "waiting", "pending", "created", "blocked", "scheduled"], paint: (colors) => colors.yellow },
-  skipped: { symbol: "-", words: ["skipped", "cancelled", "canceled", "manual"], paint: (colors) => colors.dim }
+function role(name, stream, env = process5.env) {
+  const colors = paint(stream, env);
+  return takesControlCodes(stream, env) ? tinted(colors, activeTheme().theme.colors[name]) : colors;
+}
+var STATUS_WORDS = {
+  passed: ["passed", "success", "succeeded", "ok"],
+  failed: ["failed", "failure", "error", "errored"],
+  running: ["running", "in_progress", "started"],
+  queued: ["queued", "waiting", "pending", "created", "blocked", "scheduled"],
+  skipped: ["skipped", "cancelled", "canceled", "manual"]
 };
-var STATUS_OF = new Map(Object.entries(STATUSES).flatMap(([status, { words }]) => words.map((word) => [word, status])));
+var STATUS_OF = new Map(Object.entries(STATUS_WORDS).flatMap(([status, words]) => words.map((word) => [word, status])));
 
 // ../kit/src/format.ts
 function upTo(text, separator) {
@@ -298,27 +486,27 @@ function printJson(value) {
 }
 
 // ../kit/src/help.ts
-import process3 from "process";
+import process6 from "process";
 var OPTIONAL = /\[[^\]]+\]/g;
 var USAGE_PREFIX = /^usage:\s*/i;
 var FULL_STOP = /\.$/;
-function usageLine(usage, colors = paint(process3.stdout)) {
+function usageLine(usage, colors = paint(process6.stdout)) {
   return `${colors.bold("Usage:")} ${usage.replace(USAGE_PREFIX, "").replaceAll(OPTIONAL, (part) => colors.dim(part))}`;
 }
-function helpText(usage, options, colors = paint(process3.stdout), { examples = [], replaces, exits = [] } = {}) {
+function helpText(usage, options, colors = paint(process6.stdout), { examples = [], replaces, exits = [] } = {}) {
   return [usageLine(usage, colors), ...replacesRows(replaces, colors), "", colors.bold("Options:"), ...optionRows(options, colors), ...exitRows(exits, colors), ...exampleRows(examples, colors)].join(`
 `);
 }
-function exitRows(exits, colors = paint(process3.stdout)) {
+function exitRows(exits, colors = paint(process6.stdout)) {
   if (exits.length === 0)
     return [];
   const width = Math.max(...exits.map(([code]) => String(code).length));
   return ["", colors.bold("Exits:"), ...exits.map(([code, meaning]) => `  ${colors.cyan(String(code).padEnd(width))}  ${meaning}`)];
 }
-function replacesRows(replaces, colors = paint(process3.stdout)) {
+function replacesRows(replaces, colors = paint(process6.stdout)) {
   return replaces === undefined ? [] : ["", `${colors.bold("Instead of:")} ${replaces}`];
 }
-function wantsHelpJson(env = process3.env) {
+function wantsHelpJson(env = process6.env) {
   return env.KIT_HELP === "json";
 }
 function description(usage, { examples = [], replaces, exits } = {}, options) {
@@ -337,12 +525,12 @@ function description(usage, { examples = [], replaces, exits } = {}, options) {
     ...options === undefined ? {} : { options: Object.entries(options).map(([name, { short, description }]) => ({ name, ...short === undefined ? {} : { short }, ...description === undefined ? {} : { description } })) }
   };
 }
-function exampleRows(examples, colors = paint(process3.stdout)) {
+function exampleRows(examples, colors = paint(process6.stdout)) {
   if (examples.length === 0)
     return [];
   return ["", colors.bold("Examples:"), ...examples.map((example) => typeof example === "string" ? `  ${example}` : `  ${example[0]}  ${colors.dim(`# ${example[1]}`)}`)];
 }
-function optionRows(options, colors = paint(process3.stdout)) {
+function optionRows(options, colors = paint(process6.stdout)) {
   const rows = Object.entries(options).map(([name, option]) => {
     const short = option.short === undefined ? "    " : `${colors.cyan(`-${option.short}`)}, `;
     const named = option.choices === undefined ? "<value>" : `<${option.choices.join("|")}>`;
@@ -436,7 +624,7 @@ var OUTPUT_OPTIONS = {
   color: { type: "string", description: "auto (on a terminal alone), always or never" },
   plain: { type: "boolean", description: "plain text, no colour or spinner: --color never" }
 };
-function applyOutput(color, plain, env = process4.env) {
+function applyOutput(color, plain, env = process7.env) {
   const when = plain === true ? "never" : color ?? "auto";
   if (when === "auto")
     return;
@@ -611,15 +799,15 @@ var ESCAPE_CODE = new RegExp(`${ESC}(?:\\[[\\x30-\\x3F]*[\\x20-\\x2F]*[\\x40-\\x
 var RESET_STYLE = `${ESC}[0m`;
 var CLOSE_LINK = `${ESC}]8;;${ESC}\\`;
 // ../kit/src/cli.ts
-import { readFileSync, realpathSync } from "fs";
-import { dirname as dirname2, join as join2 } from "path";
-import process6 from "process";
+import { readFileSync as readFileSync2, realpathSync } from "fs";
+import { dirname as dirname3, join as join5 } from "path";
+import process9 from "process";
 
 // ../kit/src/usage.ts
 import { appendFileSync, mkdirSync } from "fs";
-import { homedir } from "os";
-import { dirname, isAbsolute, join } from "path";
-import process5 from "process";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname2, isAbsolute, join as join4 } from "path";
+import process8 from "process";
 
 // ../kit/src/logs.ts
 var DAY_MS = 24 * 60 * 60 * 1000;
@@ -633,14 +821,14 @@ var usageError;
 function noteUsageError(message) {
   usageError = message;
 }
-function stateHome(env = process5.env) {
+function stateHome(env = process8.env) {
   const dir = env.XDG_STATE_HOME;
-  return dir !== undefined && isAbsolute(dir) ? dir : join(homedir(), ".local", "state");
+  return dir !== undefined && isAbsolute(dir) ? dir : join4(homedir3(), ".local", "state");
 }
-function usagePath(env = process5.env) {
-  return join(stateHome(env), CLI_FOLDER, "usage.jsonl");
+function usagePath(env = process8.env) {
+  return join4(stateHome(env), CLI_FOLDER, "usage.jsonl");
 }
-function usageRecorded(env = process5.env) {
+function usageRecorded(env = process8.env) {
   const off = env.KAYNOOO_CLI_NO_USAGE;
   return env.NODE_ENV !== "test" && (off === undefined || off === "" || off === "0");
 }
@@ -654,12 +842,12 @@ function usageEntry(bin, command, argv, code, now = new Date) {
   usageError = undefined;
   return { at: now.toISOString(), bin, ...command === undefined ? {} : { command }, flags: flagNames(argv), code, ...unknown === undefined ? {} : { unknown } };
 }
-function recordUsage(entry, env = process5.env) {
+function recordUsage(entry, env = process8.env) {
   if (!usageRecorded(env))
     return;
   try {
     const path = usagePath(env);
-    mkdirSync(dirname(path), { recursive: true, mode: 448 });
+    mkdirSync(dirname2(path), { recursive: true, mode: 448 });
     appendFileSync(path, `${JSON.stringify(entry)}
 `, { mode: 384 });
   } catch {}
@@ -672,8 +860,8 @@ var LEVEL_OPTIONS = {
 };
 var TOP_OPTIONS = { ...LEVEL_OPTIONS, version: { type: "boolean", short: "v", description: "print the version" } };
 function printError(prefix, message, hint, cause) {
-  const colors = paint(process6.stderr);
-  const styled = takesControlCodes(process6.stderr);
+  const colors = paint(process9.stderr);
+  const styled = takesControlCodes(process9.stderr);
   const head = styled ? `${colors.red.bold("error")} ${colors.dim(`${prefix}:`)}` : `error: ${prefix}:`;
   const under = (label, text, tint) => text === undefined ? "" : `
   ${styled ? tint(label) : `${label}:`} ${text}`;
@@ -692,7 +880,7 @@ function reportThrown(prefix, error, redact = (text) => text, json = false) {
   const help = error instanceof UsageError ? `run ${prefix} --help for its options` : undefined;
   const named = error instanceof Error && !(error instanceof Exit) && error.name !== "Error" ? `${error.name}: ${error.message}` : undefined;
   const cause = error instanceof Error && error.cause instanceof Error ? redact(error.cause.message) : undefined;
-  if (error instanceof UsageError)
+  if (error instanceof Exit && error.code === 2)
     noteUsageError(error.message);
   const report = json ? printJsonError : (message, hint, causeText) => printError(prefix, message, hint, causeText);
   report(redact(named ?? (error instanceof Error ? error.message : String(error))), error instanceof Exit ? error.hint ?? help : undefined, cause);
@@ -756,17 +944,17 @@ async function printCandidates(found) {
   return 0;
 }
 function packageVersion(entry = Bun.main) {
-  for (let dir = dirname2(realpathSync(entry));; dir = dirname2(dir)) {
+  for (let dir = dirname3(realpathSync(entry));; dir = dirname3(dir)) {
     try {
-      const { version } = JSON.parse(readFileSync(join2(dir, "package.json"), "utf8"));
+      const { version } = JSON.parse(readFileSync2(join5(dir, "package.json"), "utf8"));
       if (typeof version === "string")
         return version;
     } catch {}
-    if (dirname2(dir) === dir)
+    if (dirname3(dir) === dir)
       return "0.0.0";
   }
 }
-async function runMain({ name, version, run, redact, usage }, argv = process6.argv.slice(2)) {
+async function runMain({ name, version, run, redact, usage }, argv = process9.argv.slice(2)) {
   if (argv[0] === COMPLETE)
     return printCandidates(leafCandidates(run, argv.slice(1)));
   if (argv.length === 1 && (argv[0] === "--version" || argv[0] === "-v")) {
@@ -809,11 +997,11 @@ var {Glob } = globalThis.Bun;
 var SESSION_FILES = new Glob("*.json");
 var ACCOUNT_DIRS = new Glob("*/sessions");
 // src/dx.ts
-import process10 from "process";
+import process15 from "process";
 
 // ../env/src/files.ts
 import { chmod, chown, readdir, realpath, rename, rm, stat, writeFile } from "fs/promises";
-import { basename, dirname as dirname3, join as join3 } from "path";
+import { basename, dirname as dirname4, join as join6 } from "path";
 
 // ../env/src/dotenv.ts
 var ASSIGNMENT = /^\s*(?:export\s+)?([A-Z_][\w.-]*)\s*=(.*)$/i;
@@ -1084,7 +1272,7 @@ async function envFilesBelow(folder, depth = 0) {
     return found;
   }
   for (const entry of children) {
-    const path = join3(folder, entry.name);
+    const path = join6(folder, entry.name);
     if (entry.isDirectory() && depth < KNOWN_DEPTH && !SKIPPED.has(entry.name))
       found.push(...await envFilesBelow(path, depth + 1));
     else if (ENV_FILE.test(entry.name) && await isFileEntry(entry, path))
@@ -1161,11 +1349,630 @@ class Redactor {
   }
 }
 
-// ../kit/src/fzf.ts
-import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { dirname as dirname4, join as join4 } from "path";
-import process8 from "process";
+// ../kit/src/picker.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname5, join as join7 } from "path";
+import process13 from "process";
+
+// ../kit/src/picker/score.ts
+var MATCH = 16;
+var CONSECUTIVE = 12;
+var BOUNDARY = 10;
+var PREFIX = 8;
+var GAP = 1;
+var BOUNDARY_AFTER = new Set([" ", "/", "-", "_", ".", ":", "\\", "(", "[", ",", "\t"]);
+var UPPER = /\p{Lu}/u;
+var LOWER = /\p{Ll}/u;
+var NONE = Number.NEGATIVE_INFINITY;
+function startsWord(text, index) {
+  if (index === 0)
+    return true;
+  const before = text[index - 1];
+  return BOUNDARY_AFTER.has(before) || LOWER.test(before) && UPPER.test(text[index]);
+}
+function fuzzy(query, text) {
+  if (query === "")
+    return { score: 0, positions: [] };
+  const exact = query !== query.toLowerCase();
+  const needle = exact ? query : query.toLowerCase();
+  const haystack = exact ? text : text.toLowerCase();
+  if (haystack.length !== text.length || needle.length > haystack.length)
+    return;
+  const width = haystack.length;
+  const best = Array.from({ length: needle.length }, () => new Array(width).fill(NONE));
+  const from = Array.from({ length: needle.length }, () => new Array(width).fill(-1));
+  for (let j = 0;j < needle.length; j++) {
+    let run = NONE;
+    let runAt = -1;
+    for (let i = j;i < width; i++) {
+      if (j > 0 && i - 2 >= j - 1) {
+        const candidate = best[j - 1][i - 2] + (i - 2) * GAP;
+        if (candidate > run) {
+          run = candidate;
+          runAt = i - 2;
+        }
+      }
+      if (haystack[i] !== needle[j])
+        continue;
+      const here = MATCH + (startsWord(text, i) ? BOUNDARY : 0) + (i === 0 ? PREFIX : 0);
+      if (j === 0) {
+        best[0][i] = here - i * GAP;
+        continue;
+      }
+      const joined = best[j - 1][i - 1] + CONSECUTIVE;
+      const skipped = run - (i - 1) * GAP;
+      if (joined > NONE && joined >= skipped) {
+        best[j][i] = joined + here;
+        from[j][i] = i - 1;
+      } else if (skipped > NONE) {
+        best[j][i] = skipped + here;
+        from[j][i] = runAt;
+      }
+    }
+  }
+  const last = best[needle.length - 1];
+  let end = -1;
+  for (let i = 0;i < width; i++) {
+    if (last[i] > NONE && (end === -1 || last[i] > last[end]))
+      end = i;
+  }
+  if (end === -1)
+    return;
+  const positions = [];
+  for (let j = needle.length - 1, i = end;j >= 0; j--) {
+    positions.unshift(i);
+    i = from[j][i];
+  }
+  return { score: last[end], positions };
+}
+function rank(query, lines) {
+  if (query === "")
+    return lines.map((_, index) => ({ index, positions: [] }));
+  const found = [];
+  for (const [index, line] of lines.entries()) {
+    const match = fuzzy(query, line);
+    if (match !== undefined)
+      found.push({ index, positions: match.positions, score: match.score });
+  }
+  return found.sort((a, b) => b.score - a.score || lines[a.index].length - lines[b.index].length || a.index - b.index);
+}
+
+// ../kit/src/picker/state.ts
+var ANSI2 = /\x1B(?:\[[\x30-\x3F]*[\x20-\x2F]*[\x40-\x7E]|\][^\x07\x1B]*(?:\x07|\x1B\\)|[\x40-\x5A\x5C-\x5F])/g;
+var CONTROL2 = /[\x00-\x1F\x7F-\x9F]/g;
+var IS_CONTROL = /[\x00-\x1F\x7F-\x9F]/;
+var SGR = /^\x1B\[[0-9;]*m$/;
+var RESET = /^\x1B\[0?m$/;
+var COLUMN_GAP = 2;
+var PASTE_START = "\x1B[200~";
+var PASTE_END = "\x1B[201~";
+var LAST_WORD = /\S*\s*$/;
+var KEY_SEQUENCES = /\x1B\[[0-9;]*[A-Z~]|\x1BO[A-Z]|\x1B[\s\S]|[\s\S]/gu;
+var KEYS = {
+  "\x1B[A": "up",
+  "\x1BOA": "up",
+  "\x10": "up",
+  "\x1B[B": "down",
+  "\x1BOB": "down",
+  "\x0E": "down",
+  "\r": "enter",
+  "\n": "enter",
+  "\x03": "cancel",
+  "\x1B": "cancel",
+  "\x7F": "erase",
+  "\b": "erase",
+  "\x15": "clear",
+  "\x17": "word",
+  "\t": "tab"
+};
+var CTRL_KEY = /^ctrl-[abd-gkln-z]$/;
+function repeat(value, count) {
+  return Array.from({ length: count }).fill(value);
+}
+function styled(line) {
+  let text = "";
+  const styles = [];
+  let active = "";
+  let colored = false;
+  let last = 0;
+  function add(chunk) {
+    const flat = chunk.replace(CONTROL2, " ");
+    text += flat;
+    colored ||= active !== "" && flat !== "";
+    styles.push(...repeat(active, flat.length));
+  }
+  for (const found of line.matchAll(ANSI2)) {
+    add(line.slice(last, found.index));
+    last = found.index + found[0].length;
+    if (SGR.test(found[0]))
+      active = RESET.test(found[0]) ? "" : active + found[0];
+  }
+  add(line.slice(last));
+  return { text, styles: colored ? styles : undefined };
+}
+function lay(rows, searched) {
+  const parsed = rows.map((row) => row.cells.map(styled));
+  const widths = (parsed[0] ?? []).map((_, column) => Math.max(...parsed.map((cells) => Bun.stringWidth(cells[column]?.text ?? ""))));
+  return parsed.map((cells) => {
+    let text = "";
+    const styles = [];
+    let colored = false;
+    let searchEnd = 0;
+    for (const [column, cell] of cells.entries()) {
+      const last = column === cells.length - 1;
+      const shown = cells.length > 1 && last ? cell.text.trimEnd() : cell.text;
+      text += shown;
+      colored ||= cell.styles !== undefined;
+      styles.push(...cell.styles?.slice(0, shown.length) ?? repeat("", shown.length));
+      if (column < searched)
+        searchEnd = cells.length > 1 ? text.trimEnd().length : text.length;
+      if (!last) {
+        const pad = widths[column] - Bun.stringWidth(cell.text) + COLUMN_GAP;
+        text += " ".repeat(pad);
+        styles.push(...repeat("", pad));
+      }
+    }
+    return { text, styles: colored ? styles : undefined, searchable: text.slice(0, searchEnd) };
+  });
+}
+function parseKeys(input, paste = { active: false }, ctrls = []) {
+  const codes = new Map(ctrls.map((name) => [String.fromCharCode(name.codePointAt(name.length - 1) - 96), name]));
+  return (input.match(KEY_SEQUENCES) ?? []).flatMap((sequence) => {
+    const named = codes.get(sequence);
+    const key = named === undefined ? KEYS[sequence] : { ctrl: named };
+    if (sequence === PASTE_START || sequence === PASTE_END) {
+      paste.active = sequence === PASTE_START;
+      return [];
+    }
+    if (paste.active && (sequence === "\r" || sequence === `
+`))
+      return [];
+    if (key !== undefined)
+      return [key];
+    return IS_CONTROL.test(sequence) || sequence.startsWith("\x1B") ? [] : [{ text: sequence }];
+  });
+}
+function createState(rows, { multi = false, prompt = "> ", query = "", header = "", expect = [], searched = Number.POSITIVE_INFINITY } = {}) {
+  const state = { rows: [], items: [], styles: [], searchable: [], searched, header, expect, key: "", status: "", query, matches: [], cursor: 0, marked: new Set, multi, prompt, done: undefined };
+  return withRows(state, rows);
+}
+function withRows(state, rows, header = state.header) {
+  const cells = rows.map((row) => typeof row === "string" ? { hidden: [], cells: [row] } : row);
+  const laid = lay(cells, state.searched);
+  const searchable = laid.map((row) => row.searchable);
+  const matches = rank(state.query, searchable);
+  return { ...state, rows: cells, items: laid.map((row) => row.text), styles: laid.map((row) => row.styles), searchable, header, matches, cursor: Math.max(0, Math.min(matches.length - 1, state.cursor)), marked: new Set };
+}
+function withQuery(state, query) {
+  return { ...state, query, matches: rank(query, state.searchable), cursor: 0 };
+}
+function move(state, by) {
+  return { ...state, cursor: Math.max(0, Math.min(state.matches.length - 1, state.cursor + by)) };
+}
+function highlighted(state) {
+  return state.matches[state.cursor]?.index;
+}
+function press(state, key) {
+  if (state.done !== undefined)
+    return state;
+  if (typeof key === "object") {
+    if ("text" in key)
+      return withQuery(state, state.query + key.text);
+    return state.expect.includes(key.ctrl) ? { ...state, done: "accept", key: key.ctrl } : state;
+  }
+  switch (key) {
+    case "up":
+      return move(state, -1);
+    case "down":
+      return move(state, 1);
+    case "cancel":
+      return { ...state, done: "cancel" };
+    case "erase":
+      return withQuery(state, [...state.query].slice(0, -1).join(""));
+    case "clear":
+      return withQuery(state, "");
+    case "word":
+      return withQuery(state, state.query.replace(LAST_WORD, ""));
+    case "enter":
+      return state.matches.length === 0 && state.marked.size === 0 ? state : { ...state, done: "accept" };
+    case "tab": {
+      const at = highlighted(state);
+      if (!state.multi || at === undefined)
+        return state;
+      const marked = new Set(state.marked);
+      if (!marked.delete(at))
+        marked.add(at);
+      return move({ ...state, marked }, 1);
+    }
+  }
+}
+function chosen(state) {
+  if (state.marked.size > 0)
+    return state.rows.filter((_, index) => state.marked.has(index));
+  const at = highlighted(state);
+  return at === undefined ? [] : [state.rows[at]];
+}
+
+// ../kit/src/picker/terminal.ts
+import { openSync } from "fs";
+import process12 from "process";
+import tty from "tty";
+
+// ../kit/src/picker/preview.ts
+import process11 from "process";
+
+// ../kit/src/shell.ts
+var SEPARATORS = new Set([`
+`, ";", "|"]);
+var PLAIN_BREAKERS = new Set(["<", ">", "(", ")", "&", "|"]);
+var GLOB_CHARS = new Set(["*", "?", "["]);
+var COMMENT_PREFIXES = new Set([";", "&", "|", "(", ")"]);
+var SAFE_WORD = /^[\w@%+=:,./-]+$/;
+var DOUBLE_QUOTED_ESCAPES = new Set(["$", "`", '"', "\\"]);
+var KEYWORDS = new Set(["then", "do", "else", "if", "elif", "while", "until", "!", "{", "}"]);
+var SHELLS = new Set(["sh", "bash", "zsh", "dash", "ash", "ksh", "fish", "csh", "tcsh", "nu", "xonsh", "elvish", "pwsh", "powershell"]);
+var SCANNED_PROGRAMS = new Set(["su", "runuser", "flock"]);
+var COMMAND_STRING_PROGRAMS = new Set([...SHELLS, ...SCANNED_PROGRAMS]);
+var POWERSHELL = new Set(["pwsh", "powershell"]);
+var SHELL_VALUE_OPTIONS = new Set(["-o", "-O", "--rcfile", "--init-file"]);
+var FISH_VALUE_OPTIONS = new Set(["-C", "--init-command"]);
+var PRINTERS = new Set(["echo", "printf"]);
+var FIND_EXEC = new Set(["-exec", "-execdir", "-ok", "-okdir"]);
+function wrapper(short = "", long = [], operands = 0, runsString = false) {
+  return { short, long, operands, runsString };
+}
+var WRAPPERS = new Map([
+  ["command", wrapper()],
+  ["builtin", wrapper()],
+  ["nohup", wrapper()],
+  ["setsid", wrapper()],
+  ["busybox", wrapper()],
+  ["exec", wrapper("a")],
+  ["time", wrapper("fo", ["--format", "--output"])],
+  ["env", wrapper("uCS", ["--unset", "--chdir", "--split-string", "--argv0"])],
+  ["sudo", wrapper("ughpCTrtUDR", ["--user", "--group", "--host", "--prompt", "--close-from", "--command-timeout", "--role", "--type", "--other-user", "--chdir", "--chroot"])],
+  ["doas", wrapper("uC")],
+  ["timeout", wrapper("sk", ["--signal", "--kill-after"], 1)],
+  ["nice", wrapper("n", ["--adjustment"])],
+  ["ionice", wrapper("cnpPu", ["--class", "--classdata", "--pid", "--pgid", "--uid"])],
+  ["stdbuf", wrapper("ioe", ["--input", "--output", "--error"])],
+  ["chroot", wrapper("", ["--userspec", "--groups"], 1)],
+  ["watch", wrapper("n", ["--interval"], 0, true)],
+  ["flock", wrapper("wE", ["--timeout", "--conflict-exit-code"], 1)],
+  ["parallel", wrapper("jnNSaIPlLdTsC", ["--jobs", "--max-args", "--max-replace-args", "--sshlogin", "--arg-file", "--delimiter", "--colsep"], 0, true)],
+  ["unbuffer", wrapper()],
+  ["systemd-run", wrapper("puEMH", ["--property", "--unit", "--description", "--slice", "--setenv", "--machine", "--host", "--uid", "--gid", "--working-directory", "--nice", "--service-type"])],
+  ["xargs", wrapper("IndsEaPL", ["--max-args", "--max-procs", "--max-chars", "--delimiter", "--arg-file", "--eof", "--max-lines", "--process-slot-var"])]
+]);
+function shellQuote(word) {
+  return SAFE_WORD.test(word) && !word.startsWith("=") ? word : `'${word.replaceAll("'", "'\\''")}'`;
+}
+
+// ../kit/src/picker/preview.ts
+var PREVIEW_BYTES = 64 * 1024;
+var PREVIEW_LINES = 200;
+var PREVIEW_TIMEOUT_MS = 3000;
+var PLACEHOLDER2 = /\{([1-9]\d*)?\}/g;
+function previewCommand(template, line, hidden = []) {
+  return template.replace(PLACEHOLDER2, (_, field) => shellQuote(field === undefined ? line : hidden[Number(field) - 1] ?? ""));
+}
+function previewLines(output) {
+  const lines = output.split(`
+`);
+  if (lines.at(-1) === "")
+    lines.pop();
+  return lines.slice(0, PREVIEW_LINES);
+}
+async function runPreview(template, line, signal, hidden = []) {
+  const proc = Bun.spawn(["sh", "-c", `exec 2>&1
+${previewCommand(template, line, hidden)}`], { stdin: "ignore", stdout: "pipe", stderr: "ignore", detached: true });
+  const stop = () => {
+    try {
+      process11.kill(-proc.pid, "SIGKILL");
+    } catch {
+      proc.kill();
+    }
+  };
+  const timer = setTimeout(stop, PREVIEW_TIMEOUT_MS);
+  const chunks = [];
+  let size = 0;
+  signal.addEventListener("abort", stop);
+  try {
+    for await (const chunk of proc.stdout) {
+      chunks.push(chunk);
+      size += chunk.length;
+      if (size >= PREVIEW_BYTES) {
+        stop();
+        break;
+      }
+    }
+  } finally {
+    clearTimeout(timer);
+    signal.removeEventListener("abort", stop);
+  }
+  return signal.aborted ? [] : previewLines(Buffer.concat(chunks).subarray(0, PREVIEW_BYTES).toString());
+}
+
+// ../kit/src/picker/view.ts
+var MIN_HEIGHT = 4;
+var PREVIEW_MIN_COLUMNS = 80;
+var PREVIEW_MIN_ROWS = 10;
+var PREVIEW_SHARE = 0.4;
+var RESET2 = "\x1B[0m";
+var SEPARATOR = " \u2502 ";
+var HEIGHT = /^(\d+)(%?)$/;
+function parseHeight(text) {
+  const found = HEIGHT.exec(text);
+  if (found === null || Number(found[1]) < 1)
+    return;
+  return found[2] === "%" ? { percent: Math.min(100, Number(found[1])) } : { lines: Number(found[1]) };
+}
+function layoutFor(size, height, previewing, position = "right") {
+  const wanted = "lines" in height ? height.lines : Math.round(size.rows * height.percent / 100);
+  const rows = Math.min(size.rows, Math.max(MIN_HEIGHT, wanted));
+  if (position === "down") {
+    const previewHeight = previewing && rows >= PREVIEW_MIN_ROWS ? Math.round(rows * PREVIEW_SHARE) : 0;
+    return { height: rows, listHeight: rows - previewHeight, listWidth: size.columns, previewWidth: 0, previewHeight };
+  }
+  const split = previewing && size.columns >= PREVIEW_MIN_COLUMNS;
+  const listWidth = split ? Math.floor(size.columns / 2) : size.columns;
+  return { height: rows, listHeight: rows, listWidth, previewWidth: split ? size.columns - listWidth - SEPARATOR.length : 0, previewHeight: 0 };
+}
+function fit(text, width, plain, mark = plain, marked = new Set, styles) {
+  const room = Bun.stringWidth(text) > width ? width - 1 : width;
+  let out = "";
+  let used = 0;
+  let at = 0;
+  for (const char of text) {
+    const size = Bun.stringWidth(char);
+    if (used + size > room)
+      break;
+    const style = marked.has(at) ? "" : styles?.[at] ?? "";
+    out += style === "" ? (marked.has(at) ? mark : plain)(char) : `${style}${char}${RESET2}`;
+    used += size;
+    at += char.length;
+  }
+  if (room < width) {
+    out += plain("\u2026");
+    used += 1;
+  }
+  return { text: out, width: used };
+}
+var identity = (text) => text;
+function fitStyled(line, width, plain = identity) {
+  const { text, styles } = styled(line);
+  return fit(text, width, plain, plain, new Set, styles);
+}
+function caretColumn(state, layout) {
+  return Math.min(layout.listWidth, Bun.stringWidth(state.prompt) + Bun.stringWidth(state.query) + 1);
+}
+function listLines(state, layout, theme) {
+  const header = state.header === "" ? [] : state.header.split(`
+`).map((line) => fitStyled(line, layout.listWidth, theme.label));
+  const rows = Math.max(1, layout.listHeight - 2 - header.length);
+  const prefixWidth = state.multi ? 4 : 2;
+  const top = Math.max(0, Math.min(state.cursor - Math.floor(rows / 2), state.matches.length - rows));
+  const marks = (state.marked.size > 0 ? ` (${state.marked.size} marked)` : "") + (state.status === "" ? "" : ` ${state.status}`);
+  const promptWidth = Bun.stringWidth(state.prompt);
+  const query = fit(state.query, Math.max(1, layout.listWidth - promptWidth), identity);
+  const count = fit(`  ${state.matches.length}/${state.items.length}${marks}`, layout.listWidth, theme.label);
+  const lines = [{ text: theme.accent(state.prompt) + query.text, width: promptWidth + query.width }, count, ...header];
+  if (state.matches.length === 0)
+    lines.push(fit("  no match", layout.listWidth, theme.label));
+  for (const [offset, match] of state.matches.slice(top, top + rows).entries()) {
+    const current = top + offset === state.cursor;
+    const pointer = current ? theme.accent("\u276F") : " ";
+    const mark = state.multi ? `${state.marked.has(match.index) ? theme.id("\u25CF") : " "} ` : "";
+    const text = fit(state.items[match.index], layout.listWidth - prefixWidth, current ? theme.value : identity, theme.accent, new Set(match.positions), state.styles[match.index]);
+    lines.push({ text: `${pointer} ${mark}${text.text}`, width: prefixWidth + text.width });
+  }
+  return lines;
+}
+function render(state, layout, theme, preview = []) {
+  const left = listLines(state, layout, theme);
+  return Array.from({ length: layout.height }, (_, row) => {
+    if (row >= layout.listHeight)
+      return row === layout.listHeight ? theme.label("\u2500".repeat(layout.listWidth)) : fitStyled(preview[row - layout.listHeight - 1] ?? "", layout.listWidth).text;
+    const list = left[row] ?? { text: "", width: 0 };
+    if (layout.previewWidth === 0)
+      return list.text;
+    return `${list.text}${" ".repeat(Math.max(0, layout.listWidth - list.width))}${theme.label(SEPARATOR)}${fitStyled(preview[row] ?? "", layout.previewWidth).text}`;
+  });
+}
+
+// ../kit/src/picker/terminal.ts
+var PREVIEW_DELAY_MS = 120;
+var OPEN = { ctrl: "open" };
+var HIDE_CURSOR = "\x1B[?25l";
+var SHOW_CURSOR = "\x1B[?25h";
+var PASTE_ON = "\x1B[?2004h";
+var PASTE_OFF = "\x1B[?2004l";
+var CLEAR_BELOW = "\r\x1B[J";
+var SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+function up(lines) {
+  return lines > 0 ? `\x1B[${lines}A` : "";
+}
+function openTerminal() {
+  let input;
+  try {
+    input = new tty.ReadStream(openSync("/dev/tty", "r"));
+  } catch {
+    return fail("no terminal to read keys from (/dev/tty)");
+  }
+  const out = process12.stderr;
+  let resize;
+  return {
+    get columns() {
+      return out.columns || 80;
+    },
+    get rows() {
+      return out.rows || 24;
+    },
+    theme: { accent: role("accent", out), label: role("label", out), value: role("value", out), id: role("id", out) },
+    write: (text) => void out.write(text),
+    listen(onChunk, onResize) {
+      resize = onResize;
+      input.setRawMode(true);
+      out.on("resize", onResize);
+      input.on("data", (chunk) => onChunk(chunk.toString()));
+    },
+    close() {
+      if (resize !== undefined)
+        out.off("resize", resize);
+      try {
+        input.setRawMode(false);
+      } finally {
+        input.destroy();
+      }
+    }
+  };
+}
+async function select(rows, settings, terminal = openTerminal()) {
+  const { theme } = terminal;
+  let state = createState(rows, settings);
+  let preview = [];
+  let reserved = 0;
+  let previewTimer;
+  let previewing = new AbortController;
+  let shownLine;
+  let finish;
+  let restored = false;
+  function draw(clear = false) {
+    if (restored)
+      return;
+    const layout = layoutFor({ columns: terminal.columns, rows: terminal.rows }, settings.height, settings.preview !== undefined, settings.previewPosition);
+    let frame = HIDE_CURSOR;
+    if (reserved !== layout.height || clear) {
+      frame += CLEAR_BELOW + `
+`.repeat(layout.height - 1) + up(layout.height - 1);
+      reserved = layout.height;
+    }
+    frame += `\r${render(state, layout, theme, preview).map((line) => `\x1B[2K${line}`).join(`
+`)}${up(layout.height - 1)}\r\x1B[${caretColumn(state, layout)}G${SHOW_CURSOR}`;
+    terminal.write(frame);
+  }
+  function refreshPreview() {
+    const at = highlighted(state);
+    if (settings.preview === undefined || at === shownLine)
+      return;
+    shownLine = at;
+    clearTimeout(previewTimer);
+    previewing.abort();
+    previewing = new AbortController;
+    if (at === undefined) {
+      preview = [];
+      return;
+    }
+    const { signal } = previewing;
+    const template = settings.preview;
+    const row = state.rows[at];
+    async function show() {
+      const shown = typeof template === "string" ? await runPreview(template, row.cells.join(" "), signal, row.hidden) : await previewOf(template, row.hidden, signal);
+      if (!signal.aborted) {
+        preview = shown;
+        draw();
+      }
+    }
+    previewTimer = setTimeout(() => void show(), PREVIEW_DELAY_MS);
+  }
+  function restore() {
+    if (restored)
+      return;
+    restored = true;
+    clearTimeout(previewTimer);
+    previewing.abort();
+    terminal.write(`${CLEAR_BELOW}${PASTE_OFF}${SHOW_CURSOR}`);
+    terminal.close();
+  }
+  const stop = () => {
+    state = { ...state, done: "cancel" };
+    finish?.();
+  };
+  const paste = { active: false };
+  const { reload } = settings;
+  const pending = [];
+  let busy = false;
+  let draining = false;
+  async function reloadRows() {
+    if (reload === undefined)
+      return;
+    busy = true;
+    state = { ...state, status: "reloading" };
+    draw();
+    try {
+      const next = await reload.run();
+      state = { ...withRows(state, next.rows, next.header), status: "" };
+      shownLine = undefined;
+    } catch (error) {
+      state = { ...state, status: `reload failed: ${error instanceof Error ? error.message : String(error)}` };
+    } finally {
+      busy = false;
+    }
+  }
+  async function drain() {
+    if (draining)
+      return;
+    draining = true;
+    try {
+      for (let key = pending.shift();key !== undefined && state.done === undefined; key = pending.shift()) {
+        if (key === OPEN || typeof key === "object" && "ctrl" in key && key.ctrl === reload?.key)
+          await reloadRows();
+        else
+          state = press(state, key);
+      }
+    } finally {
+      draining = false;
+    }
+    if (state.done !== undefined) {
+      finish?.();
+      return;
+    }
+    refreshPreview();
+    draw();
+  }
+  function onChunk(chunk) {
+    const keys = parseKeys(chunk, paste, [...settings.expect ?? [], ...reload?.key === undefined ? [] : [reload.key]]);
+    if (busy && keys.includes("cancel")) {
+      stop();
+      return;
+    }
+    pending.push(...keys);
+    drain();
+  }
+  const ended = new Promise((resolve) => {
+    finish = resolve;
+  });
+  process12.once("exit", restore);
+  for (const signal of SIGNALS)
+    process12.once(signal, stop);
+  try {
+    terminal.write(PASTE_ON);
+    terminal.listen(onChunk, () => draw(true));
+    refreshPreview();
+    draw(true);
+    if (reload?.onOpen === true) {
+      pending.push(OPEN);
+      drain();
+    }
+    await ended;
+  } finally {
+    for (const signal of SIGNALS)
+      process12.off(signal, stop);
+    process12.off("exit", restore);
+    restore();
+  }
+  return state.done === "accept" ? { rows: chosen(state), key: state.key, query: state.query } : undefined;
+}
+async function previewOf(preview, hidden, signal) {
+  try {
+    return previewLines(await preview(hidden, signal));
+  } catch (error) {
+    return [error instanceof Error ? error.message : String(error)];
+  }
+}
+
+// ../kit/src/picker.ts
 var REMEMBERED = 20;
 function table(rows) {
   const widths = rows[0]?.cells.map((_, index) => Math.max(...rows.map((row) => Bun.stringWidth(row.cells[index])))) ?? [];
@@ -1174,70 +1981,40 @@ function table(rows) {
     ...row.cells.map((cell, index) => index === row.cells.length - 1 ? cell.trimEnd() : `${cell}${" ".repeat(widths[index] + 1 - Bun.stringWidth(cell))}`)
   ].join("\t"));
 }
-function fzf(rows, options) {
-  const hidden = options.hidden ?? rows[0]?.hidden.length ?? 0;
-  const proc = Bun.spawnSync([
-    "fzf",
-    "--prompt",
-    options.prompt,
-    ...options.header === undefined ? [] : ["--header", options.header],
-    ...(options.expect ?? []).length > 0 ? ["--expect", (options.expect ?? []).join(",")] : [],
-    "--ansi",
-    "--reverse",
-    "--height",
-    options.height ?? "100%",
-    "--delimiter",
-    "\t",
-    "--with-nth",
-    `${hidden + 1}..`,
-    "--nth",
-    `1..${options.searched}`,
-    "--tabstop",
-    "1",
-    "--tiebreak",
-    "chunk,index",
-    ...options.preview === undefined ? [] : ["--preview", options.preview, "--preview-window", "down,40%"],
-    ...(options.bind ?? []).flatMap((bind) => ["--bind", bind]),
-    ...options.query === true ? ["--print-query"] : []
-  ], {
-    stdin: new TextEncoder().encode(table(rows).join(`
-`)),
-    stdout: "pipe",
-    stderr: "inherit"
-  });
-  return picked(proc.stdout.toString(), hidden, options);
-}
-function picked(output, hidden, options) {
-  const lines = output.split(`
-`);
-  const query = options.query === true ? lines.shift() : "";
-  const [key, line] = (options.expect ?? []).length > 0 ? [lines[0], lines[1]] : ["", lines[0]];
-  if (line !== undefined && line !== "")
-    return { key, hidden: line.split("\t").slice(0, hidden), query };
-  return options.query === true && key !== "" ? { key, hidden: [], query } : undefined;
+async function pick(rows, options) {
+  const height = parseHeight(options.height ?? "100%");
+  const keys = [...options.expect ?? [], ...options.reload?.key === undefined ? [] : [options.reload.key]];
+  if (height === undefined)
+    throw new Error(`pick: the height is lines or a percentage, not ${options.height}`);
+  for (const key of keys) {
+    if (!CTRL_KEY.test(key))
+      throw new Error(`pick: ${key} is not a key it can report, one of ctrl-a to ctrl-z but ctrl-c, h, i, j and m`);
+  }
+  const found = await select(rows, { multi: false, prompt: options.prompt, query: "", height, preview: options.preview, previewPosition: "down", header: options.header, expect: options.expect, searched: options.searched, reload: options.reload });
+  return found === undefined ? undefined : { key: found.key, hidden: found.rows[0]?.hidden ?? [], query: found.query };
 }
 function heightFor(count) {
   return String(Math.max(15, Math.ceil((count + 4) / 0.6)));
 }
 function historyFile(name) {
-  return join4(process8.env.XDG_CACHE_HOME ?? join4(homedir2(), ".cache"), name, "history.json");
+  return join7(process13.env.XDG_CACHE_HOME ?? join7(homedir4(), ".cache"), name, "history.json");
 }
 function history(name) {
   try {
     const file = historyFile(name);
-    return existsSync(file) ? JSON.parse(readFileSync2(file, "utf-8")) : {};
+    return existsSync3(file) ? JSON.parse(readFileSync3(file, "utf-8")) : {};
   } catch {
     return {};
   }
 }
 function runs(name) {
-  return history(name)[process8.cwd()] ?? [];
+  return history(name)[process13.cwd()] ?? [];
 }
 function record(name, run) {
   const all = history(name);
   const file = historyFile(name);
-  all[process8.cwd()] = [run, ...(all[process8.cwd()] ?? []).filter((earlier) => earlier.id !== run.id)].slice(0, REMEMBERED);
-  mkdirSync2(dirname4(file), { recursive: true });
+  all[process13.cwd()] = [run, ...(all[process13.cwd()] ?? []).filter((earlier) => earlier.id !== run.id)].slice(0, REMEMBERED);
+  mkdirSync2(dirname5(file), { recursive: true });
   writeFileSync(file, JSON.stringify(all));
 }
 function byRecency(items, previous, idOf) {
@@ -1260,11 +2037,11 @@ function list(rows) {
 }
 
 // src/picker.ts
-import process9 from "process";
+import process14 from "process";
 
 // src/stack.ts
-import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname5, join as join5, relative, resolve } from "path";
+import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname6, join as join8, relative, resolve as resolve3 } from "path";
 var LABEL_FORMAT = ["project", "project.config_files", "project.environment_file", "project.working_dir"].map((label) => `{{.Label "com.docker.compose.${label}"}}`).join("\t");
 var COMPOSE_FILE_VAR = /^\s*(?:export\s+)?COMPOSE_FILE\s*=\s*\S/m;
 var COMPOSE_FILES = ["compose.yaml", "compose.yml", "docker-compose.yaml", "docker-compose.yml"];
@@ -1276,29 +2053,29 @@ function from(dir, command) {
 function children(dir = ".") {
   return readdirSync(dir, { withFileTypes: true }).filter((child) => child.isDirectory() && !child.name.startsWith(".") && !SKIPPED2.has(child.name)).map((child) => child.name).sort();
 }
-function up(dir) {
+function up2(dir) {
   const dirs = [];
-  for (let current = dir;; current = join5(current, "..")) {
+  for (let current = dir;; current = join8(current, "..")) {
     dirs.push(current);
-    const absolute = resolve(current);
-    if (existsSync2(join5(current, ".git")) || dirname5(absolute) === absolute)
+    const absolute = resolve3(current);
+    if (existsSync4(join8(current, ".git")) || dirname6(absolute) === absolute)
       return dirs;
   }
 }
 function stackAt(dir) {
-  return { dir, run: from(dir, ["docker", "compose"]), list: { argv: ["docker", "compose"], cwd: resolve(dir), env: process.env } };
+  return { dir, run: from(dir, ["docker", "compose"]), list: { argv: ["docker", "compose"], cwd: resolve3(dir), env: process.env } };
 }
 function holdsStack(dir) {
-  if (COMPOSE_FILES.some((name) => existsSync2(join5(dir, name))))
+  if (COMPOSE_FILES.some((name) => existsSync4(join8(dir, name))))
     return true;
   try {
-    return COMPOSE_FILE_VAR.test(readFileSync3(join5(dir, ".env"), "utf-8"));
+    return COMPOSE_FILE_VAR.test(readFileSync4(join8(dir, ".env"), "utf-8"));
   } catch {
     return false;
   }
 }
 function nearestStack(dir) {
-  const found = up(dir).find(holdsStack);
+  const found = up2(dir).find(holdsStack);
   return found === undefined ? undefined : stackAt(found);
 }
 function stacks() {
@@ -1321,7 +2098,7 @@ async function labels(project) {
   const proc = Bun.spawn(["docker", "ps", "--all", ...filter, "--format", LABEL_FORMAT], { stdout: "pipe", stderr: "ignore" });
   if (await proc.exited !== 0)
     return [];
-  return labelled(await new Response(proc.stdout).text()).filter((stack) => [...stack.files, ...stack.envFiles].every((file) => existsSync2(file)));
+  return labelled(await new Response(proc.stdout).text()).filter((stack) => [...stack.files, ...stack.envFiles].every((file) => existsSync4(file)));
 }
 function labelledStack(dir, { project, files, envFiles, workdir }) {
   const options = (paths) => ["-p", project, ...files.flatMap((file) => ["-f", paths(file)]), ...envFiles.flatMap((file) => ["--env-file", paths(file)])];
@@ -1336,7 +2113,7 @@ function stackOf(recorded) {
   return labelledStack(relative(".", recorded.workdir) || ".", recorded);
 }
 async function recordedNearby() {
-  const dirs = new Set([...up("."), ...children()].map((dir) => resolve(dir)));
+  const dirs = new Set([...up2("."), ...children()].map((dir) => resolve3(dir)));
   return (await labels()).filter((stack) => dirs.has(stack.workdir));
 }
 async function attempt(stack, args) {
@@ -1427,10 +2204,10 @@ async function logsOf(stack, name) {
 }
 
 // src/picker.ts
-var KEYS = { "ctrl-l": "logs", "ctrl-r": "restart", "ctrl-x": "stop", "ctrl-b": "build" };
+var KEYS2 = { "ctrl-l": "logs", "ctrl-r": "restart", "ctrl-x": "stop", "ctrl-b": "build" };
 var KEY_LABELS = { "ctrl-l": "Logs", "ctrl-r": "Restart", "ctrl-x": "Stop", "ctrl-b": "Rebuild" };
 function row(service) {
-  const colors = paint(process9.stderr);
+  const colors = paint(process14.stderr);
   const dir = service.stack.dir;
   const project = service.stack.project;
   const name = project === undefined ? service.name : `${colors.dim(`${project}:`)}${service.name}`;
@@ -1439,14 +2216,14 @@ function row(service) {
     cells: [dir === "." ? name : `${colors.dim(`${dir}/`)}${name}`, colors[stateColor(service.state)](service.state), colors.cyan(service.ports), colors.dim(service.image)]
   };
 }
-function pickService(services) {
-  const picked = fzf(services.map(row), {
+async function pickService(services) {
+  const picked = await pick(services.map(row), {
     prompt: "dx> ",
     header: "enter shell or up, ctrl-l logs, ctrl-r restart, ctrl-x stop, ctrl-b rebuild",
-    expect: Object.keys(KEYS),
+    expect: Object.keys(KEYS2),
     searched: 1,
     height: heightFor(services.length),
-    preview: `${process9.execPath} ${process9.argv[1]} --show {1} {2} {4}`
+    preview: `${process14.execPath} ${process14.argv[1]} --show {1} {2} {4}`
   });
   const service = services.find((candidate) => key(candidate) === picked?.hidden[2]);
   return picked === undefined || service === undefined ? undefined : { service, key: picked.key };
@@ -1456,7 +2233,7 @@ function pickService(services) {
 var usage2 = `dx [service] [action]
 dx -
 
-Without a terminal or without fzf (a script, a pipe, an agent) \`dx\` lists the services with their state, ports and image: that listing is the form to use there, \`--json\` giving the full record. On a terminal with fzf it picks one instead: enter opens its shell (or brings a stopped service up), ctrl-l follows its logs, ctrl-r restarts, ctrl-x stops and ctrl-b rebuilds it. The services last acted on come first, per folder.
+Without a terminal (a script, a pipe, an agent) \`dx\` lists the services with their state, ports and image: that listing is the form to use there, \`--json\` giving the full record. On a terminal it picks one instead: enter opens its shell (or brings a stopped service up), ctrl-l follows its logs, ctrl-r restarts, ctrl-x stops and ctrl-b rebuilds it. The services last acted on come first, per folder.
 \`dx -\` does the last action again, \`dx <service> [action]\` acts without the picker: \`shell\` (bash when the container has it), \`logs\` (follows the last ${LOGS_TAIL} lines; \`--tail N\` changes the count and \`--no-follow\` prints them once and exits, for a script), \`restart\`, \`up\`, \`stop\` or \`build\` (up with a rebuild).
 The services are the stack of this folder or its nearest parent, the ones of the child folders (keyed \`api/php\`), and stacks found only through their containers (keyed \`<project>:php\`).`;
 var EXITS = [["the code of the command it ran", "a listing, a shell, logs, restart, up, stop or build"], [0, "it listed the services"], [1, "no compose service here or none by that name"], [2, "a usage error"]];
@@ -1466,7 +2243,7 @@ var options = {
   follow: { type: "boolean", negative: "print the logs once and exit instead of following them" }
 };
 function table2(services) {
-  const colors = paint(process10.stdout);
+  const colors = paint(process15.stdout);
   const keys = services.map(key);
   const width = Math.max(...keys.map((name) => name.length));
   const states = Math.max(...services.map((service) => service.state.length));
@@ -1491,7 +2268,7 @@ function listed2(services) {
     hint: [service.state, service.ports, service.image].filter(Boolean).join(" \xB7 "),
     typed: key(service),
     preview: ["--show", service.stack.dir, service.name, service.stack.project ?? ""],
-    actions: Object.entries(KEYS).map(([pressed, action]) => ({ label: KEY_LABELS[pressed] ?? action, key: pressed, typed: `${key(service)} ${action}` }))
+    actions: Object.entries(KEYS2).map(([pressed, action]) => ({ label: KEY_LABELS[pressed] ?? action, key: pressed, typed: `${key(service)} ${action}` }))
   }));
 }
 async function hidden(flag, rest, services) {
@@ -1509,7 +2286,7 @@ async function hidden(flag, rest, services) {
     const service = await serviceNamed(dir, name, project);
     if (service === undefined)
       return 0;
-    const colors = paint(process10.stdout);
+    const colors = paint(process15.stdout);
     console.log(`${colors[stateColor(service.state)](service.status || service.state)}  ${colors.dim(service.image)}${service.ports ? `  ${colors.cyan(service.ports)}` : ""}
 `);
     console.log(await logsOf(service.stack, name));
@@ -1527,8 +2304,8 @@ async function followMasked(command) {
   const decoder = new TextDecoder;
   const proc = Bun.spawn(command, { stdio: ["inherit", "pipe", "inherit"] });
   for await (const chunk of proc.stdout)
-    process10.stdout.write(redactor.push(decoder.decode(chunk, { stream: true })));
-  process10.stdout.write(redactor.end());
+    process15.stdout.write(redactor.push(decoder.decode(chunk, { stream: true })));
+  process15.stdout.write(redactor.end());
   return proc.exited;
 }
 async function dx(args) {
@@ -1548,23 +2325,21 @@ async function dx(args) {
   let service;
   let action;
   if (named === undefined) {
-    const interactive = process10.stdin.isTTY && process10.stderr.isTTY && parsed.values.json !== true;
-    if (!interactive || Bun.which("fzf") === null) {
+    const interactive = process15.stdin.isTTY && process15.stderr.isTTY && parsed.values.json !== true;
+    if (!interactive) {
       if (emit)
-        fail("the picker needs a terminal and fzf", 1);
-      if (interactive)
-        console.error("fzf is not installed, listing the services instead");
+        fail("the picker needs a terminal", 1);
       if (parsed.values.json === true)
         printJson(services.map((each) => ({ key: key(each), project: each.project, name: each.name, state: each.state, status: each.status, ports: each.ports, image: each.image })));
       else
         console.log(table2(services));
       return 0;
     }
-    const picked = pickService(byRecency(services, runs("dx"), key));
+    const picked = await pickService(byRecency(services, runs("dx"), key));
     if (picked === undefined)
       return 1;
     service = picked.service;
-    action = KEYS[picked.key];
+    action = KEYS2[picked.key];
   } else if (named === "-") {
     const last = runs("dx")[0];
     service = last && services.find((candidate) => key(candidate) === last.id);
@@ -1592,4 +2367,4 @@ async function dx(args) {
 }
 
 // src/dx-cli.ts
-process11.exitCode = await runMain({ name: "dx", run: dx });
+process16.exitCode = await runMain({ name: "dx", run: dx });