{
  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
  "name": "signature-pad",
  "title": "Signature Pad",
  "author": "Visant Labs <visantsupply@gmail.com>",
  "description": "Campo de assinatura com tinta que engrossa e afina como caneta, com desfazer e limpar.",
  "dependencies": [
    "motion",
    "lucide-react"
  ],
  "registryDependencies": [
    "utils",
    "@visant/motion"
  ],
  "files": [
    {
      "path": "registry/visant/ui/signature-pad.tsx",
      "content": "\"use client\";\n\n/* Adaptado de Signature Pad — https://uiarc.dev/components/signature-pad — Copyright (c) 2026 Elia Kuratli, licença MIT (texto integral em ATTRIBUTIONS.md do @visant/ui). */\n\nimport * as React from \"react\";\nimport { AnimatePresence, animate, motion, useReducedMotion } from \"motion/react\";\nimport { Eraser, Redo2, Undo2, X } from \"lucide-react\";\n\nimport { DUR, EASE_OUT, INSTANT } from \"@/lib/motion\";\nimport { cn } from \"@/lib/utils\";\n\n/**\n * Signature Pad — o campo de assinatura com tinta de verdade.\n *\n * Fecho de contrato, aceite de proposta, recibo de entrega. Assinatura de\n * polilinha fina parece rabisco de teste; aqui a espessura acompanha a pressão\n * da caneta (ou, no mouse e no dedo, a velocidade: rápido afina, devagar\n * engrossa) e as pontas afinam como pena saindo do papel.\n *\n * ── O que não é óbvio ──────────────────────────────────────────────────────\n *\n * 1. **O traço é um contorno preenchido, não uma linha com `stroke-width`.**\n *    `getStrokeOutline` monta o polígono da tinta (no espírito do\n *    perfect-freehand): cada ponto anda só uma fração até o ponteiro, o que\n *    tira o tremido sem passada de suavização; curva fechada ganha junta\n *    redonda, e as duas pontas ganham tampa redonda.\n * 2. **As coordenadas moram num espaço de 600 por 260.** O campo guarda essa\n *    proporção, então a assinatura escala junto em qualquer largura. A conversão\n *    do ponteiro é uma RAZÃO do retângulo de tela, e por isso o palco escalado\n *    da vitrine não desloca a tinta.\n * 3. **Eventos coalescidos.** O navegador junta vários pontos num quadro; a\n *    peça lê todos (`getCoalescedEvents`), e a curva rápida não vira polígono.\n * 4. **Limpar é desfazível.** O rodo passa da esquerda pra direita levando a\n *    tinta, e \"Desfazer\" traz tudo de volta. Apagar sem volta não existe aqui.\n * 5. **A tinta é `currentColor`.** Veste o `text-foreground` do tema; quem\n *    exporta passa a cor concreta pra `signatureToSvg`, porque arquivo não lê\n *    token.\n *\n * Teclado no campo: Ctrl/Cmd+Z desfaz, com Shift refaz, Ctrl/Cmd+Y refaz,\n * Delete limpa. Os botões da barra fazem o mesmo, um Tab de cada vez.\n */\n\n/** Um ponto: posição no espaço do campo, pressão de 0 a 1 (ou -1 sem caneta) e ms desde o começo do traço. */\nexport interface InkPoint {\n  x: number;\n  y: number;\n  p: number;\n  t: number;\n}\nexport type InkWidth = \"fine\" | \"medium\" | \"bold\";\nexport interface InkStroke {\n  id: string;\n  points: InkPoint[];\n  width: InkWidth;\n}\n\nexport interface OutlineOptions {\n  /** Diâmetro do traço a meia pressão, em unidades do campo. */\n  size: number;\n  /** Quanto a pressão muda a largura, de 0 a 1. */\n  thinning?: number;\n  /** Quanto cada ponto atrasa atrás do ponteiro, de 0 a 1. Mais é mais liso e mais lento. */\n  streamline?: number;\n  /** Deriva pressão da velocidade quando o aparelho não informa. */\n  simulatePressure?: boolean;\n  /** Comprimento do afinamento no começo e no fim, em unidades do campo. */\n  taperStart?: number;\n  taperEnd?: number;\n  /** Falso enquanto o traço ainda está sendo feito: o fim não afina ainda. */\n  last?: boolean;\n}\n\n/** Espaço de coordenadas do campo. Os traços são guardados nele. */\nexport const PAD_WIDTH = 600;\nexport const PAD_HEIGHT = 260;\n\nconst LARGURAS: Record<InkWidth, { label: string; size: number }> = {\n  fine: { label: \"Fina\", size: 3.4 },\n  medium: { label: \"Média\", size: 5.6 },\n  bold: { label: \"Grossa\", size: 8.4 },\n};\nconst OPCOES_LARGURA = Object.keys(LARGURAS) as InkWidth[];\n\ntype Vec = [number, number];\nconst soma = (a: Vec, b: Vec): Vec => [a[0] + b[0], a[1] + b[1]];\nconst sub = (a: Vec, b: Vec): Vec => [a[0] - b[0], a[1] - b[1]];\nconst mul = (a: Vec, n: number): Vec => [a[0] * n, a[1] * n];\nconst lerp = (a: Vec, b: Vec, t: number): Vec => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];\nconst dist = (a: Vec, b: Vec) => Math.hypot(a[0] - b[0], a[1] - b[1]);\nconst unit = (a: Vec): Vec => {\n  const l = Math.hypot(a[0], a[1]);\n  return l ? [a[0] / l, a[1] / l] : [0, 0];\n};\nconst perp = (a: Vec): Vec => [a[1], -a[0]];\nconst dot = (a: Vec, b: Vec) => a[0] * b[0] + a[1] * b[1];\nconst girar = (p: Vec, c: Vec, r: number): Vec => {\n  const s = Math.sin(r);\n  const co = Math.cos(r);\n  const px = p[0] - c[0];\n  const py = p[1] - c[1];\n  return [px * co - py * s + c[0], px * s + py * co + c[1]];\n};\nconst easeOut = (t: number) => t * (2 - t);\n\n/** Transforma os pontos amostrados no contorno de um traço de largura variável. Ver a nota 1. */\nexport function getStrokeOutline(input: InkPoint[], options: OutlineOptions): Vec[] {\n  const {\n    size,\n    thinning = 0.62,\n    streamline = 0.42,\n    simulatePressure = true,\n    taperStart = 0,\n    taperEnd = 0,\n    last = true,\n  } = options;\n  const [cabeca] = input;\n  if (!cabeca) return [];\n  const caneta = !simulatePressure && input.some((p) => p.p > 0);\n\n  const pts: { at: Vec; pressure: number; length: number; vector: Vec }[] = [];\n  let ant: Vec = [cabeca.x, cabeca.y];\n  let comprimento = 0;\n  const inicio = { at: ant, pressure: caneta ? cabeca.p : 0.5, length: 0, vector: [1, 0] as Vec };\n  pts.push(inicio);\n  for (let i = 1; i < input.length; i++) {\n    const s = input[i]!;\n    const cru: Vec = [s.x, s.y];\n    const at = i === input.length - 1 && last ? cru : lerp(ant, cru, 1 - streamline);\n    const d = dist(at, ant);\n    if (d < 0.4) continue;\n    comprimento += d;\n    pts.push({ at, pressure: caneta ? s.p : 0.5, length: comprimento, vector: unit(sub(ant, at)) });\n    ant = at;\n  }\n  const segundo = pts[1];\n  if (segundo) inicio.vector = segundo.vector;\n  const total = comprimento;\n\n  // Um toque só: um ponto redondo do tamanho da primeira pressão.\n  if (pts.length === 1) {\n    const r = Math.max(0.6, size * (0.5 - thinning * (0.5 - inicio.pressure)) * 0.9);\n    return Array.from({ length: 18 }, (_, i) =>\n      soma(inicio.at, mul([Math.cos((i / 18) * Math.PI * 2), Math.sin((i / 18) * Math.PI * 2)], r)),\n    );\n  }\n\n  const esq: Vec[] = [];\n  const dir: Vec[] = [];\n  let pressao = inicio.pressure;\n  let vetorAnt = inicio.vector;\n  for (let i = 0; i < pts.length; i++) {\n    const ponto = pts[i]!;\n    if (!caneta) {\n      // Passo longo entre amostras é traço rápido, e traço rápido afina.\n      const passo = i === 0 ? 0 : dist(ponto.at, pts[i - 1]!.at);\n      const vel = Math.min(1, passo / size);\n      const alvo = Math.min(1, 1 - vel);\n      pressao = Math.min(1, pressao + (alvo - pressao) * vel * 0.3);\n    } else {\n      pressao = ponto.pressure;\n    }\n    let raio = Math.max(0.25, size * (0.5 - thinning * (0.5 - pressao)));\n    const ti = taperStart ? easeOut(Math.min(1, ponto.length / taperStart)) : 1;\n    const tf = taperEnd && last ? easeOut(Math.min(1, (total - ponto.length) / taperEnd)) : 1;\n    raio = Math.max(0.12 * size, raio * Math.min(ti, tf));\n\n    const prox = pts[i + 1]?.vector ?? ponto.vector;\n    const desvio = mul(perp(lerp(prox, ponto.vector, 0.5)), raio);\n    // Curva fechada: varre a quina em arco, senão o contorno estrangula.\n    if (i > 0 && i < pts.length - 1 && dot(ponto.vector, prox) < -0.2) {\n      const quina = mul(perp(vetorAnt), raio);\n      for (let t = 0; t <= 1; t += 1 / 12) {\n        esq.push(girar(sub(ponto.at, quina), ponto.at, Math.PI * t));\n        dir.push(girar(soma(ponto.at, quina), ponto.at, -Math.PI * t));\n      }\n    } else {\n      esq.push(sub(ponto.at, desvio));\n      dir.push(soma(ponto.at, desvio));\n    }\n    vetorAnt = ponto.vector;\n  }\n\n  // Tampas redondas: meia-volta em torno da primeira e da última amostra, do lado de fora.\n  const tampa = (centro: Vec, de: Vec, ate: Vec, fora: Vec) => {\n    const out: Vec[] = [];\n    const r = dist(centro, de);\n    const a0 = Math.atan2(de[1] - centro[1], de[0] - centro[0]);\n    const meio = a0 + Math.PI / 2;\n    const sinal = dot([Math.cos(meio), Math.sin(meio)], fora) >= 0 ? 1 : -1;\n    for (let k = 1; k < 12; k++) {\n      const a = a0 + (sinal * Math.PI * k) / 12;\n      out.push([centro[0] + Math.cos(a) * r, centro[1] + Math.sin(a) * r]);\n    }\n    out.push(ate);\n    return out;\n  };\n  const fim = pts[pts.length - 1]!;\n  const tampaFim = tampa(fim.at, esq[esq.length - 1]!, dir[dir.length - 1]!, mul(fim.vector, -1));\n  const tampaIni = tampa(inicio.at, dir[0]!, esq[0]!, inicio.vector);\n  return [...esq, ...tampaFim, ...dir.reverse(), ...tampaIni];\n}\n\nconst arred = (v: number) => Math.round(v * 100) / 100;\n/** Desenha o contorno como um caminho fechado e liso, com curvas quadráticas pelos pontos médios. */\nexport function outlineToPath(points: Vec[]) {\n  if (points.length < 3) return \"\";\n  let d = `M${arred(points[0]![0])} ${arred(points[0]![1])} Q`;\n  for (let i = 0; i < points.length; i++) {\n    const [x0, y0] = points[i]!;\n    const [x1, y1] = points[(i + 1) % points.length]!;\n    d += `${arred(x0)} ${arred(y0)} ${arred((x0 + x1) / 2)} ${arred((y0 + y1) / 2)} `;\n  }\n  return `${d}Z`;\n}\n\nfunction opcoesDoTraco(s: Pick<InkStroke, \"width\" | \"points\">, last: boolean): OutlineOptions {\n  const size = LARGURAS[s.width].size;\n  const caneta = s.points.some((p) => p.p > 0);\n  return { size, simulatePressure: !caneta, taperStart: size * 1.5, taperEnd: caneta ? 0 : size * 5, last };\n}\n\n/** O caminho SVG de um traço. */\nexport function strokePath(s: Pick<InkStroke, \"width\" | \"points\">) {\n  return outlineToPath(getStrokeOutline(s.points, opcoesDoTraco(s, true)));\n}\n\n/**\n * Um SVG solto da assinatura, recortado na tinta. `color` é a cor concreta\n * (`getComputedStyle(el).color`, por exemplo): arquivo exportado não lê token.\n */\nexport function signatureToSvg(strokes: InkStroke[], color: string) {\n  if (!strokes.length) return \"\";\n  let x0 = Infinity;\n  let y0 = Infinity;\n  let x1 = -Infinity;\n  let y1 = -Infinity;\n  for (const s of strokes)\n    for (const p of s.points) {\n      x0 = Math.min(x0, p.x);\n      y0 = Math.min(y0, p.y);\n      x1 = Math.max(x1, p.x);\n      y1 = Math.max(y1, p.y);\n    }\n  const m = 16;\n  const box = { x: Math.floor(x0 - m), y: Math.floor(y0 - m), w: Math.ceil(x1 - x0 + m * 2), h: Math.ceil(y1 - y0 + m * 2) };\n  const caminhos = strokes.map((s) => `<path d=\"${strokePath(s)}\"/>`).join(\"\");\n  return `<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"${box.x} ${box.y} ${box.w} ${box.h}\" width=\"${box.w}\" height=\"${box.h}\" fill=\"${color}\">${caminhos}</svg>`;\n}\n\nexport interface SignaturePadProps {\n  /** Impresso embaixo da linha, como o nome de quem assina. */\n  signer?: string;\n  /** Dica sobre a linha antes do primeiro traço. */\n  hint?: string;\n  defaultWidth?: InkWidth;\n  /** Recebe os traços depois de cada mudança. */\n  onChange?: (strokes: InkStroke[]) => void;\n  /** Nome do campo pro leitor de tela. */\n  label?: string;\n  className?: string;\n}\n\ninterface Historico {\n  past: InkStroke[][];\n  present: InkStroke[];\n  future: InkStroke[][];\n  /** O traço recém-feito já está na tela pelo caminho ao vivo: entra sem fade. */\n  fresh: string | null;\n}\n\n// Rodo e trocas respondem a clique: dentro dos 300 ms da casa.\nconst RODO = DUR.slow;\nconst EM_MEIO = [0.65, 0, 0.35, 1] as const;\nconst SAIDA = EASE_OUT;\nconst MOLA_FORMA = { type: \"spring\", visualDuration: 0.3, bounce: 0.14 } as const;\n\nconst nada = () => () => {};\nfunction useReduzir() {\n  const hidratado = React.useSyncExternalStore(nada, () => true, () => false);\n  return !!useReducedMotion() && hidratado;\n}\n\nconst foco = \"focus-visible:outline-none focus-visible:[box-shadow:var(--focus)]\";\nconst botaoIcone = cn(\n  \"relative grid size-9 pointer-coarse:after:absolute pointer-coarse:after:-inset-1 cursor-pointer place-items-center rounded-[var(--r-pill)] border-0 bg-transparent p-0 text-muted-foreground [-webkit-tap-highlight-color:transparent] [transition:background-color_var(--dur-fast)_var(--ease-out),color_var(--dur-fast)_var(--ease-out)] hover:enabled:bg-muted hover:enabled:text-foreground disabled:cursor-default disabled:opacity-45\",\n  foco,\n);\n\nexport function SignaturePad({\n  signer,\n  hint = \"Assine aqui\",\n  defaultWidth = \"medium\",\n  onChange,\n  label = \"Campo de assinatura\",\n  className,\n}: SignaturePadProps) {\n  const uid = React.useId().replace(/[^a-zA-Z0-9-]/g, \"\");\n  const reduzir = useReduzir();\n  const [hist, setHist] = React.useState<Historico>({ past: [], present: [], future: [], fresh: null });\n  const [largura, setLargura] = React.useState<InkWidth>(defaultWidth);\n  const [desenhando, setDesenhando] = React.useState(false);\n  const [rodando, setRodando] = React.useState(false);\n  const [status, setStatus] = React.useState(\"\");\n\n  const campo = React.useRef<HTMLDivElement>(null);\n  const tinta = React.useRef<HTMLDivElement>(null);\n  const aoVivo = React.useRef<SVGPathElement>(null);\n  const atual = React.useRef<{ id: number; stroke: InkStroke; stamp: number } | null>(null);\n  const rodo = React.useRef<{ complete: () => void } | null>(null);\n  const contador = React.useRef(0);\n  const aoMudar = React.useRef(onChange);\n  React.useEffect(() => {\n    aoMudar.current = onChange;\n  });\n\n  const tracos = hist.present;\n  const vazio = tracos.length === 0;\n\n  React.useEffect(() => {\n    aoMudar.current?.(tracos);\n  }, [tracos]);\n\n  const gravar = React.useCallback((prox: InkStroke[], fresh: string | null = null) => {\n    setHist((h) => ({ past: [...h.past, h.present].slice(-60), present: prox, future: [], fresh }));\n  }, []);\n  /** Rodo em voo termina na hora: o que vier depois começa de campo limpo. */\n  const assentarRodo = () => rodo.current?.complete();\n\n  function paraCampo(e: { clientX: number; clientY: number }) {\n    // Razão do retângulo de tela: a escala do palco entra em cima e embaixo e se anula.\n    const r = campo.current!.getBoundingClientRect();\n    return { x: ((e.clientX - r.left) / r.width) * PAD_WIDTH, y: ((e.clientY - r.top) / r.height) * PAD_HEIGHT };\n  }\n\n  function pintarAoVivo() {\n    const a = atual.current;\n    if (!a || !aoVivo.current) return;\n    aoVivo.current.setAttribute(\"d\", outlineToPath(getStrokeOutline(a.stroke.points, opcoesDoTraco(a.stroke, false))));\n  }\n\n  function onPointerDown(e: React.PointerEvent<HTMLDivElement>) {\n    if (atual.current || (e.pointerType === \"mouse\" && e.button !== 0)) return;\n    e.preventDefault();\n    assentarRodo();\n    campo.current?.focus({ preventScroll: true });\n    e.currentTarget.setPointerCapture(e.pointerId);\n    const { x, y } = paraCampo(e);\n    contador.current += 1;\n    const caneta = e.pointerType === \"pen\" && e.pressure > 0;\n    atual.current = {\n      id: e.pointerId,\n      stamp: e.nativeEvent.timeStamp,\n      stroke: { id: `${uid}-${contador.current}`, width: largura, points: [{ x, y, p: caneta ? e.pressure : -1, t: 0 }] },\n    };\n    setDesenhando(true);\n    pintarAoVivo();\n  }\n\n  function onPointerMove(e: React.PointerEvent<HTMLDivElement>) {\n    const a = atual.current;\n    if (!a || a.id !== e.pointerId) return;\n    const juntos = typeof e.nativeEvent.getCoalescedEvents === \"function\" ? e.nativeEvent.getCoalescedEvents() : [];\n    for (const s of juntos.length ? juntos : [e.nativeEvent]) {\n      const { x, y } = paraCampo(s);\n      const caneta = s.pointerType === \"pen\" && s.pressure > 0;\n      const ult = a.stroke.points[a.stroke.points.length - 1]!.t;\n      a.stroke.points.push({ x, y, p: caneta ? s.pressure : -1, t: Math.max(ult, s.timeStamp - a.stamp) });\n    }\n    pintarAoVivo();\n  }\n\n  function onPointerUp(e: React.PointerEvent<HTMLDivElement>) {\n    const a = atual.current;\n    if (!a || a.id !== e.pointerId) return;\n    atual.current = null;\n    gravar([...tracos, a.stroke], a.stroke.id);\n    aoVivo.current?.setAttribute(\"d\", \"\");\n    setDesenhando(false);\n    setStatus(`Traço feito. ${tracos.length + 1} na assinatura.`);\n  }\n\n  function desfazer() {\n    if (!hist.past.length || atual.current) return;\n    assentarRodo();\n    setHist((h) =>\n      h.past.length\n        ? { past: h.past.slice(0, -1), present: h.past[h.past.length - 1]!, future: [h.present, ...h.future], fresh: null }\n        : h,\n    );\n    setStatus(\"Desfeito\");\n  }\n\n  function refazer() {\n    if (!hist.future.length || atual.current) return;\n    assentarRodo();\n    setHist((h) =>\n      h.future.length ? { past: [...h.past, h.present], present: h.future[0]!, future: h.future.slice(1), fresh: null } : h,\n    );\n    setStatus(\"Refeito\");\n  }\n\n  function limpar() {\n    if (vazio || rodando || atual.current) return;\n    const no = tinta.current;\n    const terminar = () => {\n      rodo.current = null;\n      gravar([]);\n      setRodando(false);\n      setStatus(\"Assinatura apagada. Desfazer traz de volta.\");\n      // Só tira o recorte quando a tinta apagada já saiu, senão ela pisca um quadro.\n      if (no) requestAnimationFrame(() => requestAnimationFrame(() => (no.style.clipPath = \"\")));\n    };\n    if (!no || reduzir) {\n      terminar();\n      return;\n    }\n    setRodando(true);\n    // A tinta é cortada atrás da borda do rodo, que atravessa o campo.\n    const c = animate(no, { clipPath: [\"inset(0% 0% 0% 0%)\", \"inset(0% 0% 0% 100%)\"] }, { duration: RODO, ease: EM_MEIO });\n    rodo.current = { complete: () => c.complete() };\n    c.then(terminar);\n  }\n\n  function onKeyDown(e: React.KeyboardEvent<HTMLDivElement>) {\n    const mod = e.metaKey || e.ctrlKey;\n    const k = e.key.toLowerCase();\n    if (mod && k === \"z\") {\n      e.preventDefault();\n      if (e.shiftKey) refazer();\n      else desfazer();\n    } else if (mod && k === \"y\") {\n      e.preventDefault();\n      refazer();\n    } else if (!mod && (e.key === \"Delete\" || e.key === \"Backspace\") && e.currentTarget === e.target) {\n      e.preventDefault();\n      limpar();\n    }\n  }\n\n  const mostraDica = vazio && !desenhando && !rodando;\n  const dicaSome = reduzir ? { opacity: 0 } : { opacity: 0, y: 6, scale: 0.97, filter: \"blur(4px)\" };\n\n  return (\n    <div className={cn(\"grid w-full min-w-0 gap-2.5 text-foreground\", className)}>\n      <div\n        ref={campo}\n        tabIndex={0}\n        role=\"img\"\n        aria-roledescription=\"campo de assinatura\"\n        aria-label={`${label}. ${vazio ? \"Vazio.\" : `${tracos.length} ${tracos.length === 1 ? \"traço\" : \"traços\"}.`} Assine com mouse, caneta ou dedo.`}\n        aria-describedby={`${uid}-teclas`}\n        onPointerDown={onPointerDown}\n        onPointerMove={onPointerMove}\n        onPointerUp={onPointerUp}\n        onPointerCancel={onPointerUp}\n        onKeyDown={onKeyDown}\n        className={cn(\n          \"relative isolate aspect-[600/260] cursor-crosshair touch-none select-none overflow-hidden rounded-[var(--r-surface)] border bg-card [transition:border-color_var(--dur-fast)_var(--ease-out)]\",\n          desenhando ? \"border-foreground/40\" : \"border-border\",\n          foco,\n        )}\n      >\n        <div className=\"pointer-events-none absolute inset-0\" aria-hidden=\"true\">\n          <X className=\"absolute left-[7%] top-[72%] size-3.5 -translate-y-[calc(100%+6px)] text-muted-foreground\" strokeWidth={1.75} />\n          <span className=\"absolute inset-x-[7%] top-[72%] border-t-[1.5px] border-dashed border-foreground/25\" />\n          {signer && <span className=\"absolute left-[7%] top-[calc(72%+8px)] text-apoio text-muted-foreground\">{signer}</span>}\n          <AnimatePresence initial={false}>\n            {mostraDica && (\n              <motion.span\n                key=\"dica\"\n                className=\"absolute left-1/2 top-[72%] -translate-x-1/2 -translate-y-[calc(100%+8px)] whitespace-nowrap text-destaque text-muted-foreground\"\n                initial={dicaSome}\n                animate={{ opacity: 1, y: 0, scale: 1, filter: \"blur(0px)\" }}\n                exit={{ ...dicaSome, transition: { duration: DUR.fast, ease: SAIDA } }}\n                transition={{ duration: reduzir ? 0.12 : 0.24, ease: SAIDA }}\n              >\n                {hint}\n              </motion.span>\n            )}\n          </AnimatePresence>\n        </div>\n\n        <div ref={tinta} className=\"pointer-events-none absolute inset-0\">\n          <svg\n            viewBox={`0 0 ${PAD_WIDTH} ${PAD_HEIGHT}`}\n            preserveAspectRatio=\"none\"\n            aria-hidden=\"true\"\n            className=\"block size-full overflow-visible fill-current\"\n          >\n            <AnimatePresence initial={false}>\n              {tracos.map((s) => (\n                <motion.path\n                  key={s.id}\n                  d={strokePath(s)}\n                  initial={hist.fresh === s.id ? false : { opacity: 0 }}\n                  animate={{ opacity: 1 }}\n                  exit={{ opacity: 0, transition: { duration: rodando ? 0 : 0.2, ease: SAIDA } }}\n                  transition={{ duration: DUR.base, ease: SAIDA }}\n                />\n              ))}\n            </AnimatePresence>\n            <path ref={aoVivo} />\n          </svg>\n        </div>\n\n        {rodando && (\n          <motion.span\n            aria-hidden=\"true\"\n            className=\"pointer-events-none absolute inset-0\"\n            initial={{ x: \"0%\", opacity: 0 }}\n            animate={{ x: \"100%\", opacity: [0, 1, 1, 0] }}\n            transition={{ duration: RODO, ease: EM_MEIO, opacity: { duration: RODO, times: [0, 0.12, 0.85, 1] } }}\n          >\n            {/* A borda do rodo e o rastro claro que ele deixa. */}\n            <span className=\"absolute -left-px bottom-[8%] top-[8%] w-0.5 rounded-sm bg-foreground/50\" />\n            <span className=\"absolute -left-7 inset-y-0 w-7 bg-gradient-to-r from-transparent to-foreground/5\" />\n          </motion.span>\n        )}\n      </div>\n\n      <div className=\"flex flex-wrap items-center justify-between gap-2\">\n        <Espessura value={largura} onChange={(v) => { setLargura(v); setStatus(`Ponta ${LARGURAS[v].label.toLowerCase()}`); }} grupo={`${uid}-larg`} reduzir={reduzir} />\n        <div className=\"flex items-center gap-0.5 pointer-coarse:gap-2\">\n          <button type=\"button\" className={botaoIcone} aria-label=\"Desfazer\" title=\"Desfazer\" onClick={desfazer} disabled={!hist.past.length || rodando}>\n            <Undo2 size={18} strokeWidth={1.75} aria-hidden=\"true\" />\n          </button>\n          <button type=\"button\" className={botaoIcone} aria-label=\"Refazer\" title=\"Refazer\" onClick={refazer} disabled={!hist.future.length || rodando}>\n            <Redo2 size={18} strokeWidth={1.75} aria-hidden=\"true\" />\n          </button>\n          <button type=\"button\" className={botaoIcone} aria-label=\"Limpar assinatura\" title=\"Limpar\" onClick={limpar} disabled={vazio || rodando}>\n            <Eraser size={18} strokeWidth={1.75} aria-hidden=\"true\" />\n          </button>\n        </div>\n      </div>\n\n      <p id={`${uid}-teclas`} className=\"sr-only\">\n        Control ou Command mais Z desfaz, com Shift refaz, e Delete limpa.\n      </p>\n      <p className=\"sr-only\" role=\"status\" aria-live=\"polite\">\n        {status}\n      </p>\n    </div>\n  );\n}\n\n/** Grupo de rádio compacto: o realce desliza até a ponta escolhida, setas trocam. */\nfunction Espessura({\n  value,\n  onChange,\n  grupo,\n  reduzir,\n}: {\n  value: InkWidth;\n  onChange: (v: InkWidth) => void;\n  grupo: string;\n  reduzir: boolean;\n}) {\n  const refs = React.useRef<(HTMLButtonElement | null)[]>([]);\n  function onKeyDown(e: React.KeyboardEvent<HTMLDivElement>) {\n    const passo =\n      e.key === \"ArrowRight\" || e.key === \"ArrowDown\" ? 1 : e.key === \"ArrowLeft\" || e.key === \"ArrowUp\" ? -1 : 0;\n    if (!passo) return;\n    e.preventDefault();\n    const n = OPCOES_LARGURA.length;\n    const i = (OPCOES_LARGURA.indexOf(value) + passo + n) % n;\n    onChange(OPCOES_LARGURA[i]!);\n    refs.current[i]?.focus();\n  }\n  return (\n    <div className=\"flex items-center gap-0.5 pointer-coarse:gap-2\" role=\"radiogroup\" aria-label=\"Espessura da ponta\" onKeyDown={onKeyDown}>\n      {OPCOES_LARGURA.map((o, i) => (\n        <button\n          key={o}\n          ref={(n) => {\n            refs.current[i] = n;\n          }}\n          type=\"button\"\n          role=\"radio\"\n          aria-checked={o === value}\n          aria-label={LARGURAS[o].label}\n          title={LARGURAS[o].label}\n          tabIndex={o === value ? 0 : -1}\n          onClick={() => onChange(o)}\n          className={cn(\n            \"relative grid size-9 pointer-coarse:after:absolute pointer-coarse:after:-inset-1 cursor-pointer place-items-center rounded-[var(--r-pill)] border-0 bg-transparent p-0 [-webkit-tap-highlight-color:transparent]\",\n            foco,\n          )}\n        >\n          {o === value && (\n            <motion.span\n              layoutId={grupo}\n              className=\"absolute inset-0 rounded-[inherit] border border-border bg-muted\"\n              transition={reduzir ? INSTANT : MOLA_FORMA}\n            />\n          )}\n          <span\n            className=\"relative rounded-full bg-foreground\"\n            style={{ width: LARGURAS[o].size + 2, height: LARGURAS[o].size + 2 }}\n          />\n        </button>\n      ))}\n    </div>\n  );\n}\n",
      "type": "registry:ui"
    }
  ],
  "meta": {
    "uso": {
      "quando": "Coletar assinatura à mão em contrato, aceite ou comprovante de entrega, com desfazer e limpar",
      "evite": "Aceite simples de termos: checkbox do tema; confirmar pagamento, slide-to-confirm"
    }
  },
  "categories": [
    "controles",
    "assinatura",
    "formulario",
    "contrato",
    "aceite",
    "desenho"
  ],
  "type": "registry:ui"
}