@vertaaux/cli 0.4.0 → 0.5.1

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

@@ -1,11 +1,15 @@
 'use strict';
 
-var chalk = require('chalk');
+var process2 = require('process');
+var os = require('os');
+var tty = require('tty');
 var events = require('events');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var chalk__default = /*#__PURE__*/_interopDefault(chalk);
+var process2__default = /*#__PURE__*/_interopDefault(process2);
+var os__default = /*#__PURE__*/_interopDefault(os);
+var tty__default = /*#__PURE__*/_interopDefault(tty);
 
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
@@ -142,6 +146,498 @@ function truncate(str, maxWidth) {
   if (maxWidth <= 3) return stripped.slice(0, maxWidth);
   return stripped.slice(0, maxWidth - 1) + "\u2026";
 }
+
+// node_modules/chalk/source/vendor/ansi-styles/index.js
+var ANSI_BACKGROUND_OFFSET = 10;
+var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+var styles = {
+  modifier: {
+    reset: [0, 0],
+    // 21 isn't widely supported and 22 does the same thing
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29]
+  },
+  color: {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    // Bright color
+    blackBright: [90, 39],
+    gray: [90, 39],
+    // Alias of `blackBright`
+    grey: [90, 39],
+    // Alias of `blackBright`
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39]
+  },
+  bgColor: {
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    // Bright color
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    // Alias of `bgBlackBright`
+    bgGrey: [100, 49],
+    // Alias of `bgBlackBright`
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49]
+  }
+};
+Object.keys(styles.modifier);
+var foregroundColorNames = Object.keys(styles.color);
+var backgroundColorNames = Object.keys(styles.bgColor);
+[...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+  const codes = /* @__PURE__ */ new Map();
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style2] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style2[0]}m`,
+        close: `\x1B[${style2[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style2[0], style2[1]);
+    }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          /* eslint-disable no-bitwise */
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+          /* eslint-enable no-bitwise */
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+      enumerable: false
+    }
+  });
+  return styles;
+}
+var ansiStyles = assembleStyles();
+var ansi_styles_default = ansiStyles;
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2__default.default.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+var { env } = process2__default.default;
+var flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+  flagForceColor = 0;
+} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+  flagForceColor = 1;
+}
+function envForceColor() {
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      return 1;
+    }
+    if (env.FORCE_COLOR === "false") {
+      return 0;
+    }
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  }
+}
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== void 0) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === void 0) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (process2__default.default.platform === "win32") {
+    const osRelease = os__default.default.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+    return 1;
+  }
+  if ("CI" in env) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)) {
+      return 3;
+    }
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if (env.TERM === "wezterm") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+var supportsColor = {
+  stdout: createSupportsColor({ isTTY: tty__default.default.isatty(1) }),
+  stderr: createSupportsColor({ isTTY: tty__default.default.isatty(2) })
+};
+var supports_color_default = supportsColor;
+
+// node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, replacer) {
+  let index = string.indexOf(substring);
+  if (index === -1) {
+    return string;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const gotCR = string[index - 1] === "\r";
+    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+    endIndex = index + 1;
+    index = string.indexOf("\n", endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+
+// node_modules/chalk/source/index.js
+var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
+var GENERATOR = /* @__PURE__ */ Symbol("GENERATOR");
+var STYLER = /* @__PURE__ */ Symbol("STYLER");
+var IS_EMPTY = /* @__PURE__ */ Symbol("IS_EMPTY");
+var levelMapping = [
+  "ansi",
+  "ansi",
+  "ansi256",
+  "ansi16m"
+];
+var styles2 = /* @__PURE__ */ Object.create(null);
+var applyOptions = (object, options = {}) => {
+  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+    throw new Error("The `level` option should be an integer from 0 to 3");
+  }
+  const colorLevel = stdoutColor ? stdoutColor.level : 0;
+  object.level = options.level === void 0 ? colorLevel : options.level;
+};
+var chalkFactory = (options) => {
+  const chalk2 = (...strings) => strings.join(" ");
+  applyOptions(chalk2, options);
+  Object.setPrototypeOf(chalk2, createChalk.prototype);
+  return chalk2;
+};
+function createChalk(options) {
+  return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style2] of Object.entries(ansi_styles_default)) {
+  styles2[styleName] = {
+    get() {
+      const builder = createBuilder(this, createStyler(style2.open, style2.close, this[STYLER]), this[IS_EMPTY]);
+      Object.defineProperty(this, styleName, { value: builder });
+      return builder;
+    }
+  };
+}
+styles2.visible = {
+  get() {
+    const builder = createBuilder(this, this[STYLER], true);
+    Object.defineProperty(this, "visible", { value: builder });
+    return builder;
+  }
+};
+var getModelAnsi = (model, level, type, ...arguments_) => {
+  if (model === "rgb") {
+    if (level === "ansi16m") {
+      return ansi_styles_default[type].ansi16m(...arguments_);
+    }
+    if (level === "ansi256") {
+      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
+    }
+    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
+  }
+  if (model === "hex") {
+    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+  }
+  return ansi_styles_default[type][model](...arguments_);
+};
+var usedModels = ["rgb", "hex", "ansi256"];
+for (const model of usedModels) {
+  styles2[model] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+  styles2[bgModel] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+}
+var proto = Object.defineProperties(() => {
+}, {
+  ...styles2,
+  level: {
+    enumerable: true,
+    get() {
+      return this[GENERATOR].level;
+    },
+    set(level) {
+      this[GENERATOR].level = level;
+    }
+  }
+});
+var createStyler = (open, close, parent) => {
+  let openAll;
+  let closeAll;
+  if (parent === void 0) {
+    openAll = open;
+    closeAll = close;
+  } else {
+    openAll = parent.openAll + open;
+    closeAll = close + parent.closeAll;
+  }
+  return {
+    open,
+    close,
+    openAll,
+    closeAll,
+    parent
+  };
+};
+var createBuilder = (self, _styler, _isEmpty) => {
+  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+  Object.setPrototypeOf(builder, proto);
+  builder[GENERATOR] = self;
+  builder[STYLER] = _styler;
+  builder[IS_EMPTY] = _isEmpty;
+  return builder;
+};
+var applyStyle = (self, string) => {
+  if (self.level <= 0 || !string) {
+    return self[IS_EMPTY] ? "" : string;
+  }
+  let styler = self[STYLER];
+  if (styler === void 0) {
+    return string;
+  }
+  const { openAll, closeAll } = styler;
+  if (string.includes("\x1B")) {
+    while (styler !== void 0) {
+      string = stringReplaceAll(string, styler.close, styler.open);
+      styler = styler.parent;
+    }
+  }
+  const lfIndex = string.indexOf("\n");
+  if (lfIndex !== -1) {
+    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+  }
+  return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk.prototype, styles2);
+var chalk = createChalk();
+createChalk({ level: stderrColor ? stderrColor.level : 0 });
+var source_default = chalk;
+
+// src/theme.ts
 var brand = {
   lime: "#78FFB4",
   tealLight: "#6BEEBD",
@@ -202,25 +698,37 @@ var tokens = {
 var _colorEnabled = true;
 function setColorEnabled(enabled) {
   _colorEnabled = enabled;
+  source_default.level = enabled ? 3 : 0;
 }
 function isColorEnabled() {
   return _colorEnabled;
 }
 function colorize(text, hex) {
   if (!_colorEnabled) return text;
-  return chalk__default.default.hex(hex)(text);
+  return source_default.hex(hex)(text);
 }
 function boldColor(text, hex) {
   if (!_colorEnabled) return text;
-  return chalk__default.default.hex(hex).bold(text);
+  return source_default.hex(hex).bold(text);
 }
 function dim(text) {
   if (!_colorEnabled) return text;
-  return chalk__default.default.dim(text);
+  return source_default.dim(text);
 }
 function bold(text) {
   if (!_colorEnabled) return text;
-  return chalk__default.default.bold(text);
+  return source_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 source_default.bgHex(hex)(text);
 }
 function applyGradient(text, colors = gradient) {
   if (!_colorEnabled) return text;
@@ -229,7 +737,7 @@ function applyGradient(text, colors = gradient) {
   let idx = 0;
   for (const char of text) {
     if (char !== " " && char !== "\n") {
-      result += chalk__default.default.hex(colors[idx % colorCount])(char);
+      result += source_default.hex(colors[idx % colorCount])(char);
       idx++;
     } else {
       result += char;
@@ -260,7 +768,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 +781,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 +989,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 +1135,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 +1147,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 +1176,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 +1200,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 +1234,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 +1256,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 +1265,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 +1473,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 +1788,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 +1813,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 +1960,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 +1968,10 @@ var InlineRenderer = class {
   }
   dispose() {
   }
+  suspend() {
+  }
+  resume() {
+  }
 };
 function timestamp() {
   const now = /* @__PURE__ */ new Date();
@@ -1041,23 +1980,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 +2267,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 +2288,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;