{
  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
  "name": "board-kanban-ascii-wip",
  "title": "Board Kanban ASCII WIP",
  "description": "A kanban board drawn as box-drawing frames, each column header showing its card count against its WIP limit; going over turns the frame accent and appends the overflow count, mid-drag, before you release.",
  "dependencies": [],
  "files": [
    {
      "path": "registry/core/board-kanban-ascii-wip/component.tsx",
      "content": "\"use client\";\n\nimport {\n  useCallback,\n  useEffect,\n  useLayoutEffect,\n  useRef,\n  useState,\n  type KeyboardEvent as ReactKeyboardEvent,\n  type PointerEvent as ReactPointerEvent,\n  type ReactNode,\n} from \"react\";\n\n// ---------------------------------------------------------------------------\n// WipBoard — a kanban board whose column frames are real box-drawing glyphs.\n// Each column header reads `┌─ In Progress ───── 3/3 ─┐`; when the card count\n// exceeds the limit the counter gains a `▲1` suffix and the whole frame\n// switches from the resting muted ink to the accent token. Dragging a card\n// renders a ╌╌╌╌ placeholder at the live insertion point and drives the TARGET\n// column's counter with the PREDICTED count while the card is still in the air.\n// Over-limit drops are allowed: a WIP limit is a policy signal, not a lock, and\n// `onOverLimit` lets the consumer decide. Plain React state, no rAF loop and no\n// canvas; the only motion is a 120ms FLIP transform on card reflow, skipped\n// entirely under prefers-reduced-motion.\n// ---------------------------------------------------------------------------\n\nexport interface WipCard {\n  id: string;\n  /** short issue key rendered at the head of the row, e.g. \"ATL-214\" */\n  ref?: string;\n  title: string;\n  /** right-aligned trailing note: assignee, age, review count */\n  meta?: string;\n}\n\nexport interface WipColumn {\n  id: string;\n  title: string;\n  /** the column's WIP limit — the denominator of the header counter */\n  limit: number;\n  cards: WipCard[];\n}\n\nexport interface WipBoardProps {\n  /** the board's columns, each with its own WIP limit */\n  columns: WipColumn[];\n  /** column width in monospace character cells (the frame tiles to exactly this) */\n  width?: number;\n  /** fires on every committed move, pointer or keyboard */\n  onChange?: (columns: WipColumn[]) => void;\n  /** fires per commit for the receiving column: `over` is count - limit, 0 when within policy */\n  onOverLimit?: (columnId: string, over: number) => void;\n  /** extra classes merged onto the rendered root element */\n  className?: string;\n  /** accessible name for the board */\n  \"aria-label\"?: string;\n}\n\nconst DRAG_THRESHOLD = 4; // px of travel before a pointerdown becomes a live drag\nconst REFLOW_MS = 120;\nconst DASH = \"╌\";\n// the resting frame ink. NOT `text-border` — --border is tuned for 1px\n// hairlines and is invisible as type on the light theme (#ebebeb on #ffffff),\n// which would leave the box-drawing frame — the whole point of the component —\n// blank at rest. A muted tint reads in both themes and still sits below the\n// card text in the hierarchy.\nconst FRAME_INK = \"text-ns-muted/55\";\n\n/** `┌─ In Progress ───────── 3/3 ─┐` — exactly `width` characters wide. */\nfunction headerLine(title: string, count: number, limit: number, width: number) {\n  const over = Math.max(0, count - limit);\n  const label = over > 0 ? `${count}/${limit} ▲${over}` : `${count}/${limit}`;\n  const rule = \"─\".repeat(Math.max(1, width - 8 - title.length - label.length));\n  return `┌─ ${title} ${rule} ${label} ─┐`;\n}\n\nfunction moveCard(\n  cols: WipColumn[],\n  cardId: string,\n  toColId: string,\n  toIndex: number\n): WipColumn[] {\n  let card: WipCard | undefined;\n  const stripped = cols.map((c) => {\n    const found = c.cards.find((x) => x.id === cardId);\n    if (!found) return c;\n    card = found;\n    return { ...c, cards: c.cards.filter((x) => x.id !== cardId) };\n  });\n  if (!card) return cols;\n  const picked = card;\n  return stripped.map((c) => {\n    if (c.id !== toColId) return c;\n    const i = Math.min(c.cards.length, Math.max(0, toIndex));\n    return { ...c, cards: [...c.cards.slice(0, i), picked, ...c.cards.slice(i)] };\n  });\n}\n\ntype Drop = { col: string; index: number };\n\ntype DragState = {\n  id: string;\n  fromCol: string;\n  pointerId: number;\n  offsetX: number;\n  offsetY: number;\n  startX: number;\n  startY: number;\n  active: boolean;\n  width: number;\n  /** column boxes cached at pickup — recomputing them mid-drag would chase the placeholder */\n  colRects: { id: string; left: number; right: number }[];\n  /** per-column card mid-Y cached at pickup, in committed order */\n  cardMids: Map<string, { id: string; mid: number }[]>;\n};\n\nexport function WipBoard({\n  columns,\n  width = 34,\n  onChange,\n  onOverLimit,\n  className = \"\",\n  \"aria-label\": ariaLabel = \"Kanban board with WIP limits\",\n}: WipBoardProps) {\n  const [cols, setCols] = useState<WipColumn[]>(columns);\n  const [drop, setDrop] = useState<Drop | null>(null);\n  const [dragId, setDragId] = useState<string | null>(null);\n  const [liveMsg, setLiveMsg] = useState(\"\");\n\n  const colsRef = useRef(cols);\n  colsRef.current = cols;\n  const dragRef = useRef<DragState | null>(null);\n  const dropRef = useRef<Drop | null>(null);\n  dropRef.current = drop;\n\n  const boardRef = useRef<HTMLDivElement>(null);\n  const colEls = useRef<Map<string, HTMLDivElement>>(new Map());\n  const cardEls = useRef<Map<string, HTMLButtonElement>>(new Map());\n  const prevRects = useRef<Map<string, DOMRect>>(new Map());\n  const focusNext = useRef<string | null>(null);\n  const reducedRef = useRef(false);\n\n  useEffect(() => {\n    const mq = window.matchMedia(\"(prefers-reduced-motion: reduce)\");\n    const update = () => {\n      reducedRef.current = mq.matches;\n    };\n    update();\n    mq.addEventListener(\"change\", update);\n    return () => mq.removeEventListener(\"change\", update);\n  }, []);\n\n  // FLIP: cards live in normal flow, so a commit is measured before/after and\n  // played back as one short transform. Never runs mid-drag (the lifted card is\n  // position:fixed and its neighbours have already collapsed) or under\n  // reduced motion, where the reflow is simply instant.\n  useLayoutEffect(() => {\n    const next = new Map<string, DOMRect>();\n    cardEls.current.forEach((el, id) => next.set(id, el.getBoundingClientRect()));\n    if (!reducedRef.current && !dragRef.current) {\n      next.forEach((r, id) => {\n        const p = prevRects.current.get(id);\n        const el = cardEls.current.get(id);\n        if (!p || !el) return;\n        const dx = p.left - r.left;\n        const dy = p.top - r.top;\n        if (Math.abs(dx) < 0.5 && Math.abs(dy) < 0.5) return;\n        el.style.transition = \"none\";\n        el.style.transform = `translate3d(${dx.toFixed(1)}px, ${dy.toFixed(1)}px, 0)`;\n        requestAnimationFrame(() => {\n          if (!el.isConnected) return;\n          el.style.transition = `transform ${REFLOW_MS}ms cubic-bezier(0.2, 0, 0, 1)`;\n          el.style.transform = \"\";\n        });\n      });\n    }\n    prevRects.current = next;\n  });\n\n  useEffect(() => {\n    const id = focusNext.current;\n    if (!id) return;\n    focusNext.current = null;\n    cardEls.current.get(id)?.focus();\n  }, [cols]);\n\n  const announce = useCallback(\n    (card: WipCard, next: WipColumn[], toColId: string) => {\n      const col = next.find((c) => c.id === toColId);\n      if (!col) return;\n      const count = col.cards.length;\n      const over = Math.max(0, count - col.limit);\n      setLiveMsg(\n        `Moved ${card.title} to ${col.title}. ${count} of ${col.limit}` +\n          (over > 0 ? `, over limit by ${over}.` : \", within limit.\")\n      );\n      onOverLimit?.(col.id, over);\n    },\n    [onOverLimit]\n  );\n\n  const commit = useCallback(\n    (cardId: string, toColId: string, toIndex: number, refocus: boolean) => {\n      const prev = colsRef.current;\n      const card = prev.flatMap((c) => c.cards).find((x) => x.id === cardId);\n      const next = moveCard(prev, cardId, toColId, toIndex);\n      setCols(next);\n      onChange?.(next);\n      if (card) announce(card, next, toColId);\n      if (refocus) focusNext.current = cardId;\n    },\n    [announce, onChange]\n  );\n\n  const liftEnd = useCallback((id: string) => {\n    const el = cardEls.current.get(id);\n    if (!el) return;\n    el.style.position = \"\";\n    el.style.left = \"\";\n    el.style.top = \"\";\n    el.style.width = \"\";\n    el.style.zIndex = \"\";\n    el.style.transition = \"\";\n    el.style.transform = \"\";\n  }, []);\n\n  // Move/up live on the document, not on the card. A real pointer would be\n  // retargeted to the card by its own pointer capture, but the preview driver\n  // dispatches synthetic events to whatever it hit-tests under the cursor — so\n  // a card-scoped handler goes silent the moment the pointer crosses into\n  // another column. Document listeners receive both, and the drag survives.\n  const moveHandler = useRef<((e: PointerEvent) => void) | null>(null);\n  const upHandler = useRef<((e: PointerEvent) => void) | null>(null);\n\n  const detach = useCallback(() => {\n    if (moveHandler.current) document.removeEventListener(\"pointermove\", moveHandler.current);\n    if (upHandler.current) {\n      document.removeEventListener(\"pointerup\", upHandler.current);\n      document.removeEventListener(\"pointercancel\", upHandler.current);\n    }\n    moveHandler.current = null;\n    upHandler.current = null;\n  }, []);\n\n  const cancelDrag = useCallback(() => {\n    detach();\n    const d = dragRef.current;\n    if (!d) return;\n    dragRef.current = null;\n    // Escape ends the drag with no pointerup coming, so the capture the card\n    // took on pointerdown has to be handed back explicitly or the card keeps\n    // swallowing the pointer stream until the button is physically released.\n    const el = cardEls.current.get(d.id);\n    if (el?.hasPointerCapture(d.pointerId)) el.releasePointerCapture(d.pointerId);\n    if (d.active) liftEnd(d.id);\n    setDragId(null);\n    setDrop(null);\n  }, [detach, liftEnd]);\n\n  const handleMove = useCallback((e: PointerEvent) => {\n    const d = dragRef.current;\n    if (!d || d.pointerId !== e.pointerId) return;\n    const el = cardEls.current.get(d.id);\n    if (!el) return;\n\n    if (!d.active) {\n      const moved = Math.hypot(e.clientX - d.startX, e.clientY - d.startY);\n      if (moved <= DRAG_THRESHOLD) return;\n      d.active = true;\n      el.style.transition = \"none\";\n      el.style.transform = \"\";\n      el.style.position = \"fixed\";\n      el.style.width = `${d.width}px`;\n      el.style.zIndex = \"30\";\n      setDragId(d.id);\n    }\n\n    el.style.left = `${e.clientX - d.offsetX}px`;\n    el.style.top = `${e.clientY - d.offsetY}px`;\n\n    // target column: the box the pointer is inside, else the nearest edge\n    let colId = d.colRects[0]?.id ?? d.fromCol;\n    let best = Infinity;\n    for (const c of d.colRects) {\n      const dist = e.clientX < c.left ? c.left - e.clientX : e.clientX > c.right ? e.clientX - c.right : 0;\n      if (dist < best) {\n        best = dist;\n        colId = c.id;\n      }\n    }\n    const mids = (d.cardMids.get(colId) ?? []).filter((m) => m.id !== d.id);\n    let index = 0;\n    while (index < mids.length && mids[index].mid < e.clientY) index++;\n\n    const cur = dropRef.current;\n    if (!cur || cur.col !== colId || cur.index !== index) setDrop({ col: colId, index });\n  }, []);\n\n  const handleUp = useCallback(\n    (e: PointerEvent) => {\n      const d = dragRef.current;\n      if (!d || d.pointerId !== e.pointerId) return;\n      detach();\n      const card = cardEls.current.get(d.id);\n      if (card?.hasPointerCapture(e.pointerId)) card.releasePointerCapture(e.pointerId);\n      const target = dropRef.current;\n      const wasActive = d.active;\n      dragRef.current = null;\n      if (wasActive) liftEnd(d.id);\n      setDragId(null);\n      setDrop(null);\n      if (wasActive && target && e.type !== \"pointercancel\") {\n        commit(d.id, target.col, target.index, false);\n      }\n    },\n    [commit, detach, liftEnd]\n  );\n\n  const onPointerDown = useCallback(\n    (cardId: string, colId: string, e: ReactPointerEvent<HTMLButtonElement>) => {\n      const board = boardRef.current;\n      if (!board || e.button !== 0) return;\n      const rect = e.currentTarget.getBoundingClientRect();\n      e.currentTarget.setPointerCapture(e.pointerId);\n\n      const colRects = colsRef.current.map((c) => {\n        const el = colEls.current.get(c.id);\n        const r = el?.getBoundingClientRect();\n        return { id: c.id, left: r?.left ?? 0, right: r?.right ?? 0 };\n      });\n      const cardMids = new Map<string, { id: string; mid: number }[]>();\n      for (const c of colsRef.current) {\n        cardMids.set(\n          c.id,\n          c.cards.map((card) => {\n            const r = cardEls.current.get(card.id)?.getBoundingClientRect();\n            return { id: card.id, mid: r ? r.top + r.height / 2 : 0 };\n          })\n        );\n      }\n\n      dragRef.current = {\n        id: cardId,\n        fromCol: colId,\n        pointerId: e.pointerId,\n        offsetX: e.clientX - rect.left,\n        offsetY: e.clientY - rect.top,\n        startX: e.clientX,\n        startY: e.clientY,\n        active: false,\n        width: rect.width,\n        colRects,\n        cardMids,\n      };\n\n      detach();\n      moveHandler.current = handleMove;\n      upHandler.current = handleUp;\n      document.addEventListener(\"pointermove\", handleMove);\n      document.addEventListener(\"pointerup\", handleUp);\n      document.addEventListener(\"pointercancel\", handleUp);\n    },\n    [detach, handleMove, handleUp]\n  );\n\n  // a drag can outlive the component (unmount mid-flight); never leave the\n  // document listening to a handler whose state is gone\n  useEffect(() => detach, [detach]);\n\n  // Escape is a document listener, not a key handler on the card: the drag is\n  // in flight regardless of where focus happens to sit.\n  useEffect(() => {\n    function onKey(e: KeyboardEvent) {\n      if (e.key === \"Escape\" && dragRef.current) cancelDrag();\n    }\n    document.addEventListener(\"keydown\", onKey);\n    return () => document.removeEventListener(\"keydown\", onKey);\n  }, [cancelDrag]);\n\n  const onCardKeyDown = useCallback(\n    (cardId: string, colId: string, e: ReactKeyboardEvent<HTMLButtonElement>) => {\n      const cur = colsRef.current;\n      const ci = cur.findIndex((c) => c.id === colId);\n      if (ci < 0) return;\n      const idx = cur[ci].cards.findIndex((x) => x.id === cardId);\n      if (idx < 0) return;\n\n      if (e.key === \"ArrowLeft\" || e.key === \"ArrowRight\") {\n        const to = ci + (e.key === \"ArrowLeft\" ? -1 : 1);\n        if (to < 0 || to >= cur.length) return;\n        e.preventDefault();\n        commit(cardId, cur[to].id, Math.min(idx, cur[to].cards.length), true);\n        return;\n      }\n      if (e.key === \"ArrowUp\" || e.key === \"ArrowDown\") {\n        const to = idx + (e.key === \"ArrowUp\" ? -1 : 1);\n        if (to < 0 || to >= cur[ci].cards.length) return;\n        e.preventDefault();\n        commit(cardId, colId, to, true);\n      }\n    },\n    [commit]\n  );\n\n  const rowCount = Math.max(1, ...cols.map((c) => c.cards.length)) + 1;\n  const blank = `│${\" \".repeat(Math.max(0, width - 2))}│`;\n  const footer = `└${\"─\".repeat(Math.max(0, width - 2))}┘`;\n\n  return (\n    <div\n      ref={boardRef}\n      data-board\n      role=\"group\"\n      aria-label={ariaLabel}\n      className={`flex select-none items-start gap-3 font-mono text-xs leading-[1.7] ${className}`}\n    >\n      <div aria-live=\"polite\" role=\"status\" className=\"sr-only\">\n        {liveMsg}\n      </div>\n\n      {cols.map((col) => {\n        const isSource = dragId != null && col.cards.some((c) => c.id === dragId);\n        const isTarget = drop?.col === col.id;\n        // the predicted count: the lifted card has already left its source\n        // column and is already counted by whichever column it is over\n        const count = col.cards.length - (isSource ? 1 : 0) + (isTarget ? 1 : 0);\n        const over = Math.max(0, count - col.limit);\n        const rows: ReactNode[] = [];\n        const placeholder = (\n          <div key=\"ph\" className=\"flex whitespace-pre text-ns-accent\">\n            <span aria-hidden>│</span>\n            <span aria-hidden className=\"min-w-0 flex-1 overflow-hidden px-1\">\n              {DASH.repeat(Math.max(0, width - 4))}\n            </span>\n            <span aria-hidden>│</span>\n          </div>\n        );\n        // `slot` counts only the rows that actually occupy space: the lifted\n        // card is position:fixed, so it stays in the DOM (its pointer capture\n        // depends on it) but its slot has already collapsed.\n        let slot = 0;\n        let placed = false;\n\n        col.cards.forEach((card, i) => {\n          if (isTarget && drop && !placed && slot === drop.index) {\n            rows.push(placeholder);\n            placed = true;\n          }\n          if (card.id !== dragId) slot++;\n          rows.push(\n            // the lifted card is position:fixed, so its row must stop occupying\n            // a line too — otherwise the source column stands one row taller\n            // than its neighbours and the footers stop aligning mid-drag.\n            // `overflow-hidden` here cannot clip the card: no ancestor is\n            // transformed, so a fixed descendant escapes this box.\n            <div\n              key={card.id}\n              className={`flex whitespace-pre ${dragId === card.id ? \"h-0 overflow-hidden\" : \"\"}`}\n            >\n              <span aria-hidden>│</span>\n              <button\n                type=\"button\"\n                ref={(el) => {\n                  if (el) cardEls.current.set(card.id, el);\n                  else cardEls.current.delete(card.id);\n                }}\n                data-card={card.id}\n                aria-label={`${card.title}${card.ref ? `, ${card.ref}` : \"\"}. ${col.title}, position ${\n                  i + 1\n                } of ${col.cards.length}, column at ${col.cards.length} of ${col.limit}. Arrow keys move and reorder.`}\n                onPointerDown={(e) => onPointerDown(card.id, col.id, e)}\n                onKeyDown={(e) => onCardKeyDown(card.id, col.id, e)}\n                className={`flex min-w-0 flex-1 cursor-grab touch-none items-baseline gap-2 rounded-sm px-1 text-left text-ns-muted transition-colors duration-150 hover:bg-surface hover:text-foreground focus-visible:outline-2 focus-visible:-outline-offset-2 focus-visible:outline-ns-accent active:cursor-grabbing ${\n                  dragId === card.id ? \"bg-surface text-foreground\" : \"\"\n                }`}\n              >\n                {card.ref ? <span className=\"shrink-0 opacity-60\">{card.ref}</span> : null}\n                <span className=\"min-w-0 flex-1 truncate\">{card.title}</span>\n                {card.meta ? <span className=\"shrink-0 opacity-60\">{card.meta}</span> : null}\n              </button>\n              <span aria-hidden>│</span>\n            </div>\n          );\n        });\n\n        // insertion past the last card\n        if (isTarget && drop && !placed) {\n          rows.push(placeholder);\n          placed = true;\n        }\n\n        const occupied = slot + (placed ? 1 : 0);\n        for (let i = occupied; i < rowCount; i++) {\n          rows.push(\n            <div key={`b${i}`} aria-hidden className=\"whitespace-pre\">\n              {blank}\n            </div>\n          );\n        }\n\n        return (\n          <div\n            key={col.id}\n            ref={(el) => {\n              if (el) colEls.current.set(col.id, el);\n              else colEls.current.delete(col.id);\n            }}\n            data-column={col.id}\n            data-over={over > 0 ? \"true\" : undefined}\n            role=\"group\"\n            aria-label={`${col.title}, ${col.cards.length} of ${col.limit}${\n              col.cards.length > col.limit ? `, over limit by ${col.cards.length - col.limit}` : \"\"\n            }`}\n            style={{ width: `${width}ch` }}\n            className={`shrink-0 transition-colors duration-150 ${over > 0 ? \"text-ns-accent\" : FRAME_INK}`}\n          >\n            <div className=\"whitespace-pre\" aria-hidden>\n              {headerLine(col.title, count, col.limit, width)}\n            </div>\n            <div aria-hidden className=\"whitespace-pre\">\n              {blank}\n            </div>\n            {rows}\n            <div className=\"whitespace-pre\" aria-hidden>\n              {footer}\n            </div>\n          </div>\n        );\n      })}\n    </div>\n  );\n}\n",
      "type": "registry:ui",
      "target": "components/ui/board-kanban-ascii-wip.tsx"
    }
  ],
  "cssVars": {
    "theme": {
      "color-ns-muted": "var(--ns-muted)",
      "color-ns-accent": "var(--ns-accent)",
      "color-surface": "var(--surface)"
    },
    "light": {
      "ns-muted": "#4d4d4d",
      "ns-accent": "#006bff",
      "surface": "#fafafa"
    },
    "dark": {
      "ns-muted": "#8f8f8f",
      "surface": "#171717"
    }
  },
  "meta": {
    "collection": "core",
    "tags": [
      "kanban",
      "board",
      "ascii",
      "box-drawing",
      "drag",
      "wip-limit",
      "keyboard-navigation",
      "project-management"
    ],
    "instruction": "Build <WipBoard columns width? onChange? onOverLimit? className? aria-label?> as a kanban board whose column chrome is real box-drawing glyphs. FRAME: each column is exactly `width` monospace cells wide (default 34, set as `width: {n}ch` so the frame tiles to a whole character count) with a `┌─ In Progress ───────── 3/3 ─┐` header, per-row `│` side rules, blank `│    │` rails padding every column to a common row count, and a `└──────┘` footer. The header rule is uniform `─`, sized to `width − 8 − title.length − label.length` so the header is exactly `width` characters regardless of the label. LIMIT: the header label is a plain `count/limit` readout; when `count > limit` it reads `4/3 ▲1` and the whole column — frame, rails, footer and counter — switches from its resting muted ink to the `accent` token. There is no red, no amber, no fill colour and no glow: the overload state is one accent ink plus the number, so it survives both themes and reads at card scale. DRAG: `pointerdown` on a card's button takes `setPointerCapture` and then binds `pointermove`/`pointerup`/`pointercancel` on the DOCUMENT, not on the card — a real pointer would be retargeted to the card by its own capture, but a synthesised pointer (the catalog's preview driver) is dispatched to whatever sits under the cursor, so a card-scoped move handler goes silent the instant the pointer crosses into another column; the document sees both. Past a 4px threshold the card becomes `position: fixed` and tracks the pointer 1:1, and its row is collapsed to `h-0 overflow-hidden` so the source column does not stand a line taller than its neighbours while the card is airborne (no ancestor is transformed, so the fixed card escapes that clip). Column boxes and per-card mid-Y are cached ONCE at pickup — recomputing them mid-drag would make the hit test chase the placeholder it just opened. `pointermove` picks the target column by testing clientX against the cached column boxes (nearest edge when the pointer is between them) and the insertion index by counting cached card mid-Ys above clientY, excluding the dragged card. A `╌╌╌╌` dashed placeholder row opens at that index in the accent ink, and the target column's counter renders the PREDICTED count (`count + 1`) while the card is still in the air, the source column's `count − 1`, so you watch the limit tip over and flip the frame to accent BEFORE the pointer is released. `pointerup` commits; `Escape` mid-drag is a document-level listener (the drag is in flight regardless of where focus sits) that cancels and restores the origin and the true counts. Over-limit drops are deliberately ALLOWED — a WIP limit is a policy signal, not a lock — and `onOverLimit(columnId, over)` fires per commit so a consumer can warn, log or block. KEYBOARD / SEMANTICS: the header line is decorative (`aria-hidden`), so each column div carries `role=\"group\"` with `aria-label=\"Review, 5 of 3, over limit by 2\"` — otherwise an empty column would be entirely invisible to a screen reader. Every card is a real `<button>` with a full accessible name (title, issue ref, column, position, and the column's current count/limit) and a visible `focus-visible` accent outline inset by 2px so the ring sits inside the box rule. ArrowLeft/ArrowRight move the focused card between columns at the same clamped index, ArrowUp/ArrowDown reorder it within its column, both through the exact same `commit()` path as the pointer, focus follows the card across the move, and an `aria-live=\"polite\"` region announces `Moved Ship API pagination to In Progress. 4 of 3, over limit by 1.` MOTION: plain React state — no rAF loop, no canvas, nothing on a hot path. The only animation is a FLIP on commit: card rects are measured in `useLayoutEffect` before and after, the delta is applied as an instant inverse transform and released on the next frame over 120ms `cubic-bezier(0.2,0,0,1)`. It never runs mid-drag (the lifted card is fixed and its neighbours have already collapsed) and is skipped entirely when `prefers-reduced-motion: reduce` matches, where reflow is instant and the placeholder alone carries the anticipation. THEME: every colour is a token (`accent`, `muted`, `foreground`, `surface`) — the frame is `text-ns-muted/55` (deliberately NOT `text-border`: `--border` is tuned for 1px hairlines and is invisible as type on the light theme, #ebebeb on #ffffff, which would leave the box frame blank at rest) and switches to `text-ns-accent` on overload, a card is `text-ns-muted` at rest and rises to `text-foreground` on a `bg-surface` chip on hover, so both themes invert correctly with no hardcoded ink anywhere."
  },
  "type": "registry:ui"
}