@mkbabb/glass-ui 3.6.0 → 3.8.0

package/dist/components/custom/constellation/constellationField.d.ts

@@ -19,16 +19,49 @@ export interface ConstellationPointer {
     x: number;
     y: number;
 }
-/** The neutral palette resolved off the canvas custom properties. */
+/**
+ * The neutral palette + legibility weights resolved off the canvas custom
+ * properties (the FULL `--constellation-*` set — AX.W17). `node`/`nodeDim`/
+ * `line` are the colors; `edgeAlpha`/`edgeFocusAlpha`/`alpha` are the per-mode
+ * legibility multipliers (replacing the `0.17`/`0.24` magic literals).
+ */
 export interface ConstellationPalette {
     node: string;
     nodeDim: string;
     line: string;
+    /** The hairline-edge alpha multiplier (was the `0.17` literal). */
+    edgeAlpha: number;
+    /** The focus-proximity edge multiplier (consumer skins may read it). */
+    edgeFocusAlpha: number;
+    /** The field-yields-to-type translucency knob (the global field dimmer). */
+    alpha: number;
+}
+/**
+ * The per-axis critically-damped warp spring on the focal node (AX.W17). The
+ * focal mark's position is `(x, y)`; `vx`/`vy` its velocity; `targetIdx` the
+ * LIVE node index it chases (re-read each frame so it tracks a DRIFTING target,
+ * not a frozen click-time snapshot). `-1` = no active warp (the focal mark
+ * rides its node's drift directly — the identity-ride at settle).
+ */
+export interface ConstellationWarp {
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    /** The chased node's INDEX (live target), or -1 when inactive. */
+    targetIdx: number;
 }
 /**
  * The field state the component exposes to its `drawOverlay` consumer so a
  * skin can pin itself to a real field node. `k` is the `width / BASE_WIDTH`
  * scale, `dpr` the device-pixel ratio applied by the substrate.
+ *
+ * The focal node (AX.W17) is a FIRST-CLASS library concept: `focalIndex` names
+ * which node is focal (consumer-owned via `warpTo`), and the engine OWNS its
+ * position via the `warp` spring stepped inside `stepField`. A `drawOverlay`
+ * paints the focal mark at `field.warp.{x,y}` (the spring-eased position) —
+ * node-position mutation `drawOverlay` structurally cannot express, resolved by
+ * ONE first-class concept (warp + drift unify; no second parallel hook).
  */
 export interface ConstellationField {
     nodes: ConstellationNode[];
@@ -38,6 +71,14 @@ export interface ConstellationField {
     h: number;
     k: number;
     dpr: number;
+    /**
+     * The designated focal node's INDEX, or `-1` when none is pinned. Re-points
+     * on each `warpTo`; node count is conserved (it is a designation, not a new
+     * node). A `drawOverlay` reads `field.warp.{x,y}` for the spring-eased mark.
+     */
+    focalIndex: number;
+    /** The per-axis warp spring the engine steps inside `stepField` (AX.W17). */
+    warp: ConstellationWarp;
 }
 /**
  * The `<Constellation>` consumer prop surface (the public type a consumer types
@@ -55,26 +96,90 @@ export interface ConstellationProps {
     seed?: number | string;
     /** Steer-toward-cursor + tap ripples. Default true; auto-off under reduced-motion. */
     pointerReactive?: boolean;
+    /**
+     * Click-to-warp (AX.W17): a click warps the focal node to the nearest
+     * drifting node + springs it there. INDEPENDENT of `pointerReactive` (warp
+     * works on a non-ripple lattice). Default false; auto-off under
+     * reduced-motion (the focal mark stays put — the stated PRM policy).
+     */
+    warpOnClick?: boolean;
     class?: string;
     /** The skin seam — paints the consumer's focal mark on the live field. */
     drawOverlay?: (ctx: CanvasRenderingContext2D, field: ConstellationField, now: number) => void;
 }
 export declare const DEFAULT_PALETTE: ConstellationPalette;
-/** Resolve the neutral palette off a canvas's resolved custom properties. */
+/**
+ * Resolve the FULL neutral palette + legibility weights off a canvas's resolved
+ * custom properties (AX.W17). The colors AND the alpha multipliers route through
+ * the same `getComputedStyle` probe, so a dark-mode flip re-resolves BOTH the
+ * `:root`/`.dark` color arms AND the per-mode alpha defaults in one read.
+ */
 export declare function readPalette(canvas: HTMLCanvasElement): ConstellationPalette;
 /**
  * Seed `count` drifting nodes inside `w × h`. `rng` is a `() => number` in
  * `[0, 1)` (the glass-ui `mulberry32`/`Math.random`); a seeded `rng` lays out a
- * reproducible field. No node is pinned — every node drifts (pinning a focal
- * node is consumer skin, not field mechanics).
+ * reproducible field. Every node drifts; a focal node IS pinnable (AX.W17) — the
+ * `field.focalIndex` designation + the engine-owned `warp` spring chase a node,
+ * but the underlying node still drifts (warp re-points an EXISTING node, never
+ * adds one, so node count is conserved).
  */
 export declare function seedField(rng: () => number, count: number, w: number, h: number, speed: number): ConstellationNode[];
 /**
  * Advance the field one step: drift + wall-bounce every node, then (if the
  * pointer is live) lean nodes within reach toward the cursor WITHOUT changing
  * their speed (the slow geometric drift is preserved). `k` is the scale factor.
+ *
+ * `dt` (seconds since the previous frame) advances the focal-node warp spring
+ * via `warpStep` INSIDE this single per-frame call (AX.W17) — NO second rAF,
+ * NO `useSpring`. The warp rides the substrate's ONE parked rAF; a `dt` of `0`
+ * (omitted / first frame) leaves the spring untouched.
+ */
+export declare function stepField(field: ConstellationField, k: number, speed: number, pointer: ConstellationPointer | null, dt?: number): void;
+/**
+ * The nearest DRIFTING node to `(px, py)` in canvas-local px — a linear O(count)
+ * min-d² scan (count 64 default — negligible; matches the O(count²) edge pass).
+ * "Lattice point" = the nearest drifting NODE (the constellation has NO fixed
+ * lattice). `excludeIdx` drops a node from the candidate set (the focal node
+ * excludes ITSELF, so a cursor-on-focal warp no-ops). Returns `-1` if no
+ * eligible node exists (empty field, or only the excluded node).
+ */
+export declare function nearestNode(field: ConstellationField, px: number, py: number, excludeIdx?: number): number;
+/**
+ * Advance the focal-node warp spring one `dt` (seconds). A per-axis 2nd-order
+ * critically-damped integrator over `field.warp.{x,y}` toward the LIVE position
+ * of `field.nodes[field.warp.targetIdx]` — re-read EACH frame, so the spring
+ * CHASES a drifting target and arrives ON it (the identity-ride). No-ops when no
+ * warp is active (`targetIdx < 0`). `dt` is clamped to {@link WARP_DT_CLAMP} so a
+ * tab-throttle / offscreen-park-resume gap cannot teleport the mark.
+ *
+ *   x += v·dt ;  v += (−2ζω·v − ω²·(x − target))·dt
+ *
+ * Reuses the keyframes.js `(response, dampingFraction)` param model
+ * (ω = 2π/response, ζ = dampingFraction) but NOT its rAF — the FORBID-useSpring
+ * contract (a second rAF would defeat the parked-substrate one-path freeze).
+ */
+export declare function warpStep(field: ConstellationField, dt: number): void;
+/**
+ * Point the warp at a node INDEX (the live target-source seam). The focal node
+ * re-points to `idx`; the spring chases `nodes[idx]`'s LIVE position FROM the
+ * focal mark's CURRENT position (`warp.{x,y}`) — a continuous spring-eased path,
+ * never a snap. The component seeds `warp.{x,y}` at field-center on first layout,
+ * so even the first warp springs from a real start point. `idx < 0` clears the
+ * warp (the focal mark is removed). Re-pointing does NOT zero the velocity, so a
+ * mid-flight re-target curves smoothly toward the new node.
+ */
+export declare function setWarpTarget(field: ConstellationField, idx: number): void;
+/**
+ * Warp the focal node to the nearest drifting node to a canvas-LOCAL px point
+ * (the `warpTo(point)` primitive). The DEGENERATE case — the click's UNCONSTRAINED
+ * nearest node is already the current focal (cursor on/closest to the focal mark)
+ * — NO-OPS (returns the current focal; a click on yourself does not re-warp). Any
+ * OTHER click re-points to the nearest node, with the focal EXCLUDED from the
+ * candidate set (you never re-warp to yourself; the next-nearest wins). Returns
+ * the chosen node index, or `-1` when no eligible node exists. The component's
+ * `warpTo(clientX, clientY)` sugar maps client→local px via `toLocal` first.
  */
-export declare function stepField(field: ConstellationField, k: number, speed: number, pointer: ConstellationPointer | null): void;
+export declare function warpTo(field: ConstellationField, px: number, py: number): number;
 /** Pass 1 — hairline edges between any two nodes within `link` px (alpha falls off with distance). */
 export declare function drawEdges(ctx: CanvasRenderingContext2D, field: ConstellationField, link: number, palette: ConstellationPalette): void;
 /** Pass 2 — ambient node dots. */

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

@@ -1,3 +1,3 @@
 export { default as Constellation } from "./Constellation.vue";
-export { seedField, stepField, readPalette, drawEdges, drawNodes, drawPointerWeb, drawRipples, BASE_WIDTH, DEFAULT_PALETTE, } from "./constellationField";
-export type { ConstellationNode, ConstellationRipple, ConstellationPointer, ConstellationPalette, ConstellationField, ConstellationProps, } from "./constellationField";
+export { seedField, stepField, readPalette, drawEdges, drawNodes, drawPointerWeb, drawRipples, nearestNode, warpStep, warpTo, setWarpTarget, BASE_WIDTH, DEFAULT_PALETTE, } from "./constellationField";
+export type { ConstellationNode, ConstellationRipple, ConstellationPointer, ConstellationPalette, ConstellationField, ConstellationWarp, ConstellationProps, } from "./constellationField";

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

@@ -80,10 +80,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

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

@@ -7,4 +7,6 @@ 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 { useLayerTransition } from "./composables";
+export type { UseLayerTransitionOptions, UseLayerTransitionReturn, } from "./composables";
 export { DOCK_CONTEXT_KEY, useDockContext, useOptionalDockContext, provideDockContext, type DockContext, type DockOrientation, } from "./composables/dockContext";

package/dist/components/custom/fourier-field/FourierField.vue.d.ts

@@ -0,0 +1,38 @@
+import { type ColorResolver } from "../../../composables/color";
+/**
+ * FourierField — a Fourier epicycle field on a Canvas2D surface, a sibling
+ * primitive to Aurora and GooBlob. A seeded elliptic spectrum reconstructs a
+ * slow, never-ending closed curve via the inverse DFT; a fading comet trail
+ * chases the curve's head, and (in the `hero` preset) the nested epicycle
+ * circles and arms draw underneath in a harmonious second hue. It composes the
+ * `useCanvas2D` substrate, so it inherits the offscreen / tab-hidden /
+ * reduced-motion freeze for free — no hand-rolled RAF-park.
+ *
+ * Color resolves through the same INJECTED `colorResolver` seam as GooBlob: the
+ * field paints the gamma-sRGB triple it returns. The prop is REQUIRED — pass
+ * `defaultBlobColorResolver` from `@mkbabb/glass-ui/color` so a `var()` /
+ * `light-dark()` token, an `oklch()` / `hsl()` / hex string all resolve. A
+ * `var()` token is first resolved to a concrete `rgb()` against the host's
+ * inherited color-scheme, then re-resolved on a color change AND on a dark-mode
+ * toggle so the field retints with the theme.
+ *
+ * `variant` is the configuration BUNDLE, not a recolour of one curve: `hero`
+ * draws a few big phasors with the epicycles ON and a warm trail feel; `final`
+ * draws a denser elliptic spectrum with the epicycles OFF. One engine, two
+ * presets. The hue itself always comes from the consumer's `color`.
+ */
+type __VLS_Props = {
+    /** Configuration bundle. `hero` = epicycles on, fewer harmonics; `final` = epicycles off, denser. Default `hero`. */
+    variant?: "hero" | "final";
+    /** Base CSS color (any form the resolver understands; a `var()`/`light-dark()` token resolves against the host). */
+    color: string;
+    /** REQUIRED color seam — resolves a concrete color to a gamma-sRGB [r,g,b] triple in [0,1]. */
+    colorResolver: ColorResolver;
+    /** Extra seed mixed into the spectrum PRNG for a unique-but-reproducible curve. Default "". */
+    seed?: string;
+    /** When true, paint ONE static deterministic best-frame and never animate (the capture/export lever). Default false. */
+    freeze?: boolean;
+};
+declare const __VLS_export: 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 _default: typeof __VLS_export;
+export default _default;

package/dist/components/custom/fourier-field/index.d.ts

@@ -0,0 +1,2 @@
+export { default as FourierField } from "./FourierField.vue";
+export { comp, evalFourier, positionsAt, makeEllipticSpectrum, type BasisComponent, type EllipticSpectrumOptions, } from "./math";

package/dist/components/custom/fourier-field/math.d.ts

@@ -0,0 +1,57 @@
+/**
+ * One Fourier phasor. `index` is the integer frequency (a counter-rotating pair
+ * is `+1` and `-1`); `coefficient` is the complex coefficient `[re, im]`;
+ * `amplitude`/`phase` are its polar form (carried for callers that prefer the
+ * polar read — the reconstruction uses the rectangular `coefficient`).
+ */
+export interface BasisComponent {
+    index: number;
+    coefficient: [number, number];
+    amplitude: number;
+    phase: number;
+}
+/**
+ * Build a {@link BasisComponent} from a frequency index and its rectangular
+ * coefficient `(re, im)`, deriving the polar `amplitude`/`phase`.
+ */
+export declare function comp(index: number, re: number, im: number): BasisComponent;
+/**
+ * Sum `c_k * exp(2*pi*i*k*t)` — the curve point at parameter `t`. `maxTerms`
+ * truncates the series (the partial-sum read). Returns the complex value as
+ * `[re, im]` (the curve's `[x, y]` before view-fit).
+ */
+export declare function evalFourier(components: BasisComponent[], t: number, maxTerms?: number): [number, number];
+/**
+ * The epicycle chain at parameter `t`: the running tip of each phasor stacked on
+ * the last, starting at the origin. `positions[0]` is `[0, 0]`; the final entry
+ * is the curve point ({@link evalFourier} at the same `t`). `maxCircles`
+ * truncates the chain (draw fewer arms than the spectrum carries).
+ */
+export declare function positionsAt(components: BasisComponent[], t: number, maxCircles?: number): [number, number][];
+/** Tuning for {@link makeEllipticSpectrum}. */
+export interface EllipticSpectrumOptions {
+    /**
+     * How many smaller higher-order harmonics to layer on top of the dominant
+     * counter-rotating pair (the dominant pair is always present). Default 4.
+     * The `final` preset passes a larger count for a denser, busier curve.
+     */
+    harmonics?: number;
+    /**
+     * Peak magnitude of the higher-order harmonics relative to the dominant
+     * phasor. Smaller keeps the curve a clean, smooth ellipse with a little
+     * character; larger crinkles it. Default ~0.22.
+     */
+    harmonicScale?: number;
+}
+/**
+ * Emit a procedural elliptic spectrum: a DOMINANT counter-rotating pair (index
+ * `+1` and `-1`) of UNEQUAL magnitude — the inequality is what draws a tilted
+ * ellipse rather than a circle — plus a few smaller higher-order harmonics with
+ * random small magnitudes and phases for character. Lower orders carry more
+ * weight (a `1 / order` falloff), so the curve stays large, smooth and
+ * few-big-phasor; the `harmonics` knob lifts it to the denser `final` look.
+ *
+ * Deterministic in `rng`: the same seeded `() => number` yields the same
+ * spectrum, so a frozen frame reproduces exactly.
+ */
+export declare function makeEllipticSpectrum(rng: () => number, opts?: EllipticSpectrumOptions): BasisComponent[];

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

@@ -32,17 +32,32 @@ 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;
+declare function pulse(): void;
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
     nudge: typeof nudge;
     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

@@ -1,14 +1,30 @@
 import { type Ref } from "vue";
 import type { BlobMood, MoodParams } from "../types";
+/** The interaction signals `update` reads to drive the auto-mood arc. */
+export interface MoodInteraction {
+    /** The pointer is over the blob (drives `curious`). */
+    pointerActive: boolean;
+    /** A click landed this frame (drives a one-shot `excited`). */
+    clicked: boolean;
+    /** ms since the last pointer activity (drives `sleepy` past IDLE_SLEEP_MS). */
+    idleMs: number;
+}
 /**
  * Animates the blob's mood parameters — a cross-fade between named mood targets
- * driven per frame by `tick(dt)`. `setMood` retargets; `params` is the eased
- * current value the renderer reads.
+ * 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.
  */
 export declare function useBlobMood(): {
     currentMood: Readonly<Ref<BlobMood>>;
     params: Readonly<Ref<MoodParams>>;
     setMood: (mood: BlobMood) => 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>;