@mkbabb/glass-ui 3.1.1 → 3.3.0

package/dist/components/custom/dock/GlassDock.vue.d.ts

@@ -5,8 +5,6 @@ type __VLS_Props = {
     fitContent?: boolean;
     position?: "fixed" | "inline" | "sticky";
     alwaysExpanded?: boolean;
-    /** Allow expanded content to wrap to multiple lines. */
-    wrap?: boolean;
     /**
      * Visual/behavioral preset.
      *   `dock`             — the horizontal floating dock (default).
@@ -43,17 +41,40 @@ type __VLS_Props = {
      * dock control sizing. Root CSS variables can override each density.
      */
     density?: DockDensity;
+    /**
+     * Overflow strategy when the expanded content exceeds the dock's
+     * axis cap (`--dock-max-inline-size` horizontally,
+     * `--dock-max-block-size` vertically). The ONE knob governing every
+     * overflow behaviour (AT.W7-dock-a clean break — collapsed from the
+     * prior `wrap` boolean + `overflow` pair + `containerName` clip-lift,
+     * which all touched overflow divergently).
+     *   `"grow"`   — content grows to fit then overflows visibly past
+     *                the cap (the default; nothing clips or scrolls).
+     *   `"wrap"`   — expanded content wraps to multiple lines/rows (the
+     *                `.dock-overflow-wrap` recipe — a multi-row pill that narrows
+     *                to the viewport gutter on small screens and snaps
+     *                back to a single nowrap row past `--dock-overflow-bp`).
+     *   `"scroll"` — the dock becomes the scroll port. Horizontal docks
+     *                scroll the active layer on the inline axis
+     *                (`.dock-scroll-x`); vertical rails scroll on the
+     *                block axis (`.dock-scroll-y`), keeping the
+     *                `max-block-size` cap. The rounded pill masks the
+     *                scroll edge; the scrollbar is hidden. The axis is
+     *                chosen automatically from `orientation`.
+     */
+    overflow?: "grow" | "wrap" | "scroll";
     /**
      * When set, the dock root establishes an inline-size container query
-     * subject (`container-type: inline-size; container-name: <value>`)
-     * and lifts its `overflow: hidden` clip so descendants can wrap or
-     * report intrinsic widths at narrow viewports. Consumers query the
-     * named container via `@container <value> (...)` rules.
+     * subject (`container-type: inline-size; container-name: <value>`) so
+     * descendants can query the named container via `@container <value>
+     * (...)` rules. ORTHOGONAL to the `overflow` clip: opting into a
+     * container subject does NOT silently change the dock's clip shell
+     * (AT.W7-dock-a — the prior clip-lift was folded out; use
+     * `overflow="wrap"` to allow multi-line content).
      *
-     * Without this prop the dock retains its default `overflow: hidden`
-     * shell — the pre-T behaviour. T.B audit §1.3 cornerstone: the
-     * cluster's container subject must live on the dock primitive, never
-     * on a descendant whose intrinsic size the dock relies on.
+     * T.B audit §1.3 cornerstone: the cluster's container subject must
+     * live on the dock primitive, never on a descendant whose intrinsic
+     * size the dock relies on.
      */
     containerName?: string;
 };
@@ -76,15 +97,15 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
     release: () => void;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
     position: "fixed" | "inline" | "sticky";
-    variant: "dock" | "rail" | "instrument-strip";
+    overflow: "grow" | "wrap" | "scroll";
     orientation: "horizontal" | "vertical";
-    wrap: boolean;
+    variant: "dock" | "rail" | "instrument-strip";
     density: DockDensity;
+    shape: "pill" | "rounded";
     collapseDelay: number;
     alwaysExpanded: boolean;
     startCollapsed: boolean;
     fitContent: boolean;
-    shape: "pill" | "rounded";
 }, {}, {}, {}, 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/custom/dock/composables/dockContext.d.ts

@@ -1,4 +1,4 @@
-import { type ComputedRef, type InjectionKey } from "vue";
+import type { ComputedRef } from "vue";
 export type DockOrientation = "horizontal" | "vertical";
 /**
  * Dock context surfaces the dock id + orientation + held-state coordination
@@ -32,9 +32,9 @@ export interface DockContext {
     /** Reactive `keepOpenCount > 0` flag; descendants reflect via `data-held`. */
     held: ComputedRef<boolean>;
 }
-export declare const DOCK_CONTEXT_KEY: InjectionKey<DockContext>;
+export declare const DOCK_CONTEXT_KEY: import("vue").InjectionKey<DockContext>;
 export declare function provideDockContext(context: DockContext): void;
 /** Strict — throws when used outside `<GlassDock>`. */
-export declare function useDockContext(): DockContext;
+export declare const useDockContext: () => DockContext;
 /** Befitting silent default for primitives that may render outside a dock. */
-export declare function useOptionalDockContext(): DockContext | null;
+export declare const useOptionalDockContext: () => DockContext | null;

package/dist/components/custom/dock/composables/dockLayerContext.d.ts

@@ -1,4 +1,4 @@
-import { type Component, type InjectionKey, type Ref } from "vue";
+import type { Component, Ref } from "vue";
 /**
  * DockLayerGroup context — DI surface for `<DockLayer>` children registering
  * with their parent `<DockLayerGroup>` for the switcher rail + crossfade
@@ -18,12 +18,19 @@ export interface DockLayerDescriptor {
 export interface DockLayerGroupContext {
     register(desc: DockLayerDescriptor): void;
     unregister(id: string): void;
-    currentLayerId: Ref<string>;
-    leavingLayerId: Ref<string | null>;
+    /**
+     * AU.W8b.6 — group-orchestrated layer state, exposed READ-ONLY. The
+     * `<DockLayerGroup>` (via `useLayerTransition`) owns the writable refs and
+     * provides `readonly()` projections; a `<DockLayer>` child can read but
+     * never write this state. A child `currentLayerId.value = …` is a compile
+     * error (see `__tests__/dockLayerContext.readonly.test-d.ts`).
+     */
+    currentLayerId: Readonly<Ref<string>>;
+    leavingLayerId: Readonly<Ref<string | null>>;
 }
-export declare const DOCK_LAYER_GROUP_KEY: InjectionKey<DockLayerGroupContext>;
+export declare const DOCK_LAYER_GROUP_KEY: import("vue").InjectionKey<DockLayerGroupContext>;
 export declare function provideDockLayerGroupContext(context: DockLayerGroupContext): void;
 /** Strict — throws when used outside `<DockLayerGroup>`. */
-export declare function useDockLayerGroupContext(): DockLayerGroupContext;
+export declare const useDockLayerGroupContext: () => DockLayerGroupContext;
 /** Befitting silent default; reserved for future consumers. */
-export declare function useOptionalDockLayerGroupContext(): DockLayerGroupContext | null;
+export declare const useOptionalDockLayerGroupContext: () => DockLayerGroupContext | null;

package/dist/components/custom/dock/composables/useLayerTransition.d.ts

@@ -31,14 +31,38 @@ export interface UseLayerTransitionReturn {
  *   the size + crossfades the pane content with ZERO `getBoundingClientRect`
  *   reads. No pin/measure/re-pin dance, no inline size, no rAF.
  *
- * - **Fallback path** (no `startViewTransition`): the existing axis-aware FLIP
- *   runs verbatim, KEPT as the sole feature-detected fallback (no alias — one
- *   path or the other runs per swap, never both):
- *   1. Capture current container size
+ * - **Fallback path** (no `startViewTransition`): the axis-aware FLIP, KEPT as
+ *   the sole feature-detected fallback (no alias — one path or the other runs per
+ *   swap, never both). It is now the ONLY driver that writes inline size on a
+ *   non-VT engine (AV.W9.0 retired the `interpolate-size`/`calc-size` CSS arm that
+ *   used to second-drive width on Chrome 129+ and freeze the dock):
+ *   1. Capture current container size (or the live spring's pixel value on a
+ *      retarget)
  *   2. Pin container to that size
- *   3. Swap classes: old layer → leaving, new layer → active
- *   4. nextTick: measure new natural size, re-pin to old
- *   5. Animate to new size via CSS transition
- *   6. On transitionend(size), clear inline size
+ *   3. nextTick → rAF: swap classes (old → leaving, new → active) AND measure new
+ *      natural size in ONE frame origin
+ *   4. Drive size off ONE `SpringProgress` clock in PIXEL space (its `value` IS
+ *      the live width/height)
+ *   5. On settle, clear inline size + restore the CSS transition
+ *
+ *   AV.W9.2 — velocity-continuity: an interrupted swap (a re-toggle while the
+ *   spring is still live) RE-SEATS the existing solver's target from its current
+ *   `(value, velocity)` instead of dispose+reconstruct-from-rest, so the morph is
+ *   continuous through a retarget (the iOS interruptible-spring contract).
+ *
+ * AV.W7 perf folds:
+ *   - F3 — on-demand `will-change`: the morphing box gets `will-change:<dim>`
+ *     ONLY for the gesture's duration (set just before the spring drives it,
+ *     cleared to `auto` on settle/`transitionend`). NEVER a standing hint — a
+ *     permanent `will-change` holds a compositor layer + VRAM for an idle dock.
+ *   - F5 — inheritance-bomb guard (CONVENTION): this driver animates ONLY the
+ *     element's own `width`/`height` (the spring's pixel-space `value`) and the
+ *     pane opacity rides a class-driven CSS transition on the SEPARATE
+ *     `.dock-layer-item-host`. NO INHERITED custom property (`--phase-color` /
+ *     `--shadow-color`) is TWEENED per frame here — animating an inherited
+ *     custom property forces a whole-subtree style recalc every frame (the
+ *     inheritance bomb). Phase/shadow colors are SET on a discrete state change,
+ *     never interpolated frame-by-frame. Keep new motion on `transform`/`opacity`
+ *     /`width`/`height`; route any color shift through a discrete class swap.
  */
 export declare function useLayerTransition(options: UseLayerTransitionOptions): UseLayerTransitionReturn;

package/dist/components/custom/dock/index.d.ts

@@ -2,6 +2,7 @@ export { default as GlassDock } from "./GlassDock.vue";
 export { default as DockLayerGroup } from "./DockLayerGroup.vue";
 export { default as DockLayer } from "./DockLayer.vue";
 export { default as DockIconButton } from "./DockIconButton.vue";
+export { default as DockBackgroundToggle } from "./DockBackgroundToggle.vue";
 export { default as DockTabButton } from "./DockTabButton.vue";
 export { default as DockSelectTrigger } from "./DockSelectTrigger.vue";
 export { default as DockDropdownTrigger } from "./DockDropdownTrigger.vue";

package/dist/components/custom/expandable-container/ExpandableContainer.vue.d.ts

@@ -2,6 +2,10 @@ declare const _default: typeof __VLS_export;
 export default _default;
 declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
     buttonPosition?: "left" | "right";
+    /** Accessible name for the expand (fullscreen) button. */
+    expandLabel?: string;
+    /** Accessible name for the collapse (exit fullscreen) button. */
+    collapseLabel?: string;
 } & {
     /**
      * Two-way `open` model so consumers can drive fullscreen externally
@@ -13,6 +17,10 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
     "update:open": (value: boolean) => any;
 }, string, import("vue").PublicProps, Readonly<{
     buttonPosition?: "left" | "right";
+    /** Accessible name for the expand (fullscreen) button. */
+    expandLabel?: string;
+    /** Accessible name for the collapse (exit fullscreen) button. */
+    collapseLabel?: string;
 } & {
     /**
      * Two-way `open` model so consumers can drive fullscreen externally
@@ -24,6 +32,8 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
     "onUpdate:open"?: ((value: boolean) => any) | undefined;
 }>, {
     buttonPosition: "left" | "right";
+    expandLabel: string;
+    collapseLabel: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
     default?: (props: {
         fullscreen: boolean;

package/dist/components/custom/glass-panel/GlassPanel.vue.d.ts

@@ -26,8 +26,8 @@ type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_1) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<GlassPanelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<GlassPanelProps> & Readonly<{}>, {
-    blur: number;
     variant: GlassPanelVariant;
+    blur: number;
     refraction: number;
     chromaticAberration: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/components/custom/glyph-face/keys.d.ts

@@ -1,35 +1,9 @@
-import { type InjectionKey, type Ref } from "vue";
-/**
- * Silhouette injection slot used by `<GlyphFace>` to receive a silhouette
- * path from a descendant such as `<DiscoGlyph>`. The descendant writes
- * the path on mount (and on subsequent silhouette changes); the wrapping
- * `<GlyphFace>` reads it as a fallback when no `silhouette` prop resolves
- * — closes the disco-glyph cap-clip path without consumer-side prop plumb.
- *
- * P.W2 Lane C — canonical typed-key + helper-pair DI shape per invariant 25.
- *
- * Naming: `GLYPH_FACE_SILHOUETTE_KEY` (UPPER_SNAKE_CASE) matches every other
- * typed key at HEAD (`DOCK_CONTEXT_KEY`, `DOCK_LAYER_GROUP_KEY`,
- * `TOGGLE_GROUP_KEY`, `CONFIGURATOR_DENSITY_KEY`, `SORTABLE_CONTEXT`). The
- * pre-P.W2 PascalCase variant was a convention outlier;
- * renamed clean per P invariant 5 (no legacy aliases). Only callers live
- * inside glass-ui (GlyphFace.vue + DiscoGlyph.vue + this barrel).
- *
- * Paired helpers (optional-only by intent per Pδ §2.2):
- *  - `provideGlyphFaceSilhouette(slot)` — provider wrapper.
- *  - `useOptionalGlyphFaceSilhouette()` — befitting silent default for
- *    `<DiscoGlyph>`, which stands alone OR cooperates with a wrapping
- *    `<GlyphFace>` when present.
- *
- * NO strict counterpart is shipped — silent absence is the design intent;
- * `<DiscoGlyph>` rendering outside `<GlyphFace>` is a first-class use case,
- * not an error condition.
- */
-export declare const GLYPH_FACE_SILHOUETTE_KEY: InjectionKey<Ref<string | undefined>>;
+import type { Ref } from "vue";
+export declare const GLYPH_FACE_SILHOUETTE_KEY: import("vue").InjectionKey<Ref<string | undefined, string | undefined>>;
 export declare function provideGlyphFaceSilhouette(slot: Ref<string | undefined>): void;
 /**
  * Befitting silent default — returns `null` when no parent `<GlyphFace>`
  * is present. `<DiscoGlyph>` cooperates with a wrapping `<GlyphFace>` when
  * the slot is available; otherwise stands alone.
  */
-export declare function useOptionalGlyphFaceSilhouette(): Ref<string | undefined> | null;
+export declare const useOptionalGlyphFaceSilhouette: () => Ref<string | undefined, string | undefined> | null;

package/dist/components/custom/goo-blob/GooBlob.vue.d.ts

@@ -0,0 +1,48 @@
+import type { ColorResolver } from "../../../composables/color";
+import type { BlobMood, BlobConfig } from "./types";
+/**
+ * GooBlob — a gooey metaball creature on a WebGL2 canvas.
+ *
+ * Renders a pulsing SDF body with orbiting satellites that periodically merge in,
+ * get absorbed, then re-emerge. Mood, pointer-attraction and a deterministic
+ * satellite system drive the motion. The renderer composes the `useWebGLCanvas`
+ * substrate — it never bootstraps its own context.
+ *
+ * Color is resolved through an INJECTED `colorResolver` seam (DEC-AT-2): the blob
+ * paints the GAMMA-sRGB triple it returns. The prop is REQUIRED — pass
+ * `defaultBlobColorResolver` from `@mkbabb/glass-ui/color` (or your own) so a
+ * `lab()`/`oklch()`/`hsl()`/hex string resolves correctly. A missing resolver
+ * throws (the loud failure, not a silent gray).
+ *
+ * Config is resolved with the SAME loud discipline as the resolver: either
+ * `provide(BLOB_CONFIG_KEY, cfg)` from an ancestor OR pass an explicit `config`
+ * prop. A mount with NEITHER throws — there is no silent reactive-defaults
+ * synthesis. A consumer that genuinely wants the stock tuning passes
+ * `BLOB_CONFIG_DEFAULTS` explicitly.
+ */
+type __VLS_Props = {
+    /** Base CSS color string (any form the `colorResolver` understands). */
+    color: string;
+    /** REQUIRED color seam — resolves `color` to a gamma-sRGB [r,g,b] triple in [0,1]. */
+    colorResolver: ColorResolver;
+    /**
+     * REQUIRED unless an ancestor `provide(BLOB_CONFIG_KEY, …)` supplies it.
+     * The metaball tuning. Pass `BLOB_CONFIG_DEFAULTS` for the stock look.
+     */
+    config?: BlobConfig;
+    /** Extra seed string mixed into the satellite PRNG for a unique-but-reproducible system. */
+    seed?: string;
+};
+declare function nudge(): void;
+declare function setMood(m: BlobMood): void;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
+    nudge: typeof nudge;
+    setMood: typeof setMood;
+    currentMood: Readonly<import("vue").Ref<BlobMood, BlobMood>>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClick?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/custom/goo-blob/composables/easing.d.ts

@@ -0,0 +1,6 @@
+/** Quadratic ease-in-out (the useBlobMood mood cross-fade curve). */
+export declare function easeInOut(t: number): number;
+/** Quadratic ease-in (the satellite spawn ramp). */
+export declare function easeIn(t: number): number;
+/** Quadratic ease-out (the satellite retract ramp). */
+export declare function easeOut(t: number): number;

package/dist/components/custom/goo-blob/composables/useBlobMood.d.ts

@@ -0,0 +1,14 @@
+import { type Ref } from "vue";
+import type { BlobMood, MoodParams } from "../types";
+/**
+ * Animates the blob's mood parameters — a cross-fade between named mood targets
+ * driven per frame by `tick(dt)`. `setMood` retargets; `params` is the eased
+ * current value the renderer reads.
+ */
+export declare function useBlobMood(): {
+    currentMood: Readonly<Ref<BlobMood>>;
+    params: Readonly<Ref<MoodParams>>;
+    setMood: (mood: BlobMood) => void;
+    tick: (dt: number) => void;
+};
+export type BlobMoodSystem = ReturnType<typeof useBlobMood>;

package/dist/components/custom/goo-blob/composables/useBlobPointer.d.ts

@@ -0,0 +1,18 @@
+import { type Ref } from "vue";
+/**
+ * Tracks the pointer over a host element, normalised to [-1, 1] relative to the
+ * element centre, and smooths it per frame via `tick()`. On pointer-leave the
+ * smoothed position decays back toward centre.
+ */
+export declare function useBlobPointer(el: Ref<HTMLElement | null>): {
+    pointer: Readonly<Ref<{
+        readonly x: number;
+        readonly y: number;
+    }, {
+        readonly x: number;
+        readonly y: number;
+    }>>;
+    active: Readonly<Ref<boolean, boolean>>;
+    tick: () => void;
+};
+export type BlobPointer = ReturnType<typeof useBlobPointer>;

package/dist/components/custom/goo-blob/composables/useBlobSatellites.d.ts

@@ -0,0 +1,13 @@
+import type { BlobConfig, MetaballSource, MoodParams } from "../types";
+/**
+ * The satellite system — a small pool of orbiting metaball sources that
+ * periodically merge into the body, get absorbed, then re-emerge on a fresh
+ * orbit. Deterministic given `initialColor` (seeds the PRNG); `reseed` rekeys it.
+ */
+export declare function useBlobSatellites(config: BlobConfig, initialColor: string): {
+    sources: MetaballSource[];
+    tick: (now: number, mood: MoodParams) => void;
+    nudge: () => void;
+    reseed: (color: string) => void;
+};
+export type BlobSatelliteSystem = ReturnType<typeof useBlobSatellites>;

package/dist/components/custom/goo-blob/composables/useMetaballRenderer.d.ts

@@ -0,0 +1,42 @@
+import { type Ref } from "vue";
+import type { ColorResolver } from "../../../../composables/color";
+import type { BlobConfig } from "../types";
+import type { BlobMoodSystem } from "./useBlobMood";
+import type { BlobPointer } from "./useBlobPointer";
+import type { BlobSatelliteSystem } from "./useBlobSatellites";
+export interface UseMetaballRendererOptions {
+    canvasRef: Ref<HTMLCanvasElement | null>;
+    color: Ref<string>;
+    mood: BlobMoodSystem;
+    pointer: BlobPointer;
+    satellites: BlobSatelliteSystem;
+    config: BlobConfig;
+    /**
+     * The injected color seam (DEC-AT-2). Resolves a CSS color string to a GAMMA-
+     * sRGB triple in [0,1] fed straight into the shader's base-color uniform — the
+     * faithful AU.W7 lift paints gamma. REQUIRED: a no-resolver mount throws (the
+     * loud failure, not a silent gray) instructing the consumer to pass
+     * `defaultBlobColorResolver` from `@mkbabb/glass-ui/color` (or their own).
+     */
+    colorResolver: ColorResolver;
+}
+/**
+ * The GooBlob WebGL renderer — composes the `useWebGLCanvas` substrate (AU.W6).
+ *
+ * This module owns ONLY the metaball-specific concerns: compiling the shader,
+ * building the quad + uniform cache, and uploading the per-frame uniforms derived
+ * from the mood / pointer / satellite systems and the injected color resolver. The
+ * generic WebGL2 lifecycle — context creation, the suspend/resume model, the
+ * demand-driven rAF loop, the tab-visibility owner, the ResizeObserver, and the
+ * webglcontextlost/restored robustness — lives in the substrate; this renderer
+ * threads its behaviour through the substrate's
+ * `setup`/`frame`/`shouldContinue`/`resize`/`teardown` callbacks. It does NOT call
+ * `getContext("webgl2")` itself (the single-bootstrap contract).
+ *
+ * Colors arrive ALREADY resolved to a gamma-sRGB triple via the injected
+ * `colorResolver`; the value.js 1×1-canvas DOM probe is gone (the seam replaces it).
+ */
+export declare function useMetaballRenderer(options: UseMetaballRendererOptions): {
+    pause: () => void;
+    resume: () => void;
+};

package/dist/components/custom/goo-blob/index.d.ts

@@ -0,0 +1,7 @@
+export { default as GooBlob } from "./GooBlob.vue";
+export type { BlobMood, MoodParams, MetaballSource, BlobConfig, SatellitePhase, SatelliteInternal, } from "./types";
+export { BLOB_CONFIG_DEFAULTS, BLOB_CONFIG_KEY } from "./types";
+export { useBlobMood, type BlobMoodSystem } from "./composables/useBlobMood";
+export { useBlobPointer, type BlobPointer } from "./composables/useBlobPointer";
+export { useBlobSatellites, type BlobSatelliteSystem, } from "./composables/useBlobSatellites";
+export { useMetaballRenderer, type UseMetaballRendererOptions, } from "./composables/useMetaballRenderer";

package/dist/components/custom/goo-blob/shaders/metaball.frag.d.ts

@@ -0,0 +1 @@
+export declare const METABALL_FRAGMENT_SRC: string;

package/dist/components/custom/goo-blob/shaders/metaball.vert.d.ts

@@ -0,0 +1 @@
+export declare const METABALL_VERTEX_SRC = "#version 300 es\n\nin vec2 aPosition;\nout vec2 vUv;\n\nvoid main() {\n    vUv = 0.5 * (aPosition + 1.0);\n    gl_Position = vec4(aPosition, 0.0, 1.0);\n}";

package/dist/components/custom/goo-blob/shaders/oklch-perturb.glsl.d.ts

@@ -0,0 +1 @@
+export declare const METABALL_OKLCH_PERTURB_GLSL = "// Edit #4's gamut step \u2014 hue-preserving inward chroma clamp. If the linear result\n// is out of [0,1], bisect chroma toward 0 (L + h fixed) until in gamut. Preserves\n// hue exactly (only C shrinks). 16 steps resolve C to < 2^-16 of its span.\nbool inGamut(vec3 lin) {\n    return all(greaterThanEqual(lin, vec3(0.0))) && all(lessThanEqual(lin, vec3(1.0)));\n}\nvec3 gamutClampOklch(vec3 lch) {\n    vec3 lin = oklabToLinearSrgb(oklchToOklab(lch));\n    if (inGamut(lin)) return lch;\n    float lo = 0.0;\n    float hi = lch.y;\n    for (int i = 0; i < 16; i++) {\n        float mid = 0.5 * (lo + hi);\n        vec3 test = vec3(lch.x, mid, lch.z);\n        if (inGamut(oklabToLinearSrgb(oklchToOklab(test)))) {\n            lo = mid;\n        } else {\n            hi = mid;\n        }\n    }\n    return vec3(lch.x, lo, lch.z);\n}";

package/dist/components/custom/goo-blob/shaders/sdf-body.glsl.d.ts

@@ -0,0 +1 @@
+export declare const METABALL_SDF_GLSL = "// --- SDF ---\n\nfloat sdCircle(vec2 p, vec2 center, float radius) {\n    return length(p - center) - radius;\n}\n\n// Edit #2 \u2014 Inigo Quilez quadratic polynomial smin (same uSmoothK uniform). The\n// quadratic h*h*k*0.25 form has a cleaner C1 seam than the prior cubic smin.\nfloat smin(float a, float b, float k) {\n    float h = max(k - abs(a - b), 0.0) / k;\n    return min(a, b) - h * h * k * 0.25;\n}";

package/dist/components/custom/goo-blob/shaders/watercolor-edges.glsl.d.ts

@@ -0,0 +1,2 @@
+export declare const METABALL_EDGE_NOISE_PRE_GLSL = "// --- Noise ---\n\nfloat hash21(vec2 p) {\n    vec3 p3 = fract(vec3(p.xyx) * 0.1031);\n    p3 += dot(p3, p3.yzx + 33.33);\n    return fract((p3.x + p3.y) * p3.z);\n}\n\nfloat valueNoise(vec2 p) {\n    vec2 i = floor(p);\n    vec2 f = fract(p);\n    f = f * f * (3.0 - 2.0 * f);\n\n    float a = hash21(i);\n    float b = hash21(i + vec2(1.0, 0.0));\n    float c = hash21(i + vec2(0.0, 1.0));\n    float d = hash21(i + vec2(1.0, 1.0));\n\n    return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);\n}\n\n// Edit #3 \u2014 rotated-octave FBM: a fixed ~0.5 rad 2x2 rotation between octaves\n// breaks the axis-aligned banding the un-rotated lattice noise produces. The\n// rotation CONSTANT is spliced from the shared chunk (AV.W2 \u2014 the one FBM_ROT);\n// the loop below stays blob-local (param octaves + 2.0 lacunarity, per \u00A73a).";
+export declare const METABALL_EDGE_NOISE_POST_GLSL = "float fbm(vec2 p, int octaves) {\n    float value = 0.0;\n    float amp = 0.5;\n    float freq = 1.0;\n    for (int i = 0; i < 4; i++) {\n        if (i >= octaves) break;\n        value += amp * valueNoise(p * freq);\n        p = FBM_ROT * p;\n        freq *= 2.0;\n        amp *= 0.5;\n    }\n    return value;\n}\n";

package/dist/components/custom/goo-blob/types.d.ts

@@ -0,0 +1,77 @@
+import type { InjectionKey } from "vue";
+export type BlobMood = "idle" | "happy" | "curious" | "sleepy" | "excited";
+export interface MoodParams {
+    orbitSpeedScale: number;
+    wobbleScale: number;
+    pulseFreq: number;
+    pulseAmp: number;
+    noiseAmp: number;
+    hueRange: number;
+    satShift: number;
+    brightnessShift: number;
+    smoothK: number;
+    pointerAttraction: number;
+    mergeRate: number;
+}
+export interface MetaballSource {
+    x: number;
+    y: number;
+    radius: number;
+    opacity: number;
+}
+export type SatellitePhase = "orbiting" | "merging" | "absorbed" | "emerging";
+export interface SatelliteInternal {
+    phase: SatellitePhase;
+    phaseStart: number;
+    phaseDuration: number;
+    timeOrigin: number;
+    angularSpeed: number;
+    phaseOffset: number;
+    baseRadiusX: number;
+    baseRadiusY: number;
+    wobbleAmp1: number;
+    wobbleFreq1: number;
+    wobbleAmp2: number;
+    wobbleFreq2: number;
+    pertXAmp: number;
+    pertXFreq: number;
+    pertXPhase: number;
+    pertYAmp: number;
+    pertYFreq: number;
+    pertYPhase: number;
+    startX: number;
+    startY: number;
+    endX: number;
+    endY: number;
+}
+/** Externally tunable blob configuration — all fields concrete, defaults applied via `BLOB_CONFIG_DEFAULTS`. */
+export interface BlobConfig {
+    canvasSize: number;
+    bodyRadius: number;
+    satelliteCount: number;
+    satelliteRadius: number;
+    orbitRadius: number;
+    smoothK: number;
+    noiseAmp: number;
+    noiseFreq: number;
+    noiseSpeed: number;
+    pulseFreq: number;
+    pulseAmp: number;
+    hueRange: number;
+    satShift: number;
+    brightnessShift: number;
+    colorNoiseFreq: number;
+    colorNoiseSpeed: number;
+    pointerAttraction: number;
+    pointerStrength: number;
+    eccentricity: number;
+    orbitSpeedScale: number;
+    wobbleScale: number;
+    mergeRate: number;
+    mergeDuration: number;
+    absorbedDuration: [number, number];
+    emergeDuration: number;
+    orbitDuration: [number, number];
+}
+export declare const BLOB_CONFIG_DEFAULTS: BlobConfig;
+export declare const BLOB_CONFIG_KEY: InjectionKey<BlobConfig>;

package/dist/components/custom/hover-popover/HoverPopover.vue.d.ts

@@ -1,11 +1,33 @@
 import type { HTMLAttributes } from "vue";
+/**
+ * <HoverPopover> — hover-triggered floating label.
+ *
+ * Substrate carry-forward of A5 §10 row 4 — IconTooltip's tooltip register
+ * is too quiet for chassis-tier dock-icon-button consumers (SettingsCog,
+ * ActionCluster). HoverPopover ships a popover-tier substrate (glass +
+ * border + radius) at tooltip cadence: hover-trigger, defer-on-leave
+ * timer, adaptive `side`/`align` that auto-flips off viewport edges.
+ *
+ * Default register: a single line of label text, sized for icon-button
+ * accompaniment (max-width clamps; subtle vertical padding). Pass a
+ * default slot for richer content (kbd hints, secondary lines). The
+ * `content` prop is the convenience path — most consumers want a single
+ * label string.
+ *
+ * Composition rests on reka-ui's HoverCard primitives so the
+ * collision-avoidance + open/close timer machinery come for free; this
+ * component is mostly a tighter substrate + a label-shaped default.
+ *
+ * J.W3.B — `keepDockOpen` extends the primitive with the dock-keep
+ * sink contract. While the popover is open inside a `<GlassDock>`,
+ * the dock's collapse timer is suppressed via the parent-provided
+ * `dockKeepOpen` / `dockRelease` callbacks. No-op outside a dock
+ * context — the inject fallbacks are `null`, so non-dock consumers
+ * pay nothing.
+ */
 type __VLS_Props = {
     /** Convenience: label text. Slot wins if both supplied. */
     content?: string;
-    /** AB.W2 — externally-controlled open state. Two-way bound via
-     *  `v-model:open`. Leave undefined for the default uncontrolled
-     *  cadence (reka-ui drives the open state internally). */
-    open?: boolean;
     /** Side relative to trigger. Defaults `top` (tooltip register). */
     side?: "top" | "right" | "bottom" | "left";
     /** Alignment along the side. Defaults `center`. */
@@ -56,6 +78,23 @@ type __VLS_Props = {
      */
     native?: boolean;
 };
+type __VLS_ModelProps = {
+    /**
+     * AB.W2 — open-state two-way binding via Vue 3.5 `defineModel`.
+     *
+     * `open` is the single source of truth for the dock-keep-open watcher, the
+     * `update:open` surface, and reka-ui's HoverCardRoot `v-model:open`. The
+     * `{ default: false }` preserves the prior `props.open ?? false` uncontrolled
+     * cadence — reka writes the local model ref to drive its internal open state
+     * when no parent `v-model:open` is bound; a parent that binds it controls the
+     * value and receives `update:open` (the debounced signal honoring
+     * `hoverOpenDelay`/`closeDelay`). The prior dual-watch reconciliation
+     * (external `props.open` → internal `isOpen` + internal `isOpen` →
+     * `update:open` emit) is RETIRED — `defineModel` collapses both legs.
+     */
+    "open"?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
 declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {}, __VLS_20: {}, __VLS_22: {}, __VLS_36: {};
 type __VLS_Slots = {} & {
     trigger?: (props: typeof __VLS_1) => any;
@@ -70,17 +109,17 @@ type __VLS_Slots = {} & {
 } & {
     content?: (props: typeof __VLS_36) => any;
 };
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:open": (open: boolean) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
 }>, {
     align: "start" | "center" | "end";
     side: "top" | "right" | "bottom" | "left";
     sideOffset: number;
     closeDelay: number;
-    hoverOpenDelay: number;
     keepDockOpen: boolean;
+    hoverOpenDelay: number;
     native: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist/components/custom/labeled-field/LabeledField.vue.d.ts

@@ -33,6 +33,8 @@ type __VLS_Props = {
 };
 declare var __VLS_7: {
     errorId: string;
+    controlId: string;
+    labelledBy: string;
 }, __VLS_9: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_7) => any;

package/dist/components/custom/labeled-field/LabeledSelect.vue.d.ts

@@ -10,11 +10,11 @@ type __VLS_Props = {
     required?: boolean;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:open": (value: boolean) => any;
     "update:modelValue": (value: string) => any;
+    "update:open": (value: boolean) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:open"?: ((value: boolean) => any) | undefined;
     "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;