@danxbot/ui 1.0.0

package/dist/types/components/Toggle.d.ts

@@ -0,0 +1,65 @@
+import type { Ref } from "react";
+import { Toggle as BaseToggle } from "@base-ui/react/toggle";
+import { ToggleGroup as BaseToggleGroup } from "@base-ui/react/toggle-group";
+import { Toolbar as BaseToolbar } from "@base-ui/react/toolbar";
+import { type VariantProps } from "tailwind-variants";
+declare const toggle: import("tailwind-variants").TVReturnType<{
+    size: {
+        sm: "h-control-sm px-2.5 text-xs";
+        md: "h-control-md px-3 text-sm";
+        lg: "h-control-lg px-4 text-md";
+    };
+    iconOnly: {
+        true: "px-0 aspect-square";
+        false: "";
+    };
+}, undefined, string[], {
+    size: {
+        sm: "h-control-sm px-2.5 text-xs";
+        md: "h-control-md px-3 text-sm";
+        lg: "h-control-lg px-4 text-md";
+    };
+    iconOnly: {
+        true: "px-0 aspect-square";
+        false: "";
+    };
+}, undefined, import("tailwind-variants").TVReturnTypeLike<{
+    size: {
+        sm: "h-control-sm px-2.5 text-xs";
+        md: "h-control-md px-3 text-sm";
+        lg: "h-control-lg px-4 text-md";
+    };
+    iconOnly: {
+        true: "px-0 aspect-square";
+        false: "";
+    };
+}, undefined>>;
+export interface ToggleProps extends Omit<BaseToggle.Props, "className" | "render">, VariantProps<typeof toggle> {
+    className?: string;
+    ref?: Ref<HTMLButtonElement>;
+}
+export declare function Toggle({ size, iconOnly, className, children, ref, ...props }: ToggleProps): import("react").JSX.Element;
+export interface ToggleGroupProps extends Omit<BaseToggleGroup.Props, "className" | "render"> {
+    className?: string;
+    /** Segmented gives the group a shared inset background. */
+    variant?: "plain" | "segmented";
+    ref?: Ref<HTMLDivElement>;
+}
+/**
+ * A set of related toggles.
+ *
+ * `multiple` decides the meaning: false makes it a single choice (list
+ * view OR grid view), true makes it independent formats (bold AND italic).
+ * There is no separate "type" prop, because the multiplicity IS the type.
+ */
+export declare function ToggleGroup({ className, variant, children, ref, ...props }: ToggleGroupProps): import("react").JSX.Element;
+export interface ToolbarProps extends Omit<BaseToolbar.Root.Props, "className" | "render"> {
+    className?: string;
+    ref?: Ref<HTMLDivElement>;
+}
+export declare function Toolbar({ className, children, ref, ...props }: ToolbarProps): import("react").JSX.Element;
+/** A hairline between groups of toolbar controls. */
+export declare function ToolbarSeparator({ className }: {
+    className?: string;
+}): import("react").JSX.Element;
+export {};

package/dist/types/components/Tree.d.ts

@@ -0,0 +1,20 @@
+import type { ReactNode } from "react";
+import { type IconName } from "./Icon";
+export type TreeNode = {
+    id: string;
+    label: ReactNode;
+    icon?: IconName;
+    /** Trailing content — a count, a status dot, a menu. */
+    meta?: ReactNode;
+    children?: TreeNode[];
+    disabled?: boolean;
+};
+export interface TreeProps {
+    nodes: TreeNode[];
+    /** Ids expanded on first render. */
+    defaultExpanded?: string[];
+    selectedId?: string;
+    onSelect?: (node: TreeNode) => void;
+    className?: string;
+}
+export declare function Tree({ nodes, defaultExpanded, selectedId, onSelect, className }: TreeProps): import("react").JSX.Element;

package/dist/types/components/calendar/CalendarMonth.d.ts

@@ -0,0 +1,33 @@
+import { type ReactNode } from "react";
+import { addDays, startOfMonth, type PlainDate, type TimeZone } from "@/lib/time";
+import type { CalendarEvent } from "@/lib/calendar/types";
+export interface CalendarMonthProps {
+    /** Any day in the month to display. */
+    month: PlainDate;
+    /** The zone every timed event is interpreted in. Required — there is no default. */
+    zone: TimeZone;
+    events: readonly CalendarEvent[];
+    /** 0 = Sunday. No default anywhere up the stack — see `startOfWeek`. */
+    weekStartsOn?: number;
+    /** Today, for the highlight. Omit in tests so snapshots do not rot. */
+    today?: PlainDate;
+    selectedDate?: PlainDate;
+    onSelectDate?: (day: PlainDate) => void;
+    onSelectEvent?: (event: CalendarEvent) => void;
+    /** Fired when navigation or paging leaves the displayed month. */
+    onMonthChange?: (month: PlainDate) => void;
+    /**
+     * Most bar rows a cell may show, INCLUDING the row the "+N more" link takes.
+     * See `packBand`; the affordance is counted so it cannot be drawn over an event.
+     */
+    maxEventRows?: number;
+    locale?: string;
+    /** Replace a chip's contents. The chip itself — button, label, colour — stays ours. */
+    renderEvent?: (event: CalendarEvent) => ReactNode;
+    className?: string;
+    /** Accessible name for the grid. */
+    label?: string;
+}
+export declare function CalendarMonth({ month: monthProp, zone, events, weekStartsOn, today, selectedDate, onSelectDate, onSelectEvent, onMonthChange, maxEventRows, locale, renderEvent, className, label, }: CalendarMonthProps): import("react").JSX.Element;
+/** The first day of the month `date` falls in — re-exported for consumers paging. */
+export { startOfMonth, addDays };

package/dist/types/components/calendar/CalendarTimeGrid.d.ts

@@ -0,0 +1,75 @@
+import { type ReactNode } from "react";
+import { type PlainDate, type TimeZone } from "@/lib/time";
+import type { CalendarEvent } from "@/lib/calendar/types";
+import type { Instant } from "@/lib/time";
+export interface CalendarTimeGridProps {
+    /** The days to show. One for Day view, seven for Week. */
+    days: readonly PlainDate[];
+    zone: TimeZone;
+    events: readonly CalendarEvent[];
+    today?: PlainDate;
+    onSelectEvent?: (event: CalendarEvent) => void;
+    /** Minutes per rail. 60 by default — see `snapMinutes` for why they differ. */
+    slotMinutes?: number;
+    /** Pixel height of one rail. The column's total height is derived from it. */
+    slotHeightPx?: number;
+    /**
+     * Hour the grid scrolls to on load. 8 by default.
+     *
+     * Applied on the RANGE's identity, not on every render. react-big-calendar
+     * re-runs its scroll effect on render, so selecting an event snaps the user
+     * back to 8am — an open issue, and a genuinely maddening one.
+     */
+    scrollToHour?: number;
+    /**
+     * Rows the all-day band may show before it scrolls internally.
+     *
+     * REQUIRED TO BE FINITE. An uncapped band eats the container and makes the
+     * time grid unreachable — an open FullCalendar bug, and react-big-calendar's
+     * default is literally `Infinity`.
+     */
+    maxAllDayRows?: number;
+    /** Most lanes a batch of overlapping events may divide into. */
+    maxLanes?: number;
+    /** `cascade` is the Google look and the default. */
+    overlapMode?: "cascade" | "split";
+    /** Fix the now-indicator for a screenshot. */
+    nowInstant?: number;
+    /**
+     * Minutes a drag snaps to. DELIBERATELY INDEPENDENT of `slotMinutes`.
+     *
+     * FullCalendar, react-big-calendar and Schedule-X all couple snap to the rail
+     * spacing; Google and Mobiscroll do not, and Google is 15-minute snap on
+     * 60-minute rails — the combination that feels right. Retrofitting the split
+     * is a rewrite, so the two are separate values.
+     */
+    snapMinutes?: number;
+    /** Commit a move or a resize. Omit to make the grid read-only. */
+    onEventChange?: (event: CalendarEvent, next: CalendarEvent) => void;
+    /** Commit a drag-to-create. Omit to disable creating. */
+    onCreate?: (range: {
+        start: Instant;
+        endExclusive: Instant;
+    }) => void;
+    /** Announcements for the live region. The grid renders its own if omitted. */
+    onAnnounce?: (message: string) => void;
+    /**
+     * Whether clicking an editable event opens the move/resize action menu.
+     *
+     * ON BY DEFAULT WHEN THE GRID IS EDITABLE, AND TURNING IT OFF FAILS WCAG 2.2
+     * SC 2.5.7 unless you provide an equivalent. That criterion asks for a
+     * single-pointer, NON-DRAGGING route to every outcome a drag can produce, and
+     * it is assessed independently of keyboard access — a keyboard equivalent does
+     * not satisfy it. This menu is that route. See `EventActions` for why the
+     * pointer path is tier one and the keyboard is not.
+     *
+     * Set false ONLY when your `onSelectEvent` opens something that offers the
+     * same three outcomes: a new day, a new start, a new length.
+     */
+    eventActions?: boolean;
+    locale?: string;
+    renderEvent?: (event: CalendarEvent) => ReactNode;
+    className?: string;
+    label?: string;
+}
+export declare function CalendarTimeGrid({ days, zone, events, today, onSelectEvent, slotMinutes, slotHeightPx, scrollToHour, maxAllDayRows, maxLanes, overlapMode, nowInstant, snapMinutes, onEventChange, onCreate, onAnnounce, eventActions, locale, renderEvent, className, label, }: CalendarTimeGridProps): import("react").JSX.Element;

package/dist/types/components/calendar/EventActions.d.ts

@@ -0,0 +1,17 @@
+import { type PlainDate, type TimeZone } from "@/lib/time";
+import type { TimedEvent } from "@/lib/calendar/types";
+export interface EventActionsProps {
+    event: TimedEvent;
+    zone: TimeZone;
+    /** The days the view is showing — the destinations "Move to" offers. */
+    days: readonly PlainDate[];
+    /** Same step the drag snaps to, so the two paths reach the same positions. */
+    snapMinutes?: number;
+    /** Longest duration offered, in minutes. */
+    maxDurationMinutes?: number;
+    onApply: (next: TimedEvent) => void;
+    onClose?: () => void;
+    locale?: string;
+    className?: string;
+}
+export declare function EventActions({ event, zone, days, snapMinutes, maxDurationMinutes, onApply, onClose, locale, className, }: EventActionsProps): import("react").JSX.Element;

package/dist/types/components/calendar/format.d.ts

@@ -0,0 +1,43 @@
+import { isoDateString, type Instant, type PlainDate, type TimeZone } from "@/lib/time";
+import type { CalendarEvent } from "@/lib/calendar/types";
+/** `Monday` / `Mon` / `M`, in the viewer's locale. */
+export declare function weekdayName(date: PlainDate, width: "long" | "short" | "narrow", locale?: string): string;
+/** `15` — the number in the cell. */
+export declare function dayNumber(date: PlainDate, locale?: string): string;
+/** `June 2026` — the view's title. */
+export declare function monthTitle(date: PlainDate, locale?: string): string;
+/** `Monday, 15 June 2026` — a cell's accessible name starts with this. */
+export declare function longDate(date: PlainDate, locale?: string): string;
+/** `9:30 AM` in the calendar's zone — never the host's. */
+export declare function timeOfDay(instant: Instant, zone: TimeZone, locale?: string, withMinutes?: boolean): string;
+/** `GMT−6` — the label above the hour gutter. */
+export declare function zoneLabel(zone: TimeZone, at: Instant, locale?: string): string;
+/**
+ * The human range of an event: `15–17 June`, `9:30 – 10:30 AM`, `All day`.
+ *
+ * THE ONLY PLACE THE EXCLUSIVE END BECOMES AN INCLUSIVE ONE. An all-day event
+ * stored 15th → 16th is ONE day and reads "15 June"; stored 15th → 18th it
+ * reads "15 – 17 June". Getting this wrong in the other direction is the
+ * most-reported bug in calendar interoperability, so it happens once, here,
+ * where a test can point at it.
+ */
+export declare function formatDateRange(event: CalendarEvent, zone: TimeZone, locale?: string): string;
+/**
+ * A cell's accessible name: `Monday, 15 June 2026, 3 events`.
+ *
+ * THE COUNT IS PART OF THE NAME, and that is the difference between a grid a
+ * screen-reader user can skim and one they must enter cell by cell to discover
+ * is empty. Arrowing across a month hearing "14. 15. 16." tells them nothing
+ * about where the work is.
+ */
+export declare function cellLabel(date: PlainDate, eventCount: number, locale?: string): string;
+/**
+ * An event chip's accessible name.
+ *
+ * Title, then the range, then the calendar's colour LABEL — the last so that
+ * two identically-titled events on different calendars are distinguishable
+ * without seeing the colour.
+ */
+export declare function eventLabel(event: CalendarEvent, zone: TimeZone, paletteLabel: string | undefined, locale?: string): string;
+/** Stable React key for a day. */
+export declare const keyForDay: typeof isoDateString;

package/dist/types/components/calendar/index.d.ts

@@ -0,0 +1,9 @@
+export { CalendarMonth, type CalendarMonthProps } from "./CalendarMonth";
+export { CalendarTimeGrid, type CalendarTimeGridProps } from "./CalendarTimeGrid";
+export { useNow, type UseNowOptions } from "./use-now";
+export { EventActions, type EventActionsProps } from "./EventActions";
+export { useCalendarDrag, type CalendarDragOptions, type CalendarDragState, } from "./use-calendar-drag";
+export { useEventKeyboard, type EventKeyboardOptions, type EventKeyboardState, } from "./use-event-keyboard";
+export { EVENT_PALETTE, DEFAULT_PALETTE_KEY, isPaletteKey, paletteFor } from "./palette";
+export { cellLabel, dayNumber, eventLabel, formatDateRange, longDate, monthTitle, timeOfDay, weekdayName, zoneLabel, } from "./format";
+export { initialFocusDay, isInMonth, nextDayForKey, useGridNavigation, type GridNavigation, type GridNavigationOptions, } from "./use-grid-navigation";

package/dist/types/components/calendar/palette.d.ts

@@ -0,0 +1,17 @@
+import type { EventPalette, PaletteEntry } from "@/lib/calendar/types";
+export declare const EVENT_PALETTE: EventPalette;
+export declare const DEFAULT_PALETTE_KEY = "iris";
+/**
+ * The swatch for a key, falling back to the default for an unknown one.
+ *
+ * A FALLBACK RATHER THAN A THROW, deliberately, and this is the one place in
+ * the calendar where that is the right call. Event data arrives from a server
+ * and an unrecognised colour key is a data problem, not a programming error —
+ * refusing to render the whole month because one event has a stale key would
+ * turn a cosmetic mismatch into an outage. The event still renders, still
+ * carries its title and time, and is still reachable; only its colour is
+ * generic.
+ */
+export declare function paletteFor(key: string | undefined): PaletteEntry;
+/** Whether a key names a real swatch — for a consumer validating its own data. */
+export declare function isPaletteKey(key: string): boolean;

package/dist/types/components/calendar/use-calendar-drag.d.ts

@@ -0,0 +1,54 @@
+import { type ColumnRect } from "@/lib/calendar/drag";
+import type { CalendarEvent, DragKind, EventDraft, TimedEvent } from "@/lib/calendar/types";
+import type { Instant, PlainDate, TimeZone } from "@/lib/time";
+export interface CalendarDragOptions {
+    readonly zone: TimeZone;
+    readonly days: readonly PlainDate[];
+    readonly snapMinutes: number;
+    /** Measure the day columns. Called at activation and on every scroll. */
+    readonly measure: () => ColumnRect[];
+    /** Commit. Not called for a gesture that changed nothing. */
+    readonly onCommit?: (event: CalendarEvent, next: TimedEvent) => void;
+    /** Commit a drag-to-create. */
+    readonly onCreate?: (range: {
+        start: Instant;
+        endExclusive: Instant;
+        day: PlainDate;
+    }) => void;
+    /** Fired on every committed slot change, for the live region. */
+    readonly onAnnounce?: (message: string) => void;
+    readonly locale?: string;
+    readonly disabled?: boolean;
+}
+export interface CalendarDragState {
+    /** The gesture in flight, or null. */
+    readonly draft: EventDraft | null;
+    /** The rubber-band range while creating, or null. */
+    readonly creating: {
+        start: Instant;
+        endExclusive: Instant;
+        day: PlainDate;
+    } | null;
+    /** True while a resize would be refused — the view dims the preview. */
+    readonly invalid: boolean;
+    /** Wire an event chip. `kind` decides which edge, if any, is being moved. */
+    readonly bindEvent: (event: TimedEvent, kind: DragKind) => (node: HTMLElement | null) => void;
+    /** Wire the empty area of a day column, for drag-to-create. */
+    readonly bindCanvas: () => (node: HTMLElement | null) => void;
+    /** The event as it would be if dropped now — for the live preview. */
+    readonly preview: (event: TimedEvent) => TimedEvent;
+    /**
+     * The two questions the edge auto-scroll loop asks. Passed straight to
+     * `attachEdgeAutoScroll` — see its `AutoScrollDriver` for why re-feeding the
+     * point on scroll is the whole reason the second one exists.
+     */
+    readonly getPoint: () => {
+        x: number;
+        y: number;
+    } | null;
+    readonly onScrolled: (point: {
+        x: number;
+        y: number;
+    }) => void;
+}
+export declare function useCalendarDrag(options: CalendarDragOptions): CalendarDragState;

package/dist/types/components/calendar/use-event-keyboard.d.ts

@@ -0,0 +1,24 @@
+import { type KeyboardEvent } from "react";
+import { type CalendarDuration, type PlainDate, type TimeZone } from "@/lib/time";
+import type { TimedEvent } from "@/lib/calendar/types";
+export interface EventKeyboardOptions {
+    readonly zone: TimeZone;
+    /** Same step the drag snaps to, so both paths reach the same positions. */
+    readonly snapMinutes: number;
+    /** Days in view, for the day-change bounds and for the announcement. */
+    readonly days: readonly PlainDate[];
+    readonly onCommit: (event: TimedEvent, next: TimedEvent) => void;
+    readonly onAnnounce?: (message: string) => void;
+    readonly locale?: string;
+}
+export interface EventKeyboardState {
+    /** The event currently held, or null. */
+    readonly grabbedId: string | null;
+    /** The pending delta while held. */
+    readonly delta: CalendarDuration;
+    /** Attach to an event chip. */
+    readonly onKeyDown: (event: TimedEvent, e: KeyboardEvent<HTMLElement>) => void;
+    /** The event as it would be if dropped now. */
+    readonly preview: (event: TimedEvent) => TimedEvent;
+}
+export declare function useEventKeyboard(options: EventKeyboardOptions): EventKeyboardState;

package/dist/types/components/calendar/use-grid-navigation.d.ts

@@ -0,0 +1,47 @@
+import { type KeyboardEvent } from "react";
+import { comparePlainDate, type PlainDate } from "@/lib/time";
+export interface GridNavigationOptions {
+    /** Any day in the displayed month. Used to clamp paging. */
+    readonly month: PlainDate;
+    readonly weekStartsOn: number;
+    /** Called when navigation lands outside the displayed month. */
+    readonly onMonthChange?: (month: PlainDate) => void;
+}
+export interface GridNavigation {
+    /** The day that currently holds `tabIndex={0}`. Exactly one, always. */
+    readonly focusedDay: PlainDate;
+    readonly setFocusedDay: (day: PlainDate) => void;
+    /** True while the user is INSIDE a cell, interacting with its events. */
+    readonly insideCell: boolean;
+    readonly enterCell: () => void;
+    readonly leaveCell: () => void;
+    /** Attach to the table. Returns true when it consumed the event. */
+    readonly onKeyDown: (event: KeyboardEvent<HTMLElement>) => void;
+}
+/**
+ * Which day a key moves to, or `null` when the key is not ours.
+ *
+ * PURE, AND EXPORTED, so the whole key map is testable without a DOM. Every
+ * binding below is APG-normative; the file header records the two it
+ * deliberately does not use.
+ */
+export declare function nextDayForKey(key: string, current: PlainDate, weekStartsOn: number, modifiers: {
+    ctrl: boolean;
+    shift: boolean;
+    meta: boolean;
+}): PlainDate | null;
+export declare function useGridNavigation(initialDay: PlainDate, options: GridNavigationOptions): GridNavigation;
+/**
+ * The day that should carry `tabIndex={0}` when the grid has never been used.
+ *
+ * EXACTLY ONE CELL IS TABBABLE, ALWAYS — that is the roving-tabindex contract
+ * and the thing a probe should assert after every keypress. Preference order:
+ * the selected day, else today if the month contains it, else the 1st. Landing
+ * on today is what a user expects; landing on the 1st of a month they paged to
+ * is what they expect there.
+ */
+export declare function initialFocusDay(days: readonly PlainDate[], month: PlainDate, today: PlainDate | undefined, selected: PlainDate | undefined): PlainDate;
+/** Whether `day` belongs to the displayed month rather than a neighbour. */
+export declare function isInMonth(day: PlainDate, month: PlainDate): boolean;
+/** Ordering helper for consumers rendering their own event lists. */
+export { comparePlainDate };

package/dist/types/components/calendar/use-now.d.ts

@@ -0,0 +1,20 @@
+export interface UseNowOptions {
+    /**
+     * How often the value should change, in ms. 60,000 for a minute-resolution
+     * indicator.
+     */
+    readonly resolutionMs?: number;
+    /** Set false to freeze the value — for tests and visual baselines. */
+    readonly enabled?: boolean;
+    /** A fixed instant to report instead of the clock. Overrides `enabled`. */
+    readonly fixed?: number;
+}
+/**
+ * `Date.now()`, re-read on each boundary of `resolutionMs`.
+ *
+ * `fixed` exists because every visual baseline in this package is a screenshot:
+ * a now-indicator driven by the real clock moves a few pixels every minute and
+ * re-records itself forever, so the demo and the preview pass a fixed instant
+ * and the gate keeps gating.
+ */
+export declare function useNow(options?: UseNowOptions): number;

package/dist/types/components/chat/Attachment.d.ts

@@ -0,0 +1,49 @@
+import { type ReactNode, type Ref } from "react";
+import type { ChatFile } from "./types";
+/** Binary units, because these are file sizes and every OS reports them this way. */
+export declare function formatBytes(bytes: number): string;
+export type AttachmentLayout = "tile" | "row";
+export interface AttachmentProps {
+    file: ChatFile;
+    layout?: AttachmentLayout;
+    /** Overrides the size line — "Sheet 2 of 4", a page count, anything truer. */
+    meta?: ReactNode;
+    onRemove?: (file: ChatFile) => void;
+    onPreview?: (file: ChatFile) => void;
+    onDownload?: (file: ChatFile) => void;
+    /** Marks the file as the current selection in a gallery. */
+    selected?: boolean;
+    disabled?: boolean;
+    className?: string;
+    ref?: Ref<HTMLDivElement>;
+}
+export declare function Attachment({ file, layout, meta, onRemove, onPreview, onDownload, selected, disabled, className, ref, }: AttachmentProps): import("react").JSX.Element;
+export interface AttachmentPreviewProps {
+    file: ChatFile | null;
+    onOpenChange: (open: boolean) => void;
+    onDownload?: (file: ChatFile) => void;
+    /** Renders the body for a file this component cannot show itself. */
+    renderBody?: (file: ChatFile) => ReactNode;
+}
+/**
+ * A file, opened.
+ *
+ * Deliberately narrow about what it displays: images, and anything the
+ * consumer hands it through `renderBody`. It does NOT attempt to preview PDFs,
+ * office documents or video by embedding them — an iframe pointed at an
+ * arbitrary attachment is a security surface, and a half-working preview is
+ * worse than an honest "open it" because people trust what they see.
+ */
+export declare function AttachmentPreview({ file, onOpenChange, onDownload, renderBody, }: AttachmentPreviewProps): import("react").JSX.Element;
+export interface AttachmentListProps {
+    files: ChatFile[];
+    layout?: AttachmentLayout;
+    onRemove?: (file: ChatFile) => void;
+    onPreview?: (file: ChatFile) => void;
+    onDownload?: (file: ChatFile) => void;
+    /** Collapses to "+N more" past this count. */
+    max?: number;
+    disabled?: boolean;
+    className?: string;
+}
+export declare function AttachmentList({ files, layout, onRemove, onPreview, onDownload, max, disabled, className, }: AttachmentListProps): import("react").JSX.Element | null;

package/dist/types/components/chat/Chat.d.ts

@@ -0,0 +1,60 @@
+import { type ReactNode } from "react";
+import { type ComposerProps } from "./Composer";
+import { type MessageAction } from "./Message";
+import { ModelSelector, type ChatModel } from "./ModelSelector";
+import { type EffortLevel } from "./EffortControl";
+import { type ContextSegment, type UsageLimit } from "./ContextMeter";
+import type { ChatComponents, ChatMessage, PartRenderers } from "./types";
+export type ChatSurface = "inline" | "sidebar" | "popover";
+export interface ChatProps<TApp = unknown> extends Pick<ComposerProps, "value" | "onValueChange" | "onSubmit" | "files" | "onFilesAdded" | "onFileRemoved" | "busy" | "onStop" | "placeholder" | "disabled" | "error" | "accept"> {
+    messages: ChatMessage[];
+    /** Replaces a built-in part renderer. Partial — override one, keep the rest. */
+    renderers?: PartRenderers<TApp>;
+    /** Application components a message may address by name. */
+    components?: ChatComponents<TApp>;
+    /** Handed to every renderer at call time, so a module-scope registry still
+        reaches live application state. */
+    appContext?: TApp;
+    title?: ReactNode;
+    subtitle?: ReactNode;
+    /** Buttons in the header — new thread, settings, close. */
+    headerActions?: ReactNode;
+    /** Shown instead of the transcript when there are no messages. */
+    empty?: ReactNode;
+    models?: ChatModel[];
+    model?: string;
+    onModelChange?: (id: string) => void;
+    /** Switches under the model list — fast mode, thinking, and so on. */
+    modelOptions?: Parameters<typeof ModelSelector>[0]["options"];
+    effortLevels?: EffortLevel[];
+    effort?: string;
+    onEffortChange?: (id: string) => void;
+    context?: {
+        segments: ContextSegment[];
+        capacity: number;
+        limits?: UsageLimit[];
+    };
+    /** Per-message buttons. Copy is always present and is not listed here. */
+    messageActions?: MessageAction[];
+    showTimestamps?: boolean;
+    /** Status line above the composer — "Thinking…", "Running tests". */
+    status?: ReactNode;
+    hint?: ReactNode;
+    surface?: ChatSurface;
+    className?: string;
+}
+export declare function Chat<TApp = unknown>({ messages, renderers, components, appContext, title, subtitle, headerActions, empty, models, model, onModelChange, modelOptions, effortLevels, effort, onEffortChange, context, messageActions, showTimestamps, status, hint, surface, className, ...composer }: ChatProps<TApp>): import("react").JSX.Element;
+export interface ChatPopoverProps<TApp = unknown> extends ChatProps<TApp> {
+    /** The control that opens it. Defaults to a floating round button. */
+    trigger?: ReactNode;
+    side?: "top" | "bottom" | "left" | "right";
+    align?: "start" | "center" | "end";
+}
+/**
+ * The same chat, anchored to a trigger.
+ *
+ * A popover rather than a fixed-position widget: anchoring is the positioning
+ * engine's job, and a hand-placed `bottom-6 right-6` panel is the version that
+ * ends up off screen on a short viewport or under a cookie banner.
+ */
+export declare function ChatPopover<TApp = unknown>({ trigger, side, align, ...chat }: ChatPopoverProps<TApp>): import("react").JSX.Element;

package/dist/types/components/chat/Composer.d.ts

@@ -0,0 +1,29 @@
+import { type ReactNode, type Ref } from "react";
+import type { ChatFile } from "./types";
+export interface ComposerProps {
+    value: string;
+    onValueChange: (value: string) => void;
+    onSubmit: (value: string, files: ChatFile[]) => void;
+    /** Staged files, shown above the text. */
+    files?: ChatFile[];
+    onFilesAdded?: (files: File[]) => void;
+    onFileRemoved?: (file: ChatFile) => void;
+    /** Streaming — the send button becomes stop. */
+    busy?: boolean;
+    onStop?: () => void;
+    placeholder?: string;
+    disabled?: boolean;
+    /** Blocks submit and explains why, under the field. */
+    error?: ReactNode;
+    /** Controls at the bottom-left — model, effort, context, whatever applies. */
+    toolbar?: ReactNode;
+    /** Extra buttons beside the attach button. */
+    leading?: ReactNode;
+    /** Hint at bottom-right, left of the send button. */
+    hint?: ReactNode;
+    accept?: string;
+    maxRows?: number;
+    className?: string;
+    ref?: Ref<HTMLTextAreaElement>;
+}
+export declare function Composer({ value, onValueChange, onSubmit, files, onFilesAdded, onFileRemoved, busy, onStop, placeholder, disabled, error, toolbar, leading, hint, accept, maxRows, className, ref, }: ComposerProps): import("react").JSX.Element;

package/dist/types/components/chat/ContextMeter.d.ts

@@ -0,0 +1,55 @@
+import { type ReactNode } from "react";
+export interface ContextSegment {
+    id: string;
+    label: string;
+    tokens: number;
+    /** Any CSS colour. Defaults walk a fixed palette in declaration order. */
+    color?: string;
+}
+/**
+ * 241_600 → "241.6k".
+ *
+ * One decimal all the way to 1M, and exact below 1k. Unlike a file size — where
+ * a tenth of a kilobyte is noise on a number nobody acts on — the tenth here is
+ * the digit that moves while you work: at 1M capacity, a whole percent is
+ * 10_000 tokens, so rounding to "242k" holds a figure still for several
+ * exchanges and makes a live meter look frozen.
+ */
+export declare function formatTokens(tokens: number): string;
+export interface UsageLimit {
+    id: string;
+    label: string;
+    /** 0–100. */
+    percent: number;
+    /** "Resets in 1 hr 46 min" — relative or absolute, whichever is clearer. */
+    resets?: string;
+}
+export interface ContextMeterProps {
+    segments: ContextSegment[];
+    /** Total window size in tokens. */
+    capacity: number;
+    /** Plan or rate limits, listed under the breakdown. */
+    limits?: UsageLimit[];
+    /** Fraction of capacity at which the bar turns amber, then red. */
+    warnAt?: number;
+    dangerAt?: number;
+    /** Renders the panel inline rather than behind a trigger row. */
+    inline?: boolean;
+    side?: "top" | "bottom";
+    align?: "start" | "center" | "end";
+    className?: string;
+}
+export declare function ContextMeter({ segments, capacity, limits, warnAt, dangerAt, inline, side, align, className, }: ContextMeterProps): import("react").JSX.Element;
+/**
+ * A live status line for the composer — "Thinking…", "Ran 3 commands".
+ *
+ * Shimmer rather than a spinner: a spinner beside text competes with it for
+ * attention and adds a second thing moving in a row that already has one. The
+ * text saying what is happening IS the indicator.
+ */
+export interface ChatStatusProps {
+    children: ReactNode;
+    active?: boolean;
+    className?: string;
+}
+export declare function ChatStatus({ children, active, className }: ChatStatusProps): import("react").JSX.Element;

package/dist/types/components/chat/EffortControl.d.ts

@@ -0,0 +1,23 @@
+import { type ReactNode } from "react";
+export interface EffortLevel {
+    id: string;
+    /** "High" — appears on the trigger and above the slider. */
+    label: string;
+    /** One line explaining the trade at this stop. */
+    description?: ReactNode;
+}
+export declare const DEFAULT_EFFORT_LEVELS: EffortLevel[];
+export interface EffortControlProps {
+    levels?: EffortLevel[];
+    value: string;
+    onValueChange: (id: string) => void;
+    /** Explains the whole control, behind the header's help affordance. */
+    help?: ReactNode;
+    /** Renders the slider inline instead of behind a trigger button. */
+    inline?: boolean;
+    side?: "top" | "bottom";
+    align?: "start" | "center" | "end";
+    disabled?: boolean;
+    className?: string;
+}
+export declare function EffortControl({ levels, value, onValueChange, help, inline, side, align, disabled, className, }: EffortControlProps): import("react").JSX.Element;