{
  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
  "name": "fog-garden",
  "title": "Fog Garden",
  "author": "Visant Labs <visantsupply@gmail.com>",
  "description": "A caminhada por um jardim na névoa presa ao scroll: cada parada de texto sai da névoa e volta para ela, em mix-blend-difference sobre as copas, com clareiras derivadas das paradas e plantio semeado.",
  "dependencies": [
    "three@^0.170.0",
    "@dgreenheck/ez-tree@^1.1.0",
    "framer-motion"
  ],
  "devDependencies": [
    "@types/three@^0.170.0"
  ],
  "registryDependencies": [
    "utils",
    "@visant/css-color",
    "@visant/fog-tree"
  ],
  "files": [
    {
      "path": "registry/visant/blocks/fog-garden/garden-scene.ts",
      "content": "/**\n * A cena do `fog-garden`: uma trilha sinuosa num jardim na névoa, percorrida\n * pela câmera conforme o progresso.\n *\n * Mesma floresta do `fog-tree` (mesmos cinzas, mesmo `growTree`, mesmo\n * `fog-post`), outra escala: dezenas de árvores em vez de uma. O que torna isso\n * viável num notebook é a decisão 1.\n *\n * 1. **Sete árvores geradas, dezenas plantadas.** O ez-tree gera geometria na\n *    thread principal (dezenas de ms por árvore). Aqui nascem sete variantes,\n *    uma vez, e cada árvore da trilha é um `Group` com malhas que APONTAM para\n *    a geometria e o material da variante — memória de sete, custo de upload de\n *    sete. E o vento vem de graça: o uniform de tempo mora no material\n *    compartilhado, então atualizar a variante balança todos os clones dela.\n * 2. **Clone na mão, não `tree.clone()`.** O construtor do `Tree` cria duas\n *    malhas vazias; o `clone()` do three chama esse construtor e DEPOIS copia os\n *    filhos, então cada clone carregava duas malhas fantasmas com material\n *    próprio que ninguém descartava.\n * 3. **Semente fixa.** O plantio usa um LCG semeado: o jardim é o mesmo a cada\n *    visita e em toda máquina. Jardim que muda a cada recarga faz a pessoa\n *    achar que a página está quebrando, não que é generativa.\n * 4. **Clareiras são parâmetro.** Perto delas o plantio rareia e entra uma\n *    árvore protagonista (a copa redonda) ao lado da trilha, para a câmera\n *    passar perto. Os marcos (`landmark`) vêm de fora: a cena não sabe o que é\n *    o produto de ninguém.\n * 5. **Parâmetro não refaz cena.** O que custa é o `growTree` (sete árvores, 400ms\n *    na thread principal) e o programa do pós. Replantar só troca `Group` que aponta\n *    para o que já existe, e rastro e grão são uniforms: mexer num controle a 60\n *    quadros por segundo não pode passar por `createGardenScene`.\n */\n\nimport * as THREE from \"three\";\nimport type { Tree } from \"@dgreenheck/ez-tree\";\n\nimport type { RGB } from \"@/lib/css-color\";\nimport {\n  contactShadowTexture,\n  createFogPost,\n  createFogRenderer,\n  densidadeDoCanvas,\n  disposeTree,\n  gray,\n  releaseRenderer,\n} from \"@/lib/fog-post\";\nimport { growTree, roundCrown } from \"@/lib/fog-tree-scene\";\n\n/**\n * Fábrica de marco para as clareiras (um objeto, um produto, uma escultura).\n *\n * Recebe o índice da clareira e devolve o objeto em unidades da cena (uma\n * árvore de fundo tem ~25 de altura; a câmera anda a 13 do chão). A cena\n * posiciona, gira `userData.spin` rad/s se houver, e DESCARTA geometria e\n * material do que for devolvido no fim — não reaproveite fora daqui.\n */\nexport type GardenLandmark = (index: number) => THREE.Object3D | null | undefined;\n\n/** O que muda o desenho do jardim sem gerar árvore nova (decisão 5). */\nexport interface GardenPlanting {\n  seed: number;\n  /** Quantas posições de plantio ao longo da trilha. */\n  density: number;\n  /** Pontos 0..1 da trilha com clareira. */\n  clearings: number[];\n}\n\nexport interface GardenSceneOptions extends GardenPlanting {\n  landmark?: GardenLandmark;\n  trail: number;\n  grain: number;\n  reduce: boolean;\n  light: boolean;\n}\n\nexport interface GardenScene {\n  setProgress(p: number): void;\n  /** Ponteiro em -1..1; desvia o olhar da câmera para os lados. */\n  setPointer(x: number, y: number): void;\n  setColors(paper: RGB, ink: RGB): void;\n  setPlanting(planting: GardenPlanting): void;\n  setTrail(trail: number): void;\n  setGrain(grain: number): void;\n  setRunning(on: boolean): void;\n  dispose(): void;\n}\n\n// LCG de Numerical Recipes: curto, rápido e igual em todo motor JS\nfunction rng(seed: number) {\n  let s = seed >>> 0;\n  return () => (s = (s * 1664525 + 1013904223) >>> 0) / 4294967296;\n}\n\n/** Um \"clone\" que compartilha geometria e material com a variante (decisão 2). */\nfunction instance(base: Tree) {\n  const g = new THREE.Group();\n  for (const m of [base.branchesMesh, base.leavesMesh]) {\n    g.add(new THREE.Mesh(m.geometry, m.material));\n  }\n  return g;\n}\n\nexport function createGardenScene(\n  canvas: HTMLCanvasElement,\n  opts: GardenSceneOptions,\n): GardenScene | null {\n  const renderer = createFogRenderer(canvas, opts.light);\n  if (!renderer) return null;\n\n  const scene = new THREE.Scene();\n  const branco = gray(1);\n  scene.background = branco;\n  // densidade absoluta: o jardim tem escala fixa, diferente da árvore sozinha\n  scene.fog = new THREE.FogExp2(branco, 0.0042);\n\n  const camera = new THREE.PerspectiveCamera(42, 1, 0.5, 900);\n  scene.add(new THREE.HemisphereLight(branco, gray(0.604), 2.2));\n  const sol = new THREE.DirectionalLight(branco, 1.1);\n  sol.position.set(40, 120, 60);\n  scene.add(sol);\n\n  // Trilha: senoide suave em profundidade. `centripetal` evita a laçada que a\n  // Catmull-Rom uniforme faz quando dois pontos ficam próximos demais.\n  const pontos = Array.from(\n    { length: 14 },\n    (_, i) => new THREE.Vector3(Math.sin(i * 0.85) * 55, 0, -i * 210),\n  );\n  const trilha = new THREE.CatmullRomCurve3(pontos, false, \"centripetal\");\n\n  const chaoGeo = new THREE.PlaneGeometry(6000, 6000);\n  const chaoMat = new THREE.MeshBasicMaterial({ color: gray(0.957) });\n  const chao = new THREE.Mesh(chaoGeo, chaoMat);\n  chao.rotation.x = -Math.PI / 2;\n  chao.position.z = -1300;\n  scene.add(chao);\n\n  // Uma textura, uma geometria e um material de sombra para o jardim inteiro;\n  // o tamanho de cada sombra vem da escala da malha.\n  const sombraTex = contactShadowTexture(128, 0.32);\n  const sombraGeo = new THREE.PlaneGeometry(1, 1);\n  const sombraMat = new THREE.MeshBasicMaterial({\n    map: sombraTex,\n    transparent: true,\n    depthWrite: false,\n  });\n\n  // Variantes (decisão 1). Folha mais rala nas de fundo: elas passam ao longe,\n  // na névoa densa, e a contagem de folha é o grosso dos vértices.\n  const folhas = opts.light ? 10 : 16;\n  const rala = (t: Tree) => {\n    t.options.leaves.count = folhas;\n  };\n  const protagonista = growTree(\"Oak Medium\", 4242, roundCrown);\n  const fundo = [\n    growTree(\"Oak Medium\", 11, rala),\n    growTree(\"Ash Medium\", 23, rala),\n    growTree(\"Aspen Medium\", 37, rala),\n    growTree(\"Oak Small\", 51, rala),\n  ];\n  const arbustos = [growTree(\"Bush 1\", 7), growTree(\"Bush 2\", 9)];\n  const variantes = [protagonista, ...fundo, ...arbustos];\n  const tamanho = new Map(\n    variantes.map((v) => [v, new THREE.Box3().setFromObject(v).getSize(new THREE.Vector3())]),\n  );\n\n  // O jardim mora num grupo só: replantar é esvaziar o grupo e plantar de novo.\n  const jardim = new THREE.Group();\n  scene.add(jardim);\n\n  const plantar = (base: Tree, pos: THREE.Vector3, escala: number, rot: number) => {\n    const c = instance(base);\n    c.position.copy(pos);\n    c.scale.setScalar(escala);\n    c.rotation.y = rot;\n    jardim.add(c);\n    const tam = tamanho.get(base)!;\n    const s = new THREE.Mesh(sombraGeo, sombraMat);\n    s.rotation.x = -Math.PI / 2;\n    s.position.set(pos.x, 0.05, pos.z);\n    s.scale.set(tam.x * escala * 1.4, tam.z * escala * 1.1, 1);\n    jardim.add(s);\n  };\n\n  const tangente = new THREE.Vector3();\n  const lado = new THREE.Vector3();\n  /** Ponto da trilha deslocado para o lado (perpendicular à tangente, no chão). */\n  const aoLado = (u: number, desvio: number, out = new THREE.Vector3()) => {\n    trilha.getPointAt(THREE.MathUtils.clamp(u, 0, 1), out);\n    trilha.getTangentAt(THREE.MathUtils.clamp(u, 0, 1), tangente);\n    lado.set(-tangente.z, 0, tangente.x).normalize();\n    return out.addScaledVector(lado, desvio);\n  };\n\n  // Um marco por índice de clareira, feito uma vez: a fábrica é de quem usa e\n  // pode ser cara. Clareira que some só esconde o marco dela.\n  const marcos = new Map<number, THREE.Object3D | null>();\n\n  const replantar = ({ seed, density, clearings }: GardenPlanting) => {\n    jardim.clear();\n\n    // Plantio (decisão 3): mais ralo perto das clareiras, arbusto perto da\n    // trilha e árvore mais longe, para a trilha ler como caminho aberto.\n    const r = rng(seed);\n    const passos = Math.max(8, Math.round(opts.light ? density * 0.6 : density));\n    for (let k = 0; k < passos; k++) {\n      const u = 0.02 + (k / passos) * 0.97;\n      const perto = clearings.some((c) => Math.abs(c - u) < 0.035);\n      if (perto && r() < 0.8) continue;\n      const sinal = r() < 0.5 ? -1 : 1;\n      const arbusto = r() < 0.3;\n      const dist = arbusto ? 18 + r() * 26 : 50 + r() * 110;\n      const base = arbusto\n        ? arbustos[(r() * arbustos.length) | 0]\n        : fundo[(r() * fundo.length) | 0];\n      const escala = arbusto ? 1.2 + r() * 1.2 : 0.75 + r() * 0.6;\n      plantar(base, aoLado(u, sinal * dist), escala, r() * Math.PI * 2);\n    }\n\n    // Protagonista em cada clareira, alternando o lado, um pouco à frente do\n    // ponto: a câmera olha adiante, então a árvore entra no quadro ANTES de a\n    // câmera chegar, e não de lado quando já passou.\n    marcos.forEach((m) => {\n      if (m) m.visible = false;\n    });\n    clearings.forEach((u, i) => {\n      const flanco = i % 2 ? 1 : -1;\n      plantar(protagonista, aoLado(u + 0.012, flanco * 26), 1, i * 1.7);\n      if (!marcos.has(i)) {\n        const novo = opts.landmark?.(i) ?? null;\n        marcos.set(i, novo);\n        if (novo) scene.add(novo);\n      }\n      const marco = marcos.get(i);\n      if (marco) {\n        // do lado oposto à árvore, mais perto da trilha: os dois dividem o quadro\n        marco.position.copy(aoLado(u, -flanco * 15));\n        marco.visible = true;\n      }\n    });\n  };\n  replantar(opts);\n\n  const post = createFogPost(renderer, scene, camera, {\n    trail: opts.reduce ? 0 : opts.trail,\n    grain: opts.grain,\n    light: opts.light,\n  });\n\n  const resize = () => {\n    const w = Math.max(1, canvas.clientWidth);\n    const h = Math.max(1, canvas.clientHeight);\n    renderer.setPixelRatio(densidadeDoCanvas(canvas, opts.light));\n    renderer.setSize(w, h, false);\n    post.setSize(w, h);\n    camera.aspect = w / h;\n    camera.updateProjectionMatrix();\n    pedir();\n  };\n  const ro = new ResizeObserver(resize);\n  ro.observe(canvas);\n  // A escala do palco muda com a janela sem mudar o tamanho de layout do canvas.\n  window.addEventListener(\"resize\", resize);\n\n  const alvo = { p: 0, px: 0, py: 0 };\n  const atual = { p: 0, px: 0, py: 0 };\n  const posCam = new THREE.Vector3();\n  const olhar = new THREE.Vector3();\n  const relogio = new THREE.Clock();\n  let visivel = false;\n  let raf = 0;\n\n  const quadro = () => {\n    const t = relogio.getElapsedTime();\n    const k = opts.reduce ? 1 : 0.055;\n    atual.p += (alvo.p - atual.p) * k;\n    atual.px += (alvo.px - atual.px) * 0.04;\n    atual.py += (alvo.py - atual.py) * 0.04;\n\n    // 0.995 e não 1: `getTangentAt(1)` na ponta da curva aberta vira o olhar\n    // para o lado no último quadro da caminhada.\n    const u = THREE.MathUtils.clamp(atual.p, 0, 0.995);\n    trilha.getPointAt(u, posCam);\n    // a respiração de quem caminha: sobe e desce quase nada\n    camera.position.set(posCam.x, 13 + (opts.reduce ? 0 : Math.sin(t * 0.9) * 0.35), posCam.z);\n    aoLado(u + 0.03, atual.px * 40, olhar);\n    olhar.y = 16 - atual.py * 10;\n    camera.lookAt(olhar);\n\n    if (!opts.reduce) {\n      variantes.forEach((v) => v.update(t));\n      marcos.forEach((m) => {\n        const spin = Number(m?.userData.spin) || 0;\n        if (m && spin) m.rotation.y = t * spin;\n      });\n      post.setTime(t);\n    }\n    post.render();\n  };\n\n  const animando = () =>\n    visivel &&\n    (!opts.reduce ||\n      Math.abs(alvo.p - atual.p) > 1e-4 ||\n      Math.abs(alvo.px - atual.px) > 1e-3 ||\n      Math.abs(alvo.py - atual.py) > 1e-3);\n\n  // `raf` só zera depois do quadro, para um `pedir()` de dentro dele não\n  // agendar um segundo laço em paralelo\n  const tick = () => {\n    quadro();\n    raf = animando() ? requestAnimationFrame(tick) : 0;\n  };\n  function pedir() {\n    if (visivel && !raf) raf = requestAnimationFrame(tick);\n  }\n\n  resize();\n\n  return {\n    setProgress(p) {\n      alvo.p = THREE.MathUtils.clamp(p, 0, 1);\n      pedir();\n    },\n    setPointer(x, y) {\n      // com movimento reduzido o olhar não segue o ponteiro: é deslocamento\n      // de câmera que a pessoa não pediu\n      if (opts.reduce) return;\n      alvo.px = x;\n      alvo.py = y;\n      pedir();\n    },\n    setColors(paper, ink) {\n      post.setColors(paper, ink);\n      pedir();\n    },\n    setPlanting(planting) {\n      replantar(planting);\n      pedir();\n    },\n    setTrail(v) {\n      // movimento reduzido fica sem rastro: é a mesma regra de quando a cena nasce\n      if (opts.reduce) return;\n      post.setTrail(v);\n      pedir();\n    },\n    setGrain(v) {\n      post.setGrain(v);\n      pedir();\n    },\n    setRunning(on) {\n      if (on === visivel) return;\n      visivel = on;\n      if (on) {\n        post.resetTrail();\n        pedir();\n      } else if (raf) {\n        cancelAnimationFrame(raf);\n        raf = 0;\n      }\n    },\n    dispose() {\n      visivel = false;\n      if (raf) cancelAnimationFrame(raf);\n      ro.disconnect();\n      window.removeEventListener(\"resize\", resize);\n      // os clones só apontam para o que é das variantes (decisão 1)\n      variantes.forEach(disposeTree);\n      marcos.forEach((m) => m && disposeTree(m));\n      chaoGeo.dispose();\n      chaoMat.dispose();\n      sombraGeo.dispose();\n      sombraMat.dispose();\n      sombraTex.dispose();\n      post.dispose();\n      releaseRenderer(renderer);\n    },\n  };\n}\n",
      "type": "registry:component",
      "target": "~/components/fog-garden/garden-scene.ts"
    },
    {
      "path": "registry/visant/blocks/fog-garden/FogGarden.tsx",
      "content": "\"use client\";\n\n/**\n * FogGarden — a caminhada por um jardim na névoa, presa ao scroll.\n *\n * Colhido da rota de jardim de um site de cliente (2026-10). A seção é alta (uma\n * janela de scroll por parada) e o palco fica preso na tela: rolar leva a\n * câmera pela trilha, e cada parada de texto sai da névoa, fica, e volta para\n * ela. Nenhuma cor própria — a cena é cinza até o duotone do `fog-post` pintar\n * com `--background` e `--foreground`.\n *\n * Decisões que sobrevivem à colheita:\n *\n * 1. **Mola antes de qualquer `useTransform`.** `useScroll` direto num\n *    `useTransform` de opacidade é acelerado pelo ScrollTimeline nativo, que\n *    erra a faixa dentro de `position: sticky` — as paradas acendiam na hora\n *    errada. Passar pela `useSpring` tira a cadeia do caminho nativo e ainda dá\n *    passo de caminhada à câmera, em vez do tranco da roda do mouse.\n * 2. **Texto em `mix-blend-difference`.** Sobre a névoa ele lê como tinta;\n *    sobre uma copa escura, em negativo. Nenhuma posição da trilha deixa o\n *    texto ilegível, e ninguém precisa de caixa de vidro atrás da frase. A cor\n *    da camada é o tom MAIS CLARO do duotone (papel no claro, tinta no escuro):\n *    `difference` com cor escura sobre fundo escuro dá preto no preto, e o\n *    texto sumia no dark mode.\n * 3. **Cada parada tem a sua janela.** Parada `i` de `n` acende em torno de\n *    `(i + 0.5) / n`. A primeira já está acesa no carregamento (a seção não abre\n *    vazia) e a última fica — a caminhada termina num lugar, não no nada.\n *    `keep` faz qualquer uma ficar.\n * 4. **Só clica o que se vê.** O conteúdo das paradas apagadas continua no DOM\n *    (leitor de tela lê a sequência inteira), mas `pointer-events` só liga com\n *    a parada acima de 60% de opacidade: link invisível não rouba clique.\n * 5. **Clareiras saem das paradas.** Sem `clearings`, cada parada a partir da\n *    segunda ganha uma clareira um pouco à frente do seu centro — o texto\n *    acende quando a árvore protagonista entra no quadro.\n * 6. **O WebGL só desce perto da tela, e para fora dela.** Mesmo trato do\n *    `fog-tree`: `import()` a 400px da viewport, laço parado fora da tela e com\n *    a aba escondida, modo leve no toque e em tela pequena.\n * 7. **Prop não refaz a cena.** `seed`, `density`, `trail` e `grain` chegam por\n *    método: refazer gerava sete árvores por tique de um slider (6s de thread\n *    presa num arrasto de 1s) e, pior, o `forceContextLoss` do descarte matava o\n *    contexto do MESMO canvas, e a cena seguinte nascia morta. Por isso também o\n *    canvas tem `key`: a única troca que refaz a cena (`reduce`) ganha canvas novo.\n *\n * Requer `three`, `@dgreenheck/ez-tree` e `framer-motion`.\n */\n\nimport * as React from \"react\";\nimport {\n  motion,\n  useReducedMotion,\n  useScroll,\n  useSpring,\n  useTransform,\n  type MotionValue,\n} from \"framer-motion\";\n\nimport { cn } from \"@/lib/utils\";\nimport { onThemeChange, resolveCssColor, type RGB } from \"@/lib/css-color\";\nimport type { GardenLandmark, GardenScene } from \"./garden-scene\";\n\nexport type { GardenLandmark };\n\nexport interface FogGardenStop {\n  id: string;\n  content: React.ReactNode;\n  /** Onde o bloco encosta na horizontal. */\n  align?: \"start\" | \"center\" | \"end\";\n  /** Fica aceso depois da sua janela, em vez de voltar para a névoa. */\n  keep?: boolean;\n}\n\nexport interface FogGardenProps extends Omit<React.HTMLAttributes<HTMLElement>, \"children\"> {\n  stops: FogGardenStop[];\n  /** Comprimento de scroll de cada parada. A seção mede `n × heightPerStop`. */\n  heightPerStop?: string;\n  /**\n   * Altura do palco preso. Com `container`, o padrão é a altura do container\n   * (medida), porque `svh` é da janela e não do scroller.\n   */\n  viewport?: string;\n  /**\n   * Posições de plantio ao longo da trilha. O modo leve usa 60% disso.\n   * @min 8\n   * @max 140\n   * @step 1\n   */\n  density?: number;\n  /** Pontos 0..1 da trilha com clareira. Padrão: derivados das paradas. */\n  clearings?: number[];\n  /**\n   * Objeto para cada clareira (ver `GardenLandmark`). Lido uma vez, quando a\n   * cena nasce: uma função inline mudaria a cada render e replantaria o jardim.\n   */\n  landmark?: GardenLandmark;\n  /** Contador \"01 / 05\" no canto. */\n  counter?: boolean;\n  /**\n   * Semente do plantio. Mesma semente, mesmo jardim.\n   * @min 1\n   * @max 9999\n   * @step 1\n   */\n  seed?: number;\n  paper?: string;\n  ink?: string;\n  /**\n   * Rastro de longa exposição. 0 desliga.\n   * @min 0\n   * @max 0.98\n   * @step 0.01\n   */\n  trail?: number;\n  /**\n   * Grão de película.\n   * @min 0\n   * @max 0.2\n   * @step 0.01\n   */\n  grain?: number;\n  /**\n   * Scroller que não é a janela (um painel com `overflow: auto`). O progresso\n   * passa a ser medido nele.\n   */\n  container?: React.RefObject<HTMLElement | null>;\n}\n\nconst ALIGN = {\n  start: \"items-start text-left\",\n  center: \"items-center text-center\",\n  end: \"items-end text-right\",\n} as const;\n\nconst pad = (n: number) => String(n).padStart(2, \"0\");\n\n/** Luminância relativa aproximada — só para escolher o tom claro do par. */\nconst luma = ([r, g, b]: RGB) => 0.2126 * r + 0.7152 * g + 0.0722 * b;\nconst toCss = ([r, g, b]: RGB) =>\n  `rgb(${Math.round(r * 255)} ${Math.round(g * 255)} ${Math.round(b * 255)})`;\n\nconst prefersLight = () =>\n  window.matchMedia(\"(pointer: coarse)\").matches || window.innerWidth < 768;\n\nexport function FogGarden({\n  stops,\n  heightPerStop = \"120vh\",\n  viewport,\n  density = 78,\n  clearings,\n  landmark,\n  counter = true,\n  seed = 2026,\n  paper = \"var(--background)\",\n  ink = \"var(--foreground)\",\n  trail = 0.84,\n  grain = 0.05,\n  container,\n  className,\n  style,\n  ...props\n}: FogGardenProps) {\n  const rootRef = React.useRef<HTMLElement>(null);\n  const canvasRef = React.useRef<HTMLCanvasElement>(null);\n  const sceneRef = React.useRef<GardenScene | null>(null);\n  const reduce = useReducedMotion() ?? false;\n  const n = stops.length;\n\n  const { scrollYProgress } = useScroll({\n    target: rootRef,\n    container,\n    offset: [\"start start\", \"end end\"],\n  });\n  // decisão 1 — passo de caminhada: mais mole que a mola do `fog-tree`\n  const prog = useSpring(scrollYProgress, { stiffness: 70, damping: 24, restDelta: 0.0002 });\n\n  React.useEffect(() => {\n    sceneRef.current?.setProgress(prog.get());\n    return prog.on(\"change\", (v) => sceneRef.current?.setProgress(v));\n  }, [prog]);\n\n  // ── Palco: altura da janela, ou do container medido ──────────────────────\n  const [measured, setMeasured] = React.useState<string | null>(null);\n  React.useEffect(() => {\n    const el = container?.current;\n    if (!el || viewport) return;\n    const ro = new ResizeObserver(() => setMeasured(`${el.clientHeight}px`));\n    ro.observe(el);\n    return () => ro.disconnect();\n  }, [container, viewport]);\n  const stageHeight = viewport ?? measured ?? \"100svh\";\n\n  // ── Clareiras (decisão 5). Chave em string: array novo a cada render do pai\n  //    não pode replantar o jardim. ───────────────────────────────────────────\n  const clearingKey = clearings\n    ? clearings.join(\",\")\n    : Array.from({ length: Math.max(0, n - 1) }, (_, j) =>\n        Math.min(0.97, (j + 1.5) / n + 0.02).toFixed(4),\n      ).join(\",\");\n\n  const landmarkRef = React.useRef(landmark);\n  landmarkRef.current = landmark;\n\n  // ── Cores (decisão 2) ────────────────────────────────────────────────────\n  const applyColors = React.useCallback(() => {\n    const el = rootRef.current;\n    if (!el) return;\n    const p = resolveCssColor(paper, el);\n    const k = resolveCssColor(ink, el);\n    el.style.setProperty(\"--fog-garden-text\", toCss(luma(p) >= luma(k) ? p : k));\n    sceneRef.current?.setColors(p, k);\n  }, [paper, ink]);\n  const applyRef = React.useRef(applyColors);\n  applyRef.current = applyColors;\n\n  React.useEffect(() => {\n    applyColors();\n    const off = onThemeChange(applyColors);\n    const mq = window.matchMedia(\"(prefers-color-scheme: dark)\");\n    mq.addEventListener(\"change\", applyColors);\n    return () => {\n      off();\n      mq.removeEventListener(\"change\", applyColors);\n    };\n  }, [applyColors]);\n\n  // ── Parâmetros ao vivo (decisão 7). A cena nascendo lê o valor mais recente\n  //    por aqui; a que já existe recebe por método. ───────────────────────────\n  const clearingList = React.useMemo(\n    () => (clearingKey ? clearingKey.split(\",\").map(Number) : []),\n    [clearingKey],\n  );\n  const liveRef = React.useRef({ seed, density, clearings: clearingList, trail, grain });\n  liveRef.current = { seed, density, clearings: clearingList, trail, grain };\n\n  React.useEffect(() => {\n    sceneRef.current?.setPlanting({ seed, density, clearings: clearingList });\n  }, [seed, density, clearingList]);\n  React.useEffect(() => sceneRef.current?.setTrail(trail), [trail]);\n  React.useEffect(() => sceneRef.current?.setGrain(grain), [grain]);\n\n  // ── Ciclo de vida da cena (decisão 6) ────────────────────────────────────\n  React.useEffect(() => {\n    const canvas = canvasRef.current;\n    const root = rootRef.current;\n    if (!canvas || !root) return;\n    let alive = true;\n    let loading = false;\n    let near = false;\n\n    const running = () => near && document.visibilityState === \"visible\";\n    const sync = () => sceneRef.current?.setRunning(running());\n\n    const io = new IntersectionObserver(\n      ([e]) => {\n        near = !!e?.isIntersecting;\n        if (near && !sceneRef.current && !loading) {\n          loading = true;\n          import(\"./garden-scene\")\n            .then(({ createGardenScene }) => {\n              if (!alive) return;\n              const scene = createGardenScene(canvas, {\n                ...liveRef.current,\n                landmark: landmarkRef.current,\n                reduce,\n                light: prefersLight(),\n              });\n              sceneRef.current = scene;\n              if (!scene) return;\n              applyRef.current();\n              scene.setProgress(prog.get());\n              sync();\n            })\n            .catch(() => {});\n        }\n        sync();\n      },\n      // `root: null` mesmo com container: o IO observa a interseção com a\n      // janela, e o container está dentro dela — continua valendo.\n      { rootMargin: \"400px 0px\" },\n    );\n    io.observe(root);\n    document.addEventListener(\"visibilitychange\", sync);\n\n    // Olhar que segue o ponteiro: só com mouse. No toque não há ponteiro\n    // pairando, e o \"olhar\" pularia a cada toque de scroll.\n    const fine = window.matchMedia(\"(pointer: fine)\").matches;\n    const move = (e: PointerEvent) =>\n      sceneRef.current?.setPointer(\n        (e.clientX / window.innerWidth) * 2 - 1,\n        (e.clientY / window.innerHeight) * 2 - 1,\n      );\n    if (fine && !reduce) window.addEventListener(\"pointermove\", move, { passive: true });\n\n    return () => {\n      alive = false;\n      io.disconnect();\n      document.removeEventListener(\"visibilitychange\", sync);\n      window.removeEventListener(\"pointermove\", move);\n      sceneRef.current?.dispose();\n      sceneRef.current = null;\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [reduce]);\n\n  const counterText = useTransform(prog, (v) => pad(Math.min(n, Math.floor(v * n) + 1)));\n\n  if (!n) return null;\n\n  return (\n    <section\n      ref={rootRef}\n      className={cn(\"relative\", className)}\n      style={{ height: `calc(${n} * ${heightPerStop})`, background: paper, ...style }}\n      {...props}\n    >\n      <div className=\"sticky top-0 overflow-hidden\" style={{ height: stageHeight }}>\n        <canvas key={String(reduce)} ref={canvasRef} aria-hidden className=\"pointer-events-none absolute inset-0 block h-full w-full\" />\n\n        <div\n          className=\"pointer-events-none absolute inset-0 mix-blend-difference\"\n          style={{ color: \"var(--fog-garden-text, var(--background))\" }}\n        >\n          {stops.map((s, i) => (\n            <Stop key={s.id} stop={s} i={i} n={n} prog={prog} reduce={reduce} />\n          ))}\n\n          {counter && n > 1 && (\n            <div\n              aria-hidden\n              className=\"absolute bottom-6 left-6 flex items-center gap-3 text-[11px] uppercase tracking-[0.12em] md:bottom-8 md:left-10\"\n            >\n              <motion.span className=\"tabular-nums\">{counterText}</motion.span>\n              <span className=\"opacity-50\">/ {pad(n)}</span>\n            </div>\n          )}\n        </div>\n      </div>\n    </section>\n  );\n}\n\nfunction Stop({\n  stop,\n  i,\n  n,\n  prog,\n  reduce,\n}: {\n  stop: FogGardenStop;\n  i: number;\n  n: number;\n  prog: MotionValue<number>;\n  reduce: boolean;\n}) {\n  const c = (i + 0.5) / n;\n  const w = 0.5 / n;\n  const first = i === 0;\n  const stays = stop.keep || i === n - 1;\n\n  // decisão 3 — entra da névoa, fica, volta para ela\n  const range = [c - w, c - w * 0.35, c + w * 0.35, c + w];\n  const enter = first ? 1 : 0;\n  const leave = stays ? 1 : 0;\n  const opacity = useTransform(prog, range, [enter, 1, 1, leave]);\n  const fogBlur = reduce ? 0 : 14;\n  const filter = useTransform(\n    prog,\n    range,\n    [(1 - enter) * fogBlur, 0, 0, (1 - leave) * fogBlur].map((b) => `blur(${b}px)`),\n  );\n  const drift = reduce ? 0 : 40;\n  const y = useTransform(\n    prog,\n    [c - w, c, c + w],\n    [first ? 0 : drift, 0, stays ? 0 : -drift],\n  );\n  // decisão 4\n  const pointerEvents = useTransform(opacity, (o) => (o > 0.6 ? \"auto\" : \"none\"));\n\n  return (\n    <motion.div\n      style={{ opacity, filter, y }}\n      className={cn(\n        \"absolute inset-0 flex flex-col justify-center px-6 md:px-10 lg:px-16\",\n        ALIGN[stop.align ?? \"center\"],\n      )}\n    >\n      <motion.div\n        style={{ pointerEvents }}\n        className={cn(\"flex max-w-full flex-col\", ALIGN[stop.align ?? \"center\"])}\n      >\n        {stop.content}\n      </motion.div>\n    </motion.div>\n  );\n}\n\nexport default FogGarden;\n",
      "type": "registry:component",
      "target": "~/components/fog-garden/FogGarden.tsx"
    },
    {
      "path": "registry/visant/blocks/fog-garden/index.ts",
      "content": "export { FogGarden } from \"./FogGarden\";\nexport type { FogGardenProps, FogGardenStop, GardenLandmark } from \"./FogGarden\";\n",
      "type": "registry:component",
      "target": "~/components/fog-garden/index.ts"
    }
  ],
  "meta": {
    "uso": {
      "quando": "Storytelling longo de marca: caminhada 3D na névoa com paradas de texto presas ao scroll",
      "evite": "Uma imagem só de atmosfera: fog-tree; passos sem 3D, pinned-scene"
    }
  },
  "categories": [
    "conteudo",
    "3d",
    "webgl",
    "scroll",
    "sticky",
    "nevoa",
    "storytelling",
    "jardim"
  ],
  "type": "registry:block"
}