@mkbabb/glass-ui 4.2.0 → 5.0.0

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

@@ -0,0 +1,115 @@
+import { type HTMLAttributes } from 'vue';
+import { type DialogContentProps } from 'reka-ui';
+import { type SpringPreset } from '../../composables/motion/useSpringMount';
+import type { Motion, Placement } from '../_shared/axes';
+import { type Surface } from '../_shared/useSurfaceAxis';
+type __VLS_Props = DialogContentProps & {
+    class?: HTMLAttributes['class'];
+    /** Surface decoration register (BA.W-SURFACE-AXIS) — the SHARED
+     *  {glass·veil·opaque} axis. `glass` (translucent blur, default) renders the
+     *  floating glass tier; `veil` overlays the borderless/rimless text-legibility
+     *  plate; `opaque` sets `--glass-level:0` (the solid-card escape). Replaces the
+     *  retired binary `variant: glass|opaque` (clean break). */
+    surface?: Surface;
+    /**
+     * BI.W-DIALOG-PLACEMENT — the overlay-placement axis (Sheet FOLDED onto Dialog).
+     * `center` (default) is the byte-identical centered modal — the `.glass-reveal`
+     * bloom over the see-through `--glass-bg-dialog` rung. `top|right|bottom|left`
+     * are the edge SIDE-SLIDE (the former `<Sheet side>`): the content fixes to that
+     * viewport edge, spans the cross axis, rounds its INNER corners on the dialog rung,
+     * and slides in via the shared `sheet-animate` CSS register (byte-identical to the
+     * retired Sheet frame-series). N3: a placement != center Dialog is a NON-detented
+     * side sheet — a detented bottom sheet over a LIVE surface stays `<Drawer>` (snap
+     * physics is Drawer's mechanism, never this paint axis).
+     */
+    placement?: Placement;
+    /**
+     * Optional CSS `animation` shorthand forwarded to the portaled scrim
+     * via the `--scrim-animation` typed cascade variable. reka-ui's
+     * `DialogPortal` teleports the `DialogOverlay` outside the consumer's
+     * component subtree, so a scoped `--scrim-animation` declaration on a
+     * parent of `<Dialog>` never reaches the overlay — the publisher owns
+     * the bridge.
+     *
+     * Pass a complete `animation` shorthand (e.g. `"scrim-breath 6s
+     * ease-in-out infinite"`); the rule
+     * `[data-scrim-animation] { animation: var(--scrim-animation, none) }`
+     * in `animations.css` consumes it on the portaled overlay element.
+     * Composes with the default `animate="fade"` enter/exit (distinct
+     * selectors: `[data-state]` keys the fade, `[data-scrim-animation]`
+     * keys the breath — no cascade fight).
+     *
+     * Reduced-motion: the global `@media (prefers-reduced-motion: reduce)`
+     * bracket in `animations.css` retires the breath automatically.
+     *
+     * AJ-W4-δ.
+     */
+    scrimAnimation?: string;
+    /**
+     * BH.W-MOTION-AXIS — the ONE motion-weight axis (the `spring` boolean's clean-break
+     * successor). `full` (default) is the FULL liquid register: the default entrance is
+     * the spring-clocked `.glass-reveal` CSS bloom (byte-identical to HEAD's unset
+     * `spring`); an explicit `springPreset` opts into the JS `useSpringMount` entrance.
+     * `reduced`/`off` opt DOWN — the JS spring entrance unbinds and the `.glass-reveal`
+     * CSS floor stands (the SAME state PRM produces). PRM forces `full → reduced`
+     * regardless (a11y absolute).
+     */
+    motion?: Motion;
+    /**
+     * BH.W-MOTION-AXIS — the JS spring entrance PRESET (the curve choice carved OFF the
+     * retired `spring` boolean; a distinct concern from motion INTENSITY). UNSET (default)
+     * keeps the `.glass-reveal` CSS bloom (byte-identical to HEAD's unset `spring`);
+     * naming one of `'smooth' | 'snappy' | 'bouncy' | 'gentle'` opts into the
+     * `useSpringMount` JS entrance (the W13 iOS spring-physics scale+fade). Ignored when
+     * `motion === "off"` (the CSS floor stands). PRM snaps the spring to target (no-op
+     * transform).
+     */
+    springPreset?: SpringPreset;
+    /**
+     * Render the default top-right close (X) button (default `true`).
+     * Set `false` when the consumer composes its own header / dismiss control
+     * (e.g. a hand-composed access modal) so the built-in X does not
+     * double-up. The default keeps every existing mount byte-identical.
+     */
+    showClose?: boolean;
+    /**
+     * BD.W-OVERLAY-STAGE-COUPLE — the scene-staging enum for the centered modal band.
+     * `none` (default — byte-identical to HEAD) leaves the page untouched; `dim`/
+     * `scale`/`immersive` flip the ONE `--stage-t` scalar 0→1 on open so the page
+     * RECEDES + SCALES behind the dialog (the iOS card-recede) and the scrim deepens.
+     * PRM degrades `scale`/`immersive` → `dim` (no page transform, fold C1·R6).
+     */
+    stage?: 'none' | 'dim' | 'scale' | 'immersive';
+};
+declare var __VLS_19: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_19) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    escapeKeyDown: (event: KeyboardEvent) => any;
+    pointerDownOutside: (event: import("reka-ui").PointerDownOutsideEvent) => any;
+    focusOutside: (event: import("reka-ui").FocusOutsideEvent) => any;
+    interactOutside: (event: import("reka-ui").PointerDownOutsideEvent | import("reka-ui").FocusOutsideEvent) => any;
+    openAutoFocus: (event: Event) => any;
+    closeAutoFocus: (event: Event) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: import("reka-ui").PointerDownOutsideEvent) => any) | undefined;
+    onFocusOutside?: ((event: import("reka-ui").FocusOutsideEvent) => any) | undefined;
+    onInteractOutside?: ((event: import("reka-ui").PointerDownOutsideEvent | import("reka-ui").FocusOutsideEvent) => any) | undefined;
+    onOpenAutoFocus?: ((event: Event) => any) | undefined;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
+}>, {
+    surface: Surface;
+    placement: Placement;
+    showClose: boolean;
+    stage: "none" | "dim" | "scale" | "immersive";
+}, {}, {}, {}, 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/dock/DockBackgroundToggle.vue.d.ts

@@ -0,0 +1,46 @@
+/**
+ * <DockBackgroundToggle> — the WCAG 2.2.2 (Pause, Stop, Hide), Level A pause/play
+ * control for a continuously-running AV background (Aurora / Blob).
+ *
+ * WCAG 2.2.2 is OBLIGATORY for any auto-starting, >5s, non-essential motion and
+ * the control must be available to ALL users — it is NOT gated behind
+ * `prefers-reduced-motion` (which the substrate handles separately via the G1
+ * freeze). This is the USER-driven stop control any user can reach.
+ *
+ * Binding contract (KISS — it binds an EXISTING renderer seam, adds no parallel
+ * pause path): the consumer holds the paused state and wires it to the renderer's
+ * `pause()`/`resume()`. The toggle is a thin `v-model:paused` control over a
+ * `<DockControl>` host (the dock is the natural home for a background control):
+ *
+ * ```vue
+ * <script setup>
+ * const blob = ref<InstanceType<typeof Blob>>();
+ * const paused = ref(false);
+ * watch(paused, (p) => (p ? blob.value?.pause() : blob.value?.resume()));
+ * <\/script>
+ * <DockBackgroundToggle v-model:paused="paused" />
+ * ```
+ *
+ * The control reflects state via `aria-pressed` (pressed ⇒ paused) and swaps the
+ * Pause↔Play glyph + the accessible label, so a screen reader announces both the
+ * action and the current state.
+ */
+type __VLS_Props = {
+    /** Whether the background is currently paused (the controlled state). */
+    paused?: boolean;
+    /** Accessible label when RUNNING (the action: pause). */
+    pauseLabel?: string;
+    /** Accessible label when PAUSED (the action: play/resume). */
+    playLabel?: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:paused": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:paused"?: ((value: boolean) => any) | undefined;
+}>, {
+    paused: boolean;
+    pauseLabel: string;
+    playLabel: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/dock/DockControl.vue.d.ts

@@ -0,0 +1,73 @@
+import { type ButtonHTMLAttributes, type Component, type HTMLAttributes } from "vue";
+/**
+ * <DockControl> — the ONE dock control (BI.W-DOCK-CONTROLS; folds
+ * `DockIconButton` + `DockTabButton` onto a `shape` axis). The dock IS
+ * SegmentedTabs/ToggleGroup wearing chrome (PASS-1 §1 DOCK-D verdict), so the two
+ * control components collapse to ONE with a `shape` discriminant:
+ *
+ *   • `shape="icon"` (DEFAULT) — the fixed-square icon control (the prior
+ *     `DockIconButton`): glass hover, the interruptible spring-press, the
+ *     pointer-anchored specular gleam, the selectable `active` glass-capsule seat.
+ *   • `shape="tab"` — the auto-sized text-tab control (the prior `DockTabButton`):
+ *     the de-red'd glass hover register + the pointer-following gleam.
+ *
+ * ONE FACE, the folded safe-inset. Both shapes read the shared `.glass-capsule`
+ * face (glass/glass-capsule.css): the painted plate insets via the dock-scoped
+ * `--dock-control-safe-inset` fold, while the HIT CELL stays the full
+ * `--dock-control-size` (≥44px on coarse via the density clamp) — hit box ≠ paint
+ * box (A11Y-5's 17×40px defect dies by construction, with W-DOCK-SPINE's L1
+ * `overflow: visible` making the clip structurally absent).
+ *
+ * Role rides the consumer: an `active` control stamps `aria-pressed` (the
+ * AT-selectable semantic) + `data-active` (the CSS hook reading the
+ * `--dock-control-active-bg` "selected reads as glass" tier — never a saturated
+ * brand hue, per W-REGISTER-IOS). A dock built on `useSelectionGroup` threads the
+ * role-per-mode (radio/tab/pressed) at the group level.
+ */
+type __VLS_Props = {
+    /**
+     * The control shape — `icon` (default, fixed-square) or `tab` (auto-sized
+     * text tab). The fold's ONE axis.
+     */
+    shape?: "icon" | "tab";
+    /** Compact icon variant: auto-sized instead of fixed square (icon shape). */
+    compact?: boolean;
+    /**
+     * Selected/toggled state. Stamps `aria-pressed` + `data-active`; the icon
+     * shape composes the `.glass-capsule` selected seat.
+     */
+    active?: boolean;
+    /** Button type (default "button" to prevent form submission). */
+    type?: ButtonHTMLAttributes["type"];
+    /**
+     * Disabled state (the four-state contract). A boundary nav control stays
+     * PRESENT but disabled so the row geometry holds, never DOM-absent.
+     */
+    disabled?: boolean;
+    /** Host tag/component (reka-ui Primitive `as`; default "button"). */
+    as?: string | Component;
+    /** Merge props onto a slotted child instead of rendering a host tag. */
+    asChild?: boolean;
+    class?: HTMLAttributes["class"];
+};
+declare var __VLS_13: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_13) => 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;
+    type: "button" | "reset" | "submit";
+    compact: boolean;
+    disabled: boolean;
+    asChild: boolean;
+    as: string | Component;
+    shape: "icon" | "tab";
+}, {}, {}, {}, 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/dock/DockCrossfade.vue.d.ts

@@ -0,0 +1,50 @@
+import { type DockFaceDescriptor } from "./composables/dockCrossfadeContext";
+/**
+ * <DockCrossfade :active> — the THIN controlled face-swap core (BI.W-DOCK-CROSSFADE,
+ * PASS-1 §2.6 / PASS-4B ruling 3).
+ *
+ * The content layer hosts ONE active face; a switch is a two-child OPACITY OVERLAP on
+ * the per-face `--dock-t` scalar — driven by the ONE dock spring (`useDockSpring`,
+ * velocity-continuous + interruptible), NOT a UA-eased View Transition. G6 CLOSED:
+ * `startViewTransition` is non-interruptible (a hard cut on rapid re-toggle — a direct
+ * violation of the liquid-weight edict) and its snapshot of a live `backdrop-filter`
+ * plate over aurora is unproven (blur ghost / edge pop); the two-child crossfade needs
+ * no VT and stays spring-driven. The reserved box is sized to the PEAK face as a
+ * MEASURE-ONCE `min-block-size` (a running max — NOT a per-swap FLIP). A dissolving
+ * focus-holding face transfers focus to its successor, else the body
+ * (un-inert-before-focus is load-bearing).
+ *
+ * Faces register through the crossfade context (`<DockLayer>` children). Where a rail
+ * exists, `useSelectionGroup` (the switcher run) drives `:active` — the composing
+ * `<DockLayerGroup>` case. The controlled-no-rail 5-pane case (speedtest) consumes this
+ * DIRECTLY: a no-selection face-swap does NOT route through a selection engine (the
+ * roving machine + indicator + selection model are all inert in that mode; don't
+ * abstract them over a case that never selects).
+ */
+type __VLS_Props = {
+    /** The active face id — the caller-owned model (the ONE registry, no shadow state). */
+    active: string;
+    /**
+     * The reserve axis. `block` (default) reserves the peak face HEIGHT; `inline`
+     * reserves the peak WIDTH (a horizontal control run). The opacity crossfade is
+     * axis-agnostic — only the peak reserve axis differs.
+     */
+    reserve?: "block" | "inline";
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+    faces: import("vue").ComputedRef<DockFaceDescriptor[]>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    reserve: "block" | "inline";
+}, {}, {}, {}, 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/dock/DockLayer.vue.d.ts

@@ -0,0 +1,33 @@
+import type { Component } from "vue";
+/**
+ * <DockLayer> — a named content pane (a "face") inside a <DockCrossfade> /
+ * <DockLayerGroup>.
+ *
+ * BI.W-DOCK-CROSSFADE — the FLIP/registration engine is RETIRED. A face now does one
+ * thing: it registers its id + label + icon + host element with the crossfade slot on
+ * mount, renders its content in a `.dock-face` host, and reads its active/leaving state
+ * off the context. The crossfade slot (`<DockCrossfade>`) owns the two-child opacity
+ * overlap, the peak reserve, and the focus-transfer-on-dissolve — this component holds
+ * no spring, no measure, no orphan-focus watch (all folded to the ONE crossfade slot).
+ */
+type __VLS_Props = {
+    /** Stable identifier — referenced by the crossfade's `active` id. */
+    id: string;
+    /** Human-readable label; used for tooltip + the switcher rail glyph. */
+    label?: string;
+    /** Optional icon: a Vue component, or a raw string (rendered as text). */
+    icon?: Component | string;
+};
+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<{}>, {}, {}, {}, {}, 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/dock/DockLayerGroup.vue.d.ts

@@ -0,0 +1,65 @@
+import type { Motion } from "../_shared/axes";
+/**
+ * <DockLayerGroup> — a stack of <DockLayer> faces with an optional Figma-style
+ * switcher rail built from each face's metadata.
+ *
+ * BI.W-DOCK-CROSSFADE — the FLIP/registration engine is RETIRED. The face-swap is now
+ * ONE crossfade slot: this component COMPOSES `<DockCrossfade :active>` (the thin
+ * controlled core — two-child opacity overlap, peak reserve, focus-transfer) and reads
+ * the registered face descriptors off it for the rail.
+ *
+ * BI.W-DOCK-FOLD — the switcher rail is driven by the library's ONE headless selection
+ * engine `useSelectionGroup` (the dock IS SegmentedTabs/ToggleGroup wearing chrome). The
+ * reka `ui/tabs` substrate + its `--reka-tabs-indicator-*` position path are DEFINITION-
+ * ABSENT (retired); the rail is a plain `role="tablist"` of `role="tab"` buttons whose
+ * roving focus (Arrow/Home/End), role-per-mode ARIA, and the ONE traveling-indicator
+ * writer (`useSelectionIndicator`, Safari-identical by construction) come from the engine.
+ * Selecting a tab writes the SAME `activeLayer` the crossfade slot reads — one registry,
+ * no second source of truth.
+ *
+ * Usage:
+ *   <DockLayerGroup v-model:active="layer">
+ *     <DockLayer id="assets" label="Assets" :icon="AssetsIcon">...</DockLayer>
+ *     <DockLayer id="layers" label="Layers" :icon="LayersIcon">...</DockLayer>
+ *   </DockLayerGroup>
+ */
+type __VLS_Props = {
+    /** Layout axis; matches `GlassDock.orientation`. Drives the rail + face axis. */
+    orientation?: "horizontal" | "vertical";
+    /** Render the embedded switcher rail. Hidden when there is 0 or 1 face. */
+    showRail?: boolean;
+    /** Rail placement relative to the face stack. */
+    railPosition?: "start" | "end";
+    /**
+     * BH.W-MOTION-AXIS — the ONE motion-weight axis. `full` (default) arms
+     * pull-to-switch: the switcher-rail indicator is draggable — pull along the rail
+     * axis to the next face chip, the fling-to-nearest on release writes `active`
+     * (`useDragMorph`, consumer #2). `reduced`/`off` opt DOWN to click/keyboard-only
+     * (the roving tabindex + Arrow keys stay). PRM forces `full → reduced`.
+     */
+    motion?: Motion;
+};
+type __VLS_ModelProps = {
+    "active": string;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_14: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_14) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:active": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:active"?: ((value: string) => any) | undefined;
+}>, {
+    showRail: boolean;
+    railPosition: "start" | "end";
+}, {}, {}, {}, 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/dock/DockStack.vue.d.ts

@@ -0,0 +1,73 @@
+import { type Component } from "vue";
+import type { DockStackItem } from "./constants";
+/**
+ * <DockStack> — BI.W-DOCK-ESCAPE. The dock's satellite fan / facet strip, rebuilt as a
+ * TOP-LAYER POPOVER.
+ *
+ * The CORE anchor is a normal in-flow dock control (the popover invoker). Its members FAN
+ * OUT of a native `popover` surface promoted to the TOP LAYER — exempt from ancestor
+ * `overflow`/`clip`/`contain`/`transform`/`filter` BY SPEC. "Chips overlap the dock body"
+ * / "the fan clips at the port end" (UF-C2) are impossible once the surface is in the top
+ * layer: there is nothing to escape from. The dock box stays INVIOLATE — the fan feeds NO
+ * size into the dock's intrinsic box (it is a fixed-positioned top-layer element).
+ *
+ * This REPLACES the retired `.glass-dock-frame` `display:contents` sibling + the
+ * `railProjection.ts` φ²-crossing ring math (PASS-4B ruling 4 — an anchored flex strip
+ * needs no tier math; the fan is a plain anchored flex strip in the popover).
+ *
+ * PLACEMENT is the JS one-shot (`useDockPopover` — a `getBoundingClientRect` on open + a
+ * resize/scroll re-place, viewport-clamped). NO native CSS anchor positioning
+ * (`anchor()`/`position-anchor`/`@position-try` BANKED — the SAF-1 Safari-transform-chain
+ * fence). HOVER-INTENT + light-dismiss + focus-return are wired in the composable.
+ *
+ *   • `mode="stack"` (DEFAULT) — the macOS Dock hover-expand glyph fan: N members, each a
+ *     clear `--glass-bg-floating` glass icon.
+ *   • `mode="facets"` — the context carousel: each member is an ACCENT-tinted context chip
+ *     writing its OWN `--glass-accent` hue (the BB.W-GLASS-ACCENT per-instance
+ *     chromatic-rim axis), the active facet on the selected-as-glass tier.
+ *
+ * ONE REGISTRY (KEPT). The members write the consumer-owned `v-model:selected`; this
+ * primitive owns NO internal selection shadow. The hover `open` is a transient UI state.
+ */
+type __VLS_Props = {
+    /** The stack/facet members — the fan-out contents. */
+    items: readonly DockStackItem[];
+    /**
+     * The render mode. `"stack"` (default) = the macOS hover-expand glyph fan.
+     * `"facets"` = the accent-tinted context carousel (each chip writes its own
+     * `--glass-accent` hue).
+     */
+    mode?: "stack" | "facets";
+    /** The core anchor glyph (the always-visible dock(1) invoker). Default: a layers glyph. */
+    core?: Component;
+    /** The core's accessible label (the stack's name). */
+    coreLabel?: string;
+    /** Members visible in the fan before it overflows the `<FadingScroll>` port. */
+    visibleCount?: number;
+    /** WRAP a >`visibleCount` fan into a second rank instead of scrolling. */
+    wrap?: boolean;
+    /**
+     * Which end of the anchor the fan aligns to (the cross-axis alignment of the
+     * top-layer placement). `"end"` (default) trails the anchor's leading edge.
+     */
+    position?: "start" | "end";
+};
+type __VLS_ModelProps = {
+    "selected"?: string;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (id: string) => any;
+    "update:selected": (value: string | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onSelect?: ((id: string) => any) | undefined;
+    "onUpdate:selected"?: ((value: string | undefined) => any) | undefined;
+}>, {
+    position: "start" | "end";
+    wrap: boolean;
+    mode: "stack" | "facets";
+    visibleCount: number;
+    coreLabel: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/dock/DockTrigger.vue.d.ts

@@ -0,0 +1,27 @@
+import { type HTMLAttributes } from "vue";
+type __VLS_Props = {
+    /** Which overlay this trigger opens. */
+    for?: "select" | "dropdown" | "popover";
+    class?: HTMLAttributes["class"];
+};
+declare var __VLS_8: {}, __VLS_16: {}, __VLS_30: {}, __VLS_39: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+} & {
+    icon?: (props: typeof __VLS_16) => any;
+} & {
+    default?: (props: typeof __VLS_30) => any;
+} & {
+    default?: (props: typeof __VLS_39) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    for: "select" | "dropdown" | "popover";
+}, {}, {}, {}, 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/dock/GlassDock.vue.d.ts

@@ -0,0 +1,33 @@
+import { type DockProps } from "./composables/useDockShellProps";
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {}, __VLS_7: {}, __VLS_9: {};
+type __VLS_Slots = {} & {
+    persistent?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_3) => any;
+} & {
+    collapsed?: (props: typeof __VLS_5) => any;
+} & {
+    search?: (props: typeof __VLS_7) => any;
+} & {
+    'persistent-end'?: (props: typeof __VLS_9) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<DockProps, {
+    expanded: import("vue").Ref<boolean, boolean>;
+    isPinned: import("vue").Ref<boolean, boolean>;
+    isHeld: import("vue").ComputedRef<boolean>;
+    isTransitioning: import("vue").Ref<boolean, boolean>;
+    expand: () => void;
+    collapse: () => void;
+    keepOpen: () => void;
+    release: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DockProps> & Readonly<{}>, {
+    autoLuminance: 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/dock/composables/dockContext.d.ts

@@ -0,0 +1,48 @@
+import type { ComputedRef } from "vue";
+export type DockOrientation = "horizontal" | "vertical";
+export type DockLayout = "linear" | "grid";
+/**
+ * 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 `<Popover trigger="hover" keep-dock-open>` (the
+ * BI.W-OVERLAY-UNION sealed union; the fine-hover branch is reka's
+ * HoverCardRoot). Open/close cadence is owned by reka's hover primitives;
+ * cooperative dismissal between sibling popovers is no longer needed (the
+ * pointer-leave timer handles the cluster transit case).
+ */
+export interface DockContext {
+    id: string;
+    orientation: ComputedRef<DockOrientation>;
+    /**
+     * In-cap arrangement (`linear` row/column vs `grid` tile panel). AX.W45 —
+     * `<DockSeparator>` reads this to paint a full-row section break in a grid dock
+     * (a 1px perpendicular hairline is useless in a 2D tile grid).
+     */
+    layout: ComputedRef<DockLayout>;
+    /** 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: import("vue").InjectionKey<DockContext>;
+export declare function provideDockContext(context: DockContext): void;
+/** Strict — throws when used outside `<GlassDock>`. */
+export declare const useDockContext: () => DockContext;
+/** Befitting silent default for primitives that may render outside a dock. */
+export declare const useOptionalDockContext: () => DockContext | null;

package/dist/components/dock/composables/dockCrossfadeContext.d.ts

@@ -0,0 +1,57 @@
+import type { Component, Ref } from "vue";
+/**
+ * BI.W-DOCK-CROSSFADE — the crossfade face-registration context.
+ *
+ * `<DockCrossfade :active>` provides this; each face host (`<DockLayer>`) registers
+ * its id + label + icon + host element on mount. The crossfade slot owns ONE face
+ * registry — the registration machinery FOLDED here from the retired
+ * `DockLayerGroup` `register`/`unregister` + `useLayerTransition` FLIP (PASS-1 §2.6).
+ * A switcher rail (where one exists — `<DockLayerGroup>`) reads `faces` for its chip
+ * run; the controlled-no-rail 5-pane case (speedtest) consumes `<DockCrossfade>`
+ * DIRECTLY and reads only `activeId`/`leavingId` (no rail, no selection engine).
+ *
+ * The context is DISTINCT from `DockContext` (a `<DockCrossfade>` need not live inside
+ * a `<GlassDock>`) and from `DockMorphContext` (the plate collapse orchestrator) — the
+ * face crossfade is orthogonal to the box morph (the compound: a face-swap DURING a
+ * simultaneous collapse rides two independent scalars — per-face `--dock-t` for the
+ * opacity overlap, the inheriting `--dock-morph-t` for the plate clip). It keeps its
+ * own module-local key (canonical typed-key DI, invariant 25).
+ */
+export interface DockFaceDescriptor {
+    id: string;
+    label?: string;
+    icon?: Component | string;
+}
+export interface DockFaceRegistration extends DockFaceDescriptor {
+    /**
+     * The face host element. The crossfade slot writes the per-face `--dock-t`
+     * opacity scalar here + measures its `scrollHeight` for the peak reserve.
+     */
+    el: HTMLElement;
+}
+export interface DockCrossfadeContext {
+    /** Announce a face host (idempotent per id) — kicks a peak re-measure. */
+    register(reg: DockFaceRegistration): void;
+    /** Retract a face host on unmount — kicks a peak re-measure. */
+    unregister(id: string): void;
+    /**
+     * The active face id (the one shown at rest). Exposed READ-ONLY: a `<DockLayer>`
+     * child reads its active state but never writes the controlled `active` value
+     * (the ONE registry lives on the caller's model).
+     */
+    activeId: Readonly<Ref<string>>;
+    /** The face currently dissolving out, or `null`. READ-ONLY to faces. */
+    leavingId: Readonly<Ref<string | null>>;
+    /**
+     * The registered face descriptors in registration order — the switcher rail's
+     * chip source (a `<DockLayerGroup>` reads this; the controlled-no-rail case
+     * ignores it).
+     */
+    faces: Readonly<Ref<DockFaceDescriptor[]>>;
+}
+export declare const DOCK_CROSSFADE_KEY: import("vue").InjectionKey<DockCrossfadeContext>;
+export declare function provideDockCrossfadeContext(context: DockCrossfadeContext): void;
+/** Strict — throws when used outside `<DockCrossfade>`. */
+export declare const useDockCrossfadeContext: () => DockCrossfadeContext;
+/** Befitting silent default; reserved for future consumers. */
+export declare const useOptionalDockCrossfadeContext: () => DockCrossfadeContext | null;