@uisatin/ui 0.0.0-stage → 0.1.0

package/components/sidebar.d.ts

@@ -0,0 +1,52 @@
+import * as React from 'react';
+import { Collapsible } from 'radix-ui';
+export interface SidebarProps extends React.ComponentProps<'nav'> {
+}
+/** The navigation landmark. Name it with `aria-label` when a page has more than one nav. */
+export declare function Sidebar({ className, ...props }: SidebarProps): React.JSX.Element;
+export interface SidebarItemProps extends Omit<React.ComponentProps<'a'>, 'children'> {
+    label: string;
+    icon?: React.ReactNode;
+    /** The current page. Sets `aria-current="page"`. */
+    active?: boolean;
+    /** Unread or pending work. Hidden at 0. */
+    count?: number;
+    /** The collapsed rail: icon only, label in a tooltip. */
+    iconOnly?: boolean;
+    disabled?: boolean;
+    /** Render your router's link instead of `<a>`. */
+    asChild?: boolean;
+    children?: React.ReactNode;
+}
+export declare function SidebarItem({ className, label, icon, active, count, iconOnly, disabled, asChild, href, children, ...props }: SidebarItemProps): React.JSX.Element;
+export interface SidebarGroupProps extends Omit<React.ComponentProps<typeof Collapsible.Root>, 'children'> {
+    label: string;
+    icon?: React.ReactNode;
+    /** How many items the group holds. */
+    count?: number;
+    children?: React.ReactNode;
+    /** Forwarded to the header button, e.g. `data-force="hover"` on a state sheet. */
+    triggerProps?: React.ComponentProps<'button'> & {
+        'data-force'?: string;
+    };
+}
+export declare function SidebarGroup({ className, label, icon, count, defaultOpen, open: openProp, onOpenChange, children, triggerProps, ...props }: SidebarGroupProps): React.JSX.Element;
+export interface SidebarSubItemProps extends Omit<React.ComponentProps<'a'>, 'children'> {
+    label: string;
+    active?: boolean;
+    disabled?: boolean;
+    asChild?: boolean;
+    children?: React.ReactNode;
+}
+export declare function SidebarSubItem({ className, label, active, disabled, asChild, href, children, ...props }: SidebarSubItemProps): React.JSX.Element;
+export interface SidebarSubGroupProps extends Omit<React.ComponentProps<'div'>, 'children'> {
+    label: string;
+    /** Its `SidebarSubItem`s; they sit 12px further in. */
+    children?: React.ReactNode;
+    /** One of its sub-items is the current page: opens it by default and marks the label. */
+    active?: boolean;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+export declare function SidebarSubGroup({ className, label, children, active, open: openProp, defaultOpen, onOpenChange, ...props }: SidebarSubGroupProps): React.JSX.Element;

package/components/sidebar.js

@@ -0,0 +1,4 @@
+'use client';export { Sidebar, SidebarGroup, SidebarItem, SidebarSubGroup, SidebarSubItem } from '../chunk-BNTPPZCK.js';
+import '../chunk-H63FYCMY.js';
+//# sourceMappingURL=sidebar.js.map
+//# sourceMappingURL=sidebar.js.map

package/components/sidebar.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"sidebar.js"}

package/components/skeleton.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+/**
+ * Skeleton, 1:1 with the uiKit `Skeleton` set (4025:3862): a bg/muted placeholder in three
+ * shapes. text is a 12px line at radius-sm (240 wide by default), circle 32px round, rect
+ * 240 × 120 at radius-lg. Size it with `width` / `height` or classes.
+ *
+ * `animated` runs a soft band across the block (a 6% wash of text/default, so it lightens in
+ * Dark and darkens in Light), 1.6 s a pass on ease-in-out; with reduced motion it stays still.
+ *
+ * The blocks are aria-hidden: put `aria-busy` on the region that is loading.
+ */
+export interface SkeletonProps extends React.ComponentProps<'div'> {
+    shape?: 'text' | 'circle' | 'rect';
+    animated?: boolean;
+    width?: number | string;
+    height?: number | string;
+}
+export declare function Skeleton({ shape, animated, width, height, className, style, ...props }: SkeletonProps): React.JSX.Element;

package/components/skeleton.js

@@ -0,0 +1,4 @@
+'use client';export { Skeleton } from '../chunk-YG7JOOLJ.js';
+import '../chunk-H63FYCMY.js';
+//# sourceMappingURL=skeleton.js.map
+//# sourceMappingURL=skeleton.js.map

package/components/skeleton.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"skeleton.js"}

package/components/slider.d.ts

@@ -0,0 +1,57 @@
+import * as React from 'react';
+/**
+ * Slider, 1:1 with the uiKit `Slider` set (4025:3621): a 4px bg/muted track with the picked
+ * part in action/primary/bg, and 16px bg/popover thumbs with a border/strong ring and the
+ * shadow-sm drop (0 1 3). Hover turns the ring text/subtle, keyboard focus adds a 2px focus
+ * ring, disabled fades the whole slider to 50%. 20px tall, so the thumbs have room.
+ *
+ * One value or a range: pass a number or a `[from, to]` pair as `value` / `defaultValue`.
+ *
+ * Around it, all optional:
+ * - `label` on the left above the track and, on the same line at the right, the picked value
+ *   (`showValue`, on by default, "40" or "20 – 80", through `formatValue`).
+ * - `inputs`: small number fields beside the track to type a value: the range's from on the
+ *   left and to on the right, a single value on the right. They take the readout's place.
+ *   A typed value is clamped, snapped to `step` and kept in order on Enter or blur; Escape
+ *   puts the current value back.
+ * - `tooltip`: the value in a Tooltip bubble over the thumb while it is dragged or moved with
+ *   the keys.
+ * - `orientation="vertical"`: the track runs bottom to top (160px unless styled), the inputs
+ *   go above (to) and below (from or the single value).
+ *
+ * Built on the Radix Slider: arrow keys, Page Up/Down, Home/End, a native form value (`name`)
+ * and a `slider` role per thumb, with `formatValue` as its spoken value.
+ */
+export interface SliderProps {
+    /** A number, or a `[from, to]` pair for a range. */
+    value?: number | [number, number];
+    defaultValue?: number | [number, number];
+    /** Every change while it moves. Gets a number or a pair, as given. */
+    onValueChange?: (value: number | [number, number]) => void;
+    /** Once, when a drag ends or a key or a typed value changes it. */
+    onValueCommit?: (value: number | [number, number]) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    /** Smallest gap between the range's thumbs, in steps. */
+    minStepsBetweenThumbs?: number;
+    label?: React.ReactNode;
+    /** The picked value at the right of the label's line. Hidden while `inputs` are on. */
+    showValue?: boolean;
+    /** Small number fields beside the track to type the value. */
+    inputs?: boolean;
+    /** The value in a bubble over the thumb while it moves. */
+    tooltip?: boolean;
+    orientation?: 'horizontal' | 'vertical';
+    /** How a value reads in the readout, the bubble, the fields' neighbours and to screen readers. */
+    formatValue?: (value: number) => string;
+    disabled?: boolean;
+    /** Form field name, for a native form submit. */
+    name?: string;
+    id?: string;
+    /** Names the slider when there is no `label`. */
+    'aria-label'?: string;
+    /** Classes for the outer wrapper. */
+    className?: string;
+}
+export declare function Slider({ value: valueProp, defaultValue, onValueChange, onValueCommit, min, max, step, minStepsBetweenThumbs, label, showValue, inputs, tooltip, orientation, formatValue, disabled, name, id, 'aria-label': ariaLabel, className, }: SliderProps): React.JSX.Element;

package/components/slider.js

@@ -0,0 +1,8 @@
+'use client';export { Slider } from '../chunk-L6NCCSIP.js';
+import '../chunk-YPNKBE5X.js';
+import '../chunk-B6V4VSGH.js';
+import '../chunk-UBNHSZSE.js';
+import '../chunk-BKZBWPUH.js';
+import '../chunk-H63FYCMY.js';
+//# sourceMappingURL=slider.js.map
+//# sourceMappingURL=slider.js.map

package/components/slider.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"slider.js"}

package/components/sliding-indicator.d.ts

@@ -0,0 +1,23 @@
+import * as React from 'react';
+/**
+ * The background (or underline) that slides under the selected item of Tabs, Segmented control
+ * and Pagination, all on one motion: 300 ms on the kit's ease-out, the leading edge (the one
+ * on the side it is heading to) moving straight away and the trailing edge 30 ms behind, so it
+ * stretches a little towards the new item and settles there. A change mid-move carries on from
+ * wherever it is. Only a change of selection animates; a resize just puts it in place. With
+ * reduced motion it moves at once.
+ *
+ * `listRef` is the positioned element the items sit in, `selector` finds the selected item in
+ * it, `selected` is whatever names the selection. Render the indicator absolutely at left 0 of
+ * the list with the returned `ref`; until it is placed (`ready`), let the selected item paint
+ * its own fill so the server render isn't bare.
+ */
+export declare const SLIDE_MS = 300;
+export declare function useSlidingIndicator<T extends HTMLElement = HTMLSpanElement>(listRef: React.RefObject<HTMLElement | null>, selector: string, selected: unknown, 
+/** Off: it moves to the new item at once. */
+{ animate: motionOn }?: {
+    animate?: boolean;
+}): {
+    ref: React.RefObject<T | null>;
+    ready: boolean;
+};

package/components/sliding-indicator.js

@@ -0,0 +1,3 @@
+'use client';export { SLIDE_MS, useSlidingIndicator } from '../chunk-J3NSDRVH.js';
+//# sourceMappingURL=sliding-indicator.js.map
+//# sourceMappingURL=sliding-indicator.js.map

package/components/sliding-indicator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"sliding-indicator.js"}

package/components/streaming-text.d.ts

@@ -0,0 +1,33 @@
+import * as React from 'react';
+/**
+ * Streaming text: an agent's answer writing itself out as it arrives, in the assistant
+ * Message's type (text/default 13/19.5).
+ *
+ * Give it the text received so far and keep it growing; `streaming` while more is coming. A
+ * model sends text in uneven chunks, so the component doesn't print them as they land: it
+ * writes at an even pace (`speed`, letters a second), stops briefly after a full stop or a
+ * comma, and speeds up when it falls behind, so a backlog never takes more than about a second
+ * to catch up. A caret (2px, action/primary/bg) sits at the end while it writes.
+ *
+ * `reveal` is how each piece comes in: `blur` (default) fades every letter in from a 2px blur
+ * over 220 ms, `fade` without the blur, `word` a word at a time, `none` prints letters as they
+ * come with no motion. Only the letters arriving animate; the rest carry no filter.
+ *
+ * The whole text received is in the DOM from the start (letters not yet written are only
+ * transparent), so screen readers get it at once; the box is aria-busy while it streams.
+ * With reduced motion it shows everything received straight away.
+ */
+export interface StreamingTextProps extends Omit<React.ComponentProps<'div'>, 'children'> {
+    /** Everything received so far. Grow it as chunks arrive. */
+    text: string;
+    /** More is coming: keeps the caret and the pace going. */
+    streaming?: boolean;
+    /** Letters written a second at the even pace. */
+    speed?: number;
+    reveal?: 'blur' | 'fade' | 'word' | 'none';
+    /** The caret at the end while it writes. */
+    caret?: boolean;
+    /** Called once everything received is written and `streaming` is off. */
+    onDone?: () => void;
+}
+export declare function StreamingText({ text, streaming, speed, reveal, caret, onDone, className, ...props }: StreamingTextProps): React.JSX.Element;

package/components/streaming-text.js

@@ -0,0 +1,4 @@
+'use client';export { StreamingText } from '../chunk-RTJ76X5U.js';
+import '../chunk-H63FYCMY.js';
+//# sourceMappingURL=streaming-text.js.map
+//# sourceMappingURL=streaming-text.js.map

package/components/streaming-text.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"streaming-text.js"}

package/components/switch.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import { Switch as SwitchPrimitive } from 'radix-ui';
+/**
+ * Switch, 1:1 with the uiKit `_switchBase` (3647:17617) and `Switch` (3647:17714) sets: a
+ * 32 × 18 track (border/input off, calm green on, each with its hover), a 14px white thumb,
+ * a 2px focus ring, 50% when disabled. Label medium 13/19.5, description muted, 10px from
+ * the track. Use it for settings that apply at once; use a checkbox inside a form.
+ * The look of every state lives in styles/components.css.
+ */
+export interface SwitchProps extends React.ComponentProps<typeof SwitchPrimitive.Root> {
+    label?: React.ReactNode;
+    description?: React.ReactNode;
+    placement?: 'left' | 'right';
+}
+export declare function Switch({ className, label, description, placement, id, ...props }: SwitchProps): React.JSX.Element;

package/components/switch.js

@@ -0,0 +1,4 @@
+'use client';export { Switch } from '../chunk-SH6NG6VN.js';
+import '../chunk-H63FYCMY.js';
+//# sourceMappingURL=switch.js.map
+//# sourceMappingURL=switch.js.map

package/components/switch.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"switch.js"}

package/components/table.d.ts

@@ -0,0 +1,57 @@
+import * as React from 'react';
+/**
+ * Table, 1:1 with the uiKit `Table` set (3411:21610) and its parts: table/header (3410:17835),
+ * table/row (3410:18040), table/cell (3409:17760), table/headerCell (3409:17734) and
+ * table/checkboxCell (3409:17703). A real `<table>`.
+ *
+ * - Frame: bg/card, 1px border-subtle, radius-xl, clipped.
+ * - Header row: component/table-header fill, 1px border-subtle under it. Header cells pad
+ *   4 / 8 / 4 / 4 around a label button (8px sides, 3px top and bottom, radius-md, medium
+ *   13/18, text-muted); hover tints the button bg-hover. Sortable headers cycle
+ *   none → asc → desc with a 14px arrow 10px after the label, and set aria-sort.
+ * - Cells: 12 left, 10 right, 8 top and bottom, at least 40 high, regular 13/19.5, clipped
+ *   with an ellipsis. Chips and other nodes sit in a row 4px apart.
+ * - Checkbox column: 8px left padding, no right padding; the header box selects all.
+ * - zebra: every second row on component/table-zebra.
+ * - Row hover lifts the row: bg-hover, 1px border-strong edge, radius-xl, shadow sm.
+ * - overflow="fit": columns are proportional (`width` is an fr weight). overflow="scroll":
+ *   columns keep their pixel `width`, the first column stays in place, a 64px fade marks
+ *   the clipped edge and a 6px scrollbar (bg-muted track, border-strong thumb) sits below.
+ *
+ * The row edge is drawn with inset shadows on the cells, since table rows can't take a
+ * border radius. `data-force="hover"` on a `<tr>` shows the hover state.
+ */
+export type Sort = {
+    key: string;
+    direction: 'asc' | 'desc';
+} | null;
+export type Row = {
+    id: string;
+} & Record<string, unknown>;
+export interface Column<R extends Row = Row> {
+    key: string;
+    header: React.ReactNode;
+    /** fr weight with overflow="fit" (default 1), pixels with overflow="scroll" (default 160). */
+    width?: number;
+    sortable?: boolean;
+    /** Renders the cell; defaults to the row's value at `key`. */
+    cell?: (row: R) => React.ReactNode;
+    align?: 'left' | 'right';
+}
+export interface TableProps<R extends Row = Row> extends Omit<React.ComponentProps<'div'>, 'children'> {
+    columns: Column<R>[];
+    rows: R[];
+    selectable?: boolean;
+    zebra?: boolean;
+    overflow?: 'fit' | 'scroll';
+    /** Called with the new sort; rows are sorted by value unless `manualSort` is set. */
+    onSortChange?: (sort: Sort) => void;
+    defaultSort?: Sort;
+    /** Leave rows in the order given (sort them yourself in onSortChange). */
+    manualSort?: boolean;
+    selected?: string[];
+    onSelectedChange?: (ids: string[]) => void;
+    /** Accessible name of the table. */
+    label?: string;
+}
+export declare function Table<R extends Row = Row>({ columns, rows, selectable, zebra, overflow, onSortChange, defaultSort, manualSort, selected: selectedProp, onSelectedChange, label, className, ...props }: TableProps<R>): React.JSX.Element;

package/components/table.js

@@ -0,0 +1,5 @@
+'use client';export { Table } from '../chunk-X3PQANZO.js';
+import '../chunk-FDKIX4DC.js';
+import '../chunk-H63FYCMY.js';
+//# sourceMappingURL=table.js.map
+//# sourceMappingURL=table.js.map

package/components/table.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"table.js"}

package/components/tabs.d.ts

@@ -0,0 +1,45 @@
+import * as React from 'react';
+import { Tabs as TabsPrimitive } from 'radix-ui';
+/**
+ * Tabs, 1:1 with the uiKit `Tabs` (3635:18677) and `tabs/item` (3635:18591) sets.
+ *
+ * Underline: tabs 32px apart on a 1px border/default rule; md is 36px high with a 14px label,
+ * sm 32px with 13px. The selected tab has a 2px action/primary indicator sitting on the rule;
+ * hover shows it in border/strong. Focus draws a 1.5px border/focus ring around the label.
+ *
+ * Pill: tabs 4px apart, radius-full; md 32px high with 12px sides, sm 28px with 10px. Hover
+ * fills bg/muted, selected bg/selected, focus a 1px border/focus ring.
+ *
+ * The selected tab's indicator (the underline's 2px bar, the pill's bg/selected) is one element
+ * that slides from tab to tab under the labels, as in the Segmented control and Pagination
+ * (sliding-indicator.tsx): 300 ms, the leading edge first.
+ *
+ * Labels are text/muted, text/default on hover, focus and selected; disabled is 50%. Optional
+ * 16px leading icon, 6px from the label. Built on the Radix Tabs (arrow keys move between tabs).
+ * States answer to `data-force="hover" | "focus"` for state sheets.
+ */
+export type TabItem = string | {
+    value: string;
+    label: React.ReactNode;
+    /** 16px leading icon. */
+    icon?: React.ReactNode;
+    disabled?: boolean;
+};
+export interface TabsProps {
+    items: TabItem[];
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    variant?: 'underline' | 'pill';
+    size?: 'md' | 'sm';
+    /** Disable every tab. */
+    disabled?: boolean;
+    /** Accessible name for the tab list. */
+    'aria-label'?: string;
+    /** `TabsContent` panels, one per item value. */
+    children?: React.ReactNode;
+    className?: string;
+}
+export declare function Tabs({ items, value, defaultValue, onValueChange, variant, size, disabled, children, className, ...props }: TabsProps): React.JSX.Element;
+/** The panel for one tab value. */
+export declare function TabsContent({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.Content>): React.JSX.Element;

package/components/tabs.js

@@ -0,0 +1,5 @@
+'use client';export { Tabs, TabsContent } from '../chunk-DETGJAIC.js';
+import '../chunk-J3NSDRVH.js';
+import '../chunk-H63FYCMY.js';
+//# sourceMappingURL=tabs.js.map
+//# sourceMappingURL=tabs.js.map

package/components/tabs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"tabs.js"}

package/components/textarea.d.ts

@@ -0,0 +1,30 @@
+import * as React from 'react';
+/**
+ * Textarea, 1:1 with the uiKit `Textarea` set (3647:17812): the Input skin (surface fill,
+ * border/default, radius-lg, shadow xs; border/strong on hover, border/focus and the focus
+ * ring on focus, action/destructive/bg on error) at 96px tall with a resize grip. Above it a
+ * label (medium 13/18) with an optional "(Optional)" in muted 13; under it a hint row: the
+ * hint (muted) and, with `maxLength`, a counter (text/subtle) on the right. An error message
+ * replaces the hint and turns the whole row action/destructive/bg. Disabled is bg/muted with
+ * text/subtle and the whole field at 60%.
+ *
+ * `maxLength` drives the counter and is not enforced, so a pasted text can run over and show
+ * it (134/120); pair it with `error` to say what to fix. The look is styles/components/
+ * input.css (`.satin-field`) plus textarea.css.
+ */
+export interface TextareaProps extends Omit<React.ComponentProps<'textarea'>, 'onChange' | 'maxLength'> {
+    label?: React.ReactNode;
+    /** Adds a muted "(Optional)" after the label. */
+    optional?: boolean;
+    hint?: React.ReactNode;
+    /** An error message (replaces the hint), or `true` to mark the field invalid without one. */
+    error?: React.ReactNode | boolean;
+    /** Shows a `length/maxLength` counter. */
+    maxLength?: number;
+    onChange?: (value: string) => void;
+    /** Classes for the outer wrapper (label + field + hint row). `className` styles the field. */
+    wrapperClassName?: string;
+    /** Show a state without interacting, for state sheets. */
+    'data-force'?: 'hover' | 'focus';
+}
+export declare function Textarea({ label, optional, hint, error, maxLength, className, wrapperClassName, id, disabled, required, value, defaultValue, onChange, 'aria-describedby': ariaDescribedBy, 'data-force': force, ...props }: TextareaProps): React.JSX.Element;

package/components/textarea.js

@@ -0,0 +1,5 @@
+'use client';export { Textarea } from '../chunk-QUF2IPOZ.js';
+import '../chunk-UBNHSZSE.js';
+import '../chunk-H63FYCMY.js';
+//# sourceMappingURL=textarea.js.map
+//# sourceMappingURL=textarea.js.map

package/components/textarea.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"textarea.js"}

package/components/thinking.d.ts

@@ -0,0 +1,64 @@
+import * as React from 'react';
+import { type AgentLoadingIndicator } from './agent-loading';
+/**
+ * Thinking, 1:1 with the uiKit `Thinking` set (3239:20908) and its parts thinking/header
+ * (3239:20766), thinking/step (3239:20791) and thinking/_mark (3239:20674).
+ *
+ * What an agent did, once it is done; while it works, AgentLoading (agent-loading.tsx) shows
+ * instead. collapsed: the mark at rest (the full tetris board, or the flappy bird), summary
+ * and a 14px chevron. expanded: the same header with the chevron turned up, then 8px down a body
+ * with 4px left inset: a 16px rail (1px line, rail-edge → rail-center → rail-edge) and, 12px
+ * on, the steps 8px apart.
+ *
+ * The header is a button (click, Enter, Space) that opens and folds the body with the
+ * Accordion's motion; the folded body stays mounted but leaves tab order and screen readers.
+ * `state` sets the starting state and follows later changes, `onToggle` reports them.
+ */
+export type ThinkingStep = 
+/** A finished action: green check, label, muted meta that truncates. */
+{
+    type?: 'task';
+    label: React.ReactNode;
+    meta?: React.ReactNode;
+}
+/** A thought, wrapping in text/muted. */
+ | {
+    type: 'text';
+    text: React.ReactNode;
+}
+/** A page that was read: 16px favicon, title, muted meta. */
+ | {
+    type: 'source';
+    icon?: React.ReactNode;
+    label: React.ReactNode;
+    meta?: React.ReactNode;
+}
+/** A dev tool call: icon (pencil by default), name, mono target, +added −removed, meta. */
+ | {
+    type: 'tool';
+    icon?: React.ReactNode;
+    label: React.ReactNode;
+    target?: React.ReactNode;
+    added?: React.ReactNode;
+    removed?: React.ReactNode;
+    meta?: React.ReactNode;
+}
+/** The rest, folded: "+5 more". */
+ | {
+    type: 'more';
+    label: React.ReactNode;
+};
+export type ThinkingState = 'collapsed' | 'expanded';
+/** The mark beside the summary, matching the AgentLoading that ran before it. */
+export type ThinkingIndicator = AgentLoadingIndicator;
+export interface ThinkingProps extends Omit<React.ComponentProps<'div'>, 'onToggle'> {
+    /** collapsed once the agent is done, expanded when people open it. */
+    state?: ThinkingState;
+    /** The summary, e.g. "Thought for 2m 45s". */
+    label?: React.ReactNode;
+    steps?: ThinkingStep[];
+    /** The mark beside the summary. */
+    indicator?: ThinkingIndicator;
+    onToggle?: (open: boolean) => void;
+}
+export declare function Thinking({ state, label, steps, indicator, onToggle, className, ...props }: ThinkingProps): React.JSX.Element;

package/components/thinking.js

@@ -0,0 +1,5 @@
+'use client';export { Thinking } from '../chunk-ESC5JCVQ.js';
+import '../chunk-KNUWZNFV.js';
+import '../chunk-H63FYCMY.js';
+//# sourceMappingURL=thinking.js.map
+//# sourceMappingURL=thinking.js.map

package/components/thinking.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"thinking.js"}

package/components/toast.d.ts

@@ -0,0 +1,71 @@
+import * as React from 'react';
+import { Toast as ToastPrimitive } from 'radix-ui';
+/**
+ * Toast, 1:1 with the uiKit `Toast` set (3650:17696): intent neutral, info, success, warning or
+ * error. A 397px popover surface, radius-xl, border/default, the shadcn `lg` shadow, padding
+ * 10 left / 8 right and 10 top and bottom (12 at the bottom on the four status intents, as in
+ * Figma). A 36px radius-md icon tile in the intent's status bg, a 13px medium title (20px line)
+ * over a 13px muted description (16px line), then an optional secondary action and a 24px close.
+ *
+ * Built on the Radix Toast. Render one `<Toaster />` near the root and call `toast()` anywhere:
+ *   toast.success('Booking confirmed', { description: 'Table for 4…', action: { label: 'Undo' } })
+ *
+ * The Toaster stacks them bottom-right, newest in front. Behind it, the next ones peek 16px above,
+ * each 5% smaller, cut to the front one's height with their content faded out, so the stack is
+ * even; three show at most and the rest wait, parked in the last place. Hovering or focusing the
+ * stack unfolds it, one under another 8px apart at their own heights, every toast readable, and
+ * pauses their timers.
+ *
+ * Toasts move as whole cards and never fade on the way: a new one slides up from below the
+ * stack (150% of its height), a closed one slides back down the same way, and the rest move to
+ * their new places at the same time. Every move is one transform on one element, 500 ms on the
+ * kit's ease-out, so a toast added or closed mid-move just carries on from where it is. The
+ * cut to the front one's height eases over 150 ms, the content fade over 250 ms.
+ */
+export type ToastIntent = 'neutral' | 'info' | 'success' | 'warning' | 'error';
+export interface ToastAction {
+    label: string;
+    onClick?: () => void;
+}
+export interface ToastOptions {
+    description?: React.ReactNode;
+    intent?: ToastIntent;
+    action?: ToastAction;
+    /** The small close button on the right. */
+    closeButton?: boolean;
+    /** The status icon tile on the left. */
+    icon?: boolean;
+    /** Milliseconds before it closes by itself. `Infinity` keeps it until dismissed. */
+    duration?: number;
+    id?: string;
+}
+type Shortcut = (title: React.ReactNode, options?: Omit<ToastOptions, 'intent'>) => string;
+/** Show a toast. Returns its id, which `toast.dismiss(id)` takes. */
+export declare const toast: ((title: React.ReactNode, options?: ToastOptions) => string) & {
+    info: Shortcut;
+    success: Shortcut;
+    warning: Shortcut;
+    error: Shortcut;
+    /** Close one toast, or all of them. */
+    dismiss: (id?: string) => void;
+};
+export interface ToastProps extends Omit<React.ComponentProps<typeof ToastPrimitive.Root>, 'title'> {
+    title: React.ReactNode;
+    description?: React.ReactNode;
+    intent?: ToastIntent;
+    action?: ToastAction;
+    closeButton?: boolean;
+    icon?: boolean;
+}
+/** A single toast on its own. Lives inside `<Toaster>` (it needs the Radix toast provider). */
+export declare function Toast({ title, description, intent, action, closeButton, icon, duration, className, ...props }: ToastProps): React.JSX.Element;
+export interface ToasterProps {
+    /** Classes for the viewport; `absolute` instead of `fixed` keeps it inside a positioned parent. */
+    className?: string;
+    /** Most toasts on screen at once; the rest wait behind. */
+    limit?: number;
+    /** Your own controlled `<Toast>`s, rendered alongside the ones from `toast()`. */
+    children?: React.ReactNode;
+}
+export declare function Toaster({ className, limit, children }: ToasterProps): React.JSX.Element;
+export {};

package/components/toast.js

@@ -0,0 +1,5 @@
+'use client';export { Toast, Toaster, toast } from '../chunk-2HKBZFIK.js';
+import '../chunk-HNQUX43Z.js';
+import '../chunk-H63FYCMY.js';
+//# sourceMappingURL=toast.js.map
+//# sourceMappingURL=toast.js.map

package/components/toast.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"toast.js"}

package/components/toggle.d.ts

@@ -0,0 +1,30 @@
+import * as React from 'react';
+import { Toggle as TogglePrimitive } from 'radix-ui';
+import { type VariantProps } from 'class-variance-authority';
+/**
+ * Toggle, 1:1 with the uiKit `Toggle` set (852:21771): a button that stays pressed. Two
+ * variants, outline (bg/popover, border/default, radius-lg) and ghost (no fill, radius-md),
+ * two sizes, md 32 (14/21) and sm 28 (13/18), 10px side padding, a 16px icon 8px from the
+ * label, and a square icon-only form.
+ *
+ * At rest the label and icon are text/muted. Hover: bg/muted (outline adds border/strong).
+ * Focus: an action/primary border, plus the 2px focus ring on outline. Pressed:
+ * action/secondary/bg-pressed (outline with border/strong), text/default; pressed + focus
+ * adds the ring on both. Disabled: text/subtle, outline on bg/muted. Ghost rounds to radius-lg
+ * whenever it is hovered, focused or pressed, as in Figma.
+ *
+ * States use satin-hover / satin-focus (or data-force), pressed is Radix's data-state="on".
+ */
+declare const toggleVariants: (props?: ({
+    variant?: "ghost" | "outline" | null | undefined;
+    size?: "md" | "sm" | null | undefined;
+    iconOnly?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface ToggleProps extends React.ComponentProps<typeof TogglePrimitive.Root>, VariantProps<typeof toggleVariants> {
+    /** A 16px icon before the label, or the only content when `iconOnly` (then pass an aria-label). */
+    icon?: React.ReactNode;
+    /** Show a state without interacting, for state sheets. */
+    'data-force'?: 'hover' | 'focus';
+}
+export declare function Toggle({ className, variant, size, iconOnly, icon, children, ...props }: ToggleProps): React.JSX.Element;
+export { toggleVariants };

package/components/toggle.js

@@ -0,0 +1,4 @@
+'use client';export { Toggle, toggleVariants } from '../chunk-UC3ZJWOD.js';
+import '../chunk-H63FYCMY.js';
+//# sourceMappingURL=toggle.js.map
+//# sourceMappingURL=toggle.js.map

package/components/toggle.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"toggle.js"}