@mkbabb/glass-ui 3.7.0 → 3.9.0

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

@@ -1,33 +1,8 @@
 type DockDensity = "compact" | "comfortable" | "spacious" | "audacious";
-type __VLS_Props = {
-    collapseDelay?: number;
-    startCollapsed?: boolean;
+interface DockCommonProps {
     fitContent?: boolean;
     position?: "fixed" | "inline" | "sticky";
     alwaysExpanded?: boolean;
-    /**
-     * Visual/behavioral preset.
-     *   `dock`             — the horizontal floating dock (default).
-     *   `rail`             — the vertical icon rail variant used by
-     *                        app chrome (stadium-pill silhouette,
-     *                        `--glass-bg-wash` plate).
-     *   `instrument-strip` — vertical chassis-strip mode for consumer
-     *                        cockpits composing an instrument-cluster
-     *                        gauge column (the speedtest
-     *                        SurveyResultDock consumer). Drops the
-     *                        rail variant's `--radius-pill` extreme
-     *                        and adopts the `<InstrumentChassis>`
-     *                        family's surface vocabulary
-     *                        (`--radius-card` border-radius,
-     *                        `--glass-bg-chassis` background,
-     *                        `--glass-border-quiet` border,
-     *                        `--glass-shadow-quiet` shadow, plus an
-     *                        engraved-bezel `::before` inner stroke
-     *                        matching `InstrumentChassis::before`).
-     *                        No new tokens — lifts the existing
-     *                        chassis vocabulary. AJ-W1-δ / G-AJ-D7.
-     */
-    variant?: "dock" | "rail" | "instrument-strip";
     /**
      * Corner treatment.
      *   `"pill"`    — the stadium silhouette (default).
@@ -36,9 +11,12 @@ type __VLS_Props = {
      *                 radius (`--dock-card-radius`, default `--radius-3xl`)
      *                 ABOVE 2xl, below pill — does NOT collapse to a stadium.
      *                 Collapsed it returns to a pill; the pill↔card swap
-     *                 morphs on the `--dock-motion-resize` spring. A `@supports
-     *                 (corner-shape: squircle)` enhancement reads better at the
-     *                 large radius (the border-radius arc is the contract).
+     *                 morphs on the `--dock-motion-resize` spring. AX.W56's
+     *                 squircle policy applies `corner-shape:
+     *                 var(--corner-shape-bigdock)` here under `@supports
+     *                 (corner-shape: superellipse(2))` — the big-dock is the ONE
+     *                 surface where the superellipse reads (cards/pills stay
+     *                 round); the border-radius arc is the cross-engine contract.
      *
      * `"pill"`/`"rounded"` previously bound ONLY under the vertical rail
      * variant — on a horizontal dock the prop silently no-op'd. AW.W3b adds
@@ -46,24 +24,11 @@ type __VLS_Props = {
      * so `shape` now paints on a horizontal dock too.
      */
     shape?: "pill" | "rounded" | "card";
-    /**
-     * In-cap arrangement. `"linear"` (default) lays the active layer out as a
-     * linear row/column. `"grid"` makes the active layer a self-wrapping tile
-     * grid (Launchpad/Stage-Manager track symmetry — `auto-fill` columns of
-     * `--dock-tile-min`). ORTHOGONAL to `overflow` (the OVER-cap strategy):
-     * `layout` is the IN-cap arrangement.
-     *
-     * Hard contract: a `layout="grid"` dock is `alwaysExpanded` (a 2D panel
-     * does not read as a collapsible pill, and no width morph means no
-     * per-frame grid reflow). The canonical pairing is
-     * `shape="card" layout="grid"` (the props stay independent — no
-     * auto-implication of `shape`).
-     */
-    layout?: "linear" | "grid";
     /**
      * Layout axis of the dock. `"horizontal"` (default) lays items out
      * left-to-right and animates `width`; `"vertical"` lays items out
-     * top-to-bottom and animates `height`.
+     * top-to-bottom and animates `height`. IGNORED under `variant="rail"` /
+     * `"instrument-strip"` (those force vertical by construction).
      */
     orientation?: "horizontal" | "vertical";
     /**
@@ -80,10 +45,18 @@ type __VLS_Props = {
      * 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`).
+     *   `"wrap"`   — expanded content wraps to multiple rows via CONTENT-DRIVEN
+     *                intrinsic flex-wrap (the `.dock-overflow-wrap` recipe). The
+     *                dock shrink-wraps to content and caps that intrinsic width
+     *                at `max-inline-size: var(--dock-max-inline-size)`, so the row
+     *                reflows to N rows EXACTLY when its intrinsic width exceeds
+     *                the cap — at ANY viewport width — and collapses to one row
+     *                when it fits (no viewport breakpoint). The wrapped multi-row silhouette lifts
+     *                onto the card/floating shadow tier as the dock expands.
+     *                HORIZONTAL-ONLY: a vertical rail grows-to-fit + clamps via
+     *                `--dock-max-block-size` (its own overflow story), so the
+     *                `.dock-overflow-wrap` class is not emitted for a vertical
+     *                orientation.
      *   `"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
@@ -107,16 +80,45 @@ type __VLS_Props = {
      * size the dock relies on.
      */
     containerName?: string;
-};
-declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {};
+}
+interface DockVariantProps extends DockCommonProps {
+    variant?: "dock";
+    /** Idle-collapse delay in ms (default 2000). DOCK-ONLY — a rail never collapses. */
+    collapseDelay?: number;
+    /** Start in the collapsed state (default true). DOCK-ONLY — a rail is always expanded. */
+    startCollapsed?: boolean;
+    /**
+     * In-cap arrangement. `"linear"` (default) lays the active layer out as a
+     * linear row/column. `"grid"` makes the active layer a self-wrapping tile
+     * grid (Launchpad/Stage-Manager track symmetry — `auto-fill` columns of
+     * `--dock-tile-min`). ORTHOGONAL to `overflow` (the OVER-cap strategy):
+     * `layout` is the IN-cap arrangement.
+     *
+     * Hard contract: a `layout="grid"` dock is `alwaysExpanded` (a 2D panel
+     * does not read as a collapsible pill, and no width morph means no
+     * per-frame grid reflow). The canonical pairing is
+     * `shape="card" layout="grid"` (the props stay independent — no
+     * auto-implication of `shape`). DOCK-ONLY — the grid is a horizontal big-dock
+     * arrangement, never a rail's.
+     */
+    layout?: "linear" | "grid";
+}
+interface DockRailProps extends DockCommonProps {
+    variant: "rail" | "instrument-strip";
+}
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {}, __VLS_7: {}, __VLS_14: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_1) => any;
+    persistent?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_3) => any;
+} & {
+    collapsed?: (props: typeof __VLS_5) => any;
 } & {
-    collapsed?: (props: typeof __VLS_3) => any;
+    default?: (props: typeof __VLS_7) => any;
 } & {
-    default?: (props: typeof __VLS_5) => any;
+    collapsed?: (props: typeof __VLS_14) => any;
 };
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+declare const __VLS_base: import("vue").DefineComponent<DockVariantProps | DockRailProps, {
     expanded: import("vue").Ref<boolean, boolean>;
     isPinned: import("vue").Ref<boolean, boolean>;
     isHeld: import("vue").ComputedRef<boolean>;
@@ -125,19 +127,7 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
     collapse: () => void;
     keepOpen: () => void;
     release: () => void;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    position: "fixed" | "inline" | "sticky";
-    overflow: "grow" | "wrap" | "scroll";
-    orientation: "horizontal" | "vertical";
-    variant: "dock" | "rail" | "instrument-strip";
-    density: DockDensity;
-    shape: "pill" | "rounded" | "card";
-    layout: "linear" | "grid";
-    collapseDelay: number;
-    alwaysExpanded: boolean;
-    startCollapsed: boolean;
-    fitContent: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DockVariantProps | DockRailProps> & 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;

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

@@ -1,5 +1,6 @@
 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.
@@ -25,6 +26,12 @@ export type DockOrientation = "horizontal" | "vertical";
 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. */

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

@@ -0,0 +1,57 @@
+import type { Ref } from "vue";
+export interface DockMorphGroupRegistration {
+    /** The container element owning this group's grid-stacked panes. */
+    containerEl: Ref<HTMLElement | null>;
+    /** The group's currently-active pane id (its `v-model:active`). */
+    activeLayer: Ref<string>;
+    /** Layout axis of the group; matches the group's `orientation`. */
+    axis: Ref<"horizontal" | "vertical">;
+}
+export interface DockMorphGroupHandle {
+    /** The active pane id post-swap (the orchestrator mutates it). */
+    currentLayer: Readonly<Ref<string>>;
+    /** The pane id currently fading out, or null. */
+    leavingLayer: Readonly<Ref<string | null>>;
+    /** Detach this group from the orchestrator (on the group's unmount). */
+    release(): void;
+}
+/**
+ * The provided morph seam. A nested `<DockLayerGroup>` injects this and DEFERS
+ * its pane-swap morph to the dock's single orchestrator via `registerGroup`.
+ */
+export interface DockMorphContext {
+    registerGroup(group: DockMorphGroupRegistration): DockMorphGroupHandle;
+}
+export declare const DOCK_MORPH_KEY: import("vue").InjectionKey<DockMorphContext>;
+export declare function provideDockMorphContext(context: DockMorphContext): void;
+/**
+ * Befitting-silent — returns `null` for a `<DockLayerGroup>` rendered outside a
+ * `<GlassDock>` (the standalone self-orchestrate path).
+ */
+export declare const useOptionalDockMorphContext: () => DockMorphContext | null;
+export interface UseDockMorphOrchestratorOptions {
+    /** The `.glass-dock` root that carries the shared scalar + clip aperture. */
+    rootEl: Ref<HTMLElement | null>;
+    /** The outer collapse↔expand container (`.dock-layers`). */
+    outerEl: Ref<HTMLElement | null>;
+    /** The outer active "layer" id — `(expandedState)` projected to a string. */
+    outerActiveLayer: Ref<string>;
+    /** The outer pair morphs the inline axis (a horizontal dock). */
+    outerAxis: Ref<"horizontal" | "vertical">;
+}
+export interface UseDockMorphOrchestratorReturn {
+    /** Provide-able context: a nested `<DockLayerGroup>` registers through it. */
+    context: DockMorphContext;
+    /** The outer pair's post-swap active layer id (call-site parity). */
+    outerCurrentLayer: Readonly<Ref<string>>;
+    /** Defensive settle on a stray `@transitionend` (call-site parity). */
+    onOuterTransitionEnd(e: TransitionEvent): void;
+}
+/**
+ * The ONE morph engine for a dock instance. Owns a single `SpringProgress`;
+ * drives the outer collapse↔expand box AND every nested `<DockLayerGroup>`'s
+ * pane-swap off the one `--dock-morph-t` scalar. Replaces the per-pair
+ * `useLayerTransition` instantiation (W01's single-scalar primitive) with a
+ * single multi-target driver, so a nested dock runs ONE engine, not two.
+ */
+export declare function useDockMorphOrchestrator(options: UseDockMorphOrchestratorOptions): UseDockMorphOrchestratorReturn;

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

@@ -2,6 +2,9 @@ export { useDockState } from "./useDockState";
 export type { UseDockStateOptions, UseDockStateReturn, DockState } from "./useDockState";
 export { useLayerTransition } from "./useLayerTransition";
 export type { UseLayerTransitionOptions, UseLayerTransitionReturn } from "./useLayerTransition";
+export { useDockHold } from "./useDockHold";
+export type { UseDockHoldOptions, UseDockHoldReturn } from "./useDockHold";
 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";
+export { useDockMorphOrchestrator, provideDockMorphContext, useOptionalDockMorphContext, DOCK_MORPH_KEY, type DockMorphContext, type DockMorphGroupRegistration, type DockMorphGroupHandle, type UseDockMorphOrchestratorOptions, type UseDockMorphOrchestratorReturn, } from "./dockMorphContext";

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

@@ -0,0 +1,61 @@
+import type { ComputedRef } from "vue";
+/**
+ * AX.W03 — the host-native dock hold.
+ *
+ * `keepDockOpen` is a FIRST-CLASS, synchronous morph-state input to the dock's
+ * one state machine: while a continuous pointer/touch gesture is live on a
+ * descendant control, the dock holds open (idle-collapse suppressed) and the
+ * dock's `held` edge lights `data-held` on the dock root AND the control for the
+ * thumb-halo intensification.
+ *
+ * Why NATIVE host listeners (not a Vue `@pointerdown` template binding):
+ * reka-ui's `<SliderRoot>` is a FORWARDING component — it renders through a
+ * `CollectionSlot` + `resolveDynamicComponent` (SliderHorizontal/Vertical) +
+ * `forwardRef` chain and binds its OWN cached `onPointerdown`
+ * (`SliderRoot.js → SliderImpl.js`, which calls `setPointerCapture`). A consumer
+ * `@pointerdown` arrives as `$attrs.onPointerdown` and is DROPPED across that
+ * Slot/forwardRef boundary — vue-tsc + units pass, only a real drag catches it
+ * (the canonical binding-verification class, `feedback_glass_ui_binding_*`). A
+ * native `addEventListener` on the RESOLVED host element is immune: the event
+ * always reaches the DOM node the user actually presses. This is the
+ * device-proven fix (AX.W03 §Scope.1/2 — slice-2 F0/F2; ratified host-native
+ * over a reka `dragging`-ref subscription, which reka does not publicly expose
+ * and which would re-introduce the same forwarding fragility).
+ *
+ * The hold is INSTANT-ON (Apple "Building Fluid Interfaces", facet 5): the first
+ * line `keepOpen()` is capture-independent and synchronous, so the halo +
+ * substrate tier-shade light the instant the pointer goes down (under the ~100ms
+ * perception threshold — reads as instant); the spring governs only the settle.
+ *
+ * The release window is window-scoped `pointerup`/`pointercancel`: reka
+ * `setPointerCapture`-retargets the move/up to the captured element, which
+ * bubbles to `window`, so a release anywhere ends the hold. The touch parity
+ * folds onto the SAME single acquire — one owner, one acquire path (no second
+ * hold path, no parallel `touchGate` watch).
+ *
+ * DI: consumes the EXISTING typed `DockContext` via `useOptionalDockContext()`
+ * (the `keepOpen`/`release` pair, O.W2 single-typed-key collapse). A control
+ * rendered OUTSIDE a `<GlassDock>` gets the befitting-silent default (no dock) —
+ * every hook is a no-op, a primitive may legitimately render outside a dock.
+ */
+export interface UseDockHoldOptions {
+    /**
+     * Whether the hold is armed. A reactive getter so a consumer prop
+     * (`keepDockOpen`) can disarm it without re-instantiating the composable.
+     * Defaults to always-armed.
+     */
+    enabled?: () => boolean;
+}
+export interface UseDockHoldReturn {
+    /** `true` whenever the dock observes ≥1 held token (the `data-held` edge). */
+    isHeld: ComputedRef<boolean> | undefined;
+}
+/**
+ * @param resolveHost A getter that resolves the REAL host element to attach the
+ *   native listeners to. Called inside `onMounted` (template refs are populated
+ *   before `onMounted` fires), so a reka forwardRef host (`SliderRoot.$el`) is
+ *   live by then. A getter — not a `Ref` — sidesteps the cross-composable
+ *   `onMounted`-ordering trap (a sibling `onMounted` that populates a ref runs
+ *   AFTER this one).
+ */
+export declare function useDockHold(resolveHost: () => HTMLElement | null, options?: UseDockHoldOptions): UseDockHoldReturn;

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

@@ -2,78 +2,32 @@ 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 */
+    /** The currently active layer id. */
     activeLayer: Ref<string>;
     /**
-     * Animation axis. `"horizontal"` animates `width`; `"vertical"` animates
-     * `height`. Defaults to horizontal when omitted.
+     * Animation axis. `"horizontal"` morphs the inline axis; `"vertical"` morphs
+     * the block axis. Defaults to horizontal when omitted.
      */
     axis?: Ref<"horizontal" | "vertical">;
     /**
-     * AW.W3 — typed directional View-Transitions. Maps a swap `(from, to)` to
-     * the `types` array passed to `startViewTransition`, so
-     * `:active-view-transition-type(<t>)` CSS can author DIRECTION-specific
-     * curves (snappier exit, softer entry-overshoot — the iOS-feel asymmetry).
-     * The outer collapsed↔expanded pair resolves `dock-expand` / `dock-collapse`;
-     * the inner DockLayerGroup pane swap resolves `layer-forward` / `layer-back`.
-     * Omit to run the single symmetric curve. Feature-detected — degrades to the
-     * symmetric curve on an engine without the `types` overload (Firefox 144).
+     * Retained for API parity with the prior VT-typed signature (consumed by
+     * `GlassDock` + `DockLayerGroup`). The single-scalar morph runs ONE symmetric
+     * spring on every engine, so the direction hint is no longer a curve fork — it
+     * is accepted and ignored. Kept so the call sites need no edit.
      */
     directionTypes?: (from: string, to: string) => string[];
 }
 export interface UseLayerTransitionReturn {
-    /** Attach to @transitionend on the container */
+    /** Attach to `@transitionend` on the container (kept for call-site parity). */
     onTransitionEnd(e: TransitionEvent): void;
-    /** The currently active layer id (post-swap) */
+    /** The currently active layer id (post-swap). */
     currentLayer: Ref<string>;
-    /** The layer id currently fading out, or null */
+    /** The layer id currently fading out, or null. */
     leavingLayer: Ref<string | null>;
 }
 /**
- * Coordinates the crossfade + size animation between grid-stacked dock layer
- * panes. Reusable at any nesting level (the inner `<DockLayerGroup>` pair AND
- * the outer GlassDock collapsed↔expanded pair).
- *
- * AQ.W6 §Design 7 — the swap FORKS on View-Transitions support:
- *
- * - **Native path** (`document.startViewTransition` present): the layer swap is
- *   wrapped in `startViewTransition(() => mutate())`. The browser snapshots the
- *   container + panes (tagged `view-transition-name` in `dock.css`) and morphs
- *   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 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. 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.
+ * Coordinates the size morph + crossfade between grid-stacked dock layer panes.
+ * Reusable at any nesting level (the inner `<DockLayerGroup>` pair AND the outer
+ * `GlassDock` collapsed↔expanded pair).
  */
 export declare function useLayerTransition(options: UseLayerTransitionOptions): UseLayerTransitionReturn;

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

@@ -6,5 +6,8 @@ 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";
+export { default as DockSeparator } from "./DockSeparator.vue";
 export type { UseDockStateOptions, UseDockStateReturn, DockState } from "./composables";
-export { DOCK_CONTEXT_KEY, useDockContext, useOptionalDockContext, provideDockContext, type DockContext, type DockOrientation, } from "./composables/dockContext";
+export { useLayerTransition } from "./composables";
+export type { UseLayerTransitionOptions, UseLayerTransitionReturn, } from "./composables";
+export { DOCK_CONTEXT_KEY, useDockContext, useOptionalDockContext, provideDockContext, type DockContext, type DockOrientation, type DockLayout, } from "./composables/dockContext";

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

@@ -32,6 +32,15 @@ type __VLS_Props = {
     config?: BlobConfig;
     /** Extra seed string mixed into the satellite PRNG for a unique-but-reproducible system. */
     seed?: string;
+    /**
+     * AX.W16 — the declarative WCAG-2.2.2 pause seam. `v-model:paused` parks the
+     * render loop (the substrate's `manual` suspend) when `true` and restarts it when
+     * `false`. This is the EXACT shape `<DockBackgroundToggle>` wears — wire its
+     * `@update:paused` to this `v-model` and the blob's animation stops/starts for ALL
+     * users. The imperative `pause()`/`resume()` defineExpose handles bind the SAME
+     * renderer seam (no parallel pause path); the prop owns the default.
+     */
+    paused?: boolean;
 };
 declare function nudge(): void;
 declare function setMood(m: BlobMood): void;
@@ -41,10 +50,14 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
     setMood: typeof setMood;
     pulse: typeof pulse;
     currentMood: Readonly<import("vue").Ref<BlobMood, BlobMood>>;
+    pause: () => void;
+    resume: () => void;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     click: () => any;
+    "update:paused": (value: boolean) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     onClick?: (() => any) | undefined;
+    "onUpdate:paused"?: ((value: boolean) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -9,18 +9,36 @@ export interface MoodInteraction {
     /** ms since the last pointer activity (drives `sleepy` past IDLE_SLEEP_MS). */
     idleMs: number;
 }
+/**
+ * Who is driving a `setMood` retarget (AX.W46 D7). `"auto"` — the autonomic arc
+ * (`update` from the pointer/idle state); `"manual"` — the public expose (an imperative
+ * `setMood` from a consumer / the demo mood pills). A manual retarget arms the
+ * `manualOverride` latch the auto-arc respects.
+ */
+export type MoodSource = "auto" | "manual";
+/** The options bag for `setMood` — the source discriminant (default `"manual"`). */
+export interface SetMoodOptions {
+    /** Who is driving the retarget. Defaults to `"manual"` (the public-expose default). */
+    source?: MoodSource;
+}
 /**
  * Animates the blob's mood parameters — a cross-fade between named mood targets
- * driven per frame by `tick(dt)`. `setMood` retargets; `update(interaction)` wires
- * `setMood` internally from the AW.W10 pointer/idle state (curious on approach,
- * excited on click, sleepy after inactivity); `params` is the eased current value
- * the renderer reads.
+ * driven per frame by `tick(dt)`. `setMood(mood, { source })` retargets (a `"manual"`
+ * source — the default — pins the mood above the auto-arc, AX.W46 D7);
+ * `update(interaction)` drives the AUTONOMIC arc from the AW.W10 pointer/idle state
+ * (curious on approach, excited on click, sleepy after inactivity), always
+ * `source: "auto"`, and early-returns while a manual mood is pinned; `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;
+    setMood: (mood: BlobMood, options?: SetMoodOptions) => void;
     update: (interaction: MoodInteraction) => void;
     tick: (dt: number) => void;
+    /** AX.W16 — the quiescence at-rest predicate the renderer's demand gate reads. */
+    isSettled: () => boolean;
+    /** AX.W16 — wall-ms to the next auto-mood retarget (the wake horizon). */
+    nextAutoMoodMs: () => number;
 };
 export type BlobMoodSystem = ReturnType<typeof useBlobMood>;

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

@@ -55,5 +55,7 @@ export declare function useBlobPointer(el: Ref<HTMLElement | null>): {
     click: (amp: number) => void;
     consumeClick: () => boolean;
     rest: () => void;
+    /** AX.W16 — the quiescence at-rest predicate the renderer's demand gate reads. */
+    isAtRest: () => boolean;
 };
 export type BlobPointer = ReturnType<typeof useBlobPointer>;

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

@@ -9,5 +9,7 @@ export declare function useBlobSatellites(config: BlobConfig, initialColor: stri
     tick: (now: number, mood: MoodParams) => void;
     nudge: () => void;
     reseed: (color: string) => void;
+    isQuiescent: () => boolean;
+    nextEventMs: (now: number) => number;
 };
 export type BlobSatelliteSystem = ReturnType<typeof useBlobSatellites>;

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

@@ -1,22 +1,37 @@
 import { type Ref } from "vue";
 import type { ColorResolver } from "../../../../composables/color";
-import { type BlobConfig } from "../types";
+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>;
+    /** The base color, ALREADY un-wrapped to a CONCRETE string by the SFC (DOM-free). */
     color: Ref<string>;
+    /**
+     * The Fresnel rim color, ALREADY un-wrapped to a CONCRETE string by the SFC
+     * (AX.W16 — the renderer no longer reaches the DOM for the `var()`-cascade read;
+     * the SFC's `resolveTokenColor` leaf does ALL un-wrapping before the renderer sees
+     * it). A `var(--token)` rim arrives here already resolved to `rgb(...)`.
+     */
+    rimColor: Ref<string>;
+    /**
+     * The multi-stop palette, ALREADY un-wrapped to CONCRETE strings by the SFC
+     * (AX.W16). EMPTY falls back to the base color (uStopCount <= 1).
+     */
+    paletteStops: 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
+     * The injected color seam (DEC-AT-2). Resolves a CONCRETE 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).
+     * `defaultBlobColorResolver` from `@mkbabb/glass-ui/color` (or their own). The
+     * renderer is DOM-FREE: it never un-wraps a `var(--token)` — the SFC's
+     * `resolveTokenColor` leaf does that BEFORE handing strings here (inv-K-3 seam).
      */
     colorResolver: ColorResolver;
 }

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

@@ -1,5 +1,5 @@
 export { default as GooBlob } from "./GooBlob.vue";
-export type { BlobMood, BlobMerge, MoodParams, MetaballSource, BlobConfig, SatellitePhase, SatelliteInternal, } from "./types";
+export type { BlobMood, BlobMerge, BlobQuality, 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";

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

@@ -1 +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// IQ 2024 quadratic-polynomial smin, NORMALIZED so k is a blend band in distance\n// units. The k *= 4.0 pre-scale makes the h*h*k*0.25 poly's effective blend width\n// equal to k (the un-normalized form's width was 0.25*k).\nfloat sminQuadratic(float a, float b, float k) {\n    k *= 4.0;\n    float h = max(k - abs(a - b), 0.0) / k;\n    return min(a, b) - h * h * k * 0.25;\n}\n\n// IQ circular smin \u2014 a quarter-circle fillet at the seam (rounder than the\n// quadratic). The k *= 1.0/(1.0-sqrt(0.5)) factor normalizes k to the same\n// blend-band units so the merge axis swaps shape without re-tuning uSmoothK.\nfloat sminCircular(float a, float b, float k) {\n    k *= 1.0 / (1.0 - sqrt(0.5));\n    float h = max(k - abs(a - b), 0.0) / k;\n    return min(a, b) - k * 0.5 * (1.0 + h - sqrt(1.0 - h * (h - 2.0)));\n}\n\n// Config-gated merge dispatch \u2014 uMerge 0 = quadratic, 1 = circular.\nfloat smin(float a, float b, float k) {\n    if (uMerge > 0.5) return sminCircular(a, b, k);\n    return sminQuadratic(a, b, k);\n}";
+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// AX.W15 \u2014 the VALUE+GRADIENT circle: returns vec3(d, dd/dx, dd/dy). The circle\n// gradient is the UNIT radial direction (p - center)/length(p - center) (the\n// eikonal property holds EXACTLY for a circle), guarded at the degenerate centre.\n// This is the keystone of the analytic-gradient smin: carrying the gradient\n// through the scene field DELETES the per-pixel 4-tap normal (4 full sceneDist\n// evals, each running 3-octave FBM + the sat/trail loops).\nvec3 sdgCircle(vec2 p, vec2 center, float radius) {\n    vec2 d = p - center;\n    float len = length(d);\n    vec2 grad = len > 1e-6 ? d / len : vec2(0.0, 1.0);\n    return vec3(len - radius, grad);\n}\n\n// IQ 2024 quadratic-polynomial smin, NORMALIZED so k is a blend band in distance\n// units. The k *= 4.0 pre-scale makes the h*h*k*0.25 poly's effective blend width\n// equal to k (the un-normalized form's width was 0.25*k).\nfloat sminQuadratic(float a, float b, float k) {\n    k *= 4.0;\n    float h = max(k - abs(a - b), 0.0) / k;\n    return min(a, b) - h * h * k * 0.25;\n}\n\n// IQ circular smin \u2014 a quarter-circle fillet at the seam (rounder than the\n// quadratic). The k *= 1.0/(1.0-sqrt(0.5)) factor normalizes k to the same\n// blend-band units so the merge axis swaps shape without re-tuning uSmoothK.\nfloat sminCircular(float a, float b, float k) {\n    k *= 1.0 / (1.0 - sqrt(0.5));\n    float h = max(k - abs(a - b), 0.0) / k;\n    return min(a, b) - k * 0.5 * (1.0 + h - sqrt(1.0 - h * (h - 2.0)));\n}\n\n// Config-gated merge dispatch \u2014 uMerge 0 = quadratic, 1 = circular.\nfloat smin(float a, float b, float k) {\n    if (uMerge > 0.5) return sminCircular(a, b, k);\n    return sminQuadratic(a, b, k);\n}\n\n// AX.W15 \u2014 the VALUE+GRADIENT smin. a/b are vec3(dist, grad.xy); the blended\n// gradient is mix(a.yz, b.yz, w) with the interpolation weight w the distance\n// blend uses (IQ's vec2-smin insight). This propagates the analytic gradient\n// through the merge so the surface normal reads the field gradient DIRECTLY \u2014 no\n// finite-difference tap. The blend weight matches each variant.\nvec3 sminQuadraticG(vec3 a, vec3 b, float k) {\n    k *= 4.0;\n    float h = max(k - abs(a.x - b.x), 0.0) / k;\n    float m = h * h * k * 0.25;\n    // h-weight that selects which surface dominates (0 \u2192 a, 1 \u2192 b).\n    float w = (a.x < b.x) ? 0.5 * h * h : 1.0 - 0.5 * h * h;\n    float dist = min(a.x, b.x) - m;\n    vec2 grad = mix(a.yz, b.yz, w);\n    return vec3(dist, grad);\n}\n\nvec3 sminCircularG(vec3 a, vec3 b, float k) {\n    k *= 1.0 / (1.0 - sqrt(0.5));\n    float h = max(k - abs(a.x - b.x), 0.0) / k;\n    float m = k * 0.5 * (1.0 + h - sqrt(1.0 - h * (h - 2.0)));\n    float w = (a.x < b.x) ? 0.5 * h : 1.0 - 0.5 * h;\n    float dist = min(a.x, b.x) - m;\n    vec2 grad = mix(a.yz, b.yz, w);\n    return vec3(dist, grad);\n}\n\nvec3 sminG(vec3 a, vec3 b, float k) {\n    if (uMerge > 0.5) return sminCircularG(a, b, k);\n    return sminQuadraticG(a, b, k);\n}";

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

@@ -1,2 +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\n// IQ analytic-derivative gradient noise \u2014 value in .x, ANALYTIC gradient\n// (d/dx, d/dy) in .yz, from one eval. The quintic fade has a continuous 2nd\n// derivative so the gradient is smooth (a cubic smoothstep fade would crease it).\n// (Inigo Quilez, https://iquilezles.org/articles/gradientnoise/.)\nvec3 noised(vec2 p) {\n    vec2 i = floor(p);\n    vec2 f = fract(p);\n\n    // Quintic fade + its derivative.\n    vec2 u = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);\n    vec2 du = 30.0 * f * f * (f * (f - 2.0) + 1.0);\n\n    // Per-corner gradient vectors from the hash (centred to [-1, 1]).\n    vec2 ga = -1.0 + 2.0 * vec2(hash21(i + vec2(0.0, 0.0)), hash21(i + vec2(7.3, 0.0)));\n    vec2 gb = -1.0 + 2.0 * vec2(hash21(i + vec2(1.0, 0.0)), hash21(i + vec2(8.3, 0.0)));\n    vec2 gc = -1.0 + 2.0 * vec2(hash21(i + vec2(0.0, 1.0)), hash21(i + vec2(7.3, 1.0)));\n    vec2 gd = -1.0 + 2.0 * vec2(hash21(i + vec2(1.0, 1.0)), hash21(i + vec2(8.3, 1.0)));\n\n    float va = dot(ga, f - vec2(0.0, 0.0));\n    float vb = dot(gb, f - vec2(1.0, 0.0));\n    float vc = dot(gc, f - vec2(0.0, 1.0));\n    float vd = dot(gd, f - vec2(1.0, 1.0));\n\n    // Value, remapped to [0,1] so it drops in for the prior valueNoise.\n    float n = va + u.x * (vb - va) + u.y * (vc - va) + u.x * u.y * (va - vb - vc + vd);\n    float value = 0.5 + 0.5 * n;\n\n    // Analytic gradient (chain rule through the bilinear blend + the fade).\n    vec2 grad =\n        ga + u.x * (gb - ga) + u.y * (gc - ga) + u.x * u.y * (ga - gb - gc + gd) +\n        du * (vec2(u.y, u.x) * (va - vb - vc + vd) + vec2(vb, vc) - va);\n    return vec3(value, 0.5 * grad);\n}\n\n// Rotated-octave FBM over the analytic gradient noise: a fixed ~0.5 rad 2x2\n// rotation between octaves breaks the axis-aligned banding. The rotation CONSTANT\n// is spliced from the shared chunk (AV.W2 \u2014 the one FBM_ROT); the loops below\n// stay 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 * noised(p * freq).x;\n        p = FBM_ROT * p;\n        freq *= 2.0;\n        amp *= 0.5;\n    }\n    return value;\n}\n\n// One domain-warp pass: offset the sample point by a low-frequency FBM of itself\n// (the IQ fbm(p + W*fbm(p)) marbling). warpAmp (uniform-driven) is the warp\n// strength; warpAmp == 0.0 degrades to plain fbm (the pre-warp look).\nfloat fbmWarped(vec2 p, int octaves, float warpAmp) {\n    if (warpAmp <= 0.0) return fbm(p, octaves);\n    vec2 q = vec2(fbm(p + vec2(0.0, 0.0), octaves), fbm(p + vec2(5.2, 1.3), octaves));\n    return fbm(p + warpAmp * (q - 0.5), octaves);\n}\n";
+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\n// IQ analytic-derivative gradient noise \u2014 value in .x, ANALYTIC gradient\n// (d/dx, d/dy) in .yz, from one eval. The quintic fade has a continuous 2nd\n// derivative so the gradient is smooth (a cubic smoothstep fade would crease it).\n// (Inigo Quilez, https://iquilezles.org/articles/gradientnoise/.)\nvec3 noised(vec2 p) {\n    vec2 i = floor(p);\n    vec2 f = fract(p);\n\n    // Quintic fade + its derivative.\n    vec2 u = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);\n    vec2 du = 30.0 * f * f * (f * (f - 2.0) + 1.0);\n\n    // Per-corner gradient vectors from the hash (centred to [-1, 1]).\n    vec2 ga = -1.0 + 2.0 * vec2(hash21(i + vec2(0.0, 0.0)), hash21(i + vec2(7.3, 0.0)));\n    vec2 gb = -1.0 + 2.0 * vec2(hash21(i + vec2(1.0, 0.0)), hash21(i + vec2(8.3, 0.0)));\n    vec2 gc = -1.0 + 2.0 * vec2(hash21(i + vec2(0.0, 1.0)), hash21(i + vec2(7.3, 1.0)));\n    vec2 gd = -1.0 + 2.0 * vec2(hash21(i + vec2(1.0, 1.0)), hash21(i + vec2(8.3, 1.0)));\n\n    float va = dot(ga, f - vec2(0.0, 0.0));\n    float vb = dot(gb, f - vec2(1.0, 0.0));\n    float vc = dot(gc, f - vec2(0.0, 1.0));\n    float vd = dot(gd, f - vec2(1.0, 1.0));\n\n    // Value, remapped to [0,1] so it drops in for the prior valueNoise.\n    float n = va + u.x * (vb - va) + u.y * (vc - va) + u.x * u.y * (va - vb - vc + vd);\n    float value = 0.5 + 0.5 * n;\n\n    // Analytic gradient (chain rule through the bilinear blend + the fade).\n    vec2 grad =\n        ga + u.x * (gb - ga) + u.y * (gc - ga) + u.x * u.y * (ga - gb - gc + gd) +\n        du * (vec2(u.y, u.x) * (va - vb - vc + vd) + vec2(vb, vc) - va);\n    return vec3(value, 0.5 * grad);\n}\n\n// Rotated-octave FBM over the analytic gradient noise: a fixed ~0.5 rad 2x2\n// rotation between octaves breaks the axis-aligned banding. The rotation CONSTANT\n// is spliced from the shared chunk (AV.W2 \u2014 the one FBM_ROT); the loops below\n// stay blob-local (param octaves + the LIQUID lacunarity/persistence, per \u00A73a).";
+export declare const METABALL_EDGE_NOISE_POST_GLSL: string;

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

@@ -2,6 +2,13 @@ import type { InjectionKey } from "vue";
 export type BlobMood = "idle" | "happy" | "curious" | "sleepy" | "excited";
 /** Smin merge variant — `quadratic` (cheap, creased) | `circular` (rounder menisci). */
 export type BlobMerge = "quadratic" | "circular";
+/**
+ * Render-quality axis (AX.W16) — `full` (default) renders the metaball pass at the
+ * clamped DPR; `half` renders the backing store at HALF resolution and lets the
+ * browser bilinear-upsample on composite (~4× fragment savings for weak GPUs — the
+ * blob is the ideal candidate: the soft FBM/AA edge hides the interpolation).
+ */
+export type BlobQuality = "full" | "half";
 export interface MoodParams {
     orbitSpeedScale: number;
     wobbleScale: number;
@@ -55,6 +62,7 @@ export interface BlobConfig {
     satelliteCount: number;
     satelliteRadius: number;
     orbitRadius: number;
+    quality: BlobQuality;
     tempo: number;
     smoothK: number;
     /** Smin merge variant — `quadratic` (default) | `circular` (rounder menisci). */