pyre-cli 9.3.0 → 9.5.0

package/dist/chunk-MOAEGMFP.js

@@ -0,0 +1,1042 @@
+// src/formatters/render.ts
+import chalk2 from "chalk";
+
+// src/sparkline.ts
+var BLOCKS = " \u2582\u2583\u2584\u2585\u2586\u2587\u2588";
+function sparkline(values, opts = {}) {
+  if (!values.length) return "";
+  if (opts.plainText) {
+    const first = values[0];
+    const last = values[values.length - 1];
+    const diff = last - first;
+    const sign = diff >= 0 ? "+" : "";
+    return `[${first.toFixed(1)} -> ${last.toFixed(1)} (\u0394:${sign}${diff.toFixed(1)})]`;
+  }
+  let min = opts.min ?? Infinity;
+  let max = opts.max ?? -Infinity;
+  if (opts.min === void 0 || opts.max === void 0) {
+    for (const v of values) {
+      if (v < min) min = v;
+      if (v > max) max = v;
+    }
+  }
+  const range = max - min || 1;
+  return values.map((v) => {
+    const idx = Math.round((v - min) / range * (BLOCKS.length - 1));
+    const clamped = Math.min(BLOCKS.length - 1, Math.max(0, idx));
+    return BLOCKS[clamped];
+  }).join("");
+}
+function multiRowBrailleGraph(values, height, opts = {}) {
+  if (!values.length || height <= 0) return Array(height).fill("");
+  let min = opts.min ?? Infinity;
+  let max = opts.max ?? -Infinity;
+  if (opts.min === void 0 || opts.max === void 0) {
+    for (const v of values) {
+      if (v < min) min = v;
+      if (v > max) max = v;
+    }
+  }
+  const range = max - min || 1;
+  const levels = height * 4;
+  const dotsCol0 = [64, 4, 2, 1];
+  const dotsCol1 = [128, 32, 16, 8];
+  const rows = Array.from({ length: height }, () => []);
+  for (let i = 0; i < values.length; i += 2) {
+    const v0 = values[i];
+    const v1 = i + 1 < values.length ? values[i + 1] : v0;
+    const rawSteps0 = Math.round((v0 - min) / range * levels);
+    const totalSteps0 = Math.min(levels, Math.max(0, rawSteps0));
+    const rawSteps1 = Math.round((v1 - min) / range * levels);
+    const totalSteps1 = Math.min(levels, Math.max(0, rawSteps1));
+    for (let r = 0; r < height; r++) {
+      const rowFromBottom = height - 1 - r;
+      const minForThisRow = rowFromBottom * 4;
+      const stepsInThisRow0 = Math.min(4, Math.max(0, totalSteps0 - minForThisRow));
+      const stepsInThisRow1 = Math.min(4, Math.max(0, totalSteps1 - minForThisRow));
+      let code = 10240;
+      for (let d = 0; d < stepsInThisRow0; d++) code |= dotsCol0[d];
+      for (let d = 0; d < stepsInThisRow1; d++) code |= dotsCol1[d];
+      rows[r].push(String.fromCharCode(code));
+    }
+  }
+  return rows.map((r) => r.join(""));
+}
+function brailleGraph(values, opts = {}) {
+  if (!values.length) return "";
+  let min = opts.min ?? Infinity;
+  let max = opts.max ?? -Infinity;
+  if (opts.min === void 0 || opts.max === void 0) {
+    for (const v of values) {
+      if (v < min) min = v;
+      if (v > max) max = v;
+    }
+  }
+  const range = max - min || 1;
+  const dotsCol0 = [64, 4, 2, 1];
+  const dotsCol1 = [128, 32, 16, 8];
+  let result = "";
+  for (let i = 0; i < values.length; i += 2) {
+    const v0 = values[i];
+    const v1 = i + 1 < values.length ? values[i + 1] : v0;
+    const fill0 = Math.min(4, Math.max(0, Math.round((v0 - min) / range * 4)));
+    const fill1 = Math.min(4, Math.max(0, Math.round((v1 - min) / range * 4)));
+    let code = 10240;
+    for (let d = 0; d < fill0; d++) code |= dotsCol0[d];
+    for (let d = 0; d < fill1; d++) code |= dotsCol1[d];
+    result += String.fromCharCode(code);
+  }
+  return result;
+}
+
+// src/formatters/themes.ts
+import chalk from "chalk";
+import fs from "fs";
+import os from "os";
+import path from "path";
+var BUILTIN_THEMES = {
+  default: {
+    border: chalk.hex("#4b5563"),
+    cpu: chalk.hex("#22d3ee"),
+    mem: chalk.hex("#a78bfa"),
+    gpu: chalk.hex("#f472b6"),
+    power: chalk.hex("#fbbf24"),
+    battery: chalk.hex("#34d399"),
+    thermal: chalk.hex("#fb923c"),
+    network: chalk.hex("#60a5fa"),
+    disk: chalk.hex("#f472b6"),
+    graphs: chalk.hex("#22d3ee"),
+    process: chalk.hex("#e5e7eb")
+  },
+  dracula: {
+    border: chalk.hex("#6272a4"),
+    cpu: chalk.hex("#8be9fd"),
+    mem: chalk.hex("#bd93f9"),
+    gpu: chalk.hex("#ff5555"),
+    power: chalk.hex("#f1fa8c"),
+    battery: chalk.hex("#50fa7b"),
+    thermal: chalk.hex("#ffb86c"),
+    network: chalk.hex("#ff79c6"),
+    disk: chalk.hex("#ff5555"),
+    graphs: chalk.hex("#8be9fd"),
+    process: chalk.hex("#f8f8f2")
+  },
+  cyberpunk: {
+    border: chalk.hex("#ff0055"),
+    cpu: chalk.hex("#00ffcc"),
+    mem: chalk.hex("#ff00ff"),
+    gpu: chalk.hex("#ffff00"),
+    power: chalk.hex("#ffff00"),
+    battery: chalk.hex("#00ff00"),
+    thermal: chalk.hex("#ff6600"),
+    network: chalk.hex("#00ffff"),
+    disk: chalk.hex("#ff007f"),
+    graphs: chalk.hex("#00ffcc"),
+    process: chalk.hex("#ffffff")
+  },
+  monochrome: {
+    border: chalk.gray,
+    cpu: chalk.white.bold,
+    mem: chalk.white.bold,
+    gpu: chalk.white.bold,
+    power: chalk.white.bold,
+    battery: chalk.white.bold,
+    thermal: chalk.white.bold,
+    network: chalk.white.bold,
+    disk: chalk.white.bold,
+    graphs: chalk.white.bold,
+    process: chalk.white.bold
+  },
+  nord: {
+    border: chalk.hex("#4c566a"),
+    cpu: chalk.hex("#88c0d0"),
+    mem: chalk.hex("#b48ead"),
+    gpu: chalk.hex("#bf616a"),
+    power: chalk.hex("#ebcb8b"),
+    battery: chalk.hex("#a3be8c"),
+    thermal: chalk.hex("#d08770"),
+    network: chalk.hex("#81a1c1"),
+    disk: chalk.hex("#b48ead"),
+    graphs: chalk.hex("#88c0d0"),
+    process: chalk.hex("#eceff4")
+  },
+  gruvbox: {
+    border: chalk.hex("#928374"),
+    cpu: chalk.hex("#fb4934"),
+    mem: chalk.hex("#b8bb26"),
+    gpu: chalk.hex("#d3869b"),
+    power: chalk.hex("#fabd2f"),
+    battery: chalk.hex("#b8bb26"),
+    thermal: chalk.hex("#fb4934"),
+    network: chalk.hex("#83a598"),
+    disk: chalk.hex("#d3869b"),
+    graphs: chalk.hex("#fb4934"),
+    process: chalk.hex("#ebdbb2")
+  }
+};
+function loadCustomThemes() {
+  const themes = { ...BUILTIN_THEMES };
+  const themesDir = path.join(os.homedir(), ".config", "pyre", "themes");
+  try {
+    if (fs.existsSync(themesDir)) {
+      const files = fs.readdirSync(themesDir);
+      for (const file of files) {
+        if (file.endsWith(".json")) {
+          const name = path.basename(file, ".json");
+          try {
+            const raw = fs.readFileSync(path.join(themesDir, file), "utf-8");
+            const data = JSON.parse(raw);
+            const buildColor = (val) => val ? val.startsWith("#") ? chalk.hex(val) : chalk[val] || chalk.white : chalk.white;
+            themes[name] = {
+              border: buildColor(data.border),
+              cpu: buildColor(data.cpu),
+              mem: buildColor(data.mem),
+              gpu: buildColor(data.gpu),
+              power: buildColor(data.power),
+              battery: buildColor(data.battery),
+              thermal: buildColor(data.thermal),
+              network: buildColor(data.network),
+              disk: buildColor(data.disk),
+              graphs: buildColor(data.graphs),
+              process: buildColor(data.process)
+            };
+          } catch {
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  return themes;
+}
+var THEMES = loadCustomThemes();
+
+// src/formatters/render.ts
+function visLen(s) {
+  return s.replace(/\x1b\[[0-9;]*m/g, "").length;
+}
+function fitVisible(s, width) {
+  const w = Math.max(0, width);
+  const len = visLen(s);
+  if (len === w) return s;
+  if (len < w) return s + " ".repeat(w - len);
+  let visibleCount = 0;
+  let out = "";
+  let inAnsi = false;
+  for (let i = 0; i < s.length; i++) {
+    const char = s[i];
+    if (char === "\x1B") {
+      inAnsi = true;
+      out += char;
+    } else if (inAnsi) {
+      out += char;
+      if (char >= "a" && char <= "z" || char >= "A" && char <= "Z") {
+        inAnsi = false;
+      }
+    } else {
+      if (visibleCount < w) {
+        out += char;
+        visibleCount++;
+      } else {
+        break;
+      }
+    }
+  }
+  out += "\x1B[0m";
+  const resLen = visLen(out);
+  if (resLen < w) {
+    out += " ".repeat(w - resLen);
+  }
+  return out;
+}
+function truncatePlain(s, width) {
+  if (s.length <= width) return s;
+  return width <= 1 ? s.slice(0, width) : s.slice(0, width - 1) + "\u2026";
+}
+function panel(title, lines, width, accent, borderAccent, height, rightTitle) {
+  const h = height ?? lines.length;
+  const contentWidth = Math.max(1, width - 4);
+  const leftLabel = title ? ` ${title} ` : "";
+  const rightLabel = rightTitle ? ` ${rightTitle} ` : "";
+  const innerW = Math.max(0, width - 2);
+  let topInner = leftLabel + "\u2500".repeat(Math.max(0, innerW - visLen(leftLabel) - visLen(rightLabel))) + rightLabel;
+  if (visLen(topInner) > innerW) {
+    topInner = fitVisible(topInner, innerW);
+  } else if (visLen(topInner) < innerW) {
+    topInner = topInner + "\u2500".repeat(innerW - visLen(topInner));
+  }
+  const top = borderAccent("\u256D" + topInner + "\u256E");
+  const bottom = borderAccent("\u2570" + "\u2500".repeat(innerW) + "\u256F");
+  const body = [];
+  for (let i = 0; i < h; i++) {
+    const line = lines[i] ?? "";
+    body.push(`${borderAccent("\u2502")} ${fitVisible(line, contentWidth)} ${borderAccent("\u2502")}`);
+  }
+  return [top, ...body, bottom];
+}
+function gaugeBar(percent, width = 12) {
+  const w = Math.max(1, width);
+  const pct = Math.min(100, Math.max(0, percent));
+  const totalEighths = Math.round(pct / 100 * w * 8);
+  const fullBlocks = Math.floor(totalEighths / 8);
+  const remainder = totalEighths % 8;
+  const blocks = [" ", "\u258F", "\u258E", "\u258D", "\u258C", "\u258B", "\u258A", "\u2589", "\u2588"];
+  let str = "\u2588".repeat(fullBlocks);
+  if (fullBlocks < w && remainder > 0) {
+    str += blocks[remainder];
+  }
+  const empty = Math.max(0, w - visLen(str));
+  const color = pct > 85 ? chalk2.red : pct > 65 ? chalk2.yellow : chalk2.cyan;
+  return color(str) + chalk2.dim("\u2500".repeat(empty));
+}
+function hstack(blocks, gap = 2, targetWidth) {
+  if (!blocks.length) return [];
+  const height = Math.max(...blocks.map((b) => b.length));
+  const widths = blocks.map((b) => Math.max(0, ...b.map((l) => visLen(l))));
+  const padded = blocks.map((b, i) => {
+    const w = widths[i];
+    const filler = " ".repeat(w);
+    const arr = b.map((line) => fitVisible(line, w));
+    while (arr.length < height) arr.push(filler);
+    return arr;
+  });
+  const out = [];
+  for (let row = 0; row < height; row++) {
+    let line = padded.map((a) => a[row]).join(" ".repeat(gap));
+    if (targetWidth !== void 0) {
+      line = fitVisible(line, targetWidth);
+    }
+    out.push(line);
+  }
+  return out;
+}
+function statRow(label, value, width = 9) {
+  const w = Math.max(width, label.length + 1);
+  return `${chalk2.dim(label.padEnd(w))}${value}`;
+}
+function gaugeRow(label, percent, contentWidth) {
+  const labelW = 9;
+  const pctText = `${Math.round(percent)}%`;
+  const barW = Math.max(6, contentWidth - labelW - pctText.length - 1);
+  const pct = Math.min(100, Math.max(0, percent));
+  const totalEighths = Math.round(pct / 100 * barW * 8);
+  const fullBlocks = Math.floor(totalEighths / 8);
+  const remainder = totalEighths % 8;
+  const blocks = [" ", "\u258F", "\u258E", "\u258D", "\u258C", "\u258B", "\u258A", "\u2589", "\u2588"];
+  let str = "\u2588".repeat(fullBlocks);
+  if (fullBlocks < barW && remainder > 0) {
+    str += blocks[remainder];
+  }
+  const empty = Math.max(0, barW - visLen(str));
+  const color = pct > 90 ? chalk2.red : pct > 70 ? chalk2.yellow : chalk2.green;
+  return `${chalk2.dim(label.padEnd(labelW))}${color(str)}${chalk2.dim("\u2500".repeat(empty))} ${pctText}`;
+}
+function thermalColor(pressureLevel) {
+  const symbol = pressureLevel >= 3 ? "\u2715 " : pressureLevel >= 1 ? "\u26A0 " : "\u2713 ";
+  if (pressureLevel >= 3) return (s) => chalk2.red(symbol + s);
+  if (pressureLevel === 2) return (s) => chalk2.yellow(symbol + s);
+  if (pressureLevel === 1) return (s) => chalk2.yellowBright(symbol + s);
+  return (s) => chalk2.green(symbol + s);
+}
+function capacityColor(percent) {
+  const symbol = percent < 80 ? "\u2715 " : percent < 90 ? "\u26A0 " : "\u2713 ";
+  if (percent < 80) return (s) => chalk2.red(symbol + s);
+  if (percent < 90) return (s) => chalk2.yellow(symbol + s);
+  return (s) => chalk2.green(symbol + s);
+}
+function formatBytes(bytes) {
+  if (isNaN(bytes) || bytes < 0) return "0 B";
+  if (bytes < 1024) return `${Math.round(bytes)} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+function celsiusToFahrenheit(c) {
+  return c * (9 / 5) + 32;
+}
+function formatTemp(c) {
+  return `${c.toFixed(1)}\xB0C / ${celsiusToFahrenheit(c).toFixed(1)}\xB0F`;
+}
+function formatTempUnit(c, unit = "c") {
+  if (unit === "f") {
+    return `${(c * (9 / 5) + 32).toFixed(1)}\xB0F`;
+  }
+  return `${c.toFixed(1)}\xB0C`;
+}
+function cpuCard(data, contentWidth) {
+  const lines = [
+    statRow("Brand", truncatePlain(data.cpu.brand, Math.max(4, contentWidth - 8))),
+    statRow("Cores", `${data.cpu.physicalCores}/${data.cpu.cores} phys/log`),
+    statRow("Freq", `${data.cpu.frequency} MHz`),
+    gaugeRow("Usage", data.cpu.usage, contentWidth),
+    statRow("Load", data.cpu.loadAvg.map((l) => l.toFixed(2)).join(" "))
+  ];
+  if (data.cpu.clusters && data.cpu.clusters.length) {
+    for (const cl of data.cpu.clusters) {
+      lines.push(statRow(cl.name, `${cl.frequencyMhz} MHz \xB7 eff ${cl.effectiveUsagePercent}% \xB7 act ${cl.activeResidencyPercent}%`));
+    }
+  }
+  if (data.cpu.coreUsage && data.cpu.coreUsage.length) {
+    const slotW = 2;
+    const maxCores = Math.max(1, Math.floor((contentWidth - 10) / (slotW + 1)));
+    const cores = data.cpu.coreUsage.slice(0, maxCores);
+    const bars = cores.map((u) => {
+      const fill = Math.round(Math.min(100, u) / 100 * slotW);
+      const str = "\u2588".repeat(Math.max(0, fill)) + "\u2591".repeat(slotW - fill);
+      const color = u > 90 ? chalk2.red : u > 70 ? chalk2.yellow : chalk2.green;
+      return color(str);
+    });
+    lines.push(statRow("Cores", bars.join(" ")));
+  }
+  if (data.cpu.temperature) lines.push(statRow("Temp", formatTemp(data.cpu.temperature)));
+  return lines;
+}
+function memCard(data, contentWidth) {
+  return [
+    statRow("Total", formatBytes(data.memory.total)),
+    statRow("Used", formatBytes(data.memory.used)),
+    statRow("Cached", formatBytes(data.memory.total - data.memory.free - data.memory.used)),
+    statRow("Free", formatBytes(data.memory.free)),
+    gaugeRow("Usage", data.memory.usagePercent, contentWidth),
+    statRow("Swap", `${formatBytes(data.memory.swapUsed)} / ${formatBytes(data.memory.swapTotal)}`)
+  ];
+}
+function gpuCard(data, contentWidth) {
+  if (!data.gpu) return null;
+  const lines = [];
+  lines.push(statRow("Model", truncatePlain(data.gpu.model, Math.max(4, contentWidth - 8))));
+  lines.push(statRow("Memory", formatBytes(data.gpu.memory)));
+  lines.push(statRow("Util", `${data.gpu.utilization}%`));
+  if (data.gpu.temperature) lines.push(statRow("Temp", formatTemp(data.gpu.temperature)));
+  lines.push(statRow("Procs", String(data.gpu.processes)));
+  return lines;
+}
+function powerCard(data) {
+  const lines = [];
+  if (data.power) {
+    if (data.power.cpuWatts !== void 0) lines.push(statRow("CPU", `${data.power.cpuWatts.toFixed(2)} W`));
+    if (data.power.gpuWatts !== void 0) lines.push(statRow("GPU", `${data.power.gpuWatts.toFixed(2)} W`));
+    lines.push(statRow("ANE", `${(data.power.aneWatts ?? 0).toFixed(2)} W`));
+    if (data.power.combinedWatts !== void 0) lines.push(statRow("Total", `${data.power.combinedWatts.toFixed(2)} W`));
+  }
+  if (data.battery?.powerWatts !== void 0 && data.battery.powerWatts > 0) {
+    lines.push(statRow("Battery", `${data.battery.powerWatts.toFixed(2)} W`));
+  }
+  return lines.length ? lines : null;
+}
+function batteryCard(data, contentWidth) {
+  if (!data.battery) return null;
+  const valW = Math.max(6, contentWidth - 10);
+  const lines = [
+    statRow("Level", `${data.battery.level}%  (${data.battery.state})`),
+    statRow("Time", data.battery.timeRemaining),
+    statRow("Cycles", String(data.battery.cycles ?? "N/A")),
+    statRow("Condition", data.battery.condition ?? "N/A")
+  ];
+  if (data.battery.maxCapacityPercent !== void 0) {
+    lines.push(statRow("Capacity", capacityColor(data.battery.maxCapacityPercent)(`${data.battery.maxCapacityPercent}%`)));
+  }
+  lines.push(statRow("Source", data.battery.powerSource));
+  if (data.battery.estimatedTimeToEmpty && data.battery.state !== "charged") {
+    lines.push(statRow("Est. Empty", data.battery.estimatedTimeToEmpty));
+  }
+  if (data.battery.dischargeRatePerHour !== void 0 && data.battery.state !== "charged") {
+    lines.push(statRow("Disch. Rate", `${data.battery.dischargeRatePerHour}%/h`));
+  }
+  return lines;
+}
+function thermalCard(data, contentWidth) {
+  const valW = Math.max(6, contentWidth - 10);
+  const lines = [statRow("State", thermalColor(data.thermal.pressureLevel)(truncatePlain(data.thermal.state, valW)))];
+  if (data.thermal.temperatures) {
+    for (const [k, v] of Object.entries(data.thermal.temperatures)) {
+      lines.push(statRow(k.replace("_", " "), v !== null && v !== void 0 ? formatTemp(v) : "N/A"));
+    }
+  }
+  if (data.thermal.error) lines.push(statRow("Error", truncatePlain(data.thermal.error, valW)));
+  return lines;
+}
+function networkCard(data, contentWidth) {
+  const valW = Math.max(6, contentWidth - 8);
+  return [
+    statRow("Iface", truncatePlain(`${data.network.interface} (${data.network.ip})`, valW)),
+    statRow("RX", `${formatBytes(data.network.rxBytes)} / ${data.network.rxPackets} pkt`),
+    statRow("TX", `${formatBytes(data.network.txBytes)} / ${data.network.txPackets} pkt`)
+  ];
+}
+function tasksCard(data, contentWidth) {
+  if (!data.tasks || !data.tasks.length) return null;
+  const lines = [];
+  for (const task of data.tasks.slice(0, 6)) {
+    const cmd = truncatePlain(task.command, Math.max(4, contentWidth - 28));
+    lines.push(statRow(`${task.pid}`, `${task.user.padEnd(8)} ${task.cpu.toFixed(1).padStart(5)}% ${task.mem.toFixed(1).padStart(5)}% ${task.state} ${cmd}`));
+  }
+  return lines;
+}
+function header(data, width, badges = [], borderAccent = THEMES.default.border) {
+  const now = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+  const left = `${chalk2.hex("#ff5500").bold(" PYRE ")} ${chalk2.bold(data.header.hostname)}  ${chalk2.dim(data.header.os)}  ${chalk2.dim("up " + data.header.uptime)}`;
+  const right = `${chalk2.dim(now)}  ${badges.join("  ")}`;
+  const gap = Math.max(1, width - visLen(left) - visLen(right));
+  const line = fitVisible(left + " ".repeat(gap) + right, width);
+  return [line, borderAccent("\u2500".repeat(width))];
+}
+var TAB_DEFS = [
+  { id: "cpu", label: "CPU", key: "1" },
+  { id: "mem", label: "Memory", key: "2" },
+  { id: "gpu", label: "GPU", key: "3" },
+  { id: "power", label: "Power", key: "4" },
+  { id: "battery", label: "Battery", key: "5" },
+  { id: "thermal", label: "Thermal", key: "6" },
+  { id: "network", label: "Network", key: "7" },
+  { id: "packets", label: "Packets", key: "8" },
+  { id: "tasks", label: "Tasks", key: "9" },
+  { id: "disk", label: "Disk", key: "0" },
+  { id: "process", label: "Process", key: "P" },
+  { id: "p2p", label: "P2P", key: "R" },
+  { id: "anomalies", label: "Anomalies", key: "A" }
+];
+var TAB_BAR_INDENT = 2;
+var TAB_SEPARATOR_WIDTH = 3;
+function getTabHitboxes() {
+  const boxes = [];
+  let col = TAB_BAR_INDENT;
+  TAB_DEFS.forEach((t, i) => {
+    const text = `[${t.key}]${t.label}`;
+    const start = col;
+    const end = col + text.length;
+    boxes.push({ id: t.id, start, end });
+    col = end;
+    if (i < TAB_DEFS.length - 1) col += TAB_SEPARATOR_WIDTH;
+  });
+  return boxes;
+}
+var TAB_BAR_ROW = 4;
+function tabBar(activePanel, width, theme) {
+  const rendered = TAB_DEFS.map((t) => {
+    const isActive = activePanel === t.id;
+    const label = isActive ? chalk2.bold(t.label) : chalk2.dim(t.label);
+    const keyHint = chalk2.dim(`[${t.key}]`);
+    return `${keyHint}${label}`;
+  });
+  const separator = chalk2.dim(" \u2502 ");
+  const joined = rendered.join(separator);
+  const indent = "  ";
+  const available = width - visLen(indent);
+  let result = joined;
+  if (visLen(joined) > available) {
+    let used = 0;
+    const kept = [];
+    for (let i = 0; i < rendered.length; i++) {
+      const tabW = visLen(rendered[i]) + (kept.length > 0 ? visLen(separator) : 0);
+      if (used + tabW > available && kept.length > 0) break;
+      kept.push(rendered[i]);
+      used += tabW;
+    }
+    if (kept.length < rendered.length) {
+      result = kept.join(separator) + chalk2.dim("\u22EF");
+    }
+  }
+  const pad = Math.max(0, available - visLen(result));
+  return fitVisible(chalk2.dim(indent) + result + " ".repeat(pad), width);
+}
+function sortProcesses(processes, sortBy) {
+  const copy = [...processes];
+  switch (sortBy) {
+    case "pid":
+      return copy.sort((a, b) => a.pid - b.pid);
+    case "mem":
+      return copy.sort((a, b) => b.mem - a.mem);
+    case "user":
+      return copy.sort((a, b) => a.user.localeCompare(b.user));
+    case "command":
+      return copy.sort((a, b) => a.command.localeCompare(b.command));
+    case "state":
+      return copy.sort((a, b) => a.state.localeCompare(b.state));
+    case "threads":
+      return copy.sort((a, b) => b.threads - a.threads);
+    case "runtime":
+      return copy.sort((a, b) => b.runtime - a.runtime);
+    default:
+      return copy.sort((a, b) => b.cpu - a.cpu);
+  }
+}
+function pctColor(v) {
+  return v > 80 ? chalk2.red : v > 50 ? chalk2.yellow : chalk2.dim;
+}
+function processTableLines(processes, contentWidth, borderAccent = THEMES.default.border, selectedIdx = -1) {
+  const pidW = 8, ppidW = 8, userW = 12, cpuW = 8, memW = 8, stateW = 8, thrW = 6, rtW = 10;
+  const cmdW = Math.max(10, contentWidth - pidW - ppidW - userW - cpuW - memW - stateW - thrW - rtW - 8);
+  const head = chalk2.bold.hex("#f8f8f2").bgHex("#44475a")(" PID    ") + chalk2.bold.hex("#f8f8f2").bgHex("#44475a")(" PPID   ") + chalk2.bold.hex("#f8f8f2").bgHex("#44475a")(" USER       ") + chalk2.bold.hex("#f8f8f2").bgHex("#44475a")(" CPU%   ") + chalk2.bold.hex("#f8f8f2").bgHex("#44475a")(" MEM%   ") + chalk2.bold.hex("#f8f8f2").bgHex("#44475a")(" STATE   ") + chalk2.bold.hex("#f8f8f2").bgHex("#44475a")(" THREADS") + chalk2.bold.hex("#f8f8f2").bgHex("#44475a")(" RUNTIME  ") + chalk2.bold.hex("#f8f8f2").bgHex("#44475a")(" COMMAND".padEnd(cmdW + 1));
+  const rows = processes.map((p, idx) => {
+    const isSelected = idx === selectedIdx;
+    const cpuStr = pctColor(p.cpu)(`${p.cpu.toFixed(1)}`.padEnd(cpuW));
+    const memStr = pctColor(p.mem)(`${p.mem.toFixed(1)}`.padEnd(memW));
+    const stateStr = chalk2.dim(p.state.padEnd(stateW));
+    const thrStr = String(p.threads).padEnd(thrW);
+    const rtStr = formatRuntime(p.runtime).padEnd(rtW);
+    const line = String(p.pid).padEnd(pidW) + String(p.ppid).padEnd(ppidW) + truncatePlain(p.user, userW - 1).padEnd(userW) + cpuStr + memStr + stateStr + thrStr + rtStr + truncatePlain(p.command, cmdW);
+    return isSelected ? chalk2.bgCyan.black(line) : line;
+  });
+  return [head, borderAccent("\u2500".repeat(contentWidth)), ...rows];
+}
+function formatRuntime(seconds) {
+  if (seconds < 60) return `${seconds}s`;
+  const mins = Math.floor(seconds / 60);
+  if (mins < 60) return `${mins}m ${seconds % 60}s`;
+  const hrs = Math.floor(mins / 60);
+  return `${hrs}h ${mins % 60}m`;
+}
+function buildProcessTree(processes) {
+  const map = /* @__PURE__ */ new Map();
+  const roots = [];
+  for (const p of processes) map.set(p.pid, p);
+  for (const p of processes) {
+    if (p.ppid === 0 || !map.has(p.ppid)) roots.push(p);
+  }
+  const childrenMap = /* @__PURE__ */ new Map();
+  for (const p of processes) {
+    const list = childrenMap.get(p.ppid) || [];
+    list.push(p);
+    childrenMap.set(p.ppid, list);
+  }
+  for (const list of childrenMap.values()) {
+    list.sort((a, b) => b.cpu - a.cpu);
+  }
+  const lines = [];
+  const visited = /* @__PURE__ */ new Set();
+  function renderNode(proc, prefix, isLast) {
+    if (visited.has(proc.pid)) return;
+    visited.add(proc.pid);
+    const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const pidStr = String(proc.pid).padEnd(8);
+    const cpuStr = pctColor(proc.cpu)(`${proc.cpu.toFixed(1)}%`.padEnd(8));
+    const memStr = pctColor(proc.mem)(`${proc.mem.toFixed(1)}%`.padEnd(8));
+    const stateStr = chalk2.dim(proc.state.padEnd(8));
+    const thrStr = String(proc.threads).padEnd(6);
+    const cmd = truncatePlain(proc.command, Math.max(10, 100 - pidStr.length - cpuStr.length - memStr.length - stateStr.length - thrStr.length - 10));
+    lines.push(`${prefix}${connector}${pidStr}${cpuStr}${memStr}${stateStr}${thrStr} ${cmd}`);
+    const children = childrenMap.get(proc.pid);
+    if (children) {
+      let idx = 0;
+      let total = 0;
+      for (const c of children) {
+        if (!visited.has(c.pid)) total++;
+      }
+      for (const child of children) {
+        if (visited.has(child.pid)) continue;
+        const nextPrefix = prefix + (isLast ? "    " : "\u2502   ");
+        renderNode(child, nextPrefix, ++idx === total);
+      }
+    }
+  }
+  roots.sort((a, b) => b.cpu - a.cpu);
+  roots.forEach((root, i) => renderNode(root, "", i === roots.length - 1));
+  return lines;
+}
+function diskTableLines(disks, contentWidth, borderAccent = THEMES.default.border) {
+  const fsW = 20, sizeW = 10, usedW = 10, availW = 10, capW = 8;
+  const mountW = Math.max(8, contentWidth - fsW - sizeW - usedW - availW - capW - 5);
+  const head = chalk2.bold.hex("#f8f8f2").bgHex("#44475a")(" FILESYSTEM          ") + chalk2.bold.hex("#f8f8f2").bgHex("#44475a")(" SIZE      ") + chalk2.bold.hex("#f8f8f2").bgHex("#44475a")(" USED      ") + chalk2.bold.hex("#f8f8f2").bgHex("#44475a")(" AVAIL     ") + chalk2.bold.hex("#f8f8f2").bgHex("#44475a")(" CAP     ") + chalk2.bold.hex("#f8f8f2").bgHex("#44475a")(" MOUNT".padEnd(mountW + 1));
+  const rows = disks.map((d) => {
+    const capNum = parseInt(d.capacity, 10) || 0;
+    const capStr = pctColor(capNum)(d.capacity.padEnd(capW));
+    return truncatePlain(d.filesystem, fsW - 1).padEnd(fsW) + d.size.padEnd(sizeW) + d.used.padEnd(usedW) + d.available.padEnd(availW) + capStr + truncatePlain(d.mountpoint, mountW);
+  });
+  return [head, borderAccent("\u2500".repeat(contentWidth)), ...rows];
+}
+function detailPanelTitle(panel2, trackedPid) {
+  const map = {
+    cpu: "CPU",
+    mem: "Memory",
+    gpu: "GPU",
+    power: "Power",
+    battery: "Battery",
+    thermal: "Thermal",
+    network: "Network",
+    packets: "Packets",
+    tasks: "Tasks",
+    disk: "Disk",
+    process: trackedPid !== void 0 && trackedPid !== null ? `Processes (Following PID ${trackedPid})` : "Processes"
+  };
+  return map[panel2] || panel2;
+}
+function activeDetailLines(data, activePanel, width, opts = {}) {
+  const contentWidth = width - 4;
+  const themeName = opts.theme || "default";
+  const theme = THEMES[themeName] || THEMES.default;
+  switch (activePanel) {
+    case "cpu":
+      return cpuCard(data, contentWidth);
+    case "mem":
+      return memCard(data, contentWidth);
+    case "gpu": {
+      const gpu = gpuCard(data, contentWidth);
+      return gpu ?? ["No GPU data available"];
+    }
+    case "power": {
+      const power = powerCard(data);
+      if (!power && !data.battery) return ["No power data available"];
+      const lines = [];
+      if (power) lines.push(...power);
+      if (data.battery?.powerWatts !== void 0 && data.battery.powerWatts > 0) {
+        lines.push(statRow("Battery", `${data.battery.powerWatts.toFixed(2)} W`));
+      }
+      return lines.length ? lines : ["No power data available"];
+    }
+    case "battery":
+      return data.battery ? batteryCard(data, contentWidth) : ["No battery data available"];
+    case "thermal":
+      return thermalCard(data, contentWidth);
+    case "network":
+      return networkCard(data, contentWidth);
+    case "packets": {
+      if (!data.packets) return ["No packet data available"];
+      const lines = [];
+      lines.push(statRow("Total", `${data.packets.totalPackets} pkt`));
+      lines.push(statRow("RX", `${data.packets.rxPackets} pkt`));
+      lines.push(statRow("TX", `${data.packets.txPackets} pkt`));
+      lines.push(statRow("Conns", `${data.packets.connections} TCP`));
+      if (data.packets.interfaces && data.packets.interfaces.length) {
+        lines.push(statRow("Ifaces", `${data.packets.interfaces.length} active`));
+        for (const iface of data.packets.interfaces.slice(0, 8)) {
+          lines.push(statRow(`  ${iface.iface}`, `RX ${formatBytes(iface.rxBytes)} / TX ${formatBytes(iface.txBytes)}`));
+        }
+      }
+      if (data.packets.allProcesses && data.packets.allProcesses.length) {
+        lines.push(statRow("Net Procs", `${data.packets.allProcesses.length} total`));
+        for (const proc of data.packets.allProcesses.slice(0, 10)) {
+          lines.push(statRow(`  ${proc.pid}`, `${truncatePlain(proc.command, 20)}  TX ${formatBytes(proc.txBytes)}`));
+        }
+      }
+      return lines;
+    }
+    case "tasks":
+      return data.tasks?.length ? tasksCard(data, contentWidth) : ["No task data available"];
+    case "disk":
+      return data.disk.length ? diskTableLines(data.disk, width - 4, theme.border) : ["No disk data available"];
+    case "process": {
+      const filtered = opts.filter ? data.processes.filter((p) => p.command.toLowerCase().includes(opts.filter.toLowerCase())) : data.processes;
+      const sorted = sortProcesses(filtered, opts.sortBy ?? "cpu");
+      let selectedIdx = opts.selectedProcessIndex ?? -1;
+      const isTracking = opts.trackedPid !== void 0 && opts.trackedPid !== null;
+      if (isTracking) {
+        const trackedIdx = sorted.findIndex((p) => p.pid === opts.trackedPid);
+        if (trackedIdx >= 0) {
+          selectedIdx = trackedIdx;
+        }
+      }
+      const trackingLines = [];
+      if (isTracking) {
+        const tp = sorted.find((p) => p.pid === opts.trackedPid);
+        if (tp) {
+          const cpuColor = tp.cpu > 50 ? chalk2.red.bold : tp.cpu > 20 ? chalk2.yellow : chalk2.green;
+          const memColor = tp.mem > 50 ? chalk2.red.bold : tp.mem > 20 ? chalk2.yellow : chalk2.green;
+          trackingLines.push(chalk2.bgHex("#1a1a2e").hex("#e94560").bold(` \u25C9 FOLLOWING PID ${tp.pid} \u2014 ${truncatePlain(tp.command, Math.max(10, contentWidth - 30))} `));
+          trackingLines.push(
+            `  ${chalk2.bold("CPU:")} ${cpuColor(tp.cpu.toFixed(1) + "%")}   ${chalk2.bold("MEM:")} ${memColor(tp.mem.toFixed(1) + "%")}   ${chalk2.bold("State:")} ${chalk2.dim(tp.state)}   ${chalk2.bold("Threads:")} ${tp.threads}   ${chalk2.bold("Runtime:")} ${formatRuntime(tp.runtime)}   ${chalk2.bold("User:")} ${tp.user}`
+          );
+          trackingLines.push(chalk2.dim(`  Full: ${tp.command}`));
+          trackingLines.push(theme.border("\u2500".repeat(contentWidth)));
+        } else {
+          trackingLines.push(chalk2.yellow(` \u25C9 PID ${opts.trackedPid} exited \u2014 no longer in process list`));
+          trackingLines.push(theme.border("\u2500".repeat(contentWidth)));
+        }
+      }
+      const availableRows = Math.max(1, (opts.processLimit || sorted.length) - trackingLines.length);
+      let offset = 0;
+      if (selectedIdx >= 0) {
+        if (selectedIdx >= availableRows) {
+          offset = selectedIdx - availableRows + 1;
+        }
+      }
+      const visible = sorted.slice(offset, offset + availableRows);
+      if (opts.treeView) {
+        return [...trackingLines, ...buildProcessTree(visible)];
+      }
+      return [...trackingLines, ...processTableLines(visible, width - 4, theme.border, selectedIdx - offset)];
+    }
+    case "anomalies": {
+      if (!opts.anomalyHistory || opts.anomalyHistory.length === 0) return ["No anomalies detected yet."];
+      const lines = [];
+      const sorted = [...opts.anomalyHistory].sort((a, b) => (b.timestamp?.getTime() || 0) - (a.timestamp?.getTime() || 0));
+      for (const a of sorted) {
+        const color = a.severity === "critical" ? chalk2.red.bold : chalk2.yellow;
+        const direction = a.zScore > 0 ? "\u2191 spike" : "\u2193 drop";
+        const valStr = a.metric.toLowerCase().includes("net") ? `${formatBytes(a.value)}/s` : `${a.value.toFixed(1)}%`;
+        const timeStr = a.timestamp ? a.timestamp.toLocaleTimeString() : "";
+        lines.push(color(` ${timeStr.padEnd(10)} \u26A0 ${a.metric.padEnd(8)}: ${valStr.padEnd(12)} (${direction}, \u03C3=${a.zScore.toFixed(1)})`));
+      }
+      return lines;
+    }
+    default:
+      return null;
+  }
+}
+function anomalyPanel(anomalies, width, theme) {
+  const lines = [];
+  for (const a of anomalies) {
+    const color = a.severity === "critical" ? chalk2.red.bold : chalk2.yellow;
+    const direction = a.zScore > 0 ? "\u2191 spike" : "\u2193 drop";
+    const valStr = a.metric.toLowerCase().includes("net") ? `${formatBytes(a.value)}/s` : `${a.value.toFixed(1)}%`;
+    lines.push(color(` \u26A0 ${a.metric}: ${valStr} (${direction}, \u03C3=${a.zScore.toFixed(1)})`));
+  }
+  return lines;
+}
+function btopCpuBox(data, width, theme, opts) {
+  const contentWidth = width - 4;
+  const rightTitle = `${data.header.hostname} \xB7 up ${data.header.uptime} \xB7 ${data.cpu.usage.toFixed(0)}%`;
+  if (contentWidth >= 65) {
+    const leftW = Math.floor(contentWidth * 0.48);
+    const rightW = contentWidth - leftW - 2;
+    const leftLines = [];
+    const cpuHistory = opts.history?.cpuUsage || [];
+    let historyLabel = "CPU Usage History";
+    if (cpuHistory.length > 0) {
+      const avg = Math.round(cpuHistory.reduce((a, b) => a + b, 0) / cpuHistory.length);
+      const max = Math.round(Math.max(...cpuHistory));
+      historyLabel += ` (avg ${avg}% \xB7 max ${max}%)`;
+    }
+    leftLines.push(fitVisible(theme.cpu(historyLabel), leftW));
+    if (cpuHistory.length > 1) {
+      const graphRows = multiRowBrailleGraph(cpuHistory, 3, { min: 0, max: 100 });
+      for (const gr of graphRows) {
+        leftLines.push(theme.cpu(fitVisible(gr, leftW)));
+      }
+    } else {
+      leftLines.push(theme.cpu(fitVisible(gaugeBar(data.cpu.usage, leftW), leftW)));
+      leftLines.push(" ".repeat(leftW));
+      leftLines.push(" ".repeat(leftW));
+    }
+    const rightLines = [];
+    rightLines.push(fitVisible(chalk2.bold(truncatePlain(data.cpu.brand, rightW)), rightW));
+    const cpuBarW = Math.max(6, rightW - 18);
+    const tempStr = data.cpu.temperature ? formatTempUnit(data.cpu.temperature, opts.tempUnit) : "";
+    rightLines.push(fitVisible(`CPU ${gaugeBar(data.cpu.usage, cpuBarW)} ${data.cpu.usage.toFixed(0).padStart(3)}% ${tempStr}`, rightW));
+    const loadStr = data.cpu.loadAvg.map((l) => l.toFixed(2)).join(" ");
+    rightLines.push(fitVisible(`${chalk2.dim("Load:")} ${loadStr}`, rightW));
+    if (data.cpu.coreUsage && data.cpu.coreUsage.length) {
+      const coreColW = Math.floor((rightW - 1) / 2);
+      const half = Math.ceil(data.cpu.coreUsage.length / 2);
+      for (let i = 0; i < half; i++) {
+        const u1 = data.cpu.coreUsage[i];
+        const u2 = data.cpu.coreUsage[i + half];
+        const c1BarW = Math.max(3, coreColW - 8);
+        const c1Str = `C${i} ${gaugeBar(u1, c1BarW)} ${Math.round(u1)}%`;
+        const c2Str = u2 !== void 0 ? `C${i + half} ${gaugeBar(u2, c1BarW)} ${Math.round(u2)}%` : "";
+        rightLines.push(fitVisible(fitVisible(c1Str, coreColW) + " " + fitVisible(c2Str, coreColW), rightW));
+      }
+    }
+    if (data.gpu) {
+      rightLines.push(fitVisible(`GPU ${gaugeBar(data.gpu.utilization, cpuBarW)} ${data.gpu.utilization}% ${formatBytes(data.gpu.memory)}`, rightW));
+    }
+    const combinedBody = hstack([leftLines, rightLines], 2, contentWidth);
+    return panel("1 cpu", combinedBody, width, theme.cpu, theme.border, combinedBody.length, rightTitle);
+  } else {
+    const lines = [];
+    lines.push(chalk2.bold(truncatePlain(data.cpu.brand, contentWidth)));
+    lines.push(`CPU ${gaugeBar(data.cpu.usage, Math.max(4, contentWidth - 12))} ${data.cpu.usage.toFixed(0)}%`);
+    if (opts.history?.cpuUsage.length) {
+      const gMode = opts.graphMode || "spark";
+      const gStr = gMode === "bar" ? sparkline(opts.history.cpuUsage, { min: 0, max: 100 }) : brailleGraph(opts.history.cpuUsage, { min: 0, max: 100 });
+      lines.push(theme.cpu(gStr));
+    }
+    lines.push(`Load: ${data.cpu.loadAvg.map((l) => l.toFixed(2)).join(" ")}`);
+    return panel("1 cpu", lines, width, theme.cpu, theme.border, lines.length, rightTitle);
+  }
+}
+function btopLeftColumn(data, width, theme, opts) {
+  const contentWidth = width - 4;
+  const out = [];
+  const layout = opts.panelLayout || ["mem", "disk", "net"];
+  for (const panelName of layout) {
+    if (panelName === "mem") {
+      const memLines = [];
+      memLines.push(`RAM [${gaugeBar(data.memory.usagePercent, Math.max(4, contentWidth - 12))}] ${data.memory.usagePercent}%`);
+      memLines.push(`Used: ${formatBytes(data.memory.used)} / ${formatBytes(data.memory.total)}`);
+      memLines.push(`Free: ${formatBytes(data.memory.free)} \xB7 Cache: ${formatBytes(data.memory.total - data.memory.free - data.memory.used)}`);
+      if (data.memory.swapTotal > 0) {
+        const swapPct = Math.round(data.memory.swapUsed / data.memory.swapTotal * 100);
+        memLines.push(`Swap [${gaugeBar(swapPct, Math.max(4, contentWidth - 12))}] ${swapPct}%`);
+      }
+      out.push(...panel("2 mem", memLines, width, theme.mem, theme.border, memLines.length, `${formatBytes(data.memory.used)}`));
+    } else if (panelName === "disk" && data.disk.length) {
+      const diskLines = [];
+      for (const d of data.disk.slice(0, 2)) {
+        const capNum = parseInt(d.capacity, 10) || 0;
+        const mountShort = truncatePlain(d.mountpoint, 8);
+        let ioStr = "";
+        if (d.readBytesSec !== void 0 || d.writeBytesSec !== void 0) {
+          const rStr = formatBytes(d.readBytesSec || 0);
+          const wStr = formatBytes(d.writeBytesSec || 0);
+          ioStr = ` R:${rStr}/s W:${wStr}/s`;
+        }
+        diskLines.push(`${mountShort} ${d.used}/${d.size} [${gaugeBar(capNum, Math.max(3, contentWidth - 18 - ioStr.length))}] ${d.capacity}${ioStr}`);
+      }
+      const totalRead = data.disk.reduce((acc, d) => acc + (d.readBytesSec || 0), 0);
+      const totalWrite = data.disk.reduce((acc, d) => acc + (d.writeBytesSec || 0), 0);
+      const diskHeaderRight = `R:${formatBytes(totalRead)}/s W:${formatBytes(totalWrite)}/s`;
+      out.push(...panel("0 disk io", diskLines, width, theme.disk, theme.border, diskLines.length, diskHeaderRight));
+    } else if (panelName === "net") {
+      const netLines = [];
+      const rxRate = opts.history?.netRxRate.length ? opts.history.netRxRate[opts.history.netRxRate.length - 1] : 0;
+      const txRate = opts.history?.netTxRate.length ? opts.history.netTxRate[opts.history.netTxRate.length - 1] : 0;
+      netLines.push(`down \u25BC ${formatBytes(rxRate)}/s (${formatBytes(data.network.rxBytes)})`);
+      if (opts.history?.netRxRate.length) {
+        const gMode = opts.graphMode || "spark";
+        const gStr = gMode === "bar" ? sparkline(opts.history.netRxRate, {}) : brailleGraph(opts.history.netRxRate, {});
+        netLines.push(chalk2.cyan(fitVisible(gStr, contentWidth)));
+      }
+      netLines.push(`up   \u25B2 ${formatBytes(txRate)}/s (${formatBytes(data.network.txBytes)})`);
+      if (opts.history?.netTxRate.length) {
+        const gMode = opts.graphMode || "spark";
+        const gStr = gMode === "bar" ? sparkline(opts.history.netTxRate, {}) : brailleGraph(opts.history.netTxRate, {});
+        netLines.push(theme.network(fitVisible(gStr, contentWidth)));
+      }
+      out.push(...panel("7 net", netLines, width, theme.network, theme.border, netLines.length, `${data.network.interface}`));
+    }
+  }
+  return out;
+}
+function btopProcBox(data, width, targetHeight, theme, opts) {
+  const contentWidth = width - 4;
+  const filtered = opts.filter ? data.processes.filter((p) => p.command.toLowerCase().includes(opts.filter.toLowerCase())) : data.processes;
+  const sorted = sortProcesses(filtered, opts.sortBy ?? "cpu");
+  const headerRowOverhead = 2;
+  const tableHeaderOverhead = 2;
+  const isTracking = opts.trackedPid !== void 0 && opts.trackedPid !== null;
+  const trackingLines = [];
+  if (isTracking) {
+    const tp = sorted.find((p) => p.pid === opts.trackedPid);
+    if (tp) {
+      const cpuColor = tp.cpu > 50 ? chalk2.red.bold : tp.cpu > 20 ? chalk2.yellow : chalk2.green;
+      const memColor = tp.mem > 50 ? chalk2.red.bold : tp.mem > 20 ? chalk2.yellow : chalk2.green;
+      trackingLines.push(chalk2.bgHex("#1a1a2e").hex("#e94560").bold(` \u25C9 PID ${tp.pid} ${truncatePlain(tp.command, Math.max(6, contentWidth - 20))} `));
+      trackingLines.push(
+        ` ${cpuColor("CPU " + tp.cpu.toFixed(1) + "%")} ${memColor("MEM " + tp.mem.toFixed(1) + "%")} ${chalk2.dim(tp.state)} THR:${tp.threads} ${formatRuntime(tp.runtime)}`
+      );
+      trackingLines.push(theme.border("\u2500".repeat(contentWidth)));
+    } else {
+      trackingLines.push(chalk2.yellow(` \u25C9 PID ${opts.trackedPid} exited`));
+      trackingLines.push(theme.border("\u2500".repeat(contentWidth)));
+    }
+  }
+  const availableRows = Math.max(1, targetHeight - headerRowOverhead - tableHeaderOverhead - trackingLines.length);
+  let selectedIdx = opts.selectedProcessIndex ?? -1;
+  if (isTracking) {
+    const trackedIdx = sorted.findIndex((p) => p.pid === opts.trackedPid);
+    if (trackedIdx >= 0) {
+      selectedIdx = trackedIdx;
+    }
+  }
+  let offset = 0;
+  if (selectedIdx >= 0) {
+    if (selectedIdx >= availableRows) {
+      offset = selectedIdx - availableRows + 1;
+    }
+  }
+  const visible = sorted.slice(offset, offset + availableRows);
+  const pidW = 6, userW = 7, thrW = 3, memW = 6, cpuW = 6;
+  const fixedW = pidW + userW + thrW + memW + cpuW + 5;
+  const cmdW = Math.max(8, contentWidth - fixedW);
+  const head = chalk2.bold("PID".padEnd(pidW)) + " " + chalk2.bold("PROGRAM".padEnd(cmdW)) + " " + chalk2.bold("USER".padEnd(userW)) + " " + chalk2.bold("THR".padStart(thrW)) + " " + chalk2.bold("MEM%".padStart(memW)) + " " + chalk2.bold("CPU%".padStart(cpuW));
+  if (opts.treeView) {
+    const treeLines = buildProcessTree(visible);
+    let rightTitle2 = opts.filter ? `filter: "${opts.filter}"` : `tree \xB7 sort: ${opts.sortBy || "cpu"}`;
+    if (isTracking) rightTitle2 += ` \xB7 following PID ${opts.trackedPid}`;
+    return panel("P proc", [...trackingLines, head, theme.border("\u2500".repeat(contentWidth)), ...treeLines], width, theme.process, theme.border, targetHeight - 2, rightTitle2);
+  }
+  const rows = visible.map((p, idx) => {
+    const isSelected = offset + idx === selectedIdx;
+    const cpuVal = p.cpu.toFixed(1) + "%";
+    const cpuStr = p.cpu > 50 ? chalk2.red.bold(cpuVal.padStart(cpuW)) : p.cpu > 20 ? chalk2.yellow(cpuVal.padStart(cpuW)) : chalk2.green(cpuVal.padStart(cpuW));
+    const memStr = (p.mem.toFixed(1) + "%").padStart(memW);
+    const userStr = truncatePlain(p.user, userW).padEnd(userW);
+    const thrStr = String(p.threads).padStart(thrW);
+    const pidStr = String(p.pid).padEnd(pidW);
+    const cmdStr = truncatePlain(p.command, cmdW).padEnd(cmdW);
+    const line = `${pidStr} ${cmdStr} ${userStr} ${thrStr} ${memStr} ${cpuStr}`;
+    return isSelected ? chalk2.bgCyan.black(line) : line;
+  });
+  const lines = [...trackingLines, head, theme.border("\u2500".repeat(contentWidth)), ...rows];
+  if (rows.length === 0) {
+    lines.push(chalk2.dim(`No processes match "${opts.filter || ""}"`));
+  }
+  let rightTitle = opts.filter ? `filter: "${opts.filter}"` : `sort: ${opts.sortBy || "cpu"}`;
+  if (isTracking) {
+    rightTitle += ` \xB7 following PID ${opts.trackedPid}`;
+  }
+  return panel("P proc", lines, width, theme.process, theme.border, targetHeight - 2, rightTitle);
+}
+function formatTable(data, opts = {}) {
+  const width = clampWidth(opts.width);
+  const activePanel = opts.activePanel || "grid";
+  const themeName = opts.theme || "default";
+  const theme = THEMES[themeName] || THEMES.default;
+  const out = [];
+  out.push(...header(data, width, [], theme.border));
+  out.push("");
+  const anomalies = opts.anomalies ?? [];
+  if (anomalies.length && activePanel === "grid") {
+    out.push(...anomalyPanel(anomalies, width, theme));
+    out.push("");
+  }
+  out.push(tabBar(activePanel, width, theme));
+  out.push("");
+  if (opts.minimal) {
+    const contentWidth = width - 4;
+    const lines = [];
+    lines.push(gaugeRow("CPU", data.cpu.usage, contentWidth));
+    lines.push(gaugeRow("Memory", data.memory.usagePercent, contentWidth));
+    if (data.gpu) {
+      lines.push(gaugeRow("GPU", data.gpu.utilization, contentWidth));
+    }
+    const tempC = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die;
+    if (tempC !== void 0) {
+      const tempStr = formatTempUnit(tempC, opts.tempUnit);
+      lines.push(statRow("Temp", thermalColor(data.thermal.pressureLevel)(tempStr)));
+    }
+    out.push(...panel("macmon mode", lines, width, theme.cpu, theme.border));
+    return out.join("\n");
+  }
+  if (activePanel !== "grid") {
+    const lines = activeDetailLines(data, activePanel, width, opts);
+    if (lines) {
+      out.push(...panel(detailPanelTitle(activePanel, opts.trackedPid), lines, width, theme[activePanel] ?? theme.cpu, theme.border));
+    }
+  } else {
+    out.push(...btopCpuBox(data, width, theme, opts));
+    out.push("");
+    if (width >= 85) {
+      const leftColW = Math.max(32, Math.floor(width * 0.38));
+      const rightColW = width - leftColW - 2;
+      const leftLines = btopLeftColumn(data, leftColW, theme, opts);
+      const procLines = btopProcBox(data, rightColW, leftLines.length, theme, opts);
+      out.push(...hstack([leftLines, procLines], 2, width));
+    } else {
+      const leftLines = btopLeftColumn(data, width, theme, opts);
+      out.push(...leftLines);
+      out.push("");
+      const procLines = btopProcBox(data, width, 12, theme, opts);
+      out.push(...procLines);
+    }
+  }
+  return out.join("\n");
+}
+function clampWidth(width) {
+  if (!width || Number.isNaN(width)) return 80;
+  return Math.max(40, Math.min(width, 240));
+}
+
+export {
+  sparkline,
+  THEMES,
+  visLen,
+  fitVisible,
+  panel,
+  formatBytes,
+  celsiusToFahrenheit,
+  getTabHitboxes,
+  TAB_BAR_ROW,
+  formatTable
+};