bytecut 0.0.0-stage → 0.1.0

package/dist/tui-CDF23I73.js

@@ -0,0 +1,1691 @@
+#!/usr/bin/env node
+import {
+  audit
+} from "./chunk-4PWCQ4NF.js";
+import {
+  formatSummary,
+  optimize
+} from "./chunk-P5PFI3AO.js";
+import {
+  buildSnippet,
+  originalUrl,
+  snippetFormatFor
+} from "./chunk-WZ6MMRNB.js";
+import "./chunk-3DBJKHOD.js";
+import {
+  startCompareServer
+} from "./chunk-7DHE25UE.js";
+import {
+  MANIFEST_FILE,
+  parseManifest
+} from "./chunk-TCQFQ354.js";
+import "./chunk-XUBQWBWH.js";
+import {
+  toPosix
+} from "./chunk-QOG2F4SF.js";
+import {
+  resolveConfig,
+  resolveConfigData
+} from "./chunk-3PF6BBFK.js";
+import {
+  applyChoices,
+  canRewrite,
+  isEmpty,
+  renderChoicesSnippet,
+  renderConfig
+} from "./chunk-4FIB6VNC.js";
+import {
+  SafeFs,
+  writeConfigFile
+} from "./chunk-IZ4JEL3Q.js";
+import {
+  ALL_RULES,
+  BytecutError,
+  formatBytes,
+  loadConfig,
+  parseConfig,
+  percentChange,
+  plural
+} from "./chunk-FY53B4NB.js";
+
+// src/tui/index.tsx
+import { render } from "ink";
+
+// src/tui/app.tsx
+import { Box as Box5, Text as Text5, useApp, useInput, useStdout } from "ink";
+import {
+  useCallback,
+  useEffect,
+  useMemo,
+  useReducer,
+  useRef,
+  useState
+} from "react";
+
+// src/tui/commands.ts
+var COMMANDS = [
+  { name: "audit", usage: "/audit", description: "Rescan the project" },
+  {
+    name: "optimize",
+    usage: "/optimize [@file\u2026]",
+    description: "Review the plan for the selection (or the mentioned files)"
+  },
+  {
+    name: "preset",
+    usage: "/preset <photo|hero|icon> [@file\u2026]",
+    description: "Set the preset for the highlighted (or mentioned) files"
+  },
+  {
+    name: "snippet",
+    usage: "/snippet @file",
+    description: "Copy the <picture>/<video> markup for an optimized file"
+  },
+  {
+    name: "compare",
+    usage: "/compare @file",
+    description: "Serve a before/after page for an optimized file on localhost"
+  },
+  {
+    name: "save",
+    usage: "/save",
+    description: "Keep this session's preset and folder choices in the project config"
+  },
+  { name: "out", usage: "/out <dir>", description: "Change the output folder" },
+  { name: "select", usage: "/select <all|none|warn>", description: "Change the selection" },
+  { name: "doctor", usage: "/doctor", description: "Show Node, sharp and ffmpeg status" },
+  { name: "help", usage: "/help", description: "Show keys and commands" },
+  { name: "quit", usage: "/quit", description: "Leave bytecut" }
+];
+function parseCommand(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("/")) {
+    return { ok: false, error: "Commands start with / (try /help)" };
+  }
+  const tokens = trimmed.slice(1).split(/\s+/).filter(Boolean);
+  const name = tokens.shift()?.toLowerCase() ?? "";
+  if (!name) return { ok: false, error: "Type a command after / (try /help)" };
+  if (!COMMANDS.some((c) => c.name === name)) {
+    return { ok: false, error: `Unknown command /${name} (try /help)` };
+  }
+  const args = [];
+  const mentions = [];
+  for (const token of tokens) {
+    if (token.startsWith("@") && token.length > 1) mentions.push(token.slice(1));
+    else args.push(token);
+  }
+  return { ok: true, name, args, mentions };
+}
+function suggestCommands(text) {
+  const m = /^\/(\S*)$/.exec(text.trimStart());
+  if (!m) return [];
+  const prefix = m[1].toLowerCase();
+  return COMMANDS.filter((c) => c.name.startsWith(prefix));
+}
+function activeMention(text) {
+  const m = /(?:^|\s)@(\S*)$/.exec(text);
+  return m ? m[1] : null;
+}
+function subsequenceScore(q, text) {
+  let score = 0;
+  let from = 0;
+  let previous = -2;
+  for (const ch of q) {
+    const at = text.indexOf(ch, from);
+    if (at === -1) return null;
+    score += 1;
+    if (at === previous + 1) score += 3;
+    if (at === 0 || "/-_. ".includes(text[at - 1])) score += 2;
+    previous = at;
+    from = at + 1;
+  }
+  return score;
+}
+function fuzzyScore(query, path) {
+  if (query === "") return 0;
+  const q = query.toLowerCase();
+  const p = path.toLowerCase();
+  const name = p.slice(p.lastIndexOf("/") + 1);
+  const inName = subsequenceScore(q, name);
+  const inPath = subsequenceScore(q, p);
+  if (inName === null && inPath === null) return null;
+  let score = inName !== null ? inName + 8 : inPath ?? 0;
+  if (inName !== null && inPath !== null) score = Math.max(score, inPath);
+  if (name.includes(q)) score += 10;
+  if (name.startsWith(q)) score += 4;
+  return score * 100 - path.length;
+}
+function fuzzyFiles(query, files, limit = 8) {
+  return files.map((file) => ({ file, score: fuzzyScore(query, file) })).filter((x) => x.score !== null).sort((a, b) => b.score - a.score || (a.file < b.file ? -1 : 1)).slice(0, limit).map((x) => x.file);
+}
+function completeMention(text, file) {
+  return text.replace(/(^|\s)@\S*$/, `$1@${file} `);
+}
+
+// src/tui/clipboard.ts
+import { spawn } from "child_process";
+function candidates(platform, env) {
+  switch (platform) {
+    case "darwin":
+      return [{ method: "pbcopy", file: "pbcopy", args: [] }];
+    case "win32":
+      return [{ method: "clip", file: "clip", args: [] }];
+    default: {
+      const list = [];
+      if (env.WAYLAND_DISPLAY) list.push({ method: "wl-copy", file: "wl-copy", args: [] });
+      list.push({ method: "xclip", file: "xclip", args: ["-selection", "clipboard"] });
+      list.push({ method: "xsel", file: "xsel", args: ["--clipboard", "--input"] });
+      if (!env.WAYLAND_DISPLAY) list.push({ method: "wl-copy", file: "wl-copy", args: [] });
+      return list;
+    }
+  }
+}
+function osc52(text) {
+  return `\x1B]52;c;${Buffer.from(text, "utf8").toString("base64")}\x07`;
+}
+var OSC52_MAX_BYTES = 1e5;
+async function copyToClipboard(text, deps) {
+  for (const c of candidates(deps.platform, deps.env)) {
+    if (await deps.run(c.file, c.args, text)) return { ok: true, method: c.method };
+  }
+  if (deps.writeTerminal && Buffer.byteLength(text) <= OSC52_MAX_BYTES) {
+    deps.writeTerminal(osc52(text));
+    return { ok: true, method: "osc52" };
+  }
+  return { ok: false };
+}
+function systemClipboardDeps() {
+  return {
+    platform: process.platform,
+    env: process.env,
+    run: (file, args, input) => new Promise((resolve2) => {
+      let settled = false;
+      const done = (value) => {
+        if (!settled) {
+          settled = true;
+          resolve2(value);
+        }
+      };
+      try {
+        const child = spawn(file, args, { stdio: ["pipe", "ignore", "ignore"] });
+        const timer = setTimeout(() => {
+          child.kill();
+          done(false);
+        }, 2e3);
+        child.on("error", () => {
+          clearTimeout(timer);
+          done(false);
+        });
+        child.on("close", (code) => {
+          clearTimeout(timer);
+          done(code === 0);
+        });
+        child.stdin.on("error", () => done(false));
+        child.stdin.end(input);
+      } catch {
+        done(false);
+      }
+    }),
+    writeTerminal: process.stdout.isTTY ? (data) => void process.stdout.write(data) : null
+  };
+}
+
+// src/tui/components/commandbar.tsx
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function computeSuggestions(input, files) {
+  const mention = activeMention(input);
+  if (mention !== null) {
+    return { kind: "file", items: fuzzyFiles(mention, files).map((value) => ({ value })) };
+  }
+  const commands = suggestCommands(input);
+  if (commands.length > 0) {
+    return {
+      kind: "command",
+      items: commands.map((c) => ({ value: c.name, hint: c.description }))
+    };
+  }
+  return { kind: "none", items: [] };
+}
+function CommandBar(props) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsxs(Text, { color: "cyan", children: [
+        props.prompt,
+        " "
+      ] }),
+      /* @__PURE__ */ jsx(Text, { children: props.input }),
+      /* @__PURE__ */ jsx(Text, { inverse: true, children: " " })
+    ] }),
+    props.hint ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: props.hint }) : null,
+    props.suggestions.items.map((item, i) => /* @__PURE__ */ jsxs(
+      Text,
+      {
+        color: i === props.selected ? "cyan" : void 0,
+        wrap: "truncate-end",
+        children: [
+          i === props.selected ? "\u203A " : "  ",
+          props.suggestions.kind === "command" ? "/" : "@",
+          item.value,
+          item.hint ? /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+            " \u2014 ",
+            item.hint
+          ] }) : null
+        ]
+      },
+      item.value
+    ))
+  ] });
+}
+
+// src/tui/components/layout.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+
+// src/tui/model.ts
+var FIX_BY_RULE = new Map(ALL_RULES.map((r) => [r.id, r.fix]));
+var RANK = { error: 0, warn: 1, info: 2 };
+function buildModel(report) {
+  const files = new Map(report.files.map((f) => [f.source, f]));
+  const fixable = /* @__PURE__ */ new Map();
+  const reportOnly = [];
+  for (const finding of report.findings) {
+    const file = finding.source ? files.get(finding.source) : void 0;
+    const canFix = FIX_BY_RULE.get(finding.ruleId) === "optimize" && file && !file.skipped;
+    if (canFix && finding.source) {
+      fixable.set(finding.source, [...fixable.get(finding.source) ?? [], finding]);
+    } else {
+      reportOnly.push(finding);
+    }
+  }
+  const rows = [];
+  for (const [source, findings] of fixable) {
+    const file = files.get(source);
+    if (file.covered) continue;
+    const severity = findings.reduce(
+      (best, f) => RANK[f.severity] < RANK[best] ? f.severity : best,
+      "info"
+    );
+    rows.push({
+      source,
+      bytes: file.bytes,
+      width: file.width,
+      height: file.height,
+      preset: file.preset,
+      reason: file.reason,
+      estimatedBytes: file.estimatedBytes,
+      savingsBytes: file.savingsBytes,
+      plannedOutputs: file.plannedOutputs,
+      findings,
+      severity
+    });
+  }
+  rows.sort(
+    (a, b) => (b.savingsBytes ?? 0) - (a.savingsBytes ?? 0) || (a.source < b.source ? -1 : 1)
+  );
+  return {
+    rows,
+    reportOnly,
+    covered: report.files.filter((f) => f.covered).length,
+    skipped: report.files.filter((f) => f.skipped).map((f) => ({ source: f.source, reason: f.skipped })),
+    notes: report.notes
+  };
+}
+function defaultSelection(rows) {
+  return new Set(rows.filter((r) => r.severity !== "info").map((r) => r.source));
+}
+function selectionTotals(rows, selected) {
+  let bytes = 0;
+  let savings = 0;
+  let count = 0;
+  for (const row of rows) {
+    if (!selected.has(row.source)) continue;
+    count++;
+    bytes += row.bytes;
+    savings += row.savingsBytes ?? 0;
+  }
+  return { count, bytes, savings };
+}
+
+// src/tui/components/layout.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function Header(props) {
+  return /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsxs2(Text2, { children: [
+    /* @__PURE__ */ jsx2(Text2, { bold: true, color: "cyan", children: "bytecut" }),
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: " \xB7 " }),
+    /* @__PURE__ */ jsx2(Text2, { children: props.framework }),
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: " \xB7 scanning " }),
+    /* @__PURE__ */ jsx2(Text2, { children: props.scanning }),
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: " \u2192 " }),
+    /* @__PURE__ */ jsx2(Text2, { children: props.outDir })
+  ] }) });
+}
+var HINTS = {
+  list: "\u2191\u2193 move \xB7 space select \xB7 p preset \xB7 d details \xB7 o out dir \xB7 enter review \xB7 / cmds \xB7 ? help",
+  review: "enter run \xB7 esc back",
+  running: "esc cancel",
+  done: "\u2191\u2193 select \xB7 c copy markup \xB7 s save choices \xB7 enter/esc back \xB7 q quit",
+  scanning: "q quit",
+  error: "q quit"
+};
+function StatusLine(props) {
+  const { state, model } = props;
+  let left = "";
+  if (state.view === "list") {
+    const t = selectionTotals(model.rows, state.selected);
+    left = `${t.count} of ${plural(model.rows.length, "file")} selected`;
+    if (t.savings > 0) left += ` \xB7 est. save ~${formatBytes(t.savings)}`;
+    if (model.covered > 0) left += ` \xB7 ${model.covered} already optimized`;
+  }
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginTop: 1, children: [
+    state.status ? /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: state.status }) : null,
+    left ? /* @__PURE__ */ jsx2(Text2, { children: left }) : null,
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: HINTS[state.view] })
+  ] });
+}
+function Help() {
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", borderStyle: "round", paddingX: 1, children: [
+    /* @__PURE__ */ jsx2(Text2, { bold: true, children: "Keys" }),
+    /* @__PURE__ */ jsx2(Text2, { children: "\u2191/\u2193 or k/j move \xB7 space toggle \xB7 a select all/none" }),
+    /* @__PURE__ */ jsx2(Text2, { children: "enter review the plan, then run it \xB7 esc go back / cancel a run" }),
+    /* @__PURE__ */ jsx2(Text2, { children: "p cycle preset for the highlighted file \xB7 o change output folder" }),
+    /* @__PURE__ */ jsx2(Text2, { children: "d details \xB7 / command bar \xB7 @ jump to a file \xB7 ? this help \xB7 q quit" }),
+    /* @__PURE__ */ jsx2(Text2, { bold: true, children: "Commands" }),
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      "/audit /optimize [@file\u2026] /preset ",
+      "<name>",
+      " [@file\u2026] /out ",
+      "<dir>"
+    ] }),
+    /* @__PURE__ */ jsx2(Text2, { children: "/select all|none|warn /snippet @file /compare @file /save /doctor /help /quit" }),
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "esc closes this" })
+  ] });
+}
+
+// src/tui/components/list.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+
+// src/tui/state.ts
+var PRESET_CYCLE = ["photo", "hero", "icon"];
+var EMPTY_MODEL = { rows: [], reportOnly: [], covered: 0, skipped: [], notes: [] };
+function initialState(outDir, presetNames = PRESET_CYCLE) {
+  return {
+    view: "scanning",
+    presetNames: [...presetNames],
+    baseline: { presets: {}, outDir },
+    save: null,
+    snippet: null,
+    doneCursor: 0,
+    scanId: 0,
+    overlay: null,
+    scan: null,
+    model: EMPTY_MODEL,
+    files: [],
+    selected: /* @__PURE__ */ new Set(),
+    cursor: 0,
+    presets: {},
+    outDir,
+    input: "",
+    suggestion: 0,
+    review: null,
+    run: null,
+    result: null,
+    cancelling: false,
+    status: null,
+    error: null
+  };
+}
+function unsavedChoices(state) {
+  const presets = Object.fromEntries(
+    Object.entries(state.presets).filter(
+      ([source, preset]) => state.baseline.presets[source] !== preset
+    )
+  );
+  return {
+    ...state.outDir !== state.baseline.outDir ? { outDir: state.outDir } : {},
+    ...Object.keys(presets).length > 0 ? { presets } : {}
+  };
+}
+var clamp = (n, lo, hi) => Math.max(lo, Math.min(hi, n));
+function rowAt(state) {
+  return state.model.rows[state.cursor];
+}
+function effectivePreset(state, row) {
+  return state.presets[row.source] ?? row.preset;
+}
+function reducer(state, action) {
+  switch (action.type) {
+    case "scan-progress":
+      return { ...state, scan: { phase: action.phase, done: action.done, total: action.total } };
+    case "scan-done":
+      return {
+        ...state,
+        view: "list",
+        overlay: null,
+        scan: null,
+        model: action.model,
+        files: action.files,
+        selected: defaultSelection(action.model.rows),
+        cursor: 0,
+        review: null,
+        result: null,
+        run: null,
+        cancelling: false,
+        status: null
+      };
+    case "fatal":
+      return { ...state, view: "error", error: action.error };
+    case "move": {
+      const last = Math.max(0, state.model.rows.length - 1);
+      return { ...state, cursor: clamp(state.cursor + action.delta, 0, last) };
+    }
+    case "toggle": {
+      const row = rowAt(state);
+      if (!row) return state;
+      const selected = new Set(state.selected);
+      if (selected.has(row.source)) selected.delete(row.source);
+      else selected.add(row.source);
+      return { ...state, selected };
+    }
+    case "toggle-all": {
+      const all = state.model.rows.every((r) => state.selected.has(r.source));
+      return {
+        ...state,
+        selected: all ? /* @__PURE__ */ new Set() : new Set(state.model.rows.map((r) => r.source))
+      };
+    }
+    case "select": {
+      const rows = state.model.rows;
+      const sources = action.mode === "all" ? rows.map((r) => r.source) : action.mode === "none" ? [] : rows.filter((r) => r.severity !== "info").map((r) => r.source);
+      return { ...state, selected: new Set(sources) };
+    }
+    case "select-files": {
+      const known = new Set(state.model.rows.map((r) => r.source));
+      return { ...state, selected: new Set(action.sources.filter((s) => known.has(s))) };
+    }
+    case "cursor-to": {
+      const at = state.model.rows.findIndex((r) => r.source === action.source);
+      return at === -1 ? state : { ...state, cursor: at };
+    }
+    case "cycle-preset": {
+      const targets = action.sources ?? (rowAt(state) ? [rowAt(state).source] : []);
+      if (targets.length === 0) return state;
+      const presets = { ...state.presets };
+      for (const source of targets) {
+        const row = state.model.rows.find((r) => r.source === source);
+        if (!row) continue;
+        const current = presets[source] ?? row.preset;
+        const names = state.presetNames;
+        const next = action.to ?? names[(names.indexOf(current) + 1) % names.length];
+        if (next === row.preset) delete presets[source];
+        else presets[source] = next;
+      }
+      return { ...state, presets };
+    }
+    case "overlay":
+      return {
+        ...state,
+        overlay: action.overlay,
+        input: action.input ?? "",
+        suggestion: 0,
+        status: null
+      };
+    case "input":
+      return { ...state, input: action.text, suggestion: 0 };
+    case "suggest":
+      return {
+        ...state,
+        suggestion: clamp(state.suggestion + action.delta, 0, Math.max(0, action.max - 1))
+      };
+    case "set-out-dir":
+      return { ...state, outDir: action.outDir, overlay: null, input: "", review: null };
+    case "review-ready":
+      return { ...state, view: "review", overlay: null, review: action.review, status: null };
+    case "run-start":
+      return {
+        ...state,
+        view: "running",
+        overlay: null,
+        cancelling: false,
+        run: { total: action.total, done: 0, current: null, log: [], progress: {} }
+      };
+    case "run-item-start":
+      return state.run ? { ...state, run: { ...state.run, current: action.source } } : state;
+    case "run-output":
+      return state.run ? {
+        ...state,
+        run: {
+          ...state.run,
+          log: [...state.run.log, { source: action.source, output: action.output }]
+        }
+      } : state;
+    case "run-progress":
+      return state.run ? {
+        ...state,
+        run: {
+          ...state.run,
+          progress: { ...state.run.progress, [action.path]: action.fraction }
+        }
+      } : state;
+    case "run-item-done":
+      return state.run ? { ...state, run: { ...state.run, done: state.run.done + 1 } } : state;
+    case "run-done":
+      return { ...state, view: "done", result: action.result, cancelling: false, doneCursor: 0 };
+    case "save-open":
+      return {
+        ...state,
+        overlay: "save",
+        save: { choices: action.choices, outcome: null },
+        input: "",
+        status: null
+      };
+    case "save-result": {
+      if (!state.save) return state;
+      const saved = action.outcome.kind === "written";
+      return {
+        ...state,
+        save: { ...state.save, outcome: action.outcome },
+        // Once written, the config holds these, so they are no longer news.
+        baseline: saved ? {
+          presets: { ...state.baseline.presets, ...state.save.choices.presets },
+          outDir: state.outDir
+        } : state.baseline
+      };
+    }
+    case "snippet":
+      return { ...state, overlay: "snippet", snippet: action.snippet, input: "", status: null };
+    case "snippet-copied":
+      return state.snippet ? { ...state, snippet: { ...state.snippet, copied: action.copied } } : state;
+    case "done-move":
+      return {
+        ...state,
+        doneCursor: Math.max(0, Math.min(action.max, state.doneCursor + action.delta))
+      };
+    case "rescan":
+      return { ...state, view: "scanning", scanId: state.scanId + 1, scan: null, overlay: null };
+    case "cancel":
+      return state.view === "running" ? { ...state, cancelling: true } : state;
+    case "back": {
+      if (state.overlay) return { ...state, overlay: null, input: "", status: null };
+      switch (state.view) {
+        case "review":
+          return { ...state, view: "list", review: null };
+        case "running":
+          return { ...state, cancelling: true };
+        case "done":
+          return {
+            ...state,
+            view: "scanning",
+            scanId: state.scanId + 1,
+            result: null,
+            run: null,
+            scan: null
+          };
+        default:
+          return state;
+      }
+    }
+    case "status":
+      return { ...state, status: action.message };
+  }
+}
+
+// src/tui/components/list.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var SEVERITY_COLOR = { error: "red", warn: "yellow", info: "gray" };
+function windowStart(cursor, total, height) {
+  if (total <= height) return 0;
+  return Math.max(0, Math.min(cursor - Math.floor(height / 2), total - height));
+}
+var BADGE_WIDTH = 26;
+function badges(row) {
+  const names = [...new Set(row.findings.map((f) => f.ruleId.split("/")[1] ?? f.ruleId))];
+  const text = names.length > 1 ? `${names[0]} +${names.length - 1}` : names[0] ?? "";
+  return text.length > BADGE_WIDTH ? `${text.slice(0, BADGE_WIDTH - 1)}\u2026` : text;
+}
+function FileList(props) {
+  const { state, height, width } = props;
+  const rows = state.model.rows;
+  if (rows.length === 0) {
+    return /* @__PURE__ */ jsxs3(Text3, { color: "green", children: [
+      "Nothing to optimize",
+      state.model.covered > 0 ? ` (${state.model.covered} already optimized)` : "",
+      "."
+    ] });
+  }
+  const start = windowStart(state.cursor, rows.length, height);
+  const visible = rows.slice(start, start + height);
+  const sizeText = (row) => row.estimatedBytes !== null ? `${formatBytes(row.bytes)} \u2192 ~${formatBytes(row.estimatedBytes)} (${percentChange(row.bytes, row.estimatedBytes)})` : formatBytes(row.bytes);
+  const sizeWidth = Math.max(...rows.map((r) => sizeText(r).length));
+  const presetWidth = Math.max(...rows.map((r) => effectivePreset(state, r).length + 1));
+  const fixed = 2 + 4 + 1 + sizeWidth + 1 + 1 + presetWidth + 1 + BADGE_WIDTH;
+  const pathWidth = Math.max(12, width - 1 - fixed);
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    start > 0 ? /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+      " \u2191 ",
+      start,
+      " more"
+    ] }) : null,
+    visible.map((row, i) => {
+      const index = start + i;
+      const here = index === state.cursor;
+      const on = state.selected.has(row.source);
+      const preset = effectivePreset(state, row);
+      const overridden = state.presets[row.source] !== void 0;
+      const size = sizeText(row).padStart(sizeWidth);
+      const presetText = `${preset}${overridden ? "*" : ""}`.padEnd(presetWidth);
+      return /* @__PURE__ */ jsxs3(Box3, { children: [
+        /* @__PURE__ */ jsxs3(Text3, { color: here ? "cyan" : void 0, children: [
+          here ? "\u203A" : " ",
+          " "
+        ] }),
+        /* @__PURE__ */ jsxs3(Text3, { color: on ? "green" : "gray", children: [
+          on ? "[x]" : "[ ]",
+          " "
+        ] }),
+        /* @__PURE__ */ jsx3(Box3, { width: pathWidth, flexShrink: 0, children: /* @__PURE__ */ jsx3(Text3, { bold: here, wrap: "truncate-middle", children: row.source }) }),
+        /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+          " ",
+          size,
+          " "
+        ] }),
+        /* @__PURE__ */ jsxs3(Text3, { color: overridden ? "magenta" : "blue", children: [
+          " ",
+          presetText
+        ] }),
+        /* @__PURE__ */ jsxs3(Text3, { color: SEVERITY_COLOR[row.severity], children: [
+          " ",
+          badges(row)
+        ] })
+      ] }, row.source);
+    }),
+    start + height < rows.length ? /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+      " \u2193 ",
+      rows.length - start - height,
+      " more"
+    ] }) : null
+  ] });
+}
+function ReportOnly(props) {
+  const { findings, skipped } = props;
+  if (findings.length === 0 && skipped.length === 0) return null;
+  const byRule = /* @__PURE__ */ new Map();
+  for (const f of findings) byRule.set(f.ruleId, (byRule.get(f.ruleId) ?? 0) + 1);
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "Report only (optimize can't fix these yet):" }),
+    [...byRule.entries()].map(([rule, count]) => /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+      "  ",
+      rule,
+      " \xD7",
+      count
+    ] }, rule)),
+    skipped.map((s) => /* @__PURE__ */ jsxs3(Text3, { dimColor: true, wrap: "truncate-middle", children: [
+      "  ",
+      "skipped ",
+      s.source,
+      ": ",
+      s.reason
+    ] }, s.source))
+  ] });
+}
+function Details(props) {
+  const { state, row } = props;
+  if (!row) return null;
+  const preset = effectivePreset(state, row);
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", borderStyle: "round", paddingX: 1, children: [
+    /* @__PURE__ */ jsx3(Text3, { bold: true, wrap: "truncate-middle", children: row.source }),
+    /* @__PURE__ */ jsxs3(Text3, { children: [
+      formatBytes(row.bytes),
+      " \xB7 ",
+      row.width,
+      "x",
+      row.height,
+      " \xB7 preset ",
+      preset,
+      state.presets[row.source] ? " (your override)" : ""
+    ] }),
+    /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+      "classified: ",
+      row.reason
+    ] }),
+    row.estimatedBytes !== null ? /* @__PURE__ */ jsxs3(Text3, { children: [
+      "estimate: ~",
+      formatBytes(row.estimatedBytes),
+      " at the largest width (",
+      row.plannedOutputs,
+      " ",
+      "outputs planned)"
+    ] }) : null,
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "Findings" }),
+    row.findings.map((f) => /* @__PURE__ */ jsxs3(Text3, { children: [
+      /* @__PURE__ */ jsx3(Text3, { color: SEVERITY_COLOR[f.severity], children: f.severity.padEnd(5) }),
+      " ",
+      f.ruleId,
+      ":",
+      " ",
+      f.message
+    ] }, `${f.ruleId}${f.message}`)),
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "esc closes this" })
+  ] });
+}
+
+// src/tui/components/run.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { Fragment, jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var BAR_WIDTH = 30;
+function bar(done, total) {
+  const filled = total === 0 ? 0 : Math.round(done / total * BAR_WIDTH);
+  return "\u2588".repeat(filled) + "\u2591".repeat(BAR_WIDTH - filled);
+}
+var STATUS_COLOR = {
+  written: "green",
+  unchanged: "gray",
+  "already-optimal": "gray",
+  protected: "yellow",
+  unavailable: "yellow",
+  failed: "red",
+  unmet: "red",
+  cancelled: "yellow"
+};
+function ReviewView(props) {
+  const { review } = props;
+  const LIMIT = 12;
+  const shown = review.items.slice(0, LIMIT);
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs4(Text4, { bold: true, children: [
+      "Review: ",
+      plural(review.willEncode, "image"),
+      " \u2192 ",
+      plural(review.outputs, "output"),
+      " in",
+      " ",
+      props.outDir
+    ] }),
+    review.unchanged > 0 ? /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+      review.unchanged,
+      " already up to date (will be skipped)"
+    ] }) : null,
+    /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginTop: 1, children: [
+      shown.map((item) => /* @__PURE__ */ jsxs4(Box4, { children: [
+        /* @__PURE__ */ jsx4(Box4, { flexGrow: 1, flexShrink: 1, children: /* @__PURE__ */ jsx4(Text4, { wrap: "truncate-middle", dimColor: item.state !== "encode", children: item.source }) }),
+        /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+          " ",
+          item.state === "encode" ? `${item.preset} \xB7 ${plural(item.outputs, "output")}` : item.state === "unchanged" ? "unchanged" : `skipped: ${item.note}`
+        ] })
+      ] }, item.source)),
+      review.items.length > LIMIT ? /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+        "\u2026 and ",
+        review.items.length - LIMIT,
+        " more"
+      ] }) : null
+    ] }),
+    review.findings.length > 0 ? /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx4(Text4, { color: "yellow", children: "Heads up:" }),
+      review.findings.slice(0, 4).map((f) => /* @__PURE__ */ jsxs4(Text4, { color: "yellow", wrap: "truncate-end", children: [
+        "  ",
+        f.source,
+        ": ",
+        f.message
+      ] }, `${f.source}${f.path}${f.message}`))
+    ] }) : null,
+    /* @__PURE__ */ jsx4(Text4, { bold: true, color: "cyan", children: "enter to write these files \xB7 esc to go back" })
+  ] });
+}
+function RunView(props) {
+  const run = props.state.run;
+  if (!run) return null;
+  const tail = run.log.slice(-8);
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs4(Text4, { children: [
+      bar(run.done, run.total),
+      " ",
+      run.done,
+      "/",
+      run.total
+    ] }),
+    run.current ? /* @__PURE__ */ jsxs4(Text4, { dimColor: true, wrap: "truncate-middle", children: [
+      props.state.cancelling ? "finishing " : "optimizing ",
+      run.current
+    ] }) : null,
+    props.state.cancelling ? /* @__PURE__ */ jsx4(Text4, { color: "yellow", children: "Cancelling: finishing the current encode so no partial file is left behind\u2026" }) : null,
+    Object.entries(run.progress).filter(([, f]) => f > 0 && f < 1).slice(-2).map(([path, f]) => /* @__PURE__ */ jsxs4(Text4, { dimColor: true, wrap: "truncate-end", children: [
+      path,
+      " ",
+      Math.round(f * 100),
+      "%"
+    ] }, path)),
+    /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", marginTop: 1, children: tail.map(({ source, output }, i) => /* @__PURE__ */ jsxs4(
+      Text4,
+      {
+        color: STATUS_COLOR[output.status],
+        wrap: "truncate-end",
+        children: [
+          output.status === "written" ? "\u2713" : output.status === "failed" ? "\u2717" : "\xB7",
+          " ",
+          output.path,
+          " ",
+          output.bytes > 0 ? formatBytes(output.bytes) : "",
+          " ",
+          output.status
+        ]
+      },
+      `${source}${output.path}${i}`
+    )) })
+  ] });
+}
+function SnippetOverlay(props) {
+  const { snippet } = props;
+  const lines = snippet.code.split("\n");
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", borderStyle: "round", paddingX: 1, children: [
+    /* @__PURE__ */ jsx4(Text4, { bold: true, wrap: "truncate-middle", children: snippet.source }),
+    lines.map((line, i) => /* @__PURE__ */ jsx4(Text4, { wrap: "truncate-end", children: line }, i)),
+    /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginTop: 1, children: [
+      snippet.copied ? /* @__PURE__ */ jsxs4(Text4, { color: "green", children: [
+        "Copied to the clipboard (",
+        snippet.copied,
+        ")."
+      ] }) : /* @__PURE__ */ jsx4(Text4, { color: "yellow", children: "Could not reach the clipboard: select the text above to copy it." }),
+      snippet.hints.map((h) => /* @__PURE__ */ jsxs4(Text4, { dimColor: true, wrap: "truncate-end", children: [
+        "Note: ",
+        h
+      ] }, h)),
+      /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "c copy again \xB7 esc close" })
+    ] })
+  ] });
+}
+function SaveOverlay(props) {
+  const { save } = props;
+  const { choices, outcome } = save;
+  const entries = Object.entries(choices.presets ?? {});
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", borderStyle: "round", paddingX: 1, children: [
+    /* @__PURE__ */ jsx4(Text4, { bold: true, children: "Save these choices to the project config?" }),
+    /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginTop: 1, children: [
+      entries.slice(0, 10).map(([source, preset]) => /* @__PURE__ */ jsxs4(Text4, { wrap: "truncate-middle", children: [
+        source,
+        " \u2192 ",
+        preset
+      ] }, source)),
+      entries.length > 10 ? /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+        "\u2026 and ",
+        entries.length - 10,
+        " more"
+      ] }) : null,
+      choices.outDir !== void 0 ? /* @__PURE__ */ jsxs4(Text4, { children: [
+        "output folder \u2192 ",
+        choices.outDir
+      ] }) : null
+    ] }),
+    /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginTop: 1, children: [
+      outcome === null ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "y save \xB7 n not now" }) : outcome.kind === "written" ? /* @__PURE__ */ jsxs4(Text4, { color: "green", children: [
+        outcome.created ? "Created" : "Updated",
+        " ",
+        outcome.file,
+        ". Later runs use it."
+      ] }) : outcome.kind === "manual" ? /* @__PURE__ */ jsxs4(Fragment, { children: [
+        /* @__PURE__ */ jsxs4(Text4, { color: "yellow", children: [
+          outcome.file,
+          " is a file you maintain, so it was not rewritten. Add:"
+        ] }),
+        outcome.snippet.split("\n").map((line, i) => /* @__PURE__ */ jsx4(Text4, { children: line }, i))
+      ] }) : outcome.kind === "error" ? /* @__PURE__ */ jsx4(Text4, { color: "red", children: outcome.message }) : /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Nothing to save." }),
+      outcome !== null ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "any key closes this" }) : null
+    ] })
+  ] });
+}
+function DoneView(props) {
+  const { result } = props.state;
+  if (!result) return null;
+  const summary = formatSummary(result).split("\n");
+  const split = summary.lastIndexOf("");
+  const totals = summary.slice(split + 1);
+  const files = summary.slice(0, Math.max(0, split)).filter((l) => !l.startsWith("  "));
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx4(Text4, { bold: true, color: result.cancelled ? "yellow" : "green", children: result.cancelled ? "Cancelled" : "Done" }),
+    /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginTop: 1, children: [
+      files.slice(0, 12).map((line, i) => /* @__PURE__ */ jsxs4(
+        Text4,
+        {
+          wrap: "truncate-end",
+          color: i === props.state.doneCursor ? "cyan" : void 0,
+          children: [
+            i === props.state.doneCursor ? "\u203A " : "  ",
+            line
+          ]
+        },
+        i
+      )),
+      files.length > 12 ? /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+        "\u2026 and ",
+        files.length - 12,
+        " more files"
+      ] }) : null
+    ] }),
+    /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", marginTop: 1, children: totals.map((line, i) => /* @__PURE__ */ jsx4(Text4, { children: line }, i)) }),
+    result.warnings.map((w) => /* @__PURE__ */ jsxs4(Text4, { color: "yellow", wrap: "truncate-end", children: [
+      "warning: ",
+      w
+    ] }, w))
+  ] });
+}
+
+// src/tui/session.ts
+import { stat } from "fs/promises";
+import { relative, resolve } from "path";
+import { readFile } from "fs/promises";
+function createSession(options) {
+  const { projectRoot, engine } = options;
+  const compareServers = [];
+  let config = options.config ?? resolveConfigData({}, options.project, null);
+  const common = (outDir) => ({
+    projectRoot,
+    engine,
+    toolVersion: options.toolVersion,
+    videoEngine: options.videoEngine ?? null,
+    ...options.needsFfmpeg ? { needsFfmpeg: options.needsFfmpeg } : {},
+    outDir,
+    staticRoot: config.project.staticRoot,
+    publicPath: config.project.publicPath,
+    policy: config.policy,
+    exclude: config.exclude,
+    ...config.placeholder ? { placeholder: config.placeholder } : {},
+    ...options.makeScorer ? { makeScorer: options.makeScorer } : {}
+  });
+  return {
+    async scan(outDir, presets, onProgress) {
+      const report = await audit({
+        projectRoot,
+        engine,
+        svgEngine: options.svgEngine,
+        inputs: options.inputs,
+        outDir,
+        staticRoot: config.project.staticRoot,
+        policy: config.policy,
+        exclude: config.exclude,
+        ignore: config.auditIgnore,
+        settings: config.rules,
+        budgets: config.budgets,
+        ffmpeg: options.ffmpeg,
+        videoEngine: options.videoEngine ?? null,
+        ...options.needsFfmpeg ? { needsFfmpeg: options.needsFfmpeg } : {},
+        persistCache: true,
+        presetOverrides: presets,
+        onProgress
+      });
+      return { model: buildModel(report), files: report.files.map((f) => f.source) };
+    },
+    async review(sources, presets, outDir) {
+      const outcome = await optimize({
+        ...common(outDir),
+        inputs: sources,
+        presetOverrides: presets,
+        execute: false
+      });
+      const videoItems = (outcome.plan.videos ?? []).map((item) => {
+        if (item.skip) {
+          return {
+            source: item.source,
+            preset: item.preset,
+            state: "skipped",
+            outputs: 0,
+            note: item.skip.reason
+          };
+        }
+        const unchanged = outcome.cache.get(item.source)?.kind === "hit";
+        return {
+          source: item.source,
+          preset: item.preset,
+          state: unchanged ? "unchanged" : "encode",
+          outputs: item.outputs.length
+        };
+      });
+      const items = [
+        ...outcome.plan.items.map((item) => {
+          if (item.skip) {
+            return {
+              source: item.source,
+              preset: item.preset,
+              state: "skipped",
+              outputs: 0,
+              note: item.skip.reason
+            };
+          }
+          const unchanged = outcome.cache.get(item.source)?.kind === "hit";
+          return {
+            source: item.source,
+            preset: item.preset,
+            state: unchanged ? "unchanged" : "encode",
+            outputs: item.outputs.length
+          };
+        }),
+        ...videoItems
+      ];
+      return {
+        plan: outcome.plan,
+        items,
+        willEncode: items.filter((i) => i.state === "encode").length,
+        unchanged: items.filter((i) => i.state === "unchanged").length,
+        outputs: items.filter((i) => i.state === "encode").reduce((n, i) => n + i.outputs, 0),
+        findings: outcome.findings
+      };
+    },
+    async run(sources, presets, outDir, handlers, signal) {
+      const outcome = await optimize({
+        ...common(outDir),
+        inputs: sources,
+        presetOverrides: presets,
+        execute: true,
+        signal,
+        concurrency: options.concurrency ?? config.concurrency ?? 2,
+        onItemStart: handlers.onItemStart,
+        onOutputDone: handlers.onOutput,
+        onItemDone: (result) => handlers.onItemDone(result),
+        onVideoItemStart: handlers.onItemStart,
+        onVideoOutputDone: handlers.onOutput,
+        onVideoItemDone: (result) => handlers.onItemDone(result),
+        ...handlers.onProgress ? { onVideoProgress: handlers.onProgress } : {}
+      });
+      if (!outcome.result) {
+        throw new BytecutError("BAD_ARGUMENTS", "Nothing was run.");
+      }
+      return outcome.result;
+    },
+    async snippet(source, outDir) {
+      let text;
+      try {
+        text = await readFile(resolve(projectRoot, outDir, MANIFEST_FILE), "utf8");
+      } catch {
+        return { error: `No manifest in ${outDir} yet: run the optimizer first.` };
+      }
+      const manifest = parseManifest(text);
+      const built = buildSnippet(
+        manifest,
+        { source, originalUrl: originalUrl(source, config.project.staticRoot) },
+        { format: snippetFormatFor(config.project) }
+      );
+      if (!built) return { error: `${source} has not been optimized yet.` };
+      return { code: built.code, hints: built.hints };
+    },
+    async compare(source, outDir) {
+      let text;
+      try {
+        text = await readFile(resolve(projectRoot, outDir, MANIFEST_FILE), "utf8");
+      } catch {
+        return { error: `No manifest in ${outDir} yet: run the optimizer first.` };
+      }
+      try {
+        const server = await startCompareServer({
+          projectRoot,
+          outDir,
+          manifest: parseManifest(text),
+          source
+        });
+        compareServers.push(server);
+        return { url: server.url };
+      } catch (error) {
+        return { error: error instanceof Error ? error.message : String(error) };
+      }
+    },
+    async stop() {
+      await Promise.all(compareServers.splice(0).map((s) => s.close()));
+    },
+    async saveChoices(choices) {
+      if (isEmpty(choices)) return { kind: "nothing" };
+      try {
+        const loaded = await loadConfig(projectRoot);
+        if (loaded && !canRewrite(loaded.format)) {
+          return {
+            kind: "manual",
+            file: loaded.name,
+            snippet: renderChoicesSnippet(loaded.format, choices)
+          };
+        }
+        const next = applyChoices(loaded?.raw ?? {}, choices);
+        const file = loaded?.name ?? "bytecut.config.json";
+        parseConfig(next, file);
+        await writeConfigFile(projectRoot, file, renderConfig("json", next));
+        config = await resolveConfig(projectRoot, await loadConfig(projectRoot));
+        return { kind: "written", file, created: loaded === null };
+      } catch (error) {
+        return { kind: "error", message: error instanceof Error ? error.message : String(error) };
+      }
+    },
+    async validateOutDir(outDir, sources) {
+      const absolute = resolve(projectRoot, outDir);
+      try {
+        await SafeFs.create({
+          projectRoot,
+          outDir: absolute,
+          sourceFiles: sources.map((s) => resolve(projectRoot, ...s.split("/"))),
+          sourceDirs: []
+        });
+        const info = await stat(absolute).catch(() => null);
+        if (info && !info.isDirectory()) return `${outDir} is a file, not a folder`;
+        return null;
+      } catch (error) {
+        return error instanceof Error ? error.message : String(error);
+      }
+    }
+  };
+}
+function displayOutDir(projectRoot, outDir) {
+  const rel = relative(projectRoot, resolve(projectRoot, outDir));
+  return toPosix(rel === "" ? "." : rel);
+}
+
+// src/tui/app.tsx
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var FRAMEWORK_NAMES = {
+  next: "Next.js",
+  astro: "Astro",
+  vite: "Vite",
+  static: "static site"
+};
+function App(props) {
+  const { session, project, projectRoot } = props;
+  const { exit } = useApp();
+  const { stdout } = useStdout();
+  const [state, dispatch] = useReducer(
+    reducer,
+    props.outDir,
+    (outDir) => initialState(outDir, props.presetNames)
+  );
+  const [doctor, setDoctor] = useState(null);
+  const stateRef = useRef(state);
+  stateRef.current = state;
+  const abortRef = useRef(null);
+  const declinedRef = useRef(null);
+  const term = stdout;
+  const rows = term?.rows ?? 24;
+  const columns = term?.columns ?? 100;
+  const listHeight = Math.max(5, rows - 12);
+  useEffect(() => {
+    let cancelled = false;
+    void (async () => {
+      try {
+        const { model: model2, files } = await session.scan(
+          stateRef.current.outDir,
+          stateRef.current.presets,
+          (p) => {
+            if (!cancelled) dispatch({ type: "scan-progress", ...p });
+          }
+        );
+        if (!cancelled) dispatch({ type: "scan-done", model: model2, files });
+      } catch (error) {
+        if (!cancelled) {
+          dispatch({
+            type: "fatal",
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [session, state.scanId]);
+  const startReview = useCallback(
+    async (only) => {
+      const s = stateRef.current;
+      const sources = only ?? s.model.rows.filter((r) => s.selected.has(r.source)).map((r) => r.source);
+      if (sources.length === 0) {
+        dispatch({ type: "status", message: "Nothing selected: press space to select files." });
+        return;
+      }
+      dispatch({ type: "status", message: "Planning\u2026" });
+      try {
+        const review = await session.review(sources, s.presets, s.outDir);
+        dispatch({ type: "review-ready", review });
+      } catch (error) {
+        dispatch({
+          type: "status",
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
+    },
+    [session]
+  );
+  const startRun = useCallback(async () => {
+    const s = stateRef.current;
+    if (!s.review) return;
+    const sources = s.review.items.filter((i) => i.state === "encode").map((i) => i.source);
+    if (sources.length === 0) {
+      dispatch({ type: "status", message: "Everything is already up to date." });
+      return;
+    }
+    const controller = new AbortController();
+    abortRef.current = controller;
+    dispatch({ type: "run-start", total: sources.length });
+    try {
+      const result = await session.run(
+        sources,
+        s.presets,
+        s.outDir,
+        {
+          onItemStart: (source) => dispatch({ type: "run-item-start", source }),
+          onOutput: (source, output) => dispatch({ type: "run-output", source, output }),
+          onItemDone: () => dispatch({ type: "run-item-done" }),
+          onProgress: (_source, path, fraction) => dispatch({ type: "run-progress", path, fraction })
+        },
+        controller.signal
+      );
+      dispatch({ type: "run-done", result });
+      const unsaved = unsavedChoices(stateRef.current);
+      if (!result.cancelled && (unsaved.outDir !== void 0 || unsaved.presets !== void 0) && JSON.stringify(unsaved) !== declinedRef.current) {
+        dispatch({ type: "save-open", choices: unsaved });
+      }
+    } catch (error) {
+      dispatch({ type: "fatal", error: error instanceof Error ? error.message : String(error) });
+    } finally {
+      abortRef.current = null;
+    }
+  }, [session]);
+  const cancelRun = useCallback(() => {
+    dispatch({ type: "cancel" });
+    abortRef.current?.abort();
+  }, []);
+  const applyOutDir = useCallback(
+    async (text) => {
+      const value = text.trim();
+      if (!value) return;
+      const s = stateRef.current;
+      const reason = await session.validateOutDir(
+        value,
+        s.model.rows.map((r) => r.source)
+      );
+      if (reason) {
+        dispatch({ type: "status", message: reason });
+        return;
+      }
+      dispatch({ type: "set-out-dir", outDir: displayOutDir(projectRoot, value) });
+      dispatch({ type: "rescan" });
+    },
+    [session, projectRoot]
+  );
+  const resolveMentions = useCallback((mentions) => {
+    const known = stateRef.current.model.rows.map((r) => r.source);
+    const out = [];
+    for (const m of mentions) {
+      const hit = known.includes(m) ? m : fuzzyFiles(m, known, 1)[0];
+      if (hit) out.push(hit);
+    }
+    return out;
+  }, []);
+  const copy = props.copy ?? ((text) => copyToClipboard(text, systemClipboardDeps()));
+  const showSnippet = useCallback(
+    async (source) => {
+      const s = stateRef.current;
+      const built = await session.snippet(source, s.outDir);
+      if ("error" in built) {
+        dispatch({ type: "status", message: built.error });
+        return;
+      }
+      dispatch({
+        type: "snippet",
+        snippet: { source, code: built.code, hints: built.hints, copied: null }
+      });
+      const result = await copy(built.code);
+      dispatch({ type: "snippet-copied", copied: result.ok ? result.method : null });
+    },
+    [session, copy]
+  );
+  const askToSave = useCallback(() => {
+    const unsaved = unsavedChoices(stateRef.current);
+    if (unsaved.outDir === void 0 && unsaved.presets === void 0) {
+      dispatch({
+        type: "status",
+        message: "Nothing to save: no choice differs from the project config."
+      });
+      return;
+    }
+    dispatch({ type: "save-open", choices: unsaved });
+  }, []);
+  const confirmSave = useCallback(async () => {
+    const s = stateRef.current;
+    if (!s.save) return;
+    dispatch({ type: "save-result", outcome: await session.saveChoices(s.save.choices) });
+  }, [session]);
+  const doneFiles = useCallback(() => {
+    const r = stateRef.current.result;
+    return r ? [...r.items.map((i) => i.source), ...(r.videos ?? []).map((v) => v.source)] : [];
+  }, []);
+  const execute = useCallback(
+    async (text) => {
+      const s = stateRef.current;
+      if (!text.trim().startsWith("/")) {
+        const mention = /@(\S+)/.exec(text)?.[1];
+        const [hit] = mention ? resolveMentions([mention]) : [];
+        dispatch({ type: "overlay", overlay: null });
+        if (hit) dispatch({ type: "cursor-to", source: hit });
+        else dispatch({ type: "status", message: "No such file in the list." });
+        return;
+      }
+      const parsed = parseCommand(text);
+      if (!parsed.ok) {
+        dispatch({ type: "status", message: parsed.error });
+        return;
+      }
+      const targets = resolveMentions(parsed.mentions);
+      dispatch({ type: "overlay", overlay: null });
+      switch (parsed.name) {
+        case "audit":
+          dispatch({ type: "rescan" });
+          return;
+        case "optimize":
+          if (targets.length > 0) dispatch({ type: "select-files", sources: targets });
+          await startReview(targets.length > 0 ? targets : void 0);
+          return;
+        case "preset": {
+          const name = parsed.args[0];
+          if (!name || !s.presetNames.includes(name)) {
+            dispatch({
+              type: "status",
+              message: `Usage: /preset <${s.presetNames.join("|")}> [@file\u2026]`
+            });
+            return;
+          }
+          const sources = targets.length > 0 ? targets : rowAt(s) ? [rowAt(s).source] : [];
+          dispatch({ type: "cycle-preset", sources, to: name });
+          return;
+        }
+        case "save":
+          askToSave();
+          return;
+        case "out":
+          if (parsed.args[0]) await applyOutDir(parsed.args[0]);
+          else dispatch({ type: "status", message: "Usage: /out <dir>" });
+          return;
+        case "select": {
+          const mode = parsed.args[0];
+          if (mode === "all" || mode === "none" || mode === "warn") {
+            dispatch({ type: "select", mode });
+          } else dispatch({ type: "status", message: "Usage: /select <all|none|warn>" });
+          return;
+        }
+        case "snippet": {
+          const known = s.files;
+          const wanted = parsed.mentions[0];
+          const hit = wanted ? known.includes(wanted) ? wanted : fuzzyFiles(wanted, known, 1)[0] : rowAt(s)?.source;
+          if (!hit) {
+            dispatch({ type: "status", message: "Usage: /snippet @file (an optimized file)" });
+            return;
+          }
+          await showSnippet(hit);
+          return;
+        }
+        case "compare": {
+          const wanted = parsed.mentions[0];
+          const hit = wanted ? s.files.includes(wanted) ? wanted : fuzzyFiles(wanted, s.files, 1)[0] : rowAt(s)?.source;
+          if (!hit) {
+            dispatch({ type: "status", message: "Usage: /compare @file (an optimized file)" });
+            return;
+          }
+          const started = await session.compare(hit, s.outDir);
+          dispatch({
+            type: "status",
+            message: "error" in started ? started.error : `Compare ${hit}: ${started.url} (local only; stops when you quit)`
+          });
+          return;
+        }
+        case "doctor":
+          dispatch({ type: "overlay", overlay: "doctor" });
+          void props.loadDoctor().then(setDoctor);
+          return;
+        case "help":
+          dispatch({ type: "overlay", overlay: "help" });
+          return;
+        case "quit":
+          exit();
+          return;
+      }
+    },
+    [applyOutDir, askToSave, exit, props, resolveMentions, showSnippet, startReview]
+  );
+  const suggestions = useMemo(
+    () => computeSuggestions(state.input, state.files),
+    [state.input, state.files]
+  );
+  useInput((input, key) => {
+    const s = stateRef.current;
+    if (key.ctrl && input === "c") {
+      if (s.view === "running") cancelRun();
+      else exit();
+      return;
+    }
+    const clean = (t) => t.replace(/[\u0000-\u001f\u007f]/g, "");
+    const chunk = input.length > 1 && !key.ctrl && !key.meta ? input : null;
+    if (chunk !== null) {
+      const submit = /[\r\n]$/.test(chunk);
+      const text = clean(chunk);
+      if (s.overlay === "command" || s.overlay === "outdir") {
+        const next = s.input + text;
+        dispatch({ type: "input", text: next });
+        if (submit) {
+          if (s.overlay === "outdir") void applyOutDir(next);
+          else void execute(next);
+        }
+        return;
+      }
+      if (!s.overlay && s.view === "list" && (text.startsWith("/") || text.startsWith("@"))) {
+        dispatch({ type: "overlay", overlay: "command", input: text });
+        if (submit) void execute(text);
+        return;
+      }
+    }
+    if (s.overlay === "command" || s.overlay === "outdir") {
+      if (key.escape) {
+        dispatch({ type: "back" });
+      } else if (key.return) {
+        if (s.overlay === "outdir") void applyOutDir(s.input);
+        else {
+          const picked = suggestions.items[s.suggestion];
+          if (picked && suggestions.kind === "command" && /^\/\S*$/.test(s.input.trim())) {
+            const complete = `/${picked.value}`;
+            if (s.input.trim() !== complete) {
+              dispatch({ type: "input", text: `${complete} ` });
+              return;
+            }
+          }
+          void execute(s.input);
+        }
+      } else if (key.tab) {
+        const picked = suggestions.items[s.suggestion];
+        if (!picked) return;
+        dispatch({
+          type: "input",
+          text: suggestions.kind === "file" ? completeMention(s.input, picked.value) : `/${picked.value} `
+        });
+      } else if (key.upArrow) {
+        dispatch({ type: "suggest", delta: -1, max: suggestions.items.length });
+      } else if (key.downArrow) {
+        dispatch({ type: "suggest", delta: 1, max: suggestions.items.length });
+      } else if (key.backspace || key.delete) {
+        dispatch({ type: "input", text: s.input.slice(0, -1) });
+      } else if (input && !key.ctrl && !key.meta) {
+        dispatch({ type: "input", text: s.input + input.replace(/[\u0000-\u001f\u007f]/g, "") });
+      }
+      return;
+    }
+    if (s.overlay === "snippet") {
+      if (input === "c" && s.snippet) {
+        void copy(s.snippet.code).then(
+          (r) => dispatch({ type: "snippet-copied", copied: r.ok ? r.method : null })
+        );
+      } else if (key.escape || key.return || input === "q") {
+        dispatch({ type: "back" });
+      }
+      return;
+    }
+    if (s.overlay === "save") {
+      if (s.save?.outcome != null) dispatch({ type: "back" });
+      else if (input === "y" || key.return) void confirmSave();
+      else if (input === "n" || input === "q" || key.escape) {
+        if (s.save) declinedRef.current = JSON.stringify(s.save.choices);
+        dispatch({ type: "back" });
+      }
+      return;
+    }
+    if (s.overlay) {
+      if (key.escape || key.return || input === "q" || input === "?" || input === "d") {
+        dispatch({ type: "back" });
+      }
+      return;
+    }
+    if (input === "q" && s.view !== "running") {
+      exit();
+      return;
+    }
+    switch (s.view) {
+      case "list":
+        if (key.upArrow || input === "k") dispatch({ type: "move", delta: -1 });
+        else if (key.downArrow || input === "j") dispatch({ type: "move", delta: 1 });
+        else if (key.pageUp) dispatch({ type: "move", delta: -listHeight });
+        else if (key.pageDown) dispatch({ type: "move", delta: listHeight });
+        else if (input === " ") dispatch({ type: "toggle" });
+        else if (input === "a") dispatch({ type: "toggle-all" });
+        else if (input === "p") dispatch({ type: "cycle-preset" });
+        else if (input === "d") {
+          if (rowAt(s)) dispatch({ type: "overlay", overlay: "details" });
+        } else if (input === "o") dispatch({ type: "overlay", overlay: "outdir", input: s.outDir });
+        else if (input === "?") dispatch({ type: "overlay", overlay: "help" });
+        else if (input === "/") dispatch({ type: "overlay", overlay: "command", input: "/" });
+        else if (input === "@") dispatch({ type: "overlay", overlay: "command", input: "@" });
+        else if (key.return) void startReview();
+        break;
+      case "review":
+        if (key.return) void startRun();
+        else if (key.escape) dispatch({ type: "back" });
+        break;
+      case "running":
+        if (key.escape) cancelRun();
+        break;
+      case "done": {
+        const files = doneFiles();
+        if (key.upArrow || input === "k")
+          dispatch({ type: "done-move", delta: -1, max: files.length - 1 });
+        else if (key.downArrow || input === "j")
+          dispatch({ type: "done-move", delta: 1, max: files.length - 1 });
+        else if (input === "c") {
+          const file = files[s.doneCursor];
+          if (file) void showSnippet(file);
+        } else if (input === "s") askToSave();
+        else if (key.return || key.escape) dispatch({ type: "back" });
+        break;
+      }
+      case "scanning":
+      case "error":
+        break;
+    }
+  });
+  const model = state.model;
+  const scanLabel = props.inputs.join(", ");
+  let body;
+  if (state.view === "scanning") {
+    const sc = state.scan;
+    body = /* @__PURE__ */ jsxs5(Text5, { children: [
+      "Scanning",
+      sc && sc.total > 0 ? ` ${Math.min(sc.done, sc.total)}/${sc.total} images (${sc.phase})` : "",
+      "\u2026"
+    ] });
+  } else if (state.view === "error") {
+    body = /* @__PURE__ */ jsx5(Text5, { color: "red", children: state.error });
+  } else if (state.view === "review" && state.review) {
+    body = /* @__PURE__ */ jsx5(ReviewView, { review: state.review, outDir: state.outDir });
+  } else if (state.view === "running") {
+    body = /* @__PURE__ */ jsx5(RunView, { state });
+  } else if (state.overlay === "save" && state.save) {
+    body = state.view === "done" ? /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx5(DoneView, { state }),
+      /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx5(SaveOverlay, { save: state.save, outDir: state.outDir }) })
+    ] }) : /* @__PURE__ */ jsx5(SaveOverlay, { save: state.save, outDir: state.outDir });
+  } else if (state.overlay === "snippet" && state.snippet) {
+    body = /* @__PURE__ */ jsx5(SnippetOverlay, { snippet: state.snippet });
+  } else if (state.view === "done") {
+    body = /* @__PURE__ */ jsx5(DoneView, { state });
+  } else if (state.overlay === "help") {
+    body = /* @__PURE__ */ jsx5(Help, {});
+  } else if (state.overlay === "details") {
+    body = /* @__PURE__ */ jsx5(Details, { state, row: rowAt(state) });
+  } else if (state.overlay === "doctor") {
+    body = /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", borderStyle: "round", paddingX: 1, children: [
+      /* @__PURE__ */ jsx5(Text5, { children: doctor ?? "Checking\u2026" }),
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "esc closes this" })
+    ] });
+  } else {
+    body = /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx5(FileList, { state, height: listHeight, width: columns }),
+      /* @__PURE__ */ jsx5(ReportOnly, { findings: model.reportOnly, skipped: model.skipped }),
+      model.notes.map((n) => /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: n }, n)),
+      state.overlay === "command" ? /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx5(
+        CommandBar,
+        {
+          prompt: "\u203A",
+          input: state.input,
+          suggestions,
+          selected: state.suggestion,
+          hint: "tab completes \xB7 enter runs \xB7 esc cancels \xB7 @ mentions a file"
+        }
+      ) }) : null,
+      state.overlay === "outdir" ? /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx5(
+        CommandBar,
+        {
+          prompt: "Output folder:",
+          input: state.input,
+          suggestions: { kind: "none", items: [] },
+          selected: 0,
+          hint: "enter applies (the project is rescanned) \xB7 esc cancels"
+        }
+      ) }) : null
+    ] });
+  }
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx5(
+      Header,
+      {
+        framework: FRAMEWORK_NAMES[project.framework] ?? project.framework,
+        scanning: scanLabel,
+        outDir: state.outDir
+      }
+    ),
+    body,
+    /* @__PURE__ */ jsx5(StatusLine, { state, model })
+  ] });
+}
+
+// src/tui/index.tsx
+import { jsx as jsx6 } from "react/jsx-runtime";
+async function runTui(options) {
+  const session = options.session ?? createSession({
+    projectRoot: options.projectRoot,
+    engine: options.engine,
+    svgEngine: options.svgEngine,
+    project: options.project,
+    ...options.config ? { config: options.config } : {},
+    inputs: options.inputs,
+    toolVersion: options.toolVersion,
+    ffmpeg: options.ffmpeg,
+    videoEngine: options.videoEngine ?? null,
+    ...options.makeScorer ? { makeScorer: options.makeScorer } : {},
+    ...options.needsFfmpeg ? { needsFfmpeg: options.needsFfmpeg } : {}
+  });
+  const instance = render(
+    /* @__PURE__ */ jsx6(
+      App,
+      {
+        session,
+        project: options.project,
+        projectRoot: options.projectRoot,
+        inputs: options.inputs,
+        outDir: options.outDir,
+        presetNames: options.config ? Object.keys(options.config.catalog.image) : void 0,
+        loadDoctor: options.loadDoctor
+      }
+    ),
+    { exitOnCtrlC: false }
+  );
+  try {
+    await instance.waitUntilExit();
+  } finally {
+    await session.stop();
+  }
+}
+export {
+  runTui
+};