{
  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
  "name": "ipod-classic",
  "title": "iPod Classic",
  "author": "ncdai <dai@chanhdai.com>",
  "description": "iPod classic with a working click wheel, menus, and music playback.",
  "dependencies": [
    "jotai",
    "motion"
  ],
  "files": [
    {
      "path": "src/registry/components/ipod-classic/index.ts",
      "content": "export { IpodClassic, type IpodClassicProps } from \"./ipod-classic\"\nexport type { IpodLibrary, IpodPlaylist, IpodSong } from \"./lib/types\"\n",
      "type": "registry:component",
      "target": "@components/ipod-classic/index.ts"
    },
    {
      "path": "src/registry/components/ipod-classic/components/brick-game.tsx",
      "content": "\"use client\"\n\nimport { useEffect, useRef } from \"react\"\nimport { useAtomValue, useStore } from \"jotai\"\n\nimport styles from \"../ipod-classic.module.css\"\nimport { brickStatusAtom, engineAtom, isInertAtom } from \"../lib/atoms\"\nimport {\n  brickStatus,\n  createBrickGame,\n  createLcdInk,\n  createLcdRenderer,\n  drawField,\n  FIELD_HEIGHT,\n  FIELD_WIDTH,\n  INITIAL_BRICK_STATUS,\n  tickMs,\n} from \"../lib/brick-engine\"\nimport { BRICK_PADDLE_STEER } from \"../lib/constants\"\n\n/** Catching up after a stall is capped, so the ball never teleports. */\nconst MAX_CATCH_UP_TICKS = 10\n\nexport function BrickGame() {\n  const store = useStore()\n  const engine = useAtomValue(engineAtom)\n  const { message } = useAtomValue(brickStatusAtom)\n  const canvasRef = useRef<HTMLCanvasElement>(null)\n\n  useEffect(() => {\n    const canvas = canvasRef.current\n    if (!canvas || !engine) return\n    const game = createBrickGame()\n    const lcd = createLcdInk(FIELD_WIDTH, FIELD_HEIGHT)\n    const { state } = game\n    const isPaused = () => store.get(isInertAtom)\n    let frame: number | undefined\n    let lastTime: number | undefined\n    let backlog = 0\n    let needsDraw = false\n    let steer = 0\n    let hasSteered = false\n\n    function draw() {\n      drawField(state, lcd.drive)\n      needsDraw = false\n    }\n\n    // Fixed ticks keep the physics identical at any frame rate.\n    function step(now: number) {\n      const elapsed = lastTime === undefined ? 0 : now - lastTime\n      const interval = tickMs(state.level)\n      const paused = isPaused()\n      lastTime = now\n      backlog = Math.min(backlog + elapsed, interval * MAX_CATCH_UP_TICKS)\n\n      let ticked = false\n      while (backlog >= interval) {\n        backlog -= interval\n        ticked = true\n        if (paused) continue\n        game.movePaddle(steer * BRICK_PADDLE_STEER)\n        hasSteered ||= steer !== 0\n        game.tick()\n      }\n      if (ticked) {\n        draw()\n        store.set(brickStatusAtom, brickStatus(state))\n      }\n      const isFading = lcd.fade(elapsed)\n      if (ticked || isFading) renderer.paint()\n\n      const isMoving =\n        !paused && (state.isBallInPlay || state.serveTicks > 0 || steer !== 0)\n      frame =\n        isMoving || needsDraw || isFading\n          ? requestAnimationFrame(step)\n          : undefined\n    }\n\n    function start() {\n      if (frame !== undefined) return\n      lastTime = undefined\n      frame = requestAnimationFrame(step)\n    }\n\n    function movePaddle(fraction: number) {\n      game.movePaddle(fraction)\n      needsDraw = true\n      start()\n    }\n\n    draw()\n    lcd.settle()\n    const renderer = createLcdRenderer(canvas, lcd)\n    store.set(brickStatusAtom, INITIAL_BRICK_STATUS)\n    const unsubscribe = store.sub(isInertAtom, () => {\n      if (!isPaused()) start()\n    })\n\n    engine.menu.registerBrick({\n      movePaddle,\n      steerPaddle(direction) {\n        // A tap too short to reach a tick still nudges the paddle once.\n        if (direction === 0 && !hasSteered && !isPaused()) {\n          movePaddle(steer * BRICK_PADDLE_STEER)\n        }\n        steer = direction\n        hasSteered = false\n        start()\n      },\n      launchBall() {\n        game.launchBall()\n        needsDraw = true\n        store.set(brickStatusAtom, brickStatus(state))\n        start()\n      },\n    })\n\n    return () => {\n      engine.menu.registerBrick(null)\n      unsubscribe()\n      if (frame !== undefined) cancelAnimationFrame(frame)\n      renderer.destroy()\n    }\n  }, [store, engine])\n\n  return (\n    <div className={styles.brickScreen}>\n      <canvas\n        ref={canvasRef}\n        className={styles.brickCanvas}\n        width={FIELD_WIDTH}\n        height={FIELD_HEIGHT}\n        aria-hidden\n      />\n      <p className={styles.visuallyHidden} role=\"status\">\n        {message}\n      </p>\n    </div>\n  )\n}\n",
      "type": "registry:component",
      "target": "@components/ipod-classic/components/brick-game.tsx"
    },
    {
      "path": "src/registry/components/ipod-classic/components/click-wheel.tsx",
      "content": "\"use client\"\n\nimport {\n  useEffect,\n  useRef,\n  useState,\n  type CSSProperties,\n  type KeyboardEvent,\n  type PointerEvent,\n} from \"react\"\nimport { useAtomValue, useStore } from \"jotai\"\n\nimport styles from \"../ipod-classic.module.css\"\nimport {\n  engineAtom,\n  playbackAtom,\n  scrollTargetAtom,\n  seekAtom,\n  selectHoldMsAtom,\n} from \"../lib/atoms\"\nimport {\n  HOLD_MS,\n  HOLD_REPEAT_MS,\n  KEY_REPEAT_DELAY_MS,\n  KEY_REPEAT_INTERVAL_MS,\n  SCROLL_WHEEL_PERCENT,\n  SELECT_BUTTON_PERCENT,\n} from \"../lib/constants\"\nimport type { IpodEngine } from \"../lib/engine\"\nimport { createHoldTimer } from \"../lib/timers\"\nimport type { ScrollTarget } from \"../lib/types\"\nimport { bindPressAndHold, bindWheelGesture } from \"../lib/wheel-gesture\"\nimport { MenuLabel, PlayPauseIcon, SkipIcon } from \"./icons\"\n\ntype Button = \"menu\" | \"select\" | \"playPause\" | \"back\" | \"forward\"\ntype HoldButton = Exclude<Button, \"menu\" | \"playPause\">\n\ntype KeyAction =\n  | { kind: \"scroll\" | \"steer\"; step: 1 | -1 }\n  | {\n      kind: \"hold\"\n      button: HoldButton\n      duration?: number\n      repeatInterval?: number\n    }\n  | { kind: \"press\"; button: Button }\n  | { kind: \"none\" }\n\nconst LONG_PRESS: Record<\n  HoldButton,\n  (wheel: IpodEngine[\"wheel\"], repeat: boolean) => void\n> = {\n  select: (wheel) => wheel.selectHold(),\n  back: (wheel, repeat) => wheel.backHold(repeat),\n  forward: (wheel, repeat) => wheel.forwardHold(repeat),\n}\n\nconst isSkip = (button: Button) => button === \"back\" || button === \"forward\"\n\nfunction keyAction(\n  key: string,\n  target: ScrollTarget,\n  selectHoldMs: number | null\n): KeyAction | undefined {\n  switch (key) {\n    case \"ArrowUp\":\n    case \"ArrowDown\":\n      if (target === \"brick\") return { kind: \"none\" }\n      // Lists scroll down with ArrowDown; sliders go up with ArrowUp.\n      return {\n        kind: \"scroll\",\n        step: key === (target === \"list\" ? \"ArrowDown\" : \"ArrowUp\") ? 1 : -1,\n      }\n    case \"ArrowLeft\":\n    case \"ArrowRight\": {\n      const isLeft = key === \"ArrowLeft\"\n      if (target === \"seek\") return { kind: \"scroll\", step: isLeft ? -1 : 1 }\n      if (target === \"brick\") return { kind: \"steer\", step: isLeft ? -1 : 1 }\n      if (target === \"volume\") {\n        return {\n          kind: \"hold\",\n          button: isLeft ? \"back\" : \"forward\",\n          repeatInterval: HOLD_REPEAT_MS,\n        }\n      }\n      return { kind: \"press\", button: isLeft ? \"menu\" : \"select\" }\n    }\n    case \"Enter\":\n      return selectHoldMs === null\n        ? { kind: \"press\", button: \"select\" }\n        : { kind: \"hold\", button: \"select\", duration: selectHoldMs }\n    case \" \":\n      return { kind: \"press\", button: \"playPause\" }\n    case \"Escape\":\n      return { kind: \"press\", button: \"menu\" }\n  }\n}\n\nexport function ClickWheel() {\n  const store = useStore()\n  const isPlaying = useAtomValue(playbackAtom).isPlaying\n  const disableSkip = useAtomValue(seekAtom).isSeeking\n  const ringRef = useRef<HTMLDivElement>(null)\n  const backRef = useRef<HTMLButtonElement>(null)\n  const forwardRef = useRef<HTMLButtonElement>(null)\n  const selectRef = useRef<HTMLButtonElement>(null)\n  const isDraggingRef = useRef(false)\n  const [isDragging, setIsDragging] = useState(false)\n  const keyRef = useRef<{\n    key?: string\n    action?: KeyAction\n    pressedAt: number\n    target?: ScrollTarget\n    selectHoldMs?: number | null\n    timer?: ReturnType<typeof createHoldTimer>\n  }>({ pressedAt: 0 })\n\n  // Listeners read the store directly, so they always see the current screen.\n  const wheel = () => store.get(engineAtom)?.wheel\n  const isSkipDisabled = () => store.get(seekAtom).isSeeking\n\n  function press(button: Button) {\n    if (isSkip(button) && isSkipDisabled()) return\n    wheel()?.[button]()\n  }\n\n  function hold(button: HoldButton, repeat: boolean) {\n    const handlers = wheel()\n    if (!handlers || (isSkip(button) && isSkipDisabled())) return\n    LONG_PRESS[button](handlers, repeat)\n  }\n\n  function focusRing() {\n    if (matchMedia(\"(any-pointer: fine)\").matches) {\n      ringRef.current?.focus({ preventScroll: true })\n    }\n  }\n\n  function cancelKey(commit: boolean) {\n    const state = keyRef.current\n    const { action } = state\n    const didFire = state.timer?.stop() ?? false\n    state.key = undefined\n    state.action = undefined\n    if (action?.kind === \"scroll\") {\n      if (!isDraggingRef.current) wheel()?.dragEnd()\n    } else if (action?.kind === \"steer\") {\n      wheel()?.steer(null)\n    } else if (\n      (action?.kind === \"press\" || action?.kind === \"hold\") &&\n      commit &&\n      !didFire\n    ) {\n      press(action.button)\n    }\n  }\n\n  function fireKey(repeat: boolean) {\n    const state = keyRef.current\n    // The screen changed under the held key, so it no longer means the same.\n    if (\n      store.get(scrollTargetAtom) !== state.target ||\n      store.get(selectHoldMsAtom) !== state.selectHoldMs\n    ) {\n      cancelKey(false)\n      return\n    }\n    const { action } = state\n    if (action?.kind === \"scroll\") {\n      wheel()?.keyScroll(action.step, performance.now() - state.pressedAt)\n    } else if (action?.kind === \"hold\") {\n      hold(action.button, repeat)\n    }\n  }\n\n  function handleKeyDown(event: KeyboardEvent<HTMLDivElement>) {\n    if (event.ctrlKey || event.metaKey || event.altKey) {\n      cancelKey(false)\n      return\n    }\n    const target = store.get(scrollTargetAtom)\n    const selectHoldMs = store.get(selectHoldMsAtom)\n    const action = keyAction(event.key, target, selectHoldMs)\n    if (!action) return\n    event.preventDefault()\n    event.stopPropagation()\n    const state = keyRef.current\n    if (event.repeat || event.key === state.key) return\n\n    cancelKey(false)\n    Object.assign(state, {\n      key: event.key,\n      action,\n      pressedAt: performance.now(),\n      target,\n      selectHoldMs,\n    })\n    state.timer ??= createHoldTimer(fireKey)\n\n    if (action.kind === \"scroll\") {\n      if (!isDraggingRef.current) wheel()?.dragStart()\n      wheel()?.keyScroll(action.step, 0)\n      state.timer.start(KEY_REPEAT_DELAY_MS, KEY_REPEAT_INTERVAL_MS)\n    } else if (action.kind === \"steer\") {\n      wheel()?.steer(action.step)\n    } else if (action.kind === \"hold\") {\n      state.timer.start(action.duration ?? HOLD_MS, action.repeatInterval)\n    }\n  }\n\n  function handleKeyUp(event: KeyboardEvent<HTMLDivElement>) {\n    if (event.key !== keyRef.current.key) return\n    event.preventDefault()\n    event.stopPropagation()\n    cancelKey(true)\n  }\n\n  function handlePointerUp(event: PointerEvent<HTMLDivElement>) {\n    const isRealMouse =\n      event.pointerType === \"mouse\" && (event.width > 0 || event.height > 0)\n    if (isRealMouse) focusRing()\n  }\n\n  useEffect(() => {\n    const ring = ringRef.current\n    if (!ring) return\n    // A key-driven scroll already opened the drag, so it is not repeated.\n    const setDragging = (dragging: boolean) => {\n      isDraggingRef.current = dragging\n      setIsDragging(dragging)\n      if (keyRef.current.action?.kind === \"scroll\") return\n      if (dragging) wheel()?.dragStart()\n      else wheel()?.dragEnd()\n    }\n    return bindWheelGesture(ring, {\n      excludeRadiusRatio: SELECT_BUTTON_PERCENT / SCROLL_WHEEL_PERCENT,\n      onScroll: (scroll) => wheel()?.scroll(scroll),\n      onDragStart: () => setDragging(true),\n      onDragEnd: () => setDragging(false),\n    })\n    // `wheel` reads the store at call time.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [store])\n\n  useEffect(() => {\n    const buttons: [HTMLElement | null, HoldButton][] = [\n      [backRef.current, \"back\"],\n      [forwardRef.current, \"forward\"],\n      [selectRef.current, \"select\"],\n    ]\n    const unbinds = buttons.map(([element, button]) => {\n      if (!element) return\n      return bindPressAndHold(element, () => {\n        const selectHoldMs = store.get(selectHoldMsAtom)\n        const isSelect = button === \"select\"\n        return {\n          duration: isSelect ? (selectHoldMs ?? HOLD_MS) : HOLD_MS,\n          repeatInterval: isSkip(button) ? HOLD_REPEAT_MS : undefined,\n          // Enter on Select is the wheel's own key, handled above.\n          keyboard: !isSelect,\n          disabled: isSelect && selectHoldMs === null,\n          onLongPress: (repeat) => hold(button, repeat),\n        }\n      })\n    })\n    const keyState = keyRef.current\n    return () => {\n      unbinds.forEach((unbind) => unbind?.())\n      keyState.timer?.stop()\n    }\n    // `hold` reads the store at call time.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [store])\n\n  return (\n    <div\n      className={styles.clickWheel}\n      data-dragging={isDragging || undefined}\n      dir=\"ltr\"\n      tabIndex={-1}\n      style={\n        {\n          \"--select-button-pct\": `${SELECT_BUTTON_PERCENT}%`,\n          \"--scroll-wheel-pct\": `${SCROLL_WHEEL_PERCENT}%`,\n        } as CSSProperties\n      }\n      onKeyDown={handleKeyDown}\n      onKeyUp={handleKeyUp}\n      onBlur={() => cancelKey(false)}\n      onPointerUp={handlePointerUp}\n    >\n      <button\n        type=\"button\"\n        className={`${styles.wheelButton} ${styles.menuButton}`}\n        aria-label=\"Menu\"\n        onClick={() => press(\"menu\")}\n      >\n        <MenuLabel />\n      </button>\n      <button\n        ref={backRef}\n        type=\"button\"\n        className={`${styles.wheelButton} ${styles.backButton}`}\n        aria-label=\"Back\"\n        aria-disabled={disableSkip}\n        onClick={() => press(\"back\")}\n      >\n        <SkipIcon />\n      </button>\n      <button\n        ref={forwardRef}\n        type=\"button\"\n        className={`${styles.wheelButton} ${styles.forwardButton}`}\n        aria-label=\"Forward\"\n        aria-disabled={disableSkip}\n        onClick={() => press(\"forward\")}\n      >\n        <SkipIcon />\n      </button>\n      <button\n        type=\"button\"\n        className={`${styles.wheelButton} ${styles.playPauseButton}`}\n        aria-label={isPlaying ? \"Pause\" : \"Play\"}\n        onClick={() => press(\"playPause\")}\n      >\n        <PlayPauseIcon />\n      </button>\n      <div className={styles.wheelDividers} />\n      <div\n        ref={ringRef}\n        className={styles.scrollWheel}\n        aria-hidden\n        tabIndex={-1}\n        onPointerDown={focusRing}\n      />\n      <button\n        ref={selectRef}\n        type=\"button\"\n        className={styles.selectButton}\n        aria-label=\"Select\"\n        onClick={() => press(\"select\")}\n      />\n    </div>\n  )\n}\n",
      "type": "registry:component",
      "target": "@components/ipod-classic/components/click-wheel.tsx"
    },
    {
      "path": "src/registry/components/ipod-classic/components/icons.tsx",
      "content": "import { useId, type SVGProps } from \"react\"\n\ntype IconProps = SVGProps<SVGSVGElement>\n\n/** A vector logo, so the boot screen stays sharp at any scale. */\nexport function AppleLogo(props: IconProps) {\n  return (\n    <svg viewBox=\"2.225 0 19.55 24\" aria-hidden {...props}>\n      <path d=\"M12.152 6.896c-.948 0-2.415-1.078-3.96-1.04-2.04.027-3.91 1.183-4.961 3.014-2.117 3.675-.546 9.103 1.519 12.09 1.013 1.454 2.208 3.09 3.792 3.039 1.52-.065 2.09-.987 3.935-.987 1.831 0 2.35.987 3.96.948 1.637-.026 2.676-1.48 3.676-2.948 1.156-1.688 1.636-3.325 1.662-3.415-.039-.013-3.182-1.221-3.22-4.857-.026-3.04 2.48-4.494 2.597-4.559-1.429-2.09-3.623-2.324-4.39-2.376-2-.156-3.675 1.09-4.61 1.09zM15.53 3.83c.843-1.012 1.4-2.427 1.245-3.83-1.207.052-2.662.805-3.532 1.818-.78.896-1.454 2.338-1.273 3.714 1.338.104 2.715-.688 3.559-1.701\" />\n    </svg>\n  )\n}\n\nexport function PlayIcon(props: IconProps) {\n  return (\n    <svg width=\"17\" height=\"20\" viewBox=\"0 0 17 20\" aria-hidden {...props}>\n      <path\n        d=\"M71.234-28.693 10.883 7.049v-71.533z\"\n        transform=\"translate(-3.043 18.03)scale(.27959)\"\n      />\n    </svg>\n  )\n}\n\nexport function PauseIcon(props: IconProps) {\n  return (\n    <svg width=\"14\" height=\"20\" viewBox=\"0 0 14 20\" aria-hidden {...props}>\n      <path\n        d=\"M6.576-95.378h21.875V0H6.576zm42.578 0h21.94V0h-21.94z\"\n        transform=\"translate(-1.379 20)scale(.2097)\"\n      />\n    </svg>\n  )\n}\n\nexport function RepeatAllIcon(props: IconProps) {\n  return (\n    <svg width=\"18\" height=\"15\" viewBox=\"0 0 18 15\" aria-hidden {...props}>\n      <path\n        d=\"M24.851-6.64v-3.324H14.294q-.883 0-1.655.3a4.2 4.2 0 0 0-1.347.831 3.8 3.8 0 0 0-.906 1.272 3.9 3.9 0 0 0-.33 1.61q0 .689.277 1.378.277.688.682 1.213L7.062-.141a8.7 8.7 0 0 1-1.565-2.613 8.6 8.6 0 0 1-.562-3.092q0-1.841.697-3.452a8.92 8.92 0 0 1 4.694-4.716 8.5 8.5 0 0 1 3.414-.697h11.111v-3.533l7.232 5.944zm-9.554 2.771V-.56h10.572q.868 0 1.647-.292a4 4 0 0 0 1.348-.824q.569-.53.906-1.273a3.9 3.9 0 0 0 .337-1.624q0-.689-.277-1.355a5.5 5.5 0 0 0-.697-1.221l3.968-3.219a8.6 8.6 0 0 1 2.127 5.705 8.6 8.6 0 0 1-.697 3.451 8.9 8.9 0 0 1-1.894 2.808 9 9 0 0 1-2.8 1.894 8.5 8.5 0 0 1-3.414.697H15.297v3.548L8.08 1.791z\"\n        transform=\"translate(-2.83 10.464)scale(.57352)\"\n      />\n    </svg>\n  )\n}\n\nexport function RepeatOneIcon(props: IconProps) {\n  return (\n    <svg width=\"19\" height=\"15\" viewBox=\"0 0 19 15\" aria-hidden {...props}>\n      <path\n        d=\"M.3-.313q.04 0 .077.016.035.015.062.042a.2.2 0 0 1 .042.062q.016.036.016.077a.2.2 0 0 1-.016.076.2.2 0 0 1-.042.062.2.2 0 0 1-.062.042.2.2 0 0 1-.215-.042.2.2 0 0 1-.057-.138.2.2 0 0 1 .015-.077.2.2 0 0 1 .042-.062.2.2 0 0 1 .062-.042A.2.2 0 0 1 .3-.313m.027.302L.326-.23H.29l-.003.011-.005.01-.015.013-.009.004-.01.002-.009.002-.01.001H.225l.002.035h.054v.143h.046zM.7-.354v-.108H.355a.15.15 0 0 0-.09.03.12.12 0 0 0-.046.078.25.25 0 0 0-.147.135.3.3 0 0 1-.022-.109.293.293 0 0 1 .288-.289H.7v-.115l.236.193zm.269-.121a.283.283 0 0 1-.016.39A.3.3 0 0 1 .75 0H.522a.24.24 0 0 0 .029-.116L.55-.135l-.002-.02h.185a.14.14 0 0 0 .054-.01.1.1 0 0 0 .044-.027.1.1 0 0 0 .03-.041.1.1 0 0 0 .011-.053.1.1 0 0 0-.009-.044.2.2 0 0 0-.023-.04z\"\n        transform=\"translate(-.918 13.44)scale(18.3605)\"\n      />\n    </svg>\n  )\n}\n\nexport function ShuffleIcon(props: IconProps) {\n  return (\n    <svg width=\"20\" height=\"15\" viewBox=\"0 0 20 15\" aria-hidden {...props}>\n      <path\n        d=\"M.935-.347v-.111H.812a.1.1 0 0 0-.03.007.1.1 0 0 0-.026.02l-.252.314a1 1 0 0 1-.066.058l-.032.022-.035.019-.036.013A.2.2 0 0 1 .299 0h-.25v-.165h.25a.1.1 0 0 0 .037-.011.3.3 0 0 0 .073-.061L.68-.572l.017-.015.026-.017a.1.1 0 0 1 .035-.014.2.2 0 0 1 .044-.006h.133v-.109l.222.192zM.299-.624q.018 0 .036.006a.4.4 0 0 1 .11.064 1 1 0 0 1 .075.069l-.095.118L.38-.413.36-.429.339-.444.318-.455.299-.458h-.25v-.166zm.636.735V0H.802a.2.2 0 0 1-.044-.005.2.2 0 0 1-.061-.03L.68-.051.608-.14l.095-.116.053.066.026.018a.1.1 0 0 0 .03.007h.123v-.11l.222.192z\"\n        transform=\"translate(-.864 12.93)scale(17.6389)\"\n      />\n    </svg>\n  )\n}\n\nconst SPEAKER_PATH =\n  \"M9.476 16V0L4.307 4.495a.25.25 0 0 1-.168.073L0 4.555v6.924l4.138-.014a.24.24 0 0 1 .168.063z\"\n\nexport function VolumeLowIcon(props: IconProps) {\n  return (\n    <svg width=\"10\" height=\"16\" viewBox=\"0 0 10 16\" aria-hidden {...props}>\n      <path d={SPEAKER_PATH} />\n    </svg>\n  )\n}\n\nexport function VolumeHighIcon(props: IconProps) {\n  return (\n    <svg width=\"18\" height=\"16\" viewBox=\"0 0 18 16\" aria-hidden {...props}>\n      <path d=\"M11.526 15.763c.569.239 1.022.245 1.462-.13 2.568-2.046 4.353-4.826 4.353-7.632S15.55 2.482 13.038.425c-.44-.384-.943-.424-1.512-.185-.455.443-.257 1.07.202 1.454 2.518 1.79 3.852 3.795 3.852 6.3 0 2.493-1.597 4.509-3.816 6.317-.458.384-.7.934-.238 1.452\" />\n      <path d=\"M10.628 11.546c.426.211 1.023.148 1.365-.22.852-.843 1.45-2.069 1.45-3.311 0-1.243-.598-2.491-1.45-3.344-.342-.369-.939-.432-1.365-.21-.434.428-.343.91.055 1.299.597.6 1.14 1.385 1.14 2.29s-.457 1.746-1.177 2.293c-.384.4-.412.806-.018 1.203\" />\n      <path d={SPEAKER_PATH} />\n    </svg>\n  )\n}\n\nexport function MenuLabel(props: IconProps) {\n  const curveId = useId()\n  return (\n    <svg width=\"400\" height=\"150\" viewBox=\"0 0 400 150\" aria-hidden {...props}>\n      <path\n        id={curveId}\n        fill=\"none\"\n        stroke=\"none\"\n        d=\"M31.234 97.495S92.808 41.234 200 41.234c121.84 0 168.766 56.26 168.766 56.26\"\n      />\n      <text>\n        <textPath href={`#${curveId}`} startOffset=\"112\">\n          menu\n        </textPath>\n      </text>\n    </svg>\n  )\n}\n\n/** Drawn as ▶▶|; Back reuses it rotated. */\nexport function SkipIcon(props: IconProps) {\n  return (\n    <svg width=\"23\" height=\"12\" viewBox=\"0 0 23 12\" aria-hidden {...props}>\n      <path d=\"M9.58 5.635 0 11.212V.057zm9.623 0-9.58 5.577V.057zm0-5.635H23v11.273h-3.797z\" />\n    </svg>\n  )\n}\n\nexport function PlayPauseIcon(props: IconProps) {\n  return (\n    <svg width=\"24\" height=\"12\" viewBox=\"0 0 24 12\" aria-hidden {...props}>\n      <path d=\"M9.58 5.635 0 11.212V.057zM19.578 0h3.796v11.273h-3.796zm-5.793 0h3.797v11.273h-3.797z\" />\n    </svg>\n  )\n}\n",
      "type": "registry:component",
      "target": "@components/ipod-classic/components/icons.tsx"
    },
    {
      "path": "src/registry/components/ipod-classic/components/marquee.tsx",
      "content": "\"use client\"\n\nimport { useEffect, useRef, useState, type CSSProperties } from \"react\"\n\nimport styles from \"../ipod-classic.module.css\"\n\n/** Scrolls text that does not fit, after a pause, like the iPod's title. */\nexport function Marquee({\n  text,\n  resetKey,\n}: {\n  text: string\n  /** Restarts the scroll, e.g. for a new song with the same title. */\n  resetKey?: string\n}) {\n  const containerRef = useRef<HTMLDivElement>(null)\n  const copyRef = useRef<HTMLSpanElement>(null)\n  const [widths, setWidths] = useState({ container: 0, copy: 0 })\n\n  useEffect(() => {\n    const container = containerRef.current\n    const copy = copyRef.current\n    if (!container || !copy) return\n    const observer = new ResizeObserver(() =>\n      setWidths({ container: container.clientWidth, copy: copy.offsetWidth })\n    )\n    observer.observe(container)\n    observer.observe(copy)\n    return () => observer.disconnect()\n  }, [text, resetKey])\n\n  const isScrolling = widths.copy - widths.container > 1\n\n  return (\n    <div\n      ref={containerRef}\n      className={styles.marquee}\n      data-scrolling={isScrolling || undefined}\n      dir=\"auto\"\n    >\n      <div\n        key={`${resetKey ?? \"\"}\\0${text}`}\n        className={styles.marqueeTrack}\n        style={{ \"--marquee-copy-width\": widths.copy } as CSSProperties}\n      >\n        <span ref={copyRef} className={styles.marqueeCopy}>\n          {text}\n        </span>\n        {isScrolling && (\n          <span className={styles.marqueeCopy} aria-hidden>\n            {text}\n          </span>\n        )}\n      </div>\n    </div>\n  )\n}\n",
      "type": "registry:component",
      "target": "@components/ipod-classic/components/marquee.tsx"
    },
    {
      "path": "src/registry/components/ipod-classic/components/menu-list.tsx",
      "content": "\"use client\"\n\nimport { useLayoutEffect, useRef } from \"react\"\nimport { useAtomValue } from \"jotai\"\n\nimport styles from \"../ipod-classic.module.css\"\nimport { settingsAtom } from \"../lib/atoms\"\nimport { settingValue, type MenuItem } from \"../lib/menu\"\n\n/** Scrolls only the list, never the page, to show the row. */\nfunction revealRow(list: HTMLElement, row: HTMLElement) {\n  const top = row.offsetTop\n  const bottom = top + row.offsetHeight\n  if (top < list.scrollTop) list.scrollTop = top\n  else if (bottom > list.scrollTop + list.clientHeight) {\n    list.scrollTop = bottom - list.clientHeight\n  }\n}\n\nexport function MenuList({\n  items,\n  selectedIndex,\n  idPrefix,\n  labelledBy,\n  shouldFocus,\n  restoredScrollTop,\n  listRef,\n}: {\n  items: MenuItem[]\n  selectedIndex: number\n  idPrefix: string\n  labelledBy: string\n  shouldFocus: boolean\n  restoredScrollTop: number | undefined\n  /** Returns a cleanup, so an outgoing list cannot unregister the new one. */\n  listRef: (element: HTMLUListElement) => () => void\n}) {\n  const ref = useRef<HTMLUListElement>(null)\n  const settings = useAtomValue(settingsAtom)\n\n  // Mount only: restore where the list was left, or reveal the selection.\n  useLayoutEffect(() => {\n    const list = ref.current\n    if (!list) return\n    if (restoredScrollTop !== undefined) list.scrollTop = restoredScrollTop\n    if (shouldFocus) list.focus({ preventScroll: true })\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [])\n\n  useLayoutEffect(() => {\n    const list = ref.current\n    const row = list?.children[selectedIndex]\n    if (list && row instanceof HTMLElement) revealRow(list, row)\n  }, [selectedIndex, items.length])\n\n  return (\n    <ul\n      ref={(element) => {\n        if (!element) return\n        ref.current = element\n        return listRef(element)\n      }}\n      className={styles.menuItems}\n      role=\"listbox\"\n      tabIndex={0}\n      aria-activedescendant={`${idPrefix}-${selectedIndex}`}\n      aria-labelledby={labelledBy}\n    >\n      {items.map((item, index) => {\n        const isInfo = item.action === \"info\"\n        const isSelected = index === selectedIndex\n        const value = settingValue(item, settings)\n        return (\n          <li\n            key={item.id}\n            id={`${idPrefix}-${index}`}\n            className={styles.menuItem}\n            data-action={item.action}\n            data-selected={isSelected || undefined}\n            data-centered={(isInfo && item.centered) || undefined}\n            role={isInfo ? undefined : \"option\"}\n            aria-selected={isInfo ? undefined : isSelected}\n          >\n            <span className={styles.itemTitle} dir=\"auto\">\n              {item.title}\n            </span>\n            {value !== undefined && (\n              <span className={styles.itemValue} dir=\"auto\">\n                {value}\n              </span>\n            )}\n            {item.action === \"navigate\" && (\n              <span className={styles.chevron} aria-hidden />\n            )}\n          </li>\n        )\n      })}\n    </ul>\n  )\n}\n",
      "type": "registry:component",
      "target": "@components/ipod-classic/components/menu-list.tsx"
    },
    {
      "path": "src/registry/components/ipod-classic/components/now-playing.tsx",
      "content": "\"use client\"\n\nimport { useEffect, useRef, useState } from \"react\"\nimport { useAtomValue } from \"jotai\"\n\nimport styles from \"../ipod-classic.module.css\"\nimport {\n  engineAtom,\n  isAdjustingVolumeAtom,\n  playbackAtom,\n  seekAtom,\n  settingsAtom,\n} from \"../lib/atoms\"\nimport {\n  RepeatAllIcon,\n  RepeatOneIcon,\n  ShuffleIcon,\n  VolumeHighIcon,\n  VolumeLowIcon,\n} from \"./icons\"\nimport { Marquee } from \"./marquee\"\nimport { ProgressBar } from \"./progress-bar\"\n\nconst integer = new Intl.NumberFormat(\"en-US\")\nconst units = {\n  hour: new Intl.NumberFormat(\"en-US\", {\n    style: \"unit\",\n    unit: \"hour\",\n    unitDisplay: \"long\",\n  }),\n  minute: new Intl.NumberFormat(\"en-US\", {\n    style: \"unit\",\n    unit: \"minute\",\n    unitDisplay: \"long\",\n  }),\n  second: new Intl.NumberFormat(\"en-US\", {\n    style: \"unit\",\n    unit: \"second\",\n    unitDisplay: \"long\",\n  }),\n}\nconst list = new Intl.ListFormat(\"en-US\")\n\nfunction formatTime(seconds: number) {\n  const value = Math.max(0, Math.floor(seconds))\n  return `${Math.floor(value / 60)}:${String(value % 60).padStart(2, \"0\")}`\n}\n\n/** \"1 minute and 5 seconds\", for the scrubber's spoken value. */\nfunction spokenDuration(seconds: number) {\n  const value = Math.max(0, Math.floor(seconds))\n  const parts = (\n    [\n      [\"hour\", Math.floor(value / 3600)],\n      [\"minute\", Math.floor(value / 60) % 60],\n      [\"second\", value % 60],\n    ] as const\n  )\n    .filter(([, amount]) => amount > 0)\n    .map(([unit, amount]) => units[unit].format(amount))\n  return parts.length ? list.format(parts) : units.second.format(0)\n}\n\nconst PLAY_MODE_LABELS: Record<string, string> = {\n  \"shuffle-off\": \"Shuffle on\",\n  \"shuffle-one\": \"Shuffle on, Repeat one\",\n  \"shuffle-all\": \"Shuffle on, Repeat all\",\n  \"ordered-one\": \"Repeat one\",\n  \"ordered-all\": \"Repeat all\",\n}\n\nexport function NowPlaying({\n  labelledBy,\n  shouldFocus,\n}: {\n  labelledBy: string\n  shouldFocus: boolean\n}) {\n  const playback = useAtomValue(playbackAtom)\n  const seek = useAtomValue(seekAtom)\n  const isAdjustingVolume = useAtomValue(isAdjustingVolumeAtom)\n  const { shuffle, repeat } = useAtomValue(settingsAtom)\n  const sliders = useAtomValue(engineAtom)?.sliders\n  const ref = useRef<HTMLDivElement>(null)\n\n  const song = playback.queue[playback.currentTrackIndex]\n  const { duration } = playback\n  const time =\n    seek.isSeeking && seek.previewTime !== undefined\n      ? seek.previewTime\n      : playback.currentTime\n  const hasDuration = Number.isFinite(duration) && duration > 0\n  const elapsed = hasDuration ? formatTime(time) : \"\"\n  const remaining = hasDuration\n    ? `-${formatTime(Math.ceil(duration - time))}`\n    : \"\"\n  const scrubValue = hasDuration ? Math.floor(time) : 0\n  const volume = Math.round(playback.volume * 100)\n  const isShuffled = shuffle === \"songs\"\n  const playModesLabel =\n    PLAY_MODE_LABELS[`${isShuffled ? \"shuffle\" : \"ordered\"}-${repeat}`]\n\n  const mode = isAdjustingVolume\n    ? \"volume\"\n    : seek.isSeeking\n      ? \"scrubbing\"\n      : \"progress\"\n  // The pane sliding out keeps its content until it is off screen.\n  const [pane, setPane] = useState<\"volume\" | \"scrubbing\">(\"volume\")\n  const shownPane = mode === \"progress\" ? pane : mode\n  if (shownPane !== pane) setPane(shownPane)\n\n  useEffect(() => {\n    if (shouldFocus) ref.current?.focus({ preventScroll: true })\n    // Focus only when this page arrives.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [])\n\n  const labels = (\n    <>\n      <span>{elapsed}</span>\n      <span>{remaining}</span>\n    </>\n  )\n\n  return (\n    <div\n      ref={ref}\n      className={styles.nowPlaying}\n      role=\"group\"\n      aria-labelledby={labelledBy}\n      tabIndex={0}\n    >\n      <div className={styles.nowPlayingIndex}>\n        <span>\n          {integer.format(playback.queuePosition + 1)} of{\" \"}\n          {integer.format(playback.queue.length)}\n        </span>\n        {playModesLabel && (\n          <>\n            <div className={styles.playModifier} aria-hidden>\n              {repeat === \"one\" && <RepeatOneIcon />}\n              {repeat === \"all\" && <RepeatAllIcon />}\n              {isShuffled && <ShuffleIcon />}\n            </div>\n            <span className={styles.visuallyHidden}>{playModesLabel}</span>\n          </>\n        )}\n      </div>\n\n      {song && (\n        <div className={styles.nowPlayingInfo}>\n          <div className={styles.songTitle}>\n            {song.url ? (\n              <a\n                className={styles.songTitleLink}\n                href={song.url}\n                target=\"_blank\"\n                rel=\"noopener noreferrer\"\n              >\n                <Marquee text={song.name} resetKey={song.id} />\n              </a>\n            ) : (\n              <Marquee text={song.name} resetKey={song.id} />\n            )}\n          </div>\n          <div className={styles.artist} dir=\"auto\">\n            {song.artistName}\n          </div>\n          {song.albumName && (\n            <div className={styles.album} dir=\"auto\">\n              {song.albumName}\n            </div>\n          )}\n        </div>\n      )}\n\n      <div className={styles.progressPanes} data-mode={mode}>\n        <div className={styles.timeAndProgress} aria-hidden>\n          <ProgressBar value={time} max={duration} />\n          <div className={styles.progressLabels}>{labels}</div>\n        </div>\n\n        <div\n          className={styles.scrubber}\n          data-inactive={shownPane !== \"scrubbing\" || undefined}\n        >\n          <ProgressBar\n            variant=\"marker\"\n            value={scrubValue}\n            max={duration}\n            disabled={!playback.hasLoadedItem}\n            label=\"Playback Progress\"\n            valueText={spokenDuration(scrubValue)}\n            onFocus={sliders?.focusScrub}\n            onInput={sliders?.scrub}\n            onCommit={sliders?.commitScrub}\n            onBlur={sliders?.blurScrub}\n          />\n          <div className={styles.progressLabels} aria-hidden>\n            {labels}\n          </div>\n        </div>\n\n        <div\n          className={styles.volume}\n          data-inactive={shownPane !== \"volume\" || undefined}\n        >\n          <VolumeLowIcon />\n          <ProgressBar\n            value={volume}\n            max={100}\n            label=\"Volume\"\n            valueText={`${volume}%`}\n            onFocus={sliders?.focusVolume}\n            onInput={sliders?.setVolume}\n            onBlur={sliders?.blurVolume}\n          />\n          <VolumeHighIcon />\n        </div>\n      </div>\n    </div>\n  )\n}\n",
      "type": "registry:component",
      "target": "@components/ipod-classic/components/now-playing.tsx"
    },
    {
      "path": "src/registry/components/ipod-classic/components/progress-bar.tsx",
      "content": "import styles from \"../ipod-classic.module.css\"\n\n/**\n * The LCD's rounded bar, filled or with a diamond marker. With a `label` it\n * carries an invisible range input for keyboard and screen readers.\n */\nexport function ProgressBar({\n  value,\n  max,\n  variant = \"fill\",\n  label,\n  valueText,\n  disabled,\n  onFocus,\n  onInput,\n  onCommit,\n  onBlur,\n}: {\n  value: number\n  max: number\n  variant?: \"fill\" | \"marker\"\n  label?: string\n  valueText?: string\n  disabled?: boolean\n  onFocus?: () => void\n  onInput?: (value: number) => void\n  onCommit?: () => void\n  onBlur?: () => void\n}) {\n  const percent = max > 0 ? Math.min(100, (value * 100) / max) : 0\n  return (\n    <div className={styles.progressBar}>\n      {variant === \"marker\" ? (\n        <div\n          className={styles.progressMarker}\n          style={{ left: `${percent}%` }}\n        />\n      ) : (\n        <div className={styles.progressFill} style={{ width: `${percent}%` }} />\n      )}\n      {label && (\n        <input\n          className={styles.rangeInput}\n          type=\"range\"\n          min={0}\n          max={max}\n          value={value}\n          disabled={disabled}\n          aria-label={label}\n          aria-valuetext={valueText}\n          onFocus={onFocus}\n          onChange={(event) => onInput?.(event.currentTarget.valueAsNumber)}\n          onPointerUp={onCommit}\n          onKeyUp={onCommit}\n          onBlur={onBlur}\n        />\n      )}\n    </div>\n  )\n}\n",
      "type": "registry:component",
      "target": "@components/ipod-classic/components/progress-bar.tsx"
    },
    {
      "path": "src/registry/components/ipod-classic/components/screen.tsx",
      "content": "\"use client\"\n\nimport { useId, type CSSProperties, type RefObject } from \"react\"\nimport { useAtomValue } from \"jotai\"\nimport { AnimatePresence, motion, useReducedMotion } from \"motion/react\"\n\nimport styles from \"../ipod-classic.module.css\"\nimport { SAD_IPOD } from \"../lib/assets\"\nimport {\n  isInertAtom,\n  itemsAtom,\n  navigationAtom,\n  statusAtom,\n  viewAtom,\n} from \"../lib/atoms\"\nimport { BrickGame } from \"./brick-game\"\nimport { AppleLogo } from \"./icons\"\nimport { MenuList } from \"./menu-list\"\nimport { NowPlaying } from \"./now-playing\"\nimport { TitleBar } from \"./title-bar\"\nimport { useScreenKeyboard } from \"./use-screen-keyboard\"\n\nconst OFFLINE_MESSAGE = \"You are not connected to the internet\"\n\nconst slide = {\n  enter: (back: boolean) => ({ x: back ? \"-100%\" : \"100%\" }),\n  center: { x: 0 },\n  exit: (back: boolean) => ({ x: back ? \"100%\" : \"-100%\" }),\n}\nconst EASE_IN_OUT_SINE = [0.37, 0, 0.63, 1] as const\n\nexport function Screen({\n  menuRef,\n  registerList,\n}: {\n  menuRef: RefObject<HTMLDivElement | null>\n  registerList: (element: HTMLUListElement) => () => void\n}) {\n  const status = useAtomValue(statusAtom)\n  const isInert = useAtomValue(isInertAtom)\n  const titleId = useId()\n\n  return (\n    <div className={styles.screen}>\n      <p className={styles.visuallyHidden} role=\"status\">\n        {status.isOnline\n          ? status.isBooting\n            ? \"Loading\"\n            : \"Ready\"\n          : OFFLINE_MESSAGE}\n      </p>\n\n      {!status.isOnline ? (\n        <OfflineOverlay />\n      ) : (\n        status.isBooting && (\n          <div className={styles.overlay} aria-hidden>\n            <AppleLogo className={styles.bootLogo} />\n          </div>\n        )\n      )}\n\n      <div className={styles.menuLayer} data-hidden={isInert || undefined}>\n        <div ref={menuRef} className={styles.menu}>\n          <TitleBar id={titleId} />\n          <ScreenPages titleId={titleId} registerList={registerList} />\n        </div>\n      </div>\n    </div>\n  )\n}\n\nfunction OfflineOverlay() {\n  return (\n    <div className={styles.overlay} aria-hidden>\n      <div className={styles.sadIpod}>\n        <div\n          className={styles.sadIpodIcon}\n          style={{ \"--mask\": `url(${SAD_IPOD})` } as CSSProperties}\n        />\n        <p className={styles.errorMessage}>{OFFLINE_MESSAGE}</p>\n      </div>\n    </div>\n  )\n}\n\n/** Each push or pop slides a new page in; the old one keeps its content. */\nfunction ScreenPages({\n  titleId,\n  registerList,\n}: {\n  titleId: string\n  registerList: (element: HTMLUListElement) => () => void\n}) {\n  const navigation = useAtomValue(navigationAtom)\n  const view = useAtomValue(viewAtom)\n  const items = useAtomValue(itemsAtom)\n  const reduceMotion = useReducedMotion()\n  const keyboard = useScreenKeyboard()\n\n  return (\n    <div className={styles.screenBody} {...keyboard}>\n      <AnimatePresence initial={false} custom={navigation.back}>\n        <motion.div\n          key={navigation.navigationId}\n          className={styles.screenPage}\n          custom={navigation.back}\n          variants={slide}\n          initial=\"enter\"\n          animate=\"center\"\n          exit=\"exit\"\n          transition={\n            reduceMotion\n              ? { duration: 0 }\n              : { duration: 0.24, ease: EASE_IN_OUT_SINE }\n          }\n        >\n          {view === \"list\" && (\n            <MenuList\n              items={items}\n              selectedIndex={navigation.selectedIndex}\n              idPrefix={`${titleId}-${navigation.navigationId}`}\n              labelledBy={titleId}\n              shouldFocus={navigation.shouldFocus}\n              restoredScrollTop={navigation.restoredScrollTop}\n              listRef={registerList}\n            />\n          )}\n          {view === \"now-playing\" && (\n            <NowPlaying\n              labelledBy={titleId}\n              shouldFocus={navigation.shouldFocus}\n            />\n          )}\n          {view === \"brick\" && <BrickGame />}\n        </motion.div>\n      </AnimatePresence>\n    </div>\n  )\n}\n",
      "type": "registry:component",
      "target": "@components/ipod-classic/components/screen.tsx"
    },
    {
      "path": "src/registry/components/ipod-classic/components/title-bar.tsx",
      "content": "import { useAtomValue } from \"jotai\"\n\nimport styles from \"../ipod-classic.module.css\"\nimport {\n  brickStatusAtom,\n  playbackAtom,\n  titleAtom,\n  viewAtom,\n} from \"../lib/atoms\"\nimport { PauseIcon, PlayIcon } from \"./icons\"\n\nexport function TitleBar({ id }: { id: string }) {\n  const title = useAtomValue(titleAtom)\n  const view = useAtomValue(viewAtom)\n  const brick = useAtomValue(brickStatusAtom)\n  const { hasLoadedItem, isPlaying } = useAtomValue(playbackAtom)\n\n  return (\n    <div id={id} className={styles.titleBar}>\n      {hasLoadedItem &&\n        (isPlaying ? (\n          <PlayIcon className={styles.playIcon} />\n        ) : (\n          <PauseIcon className={styles.playIcon} data-paused=\"\" />\n        ))}\n      <div className={styles.battery} aria-hidden />\n      {/* Brick swaps the title for balls left and score. */}\n      {view === \"brick\" ? (\n        <div className={`${styles.title} ${styles.brickTitle}`} dir=\"ltr\">\n          <span>{brick.balls}</span>\n          <span>{brick.score}</span>\n        </div>\n      ) : (\n        <div className={styles.title} dir=\"auto\">\n          {title}\n        </div>\n      )}\n    </div>\n  )\n}\n",
      "type": "registry:component",
      "target": "@components/ipod-classic/components/title-bar.tsx"
    },
    {
      "path": "src/registry/components/ipod-classic/components/use-screen-keyboard.ts",
      "content": "import { useRef, type KeyboardEvent } from \"react\"\nimport { useStore } from \"jotai\"\n\nimport { wheelSpeed } from \"../lib/acceleration\"\nimport { engineAtom, isInertAtom, viewAtom } from \"../lib/atoms\"\nimport { KEY_ARROW_STEP_DEGREES } from \"../lib/constants\"\n\nconst SCREEN_KEYS = new Set([\n  \"ArrowDown\",\n  \"ArrowUp\",\n  \"ArrowRight\",\n  \"ArrowLeft\",\n  \"Enter\",\n  \" \",\n  \"Escape\",\n])\n\nconst SLIDER_KEYS = new Set([\n  \"ArrowDown\",\n  \"ArrowUp\",\n  \"ArrowRight\",\n  \"ArrowLeft\",\n  \"Home\",\n  \"End\",\n  \"PageUp\",\n  \"PageDown\",\n])\n\n/** Key repeat never counts as a fast spin, so arrows move one row. */\nconst MAX_ARROW_SPEED = 180\n\nfunction consume(event: KeyboardEvent) {\n  event.preventDefault()\n  event.stopPropagation()\n}\n\n/**\n * Keys while a list or Now Playing has focus: arrows move, Enter and Space\n * select, Escape goes back when released.\n */\nexport function useScreenKeyboard() {\n  const store = useStore()\n  const stateRef = useRef<{ isEscapeDown: boolean; lastArrowTime?: number }>({\n    isEscapeDown: false,\n  })\n\n  function onKeyDown(event: KeyboardEvent<HTMLElement>) {\n    const engine = store.get(engineAtom)\n    const view = store.get(viewAtom)\n    if (!engine || view === \"brick\") return\n\n    if (store.get(isInertAtom)) {\n      if (SCREEN_KEYS.has(event.key) || SLIDER_KEYS.has(event.key)) {\n        consume(event)\n      }\n      return\n    }\n\n    // Sliders and the song link keep their own keys on Now Playing.\n    if (view === \"now-playing\" && event.key !== \"Escape\") {\n      const { target } = event\n      const isNative =\n        (target instanceof HTMLInputElement && SLIDER_KEYS.has(event.key)) ||\n        (target instanceof HTMLAnchorElement && event.key === \"Enter\")\n      if (isNative) event.stopPropagation()\n      else if (SCREEN_KEYS.has(event.key)) consume(event)\n      return\n    }\n\n    const state = stateRef.current\n    switch (event.key) {\n      case \"ArrowDown\":\n      case \"ArrowUp\": {\n        consume(event)\n        const direction = event.key === \"ArrowDown\" ? 1 : -1\n        const elapsed =\n          state.lastArrowTime === undefined\n            ? 0\n            : event.timeStamp - state.lastArrowTime\n        state.lastArrowTime = event.timeStamp\n        const speed = Math.min(\n          wheelSpeed(KEY_ARROW_STEP_DEGREES, elapsed),\n          MAX_ARROW_SPEED\n        )\n        engine.menu.move(direction, engine.menu.accelerate(speed, direction))\n        break\n      }\n      case \"ArrowLeft\":\n      case \"ArrowRight\":\n        consume(event)\n        break\n      case \"Enter\":\n      case \" \":\n        consume(event)\n        if (!event.repeat) engine.wheel.select()\n        break\n      case \"Escape\":\n        consume(event)\n        if (!event.repeat) state.isEscapeDown = true\n        break\n    }\n  }\n\n  function onKeyUp(event: KeyboardEvent<HTMLElement>) {\n    const state = stateRef.current\n    if (event.key !== \"Escape\" || !state.isEscapeDown) return\n    state.isEscapeDown = false\n    store.get(engineAtom)?.wheel.menu()\n  }\n\n  function onBlur() {\n    stateRef.current.isEscapeDown = false\n  }\n\n  return { onKeyDown, onKeyUp, onBlur }\n}\n",
      "type": "registry:component",
      "target": "@components/ipod-classic/components/use-screen-keyboard.ts"
    },
    {
      "path": "src/registry/components/ipod-classic/ipod-classic.module.css",
      "content": "/*\n * Dimensions are the device's own pixels; the whole iPod scales down through\n * --ipod-scale on narrow containers.\n */\n\n.root {\n  /* Outlines of the body, screen and wheel. */\n  --ipod-line: var(--muted-foreground);\n  /* Text, bars and the selected row on the screen. */\n  --ipod-ink: var(--foreground);\n  /* Labels on the wheel. */\n  --ipod-icon: var(--muted-foreground);\n  display: block;\n  container-type: inline-size;\n  container-name: ipod;\n  font-family: var(--font-chicago-kare), Krungthep, system-ui, sans-serif;\n  -webkit-text-size-adjust: 100%;\n  text-size-adjust: 100%;\n  -webkit-user-select: none;\n  user-select: none;\n  -webkit-touch-callout: none;\n}\n\n@media (prefers-contrast: more) {\n  .root {\n    --ipod-line: var(--foreground);\n    --ipod-icon: var(--foreground);\n  }\n}\n\n:where(.root) *,\n:where(.root) *::before,\n:where(.root) *::after {\n  box-sizing: border-box;\n}\n\n:where(.root) :where(ul, li, p, button) {\n  margin: 0;\n  padding: 0;\n}\n\n:where(.root) :where(ul) {\n  list-style-type: none;\n}\n\n:where(.root) :where(button) {\n  background: none;\n  border: 0;\n  color: inherit;\n  cursor: pointer;\n  font: inherit;\n  line-height: inherit;\n}\n\n:where(.root) :where(svg) {\n  pointer-events: none;\n}\n\n.ipod {\n  --ipod-scale: 1;\n  position: relative;\n  display: flex;\n  justify-content: center;\n  width: 100%;\n  /* The 415px body stays laid out at full width while scaled down. */\n  overflow-x: clip;\n}\n\n@container ipod (width < 440px) {\n  .ipod {\n    --ipod-scale: 0.9;\n  }\n}\n\n@container ipod (width < 400px) {\n  .ipod {\n    --ipod-scale: 0.8;\n  }\n}\n\n@container ipod (width < 360px) {\n  .ipod {\n    --ipod-scale: 0.75;\n  }\n}\n\n.shadow {\n  position: relative;\n  flex: none;\n  width: 415px;\n  /* `scale` does not shrink layout, so the height follows it by hand. */\n  height: calc(692px * var(--ipod-scale));\n}\n\n.shadowInner {\n  position: relative;\n  width: 100%;\n  margin: 0 auto;\n  transform-origin: top;\n  transition: scale 0.25s ease-in-out;\n  scale: var(--ipod-scale);\n}\n\n.body {\n  position: relative;\n  width: 415px;\n  height: 692px;\n  background: var(--background);\n  border: 1px solid var(--ipod-line);\n  border-radius: 38px;\n}\n\n/* Screen */\n\n.screen {\n  position: relative;\n  box-sizing: content-box;\n  width: 273px;\n  height: 223px;\n  margin: 30px auto 0;\n  padding: 7px;\n  font-size: 26px;\n  line-height: 1;\n  color: var(--ipod-ink);\n  border: 1px solid var(--ipod-line);\n  border-radius: 10px;\n  pointer-events: none;\n}\n\n.menuLayer {\n  width: 100%;\n  height: 100%;\n}\n\n.menuLayer[data-hidden] {\n  visibility: hidden;\n}\n\n.visuallyHidden {\n  position: absolute;\n  width: 1px;\n  height: 1px;\n  margin: -1px;\n  padding: 0;\n  overflow: hidden;\n  clip-path: inset(50%);\n  white-space: nowrap;\n}\n\n.menu {\n  position: relative;\n  z-index: 2;\n  display: flex;\n  flex-direction: column;\n  width: 100%;\n  height: 100%;\n}\n\n.screenBody {\n  position: relative;\n  flex: none;\n  height: 181.7px;\n  overflow: clip;\n}\n\n.screenPage {\n  position: absolute;\n  top: 0;\n  left: 0;\n  width: 100%;\n}\n\n/* Title bar */\n\n.titleBar {\n  position: relative;\n  flex: none;\n  height: 37px;\n  margin: 0 5px;\n  text-align: center;\n  border-bottom: 1px solid var(--ipod-line);\n}\n\n.title {\n  position: absolute;\n  top: calc(50% + 3px);\n  left: 50%;\n  max-width: calc(100% - 86px);\n  overflow: hidden;\n  text-overflow: ellipsis;\n  white-space: nowrap;\n  transform: translate(-50%, -50%);\n}\n\n.brickTitle {\n  display: grid;\n  grid-template-columns: 1fr 1fr;\n  width: calc(100% - 110px);\n  max-width: calc(100% - 110px);\n  overflow: visible;\n}\n\n.brickTitle > :first-child {\n  justify-self: start;\n}\n\n.brickTitle > :last-child {\n  justify-self: end;\n}\n\n.playIcon {\n  position: absolute;\n  top: 50%;\n  inset-inline-start: 10px;\n  display: inline-block;\n  width: auto;\n  height: 20px;\n  fill: var(--ipod-ink);\n  transform: translate(0, calc(-50% + 1.2px)) scale(0.9);\n}\n\n.playIcon[data-paused] {\n  transform: translate(2.3px, calc(-50% + 1.2px)) scale(1, 0.8);\n}\n\n/* Drawn at 3.3x and scaled down so the 2px strokes stay crisp. */\n.battery {\n  position: absolute;\n  top: 3px;\n  inset-inline-end: 5px;\n  box-sizing: content-box;\n  width: 98px;\n  height: 44px;\n  background:\n    linear-gradient(var(--ipod-ink), var(--ipod-ink)) right 0 top -6px / 6px\n      calc((100% - 28%) / 2 + 6px) no-repeat,\n    linear-gradient(var(--ipod-ink), var(--ipod-ink)) right 0 bottom -6px / 6px\n      calc((100% - 28%) / 2 + 6px) no-repeat;\n  border: 6px solid var(--ipod-ink);\n  border-right: 0;\n  transform: scale(0.3, 0.3);\n  transform-origin: 100% 23%;\n}\n\n.battery::before {\n  content: \"\";\n  position: absolute;\n  top: 50%;\n  right: -6px;\n  width: 6px;\n  height: 28%;\n  border-top: 6px solid var(--ipod-ink);\n  border-right: 6px solid var(--ipod-ink);\n  border-bottom: 6px solid var(--ipod-ink);\n  transform: translate(0, -50%);\n}\n\n.battery::after {\n  content: \"\";\n  position: absolute;\n  top: 5px;\n  bottom: 5px;\n  left: 5px;\n  width: 84px;\n  background: repeating-linear-gradient(\n    to right,\n    var(--ipod-ink),\n    var(--ipod-ink) 16px,\n    transparent 16px,\n    transparent 22px,\n    var(--ipod-ink) 22px,\n    var(--ipod-ink) 37px,\n    transparent 38px,\n    transparent 43px,\n    var(--ipod-ink) 42px,\n    var(--ipod-ink) 57px,\n    transparent 59px,\n    transparent 64px,\n    var(--ipod-ink) 55px,\n    var(--ipod-ink) 55px\n  );\n}\n\n/* Menu list */\n\n.menuItems {\n  /* Rows measure their offset against the list. */\n  position: relative;\n  height: 180px;\n  margin: 1.7px 0 0;\n  padding: 0 5px;\n  overflow: hidden auto;\n  /*\n   * The site sets these on every element, and any value but `auto` makes\n   * Chrome ignore ::-webkit-scrollbar, leaving a thin overlay scrollbar.\n   */\n  scrollbar-width: auto;\n  scrollbar-color: auto;\n}\n\n/* Firefox has no ::-webkit-scrollbar; the closest is ink on the page. */\n@supports not selector(::-webkit-scrollbar) {\n  .menuItems {\n    scrollbar-color: var(--ipod-ink) transparent;\n  }\n}\n\n.menuItems::-webkit-scrollbar {\n  width: 12px;\n}\n\n.menuItems::-webkit-scrollbar-track {\n  border: 1px solid var(--ipod-line);\n}\n\n.menuItems::-webkit-scrollbar-thumb {\n  background-color: var(--ipod-ink);\n  background-clip: padding-box;\n  border: 2px solid transparent;\n}\n\n.menuItem {\n  display: flex;\n  align-items: center;\n  justify-content: space-between;\n  padding: 3px 12px 1px;\n  overflow: hidden;\n  text-overflow: ellipsis;\n  white-space: nowrap;\n}\n\n.menuItem[data-centered] {\n  justify-content: center;\n}\n\n.menuItem[data-selected]:not([data-action=\"info\"]) {\n  color: var(--background);\n  background-color: var(--ipod-ink);\n}\n\n.itemTitle {\n  overflow: hidden;\n  text-overflow: ellipsis;\n  white-space: nowrap;\n}\n\n.itemValue {\n  font-weight: normal;\n  white-space: nowrap;\n}\n\n.menuItem[data-action=\"inline-toggle\"] .itemValue {\n  overflow: hidden;\n  text-overflow: ellipsis;\n}\n\n.chevron {\n  display: inline-block;\n  flex: none;\n  width: 12px;\n  height: 12px;\n  margin-inline-end: 5px;\n  border-block-start: 3px solid currentcolor;\n  border-inline-end: 3px solid currentcolor;\n  transform: rotate(45deg) translateY(-2px);\n}\n\n/* Now Playing */\n\n.nowPlaying {\n  display: flex;\n  flex-direction: column;\n  height: 180px;\n  margin-top: 1.7px;\n  padding: 4px 15px 7px;\n  overflow: clip;\n}\n\n.nowPlayingIndex {\n  display: grid;\n  grid-template-columns: 1fr auto;\n  align-items: center;\n  margin-bottom: 6px;\n  font-size: 20px;\n  line-height: 1;\n  text-align: left;\n}\n\n.playModifier {\n  display: flex;\n  align-items: center;\n  gap: 6px;\n  fill: var(--ipod-ink);\n}\n\n.nowPlayingInfo {\n  margin-bottom: 5px;\n  text-align: center;\n}\n\n.songTitle {\n  margin-bottom: 2px;\n}\n\n.songTitleLink {\n  display: block;\n  color: inherit;\n  text-decoration: none;\n  pointer-events: auto;\n}\n\n.songTitleLink:hover,\n.songTitleLink:focus-visible {\n  text-decoration: underline;\n}\n\n.artist,\n.album {\n  margin-bottom: 2px;\n  overflow: hidden;\n  text-overflow: ellipsis;\n  white-space: nowrap;\n}\n\n/* Two panes side by side; scrubbing or volume slides the second in. */\n.progressPanes {\n  display: grid;\n  grid-template-columns: 1fr 1fr;\n  gap: 30px;\n  align-items: center;\n  width: calc(200% + 30px);\n  margin-top: auto;\n  transition: transform 0.3s ease-out;\n}\n\n.progressPanes[data-mode=\"volume\"],\n.progressPanes[data-mode=\"scrubbing\"] {\n  transform: translateX(calc(-50% - 15px));\n}\n\n@media (prefers-reduced-motion: reduce) {\n  .progressPanes {\n    transition: none;\n  }\n}\n\n.timeAndProgress,\n.scrubber {\n  padding-top: 10px;\n}\n\n.scrubber,\n.volume {\n  grid-area: 1 / 2;\n}\n\n.scrubber[data-inactive],\n.volume[data-inactive] {\n  opacity: 0;\n}\n\n.progressLabels {\n  display: flex;\n  justify-content: space-between;\n  margin-top: 6px;\n  font-size: 26px;\n  font-feature-settings: \"tnum\";\n  font-variant-numeric: tabular-nums;\n}\n\n.volume {\n  display: grid;\n  grid-template-columns: auto 1fr auto;\n  gap: 7px;\n  align-items: center;\n  fill: var(--ipod-ink);\n}\n\n.progressBar {\n  position: relative;\n  width: 100%;\n  height: 15px;\n  min-height: 12px;\n  overflow: hidden;\n  border: 1px solid var(--ipod-ink);\n  border-radius: 7px;\n}\n\n.progressBar:has(.progressMarker) {\n  overflow: visible;\n}\n\n.progressBar:has(.rangeInput:focus-visible) {\n  outline: 2px solid currentcolor;\n  outline-offset: 2px;\n}\n\n.progressFill {\n  width: 0%;\n  height: 15px;\n  background: var(--ipod-ink);\n}\n\n.progressMarker {\n  position: absolute;\n  top: 50%;\n  width: 10px;\n  height: 10px;\n  background: var(--ipod-ink);\n  transform: translate(-50%, -50%) rotate(45deg);\n}\n\n.rangeInput {\n  position: absolute;\n  inset: 0;\n  width: 100%;\n  height: 100%;\n  margin: 0;\n  opacity: 0;\n}\n\n/* Marquee */\n\n.marquee {\n  overflow: hidden;\n}\n\n.marqueeTrack {\n  --marquee-distance: calc(var(--marquee-copy-width, 0) + 30);\n  display: flex;\n  gap: 30px;\n  width: max-content;\n  margin-inline: auto;\n}\n\n.marquee[data-scrolling] .marqueeTrack {\n  animation: marquee-scroll calc(var(--marquee-distance) * 0.05s) linear 2s\n    infinite;\n}\n\n.marqueeCopy {\n  white-space: nowrap;\n}\n\n@keyframes marquee-scroll {\n  to {\n    transform: translateX(calc(var(--marquee-distance) * -1px));\n  }\n}\n\n@media (prefers-reduced-motion: reduce) {\n  .marqueeTrack {\n    display: block;\n    width: auto;\n  }\n\n  .marquee[data-scrolling] .marqueeTrack {\n    animation: none;\n  }\n\n  .marqueeCopy {\n    display: block;\n    max-width: 100%;\n    overflow: hidden;\n    text-overflow: ellipsis;\n  }\n\n  .marqueeCopy[aria-hidden] {\n    display: none;\n  }\n}\n\n/* Brick */\n\n.brickScreen {\n  height: 180px;\n  margin-top: 1.7px;\n  padding: 0 5px;\n}\n\n.brickCanvas {\n  display: block;\n  width: 100%;\n  color: var(--ipod-ink);\n  image-rendering: pixelated;\n}\n\n/* Boot and error overlays */\n\n.overlay {\n  position: absolute;\n  inset: 0;\n  z-index: 3;\n  display: flex;\n  align-items: center;\n  justify-content: center;\n  pointer-events: none;\n}\n\n.bootLogo {\n  width: 72px;\n  height: 90px;\n  fill: currentcolor;\n  transform: translateY(-10px);\n}\n\n.sadIpod {\n  display: flex;\n  flex-direction: column;\n  align-items: center;\n  justify-content: center;\n  gap: 8px;\n}\n\n.sadIpodIcon {\n  width: 90px;\n  height: 90px;\n  background-color: currentcolor;\n  transform: translateX(-10%);\n  mask: var(--mask) center / contain no-repeat;\n}\n\n.errorMessage {\n  position: absolute;\n  bottom: 20px;\n  margin: 0 10px;\n  font-size: 13px;\n  text-align: center;\n}\n\n/* Click wheel */\n\n.clickWheel {\n  position: relative;\n  top: 30px;\n  width: 350px;\n  height: 350px;\n  margin: 0 auto;\n  border: 1px solid var(--ipod-line);\n  border-radius: 50%;\n  cursor: pointer;\n  touch-action: none;\n  -webkit-user-select: none;\n  user-select: none;\n  -webkit-touch-callout: none;\n}\n\n.clickWheel[data-dragging] .wheelButton,\n.clickWheel[data-dragging] .selectButton {\n  pointer-events: none;\n}\n\n.wheelButton {\n  position: absolute;\n  inset: 0;\n  display: flex;\n  border-radius: 50%;\n  touch-action: manipulation;\n  -webkit-tap-highlight-color: transparent;\n}\n\n.wheelButton svg {\n  fill: var(--ipod-icon);\n  transition: scale 0.15s ease-out;\n}\n\n.wheelButton:active svg {\n  scale: 0.97;\n}\n\n.menuButton {\n  align-items: flex-start;\n  justify-content: center;\n  padding-top: 9.5px;\n  clip-path: polygon(50% 50%, 0% 0%, 100% 0%);\n}\n\n.menuButton svg {\n  width: 136px;\n  height: auto;\n}\n\n.menuButton text {\n  font-family: Arial, sans-serif;\n  font-size: 55px;\n  font-weight: bold;\n  fill: var(--ipod-icon);\n}\n\n.menuButton path {\n  fill: transparent;\n}\n\n.backButton {\n  align-items: center;\n  justify-content: flex-start;\n  padding-left: 6px;\n  clip-path: polygon(50% 50%, 0% 0%, 0% 100%);\n}\n\n.backButton svg {\n  rotate: 180deg;\n}\n\n.forwardButton {\n  align-items: center;\n  justify-content: flex-end;\n  padding-right: 6px;\n  clip-path: polygon(50% 50%, 100% 0%, 100% 100%);\n}\n\n.playPauseButton {\n  align-items: flex-end;\n  justify-content: center;\n  padding-bottom: 12px;\n  clip-path: polygon(50% 50%, 0% 100%, 100% 100%);\n}\n\n/* Two diameters; the scroll ring covers their middle, leaving four dividers. */\n/* Clipped to the wheel's outer edge, so all four ends sit flush with it. */\n.wheelDividers {\n  position: absolute;\n  inset: -1px;\n  overflow: hidden;\n  border-radius: 50%;\n  pointer-events: none;\n}\n\n.wheelDividers::before,\n.wheelDividers::after {\n  content: \"\";\n  position: absolute;\n  top: 0;\n  /* Centers the 1px line, so it turns about the wheel's true center. */\n  left: calc(50% - 0.5px);\n  height: 100%;\n  border-left: 1px solid var(--ipod-line);\n}\n\n.wheelDividers::before {\n  transform: rotate(135deg);\n}\n\n.wheelDividers::after {\n  transform: rotate(45deg);\n}\n\n.scrollWheel {\n  position: absolute;\n  top: 50%;\n  left: 50%;\n  z-index: 1;\n  width: var(--scroll-wheel-pct);\n  height: var(--scroll-wheel-pct);\n  background: var(--background);\n  border: 1px solid var(--ipod-line);\n  border-radius: 50%;\n  cursor: pointer;\n  touch-action: none;\n  transform: translate(-50%, -50%);\n  -webkit-user-select: none;\n  user-select: none;\n  -webkit-touch-callout: none;\n}\n\n.scrollWheel:focus {\n  outline: none;\n}\n\n.selectButton {\n  position: absolute;\n  top: 50%;\n  left: 50%;\n  z-index: 1;\n  width: var(--select-button-pct);\n  height: var(--select-button-pct);\n  background: var(--background);\n  border: 1px solid var(--ipod-line);\n  border-radius: 50%;\n  touch-action: manipulation;\n  transform: translate(-50%, -50%);\n  transition: background-color 0.1s ease-out;\n  -webkit-tap-highlight-color: transparent;\n}\n\n.selectButton:active {\n  background: var(--accent);\n}\n",
      "type": "registry:file",
      "target": "@components/ipod-classic/ipod-classic.module.css"
    },
    {
      "path": "src/registry/components/ipod-classic/ipod-classic.tsx",
      "content": "\"use client\"\n\n// Recreated from the iPod in Apple Music's web app (its 404 page): https://music.apple.com\nimport {\n  useCallback,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n  type ComponentProps,\n} from \"react\"\nimport { createStore, Provider, useAtomValue } from \"jotai\"\n\nimport { cn } from \"@/lib/utils\"\n\nimport { ClickWheel } from \"./components/click-wheel\"\nimport { Screen } from \"./components/screen\"\nimport styles from \"./ipod-classic.module.css\"\nimport { catalogAtom, engineAtom, type IpodStore } from \"./lib/atoms\"\nimport { createCatalog } from \"./lib/catalog\"\nimport { createIpodEngine } from \"./lib/engine\"\nimport type { IpodLibrary } from \"./lib/types\"\n\nexport type IpodClassicProps = ComponentProps<\"div\"> & {\n  /**\n   * Songs and playlists to browse and play.\n   * @fumadocsHref #ipodlibrary\n   */\n  library: IpodLibrary\n}\n\nexport function IpodClassic({\n  library,\n  className,\n  ...props\n}: IpodClassicProps) {\n  const catalog = useMemo(() => createCatalog(library), [library])\n  const [store] = useState(() => {\n    const ipodStore = createStore()\n    ipodStore.set(catalogAtom, catalog)\n    return ipodStore\n  })\n\n  useEffect(() => {\n    store.set(catalogAtom, catalog)\n  }, [store, catalog])\n\n  return (\n    <Provider store={store}>\n      <div {...props} className={cn(styles.root, className)}>\n        <IpodBody store={store} />\n      </div>\n    </Provider>\n  )\n}\n\nfunction IpodBody({ store }: { store: IpodStore }) {\n  const engine = useAtomValue(engineAtom)\n  const menuRef = useRef<HTMLDivElement>(null)\n  const listRef = useRef<HTMLUListElement | null>(null)\n\n  // An outgoing list unmounts after the new one mounts, so it only clears itself.\n  const registerList = useCallback((element: HTMLUListElement) => {\n    listRef.current = element\n    return () => {\n      if (listRef.current === element) listRef.current = null\n    }\n  }, [])\n\n  // The engine needs an AudioContext, so it only exists on the client.\n  useEffect(() => {\n    const created = createIpodEngine({\n      store,\n      getMenuElement: () => menuRef.current,\n      getListElement: () => listRef.current,\n    })\n    store.set(engineAtom, created)\n    return () => {\n      store.set(engineAtom, null)\n      created.destroy()\n    }\n  }, [store])\n\n  return (\n    <div className={styles.ipod}>\n      <div className={styles.shadow}>\n        <div className={styles.shadowInner}>\n          <div\n            className={styles.body}\n            onPointerDown={engine?.handleUserActivity}\n            onKeyDownCapture={(event) =>\n              engine?.handleKeyActivity(event.nativeEvent)\n            }\n          >\n            <Screen menuRef={menuRef} registerList={registerList} />\n            <ClickWheel />\n          </div>\n        </div>\n      </div>\n    </div>\n  )\n}\n",
      "type": "registry:component",
      "target": "@components/ipod-classic/ipod-classic.tsx"
    },
    {
      "path": "src/registry/components/ipod-classic/lib/acceleration.ts",
      "content": "import {\n  ACCELERATION_STALE_MS,\n  MAX_SMOOTHED_SPEED,\n  SPEED_SMOOTHING,\n  type Acceleration,\n} from \"./constants\"\n\n/** Degrees per second. */\nexport function wheelSpeed(degrees: number, elapsedMs: number) {\n  return elapsedMs > 0 ? (degrees / elapsedMs) * 1000 : 0\n}\n\nexport function tierFor(config: Acceleration, heldMs: number) {\n  const index = Math.min(\n    config.tiers.length - 1,\n    Math.floor(heldMs / config.tierMs)\n  )\n  return config.tiers[index]\n}\n\n/**\n * Turns a steady fast spin into bigger steps, climbing a tier every\n * `tierMs` while the smoothed speed stays above `minSpeed`.\n */\nexport function createAccelerator(config: Acceleration) {\n  let smoothed = 0\n  let lastDirection: number | undefined\n  let lastTime: number | undefined\n  let fastSince: number | undefined\n\n  function reset() {\n    smoothed = 0\n    lastDirection = undefined\n    lastTime = undefined\n    fastSince = undefined\n  }\n\n  function next(speed: number, direction: number, active: boolean) {\n    if (!active) {\n      reset()\n      return config.tiers[0]\n    }\n    const now = performance.now()\n    const isStale =\n      lastTime !== undefined && now - lastTime > ACCELERATION_STALE_MS\n    lastTime = now\n    const clamped = Math.min(speed, MAX_SMOOTHED_SPEED)\n\n    if (direction !== lastDirection || isStale) {\n      smoothed = clamped\n      lastDirection = direction\n      fastSince = undefined\n    } else {\n      smoothed += SPEED_SMOOTHING * (clamped - smoothed)\n    }\n\n    if (smoothed <= config.minSpeed) {\n      fastSince = undefined\n      return config.tiers[0]\n    }\n    fastSince ??= now\n    return tierFor(config, now - fastSince)\n  }\n\n  return { next, reset }\n}\n",
      "type": "registry:component",
      "target": "@components/ipod-classic/lib/acceleration.ts"
    },
    {
      "path": "src/registry/components/ipod-classic/lib/assets.ts",
      "content": "// Pixel art from the original firmware, as an alpha mask tinted by `color`.\n\nexport const SAD_IPOD =\n  \"data:image/png;base64,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\"\n",
      "type": "registry:component",
      "target": "@components/ipod-classic/lib/assets.ts"
    },
    {
      "path": "src/registry/components/ipod-classic/lib/atoms.ts",
      "content": "import { atom, type createStore } from \"jotai\"\nimport { atomWithStorage, createJSONStorage } from \"jotai/utils\"\n\nimport { INITIAL_BRICK_STATUS, type BrickStatus } from \"./brick-engine\"\nimport { createCatalog } from \"./catalog\"\nimport type { IpodEngine } from \"./engine\"\nimport {\n  getScreen,\n  screenItems,\n  screenTitle,\n  type MenuContext,\n  type Screen,\n} from \"./menu\"\nimport type { IpodCatalog, IpodSettings, IpodSong, ScrollTarget } from \"./types\"\n\n/** Each iPod owns a store, so two on a page never share a screen. */\nexport type IpodStore = ReturnType<typeof createStore>\n\nexport const DEFAULT_SETTINGS: IpodSettings = {\n  shuffle: \"off\",\n  repeat: \"off\",\n  clicker: \"on\",\n  volume: 50,\n}\n\nconst SETTING_VALUES = {\n  shuffle: [\"off\", \"songs\"],\n  repeat: [\"off\", \"one\", \"all\"],\n  clicker: [\"off\", \"on\"],\n} as const\n\n/** Falls back per field, so one bad value does not wipe the rest. */\nfunction parseSettings(raw: unknown): IpodSettings {\n  const value = (raw ?? {}) as Record<string, unknown>\n  const pick = <T extends string>(values: readonly T[], input: unknown) =>\n    values.includes(input as T) ? (input as T) : undefined\n  const volume = value.volume\n  return {\n    shuffle:\n      pick(SETTING_VALUES.shuffle, value.shuffle) ?? DEFAULT_SETTINGS.shuffle,\n    repeat:\n      pick(SETTING_VALUES.repeat, value.repeat) ?? DEFAULT_SETTINGS.repeat,\n    clicker:\n      pick(SETTING_VALUES.clicker, value.clicker) ?? DEFAULT_SETTINGS.clicker,\n    volume:\n      typeof volume === \"number\" && volume >= 0 && volume <= 100\n        ? volume\n        : DEFAULT_SETTINGS.volume,\n  }\n}\n\nconst settingsStorage = createJSONStorage<IpodSettings>(() => localStorage)\n\nexport const settingsAtom = atomWithStorage(\n  \"ipod-classic:settings\",\n  DEFAULT_SETTINGS,\n  {\n    ...settingsStorage,\n    getItem: (key, initialValue) =>\n      parseSettings(settingsStorage.getItem(key, initialValue)),\n  }\n)\n\nexport const catalogAtom = atom<IpodCatalog>(\n  createCatalog({ songs: [], playlists: [] })\n)\n\nexport const statusAtom = atom({ isBooting: true, isOnline: true })\n\n/** Booting or offline: the screen shows an overlay and input is ignored. */\nexport const isInertAtom = atom((get) => {\n  const { isBooting, isOnline } = get(statusAtom)\n  return isBooting || !isOnline\n})\n\nexport type PlaybackState = {\n  isPlaying: boolean\n  currentTime: number\n  duration: number\n  /** Index into `queue`, which keeps list order even when shuffled. */\n  currentTrackIndex: number\n  /** Position in play order, which differs from the queue when shuffled. */\n  queuePosition: number\n  queue: IpodSong[]\n  hasLoadedItem: boolean\n  isLoading: boolean\n  /** 0 to 1. */\n  volume: number\n}\n\nexport const playbackAtom = atom<PlaybackState>({\n  isPlaying: false,\n  currentTime: 0,\n  duration: 0,\n  currentTrackIndex: 0,\n  queuePosition: 0,\n  queue: [],\n  hasLoadedItem: false,\n  isLoading: false,\n  volume: DEFAULT_SETTINGS.volume / 100,\n})\n\nexport const hasQueueAtom = atom((get) => get(playbackAtom).queue.length > 0)\n\nexport type StackEntry = Screen & {\n  selectedItemId?: string\n  selectedIndexAtPush?: number\n  scrollTopAtPush?: number\n  /** An idle jump was not the user's choice, so going back keeps their row. */\n  suppressSyncAtPush?: boolean\n}\n\nexport type NavigationState = {\n  stack: StackEntry[]\n  selectedIndex: number\n  /** Changes on every push and pop, keying the sliding screen. */\n  navigationId: number\n  back: boolean\n  shouldFocus: boolean\n  restoredScrollTop: number | undefined\n}\n\nexport const navigationAtom = atom<NavigationState>({\n  stack: [{ key: \"main\" }],\n  selectedIndex: 0,\n  navigationId: 0,\n  back: false,\n  shouldFocus: false,\n  restoredScrollTop: undefined,\n})\n\nexport const screenAtom = atom((get) => get(navigationAtom).stack.at(-1)!)\n\nexport const viewAtom = atom((get) => getScreen(get(screenAtom).key).view)\n\nexport const titleAtom = atom((get) =>\n  screenTitle(get(screenAtom), get(catalogAtom))\n)\n\nexport const menuContextAtom = atom<MenuContext>((get) => ({\n  catalog: get(catalogAtom),\n  hasNowPlaying: get(hasQueueAtom),\n}))\n\nexport const itemsAtom = atom((get) =>\n  screenItems(get(screenAtom), get(menuContextAtom))\n)\n\n/** How long Select must be held on this screen, if holding does anything. */\nexport const selectHoldMsAtom = atom(\n  (get) => getScreen(get(screenAtom).key).selectHold?.ms ?? null\n)\n\nexport const seekAtom = atom<{ isSeeking: boolean; previewTime?: number }>({\n  isSeeking: false,\n})\n\nexport const isAdjustingVolumeAtom = atom(false)\n\n/** What turning the wheel changes right now. */\nexport const scrollTargetAtom = atom<ScrollTarget>((get) => {\n  if (get(seekAtom).isSeeking) return \"seek\"\n  const view = get(viewAtom)\n  return view === \"now-playing\" ? \"volume\" : view\n})\n\nexport const brickStatusAtom = atom<BrickStatus>(INITIAL_BRICK_STATUS)\n\n/** Set once the client has an AudioContext; null on the server. */\nexport const engineAtom = atom<IpodEngine | null>(null)\n",
      "type": "registry:component",
      "target": "@components/ipod-classic/lib/atoms.ts"
    },
    {
      "path": "src/registry/components/ipod-classic/lib/brick-engine.ts",
      "content": "/** The playfield, in LCD pixels. */\nexport const FIELD_WIDTH = 148\nexport const FIELD_HEIGHT = 101\n\nconst PADDLE_WIDTH = 30\nconst PADDLE_HEIGHT = 4\nconst BALL_RADIUS = 1.5\nconst BRICK_HEIGHT = 4\nconst BRICKS_PER_ROW = 12\nconst BRICK_GAP = 2\nconst ROW_GAP = 4\nconst SIDE_MARGIN = 3\nconst TOP_MARGIN = 3\nconst BRICK_WIDTH =\n  (FIELD_WIDTH - SIDE_MARGIN * 2 - (BRICKS_PER_ROW - 1) * BRICK_GAP) /\n  BRICKS_PER_ROW\nconst FIRST_LEVEL_ROWS = 2\nconst MAX_ROWS = 5\nconst STARTING_BALLS = 3\nconst SERVE_DELAY_MS = 1000\nconst BASE_TICK_MS = 40\nconst SPEEDUP_PER_LEVEL = 0.1\nconst MAX_SPEEDUP = 1.5\nconst BALL_COMPONENT_SPEED = 1.7\nconst BALL_SPEED = Math.hypot(BALL_COMPONENT_SPEED, BALL_COMPONENT_SPEED)\n/** Edge hits come off faster... */\nconst EDGE_SPEED_BOOST = 0.25\n/** ...and at a steeper angle. */\nconst EDGE_ANGLE = 0.8\nconst PADDLE_TRAVEL = FIELD_WIDTH - PADDLE_WIDTH\nconst PADDLE_TOP = FIELD_HEIGHT - PADDLE_HEIGHT\n\nconst clamp = (value: number, min: number, max: number) =>\n  Math.min(Math.max(value, min), max)\n\nexport function tickMs(level: number) {\n  return (\n    BASE_TICK_MS / Math.min(1 + (level - 1) * SPEEDUP_PER_LEVEL, MAX_SPEEDUP)\n  )\n}\n\ntype Brick = { x: number; y: number; destroyed: boolean }\n\nfunction createBricks(level: number) {\n  const rows = Math.min(FIRST_LEVEL_ROWS + level - 1, MAX_ROWS)\n  const bricks: Brick[] = []\n  for (let row = 0; row < rows; row += 1) {\n    for (let column = 0; column < BRICKS_PER_ROW; column += 1) {\n      bricks.push({\n        x: SIDE_MARGIN + column * (BRICK_WIDTH + BRICK_GAP),\n        y: TOP_MARGIN + row * (BRICK_HEIGHT + ROW_GAP),\n        destroyed: false,\n      })\n    }\n  }\n  return bricks\n}\n\nconst serveBall = () => ({\n  x: BALL_RADIUS,\n  y: FIELD_HEIGHT / 2,\n  dx: BALL_COMPONENT_SPEED,\n  dy: BALL_COMPONENT_SPEED,\n})\n\nfunction initialState() {\n  return {\n    paddleX: PADDLE_TRAVEL / 2,\n    ball: serveBall(),\n    isBallInPlay: false,\n    serveTicks: 0,\n    bricks: createBricks(1),\n    score: 0,\n    balls: STARTING_BALLS,\n    level: 1,\n    isGameOver: false,\n  }\n}\n\ntype BrickState = ReturnType<typeof initialState>\n\n/** What the title bar and the screen reader announce. */\nexport type BrickStatus = {\n  score: number\n  balls: number\n  message: string\n}\n\nconst LAUNCH_MESSAGE = \"Press Center to Launch Ball\"\n\nexport const INITIAL_BRICK_STATUS: BrickStatus = {\n  score: 0,\n  balls: STARTING_BALLS,\n  message: LAUNCH_MESSAGE,\n}\n\nexport function brickStatus(state: BrickState): BrickStatus {\n  let message = LAUNCH_MESSAGE\n  if (state.isGameOver) message = \"GAME OVER\"\n  else if (state.isBallInPlay || state.serveTicks > 0) message = \"\"\n  return { score: state.score, balls: state.balls, message }\n}\n\nexport function createBrickGame() {\n  const state = initialState()\n\n  function serve() {\n    state.ball = serveBall()\n    state.isBallInPlay = false\n    state.serveTicks = Math.round(SERVE_DELAY_MS / tickMs(state.level))\n  }\n\n  function loseBall() {\n    state.balls -= 1\n    if (state.balls > 0) {\n      serve()\n      return\n    }\n    state.isBallInPlay = false\n    state.isGameOver = true\n  }\n\n  function nextLevel() {\n    state.level += 1\n    state.bricks = createBricks(state.level)\n    serve()\n  }\n\n  /** Where the ball lands on the paddle sets its angle and speed. */\n  function bounceOffPaddle() {\n    const { ball } = state\n    const half = PADDLE_WIDTH / 2\n    const offset = clamp((ball.x - (state.paddleX + half)) / half, -1, 1)\n    const speed = BALL_SPEED * (1 + Math.abs(offset) * EDGE_SPEED_BOOST)\n    const x = offset * EDGE_ANGLE\n    const length = Math.hypot(x, 1)\n    ball.dx = (x / length) * speed\n    ball.dy = -speed / length\n  }\n\n  function hitSide(index: number): \"side\" | \"face\" | null {\n    const { ball, bricks } = state\n    const { x, y, destroyed } = bricks[index]\n    const neighbor = index - Math.sign(ball.dx)\n    if (\n      destroyed ||\n      ball.x + BALL_RADIUS < x ||\n      ball.x - BALL_RADIUS > x + BRICK_WIDTH ||\n      ball.y + BALL_RADIUS < y ||\n      ball.y - BALL_RADIUS > y + BRICK_HEIGHT\n    ) {\n      return null\n    }\n    const overlapX =\n      ball.dx > 0\n        ? ball.x + BALL_RADIUS - x\n        : x + BRICK_WIDTH - ball.x + BALL_RADIUS\n    const overlapY =\n      ball.dy > 0\n        ? ball.y + BALL_RADIUS - y\n        : y + BRICK_HEIGHT - ball.y + BALL_RADIUS\n    // A side hit is impossible when a live brick sits right beside it.\n    const hasNeighbor =\n      Math.floor(neighbor / BRICKS_PER_ROW) ===\n        Math.floor(index / BRICKS_PER_ROW) &&\n      bricks[neighbor]?.destroyed === false\n\n    if (\n      !hasNeighbor &&\n      overlapX * Math.abs(ball.dy) < overlapY * Math.abs(ball.dx)\n    ) {\n      return (x + BRICK_WIDTH / 2 - ball.x) * ball.dx > 0 ? \"side\" : null\n    }\n    return (y + BRICK_HEIGHT / 2 - ball.y) * ball.dy > 0 ? \"face\" : null\n  }\n\n  function collideBricks() {\n    const { ball } = state\n    for (const [index, brick] of state.bricks.entries()) {\n      const hit = hitSide(index)\n      if (!hit) continue\n      brick.destroyed = true\n      state.score += 1\n      if (hit === \"face\") ball.dy = -ball.dy\n      else ball.dx = -ball.dx\n      return true\n    }\n    return false\n  }\n\n  function tick() {\n    const { ball } = state\n    if (state.serveTicks > 0) {\n      state.serveTicks -= 1\n      state.isBallInPlay = state.serveTicks === 0\n    }\n    if (!state.isBallInPlay) return\n\n    const wasAbovePaddle = ball.y + BALL_RADIUS < PADDLE_TOP\n    ball.x += ball.dx\n    ball.y += ball.dy\n    if (\n      (ball.x <= BALL_RADIUS && ball.dx < 0) ||\n      (ball.x >= FIELD_WIDTH - BALL_RADIUS && ball.dx > 0)\n    ) {\n      ball.dx = -ball.dx\n    }\n    if (ball.y <= BALL_RADIUS && ball.dy < 0) ball.dy = -ball.dy\n    if (ball.y >= FIELD_HEIGHT) {\n      loseBall()\n      return\n    }\n    if (\n      ball.dy > 0 &&\n      wasAbovePaddle &&\n      ball.y + BALL_RADIUS >= PADDLE_TOP &&\n      ball.x + BALL_RADIUS >= state.paddleX &&\n      ball.x - BALL_RADIUS <= state.paddleX + PADDLE_WIDTH\n    ) {\n      bounceOffPaddle()\n    }\n    if (collideBricks() && state.bricks.every((brick) => brick.destroyed)) {\n      nextLevel()\n    }\n  }\n\n  /** `fraction` of the paddle's full travel; a whole turn crosses the field. */\n  function movePaddle(fraction: number) {\n    if (state.isGameOver) return\n    state.paddleX = clamp(\n      state.paddleX + fraction * PADDLE_TRAVEL,\n      0,\n      PADDLE_TRAVEL\n    )\n  }\n\n  function launchBall() {\n    if (state.isGameOver) {\n      Object.assign(state, initialState())\n      return\n    }\n    state.isBallInPlay = true\n    state.serveTicks = 0\n  }\n\n  return { state, tick, movePaddle, launchBall }\n}\n\nconst INK = 1\nconst PADDLE_INK = 2\n\n/** Pixels driven by `ink` light up per `drive`, with the LCD's smear. */\nexport function drawField(state: BrickState, drive: Uint8Array) {\n  drive.fill(0)\n  const fill = (\n    x: number,\n    y: number,\n    width: number,\n    height: number,\n    value = INK\n  ) => {\n    const left = Math.max(Math.round(x), 0)\n    const right = Math.min(Math.round(x) + width, FIELD_WIDTH)\n    const bottom = Math.min(Math.round(y) + height, FIELD_HEIGHT)\n    for (let row = Math.max(Math.round(y), 0); row < bottom; row += 1) {\n      drive.fill(value, row * FIELD_WIDTH + left, row * FIELD_WIDTH + right)\n    }\n  }\n\n  for (const brick of state.bricks) {\n    if (!brick.destroyed) fill(brick.x, brick.y, BRICK_WIDTH, BRICK_HEIGHT)\n  }\n  fill(state.paddleX, PADDLE_TOP, PADDLE_WIDTH, PADDLE_HEIGHT, PADDLE_INK)\n  fill(\n    state.ball.x - BALL_RADIUS,\n    state.ball.y - BALL_RADIUS,\n    BALL_RADIUS * 2,\n    BALL_RADIUS * 2\n  )\n}\n\nconst RISE_MS = 20\nconst FALL_MS = 70\n/** The paddle clears faster so steering does not leave a long trail. */\nconst PADDLE_FALL_MS = 25\nconst SETTLED = 1 / 255\n\n/**\n * Slow LCD crystals: each pixel eases toward its drive through two stages,\n * rising fast and fading slow, which leaves the ball a short ghost trail.\n */\nexport function createLcdInk(width: number, height: number) {\n  const size = width * height\n  const drive = new Uint8Array(size)\n  const stage = new Float32Array(size)\n  const ink = new Float32Array(size)\n  const lastDrive = new Uint8Array(size)\n\n  function fade(elapsedMs: number) {\n    const rise = 1 - Math.exp(-elapsedMs / RISE_MS)\n    const fall = 1 - Math.exp(-elapsedMs / FALL_MS)\n    const paddleFall = 1 - Math.exp(-elapsedMs / PADDLE_FALL_MS)\n    let changed = false\n\n    for (let i = 0; i < size; i += 1) {\n      const target = drive[i] === 0 ? 0 : 1\n      lastDrive[i] = drive[i] || lastDrive[i]\n      if (\n        Math.abs(target - stage[i]) > SETTLED ||\n        Math.abs(target - ink[i]) > SETTLED\n      ) {\n        const falloff = lastDrive[i] === PADDLE_INK ? paddleFall : fall\n        const toStage = target - stage[i]\n        stage[i] += toStage * (toStage > 0 ? rise : falloff)\n        const toInk = stage[i] - ink[i]\n        ink[i] += toInk * (toInk > 0 ? rise : falloff)\n        changed = true\n      } else {\n        changed ||= stage[i] !== target || ink[i] !== target\n        stage[i] = target\n        ink[i] = target\n      }\n    }\n    return changed\n  }\n\n  function settle() {\n    for (let i = 0; i < size; i += 1) {\n      lastDrive[i] = drive[i] || lastDrive[i]\n      stage[i] = drive[i] === 0 ? 0 : 1\n      ink[i] = stage[i]\n    }\n  }\n\n  return { width, height, drive, ink, fade, settle }\n}\n\ntype LcdInk = ReturnType<typeof createLcdInk>\n\n/** Pixel edges dim to this, drawing the LCD's grid between cells. */\nconst GRID_SHADE = 0.7\nconst MIN_SCALE_FOR_GRID = 3\n\nfunction gridShade(position: number, scale: number) {\n  const edge = Math.round((position + 0.5) / scale) * scale\n  return 1 - (1 - GRID_SHADE) * Math.max(0, 1 - Math.abs(position + 0.5 - edge))\n}\n\n/** Paints the ink buffer onto a canvas at device resolution. */\nexport function createLcdRenderer(canvas: HTMLCanvasElement, lcd: LcdInk) {\n  const context = canvas.getContext(\"2d\")\n  let image: ImageData | undefined\n  let sourceIndex = new Int32Array(0)\n  let shade = new Float32Array(0)\n  let resolution: MediaQueryList | undefined\n\n  function buildMaps() {\n    const { width, height } = canvas\n    const scale = width / lcd.width\n    const showGrid = scale > 1\n    sourceIndex = new Int32Array(width * height)\n    shade = new Float32Array(width * height)\n    for (let y = 0; y < height; y += 1) {\n      const row = Math.min(Math.floor((y + 0.5) / scale), lcd.height - 1)\n      const rowShade = showGrid ? gridShade(y, scale) : 1\n      for (let x = 0; x < width; x += 1) {\n        const column = Math.floor((x + 0.5) / scale)\n        const index = y * width + x\n        sourceIndex[index] = row * lcd.width + column\n        shade[index] = rowShade * (showGrid ? gridShade(x, scale) : 1) * 255\n      }\n    }\n  }\n\n  function paint() {\n    if (!context || !image) return\n    for (let i = 0; i < sourceIndex.length; i += 1) {\n      image.data[i * 4 + 3] = lcd.ink[sourceIndex[i]] * shade[i]\n    }\n    context.putImageData(image, 0, 0)\n  }\n\n  function resize() {\n    const style = getComputedStyle(canvas)\n    const scale = Number(style.getPropertyValue(\"--ipod-scale\")) || 1\n    const deviceWidth = Math.round(\n      canvas.clientWidth * scale * devicePixelRatio\n    )\n    const width =\n      deviceWidth >= lcd.width * MIN_SCALE_FOR_GRID ? deviceWidth : lcd.width\n    if (image && width === canvas.width) return\n\n    canvas.width = width\n    canvas.height = Math.round((width * lcd.height) / lcd.width)\n    buildMaps()\n    image = context?.createImageData(canvas.width, canvas.height)\n    applyInk()\n  }\n\n  /** Ink is the canvas's CSS color, which follows the site theme. */\n  function applyInk() {\n    if (!context || !image) return\n    // The canvas resolves any CSS color (e.g. oklch) to RGB for us.\n    context.fillStyle = getComputedStyle(canvas).color\n    context.fillRect(0, 0, 1, 1)\n    const [r, g, b] = context.getImageData(0, 0, 1, 1).data\n    for (let i = 0; i < image.data.length; i += 4) {\n      image.data.set([r, g, b], i)\n    }\n    paint()\n  }\n\n  function watchResolution() {\n    resolution?.removeEventListener(\"change\", watchResolution)\n    resolution = matchMedia(`(resolution: ${devicePixelRatio}dppx)`)\n    resolution.addEventListener(\"change\", watchResolution)\n    resize()\n  }\n\n  // The iPod scales with its container, which a resize of either can change.\n  const observer = new ResizeObserver(resize)\n  observer.observe(document.documentElement)\n  observer.observe(canvas)\n  watchResolution()\n  // Switching theme swaps the class on <html>.\n  const themeObserver = new MutationObserver(applyInk)\n  themeObserver.observe(document.documentElement, {\n    attributes: true,\n    attributeFilter: [\"class\"],\n  })\n\n  return {\n    paint,\n    destroy() {\n      observer.disconnect()\n      themeObserver.disconnect()\n      resolution?.removeEventListener(\"change\", watchResolution)\n    },\n  }\n}\n",
      "type": "registry:component",
      "target": "@components/ipod-classic/lib/brick-engine.ts"
    },
    {
      "path": "src/registry/components/ipod-classic/lib/catalog.ts",
      "content": "import type { IpodArtist, IpodCatalog, IpodLibrary, IpodSong } from \"./types\"\n\nconst collator = new Intl.Collator(\"en\", {\n  sensitivity: \"base\",\n  ignorePunctuation: true,\n  numeric: true,\n})\n\nconst byName = (a: { name: string }, b: { name: string }) =>\n  collator.compare(a.name, b.name)\n\nexport function createCatalog(library: IpodLibrary): IpodCatalog {\n  const songs = [...library.songs].sort(byName)\n  const songsById = new Map(songs.map((song) => [song.id, song]))\n\n  const artistsByName = new Map<string, IpodArtist>()\n  for (const song of songs) {\n    const artist = artistsByName.get(song.artistName)\n    if (artist) {\n      artist.songIds.push(song.id)\n    } else {\n      artistsByName.set(song.artistName, {\n        id: `artist:${song.artistName}`,\n        name: song.artistName,\n        songIds: [song.id],\n      })\n    }\n  }\n\n  return {\n    songs,\n    artists: [...artistsByName.values()].sort(byName),\n    playlists: library.playlists,\n    songsById,\n  }\n}\n\nexport function songsFromIds(ids: string[], catalog: IpodCatalog) {\n  return ids\n    .map((id) => catalog.songsById.get(id))\n    .filter((song): song is IpodSong => !!song)\n}\n",
      "type": "registry:component",
      "target": "@components/ipod-classic/lib/catalog.ts"
    },
    {
      "path": "src/registry/components/ipod-classic/lib/click-sound.ts",
      "content": "const GAIN = 0.3\n/** Clicks closer together than this merge, like the piezo could not keep up. */\nconst MIN_SPACING_SECONDS = 0.05\nconst MAX_BACKLOG_SECONDS = 0.15\nconst RESUME_LEAD_SECONDS = 0.08\nconst STALE_RESUME_MS = 200\n\n/** A 2ms burst of decaying noise, close to the click wheel's piezo tick. */\nfunction createClickBuffer(context: AudioContext) {\n  const { sampleRate } = context\n  const length = Math.round(sampleRate * 0.003)\n  const buffer = context.createBuffer(1, length, sampleRate)\n  const data = buffer.getChannelData(0)\n  const decay = sampleRate * 0.0007\n  // Seeded so every click sounds the same.\n  let seed = 7\n  for (let i = 0; i < length; i += 1) {\n    seed = (seed * 16807) % 2147483647\n    const noise = (seed / 2147483647) * 2 - 1\n    data[i] = noise * 0.72 * Math.exp(-i / decay)\n  }\n  return buffer\n}\n\nconst resuming = new WeakSet<AudioContext>()\n\n/** Browsers start contexts suspended until a gesture; resume on each one. */\nexport function resumeAudioContext(context: AudioContext) {\n  if (context.state === \"running\" || context.state === \"closed\") return\n  if (resuming.has(context)) return\n  resuming.add(context)\n  const done = () => resuming.delete(context)\n  context.resume().catch(done).finally(done)\n  setTimeout(done, 1000)\n}\n\nexport function createClickSound(context: AudioContext) {\n  const output = context.createGain()\n  output.gain.value = GAIN\n  output.connect(context.destination)\n  const buffer = createClickBuffer(context)\n  let nextStart = 0\n  let requestedWhileSuspended: number | null = null\n\n  function play() {\n    const { currentTime } = context\n    if (nextStart - currentTime >= MAX_BACKLOG_SECONDS) return\n    const startAt = Math.max(currentTime, nextStart)\n    const source = context.createBufferSource()\n    source.buffer = buffer\n    source.connect(output)\n    source.start(startAt)\n    nextStart = startAt + MIN_SPACING_SECONDS\n  }\n\n  function onStateChange() {\n    if (context.state !== \"running\") return\n    nextStart = Math.max(nextStart, context.currentTime + RESUME_LEAD_SECONDS)\n    if (requestedWhileSuspended === null) return\n    const isStale = Date.now() - requestedWhileSuspended > STALE_RESUME_MS\n    requestedWhileSuspended = null\n    if (!isStale) play()\n  }\n\n  context.addEventListener(\"statechange\", onStateChange)\n\n  return {\n    playClick() {\n      if (context.state !== \"running\") {\n        resumeAudioContext(context)\n        requestedWhileSuspended ??= Date.now()\n        return\n      }\n      play()\n    },\n    destroy() {\n      context.removeEventListener(\"statechange\", onStateChange)\n      output.disconnect()\n    },\n  }\n}\n",
      "type": "registry:component",
      "target": "@components/ipod-classic/lib/click-sound.ts"
    },
    {
      "path": "src/registry/components/ipod-classic/lib/constants.ts",
      "content": "export const BOOT_MIN_MS = 2000\n\n/** Degrees of wheel rotation per list row. */\nexport const DRAG_STEP_DEGREES = 15\n\n/** Volume moves 1% per 4.5° (100 steps per 1.25 turns). */\nexport const VOLUME_STEP_DEGREES = (1.25 * 360) / 100\n/** Clicks while changing volume are sparser than the steps themselves. */\nexport const VOLUME_CLICK_DEGREES = (1.25 * 360) / 22\nexport const VOLUME_KEY_STEP = 5\n\nexport const LIST_ACCELERATION = {\n  minSpeed: 180,\n  tierMs: 500,\n  /** Rows per click. */\n  tiers: [1, 2, 3, 5, 8, 13, 21, 34],\n}\n\nexport const SEEK_ACCELERATION = {\n  minSpeed: 180,\n  tierMs: 500,\n  /** Seconds per click. */\n  tiers: [1, 2, 3, 5],\n}\n\nexport type Acceleration = typeof LIST_ACCELERATION\n\nexport const MAX_SMOOTHED_SPEED = 400\nexport const SPEED_SMOOTHING = 0.15\nexport const ACCELERATION_STALE_MS = 250\n\nexport const KEY_REPEAT_DELAY_MS = 300\nexport const KEY_REPEAT_INTERVAL_MS = 80\nexport const KEY_ARROW_STEP_DEGREES = 15\n\nexport const HOLD_MS = 1000\nexport const HOLD_REPEAT_MS = 500\n/** Seconds jumped by each repeat while Back or Forward is held. */\nexport const HOLD_SEEK_STEPS = [5, 5, 5, 10, 10, 10, 20]\nexport const SELECT_HOLD_BRICK_MS = 5000\n\nexport const IDLE_JUMP_MS = 10_000\nexport const SEEK_IDLE_MS = 5000\nexport const SEEK_COMMIT_MS = 1000\nexport const VOLUME_IDLE_MS = 5000\nexport const VOLUME_SAVE_MS = 1000\n\n/** Previous restarts the song instead once it has played this long. */\nexport const RESTART_THRESHOLD_SECONDS = 3\nexport const CROSSFADE_SECONDS = 2\n\nexport const BRICK_PADDLE_STEER = 0.035\n\n/** Wheel geometry, as percentages of the 350px click wheel. */\nconst WHEEL_SIZE = 350\nexport const SELECT_BUTTON_PERCENT = (100 / WHEEL_SIZE) * 100\nexport const SCROLL_WHEEL_PERCENT = (276 / WHEEL_SIZE) * 100\n",
      "type": "registry:component",
      "target": "@components/ipod-classic/lib/constants.ts"
    },
    {
      "path": "src/registry/components/ipod-classic/lib/engine.ts",
      "content": "import {\n  isInertAtom,\n  playbackAtom,\n  scrollTargetAtom,\n  seekAtom,\n  settingsAtom,\n  statusAtom,\n  type IpodStore,\n} from \"./atoms\"\nimport { createClickSound, resumeAudioContext } from \"./click-sound\"\nimport { BOOT_MIN_MS, DRAG_STEP_DEGREES, VOLUME_SAVE_MS } from \"./constants\"\nimport { createMenuController } from \"./menu-controller\"\nimport { createPlayback } from \"./playback\"\nimport { createTimeout } from \"./timers\"\nimport type { IpodSettings, RepeatMode, ScrollTarget } from \"./types\"\nimport type { WheelScroll } from \"./wheel-gesture\"\nimport { createHoldSeeker, createWheelScroller } from \"./wheel-scroll\"\n\nconst REPEAT_MODES: Record<IpodSettings[\"repeat\"], RepeatMode> = {\n  off: \"none\",\n  one: \"one\",\n  all: \"all\",\n}\n\nexport type IpodEngine = ReturnType<typeof createIpodEngine>\n\n/** Everything that needs the browser: audio, timers, and input handling. */\nexport function createIpodEngine({\n  store,\n  getMenuElement,\n  getListElement,\n}: {\n  store: IpodStore\n  getMenuElement: () => HTMLElement | null\n  getListElement: () => HTMLElement | null\n}) {\n  const context = new AudioContext()\n  const clickSound = createClickSound(context)\n  const playback = createPlayback(store, context)\n  const menu = createMenuController({\n    store,\n    playback,\n    getMenuElement,\n    getListElement,\n  })\n  const isInert = () => store.get(isInertAtom)\n  const isSeeking = () => store.get(seekAtom).isSeeking\n  const settings = () => store.get(settingsAtom)\n\n  // Boot shows the logo for a moment, but only once the iPod is online.\n  let hasBooted = false\n  const setStatus = (partial: Partial<typeof statusAtom.init>) =>\n    store.set(statusAtom, (status) => ({ ...status, ...partial }))\n  const bootTimer = createTimeout(BOOT_MIN_MS, () =>\n    setStatus({ isBooting: false })\n  )\n\n  function handleOnlineChange() {\n    const isOnline = navigator.onLine\n    setStatus({ isOnline })\n    if (!isOnline) playback.pause()\n    if (hasBooted) return\n    if (isOnline) bootTimer.start()\n    else bootTimer.stop()\n  }\n\n  handleOnlineChange()\n  window.addEventListener(\"online\", handleOnlineChange)\n  window.addEventListener(\"offline\", handleOnlineChange)\n\n  // Volume is saved a moment after it settles, not on every step.\n  const volumePercent = () => Math.round(store.get(playbackAtom).volume * 100)\n  const volumeSaver = createTimeout(VOLUME_SAVE_MS, () =>\n    store.set(settingsAtom, (value) => ({ ...value, volume: volumePercent() }))\n  )\n  let lastVolume = store.get(playbackAtom).volume\n\n  let lastSettings: IpodSettings | undefined\n  function applySettings() {\n    const { shuffle, repeat } = settings()\n    if (shuffle !== lastSettings?.shuffle) {\n      playback.setShuffle(shuffle === \"songs\")\n    }\n    if (repeat !== lastSettings?.repeat) {\n      playback.setRepeatMode(REPEAT_MODES[repeat])\n    }\n    lastSettings = settings()\n  }\n\n  const holdSeeker = createHoldSeeker()\n\n  // Subscribing mounts settingsAtom, which loads the saved settings.\n  const unsubscribers = [\n    store.sub(settingsAtom, applySettings),\n    store.sub(isInertAtom, () => {\n      if (!isInert()) hasBooted = true\n    }),\n    store.sub(playbackAtom, () => {\n      const { volume } = store.get(playbackAtom)\n      if (volume === lastVolume) return\n      lastVolume = volume\n      if (volumePercent() !== settings().volume) volumeSaver.start()\n    }),\n    store.sub(seekAtom, () => {\n      if (isSeeking()) holdSeeker.cancel()\n    }),\n  ]\n  applySettings()\n  playback.setVolume(settings().volume / 100)\n\n  function handleUserActivity() {\n    resumeAudioContext(context)\n    menu.notifyActivity()\n  }\n\n  function click(count: number, target: ScrollTarget) {\n    if (settings().clicker !== \"on\" || target === \"seek\") return\n    for (let i = 0; i < count; i += 1) clickSound.playClick()\n  }\n\n  const scroller = createWheelScroller({ move: menu.move, click })\n\n  function holdSeek(direction: number, isRepeat: boolean) {\n    const state = store.get(playbackAtom)\n    const time = holdSeeker.step(direction, isRepeat, {\n      ...state,\n      isInert: isInert(),\n      isSeeking: isSeeking(),\n    })\n    if (time === undefined) return\n    menu.notifyActivity()\n    playback.seek(time)\n  }\n\n  /** Buttons do nothing until the iPod has booted and while offline. */\n  const whenReady =\n    <T extends unknown[]>(action: (...args: T) => void) =>\n    (...args: T) => {\n      if (!isInert()) action(...args)\n    }\n\n  const scrollTarget = () => store.get(scrollTargetAtom)\n\n  return {\n    menu,\n    handleUserActivity,\n    handleKeyActivity(event: KeyboardEvent) {\n      if (!event.repeat || event.key.startsWith(\"Arrow\")) handleUserActivity()\n    },\n    wheel: {\n      scroll({ step, degrees, speed }: WheelScroll) {\n        menu.notifyActivity()\n        if (isInert()) return\n        const target = scrollTarget()\n        if (target === \"brick\") {\n          menu.turnPaddle(step * degrees)\n          return\n        }\n        scroller.scroll({\n          step,\n          degrees,\n          target,\n          multiplier: menu.accelerate(speed, step),\n          dragStepDegrees: DRAG_STEP_DEGREES,\n        })\n      },\n      keyScroll(step: number, heldMs: number) {\n        menu.notifyActivity()\n        if (isInert()) return\n        if (menu.keyStep(step, heldMs)) click(1, scrollTarget())\n      },\n      dragStart() {\n        scroller.reset()\n        if (!store.get(statusAtom).isBooting) menu.seek.handleDragStart()\n      },\n      dragEnd: () => menu.seek.handleDragEnd(),\n      steer: (direction: number | null) => menu.steerPaddle(direction ?? 0),\n      select: whenReady(menu.select),\n      selectHold: whenReady(menu.selectHold),\n      menu: whenReady(menu.back),\n      playPause: whenReady(menu.playPause),\n      back: whenReady(() => {\n        if (!isSeeking()) playback.skipPrevious()\n      }),\n      forward: whenReady(() => {\n        if (!isSeeking()) playback.skipNext()\n      }),\n      backHold: (repeat: boolean) => holdSeek(-1, repeat),\n      forwardHold: (repeat: boolean) => holdSeek(1, repeat),\n    },\n    /** The hidden sliders on Now Playing, for keyboard and screen readers. */\n    sliders: {\n      focusScrub() {\n        if (!store.get(playbackAtom).hasLoadedItem) return\n        menu.volume.exit()\n        menu.seek.keepOpen()\n      },\n      scrub(time: number) {\n        if (store.get(playbackAtom).hasLoadedItem) {\n          menu.volume.exit()\n          menu.seek.keepOpen()\n        }\n        menu.seek.seekTo(time)\n      },\n      commitScrub: menu.seek.commit,\n      blurScrub: menu.seek.release,\n      focusVolume() {\n        menu.seek.exit()\n        menu.volume.keepOpen()\n      },\n      setVolume(value: number) {\n        menu.volume.keepOpen()\n        menu.volume.set(value)\n      },\n      blurVolume: menu.volume.release,\n    },\n    destroy() {\n      bootTimer.stop()\n      volumeSaver.flush()\n      window.removeEventListener(\"online\", handleOnlineChange)\n      window.removeEventListener(\"offline\", handleOnlineChange)\n      unsubscribers.forEach((unsubscribe) => unsubscribe())\n      menu.destroy()\n      playback.destroy()\n      clickSound.destroy()\n      context.close().catch(() => {})\n    },\n  }\n}\n",
      "type": "registry:component",
      "target": "@components/ipod-classic/lib/engine.ts"
    },
    {
      "path": "src/registry/components/ipod-classic/lib/menu-controller.ts",
      "content": "import { RESET } from \"jotai/utils\"\n\nimport { createAccelerator, tierFor } from \"./acceleration\"\nimport {\n  catalogAtom,\n  DEFAULT_SETTINGS,\n  isAdjustingVolumeAtom,\n  itemsAtom,\n  menuContextAtom,\n  navigationAtom,\n  playbackAtom,\n  screenAtom,\n  scrollTargetAtom,\n  settingsAtom,\n  viewAtom,\n  type IpodStore,\n  type NavigationState,\n  type PlaybackState,\n  type StackEntry,\n} from \"./atoms\"\nimport {\n  IDLE_JUMP_MS,\n  LIST_ACCELERATION,\n  SEEK_ACCELERATION,\n  VOLUME_KEY_STEP,\n} from \"./constants\"\nimport {\n  getScreen,\n  nowPlayingIndexIn,\n  playItems,\n  screenId,\n  screenItems,\n  songsForTarget,\n  type MenuItem,\n  type Screen,\n} from \"./menu\"\nimport {\n  createSeekController,\n  createVolumeController,\n} from \"./now-playing-modes\"\nimport type { Playback } from \"./playback\"\nimport { createTimeout } from \"./timers\"\n\nexport type BrickHandle = {\n  launchBall: () => void\n  movePaddle: (fraction: number) => void\n  steerPaddle: (direction: number) => void\n}\n\nconst NOW_PLAYING: Screen = { key: \"now-playing\" }\n\n/** Remembers each list's last row, and which list started the queue. */\nfunction createSelectionMemory() {\n  const remembered = new Map<string, { itemId: string; index: number }>()\n  let queueSource: string | undefined\n  let lastQueue: PlaybackState[\"queue\"] | undefined\n  let lastIndex: number | undefined\n\n  return {\n    /** While the source list is closed, its row follows the playing song. */\n    syncQueue({ queue, currentTrackIndex }: PlaybackState, stack: Screen[]) {\n      if (queue === lastQueue && currentTrackIndex === lastIndex) return false\n      lastQueue = queue\n      lastIndex = currentTrackIndex\n      const song = queue[currentTrackIndex]\n      if (\n        queueSource &&\n        song &&\n        !stack.some((entry) => screenId(entry) === queueSource)\n      ) {\n        remembered.set(queueSource, {\n          itemId: song.id,\n          index: currentTrackIndex,\n        })\n      }\n      return true\n    },\n    remember(screen: Screen, items: MenuItem[], index: number) {\n      const item = items[index]\n      if (!item || getScreen(screen.key).forgetsSelection) return\n      remembered.set(screenId(screen), { itemId: item.id, index })\n    },\n    indexIn(screen: Screen, items: MenuItem[]) {\n      const entry = remembered.get(screenId(screen))\n      if (!entry) return -1\n      return items[entry.index]?.id === entry.itemId\n        ? entry.index\n        : items.findIndex((item) => item.id === entry.itemId)\n    },\n    setQueueSource(screen: Screen) {\n      queueSource = screenId(screen)\n    },\n    clearQueueSource() {\n      if (!queueSource) return\n      remembered.delete(queueSource)\n      queueSource = undefined\n    },\n  }\n}\n\nexport function createMenuController({\n  store,\n  playback,\n  getMenuElement,\n  getListElement,\n}: {\n  store: IpodStore\n  playback: Playback\n  getMenuElement: () => HTMLElement | null\n  getListElement: () => HTMLElement | null\n}) {\n  const seek = createSeekController(store, playback)\n  const volume = createVolumeController(store, playback)\n  const memory = createSelectionMemory()\n  const listAccelerator = createAccelerator(LIST_ACCELERATION)\n  let brick: BrickHandle | null = null\n  /** The user moved the row, so it stops following the playing song. */\n  let suppressSync = false\n\n  const navigation = () => store.get(navigationAtom)\n  const patch = (partial: Partial<NavigationState>) =>\n    store.set(navigationAtom, (state) => ({ ...state, ...partial }))\n  const top = () => store.get(screenAtom)\n  const currentItems = () => store.get(itemsAtom)\n  const itemsFor = (screen: Screen) =>\n    screenItems(screen, store.get(menuContextAtom))\n\n  function nowPlayingIndex(items: MenuItem[]) {\n    const { queue, currentTrackIndex } = store.get(playbackAtom)\n    return nowPlayingIndexIn(items, queue, currentTrackIndex)\n  }\n\n  function isFocusElsewhere() {\n    const active = document.activeElement\n    return (\n      !!active &&\n      active !== document.body &&\n      !getMenuElement()?.contains(active)\n    )\n  }\n\n  function initialIndexFor(screen: Screen) {\n    const items = itemsFor(screen)\n    const playing = nowPlayingIndex(items)\n    return playing >= 0 ? playing : Math.max(0, memory.indexIn(screen, items))\n  }\n\n  function handleScreenChange(screen: Screen) {\n    const isNowPlaying = getScreen(screen.key).view === \"now-playing\"\n    seek.handleScreenChange(isNowPlaying)\n    volume.handleScreenChange(isNowPlaying)\n    listAccelerator.reset()\n  }\n\n  function push(screen: Screen, isIdleJump = false) {\n    const { stack, selectedIndex, navigationId } = navigation()\n    const current = top()\n    const items = currentItems()\n    memory.remember(current, items, selectedIndex)\n    const annotated: StackEntry = {\n      ...current,\n      selectedItemId: items[selectedIndex]?.id,\n      selectedIndexAtPush: selectedIndex,\n      scrollTopAtPush: getListElement()?.scrollTop,\n      suppressSyncAtPush: isIdleJump && suppressSync,\n    }\n    store.set(navigationAtom, {\n      stack: [...stack.slice(0, -1), annotated, screen],\n      selectedIndex: initialIndexFor(screen),\n      navigationId: navigationId + 1,\n      back: false,\n      shouldFocus: isIdleJump\n        ? !!getMenuElement()?.contains(document.activeElement)\n        : !isFocusElsewhere(),\n      restoredScrollTop: undefined,\n    })\n    suppressSync = false\n    handleScreenChange(screen)\n  }\n\n  function pop() {\n    const { stack, selectedIndex, navigationId } = navigation()\n    if (stack.length <= 1) return\n    memory.remember(top(), currentItems(), selectedIndex)\n    const previous = stack.at(-2)!\n    suppressSync = previous.suppressSyncAtPush ?? false\n\n    const items = itemsFor(previous)\n    const playing = nowPlayingIndex(items)\n    const nextIndex =\n      playing >= 0 && !suppressSync\n        ? playing\n        : Math.max(0, memory.indexIn(previous, items))\n\n    store.set(navigationAtom, {\n      stack: stack.slice(0, -1),\n      selectedIndex: nextIndex,\n      navigationId: navigationId + 1,\n      back: true,\n      shouldFocus: !isFocusElsewhere(),\n      restoredScrollTop:\n        nextIndex === previous.selectedIndexAtPush\n          ? previous.scrollTopAtPush\n          : undefined,\n    })\n    handleScreenChange(previous)\n  }\n\n  function moveBy(delta: number) {\n    const items = currentItems()\n    if (items.length === 0) return false\n    const { selectedIndex } = navigation()\n    const next = Math.min(items.length - 1, Math.max(0, selectedIndex + delta))\n    if (next === selectedIndex) return false\n    patch({ selectedIndex: next })\n    suppressSync = true\n    return true\n  }\n\n  function move(direction: number, count = 1) {\n    switch (store.get(scrollTargetAtom)) {\n      case \"seek\":\n        return seek.seekBy(direction * count)\n      case \"volume\":\n        return volume.change(direction * count)\n      case \"list\":\n        return moveBy(direction * count)\n      default:\n        return false\n    }\n  }\n\n  function accelerate(speed: number, direction: number) {\n    const target = store.get(scrollTargetAtom)\n    const seekMultiplier = seek.accelerate(speed, direction)\n    const listMultiplier = listAccelerator.next(\n      speed,\n      direction,\n      target === \"list\"\n    )\n    return target === \"seek\" ? seekMultiplier : listMultiplier\n  }\n\n  /** A held arrow key climbs the same tiers as a fast spin. */\n  function keyStep(direction: number, heldMs: number) {\n    switch (store.get(scrollTargetAtom)) {\n      case \"seek\":\n        return move(direction, tierFor(SEEK_ACCELERATION, heldMs))\n      case \"volume\":\n        return move(direction, VOLUME_KEY_STEP)\n      default:\n        return move(direction, tierFor(LIST_ACCELERATION, heldMs))\n    }\n  }\n\n  function playFromItem(item: MenuItem | undefined) {\n    if (item?.action !== \"navigate\") return false\n    const songs = songsForTarget(\n      item.target,\n      item.contextId,\n      store.get(catalogAtom)\n    )\n    if (songs.length === 0) return false\n    memory.setQueueSource({ key: item.target, contextId: item.contextId })\n    playback.play(songs)\n    push(NOW_PLAYING)\n    return true\n  }\n\n  function playItem(item: Extract<MenuItem, { action: \"play\" }>) {\n    const items = currentItems()\n    const { selectedIndex } = navigation()\n    if (nowPlayingIndex(items) === selectedIndex) {\n      if (!store.get(playbackAtom).isPlaying) playback.resume()\n    } else {\n      const { songsById } = store.get(catalogAtom)\n      const plays = playItems(items)\n      memory.setQueueSource(top())\n      playback.play(\n        plays\n          .map((play) => songsById.get(play.songId))\n          .filter((song) => song !== undefined),\n        plays.indexOf(item)\n      )\n    }\n    push(NOW_PLAYING)\n  }\n\n  function select() {\n    const view = store.get(viewAtom)\n    if (view === \"brick\") {\n      brick?.launchBall()\n      return\n    }\n    if (view === \"now-playing\") {\n      if (store.get(isAdjustingVolumeAtom)) {\n        volume.exit()\n      } else if (store.get(playbackAtom).hasLoadedItem) {\n        seek.toggle()\n      }\n      return\n    }\n\n    const item = currentItems()[navigation().selectedIndex]\n    switch (item?.action) {\n      case \"navigate\":\n        push({\n          key: item.target,\n          contextId: item.contextId,\n          title: item.screenTitle,\n        })\n        break\n      case \"inline-toggle\":\n        store.set(settingsAtom, (settings) => {\n          const { values, toggleKey } = item\n          const index = values.indexOf(settings[toggleKey])\n          return {\n            ...settings,\n            [toggleKey]: values[(index + 1) % values.length],\n          }\n        })\n        break\n      case \"cancel\":\n        pop()\n        break\n      case \"reset-all\":\n        store.set(settingsAtom, RESET)\n        playback.setVolume(DEFAULT_SETTINGS.volume / 100)\n        pop()\n        break\n      case \"play\":\n        playItem(item)\n        break\n    }\n  }\n\n  function playPause() {\n    const state = store.get(playbackAtom)\n    if (state.hasLoadedItem) {\n      if (state.isPlaying) playback.pause()\n      else playback.resume()\n      return\n    }\n    if (state.isLoading) {\n      playback.pause()\n      return\n    }\n    const item = currentItems()[navigation().selectedIndex]\n    if (playFromItem(item)) return\n    if (item?.action === \"play\") playItem(item)\n    else if (state.queue.length > 0) playback.resume()\n  }\n\n  function selectHold() {\n    const hold = getScreen(top().key).selectHold\n    if (hold) push({ key: hold.target })\n  }\n\n  const idleJump = createTimeout(IDLE_JUMP_MS, () => push(NOW_PLAYING, true))\n  let isIdleJumpArmed = false\n\n  function syncIdleJump() {\n    const armed =\n      store.get(playbackAtom).isPlaying && !getScreen(top().key).blocksIdleJump\n    if (armed === isIdleJumpArmed) return\n    isIdleJumpArmed = armed\n    if (armed) idleJump.start()\n    else idleJump.stop()\n  }\n\n  /** Keeps the row on the playing song and inside the list. */\n  function sync() {\n    const items = currentItems()\n    const { selectedIndex, stack } = navigation()\n    if (selectedIndex >= items.length) {\n      patch({ selectedIndex: Math.max(0, items.length - 1) })\n    }\n    if (memory.syncQueue(store.get(playbackAtom), stack)) {\n      const playing = nowPlayingIndex(items)\n      if (playing >= 0 && !suppressSync) patch({ selectedIndex: playing })\n    }\n    syncIdleJump()\n  }\n\n  const unsubscribers = [\n    store.sub(playbackAtom, sync),\n    store.sub(itemsAtom, sync),\n    store.sub(screenAtom, syncIdleJump),\n    playback.onQueueFinished(() => {\n      memory.clearQueueSource()\n      if (store.get(viewAtom) !== \"now-playing\") return\n      pop()\n      // The Now Playing row it came from no longer exists.\n      if (top().selectedItemId === NOW_PLAYING.key) {\n        patch({ selectedIndex: 0, restoredScrollTop: undefined })\n      }\n    }),\n  ]\n\n  return {\n    seek,\n    volume,\n    back: pop,\n    select,\n    selectHold,\n    playPause,\n    accelerate,\n    move,\n    keyStep,\n    /** Any input restarts the countdown to Now Playing. */\n    notifyActivity() {\n      if (isIdleJumpArmed) idleJump.start()\n    },\n    registerBrick(handle: BrickHandle | null) {\n      brick = handle\n    },\n    turnPaddle(degrees: number) {\n      brick?.movePaddle(degrees / 360)\n    },\n    steerPaddle(direction: number) {\n      brick?.steerPaddle(direction)\n    },\n    destroy() {\n      unsubscribers.forEach((unsubscribe) => unsubscribe())\n      idleJump.stop()\n      seek.destroy()\n      volume.destroy()\n    },\n  }\n}\n",
      "type": "registry:component",
      "target": "@components/ipod-classic/lib/menu-controller.ts"
    },
    {
      "path": "src/registry/components/ipod-classic/lib/menu.ts",
      "content": "import { songsFromIds } from \"./catalog\"\nimport { SELECT_HOLD_BRICK_MS } from \"./constants\"\nimport type { IpodCatalog, IpodSettings, IpodSong } from \"./types\"\n\nexport type ScreenKey =\n  | \"main\"\n  | \"settings\"\n  | \"about\"\n  | \"reset-settings\"\n  | \"playlists\"\n  | \"artists\"\n  | \"songs\"\n  | \"playlist-tracks\"\n  | \"artist-tracks\"\n  | \"now-playing\"\n  | \"brick\"\n\nexport type ToggleKey = \"shuffle\" | \"repeat\" | \"clicker\"\n\nexport type MenuItem = { id: string; title: string } & (\n  | {\n      action: \"navigate\"\n      target: ScreenKey\n      contextId?: string\n      screenTitle?: string\n    }\n  | { action: \"inline-toggle\"; toggleKey: ToggleKey; values: string[] }\n  | { action: \"cancel\" }\n  | { action: \"reset-all\" }\n  | { action: \"play\"; songId: string }\n  | { action: \"info\"; value?: string; centered?: boolean }\n)\n\nexport type Screen = {\n  key: ScreenKey\n  contextId?: string\n  /** Overrides the screen's own title, e.g. Artists > All shows \"All Songs\". */\n  title?: string\n}\n\n/** What every list is built from, apart from the screen itself. */\nexport type MenuContext = {\n  catalog: IpodCatalog\n  hasNowPlaying: boolean\n}\n\ntype ItemsContext = MenuContext & { contextId?: string }\n\ntype ScreenDefinition = {\n  view: \"list\" | \"now-playing\" | \"brick\"\n  title: string | ((catalog: IpodCatalog, contextId?: string) => string)\n  items?: (context: ItemsContext) => MenuItem[]\n  /** Main menu gains a Now Playing row while something is queued. */\n  listsNowPlaying?: boolean\n  /** Holding Select this long opens `target`. */\n  selectHold?: { ms: number; target: ScreenKey }\n  /** Reopening starts from the top instead of the last row. */\n  forgetsSelection?: boolean\n  /** Playing music does not jump here to Now Playing when idle. */\n  blocksIdleJump?: boolean\n}\n\nconst VALUE_LABELS: Record<string, string> = {\n  off: \"Off\",\n  on: \"On\",\n  songs: \"Songs\",\n  one: \"One\",\n  all: \"All\",\n}\n\nfunction settingValueLabel(value: string) {\n  return VALUE_LABELS[value] ?? value\n}\n\nconst TOGGLE_VALUES: Record<ToggleKey, string[]> = {\n  shuffle: [\"off\", \"songs\"],\n  repeat: [\"off\", \"one\", \"all\"],\n  clicker: [\"off\", \"on\"],\n}\n\nconst TOGGLE_TITLES: Record<ToggleKey, string> = {\n  shuffle: \"Shuffle\",\n  repeat: \"Repeat\",\n  clicker: \"Clicker\",\n}\n\nconst NO_MUSIC: MenuItem[] = [\n  { id: \"no-music\", title: \"No Music\", action: \"info\", centered: true },\n]\n\nconst orNoMusic = (items: MenuItem[]) => (items.length ? items : NO_MUSIC)\n\nfunction navigate(key: ScreenKey): MenuItem {\n  const { title } = SCREENS[key]\n  return {\n    id: key,\n    title: typeof title === \"string\" ? title : key,\n    action: \"navigate\",\n    target: key,\n  }\n}\n\nfunction inlineToggle(key: ToggleKey): MenuItem {\n  return {\n    id: key,\n    title: TOGGLE_TITLES[key],\n    action: \"inline-toggle\",\n    toggleKey: key,\n    values: TOGGLE_VALUES[key],\n  }\n}\n\nconst gigabytes = new Intl.NumberFormat(\"en-US\", {\n  style: \"unit\",\n  unit: \"gigabyte\",\n  maximumFractionDigits: 1,\n})\nconst integer = new Intl.NumberFormat(\"en-US\")\n\n// The original 5 GB iPod (2001), after formatting.\nconst CAPACITY_GB = 4.6\n// Apple's \"1,000 songs\" math: four minutes at 160 kbps.\nconst SONG_SIZE_GB = 0.0048\n\nexport function songsForTarget(\n  target: ScreenKey,\n  contextId: string | undefined,\n  catalog: IpodCatalog\n): IpodSong[] {\n  switch (target) {\n    case \"songs\":\n      return catalog.songs\n    case \"playlist-tracks\":\n      return songsFromIds(\n        catalog.playlists.find((playlist) => playlist.id === contextId)\n          ?.songIds ?? [],\n        catalog\n      )\n    case \"artist-tracks\":\n      return songsFromIds(\n        catalog.artists.find((artist) => artist.id === contextId)?.songIds ??\n          [],\n        catalog\n      )\n    default:\n      return []\n  }\n}\n\nfunction trackItems(target: ScreenKey) {\n  return ({ catalog, contextId }: ItemsContext) =>\n    orNoMusic(\n      songsForTarget(target, contextId, catalog).map((song) => ({\n        id: song.id,\n        title: song.name,\n        action: \"play\",\n        songId: song.id,\n      }))\n    )\n}\n\nconst SCREENS: Record<ScreenKey, ScreenDefinition> = {\n  main: {\n    view: \"list\",\n    title: \"iPod\",\n    listsNowPlaying: true,\n    items: ({ hasNowPlaying }) => [\n      navigate(\"playlists\"),\n      navigate(\"artists\"),\n      navigate(\"songs\"),\n      navigate(\"settings\"),\n      ...(hasNowPlaying ? [navigate(\"now-playing\")] : []),\n    ],\n  },\n  settings: {\n    view: \"list\",\n    title: \"Settings\",\n    items: () => [\n      navigate(\"about\"),\n      inlineToggle(\"shuffle\"),\n      inlineToggle(\"repeat\"),\n      inlineToggle(\"clicker\"),\n      navigate(\"reset-settings\"),\n    ],\n  },\n  about: {\n    view: \"list\",\n    title: \"About\",\n    selectHold: { ms: SELECT_HOLD_BRICK_MS, target: \"brick\" },\n    items: ({ catalog }) => [\n      // The name an iPod is given in iTunes; a new one is just \"iPod\".\n      { id: \"name\", title: \"ncdai iPod\", action: \"info\", centered: true },\n      {\n        id: \"songs-count\",\n        title: \"Songs\",\n        action: \"info\",\n        value: integer.format(catalog.songs.length),\n      },\n      {\n        id: \"capacity\",\n        title: \"Capacity\",\n        action: \"info\",\n        value: gigabytes.format(CAPACITY_GB),\n      },\n      {\n        id: \"available\",\n        title: \"Available\",\n        action: \"info\",\n        value: gigabytes.format(\n          Math.max(0, CAPACITY_GB - catalog.songs.length * SONG_SIZE_GB)\n        ),\n      },\n      { id: \"version\", title: \"Version\", action: \"info\", value: \"1.0\" },\n    ],\n  },\n  \"reset-settings\": {\n    view: \"list\",\n    title: \"Reset All Settings\",\n    forgetsSelection: true,\n    items: () => [\n      { id: \"cancel\", title: \"Cancel\", action: \"cancel\" },\n      { id: \"reset-all\", title: \"Reset\", action: \"reset-all\" },\n    ],\n  },\n  playlists: {\n    view: \"list\",\n    title: \"Playlists\",\n    items: ({ catalog }) =>\n      orNoMusic(\n        catalog.playlists.map((playlist) => ({\n          id: playlist.id,\n          title: playlist.name,\n          action: \"navigate\",\n          target: \"playlist-tracks\",\n          contextId: playlist.id,\n        }))\n      ),\n  },\n  artists: {\n    view: \"list\",\n    title: \"Artists\",\n    items: ({ catalog }) => {\n      const items: MenuItem[] = catalog.artists.map((artist) => ({\n        id: artist.id,\n        title: artist.name,\n        action: \"navigate\",\n        target: \"artist-tracks\",\n        contextId: artist.id,\n      }))\n      if (items.length && catalog.songs.length) {\n        items.unshift({\n          id: \"all\",\n          title: \"All\",\n          action: \"navigate\",\n          target: \"songs\",\n          screenTitle: \"All Songs\",\n        })\n      }\n      return orNoMusic(items)\n    },\n  },\n  songs: {\n    view: \"list\",\n    title: \"Songs\",\n    items: trackItems(\"songs\"),\n  },\n  \"playlist-tracks\": {\n    view: \"list\",\n    title: (catalog, contextId) =>\n      catalog.playlists.find((playlist) => playlist.id === contextId)?.name ??\n      \"Playlists\",\n    items: trackItems(\"playlist-tracks\"),\n  },\n  \"artist-tracks\": {\n    view: \"list\",\n    title: (catalog, contextId) =>\n      catalog.artists.find((artist) => artist.id === contextId)?.name ??\n      \"Artists\",\n    items: trackItems(\"artist-tracks\"),\n  },\n  \"now-playing\": {\n    view: \"now-playing\",\n    title: \"Now Playing\",\n    blocksIdleJump: true,\n  },\n  brick: {\n    view: \"brick\",\n    title: \"Brick\",\n    blocksIdleJump: true,\n  },\n}\n\nexport function getScreen(key: ScreenKey) {\n  return SCREENS[key]\n}\n\nexport function screenTitle(screen: Screen, catalog: IpodCatalog) {\n  if (screen.title) return screen.title\n  const { title } = SCREENS[screen.key]\n  return typeof title === \"string\" ? title : title(catalog, screen.contextId)\n}\n\nexport function screenItems(screen: Screen, context: MenuContext) {\n  const definition = SCREENS[screen.key]\n  return (\n    definition.items?.({\n      ...context,\n      contextId: screen.contextId,\n      hasNowPlaying: context.hasNowPlaying && !!definition.listsNowPlaying,\n    }) ?? []\n  )\n}\n\nexport function screenId({ key, contextId }: Screen) {\n  return `${key}:${contextId ?? \"\"}`\n}\n\nexport function playItems(items: MenuItem[]) {\n  return items.filter(\n    (item): item is Extract<MenuItem, { action: \"play\" }> =>\n      item.action === \"play\"\n  )\n}\n\n/**\n * Where the playing song sits in `items`, but only when the list is exactly\n * the queue, so a list follows playback only if it started it.\n */\nexport function nowPlayingIndexIn(\n  items: MenuItem[],\n  queue: IpodSong[],\n  currentTrackIndex: number\n) {\n  const plays = playItems(items)\n  const matches =\n    plays.length > 0 &&\n    plays.length === queue.length &&\n    plays.every((item, index) => item.songId === queue[index]?.id)\n  return matches ? items.indexOf(plays[currentTrackIndex]) : -1\n}\n\nexport function settingValue(item: MenuItem, settings: IpodSettings) {\n  if (item.action === \"inline-toggle\") {\n    return settingValueLabel(settings[item.toggleKey])\n  }\n  if (item.action === \"info\") return item.value\n}\n",
      "type": "registry:component",
      "target": "@components/ipod-classic/lib/menu.ts"
    },
    {
      "path": "src/registry/components/ipod-classic/lib/now-playing-modes.ts",
      "content": "import { createAccelerator } from \"./acceleration\"\nimport {\n  isAdjustingVolumeAtom,\n  playbackAtom,\n  seekAtom,\n  type IpodStore,\n  type PlaybackState,\n} from \"./atoms\"\nimport {\n  SEEK_ACCELERATION,\n  SEEK_COMMIT_MS,\n  SEEK_IDLE_MS,\n  VOLUME_IDLE_MS,\n} from \"./constants\"\nimport type { Playback } from \"./playback\"\nimport { createTimeout } from \"./timers\"\n\n/** A mode that closes itself after a quiet spell, unless held open. */\nfunction createIdleMode(options: {\n  timeoutMs: number\n  isActive: () => boolean\n  enter: () => void\n  onLeave: () => void\n}) {\n  let keptOpen = false\n  const timer = createTimeout(options.timeoutMs, leave)\n\n  function leave() {\n    if (!options.isActive()) return\n    timer.stop()\n    options.onLeave()\n  }\n\n  function exit() {\n    keptOpen = false\n    leave()\n  }\n\n  return {\n    restartIdleTimer() {\n      if (!keptOpen) timer.start()\n    },\n    /** Focus on a slider holds the mode open. */\n    keepOpen() {\n      keptOpen = true\n      timer.stop()\n      if (!options.isActive()) options.enter()\n    },\n    release() {\n      keptOpen = false\n      if (options.isActive()) timer.start()\n    },\n    exit,\n    reenter() {\n      const wasKeptOpen = keptOpen\n      leave()\n      if (wasKeptOpen) options.enter()\n    },\n    /** Leaving Now Playing closes the mode. */\n    handleScreenChange(isNowPlaying: boolean) {\n      if (!isNowPlaying) exit()\n    },\n    destroy: timer.stop,\n  }\n}\n\n/** Select on Now Playing: the wheel scrubs through the song. */\nexport function createSeekController(store: IpodStore, playback: Playback) {\n  const accelerator = createAccelerator(SEEK_ACCELERATION)\n  const playbackState = () => store.get(playbackAtom)\n  const isSeeking = () => store.get(seekAtom).isSeeking\n  const setPreview = (previewTime: number | undefined) =>\n    store.set(seekAtom, (state) => ({ ...state, previewTime }))\n  let pending: number | undefined\n  let generation = 0\n  let isDragging = false\n  let enteredTrack: number | undefined\n  let enteredQueue: PlaybackState[\"queue\"] | undefined\n  const commitTimer = createTimeout(SEEK_COMMIT_MS, commit)\n\n  function commit() {\n    commitTimer.stop()\n    if (pending === undefined) return\n    const time = pending\n    pending = undefined\n    const current = ++generation\n    playback.seek(time).then(() => {\n      if (current === generation) setPreview(undefined)\n    })\n  }\n\n  function enter() {\n    const { currentTrackIndex, queue } = playbackState()\n    enteredTrack = currentTrackIndex\n    enteredQueue = queue\n    idle.restartIdleTimer()\n    store.set(seekAtom, { isSeeking: true })\n  }\n\n  function leave() {\n    commit()\n    enteredTrack = undefined\n    enteredQueue = undefined\n    isDragging = false\n    store.set(seekAtom, { isSeeking: false })\n  }\n\n  const idle = createIdleMode({\n    timeoutMs: SEEK_IDLE_MS,\n    isActive: isSeeking,\n    enter,\n    onLeave: leave,\n  })\n\n  function shownTime() {\n    return (\n      store.get(seekAtom).previewTime ?? Math.floor(playbackState().currentTime)\n    )\n  }\n\n  function seekTo(time: number) {\n    if (!isSeeking()) return false\n    const { duration } = playbackState()\n    const max = duration > 0 ? duration : Infinity\n    const target = Math.min(max, Math.max(0, Math.round(time)))\n    idle.restartIdleTimer()\n    if (target === shownTime()) return false\n    pending = target\n    generation += 1\n    if (!isDragging) commitTimer.start()\n    setPreview(target)\n    return true\n  }\n\n  const unsubscribe = store.sub(playbackAtom, () => {\n    if (!isSeeking()) return\n    const { currentTrackIndex, queue, duration, hasLoadedItem } =\n      playbackState()\n    if (currentTrackIndex !== enteredTrack || queue !== enteredQueue) {\n      if (hasLoadedItem) idle.reenter()\n      else idle.exit()\n      return\n    }\n    const { previewTime } = store.get(seekAtom)\n    if (duration > 0 && previewTime !== undefined && previewTime > duration) {\n      if (pending !== undefined) pending = duration\n      setPreview(duration)\n    }\n  })\n\n  return {\n    toggle() {\n      if (isSeeking()) idle.exit()\n      else enter()\n    },\n    seekTo,\n    seekBy: (seconds: number) => seekTo(shownTime() + seconds),\n    commit,\n    accelerate(speed: number, direction: number) {\n      if (isSeeking()) idle.restartIdleTimer()\n      return accelerator.next(speed, direction, isSeeking())\n    },\n    keepOpen: idle.keepOpen,\n    release() {\n      commit()\n      idle.release()\n    },\n    exit: idle.exit,\n    handleScreenChange: idle.handleScreenChange,\n    /** The commit waits for the finger to lift, so audio does not stutter. */\n    handleDragStart() {\n      isDragging = true\n      commitTimer.stop()\n    },\n    handleDragEnd() {\n      isDragging = false\n      if (pending !== undefined) commitTimer.start()\n    },\n    destroy() {\n      commit()\n      idle.destroy()\n      unsubscribe()\n    },\n  }\n}\n\n/** Turning the wheel on Now Playing changes the volume. */\nexport function createVolumeController(store: IpodStore, playback: Playback) {\n  const isAdjusting = () => store.get(isAdjustingVolumeAtom)\n  const setAdjusting = (value: boolean) =>\n    store.set(isAdjustingVolumeAtom, value)\n  const percent = () => Math.round(store.get(playbackAtom).volume * 100)\n\n  const idle = createIdleMode({\n    timeoutMs: VOLUME_IDLE_MS,\n    isActive: isAdjusting,\n    enter: () => setAdjusting(true),\n    onLeave: () => setAdjusting(false),\n  })\n\n  function set(value: number) {\n    const next = Math.min(100, Math.max(0, value))\n    idle.restartIdleTimer()\n    setAdjusting(true)\n    if (next === percent()) return false\n    playback.setVolume(next / 100)\n    return true\n  }\n\n  return {\n    set,\n    change: (delta: number) => set(percent() + delta),\n    keepOpen: idle.keepOpen,\n    release: idle.release,\n    exit: idle.exit,\n    handleScreenChange: idle.handleScreenChange,\n    destroy: idle.destroy,\n  }\n}\n",
      "type": "registry:component",
      "target": "@components/ipod-classic/lib/now-playing-modes.ts"
    },
    {
      "path": "src/registry/components/ipod-classic/lib/playback.ts",
      "content": "import { playbackAtom, type IpodStore, type PlaybackState } from \"./atoms\"\nimport { CrossfadePlayer } from \"./player\"\nimport type { IpodSong, RepeatMode } from \"./types\"\n\nexport type Playback = ReturnType<typeof createPlayback>\n\n/** Owns the queue and one CrossfadePlayer for it, mirrored into `playbackAtom`. */\nexport function createPlayback(store: IpodStore, context: AudioContext) {\n  let player: CrossfadePlayer | undefined\n  let startAbort: AbortController | undefined\n  let shuffle = false\n  let repeatMode: RepeatMode = \"none\"\n  const queueFinishedListeners = new Set<() => void>()\n\n  const get = () => store.get(playbackAtom)\n  const patch = (partial: Partial<PlaybackState>) =>\n    store.set(playbackAtom, (state) => ({ ...state, ...partial }))\n\n  // Controls run one after another so a skip never races a pending start.\n  let chain = Promise.resolve()\n  function enqueue(task: () => Promise<void> | void) {\n    chain = chain.then(async () => {\n      try {\n        await task()\n      } catch {\n        // A failed control (e.g. blocked autoplay) leaves the state as is.\n      }\n    })\n    return chain\n  }\n\n  function destroyPlayer() {\n    const previous = player\n    player = undefined\n    previous?.destroy()\n  }\n\n  function clearQueue() {\n    startAbort?.abort()\n    patch({\n      queue: [],\n      currentTrackIndex: 0,\n      queuePosition: 0,\n      hasLoadedItem: false,\n      isPlaying: false,\n      isLoading: false,\n    })\n    return enqueue(destroyPlayer)\n  }\n\n  function start(queue: IpodSong[], index: number) {\n    startAbort?.abort()\n    const abort = new AbortController()\n    startAbort = abort\n    patch({\n      queue,\n      currentTrackIndex: index,\n      // Shuffle pins the chosen song first.\n      queuePosition: shuffle ? 0 : index,\n      isLoading: true,\n    })\n\n    return enqueue(async () => {\n      if (abort.signal.aborted) return\n      try {\n        destroyPlayer()\n        let hadItem = false\n        const next: CrossfadePlayer = new CrossfadePlayer({\n          urls: queue.map((song) => song.previewUrl),\n          context,\n          shuffle,\n          repeatMode,\n          onAdvance(trackIndex) {\n            if (trackIndex < get().queue.length) {\n              patch({ currentTrackIndex: trackIndex })\n            }\n          },\n          onChange(state) {\n            // A replaced player still reports while it tears down.\n            if (player !== next) return\n            patch(state)\n            if (state.hasLoadedItem === undefined) return\n            const didFinish = hadItem && !state.hasLoadedItem\n            hadItem = state.hasLoadedItem\n            if (didFinish && get().queue.length > 0) {\n              clearQueue()\n              queueFinishedListeners.forEach((listener) => listener())\n            }\n          },\n        })\n        player = next\n        next.setVolume(get().volume)\n        await next.jumpTo(index, true)\n      } finally {\n        if (!abort.signal.aborted) patch({ isLoading: false })\n      }\n    })\n  }\n\n  return {\n    play(queue: IpodSong[], index?: number) {\n      if (queue.length === 0) return Promise.resolve()\n      const startIndex =\n        index ?? (shuffle ? Math.floor(Math.random() * queue.length) : 0)\n      return start(queue, startIndex)\n    },\n    pause: () => enqueue(() => player?.pause()),\n    resume: () => enqueue(() => player?.resume()),\n    skipNext: () => enqueue(() => player?.skipToNext()),\n    skipPrevious: () => enqueue(() => player?.skipToPrevious()),\n    seek(time: number) {\n      const index = get().currentTrackIndex\n      return enqueue(() => player?.seek(time, index))\n    },\n    setVolume(volume: number) {\n      patch({ volume })\n      player?.setVolume(volume)\n    },\n    setShuffle(enabled: boolean) {\n      shuffle = enabled\n      return enqueue(() => player?.setShuffle(enabled))\n    },\n    setRepeatMode(mode: RepeatMode) {\n      repeatMode = mode\n      return enqueue(() => player?.setRepeatMode(mode))\n    },\n    onQueueFinished(listener: () => void) {\n      queueFinishedListeners.add(listener)\n      return () => {\n        queueFinishedListeners.delete(listener)\n      }\n    },\n    destroy() {\n      startAbort?.abort()\n      destroyPlayer()\n    },\n  }\n}\n",
      "type": "registry:component",
      "target": "@components/ipod-classic/lib/playback.ts"
    },
    {
      "path": "src/registry/components/ipod-classic/lib/player.ts",
      "content": "import { CROSSFADE_SECONDS, RESTART_THRESHOLD_SECONDS } from \"./constants\"\nimport type { RepeatMode } from \"./types\"\n\nconst CURVE_POINTS = 50\n\nfunction curve(fn: (t: number) => number) {\n  return Float32Array.from({ length: CURVE_POINTS }, (_, i) =>\n    fn(i / (CURVE_POINTS - 1))\n  )\n}\n\n// Equal-power curves keep the sum steady while two songs overlap.\nconst FADE_IN = curve((t) => Math.cos((1 - t) * Math.PI * 0.5))\nconst FADE_OUT = curve((t) => Math.cos(t * Math.PI * 0.5))\n\nfunction shuffle<T>(items: T[]) {\n  const result = [...items]\n  for (let i = result.length - 1; i > 0; i -= 1) {\n    const j = Math.floor(Math.random() * (i + 1))\n    ;[result[i], result[j]] = [result[j], result[i]]\n  }\n  return result\n}\n\n/** One song's audio element, routed through its own fade gain. */\nclass Channel {\n  readonly audio: HTMLAudioElement\n  private readonly context: AudioContext\n  private readonly gain: GainNode\n  private readonly source: MediaElementAudioSourceNode\n  private fadeDone: ReturnType<typeof setTimeout> | undefined\n\n  constructor(context: AudioContext, url: string, output: AudioNode) {\n    this.audio = new Audio()\n    this.audio.preload = \"auto\"\n    this.audio.crossOrigin = \"anonymous\"\n    this.audio.src = url\n    this.context = context\n    this.gain = context.createGain()\n    this.gain.gain.value = 0\n    this.source = context.createMediaElementSource(this.audio)\n    this.source.connect(this.gain).connect(output)\n  }\n\n  private cancelFade() {\n    clearTimeout(this.fadeDone)\n    this.gain.gain.cancelScheduledValues(this.context.currentTime)\n  }\n\n  private fade(values: Float32Array, onDone?: () => void) {\n    this.cancelFade()\n    this.gain.gain.setValueCurveAtTime(\n      values,\n      this.context.currentTime,\n      CROSSFADE_SECONDS\n    )\n    if (onDone) this.fadeDone = setTimeout(onDone, CROSSFADE_SECONDS * 1000)\n  }\n\n  fadeIn() {\n    this.fade(FADE_IN)\n  }\n\n  fadeOut(onDone?: () => void) {\n    this.fade(FADE_OUT, onDone)\n  }\n\n  cutIn() {\n    this.cancelFade()\n    this.gain.gain.setValueAtTime(1, this.context.currentTime)\n  }\n\n  destroy() {\n    clearTimeout(this.fadeDone)\n    this.audio.pause()\n    this.audio.removeAttribute(\"src\")\n    this.audio.load()\n    this.source.disconnect()\n    this.gain.disconnect()\n  }\n}\n\ntype PlayerState = {\n  isPlaying: boolean\n  currentTime: number\n  duration: number\n  hasLoadedItem: boolean\n  /** Position in play order, which differs from the queue when shuffled. */\n  queuePosition: number\n}\n\n/**\n * Plays a queue like a DJ with two turntables: the channel playing now and\n * the one cued up next, crossfaded over the last seconds of each song.\n */\nexport class CrossfadePlayer {\n  private readonly state: PlayerState = {\n    isPlaying: false,\n    currentTime: 0,\n    duration: 0,\n    hasLoadedItem: false,\n    queuePosition: 0,\n  }\n\n  private readonly urls: string[]\n  private readonly context: AudioContext\n  /** The song shown on screen changed to `index`. */\n  private readonly onAdvance: (index: number) => void\n  private readonly onChange: (state: Partial<PlayerState>) => void\n  private readonly volumeGain: GainNode\n\n  private currentIndex = 0\n  private current: Channel | undefined\n  private next: Channel | undefined\n  private nextIndex: number | undefined\n  /** The channel whose time is on screen; lags `current` mid-crossfade. */\n  private display: Channel | undefined\n  private readonly fading = new Set<Channel>()\n  private pendingCrossfadeFrom: { channel: Channel; index: number } | undefined\n  private hasTriggeredFade = false\n  private isShuffled: boolean\n  private repeatMode: RepeatMode\n  private playOrder: number[] = []\n\n  constructor(options: {\n    urls: string[]\n    context: AudioContext\n    shuffle: boolean\n    repeatMode: RepeatMode\n    onAdvance: (index: number) => void\n    onChange: (state: Partial<PlayerState>) => void\n  }) {\n    this.urls = options.urls\n    this.context = options.context\n    this.onAdvance = options.onAdvance\n    this.onChange = options.onChange\n    this.volumeGain = this.context.createGain()\n    this.volumeGain.connect(this.context.destination)\n    this.isShuffled = options.shuffle\n    this.repeatMode = options.repeatMode\n  }\n\n  private patch(partial: Partial<PlayerState>) {\n    Object.assign(this.state, partial)\n    this.onChange(partial)\n  }\n\n  private setCurrent(channel: Channel | undefined) {\n    this.current = channel\n    this.patch({ hasLoadedItem: !!channel })\n  }\n\n  private clearNext() {\n    this.next?.destroy()\n    this.next = undefined\n    this.nextIndex = undefined\n  }\n\n  private promoteNext() {\n    this.setCurrent(this.next)\n    this.next = undefined\n    this.nextIndex = undefined\n  }\n\n  private destroyActive() {\n    this.current?.destroy()\n    this.clearNext()\n    this.setCurrent(undefined)\n    this.display = undefined\n  }\n\n  private destroyFading() {\n    this.fading.forEach((channel) => channel.destroy())\n    this.fading.clear()\n  }\n\n  private createChannel(index: number) {\n    const url = this.urls[index]\n    if (url === undefined) return\n    const channel = new Channel(this.context, url, this.volumeGain)\n    this.bind(channel)\n    return channel\n  }\n\n  private setDuration(audio: HTMLAudioElement) {\n    if (\n      Number.isFinite(audio.duration) &&\n      audio.duration !== this.state.duration\n    ) {\n      this.patch({ duration: audio.duration })\n    }\n  }\n\n  /** Duration stays 0 until the channel knows its own. */\n  private syncToChannel(channel: Channel | undefined) {\n    this.patch({\n      currentTime: channel?.audio.currentTime ?? 0,\n      duration:\n        channel && Number.isFinite(channel.audio.duration)\n          ? channel.audio.duration\n          : 0,\n    })\n  }\n\n  private syncQueuePosition(index = this.currentIndex) {\n    this.patch({\n      queuePosition: this.isShuffled ? this.playOrder.indexOf(index) : index,\n    })\n  }\n\n  private promoteToDisplay(channel: Channel) {\n    if (channel === this.display) return\n    this.display = channel\n    this.syncToChannel(channel)\n    this.onAdvance(this.currentIndex)\n    this.syncQueuePosition()\n    this.pendingCrossfadeFrom = undefined\n  }\n\n  // Channels are compared by reference: repeat-one crossfades a song into\n  // a new instance of itself, so an index can match both.\n  private bind(channel: Channel) {\n    const { audio } = channel\n\n    audio.addEventListener(\"durationchange\", () => {\n      if (channel === this.display) this.setDuration(audio)\n    })\n\n    audio.addEventListener(\"timeupdate\", () => {\n      if (\n        channel === this.current &&\n        audio.currentTime >= CROSSFADE_SECONDS / 2\n      ) {\n        this.promoteToDisplay(channel)\n      }\n      if (channel === this.display) {\n        this.patch({ currentTime: audio.currentTime })\n        this.setDuration(audio)\n      }\n      if (channel !== this.current) return\n\n      const { currentTime, duration } = audio\n      if (\n        !Number.isFinite(duration) ||\n        duration <= CROSSFADE_SECONDS ||\n        this.hasTriggeredFade ||\n        currentTime < duration - CROSSFADE_SECONDS\n      ) {\n        return\n      }\n      this.hasTriggeredFade = true\n      if (this.next) this.crossfadeToNext()\n      else channel.fadeOut()\n    })\n\n    audio.addEventListener(\"ended\", () => {\n      if (channel !== this.current) return\n      this.promoteToDisplay(channel)\n      if (this.next) {\n        this.crossfadeToNext()\n        return\n      }\n      this.endQueue()\n    })\n  }\n\n  private endQueue() {\n    this.destroyActive()\n    this.destroyFading()\n    this.pendingCrossfadeFrom = undefined\n    this.patch({ isPlaying: false })\n    this.syncToChannel(undefined)\n  }\n\n  private autoAdvanceIndex(from: number) {\n    return this.repeatMode === \"one\" ? from : this.adjacentIndex(from, 1)\n  }\n\n  private displayedIndex() {\n    return this.pendingCrossfadeFrom?.index ?? this.currentIndex\n  }\n\n  /** Manual skips always land on a different song. */\n  private adjacentIndex(from: number, direction: 1 | -1) {\n    const wraps = this.repeatMode === \"all\"\n\n    if (!this.isShuffled) {\n      const index = from + direction\n      if (index >= 0 && index < this.urls.length) return index\n      if (!wraps) return\n      return direction === 1 ? 0 : this.urls.length - 1\n    }\n\n    const position = this.playOrder.indexOf(from) + direction\n    if (position >= 0 && position < this.playOrder.length) {\n      return this.playOrder[position]\n    }\n    if (!wraps) return\n    return this.playOrder[direction === 1 ? 0 : this.playOrder.length - 1]\n  }\n\n  /** Re-cues the second turntable whenever the index, shuffle or repeat changes. */\n  private prepareNext() {\n    if (!this.current) return\n    const index = this.autoAdvanceIndex(this.currentIndex)\n    if (index === this.nextIndex) return\n    this.clearNext()\n    if (index === undefined) return\n    this.nextIndex = index\n    this.next = this.createChannel(index)\n  }\n\n  private crossfadeToNext() {\n    const from = this.current\n    const to = this.next\n    if (!from || !to || this.nextIndex === undefined) return\n\n    this.pendingCrossfadeFrom ??= { channel: from, index: this.currentIndex }\n    from.fadeOut(() => {\n      from.destroy()\n      this.fading.delete(from)\n      if (this.pendingCrossfadeFrom?.channel === from) {\n        this.pendingCrossfadeFrom = undefined\n        if (this.current) this.promoteToDisplay(this.current)\n      } else if (to === this.current) {\n        this.promoteToDisplay(to)\n      }\n    })\n    this.fading.add(from)\n\n    to.audio.play().catch(() => {\n      if (to !== this.current) return\n      this.patch({ isPlaying: false })\n      this.promoteToDisplay(to)\n    })\n    to.fadeIn()\n\n    this.currentIndex = this.nextIndex\n    this.promoteNext()\n    this.hasTriggeredFade = false\n    this.prepareNext()\n  }\n\n  /** Undoes a crossfade that started but is not on screen yet. */\n  private revertPendingCrossfade() {\n    const pending = this.pendingCrossfadeFrom\n    if (!pending) return\n    this.pendingCrossfadeFrom = undefined\n    this.current?.destroy()\n    pending.channel.cutIn()\n    this.fading.delete(pending.channel)\n    this.destroyFading()\n    this.currentIndex = pending.index\n    this.setCurrent(pending.channel)\n    this.clearNext()\n    this.hasTriggeredFade = false\n    this.syncQueuePosition()\n    this.prepareNext()\n  }\n\n  private restartInPlace(channel: Channel) {\n    channel.audio.currentTime = 0\n    channel.cutIn()\n    this.hasTriggeredFade = false\n    this.pendingCrossfadeFrom = undefined\n    this.syncToChannel(channel)\n  }\n\n  /** Repeat-one locks Next and Previous to the current song. */\n  private restartIfRepeatOne() {\n    if (this.repeatMode !== \"one\") return false\n    if (this.current) this.restartInPlace(this.current)\n    return true\n  }\n\n  async resume() {\n    const channel = this.current\n    if (!channel) {\n      await this.jumpTo(this.currentIndex, true)\n      return\n    }\n    await channel.audio.play()\n    channel.cutIn()\n    this.hasTriggeredFade = false\n    this.patch({ isPlaying: true })\n  }\n\n  pause() {\n    this.current?.audio.pause()\n    this.fading.forEach((channel) => channel.audio.pause())\n    this.patch({ isPlaying: false })\n  }\n\n  async skipToNext() {\n    if (this.restartIfRepeatOne()) return\n    const index = this.adjacentIndex(this.currentIndex, 1)\n    if (index !== undefined) {\n      await this.jumpTo(index)\n      return\n    }\n    if (!this.pendingCrossfadeFrom && this.current) this.endQueue()\n  }\n\n  /** Restarts a song that has played a while, otherwise goes back one. */\n  async skipToPrevious() {\n    if (this.restartIfRepeatOne()) return\n    const channel = this.current\n    if (\n      channel &&\n      this.state.isPlaying &&\n      channel.audio.currentTime > RESTART_THRESHOLD_SECONDS\n    ) {\n      this.restartInPlace(channel)\n      return\n    }\n    const index = this.adjacentIndex(this.currentIndex, -1)\n    if (index !== undefined) {\n      await this.jumpTo(index)\n      return\n    }\n    if (!this.pendingCrossfadeFrom && channel) this.endQueue()\n  }\n\n  async jumpTo(index: number, forceResume = false) {\n    if (\n      (index === this.currentIndex && this.current) ||\n      index < 0 ||\n      index >= this.urls.length\n    ) {\n      return\n    }\n    const shouldPlay = forceResume || this.state.isPlaying\n    this.pendingCrossfadeFrom = undefined\n\n    if (index === this.nextIndex && this.next) {\n      this.current?.destroy()\n      this.promoteNext()\n    } else {\n      this.current?.destroy()\n      this.clearNext()\n      this.setCurrent(this.createChannel(index))\n    }\n\n    this.display = this.current\n    this.syncToChannel(this.current)\n    this.currentIndex = index\n    this.hasTriggeredFade = false\n    if (this.isShuffled && this.playOrder.length === 0) {\n      this.buildPlayOrder([index])\n    }\n    this.syncQueuePosition()\n    this.prepareNext()\n    this.onAdvance(this.currentIndex)\n    if (shouldPlay) await this.resume()\n  }\n\n  async seek(time: number, index?: number) {\n    if (\n      index !== undefined &&\n      index !== this.currentIndex &&\n      index !== this.pendingCrossfadeFrom?.index\n    ) {\n      return\n    }\n    this.revertPendingCrossfade()\n    if (index !== undefined && index !== this.currentIndex) return\n\n    const channel = this.current\n    if (!channel) return\n\n    const { duration } = channel.audio\n    const nextIndex = this.autoAdvanceIndex(this.currentIndex)\n    // Seeking into the crossfade window would fade out mid-scrub, so move on.\n    if (\n      Number.isFinite(duration) &&\n      duration > CROSSFADE_SECONDS &&\n      time >= duration - CROSSFADE_SECONDS &&\n      nextIndex !== undefined\n    ) {\n      if (nextIndex === this.currentIndex) this.restartInPlace(channel)\n      else await this.skipToNext()\n      return\n    }\n\n    channel.audio.currentTime = time\n    channel.cutIn()\n    this.hasTriggeredFade = false\n    if (channel === this.display) this.patch({ currentTime: time })\n  }\n\n  setShuffle(enabled: boolean) {\n    if (enabled === this.isShuffled) return\n    this.isShuffled = enabled\n    const shown = this.displayedIndex()\n    if (enabled) {\n      this.buildPlayOrder(\n        this.currentIndex === shown ? [shown] : [shown, this.currentIndex]\n      )\n    }\n    this.syncQueuePosition(shown)\n    this.prepareNext()\n  }\n\n  private buildPlayOrder(pinned: number[]) {\n    const rest = this.urls\n      .map((_, index) => index)\n      .filter((index) => !pinned.includes(index))\n    this.playOrder = [...pinned, ...shuffle(rest)]\n  }\n\n  setRepeatMode(mode: RepeatMode) {\n    if (mode === this.repeatMode) return\n    this.repeatMode = mode\n    this.prepareNext()\n  }\n\n  setVolume(volume: number) {\n    this.volumeGain.gain.setTargetAtTime(\n      Math.min(1, Math.max(0, volume)),\n      this.context.currentTime,\n      0.01\n    )\n  }\n\n  destroy() {\n    this.destroyActive()\n    this.destroyFading()\n    this.volumeGain.disconnect()\n  }\n}\n",
      "type": "registry:component",
      "target": "@components/ipod-classic/lib/player.ts"
    },
    {
      "path": "src/registry/components/ipod-classic/lib/timers.ts",
      "content": "export function createTimeout(ms: number, callback: () => void) {\n  let id: ReturnType<typeof setTimeout> | undefined\n\n  function stop() {\n    clearTimeout(id)\n    id = undefined\n  }\n\n  return {\n    start() {\n      stop()\n      id = setTimeout(() => {\n        id = undefined\n        callback()\n      }, ms)\n    },\n    stop,\n    flush() {\n      if (id === undefined) return\n      stop()\n      callback()\n    },\n  }\n}\n\n/**\n * Fires once after `delay`, then every `interval` until stopped. `stop()`\n * reports whether it fired, so a tap can be told apart from a hold.\n */\nexport function createHoldTimer(onFire: (repeat: boolean) => void) {\n  let timeout: ReturnType<typeof setTimeout> | undefined\n  let interval: ReturnType<typeof setInterval> | undefined\n  let fired = false\n\n  function stop() {\n    clearTimeout(timeout)\n    clearInterval(interval)\n    timeout = undefined\n    interval = undefined\n    const didFire = fired\n    fired = false\n    return didFire\n  }\n\n  return {\n    start(delay: number, repeatInterval?: number) {\n      stop()\n      timeout = setTimeout(() => {\n        timeout = undefined\n        fired = true\n        onFire(false)\n        if (fired && repeatInterval !== undefined) {\n          interval = setInterval(() => onFire(true), repeatInterval)\n        }\n      }, delay)\n    },\n    stop,\n  }\n}\n",
      "type": "registry:component",
      "target": "@components/ipod-classic/lib/timers.ts"
    },
    {
      "path": "src/registry/components/ipod-classic/lib/types.ts",
      "content": "export type IpodSong = {\n  id: string\n  name: string\n  /** Groups songs in Artists. */\n  artistName: string\n  albumName?: string\n  /** Audio file to play. Must be served with CORS headers. */\n  previewUrl: string\n  /** Opened when the song title on Now Playing is clicked. */\n  url?: string\n}\n\nexport type IpodPlaylist = {\n  id: string\n  name: string\n  /** In playback order. */\n  songIds: string[]\n}\n\nexport type IpodLibrary = {\n  /**\n   * Every song. Songs and Artists list them by name.\n   * @fumadocsHref #ipodsong\n   */\n  songs: IpodSong[]\n  /**\n   * Shown in Playlists, in this order.\n   * @fumadocsHref #ipodplaylist\n   */\n  playlists: IpodPlaylist[]\n}\n\nexport type IpodArtist = {\n  id: string\n  name: string\n  songIds: string[]\n}\n\n/** The library as the menus read it: songs and artists sorted by name. */\nexport type IpodCatalog = {\n  songs: IpodSong[]\n  artists: IpodArtist[]\n  playlists: IpodPlaylist[]\n  songsById: Map<string, IpodSong>\n}\n\nexport type RepeatMode = \"none\" | \"one\" | \"all\"\n\ntype ShuffleSetting = \"off\" | \"songs\"\ntype RepeatSetting = \"off\" | \"one\" | \"all\"\ntype ClickerSetting = \"off\" | \"on\"\nexport type IpodSettings = {\n  shuffle: ShuffleSetting\n  repeat: RepeatSetting\n  clicker: ClickerSetting\n  volume: number\n}\n\nexport type ScrollTarget = \"list\" | \"seek\" | \"volume\" | \"brick\"\n",
      "type": "registry:component",
      "target": "@components/ipod-classic/lib/types.ts"
    },
    {
      "path": "src/registry/components/ipod-classic/lib/wheel-gesture.ts",
      "content": "import { wheelSpeed } from \"./acceleration\"\n\n/** Reversing direction needs this much travel, so jitter does not tick back. */\nconst REVERSE_THRESHOLD_DEGREES = 8\n/** Moves that pass this close to the center have no reliable angle. */\nconst CENTER_DEAD_ZONE = 0.1\n\nexport type WheelScroll = {\n  step: 1 | -1\n  degrees: number\n  /** Degrees per second. */\n  speed: number\n}\n\ntype Point = { x: number; y: number }\n\nconst angleOf = ({ x, y }: Point) => (Math.atan2(y, x) * 180) / Math.PI\n\n/** Shortest signed turn from `from` to `to`, in -180..180. */\nfunction angleDelta(from: number, to: number) {\n  return ((((to - from) % 360) + 540) % 360) - 180\n}\n\n/** Squared distance from the center to the segment a to b. */\nfunction segmentDistanceSquared(a: Point, b: Point) {\n  const dx = b.x - a.x\n  const dy = b.y - a.y\n  const lengthSquared = dx * dx + dy * dy\n  const t =\n    lengthSquared === 0\n      ? 0\n      : Math.min(1, Math.max(0, -(a.x * dx + a.y * dy) / lengthSquared))\n  const x = a.x + t * dx\n  const y = a.y + t * dy\n  return x * x + y * y\n}\n\n/**\n * Tracks a finger circling the wheel ring. Presses inside\n * `excludeRadiusRatio` belong to the Select button and are ignored.\n */\nexport function bindWheelGesture(\n  element: HTMLElement,\n  options: {\n    excludeRadiusRatio: number\n    onScroll: (scroll: WheelScroll) => void\n    onDragStart: () => void\n    onDragEnd: () => void\n  }\n) {\n  let pointerId: number | undefined\n  let lastOffset: Point | undefined\n  let lastTime: number | undefined\n  let direction: 1 | -1 | undefined\n  let reverseTravel = 0\n\n  function locate(event: PointerEvent) {\n    const rect = element.getBoundingClientRect()\n    const radius = Math.min(rect.width, rect.height) / 2\n    const inner = radius * options.excludeRadiusRatio\n    const offset = {\n      x: event.clientX - (rect.left + rect.width / 2),\n      y: event.clientY - (rect.top + rect.height / 2),\n    }\n    const distanceSquared = offset.x * offset.x + offset.y * offset.y\n    return {\n      offset,\n      radius,\n      // The epsilon keeps a point exactly on the rim inside.\n      withinRing:\n        distanceSquared <= radius * radius + 1e-6 &&\n        distanceSquared >= inner * inner,\n    }\n  }\n\n  function handleDown(event: PointerEvent) {\n    if (pointerId !== undefined) return\n    const { offset, withinRing } = locate(event)\n    if (!withinRing) return\n    pointerId = event.pointerId\n    lastOffset = offset\n    lastTime = event.timeStamp\n    element.setPointerCapture?.(pointerId)\n    options.onDragStart()\n  }\n\n  function handleMove(event: PointerEvent) {\n    if (\n      event.pointerId !== pointerId ||\n      lastOffset === undefined ||\n      lastTime === undefined\n    ) {\n      return\n    }\n    const { offset, radius } = locate(event)\n    const previous = lastOffset\n    const elapsed = event.timeStamp - lastTime\n    lastOffset = offset\n    lastTime = event.timeStamp\n\n    const deadZone = radius * CENTER_DEAD_ZONE\n    if (segmentDistanceSquared(previous, offset) < deadZone * deadZone) return\n\n    const delta = angleDelta(angleOf(previous), angleOf(offset))\n    if (delta === 0) return\n    const step = delta > 0 ? 1 : -1\n    const degrees = Math.abs(delta)\n\n    if (direction === undefined || step === direction) {\n      direction = step\n      reverseTravel = 0\n    } else {\n      reverseTravel += degrees\n      if (reverseTravel < REVERSE_THRESHOLD_DEGREES) return\n      direction = step\n      reverseTravel = 0\n    }\n\n    options.onScroll({\n      step: direction,\n      degrees,\n      speed: wheelSpeed(degrees, elapsed),\n    })\n  }\n\n  function handleUp(event: PointerEvent) {\n    if (event.pointerId !== pointerId) return\n    element.releasePointerCapture?.(pointerId)\n    pointerId = undefined\n    lastOffset = undefined\n    lastTime = undefined\n    direction = undefined\n    reverseTravel = 0\n    options.onDragEnd()\n  }\n\n  element.addEventListener(\"pointerdown\", handleDown)\n  element.addEventListener(\"pointermove\", handleMove)\n  element.addEventListener(\"pointerup\", handleUp)\n  element.addEventListener(\"pointercancel\", handleUp)\n  element.addEventListener(\"lostpointercapture\", handleUp)\n\n  return () => {\n    element.removeEventListener(\"pointerdown\", handleDown)\n    element.removeEventListener(\"pointermove\", handleMove)\n    element.removeEventListener(\"pointerup\", handleUp)\n    element.removeEventListener(\"pointercancel\", handleUp)\n    element.removeEventListener(\"lostpointercapture\", handleUp)\n  }\n}\n\nconst HOLD_KEYS = [\"Enter\", \" \"]\n\n/**\n * Fires `onLongPress` after `duration` (then every `repeatInterval`) while a\n * button is held by pointer or Enter/Space. The click that ends a long press\n * is swallowed so it does not also count as a tap.\n */\nexport function bindPressAndHold(\n  element: HTMLElement,\n  getOptions: () => {\n    duration: number\n    repeatInterval?: number\n    disabled?: boolean\n    keyboard?: boolean\n    onLongPress: (repeat: boolean) => void\n  }\n) {\n  let pointerId: number | undefined\n  let heldKey: string | undefined\n  let swallowClick = false\n  let fired = false\n  let timeout: ReturnType<typeof setTimeout> | undefined\n  let interval: ReturnType<typeof setInterval> | undefined\n\n  function stopTimer() {\n    clearTimeout(timeout)\n    clearInterval(interval)\n    timeout = undefined\n    interval = undefined\n    const didFire = fired\n    fired = false\n    return didFire\n  }\n\n  function startTimer() {\n    stopTimer()\n    swallowClick = false\n    const { duration, repeatInterval } = getOptions()\n    timeout = setTimeout(() => {\n      timeout = undefined\n      fired = true\n      if (pointerId !== undefined) swallowClick = true\n      getOptions().onLongPress(false)\n      if (repeatInterval !== undefined) {\n        interval = setInterval(\n          () => getOptions().onLongPress(true),\n          repeatInterval\n        )\n      }\n    }, duration)\n  }\n\n  function reset() {\n    stopTimer()\n    pointerId = undefined\n    heldKey = undefined\n  }\n\n  const isHeld = () => pointerId !== undefined || heldKey !== undefined\n\n  function handlePointerDown(event: PointerEvent) {\n    if (\n      getOptions().disabled ||\n      !event.isPrimary ||\n      event.button !== 0 ||\n      isHeld()\n    ) {\n      return\n    }\n    pointerId = event.pointerId\n    if (element.hasPointerCapture?.(event.pointerId)) {\n      element.releasePointerCapture(event.pointerId)\n    }\n    startTimer()\n  }\n\n  function handlePointerUp(event: PointerEvent) {\n    if (event.pointerId !== pointerId) return\n    pointerId = undefined\n    stopTimer()\n  }\n\n  function handlePointerCancel(event: PointerEvent) {\n    if (event.pointerId === pointerId) reset()\n  }\n\n  function handleContextMenu(event: Event) {\n    if (pointerId !== undefined) event.preventDefault()\n  }\n\n  function handleKeyDown(event: KeyboardEvent) {\n    const options = getOptions()\n    if (options.disabled || options.keyboard === false) return\n    if (!HOLD_KEYS.includes(event.key)) return\n    event.preventDefault()\n    event.stopPropagation()\n    if (event.repeat || isHeld()) return\n    heldKey = event.key\n    startTimer()\n  }\n\n  function handleKeyUp(event: KeyboardEvent) {\n    const options = getOptions()\n    if (options.disabled || options.keyboard === false) return\n    if (!HOLD_KEYS.includes(event.key)) return\n    event.preventDefault()\n    event.stopPropagation()\n    if (event.key !== heldKey) return\n    heldKey = undefined\n    if (!stopTimer()) element.click()\n  }\n\n  function handleBlur() {\n    if (heldKey !== undefined) reset()\n  }\n\n  function handleWindowPointerDown() {\n    swallowClick = false\n  }\n\n  function handleWindowClick(event: MouseEvent) {\n    if (!swallowClick) return\n    const [target] = event.composedPath()\n    if (\n      !(target instanceof Node) ||\n      !(element.contains(target) || target.contains(element))\n    ) {\n      return\n    }\n    swallowClick = false\n    event.stopImmediatePropagation()\n    event.preventDefault()\n  }\n\n  element.addEventListener(\"pointerdown\", handlePointerDown)\n  element.addEventListener(\"pointerup\", handlePointerUp)\n  element.addEventListener(\"pointercancel\", handlePointerCancel)\n  element.addEventListener(\"pointerleave\", handlePointerCancel)\n  element.addEventListener(\"contextmenu\", handleContextMenu)\n  element.addEventListener(\"keydown\", handleKeyDown)\n  element.addEventListener(\"keyup\", handleKeyUp)\n  element.addEventListener(\"blur\", handleBlur)\n  window.addEventListener(\"blur\", reset)\n  window.addEventListener(\"pointerdown\", handleWindowPointerDown, true)\n  window.addEventListener(\"click\", handleWindowClick, true)\n\n  return () => {\n    reset()\n    element.removeEventListener(\"pointerdown\", handlePointerDown)\n    element.removeEventListener(\"pointerup\", handlePointerUp)\n    element.removeEventListener(\"pointercancel\", handlePointerCancel)\n    element.removeEventListener(\"pointerleave\", handlePointerCancel)\n    element.removeEventListener(\"contextmenu\", handleContextMenu)\n    element.removeEventListener(\"keydown\", handleKeyDown)\n    element.removeEventListener(\"keyup\", handleKeyUp)\n    element.removeEventListener(\"blur\", handleBlur)\n    window.removeEventListener(\"blur\", reset)\n    window.removeEventListener(\"pointerdown\", handleWindowPointerDown, true)\n    window.removeEventListener(\"click\", handleWindowClick, true)\n  }\n}\n",
      "type": "registry:component",
      "target": "@components/ipod-classic/lib/wheel-gesture.ts"
    },
    {
      "path": "src/registry/components/ipod-classic/lib/wheel-scroll.ts",
      "content": "import {\n  HOLD_SEEK_STEPS,\n  VOLUME_CLICK_DEGREES,\n  VOLUME_STEP_DEGREES,\n} from \"./constants\"\nimport type { ScrollTarget } from \"./types\"\n\nfunction divide(value: number, size: number) {\n  const count = Math.floor(value / size)\n  return { count, remainder: value - count * size }\n}\n\n/**\n * Turns wheel degrees into steps. Lists move a row per `dragStepDegrees`\n * (times the acceleration); volume moves 1% per 4.5° and clicks more sparsely.\n */\nexport function createWheelScroller({\n  move,\n  click,\n}: {\n  move: (step: number, count: number) => boolean\n  click: (count: number, target: ScrollTarget) => void\n}) {\n  let travel = 0\n  let clickTravel = 0\n  let lastStep: number | undefined\n  let lastWasVolume: boolean | undefined\n  let volumeChanged = false\n\n  function reset() {\n    travel = 0\n    clickTravel = 0\n    volumeChanged = false\n  }\n\n  function scrollVolume(step: number, degrees: number) {\n    const steps = divide(travel, VOLUME_STEP_DEGREES)\n    travel = steps.remainder\n    if (steps.count >= 1) {\n      volumeChanged = move(step, steps.count) || volumeChanged\n    }\n    const clicks = divide(clickTravel + degrees, VOLUME_CLICK_DEGREES)\n    clickTravel = clicks.remainder\n    if (clicks.count >= 1) {\n      if (volumeChanged) click(clicks.count, \"volume\")\n      volumeChanged = false\n    }\n  }\n\n  function scroll({\n    step,\n    degrees,\n    target,\n    multiplier,\n    dragStepDegrees,\n  }: {\n    step: number\n    degrees: number\n    target: ScrollTarget\n    multiplier: number\n    dragStepDegrees: number\n  }) {\n    const isVolume = target === \"volume\"\n    if (step !== lastStep || isVolume !== lastWasVolume) {\n      lastStep = step\n      lastWasVolume = isVolume\n      reset()\n    }\n    travel += degrees\n    if (isVolume) {\n      scrollVolume(step, degrees)\n      return\n    }\n    const steps = divide(travel, dragStepDegrees)\n    travel = steps.remainder\n    if (steps.count < 1) return\n    if (move(step, steps.count * multiplier)) click(steps.count, target)\n  }\n\n  return { scroll, reset }\n}\n\n/**\n * Holding Back or Forward on Now Playing skips through the song in growing\n * jumps, starting from where it was when the hold began.\n */\nexport function createHoldSeeker() {\n  let base: number | undefined\n  let track: number | undefined\n  let repeats = 0\n\n  return {\n    step(\n      direction: number,\n      isRepeat: boolean,\n      state: {\n        isInert: boolean\n        isSeeking: boolean\n        hasLoadedItem: boolean\n        currentTrackIndex: number\n        currentTime: number\n        duration: number\n      }\n    ) {\n      if (!isRepeat) {\n        base = state.isInert ? undefined : state.currentTime\n        track = state.currentTrackIndex\n        repeats = 0\n      }\n      if (\n        base === undefined ||\n        state.isInert ||\n        state.isSeeking ||\n        !state.hasLoadedItem ||\n        state.duration <= 0 ||\n        state.currentTrackIndex !== track\n      ) {\n        return\n      }\n      const jump =\n        HOLD_SEEK_STEPS[Math.min(repeats, HOLD_SEEK_STEPS.length - 1)]\n      const time = Math.min(\n        Math.max(base + direction * jump, 0),\n        state.duration\n      )\n      repeats += 1\n      base = time > 0 && time < state.duration ? time : undefined\n      return time\n    },\n    cancel() {\n      base = undefined\n    },\n  }\n}\n",
      "type": "registry:component",
      "target": "@components/ipod-classic/lib/wheel-scroll.ts"
    }
  ],
  "docs": "https://chanhdai.com/components/ipod-classic",
  "categories": [
    "illustrations"
  ],
  "type": "registry:component"
}