@mkbabb/glass-ui 0.2.0 → 2.0.0

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

@@ -0,0 +1,40 @@
+import { type ComputedRef, type InjectionKey } from "vue";
+export type DockOrientation = "horizontal" | "vertical";
+/**
+ * Dock context surfaces the dock id + orientation + held-state coordination
+ * to descendants.
+ *
+ * O.W2 — canonical typed-key + helper-pair DI shape per invariant 25.
+ * The 6 prior string-keyed provides (`glassDockContext`, `glassDockId`,
+ * `dockKeepOpen`, `dockRelease`, `dockHeld`, `dockExpanded`) collapse into
+ * the single `DOCK_CONTEXT_KEY` typed `InjectionKey<DockContext>`.
+ * `dockExpanded` is retired (zero downstream consumers per Rδ audit).
+ * `glassDockId` is dedup'd with `context.id`.
+ *
+ * Paired helpers:
+ *  - `useDockContext()` — strict; throws when used outside `<GlassDock>`.
+ *  - `useOptionalDockContext()` — befitting silent default for primitives
+ *    that may render outside a dock (Slider, popovers, …).
+ *
+ * J.W3.B — `registerPopover` / `closeOtherPopovers` retired. Hover-driven
+ * dock popovers compose `<HoverPopover keep-dock-open>` whose open/close
+ * cadence is owned by reka-ui's HoverCard primitives; cooperative
+ * dismissal between sibling popovers is no longer needed (HoverCard's
+ * pointer-leave timer handles the cluster transit case).
+ */
+export interface DockContext {
+    id: string;
+    orientation: ComputedRef<DockOrientation>;
+    /** Acquire a keep-open token; suppresses timer-based collapse. */
+    keepOpen: () => void;
+    /** Release a previously-acquired keep-open token. */
+    release: () => void;
+    /** Reactive `keepOpenCount > 0` flag; descendants reflect via `data-held`. */
+    held: ComputedRef<boolean>;
+}
+export declare const DOCK_CONTEXT_KEY: InjectionKey<DockContext>;
+export declare function provideDockContext(context: DockContext): void;
+/** Strict — throws when used outside `<GlassDock>`. */
+export declare function useDockContext(): DockContext;
+/** Befitting silent default for primitives that may render outside a dock. */
+export declare function useOptionalDockContext(): DockContext | null;

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

@@ -0,0 +1,29 @@
+import { type Component, type InjectionKey, type Ref } from "vue";
+/**
+ * DockLayerGroup context — DI surface for `<DockLayer>` children registering
+ * with their parent `<DockLayerGroup>` for the switcher rail + crossfade
+ * coordination.
+ *
+ * O.W2 Lane A — canonical typed-key + helper-pair DI shape per invariant
+ * 25. Replaces the prior raw `provide("dockLayerGroup", {...})` + duplicated
+ * inline interface in `DockLayer.vue`. The context is distinct from
+ * `DockContext` (a `<DockLayerGroup>` doesn't have to live inside a
+ * `<GlassDock>`) so it gets its own module-local key.
+ */
+export interface DockLayerDescriptor {
+    id: string;
+    label?: string;
+    icon?: Component | string;
+}
+export interface DockLayerGroupContext {
+    register(desc: DockLayerDescriptor): void;
+    unregister(id: string): void;
+    currentLayerId: Ref<string>;
+    leavingLayerId: Ref<string | null>;
+}
+export declare const DOCK_LAYER_GROUP_KEY: InjectionKey<DockLayerGroupContext>;
+export declare function provideDockLayerGroupContext(context: DockLayerGroupContext): void;
+/** Strict — throws when used outside `<DockLayerGroup>`. */
+export declare function useDockLayerGroupContext(): DockLayerGroupContext;
+/** Befitting silent default; reserved for future consumers. */
+export declare function useOptionalDockLayerGroupContext(): DockLayerGroupContext | null;

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

@@ -0,0 +1,7 @@
+export { useDockState } from "./useDockState";
+export type { UseDockStateOptions, UseDockStateReturn, DockState } from "./useDockState";
+export { useLayerTransition } from "./useLayerTransition";
+export type { UseLayerTransitionOptions, UseLayerTransitionReturn } from "./useLayerTransition";
+export { isTeleportedTarget } from "./isTeleportedTarget";
+export { provideDockContext, useDockContext, useOptionalDockContext, DOCK_CONTEXT_KEY, type DockContext, type DockOrientation, } from "./dockContext";
+export { provideDockLayerGroupContext, useDockLayerGroupContext, useOptionalDockLayerGroupContext, DOCK_LAYER_GROUP_KEY, type DockLayerDescriptor, type DockLayerGroupContext, } from "./dockLayerContext";

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

@@ -0,0 +1,9 @@
+/**
+ * Detect whether a DOM target is inside a dock-owned teleported overlay.
+ *
+ * Dock-owned popovers/selects/menus mark their teleported content with
+ * `data-glass-dock-portal` and `data-glass-dock-owner`. That keeps click-away
+ * logic scoped to the owning dock instead of depending on Reka internals,
+ * ARIA roles, or broad class names.
+ */
+export declare function isTeleportedTarget(target: EventTarget | null, ownerId?: string): boolean;

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

@@ -0,0 +1,70 @@
+import type { ComputedRef, Ref } from "vue";
+export interface UseDockStateOptions {
+    /** Delay before auto-collapse after mouse leaves (ms) */
+    collapseDelay?: number;
+    /** Root element ref — used for contains() checks */
+    rootEl: Ref<HTMLElement | null>;
+    /** Disable collapse behavior and keep the dock expanded. */
+    alwaysExpanded?: Ref<boolean> | boolean;
+    /** Ref that suppresses click-away during an active dock animation. */
+    isTransitioning?: Ref<boolean>;
+    /** Owner id for dock-owned teleported targets. */
+    dockId?: string;
+    /** Called on every state transition */
+    onStateChange?: (newState: DockState, oldState: DockState) => void;
+}
+export type DockState = "collapsed" | "hover" | "pinned";
+/**
+ * Canonical return shape for `useDockState`. Named per the O.W6 Lane A
+ * `UseClipboardReturn` precedent + P.W2 Lane D (Pγ.3 "useDockState inline
+ * return"); freezes today's surface so consumers wrapping `<GlassDock>` (or
+ * authoring a custom dock chassis) can type the composable handle from `/api`
+ * or the `/dock` subpath without reaching for `ReturnType<typeof useDockState>`.
+ */
+export interface UseDockStateReturn {
+    /** Three-state machine: `"collapsed" | "hover" | "pinned"`. */
+    state: Ref<DockState>;
+    /** `true` whenever `state !== "collapsed"` — derived ref. */
+    expanded: Ref<boolean>;
+    /** `true` whenever `state === "pinned"` — derived ref. */
+    isPinned: Ref<boolean>;
+    /** `true` whenever at least one child token holds the dock open via `keepOpen`. */
+    isHeld: ComputedRef<boolean>;
+    /** Mouseenter handler — transitions `collapsed → hover`. */
+    onMouseEnter: () => void;
+    /** Mouseleave handler — schedules `hover → collapsed` after `collapseDelay`. */
+    onMouseLeave: (e?: MouseEvent) => void;
+    /** Focusin handler — transitions `collapsed → hover` (keyboard parity with mouse). */
+    onFocusIn: () => void;
+    /** Focusout handler — schedules `hover → collapsed` when focus leaves the dock. */
+    onFocusOut: (e: FocusEvent) => void;
+    /** Click handler on the collapsed layer — transitions to `pinned`. */
+    onClickCollapsed: () => void;
+    /** Increment hold ref-count; suppresses timer-based collapse. */
+    keepOpen: () => void;
+    /** Decrement hold ref-count; allows timer-based collapse when count reaches 0. */
+    release: () => void;
+    /** Imperative open — forces `state = "hover"` (no-op when `alwaysExpanded`). */
+    expand: () => void;
+    /** Imperative close — forces `state = "collapsed"` (no-op when `alwaysExpanded`). */
+    collapse: () => void;
+}
+/**
+ * Dock state machine with three states and ref-counted child holds.
+ *
+ * ```
+ * State Machine:
+ *   COLLAPSED ──(mouseenter/focusin)──→ HOVER
+ *   HOVER ──(mouseleave + timeout)──→ COLLAPSED
+ *   HOVER ──(clickCollapsed)──→ PINNED
+ *   PINNED ──(clickOutside)──→ COLLAPSED
+ *   Any ──(alwaysExpanded=true)──→ PINNED
+ *
+ * keepOpen/release ref-counting prevents TIMER-BASED collapse
+ * but NOT explicit click-away dismissal (onPointerDownOutside).
+ *
+ * Teleported targets (reka-ui portals, floating panels, dock popovers)
+ * are treated as "inside the dock" for mouse/focus/click-away purposes.
+ * ```
+ */
+export declare function useDockState(options: UseDockStateOptions): UseDockStateReturn;

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

@@ -0,0 +1,34 @@
+import type { Ref } from "vue";
+export interface UseLayerTransitionOptions {
+    /** The container element that owns the stacked layer panes. */
+    containerEl: Ref<HTMLElement | null>;
+    /** The currently active layer id */
+    activeLayer: Ref<string>;
+    /**
+     * Animation axis. `"horizontal"` animates `width`; `"vertical"` animates
+     * `height`. Defaults to horizontal when omitted.
+     */
+    axis?: Ref<"horizontal" | "vertical">;
+}
+export interface UseLayerTransitionReturn {
+    /** Attach to @transitionend on the container */
+    onTransitionEnd(e: TransitionEvent): void;
+    /** The currently active layer id (post-swap) */
+    currentLayer: Ref<string>;
+    /** The layer id currently fading out, or null */
+    leavingLayer: Ref<string | null>;
+}
+/**
+ * Coordinates simultaneous crossfade + FLIP size animation for
+ * grid-stacked layer containers. Reusable at any nesting level.
+ *
+ * Algorithm on activeLayer change:
+ * 1. Capture current container size
+ * 2. Pin container to that size
+ * 3. Swap classes: old layer → leaving (absolute, fading out),
+ *    new layer → active (relative, fading in)
+ * 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
+ */
+export declare function useLayerTransition(options: UseLayerTransitionOptions): UseLayerTransitionReturn;

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

@@ -0,0 +1,9 @@
+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 DockTabButton } from "./DockTabButton.vue";
+export { default as DockSelectTrigger } from "./DockSelectTrigger.vue";
+export { default as DockDropdownTrigger } from "./DockDropdownTrigger.vue";
+export type { UseDockStateOptions, UseDockStateReturn, DockState } from "./composables";
+export { DOCK_CONTEXT_KEY, useDockContext, useOptionalDockContext, provideDockContext, type DockContext, type DockOrientation, } from "./composables/dockContext";

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

@@ -0,0 +1,40 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
+    buttonPosition?: "left" | "right";
+} & {
+    /**
+     * Two-way `open` model so consumers can drive fullscreen externally
+     * (programmatic toggles, route-driven launches, etc.) while the corner
+     * buttons continue to operate without parent wiring.
+     */
+    open?: boolean;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<{
+    buttonPosition?: "left" | "right";
+} & {
+    /**
+     * Two-way `open` model so consumers can drive fullscreen externally
+     * (programmatic toggles, route-driven launches, etc.) while the corner
+     * buttons continue to operate without parent wiring.
+     */
+    open?: boolean;
+}> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {
+    buttonPosition: "left" | "right";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {
+        fullscreen: boolean;
+    }) => any;
+} & {
+    default?: (props: {
+        fullscreen: boolean;
+    }) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/custom/glass-carousel/GlassCarousel.vue.d.ts

@@ -0,0 +1,36 @@
+import { type HTMLAttributes } from "vue";
+type __VLS_Props = {
+    /** Scroll axis */
+    orientation?: "horizontal" | "vertical";
+    /** Expanded = items spread to fill space; collapsed = compact pill */
+    expanded?: boolean;
+    /** Enable scroll-snap */
+    snap?: boolean | "mandatory" | "proximity";
+    /** Show overflow fade indicators */
+    fadeOverflow?: boolean;
+    class?: HTMLAttributes["class"];
+};
+declare var __VLS_15: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_15) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+    canScrollStart: import("vue").Ref<boolean, boolean>;
+    canScrollEnd: import("vue").Ref<boolean, boolean>;
+    scrollToItem: (index: number) => void;
+    isTransitioning: import("vue").Ref<boolean, boolean>;
+    visualExpanded: import("vue").Ref<boolean, boolean>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    orientation: "horizontal" | "vertical";
+    expanded: boolean;
+    snap: boolean | "mandatory" | "proximity";
+    fadeOverflow: boolean;
+}, {}, {}, {}, 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/custom/glass-carousel/GlassCarouselItem.vue.d.ts

@@ -0,0 +1,28 @@
+import { type HTMLAttributes } from "vue";
+type __VLS_Props = {
+    /** Whether this item is the active/highlighted one */
+    active?: boolean;
+    /** Whether the item grows/shrinks between expanded and collapsed modes */
+    expandable?: boolean;
+    class?: HTMLAttributes["class"];
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (e: MouseEvent) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClick?: ((e: MouseEvent) => any) | undefined;
+}>, {
+    active: boolean;
+    expandable: boolean;
+}, {}, {}, {}, 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/custom/glass-carousel/index.d.ts

@@ -0,0 +1,4 @@
+export { default as GlassCarousel } from "./GlassCarousel.vue";
+export { default as GlassCarouselItem } from "./GlassCarouselItem.vue";
+export { useGlassCarousel } from "./useGlassCarousel";
+export type { UseGlassCarouselOptions } from "./useGlassCarousel";

package/dist/components/custom/glass-carousel/useGlassCarousel.d.ts

@@ -0,0 +1,30 @@
+import { type Ref } from "vue";
+export interface UseGlassCarouselOptions {
+    /** Scroll axis */
+    orientation: Ref<"horizontal" | "vertical">;
+    /** The logical expanded state */
+    expanded: Ref<boolean>;
+    /** The carousel root element ref — dimensions are animated on this element */
+    rootEl: Ref<HTMLElement | null>;
+    /** The scroll viewport element ref (reka-ui ScrollAreaViewport) */
+    viewportEl: Ref<HTMLElement | null>;
+    /** Fade duration in ms before the mode swap (default: 60) */
+    fadeMs?: number;
+}
+/**
+ * Composable for GlassCarousel — manages scroll overflow detection,
+ * expand/collapse transitions (following GlassDock's FLIP pattern),
+ * and item scroll-to behavior.
+ */
+export declare function useGlassCarousel(options: UseGlassCarouselOptions): {
+    canScrollStart: Ref<boolean, boolean>;
+    canScrollEnd: Ref<boolean, boolean>;
+    getOverflowFadeClass: () => "" | "scroll-fade-y" | "scroll-fade-mask" | "scroll-fade-top" | "scroll-fade-bottom";
+    updateOverflow: () => void;
+    scrollToItem: (index: number) => void;
+    visualExpanded: Ref<boolean, boolean>;
+    isTransitioning: Ref<boolean, boolean>;
+    transitionSize: Ref<string | null, string | null>;
+    suppressTransition: Ref<boolean, boolean>;
+    onTransitionEnd: (e: TransitionEvent) => void;
+};

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

@@ -0,0 +1,41 @@
+import { type GlassTier } from "../../../composables/glass/useGlassRenderer";
+/**
+ * Surface-tier vocabulary for the CSS rendering branch. Mirrors the v0.8
+ * five-rung ladder declared in `tokens.css §8` and consumed by the
+ * `.glass-{wash,quiet,resting,floating,overlay}` utility classes.
+ *
+ * v0.8.6 — `default | medium | elevated` retired (per audit U.W0.C-b §21).
+ */
+export type GlassPanelVariant = "wash" | "quiet" | "resting" | "floating" | "overlay";
+export interface GlassPanelProps {
+    /** Force a specific rendering tier */
+    tier?: GlassTier;
+    /** Blur radius (default: 16) */
+    blur?: number;
+    /** Refraction strength 0-1 (default: 0.3) */
+    refraction?: number;
+    /** Chromatic aberration strength 0-1 (default: 0) */
+    chromaticAberration?: boolean;
+    /** Glass surface tier for the CSS rendering branch (v0.8 5-rung ladder). */
+    variant?: GlassPanelVariant;
+    /** Additional classes */
+    class?: string;
+}
+declare var __VLS_1: {};
+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;
+    refraction: number;
+    chromaticAberration: boolean;
+}, {}, {}, {}, 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/custom/glass-panel/index.d.ts

@@ -0,0 +1,2 @@
+export { default as GlassPanel } from "./GlassPanel.vue";
+export type { GlassPanelProps, GlassPanelVariant } from "./GlassPanel.vue";

package/dist/components/custom/glyph-face/GlyphFace.vue.d.ts

@@ -0,0 +1,64 @@
+import type { HTMLAttributes } from "vue";
+/**
+ * <GlyphFace> — phase-tinted lucide wrapper with catch-light cap.
+ *
+ * Three layers compose around any slotted glyph:
+ *   1. backplate — phase-tinted radial gradient (or transparent at idle).
+ *      Reads as the icon "sitting in" something.
+ *   2. slot — the slotted glyph silhouette, unchanged. Stays `currentColor`
+ *      so the glyph reads Vignelli-clean; the disco punch is in the
+ *      backplate + cap layers.
+ *   3. cap — 165° linear-gradient pseudo with `mix-blend-mode: screen`
+ *      (Q.W3 default; consumers may override to `overlay` for the
+ *      metallic-punch substrate). Reads as a single specular hot-spot
+ *      in the upper-left, painted only against the slotted silhouette.
+ *
+ * Q.W3.A.1 inversion: cap clips to silhouette by default. Three resolution
+ * paths populate `--gf-silhouette`:
+ *   - explicit `silhouette` prop on this component (path d-attr or raw
+ *     `clip-path` expression);
+ *   - provide/inject from a `<DiscoGlyph>` descendant — the disco
+ *     primitive publishes its `silhouette` upward via the
+ *     `GLYPH_FACE_SILHOUETTE_KEY` symbol, so wrappers around the four
+ *     speedtest disco icons inherit the silhouette without a
+ *     consumer-side prop plumb;
+ *   - lucide consumers pass the silhouette explicitly via the
+ *     `lucide-silhouettes.ts` table at the speedtest project.
+ *
+ * When no silhouette resolves the cap renders nothing — the fail-safe
+ * is "no cap" not "wrong cap" (closes the wrapper-rectangle leak A1 §1.2
+ * traced to the lucide consumer sites).
+ *
+ * `tint` accepts any CSS color or var (e.g. `var(--phase-color)`); the
+ * backplate's `--gf-tint` custom property reads it. Defaults transparent,
+ * so `<GlyphFace>` without `active` reads as a plain glyph wrapper.
+ */
+type __VLS_Props = {
+    /** Whether the backplate is visible. Defaults `false`. */
+    active?: boolean;
+    /** CSS color/var for the backplate tint. Defaults transparent. */
+    tint?: string;
+    /**
+     * SVG path d-attribute or raw CSS clip-path expression that
+     * masks the cap to a glyph silhouette. When set, the cap clips
+     * to the supplied shape. Takes precedence over silhouette
+     * provided by a descendant DiscoGlyph.
+     */
+    silhouette?: string;
+    class?: HTMLAttributes["class"];
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    active: boolean;
+}, {}, {}, {}, 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/custom/glyph-face/index.d.ts

@@ -0,0 +1,2 @@
+export { default as GlyphFace } from "./GlyphFace.vue";
+export { GLYPH_FACE_SILHOUETTE_KEY, provideGlyphFaceSilhouette, useOptionalGlyphFaceSilhouette, } from "./keys";

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

@@ -0,0 +1,35 @@
+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>>;
+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;

package/dist/components/custom/header-ribbon/HeaderRibbon.vue.d.ts

@@ -0,0 +1,31 @@
+import type { HeaderRibbonProps } from "./types";
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {
+    pinned: boolean;
+    toggled: boolean;
+}, __VLS_7: {};
+type __VLS_Slots = {} & {
+    left?: (props: typeof __VLS_1) => any;
+} & {
+    items?: (props: typeof __VLS_3) => any;
+} & {
+    anchor?: (props: typeof __VLS_5) => any;
+} & {
+    items?: (props: typeof __VLS_7) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<HeaderRibbonProps, {
+    isPinned: import("vue").Ref<boolean, boolean>;
+    isExpanded: import("vue").Ref<boolean, boolean>;
+    isVisible: import("vue").ComputedRef<boolean>;
+    isToggled: import("vue").Ref<boolean, boolean>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<HeaderRibbonProps> & Readonly<{}>, {
+    position: import("./types").HeaderRibbonPosition;
+    hideTimeoutMs: 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/custom/header-ribbon/index.d.ts

@@ -0,0 +1,2 @@
+export { default as HeaderRibbon } from "./HeaderRibbon.vue";
+export type { HeaderRibbonPosition, HeaderRibbonProps } from "./types";

package/dist/components/custom/header-ribbon/types.d.ts

@@ -0,0 +1,7 @@
+export type HeaderRibbonPosition = "left" | "right";
+export interface HeaderRibbonProps {
+    /** Side of the viewport the ribbon anchors against. Defaults to `"left"`. */
+    position?: HeaderRibbonPosition;
+    /** Milliseconds after the pointer leaves the ribbon before items collapse. Defaults to `2000`. */
+    hideTimeoutMs?: number;
+}

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

@@ -0,0 +1,71 @@
+import type { HTMLAttributes } from "vue";
+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`. */
+    align?: "start" | "center" | "end";
+    /**
+     * ms before opening on hover. Defaults 250 — same as IconTooltip's
+     * TooltipProvider cadence so the two read in unison across the
+     * dock cluster. Hover-popover-specific (vs. the generic reka-ui
+     * `open-delay`) so deeper-nested popovers can extend the defer
+     * without colliding with sibling cadence vocabulary.
+     */
+    hoverOpenDelay?: number;
+    /**
+     * ms before closing on hover-leave. The "defer-on-leave" timer
+     * the dispatch packet calls for; ~150ms gives the pointer time
+     * to skim across cluster gaps without flickering.
+     */
+    closeDelay?: number;
+    /** sideOffset in px. Defaults 6 — wider than tooltip's 4. */
+    sideOffset?: number;
+    /** Class merged onto the rendered HoverPopover content element. */
+    class?: HTMLAttributes["class"];
+    /**
+     * J.W3.B — when mounted inside a `<GlassDock>`, hold the parent
+     * dock open while this popover is visible. Hooks the
+     * `dockKeepOpen` / `dockRelease` provide/inject contract and
+     * is a no-op outside a dock context. The dock's collapse timer
+     * is ref-counted so multiple keep-open holds compose cleanly.
+     * Also marks the portaled HoverCard content with
+     * `data-glass-dock-portal` + `data-glass-dock-owner` so the
+     * dock's click-away handler treats clicks inside the popover
+     * as "inside the dock".
+     */
+    keepDockOpen?: boolean;
+};
+declare var __VLS_14: {}, __VLS_16: {}, __VLS_30: {};
+type __VLS_Slots = {} & {
+    trigger?: (props: typeof __VLS_14) => any;
+} & {
+    default?: (props: typeof __VLS_16) => any;
+} & {
+    content?: (props: typeof __VLS_30) => 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;
+}>, {
+    align: "start" | "center" | "end";
+    side: "top" | "right" | "bottom" | "left";
+    sideOffset: number;
+    closeDelay: number;
+    hoverOpenDelay: number;
+    keepDockOpen: boolean;
+}, {}, {}, {}, 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/custom/hover-popover/index.d.ts

@@ -0,0 +1 @@
+export { default as HoverPopover } from "./HoverPopover.vue";

package/dist/components/custom/icon-tooltip/IconTooltip.vue.d.ts

@@ -0,0 +1,16 @@
+type __VLS_Props = {
+    text: string;
+};
+declare var __VLS_20: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_20) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};