dexterm-cli 0.0.0-stage → 0.1.2

package/dist/packages/tui/src/raster.js

@@ -0,0 +1,213 @@
+import { ATTR_BOLD, ATTR_DIM, ATTR_UNDERLINE } from "./canvas.js";
+import { hexToRgb, mix } from "./color.js";
+import { glyphBits, FONT_W, FONT_H } from "./raster-font.js";
+class Px {
+    w;
+    h;
+    rgba;
+    constructor(w, h) { this.w = w; this.h = h; this.rgba = new Uint8Array(w * h * 4); }
+    rect(x, y, w, h, c, a = 1) {
+        const x0 = Math.max(0, Math.floor(x)), y0 = Math.max(0, Math.floor(y));
+        const x1 = Math.min(this.w, Math.floor(x + w)), y1 = Math.min(this.h, Math.floor(y + h));
+        for (let yy = y0; yy < y1; yy++)
+            for (let xx = x0; xx < x1; xx++) {
+                const i = (yy * this.w + xx) * 4;
+                if (a >= 1) {
+                    this.rgba[i] = c[0];
+                    this.rgba[i + 1] = c[1];
+                    this.rgba[i + 2] = c[2];
+                }
+                else {
+                    this.rgba[i] = Math.round(this.rgba[i] * (1 - a) + c[0] * a);
+                    this.rgba[i + 1] = Math.round(this.rgba[i + 1] * (1 - a) + c[1] * a);
+                    this.rgba[i + 2] = Math.round(this.rgba[i + 2] * (1 - a) + c[2] * a);
+                }
+                this.rgba[i + 3] = 255;
+            }
+    }
+}
+// Box drawing: up, down, left, right weights (0 none, 1 light, 2 heavy/double) and a dashed flag.
+const BOX = {
+    '─': '0011', '━': '0022', '│': '1100', '┃': '2200',
+    '┌': '0101', '╭': '0101', '┐': '0110', '╮': '0110', '└': '1001', '╰': '1001', '┘': '1010', '╯': '1010',
+    '┏': '0202', '┓': '0220', '┗': '2002', '┛': '2020',
+    '├': '1101', '┤': '1110', '┬': '0111', '┴': '1011', '┼': '1111',
+    '┣': '2202', '┫': '2220', '┳': '0222', '┻': '2022', '╋': '2222',
+    '═': '0022', '║': '2200', '╔': '0202', '╗': '0220', '╚': '2002', '╝': '2020', '╠': '2202', '╣': '2220', '╦': '0222', '╩': '2022', '╬': '2222',
+    '╴': '0010', '╵': '1000', '╶': '0001', '╷': '0100', '╸': '0020', '╹': '2000', '╺': '0002', '╻': '0200',
+};
+const DASH_H = new Set(['┄', '┅', '┈', '┉', '╌', '╍']);
+const DASH_V = new Set(['┆', '┇', '┊', '┋', '╎', '╏']);
+const EIGHTHS_LOW = '▁▂▃▄▅▆▇█';
+const EIGHTHS_LEFT = '▏▎▍▌▋▊▉█';
+const SHADES = { '░': 0.25, '▒': 0.5, '▓': 0.75 };
+// Quadrants: TL, TR, BL, BR.
+const QUAD = {
+    '▘': [1, 0, 0, 0], '▝': [0, 1, 0, 0], '▖': [0, 0, 1, 0], '▗': [0, 0, 0, 1], '▚': [1, 0, 0, 1], '▞': [0, 1, 1, 0],
+    '▛': [1, 1, 1, 0], '▜': [1, 1, 0, 1], '▙': [1, 0, 1, 1], '▟': [0, 1, 1, 1], '▀': [1, 1, 0, 0], '▄': [0, 0, 1, 1], '▌': [1, 0, 1, 0], '▐': [0, 1, 0, 1],
+};
+/** Draw one non-text glyph procedurally. Returns false when the glyph is not one of these families. */
+function drawSpecial(p, ch, x, y, cw, chh, fg, bg, scale) {
+    const box = BOX[ch];
+    if (box) {
+        const t1 = Math.max(1, scale), t2 = Math.max(2, scale * 2);
+        const [u, d, l, r] = [...box].map(Number);
+        const cx = x + Math.floor(cw / 2), cy = y + Math.floor(chh / 2);
+        const th = (wgt) => (wgt === 2 ? t2 : t1);
+        const hT = Math.max(th(l), th(r)), vT = Math.max(th(u), th(d));
+        if (l)
+            p.rect(x, cy - Math.floor(th(l) / 2), cx - x + Math.ceil(vT / 2), th(l), fg);
+        if (r)
+            p.rect(cx - Math.floor(vT / 2), cy - Math.floor(th(r) / 2), x + cw - (cx - Math.floor(vT / 2)), th(r), fg);
+        if (u)
+            p.rect(cx - Math.floor(th(u) / 2), y, th(u), cy - y + Math.ceil(hT / 2), fg);
+        if (d)
+            p.rect(cx - Math.floor(th(d) / 2), cy - Math.floor(hT / 2), th(d), y + chh - (cy - Math.floor(hT / 2)), fg);
+        return true;
+    }
+    if (DASH_H.has(ch)) {
+        const t = Math.max(1, scale);
+        const seg = Math.max(2, Math.floor(cw / 4));
+        for (let k = 0; k < cw; k += seg * 2)
+            p.rect(x + k, y + Math.floor(chh / 2) - Math.floor(t / 2), seg, t, fg);
+        return true;
+    }
+    if (DASH_V.has(ch)) {
+        const t = Math.max(1, scale);
+        const seg = Math.max(2, Math.floor(chh / 6));
+        for (let k = 0; k < chh; k += seg * 2)
+            p.rect(x + Math.floor(cw / 2) - Math.floor(t / 2), y + k, t, seg, fg);
+        return true;
+    }
+    const low = EIGHTHS_LOW.indexOf(ch);
+    if (low >= 0) {
+        const hh = Math.round((chh * (low + 1)) / 8);
+        p.rect(x, y + chh - hh, cw, hh, fg);
+        return true;
+    }
+    const left = EIGHTHS_LEFT.indexOf(ch);
+    if (left >= 0) {
+        p.rect(x, y, Math.round((cw * (left + 1)) / 8), chh, fg);
+        return true;
+    }
+    if (ch === '▔') {
+        p.rect(x, y, cw, Math.max(1, Math.round(chh / 8)), fg);
+        return true;
+    }
+    if (ch === '▕') {
+        const ww = Math.max(1, Math.round(cw / 8));
+        p.rect(x + cw - ww, y, ww, chh, fg);
+        return true;
+    }
+    const shade = SHADES[ch];
+    if (shade !== undefined) {
+        p.rect(x, y, cw, chh, [Math.round(bg[0] + (fg[0] - bg[0]) * shade), Math.round(bg[1] + (fg[1] - bg[1]) * shade), Math.round(bg[2] + (fg[2] - bg[2]) * shade)]);
+        return true;
+    }
+    const q = QUAD[ch];
+    if (q) {
+        const hw = Math.floor(cw / 2), hh = Math.floor(chh / 2);
+        if (q[0])
+            p.rect(x, y, hw, hh, fg);
+        if (q[1])
+            p.rect(x + hw, y, cw - hw, hh, fg);
+        if (q[2])
+            p.rect(x, y + hh, hw, chh - hh, fg);
+        if (q[3])
+            p.rect(x + hw, y + hh, cw - hw, chh - hh, fg);
+        return true;
+    }
+    const code = ch.codePointAt(0) ?? 0;
+    if (code >= 0x2800 && code <= 0x28ff) {
+        const bits = code - 0x2800;
+        // dot n → (column, row): 1(0,0) 2(0,1) 3(0,2) 4(1,0) 5(1,1) 6(1,2) 7(0,3) 8(1,3)
+        const dots = [[0x01, 0, 0], [0x02, 0, 1], [0x04, 0, 2], [0x08, 1, 0], [0x10, 1, 1], [0x20, 1, 2], [0x40, 0, 3], [0x80, 1, 3]];
+        const dw = Math.max(1, Math.floor(cw / 4)), dh = Math.max(1, Math.floor(chh / 8));
+        for (const [bit, col, row] of dots)
+            if (bits & bit)
+                p.rect(x + Math.floor((cw * (col * 2 + 1)) / 4) - Math.floor(dw / 2), y + Math.floor((chh * (row * 2 + 1)) / 8) - Math.floor(dh / 2), dw, dh, fg);
+        return true;
+    }
+    if (ch === '╱' || ch === '╲' || ch === '╳') {
+        const t = Math.max(1, scale);
+        for (let k = 0; k < chh; k++) {
+            const fx = Math.floor((k * cw) / chh);
+            if (ch !== '╲')
+                p.rect(x + cw - 1 - fx - Math.floor(t / 2), y + k, t, 1, fg);
+            if (ch !== '╱')
+                p.rect(x + fx - Math.floor(t / 2), y + k, t, 1, fg);
+        }
+        return true;
+    }
+    return false;
+}
+/** Rasterize every cell of a canvas: background, glyph (font or procedural), attributes, then image slots. */
+export function rasterizeCanvas(c, opts = {}) {
+    const cw = opts.cellW ?? 12, chh = opts.cellH ?? 24, scale = opts.scale ?? 2;
+    const p = new Px(c.w * cw, c.h * chh);
+    const gx = Math.floor((cw - FONT_W * scale) / 2), gy = Math.floor((chh - FONT_H * scale) / 2);
+    const rgbCache = new Map();
+    const rgb = (h) => { let v = rgbCache.get(h); if (!v) {
+        v = hexToRgb(h);
+        rgbCache.set(h, v);
+    } return v; };
+    for (let row = 0; row < c.h; row++)
+        for (let col = 0; col < c.w; col++) {
+            const i = row * c.w + col;
+            const x = col * cw, y = row * chh;
+            const bgHex = c.bg[i];
+            const bg = rgb(bgHex);
+            p.rect(x, y, cw, chh, bg);
+            const ch = c.ch[i];
+            if (ch === ' ' || ch === '')
+                continue;
+            const at = c.at[i];
+            const fg = rgb(at & ATTR_DIM ? mix(c.fg[i], bgHex, 0.45) : c.fg[i]);
+            if (drawSpecial(p, ch, x, y, cw, chh, fg, bg, scale))
+                continue;
+            let bits = glyphBits(ch);
+            // an accented LETTER falls back to its base letter (é → e); never a digit or symbol, whose compatibility form
+            // can change meaning (a subscript ₅ is not a 5)
+            if (!bits && /^\p{L}$/u.test(ch)) {
+                const base = ch.normalize('NFD').replace(/\p{M}+/gu, '');
+                if (base && base !== ch)
+                    bits = glyphBits(base[0]);
+            }
+            if (!bits) {
+                // tofu: a hollow box so an unsupported glyph is visible, never silently dropped
+                const t = Math.max(1, Math.floor(scale / 2));
+                const bx = x + gx + scale, by = y + gy + scale * 2, bw = (FONT_W - 2) * scale, bh = (FONT_H - 4) * scale;
+                p.rect(bx, by, bw, t, fg);
+                p.rect(bx, by + bh - t, bw, t, fg);
+                p.rect(bx, by, t, bh, fg);
+                p.rect(bx + bw - t, by, t, bh, fg);
+                continue;
+            }
+            const bold = (at & ATTR_BOLD) !== 0;
+            for (let yy = 0; yy < FONT_H; yy++)
+                for (let xx = 0; xx < FONT_W; xx++) {
+                    if (!bits[yy * FONT_W + xx])
+                        continue;
+                    p.rect(x + gx + xx * scale, y + gy + yy * scale, scale + (bold ? 1 : 0), scale, fg);
+                }
+            if (at & ATTR_UNDERLINE)
+                p.rect(x, y + chh - Math.max(1, scale), cw, Math.max(1, Math.floor(scale / 2)), fg);
+        }
+    // Pixel image slots (coin images) recorded by the canvas in 'pixels' mode: nearest-neighbour into the cell rect.
+    for (const s of c.images) {
+        const rx = s.x * cw, ry = s.y * chh, rw = s.w * cw, rh = s.h * chh;
+        const { w: iw, h: ih, rgba } = s.img;
+        if (!iw || !ih)
+            continue;
+        for (let yy = 0; yy < rh; yy++)
+            for (let xx = 0; xx < rw; xx++) {
+                const sx = Math.min(iw - 1, Math.floor((xx * iw) / rw)), sy = Math.min(ih - 1, Math.floor((yy * ih) / rh));
+                const si = (sy * iw + sx) * 4;
+                const a = rgba[si + 3] / 255;
+                if (a <= 0)
+                    continue;
+                p.rect(rx + xx, ry + yy, 1, 1, [rgba[si], rgba[si + 1], rgba[si + 2]], a);
+            }
+    }
+    return { w: p.w, h: p.h, rgba: p.rgba };
+}

package/dist/packages/tui/src/sound.js

@@ -0,0 +1,177 @@
+// @dexterm/tui — sound cues (task-1340, ported from prototype-v2/src/sound.mjs, task-1291). Synthesized locally
+// into tiny 16-bit mono WAV files on first use (~/.dexterm/sounds, DEXTERM_HOME overrides) and played with the
+// OS player (`afplay` on macOS, `paplay`/`aplay` on Linux) in a DETACHED child: never blocks the render loop,
+// never waits. MUTED by default; `--sound` (or DEXTERM_SOUND=1) turns the cues on. Cues only ever follow a
+// SETTLED outcome (playMoment is called with the same moment fireMoment produced): nothing chirps on a quote.
+//
+// Cues (all short, all quiet, none mocking):
+//   buy      up-chirp         sine sweep 440→880 Hz, 140 ms
+//   sell     down-sweep       sine sweep 880→440 Hz, 160 ms
+//   profit   chime            E5 + B5 with a soft 2nd harmonic, 420 ms
+//   loss     thud             low sine 110→50 Hz + brief noise, 200 ms
+//   error    buzz             120 Hz square-ish with 25 Hz amplitude modulation, 220 ms
+import { writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const RATE = 22050;
+export const CUES = ['buy', 'sell', 'profit', 'loss', 'error'];
+/** Where the cue files live: `$DEXTERM_HOME/sounds`, default `~/.dexterm/sounds`. */
+export function soundDir(env = process.env) {
+    return join(env.DEXTERM_HOME && env.DEXTERM_HOME.trim() ? env.DEXTERM_HOME : join(homedir(), '.dexterm'), 'sounds');
+}
+/** `--sound` or DEXTERM_SOUND=1 turns cues on; everything else is muted. */
+export function soundOn(flag, env = process.env) {
+    if (flag)
+        return true;
+    const e = (env.DEXTERM_SOUND ?? '').trim().toLowerCase();
+    return e === '1' || e === 'true' || e === 'on';
+}
+function env(i, n, attack = 0.01, release = 0.4) {
+    const t = i / n;
+    const a = Math.min(1, (i / RATE) / attack);
+    const r = t > 1 - release ? (1 - t) / release : 1;
+    return a * r;
+}
+/** Synthesize one cue as float samples in [-1, 1], peak-normalised to −6 dBFS. */
+export function synth(name) {
+    const dur = { buy: 0.14, sell: 0.16, profit: 0.42, loss: 0.2, error: 0.22 }[name];
+    const n = Math.floor(RATE * dur);
+    const out = new Float32Array(n);
+    let ph = 0, ph2 = 0;
+    let seed = 12345;
+    const noise = () => { seed = (seed * 1664525 + 1013904223) >>> 0; return seed / 4294967296 * 2 - 1; };
+    for (let i = 0; i < n; i++) {
+        const t = i / RATE, u = i / n;
+        let s = 0;
+        if (name === 'buy') {
+            const f = 440 * Math.pow(2, u);
+            ph += 2 * Math.PI * f / RATE;
+            s = Math.sin(ph) * 0.8 + Math.sin(2 * ph) * 0.15;
+            s *= env(i, n, 0.005, 0.5);
+        }
+        else if (name === 'sell') {
+            const f = 880 * Math.pow(0.5, u);
+            ph += 2 * Math.PI * f / RATE;
+            s = Math.sin(ph) * 0.8 + Math.sin(2 * ph) * 0.1;
+            s *= env(i, n, 0.005, 0.5);
+        }
+        else if (name === 'profit') {
+            ph += 2 * Math.PI * 659.25 / RATE;
+            ph2 += 2 * Math.PI * 987.77 / RATE;
+            const second = t > 0.09 ? 1 : 0;
+            s = (Math.sin(ph) * 0.6 + Math.sin(2 * ph) * 0.12) * Math.exp(-t * 6) + second * (Math.sin(ph2) * 0.6 + Math.sin(2 * ph2) * 0.1) * Math.exp(-(t - 0.09) * 5);
+            s *= env(i, n, 0.004, 0.25);
+        }
+        else if (name === 'loss') {
+            const f = 110 * Math.pow(50 / 110, u);
+            ph += 2 * Math.PI * f / RATE;
+            s = Math.sin(ph) * 0.9 * Math.exp(-t * 9) + noise() * 0.12 * Math.exp(-t * 40);
+            s *= env(i, n, 0.003, 0.3);
+        }
+        else {
+            ph += 2 * Math.PI * 120 / RATE;
+            const sq = Math.tanh(Math.sin(ph) * 3) * 0.5;
+            const am = 0.55 + 0.45 * Math.sin(2 * Math.PI * 25 * t);
+            s = sq * am * env(i, n, 0.004, 0.2);
+        }
+        out[i] = s;
+    }
+    let peak = 0;
+    for (const x of out)
+        peak = Math.max(peak, Math.abs(x));
+    const g = peak > 0 ? 0.5 / peak : 1;
+    return out.map((x) => x * g);
+}
+/** 16-bit mono PCM WAV container. */
+export function wav(samples) {
+    const n = samples.length;
+    const buf = Buffer.alloc(44 + n * 2);
+    buf.write('RIFF', 0);
+    buf.writeUInt32LE(36 + n * 2, 4);
+    buf.write('WAVE', 8);
+    buf.write('fmt ', 12);
+    buf.writeUInt32LE(16, 16);
+    buf.writeUInt16LE(1, 20);
+    buf.writeUInt16LE(1, 22);
+    buf.writeUInt32LE(RATE, 24);
+    buf.writeUInt32LE(RATE * 2, 28);
+    buf.writeUInt16LE(2, 32);
+    buf.writeUInt16LE(16, 34);
+    buf.write('data', 36);
+    buf.writeUInt32LE(n * 2, 40);
+    for (let i = 0; i < n; i++)
+        buf.writeInt16LE(Math.max(-32768, Math.min(32767, Math.round(samples[i] * 32767))), 44 + i * 2);
+    return buf;
+}
+/** Write every cue to `dir` (created). Idempotent; ~30 KB total. Returns the paths. */
+export function writeCues(dir) {
+    mkdirSync(dir, { recursive: true });
+    const out = [];
+    for (const name of CUES) {
+        const p = join(dir, `${name}.wav`);
+        if (!existsSync(p))
+            writeFileSync(p, wav(synth(name)));
+        out.push(p);
+    }
+    return out;
+}
+/** The OS player for this platform (null = no known player → cues are silently skipped). */
+export function defaultPlayer(platform = process.platform) {
+    if (platform === 'darwin')
+        return 'afplay';
+    if (platform === 'linux')
+        return 'paplay';
+    return null;
+}
+/** Non-blocking playback. Returns true when a cue was dispatched (false when muted / no player / no file). */
+export function play(name, sound, opts = {}) {
+    if (!sound || !sound.on)
+        return false;
+    const dir = opts.dir ?? soundDir();
+    const player = opts.player === undefined ? defaultPlayer() : opts.player;
+    if (opts.log) {
+        opts.log.push({ name, at: Date.now() });
+        return true;
+    }
+    if (!player)
+        return false;
+    try {
+        writeCues(dir);
+        const file = join(dir, `${name}.wav`);
+        const child = (opts.spawnFn ?? spawn)(player, [file], { detached: true, stdio: 'ignore' });
+        child.on('error', () => { });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Which cues a settled moment plays (sell sweep, then the verdict cue 150 ms later). Inflight plays nothing. */
+export function cuesFor(kind, milestone = null) {
+    if (kind === 'buy')
+        return milestone === 'first' ? [['buy', 0], ['profit', 180]] : [['buy', 0]];
+    if (kind === 'profit')
+        return [['sell', 0], ['profit', 150]];
+    if (kind === 'loss')
+        return [['sell', 0], ['loss', 150]];
+    if (kind === 'failed')
+        return [['error', 0]];
+    if (kind === 'runner')
+        return [['profit', 0]];
+    return [];
+}
+export function playMoment(kind, milestone, sound, opts = {}) {
+    let n = 0;
+    for (const [name, delay] of cuesFor(kind, milestone)) {
+        n += 1;
+        if (delay) {
+            const tm = setTimeout(() => play(name, sound, opts), delay);
+            tm.unref?.();
+        }
+        else
+            play(name, sound, opts);
+    }
+    return n;
+}

package/dist/packages/tui/src/theme.js

@@ -0,0 +1,182 @@
+/** Effect tokens for the non-cyberspace themes: effects still run, but their glyphs sit close to the theme's own dim/border. */
+const BASE_FX = {
+    rain: ['#1a2230', '#243244', '#33465c', '#5b7893'],
+    rainPump: ['#2a2414', '#5a4a1a', '#a98a2a', '#ffe08a'],
+    rainDump: ['#2a1418', '#5a1f2a', '#a93145', '#ff9db0'],
+    magenta: '#f472b6',
+    cyan: '#22d3ee',
+    coral: '#d97757',
+    acid: '#fbbf24',
+    glow: '#1b3d2c',
+    scan: '#000000',
+    logo: ['#22d3ee', '#2dd4bf', '#34d399'],
+};
+export const THEMES = {
+    cyberspace: {
+        name: 'cyberspace',
+        bg: '#020507',
+        panel: '#03090c',
+        panelAlt: '#051017',
+        border: '#0c3a24',
+        borderFocus: '#39ff14',
+        text: '#eafff0', // numbers, tickers: near-white with a phosphor cast (≈ 19:1 on bg)
+        muted: '#62c98a', // secondary labels (≈ 9:1 on bg)
+        dim: '#3aa866', // tertiary: gridlines, hints (6.8:1 on bg, 4.9:1 on the selected row)
+        accent: '#00f0ff', // electric cyan: selection, sort, links
+        accentSoft: '#043a40',
+        up: '#5dff6e', // phosphor green (direction also carries a ▲ glyph)
+        upSoft: '#0a3a16',
+        down: '#ff3b6b', // hot red/pink (direction also carries a ▼ glyph)
+        downSoft: '#3d0a1a',
+        warn: '#f5ff2d', // acid yellow
+        warnSoft: '#35380a',
+        ai: '#d97757', // Claude coral/terracotta: the analyst's voice
+        aiSoft: '#3a1a10',
+        pump: '#ff2bd6', // hot magenta
+        dbc: '#ff8a3d',
+        raydium: '#00f0ff',
+        meteora: '#ffb02e',
+        bonk: '#f5ff2d',
+        selBg: '#082618', // was #0a2e1b; darkened after the calm audit so `down` digits on the selected row clear 4.5:1 (4.29 → 4.68)
+        headBg: '#020a08',
+        tabActiveBg: '#0b3b22',
+        sparkUp: '#5dff6e',
+        sparkDown: '#ff3b6b',
+        heat: ['#062013', '#0a4a2a', '#13a04a', '#39ff14'],
+        rain: ['#06301a', '#0b5a2c', '#16a848', '#b8ffc8'],
+        rainPump: ['#3a2a05', '#8a6410', '#f0b429', '#fff1b3'],
+        rainDump: ['#3a0a12', '#7a1226', '#d12a4a', '#ffb3c1'],
+        magenta: '#ff2bd6',
+        cyan: '#00f0ff',
+        coral: '#d97757',
+        acid: '#f5ff2d',
+        glow: '#0f4d2a',
+        scan: '#000000',
+        logo: ['#39ff14', '#00f0ff', '#ff2bd6'],
+    },
+    midnight: {
+        name: 'midnight',
+        bg: '#0b0e14',
+        panel: '#0f131b',
+        panelAlt: '#121823',
+        border: '#1f2733',
+        borderFocus: '#2dd4bf',
+        text: '#d6dde6',
+        muted: '#7c8794',
+        dim: '#4b5563',
+        accent: '#22d3ee',
+        accentSoft: '#164e63',
+        up: '#34d399',
+        upSoft: '#064e3b',
+        down: '#f87171',
+        downSoft: '#4c1d24',
+        warn: '#fbbf24',
+        warnSoft: '#3f2f05',
+        ai: '#a78bfa',
+        aiSoft: '#2e1065',
+        pump: '#f472b6',
+        dbc: '#fb923c',
+        raydium: '#60a5fa',
+        meteora: '#f59e0b',
+        bonk: '#fde047',
+        selBg: '#182233',
+        headBg: '#0d1118',
+        tabActiveBg: '#1b2a36',
+        sparkUp: '#34d399',
+        sparkDown: '#f87171',
+        heat: ['#1b2a36', '#164e63', '#0e7490', '#22d3ee'],
+        ...BASE_FX,
+    },
+    ember: {
+        name: 'ember',
+        bg: '#120d0b',
+        panel: '#17110e',
+        panelAlt: '#1d1512',
+        border: '#3a2a22',
+        borderFocus: '#fb923c',
+        text: '#eadfd6',
+        muted: '#9a8578',
+        dim: '#5e4a3f',
+        accent: '#fb923c',
+        accentSoft: '#5a2e0f',
+        up: '#4ade80',
+        upSoft: '#113b26',
+        down: '#fb7185',
+        downSoft: '#4c1a27',
+        warn: '#facc15',
+        warnSoft: '#433a07',
+        ai: '#c4b5fd',
+        aiSoft: '#2d1b55',
+        pump: '#f472b6',
+        dbc: '#fdba74',
+        raydium: '#7dd3fc',
+        meteora: '#fcd34d',
+        bonk: '#fde68a',
+        selBg: '#2a1c15',
+        headBg: '#150f0c',
+        tabActiveBg: '#3a2416',
+        sparkUp: '#4ade80',
+        sparkDown: '#fb7185',
+        heat: ['#2a1c15', '#5a2e0f', '#b45309', '#fb923c'],
+        ...BASE_FX,
+        rain: ['#2a1c15', '#3f2a1c', '#5e3f2a', '#9a6a45'],
+        logo: ['#fb923c', '#facc15', '#fb7185'],
+    },
+    paper: {
+        name: 'paper',
+        bg: '#f6f3ee',
+        panel: '#fbfaf7',
+        panelAlt: '#f0ece5',
+        border: '#d9d2c7',
+        borderFocus: '#0f766e',
+        text: '#1f2933',
+        muted: '#6b7280',
+        dim: '#a8a29e',
+        accent: '#0e7490',
+        accentSoft: '#cffafe',
+        up: '#15803d',
+        upSoft: '#dcfce7',
+        down: '#b91c1c',
+        downSoft: '#fee2e2',
+        warn: '#b45309',
+        warnSoft: '#fef3c7',
+        ai: '#6d28d9',
+        aiSoft: '#ede9fe',
+        pump: '#be185d',
+        dbc: '#c2410c',
+        raydium: '#1d4ed8',
+        meteora: '#b45309',
+        bonk: '#a16207',
+        selBg: '#e7e1d6',
+        headBg: '#ebe6dd',
+        tabActiveBg: '#dcd5c8',
+        sparkUp: '#15803d',
+        sparkDown: '#b91c1c',
+        heat: ['#e7e1d6', '#a5f3fc', '#22d3ee', '#0e7490'],
+        ...BASE_FX,
+        rain: ['#ece7df', '#ddd6cb', '#c6bdb0', '#9c9184'],
+        glow: '#dcefe4',
+        scan: '#ffffff',
+        logo: ['#0e7490', '#0f766e', '#6d28d9'],
+    },
+};
+/** `t` cycles in this order: cyberspace → midnight → ember → paper. */
+export const THEME_NAMES = ['cyberspace', 'midnight', 'ember', 'paper'];
+export const DEFAULT_THEME = 'cyberspace';
+export function isThemeName(s) {
+    return THEME_NAMES.includes(s);
+}
+export function nextTheme(current) {
+    const i = THEME_NAMES.indexOf(current.name);
+    return THEMES[THEME_NAMES[(i + 1) % THEME_NAMES.length]];
+}
+export function launchpadColor(theme, lp) {
+    switch (lp) {
+        case 'pump.fun': return theme.pump;
+        case 'dbc': return theme.dbc;
+        case 'raydium': return theme.raydium;
+        case 'meteora': return theme.meteora;
+        case 'bonk': return theme.bonk;
+        default: return theme.muted;
+    }
+}