@rokkit/ui 1.4.1 → 1.5.0

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

@@ -1,30 +1,4 @@
-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;
-}
+import type { SwatchProps } from '../types/swatch.js';
 declare const Swatch: import("svelte").Component<SwatchProps, {}, "value">;
 type Swatch = ReturnType<typeof Swatch>;
 export default Swatch;

package/dist/components/Tabs.svelte

@@ -22,6 +22,7 @@
 	import { Wrapper, ProxyTree, messages } from '@rokkit/states'
 	import { Navigator } from '@rokkit/actions'
 	import { resolveSnippet, ITEM_SNIPPET, DEFAULT_STATE_ICONS } from '@rokkit/core'
+	import type { SelectableItemSnippet } from '../types/snippets.js'
 
 	let {
 		options = [],
@@ -41,7 +42,12 @@
 		onadd,
 		onremove,
 		...snippets
-	}: TabsProps & { labels?: Record<string, string>; [key: string]: unknown } = $props()
+	}: TabsProps & {
+		labels?: Record<string, string>
+		// Tabs renders its content as content(proxy, selected).
+		itemContent?: SelectableItemSnippet
+		[key: string]: unknown
+	} = $props()
 
 	const labels = $derived({ ...messages.tabs, ...userLabels })
 

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

@@ -17,8 +17,10 @@
      * receives data-panel-active. Navigator ignores panels (no data-path on them).
      */
 import type { TabsProps } from '../types/tabs.js';
+import type { SelectableItemSnippet } from '../types/snippets.js';
 type $$ComponentProps = TabsProps & {
     labels?: Record<string, string>;
+    itemContent?: SelectableItemSnippet;
     [key: string]: unknown;
 };
 declare const Tabs: import("svelte").Component<$$ComponentProps, {}, "value">;

package/dist/components/Toggle.svelte

@@ -4,6 +4,7 @@
 	import { Wrapper, ProxyTree, messages } from '@rokkit/states'
 	import { Navigator } from '@rokkit/actions'
 	import { resolveSnippet } from '@rokkit/core'
+	import type { SelectableItemSnippet } from '../types/snippets.js'
 
 	let {
 		variant = 'group',
@@ -17,7 +18,11 @@
 		label = messages.toggle.label,
 		class: className = '',
 		...snippets
-	}: ToggleProps & { [key: string]: unknown } = $props()
+	}: ToggleProps & {
+		// Toggle renders its content as content(proxy, selected).
+		itemContent?: SelectableItemSnippet
+		[key: string]: unknown
+	} = $props()
 
 	// ─── Wrapper ──────────────────────────────────────────────────────────────
 

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

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

package/dist/components/Tree.svelte

@@ -17,6 +17,7 @@
 	import { DEFAULT_STATE_ICONS, resolveSnippet, ITEM_SNIPPET } from '@rokkit/core'
 	import ItemContent from './ItemContent.svelte'
 	import Connector from './Connector.svelte'
+	import type { TreeProps } from '../types/tree.js'
 
 	let {
 		items = [],
@@ -29,18 +30,7 @@
 		onselect,
 		class: className = '',
 		...snippets
-	}: {
-		items?: unknown[]
-		fields?: Record<string, string>
-		value?: unknown
-		size?: string
-		lineStyle?: 'none' | 'solid' | 'dashed' | 'dotted'
-		labels?: Record<string, string>
-		icons?: { opened?: string; closed?: string }
-		onselect?: (value: unknown, proxy: ProxyItem) => void
-		class?: string
-		[key: string]: unknown
-	} = $props()
+	}: TreeProps = $props()
 
 	const labels = $derived({ ...messages.tree, ...userLabels })
 

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

@@ -1,31 +1,4 @@
-/**
-     * Tree — Hierarchical data navigation with tree lines and keyboard navigation.
-     *
-     * Architecture:
-     *   LazyWrapper  — owns focusedKey $state + flatView $derived (with lineTypes)
-     *   Navigator    — attaches DOM event handlers, calls wrapper[action](path)
-     *   flatView     — single flat {#each}, connectors rendered from node.lineTypes
-     *
-     * Default item content: icon + label + badge + shortcut (no avatar/description).
-     * Parent nodes hide their icon by default (showIcon=false) so only the
-     * expand/collapse chevron + label are shown, aligning with leaf icon + label.
-     */
-import type { ProxyItem } from '@rokkit/states';
-type $$ComponentProps = {
-    items?: unknown[];
-    fields?: Record<string, string>;
-    value?: unknown;
-    size?: string;
-    lineStyle?: 'none' | 'solid' | 'dashed' | 'dotted';
-    labels?: Record<string, string>;
-    icons?: {
-        opened?: string;
-        closed?: string;
-    };
-    onselect?: (value: unknown, proxy: ProxyItem) => void;
-    class?: string;
-    [key: string]: unknown;
-};
-declare const Tree: import("svelte").Component<$$ComponentProps, {}, "value">;
+import type { TreeProps } from '../types/tree.js';
+declare const Tree: import("svelte").Component<TreeProps, {}, "value">;
 type Tree = ReturnType<typeof Tree>;
 export default Tree;

package/dist/types/chat.d.ts

@@ -1,6 +1,16 @@
 import type { Snippet } from 'svelte';
 export type ChatRole = 'user' | 'assistant' | 'system';
 export type ChatStatus = 'streaming' | 'error' | 'done';
+/**
+ * A single message in a chat transcript.
+ *
+ * Also exported as `ChatMessageData`, which is the name consumers should import.
+ * The package entry exports a *component* called `ChatMessage` as well, and
+ * Svelte's generated component types contribute a type of that name — which
+ * shadows this interface, making `ChatMessage<T>` unreachable from outside the
+ * package. The alias is the reachable spelling; renaming either the component or
+ * this interface is a breaking change, so it waits for a major.
+ */
 export interface ChatMessage<T = unknown> {
     id: string;
     role: ChatRole;
@@ -12,6 +22,11 @@ export interface ChatMessage<T = unknown> {
     /** Arbitrary payload (parts/blocks/chart spec/form schema) the consumer's `message` snippet reads. */
     data?: T;
 }
+/**
+ * Reachable alias for {@link ChatMessage} — see the note on that interface for
+ * why the bare name does not survive the package boundary.
+ */
+export type ChatMessageData<T = unknown> = ChatMessage<T>;
 export interface ConversationSummary {
     id: string;
     title: string;

package/dist/types/command-palette.d.ts

@@ -0,0 +1,18 @@
+/**
+ * CommandPalette Component Types
+ *
+ * Overlay command launcher. It owns its own command source and filtering, so
+ * the public surface is just visibility and the search affordance's label.
+ */
+/**
+ * Props for the CommandPalette component.
+ *
+ * `CommandPalette.svelte` annotates its own `$props()` with this interface, so
+ * the two cannot drift.
+ */
+export interface CommandPaletteProps {
+    /** Whether the palette is open (bindable) */
+    open?: boolean;
+    /** Placeholder text for the search input */
+    placeholder?: string;
+}

package/dist/types/command-palette.js

@@ -0,0 +1,7 @@
+/**
+ * CommandPalette Component Types
+ *
+ * Overlay command launcher. It owns its own command source and filtering, so
+ * the public surface is just visibility and the search affordance's label.
+ */
+export {};

package/dist/types/grid.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Grid Component Types
+ *
+ * Data-driven grid of selectable cards. Same field-mapping and snippet
+ * contract as List — items are wrapped in a `ProxyItem` and rendered through
+ * `itemContent`, with the grid supplying only the track sizing.
+ */
+import type { ProxyItem } from '@rokkit/states';
+import type { ItemSnippets } from './snippets.js';
+/**
+ * Props for the Grid component.
+ *
+ * `Grid.svelte` annotates its own `$props()` with this interface, so the two
+ * cannot drift.
+ */
+export interface GridProps extends ItemSnippets {
+    /** Array of items to render as cells */
+    items?: unknown[];
+    /** Field mapping configuration */
+    fields?: Record<string, string>;
+    /** Selected value (bindable) */
+    value?: unknown;
+    /** Size variant */
+    size?: string;
+    /** Whether the entire grid is disabled */
+    disabled?: boolean;
+    /** Minimum track width, fed to `repeat(auto-fill, minmax(…))` */
+    minSize?: string;
+    /** Gap between cells */
+    gap?: string;
+    /** Accessible name for the grid */
+    label?: string;
+    /** Called when a cell is selected, with the item's `ProxyItem` */
+    onselect?: (value: unknown, proxy: ProxyItem) => void;
+    /** Additional CSS classes */
+    class?: string;
+}

package/dist/types/grid.js

@@ -0,0 +1,8 @@
+/**
+ * Grid Component Types
+ *
+ * Data-driven grid of selectable cards. Same field-mapping and snippet
+ * contract as List — items are wrapped in a `ProxyItem` and rendered through
+ * `itemContent`, with the grid supplying only the track sizing.
+ */
+export {};

package/dist/types/index.d.ts

@@ -46,3 +46,7 @@ export * from './stack.js';
 export * from './stepper.js';
 export * from './tilt.js';
 export * from './chat.js';
+export * from './snippets.js';
+export * from './grid.js';
+export * from './command-palette.js';
+export * from './swatch.js';

package/dist/types/index.js

@@ -91,3 +91,11 @@ export * from './stepper.js';
 export * from './tilt.js';
 // Chat Types
 export * from './chat.js';
+// Shared snippet types for the item-rendering components
+export * from './snippets.js';
+// Grid
+export * from './grid.js';
+// CommandPalette
+export * from './command-palette.js';
+// Swatch
+export * from './swatch.js';

package/dist/types/list.d.ts

@@ -5,6 +5,8 @@
  * Supports navigation links, button items, and grouped items with collapsible sections.
  * Field mapping and data access is handled by ProxyItem from @rokkit/states.
  */
+import type { ProxyItem } from '@rokkit/states';
+import type { ItemSnippets } from './snippets.js';
 /**
  * Field mapping configuration for list data.
  */
@@ -43,72 +45,37 @@ export declare const defaultListFields: Required<Omit<ListFields, 'fields'>>;
  */
 export type ListItem = Record<string, unknown>;
 /**
- * Handlers passed to custom item snippets
- */
-export interface ListItemHandlers {
-    /** Call to trigger item selection (for button items) */
-    onclick: () => void;
-    /** Forward keyboard events for accessibility */
-    onkeydown: (event: KeyboardEvent) => void;
-}
-/**
- * Snippet type for rendering list items.
- * Parameters: item, fields, handlers, isActive
- */
-export type ListItemSnippet = import('svelte').Snippet<[
-    ListItem,
-    ListFields,
-    ListItemHandlers,
-    boolean
-]>;
-/**
- * Snippet type for rendering group labels
- * Parameters: item (group), fields, toggleExpanded, isExpanded
- */
-export type ListGroupLabelSnippet = import('svelte').Snippet<[
-    ListItem,
-    ListFields,
-    () => void,
-    boolean
-]>;
-/**
- * Props for the List component
+ * Props for the List component.
+ *
+ * `List.svelte` annotates its own `$props()` with this interface, so the two
+ * cannot drift — which is how the previous version of this type came to
+ * describe `item` / `groupLabel` snippets and `multiselect` / `expanded` /
+ * `selected` props the component never read.
+ *
+ * Extends {@link ItemSnippets} for `itemContent` / `groupContent` plus the open
+ * index signature that per-item named snippets (`item.snippet = 'name'`) need.
  */
-export interface ListProps {
+export interface ListProps extends ItemSnippets {
     /** Array of list items or groups */
-    items?: ListItem[];
+    items?: unknown[];
     /** Field mapping configuration */
-    fields?: ListFields;
-    /** Currently selected value (for highlighting button items) */
+    fields?: Record<string, string>;
+    /** Selected value (bindable) — matched against each item's value field */
     value?: unknown;
     /** Size variant */
-    size?: 'sm' | 'md' | 'lg';
+    size?: string;
     /** Whether the entire list is disabled */
     disabled?: boolean;
     /** Whether groups can be collapsed */
     collapsible?: boolean;
-    /** Enable multiple item selection (Ctrl+click toggle, Shift+click range) */
-    multiselect?: boolean;
-    /** Which groups are expanded (bindable) - keyed by group value/text */
-    expanded?: Record<string, boolean>;
-    /** Selected items array (bindable) - populated in multiselect mode */
-    selected?: unknown[];
-    /** Active item value - List looks up item by this value to highlight it */
-    active?: unknown;
-    /** Called when a button item is selected */
-    onselect?: (value: unknown, item: ListItem) => void;
-    /** Called when selected items change in multiselect mode */
-    onselectedchange?: (selected: unknown[]) => void;
-    /** Called when expanded state changes (for bindable expanded) */
-    onexpandedchange?: (expanded: Record<string, boolean>) => void;
-    /** Additional CSS classes */
-    class?: string;
+    /** Accessible name for the list */
+    label?: string;
     /** Icons for list group states (expand/collapse arrow) */
     icons?: ListStateIcons;
-    /** Custom snippet for rendering list items */
-    item?: ListItemSnippet;
-    /** Custom snippet for rendering group labels/headers */
-    groupLabel?: ListGroupLabelSnippet;
+    /** Called when an item is selected, with the item's `ProxyItem` */
+    onselect?: (value: unknown, proxy: ProxyItem) => void;
+    /** Additional CSS classes */
+    class?: string;
 }
 /**
  * Icons configuration for list collapsible group states.

package/dist/types/menu.d.ts

@@ -5,12 +5,19 @@
  * Trigger action manages open/close. Dropdown content is identical to List.
  */
 import type { ProxyItem } from '@rokkit/states';
+import type { ItemSnippets } from './snippets.js';
 /**
  * Props for the Menu component.
  * Content props (items, fields, value, size, disabled, collapsible, icons, onselect, class, snippets)
  * are identical to List. Additional props: label, icon, showArrow, align, direction.
  */
-export interface MenuProps {
+/**
+ * Props for the Menu component.
+ *
+ * `Menu.svelte` annotates its own `$props()` with this interface, so the two
+ * cannot drift.
+ */
+export interface MenuProps extends ItemSnippets {
     /** Array of items (same as List: supports groups, separators, nested children) */
     items?: unknown[];
     /** Field mapping — overrides BASE_FIELDS defaults (label → 'label', value → 'value', …) */
@@ -18,7 +25,7 @@ export interface MenuProps {
     /** Current active value (highlights matching item) */
     value?: unknown;
     /** Size variant */
-    size?: 'sm' | 'md' | 'lg';
+    size?: string;
     /** Whether the entire menu is disabled */
     disabled?: boolean;
     /** Whether groups are collapsible (same as List) */

package/dist/types/select.d.ts

@@ -4,94 +4,84 @@
  * Provides types for the data-driven Select and MultiSelect components.
  * Field mapping and data access is handled by ProxyItem from @rokkit/states.
  */
-import type { Snippet } from 'svelte';
-import type { ProxyItem } from '@rokkit/states';
+import type { ItemSnippets } from './snippets.js';
 /**
  * Generic select item - can be any object with mapped fields
  */
 export type SelectItem = Record<string, unknown>;
-/** @deprecated Legacy handlers — will be removed when PaletteManager migrates to Navigator stack */
-export interface SelectItemHandlers {
-    onclick: () => void;
-    onkeydown: (event: KeyboardEvent) => void;
-}
-/**
- * Snippet type for rendering a single option in the dropdown.
- * The component renders the focusable wrapper; the snippet renders the inner content.
- * Navigator handles click selection via data-path — no handlers needed in snippet.
- */
-export type SelectOptionSnippet = Snippet<[ProxyItem]>;
-/**
- * Snippet type for rendering a group header label.
- */
-export type SelectGroupLabelSnippet = Snippet<[ProxyItem]>;
-/**
- * Snippet type for rendering the selected value display in the trigger button.
- */
-export type SelectValueSnippet = Snippet<[ProxyItem]>;
 /**
- * Snippet type for rendering selected values in MultiSelect trigger.
- * Receives the array of selected ProxyItems.
- */
-export type MultiSelectValueSnippet = Snippet<[ProxyItem[]]>;
-/**
- * Common props shared between Select and MultiSelect
+ * Common props shared between Select, MultiSelect and Dropdown.
+ *
+ * Each component annotates its own `$props()` with the derived interface, so
+ * they cannot drift — which is how the previous version came to name the data
+ * prop `options` when every component takes `items`, and to declare
+ * `option` / `groupLabel` snippets the components never read.
  */
 export interface SelectBaseProps {
-    /** Array of select options or groups */
-    options?: SelectItem[];
-    /** Field mapping — overrides BASE_FIELDS defaults (text → 'label', value → 'value', …) */
+    /** Array of options or groups */
+    items?: unknown[];
+    /** Field mapping — overrides BASE_FIELDS defaults */
     fields?: Record<string, string>;
     /** Placeholder text when no selection */
     placeholder?: string;
     /** Size variant */
-    size?: 'sm' | 'md' | 'lg';
+    size?: string;
+    /** Whether the control is disabled */
+    disabled?: boolean;
     /** Dropdown alignment relative to trigger */
-    align?: 'left' | 'right' | 'start' | 'end';
+    align?: 'start' | 'end';
     /** Dropdown slide direction */
     direction?: 'up' | 'down';
-    /** Maximum visible rows in dropdown (default: 5) */
-    maxRows?: number;
-    /** Whether the select is disabled */
-    disabled?: boolean;
+    /** Icons for dropdown arrow, check and remove */
+    icons?: SelectStateIcons;
     /** Additional CSS classes on root element */
     class?: string;
-    /** Icons for select states (dropdown arrow, check, remove) */
-    icons?: SelectStateIcons;
-    /** Custom snippet for rendering options in dropdown */
-    option?: SelectOptionSnippet;
-    /** Custom snippet for rendering group labels */
-    groupLabel?: SelectGroupLabelSnippet;
-    /** Enable typeahead filter input in dropdown header */
-    filterable?: boolean;
-    /** Placeholder text for the filter input */
-    filterPlaceholder?: string;
 }
 /**
- * Props for the Select component (single selection)
+ * Props for the Select component (single selection).
  */
-export interface SelectProps extends SelectBaseProps {
-    /** Currently selected value (bindable) — extracted via item[fields.value] */
+export interface SelectProps extends SelectBaseProps, ItemSnippets {
+    /** Selected value (bindable) — extracted via item[fields.value] */
     value?: unknown;
-    /** Currently selected raw item (bindable) — full object from options array */
-    selected?: SelectItem | null;
+    /** Selected raw item (bindable) */
+    selected?: unknown;
+    /** Enable the typeahead filter input in the dropdown header */
+    filterable?: boolean;
+    /** Placeholder for the filter input */
+    filterPlaceholder?: string;
+    /** Maximum visible rows in the dropdown */
+    maxRows?: number;
     /** Called when selection changes */
-    onchange?: (value: unknown, item: SelectItem) => void;
-    /** Custom snippet for rendering the selected value in the trigger */
-    selectedValue?: SelectValueSnippet;
+    onchange?: (value: unknown, item: unknown) => void;
 }
 /**
- * Props for the MultiSelect component (multiple selection)
+ * Props for the MultiSelect component (multiple selection).
  */
-export interface MultiSelectProps extends SelectBaseProps {
-    /** Currently selected values (bindable) - extracted primitives */
+export interface MultiSelectProps extends SelectBaseProps, ItemSnippets {
+    /** Selected values (bindable) */
     value?: unknown[];
-    /** Currently selected items (bindable) - full item objects for convenience */
-    selected?: SelectItem[];
-    /** Called when selection changes */
-    onchange?: (values: unknown[], items: SelectItem[]) => void;
-    /** Maximum number of tags to show before collapsing to count */
+    /** Selected items (bindable) */
+    selected?: unknown[];
+    /** Maximum tags shown before collapsing to a count */
     maxDisplay?: number;
+    /** Called when selection changes */
+    onchange?: (values: unknown[], items: unknown[]) => void;
+}
+/**
+ * Props for the Dropdown component.
+ *
+ * Unlike Select and MultiSelect it does not spread snippets, so it takes the
+ * base props only.
+ */
+export interface DropdownProps extends SelectBaseProps {
+    /** Selected value (bindable) */
+    value?: unknown;
+    /** Trigger icon class */
+    icon?: string;
+    /** Whether to show the dropdown arrow indicator on the trigger */
+    showArrow?: boolean;
+    /** Called when selection changes */
+    onchange?: (value: unknown, item: unknown) => void;
 }
 /**
  * Icons configuration for select expand/collapse and selection states.

package/dist/types/snippets.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Shared snippet types for the item-rendering components.
+ *
+ * List / Tree / Menu / Select / Grid and friends collect their snippets with a
+ * rest element (`...snippets`) behind an index signature, because a data item
+ * can name its own snippet (`item.snippet = 'name'`, resolved by
+ * `resolveSnippet`) — so arbitrary keys must stay accepted.
+ *
+ * The index signature alone typed every snippet as `unknown`, which made each
+ * consumer's snippet parameter implicitly `any`: a snippet body could read any
+ * property off `proxy` or pass it somewhere expecting a different type, and
+ * nothing complained until runtime. Declaring the documented snippets
+ * explicitly fixes that — TypeScript prefers an explicit member over the index
+ * signature, so the common case is checked while named snippets still work.
+ */
+import type { Snippet } from 'svelte';
+import type { ProxyItem } from '@rokkit/states';
+/**
+ * Renders one item's inner content, given its `ProxyItem`.
+ *
+ * This is the shape of `itemContent` and `groupContent` — the fallbacks
+ * `resolveSnippet` reaches for (`ITEM_SNIPPET` / `GROUP_SNIPPET`), and the
+ * shape any per-item named snippet must also have.
+ */
+export type ItemSnippet = Snippet<[ProxyItem]>;
+/**
+ * Renders one item's inner content plus whether it is currently selected.
+ *
+ * Used where selection is part of the item's own rendering rather than the
+ * wrapper's — Tabs and Toggle both call their content snippet as
+ * `content(proxy, selected)`.
+ */
+export type SelectableItemSnippet = Snippet<[ProxyItem, boolean]>;
+/**
+ * The snippet bag an item-rendering component accepts.
+ *
+ * Spread into a component's props type so the documented snippets are typed
+ * while `item.snippet = 'name'` keeps working:
+ *
+ * ```ts
+ * let { items = [], ...snippets }: { items?: unknown[] } & ItemSnippets = $props()
+ * ```
+ */
+export interface ItemSnippets {
+    /** Inner content for a leaf item. */
+    itemContent?: ItemSnippet;
+    /** Inner content for a group/parent item. Falls back to `itemContent`. */
+    groupContent?: ItemSnippet;
+    /**
+     * Per-item named snippets, selected via the item's `snippet` field. Kept as
+     * `unknown` rather than `ItemSnippet` because this signature also has to
+     * admit every other prop the component spreads through.
+     */
+    [key: string]: unknown;
+}

package/dist/types/snippets.js

@@ -0,0 +1,16 @@
+/**
+ * Shared snippet types for the item-rendering components.
+ *
+ * List / Tree / Menu / Select / Grid and friends collect their snippets with a
+ * rest element (`...snippets`) behind an index signature, because a data item
+ * can name its own snippet (`item.snippet = 'name'`, resolved by
+ * `resolveSnippet`) — so arbitrary keys must stay accepted.
+ *
+ * The index signature alone typed every snippet as `unknown`, which made each
+ * consumer's snippet parameter implicitly `any`: a snippet body could read any
+ * property off `proxy` or pass it somewhere expecting a different type, and
+ * nothing complained until runtime. Declaring the documented snippets
+ * explicitly fixes that — TypeScript prefers an explicit member over the index
+ * signature, so the common case is checked while named snippets still work.
+ */
+export {};