honeytree 1.1.5 → 1.2.0

package/src/pointcloud.js

@@ -0,0 +1,193 @@
+const SPECIES = {
+  oak:     { name: "oak",     colors: ["#55cc44", "#44bb33", "#66dd55", "#77ee66", "#3da832"], shape: "ellipsoid", widthScale: 1.4, heightScale: 1.0 },
+  pine:    { name: "pine",    colors: ["#33bbaa", "#22aa99", "#44ccbb", "#55ddcc", "#11997a"], shape: "cone",      widthScale: 0.7, heightScale: 1.6 },
+  birch:   { name: "birch",   colors: ["#ff77cc", "#ee55bb", "#ff99dd", "#ffaaee", "#dd44aa"], shape: "ellipsoid", widthScale: 0.8, heightScale: 1.0 },
+  willow:  { name: "willow",  colors: ["#aadd44", "#99cc33", "#bbee55", "#ccff66", "#88bb22"], shape: "drooping",  widthScale: 1.2, heightScale: 1.0 },
+  cherry:  { name: "cherry",  colors: ["#ff88cc", "#ff66bb", "#ffaadd", "#ffbbee", "#ee55aa", "#ff99ff", "#dd77cc"], shape: "sphere", widthScale: 1.0, heightScale: 1.0 },
+  default: { name: "default", colors: ["#88bb88", "#77aa77", "#99cc99", "#aaddaa"], shape: "ellipsoid", widthScale: 1.2, heightScale: 1.0 },
+};
+
+const TRUNK_COLOR = "#8B6914";
+const AMBER_COLORS = ["#ff3333", "#ff5555", "#ff1111", "#ff4444", "#ffffff", "#ffcccc"];
+
+const EXT_MAP = {
+  ".js": "oak", ".jsx": "oak", ".mjs": "oak", ".cjs": "oak",
+  ".ts": "pine", ".tsx": "pine", ".mts": "pine",
+  ".css": "birch", ".scss": "birch", ".sass": "birch", ".less": "birch",
+  ".py": "willow", ".pyw": "willow",
+  ".md": "cherry", ".json": "cherry", ".yaml": "cherry", ".yml": "cherry",
+  ".toml": "cherry", ".xml": "cherry", ".ini": "cherry",
+};
+
+export function getSpecies(extension) {
+  const key = EXT_MAP[extension] || "default";
+  return SPECIES[key];
+}
+
+function seededRandom(seed) {
+  let s = seed >>> 0;
+  return () => {
+    s = Math.imul((s >>> 16) ^ s, 0x45d9f3b) >>> 0;
+    s = Math.imul((s >>> 16) ^ s, 0x45d9f3b) >>> 0;
+    s = ((s >>> 16) ^ s) >>> 0;
+    return s / 0x100000000;
+  };
+}
+
+function hashString(str) {
+  let h = 0;
+  for (let i = 0; i < str.length; i++) {
+    h = Math.imul(31, h) + str.charCodeAt(i) | 0;
+  }
+  return h >>> 0;
+}
+
+export function generateTreeCloud(file, position, fileIndex = 0, lodScale = 1) {
+  const species = getSpecies(file.extension);
+  const colors = file.changed ? AMBER_COLORS : species.colors;
+  const seed = hashString(file.relativePath);
+  const rng = seededRandom(seed);
+
+  const sizeLog = Math.log2(Math.max(1, file.size));
+  const changedBoost = file.changed ? 1.5 : 1;
+  const basePoints = Math.round((220 + sizeLog * 35) * changedBoost);
+  const churnMultiplier = 1 + Math.min(1, (file.churn || 0) / 30);
+  const canopyCount = Math.round(basePoints * churnMultiplier * lodScale);
+
+  const height = 5 + sizeLog * 1.1;
+  const canopyCenterY = height;
+  const canopyRadiusX = (height * 0.45) * species.widthScale * changedBoost;
+  const canopyRadiusY = (height * 0.5) * species.heightScale;
+  const canopyRadiusZ = canopyRadiusX;
+
+  const points = [];
+
+  for (let i = 0; i < canopyCount; i++) {
+    let px, py, pz;
+
+    if (species.shape === "cone") {
+      const t = rng();
+      const angle = rng() * Math.PI * 2;
+      const radius = t * canopyRadiusX;
+      px = Math.cos(angle) * radius;
+      pz = Math.sin(angle) * radius;
+      py = canopyCenterY + canopyRadiusY * (1 - t);
+    } else if (species.shape === "drooping") {
+      const u = rng() * Math.PI * 2;
+      const v = rng() * Math.PI;
+      const r = rng();
+      px = Math.cos(u) * Math.sin(v) * canopyRadiusX * r;
+      py = canopyCenterY + Math.cos(v) * canopyRadiusY * r;
+      pz = Math.sin(u) * Math.sin(v) * canopyRadiusZ * r;
+      if (rng() < 0.3) {
+        py = canopyCenterY - rng() * canopyRadiusY * 0.8;
+      }
+    } else if (species.shape === "sphere") {
+      const u = rng() * Math.PI * 2;
+      const v = Math.acos(2 * rng() - 1);
+      const r = Math.cbrt(rng()) * canopyRadiusX;
+      px = Math.cos(u) * Math.sin(v) * r;
+      py = canopyCenterY + Math.cos(v) * r;
+      pz = Math.sin(u) * Math.sin(v) * r;
+    } else {
+      const u = rng() * Math.PI * 2;
+      const v = Math.acos(2 * rng() - 1);
+      const r = Math.cbrt(rng());
+      px = Math.cos(u) * Math.sin(v) * canopyRadiusX * r;
+      py = canopyCenterY + Math.cos(v) * canopyRadiusY * r;
+      pz = Math.sin(u) * Math.sin(v) * canopyRadiusZ * r;
+    }
+
+    const color = colors[Math.floor(rng() * colors.length)];
+    points.push({
+      x: position.x + px,
+      y: py,
+      z: position.z + pz,
+      color,
+      fileIndex,
+    });
+  }
+
+  const trunkCount = Math.round((8 + height * 2) * Math.max(0.5, lodScale));
+  for (let i = 0; i < trunkCount; i++) {
+    const t = i / trunkCount;
+    points.push({
+      x: position.x + (rng() - 0.5) * 0.5,
+      y: t * (canopyCenterY - canopyRadiusY * 0.5),
+      z: position.z + (rng() - 0.5) * 0.5,
+      color: TRUNK_COLOR,
+      fileIndex,
+    });
+  }
+
+  return points;
+}
+
+export function generateForestCloud(files) {
+  const dirGroups = {};
+  for (let i = 0; i < files.length; i++) {
+    const dir = files[i].directory || ".";
+    const topDir = dir === "." ? "." : dir.split("/")[0];
+    if (!dirGroups[topDir]) dirGroups[topDir] = [];
+    dirGroups[topDir].push({ file: files[i], index: i });
+  }
+
+  const dirs = Object.keys(dirGroups);
+  const totalFiles = files.length;
+  const spreadRadius = Math.max(20, Math.sqrt(totalFiles) * 8);
+
+  const MAX_POINTS = 80000;
+  const estimatedPointsPerFile = 400;
+  const estimatedTotal = totalFiles * estimatedPointsPerFile;
+  const lodScale = estimatedTotal > MAX_POINTS ? MAX_POINTS / estimatedTotal : 1;
+
+  const allPoints = [];
+  const filePaths = files.map((f) => f.relativePath);
+
+  dirs.forEach((dir, dirIndex) => {
+    const angle = (dirIndex / dirs.length) * Math.PI * 2;
+    const clusterCenterX = Math.cos(angle) * spreadRadius * 0.6;
+    const clusterCenterZ = Math.sin(angle) * spreadRadius * 0.6;
+
+    const group = dirGroups[dir];
+    const clusterSpread = Math.max(8, Math.sqrt(group.length) * 6);
+
+    group.forEach((entry, fileInGroup) => {
+      const seed = hashString(entry.file.relativePath);
+      const rng = seededRandom(seed);
+      const fx = clusterCenterX + (rng() - 0.5) * clusterSpread;
+      const fz = clusterCenterZ + (rng() - 0.5) * clusterSpread;
+
+      const treePoints = generateTreeCloud(entry.file, { x: fx, z: fz }, entry.index, lodScale);
+      allPoints.push(...treePoints);
+    });
+  });
+
+  return { points: allPoints, filePaths };
+}
+
+export function generateGroundPlane(radius) {
+  const points = [];
+  const step = 0.7;
+  const groundColors = ["#3a2a1a", "#4a3a2a", "#352515", "#2a1a0a"];
+
+  for (let x = -radius; x <= radius; x += step) {
+    for (let z = -radius; z <= radius; z += step) {
+      if (x * x + z * z > radius * radius) continue;
+
+      const seed = hashString(`ground_${x}_${z}`);
+      const rng = seededRandom(seed);
+      const color = groundColors[Math.floor(rng() * groundColors.length)];
+
+      points.push({
+        x,
+        y: 0,
+        z,
+        color,
+        fileIndex: -1,
+      });
+    }
+  }
+
+  return points;
+}

package/src/renderer.js

@@ -1,9 +1,10 @@
 import chalk from "chalk";
 
-import { getSprite, TREE_TYPES } from "./sprites.js";
+import { getSprite, getGroundDetail, TREE_TYPES, GROUND_DETAIL_TYPES } from "./sprites.js";
+import { getVirtualWidth } from "./plant.js";
 
 const SKY_ROWS = 4;
-const TREE_ROWS = 7;
+const TREE_ROWS = 10;
 const GROUND_ROWS = 2;
 const SPACER_ROWS = 1;
 const STATS_ROWS = 1;
@@ -92,6 +93,8 @@ const BIOMES = [
     starDensity: 12,
     starColors: ["#3a3a3a", "#444444"],
     label: "clearing",
+    detailDensity: 0,
+    detailTypes: [],
   },
   { // 10-24: young grove
     ground: ["#22492d", "#18361f"],
@@ -99,6 +102,8 @@ const BIOMES = [
     starDensity: 9,
     starColors: ["#444444", "#5d5d5d"],
     label: "grove",
+    detailDensity: 18,
+    detailTypes: ["rock", "grass"],
   },
   { // 25-49: dense woodland
     ground: ["#1e4a28", "#163a1e"],
@@ -106,6 +111,8 @@ const BIOMES = [
     starDensity: 7,
     starColors: ["#4d4d4d", "#5d5d5d", "#6a6a55"],
     label: "woodland",
+    detailDensity: 12,
+    detailTypes: ["rock", "grass", "mushroom", "bush"],
   },
   { // 50-99: old growth
     ground: ["#1a5230", "#124020"],
@@ -113,6 +120,8 @@ const BIOMES = [
     starDensity: 6,
     starColors: ["#5d5d5d", "#6d6d5a", "#7a7a60"],
     label: "old growth",
+    detailDensity: 8,
+    detailTypes: ["rock", "grass", "mushroom", "bush", "leaf"],
   },
   { // 100+: ancient forest
     ground: ["#165a32", "#0e4822"],
@@ -120,6 +129,8 @@ const BIOMES = [
     starDensity: 5,
     starColors: ["#6d6d5a", "#7a7a60", "#8a8a6a"],
     label: "ancient forest",
+    detailDensity: 5,
+    detailTypes: ["rock", "grass", "mushroom", "bush", "leaf"],
   },
 ];
 
@@ -144,6 +155,19 @@ function hash(seed) {
   return ((value >>> 16) ^ value) >>> 0;
 }
 
+function getTreeYOffset(treeId) {
+  const h = hash(treeId * 13 + 7);
+  return h % 2; // Returns 0 or 1 (only up, never below ground)
+}
+
+function getWindOffset(treeId, windTick) {
+  if (windTick == null) return 0;
+  const windDirection = Math.floor(windTick / 4) % 2 === 0 ? 1 : -1;
+  const treePhase = hash(treeId * 7) % 3;
+  const effectiveTick = Math.max(0, windTick - treePhase);
+  return (effectiveTick % 2 === 0) ? 0 : windDirection;
+}
+
 function generateStars(width, biome, twinkle = 0) {
   const stars = [];
   for (let x = 0; x < width; x += 1) {
@@ -159,14 +183,16 @@ function generateStars(width, biome, twinkle = 0) {
   return stars;
 }
 
-function compositeSprite(buffer, sprite, centerX, baseY) {
+function compositeSprite(buffer, sprite, centerX, baseY, canopyShiftX = 0) {
   const offsetX = centerX - Math.floor(sprite.width / 2);
+  const trunkRows = 2;
   for (let rowIndex = 0; rowIndex < sprite.rows.length; rowIndex += 1) {
     const targetY = baseY - rowIndex;
     if (targetY < 0 || targetY >= buffer.length) continue;
     const row = sprite.rows[rowIndex];
+    const shiftX = rowIndex < trunkRows ? 0 : canopyShiftX;
     for (let columnIndex = 0; columnIndex < row.length; columnIndex += 1) {
-      const targetX = offsetX + columnIndex;
+      const targetX = offsetX + columnIndex + shiftX;
       if (targetX < 0 || targetX >= buffer[0].length) continue;
       const [char, color] = row[columnIndex];
       if (!color) continue;
@@ -175,6 +201,41 @@ function compositeSprite(buffer, sprite, centerX, baseY) {
   }
 }
 
+function renderGroundDetails(buffer, biome, virtualWidth, groundStart) {
+  if (biome.detailDensity === 0 || biome.detailTypes.length === 0) return;
+
+  const detailRow = groundStart - 1; // lowest tree row, just above ground
+
+  for (let x = 0; x < virtualWidth; x += 1) {
+    const h = hash(x * 53 + 9973);
+    if (h % biome.detailDensity !== 0) continue;
+
+    // Pick detail type deterministically
+    const detailType = biome.detailTypes[h % biome.detailTypes.length];
+    const sprite = getGroundDetail(detailType);
+
+    // Only place if all cells are currently empty (no tree pixel there)
+    // compositeSprite centers the sprite, so match that logic here
+    const offsetX = x - Math.floor(sprite.width / 2);
+    let blocked = false;
+    for (let rowIndex = 0; rowIndex < sprite.rows.length; rowIndex++) {
+      const targetY = detailRow - rowIndex;
+      if (targetY < 0 || targetY >= buffer.length) { blocked = true; break; }
+      for (let colIndex = 0; colIndex < sprite.rows[rowIndex].length; colIndex++) {
+        const targetX = offsetX + colIndex;
+        if (targetX < 0 || targetX >= virtualWidth) { blocked = true; break; }
+        const [, color] = sprite.rows[rowIndex][colIndex];
+        if (color && buffer[targetY][targetX].color) { blocked = true; break; }
+      }
+      if (blocked) break;
+    }
+    if (blocked) continue;
+
+    // Place the detail sprite (compositeSprite centers at x)
+    compositeSprite(buffer, sprite, x, detailRow);
+  }
+}
+
 function getNextMilestone(treeCount) {
   return MILESTONES.find((value) => treeCount < value) ?? treeCount + 100;
 }
@@ -198,7 +259,7 @@ function buildStreakSegment(forest) {
   return chalk.hex(STREAK_COLOR)(`${streak}-day streak`);
 }
 
-function buildStatsLine(forest, biome) {
+function buildStatsLine(forest, biome, viewportX = 0, virtualWidth = 0, termWidth = 80) {
   const treeCount = forest.trees.length;
   const milestone = getNextMilestone(treeCount);
   const progress = milestone === 0 ? 0 : treeCount / milestone;
@@ -208,6 +269,25 @@ function buildStatsLine(forest, biome) {
     chalk.hex(BAR_FILL)("█".repeat(filledWidth)) +
     chalk.hex(BAR_EMPTY)("░".repeat(barWidth - filledWidth));
 
+  // Viewport minimap — only show when forest is wider than terminal
+  let minimap = "";
+  if (virtualWidth > termWidth) {
+    const mapWidth = 12;
+    const viewFraction = termWidth / virtualWidth;
+    const thumbWidth = Math.max(1, Math.round(viewFraction * mapWidth));
+    const maxOffset = virtualWidth - termWidth;
+    const thumbPos = maxOffset > 0
+      ? Math.round((viewportX / maxOffset) * (mapWidth - thumbWidth))
+      : 0;
+    const mapBar =
+      "─".repeat(thumbPos) +
+      "═".repeat(thumbWidth) +
+      "─".repeat(mapWidth - thumbPos - thumbWidth);
+    minimap = chalk.hex(STATS_TEXT)(" [") +
+      chalk.hex(BAR_FILL)(mapBar) +
+      chalk.hex(STATS_TEXT)("]");
+  }
+
   return (
     chalk.hex(STATS_ACCENT)(" honeytree") +
     chalk.hex(STATS_TEXT)(
@@ -217,23 +297,32 @@ function buildStatsLine(forest, biome) {
     chalk.hex(STATS_TEXT)(" · ") +
     bar +
     chalk.hex(STATS_TEXT)(` next: ${getNextTreeType(treeCount)}`) +
-    chalk.hex("#555555")(` [${biome.label}]`)
+    chalk.hex("#555555")(` [${biome.label}]`) +
+    minimap
   );
 }
 
 export function renderFrame(forest, termWidth = 80, options = {}) {
   const width = Math.max(40, termWidth);
-  const buffer = createBuffer(width);
+  const treeCount = forest.trees.length;
+  const virtualWidth = options.virtualWidth ?? getVirtualWidth(treeCount, width);
+  const viewportX = Math.max(
+    0,
+    Math.min(options.viewportX ?? 0, Math.max(0, virtualWidth - width)),
+  );
+
+  // Build the full virtual-width buffer
+  const buffer = createBuffer(virtualWidth);
   const groundStart = SKY_ROWS + TREE_ROWS;
-  const biome = getBiome(forest.trees.length);
+  const biome = getBiome(treeCount);
   const wilt = getWiltFactor(forest.lastActiveDate);
 
-  for (const star of generateStars(width, biome, options.twinkleSeed ?? 0)) {
+  for (const star of generateStars(virtualWidth, biome, options.twinkleSeed ?? 0)) {
     buffer[star.y][star.x] = { char: star.char, color: star.color };
   }
 
   for (let rowIndex = 0; rowIndex < GROUND_ROWS; rowIndex += 1) {
-    for (let x = 0; x < width; x += 1) {
+    for (let x = 0; x < virtualWidth; x += 1) {
       buffer[groundStart + rowIndex][x] = {
         char: "█",
         color: biome.ground[rowIndex],
@@ -241,21 +330,61 @@ export function renderFrame(forest, termWidth = 80, options = {}) {
     }
   }
 
+  const windTick = options.windTick ?? null;
   const treeBaseY = groundStart - 1;
+  const spriteOverride = options.spriteOverride ?? null;
   for (const tree of forest.trees) {
-    compositeSprite(buffer, getSprite(tree.type, tree.growth), tree.x, treeBaseY);
+    const yOffset = getTreeYOffset(tree.id);
+    const sprite = (spriteOverride && spriteOverride.treeId === tree.id)
+      ? spriteOverride.sprite
+      : getSprite(tree.type, tree.growth);
+    const canopyShiftX = getWindOffset(tree.id, windTick);
+    compositeSprite(buffer, sprite, tree.x, treeBaseY - yOffset, canopyShiftX);
+  }
+
+  // Apply ground overlay (soil reaction during tree birth animation)
+  const groundOverlayOpt = options.groundOverlay ?? null;
+  if (groundOverlayOpt && groundOverlayOpt.overlays) {
+    const groundRow = groundStart; // first ground row
+    for (const overlay of groundOverlayOpt.overlays) {
+      const ox = groundOverlayOpt.treeX + overlay.dx;
+      if (ox >= 0 && ox < virtualWidth && groundRow < buffer.length) {
+        buffer[groundRow][ox] = { char: overlay.char, color: overlay.color };
+      }
+    }
+  }
+
+  // Ground pulse — brighten all ground pixels by 30% during planting flash
+  const groundPulse = options.groundPulse ?? false;
+  if (groundPulse) {
+    for (let rowIndex = 0; rowIndex < GROUND_ROWS; rowIndex += 1) {
+      for (let x = 0; x < virtualWidth; x += 1) {
+        const cell = buffer[groundStart + rowIndex][x];
+        if (cell.color) {
+          const c = parseHex(cell.color);
+          cell.color = toHex({
+            r: Math.min(255, c.r + (255 - c.r) * 0.3),
+            g: Math.min(255, c.g + (255 - c.g) * 0.3),
+            b: Math.min(255, c.b + (255 - c.b) * 0.3),
+          });
+        }
+      }
+    }
   }
 
-  applyFog(buffer, wilt, width);
+  renderGroundDetails(buffer, biome, virtualWidth, groundStart);
 
+  applyFog(buffer, wilt, virtualWidth);
+
+  // Slice the viewport from the virtual buffer
   const lines = [];
   for (let y = 0; y < SCENE_HEIGHT - SPACER_ROWS - STATS_ROWS - CTA_ROWS; y += 1) {
     let line = "";
-    for (const cell of buffer[y]) {
+    for (let x = viewportX; x < viewportX + width; x += 1) {
+      const cell = buffer[y][x];
       if (!cell.color) {
         line += cell.char;
       } else {
-        // Apply wilting to tree rows and ground (skip sky)
         const color = wilt > 0 && y >= SKY_ROWS ? wiltColor(cell.color, wilt) : cell.color;
         line += chalk.hex(color)(cell.char);
       }
@@ -264,9 +393,9 @@ export function renderFrame(forest, termWidth = 80, options = {}) {
   }
 
   lines.push("");
-  lines.push(buildStatsLine(forest, biome));
+  lines.push(buildStatsLine(forest, biome, viewportX, virtualWidth, width));
   lines.push(
-    chalk.hex("#555555")(" add your forest to your README → ") +
+    chalk.hex("#555555")(" ← → pan  ·  add your forest to your README → ") +
     chalk.hex(STATS_ACCENT)("honeytree badge"),
   );
 
@@ -297,9 +426,12 @@ export function buildScene(forest, width) {
 
   const treeBaseY = groundStart - 1;
   for (const tree of forest.trees) {
-    compositeSprite(buffer, getSprite(tree.type, tree.growth), tree.x, treeBaseY);
+    const yOffset = getTreeYOffset(tree.id);
+    compositeSprite(buffer, getSprite(tree.type, tree.growth), tree.x, treeBaseY - yOffset);
   }
 
+  renderGroundDetails(buffer, biome, w, groundStart);
+
   applyFog(buffer, wilt, w);
 
   if (wilt > 0) {
@@ -333,7 +465,8 @@ export function renderPlainText(forest, width = 60) {
 
   const treeBaseY = groundStart - 1;
   for (const tree of forest.trees) {
-    compositeSprite(buffer, getSprite(tree.type, tree.growth), tree.x, treeBaseY);
+    const yOffset = getTreeYOffset(tree.id);
+    compositeSprite(buffer, getSprite(tree.type, tree.growth), tree.x, treeBaseY - yOffset);
   }
 
   const lines = [];

package/src/renderer3d.js

@@ -0,0 +1,135 @@
+import chalk from "chalk";
+
+chalk.level = 3; // force 24-bit true color
+
+const BLOCK_CHARS = ["█", "▓", "▒", "░"];
+const BG_COLOR = "#0a0a1a";
+
+function parseHex(hex) {
+  const h = hex.startsWith("#") ? hex.slice(1) : hex;
+  return {
+    r: parseInt(h.slice(0, 2), 16),
+    g: parseInt(h.slice(2, 4), 16),
+    b: parseInt(h.slice(4, 6), 16),
+  };
+}
+
+function toHex({ r, g, b }) {
+  const c = (v) => Math.max(0, Math.min(255, Math.round(v))).toString(16).padStart(2, "0");
+  return `#${c(r)}${c(g)}${c(b)}`;
+}
+
+function lerpColor(hex, targetHex, factor) {
+  const c = parseHex(hex);
+  const t = parseHex(targetHex);
+  return toHex({
+    r: c.r + (t.r - c.r) * factor,
+    g: c.g + (t.g - c.g) * factor,
+    b: c.b + (t.b - c.b) * factor,
+  });
+}
+
+export function createFrameBuffer(width, height) {
+  const chars = Array.from({ length: height }, () =>
+    Array.from({ length: width }, () => ({ char: " ", color: null }))
+  );
+  const depth = Array.from({ length: height }, () =>
+    new Float64Array(width).fill(Infinity)
+  );
+  const fileIndices = Array.from({ length: height }, () =>
+    new Int32Array(width).fill(-1)
+  );
+
+  return { chars, depth, fileIndices, width, height };
+}
+
+export function rasterize(buf, projectedPoints, depthRange = null) {
+  let minDepth = Infinity;
+  let maxDepth = -Infinity;
+
+  if (depthRange) {
+    minDepth = depthRange.minDepth;
+    maxDepth = depthRange.maxDepth;
+  } else {
+    for (const p of projectedPoints) {
+      if (!p.visible) continue;
+      if (p.depth < minDepth) minDepth = p.depth;
+      if (p.depth > maxDepth) maxDepth = p.depth;
+    }
+  }
+
+  const depthSpan = maxDepth - minDepth || 1;
+
+  for (const p of projectedPoints) {
+    if (!p.visible) continue;
+
+    const sx = p.screenX;
+    const sy = p.screenY;
+
+    const t = (p.depth - minDepth) / depthSpan;
+    const charIndex = t === 0 ? 0 : Math.min(BLOCK_CHARS.length - 1, Math.ceil(t * BLOCK_CHARS.length) - 1);
+    const blockChar = BLOCK_CHARS[charIndex];
+    const dimFactor = t * 0.6;
+    const dimmedColor = lerpColor(p.color, BG_COLOR, dimFactor);
+
+    // Point splatting — closer points splat larger (2x2 for near, 1x1 for far)
+    const splatRadius = t < 0.3 ? 2 : t < 0.7 ? 1 : 0;
+
+    for (let dy = -splatRadius; dy <= splatRadius; dy++) {
+      for (let dx = -splatRadius; dx <= splatRadius; dx++) {
+        const px = sx + dx;
+        const py = sy + dy;
+
+        if (px < 0 || px >= buf.width || py < 0 || py >= buf.height) continue;
+
+        if (p.depth < buf.depth[py][px]) {
+          buf.depth[py][px] = p.depth;
+          buf.fileIndices[py][px] = p.fileIndex;
+
+          // Edge pixels of splat use lighter block char
+          const edgeChar = (dx === 0 && dy === 0) ? blockChar : BLOCK_CHARS[Math.min(BLOCK_CHARS.length - 1, charIndex + 1)];
+          buf.chars[py][px] = { char: edgeChar, color: dimmedColor };
+        }
+      }
+    }
+  }
+}
+
+export function renderBufferToString(buf, bgColor = BG_COLOR, changedIndices = null) {
+  const lines = [];
+
+  for (let y = 0; y < buf.height; y++) {
+    let line = "";
+    for (let x = 0; x < buf.width; x++) {
+      const cell = buf.chars[y][x];
+      if (!cell.color) {
+        line += chalk.hex(bgColor)(" ");
+      } else {
+        let color = cell.color;
+        if (changedIndices && buf.fileIndices[y][x] >= 0 && !changedIndices.has(buf.fileIndices[y][x])) {
+          color = lerpColor(color, bgColor, 0.6);
+        }
+        line += chalk.hex(color)(cell.char);
+      }
+    }
+    lines.push(line);
+  }
+
+  return lines.join("\n");
+}
+
+export function renderTopBar(hoveredFile, width, modified = false) {
+  if (!hoveredFile) return " ".repeat(width);
+  const tag = modified ? " [modified]" : "";
+  const plainLen = hoveredFile.length + tag.length + 2;
+  const pad = Math.max(0, Math.floor((width - plainLen) / 2));
+  const fileText = chalk.hex("#f5a50b")(` ${hoveredFile}`);
+  const tagText = modified ? chalk.hex("#ff8822")(" [modified]") : "";
+  return " ".repeat(pad) + fileText + tagText + " " + " ".repeat(Math.max(0, width - pad - plainLen));
+}
+
+export function renderStatusBar(fileCount, width, prefix = "") {
+  const rightPart = `${prefix}${fileCount} files  |  drag to rotate  |  +/- zoom  |  d diff  |  q quit  r rescan `;
+  const padding = Math.max(0, width - rightPart.length);
+  return " ".repeat(padding) + chalk.hex("#8e8a84")(rightPart);
+}