{
  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
  "name": "fog-hero",
  "title": "Fog Hero",
  "author": "Visant Labs <visantsupply@gmail.com>",
  "description": "Hero de tela cheia que abre uma clareira na névoa, troca uma playlist de vídeo P&B pela própria fumaça e sai em desfoque no scroll, com papel e tinta vindos dos tokens.",
  "dependencies": [
    "three@^0.170.0",
    "framer-motion"
  ],
  "devDependencies": [
    "@types/three@^0.170.0"
  ],
  "registryDependencies": [
    "utils",
    "@visant/css-color"
  ],
  "files": [
    {
      "path": "registry/visant/blocks/fog-hero/fog-hero.tsx",
      "content": "\"use client\";\n\nimport * as React from \"react\";\nimport * as THREE from \"three\";\nimport { motion, useReducedMotion, useScroll, useSpring, useTransform } from \"framer-motion\";\n\nimport { cn } from \"@/lib/utils\";\nimport { onThemeChange, resolveCssColor } from \"@/lib/css-color\";\nimport { fragmentShader, vertexShader } from \"./shader\";\nimport { FOG_HERO_PRESET, type FogHeroParams } from \"./params\";\n\n/**\n * Fog Hero — a dobra de abertura que nasce da névoa.\n *\n * Colhido da hero de um site de cliente (2026-10). Uma tela cheia de fumaça (fbm com domain\n * warp) abre uma clareira do centro, e pela borda da fumaça aparece uma\n * playlist de vídeo em P&B, pintada de tinta sobre papel. O logo, se houver,\n * surge por um dissolve de ruído depois da clareira. Ao rolar, a dobra inteira\n * perde nitidez e some.\n *\n * Decisões que sobrevivem à colheita:\n *\n * 1. **Duas cores, ambas tokens.** `paper` e `ink` (padrão `--background` e\n *    `--foreground`) são resolvidas pelo navegador via `css-color` e relidas a\n *    cada troca de tema. O original tinha dois pares de hex, claro e escuro; o\n *    tema escuro agora é só a marca virando.\n * 2. **A cor vai crua para o shader.** O uniform é `Vector3`, não `THREE.Color`:\n *    o `Color` converte sRGB para linear e o `ShaderMaterial` não converte de\n *    volta, então a borda da hero sairia mais escura que o `bg-background` da\n *    página. Assim o papel do shader é o MESMO pixel do papel do site.\n * 3. **A troca de vídeo acontece no shader, pela névoa.** O próximo vídeo\n *    aparece através do mesmo ruído da fumaça (`uSwap`), e a borda da\n *    dissolução clareia. Cortar seco num `<video>` quebraria a ilusão de que é\n *    tudo a mesma matéria.\n * 4. **Para quando ninguém vê.** Fora da tela ou com a aba escondida o laço sai\n *    e o vídeo pausa. O relógio da hero só anda com ela rodando, então a\n *    abertura e a agenda da troca não \"pulam\" ao voltar.\n * 5. **Movimento reduzido:** clareira já aberta, logo já assentado, fumaça e\n *    grão congelados, sem troca de vídeo (o primeiro fica parado no primeiro\n *    quadro). O rastro do cursor continua, porque é gesto de quem usa.\n *\n * **O `<h1>` é de quem consome.** O canvas é `aria-hidden`; a hero não sabe o\n * título da página. Ponha o título em `children` (visível) ou como\n * `<h1 className=\"sr-only\">` dentro dele — sem isso a página fica sem h1.\n *\n * Vídeo e logo de outro domínio precisam de CORS (`Access-Control-Allow-Origin`):\n * textura sem isso suja o canvas e o three recusa.\n *\n * Requer `three` e `framer-motion`.\n */\n\nexport interface FogHeroProps extends React.HTMLAttributes<HTMLElement> {\n  /** Playlist de vídeo. P&B por desenho: o shader lê só a luminância. Vazio = só névoa. */\n  videos?: string[];\n  /** Imagem com alpha (PNG/WebP) desenhada em tinta no centro. Opcional. */\n  logo?: string;\n  /** Cor do papel. Qualquer cor CSS ou `var(--token)`. */\n  paper?: string;\n  /** Cor da tinta (fumaça, vídeo, logo). Qualquer cor CSS ou `var(--token)`. */\n  ink?: string;\n  /** Ajuste parcial do preset aprovado (`FOG_HERO_PRESET`). */\n  params?: Partial<FogHeroParams>;\n  /** Intervalo entre trocas de vídeo, em ms. */\n  swapEvery?: number;\n  /** Duração da dissolução entre dois vídeos, em ms. Longa de propósito: é cena, não corte. */\n  swapDuration?: number;\n  /** Conteúdo acima do canvas (título, CTA). Ver a nota do `<h1>`. */\n  children?: React.ReactNode;\n}\n\nconst easeInOut = (x: number) => (x < 0.5 ? 4 * x * x * x : 1 - Math.pow(-2 * x + 2, 3) / 2);\nconst clamp = (x: number) => Math.min(1, Math.max(0, x));\n// O rastro do cursor é desenhado num canvas 2D pequeno: 256² basta para uma\n// mancha que vai ser borrada pelo ruído de qualquer jeito.\nconst TRAIL = 256;\n\nexport function FogHero({\n  videos = [],\n  logo,\n  paper = \"var(--background)\",\n  ink = \"var(--foreground)\",\n  params,\n  swapEvery = 9000,\n  swapDuration = 2800,\n  className,\n  children,\n  ...props\n}: FogHeroProps) {\n  const canvasRef = React.useRef<HTMLCanvasElement>(null);\n  const secRef = React.useRef<HTMLElement>(null);\n  const reduce = useReducedMotion() ?? false;\n\n  // O laço lê o que estiver nos refs no quadro atual: trocar `params` ou as\n  // cores não recria o renderer, só muda o próximo quadro.\n  const paramsRef = React.useRef<FogHeroParams>({ ...FOG_HERO_PRESET, ...params });\n  paramsRef.current = { ...FOG_HERO_PRESET, ...params };\n  const coresRef = React.useRef({ paper, ink });\n  coresRef.current = { paper, ink };\n  const swapRef = React.useRef({ every: swapEvery, duration: swapDuration });\n  swapRef.current = { every: swapEvery, duration: swapDuration };\n  const ressincRef = React.useRef<() => void>(() => {});\n\n  // Saída em névoa: ao rolar, a hero perde nitidez e some. A mola não é\n  // enfeite — ligado direto no `style`, o `useScroll` pode virar ScrollTimeline\n  // nativo, que mede o alcance do offset de outro jeito e terminava a saída\n  // antes da hora. Passando pela mola, o cálculo fica em JS e respeita o offset.\n  const { scrollYProgress } = useScroll({ target: secRef, offset: [\"start start\", \"end start\"] });\n  const saida = useSpring(scrollYProgress, { stiffness: 120, damping: 30, restDelta: 0.0005 });\n  const opacity = useTransform(saida, [0, 0.85], [1, 0]);\n  // Desfoque e zoom são movimento; com movimento reduzido a saída é só opacidade.\n  const filter = useTransform(saida, [0, 0.85], reduce ? [\"none\", \"none\"] : [\"blur(0px)\", \"blur(16px)\"]);\n  const scale = useTransform(saida, [0, 1], reduce ? [1, 1] : [1, 1.06]);\n\n  const playlist = videos.join(\"\\n\");\n\n  React.useEffect(() => {\n    const canvas = canvasRef.current;\n    if (!canvas) return;\n    const fontes = playlist ? playlist.split(\"\\n\") : [];\n\n    const renderer = new THREE.WebGLRenderer({ canvas, antialias: false, powerPreference: \"high-performance\" });\n    // 1.5 de teto: tela cheia de fbm em 3× de densidade custa o triplo e o olho\n    // não vê diferença numa imagem que é névoa e grão por definição.\n    renderer.setPixelRatio(Math.min(devicePixelRatio, 1.5));\n\n    const U = <T,>(value: T) => ({ value });\n    const uniforms = {\n      uVideo: U<THREE.Texture | null>(null),\n      uVideoB: U<THREE.Texture | null>(null),\n      uSwap: U(0),\n      uLogo: U<THREE.Texture | null>(null),\n      uLogoOn: U(0),\n      uTrail: U<THREE.Texture | null>(null),\n      uRes: U(new THREE.Vector2()),\n      uVideoRes: U(new THREE.Vector2(16, 9)),\n      uVideoResB: U(new THREE.Vector2(16, 9)),\n      uLogoRes: U(new THREE.Vector2(1, 1)),\n      uTime: U(0),\n      uIntro: U(reduce ? 1 : 0),\n      uLogoIn: U(reduce ? 1 : 0),\n      uScroll: U(0),\n      uVideoReady: U(0),\n      uPaper: U(new THREE.Vector3()),\n      uInk: U(new THREE.Vector3()),\n      uGrain: U(0), uGrainSize: U(1), uGrainFps: U(24), uSoft: U(0), uSpray: U(0),\n      uFogOpacity: U(1), uSmokeLift: U(0), uContrast: U(1), uHaze: U(0), uClear: U(0.9),\n      uCenter: U(0.8), uScale: U(1), uSpeed: U(1), uWarp: U(0.7), uDetail: U(0.06),\n      uPhoto: U(0.7), uInvert: U(0), uFlipY: U(1), uVideoZoom: U(1), uVideoY: U(0), uVignette: U(0.15),\n      uLogoSize: U(0.3), uLogoBleed: U(0.006), uCursor: U(0.5),\n    };\n\n    // ── Mídia ───────────────────────────────────────────────────────────────\n    const els = fontes.map((src, i) => {\n      const v = document.createElement(\"video\");\n      v.crossOrigin = \"anonymous\";\n      v.muted = true;\n      v.loop = true;\n      // Sem `playsInline` o iOS abre o vídeo em tela cheia no primeiro play.\n      v.playsInline = true;\n      // Só o primeiro baixa inteiro; os outros esperam a vez com metadata.\n      v.preload = i === 0 ? \"auto\" : \"metadata\";\n      v.src = src;\n      return v;\n    });\n    const texs = els.map((v) => new THREE.VideoTexture(v));\n    const resDe = (i: number, alvo: THREE.Vector2) => {\n      const v = els[i];\n      if (v?.videoWidth) alvo.set(v.videoWidth, v.videoHeight);\n    };\n    els.forEach((v, i) =>\n      v.addEventListener(\"loadedmetadata\", () => {\n        if (i === atual) resDe(i, uniforms.uVideoRes.value);\n        if (i === proxima) resDe(i, uniforms.uVideoResB.value);\n      }),\n    );\n    if (els[0]) {\n      uniforms.uVideo.value = texs[0];\n      uniforms.uVideoB.value = texs[0];\n      const pronto = () => {\n        uniforms.uVideoReady.value = 1;\n        // Parado (movimento reduzido), o VideoTexture não recebe quadro novo\n        // sozinho: sem este empurrão a foto nunca sobe para a GPU.\n        texs[0].needsUpdate = true;\n      };\n      els[0].addEventListener(reduce ? \"loadeddata\" : \"playing\", pronto, { once: true });\n    }\n\n    let logoTex: THREE.Texture | null = null;\n    if (logo) {\n      logoTex = new THREE.TextureLoader().load(logo, (tex) => {\n        const img = tex.image as HTMLImageElement;\n        uniforms.uLogoRes.value.set(img.width, img.height);\n        uniforms.uLogo.value = tex;\n        uniforms.uLogoOn.value = 1;\n      });\n    }\n\n    // ── Rastro do cursor: canvas 2D que desbota a cada quadro ────────────────\n    // É máscara, não cor: preto = sem rastro, branco = rastro cheio. O shader só\n    // lê o canal R, por isso aqui pode ter preto e branco literais.\n    const trail = document.createElement(\"canvas\");\n    trail.width = trail.height = TRAIL;\n    const tctx = trail.getContext(\"2d\")!;\n    tctx.fillStyle = \"rgb(0 0 0)\";\n    tctx.fillRect(0, 0, TRAIL, TRAIL);\n    const trailTex = new THREE.CanvasTexture(trail);\n    uniforms.uTrail.value = trailTex;\n    const pointer = { x: -1, y: -1, px: -1, py: -1 };\n    const onMove = (e: PointerEvent) => {\n      const r = canvas.getBoundingClientRect();\n      pointer.x = ((e.clientX - r.left) / r.width) * TRAIL;\n      pointer.y = ((e.clientY - r.top) / r.height) * TRAIL;\n    };\n    // Na janela, não no canvas: o `children` fica por cima e engoliria o evento.\n    window.addEventListener(\"pointermove\", onMove, { passive: true });\n\n    const material = new THREE.ShaderMaterial({ uniforms, vertexShader, fragmentShader });\n    const geometry = new THREE.PlaneGeometry(2, 2);\n    const scene = new THREE.Scene();\n    scene.add(new THREE.Mesh(geometry, material));\n    const camera = new THREE.Camera();\n\n    const resize = () => {\n      renderer.setSize(canvas.clientWidth, canvas.clientHeight, false);\n      renderer.getDrawingBufferSize(uniforms.uRes.value);\n    };\n    const ro = new ResizeObserver(resize);\n    ro.observe(canvas);\n    resize();\n\n    // ── Cor: tokens resolvidos, com transição suave na troca de tema ─────────\n    const alvo = { paper: new THREE.Vector3(), ink: new THREE.Vector3() };\n    const sincCores = () => {\n      const el = secRef.current ?? document.documentElement;\n      alvo.paper.fromArray(resolveCssColor(coresRef.current.paper, el));\n      alvo.ink.fromArray(resolveCssColor(coresRef.current.ink, el));\n    };\n    sincCores();\n    uniforms.uPaper.value.copy(alvo.paper);\n    uniforms.uInk.value.copy(alvo.ink);\n    ressincRef.current = sincCores;\n    const pararTema = onThemeChange(sincCores);\n\n    // ── Agenda e relógio ─────────────────────────────────────────────────────\n    let atual = 0;\n    let proxima = -1;\n    let trocaInicio = -1; // em segundos do relógio da hero\n    let ultimaTroca = 0;\n    let s = 0;\n    let ultimoQuadro = -1;\n\n    const quadro = (agora: number) => {\n      // dt com teto: depois de uma pausa o relógio retoma de onde parou em vez\n      // de saltar o tempo que a hero ficou fora da tela.\n      const dt = ultimoQuadro < 0 ? 0 : Math.min(0.25, (agora - ultimoQuadro) / 1000);\n      ultimoQuadro = agora;\n      s += dt;\n      const p = paramsRef.current;\n      const u = uniforms;\n      // Movimento reduzido: tempo fixo num ponto qualquer da deriva (o t = 0\n      // do ruído tem um padrão simétrico que denuncia a origem).\n      u.uTime.value = reduce ? 12 : s;\n\n      const { every, duration } = swapRef.current;\n      if (!reduce && els.length > 1 && trocaInicio < 0 && (s - ultimaTroca) * 1000 > every) {\n        proxima = (atual + 1) % els.length;\n        els[proxima].currentTime = 0;\n        els[proxima].play().catch(() => {});\n        u.uVideoB.value = texs[proxima];\n        resDe(proxima, u.uVideoResB.value);\n        trocaInicio = s;\n      }\n      if (trocaInicio >= 0) {\n        const k = clamp(((s - trocaInicio) * 1000) / Math.max(1, duration));\n        u.uSwap.value = easeInOut(k);\n        if (k >= 1) {\n          els[atual].pause();\n          atual = proxima;\n          proxima = -1;\n          u.uVideo.value = texs[atual];\n          u.uVideoRes.value.copy(u.uVideoResB.value);\n          u.uSwap.value = 0;\n          trocaInicio = -1;\n          ultimaTroca = s;\n        }\n      }\n      if (!reduce) {\n        const d = p.introDur;\n        u.uIntro.value = easeInOut(clamp((s - 0.5) / d));\n        u.uLogoIn.value = easeInOut(clamp((s - 0.5 - d * 0.47) / (d * 0.56)));\n      }\n      u.uScroll.value = p.scrollClose ? easeInOut(clamp(saida.get())) : 0;\n\n      // Troca de tema em ~0.5s, não num corte: o papel do site muda por CSS\n      // num quadro, e a hero acompanhando devagar lê como névoa assentando.\n      u.uPaper.value.lerp(alvo.paper, 0.08);\n      u.uInk.value.lerp(alvo.ink, 0.08);\n\n      u.uGrain.value = p.grain; u.uGrainSize.value = p.grainSize;\n      u.uGrainFps.value = reduce ? 0 : p.grainFps;\n      u.uSoft.value = p.soft; u.uSpray.value = p.spray; u.uFogOpacity.value = p.fogOpacity;\n      u.uSmokeLift.value = p.smokeLift; u.uContrast.value = p.contrast; u.uHaze.value = p.haze;\n      u.uClear.value = p.clear; u.uCenter.value = p.center; u.uScale.value = p.scale;\n      u.uSpeed.value = p.speed; u.uWarp.value = p.warp; u.uDetail.value = p.detail;\n      u.uPhoto.value = p.photo; u.uInvert.value = p.invertVideo ? 1 : 0; u.uFlipY.value = p.flipY ? 1 : 0;\n      u.uVideoZoom.value = p.videoZoom; u.uVideoY.value = p.videoY; u.uVignette.value = p.vignette;\n      u.uLogoSize.value = p.logoSize; u.uLogoBleed.value = p.logoBleed; u.uCursor.value = p.cursor;\n\n      tctx.fillStyle = `rgba(0,0,0,${p.trailFade})`;\n      tctx.fillRect(0, 0, TRAIL, TRAIL);\n      if (pointer.x >= 0) {\n        const vel = pointer.px < 0 ? 0 : Math.hypot(pointer.x - pointer.px, pointer.y - pointer.py);\n        const rad = 18 + Math.min(vel, 30) * 1.2;\n        const grd = tctx.createRadialGradient(pointer.x, pointer.y, 0, pointer.x, pointer.y, rad);\n        grd.addColorStop(0, `rgba(255,255,255,${0.12 + Math.min(vel, 30) * 0.012})`);\n        grd.addColorStop(1, \"rgba(255,255,255,0)\");\n        tctx.fillStyle = grd;\n        tctx.beginPath();\n        tctx.arc(pointer.x, pointer.y, rad, 0, Math.PI * 2);\n        tctx.fill();\n        pointer.px = pointer.x;\n        pointer.py = pointer.y;\n      }\n      trailTex.needsUpdate = true;\n\n      renderer.render(scene, camera);\n    };\n\n    // ── Rodar só quando visível ──────────────────────────────────────────────\n    let naTela = true;\n    let rodando = false;\n    const aplicar = () => {\n      const deve = naTela && !document.hidden;\n      if (deve === rodando) return;\n      rodando = deve;\n      if (deve) {\n        ultimoQuadro = -1;\n        renderer.setAnimationLoop(quadro);\n        if (!reduce) {\n          els[atual]?.play().catch(() => {});\n          if (proxima >= 0) els[proxima].play().catch(() => {});\n        }\n      } else {\n        renderer.setAnimationLoop(null);\n        els.forEach((v) => v.pause());\n      }\n    };\n    const io = new IntersectionObserver(([e]) => {\n      naTela = e.isIntersecting;\n      aplicar();\n    });\n    io.observe(canvas);\n    document.addEventListener(\"visibilitychange\", aplicar);\n    aplicar();\n\n    return () => {\n      renderer.setAnimationLoop(null);\n      io.disconnect();\n      ro.disconnect();\n      pararTema();\n      ressincRef.current = () => {};\n      document.removeEventListener(\"visibilitychange\", aplicar);\n      window.removeEventListener(\"pointermove\", onMove);\n      // Soltar o src é o que libera o decodificador; só `pause()` deixa o\n      // buffer do vídeo preso até o GC decidir.\n      els.forEach((v) => {\n        v.pause();\n        v.removeAttribute(\"src\");\n        v.load();\n      });\n      [...texs, logoTex, trailTex].forEach((tex) => tex?.dispose());\n      material.dispose();\n      geometry.dispose();\n      renderer.dispose();\n    };\n    // `saida` é estável (motion value); `reduce` muda raramente e pede cena nova.\n  }, [playlist, logo, reduce, saida]);\n\n  // Cor trocada por prop (não por tema) também precisa reler os tokens.\n  React.useEffect(() => {\n    ressincRef.current();\n  }, [paper, ink]);\n\n  return (\n    <section\n      ref={secRef}\n      className={cn(\"relative h-svh overflow-hidden bg-background\", className)}\n      {...props}\n    >\n      <motion.div className=\"h-full w-full\" style={{ opacity, filter, scale }}>\n        <canvas ref={canvasRef} aria-hidden=\"true\" className=\"block h-full w-full\" />\n      </motion.div>\n      {children ? <div className=\"absolute inset-0 z-10\">{children}</div> : null}\n    </section>\n  );\n}\n",
      "type": "registry:component",
      "target": "~/components/fog-hero/fog-hero.tsx"
    },
    {
      "path": "registry/visant/blocks/fog-hero/shader.ts",
      "content": "/**\n * Shader da hero \"noir dissolve fog\" (protótipo de cliente, 2026-10).\n *\n * Só duas cores entram aqui, `uPaper` e `uInk`, e as duas vêm dos tokens da\n * marca resolvidos no navegador. Todo o resto é mistura entre elas: a fumaça é\n * tinta, a clareira é papel, o vídeo vira luminância e é pintado de tinta sobre\n * papel. Por isso a hero troca de tema sem uma linha de cor no GLSL — os únicos\n * literais são 0 e 1 de matemática.\n *\n * O vídeo é lido só no canal R: a hero é P&B por desenho, e a luminância de um\n * canal basta para virar mancha de tinta.\n */\nexport const fragmentShader = /* glsl */ `\nprecision highp float;\nuniform sampler2D uVideo, uVideoB, uLogo, uTrail;\nuniform vec2 uRes, uVideoRes, uVideoResB, uLogoRes;\nuniform float uTime, uIntro, uLogoIn, uScroll, uVideoReady, uSwap, uLogoOn;\nuniform vec3 uPaper, uInk;\nuniform float uGrain, uGrainSize, uGrainFps, uSoft, uSpray, uFogOpacity, uSmokeLift;\nuniform float uContrast, uHaze, uClear, uCenter, uScale, uSpeed, uWarp, uDetail;\nuniform float uPhoto, uInvert, uFlipY, uVideoZoom, uVideoY, uVignette, uLogoSize, uLogoBleed, uCursor;\nvarying vec2 vUv;\n\n// Simplex 2D (Ashima Arts / Stefan Gustavson, MIT)\nvec3 permute(vec3 x){ return mod(((x*34.0)+1.0)*x, 289.0); }\nfloat snoise(vec2 v){\n  const vec4 C = vec4(0.211324865405187, 0.366025403784439, -0.577350269189626, 0.024390243902439);\n  vec2 i = floor(v + dot(v, C.yy));\n  vec2 x0 = v - i + dot(i, C.xx);\n  vec2 i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);\n  vec4 x12 = x0.xyxy + C.xxzz; x12.xy -= i1;\n  i = mod(i, 289.0);\n  vec3 p = permute(permute(i.y + vec3(0.0, i1.y, 1.0)) + i.x + vec3(0.0, i1.x, 1.0));\n  vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);\n  m = m*m; m = m*m;\n  vec3 x = 2.0 * fract(p * C.www) - 1.0;\n  vec3 h = abs(x) - 0.5;\n  vec3 ox = floor(x + 0.5);\n  vec3 a0 = x - ox;\n  m *= 1.79284291400159 - 0.85373472095314 * (a0*a0 + h*h);\n  vec3 g;\n  g.x = a0.x * x0.x + h.x * x0.y;\n  g.yz = a0.yz * x12.xz + h.yz * x12.yw;\n  return 130.0 * dot(m, g);\n}\nfloat fbm(vec2 p){\n  float s = 0.0, a = 0.5;\n  mat2 m = mat2(1.6, 1.2, -1.2, 1.6);\n  for (int i = 0; i < 5; i++) { s += a * snoise(p); p = m * p; a *= 0.5; }\n  return s;\n}\nfloat fbm3(vec2 p){\n  float s = 0.0, a = 0.5;\n  mat2 m = mat2(1.6, 1.2, -1.2, 1.6);\n  for (int i = 0; i < 3; i++) { s += a * snoise(p); p = m * p; a *= 0.5; }\n  return s;\n}\n// hash12 (Dave Hoskins, sem sin: não gera listras)\nfloat hash(vec2 p){ vec3 p3 = fract(vec3(p.xyx) * 0.1031); p3 += dot(p3, p3.yzx + 33.33); return fract((p3.x + p3.y) * p3.z); }\n\nvec2 cover(vec2 uv, vec2 res, vec2 tex){\n  float rs = res.x / res.y, rt = tex.x / tex.y;\n  vec2 s = rs > rt ? vec2(1.0, rt / rs) : vec2(rs / rt, 1.0);\n  return (uv - 0.5) * s + 0.5;\n}\n\nvoid main(){\n  vec2 uv = vUv;\n  vec2 p = (uv - 0.5) * vec2(uRes.x / uRes.y, 1.0);\n  float t = uTime * 0.035 * uSpeed;\n  float tr = texture2D(uTrail, uv).r * uCursor * 2.0;\n\n  // Fumaça: fbm com domain warp, empurrada pelo rastro do cursor\n  vec2 q = vec2(fbm3(p * 0.7 * uScale + vec2(0.0, t)), fbm3(p * 0.7 * uScale + vec2(5.2, -t)));\n  vec2 wp = p * uScale + q * uWarp + vec2(t * 1.4, t * 0.5) + tr * 0.25;\n  float f = fbm3(wp) * 0.5 + 0.5 + snoise(wp * 3.0 - t) * uDetail;\n\n  // Abertura: clareira cresce do centro (intro) e fecha de novo (scroll)\n  float open = uIntro * (1.0 - uScroll);\n  float r = length(p * vec2(0.75, 1.0));\n  float v = f + r * uCenter * open - tr * 0.5;\n  float th = mix(-0.3, uClear, open);\n\n  // Grão por célula (tamanho e fps ajustáveis)\n  vec2 gp = floor(gl_FragCoord.xy / uGrainSize);\n  float n = hash(gp + mod(floor(uTime * uGrainFps), 64.0) * 37.0);\n\n  // Borda: pontilhado (spray) ou degradê liso\n  float fog = smoothstep(th - uSoft, th + uSoft, v + (n - 0.5) * uSoft * uSpray);\n  fog *= mix(1.0, uFogOpacity, open);\n\n  float mott = fbm3(wp * 1.6 - t) * 0.5 + 0.5;\n  float core = smoothstep(th, th + 0.45, v);\n  vec3 smoke = mix(mix(uPaper, uInk, 0.72), uInk, core) + (mott - 0.5) * 0.12 * (uInk - uPaper);\n  smoke = mix(smoke, uPaper, uSmokeLift * open);\n\n  // Foto: só na faixa perto da fumaça; centro fica limpo\n  // Cada vídeo com a própria proporção: a playlist pode misturar 16:9 e 9:16.\n  vec2 vuv = cover(uv, uRes, uVideoRes);\n  vec2 vuvB = cover(uv, uRes, uVideoResB);\n  if (uFlipY > 0.5) { vuv.y = 1.0 - vuv.y; vuvB.y = 1.0 - vuvB.y; }\n  vuv = (vuv - 0.5) / uVideoZoom + 0.5 + vec2(0.0, uVideoY);\n  vuvB = (vuvB - 0.5) / uVideoZoom + 0.5 + vec2(0.0, uVideoY);\n  // Troca de mídia em névoa: a próxima aparece através do mesmo ruído da fumaça,\n  // e a borda da dissolução clareia (mais névoa no meio da passagem).\n  // Fora do quadro do vídeo (zoom < 1) a leitura vira papel: sem isso o\n  // clamp-to-edge da textura estica a última linha em listras pela tela.\n  vec2 inA = step(vec2(0.0), vuv) * step(vuv, vec2(1.0));\n  vec2 inB = step(vec2(0.0), vuvB) * step(vuvB, vec2(1.0));\n  // Filmagem escura (vinheta de marca em fundo preto) entra invertida: o fundo\n  // vira névoa e a forma vira tinta. Inverte ANTES da borda, para o que fica\n  // fora do quadro continuar papel, e não virar tinta junto.\n  float sa = texture2D(uVideo, vuv).r;\n  float sb = texture2D(uVideoB, vuvB).r;\n  sa = mix(sa, 1.0 - sa, uInvert);\n  sb = mix(sb, 1.0 - sb, uInvert);\n  float La = mix(1.0, sa, inA.x * inA.y);\n  float Lb = mix(1.0, sb, inB.x * inB.y);\n  float nm = fbm3(p * 1.4 + vec2(t * 3.0, -t * 2.0)) * 0.5 + 0.5;\n  float troca = smoothstep(nm - 0.18, nm + 0.18, uSwap * 1.36 - 0.18);\n  float L = mix(La, Lb, troca);\n  L = mix(L, 1.0, (1.0 - abs(troca * 2.0 - 1.0)) * 0.55 * step(0.001, uSwap) * step(uSwap, 0.999));\n  float photoVis = smoothstep(th - 0.42, th - 0.06, v) * uVideoReady * uIntro;\n  vec3 paper = mix(uPaper, mix(uPaper, uInk, 1.0 - L), photoVis * uPhoto);\n\n  vec3 col = mix(paper, smoke, fog);\n\n  // Contraste e haze (levanta tudo pro papel)\n  vec3 mid = mix(uPaper, uInk, 0.5);\n  col = mix(mid, col, mix(1.0, uContrast, open));\n  col = mix(col, uPaper, uHaze * open);\n\n  // Logo: surge por dissolve de ruído com leve sangria de tinta\n  float lw = uRes.x < uRes.y ? uRes.x * min(uLogoSize * 2.1, 0.85) : min(uRes.x * uLogoSize, uRes.y * 0.8);\n  vec2 lsz = vec2(lw, lw * uLogoRes.y / uLogoRes.x);\n  vec2 lp = (gl_FragCoord.xy - uRes * 0.5) / lsz + 0.5;\n  lp += vec2(snoise(lp * 9.0 + t * 4.0), snoise(lp * 9.0 - t * 4.0)) * uLogoBleed * (1.0 - uLogoIn * 0.7);\n  float la = 0.0;\n  // Sem logo (uLogoOn = 0) o bloco inteiro vira no-op: a hero é só névoa.\n  if (uLogoOn > 0.5 && lp.x > 0.0 && lp.x < 1.0 && lp.y > 0.0 && lp.y < 1.0) la = texture2D(uLogo, lp).a;\n  float ln = fbm(lp * vec2(6.0, 1.5)) * 0.5 + 0.5;\n  la *= smoothstep(ln - 0.08, ln + 0.08, uLogoIn * 1.25 - 0.1);\n  col = mix(col, uInk, la);\n\n  // Grão + vinheta\n  col += (n - 0.5) * uGrain;\n  col = mix(col, uInk, uVignette * smoothstep(0.55, 1.15, r));\n\n  gl_FragColor = vec4(col, 1.0);\n}`\n\nexport const vertexShader = /* glsl */ `varying vec2 vUv; void main(){ vUv = uv; gl_Position = vec4(position.xy, 0.0, 1.0); }`\n",
      "type": "registry:component",
      "target": "~/components/fog-hero/shader.ts"
    },
    {
      "path": "registry/visant/blocks/fog-hero/params.ts",
      "content": "/**\n * O preset da hero de névoa, como foi aprovado num projeto de cliente (19/10/2026).\n *\n * Os valores de cena (fumaça, grão, clareira, logo) são os aprovados; os três de\n * enquadramento de vídeo foram neutralizados (ver abaixo).\n *\n * As cores NÃO moram aqui. No original havia quatro hex (papel e fumaça, claro e\n * escuro); na colheita viraram duas props do componente, `paper` e `ink`, que\n * por padrão leem `--background` e `--foreground`. O tema escuro deixa de ser um\n * segundo par de hex e passa a ser só o tema da marca virando.\n *\n * Mexa no preset por `params` (parcial) em vez de editar este arquivo: assim a\n * atualização do registry não pisa no ajuste do projeto.\n */\nexport const FOG_HERO_PRESET = {\n  /** Escurece as bordas para a tinta. 0 = sem vinheta. */\n  vignette: 0,\n  // Os três próximos são do MATERIAL, não da cena: o cliente aprovou com\n  // `flipY: true`, `videoZoom: 0.8` e `videoY: -0.07`, ajustados aos vídeos\n  // dela. Como padrão genérico eles viravam o vídeo de cabeça para baixo (o\n  // `VideoTexture` já chega na orientação certa) e afastavam o quadro além da\n  // borda. Para reproduzir o preset aprovado, passe os três por `params`.\n  /** Inverte a luminância do vídeo: use com filmagem escura (vinheta em fundo preto), que senão pinta tinta chapada. */\n  invertVideo: false,\n  /** Inverte o vídeo no eixo Y. Só para fonte gravada invertida. */\n  flipY: false,\n  /** < 1 afasta o vídeo (a sobra vira papel), > 1 aproxima. */\n  videoZoom: 1,\n  /** Desloca o enquadramento do vídeo na vertical (fração da altura). */\n  videoY: 0,\n  /** Largura do logo como fração da largura da tela (desktop). */\n  logoSize: 0.23,\n  /** Sangria de tinta no contorno do logo enquanto ele surge. */\n  logoBleed: 0,\n  /** Quanto o rastro do cursor empurra a fumaça. */\n  cursor: 0.15,\n  /** Quanto o rastro desbota por quadro (0..1). Maior = rastro mais curto. */\n  trailFade: 0.07,\n  /** Segundos da abertura da clareira. */\n  introDur: 2.5,\n  /** A fumaça fecha de novo conforme a hero sai pelo topo. */\n  scrollClose: false,\n  /** Intensidade do grão. */\n  grain: 0.025,\n  /** Tamanho da célula de grão em px do buffer. */\n  grainSize: 2.5,\n  /** Quadros por segundo do grão. 24–30 lê como película; 60 lê como chiado. */\n  grainFps: 30,\n  /** Pontilhado na borda da fumaça (spray). 0 = degradê liso. */\n  spray: 0.25,\n  /** Largura da borda da fumaça. */\n  soft: 0.8,\n  /** Opacidade da fumaça com a clareira aberta. */\n  fogOpacity: 1,\n  /** Clareia o miolo da fumaça para o papel. */\n  smokeLift: 0.4,\n  /** Contraste final (1 = neutro). */\n  contrast: 0.81,\n  /** Véu de papel por cima de tudo. */\n  haze: 0.25,\n  /** Raio da clareira aberta. */\n  clear: 0.65,\n  /** Quanto o centro empurra a fumaça para fora. */\n  center: 0.75,\n  /** Escala do ruído. Menor = manchas maiores. */\n  scale: 0.52,\n  /** Velocidade da deriva. */\n  speed: 0.7,\n  /** Domain warp: o quanto a fumaça se enrola. */\n  warp: 0.71,\n  /** Detalhe fino por cima do fbm. */\n  detail: 0.15,\n  /** Quanto do vídeo aparece na faixa perto da fumaça. */\n  photo: 0.7,\n};\n\nexport type FogHeroParams = typeof FOG_HERO_PRESET;\n",
      "type": "registry:component",
      "target": "~/components/fog-hero/params.ts"
    },
    {
      "path": "registry/visant/blocks/fog-hero/index.ts",
      "content": "export { FogHero, type FogHeroProps } from \"./fog-hero\";\nexport { FOG_HERO_PRESET, type FogHeroParams } from \"./params\";\n",
      "type": "registry:component",
      "target": "~/components/fog-hero/index.ts"
    }
  ],
  "meta": {
    "uso": {
      "quando": "Hero de tela cheia com névoa em shader, vídeo P&B e saída em desfoque, pra abertura de marca",
      "evite": "Hero leve ou de produto: section-intro com spring-dots; fundo abstrato sem vídeo, shader-neon"
    }
  },
  "categories": [
    "conteudo",
    "hero",
    "nevoa",
    "webgl",
    "shader",
    "video",
    "abertura",
    "grao"
  ],
  "type": "registry:block"
}