@bysages/solid 0.0.0 → 0.1.1

package/dist/index.d.mts

@@ -1,35 +1,40 @@
 import { Accordion as Accordion$1 } from "@ark-ui/solid/accordion";
-import { Component, JSX as JSX$1 } from "solid-js";
-import { Collapsible as Collapsible$1 } from "@ark-ui/solid/collapsible";
+import { Accessor, Component, JSX as JSX$1 } from "solid-js";
 import { Field as Field$1 } from "@ark-ui/solid/field";
+import { Collapsible as Collapsible$1 } from "@ark-ui/solid/collapsible";
 import { AngleSlider as AngleSlider$1 } from "@ark-ui/solid/angle-slider";
+import { CollectionItem, CollectionOptions, FilePathTreeNode, FlatTreeNode, GridCollection, GridCollectionOptions, ListCollection, TreeCollection, TreeCollectionOptions, TreeNode, UseAsyncListProps, UseAsyncListReturn, UseListCollectionProps, UseListCollectionReturn, UseListSelectionProps, UseListSelectionReturn, createFileTreeCollection, createGridCollection, createTreeCollection, useAsyncList, useListCollection, useListSelection } from "@ark-ui/solid/collection";
+import { Combobox as Combobox$1 } from "@ark-ui/solid/combobox";
 import { Avatar as Avatar$1 } from "@ark-ui/solid/avatar";
 import { DatePicker as DatePicker$1, DatePickerFocusChangeDetails, DatePickerOpenChangeDetails, DatePickerRootProps, DatePickerValueChangeDetails, DatePickerViewChangeDetails, DatePickerVisibleRangeChangeDetails } from "@ark-ui/solid/date-picker";
 import { Carousel as Carousel$1 } from "@ark-ui/solid/carousel";
 import { Checkbox as Checkbox$1 } from "@ark-ui/solid/checkbox";
+import { ClientOnly, ClientOnlyProps } from "@ark-ui/solid/client-only";
 import { Clipboard as Clipboard$1 } from "@ark-ui/solid/clipboard";
 import { ColorPicker as ColorPicker$1 } from "@ark-ui/solid/color-picker";
-import { Combobox as Combobox$1 } from "@ark-ui/solid/combobox";
-import { DateInput as DateInput$1, DateInputFocusChangeDetails, DateInputValueChangeDetails } from "@ark-ui/solid/date-input";
 import { Dialog as Dialog$1, DialogOpenChangeDetails } from "@ark-ui/solid/dialog";
+import { DateInput as DateInput$1, DateInputFocusChangeDetails, DateInputValueChangeDetails } from "@ark-ui/solid/date-input";
+import { DownloadTrigger, DownloadTriggerBaseProps, DownloadTriggerProps, DownloadableData, UseDownloadProps, UseDownloadReturn, useDownload } from "@ark-ui/solid/download-trigger";
 import { Drawer as Drawer$1 } from "@ark-ui/solid/drawer";
 import { Editable as Editable$1 } from "@ark-ui/solid/editable";
 import { Fieldset as Fieldset$1 } from "@ark-ui/solid/fieldset";
 import { FileUpload as FileUpload$1 } from "@ark-ui/solid/file-upload";
 import { FloatingPanel as FloatingPanel$1 } from "@ark-ui/solid/floating-panel";
+import { FocusTrap, FocusTrapBaseProps, FocusTrapProps } from "@ark-ui/solid/focus-trap";
 import { Format as Format$1 } from "@ark-ui/solid/format";
 import { HoverCard as HoverCard$1 } from "@ark-ui/solid/hover-card";
 import { ImageCropper as ImageCropper$1 } from "@ark-ui/solid/image-cropper";
 import { JsonTreeView as JsonTreeView$1 } from "@ark-ui/solid/json-tree-view";
-import { Listbox as Listbox$1, createListCollection } from "@ark-ui/solid/listbox";
+import { Listbox as Listbox$1 } from "@ark-ui/solid/listbox";
 import { Marquee as Marquee$1 } from "@ark-ui/solid/marquee";
 import { Menu as Menu$1 } from "@ark-ui/solid/menu";
+import { Popover as Popover$1 } from "@ark-ui/solid/popover";
 import { NavigationMenu as NavigationMenu$1 } from "@ark-ui/solid/navigation-menu";
 import { NumberInput as NumberInput$1 } from "@ark-ui/solid/number-input";
 import { Pagination as Pagination$1 } from "@ark-ui/solid/pagination";
 import { PasswordInput as PasswordInput$1 } from "@ark-ui/solid/password-input";
 import { PinInput as PinInput$1 } from "@ark-ui/solid/pin-input";
-import { Popover as Popover$1 } from "@ark-ui/solid/popover";
+import { Presence, PresenceProps, PresenceProvider, UsePresenceContext, UsePresenceProps, UsePresenceReturn, usePresence, usePresenceContext } from "@ark-ui/solid/presence";
 import { Progress as Progress$1 } from "@ark-ui/solid/progress";
 import { QrCode as QrCode$1 } from "@ark-ui/solid/qr-code";
 import { RadioGroup as RadioGroup$1 } from "@ark-ui/solid/radio-group";
@@ -55,6 +60,7 @@ import { Tooltip as Tooltip$1 } from "@ark-ui/solid/tooltip";
 import { Tour as Tour$1, TourInteractOutsideEvent, TourPointerDownOutsideEvent, TourStepDetails, useTour } from "@ark-ui/solid/tour";
 import { TreeView as TreeView$1, TreeViewCheckedChangeDetails, TreeViewExpandedChangeDetails, TreeViewFocusChangeDetails, TreeViewSelectionChangeDetails } from "@ark-ui/solid/tree-view";
 import { JSONSchema7, JSONSchema7 as JSONSchema7$1 } from "json-schema";
+export * from "@bysages/core";
 //#endregion
 //#region src/components/accordion/index.d.ts
 /** Ark's Accordion, dressed in the paper-and-ink system: a ruled sheet
@@ -62,6 +68,154 @@ import { JSONSchema7, JSONSchema7 as JSONSchema7$1 } from "json-schema";
  * API is Ark's own — Root, Item, ItemTrigger, ItemContent, ItemIndicator. */
 export declare const Accordion: typeof Accordion$1;
 //#endregion
+//#region src/components/affix/index.d.ts
+export interface AffixProps extends JSX$1.HTMLAttributes<HTMLDivElement> {
+  /** Where the content pins when it reaches the top of the scrolling
+   * ancestor — the height of any fixed header it must clear. */
+  offsetTop?: string;
+  /** Where it pins from the bottom instead, for footers and action bars. */
+  offsetBottom?: string;
+}
+/**
+ * A nail: the wrapped content travels with the page until it reaches its
+ * offset, then stays put while the page moves on. The semantics are
+ * plain `position: sticky` — pinning is relative to the nearest
+ * *scrolling* ancestor, so the element works inside a scrollable panel
+ * exactly as it does on the page itself, and a parent with
+ * `overflow: hidden` clips the pin. Both offsets may be given: the
+ * content then holds its place inside that band.
+ */
+export declare function Affix(props: AffixProps): JSX$1.Element;
+//#endregion
+//#region src/components/ai-action/index.d.ts
+export interface ActionProps extends JSX$1.HTMLAttributes<HTMLButtonElement> {
+  /** What the button does, spoken to assistive tech and shown as
+   * the hover title — copy, retry, thumbs. */
+  label: string;
+}
+/** A quiet icon button — copy, retry, thumbs. The label names it to
+ * assistive tech and as the hover title. The control itself is the
+ * shared Button in its ghost register. */
+export declare function Action(props: ActionProps): JSX$1.Element;
+//#endregion
+//#region src/components/ai-message/index.d.ts
+export type MessageRole = "user" | "assistant" | "system";
+export interface MessageProps extends Omit<JSX$1.HTMLAttributes<HTMLElement>, "role"> {
+  /** Whose stroke this is — the user's words sit in a recessed
+   * bubble, the assistant speaks flat on the paper. */
+  role?: MessageRole;
+}
+/** Whose stroke this is — the user's words sit in a recessed bubble,
+ * the assistant speaks flat on the paper. */
+export declare function Message(props: MessageProps): JSX$1.Element;
+//#endregion
+//#region src/components/ai-prompt-input/index.d.ts
+export interface PromptInputProps extends Omit<JSX$1.HTMLAttributes<HTMLFormElement>, "onSubmit" | "value"> {
+  /** The draft in the vessel — bind `value`; it clears itself on
+   * a successful submit. */
+  value?: string;
+  onValueChange?: (value: string) => void;
+  onSubmit?: (value: string) => void;
+  onStop?: () => void;
+  /** The quiet invitation before the reader types. */
+  placeholder?: string;
+  /** Still the words on the canvas, but the submit seal does
+   * nothing and Enter stays a line break. */
+  disabled?: boolean;
+  /** The machine is working — the seal becomes a stop seal and
+   * Enter holds its breath. */
+  busy?: boolean;
+  /** Attachments riding above the text. */
+  header?: JSX$1.Element;
+  /** The tools at the text's left. */
+  leading?: JSX$1.Element;
+  /** The row at the text's right — the send seal falls there by
+   * default. */
+  trailing?: JSX$1.Element;
+  /** The tools beneath the text. */
+  footer?: JSX$1.Element;
+  /** The controls that close the footer row — the seal falls there
+   * when a footer exists. */
+  footerEnd?: JSX$1.Element;
+}
+/** The prompt vessel: the shared field textarea — self-growing on the
+ * machine's autoresize — with the submit seal riding its last line.
+ * Around the body, the slot props answer the composer's anatomy:
+ * `header` for attachments riding above, `leading` for the tools at
+ * the text's left, `trailing` for the seal itself, `footer` for the
+ * tools beneath, and `footerEnd` for the controls that close the
+ * footer row — the seal falls there by default, so a model picker
+ * dropped in rides the send's shoulder. An empty slot renders no part,
+ * so the bare vessel stays one quiet line. Controlled — bind `value`
+ * and take the text on `onSubmit`. Enter sends; Shift+Enter breaks the
+ * line. While `busy` the seal becomes a stop seal and Enter holds its
+ * breath. */
+export declare function PromptInput(props: PromptInputProps): JSX$1.Element;
+//#endregion
+//#region src/components/ai-reasoning/index.d.ts
+export interface ReasoningProps extends JSX$1.HTMLAttributes<HTMLDivElement> {
+  /** The trigger's words — the fold arrives open under them. */
+  label?: string;
+}
+/** The model's thought, folded by the shared collapsible in its quiet
+ * register: bare ink for a trigger, the thought on one hairline. */
+export declare function Reasoning(props: ReasoningProps): JSX$1.Element;
+//#endregion
+//#region src/components/ai-response/index.d.ts
+export interface ResponseProps extends JSX$1.HTMLAttributes<HTMLDivElement> {
+  /** The markdown text to set on the paper — streamed in freely;
+   * raw HTML and executable links stay inert. */
+  content: string;
+  /** Optional code-highlighting function re-inking fenced blocks;
+   * the component stays agnostic about which engine provides it. */
+  highlighter?: (code: string, lang?: string) => string;
+}
+/** Markdown set on the paper. Rendering goes through
+ * `@tanstack/markdown`, whose defaults leave raw HTML and executable
+ * links inert — streaming-safe by construction. */
+declare function Response$1(props: ResponseProps): JSX$1.Element;
+//#endregion
+//#region src/components/ai-source/index.d.ts
+export interface SourceProps extends JSX$1.HTMLAttributes<HTMLAnchorElement> {
+  /** Where the ink came from — also the link text when no children are
+   * given; opens in a new tab, referrer-free. */
+  href: string;
+}
+/** One place the ink came from; href and the rest ride the anchor. */
+export declare function Source(props: SourceProps): JSX$1.Element;
+/** The reading list under a response: where this ink came from. */
+export declare function Sources(props: JSX$1.HTMLAttributes<HTMLOListElement>): JSX$1.Element;
+//#endregion
+//#region src/components/ai-suggestion/index.d.ts
+export interface SuggestionProps extends Omit<JSX$1.HTMLAttributes<HTMLButtonElement>, "onSelect"> {
+  /** The next stroke this seal proposes — also its label; handed
+   * back whole on `onSelect`. */
+  prompt: string;
+  onSelect?: (prompt: string) => void;
+}
+/** A seal-cut button proposing the next stroke; selection hands back
+ * the prompt. The shared Button in its outline register. */
+export declare function Suggestion(props: SuggestionProps): JSX$1.Element;
+//#endregion
+//#region src/components/ai-tool/index.d.ts
+export type ToolStatus = "pending" | "running" | "completed" | "error";
+export interface ToolProps extends JSX$1.HTMLAttributes<HTMLDivElement> {
+  /** The name the tool was reached by — shown raw on the trigger
+   * unless friendlier `label` words are given. */
+  name: string;
+  /** Friendlier trigger words than the raw tool name. */
+  label?: JSX$1.Element;
+  /** The state the call reached — pending, running, completed, or
+   * error; stamped on the fold and whispered in the status chip. */
+  status?: ToolStatus;
+  input?: string;
+  output?: string;
+}
+/** A tool call: the shared collapsible as the vessel — the name it was
+ * reached by and the state it reached in on the trigger, its input and
+ * output folded inside. */
+export declare function Tool(props: ToolProps): JSX$1.Element;
+//#endregion
 //#region ../../node_modules/.pnpm/@ai-sdk+provider@4.0.14/node_modules/@ai-sdk/provider/dist/index.d.ts
 /**
  * Audio format configuration shared by provider V4 model specifications.
@@ -10136,13 +10290,13 @@ type Schema<OBJECT = unknown> = {
 };
 type LazySchema<SCHEMA> = () => Schema<SCHEMA>;
 type ZodSchema<SCHEMA = any> = ZodType<SCHEMA, ZodTypeDef, any> | $ZodType<SCHEMA, any>;
-type StandardSchema<SCHEMA = any> = StandardSchemaV1$2<unknown, SCHEMA> & {
+type StandardSchema$1<SCHEMA = any> = StandardSchemaV1$2<unknown, SCHEMA> & {
   readonly '~standard': StandardSchemaV1$2.Props<unknown, SCHEMA> & {
     readonly jsonSchema?: StandardJSONSchemaV1.Converter;
   };
 };
-type FlexibleSchema<SCHEMA = any> = Schema<SCHEMA> | LazySchema<SCHEMA> | ZodSchema<SCHEMA> | StandardSchema<SCHEMA>;
-type InferSchema<SCHEMA> = SCHEMA extends ZodSchema<infer T> ? T : SCHEMA extends StandardSchema<infer T> ? T : SCHEMA extends LazySchema<infer T> ? T : SCHEMA extends Schema<infer T> ? T : never;
+type FlexibleSchema<SCHEMA = any> = Schema<SCHEMA> | LazySchema<SCHEMA> | ZodSchema<SCHEMA> | StandardSchema$1<SCHEMA>;
+type InferSchema<SCHEMA> = SCHEMA extends ZodSchema<infer T> ? T : SCHEMA extends StandardSchema$1<infer T> ? T : SCHEMA extends LazySchema<infer T> ? T : SCHEMA extends Schema<infer T> ? T : never;
 /**
  * A context object that is passed into tool execution.
  */
@@ -13191,98 +13345,68 @@ declare global {
 }
 //#endregion
 //#region src/components/ai/index.d.ts
-export type MessageRole = "user" | "assistant" | "system";
-export interface MessageProps extends JSX$1.HTMLAttributes<HTMLElement> {
-  role?: MessageRole;
-}
-/** Whose stroke this is — the user's words sit in a recessed bubble,
- * the assistant speaks flat on the paper. */
-export declare function Message(props: MessageProps): JSX$1.Element;
-export interface ResponseProps extends JSX$1.HTMLAttributes<HTMLDivElement> {
-  content: string;
-}
-/** Markdown set on the paper. Rendering goes through
- * `@tanstack/markdown`, whose defaults leave raw HTML and executable
- * links inert — streaming-safe by construction. */
-declare function Response$1(props: ResponseProps): JSX$1.Element;
-export interface ReasoningProps extends JSX$1.HTMLAttributes<HTMLDivElement> {
-  label?: string;
-}
-/** The model's thought, folded by the shared collapsible in its quiet
- * register: bare ink for a trigger, the thought on one hairline. */
-export declare function Reasoning(props: ReasoningProps): JSX$1.Element;
-export type ToolStatus = "pending" | "running" | "completed" | "error";
-export interface ToolProps extends JSX$1.HTMLAttributes<HTMLDivElement> {
-  name: string;
-  status?: ToolStatus;
-  input?: string;
-  output?: string;
-}
-/** A tool call: the shared collapsible as the vessel — the name it was
- * reached by and the state it reached in on the trigger, its input and
- * output folded inside. */
-export declare function Tool(props: ToolProps): JSX$1.Element;
-export interface SourceProps extends JSX$1.HTMLAttributes<HTMLAnchorElement> {
-  href: string;
-}
-/** One place the ink came from; href and the rest ride the anchor. */
-export declare function Source(props: SourceProps): JSX$1.Element;
-export interface ActionProps extends JSX$1.HTMLAttributes<HTMLButtonElement> {
-  label: string;
-}
-/** A quiet icon button — copy, retry, thumbs. The label names it to
- * assistive tech and as the hover title. The control itself is the
- * shared Button in its ghost register. */
-export declare function Action(props: ActionProps): JSX$1.Element;
-export interface SuggestionProps extends JSX$1.HTMLAttributes<HTMLButtonElement> {
-  prompt: string;
-  onSelect?: (prompt: string) => void;
-}
-/** A seal-cut button proposing the next stroke; selection hands back
- * the prompt. The shared Button in its outline register. */
-export declare function Suggestion(props: SuggestionProps): JSX$1.Element;
-export interface PromptInputProps extends JSX$1.HTMLAttributes<HTMLFormElement> {
-  value: string;
-  onValueChange?: (value: string) => void;
-  onSubmit?: (value: string) => void;
-  placeholder?: string;
-  disabled?: boolean;
-}
-/** The prompt vessel: the shared field textarea — self-growing on the
- * machine's autoresize — over a footer row carrying the submit seal.
- * Controlled — bind `value` and take the text on `onSubmit`. Enter
- * sends; Shift+Enter breaks the line. */
-export declare function PromptInput(props: PromptInputProps): JSX$1.Element;
-export declare const Ai: ((props: JSX$1.HTMLAttributes<HTMLElement>) => JSX$1.Element) & {
-  Conversation: (props: JSX$1.HTMLAttributes<HTMLElement>) => JSX$1.Element;
+/** The log itself: the column every stroke lands in, a landmark to
+ * screen readers. */
+export declare const AiConversation: (props: JSX$1.HTMLAttributes<HTMLDivElement>) => JSX$1.Element;
+/** The bubble's inner measure — content that belongs to neither side
+ * specifically. */
+export declare const AiContent: (props: JSX$1.HTMLAttributes<HTMLDivElement>) => JSX$1.Element;
+/** The quiet row under a message — copy, retry, feedback. */
+export declare const AiActions: (props: JSX$1.HTMLAttributes<HTMLDivElement>) => JSX$1.Element;
+/** The while-it-works whisper for the in-flight turns. */
+export declare const AiLoader: (props: JSX$1.HTMLAttributes<HTMLDivElement>) => JSX$1.Element;
+/** The whole family under one handle — `Ai.Conversation`,
+ * `Ai.MessageContent`, and the rest. */
+export declare const Ai: ((props: JSX$1.HTMLAttributes<HTMLDivElement>) => JSX$1.Element) & {
+  Conversation: (props: JSX$1.HTMLAttributes<HTMLDivElement>) => JSX$1.Element;
+  MessageContent: (props: JSX$1.HTMLAttributes<HTMLDivElement>) => JSX$1.Element;
+  Actions: (props: JSX$1.HTMLAttributes<HTMLDivElement>) => JSX$1.Element;
+  Loader: (props: JSX$1.HTMLAttributes<HTMLDivElement>) => JSX$1.Element;
   Message: typeof Message;
-  Content: (props: JSX$1.HTMLAttributes<HTMLElement>) => JSX$1.Element;
   Response: typeof Response$1;
   Reasoning: typeof Reasoning;
   Tool: typeof Tool;
-  Sources: (props: JSX$1.HTMLAttributes<HTMLElement>) => JSX$1.Element;
+  Sources: typeof Sources;
   Source: typeof Source;
-  Actions: (props: JSX$1.HTMLAttributes<HTMLElement>) => JSX$1.Element;
   Action: typeof Action;
   Suggestion: typeof Suggestion;
   PromptInput: typeof PromptInput;
-  Loader: (props: JSX$1.HTMLAttributes<HTMLElement>) => JSX$1.Element;
 };
 //#endregion
+//#region src/components/ai-attachments/index.d.ts
+export type AttachmentStatus = "uploading" | "ready" | "error";
+export interface AttachmentProps extends JSX$1.HTMLAttributes<HTMLSpanElement> {
+  /** The file's name — it picks the glyph by extension. */
+  name: string;
+  /** The file's size in bytes, when known — rendered human. */
+  size?: number;
+  /** The upload's state on the wire. */
+  status?: AttachmentStatus;
+  onRemove?: () => void;
+}
+/** One file riding the prompt: its glyph by extension, its name and
+ * human size, and a quiet way to take it back off. Uploading reads as
+ * a dashed ghost, error as danger ink. */
+export declare function Attachment(props: AttachmentProps): JSX$1.Element;
+/** The row the files ride in — a wrapping line of chips. */
+export declare function Attachments(props: JSX$1.HTMLAttributes<HTMLSpanElement>): JSX$1.Element;
+//#endregion
 //#region src/components/alert/index.d.ts
 export type AlertStatus = "ink" | "info" | "success" | "warning" | "danger";
 /** A notice drawn on the page: a wash of the status pigment, one heavier
  * hairline on the leading edge, the serif for its title. Root, Icon,
  * Body, Title, Description — the icon reads the status from the Root. */
-export interface AlertProps extends JSX$1.HTMLAttributes<HTMLDivElement> {}
+export interface AlertProps extends JSX$1.HTMLAttributes<HTMLDivElement> {
+  status?: AlertStatus;
+}
 declare function AlertRoot(props: AlertProps): JSX$1.Element;
-declare function Icon(): JSX$1.Element;
+declare function Icon$1(): JSX$1.Element;
 declare function Body(props: JSX$1.HTMLAttributes<HTMLDivElement>): JSX$1.Element;
 declare function Title(props: JSX$1.HTMLAttributes<HTMLParagraphElement>): JSX$1.Element;
 declare function Description(props: JSX$1.HTMLAttributes<HTMLParagraphElement>): JSX$1.Element;
 export declare const Alert: typeof AlertRoot & {
   Root: typeof AlertRoot;
-  Icon: typeof Icon;
+  Icon: typeof Icon$1;
   Body: typeof Body;
   Title: typeof Title;
   Description: typeof Description;
@@ -13295,6 +13419,34 @@ export declare const Alert: typeof AlertRoot & {
  * Marker, HiddenInput. */
 export declare const AngleSlider: typeof AngleSlider$1;
 //#endregion
+//#region src/components/aspect-ratio/index.d.ts
+/** A frame that keeps its shape: the box holds the given ratio whatever
+ * the width it is dealt, and the child fills the frame it is given. */
+export interface AspectRatioProps extends JSX$1.HTMLAttributes<HTMLDivElement> {
+  /** A CSS `aspect-ratio` value — "16 / 9", "4 / 3", "1 / 1". */
+  ratio?: string;
+}
+export declare function AspectRatio(props: AspectRatioProps): JSX$1.Element;
+//#endregion
+//#region src/components/autocomplete/index.d.ts
+export interface AutoCompleteProps {
+  value?: string;
+  items?: string[];
+  placeholder?: string;
+  /** Field text to match against; defaults to the item itself. */
+  filter?: (item: string, input: string) => boolean;
+  onValueChange?: (value: string) => void;
+}
+/**
+ * Free text with suggestions: the reader types anything, the list
+ * narrows to help, and both a pick and a custom value end up in the
+ * same `value`. A preset of the combobox machinery — same parts,
+ * same styling, one job. `items` seeds the suggestion list once;
+ * matching is a case-insensitive substring unless `filter` says
+ * otherwise.
+ */
+export declare function AutoComplete(props: AutoCompleteProps): import("solid-js").JSX.Element;
+//#endregion
 //#region src/components/avatar/index.d.ts
 /** Ark's Avatar, dressed in the paper-and-ink system: a circular seal on
  * inset paper that holds initials until the image loads over them. The
@@ -13307,6 +13459,28 @@ export declare const Avatar: typeof Avatar$1;
 export type AvatarGroupProps = JSX$1.HTMLAttributes<HTMLDivElement>;
 export declare function AvatarGroup(props: AvatarGroupProps): JSX$1.Element;
 //#endregion
+//#region src/components/back-top/index.d.ts
+export interface BackTopProps extends JSX$1.HTMLAttributes<HTMLButtonElement> {
+  /** How far the reader must have travelled (px) before the affordance
+   * appears. */
+  threshold?: number;
+  /** The accessible name; the control is icon-only by default. */
+  label?: string;
+}
+/**
+ * A way home: after the page has scrolled past `threshold`, a small
+ * floating control rises at the page's corner and returns the reader to
+ * the top. The scroll itself stays native — `window.scrollTo` defers to
+ * the stylesheet's `scroll-behavior: smooth`, which reduced motion turns
+ * back into an instant jump. The button stays mounted either way so the
+ * entrance is a transition, never a pop.
+ *
+ * The control itself is the shared `Button` (outline, square) — the
+ * paper, hairline and halo are its; this family owns only the floating
+ * and the entrance.
+ */
+export declare function BackTop(props: BackTopProps): JSX$1.Element;
+//#endregion
 //#region src/components/badge/index.d.ts
 /** A small seal of state. Ink is the neutral tone; the four semantic
  * pigments are fixed. Subtle and outline re-register the same pigment. */
@@ -13318,24 +13492,24 @@ export declare function Badge(props: BadgeProps): JSX$1.Element;
 //#endregion
 //#region src/components/banner/index.d.ts
 export type BannerStatus = "ink" | "info" | "success" | "warning" | "danger";
-export interface BannerRootProps extends JSX$1.HTMLAttributes<HTMLElement> {
+export interface BannerRootProps extends JSX$1.HTMLAttributes<HTMLDivElement> {
   status?: BannerStatus;
 }
 /** A page-level notice, spoken across the full measure: a wash of the
  * status pigment, one heavier hairline on the leading edge, and room
  * for actions and a quiet close. Ink is the neutral register; the four
  * semantic pigments are fixed. */
-declare function Root$1(props: BannerRootProps): JSX$1.Element;
+declare function Root$3(props: BannerRootProps): JSX$1.Element;
 /** The quiet close: a plain square-cut button; dismissal stays the
  * consumer's state. */
-declare function Close(props: JSX$1.HTMLAttributes<HTMLButtonElement>): JSX$1.Element;
-export declare const Banner: typeof Root$1 & {
-  Root: typeof Root$1;
-  Icon: (props: JSX$1.HTMLAttributes<HTMLElement>) => JSX$1.Element;
-  Body: (props: JSX$1.HTMLAttributes<HTMLElement>) => JSX$1.Element;
-  Title: (props: JSX$1.HTMLAttributes<HTMLElement>) => JSX$1.Element;
-  Description: (props: JSX$1.HTMLAttributes<HTMLElement>) => JSX$1.Element;
-  Actions: (props: JSX$1.HTMLAttributes<HTMLElement>) => JSX$1.Element;
+declare function Close(props: JSX$1.ButtonHTMLAttributes<HTMLButtonElement>): JSX$1.Element;
+export declare const Banner: typeof Root$3 & {
+  Root: typeof Root$3;
+  Icon: (props: JSX$1.HTMLAttributes<HTMLDivElement>) => JSX$1.Element;
+  Body: (props: JSX$1.HTMLAttributes<HTMLDivElement>) => JSX$1.Element;
+  Title: (props: JSX$1.HTMLAttributes<HTMLDivElement>) => JSX$1.Element;
+  Description: (props: JSX$1.HTMLAttributes<HTMLDivElement>) => JSX$1.Element;
+  Actions: (props: JSX$1.HTMLAttributes<HTMLDivElement>) => JSX$1.Element;
   Close: typeof Close;
 };
 //#endregion
@@ -13354,7 +13528,7 @@ export declare const Breadcrumb: Component<Record<string, unknown>> & {
  * rests, the tone chooses the pigment. Ink is the solemn default; any
  * action can carry the primary weight. The react package's asChild has
  * no solid equivalent — compose a control around `<Button>` instead. */
-export interface ButtonProps extends JSX$1.HTMLAttributes<HTMLButtonElement> {
+export interface ButtonProps extends JSX$1.ButtonHTMLAttributes<HTMLButtonElement> {
   variant?: "solid" | "outline" | "ghost" | "subtle";
   tone?: "ink" | "info" | "success" | "warning" | "danger";
   size?: "sm" | "md" | "lg";
@@ -13363,8 +13537,30 @@ export interface ButtonProps extends JSX$1.HTMLAttributes<HTMLButtonElement> {
 }
 export declare function Button(props: ButtonProps): JSX$1.Element;
 //#endregion
+//#region src/components/button-group/index.d.ts
+export interface ButtonGroupProps extends JSX$1.HTMLAttributes<HTMLDivElement> {
+  /** The seam runs across the group (default) or down it. */
+  orientation?: "horizontal" | "vertical";
+  /** One register for every member: falls onto data-size for the
+   * stylesheet to retune the buttons' heights. */
+  size?: "sm" | "md" | "lg";
+  /** The members' corner register: retunes --bs-radius-control for the
+   * whole fused shape — edges and trimmed seams keep one story. */
+  radius?: "sm" | "md" | "lg" | "xl" | "2xl" | "full";
+}
+/**
+ * Buttons fused into one control: the group owns only the joinery, so
+ * members keep every variant they were given — a solid action can sit
+ * beside an outline one and the seam still reads. Selection belongs to
+ * the toggle group; this is layout alone.
+ */
+export declare function ButtonGroupRoot(props: ButtonGroupProps): JSX$1.Element;
+export declare const ButtonGroup: typeof ButtonGroupRoot & {
+  Root: typeof ButtonGroupRoot;
+};
+//#endregion
 //#region src/components/calendar/index.d.ts
-export interface CalendarProps extends JSX.HTMLAttributes<HTMLDivElement> {
+export interface CalendarProps extends JSX$1.HTMLAttributes<HTMLDivElement> {
   /** Selected date(s) — an array, as the machine speaks in ranges. */
   value?: DatePickerRootProps["value"];
   min?: DatePickerRootProps["min"];
@@ -13376,7 +13572,7 @@ export interface CalendarProps extends JSX.HTMLAttributes<HTMLDivElement> {
  * title zooms out through month and year grids; the grids themselves
  * are the shared machinery — value, range selection, and focus ride
  * Ark's own contract. */
-export declare function Calendar(props: CalendarProps): import("solid-js").JSX.Element;
+export declare function Calendar(props: CalendarProps): JSX$1.Element;
 //#endregion
 //#region src/components/card/index.d.ts
 declare const Card$1: Component<Record<string, unknown>> & {
@@ -13396,6 +13592,31 @@ declare const Card$1: Component<Record<string, unknown>> & {
  * Indicator, AutoplayTrigger, ProgressText. */
 export declare const Carousel: typeof Carousel$1;
 //#endregion
+//#region src/components/cascade-select/index.d.ts
+export interface CascadeSelectNode {
+  label: string;
+  value: string;
+  children?: CascadeSelectNode[];
+  disabled?: boolean;
+}
+export interface CascadeSelectProps extends JSX$1.HTMLAttributes<HTMLDivElement> {
+  value?: string[][];
+  data: CascadeSelectNode[];
+  placeholder?: string;
+  highlightTrigger?: "click" | "hover";
+  multiple?: boolean;
+  disabled?: boolean;
+  onValueChange?: (value: string[][]) => void;
+}
+/**
+ * A corridor of linked columns: pick a branch and the next column
+ * dissolves open beside it, until a leaf click settles the whole path.
+ * `value` is the selected path (or paths, when `multiple`) — the
+ * joined labels ride the trigger. `highlightTrigger: "hover"` turns the
+ * classic cascading menu: pointing is enough to unfold.
+ */
+export declare function CascadeSelect(props: CascadeSelectProps): JSX$1.Element;
+//#endregion
 //#region src/components/checkbox/index.d.ts
 /** Ark's Checkbox, dressed in the paper-and-ink system: a square-cut seal
  * that fills flat with primary ink when ticked, the mark springing into
@@ -13403,6 +13624,27 @@ export declare const Carousel: typeof Carousel$1;
  * HiddenInput. */
 export declare const Checkbox: typeof Checkbox$1;
 //#endregion
+//#region src/components/checkbox-group/index.d.ts
+export interface CheckboxOption {
+  label: string;
+  value: string;
+  disabled?: boolean;
+}
+export interface CheckboxGroupProps extends JSX$1.HTMLAttributes<HTMLDivElement> {
+  value?: string[];
+  options: CheckboxOption[];
+  layout?: "vertical" | "horizontal";
+  disabled?: boolean;
+  onValueChange?: (value: string[]) => void;
+}
+/**
+ * One question, many answers: a labelled stack (or row) of the seal-cut
+ * checkboxes bound to a single array. Toggling a box adds or removes its
+ * value; the group itself is semantics (`role="group"`), the boxes stay
+ * the machine-driven originals.
+ */
+export declare function CheckboxGroup(props: CheckboxGroupProps): JSX$1.Element;
+//#endregion
 //#region src/components/chip/index.d.ts
 /** A counting coin: the numeric value, capped at `max` with an ellipsis
  * of the remainder ("99+"). */
@@ -13446,6 +13688,117 @@ export declare const ColorPicker: typeof ColorPicker$1;
  * Item, ItemText, ItemIndicator, ItemGroup, ItemGroupLabel. */
 export declare const Combobox: typeof Combobox$1;
 //#endregion
+//#region src/components/command/index.d.ts
+export interface CommandEntry {
+  label: string;
+  value: string;
+  /** Entries sharing a group are listed under one heading. */
+  group?: string;
+  /** A short affordance note, set as a keycap at the row's end. */
+  hint?: string;
+}
+export interface CommandProps {
+  /** The commands on offer, grouped as they arrive. */
+  items?: CommandEntry[];
+  placeholder?: string;
+  /** Whether the palette is up. Supply it to control the palette;
+   * changes are reported through `onOpenChange`. */
+  open?: boolean;
+  /** Whether the shell narrows `items` as the reader types. Turn it off
+   * when the caller owns the searching — a ranked engine or a remote
+   * source — and hands down the already-narrowed list. */
+  autoFilter?: boolean;
+  /** The field's text under the caller's control; changes are reported
+   * through `onInputValueChange`. */
+  inputValue?: string;
+  /** What the list whispers when nothing matches. */
+  emptyText?: string;
+  /** Called with the chosen entry's `value`; the palette closes after. */
+  onSelect?: (value: string) => void;
+  /** The palette's openness changed. */
+  onOpenChange?: (open: boolean) => void;
+  /** The field's text changed. */
+  onInputValueChange?: (value: string) => void;
+}
+/**
+ * The command palette: a modal sheet at the top of the page carrying a
+ * search field over the caller's commands, grouped as a ledger with a
+ * keycap hint at each row. The shell is the dialog machinery — scrim,
+ * focus trap, Escape — and the searching is the combobox machinery
+ * driving our own list: the vessel and the list live inside the sheet,
+ * so the combobox renders no separate popup and the machine's content
+ * grafts onto the sheet's list.
+ */
+export declare function Command(props: CommandProps): import("solid-js").JSX.Element;
+//#endregion
+//#region src/components/comment/index.d.ts
+export interface CommentProps extends JSX$1.HTMLAttributes<HTMLElement> {
+  author?: string;
+  datetime?: string;
+  /** The portrait hanging to the left of the body. */
+  avatar?: JSX$1.Element;
+  /** The row of answers beneath the ink. */
+  actions?: JSX$1.Element;
+}
+/**
+ * A voice on the record: the portrait hangs left (the `avatar` prop),
+ * the body carries the byline from `author` and `datetime`, the ink is
+ * the children, and `actions` is the row of answers.
+ */
+export declare function Comment(props: CommentProps): JSX$1.Element;
+//#endregion
+//#region src/components/config-provider/index.d.ts
+/** The four density tiers the token layer's `[data-density]` selectors
+ * name — whitespace and control heights compress, readability never
+ * does. */
+export type ConfigDensity = "compact" | "default" | "comfortable" | "spacious";
+/** The configuration a provider lays over its subtree. Every field is
+ * optional: an absent field changes nothing, and the page's own
+ * attributes keep ruling. */
+export interface ConfigContext {
+  density?: ConfigDensity;
+  /** A mineral pigment theme (qinghua, celadon, zhusha, …) landing as
+   * `[data-accent]` on the host element. */
+  accent?: string;
+  /** Writing direction, landing as the native `dir` attribute. */
+  dir?: "ltr" | "rtl";
+  /** BCP-47 locale, landing as the native `lang` attribute. */
+  locale?: string;
+}
+/** Solid context for the provider's snapshot — a custom part reads it
+ * with `useContext(ConfigContextKey)`. */
+export declare const ConfigContextKey: import("solid-js").Context<() => ConfigContext>;
+/** The nearest provider's snapshot, or an empty one when no provider
+ * wraps the caller — the hook the date and format families will consume
+ * to localize their output. */
+export declare function useConfig(): () => ConfigContext;
+export interface ConfigProviderProps extends JSX$1.HTMLAttributes<HTMLDivElement> {
+  density?: ConfigDensity;
+  accent?: string;
+  dir?: "ltr" | "rtl";
+  locale?: string;
+}
+/**
+ * The declarative host for global configuration: one element that both
+ * carries the token layer's attributes — `[data-density]` and
+ * `[data-accent]` fire on any element — and provides the same values to
+ * descendants through `useConfig`, so interactive behavior (formatting,
+ * messages) and visual theming stay one decision.
+ */
+export declare function ConfigProvider(props: ConfigProviderProps): JSX$1.Element;
+//#endregion
+//#region src/components/container/index.d.ts
+/** The reading frame: content held to a measure and centered on the
+ * page. The sizes name typographic measures, not breakpoints — the page
+ * owns its edges, the container only owns how long a line of ink runs. */
+export interface ContainerProps extends JSX$1.HTMLAttributes<HTMLDivElement> {
+  size?: "narrow" | "readable" | "wide" | "full";
+  /** Keep the ink off the page edges when the viewport runs narrower
+   * than the measure. */
+  padding?: boolean;
+}
+export declare function Container(props: ContainerProps): JSX$1.Element;
+//#endregion
 //#region src/components/date-input/index.d.ts
 /** Ark's DateInput, dressed in the paper-and-ink system: a segmented
  * field where the focused segment takes the flat ink fill. The API is
@@ -13462,6 +13815,23 @@ export declare const DateInput: typeof DateInput$1;
  * NextTrigger, Table*, MonthSelect, YearSelect, PresetTrigger. */
 export declare const DatePicker: typeof DatePicker$1;
 //#endregion
+//#region src/components/descriptions/index.d.ts
+/**
+ * A ledger laid flat: term and detail pairs in one quiet grid. The
+ * horizontal layout reads as a table of two columns; the vertical one
+ * stacks each pair for narrow measures.
+ */
+export interface DescriptionsRootProps extends JSX$1.HTMLAttributes<HTMLDListElement> {
+  layout?: "horizontal" | "vertical";
+}
+declare function Root$2(props: DescriptionsRootProps): JSX$1.Element;
+export declare const Descriptions: typeof Root$2 & {
+  Root: typeof Root$2;
+  Item: (props: JSX$1.HTMLAttributes<HTMLDivElement>) => JSX$1.Element;
+  Term: (props: JSX$1.HTMLAttributes<HTMLDivElement>) => JSX$1.Element;
+  Detail: (props: JSX$1.HTMLAttributes<HTMLDivElement>) => JSX$1.Element;
+};
+//#endregion
 //#region src/components/dialog/index.d.ts
 /** Ark's Dialog, dressed in the paper-and-ink system: the sheet dissolves
  * in on elevation, the backdrop fades, and nested overlays stack through
@@ -13477,6 +13847,33 @@ export declare const Dialog: typeof Dialog$1;
  * Description, CloseTrigger, SwipeArea. */
 export declare const Drawer: typeof Drawer$1;
 //#endregion
+//#region src/components/dynamic-input/index.d.ts
+export interface DynamicInputProps extends JSX$1.HTMLAttributes<HTMLDivElement> {
+  /** The rows' values; the group renders one Input per entry. */
+  value?: string[];
+  /** The fewest rows the group keeps; the remove seals yield first. */
+  min?: number;
+  /** The most rows the group grows to; the add control yields then. */
+  max?: number;
+  placeholder?: string;
+  /** The add control's visible words. */
+  addLabel?: string;
+  disabled?: boolean;
+  invalid?: boolean;
+  /** Every edit emits a fresh array; the caller's array stays the only
+   * truth. */
+  onValueChange?: (value: string[]) => void;
+}
+/**
+ * A column of entry rows: one Input per line, each with a quiet remove
+ * seal, and an add row at the tail. The list is controlled — every edit
+ * calls `onValueChange` with a fresh array and the caller's array stays
+ * the only truth. Deleting never drops below `min`, adding never grows
+ * past `max`, and the group always keeps one row: an entry list that
+ * emptied itself would leave the reader no place to type.
+ */
+export declare function DynamicInput(props: DynamicInputProps): JSX$1.Element;
+//#endregion
 //#region src/components/editable/index.d.ts
 /** Ark's Editable, dressed in the paper-and-ink system: bare ink while
  * reading, the full field recipe while editing. The API is Ark's own —
@@ -13484,6 +13881,15 @@ export declare const Drawer: typeof Drawer$1;
  * CancelTrigger, Control. */
 export declare const Editable: typeof Editable$1;
 //#endregion
+//#region src/components/ellipsis/index.d.ts
+/** The overflow knife: text cut at one line, or held to N lines. The
+ * primitive only draws the cut — reaching the full text (title,
+ * tooltip) stays the consumer's decision. */
+export interface EllipsisProps extends JSX$1.HTMLAttributes<HTMLSpanElement> {
+  lines?: number;
+}
+export declare function Ellipsis(props: EllipsisProps): JSX$1.Element;
+//#endregion
 //#region src/components/empty/index.d.ts
 export declare const Empty: Component<Record<string, unknown>> & {
   Root: Component<Record<string, unknown>>;
@@ -13515,6 +13921,60 @@ export declare const Fieldset: typeof Fieldset$1;
  * Context. */
 export declare const FileUpload: typeof FileUpload$1;
 //#endregion
+//#region src/components/float-button/index.d.ts
+export type FloatButtonPlacement = "bottom-end" | "bottom-start" | "top-end" | "top-start";
+/** The group's openness, shared from the mooring to its parts. */
+export interface FloatButtonContext {
+  open: () => boolean;
+  toggle: () => void;
+  /** Folds the fan — an Item calls this once its action fires, the way
+   * a speed dial closes after a choice. */
+  close: () => void;
+}
+/** Solid context for {@link FloatButtonContext}, exported so a custom
+ * part can read the group's state with `useContext`. */
+export declare const FloatButtonContextKey: import("solid-js").Context<FloatButtonContext | undefined>;
+export interface FloatButtonRootProps extends JSX$1.HTMLAttributes<HTMLDivElement> {
+  /** Controlled openness: leave unset to let the group hold its own
+   * state; while set, the Trigger reports back through
+   * `onOpenChange`. */
+  open?: boolean;
+  /** Which corner the group moors at. */
+  placement?: FloatButtonPlacement;
+  /** The openness changed — from the Trigger, or an Item folding the
+   * fan. */
+  onOpenChange?: (open: boolean) => void;
+}
+/**
+ * A floating action and its fanned-out alternatives — FAB and speed
+ * dial in one family. The Root moors the group at a page corner and
+ * holds the openness (mirrored from `open` when controlled); the
+ * Trigger flips it; each Item is a round action with its name surfacing
+ * beside it while the group is open. The buttons are the shared recipe
+ * (vessels here: round); this family owns only the mooring, the fan
+ * and the fold.
+ */
+declare function FloatButtonRoot(props: FloatButtonRootProps): JSX$1.Element;
+export interface FloatButtonTriggerProps extends JSX$1.HTMLAttributes<HTMLButtonElement> {
+  /** The accessible name; the control is icon-only. */
+  label?: string;
+}
+declare function FloatButtonTrigger(props: FloatButtonTriggerProps): JSX$1.Element;
+export interface FloatButtonItemProps extends Omit<JSX$1.HTMLAttributes<HTMLDivElement>, "onClick"> {
+  /** The action's name: the button's accessible name and the
+   * annotation surfaced beside it while the group is open. */
+  label: string;
+  disabled?: boolean;
+  /** The action fired — the fan folds right after. */
+  onClick?: (event: MouseEvent) => void;
+}
+declare function FloatButtonItem(props: FloatButtonItemProps): JSX$1.Element;
+export declare const FloatButton: typeof FloatButtonRoot & {
+  Root: typeof FloatButtonRoot;
+  Trigger: typeof FloatButtonTrigger;
+  Item: typeof FloatButtonItem;
+};
+//#endregion
 //#region src/components/floating-panel/index.d.ts
 /** Ark's FloatingPanel, dressed in the paper-and-ink system: the shared
  * popup vessel let loose — a draggable, resizable sheet whose header is the
@@ -13531,6 +13991,80 @@ export declare const FloatingPanel: typeof FloatingPanel$1;
  * Byte, Time, RelativeTime. */
 export declare const Format: typeof Format$1;
 //#endregion
+//#region src/components/form/index.d.ts
+/** The one error a field can carry: where it lives in the form state
+ * (dot notation for nested objects, indexes for arrays) and what went
+ * wrong. */
+export interface FormError {
+  name: string;
+  message: string;
+}
+/** The Standard Schema surface this package understands — the slice
+ * valibot, zod, arktype and friends all expose. Declared structurally
+ * so no spec package becomes a dependency. */
+export interface StandardSchema<Input = unknown> {
+  readonly "~standard": {
+    readonly validate: (value: Input) => Promise<ValidateResult> | ValidateResult;
+  };
+}
+interface ValidateResult {
+  readonly value?: unknown;
+  readonly issues?: ReadonlyArray<{
+    readonly message: string;
+    readonly path?: ReadonlyArray<PropertyKey | {
+      readonly key: PropertyKey;
+    }>;
+  }>;
+}
+export type FormInputEvent = "input" | "change" | "blur";
+/** The imperative handle the `ref` callback receives: run the
+ * validation, clear errors (all of them or by name), and set or read
+ * them directly. */
+export interface FormApi {
+  validate: () => Promise<Map<string, string>>;
+  clear: (name?: string | RegExp) => void;
+  setErrors: (errors: FormError[]) => void;
+  getErrors: (name?: string | RegExp) => FormError[];
+  errors: () => Map<string, string>;
+}
+export interface FormProps extends Omit<JSX$1.FormHTMLAttributes<HTMLFormElement>, "onSubmit" | "onError" | "ref"> {
+  state: Record<string, unknown>;
+  schema?: StandardSchema;
+  validate?: (state: Record<string, unknown>) => FormError[] | Promise<FormError[]>;
+  validateOn?: FormInputEvent[];
+  disabled?: boolean;
+  onSubmit?: (state: Record<string, unknown>) => void;
+  onError?: (errors: FormError[]) => void;
+  /** The imperative handle — set/clear/read errors from outside. */
+  ref?: (api: FormApi) => void;
+}
+/**
+ * The validation scheduler: one reactive error map, a submit that
+ * validates before it emits, live re-validation on the events the
+ * `validateOn` prop names, and the imperative handle. The schema is any
+ * Standard Schema (valibot, zod, arktype, …) — none are bundled; a
+ * `validate` function composes with it for the cases schemas can't
+ * express. Errors reach their field by name, through FormField.
+ */
+export declare function Form(props: FormProps): JSX$1.Element;
+export interface FormFieldProps extends JSX$1.HTMLAttributes<HTMLDivElement> {
+  name?: string;
+  label?: string;
+  hint?: string;
+  required?: boolean;
+  invalid?: boolean;
+  disabled?: boolean;
+}
+/**
+ * The named slot in the grid: label, control, hint — and the error the
+ * Form routed to this name, shown through the same parts the standalone
+ * Field family styles. The Ark field context runs underneath, so our
+ * Input and Textarea pick up the label wiring and the invalid state
+ * without knowing the Form exists. Without a Form above it degrades to
+ * a plain labelled field.
+ */
+export declare function FormField(props: FormFieldProps): JSX$1.Element;
+//#endregion
 //#region src/components/frame/index.d.ts
 /** Ark's Frame, dressed in the paper-and-ink system: a sandboxed
  * iframe whose body mounts the children and whose `head` prop
@@ -13541,6 +14075,18 @@ export declare const Format: typeof Format$1;
  * core stylesheet to hook. The API is Ark's own. */
 export declare const Frame: (props: import("@ark-ui/solid/frame").FrameProps) => import("solid-js").JSX.Element;
 //#endregion
+//#region src/components/grid/index.d.ts
+/** An alignment lattice: tracks of equal measure, sized by column count
+ * — or, with `minChildWidth`, as many tracks as the container fits. */
+export interface GridProps extends JSX$1.HTMLAttributes<HTMLDivElement> {
+  columns?: number;
+  gap?: "none" | "xs" | "sm" | "md" | "lg" | "xl";
+  /** Switch to the auto-fill lattice: each track is at least this wide,
+   * and the container decides how many fit. */
+  minChildWidth?: string;
+}
+export declare function Grid(props: GridProps): JSX$1.Element;
+//#endregion
 //#region src/components/highlight/index.d.ts
 /** Ark's Highlight, dressed in the paper-and-ink system: query hits are
  * strokes of pigment on the page — a quiet tint of the accent behind the
@@ -13554,6 +14100,36 @@ export declare const Highlight: (props: import("@ark-ui/solid/highlight").Highli
  * API is Ark's own — Root, Trigger, Positioner, Content, Arrow, ArrowTip. */
 export declare const HoverCard: typeof HoverCard$1;
 //#endregion
+//#region src/components/icon/index.d.ts
+/** The inkwell: a standard box that keeps any inline svg at its optical
+ * measure and in the text's own ink — the icon carries no pigment and no
+ * size of its own. Bring the glyph; it ships no set. */
+export interface IconProps extends JSX$1.HTMLAttributes<HTMLSpanElement> {
+  /** Size steps follow the surrounding font size; `inherit` is the
+   * default — one em of the text the icon sits in. */
+  size?: "inherit" | "sm" | "md" | "lg";
+  /** The accessible name. Without it the icon is presentation-only and
+   * hidden from the accessibility tree. */
+  label?: string;
+}
+export declare function Icon(props: IconProps): JSX$1.Element;
+//#endregion
+//#region src/components/image/index.d.ts
+/** A framed picture: while the source loads, the frame keeps the
+ * skeleton's breath; the picture dissolves in when it lands; a broken
+ * source leaves the `fallback` prop — or the placeholder glyph when the
+ * caller has nothing local to say. The frame's size is the consumer's
+ * to give. */
+export interface ImageProps extends JSX$1.HTMLAttributes<HTMLElement> {
+  src: string;
+  alt?: string;
+  fit?: "cover" | "contain" | "fill" | "none";
+  loading?: "lazy" | "eager";
+  /** What a broken source leaves instead of the picture. */
+  fallback?: JSX$1.Element;
+}
+export declare function Image(props: ImageProps): JSX$1.Element;
+//#endregion
 //#region src/components/image-cropper/index.d.ts
 /** Ark's ImageCropper, dressed in the paper-and-ink system: a rounded vessel
  * holding the photograph, one lit selection window framed by light hairlines.
@@ -13561,6 +14137,56 @@ export declare const HoverCard: typeof HoverCard$1;
  * Context. */
 export declare const ImageCropper: typeof ImageCropper$1;
 //#endregion
+//#region src/components/image-viewer/index.d.ts
+/**
+ * A lightbox: the picture over a dimmed page, with a small toolbar
+ * beneath it. Zoom is the reader's hand (half to three times, clamped),
+ * a quarter turn at a time rotates, Escape and the scrim close — the
+ * dialog machine carries the modal part. `open` may stay with the
+ * caller; left undefined the viewer keeps it to itself.
+ */
+export interface ImageViewerProps {
+  src: string;
+  alt?: string;
+  open?: boolean;
+  zoomable?: boolean;
+  /** The openness changed — from the scrim, Escape or the toolbar. */
+  onOpenChange?: (open: boolean) => void;
+}
+export declare function ImageViewer(props: ImageViewerProps): JSX$1.Element;
+//#endregion
+//#region src/components/input/index.d.ts
+export interface InputProps extends JSX$1.InputHTMLAttributes<HTMLInputElement> {
+  value?: string | number;
+  onValueChange?: (value: string) => void;
+  size?: "sm" | "md" | "lg";
+  invalid?: boolean;
+}
+/** The bare text input: the field recipe — border, surface, focus halo —
+ * on a native control. Standing alone it styles itself from the `invalid`
+ * prop; inside a `Field.Root` it consumes the field context, picking up
+ * the label id, the described-by wiring and the invalid state for free,
+ * which is also the seam the Form validation layer will drive. Disabled
+ * rides the native attribute. */
+export declare function Input(props: InputProps): JSX$1.Element;
+//#endregion
+//#region src/components/input-group/index.d.ts
+/**
+ * Merged controls: attachments and the entry fused into one seal. The
+ * Root draws the single hairline and carries the group's focus halo;
+ * the Addon is a recessed cell for the reader's fixed words — a scheme,
+ * a unit, a quiet button — placed before or after the entry. Put our
+ * Input (or Textarea) inside and its own border and halo step aside in
+ * favor of the group's; the stylesheet does the merging, the wrapper
+ * adds no visuals of its own.
+ */
+declare function InputGroupRoot(props: JSX$1.HTMLAttributes<HTMLDivElement>): JSX$1.Element;
+declare function InputGroupAddon(props: JSX$1.HTMLAttributes<HTMLDivElement>): JSX$1.Element;
+export declare const InputGroup: typeof InputGroupRoot & {
+  Root: typeof InputGroupRoot;
+  Addon: typeof InputGroupAddon;
+};
+//#endregion
 //#region src/components/json-tree-view/index.d.ts
 /** Ark's JsonTreeView, dressed in the paper-and-ink system: the tree-view
  * recipes re-scoped, with value nodes reading as tabular data. The API is
@@ -13572,6 +14198,66 @@ export declare const JsonTreeView: typeof JsonTreeView$1;
 export type KbdProps = JSX$1.HTMLAttributes<HTMLElement>;
 export declare function Kbd(props: KbdProps): JSX$1.Element;
 //#endregion
+//#region src/components/layout/index.d.ts
+export interface LayoutRootProps extends JSX$1.HTMLAttributes<HTMLDivElement> {
+  /** Declare which edge the skeleton reserves for its sider — without
+   * it the root is a single column. */
+  sider?: "start" | "end";
+}
+/** Which edge the enclosing root reserves for its rail — shared so the
+ * sider's resize handle knows which way the hand pulls. */
+export interface LayoutContextValue {
+  siderPlacement: () => "start" | "end" | undefined;
+}
+/**
+ * The application skeleton: Root, Header, Sider, Content, Footer —
+ * the admin arrangement (Element Plus / AntD keep the same anatomy)
+ * dressed in the paper-and-ink surfaces. The root is a full-height
+ * grid; a declared `sider` turns the columns around to meet whichever
+ * edge the rail stands on.
+ */
+declare function LayoutRoot(props: LayoutRootProps): JSX$1.Element;
+declare function LayoutHeader(props: JSX$1.HTMLAttributes<HTMLElement>): JSX$1.Element;
+declare function LayoutContent(props: JSX$1.HTMLAttributes<HTMLElement>): JSX$1.Element;
+declare function LayoutFooter(props: JSX$1.HTMLAttributes<HTMLElement>): JSX$1.Element;
+export interface LayoutSiderProps extends Omit<JSX$1.HTMLAttributes<HTMLElement>, "children"> {
+  /** The caller drives the fold; the sider mirrors it and echoes every
+   * change back through `onCollapsedChange`. */
+  collapsed?: boolean;
+  /** The rail's resting inline size — a layout parameter, not a visual
+   * token, so it rides an inline variable. */
+  width?: string;
+  /** The inline size when folded. */
+  collapsedWidth?: string;
+  /** Offer the hairline at the flow edge: the rail's width follows the
+   * hand (and the arrow keys), clamped by `min-width`/`max-width`, and
+   * every change rides `onWidthChange`. */
+  resizable?: boolean;
+  /** The rail's narrowest inline size while resizing. */
+  minWidth?: string;
+  /** The rail's widest inline size while resizing. */
+  maxWidth?: string;
+  /** The fold flipped. */
+  onCollapsedChange?: (collapsed: boolean) => void;
+  /** The rail's inline size changed — the hand, the arrow keys, or the
+   * caller's own width prop moving. */
+  onWidthChange?: (width: string) => void;
+  /** The children, or a function of the fold state — a rail can swap
+   * its labels for icons instead of being clipped mid-word by the
+   * narrowing edge. */
+  children?: JSX$1.Element | ((state: {
+    collapsed: boolean;
+  }) => JSX$1.Element);
+}
+declare function LayoutSider(props: LayoutSiderProps): JSX$1.Element;
+export declare const Layout: typeof LayoutRoot & {
+  Root: typeof LayoutRoot;
+  Header: typeof LayoutHeader;
+  Sider: typeof LayoutSider;
+  Content: typeof LayoutContent;
+  Footer: typeof LayoutFooter;
+};
+//#endregion
 //#region src/components/link/index.d.ts
 export interface LinkProps extends JSX$1.AnchorHTMLAttributes<HTMLAnchorElement> {
   underline?: "always" | "hover" | "none";
@@ -13581,6 +14267,31 @@ export interface LinkProps extends JSX$1.AnchorHTMLAttributes<HTMLAnchorElement>
  * always, on hover, or never. */
 export declare function Link(props: LinkProps): JSX$1.Element;
 //#endregion
+//#region src/components/list/index.d.ts
+export interface ListRootProps extends JSX$1.HTMLAttributes<HTMLUListElement> {
+  /** One hairline between rows. */
+  bordered?: boolean;
+  /** Every row answers the pointer with a wash. */
+  hoverable?: boolean;
+}
+declare function Root$1(props: ListRootProps): JSX$1.Element;
+export interface ListContentProps extends Omit<JSX$1.HTMLAttributes<HTMLDivElement>, "title"> {
+  /** The row's title, riding its own part above the words. */
+  title?: JSX$1.Element;
+  /** The quiet echo beneath the title. */
+  description?: JSX$1.Element;
+}
+/** The row's words: `title` and `description` ride their own named
+ * parts, the children follow them for anything else. */
+declare function Content(props: ListContentProps): JSX$1.Element;
+export declare const List: typeof Root$1 & {
+  Root: typeof Root$1;
+  Item: Component<JSX$1.HTMLAttributes<HTMLElement>>;
+  Leading: Component<JSX$1.HTMLAttributes<HTMLElement>>;
+  Content: typeof Content;
+  Actions: Component<JSX$1.HTMLAttributes<HTMLElement>>;
+};
+//#endregion
 //#region src/components/listbox/index.d.ts
 /** Ark's Listbox, dressed in the paper-and-ink system: quiet rows of ink
  * where the checked row alone takes the flat primary fill. The API is
@@ -13595,6 +14306,16 @@ export declare const Listbox: typeof Listbox$1;
  * cutting off. The API is Ark's own — Root, Viewport, Content, Edge, Item. */
 export declare const Marquee: typeof Marquee$1;
 //#endregion
+//#region src/components/masonry/index.d.ts
+/** A wall of uneven heights: items flow down each column before
+ * crossing to the next, so the order is column-first. A row-flow wall
+ * would need grid masonry, which browsers do not ship yet. */
+export interface MasonryProps extends JSX$1.HTMLAttributes<HTMLDivElement> {
+  columns?: number;
+  gap?: "none" | "xs" | "sm" | "md" | "lg" | "xl";
+}
+export declare function Masonry(props: MasonryProps): JSX$1.Element;
+//#endregion
 //#region src/components/menu/index.d.ts
 /** Ark's Menu, dressed in the paper-and-ink system: a quiet paper vessel on
  * elevation, hover as light on the row, checked items as the flat ink fill.
@@ -13603,8 +14324,128 @@ export declare const Marquee: typeof Marquee$1;
  * TriggerItem, Separator, Arrow, ArrowTip. */
 export declare const Menu: typeof Menu$1;
 //#endregion
+//#region src/components/menubar/index.d.ts
+export interface MenubarEntry {
+  label: string;
+  value: string;
+  danger?: boolean;
+  disabled?: boolean;
+}
+export interface MenubarGroup {
+  label: string;
+  items: MenubarEntry[];
+}
+export interface MenubarProps extends Omit<JSX$1.HTMLAttributes<HTMLDivElement>, "onSelect"> {
+  /** The menus across the bar, each with its entries. */
+  items?: MenubarGroup[];
+  /** Called with the entry's `value` when it is chosen. */
+  onSelect?: (value: string) => void;
+}
+/**
+ * A desktop-style menu bar: a row of quiet ghost triggers, each opening
+ * the same paper vessel as the menu family. The triggers are our own
+ * buttons grafted onto the menu machine's trigger via `asChild` — the
+ * machine keeps the trigger element (positioning, focus restore,
+ * `data-state`) while the element wears the menubar scope. The popups
+ * keep the menu parts untouched, so the menu stylesheet dresses them.
+ *
+ * Keyboard note: the triggers move between each other with Tab, not
+ * arrow keys — cross-menu arrow traversal is out of scope for this
+ * version. Inside an open menu the machine handles arrows and Escape.
+ */
+export declare function Menubar(props: MenubarProps): JSX$1.Element;
+//#endregion
+//#region src/components/mentions/use-mentions.d.ts
+interface UseMentionsOptions {
+  /** The candidates offered once the trigger character is typed. */
+  items: MentionEntry[];
+  /** The character that summons the candidates. */
+  trigger?: string;
+}
+interface UseMentionsHandlers {
+  /** The text the field holds right now — read at keystroke time, never
+   * from a controlled prop that lags a render behind the caret. */
+  getText: () => string;
+  /** Writes the field's next text: a mention inserted at the token. */
+  setText: (value: string) => void;
+}
+/** The @-detection machinery behind a mention field: watch the caret,
+ * offer the matching candidates, and answer for the keys that drive
+ * them. The field element arrives as an accessor because hosts wrap it
+ * differently (a bare textarea, a field's own part).
+ *
+ * `onKeydown` answers whether the vessel consumed the key, so a host
+ * with its own Enter semantics — a composer that sends — can yield to
+ * the candidates first and act only when the vessel stands down. */
+export declare function useMentions(options: Accessor<UseMentionsOptions>, textarea: Accessor<HTMLTextAreaElement | null>, handlers: UseMentionsHandlers): {
+  open: Accessor<boolean>;
+  matches: Accessor<MentionEntry[]>;
+  active: Accessor<number>;
+  setActive: import("solid-js").Setter<number>;
+  insert: (entry: MentionEntry) => void;
+  close: () => void;
+  onInput: () => void;
+  onKeydown: (event: KeyboardEvent) => boolean;
+};
+//#endregion
+//#region src/components/mentions/index.d.ts
+export interface MentionEntry {
+  label: string;
+  value: string;
+}
+export interface MentionsVesselProps {
+  open?: boolean;
+  matches?: MentionEntry[];
+  active?: number;
+  /** The live element the vessel points at — the anchor is virtual, a
+   * rectangle read off the host's field. */
+  anchor?: HTMLTextAreaElement | null;
+  onInsert?: (entry: MentionEntry) => void;
+  onActiveChange?: (index: number) => void;
+  onOpenChange?: (open: boolean) => void;
+}
+/** The vessel: the candidates themselves as a floating card. The anchor
+ * is virtual — a live rectangle off the host's field — so a host keeps
+ * its own anatomy (the textarea rides where the host puts it) and the
+ * vessel still points at the right place. Shares the detection state
+ * with the host through `useMentions`. */
+export declare function MentionsVessel(props: MentionsVesselProps): JSX$1.Element;
+export interface MentionsProps extends Omit<JSX$1.HTMLAttributes<HTMLDivElement>, "onInput"> {
+  /** The candidates offered once the trigger character is typed. */
+  items?: MentionEntry[];
+  /** The text held by the field. Supply it to control the field;
+   * changes are reported through `onValueChange`. */
+  value?: string;
+  /** The character that summons the candidates. */
+  trigger?: string;
+  placeholder?: string;
+  /** Let the field grow with its text instead of holding `rows`. */
+  autoresize?: boolean;
+  /** Standing alone, the field styles itself from this flag; inside a
+   * `Field.Root` the field's own invalid state takes over. */
+  invalid?: boolean;
+  /** The field's text changed. */
+  onValueChange?: (value: string) => void;
+}
+/**
+ * @-mentions: a plain textarea that, when the text before the caret ends
+ * with the trigger character followed by a token, offers the matching
+ * candidates in a small anchored vessel; choosing one replaces the token
+ * with `trigger + label` and hands the whole text back through
+ * `onValueChange`. Arrows move, Enter inserts, Escape dismisses.
+ *
+ * The field is the shared `Textarea` — field wiring (label ids, the
+ * invalid state) rides on it for free — and the vessel anchors to the
+ * field as a whole (popover machinery), not to the caret coordinates;
+ * caret-precise positioning would need a second positioning system for
+ * no practical gain at typical field sizes. Composers that keep their
+ * own field anatomy (the AI prompt input) skip this shell and wire
+ * `useMentions` plus `MentionsVessel` themselves.
+ */
+export declare function Mentions(props: MentionsProps): JSX$1.Element;
+//#endregion
 //#region src/components/meter/index.d.ts
-export interface MeterRootProps extends JSX$1.HTMLAttributes<HTMLElement> {
+export interface MeterRootProps extends JSX$1.HTMLAttributes<HTMLDivElement> {
   /** The measured value — clamped between min and max. */
   value: number;
   min?: number;
@@ -13667,6 +14508,22 @@ export declare const PasswordInput: typeof PasswordInput$1;
  * Root, Label, Control, Input, HiddenInput. */
 export declare const PinInput: typeof PinInput$1;
 //#endregion
+//#region src/components/popconfirm/index.d.ts
+export interface PopconfirmProps extends JSX$1.HTMLAttributes<HTMLButtonElement> {
+  /** The question the reader is answering. */
+  message: string;
+  confirmText?: string;
+  cancelText?: string;
+  onConfirm?: () => void;
+  onCancel?: () => void;
+}
+/** A question at the point of no return: the trigger opens a small
+ * anchored vessel carrying the message and two answers. Confirmation
+ * and cancellation are the caller's to act on — the panel closes
+ * either way. The children are the trigger's content, riding the
+ * machine-driven trigger button. */
+export declare function Popconfirm(props: PopconfirmProps): JSX$1.Element;
+//#endregion
 //#region src/components/popover/index.d.ts
 /** Ark's Popover, dressed in the paper-and-ink system: a paper vessel that
  * dissolves in on elevation, anchored to its trigger by a whisker arrow. The
@@ -13681,6 +14538,27 @@ export declare const Popover: typeof Popover$1;
  * CircleTrack, CircleRange. */
 export declare const Progress: typeof Progress$1;
 //#endregion
+//#region src/components/progress-group/index.d.ts
+/** One verdict on the bar. */
+export interface ProgressSegment {
+  value: number;
+  label?: string;
+  pigment?: "primary" | "success" | "warning" | "danger" | "info";
+}
+/**
+ * One bar, several verdicts: the segments stand shoulder to shoulder,
+ * each as wide as its share of the whole and speaking its own pigment;
+ * the legend reads them back beneath (swatch, label, value) unless the
+ * caller declines it. The whole is the sum of the parts unless the
+ * caller brings a larger one — the remainder then shows as groove.
+ */
+export interface ProgressGroupProps extends JSX$1.HTMLAttributes<HTMLDivElement> {
+  segments: ProgressSegment[];
+  max?: number;
+  showLegend?: boolean;
+}
+export declare function ProgressGroup(props: ProgressGroupProps): JSX$1.Element;
+//#endregion
 //#region src/components/qr-code/index.d.ts
 /** Ark's QrCode, dressed in the paper-and-ink system: the pattern prints in
  * ink on the page, with an optional paper badge and a seal-cut download
@@ -13761,25 +14639,71 @@ export interface SpinnerProps extends JSX$1.HTMLAttributes<HTMLElement> {
  * default — it reports progress without claiming attention. */
 export declare function Spinner(props: SpinnerProps): JSX$1.Element;
 //#endregion
+//#region src/components/split-button/index.d.ts
+export interface SplitButtonEntry {
+  label: string;
+  /** Handed back with `onSelect` when the entry is chosen. */
+  value: string;
+  danger?: boolean;
+  disabled?: boolean;
+}
+export interface SplitButtonProps extends Omit<JSX$1.HTMLAttributes<HTMLDivElement>, "onClick" | "onSelect"> {
+  /** The main action's label. */
+  label: string;
+  /** The dropdown's entries. */
+  items?: SplitButtonEntry[];
+  /** How both halves rest; the arrow always reads as one control with
+   * the main button. */
+  variant?: "solid" | "outline" | "ghost" | "subtle";
+  tone?: "ink" | "info" | "success" | "warning" | "danger";
+  size?: "sm" | "md" | "lg";
+  disabled?: boolean;
+  /** The main button was pressed. */
+  onClick?: (event: MouseEvent) => void;
+  /** An entry was chosen; carries its `value`. */
+  onSelect?: (value: string) => void;
+}
+/**
+ * A primary action with its alternatives one seam away: the main button
+ * fires `onClick`, the fitted arrow opens a paper vessel of the same
+ * register whose entries call `onSelect` with their value. The arrow is
+ * the menu machine's trigger with the button recipe riding over it —
+ * the machine keeps the element (positioning, focus, `data-state`), the
+ * button stylesheet's trigger register dresses it. The popup keeps the
+ * menu parts untouched.
+ */
+export declare function SplitButton(props: SplitButtonProps): JSX$1.Element;
+//#endregion
 //#region src/components/splitter/index.d.ts
 /** Ark's Splitter, dressed in the paper-and-ink system: panels divide on
  * a hairline and a small paper-seal thumb answers the hand. The API is
  * Ark's own — Root, Panel, ResizeTrigger, ResizeTriggerIndicator. */
 export declare const Splitter: typeof Splitter$1;
 //#endregion
+//#region src/components/stack/index.d.ts
+export interface StackProps extends JSX$1.HTMLAttributes<HTMLDivElement> {
+  direction?: "column" | "row";
+  gap?: "none" | "xs" | "sm" | "md" | "lg" | "xl";
+  wrap?: boolean;
+  align?: string;
+  justify?: string;
+}
+export declare function Stack(props: StackProps): JSX$1.Element;
+//#endregion
 //#region src/components/stat/index.d.ts
 export interface StatDeltaProps extends JSX$1.HTMLAttributes<HTMLElement> {
   direction?: "up" | "down" | "flat";
+  "data-direction"?: string;
 }
 /** The delta reads the direction in the fixed semantic pigments; an
  * explicit `data-direction` attribute on the consumer side still wins. */
 declare function Delta(props: StatDeltaProps): JSX$1.Element;
-export declare const Stat: ((props: JSX$1.HTMLAttributes<HTMLElement>) => JSX$1.Element) & {
-  Root: (props: JSX$1.HTMLAttributes<HTMLElement>) => JSX$1.Element;
-  Label: (props: JSX$1.HTMLAttributes<HTMLElement>) => JSX$1.Element;
-  Value: (props: JSX$1.HTMLAttributes<HTMLElement>) => JSX$1.Element;
+export declare const Stat: ((props: JSX$1.HTMLAttributes<HTMLDivElement>) => JSX$1.Element) & {
+  Root: (props: JSX$1.HTMLAttributes<HTMLDivElement>) => JSX$1.Element;
+  Label: (props: JSX$1.HTMLAttributes<HTMLDivElement>) => JSX$1.Element;
+  Value: (props: JSX$1.HTMLAttributes<HTMLDivElement>) => JSX$1.Element;
   Delta: typeof Delta;
-  Description: (props: JSX$1.HTMLAttributes<HTMLElement>) => JSX$1.Element;
+  Description: (props: JSX$1.HTMLAttributes<HTMLDivElement>) => JSX$1.Element;
 };
 //#endregion
 //#region src/components/steps/index.d.ts
@@ -13892,6 +14816,19 @@ export declare const Tabs: typeof Tabs$1;
  * Context. */
 export declare const TagsInput: typeof TagsInput$1;
 //#endregion
+//#region src/components/textarea/index.d.ts
+export interface TextareaProps extends JSX$1.TextareaHTMLAttributes<HTMLTextAreaElement> {
+  value?: string;
+  onValueChange?: (value: string) => void;
+  invalid?: boolean;
+}
+/** The bare multi-line input: the field recipe on a `<textarea>`, sized
+ * by rows and resizable in the block direction. Standing alone it styles
+ * itself from the `invalid` prop; inside a `Field.Root` it consumes the
+ * field context, picking up the label id, the described-by wiring and
+ * the invalid state for free. Disabled rides the native attribute. */
+export declare function Textarea(props: TextareaProps): JSX$1.Element;
+//#endregion
 //#region src/components/timeline/index.d.ts
 export declare const Timeline: Component<Record<string, unknown>> & {
   Root: Component<Record<string, unknown>>;
@@ -13929,13 +14866,13 @@ export declare const Toc: typeof Toc$1;
 export declare const Toggle: typeof Toggle$1;
 //#endregion
 //#region src/components/typography/index.d.ts
-export declare const Typography: ((props: JSX$1.HTMLAttributes<HTMLElement>) => JSX$1.Element) & {
-  Display: (props: JSX$1.HTMLAttributes<HTMLElement>) => JSX$1.Element;
-  Heading: (props: JSX$1.HTMLAttributes<HTMLElement>) => JSX$1.Element;
-  Lead: (props: JSX$1.HTMLAttributes<HTMLElement>) => JSX$1.Element;
-  Body: (props: JSX$1.HTMLAttributes<HTMLElement>) => JSX$1.Element;
-  Muted: (props: JSX$1.HTMLAttributes<HTMLElement>) => JSX$1.Element;
-  Label: (props: JSX$1.HTMLAttributes<HTMLElement>) => JSX$1.Element;
+export declare const Typography: ((props: JSX$1.HTMLAttributes<HTMLParagraphElement>) => JSX$1.Element) & {
+  Display: (props: JSX$1.HTMLAttributes<HTMLParagraphElement>) => JSX$1.Element;
+  Heading: (props: JSX$1.HTMLAttributes<HTMLParagraphElement>) => JSX$1.Element;
+  Lead: (props: JSX$1.HTMLAttributes<HTMLParagraphElement>) => JSX$1.Element;
+  Body: (props: JSX$1.HTMLAttributes<HTMLParagraphElement>) => JSX$1.Element;
+  Muted: (props: JSX$1.HTMLAttributes<HTMLParagraphElement>) => JSX$1.Element;
+  Label: (props: JSX$1.HTMLAttributes<HTMLParagraphElement>) => JSX$1.Element;
 };
 //#endregion
 //#region src/components/toggle-group/index.d.ts
@@ -13944,6 +14881,29 @@ export declare const Typography: ((props: JSX$1.HTMLAttributes<HTMLElement>) =>
  * Ark's own — Root, Item. */
 export declare const ToggleGroup: typeof ToggleGroup$1;
 //#endregion
+//#region src/components/transfer/index.d.ts
+export interface TransferItem {
+  label: string;
+  value: string;
+  disabled?: boolean;
+}
+export interface TransferProps extends JSX$1.HTMLAttributes<HTMLDivElement> {
+  value?: string[];
+  data: TransferItem[];
+  titles?: string[];
+  searchable?: boolean;
+  disabled?: boolean;
+  onValueChange?: (value: string[]) => void;
+}
+/**
+ * Two ledgers and a crossing: items sit in the source column until the
+ * reader checks them and walks them across — and back, the same way.
+ * `value` is the target column's value list; everything else in
+ * `data` stays on the left. `searchable` adds a filter line to each
+ * panel.
+ */
+export declare function Transfer(props: TransferProps): JSX$1.Element;
+//#endregion
 //#region src/components/tooltip/index.d.ts
 /** Ark's Tooltip, dressed in the paper-and-ink system: the smallest
  * vessel — a tight chip of ink that dissolves in over its anchor. The
@@ -13959,6 +14919,28 @@ export declare const Tooltip: typeof Tooltip$1;
  * useTour. */
 export declare const Tour: typeof Tour$1;
 //#endregion
+//#region src/components/tree-select/index.d.ts
+export interface TreeSelectNode {
+  label: string;
+  value: string;
+  children?: TreeSelectNode[];
+  disabled?: boolean;
+}
+export interface TreeSelectProps extends JSX$1.HTMLAttributes<HTMLDivElement> {
+  value?: string;
+  data: TreeSelectNode[];
+  placeholder?: string;
+  disabled?: boolean;
+  onValueChange?: (value: string) => void;
+}
+/**
+ * A tree behind a field: the control reads like an input, the vessel
+ * below walks the hierarchy, and one leaf click closes the deal. Single
+ * selection — the chosen label rides on the control, its value rides in
+ * `value`.
+ */
+export declare function TreeSelect(props: TreeSelectProps): JSX$1.Element;
+//#endregion
 //#region src/components/tree-view/index.d.ts
 /** Ark's TreeView, dressed in the paper-and-ink system: quiet rows where
  * selection is pure light on the paper, one hairline plumb line per depth,
@@ -13969,4 +14951,20 @@ export declare const Tour: typeof Tour$1;
  * NodeRenameInput, plus createTreeCollection. */
 export declare const TreeView: typeof TreeView$1;
 //#endregion
-export { Card$1 as Card, type ColumnDef, type CreateToasterReturn, type DataUIPart, type DateInputFocusChangeDetails, type DateInputValueChangeDetails, type DatePickerFocusChangeDetails, type DatePickerOpenChangeDetails, type DatePickerValueChangeDetails, type DatePickerViewChangeDetails, type DatePickerVisibleRangeChangeDetails, type DialogOpenChangeDetails, type FileUIPart, FlexRender, type ReasoningUIPart, Response$1 as Response, type SortingState, type SourceDocumentUIPart, type SourceUrlUIPart, type StepStartUIPart, type TextUIPart, type ToolUIPart, type TourInteractOutsideEvent, type TourPointerDownOutsideEvent, type TourStepDetails, type TreeViewCheckedChangeDetails, type TreeViewExpandedChangeDetails, type TreeViewFocusChangeDetails, type TreeViewSelectionChangeDetails, type UIMessage, type UIMessagePart, createColumnHelper, createListCollection, createToaster, useTour };
+//#region src/components/watermark/index.d.ts
+/**
+ * The paper bears its seal beneath the content: a canvas draws the
+ * text once into a tile (rotated, faint, crisp at the screen's pixel
+ * density) and the marks layer repeats it over the children. The
+ * seal redraws itself when a prop turns — and it never takes a
+ * pointer.
+ */
+export interface WatermarkProps extends JSX$1.HTMLAttributes<HTMLDivElement> {
+  content: string;
+  opacity?: number;
+  rotate?: number;
+  fontSize?: string;
+}
+export declare function Watermark(props: WatermarkProps): JSX$1.Element;
+//#endregion
+export { Action as AiAction, Attachment as AiAttachment, Attachments as AiAttachments, Message as AiMessage, PromptInput as AiPromptInput, Reasoning as AiReasoning, Response$1 as AiResponse, Response$1 as Response, Source as AiSource, Sources as AiSources, Suggestion as AiSuggestion, Tool as AiTool, Card$1 as Card, ClientOnly, type ClientOnlyProps, type CollectionItem, type CollectionOptions, type ColumnDef, type CreateToasterReturn, type DataUIPart, type DateInputFocusChangeDetails, type DateInputValueChangeDetails, type DatePickerFocusChangeDetails, type DatePickerOpenChangeDetails, type DatePickerValueChangeDetails, type DatePickerViewChangeDetails, type DatePickerVisibleRangeChangeDetails, type DialogOpenChangeDetails, DownloadTrigger, type DownloadTriggerBaseProps, type DownloadTriggerProps, type DownloadableData, type FilePathTreeNode, type FileUIPart, type FlatTreeNode, FlexRender, FocusTrap, type FocusTrapBaseProps, type FocusTrapProps, type GridCollection, type GridCollectionOptions, type ListCollection, Presence, type PresenceProps, PresenceProvider, type ReasoningUIPart, type SortingState, type SourceDocumentUIPart, type SourceUrlUIPart, type StepStartUIPart, type TextUIPart, type ToolUIPart, type TourInteractOutsideEvent, type TourPointerDownOutsideEvent, type TourStepDetails, type TreeCollection, type TreeCollectionOptions, type TreeNode, type TreeViewCheckedChangeDetails, type TreeViewExpandedChangeDetails, type TreeViewFocusChangeDetails, type TreeViewSelectionChangeDetails, type UIMessage, type UIMessagePart, type UseAsyncListProps, type UseAsyncListReturn, type UseDownloadProps, type UseDownloadReturn, type UseListCollectionProps, type UseListCollectionReturn, type UseListSelectionProps, type UseListSelectionReturn, type UseMentionsHandlers, type UseMentionsOptions, type UsePresenceContext, type UsePresenceProps, type UsePresenceReturn, createColumnHelper, createFileTreeCollection, createGridCollection, createToaster, createTreeCollection, useAsyncList, useDownload, useListCollection, useListSelection, usePresence, usePresenceContext, useTour };