@exegia/corpora-ui 3.0.0 → 3.1.0

package/src/components/blocks/scaffold/scaffold-tab.tsx

@@ -1,108 +0,0 @@
-"use client"
-
-import { useReducedMotion } from "motion/react"
-import * as React from "react"
-import { useAtomValue, useSetAtom } from "jotai"
-
-import { cn } from "@/lib/utils"
-import { SPRING_LAYOUT } from "@/lib/ease.ts"
-import {
-  scaffoldPanelHiddenAtom,
-  setScaffoldPanelHoveredAtom,
-  toggleScaffoldPanelAtom,
-} from "./scaffold-atom"
-import { useScaffoldContext } from "./scaffold-context"
-import type { IScaffoldTabProps } from "./type"
-import { segmentVariants } from "./utils"
-import { Button } from "@/components/ui/button"
-import { LucideAppWindow, LucideEyeOff, LucideX } from "lucide-react"
-import { GlassButtonGroup } from "@/components/ui/glasscn/glass-button-group.tsx"
-
-/**
- * A panel's tab inside the action cluster: its label plus a close
- * affordance. Render one per open panel as Actions children, keyed —
- * closes animate out of the pill. Omit `onClose` on the last remaining
- * panel's tab; the canvas keeps at least one panel open.
- *
- * With `panelId` (matching a `Scaffold.Panel`'s `id`), the tab also fronts
- * that panel's visibility: a hidden panel dims its tab behind an eye-off
- * icon, and pressing the label toggles the panel — showing one past
- * capacity hides the least-recently-activated panel in its place.
- */
-export function ScaffoldTab({
-  children,
-  panelId,
-  onClose,
-  closeLabel = "Close panel",
-  sound = true,
-  className,
-  ...rest
-}: IScaffoldTabProps): React.ReactElement {
-  const { scaffoldId } = useScaffoldContext()
-  // The per-panel atom keeps this tab still while its siblings toggle; the
-  // empty-key sentinel reads false for a tab without a `panelId`.
-  const hidden = useAtomValue(scaffoldPanelHiddenAtom(scaffoldId, panelId ?? ""))
-  const togglePanel = useSetAtom(toggleScaffoldPanelAtom(scaffoldId))
-  const setPanelHovered = useSetAtom(setScaffoldPanelHoveredAtom(scaffoldId))
-  const reduce = useReducedMotion()
-  const transition = reduce ? { duration: 0 } : SPRING_LAYOUT
-
-  // A tab closed mid-hover never fires pointer-leave — release the
-  // spotlight it holds so the canvas doesn't stay dimmed.
-  React.useEffect(() => {
-    if (panelId === undefined) return
-    return () => setPanelHovered(panelId, false)
-  }, [panelId, setPanelHovered])
-
-  return (
-    <GlassButtonGroup
-      layout
-      animate={reduce ? { opacity: 1, width: "auto" } : "visible"}
-      data-slot="scaffold-tab"
-      data-panel-hidden={hidden ? "" : undefined}
-      onPointerEnter={
-        panelId !== undefined ? () => setPanelHovered(panelId, true) : undefined
-      }
-      onPointerLeave={
-        panelId !== undefined
-          ? () => setPanelHovered(panelId, false)
-          : undefined
-      }
-      exit={reduce ? { opacity: 0, width: 0 } : "exit"}
-      initial={reduce ? { opacity: 0, width: 0 } : "hidden"}
-      transition={transition}
-      variants={segmentVariants}
-      glassVariant="subtle"
-      className={cn("h-full rounded-sm", className)}
-      {...rest}
-    >
-      <Button
-        aria-pressed={panelId !== undefined ? !hidden : undefined}
-        onClick={panelId !== undefined ? () => togglePanel(panelId) : undefined}
-        size="sm"
-        sound={sound}
-        variant="ghost"
-        className={cn(
-          "gap-2.5 rounded-sm pl-2",
-          onClose && "pr-2",
-          hidden && "text-muted-foreground/70"
-        )}
-      >
-        {hidden ? <LucideEyeOff size={16} /> : <LucideAppWindow size={16} />}
-        {children}
-      </Button>
-      {onClose && (
-        <Button
-          aria-label={closeLabel}
-          onClick={onClose}
-          size="icon-sm"
-          sound={sound}
-          variant="ghost"
-          className="self-center rounded-none!"
-        >
-          <LucideX size={16} />
-        </Button>
-      )}
-    </GlassButtonGroup>
-  )
-}

package/src/components/blocks/scaffold/type.ts

@@ -1,264 +0,0 @@
-import React, {
-  type ComponentProps,
-  type ReactElement,
-  type ReactNode,
-} from "react"
-
-/** Key of one scaffold's slice of the store. */
-export type TScaffoldInstanceId = string
-
-/** The identity every scaffold part shares through ScaffoldContext. State
- * itself lives in the store — parts subscribe to the atoms they render from,
- * so this value never changes identity while the scaffold is mounted. */
-export interface IScaffoldContextValue {
-  scaffoldId: TScaffoldInstanceId
-  /** Drawer width in px — Actions reads it to slide out of the drawer's way. */
-  inspectorWidth: number
-}
-
-export interface IScaffoldPanelLayout {
-  width?: number
-  secondarySize?: number
-  secondaryExpanded?: boolean
-  swapped?: boolean
-}
-
-/** One scaffold's whole state, as `useScaffoldState` returns it. A component
- * that watches one field should subscribe to that field's atom instead. */
-export interface IScaffoldState {
-  inspectorWidth: number | null
-  panelLayouts: Record<string, IScaffoldPanelLayout>
-  /** Whether the inspector drawer is currently shown. */
-  inspectorOpen: boolean
-  /** How many panels currently fit side by side, from the measured canvas
-   * width at `SCAFFOLD_PANEL_MIN_WIDTH` per panel (1..`SCAFFOLD_PANEL_CAPACITY`). */
-  panelCapacity: number
-  /** Ids of id'd panels the scaffold is currently hiding — auto-hidden by
-   * capacity pressure or toggled away from a tab. */
-  hiddenPanelIds: readonly string[]
-  /** Id of the panel whose tab the pointer is resting on — the canvas
-   * spotlights it by fading every other id'd panel to 0.35 opacity. */
-  hoveredPanelId: string | null
-}
-
-/** Drive a scaffold by id from anywhere, as `useScaffoldActions` returns it. */
-export interface IScaffoldStateActions {
-  resizePanel: (panelId: string, width: number) => void
-  resizeInspector: (width: number) => void
-  resizeSecondaryPanel: (panelId: string, height: number) => void
-  setSecondaryExpanded: (panelId: string, expanded: boolean) => void
-  setPanelSwapped: (panelId: string, swapped: boolean) => void
-  setInspectorOpen: (open: boolean) => void
-  toggleInspector: () => void
-  /** Show/hide an id'd panel. Showing past capacity auto-hides the
-   * least-recently-activated visible panel; the last visible one never hides. */
-  togglePanel: (panelId: string) => void
-  reset: () => void
-}
-
-/** @internal Which props currently control the scaffold — write gates for
- * the action atoms, so the store never overwrites a prop. */
-export interface IScaffoldConfig {
-  controlsInspector: boolean
-}
-
-/** @internal The mounted root's callbacks, published into the store so
- * action atoms can report changes wherever they were fired from. */
-export interface IScaffoldHandlers {
-  onInspectorOpenChange?: (open: boolean) => void
-}
-
-/** @internal Bookkeeping for responsive panel hiding.
- * - `visibleOrder`: visible panel ids, least-recently-activated first — the
- *   front is what capacity pressure evicts next.
- * - `autoHidden`: panels the scaffold hid because the canvas shrank, most
- *   recent last. They return on their own when room comes back.
- * - `userHidden`: panels hidden by a tab press. They stay hidden until the
- *   tab is pressed again, however wide the canvas grows. */
-export interface IScaffoldPanelVisibility {
-  visibleOrder: string[]
-  autoHidden: string[]
-  userHidden: string[]
-}
-
-export interface IScaffoldRootProps extends ComponentProps<"div"> {
-  /** Names this scaffold's slice of the store, so `useScaffoldState` /
-   * `useScaffoldActions` can drive it by id and its state outlives the
-   * component. Omitted, the root keys off `useId` and drops its state on
-   * unmount. `useScaffold().providerProps` carries one. */
-  scaffoldId?: TScaffoldInstanceId
-  /** Controlled inspector state — pair with `onInspectorOpenChange`. The
-   * prop stays the source of truth: store writes are gated off, and actions
-   * report through the callback instead. */
-  inspectorOpen?: boolean
-  /** Initial inspector state when uncontrolled. Closed by default. */
-  defaultInspectorOpen?: boolean
-  onInspectorOpenChange?: (open: boolean) => void
-  /** Drawer width in px. Also drives how far Actions slides aside. */
-  inspectorWidth?: number
-}
-
-export type TScaffoldSidebarProps = ComponentProps<"nav">
-
-export type TScaffoldMainProps = ComponentProps<"div">
-
-export type TScaffoldCanvasProps = ComponentProps<"div">
-
-/** React's drag/animation DOM handlers collide with motion's gesture props
- * on `motion.*` elements — strip them from pass-through HTML props. */
-type TMotionSafe<T> = Omit<
-  T,
-  | "onDrag"
-  | "onDragStart"
-  | "onDragEnd"
-  | "onAnimationStart"
-  | "onAnimationEnd"
-  | "onAnimationIteration"
->
-
-export interface IScaffoldActionsProps extends TMotionSafe<
-  Omit<ComponentProps<"div">, "children">
-> {
-  /** Called when the Add segment is pressed. The segment renders only
-   * while this is present — omit it to hide Add, e.g. once the canvas
-   * holds `SCAFFOLD_PANEL_CAPACITY` panels. */
-  onAdd?: () => void
-  /** Label of the Add segment. */
-  addLabel?: ReactNode
-  /** Replaces the default add icon. */
-  addIcon?: ReactNode
-  /** The panel tabs (`Scaffold.Tab`, one per open panel) and any extra
-   * segments, rendered before Add. Key each tab — closes animate out. */
-  children?: ReactNode
-  /** Emit interaction-sound attributes (inert until an app binds cuelume). */
-  sound?: boolean
-}
-
-export type TScaffoldPanelChild<
-  T extends IScaffoldSubPanelProps = IScaffoldSubPanelProps,
-> = ReactElement<T, React.JSXElementConstructor<T>>
-
-export interface IScaffoldPanelProps {
-  /** Stable id opting the panel into responsive hiding: the canvas hides
-   * id'd panels when it can't grant each `SCAFFOLD_PANEL_MIN_WIDTH`, and a
-   * `Scaffold.Tab` with the matching `panelId` reflects and toggles it.
-   * Omitted, the panel always renders. */
-  id?: string
-  /** The panel's content, rendered in a card with a drop shadow. */
-  children: ReactNode
-  /** The panel's content, rendered in a card with a drop shadow. */
-  SecondaryPanel?: TScaffoldPanelChild
-  /** Reveals the Swap action in the seam menu (needs `SecondaryPanel`).
-   * Swapping trades the two cards with a layout morph — flip the slot
-   * content here so each card carries its subject to its new home. */
-  onSwap?: () => void
-  /** Reveals the Close action in the seam menu — remove `SecondaryPanel`
-   * here; the strip and the menu leave together. */
-  onCloseSecondary?: () => void
-  /** Accessible name of the panel region. */
-  name?: string
-  /** Emit interaction-sound attributes on the floating buttons. */
-  sound?: boolean
-  /** Accessible name of the seam-menu toggle. */
-  swapLabel?: string
-  /** Extra class names for the panel's root element. */
-  className?: string
-}
-
-export interface IScaffoldTabProps extends TMotionSafe<
-  Omit<ComponentProps<"div">, "children">
-> {
-  /** The tab's label. */
-  children?: ReactNode
-  /** Id of the panel this tab fronts (`Scaffold.Panel`'s `id`). The tab
-   * then shows whether the panel is hidden and pressing its label toggles
-   * visibility — showing past capacity hides another panel in its place. */
-  panelId?: string
-  /** Renders the tab's close button. The button renders only while this
-   * is present — omit it to pin the tab, e.g. on the last remaining
-   * panel (the canvas keeps at least one open). */
-  onClose?: () => void
-  /** Accessible name of the close button. */
-  closeLabel?: string
-  /** Emit interaction-sound attributes on the close button. */
-  sound?: boolean
-}
-
-export type TSubPanelPosition = "bottom" | "top"
-export type TSubPanelVariant = "card" | "subtle" | "inset"
-
-export interface IScaffoldSubPanelProps extends TMotionSafe<
-  Omit<ComponentProps<"div">, "children">
-> {
-  children?: ReactNode
-  /** Accessible name of the sub-panel region. */
-  name?: string
-  /** Whether this is the primary or secondary sub-panel. */
-  primary?: boolean
-  /** Whether this sub-panel holds the flexible slot. Defaults to `primary` —
-   * the panel flips it when the Expand action trades the slots. */
-  expanded?: boolean
-  /** Visual style of the sub-panel. */
-  variant?: TSubPanelVariant
-  /** Fixed width in px; omitted, the sub-panel flexes to share the canvas. */
-  width?: number
-  /** Emit interaction-sound attributes on the floating buttons. */
-  sound?: boolean
-  /** Extra class names for the sub-panel's root element. */
-  className?: string
-}
-
-export interface IScaffoldInspectorProps extends TMotionSafe<
-  Omit<ComponentProps<"aside">, "children">
-> {
-  children?: ReactNode
-  /** Accessible name of the drawer region. */
-  name?: string
-}
-
-export interface IPanelFloatingButtonProps {
-  onClick?: () => void
-  /** Accessible name — the button is icon-only. */
-  label: string
-  sound?: boolean
-  className?: string
-}
-
-export interface IPanelMenuButtonProps extends IPanelFloatingButtonProps {
-  /** Called when the Expand action is pressed — the panel trades which
-   * sub-panel holds the flexible slot. */
-  onExpand?: () => void
-  /** Renders the Close action; called when it is pressed — the consumer
-   * removes the secondary strip. */
-  onCloseSecondary?: () => void
-  /** Whether the secondary strip currently holds the flexible slot —
-   * flips the Expand chevron between down and up. */
-  secondaryExpanded?: boolean
-  /** Whether the panel is swapped (column-reverse). Mirrors the Expand
-   * chevron so it keeps pointing at the sub-panel that grows next. */
-  swapped?: boolean
-}
-
-export interface IUseScaffoldOptions {
-  /** Names the scaffold's slice of the store. Omitted, the hook generates
-   * one and drops its state on unmount. */
-  scaffoldId?: TScaffoldInstanceId
-  /** Initial inspector state. Closed by default. */
-  defaultInspectorOpen?: boolean
-  /** Fires on every inspector open/close. */
-  onInspectorChange?: (open: boolean) => void
-}
-
-export interface IScaffoldControls {
-  /** The id the hook and the root share — hand it to `useScaffoldState` /
-   * `useScaffoldActions` to drive the scaffold from elsewhere. */
-  scaffoldId: TScaffoldInstanceId
-  inspectorOpen: boolean
-  setInspectorOpen: (open: boolean) => void
-  toggleInspector: () => void
-  /** Spread onto Scaffold.Root. */
-  providerProps: Pick<
-    IScaffoldRootProps,
-    "scaffoldId" | "defaultInspectorOpen" | "onInspectorOpenChange"
-  >
-}

package/src/components/blocks/scaffold/use-scaffold-state.ts

@@ -1,85 +0,0 @@
-"use client"
-
-import { useMemo } from "react"
-import { useAtomValue, useSetAtom } from "jotai"
-
-import {
-  resetScaffoldAtom,
-  resizeScaffoldInspectorAtom,
-  updateScaffoldPanelLayoutAtom,
-  scaffoldStateAtom,
-  setScaffoldInspectorOpenAtom,
-  toggleScaffoldInspectorAtom,
-  toggleScaffoldPanelAtom,
-} from "./scaffold-atom"
-import type {
-  TScaffoldInstanceId,
-  IScaffoldState,
-  IScaffoldStateActions,
-} from "./type"
-
-/**
- * Read the scaffold registered under `scaffoldId` from anywhere below
- * `ExegiaProvider` — no controller, no props, no provider of its own.
- *
- * ```tsx
- * const { inspectorOpen, hiddenPanelIds } = useScaffoldState("workspace")
- * ```
- *
- * This returns the whole state object, so the caller re-renders on every
- * change, hovers included. A component that reads one field should subscribe
- * to that field's atom instead:
- * `useAtomValue(scaffoldInspectorOpenAtom("workspace"))`.
- */
-export function useScaffoldState(
-  scaffoldId: TScaffoldInstanceId
-): IScaffoldState {
-  return useAtomValue(scaffoldStateAtom(scaffoldId))
-}
-
-/**
- * Drive the scaffold registered under `scaffoldId` from anywhere. Writes
- * only — the caller never re-renders when the scaffold changes, so this is
- * what a command palette or a keyboard shortcut should reach for.
- *
- * ```tsx
- * const scaffold = useScaffoldActions("workspace")
- * <Button onClick={scaffold.toggleInspector}>Inspect</Button>
- * ```
- */
-export function useScaffoldActions(
-  scaffoldId: TScaffoldInstanceId
-): IScaffoldStateActions {
-  const setInspectorOpen = useSetAtom(setScaffoldInspectorOpenAtom(scaffoldId))
-  const toggleInspector = useSetAtom(toggleScaffoldInspectorAtom(scaffoldId))
-  const togglePanel = useSetAtom(toggleScaffoldPanelAtom(scaffoldId))
-  const updatePanel = useSetAtom(updateScaffoldPanelLayoutAtom(scaffoldId))
-  const resizeInspector = useSetAtom(resizeScaffoldInspectorAtom(scaffoldId))
-  const reset = useSetAtom(resetScaffoldAtom(scaffoldId))
-
-  return useMemo(
-    () => ({
-      setInspectorOpen,
-      toggleInspector,
-      togglePanel,
-      reset,
-      resizeInspector,
-      resizePanel: (panelId: string, width: number) =>
-        updatePanel(panelId, { width }),
-      resizeSecondaryPanel: (panelId: string, secondarySize: number) =>
-        updatePanel(panelId, { secondarySize }),
-      setSecondaryExpanded: (panelId: string, secondaryExpanded: boolean) =>
-        updatePanel(panelId, { secondaryExpanded }),
-      setPanelSwapped: (panelId: string, swapped: boolean) =>
-        updatePanel(panelId, { swapped }),
-    }),
-    [
-      setInspectorOpen,
-      toggleInspector,
-      togglePanel,
-      reset,
-      resizeInspector,
-      updatePanel,
-    ]
-  )
-}

package/src/components/blocks/scaffold/use-scaffold.ts

@@ -1,59 +0,0 @@
-"use client"
-
-import { useEffect, useId, useMemo } from "react"
-import { useAtomValue, useSetAtom } from "jotai"
-
-import {
-  removeScaffoldInstance,
-  scaffoldInspectorOpenAtom,
-  setScaffoldInspectorOpenAtom,
-  toggleScaffoldInspectorAtom,
-} from "./scaffold-atom"
-import type { IScaffoldControls, IUseScaffoldOptions } from "./type"
-
-/**
- * Owns the scaffold's inspector state for UI living outside the scaffold
- * (title-bar buttons, command palette, shortcuts). Spread the returned
- * `providerProps` onto `Scaffold.Root`; without this hook the root manages
- * the same state internally via `defaultInspectorOpen`.
- *
- * The hook and the root meet in the store: `providerProps` carries a
- * `scaffoldId`, both sides read and write that instance's atoms, and
- * `useScaffoldState` / `useScaffoldActions` reach the same slice from
- * anywhere else by id. Unnamed scaffolds key off `useId` and are dropped on
- * unmount; an explicit `scaffoldId` outlives its component.
- */
-export function useScaffold({
-  scaffoldId: scaffoldIdProp,
-  defaultInspectorOpen,
-  onInspectorChange,
-}: IUseScaffoldOptions = {}): IScaffoldControls {
-  const generatedId = useId()
-  const scaffoldId = scaffoldIdProp ?? generatedId
-
-  const inspectorOpen = useAtomValue(scaffoldInspectorOpenAtom(scaffoldId))
-  const setInspectorOpen = useSetAtom(setScaffoldInspectorOpenAtom(scaffoldId))
-  const toggleInspector = useSetAtom(toggleScaffoldInspectorAtom(scaffoldId))
-
-  useEffect(() => {
-    if (scaffoldIdProp !== undefined) return
-    return () => removeScaffoldInstance(scaffoldId)
-  }, [scaffoldIdProp, scaffoldId])
-
-  const providerProps = useMemo<IScaffoldControls["providerProps"]>(
-    () => ({
-      scaffoldId,
-      defaultInspectorOpen,
-      onInspectorOpenChange: onInspectorChange,
-    }),
-    [scaffoldId, defaultInspectorOpen, onInspectorChange]
-  )
-
-  return {
-    scaffoldId,
-    inspectorOpen,
-    setInspectorOpen,
-    toggleInspector,
-    providerProps,
-  }
-}

package/src/components/blocks/scaffold/utils.ts

@@ -1,112 +0,0 @@
-import type { Variants } from "motion/react"
-import type { ClassNameValue } from "tailwind-merge"
-import type {
-  IScaffoldPanelVisibility,
-  TSubPanelVariant,
-} from "@/components/blocks/scaffold/type.ts"
-import { EASE_OUT } from "@/lib/ease.ts"
-import {
-  SCAFFOLD_CANVAS_GAP,
-  SCAFFOLD_PANEL_CAPACITY,
-  SCAFFOLD_PANEL_MIN_WIDTH,
-} from "./constants"
-
-/**
- * How many panels fit on a canvas of `width` px, granting each
- * `SCAFFOLD_PANEL_MIN_WIDTH` plus the gaps between them. Clamped to
- * [1, SCAFFOLD_PANEL_CAPACITY]; an unmeasured canvas (`null`) fits the cap.
- */
-export function getPanelCapacity(width: number | null): number {
-  if (width === null) return SCAFFOLD_PANEL_CAPACITY
-  const fits = Math.floor(
-    (width + SCAFFOLD_CANVAS_GAP) /
-      (SCAFFOLD_PANEL_MIN_WIDTH + SCAFFOLD_CANVAS_GAP)
-  )
-  return Math.max(1, Math.min(SCAFFOLD_PANEL_CAPACITY, fits))
-}
-
-/** @internal An untracked scaffold: nothing registered, nothing hidden. */
-export const EMPTY_SCAFFOLD_VISIBILITY: IScaffoldPanelVisibility = {
-  visibleOrder: [],
-  autoHidden: [],
-  userHidden: [],
-}
-
-/**
- * @internal Fold the registered ids and current capacity into a settled
- * visibility: prune departed panels, admit new ones, evict the
- * least-recently-activated visible panels past capacity, and restore
- * auto-hidden ones when room returns. Returns `prev` untouched when nothing
- * changes, so callers can compare identities instead of contents.
- */
-export function reconcileVisibility(
-  prev: IScaffoldPanelVisibility,
-  ids: readonly string[],
-  capacity: number
-): IScaffoldPanelVisibility {
-  const known = new Set(ids)
-  const visibleOrder = prev.visibleOrder.filter((id) => known.has(id))
-  const autoHidden = prev.autoHidden.filter((id) => known.has(id))
-  const userHidden = prev.userHidden.filter((id) => known.has(id))
-
-  const tracked = new Set([...visibleOrder, ...autoHidden, ...userHidden])
-  for (const id of ids) if (!tracked.has(id)) visibleOrder.push(id)
-
-  while (visibleOrder.length > capacity && visibleOrder.length > 1) {
-    autoHidden.push(visibleOrder.shift() as string)
-  }
-  while (visibleOrder.length < capacity && autoHidden.length > 0) {
-    visibleOrder.push(autoHidden.pop() as string)
-  }
-
-  const unchanged =
-    visibleOrder.join(" ") === prev.visibleOrder.join(" ") &&
-    autoHidden.join(" ") === prev.autoHidden.join(" ") &&
-    userHidden.join(" ") === prev.userHidden.join(" ")
-  return unchanged ? prev : { visibleOrder, autoHidden, userHidden }
-}
-
-/** Desktop backdrop the whole scaffold sits on — a soft warm-gray wash. */
-export const scaffoldBackgroundClass: ClassNameValue =
-  "bg-linear-to-tr/increasing from-neutral-400 via-stone-200 to-neutral-300 dark:from-neutral-900 dark:via-neutral-950 dark:to-stone-950"
-
-export const SCAFFOLD_BEZEL_CLASSES =
-  "bezel-lit-t-2 bezel-lit-blur-2 bezel-lit/57 bezel-dim-b-2 bezel-dim-blur-3 bezel-dim/11 dark:bezel-lit-blur-3 dark:bezel-lit/14 dark:bezel-dim/78"
-
-/** Card surface shared by a panel's primary area and secondary strip. */
-export const panelSurfaceClass: ClassNameValue =
-  `rounded-md bg-slate-100 dark:bg-neutral-900 ${SCAFFOLD_BEZEL_CLASSES}`
-
-/** Floating icon button hovering over a panel (close, swap). */
-export const floatingButtonClass: ClassNameValue =
-  "transition-[opacity,scale,box-shadow] duration-200 ease-smooth-out hover:text-neutral-900 hover:shadow-md active:scale-97 dark:bg-neutral-800/95 dark:text-neutral-300 dark:inset-ring-white/10 dark:hover:text-white motion-reduce:transition-none motion-reduce:active:scale-100 z-20"
-
-/** Hidden until the pointer rests on the panel (always shown for touch and
- * while focused) — the affordances stay quiet until the panel is engaged. */
-export const revealOnPanelHoverClass: ClassNameValue =
-  "opacity-0 scale-95 group-hover/panel:opacity-100 group-hover/panel:scale-100 focus-visible:opacity-100 focus-visible:scale-100 pointer-coarse:opacity-100 pointer-coarse:scale-100"
-
-/** Pill segment inside the actions cluster (Add, browse). */
-export const actionSegmentClass: ClassNameValue =
-  "flex h-[30px] items-center rounded-full text-neutral-700 transition-[background-color,color,scale,box-shadow] duration-150 ease-smooth-out hover:bg-white hover:text-neutral-900 hover:shadow-xs active:scale-97 dark:text-neutral-300 dark:hover:bg-neutral-700 dark:hover:text-white motion-reduce:transition-none motion-reduce:active:scale-100"
-
-/** Pill segments (seam-menu actions, tabs, Add) blur/fade in place while
- * the track morphs around them. The exit is a fast tween, not the layout
- * spring — the track stays overflow-visible, so popped-out segments must be
- * gone before the shrinking pill leaves them behind as a ghost. */
-export const segmentVariants: Variants = {
-  hidden: { opacity: 0, filter: "blur(4px)" },
-  visible: { opacity: 1, filter: "blur(0px)" },
-  exit: {
-    opacity: 0,
-    filter: "blur(4px)",
-    transition: { duration: 0.18, ease: EASE_OUT },
-  },
-}
-
-/** Map of sub-panel variants to their corresponding side. */
-export const subPanelVariant: Record<TSubPanelVariant, ClassNameValue> = {
-  card: `bg-neutral-50 dark:bg-neutral-900 rounded-md ${SCAFFOLD_BEZEL_CLASSES}`,
-  subtle: "bg-neutral-100 dark:bg-neutral-800",
-  inset: "bg-neutral-200 dark:bg-neutral-700",
-} as const