@kitn.ai/ui 0.26.0 → 0.27.0

package/dist/react/index.d.ts

@@ -92,7 +92,7 @@ export interface ArtifactProps extends WebComponentProps {
 }
 export declare const Artifact: import('react').ForwardRefExoticComponent<ArtifactProps & import('react').RefAttributes<HTMLElement>>;
 export interface AttachmentsProps extends WebComponentProps {
-    /** The attachments to render. Omit (or pass an empty array) for the empty state, which shows `emptyText` if set and nothing otherwise. Set as a JS property (array). */
+    /** The attachments to render. Omit (or pass an empty array) for the empty state, which shows `emptyText` if set and nothing otherwise. Set as a JS property (array). Each item's `url` must be a `data:` URI or an https URL, never `URL.createObjectURL`: a `blob:` URL previews here but the wire encoders (`toOpenAIMessages`/`toAnthropicMessages`) refuse it. */
     items?: {
         id: string;
         type: "file" | "source-document";
@@ -255,17 +255,17 @@ export interface CardsProps extends WebComponentProps {
     schemas?: Record<string, object>;
     /** Optional CardPolicy handling child events. Property: `el.policy`. */
     policy?: {
-        onSubmit?: (cardId: string, data: unknown) => void;
-        onAction?: (cardId: string, action: string, payload?: unknown) => void;
-        onSendPrompt?: (text: string, opts: {
+        onSubmit?: ((cardId: string, data: unknown) => void);
+        onAction?: ((cardId: string, action: string, payload?: unknown) => void);
+        onSendPrompt?: ((text: string, opts: {
             mode: "compose" | "send";
             context?: unknown;
-        }) => void;
-        onOpen?: (url: string, target: "tab" | "artifact") => void;
-        onState?: (cardId: string, patch: unknown) => void;
-        onDismiss?: (cardId: string) => void;
-        onReopen?: (cardId: string) => void;
-        onError?: (cardId: string, message: string) => void;
+        }) => void);
+        onOpen?: ((url: string, target: "tab" | "artifact") => void);
+        onState?: ((cardId: string, patch: unknown) => void);
+        onDismiss?: ((cardId: string) => void);
+        onReopen?: ((cardId: string) => void);
+        onError?: ((cardId: string, message: string) => void);
         maxSendPromptMode?: "compose" | "send";
     };
     /** Validate each envelope's `data` against the schema for its type before rendering it, using a built-in's own schema or yours from `schemas`. Default `true`; set `validate-cards="false"` (or `el.validateCards = false`) to opt out. A hard failure (wrong type, a missing required field) renders a diagnostic naming the field instead of the card; a soft failure (bounds) renders the card unchanged. Both emit a contract `error` event. On in production too: a model emitting a bad shape is a production failure mode, so stripping the check there would hide it from exactly the person who needs to see it. */
@@ -344,6 +344,10 @@ export interface ChatProps extends WebComponentProps {
     codeTheme?: string;
     /** Enable Shiki syntax highlighting in code blocks. Turn off to render plain `<pre>` blocks (lighter, no highlighter load). Default true. */
     codeHighlight?: boolean;
+    /** How `reasoning` parts render across the thread. `'full'` (default) is the current collapsible-disclosure behavior; `'compact'` shows only a shimmer loader while a reasoning part streams and nothing once it settles (no expandable detail); `'off'` renders reasoning parts not at all. Forwarded to every `MessageBody` as `reasoningMode`. */
+    reasoning?: "full" | "compact" | "off";
+    /** Seeds the reasoning disclosure open AND keeps it tracking the stream (open while streaming, closes when it settles): the pre-Task-19f `full` behavior. Default false/absent: the panel starts closed (just the "Thinking" shimmer chip) and only opens on click, the current default (owner ruling, 2026-08-26). Meaningless when `reasoning` is `'compact'` or `'off'`. Forwarded to every `MessageBody` as `reasoningDefaultOpen`. */
+    reasoningOpen?: boolean;
     /** Optional header title shown on the left of the header. */
     chatTitle?: string;
     /** Optional model list. When set (>1 model) a ModelSwitcher is shown in the header and a `kai-model-change` event fires on selection. */
@@ -382,6 +386,8 @@ export interface ChatProps extends WebComponentProps {
     composerActions?: boolean;
     /** INJECT: footer row below the composer (disclaimers, token meter, …). */
     footer?: boolean;
+    /** When `false`, hides the built-in paperclip attach button. Defaults to `true` (undeclared keeps today's behavior: attach visible), matching `DefaultPromptInput`'s own default: only an explicit `false` hides it. */
+    attach?: boolean;
     /** Show a web-search (Globe) button in the input toolbar; calls `onWebSearch`. */
     webSearch?: boolean;
     /** Show a Voice (Mic) button in the input toolbar; fires a `voice` event. */
@@ -578,6 +584,52 @@ export interface ChatProps extends WebComponentProps {
     onWebSearch?: (event: CustomEvent<Record<string, never>>) => void;
 }
 export declare const Chat: import('react').ForwardRefExoticComponent<ChatProps & import('react').RefAttributes<HTMLElement>>;
+export interface CheckboxProps extends WebComponentProps {
+    /** Controlled checked state. Settable and reflected to the `checked` attribute. `el.checked = true` (or `<kai-checkbox checked>`) drives it; ticking the box updates it and fires `kai-change`. Read `el.checked` for live state. */
+    checked?: boolean;
+    /** Initial checked state on mount (uncontrolled seed). Bare attribute (`<kai-checkbox default-checked>`) turns it on. */
+    defaultChecked?: boolean;
+    /** The mixed state, for a parent box whose children are partly ticked. Visual plus an accessibility hint: the box still reports `checked === false`. */
+    indeterminate?: boolean;
+    /** Disable interaction. */
+    disabled?: boolean;
+    /** Set the native `required` attribute, and nothing more. Whether an unticked box is an error is the application's rule, not the kit's. */
+    required?: boolean;
+    /** Accessible label. The visible text beside the box is the consumer's to render. */
+    label?: string;
+    /** Form-control name (paired with `value`). */
+    name?: string;
+    /** Submitted value when checked (paired with `name`). Defaults to `'on'`. */
+    value?: string;
+    /** The box was ticked or unticked. */
+    onChange?: (event: CustomEvent<{
+        checked: boolean;
+    }>) => void;
+}
+export declare const Checkbox: import('react').ForwardRefExoticComponent<CheckboxProps & import('react').RefAttributes<HTMLElement>>;
+export interface CheckboxGroupProps extends WebComponentProps {
+    /** The choices, top to bottom. Set as a JS PROPERTY (array), never an attribute. Rendered in full: the kit never truncates, re-orders or de-duplicates them. */
+    options: {
+        value: string;
+        label: string;
+        description?: undefined | string;
+        disabled?: undefined | boolean;
+    }[];
+    /** The FIRST selected value. Settable and reflected to the `value` attribute, so `:host([value])` and `el.value` see live state, and a seed can be written in markup. Writing it makes that the whole selection; to read or drive the rest, use `el.values`. */
+    value?: string;
+    /** The shared form-control name every box carries, so `FormData.getAll(name)` reads the whole selection back under one key. NO DEFAULT, unlike `<kai-radio-group>`. A radio set needs a shared `name` for the browser to make it exclusive and arrow-navigable, so one is generated when none is given; checkboxes are independent controls and behave correctly with no name at all. Generating one here would submit the selection under a random key, which is worse than submitting nothing. The element is NOT form-associated (no `ElementInternals`, no `setFormValue()`), the same known gap `<kai-input>` records: the boxes live in a shadow root, so a surrounding `<form>` collects nothing from them whether or not `name` is set. Read `el.values`. The name still lands on every inner input, so it is right the day form association arrives. */
+    name?: string;
+    /** Disable every row. Individual rows carry their own `disabled`. */
+    disabled?: boolean;
+    /** Accessible name for the group. */
+    label?: string;
+    /** A row was ticked or unticked. `values` is the whole selection after the change, which is what a multi-select control needs; `value` is the first of them (empty when nothing is selected). Both are always present, so neither shape silently loses the other. This is `<kai-select>`'s detail, deliberately. */
+    onChange?: (event: CustomEvent<{
+        value: string;
+        values: string[];
+    }>) => void;
+}
+export declare const CheckboxGroup: import('react').ForwardRefExoticComponent<CheckboxGroupProps & import('react').RefAttributes<HTMLElement>>;
 export interface CheckpointProps extends WebComponentProps {
     /** Optional text beside the icon. */
     label?: string;
@@ -811,7 +863,7 @@ export interface ComposerProps extends WebComponentProps {
     onFocus?: (event: CustomEvent<{
         originalEvent: FocusEvent;
     }>) => void;
-    /** The user submitted the composer (Enter or programmatic submit). */
+    /** The user submitted the composer (Enter or programmatic submit). Note the detail carries no `attachments`; `<kai-composer>` is the bare editing surface: no send button, toolbar, or attachments. For a drop-in composer row with all three, reach for `<kai-prompt-input>`, which is built on this. */
     onSubmit?: (event: CustomEvent<{
         doc: ({
             type: "text";
@@ -920,12 +972,16 @@ export interface ContextProps extends WebComponentProps {
 }
 export declare const Context: import('react').ForwardRefExoticComponent<ContextProps & import('react').RefAttributes<HTMLElement>>;
 export interface ConversationItemProps extends WebComponentProps {
-    /** The row's identity, handed to the container's selection contract. In the element this is the `conversation-id` attribute (host `id` is the fallback). */
+    /** The row's identity: the `conversation-id` attribute (host `id` is the fallback). Inside `<kai-conversations>` it is handed to the container's selection contract (`kai-conversation-select`); standalone it is the `id` in this element's own `kai-select` detail. */
     conversationId?: string;
-    /** Selected state. Reflected as `aria-current` on the row body and a `data-active` styling hook on the row; the container drives it from its `activeId`. */
+    /** Selected state. Reflected as `aria-current` on the row body and a `data-active` styling hook on the row; inside a container the container drives it from its `activeId`, standalone you set it yourself. */
     active?: boolean;
     /** Dense single-line row padding. */
     compact?: boolean;
+    /** STANDALONE activation only: the row was activated (click, Enter or Space on its body) while the item is NOT a direct child of `<kai-conversations>`. `id` is the row's identity: the `conversation-id` attribute, else the host `id`. Inside a container this never fires: activation surfaces once, as `kai-conversation-select` on the container. */
+    onSelect?: (event: CustomEvent<{
+        id: string;
+    }>) => void;
 }
 export declare const ConversationItem: import('react').ForwardRefExoticComponent<ConversationItemProps & import('react').RefAttributes<HTMLElement>>;
 export interface ConversationsProps extends WebComponentProps {
@@ -1017,6 +1073,8 @@ export interface DockProps extends WebComponentProps {
     unread?: boolean;
     /** Disable the launcher; `show()` and `toggle()` are gated on it. */
     disabled?: boolean;
+    /** Suppress the dock's own built-in mobile close X. Set this when your slotted panel content supplies its own close affordance (e.g. a `<kai-chat slot="header-end">` close button), otherwise the two stack. TRADEOFF: the mobile panel reserves a padding band above its content so the built-in X never paints over slotted content; that band stays reserved unless you set this true, so only set it once your own control is actually in place. Attribute: `hide-close`. */
+    hideClose?: boolean;
     /** Where focus lands on open: `content` (default, the first element you slotted), `panel`, or `none`. Attribute: `focus-on-open`. */
     focusOnOpen?: "content" | "panel" | "none";
     /** The dock opened or closed (the launcher, Escape, a driven `open`, or a method). */
@@ -1185,6 +1243,9 @@ export interface FormProps extends WebComponentProps {
             "x-kai-widget"?: "textarea" | "slider" | "rating" | "radio" | "select" | "checkbox" | "password" | "switch";
             "x-kai-placeholder"?: string;
             "x-kai-step"?: number;
+            "x-kai-format"?: "tel" | "ssn" | "credit-card" | "custom";
+            "x-kai-mask"?: string;
+            "x-kai-mask-guide"?: string;
         }>;
         "x-kai-order"?: string[];
         "x-kai-inlineMax"?: number;
@@ -1255,7 +1316,7 @@ export declare const Image: import('react').ForwardRefExoticComponent<ImageProps
 export interface InputProps extends WebComponentProps {
     /** Native input type: `text` (default) · `email` · `url` · `search` · `tel` · `password` · `number`. Single-line only. */
     type?: string;
-    /** Controlled value. Settable and reflected to the `value` attribute. `el.value = 'hi'` drives it (no event); typing updates it and fires `kai-input`. Read `el.value` for live state. */
+    /** Controlled value, and always the CANONICAL one when a mask is active: digits for `tel` / `ssn` / `credit-card`, the formatted text for `custom`. Settable and reflected to the `value` attribute. `el.value = '5551234567'` drives it (no event) and is re-fitted to the mask on the way in, so the field shows `555-123-4567`. Read `el.value` for live state; the formatted text rides along on every `kai-input` / `kai-change` detail as `formattedValue`. */
     value?: string;
     /** Placeholder shown when empty. */
     placeholder?: string;
@@ -1281,13 +1342,30 @@ export interface InputProps extends WebComponentProps {
     autocomplete?: string;
     /** Virtual-keyboard hint forwarded to the inner input (e.g. `numeric`, `email`). */
     inputmode?: string;
-    /** The value was committed (blur). */
+    /** Mask pattern: `#` a digit, `@` a letter or digit, `*` an obscurable letter or digit, and every other character a positional literal (`@@@-####` → `CHG-4821`). The literal `default` is the opt-in sentinel: it resolves to the default format of `semantic` (`tel` → `###-###-####`). A bare `semantic` never starts masking on its own, so an opt-in token is what turns tier 2 on. */
+    format?: string;
+    /** Placeholder guide shown at unfilled positions, aligned position for position with `format`: `mm/dd/yyyy` against `##/##/####`. Spaces are a valid guide character, so a guide of blanks and separators is how a phone field shows its shape without showing letters. Without a guide the field shows only up to the last typed character. A guide is a visual aid, never an accessible name: keep the `hint` text as well. */
+    guide?: string;
+    /** Semantic field type: `tel` · `ssn` · `credit-card` · `custom`. On its own it sets `inputmode` / `autocomplete` / `spellcheck` / `autocorrect` / `autocapitalize` and decides the canonical value; it never starts masking by itself. */
+    semantic?: "credit-card" | "custom" | "ssn" | "tel";
+    /** Case folding applied to typed and pasted text: `preserve` (default) · `upper` · `lower`. Attribute: `case-mode`. */
+    caseMode?: "preserve" | "upper" | "lower";
+    /** What a copy or cut of a masked field puts on the clipboard: `canonical` (default) · `formatted` · `obscured` · `blocked`. Attribute: `copy-policy`. */
+    copyPolicy?: "formatted" | "canonical" | "obscured" | "blocked";
+    /** The value was committed (blur). Same detail shape as `kai-input`. */
     onChange?: (event: CustomEvent<{
         value: string;
+        formattedValue: string;
     }>) => void;
-    /** The value changed per keystroke. */
+    /** The value changed per keystroke. `value` is the canonical value (what a backend wants); `formattedValue` is the text on screen. With no mask the two are equal. */
     onInput?: (event: CustomEvent<{
         value: string;
+        formattedValue: string;
+    }>) => void;
+    /** A mask refused, or partly refused, some content. The reasons are `full` (no free position left), `wrong-class` (a letter into a digit position), `over-capacity` (a paste longer than the mask holds; what fits was kept), and `format-change-clipped` (the `format` changed under a value that no longer fits). `data` is the content that was refused. The first three are USER-INPUT errors, and are the ones worth announcing in a polite live region. `format-change-clipped` is not one: it follows the app changing its own configuration, so it reports and nothing more. None of the four touches validity, so `invalid` and `error` stay the consumer decision. */
+    onInputRejected?: (event: CustomEvent<{
+        reason: "full" | "wrong-class" | "over-capacity" | "format-change-clipped";
+        data: string;
     }>) => void;
 }
 export declare const Input: import('react').ForwardRefExoticComponent<InputProps & import('react').RefAttributes<HTMLElement>>;
@@ -1638,6 +1716,19 @@ export interface PaneProps extends WebComponentProps {
     onSplit?: (event: CustomEvent) => void;
 }
 export declare const Pane: import('react').ForwardRefExoticComponent<PaneProps & import('react').RefAttributes<HTMLElement>>;
+export interface PaneGridProps extends WebComponentProps {
+    /** Minimum width of every pane, in px, before columns drop / the grid scrolls. Defaults to `280`. Attribute: `min-pane-width`. */
+    minPaneWidth?: number;
+    /** Minimum height of every pane, in px, before the grid scrolls vertically. Defaults to `200`. Attribute: `min-pane-height`. */
+    minPaneHeight?: number;
+    /** Column cap when the container is wide (default `3`). Attribute: `max-columns`. */
+    maxColumns?: number;
+    /** Gap between panes, any CSS length. Defaults to the kit gap (`var(--kai-pane-grid-gap, 0.5rem)`). Attribute: `gap`. */
+    gap?: string;
+    /** When set to a valid child index, render ONLY that pane full-bleed: a simple maximize hook the consumer drives (pair it with `<kai-pane>`'s `kai-maximize` event). Clear it (or point out of range) for the full tiled grid. Attribute: `maximized-index`. */
+    maximizedIndex?: number | null;
+}
+export declare const PaneGrid: import('react').ForwardRefExoticComponent<PaneGridProps & import('react').RefAttributes<HTMLElement>>;
 export interface PaneGroupProps extends WebComponentProps {
     /** The tabs to render. An array of `{ id, name, status?, needsAttention?, number? }` set as a JS PROPERTY (not an HTML attribute). */
     tabs?: {
@@ -1740,7 +1831,7 @@ export interface PromptInputProps extends WebComponentProps {
     submit?: "always" | "auto";
     /** When `false`, hides the built-in paperclip attach button even though the element otherwise supports attachments. Use this when a `+` menu in `toolbar-start` already exposes "Add files", to avoid a duplicate control. Defaults to `true`. */
     attach?: boolean;
-    /** Attachments to seed the input with (so a consumer can pre-populate staged files without an upload). Set as a JS property; the element then manages its own attachment state from there (add via the paperclip, remove per chip). */
+    /** Attachments to seed the input with (so a consumer can pre-populate staged files without an upload). Set as a JS property; the element then manages its own attachment state from there (add via the paperclip, remove per chip). Each item's `url` must be a `data:` URI or an https URL, never `URL.createObjectURL`: a `blob:` URL previews perfectly and is meaningless outside this tab, so `toOpenAIMessages`/`toAnthropicMessages` refuse it. (The built-in paperclip already stages files as `data:` URIs.) */
     attachments?: {
         id: string;
         type: "file" | "source-document";
@@ -1779,7 +1870,7 @@ export interface PromptInputProps extends WebComponentProps {
     }>) => void;
     /** The Stop button was clicked while `stoppable` and `loading` are both true. */
     onStop?: (event: CustomEvent<Record<string, never>>) => void;
-    /** The user submitted the prompt (Enter or send button). `value` is the flattened text (back-compat); `doc` is the structured document and `entities` the inserted pills (skills/agents) for downstream expansion. */
+    /** The user submitted the prompt (Enter or send button). `value` is the flattened text (back-compat); `doc` is the structured document and `entities` the inserted pills (skills/agents) for downstream expansion. `<kai-prompt-input>` is the batteries-included composer row (send button, toolbar, attachment staging) built on `<kai-composer>`, the bare editor. */
     onSubmit?: (event: CustomEvent<{
         value: string;
         doc: ({
@@ -1853,6 +1944,28 @@ export interface PromptInputProps extends WebComponentProps {
     onWebSearch?: (event: CustomEvent<Record<string, never>>) => void;
 }
 export declare const PromptInput: import('react').ForwardRefExoticComponent<PromptInputProps & import('react').RefAttributes<HTMLElement>>;
+export interface RadioGroupProps extends WebComponentProps {
+    /** The choices, top to bottom. Set as a JS PROPERTY (array), never an attribute. */
+    options: {
+        value: string;
+        label: string;
+        description?: undefined | string;
+        disabled?: undefined | boolean;
+    }[];
+    /** Controlled selected `value`. Settable and reflected to the `value` attribute. `el.value = 'degraded'` drives it; choosing a row updates it and fires `kai-change`. Read `el.value` for live state. */
+    value?: string;
+    /** Shared form-control name for every radio in the group. Defaults to a generated id, so the group is exclusive and keyboard-navigable even when nothing is submitted. */
+    name?: string;
+    /** Disable every row. Individual rows carry their own `disabled`. */
+    disabled?: boolean;
+    /** Accessible name for the group. */
+    label?: string;
+    /** A row was chosen. */
+    onChange?: (event: CustomEvent<{
+        value: string;
+    }>) => void;
+}
+export declare const RadioGroup: import('react').ForwardRefExoticComponent<RadioGroupProps & import('react').RefAttributes<HTMLElement>>;
 export interface ReasoningProps extends WebComponentProps {
     /** The reasoning text to display. */
     text: string;
@@ -2000,6 +2113,10 @@ export interface ScrollButtonProps extends WebComponentProps {
     variant?: "outline" | "ghost" | "default";
     /** Button size token. Defaults to `'icon'` (square). */
     size?: "sm" | "md" | "lg" | "icon" | "icon-sm";
+    /** The button's accessible name. It is announced whether or not the label is visible, so the text is always localisable. Defaults to `'Scroll to bottom'`. */
+    label?: string;
+    /** Also render `label` visibly beside the icon. Defaults to `false`, which is the icon-only button. When the text is visible it IS the accessible name, so nothing gets announced twice. */
+    showLabel?: boolean;
     /** Emitted when the user clicks the button and `scrollToBottom()` is called. Carries no detail; consumers use it to know a manual scroll occurred. */
     onScroll?: (event: CustomEvent) => void;
 }
@@ -2048,6 +2165,36 @@ export interface SegmentedProps extends WebComponentProps {
     }>) => void;
 }
 export declare const Segmented: import('react').ForwardRefExoticComponent<SegmentedProps & import('react').RefAttributes<HTMLElement>>;
+export interface SelectProps extends WebComponentProps {
+    /** The choices, in display order. Set as a JS PROPERTY (array), never an attribute. Rendered in full: the kit never truncates, re-orders or de-duplicates them. */
+    options: {
+        value: string;
+        label?: undefined | string;
+        disabled?: undefined | boolean;
+    }[];
+    /** Controlled selected value. Settable and reflected to the `value` attribute. `el.value = 'high'` drives it; choosing an option updates it and fires `kai-change`. Read `el.value` for live state; for a `multiple` select read `el.values` instead. */
+    value?: string;
+    /** Text for a leading, disabled, empty option: the "nothing chosen yet" row. Omitted means no such row at all; there is no default wording, because inventing one would put words in your UI. */
+    placeholder?: string;
+    /** Allow more than one selection. Turns the control into the platform's list box, so the kit's chevron is not drawn. */
+    multiple?: boolean;
+    /** Force the invalid (destructive-border) state. */
+    invalid?: boolean;
+    /** Disable interaction. */
+    disabled?: boolean;
+    /** Set the native `required` attribute, and nothing more. Whether an empty select is an error is the application's rule, not the kit's. */
+    required?: boolean;
+    /** Accessible label for the control. */
+    label?: string;
+    /** Form-control name, for a native form submit. */
+    name?: string;
+    /** A choice was made. `value` is the first selected option (empty when nothing is selected); `values` is every selected option, which is what a `multiple` select needs. Both are always present, so neither shape silently loses the other. */
+    onChange?: (event: CustomEvent<{
+        value: string;
+        values: string[];
+    }>) => void;
+}
+export declare const Select: import('react').ForwardRefExoticComponent<SelectProps & import('react').RefAttributes<HTMLElement>>;
 export interface SeparatorProps extends WebComponentProps {
     /** `horizontal` (default, block + full-width) or `vertical` (a rule inside a flex/grid row, stretching to the row height). */
     orientation?: "horizontal" | "vertical";
@@ -2086,6 +2233,33 @@ export interface SkillsProps extends WebComponentProps {
     }[];
 }
 export declare const Skills: import('react').ForwardRefExoticComponent<SkillsProps & import('react').RefAttributes<HTMLElement>>;
+export interface SliderProps extends WebComponentProps {
+    /** Lowest selectable value. Required: a range with no bounds is a guess, and the guess belongs to whoever knows what the number means. */
+    min?: number;
+    /** Highest selectable value. Required, for the same reason as `min`. */
+    max?: number;
+    /** Granularity. Omitted means the native default of 1; `any` means continuous. */
+    step?: number | "any";
+    /** Controlled value. Settable and reflected to the `value` attribute. `el.value = 40` drives it; dragging updates it and fires `kai-input` per step, `kai-change` on release. Read `el.value` for live state. */
+    value?: number;
+    /** Disable interaction. */
+    disabled?: boolean;
+    /** Accessible label for the slider. */
+    label?: string;
+    /** Form-control name, for a native form submit. */
+    name?: string;
+    /** Show the current value beside the track. Off by default. Two ways in, because one of them is not a scalar. As a bare ATTRIBUTE (`<kai-slider value-label>`) it renders the raw number. As a JS PROPERTY it also accepts a formatter function (`el.valueLabel = (v) => v + '%'`), for a slider that is not counting bare numbers. A function cannot survive an attribute, so that half is property-only. The readout is hidden from assistive tech: the slider already reports the same number, and an exposed copy would be announced twice. */
+    valueLabel?: boolean | ((value: number) => string);
+    /** The value was committed: pointer released, or a key press finished. */
+    onChange?: (event: CustomEvent<{
+        value: number;
+    }>) => void;
+    /** The thumb moved. Fires per step during a drag or a key press. */
+    onInput?: (event: CustomEvent<{
+        value: number;
+    }>) => void;
+}
+export declare const Slider: import('react').ForwardRefExoticComponent<SliderProps & import('react').RefAttributes<HTMLElement>>;
 export interface SourceProps extends WebComponentProps {
     /** The URL this citation links to (the domain also seeds the default label/favicon). */
     href?: string;
@@ -2392,7 +2566,7 @@ export interface ThreadProps extends WebComponentProps {
 }
 export declare const Thread: import('react').ForwardRefExoticComponent<ThreadProps & import('react').RefAttributes<HTMLElement>>;
 export interface ToastRegionProps extends WebComponentProps {
-    /** The toasts to render. Newest is shown on top. Set as a JS property (array); pass a new array reference to update. Omit for an empty region, which is the normal resting state and how the imperative `toast()` API starts. */
+    /** The toasts to render. Newest is shown on top. Set as a JS property (array); pass a new array reference to update. Omit for an empty region, which is the normal resting state and how the imperative `toast()` API starts. Note the handover: the first `toast()` call ADOPTS a region you placed in markup (no second region mounts) and binds the imperative store to this property, replacing any array you set. Drive a region as data OR via `toast()`, not both at once. */
     toasts?: {
         id: string;
         message: string;