@bysages/react 0.0.1 → 0.1.1

package/dist/index.d.mts

@@ -1,27 +1,32 @@
 import { Accordion as Accordion$1 } from "@ark-ui/react/accordion";
-import { AnchorHTMLAttributes, ButtonHTMLAttributes, CSSProperties, HTMLAttributes, ReactNode } from "react";
-import { Collapsible as Collapsible$1 } from "@ark-ui/react/collapsible";
+import { AnchorHTMLAttributes, ButtonHTMLAttributes, CSSProperties, HTMLAttributes, InputHTMLAttributes, ReactNode, Ref, TextareaHTMLAttributes } from "react";
 import { Field as Field$1 } from "@ark-ui/react/field";
+import { Popover as Popover$1 } from "@ark-ui/react/popover";
+import { Collapsible as Collapsible$1 } from "@ark-ui/react/collapsible";
 import { AngleSlider as AngleSlider$1 } from "@ark-ui/react/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/react/collection";
+import { Combobox as Combobox$1 } from "@ark-ui/react/combobox";
 import { Avatar as Avatar$1 } from "@ark-ui/react/avatar";
 import { DatePicker as DatePicker$1, DatePickerFocusChangeDetails, DatePickerOpenChangeDetails, DatePickerRootProps, DatePickerValueChangeDetails, DatePickerViewChangeDetails, DatePickerVisibleRangeChangeDetails } from "@ark-ui/react/date-picker";
 import { Carousel as Carousel$1 } from "@ark-ui/react/carousel";
 import { Checkbox as Checkbox$1 } from "@ark-ui/react/checkbox";
 import { Clipboard as Clipboard$1 } from "@ark-ui/react/clipboard";
+import { ClientOnly, ClientOnlyProps } from "@ark-ui/react/client-only";
 import { ColorPicker as ColorPicker$1 } from "@ark-ui/react/color-picker";
-import { Combobox as Combobox$1 } from "@ark-ui/react/combobox";
-import { DateInput as DateInput$1, DateInputFocusChangeDetails, DateInputValueChangeDetails } from "@ark-ui/react/date-input";
 import { Dialog as Dialog$1, DialogOpenChangeDetails } from "@ark-ui/react/dialog";
+import { DateInput as DateInput$1, DateInputFocusChangeDetails, DateInputValueChangeDetails } from "@ark-ui/react/date-input";
+import { DownloadTrigger, DownloadTriggerBaseProps, DownloadTriggerProps, DownloadableData, UseDownloadProps, UseDownloadReturn, useDownload } from "@ark-ui/react/download-trigger";
 import { Drawer as Drawer$1 } from "@ark-ui/react/drawer";
 import { Editable as Editable$1 } from "@ark-ui/react/editable";
 import { Fieldset as Fieldset$1 } from "@ark-ui/react/fieldset";
 import { FileUpload as FileUpload$1 } from "@ark-ui/react/file-upload";
 import { FloatingPanel as FloatingPanel$1 } from "@ark-ui/react/floating-panel";
+import { FocusTrap, FocusTrapBaseProps, FocusTrapProps } from "@ark-ui/react/focus-trap";
 import { Format as Format$1 } from "@ark-ui/react/format";
 import { HoverCard as HoverCard$1 } from "@ark-ui/react/hover-card";
 import { ImageCropper as ImageCropper$1 } from "@ark-ui/react/image-cropper";
 import { JsonTreeView as JsonTreeView$1 } from "@ark-ui/react/json-tree-view";
-import { Listbox as Listbox$1, createListCollection } from "@ark-ui/react/listbox";
+import { Listbox as Listbox$1 } from "@ark-ui/react/listbox";
 import { Marquee as Marquee$1 } from "@ark-ui/react/marquee";
 import { Menu as Menu$1 } from "@ark-ui/react/menu";
 import { NavigationMenu as NavigationMenu$1 } from "@ark-ui/react/navigation-menu";
@@ -29,7 +34,7 @@ import { NumberInput as NumberInput$1 } from "@ark-ui/react/number-input";
 import { Pagination as Pagination$1 } from "@ark-ui/react/pagination";
 import { PasswordInput as PasswordInput$1 } from "@ark-ui/react/password-input";
 import { PinInput as PinInput$1 } from "@ark-ui/react/pin-input";
-import { Popover as Popover$1 } from "@ark-ui/react/popover";
+import { Presence, PresenceBaseProps, PresenceProps, PresenceProvider, UsePresenceContext, UsePresenceProps, UsePresenceReturn, usePresence, usePresenceContext } from "@ark-ui/react/presence";
 import { Progress as Progress$1 } from "@ark-ui/react/progress";
 import { QrCode as QrCode$1 } from "@ark-ui/react/qr-code";
 import { RadioGroup as RadioGroup$1 } from "@ark-ui/react/radio-group";
@@ -63,6 +68,264 @@ export * from "@bysages/core";
  * 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
+/**
+ * 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 interface AffixProps extends 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;
+}
+export declare function Affix({ offsetTop, offsetBottom, ...rest }: AffixProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/ai-action/index.d.ts
+/** 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 interface ActionProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+  /** What the button does, spoken to assistive tech and shown as the
+   * hover title — copy, retry, thumbs. */
+  label: string;
+  children?: ReactNode;
+}
+export declare function Action({ label, children, ...rest }: ActionProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/ai-message/index.d.ts
+/** Whose stroke this is — the user's words sit in a recessed bubble,
+ * the assistant speaks flat on the paper. */
+export interface MessageProps extends HTMLAttributes<HTMLElement> {
+  role?: "user" | "assistant" | "system";
+  children?: ReactNode;
+}
+export declare function Message({ role, children, ...rest }: MessageProps): import("react").JSX.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;
+}
+/** Whatever carries a key press — a native KeyboardEvent or a React
+ * synthetic one; the detector only needs the key's name and the power
+ * to hold the key back. */
+interface MentionKeyEvent {
+  key: string;
+  preventDefault: () => 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 a getter because hosts wrap it
+ * differently (a bare textarea, a field part's ref).
+ *
+ * `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: UseMentionsOptions | (() => UseMentionsOptions), textarea: () => HTMLTextAreaElement | null, handlers: UseMentionsHandlers): {
+  open: boolean;
+  matches: MentionEntry[];
+  active: number;
+  setActive: import("react").Dispatch<import("react").SetStateAction<number>>;
+  insert: (entry: MentionEntry) => void;
+  close: () => void;
+  onInput: () => void;
+  onKeydown: (event: MentionKeyEvent) => boolean;
+};
+//#endregion
+//#region src/components/mentions/index.d.ts
+export interface MentionEntry {
+  label: string;
+  value: string;
+}
+export interface MentionsVesselProps {
+  /** Whether the candidates are up. */
+  open?: boolean;
+  /** The candidates on offer. */
+  matches?: MentionEntry[];
+  /** The keyboard's active row. */
+  active?: number;
+  /** The rectangle the vessel points at — the host's textarea. */
+  anchor?: HTMLTextAreaElement | null;
+  /** A candidate was chosen. */
+  onInsert?: (entry: MentionEntry) => void;
+  /** The pointer moved to a row. */
+  onActiveChange?: (index: number) => void;
+  /** The vessel was dismissed. */
+  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({ open, matches, active, anchor, onInsert, onActiveChange, onOpenChange }: MentionsVesselProps): import("react").JSX.Element;
+/**
+ * @-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 `Field.Textarea` — field wiring (label ids,
+ * the invalid state, autoresize) 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 interface MentionsProps extends HTMLAttributes<HTMLDivElement> {
+  /** 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 via `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;
+  /** Reports the field's next text. */
+  onValueChange?: (value: string) => void;
+}
+export declare function Mentions({ items, value, trigger, placeholder, autoresize, invalid, onValueChange, children, ...rest }: MentionsProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/ai-prompt-input/index.d.ts
+/**
+ * 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, 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. Controlled — bind `value` and take the text on
+ * `submit`. Enter sends; Shift+Enter breaks the line. While `busy`
+ * the seal becomes a stop seal and Enter holds its breath.
+ */
+export interface PromptInputProps extends Omit<HTMLAttributes<HTMLFormElement>, "onSubmit"> {
+  /** 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;
+  /** Mention candidates for the field: pass the roster and the summon
+   * character (`@` unless told otherwise) and the vessel rides the
+   * textarea. While candidates are up, Enter inserts and the send
+   * waits. */
+  mentions?: {
+    items: MentionEntry[];
+    trigger?: string;
+  };
+  header?: ReactNode;
+  leading?: ReactNode;
+  trailing?: ReactNode;
+  footer?: ReactNode;
+  footerEnd?: ReactNode;
+}
+export declare function PromptInput({ value, onValueChange, onSubmit, onStop, placeholder, disabled, busy, mentions, header, leading, trailing, footer, footerEnd, ...rest }: PromptInputProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/ai-reasoning/index.d.ts
+/** The model's thought, folded by the shared collapsible in its quiet
+ * register: bare ink for a trigger, the thought on one hairline. */
+export interface ReasoningProps extends HTMLAttributes<HTMLDivElement> {
+  /** The trigger's words — the fold arrives open under them. */
+  label?: string;
+  defaultOpen?: boolean;
+  children?: ReactNode;
+}
+export declare function Reasoning({ label, children, ...rest }: ReasoningProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/ai-response/index.d.ts
+/** Markdown set on the paper. Rendering goes through
+ * `@tanstack/markdown`, whose defaults leave raw HTML and executable
+ * links inert — streaming-safe by construction. An optional
+ * highlighter re-inks fenced code; the component stays agnostic about
+ * which engine provides it. */
+export interface ResponseProps extends 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;
+}
+declare function Response$1({ content, highlighter, ...rest }: ResponseProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/ai-source/index.d.ts
+/** One place the ink came from; href and the rest ride the anchor. */
+export interface SourceProps extends 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;
+  children?: ReactNode;
+}
+export declare function Source({ href, children, ...rest }: SourceProps): import("react").JSX.Element;
+/** The reading list under a response: where this ink came from. */
+export interface SourcesProps extends HTMLAttributes<HTMLOListElement> {
+  children?: ReactNode;
+}
+export declare function Sources({ children, ...rest }: SourcesProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/ai-suggestion/index.d.ts
+/** A seal-cut button proposing the next stroke; selection hands back
+ * the prompt. The shared Button in its outline register. */
+export interface SuggestionProps extends Omit<HTMLAttributes<HTMLButtonElement>, "onSelect"> {
+  /** The next stroke this seal proposes — also its label; handed back
+   * whole on `onSelect`. */
+  prompt: string;
+  onSelect?: (prompt: string) => void;
+}
+export declare function Suggestion({ prompt, onSelect, ...rest }: SuggestionProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/ai-tool/index.d.ts
+export type ToolStatus = "pending" | "running" | "completed" | "error";
+/** 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 interface ToolProps extends HTMLAttributes<HTMLDivElement> {
+  /** The name the tool was reached by — shown raw on the trigger
+   * unless a `label` speaks friendlier words ("Searching pages…"). */
+  name: string;
+  label?: ReactNode;
+  /** The state the call reached — pending, running, completed, or
+   * error; stamped on the fold and whispered in the status chip. */
+  status?: ToolStatus;
+  defaultOpen?: boolean;
+  input?: ReactNode;
+  output?: ReactNode;
+}
+export declare function Tool({ name, label, status, input, output, ...rest }: ToolProps): import("react").JSX.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.
@@ -7584,7 +7847,7 @@ interface ToJSONSchemaContext {
   } | undefined;
 }
 declare namespace util_d_exports {
-  export { AnyFunc, AssertEqual$1 as AssertEqual, AssertExtends, AssertNotEqual, BIGINT_FORMAT_RANGES, BuiltIn, CONSTANT_CATCH, Class, CleanKey, Constructor, EmptyObject, EmptyToNever, EnumLike, EnumValue, Exactly, Extend, ExtractIndexSignature, Flatten, FromCleanMap, HasLength, HasSize, HashAlgorithm, HashEncoding, HashFormat, IPVersion, Identity, InexactPartial, IsAny$1 as IsAny, IsProp, JSONType, JWTAlgorithm, KeyOf, Keys, KeysArray, KeysEnum, Literal, LiteralArray, LoosePartial, MakePartial, MakeReadonly, MakeRequired, Mapped, Mask, MaybeAsync, MimeTypes, NUMBER_FORMAT_RANGES, NoNever, NoNeverKeys, NoUndefined, Normalize$1 as Normalize, Numeric, Omit$1 as Omit, OmitIndexSignature, OmitKeys, ParsedTypes, Prettify, Primitive, PrimitiveArray, PrimitiveSet, PropValues, ProtoOf, SafeParseError, SafeParseResult, SafeParseSuccess, SchemaClass, ShapeGetter, SomeObject, ToCleanMap, ToEnum, TupleItems, Whatever, Widen, Writeable, aborted, allowsEval, assert, assertEqual, assertIs, assertNever, assertNotEqual, assignProp, attachSchema, base64ToUint8Array, base64urlToUint8Array, cached, captureStackTrace, cleanEnum, cleanRegex, clone, cloneDef, codePointLength, constantCatch, createTransparentProxy, defineLazy, defineLazyInternal, derived, esc, escapeRegex, explicitlyAborted, extend, finalizeIssue, floatSafeRemainder, getElementAtPath, getEnumValues, getLengthableOrigin, getParsedType, getSizableOrigin, hexToUint8Array, hide, installLazyProp, isObject, isPlainObject, issue, joinValues, jsonStringifyReplacer, members, merge, mergeDefs, normalizeParams, nullish, numKeys, objectClone, omit, optionalKeys$1 as optionalKeys, own, parsedType, partial, pick, prefixIssues, primitiveTypes, promiseAllObject, propertyKeyTypes, randomString, rawShape, required, safeExtend, shallowClone, slugify, stringifyPrimitive, toZod, uint8ArrayToBase64, uint8ArrayToBase64url, uint8ArrayToHex, unwrapMessage };
+  export { AnyFunc, AssertEqual$1 as AssertEqual, AssertExtends, AssertNotEqual, BIGINT_FORMAT_RANGES, BuiltIn, CONSTANT_CATCH, Class, CleanKey, Constructor, EmptyObject, EmptyToNever, EnumLike, EnumValue, Exactly, Extend, ExtractIndexSignature, Flatten, FromCleanMap, HasLength, HasSize, HashAlgorithm, HashEncoding, HashFormat, IPVersion, Identity, InexactPartial, IsAny$1 as IsAny, IsProp, JSONType, JWTAlgorithm, KeyOf, Keys, KeysArray, KeysEnum, Literal, LiteralArray, LoosePartial, MakePartial, MakeReadonly, MakeRequired, Mapped, Mask, MaybeAsync, MimeTypes, NUMBER_FORMAT_RANGES, NoNever, NoNeverKeys, NoUndefined, Normalize$1 as Normalize, Numeric, Omit$1 as Omit, OmitIndexSignature, OmitKeys, ParsedTypes, Prettify, Primitive, PrimitiveArray, PrimitiveSet, PropValues, ProtoOf, SafeParseError, SafeParseResult, SafeParseSuccess, SchemaClass, ShapeGetter, SomeObject, ToCleanMap, ToEnum, TupleItems, Whatever, Widen, Writeable, aborted, allowsEval, assert, assertEqual, assertIs, assertNever, assertNotEqual, assignProp, attachSchema, base64ToUint8Array, base64urlToUint8Array, cached, captureStackTrace, cleanEnum, cleanRegex, clone, cloneDef, codePointLength, constantCatch, createTransparentProxy, defineLazy, defineLazyInternal, derived, esc, escapeRegex, explicitlyAborted, extend, finalizeIssue, floatSafeRemainder, getElementAtPath, getEnumValues, getLengthableOrigin, getParsedType, getSizableOrigin, hexToUint8Array, hide, installLazyProp, isObject, isPlainObject, issue, joinValues, jsonStringifyReplacer, members, merge, mergeDefs, normalizeParams, nullish, numKeys, objectClone, omit, optionalKeys$1 as optionalKeys, own, parsedType, partial, pick, prefixIssues, primitiveTypes, promiseAllObject, propertyKeyTypes, randomString, rawShape, required$1 as required, safeExtend, shallowClone, slugify, stringifyPrimitive, toZod, uint8ArrayToBase64, uint8ArrayToBase64url, uint8ArrayToHex, unwrapMessage };
 }
 type JSONType = string | number | boolean | null | JSONType[] | {
   [key: string]: JSONType;
@@ -7755,7 +8018,7 @@ declare function extend(schema: $ZodObject, shape: $ZodShape): any;
 declare function safeExtend(schema: $ZodObject, shape: $ZodShape): any;
 declare function merge(a: $ZodObject, b: $ZodObject): any;
 declare function partial(Class: SchemaClass<$ZodOptional> | null, schema: $ZodObject, mask: object | undefined, name?: string): any;
-declare function required(Class: SchemaClass<$ZodNonOptional>, schema: $ZodObject, mask: object | undefined): any;
+declare function required$1(Class: SchemaClass<$ZodNonOptional>, schema: $ZodObject, mask: object | undefined): any;
 type Constructor<T, Def extends any[] = any[]> = new (...args: Def) => T;
 declare function aborted(x: ParsePayload, startIndex?: number): boolean;
 declare function explicitlyAborted(x: ParsePayload, startIndex?: number): boolean;
@@ -10137,13 +10400,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.
  */
@@ -13192,76 +13455,8 @@ declare global {
 }
 //#endregion
 //#region src/components/ai/index.d.ts
-export type ToolStatus = "pending" | "running" | "completed" | "error";
-/** Whose stroke this is — the user's words sit in a recessed bubble,
- * the assistant speaks flat on the paper. */
-export interface MessageProps extends HTMLAttributes<HTMLElement> {
-  role?: "user" | "assistant" | "system";
-  children?: ReactNode;
-}
-export declare function Message({ role, children, ...rest }: MessageProps): import("react").JSX.Element;
-/** Markdown set on the paper. Rendering goes through
- * `@tanstack/markdown`, whose defaults leave raw HTML and executable
- * links inert — streaming-safe by construction. */
-export interface ResponseProps extends HTMLAttributes<HTMLDivElement> {
-  content: string;
-}
-declare function Response$1({ content, ...rest }: ResponseProps): import("react").JSX.Element;
-/** The model's thought, folded by the shared collapsible in its quiet
- * register: bare ink for a trigger, the thought on one hairline. */
-export interface ReasoningProps extends HTMLAttributes<HTMLDivElement> {
-  label?: string;
-  defaultOpen?: boolean;
-  children?: ReactNode;
-}
-export declare function Reasoning({ label, children, ...rest }: ReasoningProps): import("react").JSX.Element;
-/** 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 interface ToolProps extends HTMLAttributes<HTMLDivElement> {
-  name: string;
-  /** Friendlier trigger words than the raw tool name (a `label` slot
-   * in the Vue/Svelte wrappers). */
-  label?: ReactNode;
-  status?: ToolStatus;
-  defaultOpen?: boolean;
-  input?: ReactNode;
-  output?: ReactNode;
-}
-export declare function Tool({ name, label, status, input, output, ...rest }: ToolProps): import("react").JSX.Element;
-/** One place the ink came from; href and the rest ride the anchor. */
-export interface SourceProps extends HTMLAttributes<HTMLAnchorElement> {
-  href: string;
-  children?: ReactNode;
-}
-export declare function Source({ href, children, ...rest }: SourceProps): import("react").JSX.Element;
-/** 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 interface ActionProps extends HTMLAttributes<HTMLButtonElement> {
-  label: string;
-  children?: ReactNode;
-}
-export declare function Action({ label, children, ...rest }: ActionProps): import("react").JSX.Element;
-/** A seal-cut button proposing the next stroke; selection hands back
- * the prompt. The shared Button in its outline register. */
-export interface SuggestionProps extends Omit<HTMLAttributes<HTMLButtonElement>, "onSelect"> {
-  prompt: string;
-  onSelect?: (prompt: string) => void;
-}
-export declare function Suggestion({ prompt, onSelect, ...rest }: SuggestionProps): import("react").JSX.Element;
-/** 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 `submit`. Enter
- * sends; Shift+Enter breaks the line. */
-export interface PromptInputProps extends Omit<HTMLAttributes<HTMLFormElement>, "onSubmit"> {
-  value: string;
-  onValueChange?: (value: string) => void;
-  onSubmit?: (value: string) => void;
-  placeholder?: string;
-  disabled?: boolean;
-}
-export declare function PromptInput({ value, onValueChange, onSubmit, placeholder, disabled, ...rest }: PromptInputProps): import("react").JSX.Element;
+/** The whole family under one handle — `Ai.Conversation`,
+ * `Ai.Message`, and the rest, exactly as before the split. */
 export declare const Ai: {
   ({ children, ...rest }: HTMLAttributes<HTMLElement>): import("react").JSX.Element;
   displayName: string;
@@ -13270,32 +13465,46 @@ export declare const Ai: {
     ({ children, ...rest }: HTMLAttributes<HTMLElement>): import("react").JSX.Element;
     displayName: string;
   };
-  Message: typeof Message;
   MessageContent: {
     ({ children, ...rest }: HTMLAttributes<HTMLElement>): import("react").JSX.Element;
     displayName: string;
   };
-  Response: typeof Response$1;
-  Reasoning: typeof Reasoning;
-  Tool: typeof Tool;
-  Sources: {
+  Actions: {
     ({ children, ...rest }: HTMLAttributes<HTMLElement>): import("react").JSX.Element;
     displayName: string;
   };
-  Source: typeof Source;
-  Actions: {
+  Loader: {
     ({ children, ...rest }: HTMLAttributes<HTMLElement>): import("react").JSX.Element;
     displayName: string;
   };
+  Message: typeof Message;
+  Response: typeof Response$1;
+  Reasoning: typeof Reasoning;
+  Tool: typeof Tool;
+  Sources: typeof Sources;
+  Source: typeof Source;
   Action: typeof Action;
   Suggestion: typeof Suggestion;
   PromptInput: typeof PromptInput;
-  Loader: {
-    ({ children, ...rest }: HTMLAttributes<HTMLElement>): import("react").JSX.Element;
-    displayName: string;
-  };
 };
 //#endregion
+//#region src/components/ai-attachments/index.d.ts
+/** 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 interface AttachmentProps extends 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?: "uploading" | "ready" | "error";
+  onRemove?: () => void;
+}
+export declare function Attachment({ name, size, status, onRemove, ...rest }: AttachmentProps): import("react").JSX.Element;
+/** The row the files ride in — a wrapping line of chips. */
+export declare function Attachments({ children, ...rest }: HTMLAttributes<HTMLSpanElement>): import("react").JSX.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
@@ -13306,13 +13515,13 @@ export interface AlertProps extends HTMLAttributes<HTMLDivElement> {
   children?: ReactNode;
 }
 declare function AlertRoot({ status, children, ...rest }: AlertProps): import("react").JSX.Element;
-declare function Icon(): import("react").JSX.Element;
+declare function Icon$1(): import("react").JSX.Element;
 declare function Body({ children, ...rest }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
 declare function Title({ children, ...rest }: HTMLAttributes<HTMLParagraphElement>): import("react").JSX.Element;
 declare function Description({ children, ...rest }: HTMLAttributes<HTMLParagraphElement>): import("react").JSX.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;
@@ -13325,6 +13534,33 @@ 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 HTMLAttributes<HTMLDivElement> {
+  /** A CSS `aspect-ratio` value — "16 / 9", "4 / 3", "1 / 1". */
+  ratio?: string;
+}
+export declare function AspectRatio({ ratio, ...rest }: AspectRatioProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/autocomplete/index.d.ts
+/**
+ * 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 interface AutoCompleteProps extends Omit<HTMLAttributes<HTMLDivElement>, "defaultValue" | "onSelect"> {
+  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;
+}
+export declare function AutoComplete({ value, items, placeholder, filter, onValueChange, ...rest }: AutoCompleteProps): import("react").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
@@ -13337,6 +13573,28 @@ export declare const Avatar: typeof Avatar$1;
 export type AvatarGroupProps = HTMLAttributes<HTMLDivElement>;
 export declare function AvatarGroup({ children, ...rest }: AvatarGroupProps): import("react").JSX.Element;
 //#endregion
+//#region src/components/back-top/index.d.ts
+export interface BackTopProps extends 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({ threshold, label, ...rest }: BackTopProps): import("react").JSX.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. */
@@ -13395,6 +13653,29 @@ export interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
 }
 export declare function Button({ variant, tone, size, square, asChild, disabled, type, children, ...rest }: ButtonProps): import("react").JSX.Element | null;
 //#endregion
+//#region src/components/button-group/index.d.ts
+export interface ButtonGroupProps extends 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";
+  children?: ReactNode;
+}
+/**
+ * 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.
+ */
+declare function Root$3({ orientation, size, radius, children, ...rest }: ButtonGroupProps): import("react").JSX.Element;
+export declare const ButtonGroup: typeof Root$3 & {
+  Root: typeof Root$3;
+};
+//#endregion
 //#region src/components/banner/index.d.ts
 export type BannerStatus = "ink" | "info" | "success" | "warning" | "danger";
 export interface BannerRootProps extends HTMLAttributes<HTMLElement> {
@@ -13422,7 +13703,7 @@ export declare const Banner: (({ status, children, ...rest }: BannerRootProps) =
     ({ children, ...rest }: HTMLAttributes<HTMLElement>): import("react").JSX.Element;
     displayName: string;
   };
-  Close: ({ children, ...rest }: HTMLAttributes<HTMLButtonElement>) => import("react").JSX.Element;
+  Close: (rest: ButtonHTMLAttributes<HTMLButtonElement>) => import("react").JSX.Element;
 };
 //#endregion
 //#region src/components/calendar/index.d.ts
@@ -13485,6 +13766,31 @@ declare const Card$1: {
   };
 };
 //#endregion
+//#region src/components/cascade-select/index.d.ts
+export interface CascadeSelectNode {
+  label: string;
+  value: string;
+  children?: CascadeSelectNode[];
+  disabled?: boolean;
+}
+/**
+ * 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 interface CascadeSelectProps extends HTMLAttributes<HTMLDivElement> {
+  value?: string[][];
+  data: CascadeSelectNode[];
+  placeholder?: string;
+  highlightTrigger?: "click" | "hover";
+  multiple?: boolean;
+  disabled?: boolean;
+  onValueChange?: (value: string[][]) => void;
+}
+export declare function CascadeSelect({ value, data, placeholder, highlightTrigger, multiple, disabled, onValueChange, ...rest }: CascadeSelectProps): import("react").JSX.Element;
+//#endregion
 //#region src/components/carousel/index.d.ts
 /** Ark's Carousel, dressed in the paper-and-ink system: slides ride in one
  * hairline-clipped lane, the triggers are quiet outline controls, and the
@@ -13500,6 +13806,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 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({ value, options, layout, disabled, onValueChange, ...rest }: CheckboxGroupProps): import("react").JSX.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+"). */
@@ -13543,6 +13870,115 @@ 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;
+}
+/**
+ * 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 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 via `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
+   * via `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;
+  /** Reports the palette's next state. */
+  onOpenChange?: (open: boolean) => void;
+  /** Reports the field's live text. */
+  onInputValueChange?: (value: string) => void;
+}
+export declare function Command({ items, placeholder, open, autoFilter, inputValue, emptyText, onSelect, onOpenChange, onInputValueChange }: CommandProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/comment/index.d.ts
+/**
+ * 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 interface CommentProps extends HTMLAttributes<HTMLElement> {
+  author?: string;
+  datetime?: string;
+  /** The portrait at the row's head. */
+  avatar?: ReactNode;
+  /** The row of answers beneath the ink. */
+  actions?: ReactNode;
+}
+export declare function Comment({ author, datetime, avatar, actions, children, ...rest }: CommentProps): import("react").JSX.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;
+}
+/** 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 HTMLAttributes<HTMLDivElement> {
+  density?: ConfigDensity;
+  accent?: string;
+  dir?: "ltr" | "rtl";
+  locale?: string;
+  children?: ReactNode;
+}
+/**
+ * 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({ density, accent, dir, locale, children, ...rest }: ConfigProviderProps): import("react").JSX.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 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({ size, padding, ...rest }: ContainerProps): import("react").JSX.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
@@ -13559,6 +13995,30 @@ 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 HTMLAttributes<HTMLDListElement> {
+  layout?: "horizontal" | "vertical";
+}
+export declare function DescriptionsRoot({ layout, children, ...rest }: DescriptionsRootProps): import("react").JSX.Element;
+export declare const Descriptions: {
+  Root: typeof DescriptionsRoot;
+  Item: {
+    ({ children, ...rest }: HTMLAttributes<HTMLElement>): import("react").JSX.Element;
+    displayName: string;
+  };
+  Term: {
+    ({ children, ...rest }: HTMLAttributes<HTMLElement>): import("react").JSX.Element;
+    displayName: string;
+  };
+  Detail: {
+    ({ children, ...rest }: HTMLAttributes<HTMLElement>): import("react").JSX.Element;
+    displayName: string;
+  };
+};
+//#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
@@ -13574,6 +14034,31 @@ 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 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;
+  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
+ * reports a fresh array through `onValueChange` 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({ value, min, max, placeholder, addLabel, disabled, invalid, onValueChange, children: _children, ...rest }: DynamicInputProps): import("react").JSX.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 —
@@ -13581,6 +14066,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 HTMLAttributes<HTMLElement> {
+  lines?: number;
+}
+export declare function Ellipsis({ lines, ...rest }: EllipsisProps): import("react").JSX.Element;
+//#endregion
 //#region src/components/empty/index.d.ts
 export declare const Empty: {
   ({ children, ...rest }: HTMLAttributes<HTMLElement>): import("react").JSX.Element;
@@ -13630,6 +14124,58 @@ 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 FloatButtonContextValue {
+  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;
+}
+/** Context for {@link FloatButtonContextValue}, exported so a custom
+ * part can read the group's state. */
+export declare const FLOAT_BUTTON_CONTEXT: import("react").Context<FloatButtonContextValue | null>;
+export interface FloatButtonRootProps extends 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;
+  onOpenChange?: (open: boolean) => void;
+  children?: ReactNode;
+}
+/**
+ * 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 Root$2({ open: openProp, placement, onOpenChange, children, ...rest }: FloatButtonRootProps): import("react").JSX.Element;
+declare function Trigger({ label, children }: {
+  label?: string;
+  children?: ReactNode;
+}): import("react").JSX.Element;
+interface FloatButtonItemProps {
+  /** The action's name: the button's accessible name and the
+   * annotation surfaced beside it while the group is open. */
+  label: string;
+  disabled?: boolean;
+  onClick?: () => void;
+  children?: ReactNode;
+}
+declare function Item({ label, disabled, onClick, children }: FloatButtonItemProps): import("react").JSX.Element;
+export declare const FloatButton: typeof Root$2 & {
+  Root: typeof Root$2;
+  Trigger: typeof Trigger;
+  Item: typeof Item;
+};
+//#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
@@ -13638,6 +14184,79 @@ export declare const FileUpload: typeof FileUpload$1;
  * Body. */
 export declare const FloatingPanel: typeof FloatingPanel$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 a caller holds through `ref`: the scheduled
+ * validation, the error surgery, and the live error map itself. */
+export interface FormHandle {
+  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<HTMLAttributes<HTMLFormElement>, "onSubmit" | "onError"> {
+  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;
+  ref?: Ref<FormHandle>;
+}
+/**
+ * The validation scheduler: one error map, a submit that validates
+ * before it fires, 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({ state, schema, validate, validateOn, disabled, onSubmit, onError, ref, children, ...rest }: FormProps): import("react").JSX.Element;
+/**
+ * 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 interface FormFieldProps extends HTMLAttributes<HTMLDivElement> {
+  name?: string;
+  label?: string;
+  hint?: string;
+  required?: boolean;
+  invalid?: boolean;
+  disabled?: boolean;
+  children?: ReactNode;
+}
+export declare function FormField({ name, label, hint, required, invalid, disabled, children, ...rest }: FormFieldProps): import("react").JSX.Element;
+//#endregion
 //#region src/components/format/index.d.ts
 /** Ark's Format, dressed in the paper-and-ink system: Intl formatting for
  * numbers, currency, bytes and relative time. The components render bare
@@ -13656,6 +14275,18 @@ export declare const Format: typeof Format$1;
  * to hook. The API is Ark's own. */
 export declare const Frame: import("react").ForwardRefExoticComponent<import("@ark-ui/react/frame").FrameProps & import("react").RefAttributes<HTMLIFrameElement>>;
 //#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 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({ columns, gap, minChildWidth, ...rest }: GridProps): import("react").JSX.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
@@ -13669,6 +14300,36 @@ export declare const Highlight: (props: import("@ark-ui/react/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 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({ size, label, children, ...rest }: IconProps): import("react").JSX.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` — 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 Omit<HTMLAttributes<HTMLElement>, "onError" | "onLoad"> {
+  src: string;
+  alt?: string;
+  fit?: "cover" | "contain" | "fill" | "none";
+  loading?: "lazy" | "eager";
+  /** Shown in place of the picture when the source breaks. */
+  fallback?: ReactNode;
+}
+export declare function Image({ src, alt, fit, loading, fallback, ...rest }: ImageProps): import("react").JSX.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.
@@ -13676,6 +14337,55 @@ 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;
+  /** Reports the viewer's next state. */
+  onOpenChange?: (open: boolean) => void;
+}
+export declare function ImageViewer({ src, alt, open, zoomable, onOpenChange }: ImageViewerProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/input/index.d.ts
+/** 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 interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size"> {
+  value?: string | number;
+  size?: "sm" | "md" | "lg";
+  invalid?: boolean;
+  onValueChange?: (value: string) => void;
+}
+export declare function Input({ value, size, invalid, onValueChange, ...rest }: InputProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/input-group/index.d.ts
+export type InputGroupPartProps = HTMLAttributes<HTMLDivElement>;
+export declare const InputGroup: {
+  ({ children, ...rest }: InputGroupPartProps): import("react").JSX.Element;
+  displayName: string;
+} & {
+  Root: {
+    ({ children, ...rest }: InputGroupPartProps): import("react").JSX.Element;
+    displayName: string;
+  };
+  Addon: {
+    ({ children, ...rest }: InputGroupPartProps): import("react").JSX.Element;
+    displayName: string;
+  };
+};
+//#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
@@ -13687,6 +14397,69 @@ export declare const JsonTreeView: typeof JsonTreeView$1;
 export type KbdProps = HTMLAttributes<HTMLElement>;
 export declare function Kbd({ children, ...rest }: KbdProps): import("react").JSX.Element;
 //#endregion
+//#region src/components/layout/index.d.ts
+/** Declare which edge the skeleton reserves for its sider — without
+ * it the root is a single column. */
+export interface LayoutRootProps extends HTMLAttributes<HTMLDivElement> {
+  sider?: "start" | "end";
+  children?: ReactNode;
+}
+/** 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 Root$1({ sider, children, ...rest }: LayoutRootProps): import("react").JSX.Element;
+export interface LayoutSiderProps extends Omit<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 `minWidth`/`maxWidth`, 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;
+  onCollapsedChange?: (collapsed: boolean) => void;
+  onWidthChange?: (width: string) => void;
+  /** The rail's contents; a function receives `{ collapsed }` so a
+   * caller can swap label content while the edge moves. */
+  children?: ReactNode | ((state: {
+    collapsed: boolean;
+  }) => ReactNode);
+}
+declare function Sider({ collapsed, width: widthProp, collapsedWidth, resizable, minWidth, maxWidth, style, onCollapsedChange, onWidthChange, children, ...rest }: LayoutSiderProps): import("react").JSX.Element;
+export declare const Layout: typeof Root$1 & {
+  Root: typeof Root$1;
+  Header: {
+    ({ children, ...rest }: HTMLAttributes<HTMLElement>): import("react").JSX.Element;
+    displayName: string;
+  };
+  Sider: typeof Sider;
+  Content: {
+    ({ children, ...rest }: HTMLAttributes<HTMLElement>): import("react").JSX.Element;
+    displayName: string;
+  };
+  Footer: {
+    ({ children, ...rest }: HTMLAttributes<HTMLElement>): import("react").JSX.Element;
+    displayName: string;
+  };
+};
+//#endregion
 //#region src/components/link/index.d.ts
 export interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
   underline?: "always" | "hover" | "none";
@@ -13696,6 +14469,44 @@ export interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
  * always, on hover, or never. */
 export declare function Link({ underline, children, ...rest }: LinkProps): import("react").JSX.Element;
 //#endregion
+//#region src/components/list/index.d.ts
+export interface ListRootProps extends HTMLAttributes<HTMLUListElement> {
+  /** One hairline between rows. */
+  bordered?: boolean;
+  /** Every row answers the pointer with a wash. */
+  hoverable?: boolean;
+}
+declare function Root({ bordered, hoverable, children, ...rest }: ListRootProps): import("react").JSX.Element;
+declare namespace Root {
+  var displayName: string;
+}
+/** The row's words: `title` and `description` ride their own slots, the
+ * children follow them for anything else. */
+export interface ListContentProps extends Omit<HTMLAttributes<HTMLDivElement>, "title"> {
+  title?: ReactNode;
+  description?: ReactNode;
+}
+declare function Content({ title, description, children, ...rest }: ListContentProps): import("react").JSX.Element;
+declare namespace Content {
+  var displayName: string;
+}
+export declare const List: typeof Root & {
+  Root: typeof Root;
+  Item: {
+    ({ children, ...rest }: HTMLAttributes<HTMLElement>): import("react").JSX.Element;
+    displayName: string;
+  };
+  Leading: {
+    ({ children, ...rest }: HTMLAttributes<HTMLElement>): import("react").JSX.Element;
+    displayName: string;
+  };
+  Content: typeof Content;
+  Actions: {
+    ({ children, ...rest }: HTMLAttributes<HTMLElement>): import("react").JSX.Element;
+    displayName: string;
+  };
+};
+//#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
@@ -13710,6 +14521,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 HTMLAttributes<HTMLDivElement> {
+  columns?: number;
+  gap?: "none" | "xs" | "sm" | "md" | "lg" | "xl";
+}
+export declare function Masonry({ columns, gap, ...rest }: MasonryProps): import("react").JSX.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.
@@ -13718,6 +14539,37 @@ 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[];
+}
+/**
+ * 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 interface MenubarProps extends Omit<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;
+}
+export declare function Menubar({ items, onSelect, children, ...rest }: MenubarProps): import("react").JSX.Element;
+//#endregion
 //#region src/components/meter/index.d.ts
 export interface MeterRootProps extends HTMLAttributes<HTMLElement> {
   /** The measured value — clamped between min and max. */
@@ -13738,7 +14590,7 @@ export declare const Meter: (({ value, min, max, level, label, children, ...rest
     ({ children, ...rest }: HTMLAttributes<HTMLElement>): import("react").JSX.Element;
     displayName: string;
   };
-  Track: ({ children, ...rest }: HTMLAttributes<HTMLElement>) => import("react").JSX.Element;
+  Track: ({ ...rest }: HTMLAttributes<HTMLElement>) => import("react").JSX.Element;
 };
 //#endregion
 //#region src/components/navigation-menu/index.d.ts
@@ -13777,6 +14629,25 @@ 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
+/**
+ * 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; give it a single element
+ * (wrap a group in a span otherwise).
+ */
+export interface PopconfirmProps {
+  /** The question the reader is answering. */
+  message: string;
+  confirmText?: string;
+  cancelText?: string;
+  children?: ReactNode;
+  onConfirm?: () => void;
+  onCancel?: () => void;
+}
+export declare function Popconfirm({ message, confirmText, cancelText, children, onConfirm, onCancel }: PopconfirmProps): import("react").JSX.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
@@ -13791,6 +14662,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 HTMLAttributes<HTMLDivElement> {
+  segments: ProgressSegment[];
+  max?: number;
+  showLegend?: boolean;
+}
+export declare function ProgressGroup({ segments, max, showLegend, ...rest }: ProgressGroupProps): import("react").JSX.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
@@ -13863,12 +14755,57 @@ export declare function Skeleton({ ...rest }: SkeletonProps): import("react").JS
  * Thumb, MarkerGroup, Marker, DraggingIndicator, HiddenInput. */
 export declare const Slider: typeof Slider$1;
 //#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<HTMLAttributes<HTMLDivElement>, "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?: () => 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 report `onSelect` with their value. The arrow
+ * is the menu machine's trigger grafting the button recipe — 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({ label, items, variant, tone, size, disabled, onClick, onSelect, ...rest }: SplitButtonProps): import("react").JSX.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 HTMLAttributes<HTMLDivElement> {
+  direction?: "column" | "row";
+  gap?: "none" | "xs" | "sm" | "md" | "lg" | "xl";
+  wrap?: boolean;
+  align?: string;
+  justify?: string;
+}
+export declare function Stack({ direction, gap, wrap, align, justify, ...rest }: StackProps): import("react").JSX.Element;
+//#endregion
 //#region src/components/page-header/index.d.ts
 export declare const PageHeader: {
   ({ children, ...rest }: HTMLAttributes<HTMLElement>): import("react").JSX.Element;
@@ -13911,6 +14848,7 @@ export declare function Spinner({ size, children, ...rest }: SpinnerProps): impo
 //#region src/components/stat/index.d.ts
 export interface StatDeltaProps extends HTMLAttributes<HTMLElement> {
   direction?: "up" | "down" | "flat";
+  "data-direction"?: string;
 }
 export declare const Stat: {
   ({ children, ...rest }: HTMLAttributes<HTMLElement>): import("react").JSX.Element;
@@ -14047,6 +14985,19 @@ export interface DataTableProps {
 }
 export declare function DataTable(rawProps: DataTableProps): import("react").JSX.Element;
 //#endregion
+//#region src/components/textarea/index.d.ts
+/** 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 interface TextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
+  value?: string;
+  invalid?: boolean;
+  onValueChange?: (value: string) => void;
+}
+export declare function Textarea({ value, invalid, onValueChange, ...rest }: TextareaProps): import("react").JSX.Element;
+//#endregion
 //#region src/components/timeline/index.d.ts
 export declare const Timeline: {
   ({ children, ...rest }: HTMLAttributes<HTMLElement>): import("react").JSX.Element;
@@ -14150,6 +15101,50 @@ export declare const Tooltip: typeof Tooltip$1;
  * useTour. */
 export declare const Tour: typeof Tour$1;
 //#endregion
+//#region src/components/transfer/index.d.ts
+export interface TransferItem {
+  label: string;
+  value: string;
+  disabled?: boolean;
+}
+export interface TransferProps extends 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({ value, data, titles, searchable, disabled, onValueChange, ...rest }: TransferProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/tree-select/index.d.ts
+export interface TreeSelectNode {
+  label: string;
+  value: string;
+  children?: TreeSelectNode[];
+  disabled?: boolean;
+}
+/**
+ * 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 interface TreeSelectProps extends HTMLAttributes<HTMLDivElement> {
+  value?: string;
+  data: TreeSelectNode[];
+  placeholder?: string;
+  disabled?: boolean;
+  onValueChange?: (value: string) => void;
+}
+export declare function TreeSelect({ value, data, placeholder, disabled, onValueChange, ...rest }: TreeSelectProps): import("react").JSX.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,
@@ -14160,4 +15155,19 @@ 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
+export interface WatermarkProps extends HTMLAttributes<HTMLDivElement> {
+  content: string;
+  opacity?: number;
+  rotate?: number;
+  fontSize?: string;
+}
+/**
+ * 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 declare function Watermark({ content, opacity, rotate, fontSize, children, ...rest }: WatermarkProps): import("react").JSX.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 PresenceBaseProps, 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 };