@mkbabb/glass-ui 3.2.0 → 3.4.0

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;

package/dist/composables/color/index.d.ts

@@ -0,0 +1,49 @@
+/** An OKLCh color stop. `L` 0..1, `C` 0..~0.4, `h` 0..360. */
+export interface OklchStop {
+    L: number;
+    C: number;
+    h: number;
+}
+/**
+ * The injected color seam (DEC-AT-2, consumed by the AU.W7 blob). Resolves a CSS
+ * color string to a GAMMA-sRGB triple in [0,1]. `defaultBlobColorResolver` is the
+ * opt-in default; a consumer (value.js) may inject its own.
+ */
+export type ColorResolver = (css: string) => [number, number, number];
+/**
+ * OKLCh stop → LINEAR-sRGB in [0,1] — aurora's bundle-canonical bake target (the
+ * shader ACES-tonemaps in linear, so the LUT stays linear).
+ *
+ * value.js's canonical Ottosson path (`rawOklchToOklab → oklabToLinearSRGB`,
+ * inv-K-2). The `Math.max(0,·)` wrap is the ACES-in-linear contract — value.js
+ * does not clamp negative linear (an out-of-gamut stop yields negatives; the wrap
+ * keeps them off the GPU). The equivalence canary asserts the COMPOSED path.
+ */
+export declare function oklchToLinear(stop: OklchStop): [number, number, number];
+/**
+ * OKLCh stop → GAMMA-sRGB in [0,1] — the blob's faithful-lift exit (DEC-AT-7's W7
+ * GAMMA space). value.js's `oklabToRgb255` returns gamma-encoded 0..255 (HSV/sRGB,
+ * no extra OETF); divide to [0,1]. The blob's default resolver returns THIS space
+ * so the W7 lift paints at parity (the LINEAR shader-quality flip + `linearToSrgb`
+ * is the AU.W7 stage). Channels are clamped to [0,1] (an out-of-gamut stop is
+ * already gamut-mapped upstream; this is the float-edge guard).
+ */
+export declare function oklchToGammaRgb(stop: OklchStop): [number, number, number];
+/**
+ * Resolve any CSS color string to an OKLCh stop via value.js's parser — the single
+ * canonical core (inv-K-2). DOM-free (SSR / happy-dom safe — no 1×1-canvas).
+ *
+ * Semantics: an INVALID string THROWS; ALPHA is dropped (OklchStop has no alpha);
+ * out-of-gamut inputs are NOT byte-clamped. Callers feeding user / possibly-
+ * transparent strings should wrap in try/catch and decide an alpha policy.
+ */
+export declare function cssToOklch(css: string): OklchStop;
+/** OKLCh stop → `#rrggbb` gamma hex (value.js `oklabToRgb255`). */
+export declare function oklchStopToHex(s: OklchStop): string;
+/**
+ * The OPT-IN default `ColorResolver` — `(css) => gamma [r,g,b]` via
+ * `cssToOklch → oklchToGammaRgb`. The AU.W7 goo-blob requires an INJECTED resolver
+ * and throws by THIS name on a no-resolver mount (the loud failure, not a silent
+ * gray default); value.js supplies its own, the demo story uses this one.
+ */
+export declare const defaultBlobColorResolver: ColorResolver;

package/dist/composables/context/createContext.d.ts

@@ -0,0 +1,56 @@
+import { type InjectionKey } from "vue";
+/**
+ * Domain-neutral provide/inject DI factory pair — the single source the dock,
+ * dock-layer-group, toggle-group, sortable-list, glyph-face, and configurator
+ * contexts collapse onto (AV.W14). Generalizes the four hand-rolled
+ * provide/inject/throw triplets into ONE typed factory so a `*_KEY:
+ * InjectionKey<T>` declaration + its `provide`/`use`/throw boilerplate is never
+ * re-rolled per call site — each site keeps only its distinct `interface`,
+ * label, and (strict) error message.
+ *
+ * Two shapes, chosen per the strict-vs-optional matrix (PROGRESS.md):
+ *  - `createStrictContext<T>(label, outsideError)` — a `use()` that THROWS
+ *    `outsideError` when injected outside its provider (the consumer is
+ *    meaningless without the parent). It ALSO exposes `useOptional()` over the
+ *    SAME key, so a context that is strict for its primary consumer yet must
+ *    read null-safe elsewhere (the dock: `<Slider>` may sit outside) shares one
+ *    key across both `use` shapes — no second symbol, no `any` leak.
+ *  - `createOptionalContext<T>(label)` — a `use()` that returns `T | null`
+ *    (befitting-silent; the consumer renders bare when no provider is present).
+ *    No strict counterpart is minted — a strict throw would be dead code at
+ *    these sites (invariant 25's "per intent" clause).
+ *
+ * The returned `KEY` is exported by each call site so an external provider can
+ * `provide(KEY, …)` directly (the goo-blob `BLOB_CONFIG_KEY` external-provide
+ * pattern stays a bare `inject(KEY, default)` and is NOT minted here — it is not
+ * a strict-or-optional triplet).
+ */
+export interface StrictContext<T> {
+    /** The typed injection key — exported so an external provider can target it. */
+    readonly KEY: InjectionKey<T>;
+    /** Provide the context to descendants. */
+    provide: (ctx: T) => void;
+    /** Strict — throws `outsideError` when used outside the provider. */
+    use: () => T;
+    /** Befitting-silent over the SAME key — returns `null` outside the provider. */
+    useOptional: () => T | null;
+}
+export interface OptionalContext<T> {
+    /** The typed injection key — exported so an external provider can target it. */
+    readonly KEY: InjectionKey<T>;
+    /** Provide the context to descendants. */
+    provide: (ctx: T) => void;
+    /** Befitting-silent — returns `null` when used outside the provider. */
+    use: () => T | null;
+}
+/**
+ * Strict context factory. `use()` throws `outsideError` outside the provider;
+ * `useOptional()` returns `null` over the same key for the null-safe-elsewhere
+ * case.
+ */
+export declare function createStrictContext<T>(label: string, outsideError: string): StrictContext<T>;
+/**
+ * Optional context factory. `use()` returns `T | null` (befitting-silent); no
+ * strict counterpart is minted.
+ */
+export declare function createOptionalContext<T>(label: string): OptionalContext<T>;

package/dist/composables/context/index.d.ts

@@ -0,0 +1 @@
+export { createStrictContext, createOptionalContext, type StrictContext, type OptionalContext, } from "./createContext";

package/dist/composables/dark/darkModeSyncScript.d.ts

@@ -0,0 +1,23 @@
+/** The localStorage key vueuse `useColorMode`/`useDark` defaults to. The
+ * `useGlobalDark` factory passes no `storageKey`, so this default is canonical. */
+export declare const DARK_MODE_STORAGE_KEY = "vueuse-color-scheme";
+export interface DarkModeSyncScriptOptions {
+    /**
+     * Override the localStorage key the emitted script reads. Defaults to
+     * `vueuse-color-scheme` — the key `useGlobalDark`'s underlying `useDark`
+     * uses. Override ONLY if a consumer reconfigured the vueuse storage key.
+     */
+    storageKey?: string;
+}
+/**
+ * Return the inline `<head>` script STRING that resolves dark/light at parse
+ * time and stamps `<html>` before first paint. Inject it as the FIRST blocking
+ * script in `<head>` (or into an SSR head):
+ *
+ * ```html
+ * <script>${darkModeSyncScript()}</script>
+ * ```
+ *
+ * The function has no DOM side-effect itself — it only builds a string.
+ */
+export declare function darkModeSyncScript(options?: DarkModeSyncScriptOptions): string;

package/dist/composables/dark/index.d.ts

@@ -1,2 +1,5 @@
 export { useGlobalDark } from "./useGlobalDark";
+export type { UseGlobalDarkOptions } from "./useGlobalDark";
 export { installDarkModeSync } from "./installDarkModeSync";
+export { darkModeSyncScript, DARK_MODE_STORAGE_KEY } from "./darkModeSyncScript";
+export type { DarkModeSyncScriptOptions } from "./darkModeSyncScript";