@mkbabb/glass-ui 3.1.1 → 3.3.0

package/dist/components/ui/data-table/DataTable.vue.d.ts

@@ -1,10 +1,9 @@
 import type { DataTableColumn, DataTableSort } from "./types";
 declare const __VLS_export: <T extends Record<string, any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<({
         columns: DataTableColumn<T>[];
         rows: T[];
         total: number;
-        page: number;
         pageSize: number;
         isLoading?: boolean;
         rowKey?: string;
@@ -32,8 +31,10 @@ declare const __VLS_export: <T extends Record<string, any>>(__VLS_props: NonNull
         cardBreakpoint?: number;
         class?: string;
     } & {
+        page: number;
+    }) & {
         onSelect?: ((row: T) => any) | undefined;
-        "onUpdate:page"?: ((page: number) => any) | undefined;
+        "onUpdate:page"?: ((value: number) => any) | undefined;
         "onUpdate:sort"?: ((sort: DataTableSort) => any) | undefined;
         "onLoad-more"?: (() => any) | undefined;
     }> & (typeof globalThis extends {
@@ -68,7 +69,7 @@ declare const __VLS_export: <T extends Record<string, any>>(__VLS_props: NonNull
     } & {
         sentinel?: (props: {}) => any;
     };
-    emit: ((evt: "select", row: T) => void) & ((evt: "update:page", page: number) => void) & ((evt: "update:sort", sort: DataTableSort) => void) & ((evt: "load-more") => void);
+    emit: (((evt: "select", row: T) => void) & ((evt: "update:sort", sort: DataTableSort) => void) & ((evt: "load-more") => void)) & ((event: "update:page", value: number) => void);
 }>) => import("vue").VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };

package/dist/components/ui/dialog/DialogContent.vue.d.ts

@@ -39,6 +39,13 @@ type __VLS_Props = DialogContentProps & {
      * immediately — entrance becomes a no-op transform.
      */
     spring?: boolean | SpringPreset;
+    /**
+     * Render the default top-right close (X) button (default `true`).
+     * Set `false` when the consumer composes its own header / dismiss control
+     * (e.g. a hand-composed access modal) so the built-in X does not
+     * double-up. The default keeps every existing mount byte-identical.
+     */
+    showClose?: boolean;
 };
 declare var __VLS_19: {};
 type __VLS_Slots = {} & {
@@ -60,6 +67,7 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     onCloseAutoFocus?: ((event: Event) => any) | undefined;
 }>, {
     variant: "glass" | "opaque";
+    showClose: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/components/ui/drawer/Drawer.vue.d.ts

@@ -24,18 +24,18 @@ 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:open": (open: boolean) => any;
     close: () => any;
     drag: (percentageDragged: number) => any;
-    "update:open": (open: boolean) => any;
-    release: (open: boolean) => any;
     animationEnd: (open: boolean) => any;
+    release: (open: boolean) => any;
     "update:activeSnapPoint": (val: string | number) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
     onClose?: (() => any) | undefined;
     onDrag?: ((percentageDragged: number) => any) | undefined;
-    "onUpdate:open"?: ((open: boolean) => any) | undefined;
-    onRelease?: ((open: boolean) => any) | undefined;
     onAnimationEnd?: ((open: boolean) => any) | undefined;
+    onRelease?: ((open: boolean) => any) | undefined;
     "onUpdate:activeSnapPoint"?: ((val: string | number) => any) | undefined;
 }>, {
     mode: DrawerMode;

package/dist/components/ui/input/Input.vue.d.ts

@@ -1,16 +1,34 @@
-import type { HTMLAttributes } from 'vue';
+import type { HTMLAttributes, InputHTMLAttributes } from 'vue';
 declare const _default: typeof __VLS_export;
 export default _default;
 declare const __VLS_export: import("vue").DefineComponent<{
     defaultValue?: string | number;
     modelValue?: string | number;
     class?: HTMLAttributes["class"];
+    type?: InputHTMLAttributes["type"];
+    placeholder?: InputHTMLAttributes["placeholder"];
+    disabled?: InputHTMLAttributes["disabled"];
+    required?: InputHTMLAttributes["required"];
+    inputmode?: InputHTMLAttributes["inputmode"];
+    autocomplete?: string;
+    pattern?: InputHTMLAttributes["pattern"];
+    name?: InputHTMLAttributes["name"];
+    readonly?: InputHTMLAttributes["readonly"];
 }, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     "update:modelValue": (payload: string | number) => any;
 }, string, import("vue").PublicProps, Readonly<{
     defaultValue?: string | number;
     modelValue?: string | number;
     class?: HTMLAttributes["class"];
+    type?: InputHTMLAttributes["type"];
+    placeholder?: InputHTMLAttributes["placeholder"];
+    disabled?: InputHTMLAttributes["disabled"];
+    required?: InputHTMLAttributes["required"];
+    inputmode?: InputHTMLAttributes["inputmode"];
+    autocomplete?: string;
+    pattern?: InputHTMLAttributes["pattern"];
+    name?: InputHTMLAttributes["name"];
+    readonly?: InputHTMLAttributes["readonly"];
 }> & Readonly<{
     "onUpdate:modelValue"?: ((payload: string | number) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/components/ui/multi-select/MultiSelect.vue.d.ts

@@ -6,18 +6,22 @@ export interface MultiSelectOption {
 }
 interface Props {
     options: MultiSelectOption[];
-    modelValue: string[];
     placeholder?: string;
     disabled?: boolean;
     maxDisplay?: number;
 }
-declare const __VLS_export: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+type __VLS_Props = Props;
+type __VLS_ModelProps = {
+    modelValue?: string[];
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:modelValue": (value: string[]) => any;
-}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
     "onUpdate:modelValue"?: ((value: string[]) => any) | undefined;
 }>, {
-    placeholder: string;
     disabled: boolean;
+    placeholder: string;
     maxDisplay: number;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;

package/dist/components/ui/progress/Progress.vue.d.ts

@@ -1,102 +1,41 @@
-import { type HTMLAttributes } from 'vue';
-import { type ProgressRootProps } from 'reka-ui';
-type ProgressVariant = 'default' | 'gradient' | 'sectioned';
+import { type HTMLAttributes } from "vue";
+import type { ProgressRootProps } from "reka-ui";
+import type { ProgressSegment } from "./useProgressGeometry";
+type ProgressVariant = "default" | "gradient" | "sectioned";
 /**
- * Segment shape consumed by `variant="sectioned"`. Mirrors
- * `TimelineSegment` (`@mkbabb/glass-ui/timeline`) deliberately so a
- * consumer can pass the same array to both the timeline rail and the
- * phase-bus progress without re-shaping. Optional fields default
- * sensibly:
- *  - `state`    → "pending"
- *  - `weight`   → 1 (equal share)
- *  - `color`    → consumer-controlled CSS (`var(--chart-{key})` etc.);
- *                 sectioned variant requires it for the colour cells
+ * Progress — the thin variant dispatcher over three orthogonal designs:
+ *   - `default`   → ProgressDefault   (plain rail + translateX intake-pulse)
+ *   - `gradient`  → ProgressGradient  (lifecycle motion grammar + indeterminate)
+ *   - `sectioned` → ProgressSectioned (phase-bus cells + spring active fill)
+ *
+ * The dispatcher carries an EXPLICIT prop-boundary contract: incompatible prop
+ * combinations are refused OUT LOUD (a dev throw) rather than silently producing
+ * a wrong paint. The historical break this closes: a consumer passing
+ * `:model-value` to the sectioned variant had it SILENTLY overridden by the
+ * cumulative cell-fill aggregate, so the bar ignored the value the consumer
+ * thought drove it. The contract below makes that misuse a loud error — the
+ * sectioned variant derives its own a11y value from the cells; `modelValue` is
+ * not its truth.
  */
-export interface ProgressSegment {
-    /** Stable identifier — matched against `currentSegmentKey`. */
-    key: string;
-    /** Display label (currently unused visually; surfaced for a11y/title). */
-    label?: string;
-    /**
-     * CSS colour expression (hex, oklch, color-mix, `var(--token)`).
-     * Drives the cell fill, the gradient stops between siblings, and
-     * the active-fill spring overlay.
-     */
-    color: string;
-    /** Lifecycle state. Drives saturation + sweep. Defaults to "pending". */
-    state?: 'pending' | 'active' | 'completed';
-    /**
-     * Relative width weight. Per-cell widths = `weight / sum(weights)`.
-     * Default `1` (equal share — the speedtest pings/jitter/dl/ul case).
-     */
-    weight?: number;
-}
 type __VLS_Props = ProgressRootProps & {
-    class?: HTMLAttributes['class'];
+    class?: HTMLAttributes["class"];
     /**
-     * 'default'    = bg-secondary rail + bg-primary indicator.
-     * 'gradient'   = rail respects --progress-track; indicator
-     *                respects --progress-fill (free-form CSS, including
-     *                gradients). Default variant from v1.0.x.
-     * 'sectioned'  = phase-bus (AB.W3.T2). Renders N colour-coded cells
-     *                with gradient seams between siblings; the active
-     *                cell carries a spring fill driven by
-     *                `activeProgress` and a living catch-light sweep.
-     *                The single `modelValue` is ignored in favour of
-     *                the per-cell state map. Consumers wire:
-     *                  - `segments`           (the cells)
-     *                  - `currentSegmentKey`  (which cell is active)
-     *                  - `activeProgress`     (0..1 fill of the active cell)
+     * 'default'   = bg-secondary rail + bg-primary indicator.
+     * 'gradient'  = rail respects --progress-track; indicator respects
+     *               --progress-fill; the W4 lifecycle motion grammar layers on.
+     * 'sectioned' = phase-bus (AB.W3.T2). N colour-coded cells with gradient
+     *               seams; the active cell carries a spring fill. The per-cell
+     *               state map is the truth — NOT `modelValue`.
      */
     variant?: ProgressVariant;
     /** Sectioned only — ordered segment list. */
     segments?: ProgressSegment[];
     /** Sectioned only — key of the currently active segment. */
     currentSegmentKey?: string | null;
-    /**
-     * Sectioned only — 0..1 fill of the active segment. Drives the
-     * spring overlay inside the active cell. Pre-active cells fill
-     * 0; post-active cells render at full saturation as "completed".
-     */
+    /** Sectioned only — 0..1 fill of the active segment. */
     activeProgress?: number;
-    /**
-     * AI.W4-M.1 — indeterminate sweep. When true, the gradient
-     * variant's rail runs a slow left-to-right gradient pan
-     * (`--motion-duration-progress-indeterminate`, 4s default) and
-     * the indicator hides. Reka's ProgressRoot already supports the
-     * indeterminate shape via a null modelValue; the prop here is
-     * an explicit opt-in for consumers that want the sweep without
-     * managing the modelValue lifecycle. PRM retires the sweep to
-     * a static rail.
-     */
+    /** Gradient only — indeterminate sweep opt-in. */
     indeterminate?: boolean;
-    /**
-     * AJ-W4-ε — opt out of the publisher-side crescendo overlay. The
-     * gradient variant's lifecycle paints a screen-blended white cap
-     * on the leading edge past 85% modelValue (the typed
-     * `--progress-crescendo` percentage interpolates the cap alpha).
-     * Consumers that bake their own leading-edge brightening into
-     * `--progress-fill` (e.g. speedtest's under-meter bar, whose
-     * gradient stops at 80%/100% paint a `color-mix` white tail
-     * directly into the fill) would otherwise double-brighten the
-     * same edge.
-     *
-     * The pre-W4-ε migration shape was a consumer-side typed-property
-     * override (`--progress-crescendo: 0%` in the consumer's scoped
-     * CSS) — correct in behaviour but visually noisier than a
-     * declarative prop. `:disable-crescendo="true"` collapses the
-     * publisher overlay cleanly: the crescendo rule keys off
-     * `data-crescendo="disabled"` so the screen-blended cap layer
-     * never paints, and the typed style binding pins
-     * `--progress-crescendo: 0%` so any downstream rule that
-     * `var()`s the typed property reads the floor.
-     *
-     * The intake-pulse + discharge-flash still fire — those are
-     * temporal envelopes on the rail / indicator (not gradient
-     * overlays), so a consumer that wants the lifecycle envelopes
-     * but not the crescendo cap can opt into this surgically.
-     */
-    disableCrescendo?: boolean;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
     variant: ProgressVariant;
@@ -105,7 +44,6 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     segments: ProgressSegment[];
     currentSegmentKey: string | null;
     activeProgress: number;
-    disableCrescendo: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/components/ui/progress/ProgressDefault.vue.d.ts

@@ -0,0 +1,14 @@
+import { type HTMLAttributes } from "vue";
+import { type ProgressRootProps } from "reka-ui";
+/**
+ * Default progress variant — `bg-secondary` rail + `bg-primary` indicator with a
+ * `translateX(-%)` intake-pulse. The plainest rung; no lifecycle motion grammar
+ * (that lives on the gradient variant). The thin `Progress` dispatcher routes
+ * here for `variant="default"`.
+ */
+type __VLS_Props = ProgressRootProps & {
+    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>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/ui/progress/ProgressGradient.vue.d.ts

@@ -0,0 +1,25 @@
+import { type HTMLAttributes } from "vue";
+import { type ProgressRootProps } from "reka-ui";
+/**
+ * Gradient progress variant — the rail respects `--progress-track`, the indicator
+ * respects `--progress-fill` (free-form CSS, including gradients), and the W4
+ * lifecycle motion grammar layers on top: an intake pulse on the rising edge, a
+ * leading-edge crescendo past 85%, a discharge glow at 100%, and an optional
+ * indeterminate sweep. The thin `Progress` dispatcher routes here for
+ * `variant="gradient"`.
+ */
+type __VLS_Props = ProgressRootProps & {
+    class?: HTMLAttributes["class"];
+    /**
+     * AI.W4-M.1 — indeterminate sweep. When true, the rail runs a slow
+     * left-to-right gradient pan (`--motion-duration-progress-indeterminate`, 4s
+     * default) and the indicator hides. Reka's ProgressRoot already supports the
+     * indeterminate shape via a null modelValue; the prop here is an explicit
+     * opt-in for consumers that want the sweep without managing the modelValue
+     * lifecycle. PRM retires the sweep to a static rail.
+     */
+    indeterminate?: boolean;
+};
+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/ui/progress/ProgressSectioned.vue.d.ts

@@ -0,0 +1,36 @@
+import { type HTMLAttributes } from "vue";
+import { type ProgressRootProps } from "reka-ui";
+import { type ProgressSegment } from "./useProgressGeometry";
+/**
+ * Sectioned progress variant — the phase-bus (AB.W3.T2). Renders N colour-coded
+ * cells with gradient seams between siblings; the active cell carries a spring
+ * fill driven by `activeProgress` and a living catch-light sweep.
+ *
+ * The single `modelValue` is NOT the truth here — the per-cell state map is. The
+ * underlying `[role="progressbar"]` reports a numeric `aria-valuenow` derived from
+ * the cumulative cell fill (`useProgressGeometry.aggregateValue`), which is the
+ * sectioned variant's OWN value, not a silent override of any consumer-supplied
+ * modelValue (the `Progress` dispatcher refuses a modelValue-as-truth misuse out
+ * loud — see the prop-boundary contract there). The thin dispatcher routes here
+ * for `variant="sectioned"`.
+ */
+type __VLS_Props = Omit<ProgressRootProps, "modelValue"> & {
+    class?: HTMLAttributes["class"];
+    /** Ordered segment list — the cells. */
+    segments?: ProgressSegment[];
+    /** Key of the currently active segment. */
+    currentSegmentKey?: string | null;
+    /**
+     * 0..1 fill of the active segment. Drives the spring overlay inside the
+     * active cell. Pre-active cells fill 0; post-active cells render at full
+     * saturation as "completed".
+     */
+    activeProgress?: number;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    segments: ProgressSegment[];
+    currentSegmentKey: string | null;
+    activeProgress: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/ui/progress/index.d.ts

@@ -1,2 +1,5 @@
-export { default as Progress } from './Progress.vue';
-export type { ProgressSegment } from './Progress.vue';
+export { default as Progress } from "./Progress.vue";
+export { default as ProgressDefault } from "./ProgressDefault.vue";
+export { default as ProgressGradient } from "./ProgressGradient.vue";
+export { default as ProgressSectioned } from "./ProgressSectioned.vue";
+export { useProgressGeometry, type ProgressSegment, type SectionedCell, } from "./useProgressGeometry";

package/dist/components/ui/progress/useProgressGeometry.d.ts

@@ -0,0 +1,60 @@
+import { type ComputedRef, type Ref } from "vue";
+/**
+ * Segment shape consumed by `variant="sectioned"`. Mirrors `TimelineSegment`
+ * (`@mkbabb/glass-ui/timeline`) deliberately so a consumer can pass the same
+ * array to both the timeline rail and the phase-bus progress without re-shaping.
+ * Optional fields default sensibly:
+ *  - `state`  → "pending"
+ *  - `weight` → 1 (equal share)
+ *  - `color`  → consumer-controlled CSS (`var(--chart-{key})` etc.); the
+ *               sectioned variant requires it for the colour cells.
+ */
+export interface ProgressSegment {
+    /** Stable identifier — matched against `currentSegmentKey`. */
+    key: string;
+    /** Display label (currently unused visually; surfaced for a11y/title). */
+    label?: string;
+    /**
+     * CSS colour expression (hex, oklch, color-mix, `var(--token)`). Drives the
+     * cell fill, the gradient stops between siblings, and the active-fill spring
+     * overlay.
+     */
+    color: string;
+    /** Lifecycle state. Drives saturation + sweep. Defaults to "pending". */
+    state?: "pending" | "active" | "completed";
+    /**
+     * Relative width weight. Per-cell widths = `weight / sum(weights)`. Default
+     * `1` (equal share — the speedtest pings/jitter/dl/ul case).
+     */
+    weight?: number;
+}
+/** A resolved sectioned cell — per-cell geometry + lifecycle + fill fraction. */
+export interface SectionedCell extends ProgressSegment {
+    startPct: number;
+    endPct: number;
+    widthPct: number;
+    resolvedState: "pending" | "active" | "completed";
+    /** 0..1 — how much of THIS cell paints saturated. */
+    fill: number;
+}
+/**
+ * Derive per-cell width/start/end/state/fill from the `segments` array.
+ *
+ * Widths come from the weight distribution; states resolve from each segment's
+ * explicit `state` (wins) or are inferred from `currentSegmentKey` order (cells
+ * before current = completed, current = active, after = pending). The active
+ * cell's fill follows `activeProgress`; completed cells fill 1; pending fill 0.
+ */
+export declare function useProgressGeometry(args: {
+    segments: Ref<ProgressSegment[]> | ComputedRef<ProgressSegment[]>;
+    currentSegmentKey: Ref<string | null> | ComputedRef<string | null>;
+    activeProgress: Ref<number> | ComputedRef<number>;
+}): {
+    cells: ComputedRef<SectionedCell[]>;
+    /**
+     * The cumulative-fill aggregate (0..100) — the meaningful numeric the
+     * underlying `[role="progressbar"]` reports as `aria-valuenow`. Derived from
+     * the per-cell state map, NOT from any `modelValue`.
+     */
+    aggregateValue: ComputedRef<number>;
+};

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

@@ -5,11 +5,11 @@ 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:open": (value: boolean) => any;
     "update:modelValue": (value: import("reka-ui").AcceptableValue) => any;
+    "update:open": (value: boolean) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:open"?: ((value: boolean) => any) | undefined;
     "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>;
 declare const _default: typeof __VLS_export;

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

@@ -18,7 +18,7 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
 }>, {
     position: "item-aligned" | "popper";
     align: "start" | "center" | "end";
-    collisionPadding: number | Partial<Record<"left" | "right" | "bottom" | "top", number>>;
+    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;

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

@@ -4,12 +4,15 @@ type __VLS_Props = SelectTriggerProps & {
     class?: HTMLAttributes['class'];
     /** 'default' = glass bg; 'ghost' = transparent, no border/shadow */
     variant?: 'default' | 'ghost';
+    /** Height register: 'default' = h-10 (byte-identical), 'sm' = h-9 (compact controls) */
+    size?: 'sm' | 'default';
 };
 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";
     variant: "default" | "ghost";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist/components/ui/sheet/index.d.ts

@@ -8,6 +8,6 @@ export { default as SheetTitle } from './SheetTitle.vue';
 export { default as SheetDescription } from './SheetDescription.vue';
 export { default as SheetFooter } from './SheetFooter.vue';
 export declare const sheetVariants: (props?: ({
-    side?: "left" | "right" | "bottom" | "top" | null | undefined;
+    side?: "top" | "right" | "bottom" | "left" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export type SheetVariants = VariantProps<typeof sheetVariants>;

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

@@ -9,15 +9,16 @@ export { default as Slider } from './Slider.vue';
  * `.slider-thumb` paint. The size axis lifts pure geometry via CSS vars
  * (`--slider-track-height`, `--slider-thumb-size`) the SFC defaults read.
  *
- * Variants:
- *   standard       — glass track + circular thumb (baseline)
- *   spectrum       — tall muted track + thin bar thumb
- *   timeline       — glass-wash scrub track with disc thumb
- *   glass-pill     — pill-shape track + glass-wash substrate + halo thumb
- *   glass-cartoon  — cartoon-bordered thumb + 2px-border track + cartoon shadow
- *   glass-scrubber — tall scrub track + grab-friendly thin-bar thumb;
- *                    canonicalizes the fourier-analysis 3-site shadow recipe
- *                    (GlassTimeline / SliderControl / ConvergenceTimeline)
+ * Exactly two canonical recipes ship:
+ *   standard — the continuous rounded iOS knob: a fully-circular, borderless
+ *              thumb that sits in the track and reads as a swelling of the
+ *              capsule, with halo-on-state and the iOS press spring. This is
+ *              the general-purpose glass-scrubber knob and the default.
+ *   spectrum — the 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
+ *              small ringed knob that reads against any track hue. This is the
+ *              aurora/blob color-picking surface.
  *
  * Sizes:
  *   sm — 4px track / 12px thumb
@@ -25,7 +26,7 @@ export { default as Slider } from './Slider.vue';
  *   lg — 12px track / 24px thumb
  */
 export declare const sliderVariants: (props?: ({
-    variant?: "standard" | "spectrum" | "timeline" | "glass-pill" | "glass-cartoon" | "glass-scrubber" | null | undefined;
-    size?: "lg" | "sm" | "md" | null | undefined;
+    variant?: "standard" | "spectrum" | null | undefined;
+    size?: "sm" | "lg" | "md" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export type SliderVariants = VariantProps<typeof sliderVariants>;

package/dist/components/ui/tags-input/TagsInput.vue.d.ts

@@ -8,13 +8,13 @@ type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_8) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    invalid: (payload: import("reka-ui").AcceptableInputValue) => any;
     "update:modelValue": (payload: import("reka-ui").AcceptableInputValue[]) => any;
+    invalid: (payload: import("reka-ui").AcceptableInputValue) => any;
     addTag: (payload: import("reka-ui").AcceptableInputValue) => any;
     removeTag: (payload: import("reka-ui").AcceptableInputValue) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onInvalid?: ((payload: import("reka-ui").AcceptableInputValue) => any) | undefined;
     "onUpdate:modelValue"?: ((payload: import("reka-ui").AcceptableInputValue[]) => any) | undefined;
+    onInvalid?: ((payload: import("reka-ui").AcceptableInputValue) => any) | undefined;
     onAddTag?: ((payload: import("reka-ui").AcceptableInputValue) => any) | undefined;
     onRemoveTag?: ((payload: import("reka-ui").AcceptableInputValue) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/components/ui/textarea/Textarea.vue.d.ts

@@ -1,10 +1,12 @@
-import type { HTMLAttributes } from 'vue';
+import type { HTMLAttributes, TextareaHTMLAttributes } from 'vue';
 declare const _default: typeof __VLS_export;
 export default _default;
 declare const __VLS_export: import("vue").DefineComponent<{
     class?: HTMLAttributes["class"];
     defaultValue?: string | number;
     modelValue?: string | number;
+    placeholder?: TextareaHTMLAttributes["placeholder"];
+    disabled?: TextareaHTMLAttributes["disabled"];
     /**
      * AQ.W4 §W4.3 — opt into `field-sizing: content` auto-grow. When `true`,
      * the textarea grows vertically with its content between a 3-line floor
@@ -27,6 +29,8 @@ declare const __VLS_export: import("vue").DefineComponent<{
     class?: HTMLAttributes["class"];
     defaultValue?: string | number;
     modelValue?: string | number;
+    placeholder?: TextareaHTMLAttributes["placeholder"];
+    disabled?: TextareaHTMLAttributes["disabled"];
     /**
      * AQ.W4 §W4.3 — opt into `field-sizing: content` auto-grow. When `true`,
      * the textarea grows vertically with its content between a 3-line floor

package/dist/components/ui/toast/Toast.vue.d.ts

@@ -10,10 +10,10 @@ type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_21) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<ToastProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    pause: () => any;
-    resume: () => any;
     "update:open": (value: boolean) => any;
     escapeKeyDown: (event: KeyboardEvent) => any;
+    pause: () => any;
+    resume: () => any;
     swipeStart: (event: {
         currentTarget: EventTarget & HTMLElement;
     } & Omit<CustomEvent<{
@@ -51,10 +51,10 @@ declare const __VLS_base: import("vue").DefineComponent<ToastProps, {}, {}, {},
         };
     }>, "currentTarget">) => any;
 }, string, import("vue").PublicProps, Readonly<ToastProps> & Readonly<{
-    onPause?: (() => any) | undefined;
-    onResume?: (() => any) | undefined;
     "onUpdate:open"?: ((value: boolean) => any) | undefined;
     onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPause?: (() => any) | undefined;
+    onResume?: (() => any) | undefined;
     onSwipeStart?: ((event: {
         currentTarget: EventTarget & HTMLElement;
     } & Omit<CustomEvent<{

package/dist/components/ui/toggle/Toggle.vue.d.ts

@@ -15,7 +15,7 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
 }>, {
-    size: "default" | "lg" | "sm" | null;
+    size: "default" | "sm" | "lg" | null;
     variant: "default" | "outline" | "card" | null;
     disabled: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/components/ui/toggle/index.d.ts

@@ -21,6 +21,6 @@ export { default as Toggle } from './Toggle.vue';
  */
 export declare const toggleVariants: (props?: ({
     variant?: "default" | "outline" | "card" | null | undefined;
-    size?: "default" | "lg" | "sm" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export type ToggleVariants = VariantProps<typeof toggleVariants>;

package/dist/components/ui/toggle-group/toggleGroupContext.d.ts

@@ -1,4 +1,3 @@
-import { type InjectionKey } from "vue";
 import type { VariantProps } from "class-variance-authority";
 import type { toggleVariants } from "../toggle";
 /**
@@ -15,7 +14,7 @@ export interface ToggleGroupContext {
     variant: ToggleGroupVariants["variant"];
     size: ToggleGroupVariants["size"];
 }
-export declare const TOGGLE_GROUP_KEY: InjectionKey<ToggleGroupContext>;
+export declare const TOGGLE_GROUP_KEY: import("vue").InjectionKey<ToggleGroupContext>;
 export declare function provideToggleGroupContext(context: ToggleGroupContext): void;
 /** Befitting silent default — `<ToggleGroupItem>` can also render bare. */
-export declare function useOptionalToggleGroupContext(): ToggleGroupContext | null;
+export declare const useOptionalToggleGroupContext: () => ToggleGroupContext | null;