{
  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
  "name": "reels-rail",
  "title": "Reels Rail",
  "author": "Visant Labs <visantsupply@gmail.com>",
  "description": "O trilho de vídeo vertical: cartões 9:16 com encaixe, tocando o do meio ou o que está sob o cursor. Som opcional, um card por vez, e fora da tela pausa tudo.",
  "dependencies": [
    "lucide-react"
  ],
  "registryDependencies": [
    "utils",
    "https://visant-ui.vercel.app/r/rail.json",
    "@visant/rail"
  ],
  "files": [
    {
      "path": "registry/visant/ui/reels-rail.tsx",
      "content": "\"use client\";\n\nimport * as React from \"react\";\n\nimport { MoveHorizontal, Pause, Play, Volume2, VolumeX } from \"lucide-react\";\n\nimport { cn } from \"@/lib/utils\";\nimport { Rail } from \"@/components/ui/rail\";\n\n/**\n * ReelsRail — o trilho de vídeo vertical: 9:16 passando, o do meio tocando.\n *\n * ── O que vem do `@visant/rail`, e por que não foi reescrito ────────────────\n *\n * Rolagem com encaixe, setas que desabilitam nas pontas, sangria que não\n * desalinha o primeiro item, esmaecimento que segue a borda REAL da lista e —\n * o mais caro de todos — o tabindex rotativo, que faz o trilho inteiro ser UMA\n * parada de Tab em vez de uma por card. Tudo isso já está resolvido e testado\n * ali. Um carrossel de reels escrito do zero repetiria os mesmos quatro erros\n * que o trilho já documenta.\n *\n * O que esta peça acrescenta é a única coisa que o trilho não tem como saber:\n * **qual card está no meio**. É dessa pergunta que sai o comportamento inteiro\n * do formato — um toca, os vizinhos param.\n *\n * ── Por que a posição é medida, e não observada ────────────────────────────\n *\n * `IntersectionObserver` responde \"está visível?\", e num trilho de reels três\n * cards estão visíveis ao mesmo tempo. A pergunta certa é \"qual está mais perto\n * do centro do scroller?\", que é uma comparação de distância, não um limiar. Por\n * isso a medida é `getBoundingClientRect` contra o centro do scroller, num\n * `requestAnimationFrame` por evento de rolagem. É um laço sobre N cards a cada\n * quadro de scroll — barato, e o único jeito de o card ativo trocar exatamente\n * quando o olho diz que trocou.\n *\n * O `IntersectionObserver` continua existindo, mas pra outra pergunta: se o\n * TRILHO INTEIRO saiu da tela, tudo pausa. Vídeo tocando fora da viewport é\n * bateria e banda queimadas em pixel que ninguém vê.\n *\n * ── O som ──────────────────────────────────────────────────────────────────\n *\n * Começa mudo, sempre, e não por timidez: navegador nenhum deixa um vídeo com\n * áudio tocar sozinho, e um `play()` recusado deixaria o trilho inteiro parado\n * no primeiro quadro. O botão de som é o gesto do usuário que libera o áudio, e\n * ele vale para UM card por vez — dois reels tocando som juntos é o defeito\n * clássico de quem liga o som por card.\n *\n * ── O que a peça impõe no `<video>` do slot ────────────────────────────────\n *\n * `playsInline`, `loop` e `muted` são escritos no nó por JS. Não é invasão: sem\n * `playsInline` o iOS abre o vídeo em tela cheia no play e o trilho some da\n * página, e esses três atributos são exatamente os que se esquece. A mídia\n * continua entrando por slot — a peça não busca nada e não escolhe formato.\n *\n * Sob `prefers-reduced-motion` nada toca sozinho: o card ativo mostra o pôster e\n * o botão de play, e quem quiser vídeo pede vídeo.\n *\n * ── O laço infinito, e por que ele NÃO clona sem fim ───────────────────────\n *\n * Um mural de reels que acaba no sexto card não é o formato: o formato é a\n * fileira que nunca chega ao fim. A tentação é clonar itens conforme a rolagem\n * avança — e é assim que se vaza memória com vídeo, porque cada clone traz um\n * `<video>` novo, com buffer novo, que nunca é recolhido.\n *\n * Aqui o número de nós é **fixo e calculado uma vez**: mede-se a largura de um\n * conjunto (`passo` = distância do primeiro item de um conjunto ao primeiro do\n * seguinte) e repete-se o conjunto o mínimo de vezes pra sobrar um de cada lado\n * da vista — 3 na maioria das telas. Daí em diante ninguém cria nada: quando a\n * rolagem passa de `2 × passo`, subtrai-se `passo` do `scrollLeft`. Como os\n * conjuntos são idênticos, o salto é invisível, e a fileira anda pra sempre com\n * os mesmos nós. Os `<video>` duplicados apontam pra mesma URL, então o segundo\n * conjunto não baixa um byte a mais — e a regra de reprodução continua sendo a\n * mesma de sempre: **um** card toca, o do meio, e todos os outros ficam\n * pausados no primeiro quadro.\n *\n * O encaixe (`scroll-snap`) sai enquanto o laço está ligado. Encaixe e deriva\n * contínua são dois donos da mesma rolagem: o navegador puxa de volta pro ponto\n * de encaixe a cada quadro e a fileira treme no lugar em vez de andar.\n *\n * O eco não é escondido do leitor de tela, e é decisão, não esquecimento: os\n * conjuntos repetidos são FUNCIONAIS (o card que está tocando pode ser um\n * deles, com os controles dele). `aria-hidden` no eco deixaria os botões do\n * vídeo que está tocando fora do alcance de quem usa teclado na maior parte do\n * tempo — trocar controle inalcançável por lista repetida é o pior dos dois.\n *\n * ── A deriva ───────────────────────────────────────────────────────────────\n *\n * A fileira anda sozinha, devagar, e freia quando o ponteiro entra ou o foco cai\n * dentro dela: quem foi olhar um card não quer que ele fuja. Freia e retoma em\n * rampa (~0,5s), nunca de uma vez: ligar e desligar a velocidade cheia é o que\n * fazia o trilho parecer preso a um motor. Para também com o trilho fora da tela\n * e sob `prefers-reduced-motion` — movimento perpétuo é exatamente o que essa\n * preferência existe pra desligar.\n *\n * ── Quando só cabe um card ─────────────────────────────────────────────────\n *\n * Com a vista menor que dois cards (`clientWidth < 1,8 × itemWidth`, o celular),\n * a deriva não tem o que mostrar: o card que toca passa a maior parte do tempo\n * cortado por uma das bordas, com o título pela metade. Aí o trilho para de andar\n * sozinho e volta o encaixe, no centro: um card inteiro por vez, com os vizinhos\n * aparecendo nas pontas. O laço continua: a emenda subtrai um conjunto inteiro, e\n * o card cai na mesma posição de encaixe.\n */\n\nexport interface ReelItem {\n  id: string;\n  /** A mídia, por slot. Um `<video>` com `poster` é o caso normal. */\n  media: React.ReactNode;\n  title?: React.ReactNode;\n  /** A linha miúda: autor, duração, cliente. */\n  meta?: React.ReactNode;\n  /** Vira link no título. Reel que leva a algum lugar precisa de âncora. */\n  href?: string;\n}\n\nexport interface ReelsRailProps extends React.HTMLAttributes<HTMLDivElement> {\n  items: ReelItem[];\n  /** Largura de cada card, em px. 9:16 em 260px dá ~462px de altura. */\n  itemWidth?: number;\n  /** Proporção do card, formato CSS. Reels é `\"9/16\"`; TikTok idem. */\n  ratio?: string;\n  gap?: number;\n  /** Sangra pra fora do container. Passe o mesmo respiro lateral do pai. */\n  bleed?: number | false;\n  fade?: boolean;\n  arrows?: boolean;\n  heading?: React.ReactNode;\n  hint?: React.ReactNode;\n  label?: string;\n  /** Mostra o botão de som no card ativo. Desligue em vídeo sem áudio. */\n  sound?: boolean;\n  /** O card do meio toca sozinho. Desligue e o play passa a ser sempre manual. */\n  autoPlay?: boolean;\n  /**\n   * A fileira dá a volta em vez de acabar. Ver a nota do cabeçalho.\n   *\n   * Precisa de itens suficientes pra encher a vista: com dois cards numa faixa\n   * larga, o conjunto repetido aparece na tela ao lado do original e a repetição\n   * fica óbvia. De 5 pra cima é confortável.\n   */\n  loop?: boolean;\n  /**\n   * Quem toca: o card do MEIO ou o card sob o cursor.\n   *\n   * `\"center\"` (padrão) é o formato de feed: a fileira decide, o dedo rola, o\n   * do meio toca — e funciona igual no celular, onde não existe hover.\n   *\n   * `\"hover\"` devolve a escolha ao cursor: nada toca até alguém apontar, e aí\n   * toca aquele. Combina com a deriva, que já para quando o ponteiro entra —\n   * apontar vira \"segura aí que eu quero ver esse\". Num aparelho sem cursor\n   * ele cai sozinho no `\"center\"`: um trilho onde nada nunca toca não é uma\n   * opção, é um defeito.\n   */\n  playOn?: \"center\" | \"hover\";\n  /** A fileira anda sozinha. Só faz sentido com `loop`. */\n  drift?: boolean;\n  /** Velocidade da deriva, em px por segundo. Acima de ~60 vira esteira. */\n  driftSpeed?: number;\n  /**\n   * Ícone discreto sobre o card do meio, dizendo que a fileira arrasta. Dá dois\n   * balanços ao nascer e some de vez no primeiro gesto da pessoa.\n   */\n  dragHint?: boolean;\n}\n\nexport function ReelsRail({\n  items,\n  itemWidth = 260,\n  ratio = \"9/16\",\n  gap = 16,\n  bleed = false,\n  fade = true,\n  arrows = true,\n  heading,\n  hint,\n  label = \"Vídeos\",\n  sound = true,\n  autoPlay = true,\n  playOn = \"center\",\n  loop = true,\n  drift = true,\n  dragHint = true,\n  driftSpeed = 26,\n  className,\n  ...props\n}: ReelsRailProps) {\n  const raizRef = React.useRef<HTMLDivElement>(null);\n  const [mexeu, setMexeu] = React.useState(false);\n  const [ativo, setAtivo] = React.useState(0);\n  const [naTela, setNaTela] = React.useState(true);\n  const [comSom, setComSom] = React.useState(false);\n  const [tocando, setTocando] = React.useState(false);\n  /**\n   * A vontade explícita da pessoa, e ela ganha do automático.\n   *\n   * `null` é \"ninguém mandou nada\" — aí vale a política (`autoPlay`, e nunca sob\n   * movimento reduzido). Sem este estado, o botão de pausa não funcionava com\n   * `autoPlay` ligado: pausar disparava o efeito de reprodução, que via\n   * \"autoPlay, card ativo, na tela\" e mandava tocar de novo no mesmo quadro.\n   * O botão parecia morto, e a causa era o próprio automático.\n   *\n   * Volta a `null` quando o card ativo troca: a decisão era sobre AQUELE vídeo.\n   */\n  const [manual, setManual] = React.useState<boolean | null>(null);\n\n  /**\n   * O card sob o cursor, e o aparelho que tem cursor.\n   *\n   * `any-hover: hover` e não `pointer: fine`: um laptop com tela sensível ao\n   * toque responde às duas coisas, e a pergunta aqui é \"existe um jeito de\n   * apontar sem tocar?\", não \"o ponteiro é preciso?\".\n   */\n  const [sobCursor, setSobCursor] = React.useState<number | null>(null);\n  const [temCursor, setTemCursor] = React.useState(true);\n  React.useEffect(() => {\n    const mq = window.matchMedia(\"(any-hover: hover)\");\n    const ler = () => setTemCursor(mq.matches);\n    ler();\n    mq.addEventListener(\"change\", ler);\n    return () => mq.removeEventListener(\"change\", ler);\n  }, []);\n\n  // Quem toca. No modo hover sem cursor, cai no do meio — ver a nota da prop.\n  const porHover = playOn === \"hover\" && temCursor;\n  const alvo = porHover ? sobCursor : ativo;\n\n  React.useEffect(() => setManual(null), [alvo]);\n\n  // Decidido uma vez, no cliente: o valor é usado dentro de efeitos que não\n  // devem depender de um `matchMedia` refeito a cada render.\n  const [reduzido, setReduzido] = React.useState(false);\n  React.useEffect(() => {\n    const mq = window.matchMedia(\"(prefers-reduced-motion: reduce)\");\n    const ler = () => setReduzido(mq.matches);\n    ler();\n    mq.addEventListener(\"change\", ler);\n    return () => mq.removeEventListener(\"change\", ler);\n  }, []);\n\n  /*\n   * O scroller é o `role=\"group\"` que o trilho desenha por dentro.\n   *\n   * Não existe prop pra recebê-lo, e criar uma obrigaria a mexer no trilho pra\n   * servir uma peça só. A busca é por papel ARIA e não por classe: o papel faz\n   * parte do contrato acessível do trilho — ele é o que anuncia a lista — então\n   * é a parte dele com menos chance de mudar de nome.\n   */\n  const scrollerDe = React.useCallback(\n    () => raizRef.current?.querySelector<HTMLElement>('[role=\"group\"]') ?? null,\n    [],\n  );\n\n  /** Qual card está mais perto do centro do scroller. Ver a nota do cabeçalho. */\n  React.useEffect(() => {\n    const scroller = scrollerDe();\n    if (!scroller) return;\n\n    /*\n     * O centro de cada card é medido uma vez por layout, em coordenadas de\n     * rolagem, e cada quadro de scroll só lê `scrollLeft`. Medir os N cards por\n     * `getBoundingClientRect` a cada quadro eram N leituras de caixa por quadro\n     * da deriva, que anda o tempo todo; no celular, com a CPU estrangulada, isso\n     * pesava. A divisão por `k` desfaz a escala de quem hospeda (um palco\n     * encolhido), porque `scrollLeft` vive em pixel de layout e a caixa não.\n     * O mapa refaz sozinho quando o número de cards muda (o laço) ou a caixa muda.\n     */\n    let centros: number[] = [];\n    const mapear = () => {\n      const caixa = scroller.getBoundingClientRect();\n      const k = scroller.offsetWidth ? caixa.width / scroller.offsetWidth : 1;\n      const base = scroller.scrollLeft;\n      centros = Array.from(scroller.children).map((filho) => {\n        const r = (filho as HTMLElement).getBoundingClientRect();\n        return (r.left - caixa.left + r.width / 2) / (k || 1) + base;\n      });\n    };\n\n    let pendente = 0;\n    const medir = () => {\n      pendente = 0;\n      if (centros.length !== scroller.children.length) mapear();\n      const centro = scroller.scrollLeft + scroller.offsetWidth / 2;\n      let melhor = 0;\n      let menor = Infinity;\n      centros.forEach((c, i) => {\n        const d = Math.abs(c - centro);\n        if (d < menor) {\n          menor = d;\n          melhor = i;\n        }\n      });\n      setAtivo(melhor);\n    };\n\n    const agendar = () => {\n      if (pendente) return;\n      pendente = requestAnimationFrame(medir);\n    };\n    const remapear = () => {\n      centros = [];\n      agendar();\n    };\n\n    medir();\n    scroller.addEventListener(\"scroll\", agendar, { passive: true });\n    const ro =\n      typeof ResizeObserver === \"undefined\" ? null : new ResizeObserver(remapear);\n    ro?.observe(scroller);\n    // O card que muda de largura sem o scroller mudar também desloca os centros.\n    const primeiro = scroller.firstElementChild;\n    if (ro && primeiro) ro.observe(primeiro);\n\n    return () => {\n      cancelAnimationFrame(pendente);\n      scroller.removeEventListener(\"scroll\", agendar);\n      ro?.disconnect();\n    };\n  }, [scrollerDe, items.length, itemWidth, gap, bleed]);\n\n  /*\n   * ── O laço ────────────────────────────────────────────────────────────────\n   *\n   * `copias` é quantas vezes a lista é repetida no DOM. Ele muda no máximo uma\n   * ou duas vezes (na medida inicial e quando a caixa muda de largura), e\n   * DEPOIS disso nada mais é criado — é o que separa este laço do carrossel que\n   * clona e vaza. Ver a nota do cabeçalho.\n   */\n  const [copias, setCopias] = React.useState(loop ? 3 : 1);\n  const passoRef = React.useRef(0);\n\n  /** A vista só comporta um card. Ver \"Quando só cabe um card\" no cabeçalho. */\n  const [umPorVez, setUmPorVez] = React.useState(false);\n  React.useEffect(() => {\n    const scroller = scrollerDe();\n    if (!scroller) return;\n    const ler = () => setUmPorVez(scroller.clientWidth < itemWidth * 1.8);\n    ler();\n    if (typeof ResizeObserver === \"undefined\") return;\n    const ro = new ResizeObserver(ler);\n    ro.observe(scroller);\n    return () => ro.disconnect();\n  }, [scrollerDe, itemWidth]);\n\n  React.useEffect(() => {\n    if (!loop) {\n      setCopias(1);\n      passoRef.current = 0;\n      return;\n    }\n    const scroller = scrollerDe();\n    const n = items.length;\n    if (!scroller || !n) return;\n\n    // Encaixe e deriva brigam pela mesma rolagem — ver a nota. O valor antigo\n    // volta na limpeza porque o scroller é do trilho, não desta peça.\n    const encaixeAntes = scroller.style.scrollSnapType;\n    scroller.style.scrollSnapType = umPorVez ? \"x mandatory\" : \"none\";\n\n    const medir = () => {\n      const filhos = scroller.children;\n      if (filhos.length <= n) return;\n      // O passo é a distância entre o primeiro item de um conjunto e o primeiro\n      // do seguinte: já inclui o `gap` e o arredondamento de sub-pixel do grid.\n      // Dividir `scrollWidth` por `copias` erraria um `gap` por volta, e o erro\n      // se acumularia até a emenda ficar visível.\n      const a = (filhos[0] as HTMLElement).getBoundingClientRect().left;\n      const b = (filhos[n] as HTMLElement).getBoundingClientRect().left;\n      const passo = b - a;\n      if (passo <= 0) return;\n      // O passo mudou (a largura do card mudou): a posição acompanha na mesma\n      // proporção, senão o card que estava no meio deixa de ser o mesmo.\n      const passoAntes = passoRef.current;\n      if (passoAntes && passoAntes !== passo) {\n        scroller.scrollLeft *= passo / passoAntes;\n      }\n      passoRef.current = passo;\n\n      // Um conjunto de folga de cada lado da vista: é o mínimo pra a subtração\n      // acontecer sempre sobre conteúdo já pintado.\n      const precisa = Math.max(3, Math.ceil(scroller.clientWidth / passo) + 2);\n      if (precisa !== copias) {\n        setCopias(precisa);\n        return;\n      }\n      // A janela de trabalho é [passo, 2·passo). Começar em `passo` é o que dá\n      // lista pra trás — sem isso, arrastar pra esquerda no primeiro gesto\n      // esbarraria no zero e a fileira teria um fim, do lado errado.\n      if (scroller.scrollLeft < passo * 0.5) scroller.scrollLeft = passo;\n    };\n\n    const aoRolar = () => {\n      const p = passoRef.current;\n      if (!p) return;\n      if (scroller.scrollLeft >= p * 2) scroller.scrollLeft -= p;\n      else if (scroller.scrollLeft < p) scroller.scrollLeft += p;\n    };\n\n    medir();\n    scroller.addEventListener(\"scroll\", aoRolar, { passive: true });\n    const ro =\n      typeof ResizeObserver === \"undefined\" ? null : new ResizeObserver(medir);\n    ro?.observe(scroller);\n\n    return () => {\n      scroller.removeEventListener(\"scroll\", aoRolar);\n      ro?.disconnect();\n      scroller.style.scrollSnapType = encaixeAntes;\n    };\n  }, [loop, items.length, copias, scrollerDe, umPorVez]);\n\n  /**\n   * Ponteiro dentro ou foco dentro: a fileira espera.\n   *\n   * Dois estados, não um. Os controles só existem no card ativo: quando o ativo\n   * troca, o botão focado desmonta, o `blur` dispara, e com um estado só ele soltava\n   * a fileira debaixo do ponteiro, que era o motor voltando logo depois do arrasto.\n   */\n  const [comPonteiro, setComPonteiro] = React.useState(false);\n  const [comFoco, setComFoco] = React.useState(false);\n  const pausado = comPonteiro || comFoco;\n  /** Velocidade de agora. Sobrevive ao efeito: a rampa não recomeça do zero ao mudar de estado. */\n  const velRef = React.useRef(0);\n\n  React.useEffect(() => {\n    if (!loop || !drift || reduzido || !naTela || umPorVez) {\n      velRef.current = 0;\n      return;\n    }\n    if (pausado && velRef.current === 0) return;\n    const scroller = scrollerDe();\n    if (!scroller) return;\n\n    let raf = 0;\n    let ultimo = 0;\n    let espera = 0;\n    /*\n     * A posição é mantida em ponto flutuante aqui fora porque `scrollLeft`\n     * arredonda: a 26px/s são 0,43px por quadro, e escrevendo direto no\n     * elemento cada quadro perderia a fração — a fileira andaria aos trancos ou\n     * não sairia do lugar. Quando alguém MAIS mexe na rolagem (o dedo, a seta\n     * do trilho, a emenda do laço), a divergência passa de 2px e o nosso número\n     * obedece ao elemento, nunca o contrário.\n     */\n    let pos = 0;\n\n    const quadro = (t: number) => {\n      if (ultimo) {\n        const dt = Math.min(64, t - ultimo);\n        if (Math.abs(scroller.scrollLeft - pos) > 2) pos = scroller.scrollLeft;\n        const alvo = pausado ? 0 : driftSpeed;\n        velRef.current += (alvo - velRef.current) * (1 - Math.exp(-dt / 220));\n        if (pausado && velRef.current < 0.2) {\n          velRef.current = 0;\n          return;\n        }\n        pos += (velRef.current * dt) / 1000;\n        // O elemento guarda pixel inteiro: escrever a fração a cada quadro não\n        // move nada e ainda obriga o navegador a atualizar o layout pra\n        // responder à escrita. Só escreve quando o pixel muda (~14 vezes por\n        // segundo a 14px/s, não 60).\n        if (Math.round(pos) !== scroller.scrollLeft) scroller.scrollLeft = pos;\n      }\n      ultimo = t;\n      raf = requestAnimationFrame(quadro);\n    };\n\n    const partir = () => {\n      espera = 0;\n      pos = scroller.scrollLeft;\n      raf = requestAnimationFrame(quadro);\n    };\n\n    /*\n     * Saindo do repouso, a deriva espera a página ficar ociosa. Cada quadro\n     * dela lê `scrollLeft`, e ler posição com o layout sujo obriga o navegador a\n     * refazer o layout ali mesmo. Na montagem (a peça, o laço medindo as cópias,\n     * as vizinhas acordando junto) isso era um layout forçado por quadro. A\n     * rampa já sai do zero, então começar um instante depois não se vê.\n     */\n    const ocioso = window as Window & {\n      requestIdleCallback?: (cb: () => void, o?: { timeout: number }) => number;\n      cancelIdleCallback?: (id: number) => void;\n    };\n    if (velRef.current === 0 && ocioso.requestIdleCallback) {\n      espera = ocioso.requestIdleCallback(partir, { timeout: 1500 });\n    } else {\n      partir();\n    }\n\n    return () => {\n      if (espera) ocioso.cancelIdleCallback?.(espera);\n      cancelAnimationFrame(raf);\n    };\n  }, [loop, drift, reduzido, naTela, pausado, driftSpeed, scrollerDe, umPorVez]);\n\n  /** O trilho inteiro fora da tela para tudo. */\n  React.useEffect(() => {\n    const raiz = raizRef.current;\n    if (!raiz || typeof IntersectionObserver === \"undefined\") return;\n    const io = new IntersectionObserver(\n      ([e]) => {\n        if (e) setNaTela(e.isIntersecting);\n      },\n      { threshold: 0.15 },\n    );\n    io.observe(raiz);\n    return () => io.disconnect();\n  }, []);\n\n  const videos = React.useCallback((): (HTMLVideoElement | null)[] => {\n    const scroller = scrollerDe();\n    if (!scroller) return [];\n    return Array.from(scroller.children).map((c) =>\n      (c as HTMLElement).querySelector(\"video\"),\n    );\n  }, [scrollerDe]);\n\n  /**\n   * Quem não toca não carrega.\n   *\n   * O laço põe de 9 a 15 `<video>` no DOM, e cada um com `preload=\"metadata\"`\n   * (o padrão de quase todo slot) abre um player, busca cabeçalho e decodifica o\n   * primeiro quadro, tudo junto, na hora em que a peça monta: no celular eram\n   * nove players carregando para mostrar um vídeo. O card parado mostra o `poster`, que é o\n   * que ele já mostrava; o `play()` do card que vira o do meio carrega o vídeo\n   * dele. Vídeo SEM pôster continua carregando: sem ele, o card parado ficaria\n   * vazio em vez de mostrar o primeiro quadro. Efeito de layout porque roda na mesma tarefa da montagem, antes de o\n   * navegador começar a buscar; vídeo que já carregou fica como está.\n   */\n  React.useLayoutEffect(() => {\n    videos().forEach((v, i) => {\n      if (v && i !== alvo && v.poster && v.readyState === 0 && v.preload !== \"none\") v.preload = \"none\";\n    });\n  }, [videos, alvo, copias, items]);\n\n  /**\n   * O comando de reprodução: um toca, o resto para.\n   *\n   * Roda em efeito, e não no `onClick` do botão, porque a troca de card ativo\n   * vem da ROLAGEM — o dedo é quem mais troca de vídeo aqui, e ele não passa por\n   * botão nenhum. Deixar a regra num só lugar é o que impede o estado de\n   * divergir entre \"arrastei\" e \"cliquei\".\n   */\n  React.useEffect(() => {\n    const lista = videos();\n    if (!lista.length) return;\n\n    // Movimento reduzido nunca toca sozinho — mas um `play` pedido no botão\n    // continua valendo, porque aí não é a página que se mexe sozinha.\n    // No modo hover, \"ninguém apontando\" é uma resposta legítima: tudo parado.\n    const querTocar =\n      naTela && alvo !== null && (manual ?? (autoPlay && !reduzido));\n\n    lista.forEach((v, i) => {\n      if (!v) return;\n      // Ver a nota do cabeçalho: os três atributos que sempre faltam.\n      v.playsInline = true;\n      v.loop = true;\n\n      if (i === alvo && querTocar) {\n        v.muted = !(sound && comSom);\n        // `play()` devolve promessa e ela REJEITA quando o navegador barra a\n        // reprodução (política de autoplay, aba em economia). Sem o catch isso\n        // vira \"unhandled rejection\" no console de quem instalou, por algo que\n        // a pessoa nem viu falhar.\n        void v.play().catch(() => undefined);\n      } else {\n        v.muted = true;\n        if (!v.paused) v.pause();\n        // Volta ao começo: reel é peça de 6 segundos, e reencontrar um card\n        // parado no meio parece vídeo quebrado, não vídeo pausado. Só se saiu\n        // do zero: um `currentTime = 0` em vídeo que nunca andou é uma busca de\n        // graça, e busca obriga o vídeo a carregar, o que desfaria o\n        // `preload=\"none\"` do efeito abaixo.\n        if (i !== alvo && v.currentTime > 0) v.currentTime = 0;\n      }\n    });\n  }, [alvo, naTela, comSom, sound, autoPlay, manual, reduzido, videos, items]);\n\n  /** O ícone de play só conta a verdade se o estado vier do elemento. */\n  React.useEffect(() => {\n    const v = alvo === null ? null : videos()[alvo];\n    if (!v) return;\n    const sincronizar = () => setTocando(!v.paused);\n    sincronizar();\n    v.addEventListener(\"play\", sincronizar);\n    v.addEventListener(\"pause\", sincronizar);\n    return () => {\n      v.removeEventListener(\"play\", sincronizar);\n      v.removeEventListener(\"pause\", sincronizar);\n    };\n  }, [alvo, videos, items]);\n\n\n  /**\n   * A saída só apaga o card se ele ainda for o apontado.\n   *\n   * Andando de um card ao vizinho, o `enter` do novo chega ANTES do `leave` do\n   * velho. Um `leave` que zera sem conferir apagaria a escolha recém-feita, e o\n   * vídeo pararia meio segundo depois de começar — o defeito clássico de mover\n   * o cursor rápido por uma fileira.\n   */\n  const apontar = React.useCallback((posicao: number, dentro: boolean) => {\n    setSobCursor((atual) => (dentro ? posicao : atual === posicao ? null : atual));\n  }, []);\n\n  /*\n   * A lista de cards só muda com o que ela mostra. O trilho refaz o tabindex\n   * rotativo e mede as pontas toda vez que os filhos mudam, e cada render desta\n   * peça criava uma lista nova: ponteiro entrando, foco, o trilho entrando na\n   * tela, a medida do celular, tudo virava uma volta inteira de medida no\n   * trilho, que na montagem caía em layout sujo.\n   */\n  const cards = React.useMemo(\n    () =>\n      Array.from({ length: copias }).flatMap((_, c) =>\n        items.map((item, i) => {\n          // O índice do card na fileira INTEIRA: é ele que a medida do centro\n          // devolve, e é por ele que \"o do meio\" é decidido — o conjunto de\n          // origem não importa pra quem toca.\n          const posicao = c * items.length + i;\n          return (\n            <ReelCard\n              key={`${c}:${item.id}`}\n              item={item}\n              ratio={ratio}\n              ativo={posicao === alvo}\n              onHover={porHover ? (dentro) => apontar(posicao, dentro) : undefined}\n              tocando={tocando}\n              comSom={sound && comSom}\n              mostrarSom={sound}\n              dica={dragHint ? (mexeu ? \"sumiu\" : \"visivel\") : null}\n              // O botão só declara a vontade; quem toca e quem para é o efeito\n              // de reprodução. Uma regra, num lugar só — ver a nota dele.\n              onPlay={() => setManual(!tocando)}\n              onSom={() => setComSom((v) => !v)}\n            />\n          );\n        }),\n      ),\n    [copias, items, ratio, alvo, porHover, apontar, tocando, sound, comSom, dragHint, mexeu],\n  );\n\n  /*\n   * `min-w-0` na raiz, e não é detalhe de estilo.\n   *\n   * Item de flex (e de grid) nasce com `min-width: auto`, que é \"não encolha\n   * abaixo do seu conteúdo\". O conteúdo aqui é um trilho de seis cartões de\n   * 196px: ~1250px de largura intrínseca. Largado numa linha flex — que é como\n   * qualquer página real o usa —, o trilho deixava de rolar e passava a EMPURRAR\n   * a página inteira de lado no celular. Quem rola é o trilho; a página, nunca.\n   */\n  return (\n    <div\n      ref={raizRef}\n      className={cn(\n        \"relative min-w-0\",\n        umPorVez && \"[&_[role=group]>*]:[scroll-snap-align:center]\",\n        className,\n      )}\n      // Os quatro juntos porque a deriva tem que parar pelos DOIS caminhos de\n      // atenção: o ponteiro que chega e o foco que entra por teclado. Parar só\n      // no hover deixaria a fileira fugindo debaixo de quem navega com Tab.\n      // Captura: o gesto é da fileira, mas quem precisa saber é a dica. Apertar\n      // os botões do card não é arrastar, então não conta.\n      onPointerDownCapture={(e) => {\n        if (!(e.target as HTMLElement).closest(\"button\")) setMexeu(true);\n      }}\n      onWheelCapture={(e) => {\n        if (Math.abs(e.deltaX) > Math.abs(e.deltaY)) setMexeu(true);\n      }}\n      onPointerEnter={() => setComPonteiro(true)}\n      onPointerLeave={() => setComPonteiro(false)}\n      onFocusCapture={() => setComFoco(true)}\n      onBlurCapture={(e) => {\n        if (!e.currentTarget.contains(e.relatedTarget as Node | null)) setComFoco(false);\n      }}\n      {...props}\n    >\n      <Rail\n        itemWidth={itemWidth}\n        gap={gap}\n        bleed={bleed}\n        fade={fade}\n        arrows={arrows}\n        heading={heading}\n        hint={hint}\n        label={label}\n      >\n        {cards}\n      </Rail>\n    </div>\n  );\n}\n\n/**\n * A dica mora no canto livre do card ativo: à direita ficam os controles e embaixo\n * a legenda. Não recebe toque, então nunca atrapalha o arrasto que está anunciando.\n *\n * O balanço é Web Animations e não `@keyframes`: roda sem CSS nenhum na instalação.\n */\nfunction DicaDeArrasto({ sumiu }: { sumiu: boolean }) {\n  const icone = React.useRef<HTMLSpanElement>(null);\n  React.useEffect(() => {\n    const el = icone.current;\n    if (!el?.animate || window.matchMedia(\"(prefers-reduced-motion: reduce)\").matches) return;\n    const a = el.animate(\n      [\n        { transform: \"translateX(0)\" },\n        { transform: \"translateX(-3px)\" },\n        { transform: \"translateX(3px)\" },\n        { transform: \"translateX(0)\" },\n      ],\n      // motion-lint-disable-next-line hardcoded-duration  a dica balança devagar de propósito, fora da escala de resposta da interface\n      { duration: 1400, delay: 700, iterations: 2, easing: \"ease-in-out\" },\n    );\n    return () => a.cancel();\n  }, []);\n\n  return (\n    <span\n      aria-hidden=\"true\"\n      data-reels-dica=\"\"\n      className={cn(\n        \"pointer-events-none absolute left-3 top-3 grid size-9 place-items-center\",\n        \"rounded-[var(--r-pill,9999px)] bg-black/40 text-white/90 backdrop-blur-[2px]\",\n        \"transition-opacity [transition-duration:var(--dur-slow,300ms)] [transition-timing-function:var(--ease-out)]\",\n        sumiu && \"opacity-0\",\n      )}\n    >\n      <span ref={icone} className=\"grid place-items-center\">\n        <MoveHorizontal className=\"size-4\" />\n      </span>\n    </span>\n  );\n}\n\nfunction ReelCard({\n  item,\n  ratio,\n  ativo,\n  tocando,\n  comSom,\n  mostrarSom,\n  dica,\n  onPlay,\n  onSom,\n  onHover,\n}: {\n  item: ReelItem;\n  ratio: string;\n  ativo: boolean;\n  tocando: boolean;\n  comSom: boolean;\n  mostrarSom: boolean;\n  dica: \"visivel\" | \"sumiu\" | null;\n  onPlay: () => void;\n  onSom: () => void;\n  /** Só existe no modo `playOn=\"hover\"`. Ausente = o card não escuta ponteiro. */\n  onHover?: (dentro: boolean) => void;\n}) {\n  return (\n    <article\n      data-ativo={ativo || undefined}\n      // `pointerenter/leave` e não `mouseenter`: o mesmo par cobre caneta e\n      // mouse, e não dispara no toque (que já não usa este modo).\n      onPointerEnter={onHover ? () => onHover(true) : undefined}\n      onPointerLeave={onHover ? () => onHover(false) : undefined}\n      // Teclado chega ao card pelo link do título: quem tabula até ele também\n      // quer ver o vídeo, senão o modo hover exclui quem não usa cursor.\n      onFocusCapture={onHover ? () => onHover(true) : undefined}\n      onBlurCapture={\n        onHover\n          ? (e) => {\n              if (!e.currentTarget.contains(e.relatedTarget as Node | null)) onHover(false);\n            }\n          : undefined\n      }\n      className={cn(\n        \"relative isolate overflow-hidden rounded-[var(--r-surface,1rem)] bg-[var(--muted)]\",\n        // O vizinho recua: um pouco menor e um pouco mais apagado. É o que faz o\n        // card do meio ser lido como \"o que está tocando\" sem precisar de borda\n        // nem de rótulo dizendo isso.\n        // `--dur-slow`: a troca do card ativo acontece sozinha com a deriva, e\n        // a 200ms ela piscava a cada passagem. Mais lenta, ela respira.\n        \"transition-transform [transition-duration:var(--dur-slow,300ms)]\",\n        \"[transition-timing-function:var(--ease-out)]\",\n        \"scale-[0.965] data-[ativo]:scale-100\",\n        \"motion-reduce:scale-100 motion-reduce:transition-none\",\n        /*\n         * O vizinho recua por VÉU, não por `opacity` no card.\n         *\n         * Com `opacity-70` no elemento inteiro, a foto clara se mistura com o\n         * papel da página e o card vira um retângulo em branco — foi o que\n         * apareceu na vitrine, sobre fundo claro, com retrato de estúdio. O véu\n         * escurece por cima e a foto continua opaca: recua igual no tema claro e\n         * no escuro, porque a referência é o preto do véu, não o fundo de quem\n         * hospeda.\n         */\n        \"after:pointer-events-none after:absolute after:inset-0 after:z-10 after:bg-black/30\",\n        \"after:transition-opacity after:[transition-duration:var(--dur-slow,300ms)]\",\n        \"data-[ativo]:after:opacity-0 motion-reduce:after:transition-none\",\n      )}\n      style={{ aspectRatio: ratio }}\n    >\n      <div\n        className={cn(\n          \"absolute inset-0 -z-10\",\n          \"[&_img]:size-full [&_img]:object-cover [&_video]:size-full [&_video]:object-cover\",\n        )}\n      >\n        {item.media}\n      </div>\n\n      {/* A legenda paga o próprio contraste: a mídia atrás é imprevisível. */}\n      {item.title || item.meta ? (\n        <div className=\"absolute inset-x-0 bottom-0 bg-gradient-to-t from-black/75 to-transparent p-4 pt-12 text-white\">\n          {item.title ? (\n            <p className=\"text-[length:var(--text-destaque,0.9375rem)] font-semibold leading-[1.25]\">\n              {item.href ? (\n                <a\n                  href={item.href}\n                  className=\"no-underline outline-none focus-visible:[box-shadow:var(--focus)]\"\n                >\n                  {item.title}\n                </a>\n              ) : (\n                item.title\n              )}\n            </p>\n          ) : null}\n          {item.meta ? (\n            <p className=\"text-[length:var(--text-micro,0.6875rem)] leading-[1.4] opacity-80\">\n              {item.meta}\n            </p>\n          ) : null}\n        </div>\n      ) : null}\n\n      {/*\n       * Os controles existem SÓ no card ativo, e existem no DOM só quando ele é\n       * o ativo. Não é economia de pixel: com eles montados nos oito cards, o\n       * tabindex rotativo do trilho teria dezesseis botões pra gerenciar e a\n       * pessoa de teclado atravessaria dois controles por card. Aqui há no\n       * máximo dois, e eles pertencem ao vídeo que está tocando.\n       */}\n      {ativo && dica ? <DicaDeArrasto sumiu={dica === \"sumiu\"} /> : null}\n\n      {ativo ? (\n        <div className=\"absolute right-3 top-3 flex flex-col gap-2\">\n          <ControleReel\n            onClick={onPlay}\n            label={tocando ? \"Pausar o vídeo\" : \"Tocar o vídeo\"}\n          >\n            {tocando ? <Pause className=\"size-4\" fill=\"currentColor\" /> : <Play className=\"size-4\" fill=\"currentColor\" />}\n          </ControleReel>\n\n          {mostrarSom ? (\n            <ControleReel\n              onClick={onSom}\n              pressionado={comSom}\n              label={comSom ? \"Desligar o som\" : \"Ligar o som\"}\n            >\n              {comSom ? <Volume2 className=\"size-4\" /> : <VolumeX className=\"size-4\" />}\n            </ControleReel>\n          ) : null}\n        </div>\n      ) : null}\n    </article>\n  );\n}\n\nfunction ControleReel({\n  onClick,\n  label,\n  pressionado,\n  children,\n}: {\n  onClick: () => void;\n  label: string;\n  pressionado?: boolean;\n  children: React.ReactNode;\n}) {\n  return (\n    <button\n      type=\"button\"\n      onClick={onClick}\n      aria-label={label}\n      {...(pressionado === undefined ? null : { \"aria-pressed\": pressionado })}\n      className={cn(\n        \"relative grid size-9 pointer-coarse:after:absolute pointer-coarse:after:-inset-1 place-items-center rounded-[var(--r-pill,9999px)]\",\n        // Fundo próprio e não `--background`: o controle mora sobre a mídia, e\n        // ali o contraste não pode depender do tema da página.\n        \"bg-black/55 text-white backdrop-blur-[2px]\",\n        \"transition-transform [transition-duration:var(--dur-press,120ms)]\",\n        \"[transition-timing-function:var(--ease-out)]\",\n        \"hover:bg-black/70 active:scale-95 motion-reduce:active:scale-100\",\n        \"outline-none focus-visible:[box-shadow:var(--focus)]\",\n      )}\n    >\n      <span aria-hidden=\"true\" className=\"grid place-items-center\">\n        {children}\n      </span>\n    </button>\n  );\n}\n",
      "type": "registry:ui"
    }
  ],
  "meta": {
    "uso": {
      "quando": "Trilho de vídeos 9:16 em landing ou loja, tocando um por vez como reels",
      "evite": "Cards estáticos ou produtos: use rail; vídeo de abertura em tela cheia, fog-hero"
    }
  },
  "categories": [
    "conteudo",
    "video",
    "reels",
    "shorts",
    "vertical",
    "carrossel",
    "trilho"
  ],
  "type": "registry:ui"
}