{
  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
  "name": "honeycomb-draw",
  "title": "Honeycomb Draw",
  "description": "An ambient background where wax cells start as loosely packed circles and locally relax, wall by wall, into a tight hexagonal comb: each neighbour pair's shared wall straightens on its own schedule once the circles overlap, so a cell can show straight facets and still-round ones at once, with new circles seeding in from the left edge and a periodic recap flash keeping the finished lattice alive at rest.",
  "dependencies": [],
  "files": [
    {
      "path": "registry/core/honeycomb-draw/component.tsx",
      "content": "\"use client\";\n\nimport { useEffect, useId, useRef } from \"react\";\n\n// ---------------------------------------------------------------------------\n// HoneycombDraw — an ambient background built on real comb formation: bees\n// deposit wax as loosely packed circular tubes at near-uniform spacing, and\n// each three-way wall junction relaxes toward 120 degrees purely through\n// LOCAL wall-by-wall straightening as neighbouring circles overlap — no cell\n// ever \"decides\" to be a hexagon (Pirk et al. 2004; Bauer & Bienefeld 2013).\n//\n// This is deliberately NOT a hex grid that fades in. Every cell tracks its\n// own growing radius plus, independently, a per-neighbour wall spring: a\n// wall starts relaxing only once that specific pair of circles overlaps by\n// more than a threshold, and each wall settles on its own schedule. A cell's\n// silhouette is sampled at 36 angles as an interpolation between its current\n// circular radius and each neighbour-facing wall's target distance, weighted\n// by that wall's own spring progress — so a cell can show three straight\n// facets and three still-round ones at once, which is the visible signature\n// that distinguishes this from a static grid whose opacity is ramping.\n// ---------------------------------------------------------------------------\n\nexport interface HoneycombDrawProps {\n  /** Freezes on the fully-relaxed SETTLED_COMB frame without unmounting. */\n  paused?: boolean;\n  className?: string;\n  style?: React.CSSProperties;\n}\n\nfunction parseHex(raw: string): [number, number, number] | null {\n  const m = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(raw.trim());\n  if (!m) return null;\n  let h = m[1];\n  if (h.length === 3) h = h.split(\"\").map((c) => c + c).join(\"\");\n  const n = parseInt(h, 16);\n  return [((n >> 16) & 255) / 255, ((n >> 8) & 255) / 255, (n & 255) / 255];\n}\n\nfunction rgbaCss([r, g, b]: [number, number, number], a: number): string {\n  return `rgba(${Math.round(r * 255)},${Math.round(g * 255)},${Math.round(b * 255)},${a})`;\n}\nfunction lerpRGB(\n  a: [number, number, number],\n  b: [number, number, number],\n  t: number\n): [number, number, number] {\n  return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t];\n}\n\n// Owner feedback on the first build: \"it needs to be faster\" — the 14s fill\n// at 0.6 cells/s and the 4-7s recap gap left the surface looking static most\n// of the time. Growth, seeding and the post-fill idle are all pushed up\n// substantially here; the per-wall spring is also faster (SPRING_K raised)\n// but the relaxation itself stays a real, watchable multi-frame transition —\n// only the SEED_RATE / GROWTH_SECONDS / recap-gap changed the pace at which\n// new relaxations are triggered, never the \"walls straighten, not fade\"\n// mechanic itself.\nconst GROWTH_SECONDS = 0.9;\nconst RADIUS_FRAC = 0.62; // of spacing s\nconst OVERLAP_TRIGGER_FRAC = 0.06; // of s\nconst SPRING_K = 170;\nconst SPRING_DAMP = 1.0; // critical\nconst SEED_RATE = 6; // cells/s\nconst FILL_CAP = 0.85;\nconst RECAP_MIN = 0.6;\nconst RECAP_MAX = 1.6;\nconst RECAP_FLASH = 0.22;\nconst RECAP_FADE = 0.6;\nconst SAMPLES = 36; // boundary samples per cell, for the polygon outline\n\n// Standard \"odd-r\" offset-triangular-lattice neighbour offsets — six\n// directions per cell, three shared with the row above and three with the\n// row below, so the whole field tiles without gaps.\nconst NEI_EVEN: [number, number][] = [\n  [1, 0],\n  [-1, 0],\n  [0, -1],\n  [1, -1],\n  [0, 1],\n  [1, 1],\n];\nconst NEI_ODD: [number, number][] = [\n  [1, 0],\n  [-1, 0],\n  [-1, -1],\n  [0, -1],\n  [-1, 1],\n  [0, 1],\n];\n\ninterface Wall {\n  neighbor: Cell | null;\n  triggered: boolean;\n  progress: number; // 0..1 spring value\n  velocity: number;\n  wallDist: number; // px, distance from this cell's centre to the shared wall\n  angle: number; // rad, direction from this cell to the neighbour\n}\n\ninterface Cell {\n  col: number;\n  row: number;\n  x: number;\n  y: number;\n  spawnAt: number;\n  walls: Wall[]; // length 6, index-aligned with NEI_EVEN/NEI_ODD\n  recapStart: number | null;\n}\n\nfunction easeOutCubic(t: number): number {\n  const p = 1 - t;\n  return 1 - p * p * p;\n}\n\nexport function HoneycombDraw({ paused = false, className = \"\", style }: HoneycombDrawProps) {\n  const wrapRef = useRef<HTMLDivElement | null>(null);\n  const canvasRef = useRef<HTMLCanvasElement | null>(null);\n  const uid = useId();\n  const pausedRef = useRef(paused);\n  pausedRef.current = paused;\n\n  useEffect(() => {\n    const wrap = wrapRef.current;\n    const canvas = canvasRef.current;\n    if (!wrap || !canvas) return;\n    const ctx = canvas.getContext(\"2d\");\n    if (!ctx) return;\n\n    let cssW = 0;\n    let cssH = 0;\n    let dpr = 1;\n    let disposed = false;\n    let running = false;\n    let raf = 0;\n    let staticMode = false;\n    let lastMs = performance.now();\n    let simTime = 0;\n    let s = 40; // lattice spacing, recomputed on resize\n\n    let cols = 0;\n    let rows = 0;\n    let cells: (Cell | null)[] = [];\n    let filledCount = 0;\n    let slotTotal = 0;\n    let spawnAcc = 0;\n    let nextRecapAt = 0;\n\n    let border: [number, number, number] = [0.5, 0.5, 0.5];\n    let muted: [number, number, number] = [0.5, 0.5, 0.5];\n    let fg: [number, number, number] = [0.09, 0.09, 0.09];\n\n    const readColors = () => {\n      const cs = getComputedStyle(document.documentElement);\n      border = parseHex(cs.getPropertyValue(\"--border\")) ?? [0.5, 0.5, 0.5];\n      muted = parseHex(cs.getPropertyValue(\"--ns-muted\")) ?? [0.55, 0.55, 0.55];\n      fg = parseHex(cs.getPropertyValue(\"--foreground\")) ?? [0.09, 0.09, 0.09];\n    };\n    readColors();\n\n    const cellAt = (c: number, r: number): Cell | null => {\n      if (c < 0 || r < 0 || c >= cols || r >= rows) return null;\n      return cells[r * cols + c];\n    };\n\n    const layout = () => {\n      const ref = Math.min(cssW, cssH) || 1;\n      s = ref / 11;\n      const rowH = s * (Math.sqrt(3) / 2);\n      cols = Math.max(1, Math.ceil(cssW / s) + 2);\n      rows = Math.max(1, Math.ceil(cssH / rowH) + 2);\n      cells = new Array(cols * rows).fill(null);\n      filledCount = 0;\n      slotTotal = cols * rows;\n      spawnAcc = 0;\n      nextRecapAt = simTime + RECAP_MIN + Math.random() * (RECAP_MAX - RECAP_MIN);\n    };\n\n    // Jittered lattice position for a slot — jitter is fixed per slot (seeded\n    // from its indices) so it never shifts after the cell is spawned.\n    const slotPos = (c: number, r: number): { x: number; y: number } => {\n      const rowH = s * (Math.sqrt(3) / 2);\n      const jseed = Math.sin(c * 12.9898 + r * 78.233) * 43758.5453;\n      const jx = ((jseed - Math.floor(jseed)) - 0.5) * 2 * (0.12 * s);\n      const jseed2 = Math.sin(c * 39.346 + r * 11.135) * 24634.634;\n      const jy = ((jseed2 - Math.floor(jseed2)) - 0.5) * 2 * (0.12 * s);\n      const x = c * s + (Math.abs(r % 2) === 1 ? s / 2 : 0) + jx;\n      const y = r * rowH + jy;\n      return { x, y };\n    };\n\n    const spawnCell = (c: number, r: number) => {\n      if (cellAt(c, r)) return;\n      const { x, y } = slotPos(c, r);\n      const cell: Cell = { col: c, row: r, x, y, spawnAt: simTime, walls: [], recapStart: null };\n      cells[r * cols + c] = cell;\n      filledCount++;\n      // walls are wired lazily once both cells in a pair exist, in linkWalls()\n    };\n\n    // Wire (or re-wire) the 6 potential walls for every cell whose neighbour\n    // set might have changed — cheap enough to run whenever a new cell spawns\n    // since it only touches existing neighbours.\n    const linkWalls = () => {\n      for (let r = 0; r < rows; r++) {\n        for (let c = 0; c < cols; c++) {\n          const cell = cellAt(c, r);\n          if (!cell) continue;\n          const offsets = Math.abs(r % 2) === 1 ? NEI_ODD : NEI_EVEN;\n          if (cell.walls.length !== 6) {\n            cell.walls = offsets.map(() => ({\n              neighbor: null,\n              triggered: false,\n              progress: 0,\n              velocity: 0,\n              wallDist: s * 0.5,\n              angle: 0,\n            }));\n          }\n          for (let k = 0; k < 6; k++) {\n            const [dc, dr] = offsets[k];\n            const nb = cellAt(c + dc, r + dr);\n            const w = cell.walls[k];\n            if (nb && w.neighbor !== nb) {\n              w.neighbor = nb;\n              const dx = nb.x - cell.x;\n              const dy = nb.y - cell.y;\n              w.angle = Math.atan2(dy, dx);\n              w.wallDist = Math.hypot(dx, dy) * 0.5; // Voronoi bisector foot\n            }\n          }\n        }\n      }\n    };\n\n    const radiusOf = (cell: Cell, t: number): number => {\n      const age = t - cell.spawnAt;\n      const k = Math.max(0, Math.min(1, age / GROWTH_SECONDS));\n      return RADIUS_FRAC * s * easeOutCubic(k);\n    };\n\n    const springStep = (w: Wall, dt: number) => {\n      if (!w.triggered) return;\n      const target = 1;\n      const force = -SPRING_K * (w.progress - target) - 2 * Math.sqrt(SPRING_K) * SPRING_DAMP * w.velocity;\n      w.velocity += force * dt;\n      w.progress += w.velocity * dt;\n      if (w.progress > 1 && Math.abs(w.velocity) < 0.001) {\n        w.progress = 1;\n        w.velocity = 0;\n      }\n    };\n\n    const step = (dt: number) => {\n      simTime += dt;\n\n      // growth + overlap trigger + spring integration\n      for (let i = 0; i < cells.length; i++) {\n        const cell = cells[i];\n        if (!cell) continue;\n        const r0 = radiusOf(cell, simTime);\n        for (const w of cell.walls) {\n          if (!w.neighbor) continue;\n          if (!w.triggered) {\n            const r1 = radiusOf(w.neighbor, simTime);\n            const dist = w.wallDist * 2;\n            const overlap = r0 + r1 - dist;\n            if (overlap > OVERLAP_TRIGGER_FRAC * s) w.triggered = true;\n          }\n          springStep(w, dt);\n        }\n      }\n\n      // seed new cells along the left edge while under the fill cap\n      if (filledCount / slotTotal < FILL_CAP) {\n        spawnAcc += dt * SEED_RATE;\n        while (spawnAcc >= 1 && filledCount / slotTotal < FILL_CAP) {\n          spawnAcc -= 1;\n          // leftmost column with an empty slot, topmost row first\n          let spawned = false;\n          for (let c = 0; c < cols && !spawned; c++) {\n            for (let r = 0; r < rows; r++) {\n              if (!cellAt(c, r)) {\n                spawnCell(c, r);\n                spawned = true;\n                break;\n              }\n            }\n          }\n          if (!spawned) break;\n        }\n        linkWalls();\n      }\n\n      // recap flash: once the grid is essentially full, periodically re-flash\n      // one existing cell's wall stroke — this is what keeps the piece alive\n      // at rest indefinitely once growth finishes.\n      if (filledCount / slotTotal >= FILL_CAP * 0.999 && simTime >= nextRecapAt) {\n        const alive = cells.filter((c): c is Cell => !!c);\n        if (alive.length > 0) {\n          const pick = alive[Math.floor(Math.random() * alive.length)];\n          pick.recapStart = simTime;\n        }\n        nextRecapAt = simTime + RECAP_MIN + Math.random() * (RECAP_MAX - RECAP_MIN);\n      }\n    };\n\n    // Precomputes the fully-grown, fully-relaxed lattice deterministically —\n    // used both for the reduced-motion/paused SETTLED_COMB frame and to seed\n    // a resize so the surface never shows a blank field while catching up.\n    const settle = () => {\n      layout();\n      for (let c = 0; c < cols; c++) {\n        for (let r = 0; r < rows; r++) spawnCell(c, r);\n      }\n      linkWalls();\n      for (const cell of cells) {\n        if (!cell) continue;\n        cell.spawnAt = simTime - GROWTH_SECONDS * 2;\n        for (const w of cell.walls) {\n          if (!w.neighbor) continue;\n          w.triggered = true;\n          w.progress = 1;\n          w.velocity = 0;\n        }\n      }\n    };\n\n    const strokeColorFor = (cell: Cell, t: number): [number, number, number] => {\n      if (cell.recapStart == null) return border;\n      const elapsed = t - cell.recapStart;\n      if (elapsed < 0) return border;\n      if (elapsed < RECAP_FLASH) return fg;\n      if (elapsed < RECAP_FLASH + RECAP_FADE) {\n        return lerpRGB(fg, border, (elapsed - RECAP_FLASH) / RECAP_FADE);\n      }\n      cell.recapStart = null;\n      return border;\n    };\n\n    const drawCell = (cell: Cell, t: number) => {\n      const r0 = radiusOf(cell, t);\n      if (r0 <= 0.5) return;\n      // 6 control distances, one per lattice direction, blended between the\n      // circular radius and that specific wall's target distance by ITS OWN\n      // spring progress — the source of the wall-by-wall (not all-at-once)\n      // relaxation read.\n      const dirs: number[] = [];\n      const dists: number[] = [];\n      for (const w of cell.walls) {\n        const target = w.neighbor ? w.wallDist : r0;\n        const d = w.neighbor ? r0 + (target - r0) * w.progress : r0;\n        dirs.push(w.angle);\n        dists.push(Math.min(d, r0 * 1.05));\n      }\n      if (dirs.length === 0) {\n        ctx.beginPath();\n        ctx.arc(cell.x, cell.y, r0, 0, Math.PI * 2);\n      } else {\n        // sort control points by angle so the angular interpolation below\n        // walks the boundary in order\n        const order = dirs.map((_, i) => i).sort((a, b) => dirs[a] - dirs[b]);\n        const sortedAngles = order.map((i) => dirs[i]);\n        const sortedDists = order.map((i) => dists[i]);\n        const n = sortedAngles.length;\n        ctx.beginPath();\n        for (let i = 0; i < SAMPLES; i++) {\n          const theta = (i / SAMPLES) * Math.PI * 2 - Math.PI;\n          // find bracketing control points (wrap-around)\n          let k = 0;\n          while (k < n && sortedAngles[k] < theta) k++;\n          const k1 = ((k % n) + n) % n;\n          const k0 = ((k1 - 1) % n + n) % n;\n          let a0 = sortedAngles[k0];\n          let a1 = sortedAngles[k1];\n          if (a1 <= a0) a1 += Math.PI * 2;\n          let th = theta;\n          if (th < a0) th += Math.PI * 2;\n          const f = a1 > a0 ? (th - a0) / (a1 - a0) : 0;\n          const rad = sortedDists[k0] + (sortedDists[k1] - sortedDists[k0]) * f;\n          const px = cell.x + Math.cos(theta) * rad;\n          const py = cell.y + Math.sin(theta) * rad;\n          if (i === 0) ctx.moveTo(px, py);\n          else ctx.lineTo(px, py);\n        }\n        ctx.closePath();\n      }\n      ctx.fillStyle = rgbaCss(muted, 0.1);\n      ctx.fill();\n      const [cr, cg, cb] = strokeColorFor(cell, t);\n      ctx.strokeStyle = rgbaCss([cr, cg, cb], cell.recapStart != null ? 0.9 : 0.55);\n      ctx.lineWidth = 1;\n      ctx.stroke();\n    };\n\n    const draw = () => {\n      if (cssW <= 0 || cssH <= 0) return;\n      ctx.clearRect(0, 0, cssW, cssH);\n      for (const cell of cells) {\n        if (cell) drawCell(cell, simTime);\n      }\n    };\n\n    const loop = (nowMs: number) => {\n      const rawMs = nowMs - lastMs;\n      const dt = Math.min(0.05, Math.max(0, rawMs / 1000));\n      lastMs = nowMs;\n      step(dt);\n      draw();\n      raf = requestAnimationFrame(loop);\n    };\n\n    const wake = () => {\n      if (running || disposed) return;\n      running = true;\n      lastMs = performance.now();\n      raf = requestAnimationFrame(loop);\n    };\n    const sleep = () => {\n      cancelAnimationFrame(raf);\n      running = false;\n    };\n\n    const applyBacking = () => {\n      if (cssW < 2 || cssH < 2) return;\n      dpr = Math.min(window.devicePixelRatio || 1, 2);\n      const pw = Math.round(cssW * dpr);\n      const ph = Math.round(cssH * dpr);\n      if (canvas.width !== pw || canvas.height !== ph) {\n        canvas.width = pw;\n        canvas.height = ph;\n      }\n      canvas.style.width = `${cssW}px`;\n      canvas.style.height = `${cssH}px`;\n      ctx.setTransform(dpr, 0, 0, dpr, 0, 0);\n    };\n\n    const resize = () => {\n      const rect = wrap.getBoundingClientRect();\n      if (rect.width < 2 || rect.height < 2) return;\n      cssW = rect.width;\n      cssH = rect.height;\n      applyBacking();\n      if (staticMode) {\n        settle();\n      } else {\n        layout();\n      }\n      draw();\n    };\n\n    const ro = new ResizeObserver(resize);\n    ro.observe(wrap);\n\n    const mq = window.matchMedia(\"(prefers-reduced-motion: reduce)\");\n    let reduced = mq.matches;\n    const applyMode = () => {\n      if (reduced || pausedRef.current) {\n        staticMode = true;\n        sleep();\n        settle();\n        draw();\n      } else {\n        staticMode = false;\n        layout();\n        wake();\n      }\n    };\n    const onMq = () => {\n      reduced = mq.matches;\n      applyMode();\n    };\n    mq.addEventListener(\"change\", onMq);\n\n    let onScreen = true;\n    const io = new IntersectionObserver(\n      (entries) => {\n        onScreen = entries.some((en) => en.isIntersecting);\n        if (!onScreen) sleep();\n        else if (!staticMode && !document.hidden) wake();\n      },\n      { threshold: 0 }\n    );\n    io.observe(wrap);\n\n    const onVis = () => {\n      if (document.hidden) sleep();\n      else if (!staticMode && onScreen) wake();\n    };\n    document.addEventListener(\"visibilitychange\", onVis);\n\n    const themeObserver = new MutationObserver(() => {\n      readColors();\n      if (staticMode) draw();\n    });\n    themeObserver.observe(document.documentElement, {\n      attributes: true,\n      attributeFilter: [\"class\"],\n    });\n\n    let lastPolledPaused = pausedRef.current;\n    let poll = 0;\n    const tick = () => {\n      if (pausedRef.current !== lastPolledPaused) {\n        lastPolledPaused = pausedRef.current;\n        applyMode();\n      }\n      poll = window.setTimeout(tick, 140);\n    };\n    tick();\n\n    resize();\n    applyMode();\n\n    return () => {\n      disposed = true;\n      ro.disconnect();\n      io.disconnect();\n      mq.removeEventListener(\"change\", onMq);\n      document.removeEventListener(\"visibilitychange\", onVis);\n      themeObserver.disconnect();\n      window.clearTimeout(poll);\n      sleep();\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  return (\n    <div\n      ref={wrapRef}\n      data-honeycomb-draw={uid}\n      className={`relative h-full w-full overflow-hidden bg-background ${className}`}\n      style={style}\n    >\n      <canvas ref={canvasRef} aria-hidden=\"true\" className=\"absolute inset-0 block h-full w-full\" />\n    </div>\n  );\n}\n\nHoneycombDraw.displayName = \"HoneycombDraw\";\n",
      "type": "registry:ui",
      "target": "components/ui/honeycomb-draw.tsx"
    }
  ],
  "cssVars": {
    "theme": {
      "color-ns-muted": "var(--ns-muted)"
    },
    "light": {
      "ns-muted": "#4d4d4d"
    },
    "dark": {
      "ns-muted": "#8f8f8f"
    }
  },
  "meta": {
    "collection": "core",
    "tags": [
      "background",
      "canvas",
      "hexagon",
      "relaxation",
      "generative",
      "ambient",
      "texture"
    ],
    "instruction": "Build <HoneycombDraw paused? className? style?> as a card-scale 2D-canvas background built on real comb formation (Pirk et al. 2004; Bauer & Bienefeld 2013): packed circular wax cells relax into a hexagonal lattice through purely LOCAL wall-by-wall straightening, never a hex grid fading in. LATTICE: cell centres sit on a jittered 'odd-r' offset-triangular lattice, spacing s = min(containerW, containerH) / 11, each slot jittered up to +-0.12*s in both axes (jitter derived once per slot index via a cheap sine hash, fixed for that slot's lifetime, not re-rolled per frame). GROWTH: each cell's radius eases from 0 to 0.62*s over GROWTH_SECONDS=2.2s via ease-out-cubic, timed from that cell's own spawn moment. WALLS: every cell tracks up to 6 walls, one per lattice neighbour direction (odd-r offset neighbour table), each with its own independent state: untriggered until the pair's summed radii overlap the shared distance by more than OVERLAP_TRIGGER_FRAC=0.06*s, at which point (permanently — walls never un-trigger) the wall's spring target becomes 1 and a critically-damped spring (k=SPRING_K=90, damping ratio 1.0, semi-implicit Euler: velocity += (-k*(progress-1) - 2*sqrt(k)*damping*velocity)*dt; progress += velocity*dt) carries its progress from 0 to 1 over roughly 1.4s. wallDist for a wall is the Voronoi/perpendicular-bisector foot: half the straight-line distance to that neighbour's actual (jittered) centre. RENDER: a cell's boundary is sampled at SAMPLES=36 angles; at each sample angle the boundary radius is linearly interpolated between the two angularly-nearest walls' OWN blended distance (each wall's blended distance = lerp(currentCircleRadius, wallDist, thatWall'sSpringProgress) — directions with no neighbour, or whose wall hasn't triggered, stay at the plain circle radius) — this per-wall independence, not a single global relax factor, is what makes a partially-relaxed cell show straight facets next to round ones simultaneously, the visible signature that distinguishes this from a hex grid whose opacity is ramping (the spec's explicit kill criterion). SEEDING: while filled-slot-fraction < FILL_CAP=0.85, new cells spawn at SEED_RATE=0.6/s, chosen as the leftmost column's topmost still-empty slot (reading order), so growth visibly advances as a front from the left edge rather than popping in randomly. RECAP: once filled-fraction reaches ~FILL_CAP, a uniformly-random already-placed cell is picked every RECAP_MIN..RECAP_MAX=4..7s (re-rolled each time) and its stroke flashes to --foreground for RECAP_FLASH=0.26s then eases (linear) back to --border over RECAP_FADE=0.9s — this recap cycle is what keeps the piece alive at rest indefinitely once growth is done, since growth itself is a one-shot ~14s process for an 11-cell-wide card. TOKENS: wall strokes are --border at rest (0.55 alpha, a genuine hairline separator use, not a fill) and --foreground during a recap flash (never --ns-accent, no interactive control exists on this component); the low-alpha fill (0.1 alpha --ns-muted) is constant whether a cell is still round or fully hexagonal, read live via getComputedStyle(document.documentElement) at mount and re-read on a MutationObserver watching documentElement's class. STATIC/REDUCED-MOTION: prefers-reduced-motion and paused both call settle(), which lays out every lattice slot, spawns every cell with its spawnAt backdated past GROWTH_SECONDS, and force-sets every wall to triggered/progress=1/velocity=0 in one synchronous pass (SETTLED_COMB) — the freeze frame is the fully-filled, fully-relaxed hexagon lattice with zero mid-relaxation cells and no recap flash firing, never a blank or half-built grid. `ResizeObserver` re-derives spacing and re-lays the grid (settle() if currently static, otherwise a fresh empty-then-growing layout()); `IntersectionObserver` (threshold 0) and `visibilitychange` both pause the single rAF loop. Canvas is `aria-hidden` decoration with `w-full h-full`; this is a pure background layer with no accessible content of its own — callers place real content in a sibling layer above it, as in demo.tsx."
  },
  "type": "registry:ui"
}