honeytree 1.1.6 → 1.2.0

package/src/animation.js

@@ -0,0 +1,151 @@
+import { ANIMATION_KEYFRAMES } from "./animation-keyframes.js";
+import { getSprite } from "./sprites.js";
+
+const CHAR_ORDER = [" ", "░", "▒", "█"];
+
+function charIndex(ch) {
+  const idx = CHAR_ORDER.indexOf(ch);
+  return idx >= 0 ? idx : 0;
+}
+
+function interpolateChar(ch1, ch2, t) {
+  const i1 = charIndex(ch1);
+  const i2 = charIndex(ch2);
+  const idx = Math.round(i1 + (i2 - i1) * t);
+  return CHAR_ORDER[Math.max(0, Math.min(CHAR_ORDER.length - 1, idx))];
+}
+
+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(hex1, hex2, t) {
+  const c1 = parseHex(hex1);
+  const c2 = parseHex(hex2);
+  return toHex({
+    r: c1.r + (c2.r - c1.r) * t,
+    g: c1.g + (c2.g - c1.g) * t,
+    b: c1.b + (c2.b - c1.b) * t,
+  });
+}
+
+function interpolateSprite(sprite1, sprite2, t) {
+  const rows = sprite1.rows.map((row, r) =>
+    row.map(([ch1, col1], c) => {
+      const [ch2, col2] = sprite2.rows[r][c];
+      if (!col1 && !col2) return [" ", null];
+      if (!col1 && col2) {
+        const ch = interpolateChar(" ", ch2, t);
+        if (ch === " ") return [" ", null];
+        return [ch, col2];
+      }
+      if (col1 && !col2) {
+        const ch = interpolateChar(ch1, " ", t);
+        if (ch === " ") return [" ", null];
+        return [ch, col1];
+      }
+      const ch = interpolateChar(ch1, ch2, t);
+      const col = lerpColor(col1, col2, t);
+      return [ch, col];
+    }),
+  );
+  return { rows, width: sprite1.width };
+}
+
+function brightenSprite(sprite, amount) {
+  const rows = sprite.rows.map((row) =>
+    row.map(([ch, col]) => {
+      if (!col) return [ch, col];
+      const c = parseHex(col);
+      return [ch, toHex({
+        r: Math.min(255, c.r + (255 - c.r) * amount),
+        g: Math.min(255, c.g + (255 - c.g) * amount),
+        b: Math.min(255, c.b + (255 - c.b) * amount),
+      })];
+    }),
+  );
+  return { rows, width: sprite.width };
+}
+
+export function getAnimationFrames(type, growth, frameCount = 40) {
+  const allKeyframes = ANIMATION_KEYFRAMES[type];
+  if (!allKeyframes) throw new Error(`No animation keyframes for type: ${type}`);
+
+  const finalSprite = getSprite(type, growth);
+
+  let keyframes;
+  if (growth >= 0.8) {
+    keyframes = allKeyframes;
+  } else {
+    let maxKF;
+    if (growth < 0.2) maxKF = 3;
+    else if (growth < 0.5) maxKF = 6;
+    else maxKF = 8;
+
+    keyframes = allKeyframes.slice(0, maxKF);
+    const lastTime = keyframes[keyframes.length - 1].time;
+    const timeScale = 4.0 / Math.max(lastTime, 0.1);
+
+    keyframes = keyframes.map((kf) => ({ ...kf, time: kf.time * timeScale }));
+    keyframes.push({ time: 4.0, sprite: finalSprite });
+    keyframes.push({ time: 4.5, sprite: brightenSprite(finalSprite, 0.2) });
+  }
+
+  const totalDuration = 5.0;
+  const frames = [];
+
+  for (let i = 0; i < frameCount; i++) {
+    const t = (i / (frameCount - 1)) * totalDuration;
+
+    let kfBefore = keyframes[0];
+    let kfAfter = keyframes[0];
+
+    for (let k = 0; k < keyframes.length - 1; k++) {
+      if (t >= keyframes[k].time && t <= keyframes[k + 1].time) {
+        kfBefore = keyframes[k];
+        kfAfter = keyframes[k + 1];
+        break;
+      }
+      if (k === keyframes.length - 2) {
+        kfBefore = keyframes[keyframes.length - 1];
+        kfAfter = keyframes[keyframes.length - 1];
+      }
+    }
+
+    const segmentDuration = kfAfter.time - kfBefore.time;
+    const segmentT = segmentDuration > 0 ? (t - kfBefore.time) / segmentDuration : 1;
+    const clampedT = Math.max(0, Math.min(1, segmentT));
+
+    const sprite = interpolateSprite(kfBefore.sprite, kfAfter.sprite, clampedT);
+
+    let groundOverlay = null;
+    if (t < 0.5 && kfBefore.groundEffect) {
+      const ge = kfBefore.groundEffect;
+      groundOverlay = [];
+      for (let dx = -ge.radius; dx <= ge.radius; dx++) {
+        const intensity = 1 - Math.abs(dx) / ge.radius;
+        if (intensity > 0.3) {
+          groundOverlay.push({ dx, char: "░", color: ge.color });
+        }
+      }
+    }
+
+    if (i === frameCount - 1) {
+      frames.push({ sprite: finalSprite, groundOverlay: null, groundPulse: false });
+    } else {
+      frames.push({ sprite, groundOverlay, groundPulse: i < 3 });
+    }
+  }
+
+  return frames;
+}

package/src/camera.js

@@ -0,0 +1,54 @@
+// src/camera.js
+
+const DEG_TO_RAD = Math.PI / 180;
+
+export function createCamera() {
+  return {
+    azimuth: 45,
+    elevation: 30,
+    distance: 60,
+  };
+}
+
+export function rotatePoint(x, y, z, azimuthDeg, elevationDeg) {
+  const az = azimuthDeg * DEG_TO_RAD;
+  const el = elevationDeg * DEG_TO_RAD;
+
+  const cosAz = Math.cos(az);
+  const sinAz = Math.sin(az);
+  const x1 = x * cosAz + z * sinAz;
+  const z1 = -x * sinAz + z * cosAz;
+
+  const cosEl = Math.cos(el);
+  const sinEl = Math.sin(el);
+  const y1 = y * cosEl - z1 * sinEl;
+  const z2 = y * sinEl + z1 * cosEl;
+
+  return [x1, y1, z2];
+}
+
+export function projectPoint(x, y, z, screenWidth, screenHeight, distance = 25) {
+  const fov = 60;
+  const fovRad = fov * DEG_TO_RAD;
+  const focalLength = screenHeight / (2 * Math.tan(fovRad / 2));
+
+  const zView = z - distance;
+
+  if (zView >= -1) {
+    return { screenX: -1, screenY: -1, depth: Infinity, visible: false };
+  }
+
+  const scale = focalLength / -zView;
+  const screenX = Math.round(x * scale * 2 + screenWidth / 2);
+  const screenY = Math.round(-y * scale + screenHeight / 2);
+
+  return { screenX, screenY, depth: -zView, visible: true };
+}
+
+export function clampElevation(elevation) {
+  return Math.max(10, Math.min(80, elevation));
+}
+
+export function clampAzimuth(azimuth) {
+  return ((azimuth % 360) + 360) % 360;
+}

package/src/diffactions.js

@@ -0,0 +1,32 @@
+import { execSync } from "node:child_process";
+import { hunkToPatch } from "./diffparser.js";
+
+export function stageHunk(rootDir, filePath, hunk) {
+  try {
+    const patch = hunkToPatch(filePath, hunk);
+    execSync("git apply --cached --unidiff-zero -", {
+      cwd: rootDir,
+      input: patch,
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+export function revertHunk(rootDir, filePath, hunk) {
+  try {
+    const patch = hunkToPatch(filePath, hunk);
+    execSync("git apply --reverse --unidiff-zero -", {
+      cwd: rootDir,
+      input: patch,
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}

package/src/diffpanel.js

@@ -0,0 +1,83 @@
+// src/diffpanel.js
+import chalk from "chalk";
+
+chalk.level = 3;
+
+export function createDiffPanel(filePath, hunks) {
+  return {
+    filePath,
+    hunks,
+    currentHunk: 0,
+    hunkStatus: hunks.map(() => "pending"),
+    scrollOffset: 0,
+  };
+}
+
+export function renderDiffPanel(panel, width, height) {
+  const lines = [];
+  const totalAdded = panel.hunks.reduce((s, h) => s + h.added, 0);
+  const totalRemoved = panel.hunks.reduce((s, h) => s + h.removed, 0);
+
+  // Header
+  const header = ` ${panel.filePath}  +${totalAdded} -${totalRemoved}  ${panel.hunks.length} hunks`;
+  lines.push(chalk.hex("#f5a50b").bold(header.padEnd(width).slice(0, width)));
+
+  // Separator
+  lines.push(chalk.hex("#555555")("─".repeat(width)));
+
+  // Help line
+  const help = " j/k: navigate  a: accept  r: reject  A/R: all  Esc: close";
+  lines.push(chalk.hex("#888888")(help.padEnd(width).slice(0, width)));
+
+  lines.push(chalk.hex("#555555")("─".repeat(width)));
+
+  // Render hunks
+  const bodyHeight = height - lines.length;
+  const bodyLines = [];
+
+  for (let hi = 0; hi < panel.hunks.length; hi++) {
+    const hunk = panel.hunks[hi];
+    const isCurrent = hi === panel.currentHunk;
+    const status = panel.hunkStatus[hi];
+
+    // Hunk header with status
+    let statusIcon = "[ ]";
+    if (status === "accepted") statusIcon = chalk.green("[✓]");
+    else if (status === "rejected") statusIcon = chalk.red("[✗]");
+
+    const hunkHeader = isCurrent
+      ? chalk.hex("#ffcc44").bold(`▸ Hunk ${hi + 1}/${panel.hunks.length} ${statusIcon} ${hunk.header}`)
+      : chalk.hex("#888888")(`  Hunk ${hi + 1}/${panel.hunks.length} ${statusIcon} ${hunk.header}`);
+
+    bodyLines.push(hunkHeader.padEnd(width).slice(0, width));
+
+    // Hunk lines
+    for (const line of hunk.lines) {
+      let rendered;
+      const text = line.text.padEnd(width).slice(0, width);
+      if (line.type === "added") {
+        rendered = chalk.green(text);
+      } else if (line.type === "removed") {
+        rendered = chalk.red(text);
+      } else {
+        rendered = isCurrent ? chalk.hex("#cccccc")(text) : chalk.hex("#666666")(text);
+      }
+      bodyLines.push(rendered);
+    }
+
+    bodyLines.push(""); // blank line between hunks
+  }
+
+  // Apply scroll offset and fill to height
+  const scrolled = bodyLines.slice(panel.scrollOffset, panel.scrollOffset + bodyHeight);
+  for (const line of scrolled) {
+    lines.push(line);
+  }
+
+  // Pad remaining height
+  while (lines.length < height) {
+    lines.push(" ".repeat(width));
+  }
+
+  return lines.slice(0, height);
+}

package/src/diffparser.js

@@ -0,0 +1,44 @@
+export function parseDiff(diffText) {
+  if (!diffText || !diffText.trim()) return [];
+
+  const lines = diffText.split("\n");
+  const hunks = [];
+  let currentHunk = null;
+
+  for (const line of lines) {
+    if (line.startsWith("@@")) {
+      if (currentHunk) {
+        currentHunk.added = currentHunk.lines.filter(l => l.type === "added").length;
+        currentHunk.removed = currentHunk.lines.filter(l => l.type === "removed").length;
+        hunks.push(currentHunk);
+      }
+      currentHunk = { header: line, lines: [], added: 0, removed: 0 };
+    } else if (currentHunk) {
+      if (line.startsWith("+")) {
+        currentHunk.lines.push({ type: "added", text: line });
+      } else if (line.startsWith("-")) {
+        currentHunk.lines.push({ type: "removed", text: line });
+      } else if (line.startsWith(" ") || line === "") {
+        currentHunk.lines.push({ type: "context", text: line });
+      }
+    }
+  }
+
+  if (currentHunk) {
+    currentHunk.added = currentHunk.lines.filter(l => l.type === "added").length;
+    currentHunk.removed = currentHunk.lines.filter(l => l.type === "removed").length;
+    hunks.push(currentHunk);
+  }
+
+  return hunks;
+}
+
+export function hunkToPatch(filePath, hunk) {
+  const lines = [
+    `--- a/${filePath}`,
+    `+++ b/${filePath}`,
+    hunk.header,
+    ...hunk.lines.map(l => l.text),
+  ];
+  return lines.join("\n") + "\n";
+}

package/src/diffwatch.js

@@ -0,0 +1,52 @@
+import { execFile } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+
+function execAsync(cmd, args, opts) {
+  return new Promise((resolve) => {
+    execFile(cmd, args, { timeout: 5000, encoding: "utf-8", ...opts }, (err, stdout) => {
+      resolve(err ? "" : stdout);
+    });
+  });
+}
+
+export async function getChangedFiles(rootDir) {
+  const changed = new Set();
+
+  const [tracked, untracked] = await Promise.all([
+    execAsync("git", ["diff", "--name-only"], { cwd: rootDir }),
+    execAsync("git", ["ls-files", "--others", "--exclude-standard"], { cwd: rootDir }),
+  ]);
+
+  for (const output of [tracked, untracked]) {
+    for (const line of output.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed) changed.add(trimmed);
+    }
+  }
+
+  return changed;
+}
+
+export function getFileDiff(rootDir, filePath) {
+  return execAsync("git", ["diff", "-U3", "--", filePath], { cwd: rootDir });
+}
+
+export function watchForChanges(rootDir, callback) {
+  let debounceTimer = null;
+  const debounced = () => {
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(callback, 300);
+  };
+
+  try {
+    const watcher = fs.watch(rootDir, { recursive: true }, (event, filename) => {
+      if (!filename) return;
+      if (filename.includes("node_modules") || filename.includes(".git")) return;
+      debounced();
+    });
+    return watcher;
+  } catch {
+    return null;
+  }
+}

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

@@ -160,6 +160,14 @@ function getTreeYOffset(treeId) {
   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) {
@@ -175,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;
@@ -320,10 +330,46 @@ 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) {
     const yOffset = getTreeYOffset(tree.id);
-    compositeSprite(buffer, getSprite(tree.type, tree.growth), tree.x, treeBaseY - yOffset);
+    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),
+          });
+        }
+      }
+    }
   }
 
   renderGroundDetails(buffer, biome, virtualWidth, groundStart);