@bysages/svelte 0.0.1 → 0.1.1

package/dist/index.d.mts

@@ -1,35 +1,41 @@
+import { t as useMentions } from "./use-mentions-DeF_38di.mjs";
 import { Accordion as Accordion$1 } from "@ark-ui/svelte/accordion";
-import { Collapsible as Collapsible$1 } from "@ark-ui/svelte/collapsible";
 import { Field as Field$1 } from "@ark-ui/svelte/field";
+import { Collapsible as Collapsible$1 } from "@ark-ui/svelte/collapsible";
 import { Snippet } from "svelte";
+import { Combobox as Combobox$1 } from "@ark-ui/svelte/combobox";
+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/svelte/collection";
 import { AngleSlider as AngleSlider$1 } from "@ark-ui/svelte/angle-slider";
 import { Avatar as Avatar$1 } from "@ark-ui/svelte/avatar";
 import { DatePicker as DatePicker$1, DatePickerFocusChangeDetails, DatePickerOpenChangeDetails, DatePickerRootProps, DatePickerValueChangeDetails, DatePickerViewChangeDetails, DatePickerVisibleRangeChangeDetails } from "@ark-ui/svelte/date-picker";
 import { Carousel as Carousel$1 } from "@ark-ui/svelte/carousel";
 import { Checkbox as Checkbox$1 } from "@ark-ui/svelte/checkbox";
+import { ClientOnly, ClientOnlyProps } from "@ark-ui/svelte/client-only";
 import { Clipboard as Clipboard$1 } from "@ark-ui/svelte/clipboard";
 import { ColorPicker as ColorPicker$1 } from "@ark-ui/svelte/color-picker";
-import { Combobox as Combobox$1 } from "@ark-ui/svelte/combobox";
-import { DateInput as DateInput$1, DateInputFocusChangeDetails, DateInputValueChangeDetails } from "@ark-ui/svelte/date-input";
 import { Dialog as Dialog$1, DialogOpenChangeDetails } from "@ark-ui/svelte/dialog";
+import { DateInput as DateInput$1, DateInputFocusChangeDetails, DateInputValueChangeDetails } from "@ark-ui/svelte/date-input";
+import { DownloadTrigger, DownloadTriggerBaseProps, DownloadTriggerProps, DownloadableData, UseDownloadProps, UseDownloadReturn, useDownload } from "@ark-ui/svelte/download-trigger";
 import { Drawer as Drawer$1 } from "@ark-ui/svelte/drawer";
 import { Editable as Editable$1 } from "@ark-ui/svelte/editable";
 import { Fieldset as Fieldset$1 } from "@ark-ui/svelte/fieldset";
 import { FileUpload as FileUpload$1 } from "@ark-ui/svelte/file-upload";
 import { FloatingPanel as FloatingPanel$1 } from "@ark-ui/svelte/floating-panel";
+import { FocusTrap, FocusTrapBaseProps, FocusTrapProps } from "@ark-ui/svelte/focus-trap";
 import { Format as Format$1 } from "@ark-ui/svelte/format";
 import { HoverCard as HoverCard$1 } from "@ark-ui/svelte/hover-card";
 import { ImageCropper as ImageCropper$1 } from "@ark-ui/svelte/image-cropper";
 import { JsonTreeView as JsonTreeView$1 } from "@ark-ui/svelte/json-tree-view";
-import { Listbox as Listbox$1, createListCollection } from "@ark-ui/svelte/listbox";
+import { Listbox as Listbox$1 } from "@ark-ui/svelte/listbox";
 import { Marquee as Marquee$1 } from "@ark-ui/svelte/marquee";
 import { Menu as Menu$1 } from "@ark-ui/svelte/menu";
+import { Popover as Popover$1 } from "@ark-ui/svelte/popover";
 import { NavigationMenu as NavigationMenu$1 } from "@ark-ui/svelte/navigation-menu";
 import { NumberInput as NumberInput$1 } from "@ark-ui/svelte/number-input";
 import { Pagination as Pagination$1 } from "@ark-ui/svelte/pagination";
 import { PasswordInput as PasswordInput$1 } from "@ark-ui/svelte/password-input";
 import { PinInput as PinInput$1 } from "@ark-ui/svelte/pin-input";
-import { Popover as Popover$1 } from "@ark-ui/svelte/popover";
+import { Presence, PresenceProps, PresenceProvider, UsePresenceContext, UsePresenceProps, UsePresenceReturn, splitPresenceProps, usePresence, usePresenceContext } from "@ark-ui/svelte/presence";
 import { Progress as Progress$1 } from "@ark-ui/svelte/progress";
 import { QrCode as QrCode$1 } from "@ark-ui/svelte/qr-code";
 import { RadioGroup as RadioGroup$1 } from "@ark-ui/svelte/radio-group";
@@ -64,50 +70,104 @@ 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/ai/props.d.ts
-type MessageRole = "user" | "assistant" | "system";
-type ToolStatus = "pending" | "running" | "completed" | "error";
-interface AiPartProps extends HTMLAttributes<HTMLElement> {
+//#region src/components/affix/props.d.ts
+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;
+  children?: Snippet;
+}
+//#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 declare const Affix: import("svelte").Component<AffixProps, {}, "">;
+//#endregion
+//#region src/components/ai-action/props.d.ts
+interface ActionProps extends HTMLAttributes<HTMLButtonElement> {
+  /** What the button does, spoken to assistive tech and shown as the
+   * hover title — copy, retry, thumbs. */
+  label: string;
   children?: Snippet;
 }
+//#endregion
+//#region src/components/ai-message/props.d.ts
+type MessageRole = "user" | "assistant" | "system";
 interface MessageProps extends HTMLAttributes<HTMLElement> {
+  /** Whose stroke this is — the user's words sit in a recessed
+   * bubble, the assistant speaks flat on the paper. */
   role?: MessageRole;
   children?: Snippet;
 }
-interface ResponseProps extends HTMLAttributes<HTMLDivElement> {
-  content: string;
+//#endregion
+//#region src/components/ai-prompt-input/props.d.ts
+interface PromptInputProps extends HTMLAttributes<HTMLFormElement> {
+  /** Two-way bindable — `bind:value` keeps the bound variable mirroring
+   * the field; send clears it back through the binding. */
+  value?: string;
+  onSubmit?: (value: string) => void;
+  /** The quiet invitation before the reader types. */
+  placeholder?: string;
+  disabled?: boolean;
 }
+//#endregion
+//#region src/components/ai-reasoning/props.d.ts
 interface ReasoningProps extends HTMLAttributes<HTMLDivElement> {
+  /** The trigger's words — the fold arrives open under them. */
   label?: string;
   children?: Snippet;
 }
-interface ToolProps extends HTMLAttributes<HTMLDivElement> {
-  name: string;
-  /** Friendlier trigger words than the raw tool name. */
-  label?: string;
-  status?: ToolStatus;
-  input?: string;
-  output?: string;
+//#endregion
+//#region src/components/ai-response/props.d.ts
+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;
 }
+//#endregion
+//#region src/components/ai-source/props.d.ts
 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?: Snippet;
 }
-interface ActionProps extends HTMLAttributes<HTMLButtonElement> {
-  label: string;
+interface SourcesProps extends HTMLAttributes<HTMLOListElement> {
   children?: Snippet;
 }
+//#endregion
+//#region src/components/ai-suggestion/props.d.ts
 interface SuggestionProps extends HTMLAttributes<HTMLButtonElement> {
+  /** The next stroke this seal proposes — also its label; handed
+   * back whole on `onSelect`. */
   prompt: string;
   onSelect?: (prompt: string) => void;
 }
-interface PromptInputProps extends HTMLAttributes<HTMLFormElement> {
-  /** Two-way bindable — `bind:value` keeps the bound variable mirroring
-   * the field; send clears it back through the binding. */
-  value?: string;
-  onSubmit?: (value: string) => void;
-  placeholder?: string;
-  disabled?: boolean;
+//#endregion
+//#region src/components/ai-tool/props.d.ts
+type ToolStatus = "pending" | "running" | "completed" | "error";
+interface ToolProps extends HTMLAttributes<HTMLDivElement> {
+  /** The name the tool was reached by — shown raw on the trigger
+   * unless `label` speaks friendlier words. */
+  name: string;
+  label?: string;
+  /** The state the call reached — stamped on the fold and whispered
+   * in the status chip. */
+  status?: ToolStatus;
+  input?: string;
+  output?: string;
+}
+//#endregion
+//#region src/components/ai/props.d.ts
+interface AiPartProps extends HTMLAttributes<HTMLElement> {
+  children?: Snippet;
 }
 //#endregion
 //#region ../../node_modules/.pnpm/@ai-sdk+provider@4.0.14/node_modules/@ai-sdk/provider/dist/index.d.ts
@@ -10184,13 +10244,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.
  */
@@ -13253,7 +13313,7 @@ export declare const Ai: import("svelte").Component<AiPartProps, {}, ""> & {
   Response: import("svelte").Component<ResponseProps, {}, "">;
   Reasoning: import("svelte").Component<ReasoningProps, {}, "">;
   Tool: import("svelte").Component<ToolProps, {}, "">;
-  Sources: import("svelte").Component<AiPartProps, {}, "">;
+  Sources: import("svelte").Component<SourcesProps, {}, "">;
   Source: import("svelte").Component<SourceProps, {}, "">;
   Actions: import("svelte").Component<AiPartProps, {}, "">;
   Action: import("svelte").Component<ActionProps, {}, "">;
@@ -13262,6 +13322,67 @@ export declare const Ai: import("svelte").Component<AiPartProps, {}, ""> & {
   Loader: import("svelte").Component<AiPartProps, {}, "">;
 };
 //#endregion
+//#region src/components/ai-action/index.d.ts
+/** A quiet icon button — copy, retry, thumbs. The control is the
+ * shared Button in its ghost register. */
+export declare const AiAction: import("svelte").Component<ActionProps, {}, "">;
+//#endregion
+//#region src/components/ai-attachments/props.d.ts
+/** The upload's state on the wire. */
+type AttachmentStatus = "uploading" | "ready" | "error";
+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;
+  status?: AttachmentStatus;
+  /** Taken when the reader takes the attachment back off. */
+  onRemove?: () => void;
+}
+interface AttachmentsProps extends HTMLAttributes<HTMLSpanElement> {
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/ai-attachments/index.d.ts
+export declare const Attachment: import("svelte").Component<AttachmentProps, {}, "">;
+export declare const Attachments: import("svelte").Component<AttachmentsProps, {}, "">;
+//#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 declare const AiMessage: import("svelte").Component<MessageProps, {}, "">;
+//#endregion
+//#region src/components/ai-prompt-input/index.d.ts
+/** The prompt vessel: the shared field textarea — self-growing on the
+ * machine's autoresize — over a footer row carrying the submit seal. */
+export declare const AiPromptInput: import("svelte").Component<PromptInputProps, {}, "value">;
+//#endregion
+//#region src/components/ai-reasoning/index.d.ts
+/** The model's thought, folded by the shared collapsible in its quiet
+ * register. */
+export declare const AiReasoning: import("svelte").Component<ReasoningProps, {}, "">;
+//#endregion
+//#region src/components/ai-response/index.d.ts
+/** Markdown set on the paper — streaming-safe by construction. */
+export declare const AiResponse: import("svelte").Component<ResponseProps, {}, "">;
+//#endregion
+//#region src/components/ai-source/index.d.ts
+/** One place the ink came from, and the reading list that gathers
+ * them under a response. */
+export declare const AiSource: import("svelte").Component<SourceProps, {}, "">;
+export declare const AiSources: import("svelte").Component<SourcesProps, {}, "">;
+//#endregion
+//#region src/components/ai-suggestion/index.d.ts
+/** A seal-cut button proposing the next stroke; selection hands back
+ * the prompt. */
+export declare const AiSuggestion: import("svelte").Component<SuggestionProps, {}, "">;
+//#endregion
+//#region src/components/ai-tool/index.d.ts
+/** 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 const AiTool: import("svelte").Component<ToolProps, {}, "">;
+//#endregion
 //#region src/components/alert/props.d.ts
 type AlertStatus = "ink" | "info" | "success" | "warning" | "danger";
 interface AlertProps extends HTMLAttributes<HTMLDivElement> {
@@ -13284,6 +13405,25 @@ export declare const Alert: import("svelte").Component<AlertProps, {}, ""> & {
   Description: import("svelte").Component<AlertPartProps, {}, "">;
 };
 //#endregion
+//#region src/components/autocomplete/props.d.ts
+interface AutoCompleteProps extends HTMLAttributes<HTMLDivElement> {
+  /** Two-way bindable — `bind:value` keeps the bound variable mirroring
+   * the field; a pick and a custom value land here alike. */
+  value?: string;
+  /** Seeds the suggestion list once. */
+  items?: string[];
+  placeholder?: string;
+  /** Field text to match against; defaults to a case-insensitive
+   * substring. */
+  filter?: (item: string, input: string) => boolean;
+}
+//#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. */
+export declare const AutoComplete: import("svelte").Component<AutoCompleteProps, {}, "value">;
+//#endregion
 //#region src/components/angle-slider/index.d.ts
 /** Ark's AngleSlider, dressed in the paper-and-ink system: a flat paper dial
  * the thumb sweeps as a pigment needle over hairline degree ticks. The API
@@ -13291,6 +13431,18 @@ export declare const Alert: import("svelte").Component<AlertProps, {}, ""> & {
  * Marker, HiddenInput. */
 export declare const AngleSlider: typeof AngleSlider$1;
 //#endregion
+//#region src/components/aspect-ratio/props.d.ts
+interface AspectRatioProps extends HTMLAttributes<HTMLDivElement> {
+  /** A CSS `aspect-ratio` value — "16 / 9", "4 / 3", "1 / 1". */
+  ratio?: string;
+  children?: Snippet;
+}
+//#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 declare const AspectRatio: import("svelte").Component<AspectRatioProps, {}, "">;
+//#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,27 @@ interface AvatarGroupProps extends HTMLAttributes<HTMLDivElement> {
  * stays legible. */
 export declare const AvatarGroup: import("svelte").Component<AvatarGroupProps, {}, "">;
 //#endregion
+//#region src/components/back-top/props.d.ts
+interface BackTopProps extends HTMLButtonAttributes {
+  /** 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;
+  /** The control's own content — the up-stroke glyph by default. */
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/back-top/index.d.ts
+/** 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 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 const BackTop: import("svelte").Component<BackTopProps, {}, "">;
+//#endregion
 //#region src/components/badge/props.d.ts
 interface BadgeProps extends HTMLAttributes<HTMLSpanElement> {
   tone?: "ink" | "info" | "success" | "warning" | "danger";
@@ -13371,6 +13544,24 @@ interface ButtonProps extends HTMLButtonAttributes {
  * action can carry the primary weight. */
 export declare const Button: import("svelte").Component<ButtonProps, {}, "">;
 //#endregion
+//#region src/components/button-group/props.d.ts
+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?: Snippet;
+}
+//#endregion
+//#region src/components/button-group/index.d.ts
+/** Buttons fused into one control: the group owns only the joinery, so
+ * members keep every variant they were given. */
+export declare const ButtonGroup: import("svelte").Component<ButtonGroupProps, {}, "">;
+//#endregion
 //#region src/components/banner/props.d.ts
 type BannerStatus = "ink" | "info" | "success" | "warning" | "danger";
 interface BannerProps extends HTMLAttributes<HTMLElement> {
@@ -13439,6 +13630,32 @@ declare const Card$1: import("svelte").Component<CardProps, {}, ""> & {
   Footer: import("svelte").Component<CardPartProps, {}, "">;
 };
 //#endregion
+//#region src/components/cascade-select/props.d.ts
+interface CascadeSelectNode {
+  label: string;
+  value: string;
+  children?: CascadeSelectNode[];
+  disabled?: boolean;
+}
+interface CascadeSelectProps extends HTMLAttributes<HTMLDivElement> {
+  /** Two-way bindable — `bind:value` keeps the selected path (or paths,
+   * when `multiple`) in the bound variable. */
+  value?: string[][];
+  data: CascadeSelectNode[];
+  placeholder?: string;
+  /** `"hover"` turns the classic cascading menu: pointing is enough to
+   * unfold. */
+  highlightTrigger?: "click" | "hover";
+  multiple?: boolean;
+  disabled?: boolean;
+}
+//#endregion
+//#region src/components/cascade-select/index.d.ts
+/** A corridor of linked columns: pick a branch and the next column
+ * dissolves open beside it, until a leaf click settles the whole
+ * path. */
+export declare const CascadeSelect: import("svelte").Component<CascadeSelectProps, {}, "value">;
+//#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
@@ -13454,6 +13671,27 @@ export declare const Carousel: typeof Carousel$1;
  * HiddenInput. */
 export declare const Checkbox: typeof Checkbox$1;
 //#endregion
+//#region src/components/checkbox-group/props.d.ts
+interface CheckboxOption {
+  label: string;
+  value: string;
+  disabled?: boolean;
+}
+interface CheckboxGroupProps extends HTMLAttributes<HTMLDivElement> {
+  /** Two-way bindable — `bind:value` keeps the bound array mirroring
+   * the group. */
+  value?: string[];
+  options: CheckboxOption[];
+  layout?: "vertical" | "horizontal";
+  disabled?: boolean;
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/checkbox-group/index.d.ts
+/** One question, many answers: a labelled stack (or row) of the
+ * seal-cut checkboxes bound to a single array. */
+export declare const CheckboxGroup: import("svelte").Component<CheckboxGroupProps, {}, "value">;
+//#endregion
 //#region src/components/chip/props.d.ts
 interface ChipProps extends HTMLAttributes<HTMLSpanElement> {
   value: number;
@@ -13499,6 +13737,119 @@ export declare const ColorPicker: typeof ColorPicker$1;
  * Item, ItemText, ItemIndicator, ItemGroup, ItemGroupLabel. */
 export declare const Combobox: typeof Combobox$1;
 //#endregion
+//#region src/components/command/props.d.ts
+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;
+}
+interface CommandProps {
+  /** The commands on offer, grouped as they arrive. */
+  items?: CommandEntry[];
+  placeholder?: string;
+  /** Whether the palette is up. Bind it (`bind:open`) 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 open state turned. */
+  onOpenChange?: (open: boolean) => void;
+  /** The field's live text turned. */
+  onInputValueChange?: (inputValue: string) => void;
+}
+//#endregion
+//#region src/components/command/index.d.ts
+/** 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 const Command: import("svelte").Component<CommandProps, {}, "open">;
+//#endregion
+//#region src/components/comment/props.d.ts
+interface CommentProps extends HTMLAttributes<HTMLElement> {
+  author?: string;
+  datetime?: string;
+  /** The portrait hanging left. */
+  avatar?: Snippet;
+  /** The row of answers beneath the ink. */
+  actions?: Snippet;
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/comment/index.d.ts
+/** A voice on the record: the portrait hangs left (the avatar snippet),
+ * the body carries the byline from `author` and `datetime`, the ink is
+ * the children snippet, and the actions snippet is the row of answers. */
+export declare const Comment: import("svelte").Component<CommentProps, {}, "">;
+//#endregion
+//#region src/components/config-provider/context.d.ts
+/** The four density tiers the token layer's `[data-density]` selectors
+ * name — whitespace and control heights compress, readability never
+ * does. */
+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. */
+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 live snapshot, or an empty one when no
+ * provider wraps the caller. */
+export declare function useConfig(): ConfigContext;
+//#endregion
+//#region src/components/config-provider/props.d.ts
+interface ConfigProviderProps extends HTMLAttributes<HTMLDivElement> {
+  density?: ConfigDensity;
+  accent?: string;
+  dir?: "ltr" | "rtl";
+  /** BCP-47 locale, landing as the native `lang` attribute. */
+  locale?: string;
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/config-provider/index.d.ts
+/** The declarative host for global configuration: one element carrying
+ * the token layer's attributes and providing the same values to
+ * descendants through `useConfig`. */
+export declare const ConfigProvider: import("svelte").Component<ConfigProviderProps, {}, "">;
+//#endregion
+//#region src/components/container/props.d.ts
+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;
+  children?: Snippet;
+}
+//#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 declare const Container: import("svelte").Component<ContainerProps, {}, "">;
+//#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
@@ -13515,6 +13866,28 @@ export declare const DateInput: typeof DateInput$1;
  * NextTrigger, Table*, MonthSelect, YearSelect, PresetTrigger. */
 export declare const DatePicker: typeof DatePicker$1;
 //#endregion
+//#region src/components/descriptions/props.d.ts
+interface DescriptionsRootProps extends HTMLAttributes<HTMLDListElement> {
+  /** The horizontal layout reads as a table of two columns; the
+   * vertical one stacks each pair for narrow measures. */
+  layout?: "horizontal" | "vertical";
+  children?: Snippet;
+}
+interface DescriptionsPartProps extends HTMLAttributes<HTMLElement> {
+  children?: Snippet;
+}
+//#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 declare const Descriptions: import("svelte").Component<DescriptionsRootProps, {}, ""> & {
+  Root: import("svelte").Component<DescriptionsRootProps, {}, "">;
+  Item: import("svelte").Component<DescriptionsPartProps, {}, "">;
+  Term: import("svelte").Component<DescriptionsPartProps, {}, "">;
+  Detail: import("svelte").Component<DescriptionsPartProps, {}, "">;
+};
+//#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
@@ -13530,6 +13903,28 @@ export declare const Dialog: typeof Dialog$1;
  * Description, CloseTrigger, SwipeArea. */
 export declare const Drawer: typeof Drawer$1;
 //#endregion
+//#region src/components/dynamic-input/props.d.ts
+interface DynamicInputProps extends HTMLAttributes<HTMLDivElement> {
+  /** The rows' values; the group renders one Input per entry. Two-way
+   * bindable — `bind:value` keeps the bound array mirroring the rows. */
+  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;
+}
+//#endregion
+//#region src/components/dynamic-input/index.d.ts
+/** A column of entry rows: one Input per line, each with a quiet remove
+ * seal, and an add row at the tail — the bound array stays the only
+ * truth. */
+export declare const DynamicInput: import("svelte").Component<DynamicInputProps, {}, "value">;
+//#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 —
@@ -13537,6 +13932,18 @@ export declare const Drawer: typeof Drawer$1;
  * CancelTrigger, Control. */
 export declare const Editable: typeof Editable$1;
 //#endregion
+//#region src/components/ellipsis/props.d.ts
+interface EllipsisProps extends HTMLAttributes<HTMLSpanElement> {
+  lines?: number;
+  children?: Snippet;
+}
+//#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 declare const Ellipsis: import("svelte").Component<EllipsisProps, {}, "">;
+//#endregion
 //#region src/components/empty/props.d.ts
 interface EmptyProps extends HTMLAttributes<HTMLDivElement> {
   children?: Snippet;
@@ -13585,6 +13992,56 @@ export declare const Fieldset: typeof Fieldset$1;
  * Context. */
 export declare const FileUpload: typeof FileUpload$1;
 //#endregion
+//#region src/components/float-button/props.d.ts
+type FloatButtonPlacement = "bottom-end" | "bottom-start" | "top-end" | "top-start";
+interface FloatButtonProps extends HTMLAttributes<HTMLDivElement> {
+  /** Controlled openness — `bind:open` receives every flip; leave it
+   * unbound and the group holds its own state. */
+  open?: boolean;
+  /** Which corner the group moors at. */
+  placement?: FloatButtonPlacement;
+  children?: Snippet;
+}
+interface FloatButtonTriggerProps {
+  /** The accessible name; the control is icon-only. */
+  label?: string;
+  children?: Snippet;
+}
+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;
+  /** Fired when the item's action is chosen — the fan folds right
+   * after. */
+  onclick?: () => void;
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/float-button/context.d.ts
+/** The group's openness, shared from the mooring to its parts. */
+interface FloatButtonContext {
+  /** Live openness — read through the getter, so parts re-render as it
+   * flips. */
+  readonly 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 key for {@link FloatButtonContext}, exported so a custom
+ * part can read the group's state. */
+export declare const FLOAT_BUTTON_KEY: unique symbol;
+//#endregion
+//#region src/components/float-button/index.d.ts
+/** A floating action and its fanned-out alternatives — FAB and speed
+ * dial in one family. Root, Trigger, Item. */
+export declare const FloatButton: import("svelte").Component<FloatButtonProps, {}, "open"> & {
+  Root: import("svelte").Component<FloatButtonProps, {}, "open">;
+  Trigger: import("svelte").Component<FloatButtonTriggerProps, {}, "">;
+  Item: import("svelte").Component<FloatButtonItemProps, {}, "">;
+};
+//#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
@@ -13611,6 +14068,75 @@ export declare const Format: typeof Format$1;
  * core stylesheet to hook. The API is Ark's own. */
 export declare const Frame: import("svelte").Component<import("@ark-ui/svelte/frame").FrameProps, {}, "ref">;
 //#endregion
+//#region src/components/form/props.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. */
+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. */
+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;
+    }>;
+  }>;
+}
+type FormInputEvent = "input" | "change" | "blur";
+interface FormProps extends HTMLAttributes<HTMLFormElement> {
+  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;
+  children?: Snippet;
+}
+interface FormFieldProps extends HTMLAttributes<HTMLDivElement> {
+  name?: string;
+  label?: string;
+  hint?: string;
+  required?: boolean;
+  invalid?: boolean;
+  disabled?: boolean;
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/form/index.d.ts
+/** The validation scheduler and the named slot in its grid — the
+ * schema is any Standard Schema, errors reach their field by name. */
+export declare const Form: import("svelte").Component<FormProps, {
+  validate: () => Promise<Map<string, string>>;
+}, "">;
+export declare const FormField: import("svelte").Component<FormFieldProps, {}, "">;
+//#endregion
+//#region src/components/grid/props.d.ts
+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;
+  children?: Snippet;
+}
+//#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 declare const Grid: import("svelte").Component<GridProps, {}, "">;
+//#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
@@ -13624,6 +14150,42 @@ export declare const Highlight: import("svelte").Component<import("@ark-ui/svelt
  * API is Ark's own — Root, Trigger, Positioner, Content, Arrow, ArrowTip. */
 export declare const HoverCard: typeof HoverCard$1;
 //#endregion
+//#region src/components/icon/props.d.ts
+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;
+  children?: Snippet;
+}
+//#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 declare const Icon: import("svelte").Component<IconProps, {}, "">;
+//#endregion
+//#region src/components/image/props.d.ts
+interface ImageProps extends HTMLAttributes<HTMLElement> {
+  src: string;
+  alt?: string;
+  fit?: "cover" | "contain" | "fill" | "none";
+  loading?: "lazy" | "eager";
+  /** What a broken source leaves — the quiet placeholder glyph by
+   * default. */
+  fallback?: Snippet;
+}
+//#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 snippet — or the placeholder glyph when
+ * the caller has nothing local to say. The frame's size is the
+ * consumer's to give. */
+export declare const Image: import("svelte").Component<ImageProps, {}, "">;
+//#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.
@@ -13631,6 +14193,60 @@ export declare const HoverCard: typeof HoverCard$1;
  * Context. */
 export declare const ImageCropper: typeof ImageCropper$1;
 //#endregion
+//#region src/components/image-viewer/props.d.ts
+interface ImageViewerProps {
+  src: string;
+  alt?: string;
+  /** Whether the lightbox is up. Bind it (`bind:open`) to control the
+   * viewer; left alone it keeps the state to itself. */
+  open?: boolean;
+  zoomable?: boolean;
+  /** The viewer's open state turned. */
+  onOpenChange?: (open: boolean) => void;
+}
+//#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 (`bind:open`); left alone the viewer keeps it to
+ * itself. */
+export declare const ImageViewer: import("svelte").Component<ImageViewerProps, {}, "open">;
+//#endregion
+//#region src/components/input/props.d.ts
+interface InputProps extends HTMLAttributes<HTMLInputElement> {
+  /** Two-way bindable — `bind:value` keeps the bound variable mirroring
+   * the field. */
+  value?: string | number;
+  size?: "sm" | "md" | "lg";
+  /** Standing alone this styles the control invalid; inside a Field
+   * the context's invalid state joins in. */
+  invalid?: boolean;
+}
+//#endregion
+//#region src/components/input/index.d.ts
+/** The bare text input, dressed in the field recipe: border, surface,
+ * focus halo — no shadow. Inside a Field.Root it picks up the label
+ * wiring and the invalid state from the context. */
+export declare const Input: import("svelte").Component<InputProps, {}, "value">;
+//#endregion
+//#region src/components/input-group/props.d.ts
+interface InputGroupProps extends HTMLAttributes<HTMLDivElement> {
+  children?: Snippet;
+}
+interface InputGroupAddonProps extends HTMLAttributes<HTMLDivElement> {
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/input-group/index.d.ts
+/** Merged controls: attachments and the entry fused into one seal —
+ * Root, Addon. */
+export declare const InputGroup: import("svelte").Component<InputGroupProps, {}, ""> & {
+  Root: import("svelte").Component<InputGroupProps, {}, "">;
+  Addon: import("svelte").Component<InputGroupAddonProps, {}, "">;
+};
+//#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
@@ -13646,6 +14262,61 @@ interface KbdProps extends HTMLAttributes<HTMLElement> {
 /** A keycap in miniature, riding the type it annotates. */
 export declare const Kbd: import("svelte").Component<KbdProps, {}, "">;
 //#endregion
+//#region src/components/layout/props.d.ts
+interface LayoutProps extends HTMLAttributes<HTMLDivElement> {
+  /** Declare which edge the skeleton reserves for its sider — without
+   * it the root is a single column. */
+  sider?: "start" | "end";
+  children?: Snippet;
+}
+/** A semantic block of the skeleton — header, footer, and the flow's
+ * main content each land on their native element and their grid area. */
+interface LayoutRegionProps extends HTMLAttributes<HTMLElement> {
+  children?: Snippet;
+}
+interface LayoutSiderProps extends Omit<HTMLAttributes<HTMLElement>, "children"> {
+  /** The caller drives the fold — `bind:collapsed` mirrors every
+   * change. */
+  collapsed?: boolean;
+  /** The rail's resting inline size — a layout parameter, not a visual
+   * token, so it rides an inline variable. Bindable: the drag and the
+   * arrow keys write through it. */
+  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/max, and every change
+   * rides `bind:width`. */
+  resizable?: boolean;
+  /** The rail's narrowest inline size while resizing. */
+  minWidth?: string;
+  /** The rail's widest inline size while resizing. */
+  maxWidth?: string;
+  /** Receives the fold state, so a rail can swap its labels for icons
+   * instead of being clipped mid-word by the narrowing edge. */
+  children?: Snippet<[{
+    collapsed: boolean;
+  }]>;
+}
+//#endregion
+//#region src/components/layout/context.d.ts
+/** Which edge the enclosing root reserves for its rail — shared so the
+ * sider's resize handle knows which way the hand pulls. */
+interface LayoutContext {
+  siderPlacement: () => "start" | "end" | undefined;
+}
+//#endregion
+//#region src/components/layout/index.d.ts
+/** The application skeleton: Root, Header, Sider, Content, Footer —
+ * the admin arrangement dressed in the paper-and-ink surfaces. */
+export declare const Layout: import("svelte").Component<LayoutProps, {}, ""> & {
+  Root: import("svelte").Component<LayoutProps, {}, "">;
+  Header: import("svelte").Component<LayoutRegionProps, {}, "">;
+  Sider: import("svelte").Component<LayoutSiderProps, {}, "width" | "collapsed">;
+  Content: import("svelte").Component<LayoutRegionProps, {}, "">;
+  Footer: import("svelte").Component<LayoutRegionProps, {}, "">;
+};
+//#endregion
 //#region src/components/link/props.d.ts
 interface LinkProps extends HTMLAnchorAttributes {
   underline?: "always" | "hover" | "none";
@@ -13657,6 +14328,46 @@ interface LinkProps extends HTMLAnchorAttributes {
  * the hand, the halo at focus. */
 export declare const Link: import("svelte").Component<LinkProps, {}, "">;
 //#endregion
+//#region src/components/list/props.d.ts
+interface ListProps extends HTMLAttributes<HTMLUListElement> {
+  /** One hairline between rows. */
+  bordered?: boolean;
+  /** Every row answers the pointer with a wash. */
+  hoverable?: boolean;
+  children?: Snippet;
+}
+interface ListItemProps extends HTMLAttributes<HTMLLIElement> {
+  children?: Snippet;
+}
+interface ListLeadingProps extends HTMLAttributes<HTMLDivElement> {
+  children?: Snippet;
+}
+interface ListActionsProps extends HTMLAttributes<HTMLDivElement> {
+  children?: Snippet;
+}
+interface ListContentProps extends Omit<HTMLAttributes<HTMLDivElement>, "title"> {
+  /** The row's words. */
+  title?: Snippet;
+  /** The quiet echo beneath the title. */
+  description?: Snippet;
+  /** Anything else the row holds, after title and description. */
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/list/index.d.ts
+/** A ledger of rows: Root is the list, Item one row, Leading the mark
+ * before the words, Content the title and its quiet echo, Actions the
+ * way out. The bordered variant draws the hairlines; the hoverable
+ * variant gives every row the wash — and any row the caller makes
+ * clickable (role="button") answers the pointer on its own. */
+export declare const List: import("svelte").Component<ListProps, {}, ""> & {
+  Root: import("svelte").Component<ListProps, {}, "">;
+  Item: import("svelte").Component<ListItemProps, {}, "">;
+  Leading: import("svelte").Component<ListLeadingProps, {}, "">;
+  Content: import("svelte").Component<ListContentProps, {}, "">;
+  Actions: import("svelte").Component<ListActionsProps, {}, "">;
+};
+//#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
@@ -13671,6 +14382,19 @@ 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/props.d.ts
+interface MasonryProps extends HTMLAttributes<HTMLDivElement> {
+  columns?: number;
+  gap?: "none" | "xs" | "sm" | "md" | "lg" | "xl";
+  children?: Snippet;
+}
+//#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 declare const Masonry: import("svelte").Component<MasonryProps, {}, "">;
+//#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.
@@ -13679,6 +14403,95 @@ export declare const Marquee: typeof Marquee$1;
  * TriggerItem, Separator, Arrow, ArrowTip. */
 export declare const Menu: typeof Menu$1;
 //#endregion
+//#region src/components/menubar/props.d.ts
+interface MenubarEntry {
+  label: string;
+  value: string;
+  danger?: boolean;
+  disabled?: boolean;
+}
+interface MenubarGroup {
+  label: string;
+  items: MenubarEntry[];
+}
+interface MenubarProps extends HTMLAttributes<HTMLDivElement> {
+  /** 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;
+}
+//#endregion
+//#region src/components/menubar/index.d.ts
+/** 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. */
+export declare const Menubar: import("svelte").Component<MenubarProps, {}, "">;
+//#endregion
+//#region src/components/mentions/props.d.ts
+interface MentionEntry {
+  label: string;
+  value: string;
+}
+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;
+}
+interface MentionsProps extends HTMLAttributes<HTMLDivElement> {
+  /** The candidates offered once the trigger character is typed. */
+  items?: MentionEntry[];
+  /** Two-way bindable — `bind:value` keeps the bound variable mirroring
+   * 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 announces itself invalid; inside a
+   * `Field.Root` the field's own invalid state takes over. */
+  invalid?: boolean;
+  /** The field's text turned. */
+  onValueChange?: (value: string) => void;
+}
+interface MentionsVesselProps {
+  open?: boolean;
+  matches?: MentionEntry[];
+  active?: number;
+  /** The live rectangle the vessel points at — the host's field. */
+  anchor?: HTMLTextAreaElement | null;
+  /** A candidate was confirmed (click or Enter). */
+  onInsert?: (entry: MentionEntry) => void;
+  /** The keyboard's active row moved. */
+  onActiveChange?: (index: number) => void;
+  /** The vessel's open state turned. */
+  onOpenChange?: (open: boolean) => void;
+}
+//#endregion
+//#region src/components/mentions/index.d.ts
+/** @-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 `bind:value`. Arrows move, Enter inserts, Escape dismisses. */
+export declare const Mentions: import("svelte").Component<MentionsProps, {}, "value">;
+/** The vessel: the candidates themselves as a floating card. Composers
+ * that keep their own field anatomy wire it up with `useMentions`
+ * directly. */
+export declare const MentionsVessel: import("svelte").Component<MentionsVesselProps, {}, "">;
+//#endregion
 //#region src/components/meter/props.d.ts
 interface MeterRootProps extends HTMLAttributes<HTMLDivElement> {
   /** The measured value — clamped between min and max. */
@@ -13740,6 +14553,24 @@ export declare const PasswordInput: typeof PasswordInput$1;
  * Root, Label, Control, Input, HiddenInput. */
 export declare const PinInput: typeof PinInput$1;
 //#endregion
+//#region src/components/popconfirm/props.d.ts
+interface PopconfirmProps {
+  /** The question the reader is answering. */
+  message: string;
+  confirmText?: string;
+  cancelText?: string;
+  onConfirm?: () => void;
+  onCancel?: () => void;
+  /** The trigger — give it a single element (wrap a group in a span
+   * otherwise). */
+  children?: Snippet;
+}
+//#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. */
+export declare const Popconfirm: import("svelte").Component<PopconfirmProps, {}, "">;
+//#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
@@ -13754,6 +14585,28 @@ export declare const Popover: typeof Popover$1;
  * CircleTrack, CircleRange. */
 export declare const Progress: typeof Progress$1;
 //#endregion
+//#region src/components/progress-group/props.d.ts
+/** One verdict on the bar. */
+interface ProgressSegment {
+  value: number;
+  label?: string;
+  pigment?: "primary" | "success" | "warning" | "danger" | "info";
+}
+interface ProgressGroupProps extends HTMLAttributes<HTMLDivElement> {
+  segments: ProgressSegment[];
+  max?: number;
+  showLegend?: boolean;
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/progress-group/index.d.ts
+/** 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 declare const ProgressGroup: import("svelte").Component<ProgressGroupProps, {}, "">;
+//#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
@@ -13830,12 +14683,58 @@ export declare const Skeleton: import("svelte").Component<SkeletonProps, {}, "">
  * Thumb, MarkerGroup, Marker, DraggingIndicator, HiddenInput. */
 export declare const Slider: typeof Slider$1;
 //#endregion
+//#region src/components/split-button/props.d.ts
+interface SplitButtonEntry {
+  label: string;
+  /** Handed back with `onSelect` when the entry is chosen. */
+  value: string;
+  danger?: boolean;
+  disabled?: boolean;
+}
+interface SplitButtonProps extends HTMLAttributes<HTMLDivElement> {
+  /** 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;
+}
+//#endregion
+//#region src/components/split-button/index.d.ts
+/** A primary action with its alternatives one seam away: the main
+ * button fires, the fitted arrow opens a paper vessel whose entries
+ * hand back their value. */
+export declare const SplitButton: import("svelte").Component<SplitButtonProps, {}, "">;
+//#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/props.d.ts
+interface StackProps extends HTMLAttributes<HTMLDivElement> {
+  direction?: "column" | "row";
+  gap?: "none" | "xs" | "sm" | "md" | "lg" | "xl";
+  wrap?: boolean;
+  align?: string;
+  justify?: string;
+  children?: Snippet;
+}
+//#endregion
+//#region src/components/stack/index.d.ts
+/** Whitespace chosen by name: the named steps point at the space ramp
+ * so siblings are held apart by one token, never by ad-hoc margins. */
+export declare const Stack: import("svelte").Component<StackProps, {}, "">;
+//#endregion
 //#region src/components/page-header/props.d.ts
 interface PageHeaderPartProps extends HTMLAttributes<HTMLElement> {
   children?: Snippet;
@@ -13999,6 +14898,22 @@ export declare const Tabs: typeof Tabs$1;
  * Context. */
 export declare const TagsInput: typeof TagsInput$1;
 //#endregion
+//#region src/components/textarea/props.d.ts
+interface TextareaProps extends HTMLAttributes<HTMLTextAreaElement> {
+  /** Two-way bindable — `bind:value` keeps the bound variable mirroring
+   * the field. */
+  value?: string;
+  /** Standing alone this styles the control invalid; inside a Field
+   * the context's invalid state joins in. */
+  invalid?: boolean;
+}
+//#endregion
+//#region src/components/textarea/index.d.ts
+/** The bare multi-line input, dressed in the field recipe: border,
+ * surface, focus halo — no shadow. Inside a Field.Root it picks up the
+ * label wiring and the invalid state from the context. */
+export declare const Textarea: import("svelte").Component<TextareaProps, {}, "value">;
+//#endregion
 //#region src/components/timeline/props.d.ts
 interface TimelineProps extends HTMLAttributes<HTMLOListElement> {
   children?: Snippet;
@@ -14070,6 +14985,28 @@ export declare const Typography: import("svelte").Component<TypographyPartProps,
   Label: import("svelte").Component<TypographyPartProps, {}, "">;
 };
 //#endregion
+//#region src/components/transfer/props.d.ts
+interface TransferItem {
+  label: string;
+  value: string;
+  disabled?: boolean;
+}
+interface TransferProps extends HTMLAttributes<HTMLDivElement> {
+  /** Two-way bindable — `bind:value` keeps the bound list mirroring the
+   * target column. */
+  value?: string[];
+  data: TransferItem[];
+  titles?: string[];
+  searchable?: boolean;
+  disabled?: boolean;
+}
+//#endregion
+//#region src/components/transfer/index.d.ts
+/** 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. */
+export declare const Transfer: import("svelte").Component<TransferProps, {}, "value">;
+//#endregion
 //#region src/components/toggle-group/index.d.ts
 /** Ark's ToggleGroup, dressed in the paper-and-ink system: a hairline tray
  * of quiet seals where the pressed item takes the flat ink fill. The API is
@@ -14091,6 +15028,27 @@ export declare const Tooltip: typeof Tooltip$1;
  * useTour. */
 export declare const Tour: typeof Tour$1;
 //#endregion
+//#region src/components/tree-select/props.d.ts
+interface TreeSelectNode {
+  label: string;
+  value: string;
+  children?: TreeSelectNode[];
+  disabled?: boolean;
+}
+interface TreeSelectProps extends HTMLAttributes<HTMLButtonElement> {
+  /** Two-way bindable — `bind:value` keeps the bound variable mirroring
+   * the chosen leaf. */
+  value?: string;
+  data: TreeSelectNode[];
+  placeholder?: string;
+  disabled?: boolean;
+}
+//#endregion
+//#region src/components/tree-select/index.d.ts
+/** A tree behind a field: the control reads like an input, the vessel
+ * below walks the hierarchy, and one leaf click closes the deal. */
+export declare const TreeSelect: import("svelte").Component<TreeSelectProps, {}, "value">;
+//#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,
@@ -14101,4 +15059,20 @@ export declare const Tour: typeof Tour$1;
  * NodeRenameInput, plus createTreeCollection. */
 export declare const TreeView: typeof TreeView$1;
 //#endregion
-export { type ActionProps, type AiPartProps, type AlertPartProps, type AlertProps, type AlertStatus, type AvatarGroupProps, type BadgeProps, type BannerCloseProps, type BannerPartProps, type BannerProps, type BannerStatus, type BreadcrumbCurrentProps, type BreadcrumbItemProps, type BreadcrumbLinkProps, type BreadcrumbListProps, type BreadcrumbProps, type BreadcrumbSeparatorProps, type ButtonProps, type CalendarProps, Card$1 as Card, type CardDescriptionProps, type CardPartProps, type CardProps, type CardTitleProps, type ChipProps, type ColumnDef, type CreateToasterReturn, type DataTableProps, type DataUIPart, type DateInputFocusChangeDetails, type DateInputValueChangeDetails, type DatePickerFocusChangeDetails, type DatePickerOpenChangeDetails, type DatePickerValueChangeDetails, type DatePickerViewChangeDetails, type DatePickerVisibleRangeChangeDetails, type DialogOpenChangeDetails, type EmptyDescriptionProps, type EmptyPartProps, type EmptyProps, type EmptyTitleProps, type FileUIPart, FlexRender, type KbdProps, type LinkProps, type MessageProps, type MessageRole, type MeterPartProps, type MeterRootProps, type PageHeaderPartProps, type PromptInputProps, type ReasoningProps, type ReasoningUIPart, type ResponseProps, type SeparatorProps, type SkeletonProps, type SortingState, type SourceDocumentUIPart, type SourceProps, type SourceUrlUIPart, type SpinnerProps, type StatDeltaProps, type StatPartProps, type StepStartUIPart, type SuggestionProps, type TextUIPart, type TimelineContentProps, type TimelineItemProps, type TimelineMarkerProps, type TimelineProps, type ToolProps, type ToolStatus, type ToolUIPart, type TourInteractOutsideEvent, type TourPointerDownOutsideEvent, type TourStepDetails, type TreeViewCheckedChangeDetails, type TreeViewExpandedChangeDetails, type TreeViewFocusChangeDetails, type TreeViewSelectionChangeDetails, type TypographyPartProps, type UIMessage, type UIMessagePart, createColumnHelper, createListCollection, createToaster, useTour };
+//#region src/components/watermark/props.d.ts
+interface WatermarkProps extends HTMLAttributes<HTMLDivElement> {
+  content: string;
+  opacity?: number;
+  rotate?: number;
+  fontSize?: string;
+  children?: Snippet;
+}
+//#endregion
+//#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 declare const Watermark: import("svelte").Component<WatermarkProps, {}, "">;
+//#endregion
+export { type ActionProps, type AffixProps, Attachment as AiAttachment, Attachments as AiAttachments, type AiPartProps, type AlertPartProps, type AlertProps, type AlertStatus, type AspectRatioProps, type AttachmentProps, type AttachmentStatus, type AttachmentsProps, type AutoCompleteProps, type AvatarGroupProps, type BackTopProps, type BadgeProps, type BannerCloseProps, type BannerPartProps, type BannerProps, type BannerStatus, type BreadcrumbCurrentProps, type BreadcrumbItemProps, type BreadcrumbLinkProps, type BreadcrumbListProps, type BreadcrumbProps, type BreadcrumbSeparatorProps, type ButtonGroupProps, type ButtonProps, type CalendarProps, Card$1 as Card, type CardDescriptionProps, type CardPartProps, type CardProps, type CardTitleProps, type CascadeSelectNode, type CascadeSelectProps, type CheckboxGroupProps, type CheckboxOption, type ChipProps, ClientOnly, type ClientOnlyProps, type CollectionItem, type CollectionOptions, type ColumnDef, type CommandEntry, type CommandProps, type CommentProps, type ConfigContext, type ConfigDensity, type ConfigProviderProps, type ContainerProps, type CreateToasterReturn, type DataTableProps, type DataUIPart, type DateInputFocusChangeDetails, type DateInputValueChangeDetails, type DatePickerFocusChangeDetails, type DatePickerOpenChangeDetails, type DatePickerValueChangeDetails, type DatePickerViewChangeDetails, type DatePickerVisibleRangeChangeDetails, type DescriptionsPartProps, type DescriptionsRootProps, type DialogOpenChangeDetails, DownloadTrigger, type DownloadTriggerBaseProps, type DownloadTriggerProps, type DownloadableData, type DynamicInputProps, type EllipsisProps, type EmptyDescriptionProps, type EmptyPartProps, type EmptyProps, type EmptyTitleProps, type FilePathTreeNode, type FileUIPart, type FlatTreeNode, FlexRender, type FloatButtonContext, type FloatButtonItemProps, type FloatButtonPlacement, type FloatButtonProps, type FloatButtonTriggerProps, FocusTrap, type FocusTrapBaseProps, type FocusTrapProps, type FormError, type FormFieldProps, type FormInputEvent, type FormProps, type GridCollection, type GridCollectionOptions, type GridProps, type IconProps, type ImageProps, type ImageViewerProps, type InputGroupAddonProps, type InputGroupProps, type InputProps, type KbdProps, type LayoutContext, type LayoutProps, type LayoutRegionProps, type LayoutSiderProps, type LinkProps, type ListActionsProps, type ListCollection, type ListContentProps, type ListItemProps, type ListLeadingProps, type ListProps, type MasonryProps, type MentionEntry, type MentionsProps, type MentionsVesselProps, type MenubarEntry, type MenubarGroup, type MenubarProps, type MessageProps, type MessageRole, type MeterPartProps, type MeterRootProps, type PageHeaderPartProps, type PopconfirmProps, Presence, type PresenceProps, PresenceProvider, type ProgressGroupProps, type ProgressSegment, type PromptInputProps, type ReasoningProps, type ReasoningUIPart, type ResponseProps, type SeparatorProps, type SkeletonProps, type SortingState, type SourceDocumentUIPart, type SourceProps, type SourceUrlUIPart, type SourcesProps, type SpinnerProps, type SplitButtonEntry, type SplitButtonProps, type StackProps, type StandardSchema, type StatDeltaProps, type StatPartProps, type StepStartUIPart, type SuggestionProps, type TextUIPart, type TextareaProps, type TimelineContentProps, type TimelineItemProps, type TimelineMarkerProps, type TimelineProps, type ToolProps, type ToolStatus, type ToolUIPart, type TourInteractOutsideEvent, type TourPointerDownOutsideEvent, type TourStepDetails, type TransferItem, type TransferProps, type TreeCollection, type TreeCollectionOptions, type TreeNode, type TreeSelectNode, type TreeSelectProps, type TreeViewCheckedChangeDetails, type TreeViewExpandedChangeDetails, type TreeViewFocusChangeDetails, type TreeViewSelectionChangeDetails, type TypographyPartProps, 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, type WatermarkProps, createColumnHelper, createFileTreeCollection, createGridCollection, createToaster, createTreeCollection, splitPresenceProps, useAsyncList, useDownload, useListCollection, useListSelection, useMentions, usePresence, usePresenceContext, useTour };