{
  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
  "name": "chart-11",
  "title": "Lasso scatter",
  "description": "Every request a dot, coloured by model: a lasso drawn round a cluster fades the rest and the headline counts what it holds, its average and the model most of it belongs to; a model button selects the same way from the keyboard.",
  "dependencies": [
    "motion"
  ],
  "registryDependencies": [
    "https://ui.ndekocode.dev/r/agent-run.json",
    "https://ui.ndekocode.dev/r/badge.json",
    "https://ui.ndekocode.dev/r/button.json",
    "https://ui.ndekocode.dev/r/demonstration.json",
    "https://ui.ndekocode.dev/r/live-region.json",
    "https://ui.ndekocode.dev/r/motion-number.json",
    "https://ui.ndekocode.dev/r/motion-word-roll.json",
    "https://ui.ndekocode.dev/r/theme.json",
    "https://ui.ndekocode.dev/r/use-autoplay.json",
    "https://ui.ndekocode.dev/r/use-kept-height.json",
    "https://ui.ndekocode.dev/r/utils.json"
  ],
  "files": [
    {
      "path": "registry/ndeko/components/chart/chart-11.tsx",
      "content": "'use client';\n\nimport { animate } from 'motion/react';\nimport {\n  memo,\n  useEffect,\n  useImperativeHandle,\n  useMemo,\n  useRef,\n  useState,\n} from 'react';\n\nimport { MotionNumber } from '@/components/core/motion-number';\nimport { WordRoll } from '@/components/core/word-roll';\nimport type { AutoplayStep } from '@/registry/ndeko/hooks/use-autoplay';\nimport { seriesColorOf, type SeriesSlot } from '@/registry/ndeko/lib/agent-run';\nimport { hold, spokenUnless } from '@/registry/ndeko/lib/demonstration';\nimport { cn } from '@/registry/ndeko/lib/utils';\nimport { Button } from '@/registry/ndeko/ui/button';\nimport { LiveRegion } from '@/registry/ndeko/ui/live-region';\n\nimport {\n  CategoryAxis,\n  GridLines,\n  labelStepOf,\n  spacedLabelsOf,\n  ValueAxis,\n  type AxisLabel,\n} from './_parts/axis';\nimport { ChartCard } from './_parts/chart-card';\nimport { DataTable, type DataRow } from './_parts/data-table';\nimport { COUNT_FORMAT, formatCompact, formatCount } from './_parts/format';\nimport { PLOT_SURFACE } from './_parts/plot';\nimport { seededRandom, spreadOf } from './_parts/random';\nimport { Readout, ReadoutRow, ReadoutTitle } from './_parts/readout';\nimport {\n  clamp,\n  extentOf,\n  niceScaleOf,\n  percentOf,\n  ratioOf,\n  sumOf,\n  withZero,\n  type Scale,\n} from './_parts/scale';\nimport { useChartDemo } from './_parts/use-chart-demo';\nimport { usePlotWidth } from './_parts/use-plot-width';\nimport { readingAloud, useReading } from './_parts/use-reading';\n\ntype ValueFormat = (value: number) => string;\n\nexport type ScatterGroup = {\n  id: string;\n  name: string;\n  /** Fixed per group, so a colour always names the same thing. Three groups at most keep every pair apart. */\n  series: SeriesSlot;\n};\n\nexport type ScatterPoint = {\n  id: string;\n  groupId: string;\n  x: number;\n  y: number;\n};\n\n/** A place in the plot as shares of its width and height, from its top left corner. */\nexport type PlotPoint = {\n  x: number;\n  y: number;\n};\n\nexport type LassoScatterHandle = {\n  /** Draws a lasso through these places over a duration, then selects what it holds. */\n  trace: (path: readonly PlotPoint[], durationMs: number) => void;\n  /** Selects what a lasso holds at once, with nothing drawn on the way. */\n  select: (path: readonly PlotPoint[]) => void;\n  clear: () => void;\n};\n\nexport type LassoScatterProps = {\n  title: string;\n  /** A short mark beside the title, such as \"Illustrative\" over sample data. */\n  note?: string;\n  points: readonly ScatterPoint[];\n  groups: readonly ScatterGroup[];\n  /** What one point is, in the plural: \"requests\". And what a group is: \"models\". */\n  noun: string;\n  groupNoun?: string;\n  /** What each axis measures, as the readout says it: \"tokens\", \"latency\". */\n  xName: string;\n  yName: string;\n  /** Written after the average of the vertical measure: \"s\". */\n  yUnit?: string;\n  formatX?: ValueFormat;\n  formatY?: ValueFormat;\n  /** The lasso the piece opens with, so its first picture already reads a cluster. */\n  defaultLasso?: readonly PlotPoint[];\n  /** Draw or clear a lasso from outside, for a demonstration or a control beside the plot. */\n  handleRef?: React.Ref<LassoScatterHandle>;\n  className?: string;\n};\n\ntype Placed = {\n  point: ScatterPoint;\n  place: PlotPoint;\n  color: string;\n  groupName: string;\n};\n\ntype Selection = {\n  ids: ReadonlySet<string>;\n  /** The outline that was drawn, or null when a whole group was picked. */\n  lasso: readonly PlotPoint[] | null;\n  groupId: string | null;\n};\n\ntype Layout = {\n  xScale: Scale;\n  yScale: Scale;\n  /** The points from left to right: the order the arrow keys read them in. */\n  placed: Placed[];\n};\n\nconst PLOT_HEIGHT = 220;\n\nconst MAX_LINES = 4;\n\nconst FALLBACK_WIDTH = 460;\n\n/** The lasso is drawn in a box of this many units a side, stretched to the plot. */\nconst LASSO_UNITS = 1000;\n\n/** A lasso of fewer places than this is a click, which clears the selection. */\nconst MIN_LASSO_PLACES = 6;\n\n/** A new place is kept once the pointer has moved this share of the plot away from the last one. */\nconst MIN_STEP = 0.012;\n\n/** How close the pointer has to be to a point to read it, in pixels. */\nconst HOVER_REACH_PX = 28;\n\nconst FALLBACK_COLOR = 'var(--muted-foreground)';\n\nconst ORIGIN: PlotPoint = { x: 0, y: 0 };\n\nconst NO_LASSO: readonly PlotPoint[] = [];\n\nconst AVERAGE_FORMAT: Intl.NumberFormatOptions = {\n  minimumFractionDigits: 1,\n  maximumFractionDigits: 1,\n};\n\nconst AVERAGE = new Intl.NumberFormat('en-US', AVERAGE_FORMAT);\n\nfunction scaleOf(values: readonly number[]) {\n  const extent = extentOf(values);\n  const domain = withZero(extent);\n  return niceScaleOf(domain, MAX_LINES);\n}\n\nfunction colorOf(group: ScatterGroup | undefined) {\n  if (!group) {\n    return FALLBACK_COLOR;\n  }\n  return seriesColorOf(group.series);\n}\n\nfunction placeOf(point: ScatterPoint, xScale: Scale, yScale: Scale) {\n  const x = ratioOf(point.x, xScale);\n  const fromBottom = ratioOf(point.y, yScale);\n  const y = 1 - fromBottom;\n  return { x, y };\n}\n\nfunction layoutOf(\n  points: readonly ScatterPoint[],\n  groups: readonly ScatterGroup[]\n): Layout {\n  const xValues = points.map((point) => point.x);\n  const yValues = points.map((point) => point.y);\n  const xScale = scaleOf(xValues);\n  const yScale = scaleOf(yValues);\n  const placed = points.map((point): Placed => {\n    const group = groups.find((candidate) => candidate.id === point.groupId);\n    return {\n      point,\n      place: placeOf(point, xScale, yScale),\n      color: colorOf(group),\n      groupName: group?.name ?? '',\n    };\n  });\n  placed.sort((first, second) => first.place.x - second.place.x);\n  return { xScale, yScale, placed };\n}\n\n/** Whether a horizontal ray from a place crosses the edge between two corners of an outline. */\nfunction rayCrosses(place: PlotPoint, from: PlotPoint, to: PlotPoint) {\n  const isFromBelow = from.y > place.y;\n  const isToBelow = to.y > place.y;\n  if (isFromBelow === isToBelow) {\n    return false;\n  }\n  const run = to.x - from.x;\n  const rise = to.y - from.y;\n  const climbed = place.y - from.y;\n  const along = climbed / rise;\n  const travelled = along * run;\n  const crossingX = from.x + travelled;\n  return place.x < crossingX;\n}\n\n/** A place is inside an outline when a ray from it crosses the outline an odd number of times. */\nfunction isInside(place: PlotPoint, outline: readonly PlotPoint[]) {\n  let crossings = 0;\n  let previous = outline[outline.length - 1];\n  for (const corner of outline) {\n    if (rayCrosses(place, previous, corner)) {\n      crossings += 1;\n    }\n    previous = corner;\n  }\n  return crossings % 2 === 1;\n}\n\nfunction idsOf(entries: readonly Placed[]) {\n  const ids = entries.map((entry) => entry.point.id);\n  return new Set(ids);\n}\n\nfunction lassoSelectionOf(\n  placed: readonly Placed[],\n  lasso: readonly PlotPoint[]\n): Selection {\n  const held = placed.filter((entry) => isInside(entry.place, lasso));\n  return { ids: idsOf(held), lasso, groupId: null };\n}\n\nfunction groupSelectionOf(\n  placed: readonly Placed[],\n  groupId: string\n): Selection {\n  const members = placed.filter((entry) => entry.point.groupId === groupId);\n  return { ids: idsOf(members), lasso: null, groupId };\n}\n\nfunction initialSelectionOf(\n  placed: readonly Placed[],\n  lasso: readonly PlotPoint[] | undefined\n) {\n  if (!lasso) {\n    return null;\n  }\n  return lassoSelectionOf(placed, lasso);\n}\n\nfunction selectedOf(placed: readonly Placed[], selection: Selection | null) {\n  if (!selection) {\n    return placed;\n  }\n  return placed.filter((entry) => selection.ids.has(entry.point.id));\n}\n\n/** The outline of the selection, once the lasso that drew it is closed. */\nfunction settledLassoOf(selection: Selection | null, isDrawing: boolean) {\n  if (isDrawing) {\n    return NO_LASSO;\n  }\n  return selection?.lasso ?? NO_LASSO;\n}\n\nfunction cornerOf(place: PlotPoint) {\n  const x = place.x * LASSO_UNITS;\n  const y = place.y * LASSO_UNITS;\n  const left = x.toFixed(1);\n  const top = y.toFixed(1);\n  return `${left},${top}`;\n}\n\nfunction lassoPointsOf(path: readonly PlotPoint[]) {\n  const corners = path.map((place) => cornerOf(place));\n  return corners.join(' ');\n}\n\nfunction isFarEnough(from: PlotPoint, to: PlotPoint) {\n  const dx = Math.abs(to.x - from.x);\n  const dy = Math.abs(to.y - from.y);\n  return dx + dy >= MIN_STEP;\n}\n\nfunction placeFrom(event: React.PointerEvent<HTMLElement>): PlotPoint {\n  const box = event.currentTarget.getBoundingClientRect();\n  const left = event.clientX - box.left;\n  const top = event.clientY - box.top;\n  return { x: left / box.width, y: top / box.height };\n}\n\nfunction pixelsBetween(first: PlotPoint, second: PlotPoint, box: DOMRect) {\n  const dx = first.x - second.x;\n  const dy = first.y - second.y;\n  return Math.hypot(dx * box.width, dy * box.height);\n}\n\n/** The point nearest to the pointer, when one is within reach. */\nfunction nearestIndexOf(\n  placed: readonly Placed[],\n  event: React.PointerEvent<HTMLElement>\n) {\n  const box = event.currentTarget.getBoundingClientRect();\n  const pointer = placeFrom(event);\n  let nearest: number | null = null;\n  let nearestDistance = HOVER_REACH_PX;\n  for (const [index, entry] of placed.entries()) {\n    const distance = pixelsBetween(entry.place, pointer, box);\n    if (distance < nearestDistance) {\n      nearest = index;\n      nearestDistance = distance;\n    }\n  }\n  return nearest;\n}\n\ntype Figures = {\n  count: number;\n  /** The average of the vertical measure, and the group most points belong to. */\n  averageY: number;\n  leader: string;\n};\n\nfunction leaderOf(entries: readonly Placed[]) {\n  const counts = new Map<string, number>();\n  let leader = '';\n  let leaderCount = 0;\n  for (const entry of entries) {\n    const before = counts.get(entry.groupName) ?? 0;\n    const count = before + 1;\n    counts.set(entry.groupName, count);\n    if (count > leaderCount) {\n      leader = entry.groupName;\n      leaderCount = count;\n    }\n  }\n  return leader;\n}\n\nfunction figuresOf(entries: readonly Placed[]): Figures {\n  const values = entries.map((entry) => entry.point.y);\n  const count = entries.length;\n  const total = sumOf(values);\n  const divisor = Math.max(count, 1);\n  return { count, averageY: total / divisor, leader: leaderOf(entries) };\n}\n\nfunction dimmedOf(isDimmed: boolean) {\n  if (isDimmed) {\n    return 'opacity-[0.16]';\n  }\n  return undefined;\n}\n\ntype DotsProps = {\n  placed: readonly Placed[];\n  /** Null when nothing is selected: every dot is then drawn in full. */\n  selectedIds: ReadonlySet<string> | null;\n};\n\n/** Memoized: three hundred dots are only drawn again when the selection changes, not when a readout moves. */\nconst Dots = memo(function Dots({ placed, selectedIds }: DotsProps) {\n  return (\n    <svg\n      aria-hidden='true'\n      className='pointer-events-none absolute inset-0 size-full overflow-visible'\n    >\n      {placed.map((entry) => {\n        const isOutside =\n          selectedIds !== null && !selectedIds.has(entry.point.id);\n\n        return (\n          <circle\n            key={entry.point.id}\n            cx={percentOf(entry.place.x)}\n            cy={percentOf(entry.place.y)}\n            r={4}\n            className={cn(\n              'stroke-card [stroke-width:1.5] transition-opacity duration-200',\n              dimmedOf(isOutside)\n            )}\n            style={{ fill: entry.color }}\n          />\n        );\n      })}\n    </svg>\n  );\n});\n\nfunction pressedOf(isPressed: boolean) {\n  if (isPressed) {\n    return 'bg-foreground/[0.06]';\n  }\n  return undefined;\n}\n\ntype GroupPickerProps = {\n  groups: readonly ScatterGroup[];\n  selectedGroupId: string | null;\n  onToggle: (groupId: string) => void;\n  noun: string;\n};\n\n/** The legend is also the way in for the keyboard: a group button selects every point of that group. */\nfunction GroupPicker({\n  groups,\n  selectedGroupId,\n  onToggle,\n  noun,\n}: GroupPickerProps) {\n  return (\n    <div\n      role='group'\n      aria-label={`Select the ${noun} of one group`}\n      className='-mx-1.5 flex flex-wrap gap-x-1 gap-y-0.5'\n    >\n      {groups.map((group) => (\n        <button\n          key={group.id}\n          type='button'\n          aria-pressed={group.id === selectedGroupId}\n          onClick={() => onToggle(group.id)}\n          className={cn(\n            'hover:bg-foreground/5 focus-visible:ring-ring/25 flex h-7 cursor-pointer items-center gap-2 rounded-md px-1.5 text-xs outline-none',\n            'transition-[background-color,scale] duration-150 ease-(--ease-out-strong) focus-visible:ring-[3px] active:scale-[0.97]',\n            pressedOf(group.id === selectedGroupId)\n          )}\n        >\n          <span\n            aria-hidden='true'\n            className='size-2 shrink-0 rounded-full'\n            style={{ backgroundColor: seriesColorOf(group.series) }}\n          />\n          {group.name}\n        </button>\n      ))}\n    </div>\n  );\n}\n\n/** The last label of an axis names what the axis measures. */\nfunction lastLabelOf(text: string, name: string, isLast: boolean) {\n  if (isLast) {\n    return `${text} ${name}`;\n  }\n  return text;\n}\n\n/** The ticks that fit the width of the plot, counted back from the last, which names the measure. */\nfunction tickLabelsOf(\n  scale: Scale,\n  format: ValueFormat,\n  name: string,\n  plotWidth: number\n) {\n  const lastTick = scale.ticks[scale.ticks.length - 1];\n  const all = scale.ticks.map((tick): AxisLabel => {\n    const text = format(tick);\n    return {\n      id: String(tick),\n      text: lastLabelOf(text, name, tick === lastTick),\n      ratio: ratioOf(tick, scale),\n    };\n  });\n  const step = labelStepOf(all.length, plotWidth);\n  return spacedLabelsOf(all, step);\n}\n\n/** Without a selection the headline says how wide it reads; with one, which group leads in it. */\nfunction leaderWordsOf(\n  selection: Selection | null,\n  figures: Figures,\n  groupCount: number,\n  groupNoun: string\n) {\n  if (!selection) {\n    return `across ${groupCount} ${groupNoun}`;\n  }\n  return `mostly ${figures.leader}`;\n}\n\n/** A selection is said once a person has made one: what a demonstration draws stays silent. */\nfunction spokenSelectionOf(\n  selection: Selection | null,\n  headline: string,\n  hasSelectedByHand: boolean\n) {\n  if (!selection) {\n    return '';\n  }\n  return spokenUnless(!hasSelectedByHand, headline);\n}\n\nexport function LassoScatter({\n  title,\n  note,\n  points,\n  groups,\n  noun,\n  groupNoun = 'groups',\n  xName,\n  yName,\n  yUnit = '',\n  formatX = formatCompact,\n  formatY = formatCompact,\n  defaultLasso,\n  handleRef,\n  className,\n}: LassoScatterProps) {\n  const layout = useMemo(() => layoutOf(points, groups), [points, groups]);\n  const { placed, xScale, yScale } = layout;\n  const { plotRef, width } = usePlotWidth(FALLBACK_WIDTH);\n  const [selection, setSelection] = useState(() =>\n    initialSelectionOf(placed, defaultLasso)\n  );\n  const [isDrawing, setIsDrawing] = useState(false);\n  const [hasSelectedByHand, setHasSelectedByHand] = useState(false);\n  const lassoRef = useRef<SVGPolylineElement>(null);\n  const drawing = useRef<PlotPoint[] | null>(null);\n  const tracing = useRef<ReturnType<typeof animate> | null>(null);\n  const reading = useReading({ count: placed.length, defaultIndex: 0 });\n  const shown = placed.at(reading.shownIndex);\n  const shownPlace = shown?.place ?? ORIGIN;\n  const shownX = formatX(shown?.point.x ?? 0);\n  const shownY = formatY(shown?.point.y ?? 0);\n  const shownTop = shownPlace.y * PLOT_HEIGHT;\n  const isReadoutShown = reading.isActive && !isDrawing && shown !== undefined;\n  const selected = selectedOf(placed, selection);\n  const figures = figuresOf(selected);\n  const leaderWords = leaderWordsOf(\n    selection,\n    figures,\n    groups.length,\n    groupNoun\n  );\n  /** Last on its line, the phrase takes its new width at once: its words still roll, and no width is animated frame by frame. */\n  const leaderWidths = [leaderWords];\n  const averageText = AVERAGE.format(figures.averageY);\n  const headline = `${figures.count} ${noun}, ${averageText}${yUnit} average ${yName}, ${leaderWords}`;\n  const pointReading = `${shown?.groupName}: ${shownY} ${yName}, ${shownX} ${xName}`;\n  const spokenSelection = spokenSelectionOf(\n    selection,\n    headline,\n    hasSelectedByHand\n  );\n  const settledLasso = settledLassoOf(selection, isDrawing);\n\n  useEffect(() => {\n    return () => tracing.current?.stop();\n  }, []);\n\n  function writeLasso(path: readonly PlotPoint[]) {\n    lassoRef.current?.setAttribute('points', lassoPointsOf(path));\n  }\n\n  function stopTracing() {\n    tracing.current?.stop();\n    tracing.current = null;\n  }\n\n  function selectLasso(path: readonly PlotPoint[]) {\n    setIsDrawing(false);\n    setSelection(lassoSelectionOf(placed, path));\n  }\n\n  function clear() {\n    stopTracing();\n    setIsDrawing(false);\n    setSelection(null);\n  }\n\n  function trace(path: readonly PlotPoint[], durationMs: number) {\n    stopTracing();\n    setIsDrawing(true);\n    tracing.current = animate(0, path.length, {\n      duration: durationMs / 1000,\n      ease: 'linear',\n      onUpdate: (drawn) => {\n        const cornerCount = Math.ceil(drawn);\n        writeLasso(path.slice(0, cornerCount));\n      },\n      onComplete: () => selectLasso(path),\n    });\n  }\n\n  useImperativeHandle(handleRef, () => ({\n    trace,\n    clear,\n    select: selectLasso,\n  }));\n\n  function startLasso(event: React.PointerEvent<HTMLElement>) {\n    if (event.button !== 0) {\n      return;\n    }\n    stopTracing();\n    event.currentTarget.setPointerCapture(event.pointerId);\n    const path = [placeFrom(event)];\n    drawing.current = path;\n    reading.pointTo(null);\n    setHasSelectedByHand(true);\n    setIsDrawing(true);\n    writeLasso(path);\n  }\n\n  function movePointer(event: React.PointerEvent<HTMLElement>) {\n    const path = drawing.current;\n    if (!path) {\n      const nearest = nearestIndexOf(placed, event);\n      reading.pointTo(nearest);\n      return;\n    }\n    const place = placeFrom(event);\n    const last = path[path.length - 1];\n    if (isFarEnough(last, place)) {\n      path.push(place);\n      writeLasso(path);\n    }\n  }\n\n  function endLasso() {\n    const path = drawing.current;\n    if (!path) {\n      return;\n    }\n    drawing.current = null;\n    if (path.length < MIN_LASSO_PLACES) {\n      clear();\n      return;\n    }\n    selectLasso(path);\n  }\n\n  function cancelLasso() {\n    drawing.current = null;\n    setIsDrawing(false);\n  }\n\n  function toggleGroup(groupId: string) {\n    stopTracing();\n    setHasSelectedByHand(true);\n    setIsDrawing(false);\n    if (selection?.groupId === groupId) {\n      setSelection(null);\n      return;\n    }\n    setSelection(groupSelectionOf(placed, groupId));\n  }\n\n  function clearOnEscape(event: React.KeyboardEvent<HTMLElement>) {\n    if (event.key === 'Escape') {\n      clear();\n    }\n  }\n\n  const rows: DataRow[] = groups.map((group) => {\n    const members = placed.filter((entry) => entry.point.groupId === group.id);\n    const groupFigures = figuresOf(members);\n    const average = AVERAGE.format(groupFigures.averageY);\n    return {\n      id: group.id,\n      label: group.name,\n      cells: [formatCount(groupFigures.count), `${average}${yUnit}`],\n    };\n  });\n\n  return (\n    <ChartCard\n      title={title}\n      note={note}\n      summary={`${headline}.`}\n      className={className}\n      actions={\n        <Button\n          type='button'\n          variant='ghost'\n          size='sm'\n          disabled={selection === null}\n          onClick={clear}\n        >\n          Clear selection\n        </Button>\n      }\n    >\n      <div className='flex flex-col gap-4' onKeyDown={clearOnEscape}>\n        <p className='text-muted-foreground flex flex-wrap items-baseline gap-x-1.5 text-[13px]'>\n          <MotionNumber\n            value={figures.count}\n            format={COUNT_FORMAT}\n            className='text-foreground text-2xl leading-8 font-semibold'\n          />\n          <span>{noun},</span>\n          <MotionNumber\n            value={figures.averageY}\n            format={AVERAGE_FORMAT}\n            suffix={yUnit}\n            className='text-foreground font-medium'\n          />\n          <span>average {yName},</span>\n          <WordRoll\n            text={leaderWords}\n            labels={leaderWidths}\n            className='text-foreground font-medium'\n          />\n        </p>\n        <div className='grid grid-cols-[auto_minmax(0,1fr)] gap-x-2'>\n          <ValueAxis scale={yScale} height={PLOT_HEIGHT} format={formatY} />\n          <div\n            ref={plotRef}\n            role='group'\n            tabIndex={0}\n            aria-label={`${title}. Use the arrow keys to read each point from left to right, or pick a group below.`}\n            className={cn(PLOT_SURFACE, 'cursor-crosshair select-none')}\n            style={{ height: PLOT_HEIGHT }}\n            {...reading.markHandlers}\n            onPointerDown={startLasso}\n            onPointerMove={movePointer}\n            onPointerUp={endLasso}\n            onPointerCancel={cancelLasso}\n          >\n            <GridLines scale={yScale} height={PLOT_HEIGHT} />\n            <Dots placed={placed} selectedIds={selection?.ids ?? null} />\n            <svg\n              aria-hidden='true'\n              viewBox={`0 0 ${LASSO_UNITS} ${LASSO_UNITS}`}\n              preserveAspectRatio='none'\n              className='pointer-events-none absolute inset-0 size-full overflow-visible'\n            >\n              <polygon\n                points={lassoPointsOf(settledLasso)}\n                vectorEffect='non-scaling-stroke'\n                className='fill-foreground/[0.04] stroke-foreground/50 [stroke-width:1.5] [stroke-dasharray:4_3] [stroke-linejoin:round]'\n              />\n              <polyline\n                ref={lassoRef}\n                vectorEffect='non-scaling-stroke'\n                className={cn(\n                  'stroke-foreground/60 fill-none [stroke-width:1.5] [stroke-linecap:round] [stroke-linejoin:round]',\n                  !isDrawing && 'hidden'\n                )}\n              />\n            </svg>\n            {isReadoutShown && (\n              <span\n                aria-hidden='true'\n                className='ring-foreground/50 pointer-events-none absolute size-3.5 -translate-1/2 rounded-full ring-2'\n                style={{\n                  left: percentOf(shownPlace.x),\n                  top: percentOf(shownPlace.y),\n                }}\n              />\n            )}\n            <Readout\n              ratio={shownPlace.x}\n              top={shownTop}\n              isVisible={isReadoutShown}\n              isGliding={reading.isGliding}\n              hasCrosshair={false}\n            >\n              <ReadoutTitle>{shown?.groupName}</ReadoutTitle>\n              <ReadoutRow value={shownY} name={yName} color={shown?.color} />\n              <ReadoutRow value={shownX} name={xName} />\n            </Readout>\n          </div>\n          <span aria-hidden='true' />\n          <CategoryAxis\n            labels={tickLabelsOf(xScale, formatX, xName, width)}\n            className='mt-2'\n          />\n        </div>\n        <GroupPicker\n          groups={groups}\n          selectedGroupId={selection?.groupId ?? null}\n          onToggle={toggleGroup}\n          noun={noun}\n        />\n        <p className='text-muted-foreground text-xs text-pretty'>\n          Draw around a cluster, or pick a group, to read it. Escape clears the\n          selection\n        </p>\n      </div>\n      <LiveRegion\n        message={readingAloud(reading.isReadingByKeys, pointReading)}\n      />\n      <LiveRegion message={spokenSelection} />\n      <DataTable\n        caption={`${title}, by group`}\n        columns={['Group', noun, `Average ${yName}`]}\n        rows={rows}\n      />\n    </ChartCard>\n  );\n}\n\ntype Model = ScatterGroup & {\n  seed: number;\n  requestCount: number;\n  /** Where its requests gather: tokens, then seconds, each with how far they stray. */\n  tokens: number;\n  tokenSpread: number;\n  seconds: number;\n  secondSpread: number;\n};\n\nconst MODELS: Model[] = [\n  {\n    id: 'swift',\n    name: 'Lumen Swift',\n    series: 1,\n    seed: 7,\n    requestCount: 130,\n    tokens: 1400,\n    tokenSpread: 900,\n    seconds: 0.7,\n    secondSpread: 0.35,\n  },\n  {\n    id: 'standard',\n    name: 'Lumen',\n    series: 2,\n    seed: 19,\n    requestCount: 100,\n    tokens: 3500,\n    tokenSpread: 1100,\n    seconds: 1.5,\n    secondSpread: 0.45,\n  },\n  {\n    id: 'max',\n    name: 'Lumen Max',\n    series: 3,\n    seed: 43,\n    requestCount: 82,\n    tokens: 5900,\n    tokenSpread: 1300,\n    seconds: 2.8,\n    secondSpread: 0.6,\n  },\n];\n\nconst TOKEN_RANGE = { min: 80, max: 8000 };\n\nconst SECOND_RANGE = { min: 0.1, max: 4 };\n\n/** Longer requests take longer: a share of how far a request strays in tokens is added to its time. */\nconst TOKEN_PULL = 0.5;\n\nfunction requestOf(model: Model, index: number, next: () => number) {\n  const tokenDrift = spreadOf(next);\n  const pull = tokenDrift * TOKEN_PULL;\n  const timeDrift = spreadOf(next) + pull;\n  const tokenOffset = tokenDrift * model.tokenSpread;\n  const timeOffset = timeDrift * model.secondSpread;\n  const tokens = model.tokens + tokenOffset;\n  const seconds = model.seconds + timeOffset;\n  const point: ScatterPoint = {\n    id: `${model.id}-${index}`,\n    groupId: model.id,\n    x: clamp(tokens, TOKEN_RANGE.min, TOKEN_RANGE.max),\n    y: clamp(seconds, SECOND_RANGE.min, SECOND_RANGE.max),\n  };\n  return point;\n}\n\nfunction requestsOf(model: Model) {\n  const next = seededRandom(model.seed);\n  return Array.from({ length: model.requestCount }, (_, index) =>\n    requestOf(model, index, next)\n  );\n}\n\nconst REQUESTS = MODELS.flatMap((model) => requestsOf(model));\n\nconst LOOP_CORNERS = 40;\n\nconst FULL_TURN = Math.PI * 2;\n\n/** How uneven a loop is: a hand does not draw a perfect oval. */\nconst WOBBLE = 0.07;\n\ntype Oval = {\n  center: PlotPoint;\n  radiusX: number;\n  radiusY: number;\n};\n\nfunction cornerAt(oval: Oval, corner: number, next: () => number) {\n  const progress = corner / LOOP_CORNERS;\n  const turn = progress * FULL_TURN;\n  const stray = spreadOf(next) * WOBBLE;\n  const stretch = 1 + stray;\n  const offsetX = Math.cos(turn) * oval.radiusX;\n  const offsetY = Math.sin(turn) * oval.radiusY;\n  const x = oval.center.x + offsetX * stretch;\n  const y = oval.center.y + offsetY * stretch;\n  return { x, y };\n}\n\n/** A loop round a cluster, the way a hand draws it. */\nfunction loopOf(oval: Oval, seed: number): PlotPoint[] {\n  const next = seededRandom(seed);\n  return Array.from({ length: LOOP_CORNERS }, (_, corner) =>\n    cornerAt(oval, corner, next)\n  );\n}\n\nconst MAX_LOOP = loopOf(\n  { center: { x: 0.74, y: 0.3 }, radiusX: 0.21, radiusY: 0.24 },\n  5\n);\n\nconst SWIFT_LOOP = loopOf(\n  { center: { x: 0.18, y: 0.82 }, radiusX: 0.16, radiusY: 0.14 },\n  9\n);\n\nconst TRACE_MS = 1100;\n\n/** A selection stays long enough to be read once its lasso is closed. */\nconst READ_SWIFT_MS = TRACE_MS + 2600;\n\nconst READ_MAX_MS = TRACE_MS + 1800;\n\nfunction formatSeconds(seconds: number) {\n  const figure = AVERAGE.format(seconds);\n  return `${figure}s`;\n}\n\nexport default function Chart11() {\n  const handle = useRef<LassoScatterHandle>(null);\n\n  function resetDemo() {\n    handle.current?.select(MAX_LOOP);\n  }\n\n  const steps: AutoplayStep[] = [\n    { after: 2200, run: () => handle.current?.clear() },\n    { after: 900, run: () => handle.current?.trace(SWIFT_LOOP, TRACE_MS) },\n    { after: READ_SWIFT_MS, run: () => handle.current?.clear() },\n    { after: 900, run: () => handle.current?.trace(MAX_LOOP, TRACE_MS) },\n    { after: READ_MAX_MS, run: hold },\n  ];\n  const { ref, stopOnKeyboardFocus } = useChartDemo(steps, {\n    loopAfter: 1200,\n    onReset: resetDemo,\n  });\n\n  return (\n    <div\n      ref={ref}\n      onFocus={stopOnKeyboardFocus}\n      className='flex min-h-[28.5rem] w-full max-w-[34rem]'\n    >\n      <LassoScatter\n        title='Latency against tokens'\n        note='Illustrative'\n        points={REQUESTS}\n        groups={MODELS}\n        noun='requests'\n        groupNoun='models'\n        xName='tokens'\n        yName='latency'\n        yUnit='s'\n        formatY={formatSeconds}\n        defaultLasso={MAX_LOOP}\n        handleRef={handle}\n        className='w-full'\n      />\n    </div>\n  );\n}\n",
      "type": "registry:component",
      "target": "components/chart/chart-11.tsx"
    },
    {
      "path": "registry/ndeko/components/chart/_parts/axis.tsx",
      "content": "import { cn } from '@/registry/ndeko/lib/utils';\n\nimport { yOf } from './path';\nimport { columnCenterOf, percentOf, type Scale } from './scale';\n\n/** The least room one label of the category axis needs, text and breathing space. */\nexport const LABEL_ROOM_PX = 56;\n\ntype ValueAxisProps = {\n  scale: Scale;\n  height: number;\n  format: (value: number) => string;\n  className?: string;\n};\n\n/** The figures of the value axis, one per gridline, in a column beside the plot. */\nexport function ValueAxis({\n  scale,\n  height,\n  format,\n  className,\n}: ValueAxisProps) {\n  return (\n    <div\n      aria-hidden='true'\n      className={cn('relative w-9 shrink-0', className)}\n      style={{ height }}\n    >\n      {scale.ticks.map((tick) => (\n        <span\n          key={tick}\n          className='text-muted-foreground absolute right-0 -translate-y-1/2 text-[11px] tabular-nums'\n          style={{ top: yOf(tick, scale, height) }}\n        >\n          {format(tick)}\n        </span>\n      ))}\n    </div>\n  );\n}\n\n/** Zero is drawn stronger when values go below it, since bars start there. */\nexport function gridToneOf(tick: number, scale: Scale) {\n  const isZero = tick === 0;\n  const crossesZero = scale.min < 0;\n  if (isZero && crossesZero) {\n    return 'border-foreground/25';\n  }\n  return 'border-border';\n}\n\ntype GridLinesProps = {\n  scale: Scale;\n  height: number;\n};\n\nexport function GridLines({ scale, height }: GridLinesProps) {\n  return (\n    <div aria-hidden='true' className='pointer-events-none absolute inset-0'>\n      {scale.ticks.map((tick) => (\n        <span\n          key={tick}\n          className={cn(\n            'hairline-t absolute inset-x-0',\n            gridToneOf(tick, scale)\n          )}\n          style={{ top: yOf(tick, scale, height) }}\n        />\n      ))}\n    </div>\n  );\n}\n\nexport type AxisLabel = {\n  id: string;\n  text: string;\n  /** From 0 at the left edge of the plot to 1 at its right edge. */\n  ratio: number;\n  isStrong?: boolean;\n};\n\n/** Every how many positions a label is written, so the labels that are written never touch. */\nexport function labelStepOf(count: number, plotWidth: number) {\n  const fitting = Math.floor(plotWidth / LABEL_ROOM_PX);\n  const labelCount = Math.max(fitting, 1);\n  const step = Math.ceil(count / labelCount);\n  return Math.max(step, 1);\n}\n\n/** The labels kept when one in `step` is written, counted back from the last so the latest is always named. */\nexport function spacedLabelsOf(labels: readonly AxisLabel[], step: number) {\n  const lastIndex = labels.length - 1;\n  return labels.filter((_, index) => {\n    const fromLast = lastIndex - index;\n    return fromLast % step === 0;\n  });\n}\n\n/**\n * One label per position, under the middle of its column, written as often as the room allows. The\n * one at `strongIndex`, such as today, is set stronger.\n */\nexport function positionLabelsOf(\n  labels: readonly string[],\n  plotWidth: number,\n  strongIndex?: number\n) {\n  const all: AxisLabel[] = labels.map((text, index) => ({\n    id: `${index}-${text}`,\n    text,\n    ratio: columnCenterOf(index, labels.length),\n    isStrong: index === strongIndex,\n  }));\n  const step = labelStepOf(labels.length, plotWidth);\n  return spacedLabelsOf(all, step);\n}\n\nfunction strongOf(isStrong: boolean | undefined) {\n  if (isStrong) {\n    return 'text-foreground font-medium';\n  }\n  return 'text-muted-foreground';\n}\n\ntype LabelAlign = 'spread' | 'center';\n\n/**\n * A spread label slides from its left edge to its right edge as it crosses the plot, like the\n * readout, so the first and the last never stick out of the piece. A centred label sits under its\n * mark, for the few wide columns of a bar chart.\n */\nfunction labelStyleOf(\n  label: AxisLabel,\n  align: LabelAlign\n): React.CSSProperties {\n  const left = percentOf(label.ratio);\n  if (align === 'center') {\n    return { left, transform: 'translateX(-50%)' };\n  }\n  const shift = percentOf(-label.ratio);\n  return { left, transform: `translateX(${shift})` };\n}\n\ntype CategoryAxisProps = {\n  labels: readonly AxisLabel[];\n  align?: LabelAlign;\n  className?: string;\n};\n\nexport function CategoryAxis({\n  labels,\n  align = 'spread',\n  className,\n}: CategoryAxisProps) {\n  return (\n    <div aria-hidden='true' className={cn('relative h-4', className)}>\n      {labels.map((label) => (\n        <span\n          key={label.id}\n          className={cn(\n            'absolute top-0 text-[11px] whitespace-nowrap tabular-nums',\n            strongOf(label.isStrong)\n          )}\n          style={labelStyleOf(label, align)}\n        >\n          {label.text}\n        </span>\n      ))}\n    </div>\n  );\n}\n",
      "type": "registry:component",
      "target": "components/chart/_parts/axis.tsx"
    },
    {
      "path": "registry/ndeko/components/chart/_parts/chart-card.tsx",
      "content": "import { useId } from 'react';\n\nimport { cn } from '@/registry/ndeko/lib/utils';\nimport { Badge } from '@/registry/ndeko/ui/badge';\n\ntype ChartCardProps = {\n  title: string;\n  /** A short mark beside the title, such as \"Illustrative\" over sample data. */\n  note?: string;\n  /** One line that says what the chart shows, read by screen readers with the title. */\n  summary: string;\n  /** Controls that change what the chart draws: a period, a view. */\n  actions?: React.ReactNode;\n  className?: string;\n  children: React.ReactNode;\n};\n\n/**\n * The surface every chart sits on. It is a query container, so a chart lays itself out by the\n * room it has, and it is positioned, so the hidden table of a chart never widens the page.\n */\nexport function ChartCard({\n  title,\n  note,\n  summary,\n  actions,\n  className,\n  children,\n}: ChartCardProps) {\n  const titleId = useId();\n  const summaryId = useId();\n\n  return (\n    <section\n      aria-labelledby={titleId}\n      aria-describedby={summaryId}\n      className={cn(\n        'bg-card hairline-ring ring-border @container relative flex flex-col gap-4 rounded-xl p-4 shadow-[0_1px_2px_rgb(0_0_0/0.04)]',\n        className\n      )}\n    >\n      <header className='flex min-h-7 flex-wrap items-center justify-between gap-x-3 gap-y-2'>\n        <div className='flex min-w-0 items-center gap-2'>\n          <h3 id={titleId} className='text-sm font-medium text-balance'>\n            {title}\n          </h3>\n          {note && <Badge variant='secondary'>{note}</Badge>}\n        </div>\n        {actions}\n      </header>\n      {children}\n      <p id={summaryId} className='sr-only'>\n        {summary}\n      </p>\n    </section>\n  );\n}\n",
      "type": "registry:component",
      "target": "components/chart/_parts/chart-card.tsx"
    },
    {
      "path": "registry/ndeko/components/chart/_parts/data-table.tsx",
      "content": "export type DataRow = {\n  id: string;\n  /** The heading of the row: a day, a category, a step. */\n  label: string;\n  cells: readonly string[];\n};\n\ntype DataTableProps = {\n  caption: string;\n  /** The heading of the label column first, then one per cell. */\n  columns: readonly string[];\n  rows: readonly DataRow[];\n};\n\n/**\n * The numbers a chart draws, as a table for screen readers. It is taken out of the flow, so the\n * piece it sits in has to be positioned: a hidden box inside an area that scrolls sideways widens\n * the page otherwise.\n */\nexport function DataTable({ caption, columns, rows }: DataTableProps) {\n  return (\n    <table className='sr-only'>\n      <caption>{caption}</caption>\n      <thead>\n        <tr>\n          {columns.map((column) => (\n            <th key={column} scope='col'>\n              {column}\n            </th>\n          ))}\n        </tr>\n      </thead>\n      <tbody>\n        {rows.map((row) => (\n          <tr key={row.id}>\n            <th scope='row'>{row.label}</th>\n            {row.cells.map((cell, index) => (\n              <td key={index}>{cell}</td>\n            ))}\n          </tr>\n        ))}\n      </tbody>\n    </table>\n  );\n}\n",
      "type": "registry:component",
      "target": "components/chart/_parts/data-table.tsx"
    },
    {
      "path": "registry/ndeko/components/chart/_parts/format.ts",
      "content": "const LOCALE = 'en-US';\n\nexport const COUNT_FORMAT: Intl.NumberFormatOptions = {\n  maximumFractionDigits: 0,\n};\n\nexport const SIGNED_FORMAT: Intl.NumberFormatOptions = {\n  maximumFractionDigits: 0,\n  signDisplay: 'exceptZero',\n};\n\nexport const USD_COMPACT_FORMAT: Intl.NumberFormatOptions = {\n  style: 'currency',\n  currency: 'USD',\n  notation: 'compact',\n  maximumFractionDigits: 1,\n};\n\nconst COMPACT_FORMAT: Intl.NumberFormatOptions = {\n  notation: 'compact',\n  maximumFractionDigits: 1,\n};\n\nconst COUNT = new Intl.NumberFormat(LOCALE, COUNT_FORMAT);\n\nconst SIGNED = new Intl.NumberFormat(LOCALE, SIGNED_FORMAT);\n\nconst COMPACT = new Intl.NumberFormat(LOCALE, COMPACT_FORMAT);\n\nconst USD_COMPACT = new Intl.NumberFormat(LOCALE, USD_COMPACT_FORMAT);\n\nconst DAY = new Intl.DateTimeFormat(LOCALE, {\n  month: 'short',\n  day: 'numeric',\n  timeZone: 'UTC',\n});\n\nconst MS_PER_DAY = 86_400_000;\n\nexport function formatCount(value: number) {\n  return COUNT.format(value);\n}\n\nexport function formatSigned(value: number) {\n  return SIGNED.format(value);\n}\n\nexport function formatCompact(value: number) {\n  return COMPACT.format(value);\n}\n\nexport function formatUsd(value: number) {\n  return USD_COMPACT.format(value);\n}\n\nexport function formatShare(share: number) {\n  const percent = Math.round(share * 100);\n  return `${percent}%`;\n}\n\n/** A start at zero has no percentage to grow from: it reads as no change. */\nexport function percentChangeOf(current: number, previous: number) {\n  if (previous === 0) {\n    return 0;\n  }\n  const difference = current - previous;\n  const ratio = difference / Math.abs(previous);\n  return Math.round(ratio * 100);\n}\n\nexport function changeWordsOf(percent: number, reference: string) {\n  if (percent === 0) {\n    return `level with ${reference}`;\n  }\n  const size = Math.abs(percent);\n  if (percent > 0) {\n    return `up ${size}% on ${reference}`;\n  }\n  return `down ${size}% on ${reference}`;\n}\n\nexport function nounOf(count: number, singular: string, plural: string) {\n  if (count === 1) {\n    return singular;\n  }\n  return plural;\n}\n\n/**\n * One label per day, or per `everyDays` days for a weekly series. Days are counted in UTC so the\n * server and the browser write the same label.\n */\nexport function dayLabelsOf(firstDay: string, count: number, everyDays = 1) {\n  const start = Date.parse(`${firstDay}T00:00:00Z`);\n  const stride = everyDays * MS_PER_DAY;\n  return Array.from({ length: count }, (_, index) => {\n    const elapsed = index * stride;\n    return DAY.format(start + elapsed);\n  });\n}\n",
      "type": "registry:component",
      "target": "components/chart/_parts/format.ts"
    },
    {
      "path": "registry/ndeko/components/chart/_parts/path.ts",
      "content": "import { columnCenterOf, lerp, ratioOf, type Domain } from './scale';\n\nexport type Point = {\n  x: number;\n  y: number;\n};\n\n/** Paths are drawn in a box this wide and stretched to the plot, so a change of width never redraws them. */\nexport const VIEW_WIDTH = 1000;\n\nfunction commandOf(point: Point, index: number) {\n  const x = point.x.toFixed(1);\n  const y = point.y.toFixed(1);\n  if (index === 0) {\n    return `M${x} ${y}`;\n  }\n  return `L${x} ${y}`;\n}\n\nexport function linePathOf(points: readonly Point[]) {\n  const commands = points.map((point, index) => commandOf(point, index));\n  return commands.join(' ');\n}\n\n/** The line closed down (or up) to a level, for the wash under a line. */\nexport function areaPathOf(points: readonly Point[], levelY: number) {\n  if (points.length === 0) {\n    return '';\n  }\n  const line = linePathOf(points);\n  const lastIndex = points.length - 1;\n  const firstX = points[0].x.toFixed(1);\n  const lastX = points[lastIndex].x.toFixed(1);\n  const level = levelY.toFixed(1);\n  return `${line} L${lastX} ${level} L${firstX} ${level} Z`;\n}\n\n/** The surface between two lines that share their x positions, for a range around a line. */\nexport function bandPathOf(upper: readonly Point[], lower: readonly Point[]) {\n  if (upper.length === 0) {\n    return '';\n  }\n  const backwards = [...lower].reverse();\n  const outline = [...upper, ...backwards];\n  const line = linePathOf(outline);\n  return `${line} Z`;\n}\n\n/** The pixel height of a value in a plot: the top of the domain is 0, its bottom is the plot height. */\nexport function yOf(value: number, domain: Domain, height: number) {\n  const ratio = ratioOf(value, domain);\n  const fromBottom = ratio * height;\n  return height - fromBottom;\n}\n\n/** One point per value, each in the middle of its column. */\nexport function plotPointsOf(\n  values: readonly number[],\n  domain: Domain,\n  height: number\n): Point[] {\n  return values.map((value, index) => {\n    const share = columnCenterOf(index, values.length);\n    const x = share * VIEW_WIDTH;\n    const y = yOf(value, domain, height);\n    return { x, y };\n  });\n}\n\n/** How many of the pieces lie before a segment when they are shared out evenly. */\nfunction piecesBefore(\n  segment: number,\n  segmentCount: number,\n  pieceCount: number\n) {\n  const share = segment / segmentCount;\n  return Math.floor(share * pieceCount);\n}\n\n/**\n * The same line through exactly `count` points: each segment is cut into equal parts, so two lines\n * of different lengths share one structure and one can glide into the other.\n */\nexport function densifyOf(points: readonly Point[], count: number): Point[] {\n  const segmentCount = points.length - 1;\n  const hasSegments = segmentCount >= 1;\n  const hasRoom = count > points.length;\n  if (!hasSegments || !hasRoom) {\n    return [...points];\n  }\n  const pieceCount = count - 1;\n  const dense: Point[] = [points[0]];\n  for (let segment = 0; segment < segmentCount; segment += 1) {\n    const from = points[segment];\n    const to = points[segment + 1];\n    const start = piecesBefore(segment, segmentCount, pieceCount);\n    const end = piecesBefore(segment + 1, segmentCount, pieceCount);\n    const parts = end - start;\n    for (let part = 1; part <= parts; part += 1) {\n      const amount = part / parts;\n      const x = lerp(from.x, to.x, amount);\n      const y = lerp(from.y, to.y, amount);\n      dense.push({ x, y });\n    }\n  }\n  return dense;\n}\n",
      "type": "registry:component",
      "target": "components/chart/_parts/path.ts"
    },
    {
      "path": "registry/ndeko/components/chart/_parts/plot.tsx",
      "content": "import { cn } from '@/registry/ndeko/lib/utils';\n\nimport { CategoryAxis, GridLines, ValueAxis, type AxisLabel } from './axis';\nimport { VIEW_WIDTH } from './path';\nimport type { Scale } from './scale';\n\n/**\n * A plot is a query container, so the readout and the marks inside it are placed in shares of its\n * width, and it lets the page scroll vertically under a finger while a sideways move reads values.\n */\nexport const PLOT_SURFACE =\n  'focus-visible:ring-ring/25 @container relative touch-pan-y rounded-md outline-none focus-visible:ring-[3px]';\n\ntype PlotFrameProps = {\n  /** The name of the plot and how to read it, for screen readers. */\n  label: string;\n  scale: Scale;\n  height: number;\n  formatTick: (value: number) => string;\n  axisLabels: readonly AxisLabel[];\n  axisAlign?: 'spread' | 'center';\n  /** Receives the plot element, for a chart that measures the room it has. */\n  plotRef?: (element: HTMLDivElement | null) => void;\n  /** The handlers of the reading: the plot is the one tab stop of the chart. */\n  plotProps?: React.HTMLAttributes<HTMLDivElement>;\n  plotClassName?: string;\n  /** For a chart whose marks carry their own figures, which can drop the axis on a narrow piece. */\n  valueAxisClassName?: string;\n  /** Labels laid out by the chart itself, in place of one row of `axisLabels`. */\n  categoryAxis?: React.ReactNode;\n  className?: string;\n  children: React.ReactNode;\n};\n\n/**\n * A plot between its value axis on the left and its category axis underneath. Each part has its own\n * cell: placed in turn, a plot whose value axis is hidden would fall into the axis column, which is\n * only as wide as its content, and nothing in a plot has a width of its own, so every mark would\n * stack at the left edge.\n */\nexport function PlotFrame({\n  label,\n  scale,\n  height,\n  formatTick,\n  axisLabels,\n  axisAlign,\n  plotRef,\n  plotProps,\n  plotClassName,\n  valueAxisClassName,\n  categoryAxis,\n  className,\n  children,\n}: PlotFrameProps) {\n  return (\n    <div\n      className={cn('grid grid-cols-[auto_minmax(0,1fr)] gap-x-2', className)}\n    >\n      <ValueAxis\n        scale={scale}\n        height={height}\n        format={formatTick}\n        className={cn('col-start-1 row-start-1', valueAxisClassName)}\n      />\n      <div\n        ref={plotRef}\n        role='group'\n        tabIndex={0}\n        aria-label={label}\n        className={cn(PLOT_SURFACE, 'col-start-2 row-start-1', plotClassName)}\n        style={{ height }}\n        {...plotProps}\n      >\n        <GridLines scale={scale} height={height} />\n        {children}\n      </div>\n      <div className='col-start-2 row-start-2 min-w-0'>\n        {categoryAxis}\n        {!categoryAxis && (\n          <CategoryAxis\n            labels={axisLabels}\n            align={axisAlign}\n            className='mt-2'\n          />\n        )}\n      </div>\n    </div>\n  );\n}\n\ntype PathLayerProps = {\n  height: number;\n  className?: string;\n  children: React.ReactNode;\n};\n\n/**\n * The layer the paths are drawn in: `VIEW_WIDTH` units across whatever the width of the plot, and\n * real pixels down. Strokes keep their thickness because each path opts out of the stretch.\n */\nexport function PathLayer({ height, className, children }: PathLayerProps) {\n  return (\n    <svg\n      aria-hidden='true'\n      viewBox={`0 0 ${VIEW_WIDTH} ${height}`}\n      preserveAspectRatio='none'\n      className={cn(\n        'pointer-events-none absolute inset-0 size-full overflow-visible',\n        className\n      )}\n    >\n      {children}\n    </svg>\n  );\n}\n",
      "type": "registry:component",
      "target": "components/chart/_parts/plot.tsx"
    },
    {
      "path": "registry/ndeko/components/chart/_parts/random.ts",
      "content": "const UINT_RANGE = 4_294_967_296;\n\nconst MULTIPLIER = 1_664_525;\n\nconst INCREMENT = 1_013_904_223;\n\n/**\n * Numbers between 0 and 1 drawn from a seed, the same on the server and in the browser, so sample\n * data never changes between two renders.\n */\nexport function seededRandom(seed: number) {\n  let state = seed >>> 0;\n\n  return function next() {\n    const multiplied = Math.imul(state, MULTIPLIER);\n    state = (multiplied + INCREMENT) >>> 0;\n    return state / UINT_RANGE;\n  };\n}\n\n/** A draw between -1 and 1 that favours small steps, from two flat draws. */\nexport function spreadOf(next: () => number) {\n  const first = next();\n  const second = next();\n  return first + second - 1;\n}\n",
      "type": "registry:component",
      "target": "components/chart/_parts/random.ts"
    },
    {
      "path": "registry/ndeko/components/chart/_parts/readout.tsx",
      "content": "import { cn } from '@/registry/ndeko/lib/utils';\n\nconst GLIDE = 'transition-transform duration-200 ease-(--ease-out-strong)';\n\n/** A mark on the crosshair travels with the reading, and appears in place when the reading opens. */\nconst MARK_GLIDE =\n  'group-data-gliding/readout:transition-transform group-data-gliding/readout:duration-200 group-data-gliding/readout:ease-(--ease-out-strong)';\n\nfunction glideOf(isGliding: boolean) {\n  if (isGliding) {\n    return GLIDE;\n  }\n  return undefined;\n}\n\nfunction fadedUnless(isVisible: boolean) {\n  if (isVisible) {\n    return undefined;\n  }\n  return 'opacity-0';\n}\n\nfunction glidingAttributeOf(isGliding: boolean) {\n  if (isGliding) {\n    return true;\n  }\n  return undefined;\n}\n\ntype ReadoutProps = {\n  /** From 0 at the left edge of the plot to 1 at its right edge. */\n  ratio: number;\n  /** Pixels from the top of the plot down to the point the bubble sits on. */\n  top: number;\n  isVisible: boolean;\n  /** True while the reading moves to another position: the bubble travels. False when it opens. */\n  isGliding: boolean;\n  hasCrosshair?: boolean;\n  /** What is drawn on the crosshair itself, such as the dot of each series. */\n  marks?: React.ReactNode;\n  children: React.ReactNode;\n};\n\n/**\n * The one readout of a plot: a crosshair, the marks on it and a bubble. The plot is a query\n * container (`@container`), so every position is a share of its width and nothing is measured. The\n * bubble slides from its left edge to its right edge as it crosses the plot, so it never leaves it.\n * It stays mounted to fade out where it was.\n */\nexport function Readout({\n  ratio,\n  top,\n  isVisible,\n  isGliding,\n  hasCrosshair = true,\n  marks,\n  children,\n}: ReadoutProps) {\n  const glide = glideOf(isGliding);\n  const faded = fadedUnless(isVisible);\n  const share = ratio * 100;\n  const column = { transform: `translateX(${share}cqw)` };\n  const row = { transform: `translateY(${top}px)` };\n  const slide = { transform: `translateX(-${share}%)` };\n\n  return (\n    <div\n      aria-hidden='true'\n      data-gliding={glidingAttributeOf(isGliding)}\n      className='group/readout pointer-events-none absolute inset-0 z-10'\n    >\n      <div\n        className={cn('absolute inset-y-0 left-0 w-0', glide)}\n        style={column}\n      >\n        {hasCrosshair && (\n          <span\n            className={cn(\n              'bg-foreground/15 absolute inset-y-0 left-0 w-px -translate-x-1/2 transition-opacity duration-150',\n              faded\n            )}\n          />\n        )}\n        <div\n          className={cn(\n            'absolute inset-y-0 left-0 w-0 transition-opacity duration-150',\n            faded\n          )}\n        >\n          {marks}\n        </div>\n        <div className={cn('absolute top-0 left-0 size-0', glide)} style={row}>\n          <div\n            className={cn('absolute bottom-2.5 left-0 w-max', glide)}\n            style={slide}\n          >\n            <div\n              className={cn(\n                'surface-raised flex max-w-[min(14rem,100cqw)] origin-bottom flex-col gap-1 rounded-lg px-2.5 py-1.5 text-xs',\n                'transition-[opacity,scale] duration-[125ms] ease-(--ease-out-strong)',\n                !isVisible && 'scale-[0.97] opacity-0'\n              )}\n            >\n              {children}\n            </div>\n          </div>\n        </div>\n      </div>\n    </div>\n  );\n}\n\nexport function ReadoutTitle({ children }: { children: React.ReactNode }) {\n  return <span className='text-muted-foreground'>{children}</span>;\n}\n\ntype ReadoutRowProps = {\n  value: string;\n  name: string;\n  /** The colour of the series, drawn as a short stroke. Text never wears it. */\n  color?: string;\n};\n\nexport function ReadoutRow({ value, name, color }: ReadoutRowProps) {\n  return (\n    <span className='flex items-center gap-2'>\n      {color && (\n        <span\n          className='h-0.5 w-2.5 shrink-0 rounded-full'\n          style={{ backgroundColor: color }}\n        />\n      )}\n      <span className='text-[13px] font-medium tabular-nums'>{value}</span>\n      <span className='text-muted-foreground min-w-0 truncate'>{name}</span>\n    </span>\n  );\n}\n\ntype ReadoutDotProps = {\n  /** Pixels from the top of the plot. */\n  top: number;\n  color: string;\n};\n\n/** The mark of one series where the crosshair meets it, ringed in the colour of the surface. */\nexport function ReadoutDot({ top, color }: ReadoutDotProps) {\n  const style = {\n    backgroundColor: color,\n    transform: `translate(-50%, ${top}px)`,\n  };\n\n  return (\n    <span\n      className={cn(\n        'ring-card absolute -top-1 left-0 size-2 rounded-full ring-2',\n        MARK_GLIDE\n      )}\n      style={style}\n    />\n  );\n}\n",
      "type": "registry:component",
      "target": "components/chart/_parts/readout.tsx"
    },
    {
      "path": "registry/ndeko/components/chart/_parts/scale.ts",
      "content": "export type Domain = {\n  min: number;\n  max: number;\n};\n\nexport type Scale = Domain & {\n  step: number;\n  ticks: number[];\n};\n\nconst NICE_FACTORS = [1, 2, 5, 10];\n\nconst EMPTY_DOMAIN: Domain = { min: 0, max: 0 };\n\nexport function clamp(value: number, min: number, max: number) {\n  const atLeastMin = Math.max(value, min);\n  return Math.min(atLeastMin, max);\n}\n\nexport function lerp(from: number, to: number, amount: number) {\n  const span = to - from;\n  return from + span * amount;\n}\n\nexport function sumOf(values: readonly number[]) {\n  let total = 0;\n  for (const value of values) {\n    total += value;\n  }\n  return total;\n}\n\nexport function extentOf(values: readonly number[]): Domain {\n  if (values.length === 0) {\n    return EMPTY_DOMAIN;\n  }\n  let min = values[0];\n  let max = values[0];\n  for (const value of values) {\n    min = Math.min(min, value);\n    max = Math.max(max, value);\n  }\n  return { min, max };\n}\n\n/** Bars and areas are read from zero, so their domain always holds it. */\nexport function withZero(domain: Domain): Domain {\n  const min = Math.min(domain.min, 0);\n  const max = Math.max(domain.max, 0);\n  return { min, max };\n}\n\n/** Where a value sits in a domain, from 0 at its lowest to 1 at its highest. */\nexport function ratioOf(value: number, domain: Domain) {\n  const span = domain.max - domain.min;\n  if (span === 0) {\n    return 0;\n  }\n  const offset = value - domain.min;\n  return offset / span;\n}\n\n/** A flat series still needs room above and below it to be drawn. */\nfunction spanOf(domain: Domain) {\n  const span = domain.max - domain.min;\n  if (span > 0) {\n    return span;\n  }\n  const size = Math.abs(domain.max);\n  return Math.max(size, 1);\n}\n\nfunction niceStepOf(roughStep: number) {\n  const logarithm = Math.log10(roughStep);\n  const exponent = Math.floor(logarithm);\n  const magnitude = 10 ** exponent;\n  const factor = NICE_FACTORS.find((candidate) => {\n    const candidateStep = candidate * magnitude;\n    return candidateStep >= roughStep;\n  });\n  const safeFactor = factor ?? 10;\n  return safeFactor * magnitude;\n}\n\nfunction decimalsOf(step: number) {\n  const logarithm = Math.log10(step);\n  const exponent = Math.floor(logarithm);\n  return Math.max(0, -exponent);\n}\n\n/** Adding zero turns a negative zero into zero, which a number format would write as -0. */\nfunction roundedTo(value: number, decimals: number) {\n  const factor = 10 ** decimals;\n  const scaled = Math.round(value * factor);\n  const rounded = scaled / factor;\n  return rounded + 0;\n}\n\n/** A scale with round ticks that holds the whole domain, in at most `maxLines` steps. */\nexport function niceScaleOf(domain: Domain, maxLines: number): Scale {\n  const span = spanOf(domain);\n  const roughStep = span / maxLines;\n  const step = niceStepOf(roughStep);\n  const decimals = decimalsOf(step);\n  const stepsBelow = Math.floor(domain.min / step);\n  const lowest = stepsBelow * step;\n  const highestWanted = Math.max(domain.max, lowest + step);\n  const stepsAbove = Math.ceil(highestWanted / step);\n  const lineCount = stepsAbove - stepsBelow;\n  const tickCount = lineCount + 1;\n  const ticks = Array.from({ length: tickCount }, (_, index) => {\n    const tick = lowest + index * step;\n    return roundedTo(tick, decimals);\n  });\n  const lastIndex = ticks.length - 1;\n  return { min: ticks[0], max: ticks[lastIndex], step, ticks };\n}\n\n/** Columns share the plot equally and a mark sits in the middle of its column. */\nexport function columnCenterOf(index: number, count: number) {\n  const center = index + 0.5;\n  return center / count;\n}\n\nexport function columnIndexAt(ratio: number, count: number) {\n  const rawIndex = Math.floor(ratio * count);\n  const lastIndex = Math.max(count - 1, 0);\n  return clamp(rawIndex, 0, lastIndex);\n}\n\nexport function percentOf(share: number) {\n  const percent = share * 100;\n  return `${percent}%`;\n}\n\n/** The whole numbers that lead from one position to another: the start is left out, the end is kept. */\nexport function positionsTo(from: number, to: number) {\n  const gap = to - from;\n  const distance = Math.abs(gap);\n  const direction = Math.sign(gap);\n  return Array.from({ length: distance }, (_, index) => {\n    const travelled = index + 1;\n    const offset = travelled * direction;\n    return from + offset;\n  });\n}\n",
      "type": "registry:component",
      "target": "components/chart/_parts/scale.ts"
    },
    {
      "path": "registry/ndeko/components/chart/_parts/use-chart-demo.ts",
      "content": "'use client';\n\nimport {\n  useAutoplay,\n  type AutoplayOptions,\n  type AutoplayStep,\n} from '@/registry/ndeko/hooks/use-autoplay';\nimport { useKeptHeight } from '@/registry/ndeko/hooks/use-kept-height';\n\n/**\n * What every chart demo shares: the demonstration, the box that keeps its tallest height so a round\n * never moves the page, and a stop when the keyboard brings focus in. A person who tabs to a plot\n * reads it with the arrow keys from there, and has pressed no key inside the piece yet.\n */\nexport function useChartDemo(\n  steps: readonly AutoplayStep[],\n  options?: AutoplayOptions\n) {\n  const demo = useAutoplay(steps, options);\n  const { ref, takeOver } = demo;\n\n  useKeptHeight(ref);\n\n  function stopOnKeyboardFocus(event: React.FocusEvent<HTMLElement>) {\n    const isKeyboardFocus = event.target.matches(':focus-visible');\n    if (isKeyboardFocus) {\n      takeOver();\n    }\n  }\n\n  return { ...demo, stopOnKeyboardFocus };\n}\n",
      "type": "registry:component",
      "target": "components/chart/_parts/use-chart-demo.ts"
    },
    {
      "path": "registry/ndeko/components/chart/_parts/use-plot-width.ts",
      "content": "'use client';\n\nimport { useLayoutEffect, useState } from 'react';\n\n/**\n * The width of a plot as it resizes, for what depends on the room it has: how many labels fit, how\n * many marks, which way the bars run. Shapes do not need it: they are drawn in shares of the plot.\n */\nexport function usePlotWidth(fallback: number) {\n  const [target, setTarget] = useState<HTMLElement | null>(null);\n  const [width, setWidth] = useState(fallback);\n\n  useLayoutEffect(() => {\n    if (!target) {\n      return;\n    }\n    const observer = new ResizeObserver(([entry]) => {\n      const box = entry.contentBoxSize[0];\n      setWidth(box.inlineSize);\n    });\n    observer.observe(target);\n    return () => observer.disconnect();\n  }, [target]);\n\n  return { plotRef: setTarget, width };\n}\n",
      "type": "registry:component",
      "target": "components/chart/_parts/use-plot-width.ts"
    },
    {
      "path": "registry/ndeko/components/chart/_parts/use-reading.ts",
      "content": "'use client';\n\nimport { useState } from 'react';\n\nimport { clamp, columnIndexAt } from './scale';\n\ntype ReadingOptions = {\n  /** How many positions the plot has from left to right. */\n  count: number;\n  /** Where the reading opens the first time the plot takes keyboard focus. */\n  defaultIndex: number;\n  /** A position shown from outside while nobody reads the plot, for a demonstration. */\n  guideIndex?: number | null;\n  /** Enter, Space or a click on a position. */\n  onSelect?: (index: number) => void;\n};\n\nfunction columnIndexFrom(\n  event: React.PointerEvent<HTMLElement> | React.MouseEvent<HTMLElement>,\n  count: number\n) {\n  const box = event.currentTarget.getBoundingClientRect();\n  const offset = event.clientX - box.left;\n  const ratio = offset / box.width;\n  return columnIndexAt(ratio, count);\n}\n\nexport function steppedIndexOf(key: string, current: number, count: number) {\n  const lastIndex = Math.max(count - 1, 0);\n  if (key === 'ArrowRight') {\n    const next = current + 1;\n    return Math.min(next, lastIndex);\n  }\n  if (key === 'ArrowLeft') {\n    const previous = current - 1;\n    return Math.max(previous, 0);\n  }\n  if (key === 'Home') {\n    return 0;\n  }\n  if (key === 'End') {\n    return lastIndex;\n  }\n  return null;\n}\n\nexport function activeIndexOf(isActive: boolean, shownIndex: number) {\n  if (isActive) {\n    return shownIndex;\n  }\n  return null;\n}\n\n/** A reading is said aloud only while the arrow keys move it: a pointer and a demonstration stay silent. */\nexport function readingAloud(isReadingByKeys: boolean, reading: string) {\n  if (isReadingByKeys) {\n    return reading;\n  }\n  return '';\n}\n\nfunction isSelectKey(key: string) {\n  const isEnter = key === 'Enter';\n  const isSpace = key === ' ';\n  return isEnter || isSpace;\n}\n\n/**\n * One reading position for a plot that is one tab stop. The pointer wins while it is over the plot,\n * then the arrow keys, then the position a demonstration points at. A reading that opens appears in\n * place; one that moves glides, which `isGliding` tells the readout.\n *\n * A plot read by columns spreads `handlers`. A plot whose marks are their own hit targets spreads\n * `markHandlers` and calls `pointTo` from each mark.\n */\nexport function useReading({\n  count,\n  defaultIndex,\n  guideIndex = null,\n  onSelect,\n}: ReadingOptions) {\n  const [pointerIndex, setPointerIndex] = useState<number | null>(null);\n  const [keyIndex, setKeyIndex] = useState<number | null>(null);\n  const [lastIndex, setLastIndex] = useState(defaultIndex);\n  const [isGliding, setIsGliding] = useState(false);\n  const [seenGuide, setSeenGuide] = useState(guideIndex);\n  const hasNewGuide = seenGuide !== guideIndex;\n\n  if (hasNewGuide) {\n    const wasGuided = seenGuide !== null;\n    const isGuided = guideIndex !== null;\n    setSeenGuide(guideIndex);\n    setIsGliding(wasGuided && isGuided);\n    if (guideIndex !== null) {\n      setLastIndex(guideIndex);\n    }\n  }\n\n  const activeIndex = pointerIndex ?? keyIndex ?? guideIndex;\n  const isActive = activeIndex !== null;\n  const isPointing = pointerIndex !== null;\n  const isReadingByKeys = keyIndex !== null;\n  const wantedIndex = activeIndex ?? lastIndex;\n  const highestIndex = Math.max(count - 1, 0);\n  const shownIndex = clamp(wantedIndex, 0, highestIndex);\n\n  function pointAt(event: React.PointerEvent<HTMLElement>) {\n    const index = columnIndexFrom(event, count);\n    setIsGliding(isPointing);\n    setPointerIndex(index);\n    setLastIndex(index);\n  }\n\n  /** Null when the pointer is over the plot and on no mark. */\n  function pointTo(index: number | null) {\n    if (index === null) {\n      setPointerIndex(null);\n      return;\n    }\n    setIsGliding(isPointing);\n    setPointerIndex(index);\n    setLastIndex(index);\n  }\n\n  function leave(event: React.PointerEvent<HTMLElement>) {\n    if (event.pointerType === 'mouse') {\n      setPointerIndex(null);\n    }\n  }\n\n  function focus(event: React.FocusEvent<HTMLElement>) {\n    const isKeyboardFocus = event.currentTarget.matches(':focus-visible');\n    if (isKeyboardFocus) {\n      setIsGliding(false);\n      setKeyIndex(shownIndex);\n    }\n  }\n\n  function blur() {\n    setKeyIndex(null);\n    setPointerIndex(null);\n  }\n\n  function pressKey(event: React.KeyboardEvent<HTMLElement>) {\n    if (event.key === 'Escape') {\n      setKeyIndex(null);\n      return;\n    }\n    if (isSelectKey(event.key)) {\n      if (onSelect) {\n        event.preventDefault();\n        setKeyIndex(shownIndex);\n        onSelect(shownIndex);\n      }\n      return;\n    }\n    const next = steppedIndexOf(event.key, shownIndex, count);\n    if (next === null) {\n      return;\n    }\n    event.preventDefault();\n    setIsGliding(isActive);\n    setPointerIndex(null);\n    setKeyIndex(next);\n    setLastIndex(next);\n  }\n\n  function click(event: React.MouseEvent<HTMLElement>) {\n    if (!onSelect) {\n      return;\n    }\n    const index = columnIndexFrom(event, count);\n    onSelect(index);\n  }\n\n  const handlers = {\n    onPointerMove: pointAt,\n    onPointerDown: pointAt,\n    onPointerLeave: leave,\n    onFocus: focus,\n    onBlur: blur,\n    onKeyDown: pressKey,\n    onClick: click,\n  };\n\n  const markHandlers = {\n    onPointerLeave: leave,\n    onFocus: focus,\n    onBlur: blur,\n    onKeyDown: pressKey,\n  };\n\n  return {\n    shownIndex,\n    isActive,\n    isGliding,\n    isPointing,\n    isReadingByKeys,\n    handlers,\n    markHandlers,\n    pointTo,\n  };\n}\n",
      "type": "registry:component",
      "target": "components/chart/_parts/use-reading.ts"
    }
  ],
  "categories": [
    "components",
    "chart"
  ],
  "type": "registry:component"
}