@vertaaux/cli 0.3.3 → 0.5.0

package/node_modules/@vertaaux/tui/dist/index.cjs

@@ -202,6 +202,7 @@ var tokens = {
 var _colorEnabled = true;
 function setColorEnabled(enabled) {
   _colorEnabled = enabled;
+  chalk__default.default.level = enabled ? 3 : 0;
 }
 function isColorEnabled() {
   return _colorEnabled;
@@ -222,6 +223,17 @@ function bold(text) {
   if (!_colorEnabled) return text;
   return chalk__default.default.bold(text);
 }
+function severityColor(level) {
+  const normalized = (level || "info").toLowerCase();
+  const hex = severity[normalized] ?? severity.info;
+  const isBold = ["critical", "error", "serious", "warning"].includes(normalized);
+  const label2 = normalized.toUpperCase();
+  return isBold ? boldColor(label2, hex) : colorize(label2, hex);
+}
+function bgColor(text, hex) {
+  if (!_colorEnabled) return text;
+  return chalk__default.default.bgHex(hex)(text);
+}
 function applyGradient(text, colors = gradient) {
   if (!_colorEnabled) return text;
   const colorCount = colors.length;
@@ -260,7 +272,7 @@ function shouldUseColor() {
   return isTTY();
 }
 function getTerminalWidth() {
-  return process.stderr.columns || 80;
+  return parseInt(process.env.COLUMNS ?? "", 10) || process.stderr.columns || 80;
 }
 function getTerminalHeight() {
   return process.stderr.rows || 24;
@@ -273,6 +285,96 @@ function supportsUnicode() {
   return true;
 }
 
+// src/symbols.ts
+var SYMBOL_MAP = {
+  nerd: {
+    // Nerd Font Material Design icons (private use area U+F0000+)
+    success: "\u{F012C}",
+    // 󰄬  nf-md-check_circle
+    fail: "\u{F0156}",
+    // 󰅖  nf-md-close_circle
+    warning: "\u{F01A6}",
+    // 󰀦  nf-md-alert
+    info: "\u{F02FD}",
+    // 󰋽  nf-md-information
+    pending: "\u25EF",
+    // ◯  large circle (no NF required)
+    running: "\u25C9"
+    // ◉  fisheye (no NF required)
+  },
+  unicode: {
+    success: "\u2713",
+    fail: "\u2717",
+    warning: "\u25B2",
+    info: "\u2139",
+    pending: "\u25CB",
+    running: "\u25C6"
+  },
+  ascii: {
+    success: "+",
+    fail: "x",
+    warning: "!",
+    info: "i",
+    pending: "-",
+    running: "*"
+  }
+};
+var _tier = "unicode";
+function setSymbolTier(tier) {
+  _tier = tier;
+}
+function sym(role) {
+  return SYMBOL_MAP[_tier][role];
+}
+function detectSymbolTier(options = {}) {
+  if (options.plainMode) return "ascii";
+  const envIcons = process.env.VERTAA_ICONS;
+  if (envIcons === "nerd" || envIcons === "unicode" || envIcons === "ascii") {
+    return envIcons;
+  }
+  const termProgram = process.env.TERM_PROGRAM;
+  if (termProgram === "iTerm.app" || termProgram === "WezTerm") {
+    return "nerd";
+  }
+  if (supportsUnicode()) return "unicode";
+  return "ascii";
+}
+
+// src/plain.ts
+var _plainMode = false;
+function setPlainMode(enabled) {
+  _plainMode = enabled;
+  if (enabled) {
+    setColorEnabled(false);
+    setSymbolTier("ascii");
+  }
+}
+function isPlainMode() {
+  return _plainMode;
+}
+function toPlainBox(str) {
+  if (!_plainMode) return str;
+  return str.replace(/[─━═]/g, "-").replace(/[│┃║]/g, "|").replace(/[╭╮╰╯]/g, "+").replace(/[┌┍┎┏╔]/g, "+").replace(/[┐┑┒┓╗]/g, "+").replace(/[└┕┖┗╚]/g, "+").replace(/[┘┙┚┛╝]/g, "+").replace(/[├┤┬┴┼]/g, "+");
+}
+
+// src/easing.ts
+function linear(t) {
+  return t;
+}
+function easeIn(t) {
+  return t * t;
+}
+function easeOut(t) {
+  return t * (2 - t);
+}
+function easeInOut(t) {
+  return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+}
+function lerp(from, to, t, ease = linear) {
+  const clamped = Math.max(0, Math.min(1, t));
+  return from + (to - from) * ease(clamped);
+}
+
 // src/primitives/text.ts
 var text_exports = {};
 __export(text_exports, {
@@ -391,7 +493,8 @@ function box(content, opts = {}) {
     result.push(bc(chars.vertical) + " ".repeat(termWidth - 2) + bc(chars.vertical));
   }
   result.push(renderBottomBorder(chars, termWidth, subtitle, borderColor));
-  return result.join("\n");
+  const output = result.join("\n");
+  return toPlainBox(output);
 }
 function renderNoBorder(content, padding) {
   const pad = " ".repeat(padding);
@@ -536,6 +639,9 @@ function alignCell(text, width, align) {
 // src/primitives/spinner.ts
 var BRAILLE_FRAMES = ["\u287F", "\u28DF", "\u28EF", "\u28F7", "\u28FE", "\u28FD", "\u28FB", "\u28BF"];
 var FRAME_INTERVAL = 80;
+function spinnerFrame(frameIndex) {
+  return BRAILLE_FRAMES[frameIndex % BRAILLE_FRAMES.length];
+}
 function createSpinner(text, output = process.stderr) {
   let frameIndex = 0;
   let currentText = text;
@@ -545,6 +651,11 @@ function createSpinner(text, output = process.stderr) {
   const enabled = isTTY();
   function render() {
     if (!enabled) return;
+    if (isPlainMode()) {
+      output.write(`[running] ${currentText}
+`);
+      return;
+    }
     const frame = isColorEnabled() ? colorize(BRAILLE_FRAMES[frameIndex], brand.lime) : BRAILLE_FRAMES[frameIndex];
     const phaseStr = currentPhase ? dim(` [${currentPhase}]`) : "";
     const line = `${frame} ${currentText}${phaseStr}`;
@@ -569,8 +680,12 @@ function createSpinner(text, output = process.stderr) {
       running = true;
       frameIndex = 0;
       if (enabled) {
-        render();
-        timer = setInterval(render, FRAME_INTERVAL);
+        if (isPlainMode()) {
+          render();
+        } else {
+          render();
+          timer = setInterval(render, FRAME_INTERVAL);
+        }
       }
     },
     stop() {
@@ -589,23 +704,23 @@ function createSpinner(text, output = process.stderr) {
     },
     succeed(text2) {
       instance.stop();
-      const sym = isColorEnabled() ? colorize("\u2713", "#4ADE80") : "\u2713";
-      writeFinalLine(sym, text2);
+      const icon = isColorEnabled() ? colorize(sym("success"), "#4ADE80") : sym("success");
+      writeFinalLine(icon, text2);
     },
     fail(text2) {
       instance.stop();
-      const sym = isColorEnabled() ? colorize("\u2717", "#F87171") : "\u2717";
-      writeFinalLine(sym, text2);
+      const icon = isColorEnabled() ? colorize(sym("fail"), "#F87171") : sym("fail");
+      writeFinalLine(icon, text2);
     },
     warn(text2) {
       instance.stop();
-      const sym = isColorEnabled() ? colorize("\u26A0", "#FACC15") : "\u26A0";
-      writeFinalLine(sym, text2);
+      const icon = isColorEnabled() ? colorize(sym("warning"), "#FACC15") : sym("warning");
+      writeFinalLine(icon, text2);
     },
     info(text2) {
       instance.stop();
-      const sym = isColorEnabled() ? colorize("\u2139", "#6BCEFF") : "\u2139";
-      writeFinalLine(sym, text2);
+      const icon = isColorEnabled() ? colorize(sym("info"), "#6BCEFF") : sym("info");
+      writeFinalLine(icon, text2);
     }
   };
   return instance;
@@ -623,7 +738,7 @@ function createProgressBar(opts) {
     output = process.stderr
   } = opts;
   const enabled = isTTY();
-  let startTime = Date.now();
+  const startTime = Date.now();
   function renderBar(current, barWidth) {
     const pct = total > 0 ? Math.min(current / total, 1) : 0;
     const pctStr = `${Math.round(pct * 100)}%`;
@@ -645,8 +760,8 @@ function createProgressBar(opts) {
       if (!enabled) return;
       output.write(screen.clearLine + "\r");
       if (message) {
-        const sym = isColorEnabled() ? colorize("\u2713", "#4ADE80") : "\u2713";
-        output.write(`${sym} ${message}
+        const sym2 = isColorEnabled() ? colorize("\u2713", "#4ADE80") : "\u2713";
+        output.write(`${sym2} ${message}
 `);
       }
     },
@@ -654,8 +769,8 @@ function createProgressBar(opts) {
       if (!enabled) return;
       output.write(screen.clearLine + "\r");
       if (message) {
-        const sym = isColorEnabled() ? colorize("\u2717", "#F87171") : "\u2717";
-        output.write(`${sym} ${message}
+        const sym2 = isColorEnabled() ? colorize("\u2717", "#F87171") : "\u2717";
+        output.write(`${sym2} ${message}
 `);
       }
     },
@@ -862,6 +977,200 @@ function parseDiff(diffText) {
   return lines;
 }
 
+// src/primitives/error-box.ts
+function buildBoxWidth() {
+  return Math.min(getTerminalWidth() - 4, 88);
+}
+function buildErrorContent(opts) {
+  const parts = [];
+  parts.push(
+    `${sym("fail")} Error: ${bold(opts.message)}`
+  );
+  if (opts.context !== void 0 && opts.context !== "") {
+    parts.push("");
+    parts.push(dim(opts.context));
+  }
+  if (opts.suggestion !== void 0 && opts.suggestion !== "") {
+    parts.push("");
+    parts.push(colorize(`Try: ${opts.suggestion}`, brand.lime));
+  }
+  if (opts.exitCode !== void 0) {
+    parts.push("");
+    parts.push(dim(`Exit code: ${opts.exitCode}`));
+  }
+  return parts.join("\n");
+}
+function buildWarningContent(opts) {
+  const parts = [];
+  parts.push(
+    `${sym("warning")} Warning: ${bold(opts.message)}`
+  );
+  if (opts.context !== void 0 && opts.context !== "") {
+    parts.push("");
+    parts.push(dim(opts.context));
+  }
+  if (opts.suggestion !== void 0 && opts.suggestion !== "") {
+    parts.push("");
+    parts.push(colorize(`Try: ${opts.suggestion}`, brand.lime));
+  }
+  return parts.join("\n");
+}
+function renderError(opts) {
+  const content = buildErrorContent(opts);
+  return box(content, {
+    border: "rounded",
+    borderColor: tokens.error,
+    padding: 1,
+    width: buildBoxWidth()
+  });
+}
+function renderWarning(opts) {
+  const content = buildWarningContent(opts);
+  return box(content, {
+    border: "rounded",
+    borderColor: tokens.warning,
+    padding: 1,
+    width: buildBoxWidth()
+  });
+}
+
+// src/layout/step-list.ts
+function stepGlyph(state, frameIndex) {
+  switch (state.status) {
+    case "running":
+      return colorize(spinnerFrame(frameIndex), tokens.success);
+    case "done":
+      return colorize(sym("success"), tokens.success);
+    case "failed":
+      return colorize(sym("fail"), tokens.error);
+    case "warning":
+      return colorize(sym("warning"), tokens.warning);
+    case "skipped":
+      return dim("\u2014");
+    default:
+      return dim(sym("pending"));
+  }
+}
+function stepText(state) {
+  switch (state.status) {
+    case "done":
+      return state.summaryText;
+    case "failed":
+      return state.failReason ? `${state.actionText} \u2014 ${state.failReason}` : state.actionText;
+    case "skipped":
+      return dim(state.actionText);
+    default:
+      return state.actionText;
+  }
+}
+function stepDuration(state) {
+  if (state.durationMs === void 0) return "";
+  const secs = state.durationMs / 1e3;
+  return `${secs.toFixed(1)}s`;
+}
+function renderStep(state, frameIndex, indent, termWidth) {
+  if (isPlainMode()) {
+    return renderStepPlain(state, indent);
+  }
+  const glyph = stepGlyph(state, frameIndex);
+  const text = stepText(state);
+  const duration = stepDuration(state);
+  const glyphVisible = visibleLength(glyph);
+  const textVisible = visibleLength(text);
+  const durationVisible = visibleLength(duration);
+  const indentLen = indent.length;
+  const usedWidth = indentLen + glyphVisible + 1 + textVisible + durationVisible;
+  const gap = Math.max(1, termWidth - usedWidth);
+  let line;
+  if (duration) {
+    line = `${indent}${glyph} ${text}${" ".repeat(gap)}${dim(duration)}`;
+  } else {
+    line = `${indent}${glyph} ${text}`;
+  }
+  const lines = [line];
+  if (state.subSteps && state.subSteps.length > 0) {
+    const subIndent = indent + "  | ";
+    for (const sub of state.subSteps) {
+      lines.push(renderStep(sub, frameIndex, subIndent, termWidth));
+    }
+  }
+  return lines.join("\n");
+}
+function renderStepPlain(state, indent) {
+  const text = stepText(state);
+  const duration = stepDuration(state);
+  const durationStr = duration ? ` (${duration})` : "";
+  const line = `${indent}[${state.status}] ${text}${durationStr}`;
+  const lines = [line];
+  if (state.subSteps && state.subSteps.length > 0) {
+    for (const sub of state.subSteps) {
+      lines.push(renderStepPlain(sub, indent + "  | "));
+    }
+  }
+  return lines.join("\n");
+}
+function renderStepList(steps, frameIndex, termWidth = 80) {
+  const lines = steps.map((step) => renderStep(step, frameIndex, "", termWidth));
+  return lines.join("\n");
+}
+
+// src/layout/run-steps.ts
+function defToState(def) {
+  return {
+    id: def.id,
+    actionText: def.actionText,
+    summaryText: def.summaryText,
+    status: "pending",
+    startedAt: void 0,
+    finishedAt: void 0,
+    durationMs: void 0,
+    failReason: void 0,
+    subSteps: def.subSteps ? def.subSteps.map(defToState) : void 0
+  };
+}
+async function runSteps(defs, opts = {}) {
+  const failFast = opts.failFast ?? (isCI() || !isTTY());
+  const { onStateChange } = opts;
+  const states = defs.map(defToState);
+  let anyFailed = false;
+  const notify = () => {
+    onStateChange?.(states);
+  };
+  for (let i = 0; i < defs.length; i++) {
+    const def = defs[i];
+    const state = states[i];
+    state.status = "running";
+    state.startedAt = Date.now();
+    notify();
+    try {
+      await def.run();
+      state.finishedAt = Date.now();
+      state.durationMs = state.finishedAt - (state.startedAt ?? state.finishedAt);
+      state.status = "done";
+      notify();
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      state.finishedAt = Date.now();
+      state.durationMs = state.finishedAt - (state.startedAt ?? state.finishedAt);
+      state.failReason = reason;
+      anyFailed = true;
+      if (failFast) {
+        state.status = "failed";
+        notify();
+        for (let j = i + 1; j < states.length; j++) {
+          states[j].status = "skipped";
+        }
+        notify();
+        return { success: false, states };
+      } else {
+        state.status = "warning";
+        notify();
+      }
+    }
+  }
+  return { success: !anyFailed, states };
+}
+
 // src/dashboard/state.ts
 var AuditPhase = {
   Connecting: "Connecting",
@@ -983,6 +1292,10 @@ var AlternateScreenRenderer = class {
       this.entered = false;
     }
   }
+  suspend() {
+  }
+  resume() {
+  }
   renderSummary(result) {
     const status = result.passed ? colorize("PASSED", "#4ADE80") : colorize("FAILED", "#F87171");
     const scoreStr = colorize(String(result.overallScore), result.overallScore >= 70 ? "#4ADE80" : "#F87171");
@@ -1004,6 +1317,132 @@ function formatElapsed2(ms) {
   return `${Math.floor(secs / 60)}m ${secs % 60}s`;
 }
 
+// src/layout/composed.ts
+var ComposedRenderer = class {
+  output;
+  tickTimer = null;
+  frameIndex = 0;
+  suspended = false;
+  resizeTimer = null;
+  lastState = null;
+  entered = false;
+  constructor(output = process.stderr) {
+    this.output = output;
+    process.stderr.on("resize", this.onResize);
+  }
+  update(state) {
+    if (!this.entered) {
+      this.output.write(screen.altEnter + cursor.hide);
+      this.entered = true;
+    }
+    this.lastState = state;
+    const content = this.buildContent(state, this.frameIndex);
+    const capped = this.capContent(content);
+    this.output.write(cursor.home + screen.clear + capped);
+    if (!this.tickTimer && !this.suspended) {
+      this.startTick();
+    }
+  }
+  finish(result) {
+    this.stopTick();
+    const content = this.buildFinishContent(result);
+    if (this.entered) {
+      this.output.write(cursor.home + screen.clear + content);
+    }
+    if (this.entered) {
+      this.output.write(cursor.show + screen.altExit);
+      this.entered = false;
+    }
+    this.lastState = null;
+  }
+  dispose() {
+    this.stopTick();
+    if (this.resizeTimer !== null) {
+      clearTimeout(this.resizeTimer);
+      this.resizeTimer = null;
+    }
+    process.stderr.removeListener("resize", this.onResize);
+    if (this.entered) {
+      this.output.write(cursor.show + screen.altExit);
+      this.entered = false;
+    }
+  }
+  suspend() {
+    this.suspended = true;
+    this.stopTick();
+    if (this.entered) {
+      this.output.write(cursor.show + screen.altExit);
+      this.entered = false;
+    }
+  }
+  resume() {
+    this.suspended = false;
+    if (this.lastState) {
+      this.output.write(screen.altEnter + cursor.hide);
+      this.entered = true;
+      this.startTick();
+    }
+  }
+  // ── Private helpers ──────────────────────────────────────────────
+  startTick() {
+    this.tickTimer = setInterval(() => {
+      this.frameIndex++;
+      if (this.lastState && this.entered) {
+        const content = this.buildContent(this.lastState, this.frameIndex);
+        const capped = this.capContent(content);
+        this.output.write(cursor.home + screen.clear + capped);
+      }
+    }, FRAME_INTERVAL);
+  }
+  stopTick() {
+    if (this.tickTimer !== null) {
+      clearInterval(this.tickTimer);
+      this.tickTimer = null;
+    }
+  }
+  onResize = () => {
+    if (this.resizeTimer !== null) {
+      clearTimeout(this.resizeTimer);
+    }
+    this.resizeTimer = setTimeout(() => {
+      this.resizeTimer = null;
+      if (this.lastState && this.entered) {
+        const content = this.buildContent(this.lastState, this.frameIndex);
+        const capped = this.capContent(content);
+        this.output.write(cursor.home + screen.clear + capped);
+      }
+    }, 100);
+  };
+  capContent(content) {
+    const maxLines = Math.max(1, getTerminalHeight() - 2);
+    const lines = content.split("\n");
+    if (lines.length <= maxLines) return content;
+    const overflow = lines.length - (maxLines - 1);
+    const truncated = lines.slice(0, maxLines - 1);
+    truncated.push(dim(`... ${overflow} more lines`));
+    return truncated.join("\n");
+  }
+  buildContent(state, frame) {
+    if (state.stepStates && state.stepStates.length > 0) {
+      return renderStepList(state.stepStates, frame, getTerminalWidth());
+    }
+    const spinner = spinnerFrame(frame);
+    const progress = state.phaseTotal > 0 ? ` (${state.phaseIndex}/${state.phaseTotal})` : "";
+    return `${spinner} ${state.phase}${dim(progress)}`;
+  }
+  buildFinishContent(result) {
+    if (result.passed) {
+      return `${sym("success")} ${bold("Complete")}${dim(" " + formatElapsed3(result.elapsed))}`;
+    }
+    return `${sym("fail")} ${bold("Failed")}${dim(" " + formatElapsed3(result.elapsed))}`;
+  }
+};
+function formatElapsed3(ms) {
+  const secs = Math.round(ms / 1e3);
+  if (secs < 60) return `(${secs}s)`;
+  return `(${Math.floor(secs / 60)}m ${secs % 60}s)`;
+}
+
 // src/layout/inline.ts
 var InlineRenderer = class {
   output;
@@ -1025,7 +1464,7 @@ var InlineRenderer = class {
   finish(result) {
     const ts = timestamp();
     const status = result.passed ? isColorEnabled() ? colorize("PASSED", "#4ADE80") : "PASSED" : isColorEnabled() ? colorize("FAILED", "#F87171") : "FAILED";
-    const elapsed = formatElapsed3(result.elapsed);
+    const elapsed = formatElapsed4(result.elapsed);
     this.output.write(
       `${dim(ts)} ${bold("Audit Complete")} ${status} score=${result.overallScore} issues=${result.issueCount} ${dim(elapsed)}
 `
@@ -1033,6 +1472,10 @@ var InlineRenderer = class {
   }
   dispose() {
   }
+  suspend() {
+  }
+  resume() {
+  }
 };
 function timestamp() {
   const now = /* @__PURE__ */ new Date();
@@ -1041,23 +1484,248 @@ function timestamp() {
 function pad2(n) {
   return n < 10 ? `0${n}` : String(n);
 }
-function formatElapsed3(ms) {
+function formatElapsed4(ms) {
   const secs = Math.round(ms / 1e3);
   if (secs < 60) return `(${secs}s)`;
   return `(${Math.floor(secs / 60)}m ${secs % 60}s)`;
 }
 
 // src/layout/renderer.ts
+var _rendererOverride = null;
+function setRendererOverride(renderer) {
+  _rendererOverride = renderer;
+}
 function createRenderer(mode = "auto", output = process.stderr) {
+  if (_rendererOverride) return _rendererOverride;
   if (mode === "auto") {
-    mode = isTTY() && !isCI() ? "alternate" : "inline";
+    mode = isTTY() && !isCI() ? "composed" : "inline";
   }
   if (mode === "alternate") {
     return new AlternateScreenRenderer(output);
   }
+  if (mode === "composed") {
+    if (!isTTY()) return new InlineRenderer(output);
+    return new ComposedRenderer(output);
+  }
   return new InlineRenderer(output);
 }
+
+// src/layout/physicalRows.ts
+function physicalRows(content, terminalWidth) {
+  if (terminalWidth <= 0) return 0;
+  const lines = content.split("\n");
+  return lines.reduce((total, line) => {
+    const len = visibleLength(line);
+    return total + Math.max(1, Math.ceil(len / terminalWidth));
+  }, 0);
+}
+
+// src/layout/viewport.ts
+var KEY_CTRL_C = "";
+var KEY_UP = "\x1B[A";
+var KEY_DOWN = "\x1B[B";
+var KEY_PAGE_UP = "\x1B[5~";
+var KEY_PAGE_DOWN = "\x1B[6~";
+var KEY_ENTER_CR = "\r";
+var KEY_ENTER_LF = "\n";
+var KEY_ESC = "\x1B";
+var KEY_J = "j";
+var KEY_K = "k";
+function parseKey(data) {
+  const str = data.toString("binary");
+  if (str === KEY_CTRL_C) return "quit";
+  if (str === KEY_UP) return "up";
+  if (str === KEY_DOWN) return "down";
+  if (str === KEY_PAGE_UP) return "pageup";
+  if (str === KEY_PAGE_DOWN) return "pagedown";
+  if (str === KEY_ENTER_CR || str === KEY_ENTER_LF) return "enter";
+  if (str === KEY_ESC) return "escape";
+  if (str === KEY_J) return "down";
+  if (str === KEY_K) return "up";
+  return null;
+}
+var ScrollingViewport = class {
+  items;
+  maxRows;
+  output;
+  stdin;
+  /** Index of the currently highlighted item (0-indexed) */
+  cursorIdx = 0;
+  /** Index of first visible item */
+  scrollOffset = 0;
+  /** Index of expanded item (-1 = none) */
+  expandedIdx = -1;
+  /** Calculated visible rows (updated on resize) */
+  visibleRows;
+  lastRows = 0;
+  resizeTimer = null;
+  constructor(options) {
+    this.items = options.items;
+    this.maxRows = options.maxRows ?? 10;
+    this.output = options.output ?? process.stderr;
+    this.stdin = options.stdin ?? process.stdin;
+    this.visibleRows = this.calcVisibleRows();
+  }
+  // ── Public entry point ──────────────────────────────────────────────────────
+  /**
+   * Run the viewport interactively.
+   *
+   * Guard: if stdin is not a TTY or setRawMode is unavailable, returns
+   * immediately (non-interactive fallback).
+   *
+   * Resolves when the user presses Ctrl+C.
+   */
+  async run() {
+    if (!this.stdin.isTTY || typeof this.stdin.setRawMode !== "function") {
+      return;
+    }
+    return new Promise((resolve) => {
+      this.stdin.setRawMode(true);
+      this.stdin.resume();
+      this.output.write(cursor.hide);
+      this.redraw(this.buildFrame());
+      const onResize = () => {
+        if (this.resizeTimer !== null) clearTimeout(this.resizeTimer);
+        this.resizeTimer = setTimeout(() => {
+          this.resizeTimer = null;
+          this.visibleRows = this.calcVisibleRows();
+          this.clampScrollOffset();
+          this.lastRows = 0;
+          this.redraw(this.buildFrame());
+        }, 100);
+      };
+      const onData = (data) => {
+        const action = parseKey(data);
+        if (action === "quit") {
+          cleanup();
+          resolve();
+          return;
+        }
+        this.handleAction(action);
+        this.redraw(this.buildFrame());
+      };
+      const cleanup = () => {
+        this.stdin.removeListener("data", onData);
+        process.stderr.removeListener("resize", onResize);
+        if (this.resizeTimer !== null) {
+          clearTimeout(this.resizeTimer);
+          this.resizeTimer = null;
+        }
+        try {
+          this.stdin.setRawMode(false);
+        } catch {
+        }
+        this.stdin.pause();
+        this.output.write(cursor.show);
+      };
+      this.stdin.on("data", onData);
+      process.stderr.on("resize", onResize);
+    });
+  }
+  // ── Private helpers ─────────────────────────────────────────────────────────
+  calcVisibleRows() {
+    return Math.min(this.maxRows, getTerminalHeight() - 4);
+  }
+  clampScrollOffset() {
+    const maxOffset = Math.max(0, this.items.length - this.visibleRows);
+    this.scrollOffset = Math.max(0, Math.min(this.scrollOffset, maxOffset));
+  }
+  handleAction(action) {
+    const last = this.items.length - 1;
+    switch (action) {
+      case "up":
+        this.cursorIdx = Math.max(0, this.cursorIdx - 1);
+        break;
+      case "down":
+        this.cursorIdx = Math.min(last, this.cursorIdx + 1);
+        break;
+      case "pageup":
+        this.cursorIdx = Math.max(0, this.cursorIdx - this.visibleRows);
+        break;
+      case "pagedown":
+        this.cursorIdx = Math.min(last, this.cursorIdx + this.visibleRows);
+        break;
+      case "enter":
+        this.expandedIdx = this.expandedIdx === this.cursorIdx ? -1 : this.cursorIdx;
+        break;
+      case "escape":
+        this.expandedIdx = -1;
+        break;
+    }
+    if (this.cursorIdx < this.scrollOffset) {
+      this.scrollOffset = this.cursorIdx;
+    }
+    if (this.cursorIdx >= this.scrollOffset + this.visibleRows) {
+      this.scrollOffset = this.cursorIdx - this.visibleRows + 1;
+    }
+    this.clampScrollOffset();
+  }
+  buildFrame() {
+    const width = getTerminalWidth();
+    const lines = [];
+    const plain = isPlainMode();
+    const colored = isColorEnabled();
+    if (this.scrollOffset > 0) {
+      const count = this.scrollOffset;
+      const arrow = plain ? "^" : "\u25B2";
+      lines.push(dim(`  ${arrow} ${count} more`));
+    }
+    const end = Math.min(this.scrollOffset + this.visibleRows, this.items.length);
+    for (let i = this.scrollOffset; i < end; i++) {
+      const item = this.items[i];
+      const isHighlighted = i === this.cursorIdx;
+      const isExpanded = i === this.expandedIdx;
+      const badge = severityColor(item.severity);
+      const badgeVisibleWidth = item.severity.toUpperCase().length;
+      const titleMaxWidth = Math.max(10, width - badgeVisibleWidth - 18);
+      const title = truncate(item.title, titleMaxWidth);
+      const effortTag = dim(`[${item.effort}]`);
+      let row = `  ${badge} ${title} ${effortTag}`;
+      if (isHighlighted) {
+        if (colored && !plain) {
+          row = bgColor(row, brand.teal);
+        } else {
+          row = `\x1B[7m${row}\x1B[0m`;
+        }
+      }
+      lines.push(row);
+      if (isExpanded && item.detail) {
+        const detailLines = item.detail.split("\n");
+        for (const dl of detailLines) {
+          lines.push(`    ${dim(truncate(dl, width - 6))}`);
+        }
+      }
+    }
+    if (this.scrollOffset + this.visibleRows < this.items.length) {
+      const count = this.items.length - (this.scrollOffset + this.visibleRows);
+      const arrow = plain ? "v" : "\u25BC";
+      lines.push(dim(`  ${arrow} ${count} more`));
+    }
+    return lines.join("\n");
+  }
+  redraw(content) {
+    const rows = this.lastRows;
+    let seq = rows > 0 ? cursor.up(rows) + screen.clearDown : "";
+    seq += content;
+    this.output.write(seq);
+    this.lastRows = physicalRows(content, getTerminalWidth());
+  }
+};
+var _isOverrideActive = false;
+function setKeyboardOverrideActive(active) {
+  _isOverrideActive = active;
+}
 function createKeyboardHandler(stdin = process.stdin) {
+  if (_isOverrideActive) {
+    return {
+      start() {
+      },
+      dispose() {
+      },
+      on() {
+      }
+    };
+  }
   const emitter = new events.EventEmitter();
   let started = false;
   let wasRawMode = false;
@@ -1103,9 +1771,14 @@ function createKeyboardHandler(stdin = process.stdin) {
 
 exports.AlternateScreenRenderer = AlternateScreenRenderer;
 exports.AuditPhase = AuditPhase;
+exports.BRAILLE_FRAMES = BRAILLE_FRAMES;
+exports.ComposedRenderer = ComposedRenderer;
+exports.FRAME_INTERVAL = FRAME_INTERVAL;
 exports.InlineRenderer = InlineRenderer;
 exports.PHASE_ORDER = PHASE_ORDER;
+exports.ScrollingViewport = ScrollingViewport;
 exports.applyGradient = applyGradient;
+exports.bgColor = bgColor;
 exports.bold = bold;
 exports.boldColor = boldColor;
 exports.borders = borders;
@@ -1119,37 +1792,57 @@ exports.createProgressBar = createProgressBar;
 exports.createRenderer = createRenderer;
 exports.createSpinner = createSpinner;
 exports.cursor = cursor;
+exports.detectSymbolTier = detectSymbolTier;
 exports.dim = dim;
+exports.easeIn = easeIn;
+exports.easeInOut = easeInOut;
+exports.easeOut = easeOut;
 exports.getTerminalHeight = getTerminalHeight;
 exports.getTerminalWidth = getTerminalWidth;
 exports.gradient = gradient;
 exports.isCI = isCI;
 exports.isColorEnabled = isColorEnabled;
+exports.isPlainMode = isPlainMode;
 exports.isStdinTTY = isStdinTTY;
 exports.isStdoutTTY = isStdoutTTY;
 exports.isTTY = isTTY;
+exports.lerp = lerp;
+exports.linear = linear;
 exports.padEnd = padEnd;
 exports.padStart = padStart;
 exports.parseDiff = parseDiff;
 exports.phaseIndex = phaseIndex;
 exports.phaseTotal = phaseTotal;
+exports.physicalRows = physicalRows;
 exports.renderDiff = renderDiff;
+exports.renderError = renderError;
 exports.renderFrame = renderFrame;
 exports.renderGroupedList = renderGroupedList;
 exports.renderList = renderList;
+exports.renderStepList = renderStepList;
 exports.renderTable = renderTable;
 exports.renderTree = renderTree;
+exports.renderWarning = renderWarning;
+exports.runSteps = runSteps;
 exports.scoreColor = scoreColor;
 exports.screen = screen;
 exports.setColorEnabled = setColorEnabled;
+exports.setKeyboardOverrideActive = setKeyboardOverrideActive;
+exports.setPlainMode = setPlainMode;
+exports.setRendererOverride = setRendererOverride;
+exports.setSymbolTier = setSymbolTier;
 exports.severity = severity;
+exports.severityColor = severityColor;
 exports.severityLabels = severityLabels;
 exports.severityOrder = severityOrder;
 exports.shouldUseColor = shouldUseColor;
+exports.spinnerFrame = spinnerFrame;
 exports.stripAnsi = stripAnsi;
 exports.style = style;
 exports.supportsUnicode = supportsUnicode;
+exports.sym = sym;
 exports.text = text_exports;
+exports.toPlainBox = toPlainBox;
 exports.tokens = tokens;
 exports.truncate = truncate;
 exports.visibleLength = visibleLength;