@kaynooo/cli-docker 0.5.0 → 0.6.0

package/dist/sf-cli.js

@@ -1,14 +1,14 @@
-#!/usr/bin/env bun
+#!/usr/bin/env -S bun --no-env-file
 // @bun
 
 // src/sf-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,16 +997,635 @@ var {Glob } = globalThis.Bun;
 var SESSION_FILES = new Glob("*.json");
 var ACCOUNT_DIRS = new Glob("*/sessions");
 // src/sf.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
-import { homedir as homedir3 } from "os";
-import { dirname as dirname6, join as join6, resolve as resolve2 } from "path";
-import process10 from "process";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir5 } from "os";
+import { dirname as dirname7, join as join9, resolve as resolve4 } from "path";
+import process15 from "process";
 
-// ../kit/src/fzf.ts
-import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { dirname as dirname3, join as join3 } 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 dirname4, join as join6 } 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 PLACEHOLDER = /\{([1-9]\d*)?\}/g;
+function previewCommand(template, line, hidden = []) {
+  return template.replace(PLACEHOLDER, (_, 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])))) ?? [];
@@ -827,70 +1634,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 join3(process8.env.XDG_CACHE_HOME ?? join3(homedir2(), ".cache"), name, "history.json");
+  return join6(process13.env.XDG_CACHE_HOME ?? join6(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(dirname3(file), { recursive: true });
+  all[process13.cwd()] = [run, ...(all[process13.cwd()] ?? []).filter((earlier) => earlier.id !== run.id)].slice(0, REMEMBERED);
+  mkdirSync2(dirname4(file), { recursive: true });
   writeFileSync(file, JSON.stringify(all));
 }
 function byRecency(items, previous, idOf) {
@@ -913,12 +1690,12 @@ function list(rows) {
 }
 
 // ../kit/src/prompt.ts
-import process9 from "process";
-var KEY_SEQUENCES = /\x1B\[[0-9;]*[A-Z~]|\x1BO[A-Z]|[\s\S]/giu;
-var CONTROL = /^[\x00-\x1F\x7F]/;
-var KEYS = { "\x1B[A": "up", "\x1BOA": "up", "\x1B[B": "down", "\x1BOB": "down", "\r": "enter", "\n": "enter", "\x03": "cancel", "\x1B": "cancel", "\x7F": "erase", "\b": "erase" };
+import process14 from "process";
+var KEY_SEQUENCES2 = /\x1B\[[0-9;]*[A-Z~]|\x1BO[A-Z]|[\s\S]/giu;
+var CONTROL3 = /^[\x00-\x1F\x7F]/;
+var KEYS2 = { "\x1B[A": "up", "\x1BOA": "up", "\x1B[B": "down", "\x1BOB": "down", "\r": "enter", "\n": "enter", "\x03": "cancel", "\x1B": "cancel", "\x7F": "erase", "\b": "erase" };
 function readKeys(input) {
-  return (input.match(KEY_SEQUENCES) ?? []).flatMap((sequence) => KEYS[sequence] ?? (CONTROL.test(sequence) ? [] : [{ text: sequence }]));
+  return (input.match(KEY_SEQUENCES2) ?? []).flatMap((sequence) => KEYS2[sequence] ?? (CONTROL3.test(sequence) ? [] : [{ text: sequence }]));
 }
 async function input2(question, { default: fallback, mask = false, validate, ...settings } = {}) {
   let value = "";
@@ -952,7 +1729,7 @@ async function input2(question, { default: fallback, mask = false, validate, ...
 function answer(colors, question, state, picked) {
   return state === "enter" ? `${colors.green("\u2713")} ${question} ${colors.cyan(picked)}` : `${colors.red("\u2717")} ${question} ${colors.dim("cancelled")}`;
 }
-async function ask(question, { hint, terminal = process9 }, render, press) {
+async function ask(question, { hint, terminal = process14 }, render, press) {
   const { stdin, stderr } = terminal;
   if (stdin.isTTY !== true || stderr.isTTY !== true)
     fail(`cannot ask "${question}" off a terminal`, 2, hint);
@@ -1003,12 +1780,12 @@ async function ask(question, { hint, terminal = process9 }, render, press) {
 }
 
 // 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";
 
 // ../env/src/files.ts
 import { chmod, chown, readdir, realpath, rename, rm, stat, writeFile } from "fs/promises";
-import { basename, dirname as dirname4, join as join4 } from "path";
+import { basename, dirname as dirname5, join as join7 } from "path";
 
 // ../env/src/dotenv.ts
 var ASSIGNMENT = /^\s*(?:export\s+)?([A-Z_][\w.-]*)\s*=(.*)$/i;
@@ -1088,12 +1865,12 @@ function entries(file) {
 var MIN_KNOWN_LENGTH = 4;
 var KEY_MASK = "*** private key redacted ***";
 var PLAIN_VALUE = /^(?:true|false|null|none|nil|yes|no|on|off|undefined)$/i;
-var PLACEHOLDER = /^[$%{<(*/]/;
+var PLACEHOLDER2 = /^[$%{<(*/]/;
 var URL_PASSWORD = /(?<![a-z0-9+.-])[a-z][a-z0-9+.-]{0,31}:\/\/[^\s:/@]*:([^\s'"]{1,1024})@/dgi;
 var PORT = /^\d{1,5}$/;
 var ESCAPE2 = /[.*+?^${}()|[\]\\]/g;
 function isPlaceholder(value) {
-  return PLACEHOLDER.test(value) || PLAIN_VALUE.test(value);
+  return PLACEHOLDER2.test(value) || PLAIN_VALUE.test(value);
 }
 var TOKEN_FORMATS = [
   { kind: "GitHub token", pattern: /\b(?:gh[pousr]_|github_pat_)\w{20,}/dg },
@@ -1279,7 +2056,7 @@ async function envFilesBelow(folder, depth = 0) {
     return found;
   }
   for (const entry of children) {
-    const path = join4(folder, entry.name);
+    const path = join7(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))
@@ -1368,29 +2145,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() {
@@ -1413,7 +2190,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)])];
@@ -1428,7 +2205,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) {
@@ -1522,7 +2299,7 @@ async function logsOf(stack, name) {
 var usage2 = `sf [command] [args...]
 sf -
 
-Without a terminal or without fzf (a script, a pipe, an agent) \`sf\` lists the commands, one per line with its description: that listing is the form to use there, and \`sf --list --json\` gives each with its arguments and options. On a terminal with fzf it picks a Symfony console command instead and runs it, asking for each required argument it needs. The commands last run come first, per folder, and the picker opens on the list cached from the last run while the console answers.
+Without a terminal (a script, a pipe, an agent) \`sf\` lists the commands, one per line with its description: that listing is the form to use there, and \`sf --list --json\` gives each with its arguments and options. On a terminal it picks a Symfony console command instead and runs it, asking for each required argument it needs. The commands last run come first, per folder, and the picker opens on the list cached from the last run while the console answers.
 The console is the nearest bin/console up to the repository root, then those of the child folders (keyed \`api/cache:clear\`). It runs in the php service of the nearest compose stack when there is one, else with the local php; the container's working directory is taken to be the app.
 \`sf -\` runs the last command again with the arguments it ran with, \`sf <command> [args...]\` runs without the picker: a name the list does not hold goes to the console as is, which resolves \`c:c\` to \`cache:clear\` itself.
 \`sf --list --json\` (or \`sf --json\`) prints every command as JSON, each with its console folder, description, signature, arguments and options.
@@ -1549,19 +2326,19 @@ async function consoleAt(dir) {
   const php = stack === undefined ? undefined : phpService((await services(stack)).map((service) => service.name));
   if (stack !== undefined && php !== undefined)
     return { dir, run: [...stack.run, "exec", php, "bin/console"], list: { ...stack.list, argv: [...stack.list.argv, "exec", "-T", php, "bin/console"] } };
-  return { dir, run: from(dir, ["php", "bin/console"]), list: { argv: ["php", "bin/console"], cwd: resolve2(dir), env: process10.env } };
+  return { dir, run: from(dir, ["php", "bin/console"]), list: { argv: ["php", "bin/console"], cwd: resolve4(dir), env: process15.env } };
 }
 async function consoles() {
-  const here = up(".").find((dir) => existsSync3(join6(dir, "bin/console")));
-  const dirs = [...here === undefined ? [] : [here], ...children().filter((dir) => existsSync3(join6(dir, "bin/console")))];
+  const here = up2(".").find((dir) => existsSync5(join9(dir, "bin/console")));
+  const dirs = [...here === undefined ? [] : [here], ...children().filter((dir) => existsSync5(join9(dir, "bin/console")))];
   return Promise.all([...new Set(dirs)].map(consoleAt));
 }
 function cached(dir) {
-  return join6(process10.env.XDG_CACHE_HOME ?? join6(homedir3(), ".cache"), "sf", `${resolve2(dir).replaceAll("/", "%")}.json`);
+  return join9(process15.env.XDG_CACHE_HOME ?? join9(homedir5(), ".cache"), "sf", `${resolve4(dir).replaceAll("/", "%")}.json`);
 }
 function fromCache(dir) {
   try {
-    return existsSync3(cached(dir)) ? JSON.parse(readFileSync4(cached(dir), "utf-8")) : undefined;
+    return existsSync5(cached(dir)) ? JSON.parse(readFileSync5(cached(dir), "utf-8")) : undefined;
   } catch {
     return;
   }
@@ -1577,7 +2354,7 @@ async function live(app) {
   } catch {
     return fromCache(app.dir) ?? [];
   }
-  mkdirSync3(dirname6(cached(app.dir)), { recursive: true });
+  mkdirSync3(dirname7(cached(app.dir)), { recursive: true });
   writeFileSync2(cached(app.dir), JSON.stringify(commands));
   return commands;
 }
@@ -1651,7 +2428,7 @@ async function answered(command, ask) {
   return { argv, given };
 }
 function interactive() {
-  return process10.stdin.isTTY && process10.stderr.isTTY;
+  return process15.stdin.isTTY && process15.stderr.isTTY;
 }
 async function execute(emitting, typed, recorded, command) {
   if (emitting) {
@@ -1698,7 +2475,7 @@ async function hidden(flag, rest) {
     return 0;
   }
   if (refreshed)
-    Bun.spawn([process10.execPath, process10.argv[1], "--rows"], { stdio: ["ignore", "ignore", "ignore"] }).unref();
+    Bun.spawn([process15.execPath, process15.argv[1], "--rows"], { stdio: ["ignore", "ignore", "ignore"] }).unref();
   list(byRecency(found, runs("sf"), key2).map((entry) => ({
     label: [key2(entry), signature(entry.command)].filter(Boolean).join(" "),
     hint: entry.command.description,
@@ -1749,24 +2526,21 @@ async function sf(args) {
   }
   if (found.length === 0)
     fail("no bin/console here, or it listed no command", 1);
-  if (!interactive() || Bun.which("fzf") === null) {
+  if (!interactive()) {
     if (emitting)
-      fail("the picker needs a terminal and fzf", 1);
-    if (interactive())
-      console.error("fzf is not installed, listing the commands instead");
+      fail("the picker needs a terminal", 1);
     console.log(listing(found));
     return 0;
   }
-  const self = `${process10.execPath} ${process10.argv[1]}`;
-  const picked = fzf(rows(found), {
+  const picked = await pick(rows(found), {
     prompt: "sf> ",
     searched: 1,
-    preview: `${self} --show {1} {2}`,
-    bind: refreshed ? [`load:unbind(load)+reload-sync(${self} --rows)`] : []
+    preview: `${process15.execPath} ${process15.argv[1]} --show {1} {2}`,
+    reload: refreshed ? { onOpen: true, run: async () => ({ rows: rows(await entries2(true)) }) } : undefined
   });
   const entry = picked && (await entries2(false)).find((candidate) => candidate.app.dir === picked.hidden[0] && candidate.command.name === picked.hidden[1]);
   return entry === undefined ? 1 : execute(emitting, key2(entry), key2(entry), commandFor2(entry, []));
 }
 
 // src/sf-cli.ts
-process11.exitCode = await runMain({ name: "sf", run: sf });
+process16.exitCode = await runMain({ name: "sf", run: sf });