asciify-engine 1.0.23 → 1.0.24

package/dist/index.js

@@ -1,17 +1,29 @@
 import { parseGIF, decompressFrames } from 'gifuct-js';
 
 // src/types.ts
+var PALETTE_THEMES = {
+  dracula: { name: "Dracula", accent: "#bd93f9", bg: "#282a36", fg: "#f8f8f2" },
+  monokai: { name: "Monokai", accent: "#a6e22e", bg: "#272822", fg: "#f8f8f2" },
+  nord: { name: "Nord", accent: "#88c0d0", bg: "#2e3440", fg: "#eceff4" },
+  catppuccin: { name: "Catppuccin", accent: "#cba6f7", bg: "#1e1e2e", fg: "#cdd6f4" },
+  solarized: { name: "Solarized", accent: "#268bd2", bg: "#002b36", fg: "#839496" },
+  gruvbox: { name: "Gruvbox", accent: "#b8bb26", bg: "#282828", fg: "#ebdbb2" }
+};
 var CHARSETS = {
   standard: " .:-=+*#%@",
   blocks: " \u2591\u2592\u2593\u2588",
   minimal: " .:+",
-  dense: " .'`^\",:;Il!i><~+_-?][}{1)(|\\/tfjrxnuvczXYUJCLQ0OZmwqpdbkhao*#MW&8%B@$",
+  dense: " .'`^\",:;Il!i><~+_-?][}{1)(|/tfjrxnuvczXYUJCLQ0OZmwqpdbkhao*#MW&8%B@$",
   binary: "01",
   dots: " \u2801\u2803\u2807\u2847\u28C7\u28E7\u28F7\u28FF",
   letters: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
   claudeCode: " \u2554\u2557\u255A\u255D\u2551\u2550\u2560\u2563\u2566\u2569\u256C\u2591\u2592\u2593\u2588\u2502\u2500\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C",
   box: " \u25AA\u25FE\u25FC\u25A0\u2588",
-  lines: " \u02D7\u2010\u2013\u2014\u2015\u2501"
+  lines: " \u02D7\u2010\u2013\u2014\u2015\u2501",
+  braille: " \u2801\u2802\u2803\u2804\u2805\u2806\u2807\u2808\u2809\u280A\u280B\u280C\u280D\u280E\u280F\u2810\u2811\u2812\u2813\u2814\u2815\u2816\u2817\u2818\u2819\u281A\u281B\u281C\u281D\u281E\u281F\u2820\u2821\u2822\u2823\u2824\u2825\u2826\u2827\u2828\u2829\u282A\u282B\u282C\u282D\u282E\u282F\u2830\u2831\u2832\u2833\u2834\u2835\u2836\u2837\u2838\u2839\u283A\u283B\u283C\u283D\u283E\u283F\u2840\u2841\u2842\u2843\u2844\u2845\u2846\u2847\u28C0\u28C1\u28C2\u28C3\u28C4\u28C5\u28C6\u28C7\u28C8\u28C9\u28CA\u28CB\u28CC\u28CD\u28CE\u28CF\u28D0\u28D1\u28D2\u28D3\u28D4\u28D5\u28D6\u28D7\u28D8\u28D9\u28DA\u28DB\u28DC\u28DD\u28DE\u28DF\u28E0\u28E1\u28E2\u28E3\u28E4\u28E5\u28E6\u28E7\u28E8\u28E9\u28EA\u28EB\u28EC\u28ED\u28EE\u28EF\u28F0\u28F1\u28F2\u28F3\u28F4\u28F5\u28F6\u28F7\u28F8\u28F9\u28FA\u28FB\u28FC\u28FD\u28FE\u28FF",
+  katakana: " \uFF66\uFF67\uFF68\uFF69\uFF6A\uFF6B\uFF6C\uFF6D\uFF6E\uFF6F\uFF71\uFF72\uFF73\uFF74\uFF75\uFF76\uFF77\uFF78\uFF79\uFF7A\uFF7B\uFF7C\uFF7D\uFF7E\uFF7F\uFF80\uFF81\uFF82\uFF83\uFF84\uFF85\uFF86\uFF87\uFF88\uFF89\uFF8A\uFF8B\uFF8C\uFF8D\uFF8E\uFF8F\uFF90\uFF91\uFF92\uFF93\uFF94\uFF95\uFF96\uFF97\uFF98\uFF99\uFF9A\uFF9B\uFF9C\uFF9D",
+  musical: " \u2669\u266A\u266B\u266C\u266D\u266E\u266F",
+  emoji: " \u2B1B\u{1F7EB}\u{1F7E5}\u{1F7E7}\u{1F7E8}\u{1F7E9}\u{1F7E6}\u{1F7EA}\u2B1C"
 };
 var ART_STYLE_PRESETS = {
   classic: {
@@ -54,6 +66,27 @@ var ART_STYLE_PRESETS = {
     renderMode: "ascii",
     charset: CHARSETS.lines,
     colorMode: "fullcolor"
+  },
+  braille: {
+    renderMode: "ascii",
+    charset: CHARSETS.braille,
+    colorMode: "fullcolor"
+  },
+  katakana: {
+    renderMode: "ascii",
+    charset: CHARSETS.katakana,
+    colorMode: "matrix"
+  },
+  musical: {
+    renderMode: "ascii",
+    charset: CHARSETS.musical,
+    colorMode: "accent",
+    accentColor: "#e040fb"
+  },
+  emoji: {
+    renderMode: "ascii",
+    charset: CHARSETS.emoji,
+    colorMode: "fullcolor"
   }
 };
 var DEFAULT_OPTIONS = {
@@ -109,6 +142,18 @@ var HOVER_PRESETS = {
   ice: {
     label: "Ice",
     options: { hoverStrength: 0.5, hoverEffect: "glow", hoverRadius: 0.15, hoverColor: "#60d5f7" }
+  },
+  gravity: {
+    label: "Gravity",
+    options: { hoverStrength: 0.7, hoverEffect: "attract", hoverRadius: 0.18, hoverColor: "#a5d6ff" }
+  },
+  shatter: {
+    label: "Shatter",
+    options: { hoverStrength: 0.8, hoverEffect: "shatter", hoverRadius: 0.14, hoverColor: "#ff6090" }
+  },
+  ghost: {
+    label: "Ghost",
+    options: { hoverStrength: 0.55, hoverEffect: "trail", hoverRadius: 0.2, hoverColor: "#b39ddb" }
   }
 };
 
@@ -128,14 +173,16 @@ function adjustLuminance(lum, brightness, contrast) {
 }
 function luminanceToChar(lum, charset, invert) {
   const normalized = invert ? 1 - lum / 255 : lum / 255;
-  const index = Math.floor(normalized * (charset.length - 1));
-  return charset[Math.max(0, Math.min(charset.length - 1, index))];
+  const chars = [...charset];
+  const index = Math.floor(normalized * (chars.length - 1));
+  return chars[Math.max(0, Math.min(chars.length - 1, index))];
 }
 function customTextToChar(lum, text, x, y, cols, invert) {
   const normalized = invert ? 1 - lum / 255 : lum / 255;
   if (normalized < 0.12) return " ";
+  const chars = [...text];
   const pos = y * cols + x;
-  return text[pos % text.length];
+  return chars[pos % chars.length];
 }
 var BAYER_4X4 = [
   [0, 8, 2, 10],
@@ -283,6 +330,44 @@ function getAnimationMultiplier(x, y, cols, rows, time, style, speed) {
     }
     case "waveField":
       return 1;
+    case "ripple": {
+      const cx2 = cols / 2;
+      const cy2 = rows / 2;
+      const dx2 = x - cx2;
+      const dy2 = y - cy2;
+      const dist2 = Math.sqrt(dx2 * dx2 + dy2 * dy2);
+      const maxDist2 = Math.sqrt(cx2 * cx2 + cy2 * cy2);
+      const ripple = Math.sin(dist2 / maxDist2 * Math.PI * 10 - t * 5) * 0.5 + 0.5;
+      const fadeEdge = 1 - Math.min(1, dist2 / (maxDist2 * 1.1));
+      return 0.1 + 0.9 * ripple * (0.4 + fadeEdge * 0.6);
+    }
+    case "melt": {
+      const lagPhase = y / rows * Math.PI;
+      const drip = Math.sin(lagPhase - t * 1.8 + x * 0.15) * 0.5 + 0.5;
+      const gravity = Math.max(0, y / rows - 0.1) / 0.9;
+      return 0.05 + 0.95 * (drip * (1 - gravity * 0.6));
+    }
+    case "orbit": {
+      const ocx = cols / 2;
+      const ocy = rows / 2;
+      const odx = x - ocx;
+      const ody = y - ocy;
+      const oAngle = Math.atan2(ody, odx);
+      const oDist = Math.sqrt(odx * odx + ody * ody) / Math.sqrt(ocx * ocx + ocy * ocy);
+      const orbit = Math.sin(oAngle * 2 + oDist * 6 - t * 2.5) * 0.5 + 0.5;
+      return 0.1 + 0.9 * orbit;
+    }
+    case "cellular": {
+      const tick = Math.floor(t * 4);
+      const alive = (cx, cy) => {
+        const h = Math.sin(cx * 127.1 + cy * 311.7 + tick * 43758.5453) * 43758.5453;
+        return h - Math.floor(h) > 0.38 ? 1 : 0;
+      };
+      const self = alive(x, y);
+      const neighbours = alive(x - 1, y) + alive(x + 1, y) + alive(x, y - 1) + alive(x, y + 1) + alive(x - 1, y - 1) + alive(x + 1, y - 1) + alive(x - 1, y + 1) + alive(x + 1, y + 1);
+      const nextAlive = self === 1 ? neighbours === 2 || neighbours === 3 ? 1 : 0 : neighbours === 3 ? 1 : 0;
+      return nextAlive === 1 ? 1 : 0.05;
+    }
     default:
       return 1;
   }
@@ -342,6 +427,30 @@ function computeHoverEffect(nx, ny, hoverX, hoverY, hoverIntensity, strength, ce
       glow = eased * strength * 0.2;
       colorBlend = eased * strength * 0.7;
       break;
+    case "attract": {
+      const angle3 = Math.atan2(dy, dx);
+      const pull = eased * eased * strength * 1;
+      offsetX = -Math.cos(angle3) * pull * cellW;
+      offsetY = -Math.sin(angle3) * pull * cellH;
+      glow = eased * strength * 0.3;
+      break;
+    }
+    case "shatter": {
+      const angle4 = Math.atan2(dy, dx);
+      const jitter = Math.sin(dx * 43.7 + dy * 29.3) * 0.5;
+      const scatter = eased * strength * 1.4 * (0.7 + jitter * 0.3);
+      offsetX = Math.cos(angle4 + jitter) * scatter * cellW;
+      offsetY = Math.sin(angle4 + jitter) * scatter * cellH;
+      scale = Math.max(0.1, 1 - eased * strength * 0.6);
+      glow = eased * strength * 0.25;
+      break;
+    }
+    case "trail": {
+      colorBlend = eased * strength * 0.9;
+      glow = eased * strength * 0.6;
+      scale = 1 + eased * strength * 0.15;
+      break;
+    }
   }
   _hoverResult.scale = scale;
   _hoverResult.offsetX = offsetX;
@@ -753,17 +862,18 @@ function renderFrameToCanvas(ctx, frame, options, canvasWidth, canvasHeight, tim
     const fontSize = Math.min(cellW / charAspect, cellH) * 0.9;
     const useFastRect = fontSize < 6;
     if (!useFastRect) {
-      ctx.font = `${fontSize}px "JetBrains Mono", monospace`;
+      const isEmoji = options.artStyle === "emoji";
+      ctx.font = isEmoji ? `${fontSize}px "Apple Color Emoji", "Segoe UI Emoji", "Noto Color Emoji", "Twemoji Mozilla", sans-serif` : `${fontSize}px "JetBrains Mono", monospace`;
       ctx.textAlign = "center";
       ctx.textBaseline = "middle";
     }
     let charWeights = null;
     if (useFastRect) {
       charWeights = {};
-      const cs = options.charset;
-      const csLen = cs.length;
+      const csChars = [...options.charset];
+      const csLen = csChars.length;
       for (let i = 0; i < csLen; i++) {
-        charWeights[cs[i]] = Math.max(0.1, (i + 0.3) / csLen);
+        charWeights[csChars[i]] = Math.max(0.1, (i + 0.3) / csLen);
       }
     }
     const baseTransform = !useFastRect ? ctx.getTransform() : null;
@@ -1674,6 +1784,292 @@ function renderMorphBackground(ctx, width, height, time, options = {}) {
   }
 }
 
+// src/backgrounds/fire.ts
+function renderFireBackground(ctx, width, height, time, options = {}) {
+  const {
+    fontSize = 13,
+    chars = " .,:;i+xX#&@",
+    color = "#ff4500",
+    hotColor = "#ffe066",
+    intensity = 0.85,
+    wind = 0,
+    speed = 1,
+    lightMode = false
+  } = options;
+  const charW = fontSize * 0.62;
+  const lineH = fontSize * 1.4;
+  const cols = Math.ceil(width / charW);
+  const rows = Math.ceil(height / lineH);
+  const len = cols * rows;
+  const key = "__fire_heat__";
+  const canvasAny = ctx.canvas;
+  let heat = canvasAny[key];
+  if (!heat || heat.length !== len) {
+    heat = new Float32Array(len);
+    canvasAny[key] = heat;
+  }
+  const dt = 0.016 * speed;
+  const coolingRate = 0.18 * dt;
+  const windShift = wind * speed * 0.8;
+  const baseRow = rows - 1;
+  const t = time * speed;
+  for (let c = 0; c < cols; c++) {
+    const flicker = Math.sin(c * 0.31 + t * 4.1) * 0.5 + 0.5;
+    const flicker2 = Math.sin(c * 0.73 - t * 2.7) * 0.5 + 0.5;
+    const seed = (flicker * 0.6 + flicker2 * 0.4) * intensity;
+    heat[baseRow * cols + c] = Math.min(1, seed + Math.random() * 0.15 * intensity);
+    if (baseRow > 0) heat[(baseRow - 1) * cols + c] = Math.min(1, seed * 0.85 + Math.random() * 0.1 * intensity);
+  }
+  const newHeat = new Float32Array(len);
+  for (let r = 0; r < rows - 2; r++) {
+    for (let c = 0; c < cols; c++) {
+      const below = heat[(r + 1) * cols + c];
+      const below2 = heat[(r + 2) * cols + Math.max(0, Math.min(cols - 1, c + Math.round(windShift)))];
+      const left = heat[(r + 1) * cols + Math.max(0, c - 1)];
+      const right = heat[(r + 1) * cols + Math.min(cols - 1, c + 1)];
+      const avg = below * 0.4 + below2 * 0.25 + left * 0.175 + right * 0.175;
+      newHeat[r * cols + c] = Math.max(0, avg - coolingRate - Math.random() * 0.02 * speed);
+    }
+  }
+  for (let c = 0; c < cols; c++) {
+    newHeat[(rows - 1) * cols + c] = heat[(rows - 1) * cols + c];
+    if (rows > 1) newHeat[(rows - 2) * cols + c] = heat[(rows - 2) * cols + c];
+  }
+  canvasAny[key] = newHeat;
+  const cp = parseColor(color) ?? { r: 255, g: 69, b: 0 };
+  const hp = parseColor(hotColor) ?? { r: 255, g: 224, b: 102 };
+  ctx.clearRect(0, 0, width, height);
+  ctx.font = `${fontSize}px "JetBrains Mono", monospace`;
+  ctx.textBaseline = "top";
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < cols; c++) {
+      const v = newHeat[r * cols + c];
+      if (v < 0.03) continue;
+      const charIdx = Math.min(chars.length - 1, Math.floor(v * chars.length));
+      const ch = chars[charIdx];
+      if (ch === " ") continue;
+      const blend = Math.min(1, v * 1.2);
+      const r2 = cp.r + (hp.r - cp.r) * blend | 0;
+      const g2 = cp.g + (hp.g - cp.g) * blend | 0;
+      const b2 = cp.b + (hp.b - cp.b) * blend | 0;
+      const alpha = lightMode ? 1 - v * 0.3 : Math.min(1, v + 0.15);
+      ctx.globalAlpha = alpha;
+      ctx.fillStyle = `rgb(${r2},${g2},${b2})`;
+      ctx.fillText(ch, c * charW, r * lineH);
+    }
+  }
+  ctx.globalAlpha = 1;
+}
+
+// src/backgrounds/dna.ts
+function renderDnaBackground(ctx, width, height, time, options = {}) {
+  const {
+    fontSize = 13,
+    baseChars = "ATCG",
+    bridgeChars = "-=\u2261",
+    color = "#00e5ff",
+    color2 = "#ff4081",
+    bridgeColor = "#88ffcc",
+    speed = 1,
+    helixCount,
+    lightMode = false
+  } = options;
+  const charW = fontSize * 0.62;
+  const lineH = fontSize * 1.4;
+  const cols = Math.ceil(width / charW);
+  const rows = Math.ceil(height / lineH);
+  const numHelix = helixCount ?? Math.max(1, Math.floor(width / 80));
+  const sectionW = cols / numHelix;
+  const cp = parseColor(color) ?? { r: 0, g: 229, b: 255 };
+  const cp2 = parseColor(color2) ?? { r: 255, g: 64, b: 129 };
+  const bp = parseColor(bridgeColor) ?? { r: 136, g: 255, b: 204 };
+  ctx.clearRect(0, 0, width, height);
+  ctx.font = `${fontSize}px "JetBrains Mono", monospace`;
+  ctx.textBaseline = "top";
+  const t = time * speed;
+  const amplitude = sectionW * 0.35;
+  for (let h = 0; h < numHelix; h++) {
+    const centerCol = sectionW * (h + 0.5);
+    for (let r = 0; r < rows; r++) {
+      const phase = r / rows * Math.PI * 6 - t * 1.8;
+      const strand1ColF = centerCol + Math.sin(phase) * amplitude;
+      const strand2ColF = centerCol + Math.sin(phase + Math.PI) * amplitude;
+      const strand1Col = Math.round(strand1ColF);
+      const strand2Col = Math.round(strand2ColF);
+      if (strand1Col < 0 || strand1Col >= cols) continue;
+      const baseSeed1 = hash2(h * 31 + r * 7, 3);
+      const ch1 = baseChars[Math.floor(baseSeed1 * baseChars.length)];
+      const depth1 = (Math.sin(phase) + 1) * 0.5;
+      const depth2 = (Math.sin(phase + Math.PI) + 1) * 0.5;
+      ctx.globalAlpha = 0.35 + depth1 * 0.65;
+      ctx.fillStyle = `rgb(${cp.r},${cp.g},${cp.b})`;
+      ctx.fillText(ch1, strand1Col * charW, r * lineH);
+      if (strand2Col >= 0 && strand2Col < cols) {
+        const baseSeed2 = hash2(h * 53 + r * 11, 7);
+        const ch2 = baseChars[Math.floor(baseSeed2 * baseChars.length)];
+        ctx.globalAlpha = 0.35 + depth2 * 0.65;
+        ctx.fillStyle = `rgb(${cp2.r},${cp2.g},${cp2.b})`;
+        ctx.fillText(ch2, strand2Col * charW, r * lineH);
+      }
+      const bridgeInterval = 3;
+      if (r % bridgeInterval === 0) {
+        const minC = Math.min(strand1Col, strand2Col);
+        const maxC = Math.max(strand1Col, strand2Col);
+        const bridgeLen = maxC - minC;
+        if (bridgeLen > 1) {
+          const bSeed = hash2(r * 17 + h * 43, 5);
+          const bCh = bridgeChars[Math.floor(bSeed * bridgeChars.length)];
+          const midBridgeAlpha = (depth1 + depth2) * 0.25 + 0.2;
+          ctx.globalAlpha = midBridgeAlpha;
+          ctx.fillStyle = `rgb(${bp.r},${bp.g},${bp.b})`;
+          for (let bc = minC + 1; bc < maxC; bc++) {
+            ctx.fillText(bCh, bc * charW, r * lineH);
+          }
+        }
+      }
+    }
+  }
+  ctx.globalAlpha = 1;
+}
+
+// src/backgrounds/terrain.ts
+function renderTerrainBackground(ctx, width, height, time, options = {}) {
+  const {
+    fontSize = 13,
+    chars = " .,:;+*#@",
+    color = "#4caf50",
+    skyColor = "#1a237e",
+    peakColor = "#e0e0e0",
+    speed = 1,
+    roughness = 0.55,
+    heightScale = 0.55,
+    stars = true,
+    lightMode = false
+  } = options;
+  const charW = fontSize * 0.62;
+  const lineH = fontSize * 1.4;
+  const cols = Math.ceil(width / charW);
+  const rows = Math.ceil(height / lineH);
+  const cp = parseColor(color) ?? { r: 76, g: 175, b: 80 };
+  const sky = parseColor(skyColor) ?? { r: 26, g: 35, b: 126 };
+  const peak = parseColor(peakColor) ?? { r: 224, g: 224, b: 224 };
+  ctx.clearRect(0, 0, width, height);
+  ctx.font = `${fontSize}px "JetBrains Mono", monospace`;
+  ctx.textBaseline = "top";
+  const scroll = time * speed * 0.4;
+  const terrainRow = new Array(cols);
+  for (let c = 0; c < cols; c++) {
+    const nx = (c / cols + scroll) * roughness * 3;
+    const h = (fbm(nx, 0.5) * 0.5 + 0.5) * heightScale;
+    terrainRow[c] = Math.floor(h * rows);
+  }
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < cols; c++) {
+      const terrainStart = rows - 1 - terrainRow[c];
+      const isGround = r >= terrainStart;
+      const isNearPeak = r === terrainStart;
+      if (!isGround) {
+        if (stars) {
+          const starSeed = hash2(c * 7 + Math.floor(scroll * 0.3), r * 13);
+          if (starSeed > 0.97) {
+            const twinkle = Math.sin(time * 2 + starSeed * 100) * 0.3 + 0.7;
+            ctx.globalAlpha = twinkle * 0.5;
+            ctx.fillStyle = `rgb(${sky.r + 60},${sky.g + 60},${sky.b + 80})`;
+            ctx.fillText("\xB7", c * charW, r * lineH);
+          }
+        }
+        continue;
+      }
+      const depth = (r - terrainStart) / Math.max(1, terrainRow[c]);
+      const charIdx = Math.min(chars.length - 1, Math.floor(depth * chars.length));
+      const ch = chars[charIdx];
+      if (ch === " " && !isNearPeak) continue;
+      const blendPeak = isNearPeak ? 1 : Math.max(0, 1 - depth * 4);
+      const r2 = cp.r + (peak.r - cp.r) * blendPeak | 0;
+      const g2 = cp.g + (peak.g - cp.g) * blendPeak | 0;
+      const b2 = cp.b + (peak.b - cp.b) * blendPeak | 0;
+      ctx.globalAlpha = 0.5 + depth * 0.5;
+      ctx.fillStyle = `rgb(${r2},${g2},${b2})`;
+      ctx.fillText(isNearPeak ? chars[chars.length - 1] : ch, c * charW, r * lineH);
+    }
+  }
+  ctx.globalAlpha = 1;
+}
+
+// src/backgrounds/circuit.ts
+var EAST = 1;
+var WEST = 2;
+var NORTH = 4;
+var SOUTH = 8;
+var DIR_CHARS = {
+  [EAST | WEST]: "\u2500",
+  [NORTH | SOUTH]: "\u2502",
+  [EAST | SOUTH]: "\u250C",
+  [WEST | SOUTH]: "\u2510",
+  [EAST | NORTH]: "\u2514",
+  [WEST | NORTH]: "\u2518",
+  [EAST | WEST | SOUTH]: "\u252C",
+  [EAST | WEST | NORTH]: "\u2534",
+  [NORTH | SOUTH | EAST]: "\u251C",
+  [NORTH | SOUTH | WEST]: "\u2524",
+  [EAST | WEST | NORTH | SOUTH]: "\u253C",
+  [EAST]: "\u2576",
+  [WEST]: "\u2574",
+  [NORTH]: "\u2575",
+  [SOUTH]: "\u2577"
+};
+function renderCircuitBackground(ctx, width, height, time, options = {}) {
+  const {
+    fontSize = 13,
+    pulseColor = "#ffffff",
+    color = "#00ff88",
+    density = 0.38,
+    speed = 1,
+    lightMode = false
+  } = options;
+  const charW = fontSize * 0.62;
+  const lineH = fontSize * 1.4;
+  const cols = Math.ceil(width / charW);
+  const rows = Math.ceil(height / lineH);
+  const cp = parseColor(color) ?? { r: 0, g: 255, b: 136 };
+  const pp = parseColor(pulseColor) ?? { r: 255, g: 255, b: 255 };
+  const getConnections = (c, r) => {
+    if (hash2(c * 17 + 1, r * 7 + 2) > density) return 0;
+    let mask = 0;
+    if (c + 1 < cols && hash2(c * 17 + 1, r * 7 + 2) > 0.15) mask |= EAST;
+    if (c - 1 >= 0 && hash2((c - 1) * 17 + 1, r * 7 + 2) > 0.15) mask |= WEST;
+    if (r + 1 < rows && hash2(c * 17 + 1, (r + 1) * 7 + 2) > 0.15) mask |= SOUTH;
+    if (r - 1 >= 0 && hash2(c * 17 + 1, (r - 1) * 7 + 2) > 0.15) mask |= NORTH;
+    return mask;
+  };
+  ctx.clearRect(0, 0, width, height);
+  ctx.font = `${fontSize}px "JetBrains Mono", monospace`;
+  ctx.textBaseline = "top";
+  const t = time * speed;
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < cols; c++) {
+      const mask = getConnections(c, r);
+      if (mask === 0) continue;
+      const ch = DIR_CHARS[mask] ?? "\xB7";
+      const pulsePosH = (t * 8 + hash2(c, r * 23) * 40) % cols;
+      const pulsePosV = (t * 6 + hash2(r * 17, c * 11) * 40) % rows;
+      const nearH = (mask & EAST || mask & WEST) && Math.abs(c - pulsePosH) < 1.5;
+      const nearV = (mask & NORTH || mask & SOUTH) && Math.abs(r - pulsePosV) < 1.5;
+      const isPulse = nearH || nearV;
+      const baseAlpha = 0.25 + hash2(c * 3, r * 5) * 0.35;
+      if (isPulse) {
+        ctx.globalAlpha = 0.95;
+        ctx.fillStyle = `rgb(${pp.r},${pp.g},${pp.b})`;
+      } else {
+        ctx.globalAlpha = baseAlpha;
+        ctx.fillStyle = `rgb(${cp.r},${cp.g},${cp.b})`;
+      }
+      ctx.fillText(ch, c * charW, r * lineH);
+    }
+  }
+  ctx.globalAlpha = 1;
+}
+
 // src/backgrounds/index.ts
 function _parseColor(c) {
   const hex = c.match(/^#([0-9a-f]{3,8})$/i)?.[1];
@@ -1778,6 +2174,24 @@ function asciiBackground(target, options = {}) {
     lightMode: renderOpts.lightMode !== void 0 ? renderOpts.lightMode : isLight(),
     color: color ?? renderOpts.color
   });
+  const buildFireOpts = () => ({
+    ...renderOpts,
+    color: color ?? renderOpts.color
+  });
+  const buildDnaOpts = () => ({
+    ...renderOpts,
+    color: color ?? renderOpts.color
+  });
+  const buildTerrainOpts = () => ({
+    ...renderOpts,
+    color: color ?? renderOpts.color,
+    lightMode: renderOpts.lightMode !== void 0 ? renderOpts.lightMode : isLight()
+  });
+  const buildCircuitOpts = () => ({
+    ...renderOpts,
+    color: color ?? renderOpts.color,
+    lightMode: renderOpts.lightMode !== void 0 ? renderOpts.lightMode : isLight()
+  });
   const optsRef = { current: buildWaveOpts() };
   const rebuildOpts = () => {
     if (type === "rain") optsRef.current = buildRainOpts();
@@ -1789,6 +2203,10 @@ function asciiBackground(target, options = {}) {
     else if (type === "silk") optsRef.current = buildSilkOpts();
     else if (type === "void") optsRef.current = buildVoidOpts();
     else if (type === "morph") optsRef.current = buildMorphOpts();
+    else if (type === "fire") optsRef.current = buildFireOpts();
+    else if (type === "dna") optsRef.current = buildDnaOpts();
+    else if (type === "terrain") optsRef.current = buildTerrainOpts();
+    else if (type === "circuit") optsRef.current = buildCircuitOpts();
     else optsRef.current = buildWaveOpts();
   };
   rebuildOpts();
@@ -1835,6 +2253,14 @@ function asciiBackground(target, options = {}) {
       renderVoidBackground(ctx, r.width, r.height, time, smoothMouse, optsRef.current);
     } else if (type === "morph") {
       renderMorphBackground(ctx, r.width, r.height, time, optsRef.current);
+    } else if (type === "fire") {
+      renderFireBackground(ctx, r.width, r.height, time, optsRef.current);
+    } else if (type === "dna") {
+      renderDnaBackground(ctx, r.width, r.height, time, optsRef.current);
+    } else if (type === "terrain") {
+      renderTerrainBackground(ctx, r.width, r.height, time, optsRef.current);
+    } else if (type === "circuit") {
+      renderCircuitBackground(ctx, r.width, r.height, time, optsRef.current);
     } else {
       renderWaveBackground(ctx, r.width, r.height, time, smoothMouse, optsRef.current);
     }
@@ -1855,6 +2281,178 @@ function asciiBackground(target, options = {}) {
 }
 var mountWaveBackground = asciiBackground;
 
+// src/core/ascii-text.ts
+function asciiText(source, options = {}, targetWidth, targetHeight) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const { frame, cols } = imageToAsciiFrame(source, opts, targetWidth, targetHeight);
+  if (!frame.length || cols === 0) return "";
+  const lines = [];
+  for (const row of frame) {
+    lines.push(row.map((cell) => cell.char).join(""));
+  }
+  return lines.join("\n");
+}
+function asciiTextAnsi(source, options = {}, targetWidth, targetHeight) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const { frame, cols } = imageToAsciiFrame(source, opts, targetWidth, targetHeight);
+  if (!frame.length || cols === 0) return "";
+  const RESET = "\x1B[0m";
+  const lines = [];
+  for (const row of frame) {
+    let line = "";
+    for (const cell of row) {
+      if (cell.char === " " || cell.a < 10) {
+        line += " ";
+      } else {
+        line += `\x1B[38;2;${cell.r};${cell.g};${cell.b}m${cell.char}${RESET}`;
+      }
+    }
+    lines.push(line);
+  }
+  return lines.join("\n");
+}
+
+// src/core/record.ts
+function createRecorder(canvas, options = {}) {
+  const {
+    fps = 15,
+    maxFrames = 120,
+    format = "gif",
+    quality = 10,
+    scale = 1
+  } = options;
+  const interval = 1e3 / fps;
+  let recording = false;
+  let timerId = -1;
+  const blobs = [];
+  const captureFrame = () => {
+    if (!recording || blobs.length >= maxFrames) return;
+    let src = canvas;
+    if (scale !== 1) {
+      const off = document.createElement("canvas");
+      off.width = Math.round(canvas.width * scale);
+      off.height = Math.round(canvas.height * scale);
+      const offCtx = off.getContext("2d");
+      offCtx.drawImage(canvas, 0, 0, off.width, off.height);
+      src = off;
+    }
+    blobs.push(src.toDataURL("image/png"));
+  };
+  const encodeGif = async (frames) => {
+    return new Promise((resolve, reject) => {
+      if (typeof GIF === "undefined") {
+        reject(new Error('[asciify recorder] gif.js not found. Add <script src="/gif.worker.js"> to your page.'));
+        return;
+      }
+      const gif = new GIF({
+        workers: 2,
+        quality,
+        workerScript: "/gif.worker.js"
+      });
+      let loaded = 0;
+      const total = frames.length;
+      frames.forEach((dataUrl) => {
+        const img = new Image();
+        img.onload = () => {
+          gif.addFrame(img, { delay: interval, copy: true });
+          loaded++;
+          if (loaded === total) gif.render();
+        };
+        img.src = dataUrl;
+      });
+      gif.on("finished", (blob) => {
+        const reader = new FileReader();
+        reader.onload = () => resolve(reader.result);
+        reader.readAsDataURL(blob);
+      });
+      gif.on("error", reject);
+    });
+  };
+  const encodeWebP = async (frames, _fps) => {
+    if (typeof MediaRecorder === "undefined") {
+      throw new Error("[asciify recorder] MediaRecorder not available in this browser.");
+    }
+    const off = document.createElement("canvas");
+    if (frames.length === 0) return "";
+    const probe = new Image();
+    await new Promise((res) => {
+      probe.onload = () => res();
+      probe.src = frames[0];
+    });
+    off.width = probe.naturalWidth;
+    off.height = probe.naturalHeight;
+    const offCtx = off.getContext("2d");
+    const stream = off.captureStream(_fps);
+    const recorder = new MediaRecorder(stream, { mimeType: "video/webm;codecs=vp9" });
+    const chunks = [];
+    recorder.ondataavailable = (e) => chunks.push(e.data);
+    return new Promise((resolve, reject) => {
+      recorder.onstop = () => {
+        const blob = new Blob(chunks, { type: "video/webm" });
+        const reader = new FileReader();
+        reader.onload = () => resolve(reader.result);
+        reader.readAsDataURL(blob);
+      };
+      recorder.onerror = reject;
+      recorder.start();
+      let idx = 0;
+      const drawNext = () => {
+        if (idx >= frames.length) {
+          recorder.stop();
+          return;
+        }
+        const img = new Image();
+        img.onload = () => {
+          offCtx.drawImage(img, 0, 0);
+          idx++;
+          setTimeout(drawNext, interval);
+        };
+        img.src = frames[idx];
+      };
+      drawNext();
+    });
+  };
+  return {
+    get isRecording() {
+      return recording;
+    },
+    get frameCount() {
+      return blobs.length;
+    },
+    start() {
+      if (recording) return;
+      blobs.length = 0;
+      recording = true;
+      timerId = window.setInterval(captureFrame, interval);
+    },
+    async stop() {
+      if (!recording) return "";
+      recording = false;
+      clearInterval(timerId);
+      const frames = blobs.slice();
+      if (format === "png-sequence") {
+        return JSON.stringify(frames);
+      }
+      if (format === "webp") {
+        return encodeWebP(frames, fps);
+      }
+      return encodeGif(frames);
+    }
+  };
+}
+async function recordAndDownload(canvas, durationMs, options = {}) {
+  const { filename = "asciify-recording", ...recOpts } = options;
+  const recorder = createRecorder(canvas, recOpts);
+  recorder.start();
+  await new Promise((res) => setTimeout(res, durationMs));
+  const dataUrl = await recorder.stop();
+  const ext = options.format === "webp" ? "webm" : options.format === "png-sequence" ? "json" : "gif";
+  const a = document.createElement("a");
+  a.href = dataUrl;
+  a.download = `${filename}.${ext}`;
+  a.click();
+}
+
 // src/webgl-engine.ts
 var VERT_SRC = (
   /* glsl */
@@ -2117,8 +2715,8 @@ function makeTexture(gl, filter = gl.NEAREST) {
   gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
   return t;
 }
-var ANIM_STYLES = ["none", "wave", "pulse", "rain", "breathe", "sparkle", "glitch", "spiral", "typewriter", "scatter", "waveField"];
-var HOVER_EFFECTS = ["spotlight", "magnify", "repel", "glow", "colorShift"];
+var ANIM_STYLES = ["none", "wave", "pulse", "rain", "breathe", "sparkle", "glitch", "spiral", "typewriter", "scatter", "waveField", "ripple", "melt", "orbit", "cellular"];
+var HOVER_EFFECTS = ["spotlight", "magnify", "repel", "glow", "colorShift", "attract", "shatter", "trail"];
 var COLOR_MODES = ["grayscale", "fullcolor", "matrix", "accent"];
 function tryCreateWebGLRenderer(canvas) {
   const glOrNull = canvas.getContext("webgl2", {
@@ -2303,6 +2901,6 @@ function tryCreateWebGLRenderer(canvas) {
   }
 }
 
-export { ART_STYLE_PRESETS, CHARSETS, DEFAULT_OPTIONS, HOVER_PRESETS, asciiBackground, asciify, asciifyGif, asciifyVideo, generateAnimatedEmbedCode, generateEmbedCode, gifToAsciiFrames, imageToAsciiFrame, mountWaveBackground, renderAuroraBackground, renderFrameToCanvas, renderGridBackground, renderMorphBackground, renderNoiseBackground, renderPulseBackground, renderRainBackground, renderSilkBackground, renderStarsBackground, renderVoidBackground, renderWaveBackground, tryCreateWebGLRenderer, videoToAsciiFrames };
+export { ART_STYLE_PRESETS, CHARSETS, DEFAULT_OPTIONS, HOVER_PRESETS, PALETTE_THEMES, asciiBackground, asciiText, asciiTextAnsi, asciify, asciifyGif, asciifyVideo, createRecorder, generateAnimatedEmbedCode, generateEmbedCode, gifToAsciiFrames, imageToAsciiFrame, mountWaveBackground, recordAndDownload, renderAuroraBackground, renderCircuitBackground, renderDnaBackground, renderFireBackground, renderFrameToCanvas, renderGridBackground, renderMorphBackground, renderNoiseBackground, renderPulseBackground, renderRainBackground, renderSilkBackground, renderStarsBackground, renderTerrainBackground, renderVoidBackground, renderWaveBackground, tryCreateWebGLRenderer, videoToAsciiFrames };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map