termkit 2.0.2 → 2.2.0

package/dist/index.js

@@ -30,75 +30,769 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  Bar: () => Bar,
+  Chart: () => Chart_exports,
+  Color: () => import_cosmetic4.default,
+  Column: () => Column,
   Command: () => Command,
+  Input: () => Input,
+  Log: () => Log,
+  MultiBar: () => MultiBar,
+  MultiSelect: () => MultiSelect,
   Option: () => Option,
+  Program: () => Program,
+  Scrollbox: () => Scrollbox,
+  Select: () => Select,
+  Spinner: () => Spinner,
+  Table: () => Table,
   TermKit: () => TermKit,
   Variable: () => Variable,
-  command: () => command,
-  middleware: () => middleware,
-  option: () => option,
-  parse: () => parse,
-  setDefaults: () => setDefaults
+  configure: () => configure,
+  confirm: () => confirm,
+  input: () => input,
+  log: () => log,
+  markup: () => markup,
+  multiSelect: () => multiSelect,
+  padLeft: () => padLeft,
+  padRight: () => padRight,
+  padSides: () => padSides,
+  scrollbox: () => scrollbox,
+  select: () => select,
+  stringLength: () => stringLength,
+  truncate: () => truncate,
+  wrap: () => wrap
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/config.ts
+var isLegacyTerminal = process.env.TERM === "dumb" || process.platform === "win32" && !process.env.WT_SESSION && process.env.TERM_PROGRAM !== "vscode" && process.env.TERM_PROGRAM !== "Hyper";
+var config = {
+  color: "cyan",
+  pulseColors: ["#06b6d4", "#67e8f9"],
+  glyphs: !isLegacyTerminal,
+  interactive: false
+};
+function configure(opts) {
+  if (opts.color) config.color = opts.color;
+  if (opts.pulseColors) config.pulseColors = opts.pulseColors;
+  if (opts.glyphs !== void 0) config.glyphs = opts.glyphs;
+  if (opts.interactive !== void 0) config.interactive = opts.interactive;
+}
+
 // src/models/Command.ts
 var import_cosmetic = __toESM(require("cosmetic"));
 
-// src/helpers/findCommand.ts
+// src/models/Variable.ts
+var Variable = class {
+  constructor(data) {
+    this.array = false;
+    this.default = null;
+    this.enum = null;
+    this.max = null;
+    this.min = null;
+    this.name = null;
+    this.raw = null;
+    this.required = false;
+    this.type = "string";
+    this.value = null;
+    if (!data) return;
+    if (data.array) this.array = data.array;
+    if (data.default !== void 0) this.default = data.default;
+    if (data.enum) this.enum = data.enum;
+    if (data.max !== void 0) this.max = data.max;
+    if (data.min !== void 0) this.min = data.min;
+    if (data.name) this.name = data.name;
+    if (data.raw) this.raw = data.raw;
+    if (data.required) this.required = data.required;
+    if (data.type) this.type = data.type;
+    if (this.array) this.value = [];
+  }
+  get hint() {
+    const parts = [];
+    if (this.type === "enum" && this.enum) parts.push(this.enum.join("|"));
+    if (this.min !== null && this.max !== null) parts.push(`${this.min}\u2013${this.max}`);
+    else if (this.min !== null) parts.push(`>= ${this.min}`);
+    else if (this.max !== null) parts.push(`<= ${this.max}`);
+    if (this.default !== null) parts.push(`default: ${this.default}`);
+    return parts.length > 0 ? `(${parts.join(", ")})` : null;
+  }
+};
+
+// src/utils/getVariables.ts
+function parseName(raw) {
+  const colon = raw.indexOf(":");
+  if (colon === -1) return { name: raw, type: "string" };
+  const name = raw.slice(0, colon);
+  const rest = raw.slice(colon + 1);
+  const eqIdx = rest.lastIndexOf("=");
+  const typeStr = eqIdx !== -1 ? rest.slice(0, eqIdx) : rest;
+  const defaultValue = eqIdx !== -1 ? rest.slice(eqIdx + 1) : void 0;
+  const rangeMatch = typeStr.match(/^([a-z]+)\((-?\d+(?:\.\d+)?),(-?\d+(?:\.\d+)?)\)$/);
+  if (rangeMatch) {
+    return { name, type: rangeMatch[1], min: Number(rangeMatch[2]), max: Number(rangeMatch[3]), default: defaultValue };
+  }
+  if (typeStr.includes("|")) {
+    return { name, type: "enum", enum: typeStr.split("|"), default: defaultValue };
+  }
+  return { name, type: typeStr, default: defaultValue };
+}
+function getVariables(string) {
+  const results = [];
+  for (const part of string.split(" ")) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("<") && trimmed.endsWith(">")) {
+      const { name, type, enum: enumValues, default: def, min, max } = parseName(trimmed.slice(1, -1));
+      results.push(new Variable({ default: def, enum: enumValues, max, min, name, raw: trimmed, required: true, type }));
+    } else if (trimmed.startsWith("[") && trimmed.endsWith("...]")) {
+      const { name, type, enum: enumValues, default: def, min, max } = parseName(trimmed.slice(1, -4));
+      results.push(new Variable({ array: true, default: def, enum: enumValues, max, min, name, raw: trimmed, type }));
+    } else if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      const { name, type, enum: enumValues, default: def, min, max } = parseName(trimmed.slice(1, -1));
+      results.push(new Variable({ default: def, enum: enumValues, max, min, name, raw: trimmed, type }));
+    } else {
+      throw new Error(`Unrecognized variable description: ${trimmed}`);
+    }
+  }
+  return results;
+}
+
+// src/models/Option.ts
+var Option = class {
+  constructor(data) {
+    this.short = null;
+    this.long = null;
+    this.info = null;
+    this.variables = null;
+    if (!data) return;
+    if (data.short) this.short = data.short;
+    if (data.long) this.long = data.long;
+    if (data.info) this.info = data.info;
+    if (data.variables) this.variables = getVariables(data.variables);
+  }
+  description(info) {
+    this.info = info;
+    return this;
+  }
+};
+
+// src/utils/findCommand.ts
 function findCommand(array, commands) {
-  for (const command2 of commands) {
-    if (array[0] === command2.name) {
+  for (const command of commands) {
+    if (array[0] === command.name) {
       array.shift();
-      return command2;
+      return command;
     }
   }
   return null;
 }
 
-// src/helpers/findVariable.ts
-function coerce(value, type) {
-  if (type === "number") return Number(value);
+// src/utils/color.ts
+var RESET = "\x1B[0m";
+var SHOW_CURSOR = "\x1B[?25h";
+var HIDE_CURSOR = "\x1B[?25l";
+var BOLD = "\x1B[1m";
+var FAINT = "\x1B[2m";
+var GREEN = "\x1B[32m";
+var RED = "\x1B[31m";
+var YELLOW = "\x1B[33m";
+var BLUE = "\x1B[34m";
+var MAGENTA = "\x1B[35m";
+var CYAN = "\x1B[36m";
+var DIM = 0.35;
+var SHIMMER_SPEED = 0.5;
+process.on("exit", () => {
+  if (process.stdout.isTTY) process.stdout.write(SHOW_CURSOR);
+});
+process.on("SIGINT", () => process.exit());
+function parseHex(hex) {
+  const n = parseInt(hex.replace("#", ""), 16);
+  return { r: n >> 16 & 255, g: n >> 8 & 255, b: n & 255 };
+}
+function lerpColor(a, b, t) {
+  return {
+    r: Math.round(a.r + (b.r - a.r) * t),
+    g: Math.round(a.g + (b.g - a.g) * t),
+    b: Math.round(a.b + (b.b - a.b) * t)
+  };
+}
+function interpolateColor(colors, t) {
+  const clamped = Math.max(0, Math.min(1, t));
+  const segments = colors.length - 1;
+  const scaled = clamped * segments;
+  const i = Math.min(Math.floor(scaled), segments - 1);
+  return lerpColor(colors[i], colors[i + 1], scaled - i);
+}
+function formatColor(code, color) {
+  if (!process.stdout.isTTY) return "";
+  return `\x1B[${code};2;${color.r};${color.g};${color.b}m`;
+}
+function colorText(colorOrAnsi, text) {
+  if (!process.stdout.isTTY) return text;
+  if (colorOrAnsi.startsWith("#")) {
+    const c = parseHex(colorOrAnsi);
+    return `\x1B[38;2;${c.r};${c.g};${c.b}m${text}${RESET}`;
+  }
+  return `${colorOrAnsi}${text}${RESET}`;
+}
+function dimColor(c) {
+  return { r: Math.round(c.r * DIM), g: Math.round(c.g * DIM), b: Math.round(c.b * DIM) };
+}
+function shimmerFactor(t, phase, amplitude) {
+  const wave = 0.5 + 0.5 * Math.sin(2 * Math.PI * (t - phase));
+  return 1 - amplitude * (1 - wave);
+}
+function resolveColor(color) {
+  if (typeof color === "number") return `\x1B[38;5;${color}m`;
+  if (color.startsWith("#")) return color;
+  const map = {
+    black: "\x1B[30m",
+    red: "\x1B[31m",
+    green: "\x1B[32m",
+    yellow: "\x1B[33m",
+    blue: "\x1B[34m",
+    magenta: "\x1B[35m",
+    cyan: "\x1B[36m",
+    white: "\x1B[37m"
+  };
+  return map[color] ?? "\x1B[35m";
+}
+function applyShimmer(color, t, phase, amplitude) {
+  if (amplitude === 0) return color;
+  const factor = shimmerFactor(t, phase, amplitude);
+  return {
+    r: Math.round(color.r * factor),
+    g: Math.round(color.g * factor),
+    b: Math.round(color.b * factor)
+  };
+}
+
+// src/utils/stringLength.ts
+var ANSI_PATTERN = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
+var stringLength = (string) => {
+  if (!string) return 0;
+  return string.replace(ANSI_PATTERN, "").length;
+};
+
+// src/models/Input.ts
+var CLEAR_LINE = "\x1B[2K";
+var Input = class {
+  constructor(options = {}) {
+    this.promptColor = options.promptColor ?? GREEN;
+    this.promptGlyph = options.promptGlyph ?? (config.glyphs ? "\u25C6" : ">");
+    this.inputColor = options.inputColor ?? "";
+    this.errorColor = options.errorColor ?? RED;
+    this.placeholder = options.placeholder ?? "";
+    this.mask = options.mask ?? false;
+    this.inline = options.inline ?? false;
+    this.required = options.required ?? true;
+    this.type = options.type ?? "string";
+    this.defaultValue = options.default ?? null;
+    this.enumValues = options.enum ?? null;
+    this.match = options.match ?? null;
+    this.errorMsg = options.errorMessage ?? null;
+    this.regex = options.regex ?? null;
+    this.min = options.min ?? null;
+    this.max = options.max ?? null;
+    this.minLength = options.minLength ?? null;
+    this.maxLength = options.maxLength ?? null;
+  }
+  validate(value) {
+    const fail = (msg) => this.errorMsg ?? msg;
+    if (this.type === "number") {
+      const n = Number(value);
+      if (isNaN(n)) return fail("Must be a valid number");
+      if (this.min !== null && n < this.min) return fail(`Must be at least ${this.min}`);
+      if (this.max !== null && n > this.max) return fail(`Must be at most ${this.max}`);
+      return null;
+    }
+    if (this.type === "integer") {
+      const n = Number(value);
+      if (!Number.isInteger(n)) return fail("Must be a whole number");
+      if (this.min !== null && n < this.min) return fail(`Must be at least ${this.min}`);
+      if (this.max !== null && n > this.max) return fail(`Must be at most ${this.max}`);
+      return null;
+    }
+    if (this.type === "enum" && this.enumValues) {
+      if (!this.enumValues.includes(value)) return fail(`Must be one of: ${this.enumValues.join(", ")}`);
+    }
+    if (this.match !== null && value !== this.match) return fail("Does not match");
+    if (this.regex && !this.regex.test(value)) return fail("Invalid format");
+    if (this.minLength !== null && value.length < this.minLength) return fail(`Must be at least ${this.minLength} characters`);
+    if (this.maxLength !== null && value.length > this.maxLength) return fail(`Must be at most ${this.maxLength} characters`);
+    return null;
+  }
+  coerce(value) {
+    if (this.type === "number") return Number(value);
+    if (this.type === "integer") return parseInt(value, 10);
+    return value;
+  }
+  async ask(prompt) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) throw new Error("Input requires an interactive terminal");
+    if (this.type === "boolean") return this.askBoolean(prompt);
+    let inputStr = "";
+    let cursorPos = 0;
+    let error = null;
+    let hasErrorLine = false;
+    const glyph = this.promptGlyph ? `${colorText(this.promptColor, this.promptGlyph)} ` : "";
+    const indent = " ".repeat(this.promptGlyph ? stringLength(this.promptGlyph) + 1 : 0);
+    let promptLine = prompt;
+    if (this.type === "enum" && this.enumValues) {
+      promptLine += ` \x1B[2m(${this.enumValues.join("|")})\x1B[0m`;
+    }
+    if (!this.inline) process.stdout.write(`${glyph}${promptLine}
+`);
+    const defaultStr = this.defaultValue !== null ? String(this.defaultValue) : "";
+    const getDisplayText = () => {
+      const raw = this.mask ? "\u2022".repeat(inputStr.length) : inputStr;
+      if (inputStr.length === 0 && defaultStr) return `\x1B[2m${this.placeholder || defaultStr}${RESET}`;
+      return this.inputColor ? colorText(this.inputColor, raw) : raw;
+    };
+    const renderInput = (redraw) => {
+      if (redraw && hasErrorLine) process.stdout.write("\x1B[1A");
+      const text = getDisplayText();
+      const line = this.inline ? `\r${CLEAR_LINE}${glyph}${promptLine} ${text}` : `\r${CLEAR_LINE}${indent}${text}`;
+      process.stdout.write(line);
+      if (error) {
+        process.stdout.write(`
+\r${CLEAR_LINE}${indent}${colorText(this.errorColor, `\u2717 ${error}`)}`);
+        hasErrorLine = true;
+      } else {
+        if (hasErrorLine) {
+          process.stdout.write(`
+\r${CLEAR_LINE}\x1B[1A${line}`);
+        }
+        hasErrorLine = false;
+      }
+      if (inputStr.length > 0 && cursorPos < inputStr.length && !error) {
+        process.stdout.write(`\x1B[${inputStr.length - cursorPos}D`);
+      }
+    };
+    renderInput(false);
+    return new Promise((resolve) => {
+      const cleanup = () => {
+        if (hasErrorLine) process.stdout.write(`\r${CLEAR_LINE}\x1B[1A`);
+        const text = getDisplayText();
+        const line = this.inline ? `\r${CLEAR_LINE}${glyph}${promptLine} ${text}` : `\r${CLEAR_LINE}${indent}${text}`;
+        process.stdout.write(`${line}
+`);
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        process.stdin.removeListener("data", onKey);
+      };
+      const onKey = (key) => {
+        const str = key.toString();
+        if (str === "\r" || str === "\n") {
+          const value = inputStr.length === 0 && defaultStr ? defaultStr : inputStr;
+          const err = this.validate(value);
+          if (err) {
+            error = err;
+            renderInput(true);
+          } else {
+            const usingDefault = inputStr.length === 0 && this.defaultValue !== null;
+            if (usingDefault) inputStr = defaultStr;
+            cleanup();
+            resolve(usingDefault ? this.defaultValue : this.coerce(value));
+          }
+        } else if (str === "\x1B[D") {
+          cursorPos = Math.max(0, cursorPos - 1);
+          renderInput(true);
+        } else if (str === "\x1B[C") {
+          cursorPos = Math.min(inputStr.length, cursorPos + 1);
+          renderInput(true);
+        } else if (str === "\x1B[H" || str === "\x1B[1~" || str === "
") {
+          cursorPos = 0;
+          renderInput(true);
+        } else if (str === "\x1B[F" || str === "\x1B[4~" || str === "") {
+          cursorPos = inputStr.length;
+          renderInput(true);
+        } else if (str === "\x1B[3~") {
+          if (cursorPos < inputStr.length) {
+            inputStr = inputStr.slice(0, cursorPos) + inputStr.slice(cursorPos + 1);
+            error = null;
+            renderInput(true);
+          }
+        } else if (str === "\x1B") {
+          if (!this.required) {
+            cleanup();
+            resolve(null);
+          }
+        } else if (str === "") {
+          cleanup();
+          process.exit();
+        } else if (str === "\x7F" || str === "\b") {
+          if (cursorPos > 0) {
+            inputStr = inputStr.slice(0, cursorPos - 1) + inputStr.slice(cursorPos);
+            cursorPos--;
+            error = null;
+            renderInput(true);
+          }
+        } else if (str.charCodeAt(0) >= 32) {
+          if (this.maxLength !== null && inputStr.length >= this.maxLength) return;
+          inputStr = inputStr.slice(0, cursorPos) + str + inputStr.slice(cursorPos);
+          cursorPos++;
+          error = null;
+          renderInput(true);
+        }
+      };
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+      process.stdin.on("data", onKey);
+    });
+  }
+  async askBoolean(prompt) {
+    const hasDefault = this.defaultValue !== null;
+    const defaultBool = this.defaultValue === true || this.defaultValue === "y" || this.defaultValue === "Y" || this.defaultValue === 1;
+    const hint = hasDefault ? defaultBool ? "[Y/n]" : "[y/N]" : "[y/n]";
+    const glyph = this.promptGlyph ? `${colorText(this.promptColor, this.promptGlyph)} ` : "";
+    const indent = " ".repeat(this.promptGlyph ? stringLength(this.promptGlyph) + 1 : 0);
+    if (this.inline) {
+      process.stdout.write(`${glyph}${prompt} \x1B[2m${hint}${RESET} `);
+    } else {
+      process.stdout.write(`${glyph}${prompt} \x1B[2m${hint}${RESET}
+`);
+      process.stdout.write(`${indent}`);
+    }
+    return new Promise((resolve) => {
+      const finish = (selection, value) => {
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        process.stdin.removeListener("data", onKey);
+        if (this.inline) {
+          process.stdout.write(`\r${CLEAR_LINE}${glyph}${prompt} \x1B[2m${hint}${RESET} ${selection}
+`);
+        } else {
+          process.stdout.write(`\r${CLEAR_LINE}${indent}${selection}
+`);
+        }
+        resolve(value);
+      };
+      const onKey = (key) => {
+        const str = key.toString();
+        if (str === "\r" || str === "\n") {
+          if (hasDefault) finish(defaultBool ? "yes" : "no", defaultBool);
+        } else if (str === "y" || str === "Y") {
+          finish("yes", true);
+        } else if (str === "n" || str === "N") {
+          finish("no", false);
+        } else if (str === "\x1B") {
+          if (!this.required) finish("", null);
+        } else if (str === "") {
+          process.stdin.setRawMode(false);
+          process.stdin.pause();
+          process.stdin.removeListener("data", onKey);
+          process.exit();
+        }
+      };
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+      process.stdin.on("data", onKey);
+    });
+  }
+};
+async function input(prompt, options = {}) {
+  return new Input(options).ask(prompt);
+}
+async function confirm(prompt, options) {
+  return new Input({ ...options, type: "boolean" }).ask(prompt);
+}
+
+// src/utils/cleanup.ts
+var fns = /* @__PURE__ */ new Set();
+var installed = false;
+function install() {
+  if (installed) return;
+  installed = true;
+  process.on("SIGINT", () => {
+    flush();
+    process.exit(130);
+  });
+  process.on("exit", flush);
+}
+function flush() {
+  for (const fn of fns) {
+    try {
+      fn();
+    } catch {
+    }
+  }
+  fns.clear();
+}
+function registerCleanup(fn) {
+  install();
+  fns.add(fn);
+  return () => {
+    fns.delete(fn);
+  };
+}
+
+// src/models/Select.ts
+var CURSOR_UP = (n) => `\x1B[${n}A`;
+var Select = class {
+  constructor(options = {}) {
+    this._colorOffset = 0;
+    this._shimmerPhase = 0;
+    this.promptColor = options.promptColor ?? resolveColor(config.color);
+    this.promptGlyph = options.promptGlyph ?? (config.glyphs ? "\u25C6" : ">");
+    this.descriptionColor = options.descriptionColor ?? BLUE;
+    this.skipLabel = options.skipLabel ?? "Skip";
+    this.selectedPrefix = options.selectedPrefix ?? ">";
+    this.selectedSuffix = options.selectedSuffix ?? "<";
+    this.colorCycle = options.colorCycle ?? 1;
+    this.shimmer = options.shimmer ?? 0;
+    this.interval = options.interval ?? 80;
+    this.searchEnabled = options.search ?? false;
+    this.maxHeight = options.maxHeight;
+    const colors = options.colors ?? config.pulseColors;
+    this._parsedColors = colors.length >= 2 ? colors.map(parseHex) : [];
+  }
+  pulseColor() {
+    if (this._parsedColors.length < 2) return "";
+    const t = (this._colorOffset % 1 + 1) % 1;
+    const base2 = interpolateColor(this._parsedColors, t);
+    const color = applyShimmer(base2, 0.5, this._shimmerPhase, this.shimmer);
+    return formatColor(38, color);
+  }
+  async ask(prompt, items) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) throw new Error("Select requires an interactive terminal");
+    let selectedIndex = 0;
+    let viewportOffset = 0;
+    let searchQuery = "";
+    let lastDrawnLines = 0;
+    const skipItem = { label: this.skipLabel };
+    const getFiltered = () => {
+      if (!this.searchEnabled || searchQuery === "") return items;
+      const q = searchQuery.toLowerCase();
+      return items.filter((item) => item.label.toLowerCase().includes(q) || (item.description?.toLowerCase().includes(q) ?? false));
+    };
+    process.stdout.write(HIDE_CURSOR);
+    const glyph = this.promptGlyph ? `${colorText(this.promptColor, this.promptGlyph)} ` : "";
+    const indent = " ".repeat(this.promptGlyph ? stringLength(this.promptGlyph) + 1 : 0);
+    process.stdout.write(`${glyph}${prompt}
+`);
+    const renderList = (redraw) => {
+      const filtered = getFiltered();
+      const allItems = [...filtered, skipItem];
+      if (selectedIndex >= allItems.length) selectedIndex = allItems.length - 1;
+      if (this.maxHeight) {
+        if (selectedIndex < viewportOffset) viewportOffset = selectedIndex;
+        else if (selectedIndex >= viewportOffset + this.maxHeight) viewportOffset = selectedIndex - this.maxHeight + 1;
+        viewportOffset = Math.max(0, Math.min(viewportOffset, Math.max(0, allItems.length - this.maxHeight)));
+      }
+      const visibleStart = this.maxHeight ? viewportOffset : 0;
+      const visibleEnd = this.maxHeight ? Math.min(allItems.length, viewportOffset + this.maxHeight) : allItems.length;
+      if (redraw) {
+        if (lastDrawnLines > 0) process.stdout.write(CURSOR_UP(lastDrawnLines));
+        process.stdout.write("\r\x1B[0J");
+      }
+      lastDrawnLines = 0;
+      if (this.searchEnabled) {
+        process.stdout.write(`\r${indent}${colorText(this.promptColor, "/")} ${searchQuery}|
+`);
+        lastDrawnLines++;
+      }
+      const pulse = this.pulseColor();
+      for (let i = visibleStart; i < visibleEnd; i++) {
+        const item = allItems[i];
+        const isSelected = i === selectedIndex;
+        const isSkip = i === filtered.length;
+        const relativeNum = i - visibleStart + 1;
+        const numStr = isSkip ? "0." : `${relativeNum}.`;
+        const desc = item.description ? ` ${colorText(this.descriptionColor, `\u2014 ${item.description}`)}` : "";
+        let marker, tail;
+        if (isSelected && pulse) {
+          marker = `${pulse}${this.selectedPrefix}${RESET}`;
+          tail = ` ${pulse}${this.selectedSuffix}${RESET}`;
+        } else {
+          const fallback = isSelected ? this.promptColor : "";
+          marker = fallback ? colorText(fallback, this.selectedPrefix) : " ".repeat(stringLength(this.selectedPrefix));
+          tail = isSelected ? ` ${colorText(this.promptColor, this.selectedSuffix)}` : "";
+        }
+        process.stdout.write(`\r${indent}${marker} ${numStr} ${item.label}${desc}${tail}
+`);
+        lastDrawnLines++;
+      }
+    };
+    renderList(false);
+    return new Promise((resolve) => {
+      let timer = null;
+      const deregisterCleanup = registerCleanup(() => {
+        if (timer) {
+          clearInterval(timer);
+          timer = null;
+        }
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        process.stdin.removeListener("data", onKey);
+        process.stdout.write(SHOW_CURSOR);
+      });
+      const cleanup = () => {
+        deregisterCleanup();
+        if (timer) {
+          clearInterval(timer);
+          timer = null;
+        }
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        process.stdin.removeListener("data", onKey);
+        process.stdout.write(SHOW_CURSOR);
+      };
+      if (this._parsedColors.length >= 2) {
+        timer = setInterval(() => {
+          this._colorOffset = (this._colorOffset + this.colorCycle * this.interval / 1e3) % 1;
+          if (this.shimmer > 0) {
+            this._shimmerPhase = (this._shimmerPhase + SHIMMER_SPEED * this.interval / 1e3) % 1;
+          }
+          renderList(true);
+        }, this.interval);
+      }
+      const onKey = (key) => {
+        const str = key.toString();
+        const filtered = getFiltered();
+        const allItems = [...filtered, skipItem];
+        if (str === "\x1B[A") {
+          selectedIndex = (selectedIndex - 1 + allItems.length) % allItems.length;
+          renderList(true);
+        } else if (str === "\x1B[B") {
+          selectedIndex = (selectedIndex + 1) % allItems.length;
+          renderList(true);
+        } else if (str === "\r" || str === "\n") {
+          cleanup();
+          resolve(selectedIndex === filtered.length ? null : filtered[selectedIndex] ?? null);
+        } else if (str === "") {
+          cleanup();
+          process.exit(130);
+        } else if (this.searchEnabled) {
+          if (str === "\x7F" || str === "\b") {
+            searchQuery = searchQuery.slice(0, -1);
+            const newFiltered = getFiltered();
+            if (selectedIndex >= newFiltered.length + 1) selectedIndex = Math.max(0, newFiltered.length);
+            viewportOffset = 0;
+            renderList(true);
+          } else if (str.length === 1 && str >= " ") {
+            searchQuery += str;
+            selectedIndex = 0;
+            viewportOffset = 0;
+            renderList(true);
+          }
+        } else {
+          const n = parseInt(str);
+          if (!isNaN(n) && n >= 0 && n <= Math.min(items.length, 9)) {
+            const visibleStart = this.maxHeight ? viewportOffset : 0;
+            selectedIndex = n === 0 ? allItems.length - 1 : visibleStart + n - 1;
+            selectedIndex = Math.max(0, Math.min(selectedIndex, allItems.length - 1));
+            renderList(true);
+          }
+        }
+      };
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+      process.stdin.on("data", onKey);
+    });
+  }
+};
+async function select(prompt, items, options) {
+  return new Select(options).ask(prompt, items);
+}
+
+// src/utils/findVariable.ts
+function coerce(value, type, enumValues, min = null, max = null) {
+  if (type === "number" || type === "integer") {
+    const n = Number(value);
+    if (type === "integer" && !Number.isInteger(n)) throw new Error(`Invalid value "${value}" \u2014 expected an integer`);
+    if (min !== null && n < min) throw new Error(`Invalid value "${value}" \u2014 must be >= ${min}`);
+    if (max !== null && n > max) throw new Error(`Invalid value "${value}" \u2014 must be <= ${max}`);
+    return n;
+  }
+  if (type === "string") {
+    if (min !== null && value.length < min) throw new Error(`Invalid value "${value}" \u2014 must be at least ${min} characters`);
+    if (max !== null && value.length > max) throw new Error(`Invalid value "${value}" \u2014 must be at most ${max} characters`);
+    return value;
+  }
   if (type === "boolean") return value === "true";
+  if (type === "enum" && enumValues) {
+    if (!enumValues.includes(value)) {
+      throw new Error(`Invalid value "${value}" \u2014 expected one of: ${enumValues.join(", ")}`);
+    }
+  }
   return value;
 }
-function findVariable(array, variable, commands) {
+async function promptForVariable(variable) {
+  const promptColor = resolveColor(config.color);
+  if (variable.type === "enum" && variable.enum) {
+    const items = variable.enum.map((label) => ({ label }));
+    const result = await new Select({ promptColor }).ask(`<${variable.name}>`, items);
+    return result !== null ? result.label : null;
+  }
+  const isNumeric = variable.type === "number" || variable.type === "integer";
+  return new Input({
+    type: variable.type,
+    promptColor,
+    min: isNumeric ? variable.min ?? void 0 : void 0,
+    max: isNumeric ? variable.max ?? void 0 : void 0,
+    minLength: !isNumeric ? variable.min ?? void 0 : void 0,
+    maxLength: !isNumeric ? variable.max ?? void 0 : void 0,
+    required: true
+  }).ask(`<${variable.name}>`);
+}
+async function findVariable(array, variable, commands) {
   if (variable.array) {
     const result = [];
     while (array.length > 0 && !array[0].startsWith("-")) {
       if (commands.includes(array[0])) break;
-      result.push(coerce(array.shift(), variable.type));
+      result.push(coerce(array.shift(), variable.type, variable.enum, variable.min, variable.max));
+    }
+    if (result.length === 0 && variable.required) {
+      if (config.interactive && process.stdout.isTTY) {
+        try {
+          const value = await promptForVariable(variable);
+          if (value !== null) return [value];
+        } catch {
+          throw new Error(`Missing required variable <${variable.name}> \u2014 stdin is not interactive`);
+        }
+      }
+      throw new Error(`Missing required variable <${variable.name}>`);
     }
-    if (result.length === 0 && variable.required) throw new Error(`Missing required variable <${variable.name}>`);
     return result.length > 0 ? result : true;
   }
   if (array.length > 0 && !array[0].startsWith("-")) {
     if ((!commands.includes(array[0]) || variable.required) && array[0] !== "help") {
-      return coerce(array.shift(), variable.type);
+      return coerce(array.shift(), variable.type, variable.enum, variable.min, variable.max);
+    }
+  }
+  if (variable.required) {
+    if (config.interactive && process.stdout.isTTY) {
+      try {
+        const value = await promptForVariable(variable);
+        if (value !== null) return value;
+      } catch {
+        throw new Error(`Missing required variable <${variable.name}> \u2014 stdin is not interactive`);
+      }
     }
+    throw new Error(`Missing required variable <${variable.name}>`);
   }
-  if (variable.required) throw new Error(`Missing required variable <${variable.name}>`);
+  if (variable.default !== null) return coerce(variable.default, variable.type, variable.enum);
   return true;
 }
 
-// src/helpers/findCommandVariables.ts
-function findCommandVariables(array, command2) {
-  if (!command2.variables) return null;
+// src/utils/findCommandVariables.ts
+async function findCommandVariables(array, command) {
+  if (!command.variables) return null;
   const result = {};
-  for (const variable of command2.variables) {
-    const value = findVariable(array, variable, command2.commandStrings);
+  for (const variable of command.variables) {
+    const value = await findVariable(array, variable, command.commandStrings);
     if (value !== true) result[variable.name] = value;
   }
   return Object.keys(result).length > 0 ? result : null;
 }
 
-// src/helpers/findOption.ts
+// src/utils/findOption.ts
 function findOption(string, options) {
   return options.find((o) => o.short === string || o.long === string);
 }
 
-// src/helpers/findVariables.ts
-function findVariables(base2, array, variables, commands) {
+// src/utils/findVariables.ts
+async function findVariables(base2, array, variables, commands) {
   const result = {};
   if (!variables) {
     if (base2) result[base2] = true;
@@ -106,7 +800,7 @@ function findVariables(base2, array, variables, commands) {
   }
   if (variables.length > 1 && base2) result[base2] = {};
   for (const variable of variables) {
-    const value = findVariable(array, variable, commands);
+    const value = await findVariable(array, variable, commands);
     if (variables.length > 1 && base2) {
       ;
       result[base2][variable.name] = value;
@@ -119,33 +813,41 @@ function findVariables(base2, array, variables, commands) {
   return result;
 }
 
-// src/helpers/findOptions.ts
-function findOptions(array, command2) {
+// src/utils/findOptions.ts
+async function findOptions(array, command) {
   const result = {};
   while (array.length > 0 && array[0].startsWith("-")) {
     if (array[0].startsWith("--")) {
       const raw = array.shift().slice(2);
-      const option2 = findOption(raw, command2.optionsArray);
-      if (!option2) throw new Error(`Unknown Option: --${raw}`);
+      if (raw.startsWith("no-")) {
+        const longName = raw.slice(3);
+        const negated = findOption(longName, command.optionsArray);
+        if (negated?.long) {
+          result[negated.long] = false;
+          continue;
+        }
+      }
+      const option = findOption(raw, command.optionsArray);
+      if (!option) throw new Error(`Unknown Option: --${raw}`);
       try {
-        Object.assign(result, findVariables(option2.long, array, option2.variables, command2.commandStrings));
+        Object.assign(result, await findVariables(option.long, array, option.variables, command.commandStrings));
       } catch (err) {
         ;
-        err.message += ` for --${option2.long}`;
+        err.message += ` for --${option.long}`;
         throw err;
       }
     } else {
       let string = array.shift();
       const short = string.slice(1, 2);
-      const option2 = findOption(short, command2.optionsArray);
-      if (!option2) throw new Error(`Unknown Option: -${short}`);
-      string = string.replace(short, "");
+      const option = findOption(short, command.optionsArray);
+      if (!option) throw new Error(`Unknown Option: -${short}`);
+      string = "-" + string.slice(2);
       if (string !== "-") array.unshift(string);
       try {
-        Object.assign(result, findVariables(option2.long, array, option2.variables, command2.commandStrings));
+        Object.assign(result, await findVariables(option.long, array, option.variables, command.commandStrings));
       } catch (err) {
         ;
-        err.message += ` for --${option2.long}`;
+        err.message += ` for --${option.long}`;
         throw err;
       }
     }
@@ -153,74 +855,6 @@ function findOptions(array, command2) {
   return result;
 }
 
-// src/models/Variable.ts
-var Variable = class {
-  constructor(data) {
-    this.array = false;
-    this.name = null;
-    this.raw = null;
-    this.required = false;
-    this.type = "string";
-    this.value = null;
-    if (!data) return;
-    if (data.array) this.array = data.array;
-    if (data.name) this.name = data.name;
-    if (data.raw) this.raw = data.raw;
-    if (data.required) this.required = data.required;
-    if (data.type) this.type = data.type;
-    if (this.array) this.value = [];
-  }
-};
-
-// src/helpers/getVariables.ts
-function parseName(raw) {
-  const colon = raw.indexOf(":");
-  if (colon === -1) return { name: raw, type: "string" };
-  return {
-    name: raw.slice(0, colon),
-    type: raw.slice(colon + 1)
-  };
-}
-function getVariables(string) {
-  const results = [];
-  for (const part of string.split(" ")) {
-    const trimmed = part.trim();
-    if (!trimmed) continue;
-    if (trimmed.startsWith("<") && trimmed.endsWith(">")) {
-      const { name, type } = parseName(trimmed.slice(1, -1));
-      results.push(new Variable({ name, raw: trimmed, required: true, type }));
-    } else if (trimmed.startsWith("[") && trimmed.endsWith("...]")) {
-      const { name, type } = parseName(trimmed.slice(1, -4));
-      results.push(new Variable({ array: true, name, raw: trimmed, type }));
-    } else if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
-      const { name, type } = parseName(trimmed.slice(1, -1));
-      results.push(new Variable({ name, raw: trimmed, type }));
-    } else {
-      throw new Error(`Unrecognized variable description: ${trimmed}`);
-    }
-  }
-  return results;
-}
-
-// src/models/Option.ts
-var Option = class {
-  constructor(data) {
-    this.short = null;
-    this.long = null;
-    this.info = null;
-    this.variables = null;
-    if (!data) return;
-    if (data.short) this.short = data.short;
-    if (data.long) this.long = data.long;
-    if (data.info) this.info = data.info;
-    if (data.variables) this.variables = getVariables(data.variables);
-  }
-  description(info) {
-    this.info = info;
-    return this;
-  }
-};
-
 // src/models/Command.ts
 var Command = class {
   constructor(data) {
@@ -272,8 +906,8 @@ var Command = class {
     this.middlewaresArray.push(fn);
     return this;
   }
-  middlewares(fns) {
-    this.middlewaresArray.push(...fns);
+  middlewares(fns2) {
+    this.middlewaresArray.push(...fns2);
     return this;
   }
   option(short, long, variables, info) {
@@ -288,9 +922,17 @@ var Command = class {
     this.versionString = v;
     return this;
   }
-  help(_source) {
+  buildInfo(info, variables) {
+    const hints = variables?.map((v) => v.hint).filter(Boolean) ?? [];
+    return [info, ...hints].filter(Boolean).join(" ");
+  }
+  help(source) {
+    const recursive = source?.includes("-r") === true || source?.includes("--recursive") === true;
+    this.printHelp(this.name ?? "Program", recursive);
+  }
+  printHelp(fullName, recursive) {
     const table = [];
-    let program = this.name ?? "Program";
+    let program = fullName;
     if (this.variables) for (const v of this.variables) program += ` ${v.raw}`;
     if (this.optionsArray.length > 0) program += " [...options]";
     table.push({ title: "\nCommand", info: program, data: [] });
@@ -304,7 +946,7 @@ var Command = class {
         if (opt.short && opt.long) name += ", ";
         if (opt.long) name += `--${opt.long}`;
         if (opt.variables) for (const v of opt.variables) name += ` ${v.raw}`;
-        section.data.push([name, opt.info ?? ""]);
+        section.data.push([name, this.buildInfo(opt.info, opt.variables)]);
       }
       table.push(section);
     }
@@ -313,7 +955,7 @@ var Command = class {
       for (const cmd of this.commandsArray) {
         let name = cmd.name ?? "";
         if (cmd.variables) for (const v of cmd.variables) name += ` ${v.raw}`;
-        section.data.push([name, cmd.info ?? ""]);
+        section.data.push([name, this.buildInfo(cmd.info, cmd.variables)]);
       }
       table.push(section);
     }
@@ -327,7 +969,8 @@ var Command = class {
     }
     const lines = [];
     for (const section of table) {
-      lines.push(section.title ? import_cosmetic.default.cyan.underline.encoder(section.title) : "");
+      const styled = typeof config.color === "number" ? import_cosmetic.default.xterm(config.color) : config.color.startsWith("#") ? import_cosmetic.default.hex(config.color) : import_cosmetic.default[config.color];
+      lines.push(section.title ? styled.underline.encoder(section.title) : "");
       if (section.info) lines.push(section.info);
       for (const row of section.data) {
         let line = "";
@@ -340,27 +983,37 @@ var Command = class {
       lines.push("");
     }
     for (const line of lines) console.log(line);
+    if (recursive) {
+      for (const cmd of this.commandsArray) {
+        cmd.printHelp(`${fullName} ${cmd.name ?? ""}`, true);
+      }
+    }
   }
-  async parse(input) {
-    const array = [...input];
+  async parse(input2) {
+    const array = [...input2];
     array.splice(0, 2);
-    let command2 = this;
+    let command = this;
     const options = { _source: Array.from(array) };
+    const ddIdx = array.indexOf("--");
+    if (ddIdx !== -1) {
+      options._ = array.splice(ddIdx + 1);
+      array.splice(ddIdx, 1);
+    }
     while (array.length) {
       if (!array.includes("help")) {
-        Object.assign(options, findOptions(array, command2));
-        const cmdVars = findCommandVariables(array, command2);
+        Object.assign(options, await findOptions(array, command));
+        const cmdVars = await findCommandVariables(array, command);
         if (cmdVars) Object.assign(options, cmdVars);
-        Object.assign(options, findOptions(array, command2));
+        Object.assign(options, await findOptions(array, command));
       }
       if (array.length) {
         if (!array.includes("help")) {
-          for (const mw of command2.middlewaresArray) await mw(options);
+          for (const mw of command.middlewaresArray) await mw(options);
         }
-        const next = findCommand(array, command2.commandsArray);
-        if (!next && array[0] === "help") return command2.help(options._source);
+        const next = findCommand(array, command.commandsArray);
+        if (!next && array[0] === "help") return command.help(options._source);
         if (!next) throw new SyntaxError(`Unknown command: ${array[0]}`);
-        const name = command2.name ?? "_base";
+        const name = command.name ?? "_base";
         if (!options._parents) options._parents = {};
         options._parents[name] = {};
         for (const key of Object.keys(options)) {
@@ -369,70 +1022,1831 @@ var Command = class {
             delete options[key];
           }
         }
-        command2 = next;
+        command = next;
       }
     }
-    for (const mw of command2.middlewaresArray) await mw(options);
-    if (command2.actionFunction) return command2.actionFunction(options);
-    if (options._source.length === 2) return command2.help(options._source);
-    throw new Error(`No action for command: ${command2.name ?? "_base"}`);
+    for (const opt of command.optionsArray) {
+      if (!opt.long || !opt.variables) continue;
+      for (const v of opt.variables) {
+        if (v.default !== null && !(opt.long in options)) {
+          options[opt.long] = coerce(v.default, v.type, v.enum, v.min, v.max);
+        }
+      }
+    }
+    for (const mw of command.middlewaresArray) await mw(options);
+    if (command.actionFunction) return command.actionFunction(options);
+    if (options._source.length === 2) return command.help(options._source);
+    throw new Error(`No action for command: ${command.name ?? "_base"}`);
   }
 };
 
-// src/models/TermKit.ts
-var _TermKit = class _TermKit {
-  static set defaults(obj) {
-    _TermKit.commandDefaults = obj;
+// src/models/Bar.ts
+var Bar = class {
+  constructor(options = {}) {
+    // used by MultiBar — not intended for direct external use
+    this._isManaged = false;
+    this._managedFinalLine = null;
+    this._colors = [];
+    this._parsedColors = [];
+    this._dimmedColors = [];
+    this._bgColors = [];
+    this._parsedBgColors = [];
+    this._colorOffset = 0;
+    this._shimmerPhase = 0;
+    this._completed = false;
+    this._resizeListener = null;
+    this._cleanupDeregister = null;
+    this._total = null;
+    this._tickCount = 0;
+    this._startTime = null;
+    this._etaSuffix = "";
+    this.running = false;
+    this.forwardMotion = true;
+    this._autoLength = options.length === void 0;
+    this.length = options.length ?? process.stdout.columns ?? 80;
+    this.prefixString = options.prefix ?? "[";
+    this.suffixString = options.suffix ?? "]";
+    this.character = options.character ?? "\u2500\u2500";
+    this.beforeEmpty = options.before ?? " ";
+    this.afterEmpty = options.after ?? " ";
+    this.position = 1;
+    this.interval = options.interval ?? 35;
+    this.mode = options.mode ?? "bounce";
+    this.progress = options.progress;
+    this.colorFill = options.colorFill ?? false;
+    this.colorCycle = options.colorCycle ?? 0.5;
+    this.shimmer = options.shimmer ?? 0;
+    this.text = options.text ?? "";
+    this.reverse = options.reverse ?? false;
+    this.onBounce = options.onBounce;
+    this.onLoop = options.onLoop;
+    this.onComplete = options.onComplete;
+    this.colors = options.colors ?? ["#c026d3", "#e879f9"];
+    this.bgColors = options.bgColors ?? [];
+    this._successColor = options.successColor ?? GREEN;
+    this._failColor = options.failColor ?? RED;
+    this._warnColor = options.warnColor ?? YELLOW;
+    this._infoColor = options.infoColor ?? BLUE;
+    this._glyphs = options.glyphs ?? true;
+    this._showRate = options.showRate ?? false;
+    this._showEta = options.showEta ?? false;
+    this._rateUnit = options.rateUnit ?? "";
   }
-  static setDefaults(obj) {
-    _TermKit.commandDefaults = obj;
+  get colors() {
+    return this._colors;
   }
-  static command(name, variables, info) {
-    const cmd = new Command(Object.assign({ name, variables, info }, _TermKit.commandDefaults));
-    if (!_TermKit.base) _TermKit.base = cmd;
-    return cmd;
+  set colors(value) {
+    this._colors = value;
+    this._parsedColors = value.length > 1 ? value.map(parseHex) : [];
+    this._dimmedColors = this._parsedColors.map(dimColor);
   }
-  static middleware(action) {
-    return action;
+  get bgColors() {
+    return this._bgColors;
   }
-  static option(short, long, variables, info) {
-    return new Option({ short, long, variables, info });
+  set bgColors(value) {
+    this._bgColors = value;
+    this._parsedBgColors = value.length > 1 ? value.map(parseHex) : [];
   }
-  static parse(arr) {
-    if (!_TermKit.base) throw new Error("No command defined");
-    return _TermKit.base.parse(arr);
+  set prefix(string) {
+    if (stringLength(string) > stringLength(this.prefixString)) {
+      this.position -= stringLength(string) - 1;
+      if (this.position < 1) this.position = 1;
+    } else {
+      this.position += stringLength(this.prefixString) - 1;
+    }
+    this.prefixString = string;
+  }
+  set suffix(string) {
+    const length = this.length - stringLength(this.prefixString) - stringLength(this.character) - stringLength(string);
+    if (this.position > length) {
+      this.position = length;
+      if (this.forwardMotion) this.forwardMotion = false;
+    }
+    this.suffixString = string;
+  }
+  set before(string) {
+    this.beforeEmpty = stringLength(string) > 1 ? string.charAt(0) : string;
+  }
+  set after(string) {
+    this.afterEmpty = stringLength(string) > 1 ? string.charAt(0) : string;
+  }
+  set empty(string) {
+    const char = stringLength(string) > 1 ? string.charAt(0) : string;
+    this.beforeEmpty = char;
+    this.afterEmpty = char;
+  }
+  start() {
+    if (this._isManaged) return;
+    if (!process.stdout.isTTY) return;
+    this.running = true;
+    process.stdout.write(HIDE_CURSOR);
+    this._cleanupDeregister = registerCleanup(() => {
+      this.running = false;
+      if (this._resizeListener) {
+        process.stdout.off("resize", this._resizeListener);
+        this._resizeListener = null;
+      }
+      process.stdout.clearLine?.(0);
+      process.stdout.write(SHOW_CURSOR);
+    });
+    if (this._autoLength) {
+      this._resizeListener = () => {
+        this.length = process.stdout.columns ?? 80;
+        process.stdout.write("\x1B[0J");
+      };
+      process.stdout.on("resize", this._resizeListener);
+    }
+    this.run();
+  }
+  stop(message) {
+    this.running = false;
+    if (this._isManaged) {
+      this._managedFinalLine = message ?? "";
+      return this;
+    }
+    this._cleanupDeregister?.();
+    this._cleanupDeregister = null;
+    if (process.stdout.isTTY) {
+      if (this._resizeListener) {
+        process.stdout.off("resize", this._resizeListener);
+        this._resizeListener = null;
+      }
+      this.clear();
+      process.stdout.write(SHOW_CURSOR);
+    }
+    if (message) process.stdout.write(`${message}
+`);
+    return this;
+  }
+  message(string) {
+    this.text = string;
+    return this;
+  }
+  track(total, options) {
+    this._total = total;
+    this._tickCount = 0;
+    this._startTime = Date.now();
+    this._etaSuffix = "";
+    if (options?.unit !== void 0) this._rateUnit = options.unit;
+    if (options?.showRate !== void 0) this._showRate = options.showRate;
+    if (options?.showEta !== void 0) this._showEta = options.showEta;
+    if (!this._showRate && !this._showEta) {
+      this._showRate = true;
+      this._showEta = true;
+    }
+    return this;
+  }
+  tick(n = 1) {
+    this._tickCount += n;
+    if (this._total !== null && this._startTime !== null) {
+      this.progress = Math.min(1, this._tickCount / this._total);
+      const elapsed = (Date.now() - this._startTime) / 1e3;
+      const rate = elapsed > 0 ? this._tickCount / elapsed : 0;
+      const remaining = this._total - this._tickCount;
+      const parts = [];
+      if (this._showRate) {
+        const rateStr = rate >= 1e3 ? `${(rate / 1e3).toFixed(1)}k` : rate >= 1 ? rate.toFixed(1) : rate.toFixed(2);
+        parts.push(`${rateStr}/s${this._rateUnit ? ` ${this._rateUnit}` : ""}`);
+      }
+      if (this._showEta && remaining > 0) {
+        const eta = rate > 0 ? remaining / rate : 0;
+        const etaStr = eta >= 3600 ? `${Math.floor(eta / 3600)}h${Math.floor(eta % 3600 / 60)}m` : eta >= 60 ? `${Math.floor(eta / 60)}m${Math.floor(eta % 60)}s` : `${Math.ceil(eta)}s`;
+        parts.push(`ETA ${etaStr}`);
+      }
+      this._etaSuffix = parts.join(" \xB7 ");
+    }
+    return this;
+  }
+  get rate() {
+    if (this._startTime === null || this._tickCount === 0) return 0;
+    const elapsed = (Date.now() - this._startTime) / 1e3;
+    return elapsed > 0 ? this._tickCount / elapsed : 0;
+  }
+  get eta() {
+    if (this._total === null || this.rate === 0) return 0;
+    return Math.max(0, (this._total - this._tickCount) / this.rate);
+  }
+  succeed(string) {
+    this.running = false;
+    if (this._isManaged) {
+      const glyph = this._glyphs ? colorText(this._successColor, "\u2714") + " " : "";
+      this._managedFinalLine = `${glyph}${string ?? ""}`;
+      return this;
+    }
+    this._cleanupDeregister?.();
+    this._cleanupDeregister = null;
+    if (process.stdout.isTTY) {
+      if (this._resizeListener) {
+        process.stdout.off("resize", this._resizeListener);
+        this._resizeListener = null;
+      }
+      this.clear();
+      process.stdout.write(`${SHOW_CURSOR}${colorText(this._successColor, "\u2714")}${string ? ` ${string}` : ""}
+`);
+    } else {
+      process.stdout.write(`${this._glyphs ? `\u2714${string ? ` ${string}` : ""}` : string ?? ""}
+`);
+    }
+    return this;
+  }
+  fail(string) {
+    this.running = false;
+    if (this._isManaged) {
+      const glyph = this._glyphs ? colorText(this._failColor, "\u2716") + " " : "";
+      this._managedFinalLine = `${glyph}${string ?? ""}`;
+      return this;
+    }
+    this._cleanupDeregister?.();
+    this._cleanupDeregister = null;
+    if (process.stdout.isTTY) {
+      if (this._resizeListener) {
+        process.stdout.off("resize", this._resizeListener);
+        this._resizeListener = null;
+      }
+      this.clear();
+      process.stdout.write(`${SHOW_CURSOR}${colorText(this._failColor, "\u2716")}${string ? ` ${string}` : ""}
+`);
+    } else {
+      process.stdout.write(`${this._glyphs ? `\u2716${string ? ` ${string}` : ""}` : string ?? ""}
+`);
+    }
+    return this;
+  }
+  warn(string) {
+    this.running = false;
+    if (this._isManaged) {
+      const glyph = this._glyphs ? colorText(this._warnColor, "\u26A0") + " " : "";
+      this._managedFinalLine = `${glyph}${string ?? ""}`;
+      return this;
+    }
+    this._cleanupDeregister?.();
+    this._cleanupDeregister = null;
+    if (process.stdout.isTTY) {
+      if (this._resizeListener) {
+        process.stdout.off("resize", this._resizeListener);
+        this._resizeListener = null;
+      }
+      this.clear();
+      process.stdout.write(`${SHOW_CURSOR}${colorText(this._warnColor, "\u26A0")}${string ? ` ${string}` : ""}
+`);
+    } else {
+      process.stdout.write(`${this._glyphs ? `\u26A0${string ? ` ${string}` : ""}` : string ?? ""}
+`);
+    }
+    return this;
+  }
+  info(string) {
+    this.running = false;
+    if (this._isManaged) {
+      const glyph = this._glyphs ? colorText(this._infoColor, "\u2139") + " " : "";
+      this._managedFinalLine = `${glyph}${string ?? ""}`;
+      return this;
+    }
+    this._cleanupDeregister?.();
+    this._cleanupDeregister = null;
+    if (process.stdout.isTTY) {
+      if (this._resizeListener) {
+        process.stdout.off("resize", this._resizeListener);
+        this._resizeListener = null;
+      }
+      this.clear();
+      process.stdout.write(`${SHOW_CURSOR}${colorText(this._infoColor, "\u2139")}${string ? ` ${string}` : ""}
+`);
+    } else {
+      process.stdout.write(`${this._glyphs ? `\u2139${string ? ` ${string}` : ""}` : string ?? ""}
+`);
+    }
+    return this;
+  }
+  // Returns the rendered bar line string for the current animation frame.
+  // width overrides this.length for use by MultiBar.
+  renderLine(width) {
+    return this.buildLine(width);
+  }
+  // Advances animation state (color cycle, shimmer, indeterminate position).
+  // Called by MultiBar after reading renderLine() each tick.
+  advanceFrame() {
+    const totalLength = this.length;
+    const textReserved = this.text ? stringLength(this.text) + 1 : 0;
+    const suffixReserved = this._etaSuffix ? stringLength(this._etaSuffix) + 1 : 0;
+    const length = Math.max(1, totalLength - textReserved - suffixReserved - stringLength(this.prefixString) - stringLength(this.character) - stringLength(this.suffixString));
+    if (this.progress === void 0) this.advanceIndeterminate(length);
+    if (this.colorCycle > 0) this._colorOffset = (this._colorOffset + this.colorCycle * this.interval / 1e3) % 1;
+    if (this.shimmer > 0) this._shimmerPhase = (this._shimmerPhase + SHIMMER_SPEED * this.interval / 1e3) % 1;
+  }
+  clear() {
+    process.stdout.clearLine?.(0);
+  }
+  effectiveT(t) {
+    if (this.colorCycle === 0) return t;
+    return ((t + this._colorOffset) % 1 + 1) % 1;
+  }
+  coloredChar(colors, code, t) {
+    const et = this.effectiveT(t);
+    const base2 = interpolateColor(colors, et);
+    const shimmered = applyShimmer(base2, t, this._shimmerPhase, this.shimmer);
+    return formatColor(code, shimmered);
+  }
+  colorChar(t) {
+    const fg = this._parsedColors.length >= 2 ? this.coloredChar(this._parsedColors, 38, t) : "";
+    const bg = this._parsedBgColors.length >= 2 ? this.coloredChar(this._parsedBgColors, 48, t) : "";
+    return fg || bg ? fg + bg + this.character + RESET : this.character;
+  }
+  colorFillChar(char, t) {
+    const fg = this.colorFill && this._dimmedColors.length >= 2 ? this.coloredChar(this._dimmedColors, 38, t) : "";
+    const bg = this._parsedBgColors.length >= 2 ? this.coloredChar(this._parsedBgColors, 48, t) : "";
+    return fg || bg ? fg + bg + char + RESET : char;
+  }
+  buildDeterminate(length) {
+    const charWidth = stringLength(this.character);
+    const clamped = Math.max(0, Math.min(1, this.progress));
+    const filled = Math.round(clamped * length);
+    let working = this.prefixString;
+    for (let i = 0; i < filled; i++) {
+      const t = length > 1 ? i / (length - 1) : 0;
+      working += this.colorChar(t);
+    }
+    for (let i = filled; i < length; i++) {
+      const t = length > 1 ? i / (length - 1) : 0;
+      for (let j = 0; j < charWidth; j++) {
+        working += this.colorFillChar(this.afterEmpty, t);
+      }
+    }
+    working += this.suffixString;
+    if (clamped >= 1 && !this._completed) {
+      this._completed = true;
+      this.onComplete?.();
+    } else if (clamped < 1) {
+      this._completed = false;
+    }
+    return working;
+  }
+  buildIndeterminate(length) {
+    const pos = Math.max(1, Math.min(length, this.position));
+    let working = this.prefixString;
+    let i = 1;
+    while (i < pos) {
+      const t = length > 1 ? (i - 1) / (length - 1) : 0;
+      working += this.colorFillChar(this.beforeEmpty, t);
+      i++;
+    }
+    const charT = length > 1 ? (pos - 1) / (length - 1) : 0;
+    working += this.colorChar(charT);
+    i++;
+    while (i <= length) {
+      const t = length > 1 ? (i - 1) / (length - 1) : 0;
+      working += this.colorFillChar(this.afterEmpty, t);
+      i++;
+    }
+    working += this.suffixString;
+    return working;
+  }
+  advanceIndeterminate(length) {
+    if (this.position > length) {
+      this.position = length;
+      this.forwardMotion = false;
+    }
+    if (this.position < 1) {
+      this.position = 1;
+      this.forwardMotion = true;
+    }
+    if (this.mode === "loop") {
+      this.position++;
+      if (this.position > length) {
+        this.position = 1;
+        this.onLoop?.();
+      }
+    } else if (this.mode === "loop-reverse") {
+      this.position--;
+      if (this.position < 1) {
+        this.position = length;
+        this.onLoop?.();
+      }
+    } else {
+      if (this.forwardMotion) {
+        this.position++;
+        if (this.position >= length) {
+          this.forwardMotion = false;
+          this.onBounce?.();
+        }
+      } else {
+        this.position--;
+        if (this.position <= 1) {
+          this.forwardMotion = true;
+          this.onBounce?.();
+        }
+      }
+    }
+  }
+  buildLine(width) {
+    const totalLength = width ?? this.length;
+    const charWidth = stringLength(this.character);
+    const textReserved = this.text ? stringLength(this.text) + 1 : 0;
+    const suffixReserved = this._etaSuffix ? stringLength(this._etaSuffix) + 1 : 0;
+    const available = totalLength - textReserved - suffixReserved - stringLength(this.prefixString) - stringLength(this.suffixString);
+    const length = this.progress !== void 0 ? (
+      // Determinate: every position (filled or empty) is charWidth wide → constant bar width
+      Math.max(1, Math.floor((available - 1) / charWidth))
+    ) : (
+      // Indeterminate: one position uses character, rest use 1-char fill (unchanged formula)
+      Math.max(1, available - charWidth)
+    );
+    const working = this.progress !== void 0 ? this.buildDeterminate(length) : this.buildIndeterminate(length);
+    const t = this.text;
+    const suffix = this._etaSuffix ? ` ${this._etaSuffix}` : "";
+    return this.reverse ? t ? `${t} ${working}` : working : t ? `${working} ${t}${suffix}` : `${working}${suffix}`;
+  }
+  run() {
+    process.stdout.write(`${this.buildLine()}\x1B[K\r`);
+    this.advanceFrame();
+    setTimeout(() => {
+      if (this.running) this.run();
+    }, this.interval);
+  }
+};
+Bar.COLORS = {
+  blueRed: ["#0000ff", "#ff0000"],
+  redBlue: ["#ff0000", "#0000ff"],
+  rainbow: ["#ff0000", "#ff7f00", "#ffff00", "#00ff00", "#0000ff", "#8b00ff"],
+  heat: ["#0000ff", "#00ffff", "#ffff00", "#ff0000"],
+  cool: ["#00ffff", "#0000ff", "#8b00ff"],
+  sunset: ["#8b00ff", "#ff0000", "#ff7f00"]
+};
+
+// src/models/Chart.ts
+var Chart_exports = {};
+__export(Chart_exports, {
+  Bar: () => Bar2,
+  Heatmap: () => Heatmap,
+  Line: () => Line,
+  Scatter: () => Scatter,
+  Sparkline: () => Sparkline,
+  VerticalBar: () => VerticalBar
+});
+var import_cosmetic2 = __toESM(require("cosmetic"));
+
+// src/utils/padLeft.ts
+var padLeft = (string, padding) => {
+  while (stringLength(string) < padding) string = ` ${string}`;
+  return string;
+};
+
+// src/utils/padRight.ts
+var padRight = (string, padding) => {
+  while (stringLength(string) < padding) string += " ";
+  return string;
+};
+
+// src/models/Chart.ts
+function formatNum(n) {
+  if (Number.isInteger(n)) return String(n);
+  return parseFloat(n.toFixed(2)).toString();
+}
+function applyConfigColor(s) {
+  const c = config.color;
+  if (typeof c === "number") return import_cosmetic2.default.xterm(c).encoder(s);
+  if (c.startsWith("#")) return import_cosmetic2.default.hex(c).encoder(s);
+  return import_cosmetic2.default[c].encoder(s);
+}
+function applyPadding(str, paddingX, paddingY) {
+  const lines = str.split("\n");
+  if (lines[lines.length - 1] === "") lines.pop();
+  const indented = lines.map((l) => " ".repeat(paddingX) + l).join("\n") + "\n";
+  return "\n".repeat(paddingY) + indented + "\n".repeat(paddingY);
+}
+var BLOCKS = [" ", "\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"];
+var Bar2 = class {
+  constructor(data, options = {}) {
+    this.string = "";
+    const paddingX = options.paddingX ?? 0;
+    const paddingY = options.paddingY ?? 0;
+    let maxKeyLen = 0;
+    let maxValue = 0;
+    let maxValueLen = 0;
+    for (const item of data) {
+      if (!item) continue;
+      if (item.key) maxKeyLen = Math.max(maxKeyLen, stringLength(item.key));
+      maxValue = Math.max(maxValue, item.value);
+      maxValueLen = Math.max(maxValueLen, String(item.value).length);
+    }
+    const cols = options.width ?? process.stdout.columns ?? 80;
+    const available = cols - maxKeyLen - maxValueLen - 3;
+    const scale = maxValue > 0 && available > 0 ? available / maxValue : 0;
+    const encodeKey = (s) => typeof config.color === "number" ? import_cosmetic2.default.xterm(config.color).encoder(s) : config.color.startsWith("#") ? import_cosmetic2.default.hex(config.color).encoder(s) : import_cosmetic2.default[config.color].encoder(s);
+    for (const item of data) {
+      if (!item) {
+        this.string += "\n";
+        continue;
+      }
+      const rawKey = item.key ?? "";
+      const keyPart = (rawKey ? encodeKey(rawKey) : "") + " ".repeat(maxKeyLen - stringLength(rawKey));
+      const barWidth = Math.max(1, Math.floor(item.value * scale));
+      let bar = (item.character ?? " ").repeat(barWidth);
+      bar = item.style ? item.style(bar) : import_cosmetic2.default.background.white.encoder(bar);
+      this.string += `${keyPart}|${bar} ${item.value}
+`;
+    }
+    if (paddingX > 0 || paddingY > 0) this.string = applyPadding(this.string, paddingX, paddingY);
+  }
+  print() {
+    process.stdout.write(this.string);
+  }
+  toString() {
+    return this.string;
+  }
+};
+var VerticalBar = class {
+  constructor(data, options = {}) {
+    this.string = "";
+    const paddingX = options.paddingX ?? 0;
+    const paddingY = options.paddingY ?? 0;
+    const height = options.height ?? 10;
+    const colWidth = options.colWidth ?? (options.width ? Math.max(1, Math.floor(options.width / data.length)) : 2);
+    let maxValue = 0;
+    for (const item of data) {
+      if (item) maxValue = Math.max(maxValue, item.value);
+    }
+    for (let row = height; row >= 1; row--) {
+      let line = "";
+      for (const item of data) {
+        if (!item) {
+          line += " ".repeat(colWidth);
+          continue;
+        }
+        const barHeight = maxValue > 0 ? item.value / maxValue * height : 0;
+        const full = Math.floor(barHeight);
+        const frac = barHeight - full;
+        let chars;
+        if (row <= full) {
+          chars = "\u2588".repeat(colWidth);
+        } else if (row === full + 1 && frac > 0) {
+          chars = (BLOCKS[Math.round(frac * 8)] ?? " ").repeat(colWidth);
+        } else {
+          chars = " ".repeat(colWidth);
+        }
+        if (item.style && chars.trim()) chars = item.style(chars);
+        line += chars;
+      }
+      this.string += line + "\n";
+    }
+    this.string += "\u2500".repeat(data.length * colWidth) + "\n";
+    if (data.some((item) => item?.key)) {
+      const encodeLabel = (s) => typeof config.color === "number" ? import_cosmetic2.default.xterm(config.color).encoder(s) : config.color.startsWith("#") ? import_cosmetic2.default.hex(config.color).encoder(s) : import_cosmetic2.default[config.color].encoder(s);
+      let labels = "";
+      for (const item of data) {
+        if (!item?.key) {
+          labels += " ".repeat(colWidth);
+        } else {
+          const key = item.key.length > colWidth ? item.key.slice(0, colWidth) : item.key;
+          labels += encodeLabel(key) + " ".repeat(colWidth - key.length);
+        }
+      }
+      this.string += labels + "\n";
+    }
+    if (paddingX > 0 || paddingY > 0) this.string = applyPadding(this.string, paddingX, paddingY);
+  }
+  print() {
+    process.stdout.write(this.string);
+  }
+  toString() {
+    return this.string;
+  }
+};
+var Heatmap = class {
+  constructor(data, options = {}) {
+    this.string = "";
+    const paddingX = options.paddingX ?? 0;
+    const paddingY = options.paddingY ?? 0;
+    const cellWidth = options.cellWidth ?? 2;
+    const parsedColors = (options.colors ?? ["#0000ff", "#ff0000"]).map(parseHex);
+    let min = options.min;
+    let max = options.max;
+    for (const row of data) {
+      for (const val of row) {
+        if (min === void 0 || val < min) min = val;
+        if (max === void 0 || val > max) max = val;
+      }
+    }
+    const lo = min ?? 0;
+    const hi = max ?? 1;
+    const range = hi - lo || 1;
+    const rowLabelWidth = options.rowLabels ? Math.max(...options.rowLabels.map((l) => stringLength(l))) + 1 : 0;
+    if (options.colLabels) {
+      this.string += " ".repeat(rowLabelWidth);
+      for (const label of options.colLabels) {
+        this.string += label.length > cellWidth ? label.slice(0, cellWidth) : label.padEnd(cellWidth);
+      }
+      this.string += "\n";
+    }
+    for (let r = 0; r < data.length; r++) {
+      if (options.rowLabels) {
+        this.string += padRight(options.rowLabels[r] ?? "", rowLabelWidth - 1) + " ";
+      }
+      for (const val of data[r]) {
+        const t = (val - lo) / range;
+        const color = interpolateColor(parsedColors, t);
+        this.string += `${formatColor(48, color)}${" ".repeat(cellWidth)}${RESET}`;
+      }
+      this.string += "\n";
+    }
+    if (paddingX > 0 || paddingY > 0) this.string = applyPadding(this.string, paddingX, paddingY);
+  }
+  print() {
+    process.stdout.write(this.string);
+  }
+  toString() {
+    return this.string;
+  }
+};
+var Scatter = class {
+  constructor(data, options = {}) {
+    this.string = "";
+    const paddingX = options.paddingX ?? 0;
+    const paddingY = options.paddingY ?? 0;
+    const defaultChar = options.character ?? "\u2022";
+    const showAxes = options.axes ?? true;
+    let xMin = options.xMin ?? (data.length ? Math.min(...data.map((p) => p.x)) : 0);
+    let xMax = options.xMax ?? (data.length ? Math.max(...data.map((p) => p.x)) : 1);
+    let yMin = options.yMin ?? (data.length ? Math.min(...data.map((p) => p.y)) : 0);
+    let yMax = options.yMax ?? (data.length ? Math.max(...data.map((p) => p.y)) : 1);
+    if (xMin === xMax) {
+      xMin -= 1;
+      xMax += 1;
+    }
+    if (yMin === yMax) {
+      yMin -= 1;
+      yMax += 1;
+    }
+    const totalWidth = options.width ?? process.stdout.columns ?? 80;
+    const totalHeight = options.height ?? 20;
+    const plotWidth = showAxes ? Math.max(1, totalWidth - Math.max(formatNum(yMax).length, formatNum(yMin).length, formatNum((yMin + yMax) / 2).length) - 1) : totalWidth;
+    const plotHeight = showAxes ? Math.max(1, totalHeight - 2) : totalHeight;
+    const grid = Array.from({ length: plotHeight }, () => Array(plotWidth).fill(" "));
+    for (const point of data) {
+      const col = Math.round((point.x - xMin) / (xMax - xMin) * (plotWidth - 1));
+      const row = plotHeight - 1 - Math.round((point.y - yMin) / (yMax - yMin) * (plotHeight - 1));
+      if (col >= 0 && col < plotWidth && row >= 0 && row < plotHeight) {
+        const char = point.character ?? defaultChar;
+        grid[row][col] = point.style ? point.style(char) : char;
+      }
+    }
+    if (showAxes) {
+      const yAxisWidth = Math.max(formatNum(yMax).length, formatNum(yMin).length, formatNum((yMin + yMax) / 2).length);
+      const midRow = Math.floor((plotHeight - 1) / 2);
+      for (let r = 0; r < plotHeight; r++) {
+        let yLabel = "";
+        if (r === 0) yLabel = formatNum(yMax);
+        else if (r === midRow) yLabel = formatNum((yMin + yMax) / 2);
+        else if (r === plotHeight - 1) yLabel = formatNum(yMin);
+        const coloredLabel = yLabel ? applyConfigColor(yLabel) : "";
+        this.string += padLeft(coloredLabel, yAxisWidth) + "\u2502" + grid[r].join("") + "\n";
+      }
+      this.string += " ".repeat(yAxisWidth) + "\u2514" + "\u2500".repeat(plotWidth) + "\n";
+      const xMinRaw = formatNum(xMin);
+      const xMidRaw = formatNum((xMin + xMax) / 2);
+      const xMaxRaw = formatNum(xMax);
+      const midCol = Math.floor(plotWidth / 2) - Math.floor(xMidRaw.length / 2);
+      const gap1 = Math.max(0, midCol - xMinRaw.length);
+      const gap2 = Math.max(0, plotWidth - xMinRaw.length - gap1 - xMidRaw.length - xMaxRaw.length);
+      this.string += " ".repeat(yAxisWidth + 1) + applyConfigColor(xMinRaw) + " ".repeat(gap1) + applyConfigColor(xMidRaw) + " ".repeat(gap2) + applyConfigColor(xMaxRaw) + "\n";
+    } else {
+      for (const row of grid) {
+        this.string += row.join("") + "\n";
+      }
+    }
+    if (paddingX > 0 || paddingY > 0) this.string = applyPadding(this.string, paddingX, paddingY);
+  }
+  print() {
+    process.stdout.write(this.string);
+  }
+  toString() {
+    return this.string;
+  }
+};
+var Line = class {
+  constructor(data, options = {}) {
+    this.string = "";
+    const paddingX = options.paddingX ?? 0;
+    const paddingY = options.paddingY ?? 0;
+    const defaultChar = options.character ?? "\u2022";
+    const showAxes = options.axes ?? true;
+    const fill = options.fill ?? false;
+    let xMin = options.xMin ?? (data.length ? Math.min(...data.map((p) => p.x)) : 0);
+    let xMax = options.xMax ?? (data.length ? Math.max(...data.map((p) => p.x)) : 1);
+    let yMin = options.yMin ?? (data.length ? Math.min(...data.map((p) => p.y)) : 0);
+    let yMax = options.yMax ?? (data.length ? Math.max(...data.map((p) => p.y)) : 1);
+    if (xMin === xMax) {
+      xMin -= 1;
+      xMax += 1;
+    }
+    if (yMin === yMax) {
+      yMin -= 1;
+      yMax += 1;
+    }
+    const totalWidth = options.width ?? process.stdout.columns ?? 80;
+    const totalHeight = options.height ?? 20;
+    const yAxisWidth = showAxes ? Math.max(formatNum(yMax).length, formatNum(yMin).length, formatNum((yMin + yMax) / 2).length) : 0;
+    const plotWidth = showAxes ? Math.max(1, totalWidth - yAxisWidth - 1) : totalWidth;
+    const plotHeight = showAxes ? Math.max(1, totalHeight - 2) : totalHeight;
+    const grid = Array.from({ length: plotHeight }, () => Array(plotWidth).fill(" "));
+    const sorted = [...data].sort((a, b) => a.x - b.x);
+    const xRange = xMax - xMin;
+    const yRange = yMax - yMin;
+    for (let col = 0; col < plotWidth; col++) {
+      const xVal = xMin + col / Math.max(1, plotWidth - 1) * xRange;
+      let yVal = null;
+      let pointStyle;
+      for (let pi = 0; pi < sorted.length; pi++) {
+        const p = sorted[pi];
+        const next = sorted[pi + 1];
+        if (next === void 0) {
+          if (Math.abs(p.x - xVal) <= xRange / plotWidth) {
+            yVal = p.y;
+            pointStyle = p.style;
+          }
+          break;
+        }
+        if (p.x <= xVal && next.x >= xVal) {
+          const t = next.x === p.x ? 0 : (xVal - p.x) / (next.x - p.x);
+          yVal = p.y + t * (next.y - p.y);
+          if (t < 0.5 && p.style) pointStyle = p.style;
+          else if (t >= 0.5 && next.style) pointStyle = next.style;
+          break;
+        }
+      }
+      if (yVal !== null) {
+        const row = Math.round((1 - (yVal - yMin) / yRange) * (plotHeight - 1));
+        const clampedRow = Math.max(0, Math.min(plotHeight - 1, row));
+        const char = defaultChar;
+        grid[clampedRow][col] = pointStyle ? pointStyle(char) : char;
+        if (fill) {
+          for (let r = clampedRow + 1; r < plotHeight; r++) {
+            if (grid[r][col] === " ") grid[r][col] = "\u2591";
+          }
+        }
+      }
+    }
+    if (showAxes) {
+      const midRow = Math.floor((plotHeight - 1) / 2);
+      for (let r = 0; r < plotHeight; r++) {
+        let yLabel = "";
+        if (r === 0) yLabel = formatNum(yMax);
+        else if (r === midRow) yLabel = formatNum((yMin + yMax) / 2);
+        else if (r === plotHeight - 1) yLabel = formatNum(yMin);
+        const coloredLabel = yLabel ? applyConfigColor(yLabel) : "";
+        this.string += padLeft(coloredLabel, yAxisWidth) + "\u2502" + grid[r].join("") + "\n";
+      }
+      this.string += " ".repeat(yAxisWidth) + "\u2514" + "\u2500".repeat(plotWidth) + "\n";
+      const xMinRaw = formatNum(xMin);
+      const xMidRaw = formatNum((xMin + xMax) / 2);
+      const xMaxRaw = formatNum(xMax);
+      const midCol = Math.floor(plotWidth / 2) - Math.floor(xMidRaw.length / 2);
+      const gap1 = Math.max(0, midCol - xMinRaw.length);
+      const gap2 = Math.max(0, plotWidth - xMinRaw.length - gap1 - xMidRaw.length - xMaxRaw.length);
+      this.string += " ".repeat(yAxisWidth + 1) + applyConfigColor(xMinRaw) + " ".repeat(gap1) + applyConfigColor(xMidRaw) + " ".repeat(gap2) + applyConfigColor(xMaxRaw) + "\n";
+    } else {
+      for (const row of grid) {
+        this.string += row.join("") + "\n";
+      }
+    }
+    if (paddingX > 0 || paddingY > 0) this.string = applyPadding(this.string, paddingX, paddingY);
+  }
+  print() {
+    process.stdout.write(this.string);
+  }
+  toString() {
+    return this.string;
+  }
+};
+function Sparkline(data, options = {}) {
+  const lo = options.min ?? Math.min(...data);
+  const hi = options.max ?? Math.max(...data);
+  const range = hi === lo ? 1 : hi - lo;
+  const chars = data.map((v) => {
+    const idx = Math.min(8, Math.round(Math.max(0, Math.min(1, (v - lo) / range)) * 8));
+    return BLOCKS[idx] ?? "\u2588";
+  }).join("");
+  return options.style ? options.style(chars) : chars;
+}
+
+// src/models/Column.ts
+var Column = class {
+  constructor(data) {
+    if (typeof data === "string") data = { key: data };
+    this.key = data.key ?? "";
+    this.title = data.title ?? this.key;
+    this.padding = data.padding ?? 0;
+    this.align = data.align;
+    this.hidden = data.hidden;
+    if (stringLength(this.title) > this.padding) this.padding = stringLength(this.title);
+    if (data.minimumPadding && data.minimumPadding > this.padding) this.padding = data.minimumPadding;
+    this.value = data.value ?? ((v) => v == null ? "" : String(v));
+  }
+};
+
+// src/models/Markup.ts
+var TAB = "  ";
+function markup(data, options = {}) {
+  const translations = options.translations ?? {};
+  const styles = {
+    date: options.styles?.date ?? ((v) => colorText(MAGENTA, v)),
+    null: options.styles?.null ?? ((v) => colorText(BOLD, v)),
+    undefined: options.styles?.undefined ?? ((v) => colorText(FAINT, v)),
+    number: options.styles?.number ?? ((v) => colorText(YELLOW, v)),
+    bigint: options.styles?.bigint ?? ((v) => colorText(YELLOW, v)),
+    boolean: options.styles?.boolean ?? ((v) => colorText(CYAN, v)),
+    string: options.styles?.string ?? ((v) => colorText(GREEN, v)),
+    symbol: options.styles?.symbol ?? ((v) => colorText(BLUE, v))
+  };
+  let result = "";
+  function formatPrimitive(value) {
+    if (value instanceof Date) return styles.date(String(value));
+    if (value === null) return styles.null("null");
+    if (value === void 0) return styles.undefined("undefined");
+    if (typeof value === "number") return styles.number(String(value));
+    if (typeof value === "bigint") return styles.bigint(String(value));
+    if (typeof value === "boolean") return styles.boolean(String(value));
+    if (typeof value === "string") return styles.string(value);
+    if (typeof value === "symbol") return styles.symbol(String(value));
+    return String(value);
+  }
+  function isPrimitive(value) {
+    return !Array.isArray(value) && (value === null || value === void 0 || typeof value !== "object" || value instanceof Date);
+  }
+  function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
+  }
+  function formatObjectContents(obj, pad) {
+    const keys = Object.keys(obj);
+    for (const [i, key] of keys.entries()) {
+      result += `${pad}${TAB}${key}: `;
+      let val = obj[key];
+      if (translations[key]) val = translations[key](val);
+      if (typeof val === "object" && val !== null) {
+        format(val, `${pad}${TAB}`);
+      } else {
+        format(val, "");
+      }
+      result += i === keys.length - 1 ? "\n" : ",\n";
+    }
+  }
+  function format(value, pad) {
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        result += result.endsWith(": ") ? "[]" : `${pad}[]`;
+      } else if (value.every(isPrimitive)) {
+        const inline = `[${value.map(formatPrimitive).join(", ")}]`;
+        result += result.endsWith(": ") ? inline : `${pad}${inline}`;
+      } else if (value.every(isPlainObject)) {
+        const prefix = result.endsWith(": ") ? "" : pad;
+        for (const [i, item] of value.entries()) {
+          result += i === 0 ? `${prefix}[{
+` : `${pad}},{
+`;
+          formatObjectContents(item, pad);
+        }
+        result += `${pad}}]`;
+      } else {
+        result += result.endsWith(": ") ? "[" : `${pad}[`;
+        result += "\n";
+        for (const [i, item] of value.entries()) {
+          format(item, `${pad}${TAB}`);
+          result += i === value.length - 1 ? "\n" : ",\n";
+        }
+        result += `${pad}]`;
+      }
+    } else if (value instanceof Date) {
+      result += styles.date(String(value));
+    } else if (value === null) {
+      result += styles.null("null");
+    } else if (value === void 0) {
+      result += styles.undefined("undefined");
+    } else if (isPlainObject(value)) {
+      result += result.endsWith(": ") ? "{" : `${pad}{`;
+      const keys = Object.keys(value);
+      if (keys.length === 0) {
+        result += "}";
+      } else {
+        result += "\n";
+        formatObjectContents(value, pad);
+        result += `${pad}}`;
+      }
+    } else if (typeof value === "number") {
+      result += styles.number(`${pad}${value}`);
+    } else if (typeof value === "bigint") {
+      result += styles.bigint(`${pad}${value}`);
+    } else if (typeof value === "boolean") {
+      result += styles.boolean(String(value));
+    } else if (typeof value === "string") {
+      result += styles.string(`${pad}${value}`);
+    } else if (typeof value === "symbol") {
+      result += styles.symbol(String(value));
+    }
+  }
+  format(data, "");
+  return result;
+}
+
+// src/models/Log.ts
+var Log = class {
+  constructor(options = {}) {
+    this._successColor = options.successColor ?? GREEN;
+    this._failColor = options.failColor ?? RED;
+    this._warnColor = options.warnColor ?? YELLOW;
+    this._infoColor = options.infoColor ?? BLUE;
+    this._glyphs = options.glyphs ?? true;
+  }
+  write(glyph, color, message) {
+    if (process.stdout.isTTY) {
+      process.stdout.write(`${colorText(color, glyph)}${message ? ` ${message}` : ""}
+`);
+    } else {
+      process.stdout.write(`${this._glyphs ? `${glyph}${message ? ` ${message}` : ""}` : message ?? ""}
+`);
+    }
+  }
+  succeed(message) {
+    this.write("\u2714", this._successColor, message);
+  }
+  fail(message) {
+    this.write("\u2716", this._failColor, message);
+  }
+  warn(message) {
+    this.write("\u26A0", this._warnColor, message);
+  }
+  info(message) {
+    this.write("\u2139", this._infoColor, message);
+  }
+  data(value, options) {
+    process.stdout.write(`${markup(value, options)}
+`);
+  }
+};
+var log = new Log();
+
+// src/models/MultiBar.ts
+var CURSOR_UP2 = (n) => `\x1B[${n}A`;
+var MultiBar = class {
+  constructor(options = {}) {
+    this._bars = [];
+    this._running = false;
+    this._linesWritten = 0;
+    this._cleanupDeregister = null;
+    this._interval = options.interval ?? 35;
+  }
+  // Add a bar to the group. Must be called before start().
+  // Returns the Bar instance — use .message(), .progress, .tick(), .succeed(), etc.
+  add(options = {}) {
+    const bar = new Bar(options);
+    bar._isManaged = true;
+    this._bars.push(bar);
+    return bar;
+  }
+  start() {
+    if (!process.stdout.isTTY) return;
+    this._running = true;
+    this._linesWritten = 0;
+    process.stdout.write(HIDE_CURSOR);
+    this._cleanupDeregister = registerCleanup(() => {
+      this._running = false;
+      if (this._linesWritten > 0) process.stdout.write(CURSOR_UP2(this._linesWritten));
+      process.stdout.write("\x1B[0J");
+      process.stdout.write(SHOW_CURSOR);
+    });
+    this.render();
+  }
+  stop() {
+    this._running = false;
+    this._cleanupDeregister?.();
+    this._cleanupDeregister = null;
+    if (process.stdout.isTTY) process.stdout.write(SHOW_CURSOR);
+  }
+  render() {
+    const width = Math.max(20, (process.stdout.columns ?? 80) - 1);
+    if (this._linesWritten > 0) {
+      process.stdout.write(CURSOR_UP2(this._linesWritten));
+    }
+    for (const bar of this._bars) {
+      if (bar._managedFinalLine !== null) {
+        process.stdout.write(`\r${bar._managedFinalLine}\x1B[K
+`);
+      } else {
+        process.stdout.write(`\r${bar.renderLine(width)}\x1B[K
+`);
+        bar.advanceFrame();
+      }
+    }
+    this._linesWritten = this._bars.length;
+    if (!this._running) return;
+    if (this._bars.every((b) => b._managedFinalLine !== null)) {
+      this._running = false;
+      this._cleanupDeregister?.();
+      this._cleanupDeregister = null;
+      process.stdout.write(SHOW_CURSOR);
+      return;
+    }
+    setTimeout(() => {
+      if (this._running) this.render();
+    }, this._interval);
+  }
+};
+
+// src/models/MultiSelect.ts
+var CLEAR_LINE2 = "\x1B[2K";
+var CURSOR_UP3 = (n) => `\x1B[${n}A`;
+var DIM2 = "\x1B[2m";
+var MultiSelect = class {
+  constructor(options = {}) {
+    this._colorOffset = 0;
+    this._shimmerPhase = 0;
+    this.promptColor = options.promptColor ?? resolveColor(config.color);
+    this.promptGlyph = options.promptGlyph ?? (config.glyphs ? "\u25C6" : ">");
+    this.descriptionColor = options.descriptionColor ?? BLUE;
+    this.errorColor = options.errorColor ?? RED;
+    this.checkedPrefix = options.checkedPrefix ?? (config.glyphs ? "\u25C9" : "[x]");
+    this.uncheckedPrefix = options.uncheckedPrefix ?? (config.glyphs ? "\u25CB" : "[ ]");
+    this.colorCycle = options.colorCycle ?? 1;
+    this.shimmer = options.shimmer ?? 0;
+    this.interval = options.interval ?? 80;
+    this.min = options.min ?? 0;
+    this.max = options.max ?? null;
+    this.allowSkip = options.allowSkip ?? false;
+    this.searchEnabled = options.search ?? false;
+    this.maxHeight = options.maxHeight;
+    const colors = options.colors ?? config.pulseColors;
+    this._parsedColors = colors.length >= 2 ? colors.map(parseHex) : [];
+  }
+  pulseColor() {
+    if (this._parsedColors.length < 2) return "";
+    const t = (this._colorOffset % 1 + 1) % 1;
+    const base2 = interpolateColor(this._parsedColors, t);
+    const color = applyShimmer(base2, 0.5, this._shimmerPhase, this.shimmer);
+    return formatColor(38, color);
+  }
+  async ask(prompt, items) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) throw new Error("MultiSelect requires an interactive terminal");
+    let cursor = 0;
+    let viewportOffset = 0;
+    let searchQuery = "";
+    const checked = /* @__PURE__ */ new Set();
+    let error = null;
+    let lastDrawnLines = 0;
+    process.stdout.write(HIDE_CURSOR);
+    const glyph = this.promptGlyph ? `${colorText(this.promptColor, this.promptGlyph)} ` : "";
+    const indent = " ".repeat(this.promptGlyph ? stringLength(this.promptGlyph) + 1 : 0);
+    process.stdout.write(`${glyph}${prompt}
+`);
+    const getFiltered = () => {
+      if (!this.searchEnabled || searchQuery === "") return items.map((item, i) => ({ item, originalIndex: i }));
+      const q = searchQuery.toLowerCase();
+      return items.map((item, i) => ({ item, originalIndex: i })).filter(({ item }) => item.label.toLowerCase().includes(q) || (item.description?.toLowerCase().includes(q) ?? false));
+    };
+    const renderList = (redraw) => {
+      const filtered = getFiltered();
+      if (cursor >= filtered.length) cursor = Math.max(0, filtered.length - 1);
+      if (this.maxHeight) {
+        if (cursor < viewportOffset) viewportOffset = cursor;
+        else if (cursor >= viewportOffset + this.maxHeight) viewportOffset = cursor - this.maxHeight + 1;
+        viewportOffset = Math.max(0, Math.min(viewportOffset, Math.max(0, filtered.length - this.maxHeight)));
+      }
+      const visibleStart = this.maxHeight ? viewportOffset : 0;
+      const visibleEnd = this.maxHeight ? Math.min(filtered.length, viewportOffset + this.maxHeight) : filtered.length;
+      if (redraw) {
+        if (lastDrawnLines > 0) process.stdout.write(CURSOR_UP3(lastDrawnLines));
+        process.stdout.write("\r\x1B[0J");
+      }
+      lastDrawnLines = 0;
+      if (this.searchEnabled) {
+        process.stdout.write(`\r${indent}${colorText(this.promptColor, "/")} ${searchQuery}|
+`);
+        lastDrawnLines++;
+      }
+      const pulse = this.pulseColor();
+      for (let vi = visibleStart; vi < visibleEnd; vi++) {
+        const { item, originalIndex } = filtered[vi];
+        const isCursor = vi === cursor;
+        const isChecked = checked.has(originalIndex);
+        const desc = item.description ? ` ${colorText(this.descriptionColor, `\u2014 ${item.description}`)}` : "";
+        const checkMark = isChecked ? pulse ? `${pulse}${this.checkedPrefix}${RESET}` : colorText(this.promptColor, this.checkedPrefix) : this.uncheckedPrefix;
+        const label = isCursor ? pulse ? `${pulse}${item.label}${RESET}` : colorText(this.promptColor, item.label) : item.label;
+        process.stdout.write(`\r${indent}${checkMark} ${label}${desc}
+`);
+        lastDrawnLines++;
+      }
+      const hintContent = `\u2191\u2193 move  space/tab toggle  \u2190\u2192 deselect/select${this.searchEnabled ? "  type to filter" : "  a all"}  enter confirm`;
+      const maxHintCols = Math.max(10, (process.stdout.columns ?? 80) - stringLength(indent) - 1);
+      const hint = stringLength(hintContent) > maxHintCols ? hintContent.slice(0, maxHintCols) : hintContent;
+      process.stdout.write(`\r${indent}${DIM2}${hint}${RESET}
+`);
+      lastDrawnLines++;
+      if (error) {
+        process.stdout.write(`\r${indent}${colorText(this.errorColor, `\u2717 ${error}`)}
+`);
+        lastDrawnLines++;
+      }
+    };
+    renderList(false);
+    return new Promise((resolve) => {
+      let timer = null;
+      const deregisterCleanup = registerCleanup(() => {
+        if (timer) {
+          clearInterval(timer);
+          timer = null;
+        }
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        process.stdin.removeListener("data", onKey);
+        process.stdout.write(SHOW_CURSOR);
+      });
+      const cleanup = (result) => {
+        deregisterCleanup();
+        if (timer) {
+          clearInterval(timer);
+          timer = null;
+        }
+        if (lastDrawnLines > 0) process.stdout.write(CURSOR_UP3(lastDrawnLines));
+        process.stdout.write("\x1B[0J");
+        const bulletWidth = stringLength(this.checkedPrefix) + 1;
+        for (let i = 0; i < items.length; i++) {
+          const item = items[i];
+          const bullet = checked.has(i) ? `${colorText(this.promptColor, this.checkedPrefix)} ` : " ".repeat(bulletWidth);
+          process.stdout.write(`\r${indent}${bullet}${item.label}
+`);
+        }
+        process.stdout.write(`\r${CLEAR_LINE2}`);
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        process.stdin.removeListener("data", onKey);
+        process.stdout.write(SHOW_CURSOR);
+        resolve(result);
+      };
+      if (this._parsedColors.length >= 2) {
+        timer = setInterval(() => {
+          this._colorOffset = (this._colorOffset + this.colorCycle * this.interval / 1e3) % 1;
+          if (this.shimmer > 0) this._shimmerPhase = (this._shimmerPhase + SHIMMER_SPEED * this.interval / 1e3) % 1;
+          renderList(true);
+        }, this.interval);
+      }
+      const onKey = (key) => {
+        const str = key.toString();
+        const filtered = getFiltered();
+        const safeLen = Math.max(1, filtered.length);
+        if (str === "\x1B[A" || str === "\x1B[Z") {
+          error = null;
+          cursor = (cursor - 1 + safeLen) % safeLen;
+          renderList(true);
+        } else if (str === "\x1B[B") {
+          error = null;
+          cursor = (cursor + 1) % safeLen;
+          renderList(true);
+        } else if (str === " " || str === "	") {
+          const entry = filtered[cursor];
+          if (!entry) return;
+          const oi = entry.originalIndex;
+          if (checked.has(oi)) {
+            error = null;
+            checked.delete(oi);
+          } else if (this.max === null || checked.size < this.max) {
+            error = null;
+            checked.add(oi);
+          } else {
+            error = `Maximum ${this.max} item${this.max !== 1 ? "s" : ""} allowed`;
+          }
+          renderList(true);
+        } else if (str === "\x1B[C") {
+          const entry = filtered[cursor];
+          if (!entry) return;
+          const oi = entry.originalIndex;
+          if (!checked.has(oi)) {
+            if (this.max === null || checked.size < this.max) {
+              error = null;
+              checked.add(oi);
+            } else {
+              error = `Maximum ${this.max} item${this.max !== 1 ? "s" : ""} allowed`;
+            }
+            renderList(true);
+          }
+        } else if (str === "\x1B[D") {
+          const entry = filtered[cursor];
+          if (!entry) return;
+          const oi = entry.originalIndex;
+          if (checked.has(oi)) {
+            error = null;
+            checked.delete(oi);
+            renderList(true);
+          }
+        } else if (str === "a" && !this.searchEnabled) {
+          if (checked.size === items.length) {
+            checked.clear();
+            error = null;
+          } else if (this.max !== null && items.length > this.max) {
+            error = `Maximum ${this.max} item${this.max !== 1 ? "s" : ""} allowed`;
+          } else {
+            for (let i = 0; i < items.length; i++) checked.add(i);
+            error = null;
+          }
+          renderList(true);
+        } else if (str === "\r" || str === "\n") {
+          const entry = filtered[cursor];
+          if (checked.size === 0 && entry) checked.add(entry.originalIndex);
+          if (checked.size < this.min) {
+            error = `Select at least ${this.min} item${this.min !== 1 ? "s" : ""}`;
+            renderList(true);
+            return;
+          }
+          cleanup(items.filter((_, i) => checked.has(i)));
+        } else if (str === "\x1B") {
+          if (this.allowSkip) cleanup(null);
+        } else if (str === "") {
+          deregisterCleanup();
+          if (timer) {
+            clearInterval(timer);
+            timer = null;
+          }
+          process.stdin.setRawMode(false);
+          process.stdin.pause();
+          process.stdin.removeListener("data", onKey);
+          process.stdout.write(SHOW_CURSOR);
+          process.exit(130);
+        } else if (this.searchEnabled) {
+          if (str === "\x7F" || str === "\b") {
+            searchQuery = searchQuery.slice(0, -1);
+            cursor = 0;
+            viewportOffset = 0;
+            error = null;
+            renderList(true);
+          } else if (str.length === 1 && str >= " ") {
+            searchQuery += str;
+            cursor = 0;
+            viewportOffset = 0;
+            error = null;
+            renderList(true);
+          }
+        } else {
+          const n = parseInt(str);
+          if (!isNaN(n) && n >= 1 && n <= Math.min(filtered.length, 9)) {
+            error = null;
+            cursor = viewportOffset + n - 1;
+            renderList(true);
+          }
+        }
+      };
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+      process.stdin.on("data", onKey);
+    });
+  }
+};
+async function multiSelect(prompt, items, options) {
+  return new MultiSelect(options).ask(prompt, items);
+}
+
+// src/utils/truncate.ts
+var ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]/g;
+var RESET2 = "\x1B[0m";
+function truncate(str, maxLength, suffix = "\u2026") {
+  if (stringLength(str) <= maxLength) return str;
+  const hasAnsi = ANSI_RE.test(str);
+  ANSI_RE.lastIndex = 0;
+  const suffixLen = stringLength(suffix);
+  const target = Math.max(0, maxLength - suffixLen);
+  let visible = 0;
+  let i = 0;
+  while (i < str.length && visible < target) {
+    if (str[i] === "\x1B") {
+      const m = str.slice(i).match(ANSI_RE);
+      if (m) {
+        i += m[0].length;
+        continue;
+      }
+    }
+    visible++;
+    i++;
+  }
+  return str.slice(0, i) + (hasAnsi ? RESET2 : "") + suffix;
+}
+
+// src/utils/wrap.ts
+function wrap(str, width) {
+  const words = str.split(" ");
+  const lines = [];
+  let current = "";
+  let currentLen = 0;
+  for (const word of words) {
+    const wordLen = stringLength(word);
+    if (currentLen === 0) {
+      current = word;
+      currentLen = wordLen;
+    } else if (currentLen + 1 + wordLen <= width) {
+      current += " " + word;
+      currentLen += 1 + wordLen;
+    } else {
+      lines.push(current);
+      current = word;
+      currentLen = wordLen;
+    }
+  }
+  if (current) lines.push(current);
+  return lines.join("\n");
+}
+
+// src/models/Scrollbox.ts
+var CURSOR_UP4 = (n) => `\x1B[${n}A`;
+var DIM3 = "\x1B[2m";
+var Scrollbox = class {
+  constructor(options = {}) {
+    this.height = options.height ?? 10;
+    this.title = options.title;
+    this.lineNumbers = options.lineNumbers ?? false;
+    this.showScrollbar = options.scrollbar ?? true;
+    this.borderColor = options.borderColor ?? DIM3;
+    this.wrapLines = options.wrapLines ?? false;
+  }
+  async show(lines) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) throw new Error("Scrollbox requires an interactive terminal");
+    const termWidth = process.stdout.columns ?? 80;
+    const lineNumWidth = this.lineNumbers ? String(lines.length).length + 2 : 0;
+    const gutterWidth = this.showScrollbar ? 1 : 0;
+    const contentWidth = Math.max(10, termWidth - lineNumWidth - gutterWidth);
+    const displayLines = this.wrapLines ? lines.flatMap((line) => wrap(line, contentWidth).split("\n")) : lines;
+    const total = displayLines.length;
+    let offset = 0;
+    let lastDrawnLines = 0;
+    process.stdout.write(HIDE_CURSOR);
+    const render = (redraw) => {
+      offset = Math.max(0, Math.min(offset, Math.max(0, total - this.height)));
+      if (redraw && lastDrawnLines > 0) {
+        process.stdout.write(CURSOR_UP4(lastDrawnLines));
+        process.stdout.write("\x1B[0J");
+      }
+      lastDrawnLines = 0;
+      if (this.title) {
+        process.stdout.write(`\r${colorText(this.borderColor, this.title)}
+`);
+        lastDrawnLines++;
+      }
+      let thumbStart = 0;
+      let thumbEnd = this.height;
+      if (this.showScrollbar && total > this.height) {
+        const thumbSize = Math.max(1, Math.floor(this.height / total * this.height));
+        thumbStart = Math.floor(offset / Math.max(1, total - this.height) * (this.height - thumbSize));
+        thumbEnd = thumbStart + thumbSize;
+      }
+      const visibleEnd = Math.min(total, offset + this.height);
+      for (let i = offset; i < visibleEnd; i++) {
+        const relIdx = i - offset;
+        const numStr = this.lineNumbers ? `${colorText(this.borderColor, String(i + 1).padStart(lineNumWidth - 1))} ` : "";
+        const content = this.wrapLines ? displayLines[i] : truncate(displayLines[i], contentWidth);
+        const paddedContent = padRight(content, contentWidth);
+        const gutter = this.showScrollbar ? total > this.height && relIdx >= thumbStart && relIdx < thumbEnd ? "\u2588" : colorText(this.borderColor, "\u2595") : "";
+        process.stdout.write(`\r${numStr}${paddedContent}${gutter}
+`);
+        lastDrawnLines++;
+      }
+      const pct = total <= this.height ? "100%" : `${Math.round(offset / (total - this.height) * 100)}%`;
+      process.stdout.write(`\r${DIM3}\u2191\u2193/jk line  space/b page  g/G top/end  q close  ${pct}${RESET}
+`);
+      lastDrawnLines++;
+    };
+    render(false);
+    return new Promise((resolve) => {
+      const deregisterCleanup = registerCleanup(() => {
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        process.stdin.removeListener("data", onKey);
+        process.stdout.write(SHOW_CURSOR);
+      });
+      const cleanup = () => {
+        deregisterCleanup();
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        process.stdin.removeListener("data", onKey);
+        process.stdout.write(SHOW_CURSOR);
+        resolve();
+      };
+      const onKey = (key) => {
+        const str = key.toString();
+        if (str === "\x1B[A" || str === "k") {
+          offset--;
+          render(true);
+        } else if (str === "\x1B[B" || str === "j") {
+          offset++;
+          render(true);
+        } else if (str === " " || str === "\x1B[6~") {
+          offset += this.height;
+          render(true);
+        } else if (str === "b" || str === "\x1B[5~") {
+          offset -= this.height;
+          render(true);
+        } else if (str === "g") {
+          offset = 0;
+          render(true);
+        } else if (str === "G") {
+          offset = total;
+          render(true);
+        } else if (str === "q" || str === "\x1B" || str === "\r" || str === "\n") {
+          cleanup();
+        } else if (str === "") {
+          cleanup();
+          process.exit(130);
+        }
+      };
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+      process.stdin.on("data", onKey);
+    });
+  }
+};
+async function scrollbox(lines, options) {
+  return new Scrollbox(options).show(lines);
+}
+
+// src/models/Spinner.ts
+var _Spinner = class _Spinner {
+  constructor(options = {}) {
+    this._colors = [];
+    this._parsedColors = [];
+    this._bgColors = [];
+    this._parsedBgColors = [];
+    this._colorOffset = 0;
+    this._shimmerPhase = 0;
+    this._lastLineLength = 0;
+    this._cleanupDeregister = null;
+    this.running = false;
+    this.frameIndex = 0;
+    this.frames = options.frames ?? (config.glyphs ? _Spinner.FRAMES.braille : _Spinner.FRAMES.line);
+    this.prefixString = options.prefix ?? "";
+    this.suffixString = options.suffix ?? "";
+    this.text = options.text ?? "";
+    this.reverse = options.reverse ?? false;
+    this.interval = options.interval ?? 80;
+    this.colorCycle = options.colorCycle ?? 1;
+    this.shimmer = options.shimmer ?? 0;
+    this.onSpin = options.onSpin;
+    this.colors = options.colors ?? ["#c026d3", "#e879f9"];
+    this.bgColors = options.bgColors ?? [];
+    this._successColor = options.successColor ?? GREEN;
+    this._failColor = options.failColor ?? RED;
+    this._warnColor = options.warnColor ?? YELLOW;
+    this._infoColor = options.infoColor ?? BLUE;
+    this._glyphs = options.glyphs ?? config.glyphs;
+  }
+  get colors() {
+    return this._colors;
+  }
+  set colors(value) {
+    this._colors = value;
+    this._parsedColors = value.length > 1 ? value.map(parseHex) : [];
+  }
+  get bgColors() {
+    return this._bgColors;
+  }
+  set bgColors(value) {
+    this._bgColors = value;
+    this._parsedBgColors = value.length > 1 ? value.map(parseHex) : [];
+  }
+  start() {
+    if (!process.stdout.isTTY) return;
+    this.running = true;
+    process.stdout.write(HIDE_CURSOR);
+    this._cleanupDeregister = registerCleanup(() => {
+      this.running = false;
+      process.stdout.clearLine?.(0);
+      process.stdout.write(SHOW_CURSOR);
+    });
+    this.run();
+  }
+  stop(message) {
+    this.running = false;
+    this._cleanupDeregister?.();
+    this._cleanupDeregister = null;
+    if (process.stdout.isTTY) {
+      this.clear();
+      process.stdout.write(SHOW_CURSOR);
+    }
+    if (message) process.stdout.write(`${message}
+`);
+    return this;
+  }
+  message(string) {
+    this.text = string;
+    return this;
+  }
+  succeed(string) {
+    this.running = false;
+    this._cleanupDeregister?.();
+    this._cleanupDeregister = null;
+    if (process.stdout.isTTY) {
+      this.clear();
+      const glyph = this._glyphs ? colorText(this._successColor, "\u2714") + " " : "";
+      process.stdout.write(`${SHOW_CURSOR}${glyph}${string ?? ""}
+`);
+    } else {
+      process.stdout.write(`${this._glyphs ? `\u2714 ${string ?? ""}` : string ?? ""}
+`);
+    }
+    return this;
+  }
+  fail(string) {
+    this.running = false;
+    this._cleanupDeregister?.();
+    this._cleanupDeregister = null;
+    if (process.stdout.isTTY) {
+      this.clear();
+      const glyph = this._glyphs ? colorText(this._failColor, "\u2716") + " " : "";
+      process.stdout.write(`${SHOW_CURSOR}${glyph}${string ?? ""}
+`);
+    } else {
+      process.stdout.write(`${this._glyphs ? `\u2716 ${string ?? ""}` : string ?? ""}
+`);
+    }
+    return this;
+  }
+  warn(string) {
+    this.running = false;
+    this._cleanupDeregister?.();
+    this._cleanupDeregister = null;
+    if (process.stdout.isTTY) {
+      this.clear();
+      const glyph = this._glyphs ? colorText(this._warnColor, "\u26A0") + " " : "";
+      process.stdout.write(`${SHOW_CURSOR}${glyph}${string ?? ""}
+`);
+    } else {
+      process.stdout.write(`${this._glyphs ? `\u26A0 ${string ?? ""}` : string ?? ""}
+`);
+    }
+    return this;
+  }
+  info(string) {
+    this.running = false;
+    this._cleanupDeregister?.();
+    this._cleanupDeregister = null;
+    if (process.stdout.isTTY) {
+      this.clear();
+      const glyph = this._glyphs ? colorText(this._infoColor, "\u2139") + " " : "";
+      process.stdout.write(`${SHOW_CURSOR}${glyph}${string ?? ""}
+`);
+    } else {
+      process.stdout.write(`${this._glyphs ? `\u2139 ${string ?? ""}` : string ?? ""}
+`);
+    }
+    return this;
+  }
+  clear() {
+    process.stdout.clearLine?.(0);
+    this._lastLineLength = 0;
+  }
+  coloredFrame() {
+    const t = this._parsedColors.length >= 2 && this.frames.length > 1 ? this.frameIndex / (this.frames.length - 1) : 0;
+    const et = this.colorCycle > 0 ? ((t + this._colorOffset) % 1 + 1) % 1 : t;
+    const frame = this.frames[this.frameIndex];
+    const fg = this._parsedColors.length >= 2 ? formatColor(38, applyShimmer(interpolateColor(this._parsedColors, et), 0.5, this._shimmerPhase, this.shimmer)) : "";
+    const bg = this._parsedBgColors.length >= 2 ? formatColor(48, applyShimmer(interpolateColor(this._parsedBgColors, et), 0.5, this._shimmerPhase, this.shimmer)) : "";
+    return fg || bg ? fg + bg + frame + RESET : frame;
+  }
+  run() {
+    const frame = this.coloredFrame();
+    const t = this.text;
+    const content = this.reverse ? t ? `${t} ${frame}` : frame : t ? `${frame} ${t}` : frame;
+    const raw = `${this.prefixString}${content}${this.suffixString}`;
+    const displayLen = stringLength(raw);
+    const padding = " ".repeat(Math.max(0, this._lastLineLength - displayLen));
+    this._lastLineLength = displayLen;
+    process.stdout.write(`${raw}${padding}\r`);
+    this.frameIndex = (this.frameIndex + 1) % this.frames.length;
+    if (this.frameIndex === 0) this.onSpin?.();
+    if (this.colorCycle > 0) {
+      this._colorOffset = (this._colorOffset + this.colorCycle * this.interval / 1e3) % 1;
+    }
+    if (this.shimmer > 0) {
+      this._shimmerPhase = (this._shimmerPhase + SHIMMER_SPEED * this.interval / 1e3) % 1;
+    }
+    setTimeout(() => {
+      if (this.running) this.run();
+    }, this.interval);
+  }
+};
+_Spinner.FRAMES = {
+  braille: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"],
+  dots: ["\u28FE", "\u28FD", "\u28FB", "\u28BF", "\u287F", "\u28DF", "\u28EF", "\u28F7"],
+  line: ["|", "/", "-", "\\"],
+  arrow: ["\u2190", "\u2196", "\u2191", "\u2197", "\u2192", "\u2198", "\u2193", "\u2199"],
+  bounce: ["\u2801", "\u2802", "\u2804", "\u2802"]
+};
+var Spinner = _Spinner;
+
+// src/models/Table.ts
+var import_cosmetic3 = __toESM(require("cosmetic"));
+
+// src/utils/padSides.ts
+var padSides = (string, padding) => {
+  let alt = false;
+  while (stringLength(string) < padding) {
+    if (alt) {
+      string = ` ${string}`;
+    } else {
+      string += " ";
+    }
+    alt = !alt;
+  }
+  return string;
+};
+
+// src/models/Table.ts
+var alignPad = (align) => {
+  switch (align) {
+    case "center":
+      return padSides;
+    case "right":
+      return padLeft;
+    default:
+      return padRight;
+  }
+};
+var Table = class {
+  constructor(rows, options = {}) {
+    this.rows = rows;
+    this.columns = {};
+    this.separator = options.separator ?? "|";
+    this.align = options.align ?? "left";
+    this.margin = options.margin ?? 0;
+    this.string = "";
+    if (options.title) this.title = options.title;
+    if (options.columns) {
+      for (const col of options.columns) {
+        const column = new Column(col);
+        if (!column.hidden) this.columns[column.key] = column;
+      }
+    }
+    for (const row of this.rows) {
+      for (const key of Object.keys(row)) {
+        if (Object.keys(this.columns).length) {
+          const column = this.columns[key];
+          if (!column) continue;
+          const cellLen = stringLength(column.value(row[key]));
+          if (column.padding < cellLen) this.columns[key].padding = cellLen;
+        } else {
+          const keyLen = stringLength(key);
+          const valLen = stringLength(String(row[key] ?? ""));
+          this.columns[key] = new Column({ key, padding: Math.max(keyLen, valLen) });
+        }
+      }
+    }
+    if (options.meta) {
+      this.meta = options.meta;
+      for (const meta of options.meta) {
+        for (const key of Object.keys(meta)) {
+          const column = this.columns[key];
+          if (!column) continue;
+          const cellLen = stringLength(column.value(meta[key]));
+          if (column.padding < cellLen) column.padding = cellLen;
+        }
+      }
+    }
+    if (this.title) this.string += `${alignPad(this.align)(this.title, this.width)}
+
+`;
+    const keys = Object.keys(this.columns);
+    let header = "";
+    for (const [i, key] of keys.entries()) {
+      const column = this.columns[key];
+      const pad = alignPad(column.align ?? this.align);
+      header += pad(column.title, column.padding + this.margin);
+      if (i < keys.length - 1) header += this.separator;
+    }
+    const styled = typeof config.color === "number" ? import_cosmetic3.default.xterm(config.color) : config.color.startsWith("#") ? import_cosmetic3.default.hex(config.color) : import_cosmetic3.default[config.color];
+    this.string += `${styled.underline.encoder(header)}
+`;
+    for (const [ri, row] of this.rows.entries()) {
+      for (const [ci, key] of keys.entries()) {
+        const column = this.columns[key];
+        const pad = alignPad(column.align ?? this.align);
+        const raw = row[column.key];
+        this.string += pad(column.value(raw == null ? "" : raw), column.padding + this.margin);
+        if (ci < keys.length - 1) this.string += this.separator;
+      }
+      if (ri < this.rows.length - 1) this.string += "\n";
+    }
+    if (this.meta) {
+      this.string += "\n\n";
+      for (const [mi, meta] of this.meta.entries()) {
+        for (const [ci, key] of keys.entries()) {
+          const column = this.columns[key];
+          const pad = alignPad(column.align ?? this.align);
+          const raw = meta[column.key];
+          this.string += pad(column.value(raw == null ? "" : raw), column.padding + this.margin);
+          if (ci < keys.length - 1) this.string += this.separator;
+        }
+        if (mi < this.meta.length - 1) this.string += "\n";
+      }
+    }
+  }
+  print() {
+    process.stdout.write(this.string + "\n");
+  }
+  get width() {
+    let width = 0;
+    for (const key of Object.keys(this.columns)) {
+      if (!this.columns[key].hidden) width += this.columns[key].padding + this.margin + 1;
+    }
+    return width - 1;
+  }
+};
+Table.left = "left";
+Table.center = "center";
+Table.right = "right";
+
+// src/models/TermKit.ts
+var _TermKit = class _TermKit {
+  static set defaults(obj) {
+    _TermKit.commandDefaults = obj;
+  }
+  static setDefaults(obj) {
+    _TermKit.commandDefaults = obj;
+  }
+  static command(name, variables, info) {
+    const cmd = new Command(Object.assign({ name, variables, info }, _TermKit.commandDefaults));
+    if (!_TermKit.base) _TermKit.base = cmd;
+    return cmd;
+  }
+  static middleware(action) {
+    return action;
+  }
+  static option(short, long, variables, info) {
+    return new Option({ short, long, variables, info });
+  }
+  static parse(arr) {
+    if (!_TermKit.base) throw new Error("No command defined");
+    return _TermKit.base.parse(arr);
+  }
+};
+_TermKit.base = null;
+_TermKit.commandDefaults = {};
+var TermKit = _TermKit;
+
+// src/index.ts
+var import_cosmetic4 = __toESM(require("cosmetic"));
+var base = null;
+var commandDefaults = {};
+var Program = {
+  command: (name, variables, info) => {
+    const cmd = new Command(Object.assign({ name, variables, info }, commandDefaults));
+    if (!base) base = cmd;
+    return cmd;
+  },
+  option: (short, long, variables, info) => new Option({ short, long, variables, info }),
+  middleware: (fn) => fn,
+  parse: async (arr) => {
+    if (!base) throw new Error("No command defined");
+    try {
+      await base.parse(arr);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (process.stderr.isTTY && config.glyphs) {
+        process.stderr.write(`\x1B[31m\u2716\x1B[0m ${msg}
+`);
+      } else {
+        process.stderr.write(`Error: ${msg}
+`);
+      }
+      process.exit(1);
+    }
+  },
+  setDefaults: (data) => {
+    commandDefaults = data;
   }
-};
-_TermKit.base = null;
-_TermKit.commandDefaults = {};
-var TermKit = _TermKit;
-
-// src/index.ts
-var base = null;
-var commandDefaults = {};
-var command = (name, variables, info) => {
-  const cmd = new Command(Object.assign({ name, variables, info }, commandDefaults));
-  if (!base) base = cmd;
-  return cmd;
-};
-var middleware = (fn) => fn;
-var option = (short, long, variables, info) => new Option({ short, long, variables, info });
-var parse = (arr) => {
-  if (!base) throw new Error("No command defined");
-  return base.parse(arr);
-};
-var setDefaults = (data) => {
-  commandDefaults = data;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  Bar,
+  Chart,
+  Color,
+  Column,
   Command,
+  Input,
+  Log,
+  MultiBar,
+  MultiSelect,
   Option,
+  Program,
+  Scrollbox,
+  Select,
+  Spinner,
+  Table,
   TermKit,
   Variable,
-  command,
-  middleware,
-  option,
-  parse,
-  setDefaults
+  configure,
+  confirm,
+  input,
+  log,
+  markup,
+  multiSelect,
+  padLeft,
+  padRight,
+  padSides,
+  scrollbox,
+  select,
+  stringLength,
+  truncate,
+  wrap
 });