@mkbabb/glass-ui 4.2.0 → 6.0.0

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

@@ -0,0 +1,107 @@
+import { type HTMLAttributes } from 'vue';
+import { type ToastRootProps } from 'reka-ui';
+import { type Surface } from '../_shared/useSurfaceAxis';
+import type { Tone } from '../_shared/axes';
+interface ToastProps extends ToastRootProps {
+    class?: HTMLAttributes['class'];
+    tone?: Tone;
+    surface?: Surface;
+}
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<ToastProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+    escapeKeyDown: (event: KeyboardEvent) => any;
+    pause: () => any;
+    resume: () => any;
+    swipeStart: (event: {
+        currentTarget: EventTarget & HTMLElement;
+    } & Omit<CustomEvent<{
+        originalEvent: PointerEvent;
+        delta: {
+            x: number;
+            y: number;
+        };
+    }>, "currentTarget">) => any;
+    swipeMove: (event: {
+        currentTarget: EventTarget & HTMLElement;
+    } & Omit<CustomEvent<{
+        originalEvent: PointerEvent;
+        delta: {
+            x: number;
+            y: number;
+        };
+    }>, "currentTarget">) => any;
+    swipeCancel: (event: {
+        currentTarget: EventTarget & HTMLElement;
+    } & Omit<CustomEvent<{
+        originalEvent: PointerEvent;
+        delta: {
+            x: number;
+            y: number;
+        };
+    }>, "currentTarget">) => any;
+    swipeEnd: (event: {
+        currentTarget: EventTarget & HTMLElement;
+    } & Omit<CustomEvent<{
+        originalEvent: PointerEvent;
+        delta: {
+            x: number;
+            y: number;
+        };
+    }>, "currentTarget">) => any;
+}, string, import("vue").PublicProps, Readonly<ToastProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPause?: (() => any) | undefined;
+    onResume?: (() => any) | undefined;
+    onSwipeStart?: ((event: {
+        currentTarget: EventTarget & HTMLElement;
+    } & Omit<CustomEvent<{
+        originalEvent: PointerEvent;
+        delta: {
+            x: number;
+            y: number;
+        };
+    }>, "currentTarget">) => any) | undefined;
+    onSwipeMove?: ((event: {
+        currentTarget: EventTarget & HTMLElement;
+    } & Omit<CustomEvent<{
+        originalEvent: PointerEvent;
+        delta: {
+            x: number;
+            y: number;
+        };
+    }>, "currentTarget">) => any) | undefined;
+    onSwipeCancel?: ((event: {
+        currentTarget: EventTarget & HTMLElement;
+    } & Omit<CustomEvent<{
+        originalEvent: PointerEvent;
+        delta: {
+            x: number;
+            y: number;
+        };
+    }>, "currentTarget">) => any) | undefined;
+    onSwipeEnd?: ((event: {
+        currentTarget: EventTarget & HTMLElement;
+    } & Omit<CustomEvent<{
+        originalEvent: PointerEvent;
+        delta: {
+            x: number;
+            y: number;
+        };
+    }>, "currentTarget">) => any) | undefined;
+}>, {
+    surface: Surface;
+    tone: Tone;
+}, {}, {}, {}, 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;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,9 @@
+export { default as Toast } from './Toast.vue';
+export { default as ToastAction } from './ToastAction.vue';
+export { default as ToastClose } from './ToastClose.vue';
+export { default as ToastDescription } from './ToastDescription.vue';
+export { default as ToastTitle } from './ToastTitle.vue';
+export { default as Toaster } from './Toaster.vue';
+export { toast, useToast } from './use-toast';
+export type { Toast as ToastType } from './use-toast';
+export type { ToasterPosition } from './Toaster.vue';

package/dist/components/toast/use-toast.d.ts

@@ -0,0 +1,182 @@
+import type { Component, VNode } from 'vue';
+import type { Surface } from '../_shared/useSurfaceAxis';
+import type { Tone } from '../_shared/axes';
+export interface Toast {
+    id: string;
+    title?: string;
+    description?: string;
+    action?: Component | VNode;
+    tone?: Tone;
+    /**
+     * BB.W-SURFACE-AXIS-COMPLETE — the shared {glass·veil·opaque} surface-decoration
+     * axis on a queued toast (default `glass`). Forwarded through `Toaster.vue`'s
+     * per-toast `v-bind` exactly like `variant`; orthogonal to the tone arm.
+     */
+    surface?: Surface;
+    /**
+     * Auto-dismiss delay in ms, forwarded to reka-ui's `ToastRoot`. Omit to
+     * inherit the `ToastProvider` default; `Number.POSITIVE_INFINITY` keeps the
+     * toast open until dismissed.
+     */
+    duration?: number;
+}
+type ToasterToast = Toast & {
+    id: string;
+    title?: string;
+    description?: string;
+    action?: Component | VNode;
+    open?: boolean;
+    'onUpdate:open'?: (open: boolean) => void;
+};
+type ToastOptions = Omit<ToasterToast, 'id'>;
+declare function toast(props: ToastOptions): {
+    id: string;
+    dismiss: () => void;
+    update: (props: ToasterToast) => void;
+};
+declare function useToast(): {
+    toasts: import("vue").ComputedRef<{
+        id: string;
+        title?: string | undefined;
+        description?: string | undefined;
+        action?: import("vue").FunctionalComponent<any, {}, any, {}> | {
+            new (...args: any[]): any;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | {
+            [x: string]: any;
+            setup?: ((this: void, props: import("@vue/shared").LooseRequired<any>, ctx: {
+                attrs: import("vue").Attrs;
+                slots: Readonly<{
+                    [name: string]: import("vue").Slot<any> | undefined;
+                }>;
+                emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
+                expose: <Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed) => void;
+            }) => any) | undefined;
+            name?: string | undefined;
+            template?: string | object | undefined;
+            render?: Function | undefined;
+            components?: Record<string, Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>> | undefined;
+            directives?: Record<string, import("vue").Directive<any, any, string, any>> | undefined;
+            inheritAttrs?: boolean | undefined;
+            emits?: any;
+            slots?: {} | undefined;
+            expose?: string[] | undefined;
+            serverPrefetch?: (() => void | Promise<any>) | undefined;
+            compilerOptions?: {
+                isCustomElement?: ((tag: string) => boolean) | undefined;
+                whitespace?: "preserve" | "condense" | undefined;
+                comments?: boolean | undefined;
+                delimiters?: [string, string] | undefined;
+            } | undefined;
+            call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
+            __isFragment?: never | undefined;
+            __isTeleport?: never | undefined;
+            __isSuspense?: never | undefined;
+            __defaults?: {} | undefined;
+            compatConfig?: {
+                GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
+                GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
+                GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
+                GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
+                GLOBAL_SET?: boolean | "suppress-warning" | undefined;
+                GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
+                GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
+                GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
+                CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
+                CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
+                CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
+                CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
+                CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
+                CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
+                CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
+                INSTANCE_SET?: boolean | "suppress-warning" | undefined;
+                INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
+                INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
+                INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
+                INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
+                INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
+                INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
+                INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
+                INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
+                OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
+                OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
+                OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
+                OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
+                WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
+                PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
+                V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
+                CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
+                ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
+                ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
+                TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
+                TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
+                COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
+                COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
+                COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
+                RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
+                FILTERS?: boolean | "suppress-warning" | undefined;
+                PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
+                MODE?: 2 | 3 | ((comp: Component | null) => 2 | 3) | undefined;
+            } | undefined;
+            data?: ((this: any, vm: any) => any) | undefined;
+            computed?: import("vue").ComputedOptions | undefined;
+            methods?: import("vue").MethodOptions | undefined;
+            watch?: {
+                [x: string]: (string | import("vue").WatchCallback | ({
+                    handler: import("vue").WatchCallback | string;
+                } & import("vue").WatchOptions<boolean>)) | (string | import("vue").WatchCallback | ({
+                    handler: import("vue").WatchCallback | string;
+                } & import("vue").WatchOptions<boolean>))[];
+            } | undefined;
+            provide?: import("vue").ComponentProvideOptions | undefined;
+            inject?: {} | string[] | undefined;
+            filters?: Record<string, Function> | undefined;
+            mixins?: any[] | undefined;
+            extends?: any;
+            beforeCreate?: (() => any) | undefined;
+            created?: (() => any) | undefined;
+            beforeMount?: (() => any) | undefined;
+            mounted?: (() => any) | undefined;
+            beforeUpdate?: (() => any) | undefined;
+            updated?: (() => any) | undefined;
+            activated?: (() => any) | undefined;
+            deactivated?: (() => any) | undefined;
+            beforeDestroy?: (() => any) | undefined;
+            beforeUnmount?: (() => any) | undefined;
+            destroyed?: (() => any) | undefined;
+            unmounted?: (() => any) | undefined;
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | undefined;
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | undefined;
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | undefined;
+            delimiters?: [string, string] | undefined;
+            __differentiator?: string | number | symbol | undefined;
+            __isBuiltIn?: boolean | undefined;
+            __file?: string | undefined;
+            __name?: string | undefined;
+        } | undefined;
+        tone?: Tone
+        /**
+         * BB.W-SURFACE-AXIS-COMPLETE — the shared {glass·veil·opaque} surface-decoration
+         * axis on a queued toast (default `glass`). Forwarded through `Toaster.vue`'s
+         * per-toast `v-bind` exactly like `variant`; orthogonal to the tone arm.
+         */
+         | undefined;
+        surface?: Surface
+        /**
+         * Auto-dismiss delay in ms, forwarded to reka-ui's `ToastRoot`. Omit to
+         * inherit the `ToastProvider` default; `Number.POSITIVE_INFINITY` keeps the
+         * toast open until dismissed.
+         */
+         | undefined;
+        duration?: number | undefined;
+        open?: boolean | undefined;
+        'onUpdate:open'?: ((open: boolean) => void) | undefined;
+    }[]>;
+    toast: typeof toast;
+    dismiss: (toastId?: string) => void;
+};
+export { toast, useToast };

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

@@ -0,0 +1,29 @@
+import { type HTMLAttributes } from 'vue';
+import { type ToggleProps } from 'reka-ui';
+import { type ToggleVariants } from './';
+type __VLS_Props = ToggleProps & {
+    class?: HTMLAttributes['class'];
+    variant?: ToggleVariants['variant'];
+    size?: ToggleVariants['size'];
+};
+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: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {
+    size: "sm" | "md" | "lg" | null;
+    disabled: boolean;
+    variant: "default" | "outline" | "card" | null;
+}, {}, {}, {}, 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;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,26 @@
+import { type VariantProps } from 'class-variance-authority';
+export { default as Toggle } from './Toggle.vue';
+/**
+ * `card` variant — AC.W8e (glass-ui v1.7.0).
+ *
+ * Hoist of speedtest FlowSelector's 17-class glass-card recipe. The pattern
+ * (icon-over-label-over-description on a `.glass-card` surface, hover quiet
+ * fill, `data-state="on"` selected fill + border, active scale press) is
+ * generic enough that other consumers (survey wizards, mode pickers,
+ * settings picker grids) will hit the same shape. The variant bakes:
+ *  - the quiet glass surface ladder (`.glass-card` base + hover/selected
+ *    `--glass-{bg,border,shadow}-quiet` tier composition)
+ *  - the column-stack interior (`flex-col`, `gap-4`, `p-8`, `text-center`)
+ *  - `data-state="on"` + `:hover` contracts threaded through glass tokens,
+ *    not raw `bg-accent` (which would shadow the card surface)
+ *  - the active-press scale (`active:scale-95`) for tactile affordance
+ *
+ * Reads through `.glass-card` so consumers retint via the existing glass
+ * token cascade (`--glass-bg-quiet`, `--glass-border-quiet`, etc.) rather
+ * than re-declaring the surface at the consumer.
+ */
+export declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | "card" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type ToggleVariants = VariantProps<typeof toggleVariants>;

package/dist/components/typewriter/TypewriterText.vue.d.ts

@@ -0,0 +1,82 @@
+import type { TypewriterWord } from "./types";
+interface Props {
+    /** Single text to type. Use this OR `words`, not both. */
+    text?: string;
+    /** Array of words to cycle through in rotation mode. Use this OR `text`, not both. */
+    words?: TypewriterWord[];
+    ngramSize?: number | {
+        min: number;
+        max: number;
+    };
+    baseSpeed?: number;
+    variance?: number;
+    errorRate?: number;
+    firstAnimationSpeedFactor?: number;
+    maxCharsBeforeNotice?: number;
+    continueAfterTypoProbability?: number;
+    sequentialTypoDecay?: number;
+    correctionSpeedMultiplier?: number;
+    cursorVisible?: boolean;
+    cursorBlink?: boolean;
+    cursorChar?: string;
+    startDelay?: number;
+    loop?: boolean;
+    /** Pause after typing a word before deleting (ms). Word-rotation mode only. */
+    pauseAfterType?: number;
+    /** Pause after deleting a word before typing the next (ms). Word-rotation mode only. */
+    pauseAfterDelete?: number;
+    /** Backspace speed in word-rotation mode (ms per char). */
+    deletingSpeed?: number;
+    respectReducedMotion?: boolean;
+}
+declare const __VLS_export: import("vue").DefineComponent<Props, {
+    startTyping: () => Promise<void>;
+    stopTyping: () => void;
+    reset: () => void;
+    isTyping: import("vue").Ref<boolean, boolean>;
+    isDeleting: import("vue").Ref<boolean, boolean>;
+    currentWord: import("vue").ComputedRef<{
+        text: string;
+        className?: string | undefined;
+        isCode?: boolean | undefined;
+    }>;
+    currentWordIndex: import("vue").ComputedRef<number>;
+    pause: () => void;
+    resume: () => void;
+    setCharPosition: (n: number) => void;
+    forceWord: (idx: number, charPos: number) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    start: () => any;
+    complete: () => any;
+    wordComplete: (index: number) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    onStart?: (() => any) | undefined;
+    onComplete?: (() => any) | undefined;
+    onWordComplete?: ((index: number) => any) | undefined;
+}>, {
+    text: string;
+    respectReducedMotion: boolean;
+    loop: boolean;
+    words: TypewriterWord[];
+    ngramSize: number | {
+        min: number;
+        max: number;
+    };
+    baseSpeed: number;
+    variance: number;
+    errorRate: number;
+    firstAnimationSpeedFactor: number;
+    maxCharsBeforeNotice: number;
+    continueAfterTypoProbability: number;
+    sequentialTypoDecay: number;
+    correctionSpeedMultiplier: number;
+    cursorVisible: boolean;
+    cursorBlink: boolean;
+    cursorChar: string;
+    pauseAfterType: number;
+    pauseAfterDelete: number;
+    deletingSpeed: number;
+    startDelay: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/typewriter/composables/useTypewriter.d.ts

@@ -0,0 +1,21 @@
+import type { TypewriterOptions } from "../types";
+export declare function useTypewriter(options: TypewriterOptions): {
+    displayText: import("vue").Ref<string, string>;
+    isTyping: import("vue").Ref<boolean, boolean>;
+    isFirstAnimation: import("vue").Ref<boolean, boolean>;
+    isDeleting: import("vue").Ref<boolean, boolean>;
+    currentWordIndex: import("vue").ComputedRef<number>;
+    currentWord: import("vue").ComputedRef<{
+        text: string;
+        className?: string | undefined;
+        isCode?: boolean | undefined;
+    }>;
+    startTyping: () => Promise<void>;
+    stopTyping: () => void;
+    reset: () => void;
+    updateText: (newText: string) => void;
+    pause: () => void;
+    resume: () => void;
+    setCharPosition: (n: number) => void;
+    forceWord: (idx: number, charPos: number) => void;
+};

package/dist/components/typewriter/utils/graphemes.d.ts

@@ -0,0 +1 @@
+export declare function splitGraphemes(text: string): string[];

package/dist/components/watercolor-dot/WatercolorDot.vue.d.ts

@@ -0,0 +1,74 @@
+/**
+ * WatercolorDot — an organic pastel blob swatch. A CSS/SVG primitive (NO drawing
+ * context — no WebGL/WebGPU/Canvas2D; the deliberate suite counterexample, the mark
+ * that documents WHY it is not a GPU context): the blob shape is a deterministic
+ * per-vertex `border-radius` morph (seeded by `color + seed`), and the wet, bleeding
+ * edge is an SVG turbulence + displacement filter that is INTERNALISED — the component
+ * mounts its own namespaced `<filter>` so there is zero consumer plumbing. Mount the
+ * dot and the filter just works.
+ *
+ * Safari-safe by construction (USER-DEFECTS §H): the SVG `<filter>` rasterizes ONCE
+ * + caches (the HandMark `texture.ts` idiom) and NEVER re-rasterizes per frame; the
+ * `animate` liveness rides a seeded COMPOSITOR `transform` wobble the compositor
+ * accelerates without touching the filter graph (a per-frame `border-radius` paint
+ * under the filter is the §H Safari flash, retired here). The filter `seed` is
+ * per-instance off `hashString(color + seed)` so each dot's wet edge is uniquely
+ * displaced (no twelve-clones).
+ *
+ * Color arrives as a CSS string painted straight onto the swatch background — the
+ * dot needs no resolver because it does not feed a shader; the injected-color seam
+ * shape is "pass the CSS color in". Warm-cream identity by default (the dot bakes no
+ * hue; the demo palette is presets-in-consumers).
+ */
+type __VLS_Props = {
+    /** CSS color painted as the swatch background (any CSS color form). */
+    color: string;
+    /**
+     * Render mode:
+     *   `solid` (default) — the filled organic blob (the swatch background IS the
+     *                       color; the existing register, unchanged).
+     *   `ghost`  — the SAME seeded blob SILHOUETTE traced as a DASHED outline: a
+     *              dashed CSS BORDER reading the SAME seeded `border-radius`
+     *              silhouette the solid dot fills (`activeBorderRadius`), carrying
+     *              the SAME wet `feDisplacementMap` filter so the displacement
+     *              wobbles the dashed border INTO the seeded organic outline. A
+     *              CSS dashed border hugs its own `border-radius`, so the outline
+     *              follows the seeded blob EXACTLY — NOT an ellipse, NOT a circle,
+     *              NOT a dashed rectangle. A low-alpha `color` fill is kept behind
+     *              the border. A `ghost` of a given `color + seed` traces the SAME
+     *              outline the `solid` dot of that seed fills (both read the same
+     *              `useWatercolorBlob` morph — the ONE shape source). The empty-
+     *              palette-slot / placeholder affordance.
+     */
+    variant?: "solid" | "ghost";
+    /** Run the rAF-driven compositor transform wobble (default false → static). */
+    animate?: boolean;
+    /** Host tag — `div` (decorative) or `button` (interactive). */
+    tag?: "div" | "button";
+    /** Base morph cycle duration in ms (default 4000). */
+    cycleDuration?: number;
+    /** Border-radius range [lo, hi] as percentages (default [20, 80]). */
+    range?: [number, number];
+    /** Extra seed string mixed into the shape + wet-edge PRNG for uniqueness. */
+    seed?: string;
+};
+declare var __VLS_11: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_11) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    range: [number, number];
+    animate: boolean;
+    seed: string;
+    variant: "solid" | "ghost";
+    tag: "div" | "button";
+    cycleDuration: 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;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/watercolor-dot/prng.d.ts

@@ -0,0 +1,5 @@
+export { mulberry32, hashString } from "../../composables/glass/procedural/prng";
+/** Generate 8 random border-radius percentages in [lo, hi] using the given PRNG. */
+export declare function randomRadii(rng: () => number, lo: number, hi: number): number[];
+/** Serialise 8 radii into a CSS `border-radius` shorthand (4 corners / 4 corners). */
+export declare function radiiToCSS(r: number[]): string;

package/dist/components/watercolor-dot/useWatercolorBlob.d.ts

@@ -0,0 +1,31 @@
+import { type Ref } from "vue";
+export interface UseWatercolorBlobOptions {
+    /** Enable the rAF animation loop (drives a COMPOSITOR transform wobble). */
+    animate?: boolean;
+    /** Base cycle duration in ms (default 4000). */
+    cycleDuration?: number;
+    /** Border-radius range [lo, hi] as percentages (default [20, 80]). */
+    range?: [number, number];
+    /** Extra seed string mixed into the hash for unique shapes. */
+    seed?: string;
+}
+/**
+ * Drives a watercolor dot's organic blob shape. Deterministic given `color + seed`
+ * (seeds the PRNG), so the same color reproduces the same shape across mounts. The
+ * seeded `border-radius` silhouette is set ONCE (the dot's identity) and is STATIC —
+ * the box never re-paints its radius per frame (the §H Safari fix: a per-frame
+ * `border-radius` write under the SVG filter forces the filter graph to RE-RASTERIZE
+ * every frame, which flashes Safari). In `animate` mode the liveness rides a seeded
+ * COMPOSITOR `transform` wobble (scale/skew/rotate) the compositor handles WITHOUT
+ * touching the cached filter — the HandMark static-filter idiom. The wobble is driven
+ * by the library's ONE `useRAFLoop` (BG.W-WATERCOLOR-RAF) — parked when the tab is
+ * hidden, frozen under `prefers-reduced-motion` — never a hand-rolled zombie rAF.
+ * `nudge()` retargets the wobble for a quick jiggle on hover.
+ */
+export declare function useWatercolorBlob(color: Ref<string> | (() => string), options?: UseWatercolorBlobOptions): {
+    borderRadius: Ref<string, string>;
+    hoverBorderRadius: Ref<string, string>;
+    transform: Ref<string, string>;
+    nudge: () => void;
+};
+export type WatercolorBlob = ReturnType<typeof useWatercolorBlob>;

package/dist/composables/color/accent-tone-solve.d.ts

@@ -0,0 +1,11 @@
+import type { UseAccentToneOptions } from "./useAccentTone";
+/**
+ * Resolve the contrast-safe label ink for a CONCRETE tone (the caller — the shell —
+ * has already screened out `var(--…)` tones; there is no author-time solve for a
+ * cascade var). The ink RESOLVES `safeAccentColor(toneColor, bandLightness, …)`:
+ * value.js shifts the tone's OKLCh lightness AWAY from the active-band fill until it
+ * clears the AA bar, so the label reads ON the fill in either mode. Returns an
+ * `oklch(...)` string, or `""` on an unparseable tone/surface (fail-explicit — the
+ * consumer falls back to the CSS default ink, a befitting graceful degrade).
+ */
+export declare function solveAccentInk(toneCss: string, opts?: UseAccentToneOptions): string;

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

@@ -11,7 +11,7 @@ export interface OklchStop {
  * prop (the SVG-field surface owns its own color pipeline). The goo-blob no longer
  * injects it: it resolves color internally through `cssToOklch → oklchToGammaRgb`
  * (W-BLOB3 STRIPPED the speculative DI built for an absent value.js consumer that
- * never repatriated; see `docs/consumer-evidence/goo-blob.md`).
+ * never repatriated).
  */
 export type ColorResolver = (css: string) => [number, number, number];
 /**
@@ -121,6 +121,23 @@ export interface DeriveBlobPaletteOptions {
      * the constellation focal share (the set-cohesion accent identity).
      */
     chromaCeiling?: number;
+    /**
+     * BG.W-BLOB-SATELLITE-SHADE (F9.R1 — the `uSatColor[]` companion) — pin the BODY
+     * stop's OKLCh lightness. The default ramp centres L on the seed
+     * (`anchor.L - lightnessSpread/2` at the body, climbing `lightnessSpread` to the
+     * lightest satellite). When set, the body stop (t=0) anchors at exactly this L and
+     * the satellites still climb `lightnessSpread` from it — so a consumer picks the
+     * body luminance directly (the deep-body read) without moving the seed hue/chroma.
+     * `undefined` (the default) leaves the derivation byte-identical to HEAD.
+     */
+    bodyLightness?: number;
+    /**
+     * BG.W-BLOB-SATELLITE-SHADE (F9.R1) — the OKLCh-lightness FLOOR on every derived
+     * stop. Replaces the hardcoded `0.05` low clamp, so a consumer guarantees no stop
+     * reads darker than this (a body/satellite that never collapses toward black). The
+     * `0.98` high clamp is untouched. `undefined` → the byte-identical `0.05` floor.
+     */
+    lightnessFloor?: number;
 }
 /**
  * Seed ONE color into a harmonious, gamut-safe 2-4-stop OKLCh palette for the blob

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

@@ -18,17 +18,15 @@ export interface UseAccentToneReturn {
      *  contrast-safe label colour over the active band). */
     toneStyle: ComputedRef<Record<string, string>>;
     /** The resolved contrast-safe ink as a CSS `oklch(...)` string (for a non-CSS
-     *  reader — a canvas label, a test). */
+     *  reader — a canvas label, a test). `""` on the `var()` / unset fast path or
+     *  before the concrete-tone solve lands. */
     ink: ComputedRef<string>;
 }
 /**
  * `useAccentTone(tone, opts)` — resolve the contrast-safe label ink for the tonal
- * register. The ink RESOLVES `safeAccentColor(toneColor, bandLightness, …)`:
- * value.js shifts the tone's OKLCh lightness AWAY from the active-band fill until
- * it clears the AA bar, so the label reads ON the fill in either mode (a dark band
- * gets a light ink, a light band a dark ink). The darken/lighten-until-it-passes
- * math is value.js's — glass-ui re-implements none of it.
- *
- * PRM-irrelevant (a colour, not an animation). DOM-free + deterministic.
+ * register. A `var(--…)` / unset tone is value.js-free (`""` ink, the CSS fallback);
+ * a concrete tone loads the value.js `./accent-tone-solve` leaf behind a dynamic
+ * import and upgrades the ink the next tick. PRM-irrelevant (a colour, not an
+ * animation). DOM-free + deterministic.
  */
 export declare function useAccentTone(tone: MaybeRefOrGetter<string>, opts?: UseAccentToneOptions): UseAccentToneReturn;