@duckmind/dm-darwin-x64 0.33.4 → 0.33.5

package/extensions/dm-alps/src/features/animations/registry.ts

@@ -0,0 +1,539 @@
+
+const rgb = (r: number, g: number, b: number) => `\x1b[38;2;${r};${g};${b}m`;
+const bold = "\x1b[1m";
+const dim = "\x1b[2m";
+const reset = "\x1b[0m";
+const nobold = "\x1b[22m";
+
+// DM gradient (nicobailon style): magenta → purple → cyan
+const DM_GRAD = [
+	[255, 0, 135], [175, 95, 175], [135, 95, 215],
+	[95, 95, 255], [95, 175, 255], [0, 255, 255],
+];
+
+function hsl(h: number, s = 1, l = 0.5): string {
+	const c = (1 - Math.abs(2 * l - 1)) * s;
+	const x = c * (1 - Math.abs(((h / 60) % 2) - 1));
+	const m = l - c / 2;
+	let r = 0, g = 0, b = 0;
+	if (h < 60) { r = c; g = x; } else if (h < 120) { r = x; g = c; }
+	else if (h < 180) { g = c; b = x; } else if (h < 240) { g = x; b = c; }
+	else if (h < 300) { r = x; b = c; } else { r = c; b = x; }
+	return rgb(Math.round((r + m) * 255), Math.round((g + m) * 255), Math.round((b + m) * 255));
+}
+
+function lerpGrad(grad: number[][], t: number): [number, number, number] {
+	const i = Math.floor(t * (grad.length - 1));
+	const i2 = Math.min(i + 1, grad.length - 1);
+	const lt = (t * (grad.length - 1)) % 1;
+	return [
+		Math.round(grad[i][0] + (grad[i2][0] - grad[i][0]) * lt),
+		Math.round(grad[i][1] + (grad[i2][1] - grad[i][1]) * lt),
+		Math.round(grad[i][2] + (grad[i2][2] - grad[i][2]) * lt),
+	];
+}
+
+const ellipsis = (f: number) => [".", "..", "...", ""][Math.floor(f / 10) % 4];
+
+export type AnimationPhase = "thinking" | "working" | "tool";
+export type AnimationFn = (frame: number, width: number, phase?: AnimationPhase) => string | string[];
+
+const PHASE_LABELS: Record<AnimationPhase, string> = {
+	thinking: "Thinking",
+	working: "Working",
+	tool: "Running",
+};
+
+// ─── 02 Neural Pulse ─────────────────────────────────────────────
+const neuralPulse: AnimationFn = (f, w) => {
+	const N = Math.min(14, Math.floor(w / 4));
+	const d = rgb(60, 60, 80);
+	const pulse = [rgb(80, 80, 120), rgb(120, 100, 200), rgb(180, 140, 255), rgb(220, 180, 255), rgb(255, 220, 255), rgb(220, 180, 255), rgb(180, 140, 255)];
+	let line = "";
+	for (let i = 0; i < N; i++) {
+		const dist = ((i - (f * 0.5)) % N + N) % N;
+		const pi = dist < pulse.length ? Math.floor(dist) : -1;
+		line += (pi >= 0 ? pulse[pi] : d) + (pi >= 0 ? "●" : "○");
+		if (i < N - 1) { const cd = ((i + 0.5 - (f * 0.5)) % N + N) % N; line += (cd < pulse.length ? pulse[Math.min(Math.floor(cd), pulse.length - 1)] : d) + "──"; }
+	}
+	return line + reset;
+};
+
+// ─── 03 Glitch Text ──────────────────────────────────────────────
+const glitchText: AnimationFn = (f, _w, phase) => {
+	const text = PHASE_LABELS[phase || "thinking"];
+	const glyphs = "█▓▒░╳╱╲¥£€$#@!?&%~*";
+	const colors = [rgb(0, 255, 200), rgb(255, 0, 100), rgb(100, 200, 255), rgb(255, 255, 0)];
+	let line = "";
+	for (let i = 0; i < text.length; i++) {
+		if (Math.random() < 0.12) line += colors[Math.floor(Math.random() * colors.length)] + glyphs[Math.floor(Math.random() * glyphs.length)];
+		else if (Math.random() < 0.06) line += rgb(0, 255, 200) + (text[Math.min(Math.max(i + (Math.random() < 0.5 ? -1 : 1), 0), text.length - 1)] || " ");
+		else line += bold + rgb(255, 255, 255) + text[i] + nobold;
+	}
+	const jitter = Math.random() < 0.1 ? " ".repeat(Math.floor(Math.random() * 3)) : "";
+	return jitter + line + reset;
+};
+
+// ─── 05 Plasma Wave (1-line) ─────────────────────────────────────
+const plasmaWave: AnimationFn = (f, w) => {
+	const chars = " ·∘○◎●◉█";
+	const W = w;
+	let line = "";
+	for (let x = 0; x < W; x++) {
+		const v = (Math.sin(x * 0.15 + f * 0.08) + Math.sin(x * 0.1 + f * 0.06) + Math.sin(Math.sqrt(x * x) * 0.15 + f * 0.1)) / 3;
+		const n = (v + 1) / 2;
+		const r = Math.round(Math.sin(n * Math.PI * 2) * 127 + 128);
+		const g = Math.round(Math.sin(n * Math.PI * 2 + 2.094) * 127 + 128);
+		const b = Math.round(Math.sin(n * Math.PI * 2 + 4.189) * 127 + 128);
+		line += rgb(r, g, b) + chars[Math.floor(n * (chars.length - 1))];
+	}
+	return line + reset;
+};
+
+// ─── 06 Pac-Man Chase ────────────────────────────────────────────
+const pacmanChase: AnimationFn = (f, w) => {
+	const W = Math.min(40, w);
+	const pac = [rgb(255, 255, 0) + "ᗧ", rgb(255, 255, 0) + "●"];
+	const ghost = rgb(255, 80, 80) + "ᗣ";
+	const dot = rgb(255, 180, 100) + "·";
+	const power = bold + rgb(255, 255, 255) + "●" + nobold;
+	const pp = f % (W + 8), gp = (f - 4 + W + 8) % (W + 8);
+	let line = "";
+	for (let i = 0; i < W; i++) {
+		if (i === pp % W && pp < W) line += pac[f % 4 < 2 ? 0 : 1];
+		else if (i === gp % W && gp < W) line += ghost;
+		else if (i > pp || pp >= W) line += (i % 8 === 0) ? power : dot;
+		else line += " ";
+	}
+	return line + reset;
+};
+
+// ─── 07 Matrix Rain (1-line) ─────────────────────────────────────
+let matrixDrops: { x: number; phase: number; speed: number }[] = [];
+let matrixLastW = 0;
+const matrixChars = "ﾊﾐﾋｰｳｼﾅﾓﾆｻﾜﾂｵﾘ012789Z";
+const matrixRain: AnimationFn = (f, w) => {
+	const W = w;
+	if (W !== matrixLastW) {
+		const count = Math.max(15, Math.floor(W * 0.4));
+		matrixDrops = Array.from({ length: count }, () => ({ x: Math.floor(Math.random() * W), phase: Math.random() * 100, speed: 0.3 + Math.random() * 0.5 }));
+		matrixLastW = W;
+	}
+	const buf = new Array(W).fill(" ");
+	for (const d of matrixDrops) {
+		const pos = Math.floor((f * d.speed + d.phase) % (W + 5));
+		if (pos < W) buf[pos] = rgb(0, 255, 0) + bold + matrixChars[Math.floor(Math.random() * matrixChars.length)] + nobold;
+		if (pos - 1 >= 0 && pos - 1 < W && buf[pos - 1] === " ") buf[pos - 1] = rgb(0, 160, 0) + matrixChars[Math.floor(Math.random() * matrixChars.length)];
+		if (pos - 2 >= 0 && pos - 2 < W && buf[pos - 2] === " ") buf[pos - 2] = rgb(0, 80, 0) + matrixChars[Math.floor(Math.random() * matrixChars.length)];
+	}
+	return buf.join("") + reset;
+};
+
+// ─── 08 Pipeline ─────────────────────────────────────────────────
+const pipeline: AnimationFn = (f) => {
+	const icons = [
+		{ i: "\uf0e7", c: rgb(255, 200, 50) }, { i: "\uf013", c: rgb(100, 180, 255) },
+		{ i: "\uf121", c: rgb(150, 255, 150) }, { i: "\uf0ad", c: rgb(255, 150, 100) }, { i: "\uf00c", c: rgb(100, 255, 200) }
+	];
+	const pw = 5, total = icons.length * (pw + 1) + 1, pp = (f * 0.4) % total;
+	let line = "";
+	for (let i = 0; i < icons.length; i++) {
+		const ss = i * (pw + 1), active = pp >= ss && pp < ss + pw + 1;
+		line += (active ? bold : dim) + icons[i].c + icons[i].i + " " + reset;
+		if (i < icons.length - 1) for (let p = 0; p < pw; p++) { const pos = ss + 1 + p; line += (Math.abs(pp - pos) < 1.5 ? bold + rgb(255, 255, 255) + "═" : pp > pos ? icons[i].c + "─" : rgb(60, 60, 80) + "─"); }
+	}
+	return line + reset;
+};
+
+// ─── 10 Starfield ────────────────────────────────────────────────
+const starChars = ["·", "∙", "•", "✦", "★"];
+type Star = { x: number; speed: number; bright: number; ch: string };
+let stars: Star[] = [];
+let starsLastW = 0;
+function ensureStars(W: number) {
+	if (W !== starsLastW) {
+		const count = Math.max(20, Math.floor(W * 0.6));
+		stars = Array.from({ length: count }, () => {
+			const speed = 0.2 + Math.random() * 1.2;
+			const layer = Math.floor(speed / 0.3);
+			return { x: Math.random() * W, speed, bright: Math.min(255, 80 + layer * 40), ch: starChars[Math.min(layer, starChars.length - 1)] };
+		});
+		starsLastW = W;
+	}
+}
+const starfield: AnimationFn = (f, w) => {
+	const W = w;
+	ensureStars(W);
+	const buf = new Array(W).fill(" ");
+	for (const s of stars) {
+		const xi = Math.floor(s.x);
+		if (xi >= 0 && xi < W) buf[xi] = rgb(s.bright, s.bright, Math.min(255, s.bright + 40)) + s.ch;
+		s.x += s.speed;
+		if (s.x >= W) { s.x = 0; s.speed = 0.2 + Math.random() * 1.2; const l = Math.floor(s.speed / 0.3); s.bright = Math.min(255, 80 + l * 40); s.ch = starChars[Math.min(l, starChars.length - 1)]; }
+	}
+	return buf.join("") + reset;
+};
+
+// ─── 12 Fire ─────────────────────────────────────────────────────
+const fireChars = " .:-=+*#%@█";
+const firePalette = [[0, 0, 0], [50, 0, 0], [120, 30, 0], [200, 80, 0], [240, 160, 30], [255, 230, 120], [255, 255, 200]];
+let fireBuf: Float64Array[] = [];
+let fireLastW = 0;
+const fire: AnimationFn = (f, w) => {
+	const W = w;
+	if (W !== fireLastW) { fireBuf = Array.from({ length: 4 }, () => new Float64Array(W)); fireLastW = W; }
+	for (let x = 0; x < W; x++) fireBuf[3][x] = Math.random() > 0.35 ? 1 : Math.random() * 0.5;
+	for (let y = 0; y < 3; y++) for (let x = 0; x < W; x++)
+		fireBuf[y][x] = (fireBuf[y + 1][(x - 1 + W) % W] + fireBuf[y + 1][x] + fireBuf[y + 1][(x + 1) % W]) / 3.1;
+	let line = "";
+	for (let x = 0; x < W; x++) {
+		const v = Math.min(1, Math.max(0, fireBuf[0][x]));
+		const pi = Math.floor(v * (firePalette.length - 1));
+		const ci = Math.floor(v * (fireChars.length - 1));
+		const [r, g, b] = firePalette[pi];
+		line += rgb(r, g, b) + fireChars[ci];
+	}
+	return line + reset;
+};
+
+// ─── 15 Icon Morphing ────────────────────────────────────────────
+const morphIcons = [
+	{ ch: "\uf0eb", r: 255, g: 220, b: 50 }, { ch: "\uf013", r: 100, g: 180, b: 255 },
+	{ ch: "\uf0e7", r: 255, g: 150, b: 50 }, { ch: "\uf135", r: 255, g: 100, b: 100 },
+	{ ch: "\uf005", r: 255, g: 255, b: 100 }, { ch: "\uf06d", r: 255, g: 120, b: 30 },
+	{ ch: "\uf0ac", r: 100, g: 200, b: 255 }, { ch: "\uf004", r: 255, g: 80, b: 120 }
+];
+const trans = "░▒▓█▓▒░";
+const iconMorphing: AnimationFn = (f) => {
+	const cd = 25, pos = f % (morphIcons.length * cd);
+	const ci = Math.floor(pos / cd), ni = (ci + 1) % morphIcons.length, p = (pos % cd) / cd;
+	const cur = morphIcons[ci], nxt = morphIcons[ni];
+	const r = Math.round(cur.r + (nxt.r - cur.r) * p), g = Math.round(cur.g + (nxt.g - cur.g) * p), b = Math.round(cur.b + (nxt.b - cur.b) * p);
+	let display = p < 0.3 ? cur.ch : p < 0.7 ? trans[Math.min(Math.floor((p - 0.3) / 0.4 * trans.length), trans.length - 1)] : nxt.ch;
+	let trail = "";
+	for (let i = 0; i < 20; i++) { const sp = Math.random() < 0.25 ? (Math.random() < 0.5 ? "✦" : "·") : " "; const br = Math.floor(Math.random() * 155 + 100); trail += rgb(br, br, Math.floor(br * 0.8)) + sp; }
+	return rgb(r, g, b) + display + "  " + trail + reset;
+};
+
+// ─── 16 Brainstorm ───────────────────────────────────────────────
+const weatherPhases = [
+	{ icon: "\ue30d", label: "calm", r: 255, g: 200, b: 50 },
+	{ icon: "\ue302", label: "thinking.", r: 180, g: 180, b: 200 },
+	{ icon: "\ue318", label: "thinking..", r: 140, g: 140, b: 180 },
+	{ icon: "\ue31d", label: "EUREKA!", r: 255, g: 255, b: 100 },
+	{ icon: "\ue30b", label: "insight!", r: 255, g: 220, b: 100 },
+	{ icon: "\ue302", label: "processing", r: 160, g: 160, b: 190 }
+];
+const brainstorm: AnimationFn = (f) => {
+	const pd = 35, pos = f % (weatherPhases.length * pd), pi = Math.floor(pos / pd), p = weatherPhases[pi];
+	const glow = Math.sin(f * 0.15) * 30;
+	const r = Math.min(255, Math.max(0, p.r + glow)), g = Math.min(255, Math.max(0, p.g + glow)), b = Math.min(255, Math.max(0, p.b + glow));
+	let sparks = "";
+	for (let i = 0; i < 15; i++) { if (Math.random() < 0.15) { const br = Math.floor(Math.random() * 100 + 155); sparks += rgb(br, br, Math.min(255, br + 50)) + (Math.random() < 0.3 ? "⚡" : "✦"); } else sparks += " "; }
+	return rgb(r, g, b) + bold + p.icon + "  " + p.label + nobold + " " + sparks + reset;
+};
+
+// ─── 19 Dev Constellation ────────────────────────────────────────
+const devNodes = [
+	{ ch: "\ue796", c: [50, 150, 255] }, { ch: "\ue718", c: [80, 200, 120] }, { ch: "\ue73c", c: [255, 200, 50] },
+	{ ch: "\ue7a8", c: [200, 100, 255] }, { ch: "\uf13b", c: [100, 200, 255] }, { ch: "\ue61e", c: [255, 100, 100] }
+];
+const devConstellation: AnimationFn = (f) => {
+	const gap = 5, totalW = devNodes.length * (gap + 1) - 1, pp = (f * 0.4) % totalW;
+	let line = "";
+	for (let i = 0; i < devNodes.length; i++) {
+		const np = i * (gap + 1), dist = Math.abs(pp - np);
+		line += (dist < 1.5 ? bold : dim) + rgb(devNodes[i].c[0], devNodes[i].c[1], devNodes[i].c[2]) + devNodes[i].ch + nobold;
+		if (i < devNodes.length - 1) for (let g = 0; g < gap; g++) { const cp = np + 1 + g, cd = Math.abs(pp - cp); line += (cd < 1 ? bold + rgb(255, 255, 255) + "━" : cd < 2.5 ? rgb(150, 150, 200) + "─" : rgb(40, 40, 55) + "·"); }
+	}
+	return line + reset;
+};
+
+// ─── 20 Crush Scramble ───────────────────────────────────────────
+const scrambleChars = "0123456789abcdefABCDEF~!@#$£€%^&*()+=_";
+const scrambleBirths = Array.from({ length: 15 }, () => Math.random() * 20);
+const scrambleRamp: number[][] = [];
+for (let i = 0; i < 24; i++) { const t = i / 24, a = t * Math.PI * 2; scrambleRamp.push([Math.round(Math.sin(a) * 127 + 128), Math.round(Math.sin(a + 2.094) * 80 + 80), Math.round(Math.sin(a + 4.189) * 127 + 128)]); }
+const crushScramble: AnimationFn = (f, _w, phase) => {
+	const sw = 15, init = f > 20;
+	let line = "";
+	for (let i = 0; i < sw; i++) {
+		const ci = (i + (init ? f : 0)) % scrambleRamp.length, [r, g, b] = scrambleRamp[ci];
+		line += rgb(r, g, b) + (!init && f < scrambleBirths[i] ? "." : scrambleChars[Math.floor(Math.random() * scrambleChars.length)]);
+	}
+	const label = PHASE_LABELS[phase || "thinking"];
+	line += " " + rgb(200, 200, 200) + label;
+	if (init) line += rgb(200, 200, 200) + ellipsis(f);
+	return line + reset;
+};
+
+// ─── 21 DM Pulse ────────────────────────────────────────────
+const dmPulse: AnimationFn = (f) => {
+	const dmGlyph = "\ue22c", label = "";
+	const breath = (Math.sin(f * 0.08) + 1) / 2;
+	const gi = Math.floor((f * 0.3) % DM_GRAD.length);
+	const gi2 = (gi + 1) % DM_GRAD.length;
+	const t = (f * 0.3) % 1;
+	const r = Math.round(DM_GRAD[gi][0] + (DM_GRAD[gi2][0] - DM_GRAD[gi][0]) * t);
+	const g = Math.round(DM_GRAD[gi][1] + (DM_GRAD[gi2][1] - DM_GRAD[gi][1]) * t);
+	const b = Math.round(DM_GRAD[gi][2] + (DM_GRAD[gi2][2] - DM_GRAD[gi][2]) * t);
+	const br = 0.6 + breath * 0.4;
+	const trailChars = "·∘○◎●";
+	let trail = "";
+	for (let i = 0; i < 20; i++) {
+		const phase = (i / 20 * Math.PI * 2 + f * 0.1), ti = Math.floor((Math.sin(phase) + 1) / 2 * (trailChars.length - 1));
+		const fade = Math.max(30, 200 - i * 8);
+		trail += rgb(Math.floor(r * fade / 255), Math.floor(g * fade / 255), Math.floor(b * fade / 255)) + trailChars[ti];
+	}
+	return bold + rgb(Math.round(r * br), Math.round(g * br), Math.round(b * br)) + dmGlyph + label + nobold + "  " + trail + reset;
+};
+
+// ─── 22 Shimmer Text ─────────────────────────────────────────────
+const shimmerText: AnimationFn = (f, _w, phase) => {
+	const text = PHASE_LABELS[phase || "thinking"] + "...";
+	const base = [200, 200, 200];
+	let line = "";
+	for (let i = 0; i < text.length; i++) {
+		const wave = Math.sin((i - f * 0.3) * 0.8);
+		if (wave > 0.3) {
+			const intensity = (wave - 0.3) / 0.7;
+			const gi = Math.floor(((i + f * 0.5) % (DM_GRAD.length * 2)));
+			const gIdx = gi < DM_GRAD.length ? gi : DM_GRAD.length * 2 - 1 - gi;
+			const gc = DM_GRAD[Math.min(gIdx, DM_GRAD.length - 1)];
+			line += bold + rgb(Math.round(base[0] + (gc[0] - base[0]) * intensity), Math.round(base[1] + (gc[1] - base[1]) * intensity), Math.round(base[2] + (gc[2] - base[2]) * intensity)) + text[i] + nobold;
+		} else {
+			line += rgb(base[0], base[1], base[2]) + text[i];
+		}
+	}
+	return line + reset;
+};
+
+// ─── 24 Vibe Typewriter ──────────────────────────────────────────
+const vibeMessages = [
+	"Engaging warp drive...", "Running diagnostics...", "Recalibrating sensors...",
+	"Scanning the horizon...", "Channeling the cosmos...", "Weaving neural threads...", "Parsing the matrix...",
+];
+const cursorChars = ["✦", "✧", "⚡", "★", "·"];
+const cursorColors = [[255, 220, 100], [100, 200, 255], [255, 100, 200], [200, 255, 100]];
+let vibeIdx = 0, vibeCharIdx = 0, vibeHold = 0;
+const vibeTypewriter: AnimationFn = (f) => {
+	const vibe = vibeMessages[vibeIdx];
+	if (vibeHold > 0) { vibeHold--; if (vibeHold === 0) { vibeIdx = (vibeIdx + 1) % vibeMessages.length; vibeCharIdx = 0; } }
+	else if (vibeCharIdx < vibe.length) vibeCharIdx++;
+	else vibeHold = 30;
+	const shown = vibe.slice(0, vibeCharIdx);
+	const cc = cursorColors[f % cursorColors.length];
+	const cursor = vibeCharIdx < vibe.length ? rgb(cc[0], cc[1], cc[2]) + bold + cursorChars[f % cursorChars.length] + nobold : "";
+	return rgb(200, 200, 220) + shown + cursor + reset;
+};
+
+// ─── 26 Orbit Dots ───────────────────────────────────────────────
+const dotChars = ["·", "∘", "○", "●", "◉", "●", "○", "∘"];
+const orbitDots: AnimationFn = (f, _w, phase) => {
+	let line = "";
+	for (let i = 0; i < 5; i++) {
+		const phase = Math.sin(f * 0.12 - i * 0.8), norm = (phase + 1) / 2;
+		const ci = Math.floor(norm * (dotChars.length - 1));
+		const [r, g, b] = lerpGrad(DM_GRAD, ((i + f * 0.1) % DM_GRAD.length) / DM_GRAD.length);
+		const br = 0.4 + norm * 0.6;
+		line += (norm > 0.7 ? bold : "") + rgb(Math.round(r * br), Math.round(g * br), Math.round(b * br)) + dotChars[ci] + nobold + " ";
+	}
+	const [lr, lg, lb] = lerpGrad(DM_GRAD, (f * 0.08 % DM_GRAD.length) / DM_GRAD.length);
+	const label = PHASE_LABELS[phase || "thinking"];
+	line += "  " + rgb(lr, lg, lb) + label + rgb(180, 180, 200) + ellipsis(f);
+	return line + reset;
+};
+
+// ─── 27 Neon Bounce ──────────────────────────────────────────────
+const bounceTrail: { pos: number; age: number; color: number[] }[] = [];
+const trailGlyphs = ["█", "▓", "▒", "░", "·"];
+const neonBounce: AnimationFn = (f, w) => {
+	const W = w;
+	const cycle = (f * 0.6) % (W * 2), pos = Math.floor(cycle < W ? cycle : W * 2 - cycle);
+	const [r, g, b] = lerpGrad(DM_GRAD, pos / W);
+	bounceTrail.push({ pos, age: 0, color: [r, g, b] });
+	const buf = new Array(W).fill(" ");
+	for (const t of bounceTrail) {
+		if (t.age < trailGlyphs.length && t.pos < W) {
+			const fade = Math.max(0, 1 - t.age / 5);
+			buf[t.pos] = rgb(Math.round(t.color[0] * fade), Math.round(t.color[1] * fade), Math.round(t.color[2] * fade)) + trailGlyphs[Math.min(t.age, trailGlyphs.length - 1)];
+		}
+		t.age++;
+	}
+	if (pos < W) buf[pos] = bold + rgb(Math.min(255, r + 50), Math.min(255, g + 50), Math.min(255, b + 50)) + "█" + nobold;
+	while (bounceTrail.length > 0 && bounceTrail[0].age > 5) bounceTrail.shift();
+	return rgb(80, 80, 100) + "▐" + buf.join("") + rgb(80, 80, 100) + "▌" + reset;
+};
+
+// ─── 3-LINE: Fire ────────────────────────────────────────────────
+let fire3Buf: Float64Array[] = [];
+let fire3LastW = 0;
+const fire3: AnimationFn = (f, w) => {
+	const W = w;
+	if (W !== fire3LastW) { fire3Buf = Array.from({ length: 5 }, () => new Float64Array(W)); fire3LastW = W; }
+	for (let x = 0; x < W; x++) fire3Buf[4][x] = Math.random() > 0.3 ? 1 : Math.random() * 0.5;
+	for (let y = 0; y < 4; y++) for (let x = 0; x < W; x++)
+		fire3Buf[y][x] = (fire3Buf[y + 1][(x - 1 + W) % W] + fire3Buf[y + 1][x] + fire3Buf[y + 1][(x + 1) % W]) / 3.08;
+	const lines: string[] = [];
+	for (let row = 0; row < 3; row++) {
+		let line = "";
+		for (let x = 0; x < W; x++) {
+			const v = Math.min(1, Math.max(0, fire3Buf[row][x]));
+			const ci = Math.floor(v * (fireChars.length - 1));
+			const pi = Math.floor(v * (firePalette.length - 1));
+			const [r, g, b] = firePalette[pi];
+			line += rgb(r, g, b) + fireChars[ci];
+		}
+		lines.push(line + reset);
+	}
+	return lines;
+};
+
+// ─── 3-LINE: Matrix Rain ─────────────────────────────────────────
+let mat3Drops: { x: number; y: number; speed: number; len: number }[] = [];
+let mat3LastW = 0;
+const matrix3: AnimationFn = (f, w) => {
+	const W = w, H = 3;
+	if (W !== mat3LastW) {
+		const count = Math.max(20, Math.floor(W * 0.5));
+		mat3Drops = Array.from({ length: count }, () => ({ x: Math.floor(Math.random() * W), y: Math.random() * -5, speed: 0.15 + Math.random() * 0.35, len: 2 + Math.floor(Math.random() * 3) }));
+		mat3LastW = W;
+	}
+	const grid: string[][] = Array.from({ length: H }, () => new Array(W).fill(rgb(10, 30, 10) + " "));
+	for (const d of mat3Drops) {
+		d.y += d.speed;
+		if (d.y > H + d.len) { d.y = -d.len; d.x = Math.floor(Math.random() * W); d.speed = 0.15 + Math.random() * 0.35; }
+		for (let t = 0; t < d.len; t++) {
+			const row = Math.floor(d.y - t);
+			if (row >= 0 && row < H && d.x < W) {
+				const ch = matrixChars[Math.floor(Math.random() * matrixChars.length)];
+				const brightness = t === 0 ? 255 : Math.max(40, 200 - t * 60);
+				grid[row][d.x] = (t === 0 ? bold : "") + rgb(0, brightness, 0) + ch + (t === 0 ? nobold : "");
+			}
+		}
+	}
+	return grid.map(row => row.join("") + reset);
+};
+
+// ─── 3-LINE: Starfield ───────────────────────────────────────────
+let stars3: { x: number; y: number; speed: number; ch: string; bright: number }[] = [];
+let stars3LastW = 0;
+const starfield3: AnimationFn = (f, w) => {
+	const W = w, H = 3;
+	if (W !== stars3LastW) {
+		const count = Math.max(30, Math.floor(W * 0.7));
+		stars3 = Array.from({ length: count }, () => {
+			const speed = 0.15 + Math.random() * 1.0;
+			const layer = Math.floor(speed / 0.25);
+			return { x: Math.random() * W, y: Math.floor(Math.random() * 3), speed, ch: starChars[Math.min(layer, starChars.length - 1)], bright: Math.min(255, 60 + layer * 40) };
+		});
+		stars3LastW = W;
+	}
+	const grid: string[][] = Array.from({ length: H }, () => new Array(W).fill(" "));
+	for (const s of stars3) {
+		const xi = Math.floor(s.x);
+		if (xi >= 0 && xi < W && s.y < H) grid[s.y][xi] = rgb(s.bright, s.bright, Math.min(255, s.bright + 40)) + s.ch;
+		s.x += s.speed;
+		if (s.x >= W) { s.x = 0; s.y = Math.floor(Math.random() * 3); s.speed = 0.15 + Math.random() * 1.0; const l = Math.floor(s.speed / 0.25); s.bright = Math.min(255, 60 + l * 40); s.ch = starChars[Math.min(l, starChars.length - 1)]; }
+	}
+	return grid.map(row => row.join("") + reset);
+};
+
+// ─── 3-LINE: Aurora ──────────────────────────────────────────────
+const aurora3: AnimationFn = (f, w) => {
+	const W = w, H = 3;
+	const auroraChars = " ░▒▓█▓▒░";
+	const lines: string[] = [];
+	for (let y = 0; y < H; y++) {
+		let line = "";
+		for (let x = 0; x < W; x++) {
+			const v1 = Math.sin(x * 0.08 + f * 0.04 + y * 1.2);
+			const v2 = Math.sin(x * 0.12 - f * 0.03 + y * 0.8);
+			const v3 = Math.sin((x + y * 10) * 0.06 + f * 0.05);
+			const n = (v1 + v2 + v3 + 3) / 6;
+			const hue = (x * 3 + f * 2 + y * 40) % 360;
+			const sat = 0.7 + n * 0.3;
+			const lum = 0.15 + n * 0.45;
+			const ci = Math.floor(n * (auroraChars.length - 1));
+			line += hsl(hue, sat, lum) + auroraChars[ci];
+		}
+		lines.push(line + reset);
+	}
+	return lines;
+};
+
+// ─── Registry ────────────────────────────────────────────────────
+export type AnimationCategory = "thinking" | "working" | "both";
+
+export type AnimationDefinition = {
+	name: string;
+	fn: AnimationFn;
+	category: AnimationCategory;
+	description: string;
+	lines: number;
+};
+
+export const ANIMATIONS: AnimationDefinition[] = [
+	// 1-line
+	{ name: "neural-pulse", fn: neuralPulse, category: "thinking", description: "Energy pulses along neural pathway", lines: 1 },
+	{ name: "glitch-text", fn: glitchText, category: "both", description: "Cyberpunk glitch effect", lines: 1 },
+	{ name: "plasma-wave", fn: plasmaWave, category: "thinking", description: "Colorful plasma band", lines: 1 },
+	{ name: "pacman", fn: pacmanChase, category: "working", description: "Pac-Man eating dots", lines: 1 },
+	{ name: "matrix", fn: matrixRain, category: "both", description: "Matrix rain", lines: 1 },
+	{ name: "pipeline", fn: pipeline, category: "working", description: "CI/CD pipeline with icons", lines: 1 },
+	{ name: "starfield", fn: starfield, category: "thinking", description: "Horizontal parallax stars", lines: 1 },
+	{ name: "fire", fn: fire, category: "working", description: "Demoscene fire", lines: 1 },
+	{ name: "icon-morph", fn: iconMorphing, category: "both", description: "Morphing nerd font icons", lines: 1 },
+	{ name: "brainstorm", fn: brainstorm, category: "thinking", description: "Weather icon storm", lines: 1 },
+	{ name: "dev-constellation", fn: devConstellation, category: "thinking", description: "Dev icons with pulses", lines: 1 },
+	{ name: "crush", fn: crushScramble, category: "both", description: "Crush-style scrambler", lines: 1 },
+	{ name: "dm-pulse", fn: dmPulse, category: "both", description: "DM pulse animation", lines: 1 },
+	{ name: "shimmer", fn: shimmerText, category: "thinking", description: "Rainbow shimmer text", lines: 1 },
+	{ name: "typewriter", fn: vibeTypewriter, category: "both", description: "Themed typewriter text", lines: 1 },
+	{ name: "orbit-dots", fn: orbitDots, category: "thinking", description: "Pulsing orbit dots", lines: 1 },
+	{ name: "neon-bounce", fn: neonBounce, category: "working", description: "Neon ball bouncing", lines: 1 },
+	// 3-line
+	{ name: "fire3", fn: fire3, category: "working", description: "🔥 Demoscene fire (3-line)", lines: 3 },
+	{ name: "matrix3", fn: matrix3, category: "both", description: "🟢 Matrix rain (3-line)", lines: 3 },
+	{ name: "starfield3", fn: starfield3, category: "thinking", description: "✦ Deep starfield (3-line)", lines: 3 },
+	{ name: "aurora", fn: aurora3, category: "thinking", description: "🌌 Aurora borealis (3-line)", lines: 3 },
+];
+
+export function getAnimation(name: string): AnimationDefinition | undefined {
+	return ANIMATIONS.find(a => a.name === name);
+}
+
+export function getAnimationsForCategory(category: AnimationCategory): AnimationDefinition[] {
+	return ANIMATIONS.filter((animation) => animation.category === category || animation.category === "both");
+}
+
+
+
+export function renderAnimationFrame(name: string, frame: number, width: number, phase: AnimationPhase = "thinking"): string[] {
+	const animation = getAnimation(name) ?? getAnimation("shimmer") ?? ANIMATIONS[0];
+	if (!animation) return ["Thinking..."];
+	const rendered = animation.fn(frame, Math.max(1, Math.floor(width)), phase);
+	return Array.isArray(rendered) ? rendered : [rendered];
+}
+
+export function pickRandomAnimation(category: AnimationCategory, previousName?: string): string {
+	const animations = getAnimationsForCategory(category);
+	if (animations.length === 0) return "shimmer";
+	const candidates = previousName && animations.length > 1 ? animations.filter((animation) => animation.name !== previousName) : animations;
+	const source = candidates.length > 0 ? candidates : animations;
+	const groups = [
+		source.filter((animation) => animation.lines <= 1),
+		source.filter((animation) => animation.lines > 1),
+	].filter((group) => group.length > 0);
+	const group = groups[Math.floor(Math.random() * groups.length)] ?? source;
+	return group[Math.floor(Math.random() * group.length)]!.name;
+}
+
+export type AnimationWidth = "full" | "default" | number;
+
+export function resolveAnimationWidth(setting: AnimationWidth, terminalWidth = process.stdout.columns || 80): number {
+	if (setting === "default") return 50;
+	const maxWidth = Math.max(10, Math.floor(terminalWidth) - 4);
+	if (setting === "full") return maxWidth;
+	return Math.max(10, Math.min(Math.floor(setting), maxWidth));
+}