@rokkit/ui 1.1.17 → 1.1.19

package/dist/MarkdownRenderer.svelte.d.ts

@@ -0,0 +1,15 @@
+import type { Component, Snippet } from 'svelte';
+import type { MarkdownPlugin } from './markdown-plugin.js';
+interface Props {
+    markdown: string;
+    plugins?: MarkdownPlugin[];
+    /** Optional wrapper component (e.g. CrossFilter from @rokkit/chart) for grouping
+     *  co-labelled plot blocks. When provided, plot code blocks whose JSON contains a
+     *  `crossfilter` field with the same value are wrapped in a shared instance. */
+    crossfilterWrapper?: Component<{
+        children?: Snippet;
+    }>;
+}
+declare const MarkdownRenderer: Component<Props, {}, "">;
+type MarkdownRenderer = ReturnType<typeof MarkdownRenderer>;
+export default MarkdownRenderer;

package/dist/components/AlertList.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { AlertListProps } from '../types/alert-list.js';
+declare const AlertList: import("svelte").Component<AlertListProps, {}, "">;
+type AlertList = ReturnType<typeof AlertList>;
+export default AlertList;

package/dist/components/Avatar.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { AvatarProps } from '../types/avatar.js';
+declare const Avatar: import("svelte").Component<AvatarProps, {}, "">;
+type Avatar = ReturnType<typeof Avatar>;
+export default Avatar;

package/dist/components/Badge.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { BadgeProps } from '../types/badge.js';
+declare const Badge: import("svelte").Component<BadgeProps, {}, "">;
+type Badge = ReturnType<typeof Badge>;
+export default Badge;

package/dist/components/BreadCrumbs.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { BreadCrumbsProps } from '../types/breadcrumbs.js';
+declare const BreadCrumbs: import("svelte").Component<BreadCrumbsProps, {}, "">;
+type BreadCrumbs = ReturnType<typeof BreadCrumbs>;
+export default BreadCrumbs;

package/dist/components/Button.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { ButtonProps } from '../types/button.js';
+declare const Button: import("svelte").Component<ButtonProps, {}, "">;
+type Button = ReturnType<typeof Button>;
+export default Button;

package/dist/components/ButtonGroup.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { ButtonGroupProps } from '../types/button.js';
+declare const ButtonGroup: import("svelte").Component<ButtonGroupProps, {}, "">;
+type ButtonGroup = ReturnType<typeof ButtonGroup>;
+export default ButtonGroup;

package/dist/components/Card.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { CardProps } from '../types/card.js';
+declare const Card: import("svelte").Component<CardProps, {}, "">;
+type Card = ReturnType<typeof Card>;
+export default Card;

package/dist/components/Carousel.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { CarouselProps } from '../types/carousel.js';
+declare const Carousel: import("svelte").Component<CarouselProps, {}, "current">;
+type Carousel = ReturnType<typeof Carousel>;
+export default Carousel;

package/dist/components/Code.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { CodeProps } from '../types/index.js';
+type $$ComponentProps = CodeProps & {
+    labels?: Record<string, string>;
+};
+declare const Code: import("svelte").Component<$$ComponentProps, {}, "">;
+type Code = ReturnType<typeof Code>;
+export default Code;

package/dist/components/CodeBlock.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { CodeBlockProps } from '../types/code.js';
+declare const CodeBlock: import("svelte").Component<CodeBlockProps, {}, "">;
+type CodeBlock = ReturnType<typeof CodeBlock>;
+export default CodeBlock;

package/dist/components/CodeGroup.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { CodeGroupProps } from '../types/code.js';
+declare const CodeGroup: import("svelte").Component<CodeGroupProps, {}, "">;
+type CodeGroup = ReturnType<typeof CodeGroup>;
+export default CodeGroup;

package/dist/components/CommandPalette.svelte.d.ts

@@ -0,0 +1,7 @@
+type $$ComponentProps = {
+    open?: boolean;
+    placeholder?: string;
+};
+declare const CommandPalette: import("svelte").Component<$$ComponentProps, {}, "open">;
+type CommandPalette = ReturnType<typeof CommandPalette>;
+export default CommandPalette;

package/dist/components/Connector.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { ConnectorProps } from '../types/connector.js';
+declare const Connector: import("svelte").Component<ConnectorProps, {}, "">;
+type Connector = ReturnType<typeof Connector>;
+export default Connector;

package/dist/components/Divider.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { DividerProps } from '../types/divider.js';
+declare const Divider: import("svelte").Component<DividerProps, {}, "">;
+type Divider = ReturnType<typeof Divider>;
+export default Divider;

package/dist/components/Dropdown.svelte.d.ts

@@ -0,0 +1,22 @@
+interface DropdownIcons {
+    opened?: string;
+    closed?: string;
+}
+type $$ComponentProps = {
+    items?: unknown[];
+    fields?: Record<string, string>;
+    value?: unknown;
+    placeholder?: string;
+    icon?: string;
+    size?: string;
+    disabled?: boolean;
+    showArrow?: boolean;
+    align?: 'start' | 'end';
+    direction?: 'up' | 'down';
+    icons?: DropdownIcons;
+    onchange?: (value: unknown, item: unknown) => void;
+    class?: string;
+};
+declare const Dropdown: import("svelte").Component<$$ComponentProps, {}, "value">;
+type Dropdown = ReturnType<typeof Dropdown>;
+export default Dropdown;

package/dist/components/FloatingAction.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { FloatingActionProps, FloatingActionItemSnippet } from '../types/floating-action.js';
+type $$ComponentProps = FloatingActionProps & {
+    [key: string]: FloatingActionItemSnippet | unknown;
+};
+declare const FloatingAction: import("svelte").Component<$$ComponentProps, {}, "open">;
+type FloatingAction = ReturnType<typeof FloatingAction>;
+export default FloatingAction;

package/dist/components/FloatingNavigation.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { FloatingNavigationProps } from '../types/floating-navigation.js';
+type $$ComponentProps = FloatingNavigationProps & {
+    labels?: Record<string, string>;
+};
+declare const FloatingNavigation: import("svelte").Component<$$ComponentProps, {}, "value" | "pinned">;
+type FloatingNavigation = ReturnType<typeof FloatingNavigation>;
+export default FloatingNavigation;

package/dist/components/Frame.svelte.d.ts

@@ -0,0 +1,17 @@
+/**
+     * Frame — generic header / body / footer container.
+     *
+     * The canonical "card-shaped UI block" primitive. Hands the structure
+     * to themes via `[data-frame]`, `[data-frame-header]`,
+     * `[data-frame-body]`, `[data-frame-footer]`; consumers decide what
+     * goes inside each slot.
+     *
+     * Used by PlotPlugin to wrap a chart, by CodeBlock to wrap a code
+     * block's chrome, and anywhere else a header/body/footer card is
+     * the right pattern. For an interactive card (link or button), use
+     * `<Card/>` instead.
+     */
+import type { FrameProps } from '../types/frame.js';
+declare const Frame: import("svelte").Component<FrameProps, {}, "">;
+type Frame = ReturnType<typeof Frame>;
+export default Frame;

package/dist/components/Grid.svelte.d.ts

@@ -0,0 +1,45 @@
+/**
+     * Grid — Responsive tile grid with Wrapper + Navigator horizontal navigation.
+     *
+     * Architecture:
+     *   Wrapper       — owns focusedKey $state + flatView $derived
+     *   Navigator     — attaches DOM event handlers, calls wrapper[action](path)
+     *                   horizontal orientation (ArrowLeft/ArrowRight navigation)
+     *   flatView loop — single flat {#each} rendering items as grid tiles
+     *
+     * Snippet customization:
+     *   itemContent   — replaces inner content of <button> for each tile
+     *   [named]       — per-item override via item.snippet = 'name'; falls back to itemContent
+     *
+     *   Snippets receive (proxy) only — the <button> wrapper with data-path is
+     *   always rendered by this component, so snippets never need to handle navigation.
+     *
+     * Data attributes on rendered elements:
+     *   data-grid           — root container
+     *   data-grid-item      — each tile button
+     *   data-path           — required by Navigator for click detection + scroll
+     *   data-active         — highlights current value match
+     *   data-disabled       — disabled state
+     *   data-size           — size variant
+     *
+     * CSS custom properties:
+     *   --grid-min-size     — minimum tile width for auto-fill
+     *   --grid-gap          — grid gap
+     */
+import type { ProxyItem } from '@rokkit/states';
+type $$ComponentProps = {
+    items?: unknown[];
+    fields?: Record<string, string>;
+    value?: unknown;
+    size?: string;
+    disabled?: boolean;
+    minSize?: string;
+    gap?: string;
+    label?: string;
+    onselect?: (value: unknown, proxy: ProxyItem) => void;
+    class?: string;
+    [key: string]: unknown;
+};
+declare const Grid: import("svelte").Component<$$ComponentProps, {}, "value">;
+type Grid = ReturnType<typeof Grid>;
+export default Grid;

package/dist/components/ItemContent.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { ItemContentProps } from '../types/item-content.js';
+declare const ItemContent: import("svelte").Component<ItemContentProps, {}, "">;
+type ItemContent = ReturnType<typeof ItemContent>;
+export default ItemContent;

package/dist/components/LazyTree.svelte.d.ts

@@ -0,0 +1,30 @@
+/**
+     * LazyTree — Tree + lazy loading.
+     *
+     * Same as Tree but uses LazyProxyItem via createProxy factory
+     * so nodes with children: true fetch on expand.
+     *
+     * Default item content: icon + label + badge + shortcut (no avatar/description).
+     * Parent nodes hide their icon by default.
+     */
+import type { ProxyItem } from '@rokkit/states';
+type $$ComponentProps = {
+    items?: unknown[];
+    fields?: Record<string, string>;
+    value?: unknown;
+    size?: 'sm' | 'md' | 'lg';
+    lineStyle?: 'none' | 'solid' | 'dashed' | 'dotted';
+    labels?: Record<string, string>;
+    icons?: {
+        opened?: string;
+        closed?: string;
+    };
+    onselect?: (value: unknown, proxy: ProxyItem) => void;
+    onlazyload?: (current?: unknown) => Promise<unknown[]>;
+    hasMore?: boolean;
+    class?: string;
+    [key: string]: unknown;
+};
+declare const LazyTree: import("svelte").Component<$$ComponentProps, {}, "value">;
+type LazyTree = ReturnType<typeof LazyTree>;
+export default LazyTree;

package/dist/components/List.svelte.d.ts

@@ -0,0 +1,49 @@
+/**
+     * List — ProxyItem + Wrapper + Navigator implementation.
+     *
+     * Architecture:
+     *   Wrapper       — owns focusedKey $state + flatView $derived
+     *   Navigator     — attaches DOM event handlers, calls wrapper[action](path)
+     *                   owns focus + scrollIntoView after every keyboard action
+     *   flatView loop — single flat {#each}, no nested groups in template
+     *
+     * Snippet customization:
+     *   itemContent   — replaces inner content of <a>/<button> for leaf items
+     *   groupContent  — replaces inner content of group header <button>
+     *   [named]       — per-item override via item.snippet = 'name'; falls back to itemContent
+     *
+     *   Snippets receive (proxy) only — the <a>/<button> wrapper with data-path is
+     *   always rendered by this component, so snippets never need to handle navigation.
+     *
+     * Data attributes on rendered elements:
+     *   data-path              — required by Navigator for click detection + scroll
+     *   data-level             — nesting depth (1=root); theme CSS uses for indentation
+     *   data-accordion-trigger — tells Navigator to dispatch toggle (not select) on click
+     *   data-list-item         — theme hook for leaf items
+     *   data-list-item-icon    — icon span inside leaf items
+     *   data-list-group        — theme hook for group headers
+     *   data-list-group-icon   — icon span inside group headers
+     *   data-active            — highlights current value match
+     *   data-disabled          — disabled state
+     */
+import type { ProxyItem } from '@rokkit/states';
+interface ListIcons {
+    opened?: string;
+    closed?: string;
+}
+type $$ComponentProps = {
+    items?: unknown[];
+    fields?: Record<string, string>;
+    value?: unknown;
+    size?: string;
+    disabled?: boolean;
+    collapsible?: boolean;
+    label?: string;
+    icons?: ListIcons;
+    onselect?: (value: unknown, proxy: ProxyItem) => void;
+    class?: string;
+    [key: string]: unknown;
+};
+declare const List: import("svelte").Component<$$ComponentProps, {}, "value">;
+type List = ReturnType<typeof List>;
+export default List;

package/dist/components/Menu.svelte.d.ts

@@ -0,0 +1,68 @@
+/**
+     * Menu — Trigger + dropdown with List-identical content.
+     *
+     * Architecture:
+     *   Trigger      — manages open/close from trigger button (click, Enter, Escape, click-outside)
+     *   Wrapper      — owns focusedKey $state + flatView $derived (cancel/blur overridden to close)
+     *   Navigator    — attaches DOM event handlers on dropdown, calls wrapper[action](path)
+     *   flatView loop — single flat {#each}, same as List
+     *
+     * The dropdown content is identical to List: same flatView loop, same snippet system,
+     * same collapsible groups. The only additions are trigger, alignment, and direction.
+     *
+     * Snippet customization (same as List):
+     *   itemContent   — replaces inner content of <button> for leaf items
+     *   groupContent  — replaces inner content of group header <button>
+     *   [named]       — per-item override via item.snippet = 'name'; falls back to itemContent
+     *
+     * Data attributes on rendered elements:
+     *   data-menu               — root container
+     *   data-menu-trigger       — trigger button
+     *   data-menu-label         — trigger label text
+     *   data-menu-icon          — trigger icon
+     *   data-menu-arrow         — trigger dropdown arrow
+     *   data-menu-dropdown      — dropdown container
+     *   data-menu-item          — leaf items (like data-list-item)
+     *   data-menu-item-icon     — icon span inside leaf items
+     *   data-menu-item-text     — text span inside leaf items
+     *   data-menu-group         — group headers (like data-list-group)
+     *   data-menu-group-icon    — icon span inside group headers
+     *   data-menu-group-text    — text span inside group headers
+     *   data-menu-expand-icon   — expand/collapse chevron in group headers
+     *   data-menu-separator     — separator
+     *   data-menu-spacer        — spacer
+     *   data-path               — required by Navigator for click detection + scroll
+     *   data-level              — nesting depth (1=root)
+     *   data-accordion-trigger  — tells Navigator to dispatch toggle on click
+     *   data-active             — highlights current value match
+     *   data-disabled           — disabled state
+     *   data-open               — dropdown is open
+     *   data-size               — size variant
+     *   data-align              — dropdown alignment
+     *   data-direction          — dropdown direction
+     */
+import type { ProxyItem } from '@rokkit/states';
+interface MenuIcons {
+    opened?: string;
+    closed?: string;
+}
+type $$ComponentProps = {
+    items?: unknown[];
+    fields?: Record<string, string>;
+    value?: unknown;
+    size?: string;
+    disabled?: boolean;
+    collapsible?: boolean;
+    label?: string;
+    icon?: string;
+    showArrow?: boolean;
+    align?: 'start' | 'end';
+    direction?: 'up' | 'down';
+    icons?: MenuIcons;
+    onselect?: (value: unknown, proxy: ProxyItem) => void;
+    class?: string;
+    [key: string]: unknown;
+};
+declare const Menu: import("svelte").Component<$$ComponentProps, {}, "">;
+type Menu = ReturnType<typeof Menu>;
+export default Menu;

package/dist/components/Message.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { MessageProps } from '../types/message.js';
+declare const Message: import("svelte").Component<MessageProps, {}, "">;
+type Message = ReturnType<typeof Message>;
+export default Message;

package/dist/components/MultiSelect.svelte.d.ts

@@ -0,0 +1,25 @@
+interface MultiSelectIcons {
+    opened?: string;
+    closed?: string;
+    checked?: string;
+    remove?: string;
+}
+type $$ComponentProps = {
+    items?: unknown[];
+    fields?: Record<string, string>;
+    value?: unknown[];
+    selected?: unknown[];
+    placeholder?: string;
+    size?: string;
+    disabled?: boolean;
+    maxDisplay?: number;
+    align?: 'start' | 'end';
+    direction?: 'up' | 'down';
+    icons?: MultiSelectIcons;
+    onchange?: (values: unknown[], items: unknown[]) => void;
+    class?: string;
+    [key: string]: unknown;
+};
+declare const MultiSelect: import("svelte").Component<$$ComponentProps, {}, "value" | "selected">;
+type MultiSelect = ReturnType<typeof MultiSelect>;
+export default MultiSelect;

package/dist/components/NavContent.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { NavContentProps } from '../types/nav-content.js';
+declare const NavContent: import("svelte").Component<NavContentProps, {}, "">;
+type NavContent = ReturnType<typeof NavContent>;
+export default NavContent;

package/dist/components/PaletteManager.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { PaletteManagerProps } from '../types/palette.js';
+declare const PaletteManager: import("svelte").Component<PaletteManagerProps, {}, "value" | "custom">;
+type PaletteManager = ReturnType<typeof PaletteManager>;
+export default PaletteManager;

package/dist/components/Pill.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { PillProps } from '../types/pill.js';
+declare const Pill: import("svelte").Component<PillProps, {}, "">;
+type Pill = ReturnType<typeof Pill>;
+export default Pill;

package/dist/components/ProgressBar.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { ProgressBarProps } from '../types/progress-bar.js';
+declare const ProgressBar: import("svelte").Component<ProgressBarProps, {}, "">;
+type ProgressBar = ReturnType<typeof ProgressBar>;
+export default ProgressBar;

package/dist/components/Range.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { RangeProps } from '../types/range.js';
+type $$ComponentProps = RangeProps & {
+    labels?: Record<string, string>;
+};
+declare const Range: import("svelte").Component<$$ComponentProps, {}, "value" | "lower" | "upper">;
+type Range = ReturnType<typeof Range>;
+export default Range;

package/dist/components/Rating.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { RatingProps } from '../types/rating.js';
+declare const Rating: import("svelte").Component<RatingProps, {}, "value">;
+type Rating = ReturnType<typeof Rating>;
+export default Rating;

package/dist/components/ResponsiveGrid.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { ResponsiveGridProps } from '../types/responsive-grid.js';
+declare const ResponsiveGrid: import("svelte").Component<ResponsiveGridProps, {}, "">;
+type ResponsiveGrid = ReturnType<typeof ResponsiveGrid>;
+export default ResponsiveGrid;

package/dist/components/Reveal.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { RevealProps } from '../types/reveal.js';
+declare const Reveal: import("svelte").Component<RevealProps, {}, "">;
+type Reveal = ReturnType<typeof Reveal>;
+export default Reveal;

package/dist/components/SearchFilter.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { SearchFilterProps } from '../types/search-filter.js';
+type $$ComponentProps = SearchFilterProps & {
+    labels?: Record<string, string>;
+};
+declare const SearchFilter: import("svelte").Component<$$ComponentProps, {}, "filters">;
+type SearchFilter = ReturnType<typeof SearchFilter>;
+export default SearchFilter;

package/dist/components/Select.svelte.d.ts

@@ -0,0 +1,26 @@
+interface SelectIcons {
+    opened?: string;
+    closed?: string;
+    checked?: string;
+}
+type $$ComponentProps = {
+    items?: unknown[];
+    fields?: Record<string, string>;
+    value?: unknown;
+    selected?: unknown;
+    placeholder?: string;
+    size?: string;
+    disabled?: boolean;
+    filterable?: boolean;
+    filterPlaceholder?: string;
+    align?: 'start' | 'end';
+    direction?: 'up' | 'down';
+    maxRows?: number;
+    icons?: SelectIcons;
+    onchange?: (value: unknown, item: unknown) => void;
+    class?: string;
+    [key: string]: unknown;
+};
+declare const Select: import("svelte").Component<$$ComponentProps, {}, "value" | "selected">;
+type Select = ReturnType<typeof Select>;
+export default Select;

package/dist/components/Shine.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { ShineProps } from '../types/shine.js';
+declare const Shine: import("svelte").Component<ShineProps, {}, "">;
+type Shine = ReturnType<typeof Shine>;
+export default Shine;

package/dist/components/Stack.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { StackProps } from '../types/stack.js';
+declare const Stack: import("svelte").Component<StackProps, {}, "">;
+type Stack = ReturnType<typeof Stack>;
+export default Stack;

package/dist/components/StatusList.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { StatusListProps } from '../types/status-list.js';
+declare const StatusList: import("svelte").Component<StatusListProps, {}, "">;
+type StatusList = ReturnType<typeof StatusList>;
+export default StatusList;

package/dist/components/Stepper.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { StepperProps } from '../types/stepper.js';
+declare const Stepper: import("svelte").Component<StepperProps, {}, "current" | "currentStage">;
+type Stepper = ReturnType<typeof Stepper>;
+export default Stepper;

package/dist/components/Swatch.svelte.d.ts

@@ -0,0 +1,30 @@
+import type { Snippet } from 'svelte';
+import type { ProxyItem } from '@rokkit/states';
+interface SwatchProps {
+    /** Color options — primitives (hex/name strings) or objects with mapped fields */
+    options?: Array<string | number | Record<string, unknown>>;
+    /** Field mapping for object options (value, fill, stroke, …) */
+    fields?: Record<string, string>;
+    /** Selected value (bindable). Array when `multiple`. */
+    value?: unknown;
+    /** Allow multiple selection */
+    multiple?: boolean;
+    /** Swatch shape */
+    shape?: 'square' | 'circle';
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Disable the whole group */
+    disabled?: boolean;
+    /** Accessible group label */
+    label?: string;
+    /** Additional CSS classes */
+    class?: string;
+    /** Called when selection changes */
+    onchange?: (value: unknown, item: unknown) => void;
+    /** Custom snippet for rendering a swatch (receives proxy + selected) */
+    item?: Snippet<[ProxyItem, boolean]>;
+    [key: string]: unknown;
+}
+declare const Swatch: import("svelte").Component<SwatchProps, {}, "value">;
+type Swatch = ReturnType<typeof Swatch>;
+export default Swatch;

package/dist/components/Switch.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { SwitchProps } from '../types/switch.js';
+declare const Switch: import("svelte").Component<SwitchProps, {}, "value">;
+type Switch = ReturnType<typeof Switch>;
+export default Switch;

package/dist/components/Table.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { TableProps } from '../types/table.js';
+declare const Table: import("svelte").Component<TableProps, {}, "values">;
+type Table = ReturnType<typeof Table>;
+export default Table;

package/dist/components/Tabs.svelte.d.ts

@@ -0,0 +1,26 @@
+/**
+     * Tabs — Wrapper + Navigator + ProxyItem implementation.
+     *
+     * Architecture:
+     *   Wrapper       — owns focusedKey $state + flatView $derived
+     *   Navigator     — attaches DOM event handlers, calls wrapper[action](path)
+     *                   owns focus + scrollIntoView after every keyboard action
+     *   flatView loop — single flat {#each} for tab triggers
+     *
+     * Snippet customization:
+     *   itemContent   — replaces inner content of <button> for tab triggers
+     *   tabPanel      — replaces panel content
+     *   [named]       — per-item override via item.snippet = 'name'; falls back to itemContent
+     *   empty         — rendered when no options
+     *
+     * Tab panels are rendered separately from triggers. Only the active panel
+     * receives data-panel-active. Navigator ignores panels (no data-path on them).
+     */
+import type { TabsProps } from '../types/tabs.js';
+type $$ComponentProps = TabsProps & {
+    labels?: Record<string, string>;
+    [key: string]: unknown;
+};
+declare const Tabs: import("svelte").Component<$$ComponentProps, {}, "value">;
+type Tabs = ReturnType<typeof Tabs>;
+export default Tabs;

package/dist/components/Tilt.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { TiltProps } from '../types/tilt.js';
+declare const Tilt: import("svelte").Component<TiltProps, {}, "">;
+type Tilt = ReturnType<typeof Tilt>;
+export default Tilt;

package/dist/components/Timeline.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { TimelineProps } from '../types/timeline.js';
+declare const Timeline: import("svelte").Component<TimelineProps, {}, "">;
+type Timeline = ReturnType<typeof Timeline>;
+export default Timeline;

package/dist/components/Toggle.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { ToggleProps } from '../types/toggle.js';
+type $$ComponentProps = ToggleProps & {
+    [key: string]: unknown;
+};
+declare const Toggle: import("svelte").Component<$$ComponentProps, {}, "value">;
+type Toggle = ReturnType<typeof Toggle>;
+export default Toggle;

package/dist/components/Toolbar.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { ToolbarProps, ToolbarItemSnippet } from '../types/toolbar.js';
+type $$ComponentProps = ToolbarProps & {
+    label?: string;
+    [key: string]: ToolbarItemSnippet | unknown;
+};
+declare const Toolbar: import("svelte").Component<$$ComponentProps, {}, "">;
+type Toolbar = ReturnType<typeof Toolbar>;
+export default Toolbar;

package/dist/components/ToolbarGroup.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { ToolbarGroupProps } from '../types/toolbar.js';
+declare const ToolbarGroup: import("svelte").Component<ToolbarGroupProps, {}, "">;
+type ToolbarGroup = ReturnType<typeof ToolbarGroup>;
+export default ToolbarGroup;