@exegia/corpora-ui 0.29.0 → 1.0.0

package/dist-lib/components/ui/badge.d.ts

@@ -1,7 +0,0 @@
-import { useRender } from '@base-ui/react/use-render';
-import { VariantProps } from 'class-variance-authority';
-declare const badgeVariants: (props?: ({
-    variant?: "link" | "default" | "destructive" | "ghost" | "outline" | "secondary" | null | undefined;
-} & import('class-variance-authority/types').ClassProp) | undefined) => string;
-declare function Badge({ className, variant, render, ...props }: useRender.ComponentProps<"span"> & VariantProps<typeof badgeVariants>): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
-export { Badge, badgeVariants };

package/dist-lib/components/ui/tooltip.d.ts

@@ -1,6 +0,0 @@
-import { Tooltip as TooltipPrimitive } from '@base-ui/react/tooltip';
-declare function TooltipProvider({ delay, ...props }: TooltipPrimitive.Provider.Props): import("react").JSX.Element;
-declare function Tooltip({ ...props }: TooltipPrimitive.Root.Props): import("react").JSX.Element;
-declare function TooltipTrigger({ ...props }: TooltipPrimitive.Trigger.Props): import("react").JSX.Element;
-declare function TooltipContent({ className, side, sideOffset, align, alignOffset, children, ...props }: TooltipPrimitive.Popup.Props & Pick<TooltipPrimitive.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset">): import("react").JSX.Element;
-export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/dist-lib/components/user-avatar/audio-wave.d.ts

@@ -1,2 +0,0 @@
-import { IAudioWaveProps } from './type';
-export declare function AudioWave({ className, volume: _volume, children }: IAudioWaveProps): import("react").JSX.Element;

package/dist-lib/components/user-avatar/component.d.ts

@@ -1,3 +0,0 @@
-import { UserAvatarProps } from './type';
-import * as React from "react";
-export declare function UserAvatar({ src, name, initials, alt, loading: loadingProp, presence: presenceProp, bezel, avatarId, className, style, ...props }: UserAvatarProps): React.ReactElement;

package/dist-lib/components/user-avatar/fallback.d.ts

@@ -1,5 +0,0 @@
-export declare function Fallback({ name, initials, loading, }: {
-    name?: string;
-    initials?: string;
-    loading?: boolean;
-}): import("react").JSX.Element;

package/dist-lib/components/user-avatar/index.d.ts

@@ -1,18 +0,0 @@
-import { AudioWave } from './audio-wave';
-import { UserAvatar } from './component';
-import { Fallback } from './fallback';
-export { AudioWave } from './audio-wave';
-export { UserAvatar } from './component';
-export { Fallback } from './fallback';
-export { PresenceBadge } from './presence-badge';
-export { initialsFrom } from './utils';
-export { useUserAvatar } from './use-user-avatar';
-export type { UseUserAvatarOptions, UserAvatarBinding } from './use-user-avatar';
-export { useUserAvatarActions, useUserAvatarState } from './use-user-avatar-state';
-export { DEFAULT_BEZEL_ANGLE, removeUserAvatarInstance, resetUserAvatarAtom, setUserAvatarBezelAngleAtom, setUserAvatarPresenceAtom, toggleUserAvatarPresenceAtom, userAvatarBezelAngleAtom, userAvatarIsOnlineAtom, userAvatarPresenceAtom, userAvatarStateAtom, } from './user-avatar-atom';
-export type * from './type';
-export declare const Avatar: {
-    AudioWave: typeof AudioWave;
-    Component: typeof UserAvatar;
-    Fallback: typeof Fallback;
-};

package/dist-lib/components/user-avatar/presence-badge.d.ts

@@ -1,16 +0,0 @@
-import { UserPresence } from './type';
-/**
- * Corner dot naming whether the person is reachable. Sits on the avatar
- * frame, outside the clipped circle, with a background-coloured ring so it
- * reads against any image. Colour is not the only signal: `offline` is a
- * hollow ring, `online` a filled dot, and the label is spelled out for AT.
- *
- * `lightAngle` (degrees clockwise from 12) lays a faint sheen across the dot
- * from that side — the same angle the avatar's bezel is lit from, so the two
- * highlights agree and the badge reads as a bead sitting in the same light.
- */
-export declare function PresenceBadge({ presence, lightAngle, className, }: {
-    presence: UserPresence;
-    lightAngle?: number;
-    className?: string;
-}): import("react").JSX.Element;

package/dist-lib/components/user-avatar/type.d.ts

@@ -1,79 +0,0 @@
-import { AvatarPrimitive } from '../ui/avatar';
-import type * as React from "react";
-export type ImageStatus = Parameters<NonNullable<AvatarPrimitive.Image.Props["onLoadingStatusChange"]>>[0];
-/** Whether the person is reachable right now — drawn as the corner badge. */
-export type UserPresence = "online" | "offline";
-/** Key for one avatar's state in the store. Any stable string; `useUserAvatar`
- * generates one when the component does not name itself. */
-export type UserAvatarInstanceId = string;
-export interface UserAvatarProps extends Omit<AvatarPrimitive.Root.Props, "children"> {
-    /** Image URL. Without one the initials show immediately — no skeleton. */
-    src?: string;
-    /** Drives the initials, and the alt text unless `alt` overrides it. */
-    name?: string;
-    /** Overrides the initials derived from `name`. */
-    initials?: string;
-    /**
-     * Alt text for the image. Pass "" when adjacent text already names the
-     * person — the image is then decorative.
-     */
-    alt?: string;
-    /**
-     * Force the skeleton, for when the identity itself is still being fetched.
-     * Omitted, it follows the image: a passed `src` skeletons until it resolves.
-     */
-    loading?: boolean;
-    /**
-     * Corner badge: a green dot for `online`, a hollow grey ring for `offline`.
-     * Omitted, no badge — unless the avatar is driven by id and something set
-     * its presence in the store. Controlled when passed.
-     */
-    presence?: UserPresence;
-    /**
-     * Embossed rim whose highlight follows the pointer, so the avatar reads as
-     * a lit bezel rather than a flat disc. Light and dark aware, and with a
-     * photo it samples the image's rim lightness (CORS permitting) to weight
-     * highlight against shadow, so the emboss reads on a dark portrait and a
-     * pale one alike. Static under reduced motion. On by default — pass
-     * `false` for a flat disc.
-     */
-    bezel?: boolean;
-    /**
-     * Name this avatar's slice of the store so `useUserAvatarState(id)` /
-     * `useUserAvatarActions(id)` can read or drive it from anywhere under
-     * `ExegiaProvider`. Unnamed avatars key off `useId` and are dropped on
-     * unmount.
-     */
-    avatarId?: UserAvatarInstanceId;
-}
-/** Everything the store knows about one avatar. */
-export interface UserAvatarState {
-    presence: UserPresence | null;
-    /** Bezel light direction in degrees, clockwise from 12 o'clock. Continuous
-     * (may leave [0, 360)) so the rim's CSS rotation never spins the long way;
-     * `((a % 360) + 360) % 360` if you need it normalised. */
-    bezelAngle: number;
-    imageStatus: ImageStatus;
-    /** Perceived lightness of the loaded image's rim, 0 (black) → 1 (white),
-     * or `null` while unknown — no image yet, or one that could not be sampled
-     * (non-CORS host, no canvas). The bezel's highlight/shadow alphas follow
-     * it so the emboss reads on a dark photo and a pale one alike. */
-    imageTone: number | null;
-}
-/** Write-only handles onto one avatar. Nothing here re-renders the caller. */
-export interface UserAvatarActions {
-    setPresence: (presence: UserPresence | null) => void;
-    togglePresence: () => void;
-    setBezelAngle: (angle: number) => void;
-    reset: () => void;
-}
-/** @internal Which fields the mounted component controls from props. The
- * store must never overwrite a controlled value. */
-export interface UserAvatarConfig {
-    controlsPresence: boolean;
-}
-export interface IAudioWaveProps {
-    className?: string;
-    children?: React.ReactNode;
-    volume?: number;
-}

package/dist-lib/components/user-avatar/use-user-avatar-state.d.ts

@@ -1,26 +0,0 @@
-import { UserAvatarActions, UserAvatarInstanceId, UserAvatarState } from './type';
-/**
- * Read the avatar registered under `avatarId` from anywhere below
- * `ExegiaProvider` — no props, no ref, no provider of its own.
- *
- * ```tsx
- * const { presence } = useUserAvatarState("me")
- * ```
- *
- * Returns the whole state object, so the caller re-renders on any change —
- * including every bezel frame while a pointer moves. A component that only
- * cares about presence should subscribe to that atom instead:
- * `useAtomValue(userAvatarPresenceAtom("me"))`.
- */
-export declare function useUserAvatarState(avatarId: UserAvatarInstanceId): UserAvatarState;
-/**
- * Write-only handles onto the avatar registered under `avatarId`. Nothing
- * here subscribes, so a presence indicator elsewhere in the app can flip
- * the badge without re-rendering when the avatar changes.
- *
- * ```tsx
- * const { setPresence } = useUserAvatarActions("me")
- * socket.on("presence", (p) => setPresence(p))
- * ```
- */
-export declare function useUserAvatarActions(avatarId: UserAvatarInstanceId): UserAvatarActions;

package/dist-lib/components/user-avatar/use-user-avatar.d.ts

@@ -1,37 +0,0 @@
-import { ImageStatus, UserAvatarInstanceId, UserPresence } from './type';
-import * as React from "react";
-export interface UseUserAvatarOptions {
-    avatarId?: UserAvatarInstanceId;
-    /** Controlled presence. `undefined` leaves the store in charge. */
-    presence?: UserPresence;
-    /** Track the pointer for the bezel highlight. */
-    bezel: boolean;
-    /** Only meaningful with an image — no image, no status to track. */
-    hasImage: boolean;
-    /** The image URL, sampled for its rim lightness once it has loaded so the
-     * bezel can pick alphas that read against it. Omit to skip sampling. */
-    src?: string;
-}
-export interface UserAvatarBinding {
-    avatarId: UserAvatarInstanceId;
-    presence: UserPresence | null;
-    bezelAngle: number;
-    imageStatus: ImageStatus;
-    /** Rim lightness of the loaded image, 0–1, or `null` while unknown. */
-    imageTone: number | null;
-    /** Hand to the image's `onLoadingStatusChange`. Stable. */
-    setImageStatus: (status: ImageStatus) => void;
-    /** Attach to the avatar root — the bezel is lit relative to its centre. */
-    ref: React.RefObject<HTMLElement | null>;
-}
-/**
- * Binds one avatar to its slice of the store: projects the controlled
- * `presence` prop, tracks the image status, and — while `bezel` is on —
- * follows the pointer with a rAF-coalesced `pointermove` listener that turns
- * the pointer's bearing from the avatar's centre into `bezelAngle`.
- *
- * Unnamed avatars key off `useId` and are dropped from the store on unmount;
- * a named `avatarId` outlives its component so a presence set elsewhere
- * survives a remount.
- */
-export declare function useUserAvatar(options: UseUserAvatarOptions): UserAvatarBinding;

package/dist-lib/components/user-avatar/user-avatar-atom.d.ts

@@ -1,64 +0,0 @@
-import { UserAvatarConfig, UserAvatarInstanceId, UserAvatarState, UserPresence } from './type';
-/** Light from the top-left, the classic emboss, until a pointer moves. */
-export declare const DEFAULT_BEZEL_ANGLE = 315;
-type Family<AtomType> = ((id: UserAvatarInstanceId) => AtomType) & {
-    remove: (id: UserAvatarInstanceId) => void;
-};
-/** `null` = no badge. */
-export declare const userAvatarPresenceAtom: Family<import('jotai').PrimitiveAtom<UserPresence | null> & {
-    init: UserPresence | null;
-}>;
-/** Degrees clockwise from 12 o'clock — where the bezel highlight sits. */
-export declare const userAvatarBezelAngleAtom: Family<import('jotai').PrimitiveAtom<number> & {
-    init: number;
-}>;
-export declare const userAvatarImageStatusAtom: Family<import('jotai').PrimitiveAtom<import('@base-ui/react').ImageLoadingStatus> & {
-    init: import('@base-ui/react').ImageLoadingStatus;
-}>;
-/** Rim lightness of the loaded image, `null` until sampled (or unsampleable). */
-export declare const userAvatarImageToneAtom: Family<import('jotai').PrimitiveAtom<number | null> & {
-    init: number | null;
-}>;
-/** @internal Which fields the mounted component controls from props. */
-export declare const userAvatarConfigAtom: Family<import('jotai').PrimitiveAtom<UserAvatarConfig> & {
-    init: UserAvatarConfig;
-}>;
-export declare const userAvatarIsOnlineAtom: Family<import('jotai').Atom<boolean>>;
-/** Whole-state read for callers that want the object; field atoms above are
- * cheaper for components that watch one thing. */
-export declare const userAvatarStateAtom: Family<import('jotai').Atom<UserAvatarState>>;
-/** Inert while a `presence` prop controls the avatar — the prop is truth. */
-export declare const setUserAvatarPresenceAtom: Family<import('jotai').WritableAtom<null, [presence: UserPresence | null], void> & {
-    init: null;
-}>;
-/** online ⇄ offline; a badge-less avatar comes online. */
-export declare const toggleUserAvatarPresenceAtom: Family<import('jotai').WritableAtom<null, [], void> & {
-    init: null;
-}>;
-/** Stored as given — continuous, not wrapped into [0, 360): the rim is
- * rotated with a CSS transition, and an unwrapped angle is what lets a
- * 359° → 1° move take the short way round. Written on every pointer frame,
- * so it stays a bare set — no config gate, no side effects. */
-export declare const setUserAvatarBezelAngleAtom: Family<import('jotai').WritableAtom<null, [angle: number], void> & {
-    init: null;
-}>;
-/** @internal Reported by the image element; drives the skeleton. */
-export declare const setUserAvatarImageStatusAtom: Family<import('jotai').WritableAtom<null, [status: import('@base-ui/react').ImageLoadingStatus], void> & {
-    init: null;
-}>;
-/** @internal Written by the hook once the loaded image has been sampled;
- * cleared (null) when the image changes or goes away. Clamped to [0, 1]. */
-export declare const setUserAvatarImageToneAtom: Family<import('jotai').WritableAtom<null, [tone: number | null], void> & {
-    init: null;
-}>;
-/** @internal Projection of the mounted component's controlled props. */
-export declare const projectUserAvatarPropsAtom: Family<import('jotai').WritableAtom<null, [config: UserAvatarConfig, presence: UserPresence | null | undefined], void> & {
-    init: null;
-}>;
-export declare const resetUserAvatarAtom: Family<import('jotai').WritableAtom<null, [], void> & {
-    init: null;
-}>;
-/** Forget an avatar entirely — every family drops the key so the store can
- * release its state. Call on teardown of a named instance. */
-export declare function removeUserAvatarInstance(id: UserAvatarInstanceId): void;
-export {};

package/dist-lib/components/user-avatar/utils.d.ts

@@ -1,24 +0,0 @@
-/** "Jenny Hamilton" → "JH", "luna" → "L". */
-export declare function initialsFrom(name: string): string;
-/**
- * Average perceived lightness, 0 (black) → 1 (white), of an image's outer
- * band — the pixels the bezel ring overlays — or `null` when it cannot be
- * measured: no DOM/canvas (SSR, test DOM), a decode failure, or a host
- * without CORS headers (the sample needs a CORS-clean image; the avatar's
- * own `<img>` is left untouched, so a non-CORS host still displays).
- * Results are memoised per `src`, so a room of the same face samples once.
- */
-export declare function measureRimTone(src: string): Promise<number | null>;
-/**
- * Bezel highlight/shadow alphas for an image whose rim lightness is `tone`
- * (0 → 1). Against a dark rim the white highlight is eased off (it glares)
- * and the black shadow pushed up (it has to darken mid-tones to register);
- * against a pale rim the reverse — the highlight can be full (it barely
- * shows) and the shadow is what carries the emboss, so it sits lighter.
- * Linear between; the end points are tuned by eye on a dark and a light
- * photo in both themes.
- */
-export declare function bezelAlphasForTone(tone: number): {
-    hi: number;
-    lo: number;
-};

package/src/components/beste/piece/browser-frame.tsx

@@ -1,58 +0,0 @@
-"use client"
-
-import { Globe } from "lucide-react"
-import { cn } from "@/lib/utils"
-import type { IBrowserProps } from "./type"
-import { titleBarStyle } from "./utils"
-
-export function BrowserFrame({
-  url,
-  title,
-  className,
-  titleStyle,
-  children,
-}: IBrowserProps) {
-  return (
-    <div
-      className={cn(
-        "relative flex size-full items-center justify-center",
-        className
-      )}
-    >
-      <div className="relative flex min-h-32 w-full flex-col overflow-hidden rounded-lg border border-border bg-neutral-50 shadow-lg dark:bg-neutral-900">
-        <div
-          id="title-bar"
-          className={cn(
-            "z-20 flex flex-1 items-center gap-2 px-4 py-3",
-            titleBarStyle(titleStyle, "title")
-          )}
-        >
-          <div className="flex items-center gap-2" aria-hidden="true">
-            <span className="size-3 cursor-pointer rounded-full bg-rose-500 shadow-md outline outline-rose-800" />
-            <span className="size-3 cursor-pointer rounded-full bg-amber-500 shadow-md outline outline-amber-800" />
-            <span className="size-3 cursor-pointer rounded-full bg-emerald-500 shadow-md outline outline-emerald-800" />
-          </div>
-          {url && !title && (
-            <div className="flex max-w-1/3 flex-1 items-center gap-1.5 rounded-sm border border-border bg-card p-1">
-              <Globe
-                className="size-3 shrink-0 text-muted-foreground"
-                aria-hidden="true"
-              />
-              <span className="truncate font-mono text-xs text-muted-foreground">
-                {url}
-              </span>
-            </div>
-          )}
-          {title && !url && (
-            <div className="flex w-full flex-1 justify-center select-none">
-              <span className="ml-2 text-sm text-foreground">{title}</span>
-            </div>
-          )}
-        </div>
-        <div className={cn("flex flex-1", titleBarStyle(titleStyle, "frame"))}>
-          {children}
-        </div>
-      </div>
-    </div>
-  )
-}

package/src/components/beste/piece/type.ts

@@ -1,11 +0,0 @@
-import type { ReactNode } from "react"
-
-export type TitleStyleType = "hidden" | "titlebar" | "expanded"
-
-export interface IBrowserProps {
-  url?: string
-  title?: string
-  className?: string
-  children: ReactNode
-  titleStyle: TitleStyleType
-}

package/src/components/beste/piece/utils.ts

@@ -1,21 +0,0 @@
-import type { ClassNameValue } from "tailwind-merge"
-import type { TitleStyleType } from "./type"
-
-export const titleBarStyle = (
-  style: TitleStyleType,
-  component: "title" | "frame"
-): ClassNameValue => {
-  const titleBarClassName: Record<TitleStyleType, ClassNameValue> = {
-    titlebar: "relative",
-    hidden: "top-0 left-0 absolute",
-    expanded: "relative",
-  }
-
-  const bodyClassName: Record<TitleStyleType, ClassNameValue> = {
-    titlebar: "relative",
-    hidden: "",
-    expanded: "relative",
-  }
-
-  return component == "title" ? titleBarClassName[style] : bodyClassName[style]
-}

package/src/components/composed/__tests__/user-avatar.test.tsx

@@ -1,85 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { render, screen } from "@testing-library/react"
-
-import { UserAvatar, initialsFrom } from "../user-avatar"
-
-describe("initialsFrom", () => {
-  test("takes the first and last word", () => {
-    expect(initialsFrom("Jenny Hamilton")).toBe("JH")
-    expect(initialsFrom("ada  b  lovelace")).toBe("AL")
-    expect(initialsFrom("luna")).toBe("L")
-    expect(initialsFrom("   ")).toBe("")
-  })
-})
-
-describe("UserAvatar", () => {
-  test("shows initials right away when there is no image", () => {
-    const { container } = render(<UserAvatar name="Luna Wyen" />)
-
-    expect(screen.getByText("LW")).toBeDefined()
-    expect(container.querySelector('[data-slot="avatar-skeleton"]')).toBeNull()
-    expect(container.querySelector("img")).toBeNull()
-  })
-
-  test("holds a skeleton while a passed image is still loading", () => {
-    // happy-dom resolves every Image synchronously (complete, naturalWidth 0),
-    // so stand in a request that never answers.
-    const RealImage = window.Image
-    window.Image = class {
-      complete = false
-      naturalWidth = 0
-      onload: (() => void) | null = null
-      onerror: (() => void) | null = null
-      src = ""
-    } as unknown as typeof window.Image
-
-    try {
-      const { container } = render(
-        <UserAvatar name="Jenny Hamilton" src="https://example.com/j.jpg" />
-      )
-
-      expect(
-        container.querySelector('[data-slot="avatar-skeleton"]')
-      ).not.toBeNull()
-      expect(screen.queryByText("JH")).toBeNull()
-      expect(
-        container
-          .querySelector('[data-slot="user-avatar"]')
-          ?.hasAttribute("data-loading")
-      ).toBe(true)
-    } finally {
-      window.Image = RealImage
-    }
-  })
-
-  test("settles on the initials when the image fails", () => {
-    // The stubbed DOM never fetches, so every src lands in the error branch.
-    const { container } = render(
-      <UserAvatar name="Jenny Hamilton" src="https://example.com/missing.jpg" />
-    )
-
-    expect(screen.getByText("JH")).toBeDefined()
-    expect(container.querySelector('[data-slot="avatar-skeleton"]')).toBeNull()
-  })
-
-  test("loading forces the skeleton over a resolvable image", () => {
-    const { container } = render(
-      <UserAvatar
-        loading
-        name="Jenny Hamilton"
-        src="https://example.com/j.jpg"
-      />
-    )
-
-    expect(
-      container.querySelector('[data-slot="avatar-skeleton"]')
-    ).not.toBeNull()
-    expect(container.querySelector("img")).toBeNull()
-    expect(screen.queryByText("JH")).toBeNull()
-  })
-
-  test("explicit initials win over the derived ones", () => {
-    render(<UserAvatar initials="EX" name="Jenny Hamilton" />)
-    expect(screen.getByText("EX")).toBeDefined()
-  })
-})

package/src/components/composed/user-avatar.tsx

@@ -1,13 +0,0 @@
-/**
- * Back-compat path. The avatar moved to `components/user-avatar/` (split
- * into component / atoms / hooks); this module re-exports it so existing
- * imports keep resolving to the one implementation. Prefer the new path.
- */
-export {
-  UserAvatar,
-  initialsFrom,
-  useUserAvatar,
-  useUserAvatarActions,
-  useUserAvatarState,
-} from "@/components/user-avatar"
-export type { UserAvatarProps, UserPresence } from "@/components/user-avatar"

package/src/components/docs/component-preview.tsx

@@ -1,34 +0,0 @@
-import * as React from "react"
-
-import { BrowserFrame } from "@/components/beste/piece/browser-frame"
-import type { RegistryEntry } from "@/registry"
-
-/**
- * Renders an entry's lazy demo (created at registry module scope) inside a
- * bordered canvas. Falls back to a placeholder while the demo is not
- * implemented yet.
- */
-export function ComponentPreview({ entry }: { entry: RegistryEntry }) {
-  const Demo = entry.preview
-
-  return (
-    <BrowserFrame
-      title={entry.name}
-      titleStyle={entry.titleStyle ?? "expanded"}
-    >
-      {Demo ? (
-        <React.Suspense
-          fallback={<p className="text-sm text-muted-foreground">Loading…</p>}
-        >
-          <div className="relative h-full min-h-96 w-full">
-            <Demo />
-          </div>
-        </React.Suspense>
-      ) : (
-        <p className="text-sm text-muted-foreground">
-          Preview coming soon ({entry.status}).
-        </p>
-      )}
-    </BrowserFrame>
-  )
-}

package/src/components/docs/props-table.tsx

@@ -1,35 +0,0 @@
-import type { PropDef } from "@/registry"
-
-export function PropsTable({ props }: { props: PropDef[] }) {
-  return (
-    <div className="overflow-x-auto rounded-lg border">
-      <table className="w-full text-left text-sm">
-        <thead className="border-b bg-muted/50">
-          <tr>
-            <th className="p-3 font-medium">Prop</th>
-            <th className="p-3 font-medium">Type</th>
-            <th className="p-3 font-medium">Default</th>
-            <th className="p-3 font-medium">Description</th>
-          </tr>
-        </thead>
-        <tbody>
-          {props.map((prop) => (
-            <tr key={prop.name} className="border-b last:border-b-0">
-              <td className="p-3 font-mono text-xs">
-                {prop.name}
-                {prop.required ? <span className="text-destructive">*</span> : null}
-              </td>
-              <td className="p-3 font-mono text-xs text-muted-foreground">
-                {prop.type}
-              </td>
-              <td className="p-3 font-mono text-xs text-muted-foreground">
-                {prop.default ?? "—"}
-              </td>
-              <td className="p-3 text-muted-foreground">{prop.description}</td>
-            </tr>
-          ))}
-        </tbody>
-      </table>
-    </div>
-  )
-}