@mks2508/better-logger 0.14.0-alpha.2 → 0.18.2-alpha.2

package/dist/chunks/spinner-BtkwpzYv.js

@@ -0,0 +1,982 @@
+import { a as getTerminalWidth } from "./environment-detector-7NvnYUfr.js";
+//#region src/terminal/color-converter.ts
+const ANSI_16_COLORS = {
+	black: {
+		fg: "30",
+		bg: "40",
+		bright: {
+			fg: "90",
+			bg: "100"
+		}
+	},
+	red: {
+		fg: "31",
+		bg: "41",
+		bright: {
+			fg: "91",
+			bg: "101"
+		}
+	},
+	green: {
+		fg: "32",
+		bg: "42",
+		bright: {
+			fg: "92",
+			bg: "102"
+		}
+	},
+	yellow: {
+		fg: "33",
+		bg: "43",
+		bright: {
+			fg: "93",
+			bg: "103"
+		}
+	},
+	blue: {
+		fg: "34",
+		bg: "44",
+		bright: {
+			fg: "94",
+			bg: "104"
+		}
+	},
+	magenta: {
+		fg: "35",
+		bg: "45",
+		bright: {
+			fg: "95",
+			bg: "105"
+		}
+	},
+	cyan: {
+		fg: "36",
+		bg: "46",
+		bright: {
+			fg: "96",
+			bg: "106"
+		}
+	},
+	white: {
+		fg: "37",
+		bg: "47",
+		bright: {
+			fg: "97",
+			bg: "107"
+		}
+	},
+	gray: {
+		fg: "90",
+		bg: "100",
+		bright: {
+			fg: "37",
+			bg: "47"
+		}
+	},
+	grey: {
+		fg: "90",
+		bg: "100",
+		bright: {
+			fg: "37",
+			bg: "47"
+		}
+	}
+};
+const CSS_NAMED_COLORS = {
+	aliceblue: "#f0f8ff",
+	antiquewhite: "#faebd7",
+	aqua: "#00ffff",
+	aquamarine: "#7fffd4",
+	azure: "#f0ffff",
+	beige: "#f5f5dc",
+	bisque: "#ffe4c4",
+	black: "#000000",
+	blanchedalmond: "#ffebcd",
+	blue: "#0000ff",
+	blueviolet: "#8a2be2",
+	brown: "#a52a2a",
+	burlywood: "#deb887",
+	cadetblue: "#5f9ea0",
+	chartreuse: "#7fff00",
+	chocolate: "#d2691e",
+	coral: "#ff7f50",
+	cornflowerblue: "#6495ed",
+	cornsilk: "#fff8dc",
+	crimson: "#dc143c",
+	cyan: "#00ffff",
+	darkblue: "#00008b",
+	darkcyan: "#008b8b",
+	darkgoldenrod: "#b8860b",
+	darkgray: "#a9a9a9",
+	darkgreen: "#006400",
+	darkkhaki: "#bdb76b",
+	darkmagenta: "#8b008b",
+	darkolivegreen: "#556b2f",
+	darkorange: "#ff8c00",
+	darkorchid: "#9932cc",
+	darkred: "#8b0000",
+	darksalmon: "#e9967a",
+	darkseagreen: "#8fbc8f",
+	darkslateblue: "#483d8b",
+	darkslategray: "#2f4f4f",
+	darkturquoise: "#00ced1",
+	darkviolet: "#9400d3",
+	deeppink: "#ff1493",
+	deepskyblue: "#00bfff",
+	dimgray: "#696969",
+	dodgerblue: "#1e90ff",
+	firebrick: "#b22222",
+	floralwhite: "#fffaf0",
+	forestgreen: "#228b22",
+	fuchsia: "#ff00ff",
+	gainsboro: "#dcdcdc",
+	ghostwhite: "#f8f8ff",
+	gold: "#ffd700",
+	goldenrod: "#daa520",
+	gray: "#808080",
+	green: "#008000",
+	greenyellow: "#adff2f",
+	honeydew: "#f0fff0",
+	hotpink: "#ff69b4",
+	indianred: "#cd5c5c",
+	indigo: "#4b0082",
+	ivory: "#fffff0",
+	khaki: "#f0e68c",
+	lavender: "#e6e6fa",
+	lavenderblush: "#fff0f5",
+	lawngreen: "#7cfc00",
+	lemonchiffon: "#fffacd",
+	lightblue: "#add8e6",
+	lightcoral: "#f08080",
+	lightcyan: "#e0ffff",
+	lightgoldenrodyellow: "#fafad2",
+	lightgray: "#d3d3d3",
+	lightgreen: "#90ee90",
+	lightpink: "#ffb6c1",
+	lightsalmon: "#ffa07a",
+	lightseagreen: "#20b2aa",
+	lightskyblue: "#87cefa",
+	lightslategray: "#778899",
+	lightsteelblue: "#b0c4de",
+	lightyellow: "#ffffe0",
+	lime: "#00ff00",
+	limegreen: "#32cd32",
+	linen: "#faf0e6",
+	magenta: "#ff00ff",
+	maroon: "#800000",
+	mediumaquamarine: "#66cdaa",
+	mediumblue: "#0000cd",
+	mediumorchid: "#ba55d3",
+	mediumpurple: "#9370db",
+	mediumseagreen: "#3cb371",
+	mediumslateblue: "#7b68ee",
+	mediumspringgreen: "#00fa9a",
+	mediumturquoise: "#48d1cc",
+	mediumvioletred: "#c71585",
+	midnightblue: "#191970",
+	mintcream: "#f5fffa",
+	mistyrose: "#ffe4e1",
+	moccasin: "#ffe4b5",
+	navajowhite: "#ffdead",
+	navy: "#000080",
+	oldlace: "#fdf5e6",
+	olive: "#808000",
+	olivedrab: "#6b8e23",
+	orange: "#ffa500",
+	orangered: "#ff4500",
+	orchid: "#da70d6",
+	palegoldenrod: "#eee8aa",
+	palegreen: "#98fb98",
+	paleturquoise: "#afeeee",
+	palevioletred: "#db7093",
+	papayawhip: "#ffefd5",
+	peachpuff: "#ffdab9",
+	peru: "#cd853f",
+	pink: "#ffc0cb",
+	plum: "#dda0dd",
+	powderblue: "#b0e0e6",
+	purple: "#800080",
+	rebeccapurple: "#663399",
+	red: "#ff0000",
+	rosybrown: "#bc8f8f",
+	royalblue: "#4169e1",
+	saddlebrown: "#8b4513",
+	salmon: "#fa8072",
+	sandybrown: "#f4a460",
+	seagreen: "#2e8b57",
+	seashell: "#fff5ee",
+	sienna: "#a0522d",
+	silver: "#c0c0c0",
+	skyblue: "#87ceeb",
+	slateblue: "#6a5acd",
+	slategray: "#708090",
+	snow: "#fffafa",
+	springgreen: "#00ff7f",
+	steelblue: "#4682b4",
+	tan: "#d2b48c",
+	teal: "#008080",
+	thistle: "#d8bfd8",
+	tomato: "#ff6347",
+	turquoise: "#40e0d0",
+	violet: "#ee82ee",
+	wheat: "#f5deb3",
+	white: "#ffffff",
+	whitesmoke: "#f5f5f5",
+	yellow: "#ffff00",
+	yellowgreen: "#9acd32"
+};
+function hexToRgb(hex) {
+	const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+	if (!result || !result[1] || !result[2] || !result[3]) return {
+		r: 255,
+		g: 255,
+		b: 255
+	};
+	return {
+		r: parseInt(result[1], 16),
+		g: parseInt(result[2], 16),
+		b: parseInt(result[3], 16)
+	};
+}
+function rgbToHex(r, g, b) {
+	return "#" + [
+		r,
+		g,
+		b
+	].map((x) => x.toString(16).padStart(2, "0")).join("");
+}
+function colorToHex(color) {
+	if (color.startsWith("#")) return color;
+	const named = CSS_NAMED_COLORS[color.toLowerCase()];
+	if (named) return named;
+	const rgbMatch = color.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)/);
+	if (rgbMatch && rgbMatch[1] && rgbMatch[2] && rgbMatch[3]) return rgbToHex(parseInt(rgbMatch[1]), parseInt(rgbMatch[2]), parseInt(rgbMatch[3]));
+	return "#ffffff";
+}
+function getANSIForeground(color, capability) {
+	if (capability === "none") return "";
+	const lowerColor = color.toLowerCase();
+	if (capability === "basic" && ANSI_16_COLORS[lowerColor]) return `\x1b[${ANSI_16_COLORS[lowerColor].fg}m`;
+	if (capability === "basic") {
+		const nearestBasic = findNearestBasicColor(colorToHex(color));
+		const basicColor = ANSI_16_COLORS[nearestBasic];
+		return basicColor ? `\x1b[${basicColor.fg}m` : "\x1B[37m";
+	}
+	const { r, g, b } = hexToRgb(colorToHex(color));
+	return `\x1b[38;2;${r};${g};${b}m`;
+}
+function getANSIBackground(color, capability) {
+	if (capability === "none") return "";
+	const lowerColor = color.toLowerCase();
+	if (capability === "basic" && ANSI_16_COLORS[lowerColor]) return `\x1b[${ANSI_16_COLORS[lowerColor].bg}m`;
+	if (capability === "basic") {
+		const nearestBasic = findNearestBasicColor(colorToHex(color));
+		const basicColor = ANSI_16_COLORS[nearestBasic];
+		return basicColor ? `\x1b[${basicColor.bg}m` : "\x1B[47m";
+	}
+	const { r, g, b } = hexToRgb(colorToHex(color));
+	return `\x1b[48;2;${r};${g};${b}m`;
+}
+function findNearestBasicColor(hex) {
+	const { r, g, b } = hexToRgb(hex);
+	const basicColors = {
+		black: {
+			r: 0,
+			g: 0,
+			b: 0
+		},
+		red: {
+			r: 205,
+			g: 0,
+			b: 0
+		},
+		green: {
+			r: 0,
+			g: 205,
+			b: 0
+		},
+		yellow: {
+			r: 205,
+			g: 205,
+			b: 0
+		},
+		blue: {
+			r: 0,
+			g: 0,
+			b: 238
+		},
+		magenta: {
+			r: 205,
+			g: 0,
+			b: 205
+		},
+		cyan: {
+			r: 0,
+			g: 205,
+			b: 205
+		},
+		white: {
+			r: 229,
+			g: 229,
+			b: 229
+		}
+	};
+	let nearest = "white";
+	let minDistance = Infinity;
+	for (const [name, rgb] of Object.entries(basicColors)) {
+		const distance = Math.sqrt(Math.pow(r - rgb.r, 2) + Math.pow(g - rgb.g, 2) + Math.pow(b - rgb.b, 2));
+		if (distance < minDistance) {
+			minDistance = distance;
+			nearest = name;
+		}
+	}
+	return nearest;
+}
+const ANSI = {
+	reset: "\x1B[0m",
+	bold: "\x1B[1m",
+	dim: "\x1B[2m",
+	italic: "\x1B[3m",
+	underline: "\x1B[4m",
+	blink: "\x1B[5m",
+	inverse: "\x1B[7m",
+	hidden: "\x1B[8m",
+	strikethrough: "\x1B[9m",
+	fg: {
+		black: "\x1B[30m",
+		red: "\x1B[31m",
+		green: "\x1B[32m",
+		yellow: "\x1B[33m",
+		blue: "\x1B[34m",
+		magenta: "\x1B[35m",
+		cyan: "\x1B[36m",
+		white: "\x1B[37m",
+		gray: "\x1B[90m",
+		brightRed: "\x1B[91m",
+		brightGreen: "\x1B[92m",
+		brightYellow: "\x1B[93m",
+		brightBlue: "\x1B[94m",
+		brightMagenta: "\x1B[95m",
+		brightCyan: "\x1B[96m",
+		brightWhite: "\x1B[97m"
+	},
+	bg: {
+		black: "\x1B[40m",
+		red: "\x1B[41m",
+		green: "\x1B[42m",
+		yellow: "\x1B[43m",
+		blue: "\x1B[44m",
+		magenta: "\x1B[45m",
+		cyan: "\x1B[46m",
+		white: "\x1B[47m",
+		gray: "\x1B[100m",
+		brightRed: "\x1B[101m",
+		brightGreen: "\x1B[102m",
+		brightYellow: "\x1B[103m",
+		brightBlue: "\x1B[104m",
+		brightMagenta: "\x1B[105m",
+		brightCyan: "\x1B[106m",
+		brightWhite: "\x1B[107m"
+	},
+	rgb: (r, g, b) => `\x1b[38;2;${r};${g};${b}m`,
+	bgRgb: (r, g, b) => `\x1b[48;2;${r};${g};${b}m`,
+	color256: (n) => `\x1b[38;5;${n}m`,
+	bgColor256: (n) => `\x1b[48;5;${n}m`
+};
+//#endregion
+//#region src/terminal/formatter.ts
+function stripAnsi(str) {
+	return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function getVisibleLength(str) {
+	return stripAnsi(str).length;
+}
+function padToWidth(str, width, align = "left") {
+	const visibleLen = getVisibleLength(str);
+	if (visibleLen >= width) return str;
+	const padding = width - visibleLen;
+	switch (align) {
+		case "right": return " ".repeat(padding) + str;
+		case "center":
+			const leftPad = Math.floor(padding / 2);
+			const rightPad = padding - leftPad;
+			return " ".repeat(leftPad) + str + " ".repeat(rightPad);
+		default: return str + " ".repeat(padding);
+	}
+}
+function formatBadge(badge, style = "brackets", colorCapability = "full", color) {
+	const reset = colorCapability !== "none" ? ANSI.reset : "";
+	const text = badge.toUpperCase();
+	switch (style) {
+		case "rounded":
+			const colorCode1 = color && colorCapability !== "none" ? getANSIForeground(color, colorCapability) : "";
+			return `${colorCapability !== "none" ? ANSI.bg.black : ""}${colorCode1}⟨${text}⟩${reset}`;
+		case "plain": return `${color && colorCapability !== "none" ? getANSIForeground(color, colorCapability) : ""}${text}${reset}`;
+		case "unicode":
+			const colorCode3 = color && colorCapability !== "none" ? getANSIForeground(color, colorCapability) : "";
+			return `${colorCapability !== "none" ? ANSI.bg.black : ""}${colorCode3}╭${text}╮${reset}`;
+		case "pill": return `${color && colorCapability !== "none" ? getANSIBackground(color, colorCapability) : ""}${colorCapability !== "none" ? getANSIForeground("#000000", colorCapability) : ""}[${text}]${reset}`;
+		default:
+			const colorCode5 = color && colorCapability !== "none" ? getANSIForeground(color, colorCapability) : "";
+			return `${colorCapability !== "none" ? ANSI.bg.black : ""}${colorCode5}[${text}]${reset}`;
+	}
+}
+//#endregion
+//#region src/playground/step.ts
+/**
+* @fileoverview Step progress renderer for CLI primitives
+*/
+/**
+* Renderiza un indicador de progreso de step con el formato `  [n/total] msg`,
+* donde el `[n/total]` se emite en cian bold (respetando `colorCap`) para
+* destacarlo del mensaje descriptivo. Pensado para output secuencial de CLI
+* tipo "steps de un build", "fases de un deploy" o "tareas de un script".
+*
+* No hace ningún chequeo de rango sobre `current`/`total` — el caller es
+* responsable de pasar valores coherentes (se renderizan tal cual).
+*
+* @param current - Número de step actual (típicamente 1-based).
+* @param total - Total de steps del proceso.
+* @param msg - Descripción corta del step en curso.
+* @param colorCap - Capacidad de color del terminal destino. Si es `'none'`,
+*   el label `[n/total]` se emite sin color.
+* @returns String de una sola línea con formato `  [n/total] msg`.
+*
+* @example
+* ```ts
+* const steps = ['Resolving deps', 'Bundling', 'Writing dist'];
+* steps.forEach((step, i) => {
+*   process.stdout.write(renderStep(i + 1, steps.length, step, 'full') + '\n');
+* });
+* //   [1/3] Resolving deps
+* //   [2/3] Bundling
+* //   [3/3] Writing dist
+* ```
+*/
+function renderStep(current, total, msg, colorCap) {
+	const label = `[${current}/${total}]`;
+	return `  ${colorCap !== "none" ? getANSIForeground("#00bcd4", colorCap) + ANSI.bold + label + ANSI.reset : label} ${msg}`;
+}
+//#endregion
+//#region src/playground/header.ts
+/**
+* @fileoverview Header renderer for CLI primitives
+*/
+/**
+* Renderiza un header de sección: `title` en bold seguido opcionalmente de
+* `subtitle` en dim (ANSI `2`), ideal para marcar bloques en output de CLI.
+* No usa colores de foreground — sólo atributos de texto, así que el renderer
+* es seguro para cualquier terminal sin importar la paleta del theme activo.
+*
+* @param title - Texto principal del header (siempre en bold).
+* @param subtitle - Texto secundario a la derecha del título; se renderiza
+*   dimmed y separado por un espacio. Omitir si no aplica.
+* @returns String de una línea con formato `  <bold>title</bold> <dim>subtitle</dim>`.
+*
+* @example
+* ```ts
+* process.stdout.write(renderHeader('Deploy', 'production · us-east-1') + '\n');
+* //   **Deploy** production · us-east-1   (con atributos ANSI aplicados)
+* ```
+*
+* @example
+* ```ts
+* // Header sin subtítulo
+* process.stdout.write(renderHeader('Build summary') + '\n');
+* ```
+*/
+function renderHeader(title, subtitle) {
+	return `  ${ANSI.bold + title + ANSI.reset}${subtitle ? ANSI.dim + ` ${subtitle}` + ANSI.reset : ""}`;
+}
+//#endregion
+//#region src/playground/divider.ts
+/**
+* @fileoverview Divider renderer for CLI primitives
+*/
+/**
+* Renderiza una línea divisoria horizontal dimmed (ANSI `2`) usando el
+* caracter `─`. Por defecto el ancho es `min(terminalWidth - 4, 60)` para
+* no ocupar todo el ancho de ventana y quedar visualmente alineado con otros
+* primitives (box, header, table) que dejan 2 espacios de indentación.
+*
+* @param width - Ancho explícito en columnas visibles. Si se omite, se calcula
+*   automáticamente a partir del ancho del terminal (capped a 60).
+* @returns String de una línea con `width` caracteres `─` envueltos en ANSI dim.
+*
+* @example
+* ```ts
+* // Divider automático (respeta el ancho del terminal)
+* process.stdout.write(renderDivider() + '\n');
+* ```
+*
+* @example
+* ```ts
+* // Divider de ancho fijo para alinear con otra salida
+* process.stdout.write(renderDivider(40) + '\n');
+* ```
+*
+* @see {@link getTerminalWidth} para la detección de ancho cuando `width` se omite.
+*/
+function renderDivider(width) {
+	const w = width ?? Math.min(getTerminalWidth() - 4, 60);
+	return ANSI.dim + "  " + "─".repeat(w) + ANSI.reset;
+}
+//#endregion
+//#region src/playground/box.ts
+/**
+* Mapa de juegos de caracteres Unicode para los 4 estilos de borde soportados
+* por {@link renderBox}. Cada entrada expone las 4 esquinas (`tl`, `tr`, `bl`,
+* `br`), el caracter horizontal (`h`) y el vertical (`v`) que componen el marco.
+*
+* - `single`: l\u00edneas finas (U+2500 / U+2502).
+* - `rounded`: igual que `single` con esquinas redondeadas.
+* - `double`: l\u00edneas dobles (U+2550 / U+2551), alto contraste visual.
+* - `bold`: l\u00edneas gruesas (U+2501 / U+2503), para destacar bloques cr\u00edticos.
+*
+* @internal Lookup interno del renderer; no es API p\u00fablica.
+*/
+const BORDER_CHARS = {
+	single: {
+		tl: "┌",
+		tr: "┐",
+		bl: "└",
+		br: "┘",
+		h: "─",
+		v: "│"
+	},
+	rounded: {
+		tl: "╭",
+		tr: "╮",
+		bl: "╰",
+		br: "╯",
+		h: "─",
+		v: "│"
+	},
+	double: {
+		tl: "╔",
+		tr: "╗",
+		bl: "╚",
+		br: "╝",
+		h: "═",
+		v: "║"
+	},
+	bold: {
+		tl: "┏",
+		tr: "┓",
+		bl: "┗",
+		br: "┛",
+		h: "━",
+		v: "┃"
+	}
+};
+/**
+* Renderiza `content` envuelto en un box con borde Unicode, respetando el
+* ancho del terminal. El ancho interno se calcula a partir de la l\u00ednea m\u00e1s
+* larga (o del {@link IBoxOptions.title} si es m\u00e1s ancho) y se acota a
+* `min(terminalWidth - 4, 80)` columnas para no romper layouts estrechos.
+*
+* El padding se aplica como l\u00edneas vac\u00edas sim\u00e9tricas arriba/abajo del
+* contenido. Si `borderColor` se omite o `colorCap` es `'none'`, el borde se
+* emite sin secuencias ANSI (output plain-text seguro para logs y pipes).
+*
+* @param content - Texto a envolver; puede contener m\u00faltiples l\u00edneas (`\n`) y
+*   secuencias ANSI embebidas \u2014 el c\u00e1lculo de ancho usa el largo visible.
+* @param options - Configuraci\u00f3n del box (title, borderColor, borderStyle,
+*   padding). Ver {@link IBoxOptions}.
+* @param colorCap - Capacidad de color del terminal destino. Si es `'none'`,
+*   se omite cualquier secuencia ANSI.
+* @returns String multilinea con el box ya construido (sin trailing newline).
+*
+* @example
+* ```ts
+* // Box b\u00e1sico con borde redondeado (default)
+* process.stdout.write(renderBox('Deploy completado') + '\n');
+* ```
+*
+* @example
+* ```ts
+* // Box con t\u00edtulo embebido en el borde superior y color custom
+* process.stdout.write(renderBox('Service: auth-svc\nStatus: healthy', {
+*   title: 'Health Check',
+*   borderColor: '#00bcd4',
+*   borderStyle: 'double',
+*   padding: 1
+* }) + '\n');
+* ```
+*
+* @see {@link IBoxOptions} para el detalle de cada opci\u00f3n.
+* @see {@link getTerminalWidth} para la detecci\u00f3n de ancho.
+*/
+function renderBox(content, options = {}, colorCap = "full") {
+	const { title, borderColor, borderStyle = "rounded", padding = 0 } = options;
+	const chars = BORDER_CHARS[borderStyle] ?? BORDER_CHARS.rounded;
+	const lines = content.split("\n");
+	const maxTermWidth = Math.min(getTerminalWidth() - 4, 80);
+	const contentWidths = lines.map((l) => getVisibleLength(l));
+	const titleWidth = title ? stripAnsi(title).length + 2 : 0;
+	const maxContentWidth = Math.max(...contentWidths, titleWidth);
+	const innerWidth = Math.min(maxContentWidth + 2, maxTermWidth);
+	const bc = borderColor && colorCap !== "none" ? getANSIForeground(borderColor, colorCap) : "";
+	const reset = bc ? ANSI.reset : "";
+	const wrap = (char) => `${bc}${char}${reset}`;
+	let topBorder;
+	if (title) {
+		const titleStr = ` ${title} `;
+		const afterTitle = innerWidth - stripAnsi(titleStr).length;
+		topBorder = `  ${wrap(chars.tl)}${wrap(chars.h)}${wrap(titleStr)}${wrap(chars.h.repeat(Math.max(0, afterTitle - 1)))}${wrap(chars.tr)}`;
+	} else topBorder = `  ${wrap(chars.tl)}${wrap(chars.h.repeat(innerWidth))}${wrap(chars.tr)}`;
+	const bottomBorder = `  ${wrap(chars.bl)}${wrap(chars.h.repeat(innerWidth))}${wrap(chars.br)}`;
+	const emptyLine = `  ${wrap(chars.v)}${" ".repeat(innerWidth)}${wrap(chars.v)}`;
+	const paddingLines = padding > 0 ? Array(padding).fill(emptyLine) : [];
+	const contentLines = lines.map((line) => {
+		const visible = getVisibleLength(line);
+		const pad = innerWidth - visible - 1;
+		return `  ${wrap(chars.v)} ${line}${" ".repeat(Math.max(0, pad))}${wrap(chars.v)}`;
+	});
+	return [
+		topBorder,
+		...paddingLines,
+		...contentLines,
+		...paddingLines,
+		bottomBorder
+	].join("\n");
+}
+//#endregion
+//#region src/playground/cli-table.ts
+/**
+* Renderiza un array de objetos como tabla ASCII alineada, con headers en
+* cian bold y separador (`─`) bajo la cabecera. Las columnas se autodetectan
+* a partir de las keys del primer row salvo que `options.columns` las imponga,
+* y los labels se toman de `options.head` (default: nombres de columna).
+*
+* El ancho de cada columna se calcula como `max(header, valor más largo) + 2`
+* para garantizar padding horizontal consistente. Si `colorCap` es `'none'`,
+* se omiten todas las secuencias ANSI (útil para logs plain-text o CI).
+*
+* @param rows - Array de row objects. Un array vacío devuelve string vacío.
+* @param options - Ver {@link ITableOptions} para `columns` y `head`.
+* @param colorCap - Capacidad de color del terminal destino.
+* @returns String multilinea con la tabla (header + separator + data rows),
+*   o `''` si `rows` está vacío.
+*
+* @example
+* ```ts
+* // Auto-detect columnas desde las keys del primer row
+* const rows = [
+*   { service: 'auth', status: 'healthy', latency: 12 },
+*   { service: 'api',  status: 'degraded', latency: 245 }
+* ];
+* process.stdout.write(renderTable(rows) + '\n');
+* // ┌─────────┬──────────┬─────────┐
+* // │ service │ status   │ latency │
+* // ─────────────────────────────────
+* // │ auth    │ healthy  │ 12      │
+* // │ api     │ degraded │ 245     │
+* ```
+*
+* @example
+* ```ts
+* // Forzar columnas y renombrar headers
+* process.stdout.write(renderTable(rows, {
+*   columns: ['service', 'latency'],
+*   head:    ['Service', 'Latency (ms)']
+* }, 'none') + '\n');
+* ```
+*
+* @see {@link ITableOptions} para las opciones disponibles.
+* @see {@link getVisibleLength} y {@link padToWidth} para el cálculo de ancho.
+*/
+function renderTable(rows, options = {}, colorCap = "full") {
+	if (rows.length === 0) return "";
+	const columns = options.columns ?? Object.keys(rows[0]);
+	const headers = options.head ?? columns;
+	const colWidths = columns.map((col, i) => {
+		const headerLen = getVisibleLength(headers[i] ?? col);
+		const maxValueLen = rows.reduce((max, row) => {
+			const val = String(row[col] ?? "");
+			return Math.max(max, getVisibleLength(val));
+		}, 0);
+		return Math.max(headerLen, maxValueLen) + 2;
+	});
+	const cyan = colorCap !== "none" ? getANSIForeground("#00bcd4", colorCap) : "";
+	const dim = colorCap !== "none" ? ANSI.dim : "";
+	const reset = colorCap !== "none" ? ANSI.reset : "";
+	return [
+		"  " + columns.map((col, i) => {
+			const label = headers[i] ?? col;
+			return cyan + ANSI.bold + padToWidth(` ${label}`, colWidths[i]) + reset;
+		}).join(""),
+		"  " + dim + colWidths.map((w) => "─".repeat(w)).join("─") + reset,
+		...rows.map((row) => {
+			return "  " + columns.map((col, i) => {
+				return padToWidth(` ${String(row[col] ?? "")}`, colWidths[i]);
+			}).join("");
+		})
+	].join("\n");
+}
+//#endregion
+//#region src/playground/spinner.ts
+/**
+* Frames braille usados por la animaci\u00f3n del spinner. Cada frame es un
+* car\u00e1cter del bloque Unicode Braille Patterns (U+2800\u2013U+28FF) que da la
+* ilusi\u00f3n de rotaci\u00f3n al ciclarlos a ~12 FPS. Elegidos sobre caracteres
+* ASCII (`|/-\`) porque renderizan m\u00e1s suaves en terminales modernas.
+*/
+const SPINNER_FRAMES = [
+	"⠋",
+	"⠙",
+	"⠹",
+	"⠸",
+	"⠼",
+	"⠴",
+	"⠦",
+	"⠧",
+	"⠇",
+	"⠏"
+];
+/**
+* Intervalo entre frames del spinner en milisegundos. 80 ms \u2248 12.5 FPS:
+* suficientemente r\u00e1pido para sentirse responsivo sin consumir CPU
+* perceptiblemente en runs largos.
+*/
+const FRAME_INTERVAL = 80;
+/**
+* Spinner interactivo para TTY: cicla frames braille reescribiendo la l\u00ednea
+* actual en su sitio (no emite l\u00edneas nuevas hasta el stop).
+*
+* Para no poluir stdout piped ni entrelazarse con el output normal del
+* {@link Logger}, hace dos cosas no obvias:
+*   1. Escribe SIEMPRE a `process.stderr` (carriage return + `\x1b[K` para
+*      limpiar la l\u00ednea antes de cada render).
+*   2. Con `start()` mutea el logger (`outputMode: 'silent'`) y lo restaura a
+*      `'console'` en cualquier m\u00e9todo de finalizaci\u00f3n (`stop`/`succeed`/`fail`).
+*      Sin esto, los logs del usuario se imprimir\u00edan encima del frame animado.
+*
+* No gestiona TTY detection \u2014 quien lo instancia (`TerminalBridge`) ya valid\u00f3
+* que hay TTY. Para non-TTY ver {@link NoopSpinner}.
+*
+* @implements {ISpinnerHandle}
+*
+* @example
+* ```ts
+* const spinner = new SpinnerManager('Compilando...', logger.config, logger);
+* spinner.start();
+* // ...trabajo as\u00edncrono...
+* spinner.succeed('Build OK');
+* // stderr: "  \u2713 Build OK"
+* ```
+*
+* @see {@link NoopSpinner} para el path non-TTY.
+* @see {@link ISpinnerHandle} para el contrato de la API p\u00fablica.
+*/
+var SpinnerManager = class {
+	message;
+	frameIndex = 0;
+	interval = null;
+	_logger;
+	/**
+	* @param {string} message - Texto a mostrar al lado del frame animado.
+	*   Mutables luego v\u00eda {@link SpinnerManager.text}.
+	* @param {LoggerConfig} _config - Reservado para configuraci\u00f3n futura;
+	*   actualmente no se lee dentro de la clase (lo conserva solo el caller).
+	* @param {Logger} logger - Instancia del logger due\u00f1a del spinner. Se
+	*   mutea/restaura con `updateConfig({ outputMode })` en start/stop.
+	*/
+	constructor(message, _config, logger) {
+		this.message = message;
+		this._logger = logger;
+	}
+	/**
+	* Arranca la animaci\u00f3n. Idempotente: si ya est\u00e1 corriendo, no hace nada.
+	*
+	* Como efecto lateral mutea el logger pasado al constructor cambiando su
+	* `outputMode` a `'silent'` \u2014 cualquier log durante la animaci\u00f3n quedar\u00eda
+	* bufferizado y se descarta al restaurar el modo. Llama siempre a
+	* {@link stop}, {@link succeed} o {@link fail} para restaurar el output.
+	*
+	* @returns {void}
+	*/
+	start() {
+		if (this.interval) return;
+		this._logger.updateConfig({ outputMode: "silent" });
+		this.frameIndex = 0;
+		this.render();
+		this.interval = setInterval(() => {
+			this.frameIndex = (this.frameIndex + 1) % SPINNER_FRAMES.length;
+			this.render();
+		}, FRAME_INTERVAL);
+	}
+	/**
+	* Detiene la animaci\u00f3n y limpia la l\u00ednea, sin emitir mensaje de estado.
+	* Restaura el `outputMode` del logger a `'console'`.
+	*
+	* \u00datil cuando el caller ya emiti\u00f3 su propio output final y solo necesita
+	* desmontar el spinner. Para terminaci\u00f3n con tick/cross usa
+	* {@link succeed} / {@link fail}.
+	*
+	* @returns {void}
+	*/
+	stop() {
+		this.clearInterval();
+		this.clearLine();
+		this._logger.updateConfig({ outputMode: "console" });
+	}
+	/**
+	* Detiene la animaci\u00f3n y emite el mensaje con un check verde (`\u2713`).
+	* Restaura el `outputMode` del logger a `'console'`.
+	*
+	* @param {string} [msg] - Texto final a mostrar. Si se omite, reutiliza
+	*   el `message` con el que se construy\u00f3 el spinner (o el \u00faltimo seteado
+	*   v\u00eda {@link text}).
+	* @returns {void}
+	*
+	* @example
+	* ```ts
+	* spinner.succeed();           // \u2192 "  \u2713 <message inicial>"
+	* spinner.succeed('Hecho');    // \u2192 "  \u2713 Hecho"
+	* ```
+	*/
+	succeed(msg) {
+		this.clearInterval();
+		this.clearLine();
+		const text = msg ?? this.message;
+		process.stderr.write(`  ${ANSI.fg.green}\u2713${ANSI.reset} ${text}\n`);
+		this._logger.updateConfig({ outputMode: "console" });
+	}
+	/**
+	* Detiene la animaci\u00f3n y emite el mensaje con una cruz roja (`\u2717`).
+	* Restaura el `outputMode` del logger a `'console'`.
+	*
+	* @param {string} [msg] - Texto final a mostrar. Si se omite, reutiliza
+	*   el `message` con el que se construy\u00f3 el spinner (o el \u00faltimo seteado
+	*   v\u00eda {@link text}).
+	* @returns {void}
+	*
+	* @example
+	* ```ts
+	* try {
+	*   await build();
+	*   spinner.succeed('Build OK');
+	* } catch (e) {
+	*   spinner.fail(`Build fallido: ${e.message}`);
+	* }
+	* ```
+	*/
+	fail(msg) {
+		this.clearInterval();
+		this.clearLine();
+		const text = msg ?? this.message;
+		process.stderr.write(`  ${ANSI.fg.red}\u2717${ANSI.reset} ${text}\n`);
+		this._logger.updateConfig({ outputMode: "console" });
+	}
+	/**
+	* Reemplaza el texto mostrado al lado del frame sin reiniciar la animaci\u00f3n
+	* ni perder el frame actual. Pensado para actualizar progreso in-place
+	* (p.ej. contador de items procesados).
+	*
+	* @param {string} msg - Nuevo texto a mostrar.
+	* @returns {void}
+	*/
+	text(msg) {
+		this.message = msg;
+	}
+	render() {
+		const frame = SPINNER_FRAMES[this.frameIndex] ?? SPINNER_FRAMES[0];
+		const line = `  ${ANSI.fg.cyan}${frame}${ANSI.reset} ${this.message}`;
+		process.stderr.write(`\r\x1b[K${line}`);
+	}
+	clearLine() {
+		process.stderr.write("\r\x1B[K");
+	}
+	clearInterval() {
+		if (this.interval) {
+			clearInterval(this.interval);
+			this.interval = null;
+		}
+	}
+};
+/**
+* Spinner degenerate para non-TTY (CI logs, pipes, `outputMode: 'silent'`).
+*
+* No anima nada: traduce los eventos del ciclo de vida del spinner a llamadas
+* normales del logger (`info` en start, `success`/`error` en finish). Así el
+* consumidor mantiene la misma API {@link ISpinnerHandle} sin saber si está
+* corriendo en terminal interactiva o en un job de CI.
+*
+* A diferencia de {@link SpinnerManager}, **no** toca el `outputMode` del
+* logger — no hay nada que mutear porque no hay frame animado que proteger.
+*
+* @implements {ISpinnerHandle}
+*
+* @example
+* ```ts
+* // En CI (sin TTY) el TerminalBridge entrega un NoopSpinner automáticamente:
+* const s = logger.spinner('Running tests...');
+* s.start();                 // logger.info('Running tests...')
+* s.succeed('All green');    // logger.success('All green')
+* ```
+*
+* @see {@link SpinnerManager} para el path interactivo con animación.
+*/
+var NoopSpinner = class {
+	message;
+	_logger;
+	/**
+	* @param {string} message - Texto base; se reutiliza como mensaje final
+	*   si {@link succeed} / {@link fail} se llaman sin argumento.
+	* @param {Logger} logger - Logger sobre el que se emiten los eventos.
+	*/
+	constructor(message, logger) {
+		this.message = message;
+		this._logger = logger;
+	}
+	/**
+	* Emite el mensaje inicial como `logger.info(...)`. No arranca ningún
+	* timer — en non-TTY no hay nada que animar.
+	*
+	* @returns {void}
+	*/
+	start() {
+		this._logger.info(this.message);
+	}
+	/**
+	* No-op — no hay animación que detener ni output que restaurar.
+	*
+	* @returns {void}
+	*/
+	stop() {}
+	/**
+	* Emite el mensaje final como `logger.success(...)`.
+	*
+	* @param {string} [msg] - Texto final; si se omite usa el `message`
+	*   inicial o el último seteado vía {@link text}.
+	* @returns {void}
+	*/
+	succeed(msg) {
+		this._logger.success(msg ?? this.message);
+	}
+	/**
+	* Emite el mensaje final como `logger.error(...)`.
+	*
+	* @param {string} [msg] - Texto final; si se omite usa el `message`
+	*   inicial o el último seteado vía {@link text}.
+	* @returns {void}
+	*/
+	fail(msg) {
+		this._logger.error(msg ?? this.message);
+	}
+	/**
+	* Actualiza el mensaje interno (sin output). Solo afecta al texto que
+	* emitirán {@link succeed} / {@link fail} cuando se invoquen sin argumento.
+	*
+	* @param {string} msg - Nuevo texto base.
+	* @returns {void}
+	*/
+	text(msg) {
+		this.message = msg;
+	}
+};
+//#endregion
+export { renderDivider as a, formatBadge as c, renderBox as i, SpinnerManager as n, renderHeader as o, renderTable as r, renderStep as s, NoopSpinner as t };
+
+//# sourceMappingURL=spinner-BtkwpzYv.js.map