{
  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
  "name": "ripple-pond",
  "type": "registry:component",
  "title": "Ripple Pond",
  "description": "A WebGL water surface: the cursor and raindrops leave ripples that cross, catch the light and warp a grid beneath.",
  "author": "Marcelo Treviño Velázquez <https://furin.dev>",
  "dependencies": [],
  "categories": [
    "Backgrounds"
  ],
  "docs": "Installed in components/furin/ripple-pond/. Docs, live controls and props table: https://furin.dev/components/ripple-pond/",
  "files": [
    {
      "path": "registry/ripple-pond/RipplePond.tsx",
      "content": "\"use client\";\nimport { useEffect, useRef, useState } from \"react\";\nimport type { CSSProperties, ReactNode } from \"react\";\nimport \"./RipplePond.css\";\n\nexport interface RipplePondProps {\n  /** Color del agua (cualquier color CSS, sin variables). */\n  color?: string;\n  /** Color de la luz que se refleja en las ondas. */\n  lightColor?: string;\n  /** Viscosidad: 0 es agua que no deja de ondular, 1 es aceite que apaga las ondas enseguida. */\n  viscosity?: number;\n  /** Gotas que caen solas por segundo; 0 deja el agua quieta hasta que la toques. */\n  dropRate?: number;\n  /** Fuerza de las ondas que deja el cursor; 0 las apaga. */\n  cursorForce?: number;\n  /** Si es true, una cuadrícula bajo el agua se deforma con las ondas (refracción). */\n  grid?: boolean;\n  /** Separación de la cuadrícula en px. */\n  gridSize?: number;\n  /** Clase extra para el contenedor. */\n  className?: string;\n  /** Estilos extra para el contenedor. */\n  style?: CSSProperties;\n  /** Contenido que se dibuja encima del agua, centrado. */\n  children?: ReactNode;\n}\n\ntype Rgb = [number, number, number];\n\n/** Valores que el bucle lee en cada cuadro (así cambiar una prop no reinicia WebGL). */\ninterface LiveValues {\n  water: Rgb;\n  light: Rgb;\n  /** Cuánto de la onda sobrevive en cada paso de la simulación (0 a 1). */\n  damping: number;\n  dropRate: number;\n  cursorForce: number;\n  /** Separación de la cuadrícula en px; 0 si está apagada. */\n  gridSize: number;\n}\n\nconst MAX_DPR = 1.5;\n/** Tamaño de cada celda de la simulación en px: más grande es más barato, más chico es más fino. */\nconst CELL_SIZE = 2.6;\nconst MAX_SIMULATION_SIDE = 520;\n/** Pasos de simulación por segundo, iguales en cualquier pantalla. */\nconst STEPS_PER_SECOND = 80;\n/** Cuántas gotas caben en un solo paso de la simulación. */\nconst MAX_DROPS = 8;\nconst MAX_QUEUED_DROPS = 48;\n\n// ───────────────────────── Shaders ─────────────────────────\n\nconst VERTEX_SHADER = `\nattribute vec2 aPos;\nvarying vec2 vUv;\nvoid main() {\n  vUv = aPos * 0.5 + 0.5;\n  gl_Position = vec4(aPos, 0.0, 1.0);\n}`;\n\nconst PRECISION = `\n#ifdef GL_FRAGMENT_PRECISION_HIGH\nprecision highp float;\n#else\nprecision mediump float;\n#endif\n`;\n\n/**\n * Un paso de la simulación. La textura guarda por cada punto del agua:\n * r = altura, g = velocidad vertical, b y a = inclinación de la superficie (para el sombreado).\n */\nconst UPDATE_SHADER = `${PRECISION}\n#define MAX_DROPS ${MAX_DROPS}\nuniform sampler2D uState;\nuniform vec2 uTexel;\nuniform float uDamping;\nuniform vec4 uDrops[MAX_DROPS]; // x, y (0 a 1), radio en celdas, fuerza\nvarying vec2 vUv;\n\nvoid main() {\n  vec4 here = texture2D(uState, vUv);\n  float left = texture2D(uState, vUv - vec2(uTexel.x, 0.0)).r;\n  float right = texture2D(uState, vUv + vec2(uTexel.x, 0.0)).r;\n  float down = texture2D(uState, vUv - vec2(0.0, uTexel.y)).r;\n  float up = texture2D(uState, vUv + vec2(0.0, uTexel.y)).r;\n\n  // Ecuación de onda: el punto se acelera hacia el promedio de sus vecinos.\n  float average = (left + right + up + down) * 0.25;\n  float velocity = here.g + (average - here.r) * 1.8;\n\n  // En los bordes el agua amortigua más: así las ondas no rebotan contra el marco.\n  float edge = min(min(vUv.x, 1.0 - vUv.x), min(vUv.y, 1.0 - vUv.y));\n  velocity *= uDamping * mix(0.9, 1.0, smoothstep(0.0, 0.04, edge));\n  // Un poco de difusión apaga las ondas más finas, que en una rejilla tan gruesa solo se verían como ruido.\n  float height = mix(here.r + velocity, average, 0.04);\n\n  // Gotas y toques del cursor: una joroba suave (coseno) alrededor de su centro.\n  for (int i = 0; i < MAX_DROPS; i++) {\n    vec4 drop = uDrops[i];\n    if (drop.w != 0.0) {\n      float cells = length((vUv - drop.xy) / uTexel);\n      float falloff = max(0.0, 1.0 - cells / drop.z);\n      height += drop.w * (0.5 - 0.5 * cos(falloff * 3.14159265));\n    }\n  }\n\n  gl_FragColor = vec4(height, velocity, (right - left) * 0.5, (up - down) * 0.5);\n}`;\n\nconst DISPLAY_SHADER = `${PRECISION}\nuniform sampler2D uState;\nuniform vec2 uSimSize;\nuniform vec3 uWater;\nuniform vec3 uLight;\nuniform float uGridCell;   // separación de la cuadrícula en píxeles del canvas; 0 = sin cuadrícula\nuniform float uPixelRatio;\nvarying vec2 vUv;\n\n// La simulación es de baja resolución: se interpola a mano (las texturas float no siempre filtran).\nvec4 stateAt(vec2 uv) {\n  vec2 point = uv * uSimSize - 0.5;\n  vec2 mixAmount = fract(point);\n  vec2 base = (floor(point) + 0.5) / uSimSize;\n  vec2 dx = vec2(1.0 / uSimSize.x, 0.0);\n  vec2 dy = vec2(0.0, 1.0 / uSimSize.y);\n  return mix(\n    mix(texture2D(uState, base), texture2D(uState, base + dx), mixAmount.x),\n    mix(texture2D(uState, base + dy), texture2D(uState, base + dx + dy), mixAmount.x),\n    mixAmount.y\n  );\n}\n\nvoid main() {\n  vec2 uv = vUv;\n  vec2 slope = stateAt(uv).zw * 4.5;\n  vec3 normal = normalize(vec3(-slope, 1.0));\n\n  // Agua: algo más clara arriba (cielo) que abajo (fondo).\n  vec3 color = uWater * mix(0.62, 1.14, uv.y);\n\n  // Luz desde arriba a la izquierda: las pendientes que miran a ella se aclaran y las otras se oscurecen.\n  vec3 lightDirection = normalize(vec3(-0.45, 0.6, 0.66));\n  color *= 1.0 + (dot(normal, lightDirection) - lightDirection.z) * 3.6;\n\n  // Reflejo especular (destellos en las crestas) y un brillo suave en las pendientes fuertes.\n  vec3 halfway = normalize(lightDirection + vec3(0.0, 0.0, 1.0));\n  float glint = pow(max(dot(normal, halfway), 0.0), 70.0);\n  color += uLight * glint * 1.5;\n  color += uLight * (1.0 - normal.z) * 1.4;\n\n  // Cuadrícula en el fondo: se ve a través del agua, así que las ondas la desplazan (refracción).\n  if (uGridCell > 0.0) {\n    vec2 seen = gl_FragCoord.xy + slope * 90.0 * uPixelRatio;\n    vec2 distanceToLine = abs(fract(seen / uGridCell - 0.5) - 0.5) * uGridCell;\n    float width = 1.1 * uPixelRatio;\n    float line = 1.0 - smoothstep(width - 0.7, width + 0.7, min(distanceToLine.x, distanceToLine.y));\n    color = mix(color, mix(uLight, uWater, 0.35), line * 0.3);\n  }\n\n  // Viñeta suave y un ruido mínimo para que los degradados no se vean en escalones.\n  vec2 centered = uv - 0.5;\n  color *= 1.0 - 0.38 * dot(centered, centered);\n  float dither = fract(sin(dot(gl_FragCoord.xy, vec2(12.9898, 78.233))) * 43758.5453);\n  color += (dither - 0.5) / 255.0;\n\n  gl_FragColor = vec4(color, 1.0);\n}`;\n\n// ───────────────────────── Color ─────────────────────────\n\nlet colorContext: CanvasRenderingContext2D | null = null;\n\n/** Convierte cualquier color CSS a [r, g, b] entre 0 y 1 (el navegador hace el trabajo). */\nfunction toRgb(color: string): Rgb {\n  colorContext ??= document.createElement(\"canvas\").getContext(\"2d\");\n  if (!colorContext) return [0, 0, 0];\n  colorContext.fillStyle = \"#000000\";\n  colorContext.fillStyle = color; // si el color no es válido se queda en negro\n  const normalized = colorContext.fillStyle; // \"#rrggbb\" o \"rgba(r, g, b, a)\"\n  if (normalized.startsWith(\"#\")) {\n    const n = parseInt(normalized.slice(1), 16);\n    return [(n >> 16) / 255, ((n >> 8) & 255) / 255, (n & 255) / 255];\n  }\n  const [r, g, b] = normalized.match(/[\\d.]+/g)!.map(Number);\n  return [r / 255, g / 255, b / 255];\n}\n\nconst clamp = (value: number, min: number, max: number) => Math.min(max, Math.max(min, value));\nconst random = (min: number, max: number) => min + Math.random() * (max - min);\n\n/** Viscosidad (0 a 1) → fracción de la onda que sobrevive a cada paso. */\nconst dampingFor = (viscosity: number) => 1 - (0.0006 + clamp(viscosity, 0, 1) * 0.02);\n\n// ───────────────────────── WebGL ─────────────────────────\n\ninterface Program {\n  handle: WebGLProgram;\n  uniforms: Record<string, WebGLUniformLocation | null>;\n}\n\ninterface Target {\n  texture: WebGLTexture;\n  framebuffer: WebGLFramebuffer;\n}\n\ninterface Renderer {\n  /** Tamaño del canvas (px del dispositivo), razón de píxeles y tamaño de la simulación (celdas). */\n  resize(width: number, height: number, pixelRatio: number, simWidth: number, simHeight: number): void;\n  /** Un paso de la simulación con hasta MAX_DROPS gotas [x, y, radio, fuerza, …]. */\n  step(drops: number[], damping: number): void;\n  draw(values: LiveValues): void;\n  dispose(): void;\n}\n\nfunction compile(gl: WebGLRenderingContext, type: number, source: string): WebGLShader | null {\n  const shader = gl.createShader(type);\n  if (!shader) return null;\n  gl.shaderSource(shader, source);\n  gl.compileShader(shader);\n  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {\n    gl.deleteShader(shader);\n    return null;\n  }\n  return shader;\n}\n\nfunction link(gl: WebGLRenderingContext, fragmentSource: string, uniformNames: string[]): Program | null {\n  const vertex = compile(gl, gl.VERTEX_SHADER, VERTEX_SHADER);\n  const fragment = compile(gl, gl.FRAGMENT_SHADER, fragmentSource);\n  const handle = gl.createProgram();\n  if (!vertex || !fragment || !handle) return null;\n  gl.attachShader(handle, vertex);\n  gl.attachShader(handle, fragment);\n  gl.bindAttribLocation(handle, 0, \"aPos\"); // los dos programas usan el mismo triángulo\n  gl.linkProgram(handle);\n  gl.deleteShader(vertex);\n  gl.deleteShader(fragment);\n  if (!gl.getProgramParameter(handle, gl.LINK_STATUS)) return null;\n  const uniforms = Object.fromEntries(uniformNames.map((name) => [name, gl.getUniformLocation(handle, name)]));\n  return { handle, uniforms };\n}\n\n/** Prepara una textura donde dibujar con tamaño y tipo dados; devuelve null si el navegador no puede dibujar en ella. */\nfunction createTarget(gl: WebGLRenderingContext, width: number, height: number, type: number): Target | null {\n  const texture = gl.createTexture();\n  const framebuffer = gl.createFramebuffer();\n  if (!texture || !framebuffer) return null;\n  gl.bindTexture(gl.TEXTURE_2D, texture);\n  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);\n  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);\n  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);\n  gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, type, null);\n  gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);\n  gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);\n  if (gl.checkFramebufferStatus(gl.FRAMEBUFFER) !== gl.FRAMEBUFFER_COMPLETE) {\n    gl.deleteTexture(texture);\n    gl.deleteFramebuffer(framebuffer);\n    return null;\n  }\n  gl.clearColor(0, 0, 0, 0);\n  gl.clear(gl.COLOR_BUFFER_BIT);\n  return { texture, framebuffer };\n}\n\nfunction deleteTarget(gl: WebGLRenderingContext, target: Target) {\n  gl.deleteTexture(target.texture);\n  gl.deleteFramebuffer(target.framebuffer);\n}\n\n/** Busca un formato con decimales donde se pueda dibujar: half float (el que más aceptan los celulares) o float. */\nfunction findTextureType(gl: WebGLRenderingContext): number | null {\n  const half = gl.getExtension(\"OES_texture_half_float\");\n  gl.getExtension(\"EXT_color_buffer_half_float\");\n  const full = gl.getExtension(\"OES_texture_float\");\n  gl.getExtension(\"WEBGL_color_buffer_float\");\n  const candidates = [half ? half.HALF_FLOAT_OES : null, full ? gl.FLOAT : null];\n  for (const type of candidates) {\n    if (type === null) continue;\n    const test = createTarget(gl, 4, 4, type);\n    if (test) {\n      deleteTarget(gl, test);\n      return type;\n    }\n  }\n  return null;\n}\n\n/** Crea el contexto, los dos programas y las dos texturas de la simulación. Devuelve null si no hay WebGL suficiente. */\nfunction createRenderer(canvas: HTMLCanvasElement): Renderer | null {\n  const options: WebGLContextAttributes = { alpha: false, antialias: false, depth: false, stencil: false };\n  const gl = (canvas.getContext(\"webgl\", options) ?? canvas.getContext(\"experimental-webgl\", options)) as WebGLRenderingContext | null;\n  if (!gl) return null;\n  const textureType = findTextureType(gl);\n  if (textureType === null) return null;\n\n  let update: Program | null = null;\n  let display: Program | null = null;\n  let buffer: WebGLBuffer | null = null;\n  // Las dos texturas de la simulación: en cada paso se lee de una y se escribe en la otra (ping-pong).\n  let targets: Target[] = [];\n  let current = 0;\n  let size = { width: 0, height: 0, pixelRatio: 1, simWidth: 0, simHeight: 0 };\n  const dropData = new Float32Array(MAX_DROPS * 4);\n\n  const allocate = () => {\n    targets.forEach((target) => deleteTarget(gl, target));\n    const a = createTarget(gl, size.simWidth, size.simHeight, textureType);\n    const b = createTarget(gl, size.simWidth, size.simHeight, textureType);\n    targets = a && b ? [a, b] : [];\n    current = 0;\n  };\n\n  /** Compila los shaders y sube un triángulo que cubre toda la pantalla. */\n  const build = (): boolean => {\n    update = link(gl, UPDATE_SHADER, [\"uState\", \"uTexel\", \"uDamping\", \"uDrops[0]\"]);\n    display = link(gl, DISPLAY_SHADER, [\"uState\", \"uSimSize\", \"uWater\", \"uLight\", \"uGridCell\", \"uPixelRatio\"]);\n    if (!update || !display) return false;\n    buffer = gl.createBuffer();\n    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);\n    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1, -1, 3, -1, -1, 3]), gl.STATIC_DRAW);\n    gl.enableVertexAttribArray(0);\n    gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);\n    return true;\n  };\n\n  let ready = build();\n  if (!ready) return null;\n\n  // Si el navegador pierde el contexto (p. ej. demasiados WebGL abiertos) se reconstruye todo al volver.\n  const onLost = (event: Event) => {\n    event.preventDefault();\n    ready = false;\n  };\n  const onRestored = () => {\n    ready = build();\n    allocate();\n  };\n  canvas.addEventListener(\"webglcontextlost\", onLost);\n  canvas.addEventListener(\"webglcontextrestored\", onRestored);\n\n  return {\n    resize(width, height, pixelRatio, simWidth, simHeight) {\n      canvas.width = width;\n      canvas.height = height;\n      const simChanged = simWidth !== size.simWidth || simHeight !== size.simHeight;\n      size = { width, height, pixelRatio, simWidth, simHeight };\n      if (simChanged || targets.length === 0) allocate();\n    },\n    step(drops, damping) {\n      if (!ready || gl.isContextLost() || !update || targets.length === 0) return;\n      dropData.fill(0);\n      for (let i = 0; i < Math.min(drops.length, MAX_DROPS * 4); i++) dropData[i] = drops[i];\n\n      gl.bindFramebuffer(gl.FRAMEBUFFER, targets[1 - current].framebuffer);\n      gl.viewport(0, 0, size.simWidth, size.simHeight);\n      gl.useProgram(update.handle);\n      gl.activeTexture(gl.TEXTURE0);\n      gl.bindTexture(gl.TEXTURE_2D, targets[current].texture);\n      gl.uniform1i(update.uniforms.uState, 0);\n      gl.uniform2f(update.uniforms.uTexel, 1 / size.simWidth, 1 / size.simHeight);\n      gl.uniform1f(update.uniforms.uDamping, damping);\n      gl.uniform4fv(update.uniforms[\"uDrops[0]\"], dropData);\n      gl.drawArrays(gl.TRIANGLES, 0, 3);\n      current = 1 - current;\n    },\n    draw(values) {\n      if (!ready || gl.isContextLost() || !display || targets.length === 0) return;\n      gl.bindFramebuffer(gl.FRAMEBUFFER, null);\n      gl.viewport(0, 0, size.width, size.height);\n      gl.useProgram(display.handle);\n      gl.activeTexture(gl.TEXTURE0);\n      gl.bindTexture(gl.TEXTURE_2D, targets[current].texture);\n      gl.uniform1i(display.uniforms.uState, 0);\n      gl.uniform2f(display.uniforms.uSimSize, size.simWidth, size.simHeight);\n      gl.uniform3fv(display.uniforms.uWater, values.water);\n      gl.uniform3fv(display.uniforms.uLight, values.light);\n      gl.uniform1f(display.uniforms.uGridCell, values.gridSize * size.pixelRatio);\n      gl.uniform1f(display.uniforms.uPixelRatio, size.pixelRatio);\n      gl.drawArrays(gl.TRIANGLES, 0, 3);\n    },\n    dispose() {\n      canvas.removeEventListener(\"webglcontextlost\", onLost);\n      canvas.removeEventListener(\"webglcontextrestored\", onRestored);\n      targets.forEach((target) => deleteTarget(gl, target));\n      if (update) gl.deleteProgram(update.handle);\n      if (display) gl.deleteProgram(display.handle);\n      if (buffer) gl.deleteBuffer(buffer);\n      // Libera la memoria de la GPU de inmediato en lugar de esperar al recolector de basura.\n      gl.getExtension(\"WEBGL_lose_context\")?.loseContext();\n    },\n  };\n}\n\n// ───────────────────────── Componente ─────────────────────────\n\n/** Superficie de agua con ondas (WebGL): el cursor y las gotas la agitan y la luz se refleja en las crestas. Llena a su padre. */\nexport function RipplePond({\n  color = \"#1B2A8C\",\n  lightColor = \"#C9DAFF\",\n  viscosity = 0.3,\n  dropRate = 0.8,\n  cursorForce = 1,\n  grid = true,\n  gridSize = 44,\n  className = \"\",\n  style,\n  children,\n}: RipplePondProps) {\n  const rootRef = useRef<HTMLDivElement>(null);\n  const hostRef = useRef<HTMLDivElement>(null);\n  // \"pending\": aún no se sabe si hay WebGL (el servidor y el primer render pintan el agua quieta).\n  const [mode, setMode] = useState<\"pending\" | \"webgl\" | \"static\">(\"pending\");\n  const live = useRef<LiveValues>({ water: [0, 0, 0], light: [1, 1, 1], damping: dampingFor(viscosity), dropRate, cursorForce, gridSize: grid ? gridSize : 0 });\n  const refresh = useRef<() => void>(() => {});\n\n  // Pasa las props actuales al bucle de dibujo.\n  useEffect(() => {\n    live.current = {\n      water: toRgb(color),\n      light: toRgb(lightColor),\n      damping: dampingFor(viscosity),\n      dropRate,\n      cursorForce,\n      gridSize: grid ? gridSize : 0,\n    };\n    refresh.current();\n  }, [color, lightColor, viscosity, dropRate, cursorForce, grid, gridSize]);\n\n  useEffect(() => {\n    const root = rootRef.current;\n    const host = hostRef.current;\n    if (!root || !host) return;\n\n    // El canvas se crea aquí (no en el JSX) para que un nuevo montaje siempre estrene su propio contexto.\n    const canvas = document.createElement(\"canvas\");\n    canvas.className = \"furin-ripple-pond__canvas\";\n    const renderer = createRenderer(canvas);\n    if (!renderer) {\n      setMode(\"static\");\n      return;\n    }\n    host.appendChild(canvas);\n    setMode(\"webgl\");\n\n    // Los eventos se escuchan en el padre: así reacciona aunque haya contenido encima.\n    const listener = root.parentElement ?? root;\n    const reducedMotion = window.matchMedia(\"(prefers-reduced-motion: reduce)\");\n\n    const step = 1 / STEPS_PER_SECOND;\n    let clock = 0;\n    let accumulator = 0;\n    let lastNow = 0;\n    let frameId = 0;\n    let sleepTimer = 0;\n    let visible = true;\n    /** Segundos que faltan para la próxima gota automática. */\n    let nextDrop = 0.4;\n    /** Momento (en `clock`) a partir del cual las ondas ya se apagaron y el bucle puede dormir. */\n    let calmAt = 0;\n    let simWidth = 1;\n    let simHeight = 1;\n\n    // Gotas en espera, en la forma que pide el shader: x, y, radio, fuerza.\n    const queue: number[] = [];\n    const pointer = { x: 0, y: 0, time: 0, active: false };\n\n    /** Segundos que tarda una onda en volverse invisible con la viscosidad actual. */\n    const calmTime = () => Math.log(0.01) / Math.log(live.current.damping) / STEPS_PER_SECOND;\n\n    const addDrop = (x: number, y: number, radius: number, strength: number) => {\n      if (queue.length >= MAX_QUEUED_DROPS * 4) queue.splice(0, 4);\n      queue.push(x, y, radius, strength);\n      calmAt = clock + calmTime();\n    };\n\n    const addRandomDrop = () => {\n      // Gotas de distinto tamaño: las grandes hacen ondas anchas y lentas; las chicas, finas.\n      addDrop(random(0.1, 0.9), random(0.12, 0.88), random(4, 8), random(0.5, 0.9) * (Math.random() < 0.25 ? 1.4 : 1));\n    };\n\n    const draw = () => renderer.draw(live.current);\n\n    const resize = () => {\n      const dpr = Math.min(window.devicePixelRatio || 1, MAX_DPR);\n      const cssWidth = Math.max(1, root.clientWidth);\n      const cssHeight = Math.max(1, root.clientHeight);\n      // La simulación usa celdas de ~2.6 px, con tope para que un escenario enorme no la encarezca.\n      const cell = Math.max(CELL_SIZE, Math.max(cssWidth, cssHeight) / MAX_SIMULATION_SIDE);\n      simWidth = Math.max(16, Math.round(cssWidth / cell));\n      simHeight = Math.max(16, Math.round(cssHeight / cell));\n      renderer.resize(Math.round(cssWidth * dpr), Math.round(cssHeight * dpr), dpr, simWidth, simHeight);\n      if (reducedMotion.matches) drawStill();\n      else draw();\n    };\n\n    /** Con movimiento reducido: un cuadro quieto con tres gotas a medio camino, siempre las mismas. */\n    const drawStill = () => {\n      const drops = [\n        [0.3, 0.56, 8, -0.9],\n        [0.68, 0.4, 7, -0.8],\n        [0.5, 0.78, 5, -0.6],\n      ];\n      for (let i = 0; i < 70; i++) {\n        const now = i === 0 ? drops.flat() : i === 24 ? [0.2, 0.3, 5, -0.6] : [];\n        renderer.step(now, dampingFor(0.25));\n      }\n      draw();\n    };\n\n    // ───────────────────────── Bucle ─────────────────────────\n\n    const frame = (now: number) => {\n      frameId = requestAnimationFrame(frame);\n      // El primer cuadro puede traer una marca de tiempo anterior a la de arranque: el tiempo nunca retrocede.\n      const dt = clamp((now - lastNow) / 1000, 0, 0.1);\n      lastNow = now;\n      clock += dt;\n      accumulator += dt;\n\n      const { dropRate } = live.current;\n      if (dropRate > 0) {\n        nextDrop -= dt;\n        if (nextDrop <= 0) {\n          addRandomDrop();\n          nextDrop = random(0.5, 1.5) / dropRate;\n        }\n      }\n\n      let steps = 0;\n      while (accumulator >= step && steps < 3) {\n        renderer.step(queue.splice(0, MAX_DROPS * 4), live.current.damping);\n        accumulator -= step;\n        steps++;\n      }\n      if (accumulator > step) accumulator = 0; // si la pantalla va lenta, no se acumula atraso\n      if (steps > 0) draw();\n\n      // Con las ondas apagadas y nada en espera no hay nada que animar: el bucle duerme.\n      if (clock > calmAt && queue.length === 0) {\n        stop();\n        if (dropRate > 0) sleepTimer = window.setTimeout(wakeUp, Math.max(0, nextDrop) * 1000);\n      }\n    };\n    const wakeUp = () => {\n      sleepTimer = 0;\n      nextDrop = 0;\n      start();\n    };\n    const start = () => {\n      if (frameId || !visible || reducedMotion.matches) return;\n      window.clearTimeout(sleepTimer);\n      sleepTimer = 0;\n      lastNow = performance.now();\n      frameId = requestAnimationFrame(frame);\n    };\n    const stop = () => {\n      cancelAnimationFrame(frameId);\n      frameId = 0;\n      window.clearTimeout(sleepTimer);\n      sleepTimer = 0;\n    };\n\n    // ───────────────────────── Puntero ─────────────────────────\n\n    const onPointerMove = (event: PointerEvent) => {\n      if (reducedMotion.matches) return;\n      const rect = root.getBoundingClientRect();\n      const x = (event.clientX - rect.left) / rect.width;\n      const y = 1 - (event.clientY - rect.top) / rect.height; // la textura tiene el origen abajo\n      const now = performance.now();\n      if (pointer.active && now - pointer.time < 250) {\n        // Una gota cada ~9 px del recorrido: así el trazo es continuo aunque el cursor vaya rápido.\n        const distance = Math.hypot((x - pointer.x) * rect.width, (y - pointer.y) * rect.height);\n        const speed = distance / Math.max((now - pointer.time) / 1000, 0.008);\n        const strength = clamp(speed / 1500, 0.08, 1) * live.current.cursorForce * 0.2;\n        const count = Math.min(Math.ceil(distance / 9), 6);\n        if (distance > 0.5 && strength > 0) {\n          for (let i = 1; i <= count; i++) {\n            const t = i / count;\n            addDrop(pointer.x + (x - pointer.x) * t, pointer.y + (y - pointer.y) * t, 3.8, -strength);\n          }\n        }\n      }\n      pointer.x = x;\n      pointer.y = y;\n      pointer.time = now;\n      pointer.active = true;\n      start();\n    };\n    const onPointerDown = (event: PointerEvent) => {\n      if (reducedMotion.matches || live.current.cursorForce <= 0) return;\n      const rect = root.getBoundingClientRect();\n      // Un toque o clic es una gota gorda.\n      addDrop((event.clientX - rect.left) / rect.width, 1 - (event.clientY - rect.top) / rect.height, 6, -0.7 * live.current.cursorForce);\n      start();\n    };\n    const onPointerLeave = () => {\n      pointer.active = false;\n    };\n\n    const resizeObserver = new ResizeObserver(resize);\n    resizeObserver.observe(root);\n\n    // Fuera de pantalla no se gasta GPU.\n    const visibilityObserver = new IntersectionObserver(([entry]) => {\n      visible = entry.isIntersecting;\n      if (visible) start();\n      else stop();\n    });\n    visibilityObserver.observe(root);\n\n    const onMotionPreferenceChange = () => {\n      if (reducedMotion.matches) {\n        stop();\n        drawStill();\n      } else start();\n    };\n    reducedMotion.addEventListener(\"change\", onMotionPreferenceChange);\n\n    listener.addEventListener(\"pointermove\", onPointerMove);\n    listener.addEventListener(\"pointerdown\", onPointerDown);\n    listener.addEventListener(\"pointerleave\", onPointerLeave);\n    listener.addEventListener(\"pointercancel\", onPointerLeave);\n\n    // Cuando cambian los colores u otras props: se repinta (si el bucle duerme) y se retoma el ritmo de las gotas.\n    refresh.current = () => {\n      if (reducedMotion.matches) return drawStill();\n      calmAt = Math.max(calmAt, clock + 0.5);\n      nextDrop = Math.min(nextDrop, live.current.dropRate > 0 ? 1.2 / live.current.dropRate : nextDrop);\n      draw();\n      start();\n    };\n\n    resize();\n    start();\n\n    return () => {\n      stop();\n      resizeObserver.disconnect();\n      visibilityObserver.disconnect();\n      reducedMotion.removeEventListener(\"change\", onMotionPreferenceChange);\n      listener.removeEventListener(\"pointermove\", onPointerMove);\n      listener.removeEventListener(\"pointerdown\", onPointerDown);\n      listener.removeEventListener(\"pointerleave\", onPointerLeave);\n      listener.removeEventListener(\"pointercancel\", onPointerLeave);\n      refresh.current = () => {};\n      renderer.dispose();\n      canvas.remove();\n    };\n  }, []);\n\n  const colorVars = { \"--furin-ripple-pond-water\": color, \"--furin-ripple-pond-light\": lightColor } as CSSProperties;\n\n  return (\n    <div ref={rootRef} className={`furin-ripple-pond ${className}`.trim()} style={{ ...colorVars, ...style }}>\n      {/* Sin WebGL (o antes de saberlo) se ve el agua quieta, con los mismos colores. */}\n      {mode !== \"webgl\" && <div className=\"furin-ripple-pond__fallback\" />}\n      <div ref={hostRef} className=\"furin-ripple-pond__host\" />\n      {children !== undefined && <div className=\"furin-ripple-pond__content\">{children}</div>}\n    </div>\n  );\n}\n\nexport default RipplePond;\n",
      "type": "registry:component",
      "target": "components/furin/ripple-pond/RipplePond.tsx"
    },
    {
      "path": "registry/ripple-pond/RipplePond.css",
      "content": ".furin-ripple-pond {\n  position: absolute;\n  inset: 0;\n  overflow: hidden;\n  background: var(--furin-ripple-pond-water, #1b2a8c);\n  color: #fff;\n  isolation: isolate;\n  /* Es un fondo: no estorba al resto de la página. Los eventos se escuchan en el padre. */\n  pointer-events: none;\n}\n\n/* Contenedor del canvas WebGL: lo llena por completo. */\n.furin-ripple-pond__host,\n.furin-ripple-pond__canvas {\n  position: absolute;\n  inset: 0;\n  width: 100%;\n  height: 100%;\n  display: block;\n}\n\n/* Agua quieta para cuando no hay WebGL: unas ondas congeladas con los mismos colores. */\n.furin-ripple-pond__fallback {\n  position: absolute;\n  inset: 0;\n  background:\n    repeating-radial-gradient(\n      circle at 32% 58%,\n      transparent 0 22px,\n      color-mix(in srgb, var(--furin-ripple-pond-light, #c9daff) 14%, transparent) 23px 25px,\n      transparent 26px 48px\n    ),\n    repeating-radial-gradient(\n      circle at 70% 38%,\n      transparent 0 18px,\n      color-mix(in srgb, var(--furin-ripple-pond-light, #c9daff) 10%, transparent) 19px 21px,\n      transparent 22px 40px\n    ),\n    linear-gradient(\n      180deg,\n      color-mix(in srgb, var(--furin-ripple-pond-water, #1b2a8c) 80%, #fff) 0%,\n      var(--furin-ripple-pond-water, #1b2a8c) 45%,\n      color-mix(in srgb, var(--furin-ripple-pond-water, #1b2a8c) 55%, #000) 100%\n    );\n}\n\n/* El contenido va encima, centrado. */\n.furin-ripple-pond__content {\n  position: relative;\n  z-index: 1;\n  width: 100%;\n  height: 100%;\n  display: flex;\n  flex-direction: column;\n  align-items: center;\n  justify-content: center;\n  text-align: center;\n}\n\n/* Lo que pongas encima sí recibe clics y toques. */\n.furin-ripple-pond__content > * {\n  pointer-events: auto;\n}\n",
      "type": "registry:file",
      "target": "components/furin/ripple-pond/RipplePond.css"
    }
  ]
}
