@mkbabb/glass-ui 6.0.0 → 7.0.0

package/dist/components/search/searchVariants.d.ts

@@ -1,19 +1,17 @@
-import { type VariantProps } from "class-variance-authority";
-import { type ControlSize, controlSizeClass } from "../_shared/useControlSize";
-/**
- * The search field-CHROME variant. `inline` is the boxed glass pill (identity over
- * the `.input-bar` recipe); `bare`/`floating` strip the box to a chromeless field —
- * the real CVA rung the `!important` cluster was fighting (clean break, no `!`).
- *
- *   searchFieldVariants()                    → ""                                          (the boxed pill)
- *   searchFieldVariants({ variant: "bare" }) → "border-none bg-transparent p-0 rounded-none"
- */
-export declare const searchFieldVariants: (props?: ({
-    variant?: "inline" | "floating" | "bare" | null | undefined;
-} & import("class-variance-authority/types").ClassProp) | undefined) => string;
-export type SearchVariant = NonNullable<VariantProps<typeof searchFieldVariants>["variant"]>;
-/** The CVA's variant-prop shape — the `/api` discovery surface (the SFCs cannot
- *  re-export a type, so this CVA home is the type source). */
-export type SearchVariants = VariantProps<typeof searchFieldVariants>;
+import { type ClassValue } from "../_shared/class-names";
+import { type ControlSize, controlSizeClass } from "../_shared/control-size";
+declare const VARIANT: {
+    readonly inline: "";
+    readonly bare: "border-none bg-transparent p-0 rounded-none";
+    readonly floating: "border-none bg-transparent p-0 rounded-none";
+};
+export type SearchVariant = keyof typeof VARIANT;
+export interface SearchVariants {
+    variant?: SearchVariant | null;
+    class?: ClassValue;
+    className?: ClassValue;
+}
+/** Search field chrome; size remains on the shared control-size axis. */
+export declare function searchFieldVariants(options?: SearchVariants): string;
 export { controlSizeClass };
 export type { ControlSize };

package/dist/components/select/Select.vue.d.ts

@@ -1,19 +1,30 @@
-import type { SelectRootProps } from 'reka-ui';
-type __VLS_Props = SelectRootProps;
-declare var __VLS_8: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_8) => any;
-};
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: import("reka-ui").AcceptableValue) => any;
-    "update:open": (value: boolean) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:modelValue"?: ((value: import("reka-ui").AcceptableValue) => any) | undefined;
-    "onUpdate:open"?: ((value: boolean) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+import type { Direction, FormFieldProps } from "../_shared/primitive";
+import type { SelectionValue } from "../_shared/selection";
+export interface SelectProps extends FormFieldProps {
+    modelValue?: SelectionValue;
+    defaultValue?: SelectionValue;
+    open?: boolean;
+    defaultOpen?: boolean;
+    nullableValue?: string;
+    dir?: Direction;
+    autocomplete?: string;
+    disabled?: boolean;
+}
+export interface SelectEmits {
+    "update:modelValue": [value: SelectionValue];
+    "update:open": [value: boolean];
+}
 declare const _default: typeof __VLS_export;
 export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<SelectProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: SelectionValue) => any;
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<SelectProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: SelectionValue) => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/components/select/SelectContent.vue.d.ts

@@ -1,40 +1,37 @@
-import { type HTMLAttributes } from 'vue';
-import { type SelectContentProps } from 'reka-ui';
-import { type Surface } from '../_shared/useSurfaceAxis';
-type __VLS_Props = SelectContentProps & {
-    class?: HTMLAttributes['class'];
+import type { HTMLAttributes } from "vue";
+import type { Surface } from "../_shared/axes";
+import type { FloatingPlacementProps } from "../_shared/floating";
+import type { PointerDownOutsideEvent } from "../_shared/interaction";
+export interface SelectContentProps extends FloatingPlacementProps {
+    class?: HTMLAttributes["class"];
     surface?: Surface;
-    /**
-     * BD.W-SELECT-WELL — the route's warm-field HUE re-emitted onto the portalled
-     * menu so it transmits its route identity even though it escapes to <body>
-     * (the page field stops at the route root; the portal does not). The menu-local
-     * `.glass-field-portal` spine reads this `--field-h`. A forms route resolves 48
-     * (terracotta); a feedback route a different warm hue — so each dropdown reads as
-     * different warm glass, none gray. Unset → the select.css `--field-h: 48` floor.
-     */
+    /** Hue re-emitted onto the portalled field, in CSS degrees. */
     fieldHue?: number;
-};
-declare var __VLS_25: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_25) => any;
-};
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+}
+export interface SelectContentEmits {
+    closeAutoFocus: [event: Event];
+    escapeKeyDown: [event: KeyboardEvent];
+    pointerDownOutside: [event: PointerDownOutsideEvent];
+}
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<SelectContentProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     escapeKeyDown: (event: KeyboardEvent) => any;
-    pointerDownOutside: (event: import("reka-ui").PointerDownOutsideEvent) => any;
+    pointerDownOutside: (event: PointerDownOutsideEvent) => any;
     closeAutoFocus: (event: Event) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+}, string, import("vue").PublicProps, Readonly<SelectContentProps> & Readonly<{
     onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
-    onPointerDownOutside?: ((event: import("reka-ui").PointerDownOutsideEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
     onCloseAutoFocus?: ((event: Event) => any) | undefined;
 }>, {
-    position: "item-aligned" | "popper";
+    side: import("../_shared/floating").FloatingSide;
+    sideOffset: number;
+    align: import("../_shared/floating").FloatingAlign;
+    alignOffset: number;
     surface: Surface;
-    align: "end" | "start" | "center";
-    collisionPadding: number | Partial<Record<"top" | "right" | "bottom" | "left", number>>;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
-declare const _default: typeof __VLS_export;
-export default _default;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/components/select/SelectGroup.vue.d.ts

@@ -1,16 +1,12 @@
-import { type HTMLAttributes } from 'vue';
-import { type SelectGroupProps } from 'reka-ui';
-type __VLS_Props = SelectGroupProps & {
-    class?: HTMLAttributes['class'];
-};
-declare var __VLS_8: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_8) => any;
-};
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+import type { HTMLAttributes } from "vue";
+export interface SelectGroupProps {
+    class?: HTMLAttributes["class"];
+}
 declare const _default: typeof __VLS_export;
 export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<SelectGroupProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SelectGroupProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/components/select/SelectItem.vue.d.ts

@@ -1,19 +1,30 @@
-import { type HTMLAttributes } from 'vue';
-import { type SelectItemProps } from 'reka-ui';
-type __VLS_Props = SelectItemProps & {
-    class?: HTMLAttributes['class'];
+import type { HTMLAttributes } from "vue";
+import type { SelectionValue } from "../_shared/selection";
+export interface SelectItemProps {
+    value: SelectionValue;
+    disabled?: boolean;
+    textValue?: string;
+    class?: HTMLAttributes["class"];
     hideIndicator?: boolean;
-};
-declare var __VLS_20: {}, __VLS_22: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_20) => any;
-} & {
-    description?: (props: typeof __VLS_22) => any;
-};
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+}
+export type SelectItemSelectEvent = CustomEvent<{
+    originalEvent: PointerEvent | KeyboardEvent;
+    value: SelectionValue;
+}>;
+export interface SelectItemEmits {
+    select: [event: SelectItemSelectEvent];
+}
 declare const _default: typeof __VLS_export;
 export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<SelectItemProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (event: SelectItemSelectEvent) => any;
+}, string, import("vue").PublicProps, Readonly<SelectItemProps> & Readonly<{
+    onSelect?: ((event: SelectItemSelectEvent) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+} & {
+    description?: (props: {}) => any;
+}>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/components/select/SelectLabel.vue.d.ts

@@ -1,16 +1,12 @@
-import type { HTMLAttributes } from 'vue';
-import { type SelectLabelProps } from 'reka-ui';
-type __VLS_Props = SelectLabelProps & {
-    class?: HTMLAttributes['class'];
-};
-declare var __VLS_8: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_8) => any;
-};
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+import type { HTMLAttributes } from "vue";
+export interface SelectLabelProps {
+    class?: HTMLAttributes["class"];
+}
 declare const _default: typeof __VLS_export;
 export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<SelectLabelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SelectLabelProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/components/select/SelectScrollDownButton.vue.d.ts

@@ -1,7 +1,6 @@
-import { type HTMLAttributes } from 'vue';
-import { type SelectScrollDownButtonProps } from 'reka-ui';
-type __VLS_Props = SelectScrollDownButtonProps & {
-    class?: HTMLAttributes['class'];
+import { type HTMLAttributes } from "vue";
+type __VLS_Props = {
+    class?: HTMLAttributes["class"];
 };
 declare var __VLS_8: {};
 type __VLS_Slots = {} & {

package/dist/components/select/SelectScrollUpButton.vue.d.ts

@@ -1,7 +1,6 @@
-import { type HTMLAttributes } from 'vue';
-import { type SelectScrollUpButtonProps } from 'reka-ui';
-type __VLS_Props = SelectScrollUpButtonProps & {
-    class?: HTMLAttributes['class'];
+import { type HTMLAttributes } from "vue";
+type __VLS_Props = {
+    class?: HTMLAttributes["class"];
 };
 declare var __VLS_8: {};
 type __VLS_Slots = {} & {

package/dist/components/select/SelectSeparator.vue.d.ts

@@ -1,8 +1,7 @@
-import { type HTMLAttributes } from 'vue';
-import { type SelectSeparatorProps } from 'reka-ui';
-type __VLS_Props = SelectSeparatorProps & {
-    class?: HTMLAttributes['class'];
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+import type { HTMLAttributes } from "vue";
+export interface SelectSeparatorProps {
+    class?: HTMLAttributes["class"];
+}
 declare const _default: typeof __VLS_export;
 export default _default;
+declare const __VLS_export: import("vue").DefineComponent<SelectSeparatorProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SelectSeparatorProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/components/select/SelectTrigger.vue.d.ts

@@ -1,46 +1,20 @@
-import { type HTMLAttributes } from 'vue';
-import { type SelectTriggerProps } from 'reka-ui';
-type __VLS_Props = SelectTriggerProps & {
-    class?: HTMLAttributes['class'];
-    /** 'default' = the shared control REST surface (BA.W-SURFACE-AXIS scope 7 —
-     *  the `.control-surface` register every form control reads at rest, off the
-     *  prior `glass-wash` gray fork); 'ghost' = transparent, no border/shadow */
-    variant?: 'default' | 'ghost';
-    /**
-     * The trigger register — a TWO-RANGE axis (BA.W-MENU-GLASS / BA-VJS-4 WO-3):
-     *  • HEIGHT tiers (`sm` | `default`) ride the `--control-h-*` comfort cohort
-     *    (h-9 / h-10), byte-identical to today.
-     *  • FONT-RUNG tiers (`display` | `audacious`) WRITE the shared picker-family
-     *    `--dropdown-text` token on the Select SCOPE (inline style), so the
-     *    trigger, the SelectValue, AND the item rows re-resolve at ONE scale off
-     *    the ONE documented lever (`offsets-sizing.css` — the items read
-     *    `--dropdown-text` via `menuItemVariants`' `text-dropdown` base). This is
-     *    the fix for the value.js trigger-only `text-display` desync (a 1.59×
-     *    trigger/items break): a consumer scaling the picker font reaches for the
-     *    PROP, which sets the FAMILY token, NOT a trigger-local `text-*` class that
-     *    leaves the items behind. The font rung carries a height too so the box
-     *    grows with the type. The height tiers stay; the font rung is ADDITIVE
-     *    (a consumer who never sets it keeps today's resolved sizes).
-     *
-     *  NOTE on the portal: `<SelectContent>` PORTALS to body, so the inline
-     *  `--dropdown-text` on the trigger reaches the trigger/value/chevron directly;
-     *  the items re-resolve when the consumer also threads the rung on the shared
-     *  Select scope (the documented family lever). For a single self-scaling
-     *  trigger the rung scales the visible trigger silhouette.
-     */
-    size?: 'sm' | 'default' | 'display' | 'audacious';
-};
-declare var __VLS_8: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_8) => any;
-};
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    size: "sm" | "default" | "display" | "audacious";
-    variant: "default" | "ghost";
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+import type { HTMLAttributes } from "vue";
+export interface SelectTriggerProps {
+    disabled?: boolean;
+    class?: HTMLAttributes["class"];
+    /** Shared control surface or paint-free trigger. */
+    variant?: "default" | "ghost";
+    /** Trigger height register. */
+    size?: "sm" | "default";
+}
 declare const _default: typeof __VLS_export;
 export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<SelectTriggerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SelectTriggerProps> & Readonly<{}>, {
+    size: "sm" | "default";
+    variant: "default" | "ghost";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/components/select/SelectValue.vue.d.ts

@@ -1,12 +1,18 @@
-import { type SelectValueProps } from 'reka-ui';
-declare var __VLS_8: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_8) => any;
-};
-declare const __VLS_base: import("vue").DefineComponent<SelectValueProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SelectValueProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+import type { HTMLAttributes } from "vue";
+import type { SelectionValue } from "../_shared/selection";
+export interface SelectValueProps {
+    placeholder?: string;
+    class?: HTMLAttributes["class"];
+}
+export interface SelectValueSlotProps {
+    selectedLabel: string[];
+    modelValue: SelectionValue | undefined;
+}
 declare const _default: typeof __VLS_export;
 export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<SelectValueProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SelectValueProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: SelectValueSlotProps) => unknown;
+}>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/components/select/index.d.ts

@@ -1,8 +1,16 @@
-export { default as Select } from './Select.vue';
-export { default as SelectValue } from './SelectValue.vue';
-export { default as SelectTrigger } from './SelectTrigger.vue';
-export { default as SelectContent } from './SelectContent.vue';
-export { default as SelectGroup } from './SelectGroup.vue';
-export { default as SelectItem } from './SelectItem.vue';
-export { default as SelectLabel } from './SelectLabel.vue';
-export { default as SelectSeparator } from './SelectSeparator.vue';
+export { default as Select } from "./Select.vue";
+export { default as SelectValue } from "./SelectValue.vue";
+export { default as SelectTrigger } from "./SelectTrigger.vue";
+export { default as SelectContent } from "./SelectContent.vue";
+export { default as SelectGroup } from "./SelectGroup.vue";
+export { default as SelectItem } from "./SelectItem.vue";
+export { default as SelectLabel } from "./SelectLabel.vue";
+export { default as SelectSeparator } from "./SelectSeparator.vue";
+export type { SelectEmits, SelectProps } from "./Select.vue";
+export type { SelectValueProps, SelectValueSlotProps } from "./SelectValue.vue";
+export type { SelectTriggerProps } from "./SelectTrigger.vue";
+export type { SelectContentEmits, SelectContentProps } from "./SelectContent.vue";
+export type { SelectGroupProps } from "./SelectGroup.vue";
+export type { SelectItemEmits, SelectItemProps, SelectItemSelectEvent, } from "./SelectItem.vue";
+export type { SelectLabelProps } from "./SelectLabel.vue";
+export type { SelectSeparatorProps } from "./SelectSeparator.vue";

package/dist/components/separator/Separator.vue.d.ts

@@ -1,9 +1,14 @@
-import { type HTMLAttributes } from 'vue';
-import { type SeparatorProps } from 'reka-ui';
-type __VLS_Props = SeparatorProps & {
-    class?: HTMLAttributes['class'];
+import { type HTMLAttributes } from "vue";
+import type { Orientation } from "../_shared/axes";
+export interface SeparatorProps {
+    orientation?: Orientation;
+    decorative?: boolean;
+    class?: HTMLAttributes["class"];
     label?: string;
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+}
+declare const __VLS_export: import("vue").DefineComponent<SeparatorProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SeparatorProps> & Readonly<{}>, {
+    orientation: Orientation;
+    decorative: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/components/separator/index.d.ts

@@ -1 +1 @@
-export { default as Separator } from './Separator.vue';
+export { default as Separator, type SeparatorProps } from "./Separator.vue";

package/dist/components/skeleton/Skeleton.vue.d.ts

@@ -1,35 +1,7 @@
-import type { HTMLAttributes } from 'vue';
-/**
- * Skeleton variants — three distinct temporal registers.
- *
- * • `pulse` (default) — the existing 2s Tailwind `animate-pulse`.
- *   Short-wait register: "a small wait, the screen acknowledges".
- *   Compositor-friendly opacity ramp.
- *
- * • `shimmer` — a 1.5s linear translate sweep of a translucent gradient
- *   across the surface. Use when the absence reads as
- *   "data is loading, watch the bar travel".
- *
- * • `breath` (AI.W4-M.3) — a 6s opacity-only breath synced to the
- *   `--animate-ambient-pulse-duration` canon. Use when the wait is
- *   KNOWN-IMMINENT (a few seconds; chart/series substitution). The
- *   slower register reads as "the surface is alive and resolving",
- *   not as "the screen is stuck".
- *
- * The three coexist; consumers pick the register that matches the
- * expected wait shape. PRM retires the breath cycle to the trough
- * (opacity-min) — the surface still reads but no longer cycles.
- */
-type SkeletonVariant = 'pulse' | 'shimmer' | 'breath';
-type SkeletonSurface = 'glass' | 'opaque';
+import { type HTMLAttributes } from "vue";
 type __VLS_Props = {
-    variant?: SkeletonVariant;
-    surface?: SkeletonSurface;
-    class?: HTMLAttributes['class'];
+    class?: HTMLAttributes["class"];
 };
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    surface: SkeletonSurface;
-    variant: SkeletonVariant;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/components/slider/Slider.vue.d.ts

@@ -1,41 +1,14 @@
-import { type HTMLAttributes } from 'vue';
-import type { SliderRootProps } from 'reka-ui';
-import { type SliderVariants } from './index';
-import type { Motion } from '../_shared/axes';
-type __VLS_Props = SliderRootProps & {
-    class?: HTMLAttributes['class'];
-    /** Substrate recipe — see `sliderVariants` for axis docs. */
-    variant?: SliderVariants['variant'];
-    /** Track + thumb geometry — sm | md (default) | lg. */
-    size?: SliderVariants['size'];
-    /** Quiet, paint-only checkpoints in the slider's numeric domain. */
-    marks?: readonly number[];
-    /**
-     * Acquire a `dockKeepOpen` token while the user drags the slider, so
-     * an enclosing dock doesn't auto-collapse mid-gesture. The slider also
-     * subscribes to the dock's `dockHeld` flag and reflects it via
-     * `data-held` on its root, intensifying the thumb halo. Default: true.
-     */
-    keepDockOpen?: boolean;
-    /**
-     * BH.W-MOTION-AXIS — the ONE motion-weight axis (the `liquidDrag` boolean's
-     * clean-break successor). `full` (default) arms the BD.W-GLASS-ATOM-REGISTER liquid
-     * weight-train on the fill: anticipation dip on grab → BOUNDED saturating smear while
-     * pulling (the cel cast lagging by `--motion-weight × velocity`) → follow-through
-     * overshoot on release (the `useDragVelocity` bridge writes `--atom-drag-v`). `reduced`
-     * degrades to the plain non-uniform squish floor (the SAME state PRM produces). `off`
-     * unbinds the velocity bridge AND writes `--motion-weight: 0`; the drag still sets the
-     * value. PRM forces `full → reduced` regardless (a11y absolute).
-     */
-    motion?: Motion;
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (payload: number[] | undefined) => any;
-    valueCommit: (payload: number[]) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:modelValue"?: ((payload: number[] | undefined) => any) | undefined;
-    onValueCommit?: ((payload: number[]) => any) | undefined;
+import type { SliderProps, SliderSize, SliderVariant } from "./types";
+declare const __VLS_export: import("vue").DefineComponent<SliderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: number[] | undefined) => any;
+    valueCommit: (value: number[]) => any;
+}, string, import("vue").PublicProps, Readonly<SliderProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: number[] | undefined) => any) | undefined;
+    onValueCommit?: ((value: number[]) => any) | undefined;
 }>, {
+    size: SliderSize;
+    invalid: boolean;
+    variant: SliderVariant;
     keepDockOpen: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;

package/dist/components/slider/index.d.ts

@@ -1,46 +1,2 @@
-import { type VariantProps } from 'class-variance-authority';
 export { default as Slider } from './Slider.vue';
-/**
- * Slider variant + size axes.
- *
- * The CVA emits Tailwind arbitrary CSS-variable classes on the SliderRoot.
- * The SFC's scoped CSS keys off `[data-variant]` for substrate-recipe
- * selectors — variant determines how `.slider-track`, `.slider-range`, and
- * `.slider-thumb` paint. The size axis lifts pure geometry via CSS vars
- * (`--slider-track-height`, `--slider-thumb-size`) the SFC defaults read.
- *
- * Exactly two canonical recipes ship:
- *   standard — the CONTINUOUS GLASS CYLINDER with NO VISIBLE THUMB AT ALL (the
- *              user's binding bar, USER-AUDIT-2026-06-10 §B3): you pull the TRACK
- *              itself. A THICK glass capsule track; the filled `.slider-range`
- *              glass cylinder (the W52 liquid-glass material — backdrop + edge rim,
- *              tinted to `--primary`) is pulled along it, and its leading EDGE IS
- *              the handle — the only affordance is the fill edge + the cursor/touch
- *              response. The reka `<SliderThumb>` STAYS MOUNTED (a11y/keyboard/drag/
- *              value-follow native on it) but paints INVISIBLE: width 0, opacity 0,
- *              transparent — no distinct disc/cap/ring over the continuous
- *              cylinder. Keyboard focus rings the TRACK (the W-PRIM-POLISH focus
- *              register), not the invisible thumb; hover/held lift the track FILL's
- *              edge rim; the iOS press spring gives the whole fill a felt squish.
- *              This is the general-purpose glass scrubber and the default.
- *   spectrum — the value.js gradient-track color slider: a tall capsule whose
- *              background is a consumer-supplied `--slider-track-bg`
- *              linear-gradient (the LCH/hue ramp), a transparent range, and a
- *              THIN VISIBLE squircle thumb the HEIGHT of the track (the iOS/value.js
- *              color-picker idiom — a slim vertical bar, `w-3`-thin per the value.js
- *              reference; `corner-shape: superellipse()` via `--corner-shape-thumb`,
- *              @supports-gated over a generous proportional round fallback that
- *              reads squircle-adjacent cross-engine). This is the aurora/blob
- *              color-picking surface — its thumb IS visible (it is the handle).
- *
- * Sizes — the standard cylinder is the thick glass capsule (the invisible thumb's
- * value-follow inset still rides the size token for the 44px coarse hit-halo):
- *   sm — 12px track
- *   md — 20px track (default)
- *   lg — 28px track
- */
-export declare const sliderVariants: (props?: ({
-    variant?: "standard" | "spectrum" | null | undefined;
-    size?: "sm" | "md" | "lg" | null | undefined;
-} & import("class-variance-authority/types").ClassProp) | undefined) => string;
-export type SliderVariants = VariantProps<typeof sliderVariants>;
+export type { SliderProps, SliderSize, SliderVariant } from './types';

package/dist/components/slider/types.d.ts

@@ -0,0 +1,25 @@
+import type { HTMLAttributes } from "vue";
+import type { Motion, Orientation } from "../_shared/axes";
+import type { Direction, FormFieldProps } from "../_shared/primitive";
+export type SliderVariant = "standard" | "spectrum";
+export type SliderSize = "sm" | "md" | "lg";
+export interface SliderProps extends FormFieldProps {
+    modelValue?: number[] | null;
+    defaultValue?: number[];
+    disabled?: boolean;
+    orientation?: Orientation;
+    dir?: Direction;
+    inverted?: boolean;
+    min?: number;
+    max?: number;
+    step?: number;
+    minStepsBetweenThumbs?: number;
+    class?: HTMLAttributes["class"];
+    variant?: SliderVariant;
+    size?: SliderSize;
+    /** Decorative checkpoints in the numeric domain; they never snap the value. */
+    marks?: readonly number[];
+    invalid?: boolean;
+    keepDockOpen?: boolean;
+    motion?: Motion;
+}

package/dist/components/sortable-list/SortableList.vue.d.ts

@@ -28,7 +28,7 @@ declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_se
     };
     emit: ((evt: "insert", index: number, item: unknown) => void) & ((evt: "reorder", next: T[]) => void);
 }>) => import("vue").VNode & {
-    __ctx?: Awaited<typeof __VLS_setup>;
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/components/sortable-list/composables/ghostRenderer.d.ts

@@ -17,7 +17,7 @@
  * to 0; a non-length token (`%`, `auto`) counts as non-zero so we never miss a
  * rounded corner.
  *
- * Exported (and re-exported from `useSortable`) for the D9 drag-ring regression
+ * Exported (and re-exported from `useSortable`) for the drag-ring regression
  * test — keep it a pure string predicate.
  */
 export declare function isNonZeroRadius(radius: string): boolean;