{
  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
  "name": "kanban",
  "title": "Kanban",
  "author": "Visant Labs <visantsupply@gmail.com>",
  "description": "Quadro de tarefas por etapa: arraste o cartão de uma coluna para outra. No celular as colunas empilham.",
  "dependencies": [
    "@dnd-kit/core",
    "@dnd-kit/sortable",
    "@dnd-kit/utilities",
    "@air/react-drag-to-select",
    "framer-motion",
    "motion"
  ],
  "registryDependencies": [
    "utils",
    "@visant/motion"
  ],
  "files": [
    {
      "path": "registry/visant/blocks/kanban/Kanban.tsx",
      "content": "\"use client\";\n\nimport { useCallback, useEffect, useMemo, useRef, useState } from \"react\";\nimport { createPortal } from \"react-dom\";\nimport {\n  DndContext,\n  DragOverlay,\n  KeyboardSensor,\n  MouseSensor,\n  TouchSensor,\n  closestCorners,\n  defaultDropAnimationSideEffects,\n  useDndMonitor,\n  useSensor,\n  useSensors,\n  type Announcements,\n  type DragEndEvent,\n  type DragOverEvent,\n  type DragStartEvent,\n} from \"@dnd-kit/core\";\nimport { arrayMove, sortableKeyboardCoordinates } from \"@dnd-kit/sortable\";\nimport { useSelectionContainer, boxesIntersect, type Box } from \"@air/react-drag-to-select\";\nimport { motion, useReducedMotion, useSpring } from \"motion/react\";\nimport { EASE_POUSO_CSS } from \"@/lib/motion\";\nimport { cn } from \"@/lib/utils\";\nimport { KanbanColumn } from \"./KanbanColumn\";\nimport type { KanbanItem, KanbanProps } from \"./types\";\nimport \"./kanban.css\";\n\n/**\n * Kanban primitive — headless, data-agnostic, dirigido por design tokens.\n *\n * DnD robusto via dnd-kit (Pointer + Touch + Keyboard sensors, DragOverlay,\n * multi-container sortable): substitui o HTML5 drag nativo (sem touch, ghost\n * feio, casos de borda bugados). Reordena dentro da coluna E move entre colunas.\n *\n * Theming: lê só `--kanban-*` (com fallback pros tokens do design system) — troca\n * o arquivo de tokens da marca e o mesmo componente se veste. Ver kanban.css.\n *\n * Seleção múltipla (opt-in via `selectable`): marquee \"select by area\" (arrastar\n * sobre o vazio, via @air/react-drag-to-select) + shift/ctrl/cmd-clique. O marquee\n * não inicia sobre um card (é alça de drag) nem sobre controles. Emite\n * `onSelectionChange`; a UI de batch é do consumidor. Só ativa com `enabled`.\n *\n * Distribuição: registry estilo shadcn — copia `components/ui/kanban/*` pro\n * projeto do cliente e tematiza pelos tokens. Não conhece Linear/Supabase/auth.\n */\n/*\n * O pouso do card — o imã, e o fim do pulo ao soltar.\n *\n * O `DragOverlay` estava sem configuração, então rodava o padrão da lib: 250ms\n * de `ease`, e um efeito colateral que zera a opacidade do card de origem\n * durante a viagem e a devolve de uma vez no fim. Dois problemas nisso:\n *\n * 1. O tempo e a curva vinham de dentro do node_modules. Um encaixe é uma\n *    aterrissagem: `--dur-base` e `--ease-out`, que é como tudo o mais nesta\n *    casa desacelera ao chegar.\n * 2. O card de destino voltava do nada pro opaco no frame em que o overlay\n *    sumia. O buraco agora continua desenhado durante a viagem inteira, e quem\n *    avisa o fim é o `sideEffects`: o overlay some e o card fica inteiro no mesmo\n *    quadro. Sem fade na volta: os dois estão no mesmo pixel, então a troca é\n *    invisível, e um fade ali deixava o card apagado depois do pouso.\n *\n * O tempo e a curva são LIDOS do CSS em vez de escritos aqui. A drop animation\n * é WAAPI, e a Web Animations API não aceita `var(--ease-out)` — mas ela aceita\n * a string que a variável guarda. Então a fonte da verdade continua sendo o\n * arquivo de tokens: quem trocar `--dur-base` na marca troca também o pouso do\n * card, sem abrir este arquivo.\n *\n * Quem pediu menos movimento recebe duração zero: o dnd-kit pula a animação\n * (`if (!duration) return`) e o card simplesmente ESTÁ no destino. O resultado\n * acontece, só não há percurso — e essa é a única forma de alcançar isto, já\n * que o guard global de `prefers-reduced-motion` só enxerga transição CSS.\n */\n/** O cartão na mão: inclina um grau parado e até seis no embalo, com mola. */\nconst INCLINA_PARADO = -1;\nconst INCLINA_TETO = 6;\nconst INCLINA_POR_VELOCIDADE = 5;\nconst MOLA_INCLINA = { stiffness: 320, damping: 22, mass: 0.6 };\n\n/**\n * O cartão que voa inclina na direção do gesto e volta a assentar quando a mão para.\n * A rotação fica neste nó, nunca no de fora: é o de fora que o dnd-kit mede para pousar.\n */\nfunction CartaoNaMao({ children }: { children: React.ReactNode }) {\n  const reduzir = useReducedMotion();\n  const inclina = useSpring(reduzir ? 0 : INCLINA_PARADO, MOLA_INCLINA);\n  const ultimo = useRef({ x: 0, t: 0 });\n  const calma = useRef<ReturnType<typeof setTimeout> | null>(null);\n  const parar = (alvo: number) => {\n    if (calma.current) clearTimeout(calma.current);\n    if (!reduzir) inclina.set(alvo);\n  };\n  useEffect(() => () => { if (calma.current) clearTimeout(calma.current); }, []);\n  useDndMonitor({\n    onDragMove: ({ delta }) => {\n      if (reduzir) return;\n      const agora = performance.now();\n      const dt = Math.max(8, agora - ultimo.current.t);\n      const v = (delta.x - ultimo.current.x) / dt;\n      ultimo.current = { x: delta.x, t: agora };\n      inclina.set(Math.max(-INCLINA_TETO, Math.min(INCLINA_TETO, INCLINA_PARADO + v * INCLINA_POR_VELOCIDADE)));\n      if (calma.current) clearTimeout(calma.current);\n      calma.current = setTimeout(() => inclina.set(INCLINA_PARADO), 90);\n    },\n    onDragEnd: () => parar(0),\n    onDragCancel: () => parar(0),\n  });\n  return (\n    <motion.div className=\"kanban-card-overlay\" style={{ rotate: inclina }}>\n      {children}\n    </motion.div>\n  );\n}\n\n// Sem anotar `: DropAnimation`: aquele tipo é uma união que inclui a forma\n// \"função\", e por ela o `duration` some — e o guard de pouso abaixo precisa ler\n// essa duração. O objeto inferido continua sendo aceito pelo DragOverlay.\nfunction readDropAnimation(aoPousar: () => void) {\n  const css = typeof window === \"undefined\" ? null : getComputedStyle(document.documentElement);\n  const token = (name: string, fallback: string) =>\n    (css?.getPropertyValue(name).trim() || \"\") || fallback;\n\n  const raw = token(\"--dur-slow\", \"300ms\");\n  const ms = raw.endsWith(\"ms\") ? parseFloat(raw) : parseFloat(raw) * 1000;\n  const reduzido =\n    typeof window !== \"undefined\" &&\n    window.matchMedia(\"(prefers-reduced-motion: reduce)\").matches;\n\n  // A sombra assenta enquanto o card desce (`.kanban-pousando` no kanban.css).\n  const assentar = defaultDropAnimationSideEffects({\n    className: { dragOverlay: \"kanban-pousando\" },\n  });\n\n  return {\n    duration: reduzido ? 0 : Number.isFinite(ms) ? ms : 300,\n    easing: EASE_POUSO_CSS,\n    sideEffects: (args: Parameters<typeof assentar>[0]) => {\n      const desfazer = assentar(args);\n      return () => {\n        desfazer?.();\n        aoPousar();\n      };\n    },\n  };\n}\n\n/* Sem isto o leitor de tela anuncia em inglês o id interno (\"Draggable item a was dropped\"). */\nconst AVISOS: Announcements = {\n  onDragStart: () => \"Cartão pego.\",\n  // Sobre o próprio lugar não há o que dizer: o dnd-kit dispara isto ao pegar, e o\n  // aviso atropelava o \"Cartão pego.\" no mesmo instante.\n  onDragOver: ({ active, over }) =>\n    over?.id === active.id ? undefined : over ? \"Cartão sobre uma nova posição.\" : \"Cartão fora das colunas.\",\n  onDragEnd: ({ over }) => (over ? \"Cartão solto.\" : \"Cartão devolvido.\"),\n  onDragCancel: () => \"Movimento cancelado. Cartão devolvido.\",\n};\nconst INSTRUCOES = {\n  draggable: \"Espaço pega o cartão. As setas movem. Espaço solta e Esc cancela. No toque, segure e arraste.\",\n};\n\nexport function Kanban<T = unknown, C = unknown>({\n  columns,\n  items,\n  renderCard,\n  renderColumnHeader,\n  renderColumnEmpty,\n  onMove,\n  enabled = true,\n  selectable = false,\n  selectedIds,\n  onSelectionChange,\n  className,\n  columnClassName,\n}: KanbanProps<T, C>) {\n  const itemById = useMemo(() => {\n    const m = new Map<string, KanbanItem<T>>();\n    for (const it of items) m.set(it.id, it);\n    return m;\n  }, [items]);\n\n  const colMeta = useMemo(() => new Map(columns.map((c) => [c.id, c])), [columns]);\n\n  // Fim real do pouso: quem manda é a animação; o relógio de `aguardaPouso` é só a\n  // rede para quando ela nem roda (duração zero, overlay já fora da tela).\n  const aoPousarRef = useRef<() => void>(() => {});\n\n  // Uma vez por board: a config precisa ser a MESMA referência entre renders,\n  // senão o dnd-kit refaz o handler de pouso no meio do gesto e a animação sai\n  // pela metade. `[]` de propósito.\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  const dropAnimation = useMemo(() => readDropAnimation(() => aoPousarRef.current()), []);\n\n  // Ordem vinda das props (a fonte da verdade do consumidor).\n  const fromProps = useMemo(() => {\n    const map: Record<string, string[]> = {};\n    for (const c of columns) map[c.id] = [];\n    for (const it of items) (map[it.columnId] ??= []).push(it.id);\n    return map;\n  }, [columns, items]);\n\n  // Cópia de trabalho — mutável durante o arraste pro card \"seguir\" pra coluna\n  // nova ao vivo; ressincroniza com as props quando não está arrastando.\n  const [ordered, setOrdered] = useState<Record<string, string[]>>(fromProps);\n  const [activeId, setActiveId] = useState<string | null>(null);\n  const [overColumn, setOverColumn] = useState<string | null>(null);\n  const fromColumnRef = useRef<string | null>(null);\n  // Índice de origem congelado no dragStart: comparar com fromProps atual dava\n  // falso-positivo/negativo se um refetch (realtime) chegasse durante o drag.\n  const fromIndexRef = useRef<number>(-1);\n\n  /*\n   * A ressincronização espera o card POUSAR.\n   *\n   * O efeito abaixo devolve a ordem das props assim que o gesto acaba — e o\n   * gesto acaba no instante do `mouseup`, enquanto o overlay ainda tem a viagem\n   * inteira pela frente. Um consumidor que aplique o `onMove` com qualquer\n   * diferença (o caso comum: guardar a coluna e ignorar o `columnOrder`) fazia o\n   * card SALTAR de volta debaixo do overlay que ainda estava descendo. Ir e\n   * voltar num piscar, com o fantasma ainda no ar.\n   *\n   * Segurar a ressincronização pela duração do pouso resolve pra todo mundo, e\n   * não só pra quem escreve o consumidor certo: o card encosta no lugar, e só\n   * então a verdade das props volta a mandar. Se ela discordar, a correção\n   * aparece — mas aparece sozinha, à vista, e não escondida sob uma animação.\n   */\n  const [pousando, setPousando] = useState<string | null>(null);\n  const [fantasma, setFantasma] = useState<{ escala: number; largura: number } | null>(null);\n  const pousoRef = useRef<ReturnType<typeof setTimeout> | null>(null);\n  const terminaPouso = useCallback(() => {\n    if (pousoRef.current) clearTimeout(pousoRef.current);\n    setPousando(null);\n  }, []);\n  aoPousarRef.current = terminaPouso;\n  const aguardaPouso = useCallback(\n    (id: string) => {\n      if (pousoRef.current) clearTimeout(pousoRef.current);\n      setPousando(id);\n      const duracao = dropAnimation.duration ?? 0;\n      pousoRef.current = setTimeout(terminaPouso, duracao ? duracao + 120 : 0);\n    },\n    [dropAnimation.duration, terminaPouso],\n  );\n  useEffect(() => () => void (pousoRef.current && clearTimeout(pousoRef.current)), []);\n\n  useEffect(() => {\n    if (!activeId && !pousando) setOrdered(fromProps);\n  }, [fromProps, activeId, pousando]);\n\n  const sensors = useSensors(\n    // MouseSensor, NÃO PointerSensor: Pointer Events incluem touch — com\n    // `distance: 6`, qualquer pan de 6px no dedo virava drag IMEDIATO, sem\n    // delay (o TouchSensor abaixo nem chegava a decidir). Mouse: um CLIQUE\n    // (abrir o card) só vira arraste depois de mover alguns px.\n    useSensor(MouseSensor, { activationConstraint: { distance: 6 } }),\n    // Touch: long-press deliberado (250ms parado) inicia o drag; mover o dedo\n    // além da tolerância durante a espera = é scroll, cancela o drag.\n    useSensor(TouchSensor, { activationConstraint: { delay: 250, tolerance: 8 } }),\n    useSensor(KeyboardSensor, { coordinateGetter: sortableKeyboardCoordinates })\n  );\n\n  // --- Seleção múltipla (opt-in via `selectable`, só faz efeito com `enabled`) --\n  const selectionActive = enabled && selectable;\n  const controlled = selectedIds != null;\n  const [internalSel, setInternalSel] = useState<string[]>([]);\n  const selection = controlled ? selectedIds! : internalSel;\n  const selSet = useMemo(() => new Set(selection), [selection]);\n  // Espelho sempre-atual da seleção pros callbacks do marquee (que não re-assinam).\n  const selSetRef = useRef(selSet);\n  selSetRef.current = selSet;\n\n  const commitSelection = useCallback(\n    (next: string[]) => {\n      if (!controlled) setInternalSel(next);\n      onSelectionChange?.(next);\n    },\n    [controlled, onSelectionChange]\n  );\n\n  const toggleSelect = useCallback(\n    (id: string) => {\n      const next = new Set(selSetRef.current);\n      if (next.has(id)) next.delete(id);\n      else next.add(id);\n      commitSelection([...next]);\n    },\n    [commitSelection]\n  );\n\n  // Callback ref (via state) — o marquee precisa do elemento no render pra ancorar\n  // os listeners (mousedown/move) só no board, não no document inteiro.\n  const [boardEl, setBoardEl] = useState<HTMLDivElement | null>(null);\n  // Base congelada no início do gesto: seleção pré-existente se aditivo (shift),\n  // senão vazia. O marquee soma os hits a essa base.\n  const marqueeBaseRef = useRef<Set<string>>(new Set());\n\n  // Hit-test: quais cards (por data-kanban-card-id) intersectam a caixa do marquee.\n  // A lib entrega a `box` em coords RELATIVAS ao container (`.kanban-root`), então\n  // convertemos os rects dos cards (viewport) subtraindo o rect do board.\n  const hitsInBox = useCallback(\n    (box: Box): string[] => {\n      if (!boardEl) return [];\n      const base = boardEl.getBoundingClientRect();\n      const hits: string[] = [];\n      boardEl.querySelectorAll<HTMLElement>(\"[data-kanban-card-id]\").forEach((el) => {\n        const r = el.getBoundingClientRect();\n        const rel = {\n          left: r.left - base.left,\n          top: r.top - base.top,\n          width: r.width,\n          height: r.height,\n        };\n        if (boxesIntersect(box, rel)) {\n          const id = el.dataset.kanbanCardId;\n          if (id) hits.push(id);\n        }\n      });\n      return hits;\n    },\n    [boardEl]\n  );\n\n  const { DragSelection } = useSelectionContainer<HTMLDivElement>({\n    isEnabled: selectionActive,\n    eventsElement: boardEl,\n    // Não iniciar sobre um card (é alça de drag do dnd-kit) nem sobre controles.\n    shouldStartSelecting: (target) => {\n      if (!(target instanceof Element)) return false;\n      if (target.closest(\"[data-kanban-card-id]\")) return false;\n      return !target.closest(\n        \"button, a, input, textarea, select, [role='button'], [contenteditable='true']\"\n      );\n    },\n    onSelectionStart: (e) => {\n      const additive = e.shiftKey || e.metaKey || e.ctrlKey;\n      marqueeBaseRef.current = additive ? new Set(selSetRef.current) : new Set();\n      // Clique no vazio (sem aditivo) limpa a seleção — comportamento Finder/Linear.\n      if (!additive && selSetRef.current.size) commitSelection([]);\n    },\n    onSelectionChange: (box) => {\n      const next = new Set(marqueeBaseRef.current);\n      for (const id of hitsInBox(box)) next.add(id);\n      commitSelection([...next]);\n    },\n    selectionProps: {\n      style: {\n        // Cor completa via --kanban-accent (portável entre HSL e OKLCH); ver kanban.css.\n        border: \"1px solid var(--kanban-accent, oklch(0.62 0.02 240))\",\n        background: \"color-mix(in oklch, var(--kanban-accent, oklch(0.62 0.02 240)) 12%, transparent)\",\n        borderRadius: \"4px\",\n      },\n    },\n  });\n\n  // Esc limpa a seleção.\n  useEffect(() => {\n    if (!selectionActive || selection.length === 0) return;\n    const onKey = (e: KeyboardEvent) => {\n      if (e.key === \"Escape\") commitSelection([]);\n    };\n    window.addEventListener(\"keydown\", onKey);\n    return () => window.removeEventListener(\"keydown\", onKey);\n  }, [selectionActive, selection.length, commitSelection]);\n\n  const columnOf = (id: string): string | undefined => {\n    if (id in ordered) return id;\n    return Object.keys(ordered).find((col) => ordered[col]!.includes(id));\n  };\n\n  const itemsOf = (colId: string): KanbanItem<T>[] =>\n    (ordered[colId] ?? []).map((id) => itemById.get(id)).filter(Boolean) as KanbanItem<T>[];\n\n  const activeItem = activeId ? itemById.get(activeId) ?? null : null;\n\n  // Board somente-leitura: render simples sem DnD (ex.: board do cliente).\n  if (!enabled) {\n    return (\n      <div className={cn(\"kanban-root flex\", className)}>\n        {columns.map((col) => (\n          <KanbanColumn\n            key={col.id}\n            column={col}\n            items={(fromProps[col.id] ?? [])\n              .map((id) => itemById.get(id))\n              .filter(Boolean) as KanbanItem<T>[]}\n            enabled={false}\n            isOver={false}\n            render={renderCard}\n            renderHeader={renderColumnHeader}\n            renderEmpty={renderColumnEmpty}\n            className={columnClassName}\n          />\n        ))}\n      </div>\n    );\n  }\n\n  const handleDragStart = (e: DragStartEvent) => {\n    const id = String(e.active.id);\n    setActiveId(id);\n    medirFantasma(id);\n    // O dedo não vê o cartão por baixo dele: o toque curto confirma que pegou.\n    // iOS ignora, e tudo bem: lá sobra a sombra subindo.\n    if (typeof TouchEvent !== \"undefined\" && e.activatorEvent instanceof TouchEvent) {\n      navigator.vibrate?.(8);\n    }\n    const col = columnOf(id) ?? null;\n    fromColumnRef.current = col;\n    fromIndexRef.current = col ? (ordered[col] ?? []).indexOf(id) : -1;\n  };\n\n  /*\n   * Board dentro de um `transform: scale` (vitrine, card, modal animando): o\n   * fantasma vai pro `body` e perderia a escala, e o cartão saltava de tamanho ao\n   * ser levantado. A escala medida na largura do cartão volta num invólucro, por\n   * fora do nó com a sombra, e o dedo continua movendo em pixel de tela. Fora de\n   * um palco escalado isto é nulo.\n   */\n  const medirFantasma = (id: string) => {\n    const el = boardEl?.querySelector<HTMLElement>(`[data-kanban-card-id=\"${CSS.escape(id)}\"]`);\n    const largura = el?.offsetWidth ?? 0;\n    const escala = largura ? el!.getBoundingClientRect().width / largura : 1;\n    setFantasma(Math.abs(escala - 1) > 0.01 ? { escala, largura } : null);\n  };\n\n  const handleDragOver = (e: DragOverEvent) => {\n    const active = String(e.active.id);\n    const overId = e.over ? String(e.over.id) : null;\n    if (!overId) {\n      setOverColumn(null);\n      return;\n    }\n    const activeCol = columnOf(active);\n    const overCol = columnOf(overId);\n    if (!activeCol || !overCol) return;\n    if (colMeta.get(overCol)?.dropDisabled) {\n      setOverColumn(null);\n      return;\n    }\n    setOverColumn(overCol);\n    if (activeCol === overCol) return;\n\n    // Cross-container: insere o card na coluna de destino ao vivo.\n    setOrdered((prev) => {\n      const activeItems = prev[activeCol] ?? [];\n      const overItems = prev[overCol] ?? [];\n      if (!activeItems.includes(active)) return prev;\n      const overIndex = overId in prev ? overItems.length : overItems.indexOf(overId);\n      const insertAt = overIndex >= 0 ? overIndex : overItems.length;\n      return {\n        ...prev,\n        [activeCol]: activeItems.filter((id) => id !== active),\n        [overCol]: [...overItems.slice(0, insertAt), active, ...overItems.slice(insertAt)],\n      };\n    });\n  };\n\n  // ESC / cancelamento de sensor dispara onDragCancel, NÃO onDragEnd. Sem este\n  // handler o activeId nunca zerava: overlay preso, resync com as props\n  // bloqueado e o card órfão na coluna errada até um remount.\n  const handleDragCancel = () => {\n    aguardaPouso(activeId ?? \"\");\n    setActiveId(null);\n    setOverColumn(null);\n    fromColumnRef.current = null;\n    fromIndexRef.current = -1;\n    setOrdered(fromProps);\n  };\n\n  const handleDragEnd = (e: DragEndEvent) => {\n    const active = String(e.active.id);\n    const overId = e.over ? String(e.over.id) : null;\n    const from = fromColumnRef.current;\n    aguardaPouso(active);\n    setActiveId(null);\n    setOverColumn(null);\n    fromColumnRef.current = null;\n\n    if (!overId) {\n      setOrdered(fromProps);\n      return;\n    }\n    const activeCol = columnOf(active);\n    const overCol = columnOf(overId) ?? activeCol;\n    if (!activeCol || !overCol || colMeta.get(overCol)?.dropDisabled) {\n      setOrdered(fromProps);\n      return;\n    }\n\n    // Após o dragOver, o item já vive na coluna de destino; aqui só refinamos o\n    // índice final (reorder dentro da coluna resolvida).\n    const arr = ordered[activeCol] ?? [];\n    const oldIndex = arr.indexOf(active);\n    // Soltar sobre o corpo da coluna (gap/padding, não um card) mantém a posição\n    // da prévia ao vivo — antes forçava o card pro FIM da coluna e persistia uma\n    // ordem que o usuário não pediu.\n    let newIndex = overId in ordered ? oldIndex : arr.indexOf(overId);\n    if (newIndex < 0) newIndex = oldIndex;\n    const finalArr =\n      oldIndex >= 0 && newIndex >= 0 && oldIndex !== newIndex\n        ? arrayMove(arr, oldIndex, newIndex)\n        : arr;\n    const finalOrdered = { ...ordered, [activeCol]: finalArr };\n    setOrdered(finalOrdered);\n\n    const toIndex = finalArr.indexOf(active);\n    const originalIndex = fromIndexRef.current;\n    fromIndexRef.current = -1;\n    // Só reporta mudança real (evita write fantasma ao soltar no mesmo lugar).\n    if (from !== activeCol || toIndex !== originalIndex) {\n      onMove?.({\n        itemId: active,\n        fromColumnId: from ?? activeCol,\n        toColumnId: activeCol,\n        toIndex,\n        columnOrder: finalArr,\n      });\n    }\n  };\n\n  /*\n   * O CARD QUE VOAVA PRA LONGE DO CURSOR — e por que era o pai, não o dnd-kit.\n   *\n   * O `DragOverlay` é `position: fixed`, e o dnd-kit escreve nele um\n   * `translate3d` em coordenadas de VIEWPORT (o rect que ele mediu no início do\n   * gesto, mais o delta do ponteiro). Isso só bate enquanto o bloco contenedor\n   * do `fixed` for o viewport.\n   *\n   * Qualquer ancestral com `transform`, `filter`, `perspective`, `backdrop-filter`\n   * ou `will-change` dessas propriedades passa a ser o bloco contenedor de\n   * descendentes `fixed` — regra do CSS, não bug de lib. Aí o mesmo\n   * `translate3d(x, y)` deixa de ser medido do canto da janela e passa a ser\n   * medido do canto DAQUELE elemento: o card aparece deslocado exatamente pela\n   * posição do ancestral na página (com a rolagem inteira somada, o que numa\n   * página longa joga o card pra fora da tela). Ao soltar, o overlay some e o\n   * card real reaparece no lugar certo — daí a leitura de \"pula pro lugar\".\n   *\n   * Isso não é caso de laboratório: um card com `transform: scale()` pra caber\n   * numa vitrine, um painel com `backdrop-filter`, um modal com animação de\n   * entrada — todos produzem o mesmo defeito no projeto de quem instalou.\n   *\n   * O overlay vai pro `body` por portal. Ele não pertence ao fluxo do board (é\n   * um fantasma que voa por cima de tudo), então tirá-lo de lá não muda layout\n   * nenhum — e passa a viver onde a matemática do dnd-kit já supunha que ele\n   * estava. Os tokens `--kanban-*` que o overlay usa têm fallback no ponto de\n   * uso (kanban.css), justamente porque fora do `.kanban-root` não há herança.\n   */\n  const overlay = (\n    <DragOverlay dropAnimation={dropAnimation}>\n      {activeItem ? (\n        <div style={fantasma ? { width: fantasma.largura, transform: `scale(${fantasma.escala})`, transformOrigin: \"top left\" } : undefined}>\n          <CartaoNaMao>{renderCard({ item: activeItem, overlay: true })}</CartaoNaMao>\n        </div>\n      ) : null}\n    </DragOverlay>\n  );\n\n  return (\n    <DndContext\n      sensors={sensors}\n      collisionDetection={closestCorners}\n      onDragStart={handleDragStart}\n      onDragOver={handleDragOver}\n      onDragEnd={handleDragEnd}\n      onDragCancel={handleDragCancel}\n      accessibility={{ announcements: AVISOS, screenReaderInstructions: INSTRUCOES }}\n    >\n      {/* data-kanban-dragging: consumidores (via `:has()`) desligam scroll-snap\n          durante o drag pra não brigar com o auto-scroll do dnd-kit. */}\n      <div\n        ref={setBoardEl}\n        className={cn(\"kanban-root flex\", selectionActive && \"relative\", className)}\n        data-kanban-dragging={activeId ? \"\" : undefined}\n      >\n        {/* Retângulo do marquee — renderizado no topo do container dos cards. */}\n        {selectionActive ? <DragSelection /> : null}\n        {columns.map((col) => (\n          <KanbanColumn\n            key={col.id}\n            column={col}\n            items={itemsOf(col.id)}\n            enabled\n            isOver={overColumn === col.id}\n            landingId={pousando}\n            render={renderCard}\n            renderHeader={renderColumnHeader}\n            renderEmpty={renderColumnEmpty}\n            className={columnClassName}\n            selectable={selectionActive}\n            selectedIds={selSet}\n            onSelectToggle={toggleSelect}\n          />\n        ))}\n      </div>\n      {typeof document === \"undefined\" ? overlay : createPortal(overlay, document.body)}\n    </DndContext>\n  );\n}\n",
      "type": "registry:component",
      "target": "~/components/kanban/Kanban.tsx"
    },
    {
      "path": "registry/visant/blocks/kanban/KanbanColumn.tsx",
      "content": "\"use client\";\n\nimport { useMemo } from \"react\";\nimport { useDroppable } from \"@dnd-kit/core\";\nimport {\n  SortableContext,\n  verticalListSortingStrategy,\n} from \"@dnd-kit/sortable\";\nimport { cn } from \"@/lib/utils\";\nimport { KanbanCard } from \"./KanbanCard\";\nimport type { KanbanColumn as Col, KanbanItem, KanbanRenderCardArgs } from \"./types\";\n\n/**\n * Coluna droppable + SortableContext. Também aceita drop quando vazia (o\n * useDroppable no corpo inteiro), senão colunas sem card não seriam alvo.\n */\nexport function KanbanColumn<T, C>({\n  column,\n  items,\n  enabled,\n  isOver,\n  landingId,\n  render,\n  renderHeader,\n  renderEmpty,\n  className,\n  selectable = false,\n  selectedIds,\n  onSelectToggle,\n}: {\n  column: Col<C>;\n  items: KanbanItem<T>[];\n  enabled: boolean;\n  isOver: boolean;\n  /** Cartão ainda pousando: segue como buraco até o fantasma chegar. */\n  landingId?: string | null;\n  render: (args: KanbanRenderCardArgs<T>) => React.ReactNode;\n  renderHeader?: (column: Col<C>) => React.ReactNode;\n  renderEmpty?: (column: Col<C>) => React.ReactNode;\n  className?: string;\n  selectable?: boolean;\n  selectedIds?: Set<string>;\n  onSelectToggle?: (id: string) => void;\n}) {\n  const droppable = enabled && !column.dropDisabled;\n  const { setNodeRef } = useDroppable({ id: column.id, disabled: !droppable });\n\n  // A MESMA referência enquanto a ordem não muda. O sortable compara os itens por\n  // referência: array novo a cada render lia como \"a lista mudou\" e desligava o\n  // deslize de todos os cartões, em todo render.\n  const idsKey = items.map((i) => i.id).join(\"\\n\");\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  const ids = useMemo(() => items.map((i) => i.id), [idsKey]);\n\n  return (\n    <div\n      className={cn(\n        \"kanban-column flex flex-col\",\n        isOver && droppable && \"is-drop-target\",\n        className\n      )}\n    >\n      {renderHeader?.(column)}\n      <SortableContext\n        items={ids}\n        strategy={verticalListSortingStrategy}\n      >\n        <div ref={setNodeRef} className=\"kanban-column-body flex-1\">\n          {items.length === 0\n            ? renderEmpty?.(column)\n            : items.map((item) => (\n                <KanbanCard\n                  key={item.id}\n                  item={item}\n                  enabled={enabled}\n                  landing={landingId === item.id}\n                  render={render}\n                  selectable={selectable}\n                  selected={selectedIds?.has(item.id) ?? false}\n                  onSelectToggle={onSelectToggle}\n                />\n              ))}\n        </div>\n      </SortableContext>\n    </div>\n  );\n}\n",
      "type": "registry:component",
      "target": "~/components/kanban/KanbanColumn.tsx"
    },
    {
      "path": "registry/visant/blocks/kanban/KanbanCard.tsx",
      "content": "\"use client\";\n\nimport {\n  defaultAnimateLayoutChanges,\n  useSortable,\n  type AnimateLayoutChanges,\n} from \"@dnd-kit/sortable\";\nimport { CSS } from \"@dnd-kit/utilities\";\nimport { cn } from \"@/lib/utils\";\nimport type { KanbanItem, KanbanRenderCardArgs } from \"./types\";\n\n/*\n * Vizinhos deslizam também quando o cartão muda de coluna. O padrão da lib só anima\n * quem acabou de ser arrastado: ao entrar numa coluna, os de baixo saltavam 93px de\n * um quadro para o outro, enquanto dentro da coluna tudo deslizava.\n */\nconst animarVizinhos: AnimateLayoutChanges = (args) =>\n  defaultAnimateLayoutChanges({ ...args, wasDragging: true });\n\n/**\n * Card arrastável (useSortable). O card inteiro é a alça — a distância de\n * ativação do sensor (no <Kanban>) garante que um CLIQUE simples ainda passe\n * para o onClick do conteúdo; só vira arraste depois de mover alguns px.\n */\nexport function KanbanCard<T>({\n  item,\n  enabled,\n  landing = false,\n  render,\n  selectable = false,\n  selected = false,\n  onSelectToggle,\n}: {\n  item: KanbanItem<T>;\n  enabled: boolean;\n  /** O fantasma ainda está descendo até aqui. */\n  landing?: boolean;\n  render: (args: KanbanRenderCardArgs<T>) => React.ReactNode;\n  /** Seleção múltipla ligada — habilita o shift/ctrl/cmd-clique de toggle. */\n  selectable?: boolean;\n  selected?: boolean;\n  onSelectToggle?: (id: string) => void;\n}) {\n  const {\n    setNodeRef,\n    attributes,\n    listeners,\n    transform,\n    transition,\n    isDragging,\n  } = useSortable({ id: item.id, disabled: !enabled, animateLayoutChanges: animarVizinhos });\n\n  // O tempo e a curva do deslize moram em `.kanban-card` (kanban.css), nos tokens da\n  // casa. Mas a lib também usa `transition` para DESLIGAR: `0ms` no quadro em que ela\n  // reposiciona o cartão sem animar, e nada quando não há o que animar. Ignorar esses\n  // dois fazia o CSS animar a correção, e ao soltar o vizinho saltava 93px para cima e\n  // voltava deslizando. Era o último flicker do pouso.\n  const transicao = !transition ? \"none\" : transition.includes(\" 0ms\") ? transition : undefined;\n\n  return (\n    <div\n      ref={setNodeRef}\n      // O marquee (Kanban) acha os cards por este atributo pra calcular o hit-test.\n      data-kanban-card-id={item.id}\n      data-selected={selectable && selected ? \"\" : undefined}\n      aria-selected={selectable ? selected : undefined}\n      style={{ transform: CSS.Translate.toString(transform), transition: transicao }}\n      // Modifier-clique = toggle na seleção (não abre o card). Capture pra\n      // interceptar ANTES do onClick do conteúdo (render do consumidor).\n      onClickCapture={\n        selectable\n          ? (e) => {\n              if (e.shiftKey || e.metaKey || e.ctrlKey) {\n                e.preventDefault();\n                e.stopPropagation();\n                onSelectToggle?.(item.id);\n              }\n            }\n          : undefined\n      }\n      className={cn(\n        // `manipulation`, não `none`: o TouchSensor ativa por delay (150ms) e aí\n        // preventDefault nos touchmove — `none` bloqueava o pan nativo que os\n        // scrolls mobile (coluna interna + rail snap-x) precisam quando o gesto\n        // começa em cima de um card, ou seja, quase sempre.\n        \"kanban-card touch-manipulation\",\n        enabled && \"kanban-card-movel cursor-grab active:cursor-grabbing\",\n        // O card de origem vira o ALVO em vez de sumir. Era `opacity-40` aqui —\n        // e como a demo pintava outro `.4` no conteúdo, dava 0.16 na tela: o\n        // lugar de destino existia e ninguém enxergava. Agora ele se desenha\n        // como buraco tracejado (ver `.is-drop-slot` no kanban.css), que é o\n        // ponto exato onde o card cai e o que faz o gesto ter imã.\n        (isDragging || landing) && \"is-drop-slot\"\n      )}\n      // Fora do `listeners`, que não usa ponteiro: o cartão responde ao encostar e o\n      // arraste continua esperando o segurar. Solta na `window` porque o cartão pode\n      // trocar de coluna no meio do gesto.\n      onPointerDown={\n        enabled\n          ? (e) => {\n              if (e.pointerType !== \"touch\") return;\n              const el = e.currentTarget;\n              el.setAttribute(\"data-apertado\", \"\");\n              const soltar = () => {\n                el.removeAttribute(\"data-apertado\");\n                window.removeEventListener(\"pointerup\", soltar);\n                window.removeEventListener(\"pointercancel\", soltar);\n              };\n              window.addEventListener(\"pointerup\", soltar);\n              window.addEventListener(\"pointercancel\", soltar);\n            }\n          : undefined\n      }\n      {...(enabled ? attributes : {})}\n      {...(enabled ? listeners : {})}\n    >\n      {render({ item, dragging: isDragging, selected: selectable ? selected : undefined })}\n    </div>\n  );\n}\n",
      "type": "registry:component",
      "target": "~/components/kanban/KanbanCard.tsx"
    },
    {
      "path": "registry/visant/blocks/kanban/types.ts",
      "content": "/**\n * Kanban primitive — tipos públicos.\n *\n * Data-agnostic por design: o componente não conhece Linear, Supabase, auth ou\n * \"membro\". Recebe colunas + itens e emite `onMove`. Quem pluga dado é o\n * consumidor (neste app, o board do time; num projeto de cliente, o que for).\n */\nimport type { ReactNode } from \"react\";\n\nexport interface KanbanColumn<C = unknown> {\n  /** Chave estável da coluna (ex.: um status). */\n  id: string;\n  /** Dado livre do consumidor (cor, label, contadores…) para o header. */\n  data?: C;\n  /** Coluna não aceita drops (arrastável PARA fora, mas não é alvo). */\n  dropDisabled?: boolean;\n}\n\nexport interface KanbanItem<T = unknown> {\n  /** Id estável do card. */\n  id: string;\n  /** Coluna a que o card pertence. */\n  columnId: string;\n  /** Dado livre do consumidor, repassado ao `renderCard`. */\n  data: T;\n}\n\nexport interface KanbanMove {\n  itemId: string;\n  fromColumnId: string;\n  toColumnId: string;\n  /** Índice final dentro da coluna de destino. */\n  toIndex: number;\n  /** Ordem completa (ids) da coluna de destino após o move — pronta pra persistir. */\n  columnOrder: string[];\n}\n\nexport interface KanbanRenderCardArgs<T> {\n  item: KanbanItem<T>;\n  /** true no overlay de arraste (o card \"fantasma\" que segue o cursor). */\n  overlay?: boolean;\n  /** true no card original enquanto ele está sendo arrastado. */\n  dragging?: boolean;\n  /** true quando o card faz parte da seleção múltipla (ver `selectable`). */\n  selected?: boolean;\n}\n\nexport interface KanbanProps<T = unknown, C = unknown> {\n  columns: KanbanColumn<C>[];\n  items: KanbanItem<T>[];\n  /** Slot obrigatório: o consumidor desenha o card (mantém o core de DnD genérico). */\n  renderCard: (args: KanbanRenderCardArgs<T>) => ReactNode;\n  /** Slot opcional do cabeçalho da coluna. */\n  renderColumnHeader?: (column: KanbanColumn<C>) => ReactNode;\n  /** Slot opcional do vazio da coluna. */\n  renderColumnEmpty?: (column: KanbanColumn<C>) => ReactNode;\n  /**\n   * Disparado ao soltar: mover entre colunas E reordenar dentro da mesma. O\n   * consumidor persiste (status + ordem) e/ou revalida.\n   */\n  onMove?: (move: KanbanMove) => void;\n  /** DnD ligado. Off = board somente-leitura (ex.: board do cliente). */\n  enabled?: boolean;\n  /**\n   * Liga a seleção múltipla: marquee \"select by area\" (arrastar sobre o vazio) +\n   * shift/ctrl/cmd-clique num card. Só faz efeito com `enabled` (board editável).\n   * O consumidor desenha a UI de batch a partir de `onSelectionChange`.\n   */\n  selectable?: boolean;\n  /** Ids selecionados (controlado). Se omitido, o Kanban mantém a seleção interna. */\n  selectedIds?: string[];\n  /** Notifica a nova seleção — SSoT do consumidor + gatilho da barra de batch. */\n  onSelectionChange?: (ids: string[]) => void;\n  className?: string;\n  /** Classe extra por coluna (largura, etc.). */\n  columnClassName?: string;\n}\n",
      "type": "registry:component",
      "target": "~/components/kanban/types.ts"
    },
    {
      "path": "registry/visant/blocks/kanban/index.ts",
      "content": "export { Kanban } from \"./Kanban\";\nexport type {\n  KanbanColumn,\n  KanbanItem,\n  KanbanMove,\n  KanbanProps,\n  KanbanRenderCardArgs,\n} from \"./types\";\n",
      "type": "registry:component",
      "target": "~/components/kanban/index.ts"
    },
    {
      "path": "registry/visant/blocks/kanban/kanban.css",
      "content": "/*\n * Kanban primitive — tokens + estilos base.\n *\n * TODO visual sai daqui via CSS custom properties `--kanban-*`. Cada token cai\n * primeiro no token equivalente do design system Visant (`--t-*`, `--accent`) e,\n * se ele não existir (projeto de cliente sem o design system Visant), num valor\n * neutro embutido. Trocar a marca = sobrescrever `--kanban-*` (ou `--accent`),\n * nunca o componente.\n */\n.kanban-root {\n  --kanban-gap: 1rem;\n  --kanban-col-min: 280px;\n  --kanban-col-max: 480px;\n  --kanban-card-gap: 0.75rem;\n  --kanban-card-radius: var(--t-card-radius, 0.75rem);\n  --kanban-column-radius: var(--t-card-radius, 0.75rem);\n  --kanban-column-min-h: 120px;\n  /* Accent do realce: UM token de COR COMPLETA que o primitivo consome. Cada app\n     seta `--kanban-accent` (qualquer espaço de cor) num wrapper ancestral; o\n     default mora no fallback do var(), NO PONTO DE USO. NÃO declarar\n     `--kanban-accent` aqui em `.kanban-root`: custom-prop declarada no elemento\n     vence a herdada, então o valor do wrapper ancestral seria sombreado e o\n     bridge do app não pintaria. NÃO usar `hsl(var(--accent))`: quebra em silêncio\n     quando o host guarda --accent como cor oklch em vez de triplet HSL. */\n  --kanban-drop-ring: color-mix(in oklch, var(--kanban-accent, oklch(0.62 0.02 240)) 45%, transparent);\n  --kanban-drop-bg: color-mix(in oklch, var(--kanban-accent, oklch(0.62 0.02 240)) 8%, transparent);\n\n  display: flex;\n  gap: var(--kanban-gap);\n  width: 100%;\n}\n\n@media (min-width: 640px) {\n  .kanban-root {\n    --kanban-col-min: 320px;\n  }\n}\n\n.kanban-column {\n  flex: 1 1 0%;\n  min-width: var(--kanban-col-min);\n  max-width: var(--kanban-col-max);\n  border-radius: var(--kanban-column-radius);\n  /* Inerte sem um snap container — o wrapper mobile do KanbanBoard liga\n     `snap-x`; no desktop (sm:snap-none) isto não faz nada. */\n  scroll-snap-align: start;\n}\n\n/*\n * A COLUNA NÃO ACENDE MAIS. Era o defeito central do arraste.\n *\n * Antes, passar por cima pintava a coluna inteira de fundo e punha um anel de\n * 2px em volta dela. Isso responde a pergunta errada: a pessoa já sabe sobre\n * qual coluna está o cursor — ela quer saber ONDE o card vai parar, entre quais\n * dois vizinhos. Uma coluna de 500px acesa por causa de um card de 34px é ruído\n * do tamanho da tela, e é exatamente o que fazia o gesto parecer impreciso.\n *\n * O alvo agora é o slot (`.kanban-card.is-drop-slot`, abaixo): o próprio buraco\n * onde o card vai cair, no tamanho e no lugar exatos. A classe fica como gancho\n * pra quem quiser marcar a coluna no projeto do cliente, sem pintura por padrão.\n */\n.kanban-column.is-drop-target {\n  /* sem pintura — ver comentário acima */\n}\n\n.kanban-column-body {\n  display: flex;\n  flex-direction: column;\n  gap: var(--kanban-card-gap);\n  min-height: var(--kanban-column-min-h);\n}\n\n/* Mobile: a coluna rola internamente (Trello-like) — o header da coluna fica\n   sempre visível e uma coluna longa não vira um page-scroll infinito. O dnd-kit\n   auto-rola ancestrais scrolláveis, então drag dentro da coluna segue ok.\n   Desktop (≥640px) intocado: page scroll como sempre. */\n@media (max-width: 639px) {\n  .kanban-column-body {\n    max-height: calc(100dvh - 15rem);\n    overflow-y: auto;\n    padding-bottom: 0.25rem;\n  }\n}\n\n/* Toque: long-press no card é gesto de DRAG (250ms no TouchSensor) — sem\n   isto o browser responde primeiro com seleção de texto + callout do iOS e\n   quebra o gesto no meio. Mouse mantém seleção normal. */\n@media (max-width: 639px), (pointer: coarse) {\n  .kanban-card {\n    -webkit-user-select: none;\n    user-select: none;\n    -webkit-touch-callout: none;\n  }\n}\n\n/*\n * O deslocamento dos vizinhos abrindo espaço, na SSoT da casa.\n *\n * O dnd-kit escrevia `transition: transform 200ms` (e `transform linear` nos\n * vizinhos) direto no atributo style — dois tempos e duas curvas que ninguém\n * desta casa escolheu, e que nenhum arquivo de tokens alcançava. O KanbanCard\n * parou de repassar aquele valor pro style inline e o tempo passou a morar\n * aqui. Curva `out` e tempo longo: o vizinho sai na hora em que o cartão chega e\n * desacelera até o lugar, e um novo gesto pega ele de onde estiver.\n */\n.kanban-card {\n  transition-property: transform;\n  transition-duration: var(--dur-slow, 300ms);\n  transition-timing-function: var(--ease-out);\n\n  /*\n   * O contorno do slot existe SEMPRE, transparente — e é isso que faz a entrada\n   * do buraco ser suave.\n   *\n   * `outline-style` não é animável: enquanto o repouso era `outline: none`, o\n   * tracejado do slot aparecia em um quadro, no meio de um gesto em que todo o\n   * resto desliza. Declarado aqui com cor transparente, só a COR muda de estado.\n   * `outline` não ocupa espaço, então o card parado continua com a mesma caixa.\n   */\n  border-radius: var(--kanban-card-radius);\n  outline: 1.5px dashed transparent;\n  outline-offset: -1px;\n  background-color: transparent;\n}\n\n/*\n * O foco de teclado. O `outline` do card é do slot (tracejado do encaixe), então\n * o anel de foco mora no `box-shadow` — os dois nunca disputam a mesma\n * propriedade. Sem isto o card focado pelo Tab (o dnd-kit põe `tabindex=0` pra\n * mover pelo teclado) não mostrava onde o foco estava.\n */\n.kanban-card:focus-visible {\n  box-shadow: var(--focus, 0 0 0 2px var(--background), 0 0 0 4px var(--brand));\n}\n\n/*\n * O SLOT: o buraco onde o card vai cair, no lugar exato.\n *\n * Enquanto arrasta, o card de origem já vive na posição de destino (o\n * `onDragOver` move ele ao vivo). Antes ele ficava só com `opacity: .4` — e\n * como a demo aplicava OUTRO `.4` no conteúdo, o resultado real era 0.16:\n * um borrão que não se via. Ou seja, o alvo existia e era invisível; daí a\n * sensação de arrastar sem imã.\n *\n * Agora ele se desenha como um encaixe: contorno tracejado no accent da marca e\n * o conteúdo apagado. `outline`, e não `border`, porque outline não ocupa\n * espaço — o buraco fica com o tamanho EXATO do card, que é a única forma de o\n * overlay pousar em cima dele sem sobrar nem faltar pixel.\n */\n.kanban-card.is-drop-slot {\n  transition-property: transform, outline-color, background-color;\n  outline-color: var(--kanban-drop-ring);\n  background-color: var(--kanban-drop-bg);\n}\n\n/*\n * O aperto: antes de virar arraste, o cartão responde ao dedo e ao mouse. No toque\n * são 250ms de espera até levantar, e sem isto eles pareciam tela travada. O atraso\n * deixa passar o toque de quem está só rolando a página. A escala fica no conteúdo,\n * nunca no `.kanban-card`: é ele que o dnd-kit mede.\n */\n.kanban-card-movel > * {\n  transition: transform var(--dur-press, 120ms) var(--ease-out);\n}\n\n.kanban-card-movel:active:not(.is-drop-slot) > * {\n  transform: scale(0.985);\n  transition-delay: 60ms;\n}\n\n/*\n * No dedo o aviso é outro: `:active` só chega depois do atraso de toque do navegador\n * (medido em Chrome: nem aos 200ms), e 1,5% ficaria escondido sob a mão. O KanbanCard\n * marca `data-apertado` no `pointerdown`.\n */\n.kanban-card-movel[data-apertado]:not(.is-drop-slot) > * {\n  transform: scale(0.96);\n  transition-delay: 60ms;\n}\n\n/*\n * O buraco só anima ao ENTRAR. Ao sair, o fantasma está exatamente em cima dele e\n * os dois trocam de lugar no mesmo quadro: qualquer transição aqui aparece como o\n * cartão aceso pela metade depois de pousado.\n *\n * O buraco fica aceso até o fim do pouso (`landing`, em Kanban.tsx). Ao soltar, o\n * `isDragging` vira false na hora e o fantasma ainda tem a viagem inteira: antes o\n * destino piscava inteiro, apagava e acendia de novo, com dois cartões iguais na tela.\n */\n.kanban-card.is-drop-slot > * {\n  opacity: 0.12;\n  transition: opacity var(--dur-fast, 160ms) var(--ease-out);\n}\n\n.kanban-card-overlay {\n  cursor: grabbing;\n  /* Fallback no ponto de uso, e não herança: o overlay é portalizado no `body`\n     (ver a nota do bloco contenedor em Kanban.tsx), então ele não é descendente\n     do `.kanban-root` e não alcança nenhum `--kanban-*` declarado lá. */\n  border-radius: var(--kanban-card-radius, var(--t-card-radius, 0.75rem));\n  /* A sombra é o que diz \"este está no ar e os outros no papel\". Sem ela o card\n     que viaja tem o mesmo peso visual dos parados e o gesto parece um bug de\n     render. O anel é a metade que vale no escuro: preto sobre palco escuro não se\n     vê, e no toque o cartão levantava sem mudar nada à vista.\n     Nada de `scale` aqui: o cartão levanta do tamanho que tem. A inclinação com\n     mola vem do `CartaoNaMao`, em Kanban.tsx. */\n  box-shadow:\n    0 0 0 1px color-mix(in oklch, var(--foreground, black) 16%, transparent),\n    0 1px 2px color-mix(in oklch, black 16%, transparent),\n    0 16px 32px -8px color-mix(in oklch, black 45%, transparent);\n  /* A ENTRADA do gesto. O overlay nascia já com a sombra inteira: o card não era\n     \"pego\", ele aparecia no ar de um quadro pro outro, e o começo do arraste\n     ficava com a mesma dureza que o fim tinha antes de o pouso ser animado.\n     Agora a sombra CRESCE — o card sobe do papel em vez de já estar em cima.\n\n     Só `box-shadow` anima, e o motivo está no comentário acima: o dnd-kit lê o\n     transform computado DESTE nó pra calcular o pouso, então escala ou\n     deslocamento nossos entrariam na conta e errariam o alvo. */\n  animation: kanban-overlay-erguer var(--dur-base, 200ms)\n    var(--ease-out) backwards;\n}\n\n/* O pouso: a sombra assenta enquanto o cartão desce, em vez de sumir com ele. */\n.kanban-pousando .kanban-card-overlay {\n  box-shadow: none;\n  transition: box-shadow var(--dur-slow, 300ms) var(--ease-out);\n}\n\n@keyframes kanban-overlay-erguer {\n  from {\n    box-shadow:\n      0 0 0 0 transparent,\n      0 0 0 transparent,\n      0 0 0 -8px transparent;\n  }\n}\n\n/* Quem pediu menos movimento recebe o resultado, não o percurso — o pouso já é\n   zerado no JS (ver `readDropAnimation`), e aqui vai a metade CSS do mesmo\n   acordo, pra quem instalar o bloco num projeto sem o guard global da casa. */\n@media (prefers-reduced-motion: reduce) {\n  .kanban-card {\n    transition-duration: 0.001ms;\n  }\n  .kanban-card > * {\n    transition-duration: 0.001ms;\n  }\n  .kanban-card-movel:active:not(.is-drop-slot) > * {\n    transform: none;\n  }\n  .kanban-card-overlay {\n    animation-duration: 0.001ms;\n  }\n}\n\n/* Card na seleção múltipla — anel no accent da marca (fallback neutro). O ring\n   fica no wrapper; o conteúdo (card do consumidor) mantém o próprio raio. */\n.kanban-card[data-selected] {\n  border-radius: var(--kanban-card-radius);\n  box-shadow: 0 0 0 2px var(--kanban-accent, oklch(0.62 0.02 240));\n}\n",
      "type": "registry:file",
      "target": "~/styles/kanban.css"
    }
  ],
  "meta": {
    "uso": {
      "quando": "Board de tarefas ou pipeline com arrastar entre colunas e multi-seleção, em ferramenta interna",
      "evite": "Lista densa pra ordenar e editar: data-table; triagem rápida no celular, swipe-actions"
    }
  },
  "categories": [
    "conteudo",
    "board",
    "dnd",
    "selecao"
  ],
  "type": "registry:block"
}