trama-ui 0.1.0

package/dist/lib/sketches/text-combo-figlet.js

@@ -0,0 +1,91 @@
+import { aspect, createPointer, gridOrigin, hsv, plot } from "../cells.js";
+import { bannerLines } from "../text/banner.js";
+import { textStore } from "../text/store.js";
+/**
+ * Combinación de ambas librerías: asciify-engine genera el arte de texto (FIGlet o
+ * bitmap 7×7) y textmode.js lo dibuja carácter a carácter con onda y ondas de hover.
+ */
+export function txComboFiglet(t) {
+    const ptr = createPointer(t);
+    let lines = [" "];
+    let key = "";
+    let pending = "";
+    let timer;
+    let ripple = -10;
+    let wasPressed = false;
+    const request = (text, font) => {
+        const k = `${font}|${text}`;
+        if (k === key || k === pending)
+            return;
+        pending = k;
+        clearTimeout(timer);
+        timer = setTimeout(async () => {
+            let out = await bannerLines(text, font);
+            // Si no cabe a lo ancho, prueba con fuentes más compactas
+            const cols = t.grid?.cols ?? 100;
+            for (const alt of ["Small", "Mini", "Bitmap"]) {
+                if (Math.max(...out.map((l) => l.length)) <= cols * 0.94)
+                    break;
+                out = await bannerLines(text, alt);
+            }
+            if (pending === k) {
+                lines = out;
+                key = k;
+            }
+        }, 120);
+    };
+    t.draw(() => {
+        ptr.update();
+        const s = t.secs;
+        const asp = aspect(t);
+        const { cols, rows } = gridOrigin(t);
+        request(textStore.text(), textStore.get().font);
+        if (ptr.pressed && !wasPressed)
+            ripple = s;
+        wasPressed = ptr.pressed;
+        const w = Math.max(...lines.map((l) => l.length));
+        const h = lines.length;
+        // Amplía el arte en bloques kx×ky mientras quepa en pantalla
+        const kx = Math.max(1, Math.min(4, Math.floor((cols * 0.92) / w)));
+        const ky = Math.max(1, Math.min(4, Math.floor((rows * 0.8) / h), Math.round(kx / asp)));
+        const ox = -Math.floor((w * kx) / 2);
+        const oy = -Math.floor((h * ky) / 2);
+        const R = 12;
+        t.background(6, 6, 16);
+        for (let j = 0; j < h; j++) {
+            const line = lines[j];
+            for (let i = 0; i < line.length; i++) {
+                const ch = line[i];
+                if (ch === " ")
+                    continue;
+                t.char(ch);
+                for (let sy = 0; sy < ky; sy++) {
+                    for (let sx = 0; sx < kx; sx++) {
+                        const x = ox + i * kx + sx;
+                        const y = oy + j * ky + sy;
+                        let px = x;
+                        let py = y + Math.sin(x * 0.18 + s * 2.4) * 1.2;
+                        const dx = px - ptr.x;
+                        const dy = (py - ptr.y) * asp;
+                        const d = Math.hypot(dx, dy) + 0.001;
+                        if (d < R) {
+                            const k = ((R - d) / R) ** 2;
+                            px += (dx / d) * k * 5;
+                            py += ((dy / d) * k * 5) / asp;
+                        }
+                        const age = s - ripple;
+                        if (age < 2) {
+                            const wave = Math.sin(d * 0.9 - age * 9) * Math.exp(-age * 1.6) * Math.exp(-d * 0.04);
+                            py += wave * 2.5;
+                        }
+                        const hue = (x * 0.008 + s * 0.06 + 0.5) % 1;
+                        t.charColor(...hsv(hue, 0.6, 0.95));
+                        t.cellColor(...hsv(hue, 0.85, 0.12));
+                        if (Math.abs(px) <= cols && Math.abs(py) <= rows)
+                            plot(t, Math.round(px), Math.round(py));
+                    }
+                }
+            }
+        }
+    });
+}

package/dist/lib/sketches/text-glitch.d.ts

@@ -0,0 +1,3 @@
+import type { Textmodifier } from "textmode.js";
+/** Glitch: bandas desplazadas, separación cromática y ruido. El puntero corrompe lo que toca. */
+export declare function txGlitch(t: Textmodifier): void;

package/dist/lib/sketches/text-glitch.js

@@ -0,0 +1,57 @@
+import { aspect, createPointer, gridOrigin, plot } from "../cells.js";
+import { getTextMask } from "../text/mask.js";
+import { textStore } from "../text/store.js";
+const GLYPHS = "01#%&@$/\\|<>";
+/** Glitch: bandas desplazadas, separación cromática y ruido. El puntero corrompe lo que toca. */
+export function txGlitch(t) {
+    const ptr = createPointer(t);
+    let bands = new Float32Array(0);
+    t.draw(() => {
+        ptr.update();
+        const asp = aspect(t);
+        const { cols, rows, x0, y0 } = gridOrigin(t);
+        const mask = getTextMask(textStore.text(), cols, rows, asp);
+        if (bands.length !== rows)
+            bands = new Float32Array(rows);
+        for (let j = 0; j < rows; j++)
+            bands[j] *= 0.82;
+        if (Math.random() < (ptr.pressed ? 0.9 : 0.14)) {
+            const j0 = Math.floor(Math.random() * rows);
+            const len = 1 + Math.floor(Math.random() * 5);
+            const off = (Math.random() - 0.5) * 22;
+            for (let j = j0; j < Math.min(rows, j0 + len); j++)
+                bands[j] = off;
+        }
+        const R = ptr.pressed ? 16 : 9;
+        t.background(4, 4, 10);
+        // Ruido de fondo
+        for (let n = 0; n < 50; n++) {
+            t.char(GLYPHS[Math.floor(Math.random() * GLYPHS.length)]);
+            t.charColor(30, 45, 70);
+            plot(t, x0 + Math.floor(Math.random() * cols), y0 + Math.floor(Math.random() * rows));
+        }
+        for (let j = 0; j < rows; j++) {
+            const dim = j % 3 === 0 ? 0.7 : 1; // líneas de barrido
+            for (let i = 0; i < cols; i++) {
+                if (mask.data[j * cols + i] < 90)
+                    continue;
+                const x = x0 + i;
+                const y = y0 + j;
+                let ox = Math.round(bands[j]);
+                const dx = x - ptr.x;
+                const dy = (y - ptr.y) * asp;
+                const hot = Math.hypot(dx, dy) < R;
+                if (hot)
+                    ox += Math.round((Math.random() - 0.5) * 6);
+                const ch = hot && Math.random() < 0.5 ? GLYPHS[Math.floor(Math.random() * GLYPHS.length)] : "#";
+                t.char(ch);
+                t.charColor(255 * dim, 40, 90 * dim);
+                plot(t, x + ox - 1, y);
+                t.charColor(30, 230 * dim, 255 * dim);
+                plot(t, x + ox + 1, y);
+                t.charColor(245 * dim, 245 * dim, 255 * dim);
+                plot(t, x + ox, y);
+            }
+        }
+    });
+}

package/dist/lib/sketches/text-marquee.d.ts

@@ -0,0 +1,3 @@
+import type { Textmodifier } from "textmode.js";
+/** Marquesinas con `t.print()`: cada fila corre a su velocidad y sentido. El puntero ilumina la fila que toca. */
+export declare function txMarquee(t: Textmodifier): void;

package/dist/lib/sketches/text-marquee.js

@@ -0,0 +1,35 @@
+import { createPointer, gridOrigin, hsv } from "../cells.js";
+import { textStore } from "../text/store.js";
+/** Marquesinas con `t.print()`: cada fila corre a su velocidad y sentido. El puntero ilumina la fila que toca. */
+export function txMarquee(t) {
+    const ptr = createPointer(t);
+    t.draw(() => {
+        ptr.update();
+        const s = t.secs;
+        const text = textStore.text();
+        const unit = `${text}  //  `;
+        const L = unit.length;
+        const { cols, rows, x0, y0 } = gridOrigin(t);
+        const str = unit.repeat(Math.ceil(cols / L) + 2);
+        t.background(6, 8, 18);
+        t.printAlign("left", "top");
+        for (let j = 0; j < rows; j += 2) {
+            const dir = (j / 2) % 2 ? 1 : -1;
+            const speed = 5 + 4 * Math.abs(Math.sin(j * 0.7));
+            const off = (s * speed) % L;
+            const startX = dir < 0 ? x0 - off : x0 - L + off;
+            const y = y0 + j;
+            const hot = Math.abs(y - ptr.y) < 2.5;
+            const hue = (j * 0.012 + s * 0.03 + 0.55) % 1;
+            if (hot) {
+                t.cellColor(...hsv(hue, 0.7, 0.28));
+                t.charColor(255, 240, 200);
+            }
+            else {
+                t.cellColor(6, 8, 18);
+                t.charColor(...hsv(hue, 0.55, 0.42 + 0.25 * Math.abs(Math.sin(j))));
+            }
+            t.print(str, startX, y, { markup: false });
+        }
+    });
+}

package/dist/lib/sketches/text-particles.d.ts

@@ -0,0 +1,9 @@
+import type { Textmodifier } from "textmode.js";
+/**
+ * Partículas con muelle que forman el texto. El puntero las dispersa y pulsar las
+ * hace explotar; al cambiar el texto se reasignan los destinos y vuelan a su sitio.
+ * Con `transparent` no pinta fondo, para superponerlo a otra capa.
+ */
+export declare function txParticles(t: Textmodifier, opts?: {
+    transparent?: boolean;
+}): void;

package/dist/lib/sketches/text-particles.js

@@ -0,0 +1,91 @@
+import { aspect, createPointer, gridOrigin, hsv, plot } from "../cells.js";
+import { getTextMask } from "../text/mask.js";
+import { textStore } from "../text/store.js";
+/**
+ * Partículas con muelle que forman el texto. El puntero las dispersa y pulsar las
+ * hace explotar; al cambiar el texto se reasignan los destinos y vuelan a su sitio.
+ * Con `transparent` no pinta fondo, para superponerlo a otra capa.
+ */
+export function txParticles(t, opts = {}) {
+    const ptr = createPointer(t);
+    const particles = [];
+    let key = "";
+    let wasPressed = false;
+    const retarget = (data, cols, rows, x0, y0) => {
+        const cells = [];
+        for (let j = 0; j < rows; j++)
+            for (let i = 0; i < cols; i++)
+                if (data[j * cols + i] > 140)
+                    cells.push(x0 + i, y0 + j);
+        const total = cells.length / 2;
+        const count = Math.min(2600, total);
+        const step = total / Math.max(1, count);
+        const targets = [];
+        for (let k = 0; k < count; k++) {
+            const idx = Math.floor(k * step);
+            targets.push([cells[idx * 2], cells[idx * 2 + 1]]);
+        }
+        for (let k = targets.length - 1; k > 0; k--) {
+            const r = Math.floor(Math.random() * (k + 1));
+            [targets[k], targets[r]] = [targets[r], targets[k]];
+        }
+        while (particles.length < count) {
+            particles.push({
+                x: x0 + Math.random() * cols,
+                y: y0 + Math.random() * rows,
+                vx: 0,
+                vy: 0,
+                tx: 0,
+                ty: 0,
+            });
+        }
+        particles.length = count;
+        targets.forEach(([tx, ty], k) => {
+            particles[k].tx = tx;
+            particles[k].ty = ty;
+        });
+    };
+    t.draw(() => {
+        ptr.update();
+        const s = t.secs;
+        const asp = aspect(t);
+        const { cols, rows, x0, y0 } = gridOrigin(t);
+        const mask = getTextMask(textStore.text(), cols, rows, asp);
+        if (mask.key !== key) {
+            key = mask.key;
+            retarget(mask.data, cols, rows, x0, y0);
+        }
+        const burst = ptr.pressed && !wasPressed;
+        wasPressed = ptr.pressed;
+        const R = 12;
+        if (opts.transparent)
+            t.clear();
+        else
+            t.background(4, 5, 12);
+        for (const p of particles) {
+            p.vx = (p.vx + (p.tx - p.x) * 0.06) * 0.86;
+            p.vy = (p.vy + (p.ty - p.y) * 0.06) * 0.86;
+            const dx = p.x - ptr.x;
+            const dy = (p.y - ptr.y) * asp;
+            const d = Math.hypot(dx, dy) + 0.001;
+            if (d < R) {
+                const k = ((R - d) / R) * 1.8;
+                p.vx += (dx / d) * k;
+                p.vy += ((dy / d) * k) / asp;
+            }
+            if (burst && d < 40) {
+                p.vx += (dx / d) * 6 * (1 + Math.random());
+                p.vy += ((dy / d) * 6 * (1 + Math.random())) / asp;
+            }
+            p.x += p.vx;
+            p.y += p.vy;
+            const e = Math.hypot(p.vx, p.vy);
+            t.char(e > 1.2 ? "*" : e > 0.35 ? "+" : "#");
+            const hue = (p.tx * 0.007 + s * 0.05 + 0.5) % 1;
+            t.charColor(...hsv(hue, 0.65 - Math.min(e, 1) * 0.3, 0.6 + Math.min(e, 1) * 0.4));
+            if (!opts.transparent)
+                t.cellColor(...hsv(hue, 0.8, 0.07 + Math.min(e, 1) * 0.12));
+            plot(t, Math.round(p.x), Math.round(p.y));
+        }
+    });
+}

package/dist/lib/sketches/text-rain.d.ts

@@ -0,0 +1,3 @@
+import type { Textmodifier } from "textmode.js";
+/** Lluvia digital que se ilumina donde hay texto (con las letras de tu propio texto). El puntero deja rastro de luz. */
+export declare function txRain(t: Textmodifier): void;

package/dist/lib/sketches/text-rain.js

@@ -0,0 +1,73 @@
+import { aspect, createPointer, gridOrigin, plot } from "../cells.js";
+import { getTextMask } from "../text/mask.js";
+import { textStore } from "../text/store.js";
+const GLYPHS = "01ABCDEFGHIJKLMNOPQRSTUVWXYZ<>{}[]/\\|+=*:;#$%&@";
+/** Lluvia digital que se ilumina donde hay texto (con las letras de tu propio texto). El puntero deja rastro de luz. */
+export function txRain(t) {
+    const ptr = createPointer(t);
+    let W = 0;
+    let H = 0;
+    let glow = new Float32Array(0);
+    let heads = [];
+    const rebuild = () => {
+        W = t.grid.cols;
+        H = t.grid.rows;
+        glow = new Float32Array(W * H);
+        heads = Array.from({ length: W }, () => ({ y: Math.random() * H, v: 0.25 + Math.random() * 0.7 }));
+    };
+    t.draw(() => {
+        if (W !== t.grid.cols || H !== t.grid.rows)
+            rebuild();
+        ptr.update();
+        const text = textStore.text();
+        const asp = aspect(t);
+        const { x0, y0 } = gridOrigin(t);
+        const mask = getTextMask(text, W, H, asp);
+        for (let i = 0; i < W; i++) {
+            const h = heads[i];
+            h.y += h.v;
+            if (h.y >= H + 4) {
+                h.y = -Math.random() * H * 0.5;
+                h.v = 0.25 + Math.random() * 0.7;
+            }
+            const row = Math.floor(h.y);
+            if (row >= 0 && row < H)
+                glow[row * W + i] = 1;
+        }
+        if (ptr.raw) {
+            const gx = Math.round(ptr.raw.x - x0);
+            const gy = Math.round(ptr.raw.y - y0);
+            const r = ptr.pressed ? 7 : 3;
+            for (let dy = -r; dy <= r; dy++) {
+                for (let dx = -r * 2; dx <= r * 2; dx++) {
+                    const x = gx + dx;
+                    const y = gy + dy;
+                    if (x >= 0 && y >= 0 && x < W && y < H && Math.hypot(dx / 2, dy) <= r)
+                        glow[y * W + x] = 1;
+                }
+            }
+        }
+        t.background(0, 4, 2);
+        for (let j = 0; j < H; j++) {
+            for (let i = 0; i < W; i++) {
+                const idx = j * W + i;
+                const g = glow[idx];
+                glow[idx] = g * 0.93;
+                const m = mask.data[idx] / 255;
+                const b = Math.max(g, m * 0.55);
+                if (b < 0.05)
+                    continue;
+                const lit = m > 0.4;
+                t.char(lit
+                    ? text[(i + j * 7) % text.length] || "#"
+                    : GLYPHS[(i * 31 + j * 17 + (g > 0.9 ? t.frameCount : 0)) % GLYPHS.length]);
+                if (lit)
+                    t.charColor(120 + 135 * g, 255, 150 + 90 * g);
+                else
+                    t.charColor(0, 60 + 195 * b, 40 * b);
+                t.cellColor(0, lit ? 22 + 30 * b : 6 + 12 * b, lit ? 10 : 3);
+                plot(t, x0 + i, y0 + j);
+            }
+        }
+    });
+}

package/dist/lib/sketches/text-scramble.d.ts

@@ -0,0 +1,6 @@
+import type { Textmodifier } from "textmode.js";
+/**
+ * Decodificado: el texto se descifra de izquierda a derecha entre glifos aleatorios y
+ * se repite. Bajo el puntero las letras se vuelven a mezclar. Efecto típico de titulares.
+ */
+export declare function txScramble(t: Textmodifier): void;

package/dist/lib/sketches/text-scramble.js

@@ -0,0 +1,49 @@
+import { aspect, createPointer, gridOrigin, hsv, plot } from "../cells.js";
+import { getTextMask } from "../text/mask.js";
+import { textStore } from "../text/store.js";
+const GLYPHS = "!<>-_\\/[]{}=+*^?#0123456789ABCDEF";
+/**
+ * Decodificado: el texto se descifra de izquierda a derecha entre glifos aleatorios y
+ * se repite. Bajo el puntero las letras se vuelven a mezclar. Efecto típico de titulares.
+ */
+export function txScramble(t) {
+    const ptr = createPointer(t);
+    t.draw(() => {
+        ptr.update();
+        const s = t.secs;
+        const asp = aspect(t);
+        const { cols, rows, x0, y0 } = gridOrigin(t);
+        const text = textStore.text();
+        const mask = getTextMask(text, cols, rows, asp);
+        // ciclo de 6 s: 3.2 s descifrando, resto en reposo
+        const cycle = (s % 6) / 3.2;
+        const frontier = Math.min(1.15, cycle) * cols;
+        t.background(4, 5, 12);
+        for (let j = 0; j < rows; j++) {
+            for (let i = 0; i < cols; i++) {
+                const m = mask.data[j * cols + i] / 255;
+                if (m < 0.3)
+                    continue;
+                const x = x0 + i;
+                const y = y0 + j;
+                const dx = x - ptr.x;
+                const dy = (y - ptr.y) * asp;
+                const hot = Math.hypot(dx, dy) < (ptr.pressed ? 14 : 8);
+                const decoded = i < frontier - 6 && !hot;
+                const edge = !decoded && i < frontier + 6;
+                if (decoded) {
+                    t.char(text[(i + j * 3) % text.length] || "#");
+                    t.charColor(...hsv(0.5 + i * 0.002, 0.45, 0.95));
+                    t.cellColor(...hsv(0.55, 0.7, 0.1 * m));
+                }
+                else {
+                    t.char(GLYPHS[Math.floor(Math.random() * GLYPHS.length)]);
+                    const hue = hot ? 0.9 : 0.35;
+                    t.charColor(...hsv(hue, 0.7, edge || hot ? 1 : 0.35));
+                    t.cellColor(...hsv(hue, 0.8, edge || hot ? 0.15 : 0.03));
+                }
+                plot(t, x, y);
+            }
+        }
+    });
+}

package/dist/lib/sketches/text-wave.d.ts

@@ -0,0 +1,3 @@
+import type { Textmodifier } from "textmode.js";
+/** Texto grande que ondula. El puntero aparta las letras; al pulsar, con más fuerza. */
+export declare function txWave(t: Textmodifier): void;

package/dist/lib/sketches/text-wave.js

@@ -0,0 +1,43 @@
+import { aspect, createPointer, gridOrigin, hsv, plot } from "../cells.js";
+import { getTextMask } from "../text/mask.js";
+import { textStore } from "../text/store.js";
+/** Texto grande que ondula. El puntero aparta las letras; al pulsar, con más fuerza. */
+export function txWave(t) {
+    const ptr = createPointer(t);
+    const ramp = t.createGlyphRamp(" .:-=+*#%@");
+    const noise = "01#%&@$";
+    t.draw(() => {
+        ptr.update();
+        const s = t.secs;
+        const asp = aspect(t);
+        const { cols, rows, x0, y0 } = gridOrigin(t);
+        const mask = getTextMask(textStore.text(), cols, rows, asp);
+        const R = ptr.pressed ? 18 : 11;
+        t.background(5, 6, 16);
+        for (let j = 0; j < rows; j++) {
+            for (let i = 0; i < cols; i++) {
+                const v = mask.data[j * cols + i] / 255;
+                if (v < 0.3)
+                    continue;
+                const x = x0 + i;
+                const y = y0 + j;
+                let px = x;
+                let py = y + Math.sin(x * 0.22 + s * 3) * 1.6;
+                const dx = px - ptr.x;
+                const dy = (py - ptr.y) * asp;
+                const d = Math.hypot(dx, dy) + 0.001;
+                const near = d < R;
+                if (near) {
+                    const k = (R - d) / R;
+                    px += (dx / d) * k * R * 0.7;
+                    py += ((dy / d) * k * R * 0.7) / asp;
+                }
+                const hue = (x * 0.006 + s * 0.08 + 0.55) % 1;
+                t.char(near && Math.random() < 0.25 ? noise[Math.floor(Math.random() * noise.length)] : ramp.at(v));
+                t.charColor(...hsv(hue, 0.7, 0.5 + 0.5 * v));
+                t.cellColor(...hsv(hue, 0.8, 0.1));
+                plot(t, Math.round(px), Math.round(py));
+            }
+        }
+    });
+}

package/dist/lib/sketches/theme-orbit.d.ts

@@ -0,0 +1,6 @@
+import type { Textmodifier } from "textmode.js";
+/**
+ * Órbita: del pie de la rampa de lanzamiento al espacio. El cielo se oscurece, el cohete
+ * asciende dejando estela de fuego, aparece el limbo del planeta y, al final, la luna.
+ */
+export declare function thOrbit(t: Textmodifier): void;

package/dist/lib/sketches/theme-orbit.js

@@ -0,0 +1,119 @@
+import { createPointer, eachCell, hash2, mix } from "../cells.js";
+import { clamp, scrollState, smooth, span } from "../scroll/store.js";
+/**
+ * Órbita: del pie de la rampa de lanzamiento al espacio. El cielo se oscurece, el cohete
+ * asciende dejando estela de fuego, aparece el limbo del planeta y, al final, la luna.
+ */
+export function thOrbit(t) {
+    const ptr = createPointer(t);
+    t.draw(() => {
+        ptr.update();
+        const p = scrollState.p;
+        const s = t.secs;
+        const { cols, rows } = t.grid;
+        const ground = smooth(span(p, 0, 0.3)); // la rampa se aleja hacia abajo
+        const space = smooth(span(p, 0.08, 0.55));
+        const planetUp = smooth(span(p, 0.3, 0.75));
+        const moon = smooth(span(p, 0.8, 1));
+        const groundH = Math.max(0, rows * 0.22 - ground * rows * 0.5); // altura del suelo (celdas)
+        const lift = smooth(span(p, 0.03, 0.5)) * rows * 1.5;
+        const baseAlt = groundH + 1 + lift; // altura de la base del cohete
+        const R = cols * 1.4; // radio del planeta en celdas
+        const topRow = rows * mix(1.25, 0.6, planetUp); // fila (desde arriba) donde asoma el limbo
+        const pcy = topRow + R;
+        const skyTop = [mix(25, 2, space), mix(70, 3, space), mix(160, 14, space)];
+        const skyLow = [mix(120, 4, space), mix(180, 6, space), mix(235, 24, space)];
+        t.background(0);
+        eachCell(t, (x, _y, _i, j) => {
+            const alt = rows - 1 - j; // altura sobre el borde inferior
+            // rampa de lanzamiento
+            if (alt < groundH) {
+                const tower = Math.abs(x + cols * 0.16) <= 1 && alt < groundH + rows * 0.3;
+                t.char(tower ? (alt % 3 === 0 ? "=" : "|") : "#");
+                t.charColor(70, 80, 100);
+                t.cellColor(14, 16, 26);
+                return;
+            }
+            if (ground < 0.9 && Math.abs(x + cols * 0.16) <= 1 && alt < groundH + rows * 0.34) {
+                t.char(alt % 3 === 0 ? "=" : "|");
+                t.charColor(90, 100, 125);
+                t.cellColor(...(skyLowAt(alt / rows)));
+                return;
+            }
+            // cohete
+            const rb = alt - baseAlt;
+            if (rb >= 0 && rb < 10 && Math.abs(x) <= (rb < 3 ? 2 : 1)) {
+                const fin = rb < 3 && Math.abs(x) === 2;
+                t.char(rb === 9 ? "^" : fin ? (x < 0 ? "/" : "\\") : rb === 5 ? "o" : "H");
+                t.charColor(...(fin ? [255, 90, 80] : [245, 245, 255]));
+                t.cellColor(50, 54, 70);
+                return;
+            }
+            // llama y estela
+            if (lift > 0.5 || p < 0.02) {
+                const fd = baseAlt - alt; // profundidad bajo el cohete
+                if (fd > 0 && fd < rows * 0.35 && Math.abs(x) <= Math.max(0, 2.2 - fd * 0.06)) {
+                    const f = hash2(x, Math.floor(s * 14 + alt));
+                    if (f > fd / (rows * 0.35)) {
+                        t.char(f > 0.8 ? "*" : "^");
+                        t.charColor(255, 170 + f * 80, 60 + (fd / rows) * 200);
+                        t.cellColor(70 * (1 - fd / (rows * 0.35)), 25, 0);
+                        return;
+                    }
+                }
+            }
+            // planeta
+            const dPlanet = Math.hypot(x + (ptr.x / cols) * 6, j - pcy);
+            if (planetUp > 0.01 && dPlanet < R) {
+                const n = t.noise(x * 0.05 + s * 0.02, j * 0.12) * 0.95;
+                const rim = 1 - dPlanet / R;
+                const cloud = n > 0.58;
+                const land = n > 0.4;
+                t.char(cloud ? "%" : land ? "+" : ".");
+                t.charColor(...(cloud ? [235, 245, 255] : land ? [70, 170, 110] : [40, 110, 210]));
+                t.cellColor(6, 20 + rim * 60, 50 + rim * 110);
+                return;
+            }
+            const halo = Math.exp(-(((dPlanet - R) / (rows * 0.05)) ** 2)) * planetUp;
+            if (halo > 0.1) {
+                t.char("~");
+                t.charColor(120, 200, 255, 200 * halo);
+                t.cellColor(10, 30 * halo, 80 * halo);
+                return;
+            }
+            // luna con cráteres
+            if (moon > 0.01) {
+                const d = Math.hypot(x - cols * 0.22, (j - rows * 0.26) * 1);
+                if (d < rows * 0.2 * moon) {
+                    const crater = hash2(Math.floor(x / 2), Math.floor(j / 2)) > 0.84;
+                    t.char(crater ? "o" : ".");
+                    t.charColor(215, 217, 226);
+                    t.cellColor(72, 74, 86);
+                    return;
+                }
+            }
+            // cielo
+            const k = clamp(alt / rows);
+            t.cellColor(mix(skyLow[0], skyTop[0], k), mix(skyLow[1], skyTop[1], k), mix(skyLow[2], skyTop[2], k));
+            if (hash2(x, j) > 1 - 0.04 * space) {
+                const tw = Math.sin(s * 2 + hash2(j, x) * 60) * 0.5 + 0.5;
+                t.char(tw > 0.5 ? "*" : ".");
+                t.charColor(255, 255, 255, 80 + 175 * tw);
+                return;
+            }
+            // nubes de día
+            if (space < 0.4) {
+                const c = t.noise(x * 0.05 + s * 0.03, alt * 0.09) * (1 - space / 0.4);
+                if (c > 0.55 && k > 0.15 && k < 0.7) {
+                    t.char(c > 0.66 ? "%" : "~");
+                    t.charColor(255, 255, 255, 190);
+                    return;
+                }
+            }
+            t.char(" ");
+        });
+        function skyLowAt(k) {
+            return [mix(skyLow[0], skyTop[0], k), mix(skyLow[1], skyTop[1], k), mix(skyLow[2], skyTop[2], k)];
+        }
+    });
+}

package/dist/lib/sketches/theme-pulse.d.ts

@@ -0,0 +1,7 @@
+import type { Textmodifier } from "textmode.js";
+/**
+ * Pulso: ciudad nocturna con lluvia, tres capas de edificios con ventanas parpadeantes y
+ * un cartel de neón. Al bajar, la cámara sube de la calle a las azoteas y el neón vira de
+ * rosa a cian.
+ */
+export declare function thPulse(t: Textmodifier): void;