@stevezhou/sisu 0.1.5 → 0.1.6

package/dist/logo.js

@@ -4,6 +4,8 @@ exports.sisuTreeLines = exports.sisuTreeArt = exports.sisuMarkLines = exports.si
 exports.sisuMobiusArt = sisuMobiusArt;
 exports.sisuWordmark = sisuWordmark;
 exports.displayWidth = displayWidth;
+exports.sisuSplashFrame = sisuSplashFrame;
+exports.sisuSplashHeight = sisuSplashHeight;
 exports.sisuSplash = sisuSplash;
 exports.sisuWelcomeCopy = sisuWelcomeCopy;
 exports.sisuBanner = sisuBanner;
@@ -115,9 +117,9 @@ function copyColumn(columns, color, compact) {
     }
     return lines;
 }
-function treeColumn(columns, color) {
-    const raw = (0, tree_2.sisuTreeLines)(columns);
-    const painted = (0, tree_2.sisuTreeArt)(columns, color).split('\n');
+function treeColumn(columns, color, phase, grow) {
+    const raw = (0, tree_2.sisuTreeLines)(columns, phase, grow);
+    const painted = (0, tree_2.sisuTreeArt)(columns, color, phase, grow).split('\n');
     const treeWidth = raw.reduce((max, line) => Math.max(max, line.length), 0);
     const pad = Math.max(0, Math.floor((columns - treeWidth) / 2));
     return painted.map((line, i) => {
@@ -125,31 +127,45 @@ function treeColumn(columns, color) {
         return padLeft(`${line}${' '.repeat(Math.max(0, treeWidth - vis))}`, pad);
     });
 }
+const STILL_PHASE = 2.05;
 /**
- * Login-page splash: lockup + 思有所溯 + 题跋 over the 溯源之树.
- * Side-by-side on a wide terminal; stacked when the sheet is narrow.
+ * Login-page splash. `phase` orbits the camera; `grow` is 0..1 paint progress.
+ * Line count is stable for a given width so the intro can rewrite in place.
  */
-function sisuSplash(columns = 80, color = true) {
+function sisuSplashFrame(columns = 80, color = true, phase = STILL_PHASE, grow = 1) {
     const width = Math.max(20, Math.floor(columns));
     const compact = width < 52;
     const copy = copyColumn(width, color, compact);
-    const tree = treeColumn(width, color);
-    if (width >= 100) {
+    if (width >= 72) {
         const gap = 3;
-        const leftW = Math.max(...copy.map((line) => displayWidth(line)));
-        const rightW = width - leftW - gap;
-        const right = treeColumn(rightW, color);
-        const rows = Math.max(copy.length, right.length);
-        const merged = [''];
+        const leftBudget = Math.min(44, Math.floor(width * 0.42));
+        const leftCopy = copyColumn(leftBudget, color, true);
+        const leftW = Math.max(...leftCopy.map((line) => displayWidth(line)), 22);
+        const rightW = Math.max(28, width - leftW - gap);
+        const right = treeColumn(rightW, color, phase, grow);
+        const rows = Math.max(leftCopy.length, right.length);
+        const merged = [];
         for (let i = 0; i < rows; i += 1) {
-            const left = copy[i] ?? '';
+            const left = leftCopy[i] ?? '';
             const pad = Math.max(0, leftW + gap - displayWidth(left));
             merged.push(`${left}${' '.repeat(pad)}${right[i] ?? ''}`);
         }
-        merged.push('');
+        const notes = colophon(width, color);
+        if (notes.length) {
+            merged.push('');
+            for (const note of notes)
+                merged.push(padLeft(note, 2));
+        }
         return merged.join('\n');
     }
-    return ['', ...copy, '', ...tree, ''].join('\n');
+    const tree = treeColumn(width, color, phase, grow);
+    return [...copy, '', ...tree].join('\n');
+}
+function sisuSplashHeight(columns = 80) {
+    return sisuSplashFrame(columns, false).split('\n').length;
+}
+function sisuSplash(columns = 80, color = true) {
+    return sisuSplashFrame(columns, color, STILL_PHASE, 1);
 }
 function sisuWelcomeCopy(guest, color = true) {
     const lines = [
@@ -165,8 +181,8 @@ function sisuWelcomeCopy(guest, color = true) {
     }
     return lines;
 }
-function sisuBanner(columns = 80, _phase = 0, color = false) {
-    return sisuSplash(columns, color);
+function sisuBanner(columns = 80, phase = STILL_PHASE, color = false) {
+    return sisuSplashFrame(columns, color, phase, 1);
 }
 function stripAnsi(text) {
     return text.replace(/\x1b\[[0-9;]*m/g, '');

package/dist/main.js

@@ -28,7 +28,7 @@ Usage:
   sisu history
   sisu thread <conversation-id>
   sisu training --on|--off
-  sisu                 interactive TUI (welcome tree)
+  sisu                 interactive TUI (3D welcome tree)
   sisu help
 
 Auth and workspaces live in $SISU_HOME (default ~/.sisu), shared with Desktop.

package/dist/tree.js

@@ -1,116 +1,331 @@
 "use strict";
-/** 溯源之树 — hand-inked ASCII of the login welcome painting. */
+/** Volumetric 溯源之树: 3D L-system, z-buffer, lighting, grow + orbit. */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTree3d = buildTree3d;
+exports.treeFrameHeight = treeFrameHeight;
+exports.treeFrameWidth = treeFrameWidth;
+exports.renderTreeFrame = renderTreeFrame;
 exports.sisuTreeLines = sisuTreeLines;
 exports.sisuTreeArt = sisuTreeArt;
 exports.sisuTreeWidth = sisuTreeWidth;
 exports.sisuTreeHeight = sisuTreeHeight;
 const RESET = '\x1b[0m';
-const INK = [196, 186, 170];
-const INK_DIM = [130, 120, 108];
-const FRUIT = [184, 90, 58];
-const HILL = [90, 82, 70];
-/**
- * Desktop login tree. Trunk sits near center; crown opens into an airy
- * fan with terracotta tips — the same 图景 as BrandCanvas, not a Möbius.
- */
-const TREE_WIDE = [
-    '                      •    •      •  •      •    •     •',
-    '                 •  •    •    •     •   •    •     •  •   •',
-    '              •     •  •   •   •  •    •  •    •  •    •   •',
-    '           •     •    ╲  •   ╲  •   ╱ •   ╲   •    •    •',
-    '         •      ╲    ╱ ╲    ╲    ╱ ╲     ╱ ╲   ╲    ╲  ╱',
-    '        •        ╲  ╱   ╲    ╲  ╱   ╲   ╱   ╲   ╲    ╲╱',
-    '         ╲        ╲╱     ╲    ╲╱     ╲ ╱     ╲   ╲    ╱',
-    '          ╲       ╱       ╲   ╱       Y       ╲   ╲  ╱',
-    '           ╲     ╱         ╲ ╱       ╱         ╲   ╲╱',
-    '            ╲   ╱           Y       ╱           ╲  ╱',
-    '             ╲ ╱           ╱ ╲     ╱             ╲╱',
-    '              Y           ╱   ╲   ╱              ╱',
-    '              │          ╱     ╲ ╱',
-    '              │         ╱       Y',
-    '              │        ╱',
-    '              │',
-    '▁▁▁▂▂▁▁▁▁▁▁▁▁▁│▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁',
-];
-const TREE_MID = [
-    '                •   •    •  •    •   •   •',
-    '            •  •   •  •    •   •   •    •  •',
-    '         •    •  ╲  •  ╲ •   ╱ •  ╲   •   •',
-    '       •    ╲   ╱ ╲   ╲   ╱ ╲    ╱ ╲   ╲ ╱',
-    '        ╲    ╲ ╱   ╲   ╲ ╱   ╲  ╱   ╲   Y',
-    '         ╲    Y     ╲   Y     ╲╱     ╲ ╱',
-    '          ╲  ╱       ╲ ╱      ╱       Y',
-    '           ╲╱         Y      ╱       ╱',
-    '           │         ╱ ╲    ╱',
-    '           │        ╱   ╲  ╱',
-    '           │       ╱     ╲╱',
-    '           │',
-    '▁▁▂▂▁▁▁▁▁▁▁│▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁',
-];
-const TREE_NARROW = [
-    '          •  •   •  •  •',
-    '       •   ╲ • ╱ •  ╲  •',
-    '      ╲   ╱ ╲ ╱ ╲  ╱ ╲╱',
-    '       ╲ ╱   Y   ╲╱   ╱',
-    '        Y   ╱     ╲  ╱',
-    '        │  ╱       ╲╱',
-    '        │',
-    '▁▁▁▁▁▁▁▁│▁▁▁▁▁▁▁▁▁▁▁▁▁▁',
-];
+const SHADE = ' .:-=+*#%@';
+const CELL_ASPECT = 0.52;
+const CAM = 5.35;
+const FOCAL = 4.7;
+const LOOK_Y = 0.72;
+const KEY = norm([-0.62, 0.72, 0.32]);
+const FILL = norm([0.55, 0.18, 0.82]);
+const VIEW = [0, 0.08, 1];
+const INK = [198, 186, 168];
+const FRUIT_RGB = [184, 90, 58];
+const HILL_RGB = [92, 84, 72];
+const TREE_SEED = 20260817;
+const MAX_DEPTH = 5;
+function clamp(value, lo, hi) {
+    return Math.max(lo, Math.min(hi, value));
+}
 function lerp(a, b, t) {
     return a + (b - a) * t;
 }
-function paintRgb(ch, rgb) {
-    return `\x1b[38;2;${rgb[0]};${rgb[1]};${rgb[2]}m${ch}`;
+function norm(v) {
+    const length = Math.hypot(v[0], v[1], v[2]) || 1;
+    return [v[0] / length, v[1] / length, v[2] / length];
 }
-function inkAt(x, width) {
-    const t = width <= 1 ? 0 : x / (width - 1);
+function cross(a, b) {
     return [
-        Math.round(lerp(INK[0], INK_DIM[0], t * 0.45)),
-        Math.round(lerp(INK[1], INK_DIM[1], t * 0.45)),
-        Math.round(lerp(INK[2], INK_DIM[2], t * 0.45)),
+        a[1] * b[2] - a[2] * b[1],
+        a[2] * b[0] - a[0] * b[2],
+        a[0] * b[1] - a[1] * b[2],
     ];
 }
-function paintLine(line, color) {
-    if (!color)
-        return line;
-    let out = '';
-    for (let i = 0; i < line.length; i += 1) {
-        const ch = line[i];
-        if (ch === ' ') {
-            out += ' ';
-            continue;
+function dot(a, b) {
+    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function add(a, b, s = 1) {
+    return [a[0] + b[0] * s, a[1] + b[1] * s, a[2] + b[2] * s];
+}
+function rotateY(x, z, angle) {
+    const c = Math.cos(angle);
+    const s = Math.sin(angle);
+    return [x * c + z * s, -x * s + z * c];
+}
+function rotateX(y, z, angle) {
+    const c = Math.cos(angle);
+    const s = Math.sin(angle);
+    return [y * c - z * s, y * s + z * c];
+}
+function mulberry32(seed) {
+    let a = seed >>> 0;
+    return () => {
+        a |= 0;
+        a = (a + 0x6d2b79f5) | 0;
+        let t = Math.imul(a ^ (a >>> 15), 1 | a);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+function perpFrame(dir) {
+    const helper = Math.abs(dir[1]) < 0.86 ? [0, 1, 0] : [1, 0, 0];
+    const n1 = norm(cross(dir, helper));
+    const n2 = norm(cross(dir, n1));
+    return [n1, n2];
+}
+let cached = null;
+function headingFrom(yaw, pitch) {
+    const sp = Math.sin(pitch);
+    return norm([sp * Math.sin(yaw), Math.cos(pitch), sp * Math.cos(yaw)]);
+}
+function buildTree3d(seed = TREE_SEED) {
+    if (cached && cached.seed === seed)
+        return cached.branches;
+    const rng = mulberry32(seed);
+    const branches = [];
+    const grow = (origin, yaw, pitch, len, radius, depth, t0) => {
+        if (depth > MAX_DEPTH || len < 0.08 || branches.length > 150)
+            return;
+        const heading = headingFrom(yaw, pitch);
+        const end = add(origin, heading, len);
+        const t1 = Math.min(1, t0 + len / 2.8);
+        const childCount = depth >= MAX_DEPTH ? 0 : rng() < 0.74 ? 2 : 3;
+        branches.push({
+            ax: origin[0],
+            ay: origin[1],
+            az: origin[2],
+            bx: end[0],
+            by: end[1],
+            bz: end[2],
+            radius,
+            depth,
+            t0,
+            t1,
+            tip: childCount === 0,
+        });
+        const baseYaw = yaw + (rng() - 0.5) * 0.4;
+        for (let i = 0; i < childCount; i += 1) {
+            const fork = ((i - (childCount - 1) / 2) * 2 * Math.PI) / childCount;
+            const childYaw = baseYaw + fork + (rng() - 0.5) * 0.35;
+            const childPitch = Math.min(0.98, pitch + (depth === 0 ? 0.4 : 0.26) + rng() * 0.22);
+            grow(end, childYaw, childPitch, len * (0.66 + rng() * 0.12), radius * 0.67, depth + 1, t1 + rng() * 0.02);
         }
-        if (ch === '•') {
-            out += paintRgb(ch, FRUIT);
-            continue;
+    };
+    grow([0, 0, 0], 0.1, 0.03, 0.82, 0.095, 0, 0);
+    const tMax = branches.reduce((m, b) => Math.max(m, b.t1), 0) || 1;
+    for (const b of branches) {
+        b.t0 /= tMax;
+        b.t1 /= tMax;
+    }
+    cached = { seed, branches };
+    return branches;
+}
+function shadeChar(shade) {
+    return SHADE[Math.round(clamp(shade, 0, 1) * (SHADE.length - 1))] || '@';
+}
+function ansiRgb(r, g, b) {
+    return `\x1b[38;2;${r};${g};${b}m`;
+}
+function plot(grid, col, row, depth, shade, spec, kind) {
+    if (col < 0 || row < 0 || row >= grid.length || col >= grid[0].length)
+        return;
+    if (!Number.isFinite(col) || !Number.isFinite(row) || !Number.isFinite(depth))
+        return;
+    const prev = grid[row][col];
+    if (!prev || depth < prev.z) {
+        grid[row][col] = { z: depth, shade: clamp(shade, 0.05, 1), spec, kind };
+    }
+}
+function project(x, y, z, yaw, pitch, cols, rows) {
+    ;
+    [x, z] = rotateY(x, z, yaw);
+    [y, z] = rotateX(y - LOOK_Y, z, pitch);
+    const depth = CAM - z;
+    if (depth < 0.45 || !Number.isFinite(depth))
+        return null;
+    const px = (x * FOCAL) / depth;
+    const py = (y * FOCAL) / depth;
+    if (!Number.isFinite(px) || !Number.isFinite(py))
+        return null;
+    const scale = Math.min((cols * 0.9) / 2.05, (rows * 0.88) / (1.85 * CELL_ASPECT));
+    const col = Math.round(px * scale + (cols - 1) / 2);
+    const row = Math.round(-py * scale * CELL_ASPECT + rows * 0.54);
+    return { col, row, depth };
+}
+function light(normal, back = false) {
+    const facing = dot(normal, VIEW);
+    if (facing < 0) {
+        normal = [-normal[0], -normal[1], -normal[2]];
+        back = true;
+    }
+    const lambert = Math.max(0, dot(normal, KEY));
+    const fill = Math.max(0, dot(normal, FILL)) * 0.22;
+    const cam = Math.max(0, dot(normal, VIEW)) * 0.2;
+    const half = norm([KEY[0] + VIEW[0], KEY[1] + VIEW[1], KEY[2] + VIEW[2]]);
+    const spec = Math.pow(Math.max(0, dot(normal, half)), 22);
+    const rim = Math.pow(1 - Math.abs(dot(normal, VIEW)), 2.1) * 0.22;
+    const ambient = back ? 0.1 : 0.2;
+    const lit = ambient + lambert * (back ? 0.28 : 0.72) + fill + cam + spec * 0.45 + rim;
+    return { shade: clamp(Math.pow(lit, 1.15), 0.07, 1), spec };
+}
+function swayAt(x, y, z, phase) {
+    const h = clamp(y / 2.3, 0, 1);
+    const gust = Math.sin(phase * 1.7 + x * 1.4 + z * 0.8);
+    const lean = 0.11 * h * h * gust;
+    return [x + lean, y, z + lean * 0.35];
+}
+function sampleBranch(grid, branch, grow, phase, yaw, pitch, cols, rows) {
+    if (grow <= branch.t0)
+        return;
+    const visible = clamp((grow - branch.t0) / Math.max(0.02, branch.t1 - branch.t0), 0, 1);
+    const along = Math.max(4, Math.ceil((branch.depth <= 1 ? 24 : branch.depth <= 3 ? 12 : 6) * visible));
+    const rings = branch.depth <= 1 ? 9 : branch.depth <= 3 ? 4 : 2;
+    const dx = branch.bx - branch.ax;
+    const dy = branch.by - branch.ay;
+    const dz = branch.bz - branch.az;
+    const dir = norm([dx, dy, dz]);
+    const [n1, n2] = perpFrame(dir);
+    for (let i = 0; i <= along; i += 1) {
+        const t = (i / along) * visible;
+        const px = branch.ax + dx * t;
+        const py = branch.ay + dy * t;
+        const pz = branch.az + dz * t;
+        const radius = branch.radius * (1 - t * 0.28);
+        for (let r = 0; r < rings; r += 1) {
+            const a = (r / rings) * Math.PI * 2 + phase * 0.05;
+            const ox = n1[0] * Math.cos(a) + n2[0] * Math.sin(a);
+            const oy = n1[1] * Math.cos(a) + n2[1] * Math.sin(a);
+            const oz = n1[2] * Math.cos(a) + n2[2] * Math.sin(a);
+            const [sx, sy, sz] = swayAt(px + ox * radius, py + oy * radius, pz + oz * radius, phase);
+            let nx = ox;
+            let ny = oy;
+            let nz = oz;
+            [nx, nz] = rotateY(nx, nz, yaw);
+            [ny, nz] = rotateX(ny, nz, pitch);
+            const hit = project(sx, sy, sz, yaw, pitch, cols, rows);
+            if (!hit)
+                continue;
+            const lit = light(norm([nx, ny, nz]));
+            const fog = 0.45 + 0.55 * clamp(1 - (hit.depth - 5.2) / 4.2, 0, 1);
+            plot(grid, hit.col, hit.row, hit.depth, lit.shade * fog, lit.spec * fog, 'wood');
         }
-        if (ch === '▁' || ch === '▂') {
-            out += paintRgb(ch, HILL);
+    }
+}
+function sampleFruit(grid, branches, grow, phase, yaw, pitch, cols, rows) {
+    const placed = [];
+    const gap = 0.28;
+    let count = 0;
+    for (const branch of branches) {
+        if (!branch.tip || grow < branch.t1)
+            continue;
+        if (placed.some((p) => Math.hypot(p[0] - branch.bx, p[1] - branch.by, p[2] - branch.bz) < gap))
             continue;
+        placed.push([branch.bx, branch.by, branch.bz]);
+        const [bx, by, bz] = swayAt(branch.bx, branch.by, branch.bz, phase);
+        const hit = project(bx, by, bz, yaw, pitch, cols, rows);
+        if (!hit)
+            continue;
+        const twinkle = 0.88 + 0.12 * Math.sin(phase * 3.1 + branch.bx * 7);
+        plot(grid, hit.col, hit.row, hit.depth - 0.02, 0.92 * twinkle, 0.55, 'fruit');
+        count += 1;
+        if (count >= 22)
+            break;
+    }
+}
+function sampleGround(grid, phase, yaw, pitch, cols, rows) {
+    for (let ix = -16; ix <= 16; ix += 1) {
+        for (let iz = -14; iz <= 14; iz += 1) {
+            const x = ix * 0.12;
+            const z = iz * 0.12;
+            const rr = (x * x) / (1.85 * 1.85) + (z * z) / (1.45 * 1.45);
+            if (rr > 1)
+                continue;
+            if (rr < 0.88 && rr > 0.18 && (ix * 3 + iz * 5) % 4 !== 0)
+                continue;
+            const y = 0.05 * Math.sin(x * 1.6 + 0.5) * Math.cos(z * 1.25) +
+                0.018 * Math.sin(x * 3.0 + z * 2.1 + phase * 0.15);
+            const hit = project(x, y, z, yaw, pitch, cols, rows);
+            if (!hit)
+                continue;
+            const nx = -0.08 * Math.cos(x * 1.6 + 0.5);
+            const nz = 0.06 * Math.sin(z * 1.25);
+            let nnx = nx;
+            let nny = 1;
+            let nnz = nz;
+            [nnx, nnz] = rotateY(nnx, nnz, yaw);
+            [nny, nnz] = rotateX(nny, nnz, pitch);
+            const lit = light(norm([nnx, nny, nnz]), true);
+            const fog = 0.22 + 0.35 * clamp(1 - rr, 0, 1) * clamp(1 - (hit.depth - 5.2) / 4.8, 0, 1);
+            plot(grid, hit.col, hit.row, hit.depth + 0.1, lit.shade * fog, 0, 'ground');
         }
-        out += paintRgb(ch, inkAt(i, line.length));
     }
-    return `${out}${RESET}`;
 }
-function padBlock(lines) {
-    const width = lines.reduce((max, line) => Math.max(max, line.length), 0);
-    return lines.map((line) => line.padEnd(width, ' '));
+function paintCell(cell, color) {
+    const ch = cell.kind === 'fruit' ? '\u2022' : shadeChar(cell.shade);
+    if (!color)
+        return ch;
+    const base = cell.kind === 'fruit' ? FRUIT_RGB : cell.kind === 'ground' ? HILL_RGB : INK;
+    const lift = 0.22 + cell.shade * 0.95 + cell.spec * 0.55;
+    const r = clamp(Math.round(base[0] * lift), 0, 255);
+    const g = clamp(Math.round(base[1] * lift), 0, 255);
+    const b = clamp(Math.round(base[2] * lift), 0, 255);
+    if (![r, g, b].every(Number.isFinite))
+        return ch;
+    return `${ansiRgb(r, g, b)}${ch}${RESET}`;
+}
+function treeFrameHeight(columns = 80) {
+    if (columns < 44)
+        return 10;
+    if (columns < 68)
+        return 14;
+    return 18;
+}
+function treeFrameWidth(columns = 80) {
+    if (columns < 44)
+        return Math.max(28, columns);
+    if (columns < 68)
+        return Math.min(52, columns);
+    return Math.min(72, Math.max(56, columns - 2));
+}
+function renderTreeFrame(options = {}) {
+    const cols = Math.max(24, Math.floor(options.cols ?? 64));
+    const rows = Math.max(8, Math.floor(options.rows ?? 16));
+    const phase = options.phase ?? 0.4;
+    const grow = clamp(options.grow ?? 1, 0, 1);
+    const color = options.color !== false;
+    const grid = Array.from({ length: rows }, () => Array(cols).fill(null));
+    const yaw = 0.42 + 0.62 * Math.sin(phase);
+    const pitch = 0.3 + 0.07 * Math.cos(phase * 0.85);
+    const branches = buildTree3d();
+    sampleGround(grid, phase, yaw, pitch, cols, rows);
+    for (const branch of branches)
+        sampleBranch(grid, branch, grow, phase, yaw, pitch, cols, rows);
+    sampleFruit(grid, branches, grow, phase, yaw, pitch, cols, rows);
+    return grid
+        .map((line) => line.map((cell) => (cell ? paintCell(cell, color) : ' ')).join(''))
+        .join('\n');
 }
-function sisuTreeLines(columns = 80) {
-    if (columns >= 68)
-        return padBlock(TREE_WIDE);
-    if (columns >= 44)
-        return padBlock(TREE_MID);
-    return padBlock(TREE_NARROW);
+function sisuTreeLines(columns = 80, phase = 2.05, grow = 1) {
+    const art = renderTreeFrame({
+        cols: treeFrameWidth(columns),
+        rows: treeFrameHeight(columns),
+        phase,
+        grow,
+        color: false,
+    });
+    return art.split('\n');
 }
-function sisuTreeArt(columns = 80, color = true) {
-    return sisuTreeLines(columns).map((line) => paintLine(line, color)).join('\n');
+function sisuTreeArt(columns = 80, color = true, phase = 2.05, grow = 1) {
+    return renderTreeFrame({
+        cols: treeFrameWidth(columns),
+        rows: treeFrameHeight(columns),
+        phase,
+        grow,
+        color,
+    });
 }
 function sisuTreeWidth(columns = 80) {
-    return sisuTreeLines(columns).reduce((max, line) => Math.max(max, line.length), 0);
+    return treeFrameWidth(columns);
 }
 function sisuTreeHeight(columns = 80) {
-    return sisuTreeLines(columns).length;
+    return treeFrameHeight(columns);
 }

package/dist/tui.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.shouldAnimateSplash = shouldAnimateSplash;
 exports.playMobiusIntro = playMobiusIntro;
+exports.playTreeIntro = playTreeIntro;
 exports.defaultTuiIo = defaultTuiIo;
 exports.tuiHelp = tuiHelp;
 exports.runTui = runTui;
@@ -48,6 +49,30 @@ async function playMobiusIntro(io, options = {}) {
     io.write('\x1b[?25h');
     io.write(`\n${(0, logo_1.sisuWordmark)()}\n\n`);
 }
+function easeOutCubic(t) {
+    return 1 - (1 - t) ** 3;
+}
+/** Grow the 溯源之树, then orbit so lighting and occlusion read as volume. */
+async function playTreeIntro(io, options = {}) {
+    const columns = options.columns ?? process.stdout.columns ?? 80;
+    const frames = Math.max(2, options.frames ?? 36);
+    const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    const color = options.color ?? Boolean(process.stdout.isTTY);
+    const rows = (0, logo_1.sisuSplashHeight)(columns);
+    io.write('\x1b[?25l');
+    for (let i = 0; i < frames; i += 1) {
+        const u = i / (frames - 1);
+        const grow = easeOutCubic(Math.min(1, u / 0.58));
+        const phase = 0.12 + u * 2.35;
+        const art = (0, logo_1.sisuSplashFrame)(columns, color, phase, grow);
+        if (i === 0)
+            io.write(`${art}\n`);
+        else
+            io.write(`\x1b[${rows}A${art}\n`);
+        await sleep(42);
+    }
+    io.write('\x1b[?25h');
+}
 function defaultTuiIo() {
     let rl;
     const ensureRl = () => {
@@ -174,9 +199,15 @@ async function runTui(io, deps = {}) {
     const columns = deps.columns ?? process.stdout.columns ?? 80;
     const animate = deps.animate ?? shouldAnimateSplash();
     try {
-        io.write(`${(0, logo_1.sisuSplash)(columns, true)}\n`);
         if (animate) {
-            await (deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms))))(80);
+            await playTreeIntro(io, {
+                columns,
+                color: deps.color ?? true,
+                sleep: deps.sleep,
+            });
+        }
+        else {
+            io.write(`${(0, logo_1.sisuSplash)(columns, true)}\n`);
         }
         const account = auth();
         const startWebLogin = async (notify) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stevezhou/sisu",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "SiSu CLI — one login, cloud quota, local workspace",
   "license": "UNLICENSED",
   "homepage": "https://www.sisu.chat",