@xynogen/pix-pretty 1.7.16 → 1.7.17

package/README.md

@@ -9,9 +9,10 @@ consume. It does not register user-facing tools itself — the tool renderers
 (`pix-read`, `pix-bash`, `pix-ls`, `pix-find`, `pix-grep`, `pix-edit`,
 `pix-write`) import from it. The extension entry point (`src/index.ts`) only
 initializes the syntax-highlight theme from Pi settings, clears the highlight
-cache, registers the `/pretty` icon-style switch, and registers two FFF slash
+cache, seeds the icon mode from `pix.json`, and registers two FFF slash
 commands (`/fff-health`, `/fff-rescan`) once `pix-grep` has brought the FFF
-finder online. (Activated by `pix-core`; not a standalone extension.)
+finder online. The `/pix` settings command lives in `pix-data`.
+(Activated by `pix-core`; not a standalone extension.)
 
 ### Rendering
 
@@ -33,12 +34,12 @@ problem on terminals without a Nerd Font, becomes a one-file edit here.
   mode. Modes: `nerd` (Nerd Font PUA, default), `unicode` (standard BMP glyphs,
   no patched font needed), `ascii` (plain letters). Also `iconFor(key, mode)`,
   `getIconMode()`, `setIconMode()`, `ICON_KEYS`, `ICON_MODES`.
-- **`./icon-persist`** — stores the mode in `~/.pi/agent/pretty.json`;
-  `initIconMode()` applies it on load.
-- **`/pretty`** — the single switch: an overlay that previews each mode's
-  glyphs live and persists the choice. One global knob governs every pix-*
-  package (footer, paste chips, model picker, welcome banner, optimizer cell).
-  Seeded from `PRETTY_ICONS` (`none`/`off` → `ascii`) when no choice is saved.
+- **`./icon-persist`** — reads/writes the icon mode via `pix.json`
+  (`pretty.icons`); `initIconMode()` applies it on load.
+- **`/pix`** (in `pix-data`) — unified settings overlay that includes the icon
+  mode switch. One global knob governs every pix-* package (footer, paste
+  chips, model picker, welcome banner, optimizer cell). Seeded from
+  `PRETTY_ICONS` (`none`/`off` → `ascii`) when no choice is saved.
 
 ### Shared overlay
 
@@ -70,7 +71,7 @@ Configuration is read from **`~/.pi/agent/pix.json`** (the unified config file h
 ```jsonc
 {
   "pretty": {
-    "theme": "monokai",       // syntax-highlight theme
+    "syntaxTheme": "monokai",       // syntax-highlight theme
     "icons": "nerd",          // nerd | unicode | ascii
     "maxPreviewLines": 50,
     "diffColors": true
@@ -85,8 +86,9 @@ Configuration is read from **`~/.pi/agent/pix.json`** (the unified config file h
 - `PRETTY_MAX_PREVIEW_LINES` — max lines in preview output
 - `PRETTY_CACHE_LIMIT` — FFF cache size limit
 - `PRETTY_ICONS` — default icon mode when none is persisted: `nerd` (default),
-  `unicode`, `ascii`, or `none`/`off` (→ `ascii`). Overridden by `/pretty`.
+  `unicode`, `ascii`, or `none`/`off` (→ `ascii`).
   Note: this seeds the file-icon helpers AND the semantic icon catalog.
+  Overridden by the `/pix` settings command.
 - `PRETTY_MAX_RENDER_LINES` — max lines in edit/write diff render (default: 150)
 - `PRETTY_FFF_DIR` — override FFF state dir (default: `~/.cache/pi/fff`)
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-pretty",
-	"version": "1.7.16",
+	"version": "1.7.17",
 	"description": "Enhanced tool output rendering with syntax highlighting, file icons, tree views, diff rendering, and FFF search",
 	"type": "module",
 	"main": "src/index.ts",

package/src/config.ts

@@ -1,47 +1,4 @@
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
 import { pixConfig } from "@xynogen/pix-data/pix-config";
-import type { BundledTheme } from "./types.js";
-
-const DEFAULT_THEME: BundledTheme = "github-dark";
-
-export function getDefaultAgentDir(): string | undefined {
-	const home = process.env.HOME ?? "";
-	return home ? join(home, ".pi/agent") : undefined;
-}
-
-function readThemeFromSettings(agentDir?: string): BundledTheme | undefined {
-	const resolvedAgentDir = agentDir ?? getDefaultAgentDir();
-	if (!resolvedAgentDir) return undefined;
-
-	try {
-		const settings = JSON.parse(readFileSync(join(resolvedAgentDir, "settings.json"), "utf8")) as {
-			theme?: unknown;
-		};
-		return typeof settings.theme === "string" ? (settings.theme as BundledTheme) : undefined;
-	} catch {
-		return undefined;
-	}
-}
-
-function resolvePrettyTheme(agentDir?: string): BundledTheme {
-	// Precedence: env → pix.json → settings.json → default
-	return (
-		(process.env.PRETTY_THEME as BundledTheme | undefined) ??
-		(pixConfig().pretty.theme as BundledTheme) ??
-		readThemeFromSettings(agentDir) ??
-		DEFAULT_THEME
-	);
-}
-
-export let THEME: BundledTheme = resolvePrettyTheme();
-
-export function setPrettyTheme(agentDir?: string): void {
-	const resolvedTheme = resolvePrettyTheme(agentDir);
-	if (resolvedTheme === THEME) return;
-	THEME = resolvedTheme;
-}
 
 export function envInt(name: string, fallback: number): number {
 	const v = Number.parseInt(process.env[name] ?? "", 10);

package/src/highlight.ts

@@ -1,5 +1,5 @@
 import { normalizeShikiContrast } from "./ansi.js";
-import { CACHE_LIMIT, MAX_HL_CHARS, THEME } from "./config.js";
+import { CACHE_LIMIT, MAX_HL_CHARS } from "./config.js";
 import type { BundledLanguage } from "./types.js";
 
 // Engine: cli-highlight (highlight.js-backed, synchronous ANSI output).
@@ -88,7 +88,7 @@ export async function hlBlock(
 	const hljsLang = toHljsLang(language);
 	if (!hljsLang) return code.split("\n");
 
-	const k = `${THEME}\0${hljsLang}\0${code}`;
+	const k = `${hljsLang}\0${code}`;
 	const hit = _cache.get(k);
 	if (hit) return _touch(k, hit);
 

package/src/icon-catalog.ts

@@ -10,16 +10,16 @@
  *   mode:     "nerd" | "unicode" | "ascii"       (the "locale")
  *   icon(k):  catalog[k][mode]                    (the "t(key)")
  *
- * One global mode governs the whole stack. It is switched via the `/pretty`
- * command (see pretty-command.ts), persisted to ~/.pi/agent/pretty.json, and
- * seeded from the PRETTY_ICONS env var on first load.
+ * One global mode governs the whole stack. It is switched via the `/pix`
+ * settings command (in pix-data), persisted to `~/.pi/agent/pix.json`
+ * (`pretty.icons`), and seeded from the PRETTY_ICONS env var on first load.
  *
  * Why a catalog instead of per-package toggles: reskinning or fixing a
  * missing-glyph ("tofu") problem becomes a one-file edit here, and there is
  * exactly ONE knob (the mode) rather than one env var per package.
  */
 
-/** Presentation modes, in /pretty cycle order. nerd = Nerd Font PUA glyphs. */
+/** Presentation modes, in /pix settings cycle order. nerd = Nerd Font PUA glyphs. */
 export type IconMode = "nerd" | "unicode" | "ascii";
 
 /** All modes in cycle order. */
@@ -85,12 +85,12 @@ const CATALOG = {
 /** Every valid semantic icon key. */
 export type IconKey = keyof typeof CATALOG;
 
-/** All catalog keys (useful for /pretty previews and tests). */
+/** All catalog keys (useful for /pix previews and tests). */
 export const ICON_KEYS = Object.keys(CATALOG) as IconKey[];
 
 /**
  * Active mode. Seeded from PRETTY_ICONS env (back-compat: none/off => ascii),
- * then overridden by a persisted choice when the host loads pretty.json.
+ * then overridden by a persisted choice when the host loads pix.json.
  */
 function envMode(): IconMode {
 	const raw = (process.env.PRETTY_ICONS ?? "").toLowerCase();
@@ -123,7 +123,7 @@ export function onIconModeChange(cb: ModeListener): () => void {
 
 /**
  * Set the global icon mode (does NOT persist — callers that want persistence
- * use pretty-command.ts, which writes pretty.json then calls this). Fires
+ * use the /pix command, which writes pix.json then calls this). Fires
  * subscribers only on an actual change (no-op re-sets are ignored).
  */
 export function setIconMode(mode: IconMode): void {
@@ -141,7 +141,7 @@ export function icon(key: IconKey): string {
 	return entry ? entry[activeMode] : "";
 }
 
-/** Resolve a key for an explicit mode (used by /pretty previews + tests). */
+/** Resolve a key for an explicit mode (used by /pix previews + tests). */
 export function iconFor(key: IconKey, mode: IconMode): string {
 	const entry = CATALOG[key];
 	return entry ? entry[mode] : "";

package/src/icon-persist.test.ts

@@ -2,17 +2,25 @@ import { afterAll, afterEach, beforeAll, describe, expect, it } from "bun:test";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { reloadPixConfig } from "@xynogen/pix-data/pix-config";
 import { getIconMode, setIconMode } from "./icon-catalog.ts";
 import { initIconMode, loadIconMode, saveIconMode } from "./icon-persist.ts";
 
 let tmpAgentDir: string;
+let origHome: string | undefined;
 
 beforeAll(() => {
 	tmpAgentDir = mkdtempSync(join(tmpdir(), "pretty-persist-test-"));
+	origHome = process.env.HOME;
+	// Point HOME at the temp dir so pixConfig() reads from there, not the real ~/.pi/agent/pix.json
+	process.env.HOME = tmpAgentDir;
 	process.env.PI_CODING_AGENT_DIR = tmpAgentDir;
+	// Force pix-config to re-read from the temp HOME (clears cached real config).
+	reloadPixConfig();
 });
 
 afterAll(() => {
+	process.env.HOME = origHome;
 	delete process.env.PI_CODING_AGENT_DIR;
 	try {
 		rmSync(tmpAgentDir, { recursive: true });
@@ -24,8 +32,8 @@ afterAll(() => {
 describe("icon-persist", () => {
 	afterEach(() => setIconMode("nerd"));
 
-	it("returns undefined before anything is saved", () => {
-		expect(loadIconMode()).toBeUndefined();
+	it("returns default (nerd) in a fresh config", () => {
+		expect(loadIconMode()).toBe("nerd");
 	});
 
 	it("round-trips a mode across save/load (new-session sim)", () => {

package/src/icon-persist.ts

@@ -1,37 +1,25 @@
 /**
  * icon-persist.ts — disk persistence for the global icon mode.
  *
- * Stores the single icon mode in ~/.pi/agent/pretty.json so a choice made via
- * /pretty survives quit/restart. Kept separate from icon-catalog.ts so the
- * catalog resolver stays pure (no fs) and trivially testable.
+ * Reads/writes the icon mode via the unified pix.json config
+ * (`~/.pi/agent/pix.json` → `pretty.icons`). Kept separate from
+ * icon-catalog.ts so the catalog resolver stays pure (no fs) and trivially
+ * testable.
  *
- *   ~/.pi/agent/pretty.json  ->  { "icons": "unicode" }
- *
- * Precedence: a persisted value wins; otherwise the catalog's env-seeded
- * default (PRETTY_ICONS) stands.
+ * Precedence: env PRETTY_ICONS → pix.json pretty.icons → default ("nerd")
  */
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
-import { pixConfig } from "@xynogen/pix-data/pix-config";
+import { onPixConfigChange, pixConfig, savePixConfig } from "@xynogen/pix-data/pix-config";
 import { ICON_MODES, type IconMode, setIconMode } from "./icon-catalog.js";
 
 function isIconMode(m: string): m is IconMode {
 	return (ICON_MODES as readonly string[]).includes(m);
 }
 
-function statePath(): string {
-	return join(getAgentDir(), "pretty.json");
-}
-
-/** Read the persisted icon mode, or undefined if unset/invalid/missing. */
+/** Read the persisted icon mode from pix.json, or undefined if unset/invalid. */
 export function loadIconMode(): IconMode | undefined {
 	try {
-		const p = statePath();
-		if (!existsSync(p)) return undefined;
-		const raw = JSON.parse(readFileSync(p, "utf-8")) as { icons?: string };
-		const mode = raw?.icons;
+		const mode = pixConfig().pretty.icons;
 		if (mode == null) return undefined;
 		return isIconMode(mode) ? mode : undefined;
 	} catch {
@@ -39,38 +27,28 @@ export function loadIconMode(): IconMode | undefined {
 	}
 }
 
-/** Persist the icon mode, merging into pretty.json. */
+/** Persist the icon mode to pix.json (`pretty.icons`). */
 export function saveIconMode(mode: IconMode): void {
 	try {
-		const p = statePath();
-		mkdirSync(dirname(p), { recursive: true });
-		let existing: Record<string, unknown> = {};
-		if (existsSync(p)) {
-			try {
-				existing = JSON.parse(readFileSync(p, "utf-8")) as Record<string, unknown>;
-			} catch {
-				existing = {};
-			}
-		}
-		writeFileSync(p, JSON.stringify({ ...existing, icons: mode }, null, 2));
+		savePixConfig({ pretty: { icons: mode } });
 	} catch (err) {
 		console.warn("pix-pretty: persist icon mode failed:", err);
 	}
 }
 
 /**
- * Apply the persisted mode (if any) to the catalog. Called once at extension
- * load so the env-seeded default is overridden by the user's saved choice.
+ * Apply the persisted mode (if any) to the catalog and subscribe to live
+ * changes from the /pix settings command. Called once at extension load.
  *
- * Precedence: env PRETTY_ICONS → pretty.json → pix.json pretty.icons → default ("nerd")
+ * Precedence: env PRETTY_ICONS → pix.json pretty.icons → default ("nerd")
  */
 export function initIconMode(): void {
-	const saved = loadIconMode();
-	if (saved) {
-		setIconMode(saved);
-		return;
-	}
-	// No persisted choice — try pix.json
 	const pixIcons = pixConfig().pretty.icons;
 	if (pixIcons && isIconMode(pixIcons)) setIconMode(pixIcons);
+
+	// Keep the in-memory icon mode in sync when /pix changes pretty.icons.
+	onPixConfigChange((cfg) => {
+		const mode = cfg.pretty.icons;
+		if (mode && isIconMode(mode)) setIconMode(mode);
+	});
 }

package/src/index.ts

@@ -8,33 +8,19 @@
  * UI features (paste chips, thinking blocks) live in pix-display.
  */
 
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { registerFffCommands } from "./commands/fff.js";
-import { registerPrettyCommand } from "./commands/pretty.js";
-import { getDefaultAgentDir, setPrettyTheme } from "./config.js";
 import { fffState } from "./fff.js";
 import { clearHighlightCache } from "./highlight.js";
 import { initIconMode } from "./icon-persist.js";
 import type { PiPrettyApi } from "./types.js";
 
 export default function piPrettyExtension(pi: PiPrettyApi): void {
-	// ── Theme init ──────────────────────────────────────────────────────
-	setPrettyTheme(
-		(() => {
-			try {
-				return getAgentDir?.() ?? getDefaultAgentDir();
-			} catch {
-				return getDefaultAgentDir();
-			}
-		})(),
-	);
 	clearHighlightCache();
 
 	// ── Icon mode ───────────────────────────────────────────
-	// Seed the global icon mode from pretty.json (overrides env default), then
-	// register the single /pretty switch.
+	// Seed the global icon mode from pix.json (overrides env default).
+	// The /pix settings command lives in pix-data.
 	initIconMode();
-	registerPrettyCommand(pi);
 
 	// ── FFF slash commands ──────────────────────────────────────────────
 	// fffState is a module-level singleton shared with pix-grep/pix-find.

package/src/renderers.ts

@@ -1,4 +1,5 @@
-import { truncateToWidth } from "@earendil-works/pi-tui";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { getLsStyle } from "@xynogen/pix-data/pix-config";
 
 import { BOLD, FG_BLUE, FG_DIM, FG_GREEN, FG_RED, FG_RULE, FG_YELLOW, RST } from "./ansi.js";
 import { MAX_PREVIEW_LINES } from "./config.js";
@@ -71,8 +72,13 @@ export function renderBashOutput(
 	return { summary: codeStr, body };
 }
 
-/** Render ls output as a tree view with icons. */
-export function renderTree(text: string, _basePath: string): string {
+/** Render ls output using the configured style (grid or tree). */
+export function renderTree(text: string, basePath: string): string {
+	return getLsStyle() === "tree" ? renderLsTree(text, basePath) : renderLsGrid(text, basePath);
+}
+
+/** Vertical tree view with connectors and icons. */
+function renderLsTree(text: string, _basePath: string): string {
 	const lines = text.trim().split("\n").filter(Boolean);
 	if (!lines.length) return `${FG_DIM}(empty directory)${RST}`;
 
@@ -86,7 +92,6 @@ export function renderTree(text: string, _basePath: string): string {
 		const prefix = isLast ? "└── " : "├── ";
 		const connector = `${FG_RULE}${prefix}${RST}`;
 
-		// Detect directories (entries ending with /)
 		const isDir = entry.endsWith("/");
 		const name = isDir ? entry.slice(0, -1) : entry;
 		const icon = isDir ? dirIcon() : fileIcon(name);
@@ -105,6 +110,109 @@ export function renderTree(text: string, _basePath: string): string {
 	return out.join("\n");
 }
 
+/** Horizontal grid with icons (like eza/ls). */
+function renderLsGrid(text: string, _basePath: string): string {
+	const lines = text.trim().split("\n").filter(Boolean);
+	if (!lines.length) return `${FG_DIM}(empty directory)${RST}`;
+
+	const total = lines.length;
+	const show = lines.slice(0, MAX_PREVIEW_LINES);
+
+	// Build styled cells + measure their visible widths
+	const cells: string[] = [];
+	const cellWidths: number[] = [];
+
+	for (const raw of show) {
+		const entry = raw.trim();
+		const isDir = entry.endsWith("/");
+		const name = isDir ? entry.slice(0, -1) : entry;
+		const icon = isDir ? dirIcon() : fileIcon(name);
+		const fg = isDir ? FG_BLUE + BOLD : "";
+		const reset = isDir ? RST : "";
+		const cell = `${icon}${fg}${name}${reset}`;
+		cells.push(cell);
+		cellWidths.push(visibleWidth(cell));
+	}
+
+	// Layout into columns that fit the terminal width
+	const tw = termW();
+	const GAP = 3; // spaces between columns
+	const rows = layoutGrid(cells, cellWidths, tw, GAP);
+
+	if (total > MAX_PREVIEW_LINES) {
+		rows.push(
+			`${FG_DIM}… ${pluralize(total - MAX_PREVIEW_LINES, "more entry", "more entries")}${RST}`,
+		);
+	}
+
+	return rows.join("\n");
+}
+
+/**
+ * Lay out styled cells into a grid that fills rows left-to-right,
+ * using as many columns as fit within `maxWidth`.
+ */
+function layoutGrid(cells: string[], widths: number[], maxWidth: number, gap: number): string[] {
+	const n = cells.length;
+	if (n === 0) return [];
+
+	// Try increasing column counts to find the maximum that fits
+	let bestCols = 1;
+	for (let cols = 2; cols <= n; cols++) {
+		const numRows = Math.ceil(n / cols);
+		let totalW = 0;
+		let fits = true;
+		for (let c = 0; c < cols; c++) {
+			// Find max width in this column
+			let colW = 0;
+			for (let r = 0; r < numRows; r++) {
+				const idx = r * cols + c;
+				if (idx < n && (widths[idx] ?? 0) > colW) colW = widths[idx] ?? 0;
+			}
+			totalW += colW + (c < cols - 1 ? gap : 0);
+			if (totalW > maxWidth) {
+				fits = false;
+				break;
+			}
+		}
+		if (fits) bestCols = cols;
+		else break;
+	}
+
+	const cols = bestCols;
+	const numRows = Math.ceil(n / cols);
+
+	// Compute column widths
+	const colWidths: number[] = [];
+	for (let c = 0; c < cols; c++) {
+		let colW = 0;
+		for (let r = 0; r < numRows; r++) {
+			const idx = r * cols + c;
+			if (idx < n && (widths[idx] ?? 0) > colW) colW = widths[idx] ?? 0;
+		}
+		colWidths.push(colW);
+	}
+
+	// Render rows
+	const out: string[] = [];
+	for (let r = 0; r < numRows; r++) {
+		const parts: string[] = [];
+		for (let c = 0; c < cols; c++) {
+			const idx = r * cols + c;
+			if (idx >= n) break;
+			const cell = cells[idx] ?? "";
+			const w = widths[idx] ?? 0;
+			const target = colWidths[c] ?? 0;
+			// Pad to column width, except for the last column in a row
+			const pad = c < cols - 1 ? " ".repeat(Math.max(0, target - w + gap)) : "";
+			parts.push(cell + pad);
+		}
+		out.push(parts.join(""));
+	}
+
+	return out;
+}
+
 // ---------------------------------------------------------------------------
 // FFF integration (optional) — Fast File Finder with frecency & SIMD search
 //

package/src/commands/pretty.ts

@@ -1,132 +0,0 @@
-/**
- * pretty.ts — the `/pretty` command: switch the global icon mode.
- *
- * Treats icons like an l10n locale: one global mode (nerd/unicode/ascii)
- * governs every pix-* package that renders via the icon catalog. This command
- * is the single switch — an overlay that previews each mode's glyphs live and
- * persists the choice to ~/.pi/agent/pretty.json. Headless hosts get a notify
- * fallback that cycles the mode without UI.
- */
-
-import {
-	getIconMode,
-	ICON_MODES,
-	type IconKey,
-	type IconMode,
-	icon,
-	setIconMode,
-} from "../icon-catalog.js";
-import { saveIconMode } from "../icon-persist.js";
-import { frameLines } from "../modal-frame.js";
-import type { CommandContextLike, PiPrettyApi } from "../types.js";
-
-/** Sample keys shown in the preview, one row per representative role. */
-const PREVIEW: { key: IconKey; label: string }[] = [
-	{ key: "model", label: "model" },
-	{ key: "cwd", label: "cwd" },
-	{ key: "lsp", label: "lsp" },
-	{ key: "paste.image", label: "paste" },
-	{ key: "opt.caveman", label: "optimizer" },
-];
-
-/** Apply + persist a mode in one step. */
-function applyMode(mode: IconMode): void {
-	setIconMode(mode);
-	saveIconMode(mode);
-}
-
-export function registerPrettyCommand(pi: PiPrettyApi): void {
-	pi.registerCommand("pretty", {
-		description: "pix-pretty: switch icon style (nerd / unicode / ascii)",
-		handler: async (_args: string, ctx: CommandContextLike) => {
-			const ui = ctx.ui as unknown as {
-				theme: {
-					fg(c: string, t: string): string;
-					bg(c: string, t: string): string;
-					bold(t: string): string;
-				};
-				custom?: <T>(
-					f: unknown,
-					opts?: {
-						overlay?: boolean;
-						overlayOptions?: {
-							anchor?: string;
-							width?: number;
-							maxHeight?: string;
-						};
-					},
-				) => Promise<T>;
-				notify(m: string, t?: "info" | "warning" | "error"): void;
-			};
-
-			// Headless / no custom-UI host: cycle to the next mode + notify.
-			if (typeof ui.custom !== "function") {
-				const cur = ICON_MODES.indexOf(getIconMode());
-				const next = ICON_MODES[(cur + 1) % ICON_MODES.length] ?? "nerd";
-				applyMode(next);
-				ui.notify(`pix-pretty icons: ${next}`, "info");
-				return;
-			}
-
-			const boxW = 40;
-
-			await ui.custom<null>(
-				(
-					tui: { requestRender(): void },
-					theme: typeof ui.theme,
-					_kb: unknown,
-					done: (v: null) => void,
-				) => {
-					let selected = ICON_MODES.indexOf(getIconMode());
-					if (selected < 0) selected = 0;
-
-					const choose = (i: number) => {
-						selected = (i + ICON_MODES.length) % ICON_MODES.length;
-						applyMode(ICON_MODES[selected] ?? "nerd");
-					};
-
-					return {
-						render: () => {
-							const rows = ICON_MODES.map((mode, i) => {
-								const sel = i === selected;
-								const cursor = sel ? theme.fg("accent", "→") : " ";
-								const name = theme.fg(sel ? "accent" : "text", mode.padEnd(8));
-								// Live preview: render the sample glyphs in THIS mode.
-								const prev = ICON_MODES[i] === getIconMode();
-								const samples = prev ? PREVIEW.map((p) => icon(p.key)).join(" ") : "";
-								return `${cursor} ${name} ${theme.fg("dim", samples)}`;
-							});
-							const lines = [
-								theme.fg("accent", theme.bold("  Icon style")),
-								"",
-								...rows,
-								"",
-								theme.fg("dim", "↑↓ select · esc close"),
-							];
-							return frameLines({
-								width: boxW,
-								lines,
-								color: (s) => theme.fg("accent", s),
-								bg: (s) => theme.bg("customMessageBg", s),
-							});
-						},
-						invalidate: () => {},
-						handleInput: (data: string) => {
-							if (data === "k" || data === "\u001b[A") choose(selected - 1);
-							else if (data === "j" || data === "\u001b[B") choose(selected + 1);
-							else if (data === "\u001b" || data === "q" || data === "\r") {
-								done(null);
-								return;
-							} else return;
-							tui.requestRender();
-						},
-					};
-				},
-				{
-					overlay: true,
-					overlayOptions: { anchor: "center", width: boxW, maxHeight: "60%" },
-				},
-			);
-		},
-	});
-}