dexterm-cli 0.0.0-stage → 0.1.2

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

@@ -0,0 +1,188 @@
+// @dexterm/tui — number/time formatting helpers (SPEC §7.6: compact currency, ages, subscript zeros).
+const SUB = '₀₁₂₃₄₅₆₇₈₉';
+export function fmtUsd(n, { digits = 2 } = {}) {
+    if (n == null || Number.isNaN(n))
+        return '—';
+    const a = Math.abs(n);
+    const sign = n < 0 ? '-' : '';
+    if (a >= 1e9)
+        return `${sign}$${(a / 1e9).toFixed(digits)}B`;
+    if (a >= 1e6)
+        return `${sign}$${(a / 1e6).toFixed(digits)}M`;
+    if (a >= 1e3)
+        return `${sign}$${(a / 1e3).toFixed(digits > 1 ? 1 : 0)}K`;
+    return `${sign}$${a.toFixed(0)}`;
+}
+export function fmtNum(n) {
+    if (n == null)
+        return '—';
+    const a = Math.abs(n);
+    if (a >= 1e9)
+        return `${(n / 1e9).toFixed(2)}B`;
+    if (a >= 1e6)
+        return `${(n / 1e6).toFixed(2)}M`;
+    if (a >= 1e4)
+        return `${(n / 1e3).toFixed(1)}K`;
+    if (a >= 1e3)
+        return `${(n / 1e3).toFixed(2)}K`;
+    return String(Math.round(n));
+}
+/**
+ * A TOKEN QUANTITY (what you pay / receive / hold): compact above 10 000 like fmtNum, otherwise up to four
+ * decimals with trailing zeros trimmed, and subscript-compressed below 0.01 (0.0000123 → 0.0₄123). task-1368:
+ * `fmtNum` rounds to a whole number, so a $4.33 buy of a $300 token showed `You receive 0 AVGOx` — never again.
+ * A true zero is "0"; null is a dash. Decimals unknown? Do not call this — say so (the ticket does).
+ */
+export function fmtAmount(n) {
+    if (n == null || Number.isNaN(n))
+        return '—';
+    if (n === 0)
+        return '0';
+    const a = Math.abs(n);
+    const sign = n < 0 ? '-' : '';
+    if (a >= 1e4)
+        return `${sign}${fmtNum(a)}`;
+    if (a >= 1) {
+        const d = a >= 1000 ? 2 : 4;
+        return `${sign}${trimZeros(a.toFixed(d))}`;
+    }
+    if (a >= 0.01)
+        return `${sign}${trimZeros(a.toFixed(4))}`;
+    return `${sign}${fmtPriceBare(a)}`;
+}
+function trimZeros(s) {
+    return s.includes('.') ? s.replace(/0+$/, '').replace(/\.$/, '') : s;
+}
+/**
+ * Price magnitude with subscript zero-compression, WITHOUT a currency symbol: 0.0000123 -> 0.0₄123.
+ * Use this for amounts whose unit is written out separately (e.g. SOL per token); `fmtPrice` is the
+ * USD-prefixed form. Mixing them is the task-1310 "$…​ SOL" bug: a `$` glued to a SOL amount.
+ */
+export function fmtPriceBare(p) {
+    if (p == null)
+        return '—';
+    if (p >= 1000)
+        return p.toLocaleString('en-US', { maximumFractionDigits: 0 });
+    if (p >= 1)
+        return p.toFixed(p >= 100 ? 2 : 3);
+    if (p >= 0.01)
+        return p.toFixed(4);
+    const s = p.toFixed(12);
+    const m = s.match(/^0\.(0*)(\d+)/);
+    if (!m)
+        return `${p}`;
+    const zeros = m[1].length;
+    const digits = m[2].replace(/0+$/, '').slice(0, 4) || '0';
+    if (zeros < 3)
+        return `0.${m[1]}${digits}`;
+    const sub = String(zeros).split('').map((c) => SUB[Number(c)]).join('');
+    return `0.0${sub}${digits}`;
+}
+/** USD price with subscript zero-compression: 0.0000123 -> $0.0₄123 */
+export function fmtPrice(p) {
+    const bare = fmtPriceBare(p);
+    return bare === '—' ? bare : `$${bare}`;
+}
+/**
+ * task-1366: market cap (or any large USD amount) on an axis / in a cell, compact K/M/B/T with at most three
+ * significant digits and no currency symbol: 300000 → 300K, 1234567 → 1.23M, 1.2e9 → 1.2B, 950 → 950,
+ * 0.42 → 0.42. The unit is rounded FIRST so 999 999 reads 1M, never 1000K. Non-finite → '—'.
+ */
+export function fmtMcapBare(n) {
+    if (n == null || !Number.isFinite(n))
+        return '—';
+    const sign = n < 0 ? '-' : '';
+    let a = Math.abs(n);
+    if (a === 0)
+        return '0';
+    if (a < 1)
+        return sign + String(Number(a.toPrecision(2)));
+    const units = ['', 'K', 'M', 'B', 'T'];
+    let u = 0;
+    while (u < units.length - 1 && a >= 1000) {
+        a /= 1000;
+        u++;
+    }
+    let r = Number(a.toPrecision(3));
+    if (r >= 1000 && u < units.length - 1) {
+        r = Number((r / 1000).toPrecision(3));
+        u++;
+    }
+    // three significant digits, trailing zeros dropped (1.20M → 1.2M); T stays plain digits beyond 999T
+    const digits = r >= 1000 ? String(Math.round(r)) : String(r);
+    return `${sign}${digits}${units[u]}`;
+}
+/** USD market cap, compact: `$1.2M`. See fmtMcapBare. */
+export function fmtMcap(n) {
+    const bare = fmtMcapBare(n);
+    if (bare === '—')
+        return bare;
+    return bare.startsWith('-') ? `-$${bare.slice(1)}` : `$${bare}`;
+}
+export function fmtPct(n, { sign = true, digits = 1 } = {}) {
+    if (n == null || Number.isNaN(n))
+        return '—';
+    const a = Math.abs(n);
+    const d = a >= 1000 ? 0 : digits;
+    const s = `${a.toFixed(d)}%`;
+    if (!sign)
+        return s;
+    return n > 0 ? `+${s}` : n < 0 ? `-${s}` : ` ${s}`;
+}
+export function fmtAge(minutes) {
+    if (minutes < 1)
+        return `${Math.max(1, Math.round(minutes * 60))}s`;
+    if (minutes < 60)
+        return `${Math.round(minutes)}m`;
+    if (minutes < 60 * 24)
+        return `${(minutes / 60).toFixed(minutes < 600 ? 1 : 0)}h`;
+    if (minutes < 60 * 24 * 30)
+        return `${Math.round(minutes / 1440)}d`;
+    return `${Math.round(minutes / 43200)}mo`;
+}
+export function fmtAgeSec(seconds) {
+    if (seconds < 60)
+        return `${Math.round(seconds)}s`;
+    return fmtAge(seconds / 60);
+}
+export function shortAddr(a, n = 4) {
+    if (!a)
+        return '';
+    return `${a.slice(0, n)}…${a.slice(-n)}`;
+}
+export function pad(s, w, align = 'left') {
+    let str = String(s);
+    if (str.length >= w)
+        return str.slice(0, w);
+    const sp = ' '.repeat(w - str.length);
+    return align === 'right' ? sp + str : str + sp;
+}
+export function clamp(n, lo, hi) {
+    return Math.max(lo, Math.min(hi, n));
+}
+/**
+ * HH:MM:SS clock. `timeZone` pins the zone (fixtures and snapshot tests use
+ * 'America/New_York' so renders are identical on every machine); omit for local time.
+ */
+export function clock(d = new Date(), timeZone) {
+    if (!timeZone)
+        return d.toTimeString().slice(0, 8);
+    return new Intl.DateTimeFormat('en-GB', { hour: '2-digit', minute: '2-digit', second: '2-digit', hour12: false, timeZone }).format(d);
+}
+/** Greedy word wrap; words longer than `width` are kept whole on their own line. */
+export function wrap(s, width) {
+    const words = s.split(' ');
+    const out = [];
+    let cur = '';
+    for (const wd of words) {
+        if ((cur + ' ' + wd).trim().length > width) {
+            out.push(cur);
+            cur = wd;
+        }
+        else
+            cur = (cur + ' ' + wd).trim();
+    }
+    if (cur)
+        out.push(cur);
+    return out;
+}

package/dist/packages/tui/src/fx-trade.js

@@ -0,0 +1,278 @@
+import { mix } from "./color.js";
+import { hash3, CODE } from "./fx.js";
+const unit = (a, b, c) => hash3(a, b, c) / 4294967296;
+const COINS = '$◆●¢◇✦∘';
+const BURST = '✦✧◆·∗⟡';
+const STATIC = '░▒▓▒░';
+/** Durations in seconds per kind; fever runs longer and denser. */
+export const MOMENT_SECONDS = { buy: 1.8, profit: 2.1, loss: 1.8, failed: 1.2, runner: 2.0 };
+export function momentFrames(kind, intensity, fps) {
+    if (kind === 'inflight')
+        return 0;
+    const s = MOMENT_SECONDS[kind];
+    const k = intensity === 'fever' ? 1.45 : 1;
+    return Math.max(2, Math.round(s * k * fps));
+}
+/** Progress of the current moment in [0, 1], null when none (or finished). Inflight is always 0. */
+export function momentP(v) {
+    const m = v.moment;
+    if (!m)
+        return null;
+    if (m.kind === 'inflight')
+        return 0;
+    const p = (v.frame - m.t0) / Math.max(1, m.dur);
+    return p > 1 ? null : p;
+}
+/** Classify a settled outcome: buy → 'buy'; sell → 'profit' | 'loss' by realized PnL; failed → 'failed'. */
+export function momentKindFor(tx) {
+    if (tx.status === 'failed')
+        return 'failed';
+    if (tx.side === 'buy')
+        return 'buy';
+    return (tx.pnlSol ?? 0) >= 0 ? 'profit' : 'loss';
+}
+/**
+ * Fire the moment for a SETTLED outcome. Throws unless `tx.status` is confirmed or failed — the same guard the
+ * prototype's settle() had — so a quote, a plan or an in-flight send cannot reach the effects. Returns the moment
+ * (or null when effects are off). Side effects on the vfx: mood ramp swap and a glitch for loss / failed; the
+ * shake is never used while a shielded ticket is on screen (shake() refuses shields anyway).
+ */
+export function fireMoment(v, tx, opts = {}) {
+    if (!tx || (tx.status !== 'confirmed' && tx.status !== 'failed'))
+        throw new Error('fireMoment needs a settled chain outcome (confirmed | failed), not a quote');
+    const kind = momentKindFor(tx);
+    if (v.intensity === 'off') {
+        v.moment = null;
+        return null;
+    }
+    const fps = opts.fps ?? 30;
+    const milestone = opts.milestone ?? null;
+    const m = {
+        kind, milestone, t0: v.frame, dur: momentFrames(kind, v.intensity, fps), origin: opts.origin ?? null,
+        symbol: tx.symbol, pnl: tx.pnlSol ?? 0, pct: tx.pnlPct ?? 0, tx, seed: hash3(v.seed, v.frame, 77),
+    };
+    if (milestone)
+        m.dur = Math.round(m.dur * 1.35);
+    v.moment = m;
+    const fever = v.intensity === 'fever';
+    if (kind === 'buy') {
+        v.activity = Math.max(v.activity, fever ? 1 : 0.8);
+    }
+    else if (kind === 'profit') {
+        v.mood = 'pump';
+        v.moodUntil = v.frame + Math.round(fps * (fever ? 4 : 3));
+        v.activity = 1;
+    }
+    else if (kind === 'loss') {
+        v.mood = 'dump';
+        v.moodUntil = v.frame + Math.round(fps * 3);
+        v.glitch = Math.max(v.glitch, fever ? 0.7 : 0.45);
+        v.stutter = 0;
+    }
+    else if (kind === 'failed') {
+        v.glitch = Math.max(v.glitch, 0.25);
+    }
+    if (milestone === 'rug') {
+        v.glitch = 1;
+        v.mood = 'dump';
+        v.moodUntil = v.frame + Math.round(fps * 4);
+    }
+    return m;
+}
+/** The pending state: a neutral scanning sweep while a send is in flight. Never a verdict; replaced by fireMoment. */
+export function fireInflight(v, symbol, origin = null) {
+    if (v.intensity === 'off') {
+        v.moment = null;
+        return null;
+    }
+    const m = { kind: 'inflight', milestone: null, t0: v.frame, dur: 0, origin, symbol, pnl: 0, pct: 0, tx: null, seed: hash3(v.seed, v.frame, 78) };
+    v.moment = m;
+    return m;
+}
+/** Called by stepVfx every frame: drops a finished moment and lets a mood swap expire. */
+export function stepMoment(v) {
+    if (v.moodUntil != null && v.frame >= v.moodUntil) {
+        v.mood = 'neutral';
+        v.moodUntil = null;
+    }
+    if (v.moment && v.moment.kind !== 'inflight' && momentP(v) == null)
+        v.moment = null;
+}
+/** Any key: the moment is dropped (the result card stays: it is content, not an effect). Inflight stays. */
+export function skipMoment(v) {
+    if (v.moment && v.moment.kind !== 'inflight')
+        v.moment = null;
+    if (v.moodUntil != null) {
+        v.mood = 'neutral';
+        v.moodUntil = null;
+    }
+    v.glitch = 0;
+    v.shake = 0;
+    v.stutter = 0;
+}
+/** Clear the inflight sweep (the send settled or was cancelled). */
+export function clearInflight(v) {
+    if (v.moment?.kind === 'inflight')
+        v.moment = null;
+}
+function center(o, c) {
+    if (!o)
+        return { cx: Math.floor(c.w / 2), cy: Math.floor(c.h / 2) };
+    return { cx: o.x + Math.floor(o.w / 2), cy: o.y + Math.floor(o.h / 2) };
+}
+/** Theme-derived palettes: gold from the pump ramp, a green "buy" ramp from `up`. */
+function palettes(c) {
+    const t = c.theme;
+    return { gold: t.rainPump[2], goldHot: t.rainPump[3], buy: [mix(t.bg, t.up, 0.3), mix(t.bg, t.up, 0.6), t.up, mix(t.up, '#ffffff', 0.6)] };
+}
+/** The post-pass. No-op without a live moment or when effects are off. */
+export function tradeFx(c, v) {
+    if (!v || v.intensity === 'off')
+        return;
+    const m = v.moment;
+    if (!m)
+        return;
+    const p = momentP(v);
+    if (p == null)
+        return;
+    const t = c.theme;
+    const { gold, goldHot, buy: rainBuy } = palettes(c);
+    const fever = v.intensity === 'fever';
+    const f = v.frame;
+    const W = c.w, H = c.h;
+    const fps = 30;
+    const { cx, cy } = center(m.origin, c);
+    const dist = (x, y) => Math.sqrt((x - cx) * (x - cx) + (2 * (y - cy)) * (2 * (y - cy)));
+    if (m.kind === 'inflight') {
+        // scanning sweep: one bright row sweeping down every 0.7 s, bg tint on soft cells + a faint trail
+        const per = Math.max(6, Math.round(0.7 * fps));
+        const ys = Math.floor(((f - m.t0) % per) / per * H);
+        for (let k = 0; k < 3; k++) {
+            const y = ys - k;
+            if (y < 0 || y >= H)
+                continue;
+            const amt = k === 0 ? 0.28 : k === 1 ? 0.14 : 0.06;
+            for (let x = 0; x < W; x++) {
+                c.tintFx(x, y, t.cyan, amt);
+                if (k === 0 && c.zone[c.idx(x, y)] && unit(x, y, f) < 0.35)
+                    c.putFx(x, y, '╌', { fg: mix(t.bg, t.cyan, 0.7) });
+            }
+        }
+        return;
+    }
+    if (m.kind === 'buy') {
+        // shockwave ring from the origin, 0–0.6; inside the ring the bg lifts toward green and fades
+        const R = Math.max(W, H * 2) * 0.75;
+        const pr = Math.min(1, p / 0.6);
+        const r = pr * R;
+        const fade = 1 - pr;
+        if (pr < 1) {
+            for (let y = 0; y < H; y++)
+                for (let x = 0; x < W; x++) {
+                    const d = dist(x, y);
+                    const dd = Math.abs(d - r);
+                    if (dd < 1.4) {
+                        if (c.zone[c.idx(x, y)])
+                            c.putFx(x, y, dd < 0.6 ? '○' : '∘', { fg: mix(rainBuy[2], rainBuy[3], fade), b: dd < 0.6 });
+                        c.tintFx(x, y, t.up, (dd < 0.6 ? 0.3 : 0.2) * fade);
+                    }
+                    else if (d < r && d > r - 6)
+                        c.tintFx(x, y, t.up, 0.10 * fade * (1 - (r - d) / 6));
+                }
+        }
+        // coins / glyphs streaming up from the origin row
+        const N = (fever ? 90 : 46) * Math.max(1, Math.floor(W / 120));
+        const ox = m.origin ? m.origin.x : 0, ow = m.origin ? m.origin.w : W, oy = m.origin ? m.origin.y : cy;
+        for (let i = 0; i < N; i++) {
+            const born = unit(m.seed, i, 1) * 0.55;
+            const age = p - born;
+            if (age < 0 || age > 0.55)
+                continue;
+            const x = ox + Math.floor(unit(m.seed, i, 2) * ow);
+            const speed = (0.6 + unit(m.seed, i, 3) * 0.9) * H * 1.3;
+            const y = Math.round(oy - age * speed);
+            const wobble = Math.round(Math.sin((age * 9 + i) * 1.7) * 1);
+            if (y < 0 || y >= H)
+                continue;
+            const sym = m.symbol || '';
+            const ch = unit(m.seed, i, 4) < 0.35 && sym ? sym[i % sym.length] : COINS[hash3(m.seed, i, 5) % COINS.length];
+            const life = 1 - age / 0.55;
+            const fg = life > 0.7 ? rainBuy[3] : life > 0.35 ? rainBuy[2] : rainBuy[1];
+            c.putFx(x + wobble, y, ch, { fg, b: life > 0.7 });
+            if (fever && life > 0.5)
+                c.putFx(x + wobble, y + 1, '·', { fg: rainBuy[1] });
+        }
+        return;
+    }
+    if (m.kind === 'profit' || m.kind === 'runner') {
+        // gold burst: particles radiate from the centre, slow down, drift down a little
+        const N = (fever ? 140 : 70) * Math.max(1, Math.floor(W / 120));
+        const R = Math.max(W, H * 2) * 0.5;
+        for (let i = 0; i < N; i++) {
+            const born = unit(m.seed, i, 1) * 0.18;
+            const age = p - born;
+            if (age < 0 || age > 0.75)
+                continue;
+            const a = unit(m.seed, i, 2) * Math.PI * 2;
+            const sp = 0.4 + unit(m.seed, i, 3) * 0.9;
+            const d = (1 - Math.pow(1 - age / 0.75, 2)) * sp * R * 0.9;
+            const x = Math.round(cx + Math.cos(a) * d);
+            const y = Math.round(cy + Math.sin(a) * d * 0.5 + age * age * 6);
+            if (x < 0 || x >= W || y < 0 || y >= H)
+                continue;
+            const life = 1 - age / 0.75;
+            const ch = BURST[hash3(m.seed, i, 6 + (f >> 2)) % BURST.length];
+            const fg = life > 0.75 ? goldHot : life > 0.4 ? gold : mix(t.bg, gold, 0.55);
+            if (!c.putFx(x, y, ch, { fg, b: life > 0.75 }))
+                c.tintFx(x, y, gold, 0.25 * life);
+            if (fever)
+                c.tintFx(x, y, gold, 0.12 * life);
+        }
+        if (p < 0.4)
+            for (let y = cy - 1; y <= cy + 1; y++)
+                for (let x = cx - 10; x <= cx + 10; x++)
+                    c.tintFx(x, y, gold, 0.18 * (1 - p / 0.4) * (1 - Math.abs(x - cx) / 11));
+        return;
+    }
+    if (m.kind === 'loss') {
+        // red static that collapses: 0–0.35 density rises everywhere; 0.35–1 a line falls and clears the screen above it
+        const dens = (fever ? 0.5 : 0.36) * Math.min(1, p / 0.35);
+        const yl = p < 0.35 ? -1 : Math.floor((p - 0.35) / 0.55 * (H + 1));
+        for (let y = 0; y < H; y++) {
+            if (y < yl)
+                continue;
+            const rowDens = dens * (yl >= 0 ? Math.min(1, (y - yl) / 4 + 0.3) : 1);
+            for (let x = 0; x < W; x++) {
+                if (unit(x, y, f) >= rowDens)
+                    continue;
+                const ch = unit(x, y, f + 9) < 0.7 ? STATIC[hash3(x, y, f) % STATIC.length] : CODE[hash3(x, y, f + 1) % CODE.length];
+                const tier = unit(x, y, f + 3);
+                const fg = tier < 0.1 ? t.rainDump[2] : tier < 0.5 ? t.rainDump[1] : t.rainDump[0];
+                if (!c.putFx(x, y, ch, { fg }))
+                    c.tintFx(x, y, t.down, 0.08);
+            }
+            if (y === yl || y === yl + 1)
+                for (let x = 0; x < W; x++)
+                    c.tintFx(x, y, t.down, y === yl ? 0.2 : 0.1);
+        }
+        return;
+    }
+    if (m.kind === 'failed') {
+        // lockout flicker: header band + footer row tint red every other 4 frames for 0.8 s; sparse static near the bands
+        const on = Math.floor((f - m.t0) / 4) % 2 === 0 && p < 0.7;
+        if (on)
+            for (let x = 0; x < W; x++) {
+                c.tintFx(x, 1, t.down, 0.35);
+                c.tintFx(x, 0, t.down, 0.18);
+                c.tintFx(x, H - 1, t.down, 0.18);
+                c.tintFx(x, H - 2, t.down, 0.12);
+            }
+        if (p < 0.5)
+            for (let y = 0; y < H; y++)
+                for (let x = 0; x < W; x++) {
+                    if (!c.zone[c.idx(x, y)] || unit(x, y, f) >= 0.06 * (1 - p / 0.5))
+                        continue;
+                    c.putFx(x, y, STATIC[hash3(x, y, f) % STATIC.length], { fg: t.rainDump[1] });
+                }
+    }
+}