@mkbabb/glass-ui 3.13.0 → 4.0.1

package/dist/components/custom/icon-chip/index.d.ts

@@ -0,0 +1,2 @@
+export { default as IconChip } from "./IconChip.vue";
+export type { IconChipProps, IconChipIcon, IconChipSection, IconChipTone, } from "./types";

package/dist/components/custom/icon-chip/types.d.ts

@@ -0,0 +1,82 @@
+import type { Component, FunctionalComponent, HTMLAttributes } from "vue";
+/**
+ * Permissive icon type — Vue's `Component` ships across multiple structurally
+ * incompatible shapes (the @lucide/vue v1 functional-component form is one), so
+ * we accept the union a `<component :is>` render expression handles. Mirrors the
+ * `MetricCell` `IconLike` precedent (the AZ `isComponent` allowance).
+ */
+export type IconChipIcon = Component | FunctionalComponent | object;
+/** A 0..12 index into the `--section-color-N` 13-stop ramp. */
+export type IconChipSection = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+/**
+ * A complete token colour for the chip event (e.g. `var(--chart-download)`,
+ * `var(--tier-featured)`) — the MetricCell-`iconColor` reconcile path. NEVER a
+ * demo-local literal hue (ppmycota purple stays out of the library — the chip
+ * `tone` arm takes a token).
+ */
+export type IconChipTone = string;
+export interface IconChipProps {
+    /**
+     * The lucide glyph (functional-component form per the AZ `isComponent`
+     * precedent). Rendered via `<component :is>`.
+     */
+    icon: IconChipIcon;
+    /**
+     * The `--section-color-N` ramp index (0..12) — the section arm. XOR `tone`.
+     * When both are set, `tone` wins (the explicit complete-token override).
+     * Typed `number` for data-driven consumers (a `v-for` over a descriptor list
+     * with a `section: number` field); the 0..12 canonical range is the
+     * `IconChipSection` union the discovery layer publishes.
+     */
+    section?: number;
+    /**
+     * A complete token colour (the tone arm — the MetricCell-`iconColor`
+     * reconcile). XOR `section`.
+     */
+    tone?: IconChipTone;
+    /**
+     * The chip diameter in px — the FLOOR is `glyphSize × --icon-chip-glyph-ratio`
+     * so the plate can never paint under the glyph (the d2 proportion, structural).
+     * Default `48` (the reference register, 48/22 ≈ 2.18).
+     */
+    size?: number;
+    /** The lucide glyph pixel size. Default `22` (the reference register). */
+    glyphSize?: number;
+    /** The lucide glyph stroke width. Default `1.75` (the reference register). */
+    strokeWidth?: number;
+    /**
+     * The NO-PLATE register — render the full-chroma glyph with NO backplate
+     * (the MetricCell leading-glyph tint). The chip≤glyph floor is moot (no plate).
+     */
+    bare?: boolean;
+    /**
+     * Duotone fill — a low-alpha fill of the same hue UNDER the full-chroma
+     * stroke (the iOS/Material "filled-tonal" move). Mono-hue (proportion-safe,
+     * never a second hue). Default `false`.
+     */
+    duotone?: boolean;
+    /**
+     * The chip's own smooth-glass hover register (the backplate mix lifts, a soft
+     * glow ring appears, the stroke firms) — on the §6 easing doctrine (the GROW
+     * rides --spring-smooth, the color cross-fade the bezier), PRM-gated,
+     * disco-FREE. Default `false`.
+     */
+    bloom?: boolean;
+    /**
+     * The louder focal-pop vibrancy axis (BB.W-SUFFUSE3) — re-points the
+     * backplate `color-mix` strength off the 25% reference stop to ~40% (more
+     * chroma) via `--icon-chip-plate-strength`. STILL the ONE color event per
+     * surface (the same event, louder — proof:suffuse d3 counts the event family,
+     * not the saturation); the `in srgb` space + the chip≤glyph ratio are
+     * untouched. Default `false` (byte-identical to the reference register).
+     */
+    saturated?: boolean;
+    /**
+     * Entrance choreography — composes the shipped `vReveal` directive. A numeric
+     * value is the `--d` stagger index; `true` is index 0. PRM-gated by `vReveal`'s
+     * construction. Default `false`.
+     */
+    reveal?: boolean | number;
+    /** Pass-through class on the chip root. */
+    class?: HTMLAttributes["class"];
+}

package/dist/components/custom/instrument-chassis/InstrumentChassis.vue.d.ts

@@ -17,8 +17,21 @@ export type InstrumentChassisPhase = "ready" | "ping" | "download" | "upload" |
  *   architectural underclaim. Consumed at quiet-content App-level
  *   mounts (the inner card paints its own glass tier — the spine is
  *   the housing that frames it).
+ *
+ * - `"structure"` (BA.W-ATLAS-RECONCILE C-3) — the SILVER structure-metal
+ *   register. A cool polished-steel milled-panel read: the engraved bezel +
+ *   the structural grooves re-point to the `--silver` quad (the gold quad's
+ *   cool mirror) instead of the warm-cream `--surface-tint-*` default, so the
+ *   chassis reads as an INDUSTRIAL precision-instrument housing — the cool-metal
+ *   twin of the warm-gold "complete"-phase affirmation the chassis ships by
+ *   DEFAULT (the `--phase-complete-color` consumer token defaults to gold;
+ *   BB.W-PHASE-PALETTE — a consumer may re-ink completion). The phase cascade stays
+ *   orthogonal (a `structure` chassis still retints on `data-phase`); only the
+ *   structure-metal recipe forks. The silver is the W-NO-GRAY named cool-neutral
+ *   exception. Consumer #2 of the silver quad (the atlas's structure surface is
+ *   consumer #1).
  */
-export type InstrumentChassisVariant = "glass" | "spine";
+export type InstrumentChassisVariant = "glass" | "spine" | "structure";
 /**
  * <InstrumentChassis> — single glass surface composing strip / dial / control
  * regions, glued together by twin-line hairline grooves.
@@ -56,7 +69,9 @@ type __VLS_Props = {
      * Surface register. Defaults to `"glass"` (the canonical chassis
      * plate). Pass `"spine"` at App-level mount paths to get the
      * housing register (polished sleeve, no backdrop-filter, interior
-     * vignette + hairline outer stroke).
+     * vignette + hairline outer stroke). Pass `"structure"` for the
+     * silver milled-panel register (cool polished-steel bezel + grooves;
+     * BA.W-ATLAS-RECONCILE C-3).
      */
     variant?: InstrumentChassisVariant;
     class?: HTMLAttributes["class"];

package/dist/components/custom/metric-stack/MetricStack.vue.d.ts

@@ -77,8 +77,8 @@ type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_8) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<MetricStackProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MetricStackProps> & Readonly<{}>, {
-    as: string | Component;
     containerName: string;
+    as: string | Component;
     rows: number;
     register: "audacious" | "result";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/components/custom/pager-dots/PagerDots.vue.d.ts

@@ -0,0 +1,39 @@
+import type { HTMLAttributes } from "vue";
+export interface PagerDotsProps {
+    /** Total dot count (the slide/snap count). */
+    count: number;
+    /** Rail layout axis. Default horizontal. */
+    orientation?: "horizontal" | "vertical";
+    /**
+     * When set, window the rail to `fit` dots centered on the active dot
+     * (the DeckPager dock-gutter overflow generalized). Off (undefined) →
+     * show every dot.
+     */
+    windowFit?: number;
+    /** Encapsulate the rail in the glass pager pill chassis. Default true. */
+    ring?: boolean;
+    /** Accessible name for the rail group. */
+    ariaLabel?: string;
+    /** Additional classes for the rail root. */
+    class?: HTMLAttributes["class"];
+}
+type __VLS_Props = PagerDotsProps;
+type __VLS_ModelProps = {
+    /** v-model:active — the active 0-based index. */
+    "active"?: number;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:active": (value: number) => any;
+} & {
+    select: (index: number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onSelect?: ((index: number) => any) | undefined;
+    "onUpdate:active"?: ((value: number) => any) | undefined;
+}>, {
+    orientation: "horizontal" | "vertical";
+    ariaLabel: string;
+    ring: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/custom/pager-dots/index.d.ts

@@ -0,0 +1,2 @@
+export { default as PagerDots } from "./PagerDots.vue";
+export type { PagerDotsProps } from "./PagerDots.vue";

package/dist/components/custom/spa-view/SpaView.vue.d.ts

@@ -0,0 +1,50 @@
+import type { Component } from "vue";
+export interface SpaViewProps {
+    /**
+     * The active view. Either a component (`<component :is>`) or a string key the
+     * default-slot resolves against. When `view`/`is` is set, SpaView renders the
+     * dynamic component directly; when unset, the default slot is the active view
+     * (the consumer drives `:is` inside the slot themselves).
+     */
+    view?: Component | string;
+    /** Alias of `view` (the `:is` ergonomics — same dynamic-component target). */
+    is?: Component | string;
+    /**
+     * The LRU cap — the max number of cached inactive view instances. Threaded
+     * straight onto `<KeepAlive :max>`; when unset, KeepAlive's default (unbounded)
+     * applies. The visual-load-bearing register: a bounded admin shell sets `:max`
+     * to its tab count so the cache never grows without bound.
+     */
+    max?: number;
+    /** KeepAlive include allowlist (component name / RegExp / array — pass-through). */
+    include?: string | RegExp | (string | RegExp)[];
+    /** KeepAlive exclude denylist (component name / RegExp / array — pass-through). */
+    exclude?: string | RegExp | (string | RegExp)[];
+    /**
+     * The Vue <Transition> recipe name driving the out-in cross-fade. Defaults to
+     * `"fade"` — the shared opacity-only compositor recipe (transitions.css). A
+     * consumer overrides it with another `mode="out-in"`-safe recipe name.
+     */
+    transition?: string;
+    /**
+     * The stable key the transition keys off (a re-render WITHOUT a key change is
+     * not a view swap). Defaults to the resolved `view`/`is` target. A consumer
+     * driving the active view from the default slot supplies its own `:view-key`.
+     */
+    viewKey?: string | number;
+}
+declare var __VLS_19: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_19) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<SpaViewProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SpaViewProps> & Readonly<{}>, {
+    transition: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/custom/spa-view/index.d.ts

@@ -0,0 +1,2 @@
+export { default as SpaView } from "./SpaView.vue";
+export type { SpaViewProps } from "./SpaView.vue";

package/dist/components/custom/tabs/SegmentedTabs.vue.d.ts

@@ -1,5 +1,5 @@
 import { type HTMLAttributes } from "vue";
-/** The canonical tab/option shape — one descriptor across all three variants. */
+/** The canonical tab/option shape — one descriptor across both materials. */
 export interface SegmentedTabOption {
     label: string;
     value: string;
@@ -7,9 +7,13 @@ export interface SegmentedTabOption {
     disabled?: boolean;
     tooltip?: string;
 }
-/** The three indicator chromes. `segmented` (default) = the muted pill-slider;
- *  `pill` = the solid `--foreground` pill; `underline` = the hairline rule. */
-export type SegmentedTabsVariant = "segmented" | "pill" | "underline";
+/** The two materials. `pill` (DEFAULT) = the glass-track slider (absorbs the
+ *  retired `segmented`); `underline` = the paper ink-hairline rule. */
+export type SegmentedTabsVariant = "pill" | "underline";
+/** The orientation axis — `horizontal` (default) lays children in a row + tracks
+ *  the indicator on the inline axis; `vertical` stacks a column + tracks the
+ *  block axis (the vertical underline is the leading-edge ink rail). */
+export type SegmentedTabsOrientation = "horizontal" | "vertical";
 export interface SegmentedTabsResponsive {
     /**
      * CSS length consumed inside `(min-width: <breakpoint>)`. BELOW it the
@@ -30,34 +34,35 @@ export interface SegmentedTabsResponsive {
 export interface SegmentedTabsProps {
     options: SegmentedTabOption[];
     /**
-     * Indicator chrome — `segmented` (DEFAULT, the pill-slider over a muted
-     * track), `pill` (solid foreground pill), `underline` (the hairline rule).
+     * The material — `pill` (DEFAULT, the glass-track slider) or `underline`
+     * (the paper ink-hairline rule).
      */
     variant?: SegmentedTabsVariant;
     /**
-     * Multi-select — when true the surface mutates as a ToggleGroup (N
-     * simultaneous pressed buttons, `role="group"`). Only valid on the
-     * `segmented`/`pill` variants; `underline` is panel-nav (single-select).
+     * Orientation — `horizontal` (default) or `vertical`. Axis-derived on the
+     * one indicator engine.
      */
-    multiSelect?: boolean;
+    orientation?: SegmentedTabsOrientation;
     /**
-     * Tab-row overflow handling.
-     * - `"none"` (default) — inline-grid; tabs share width and clip.
-     * - `"scroll"` — flex row with intrinsic widths + edge fades; never clips.
-     * - `"auto"` — flex row with intrinsic widths + plain horizontal scroll.
+     * Responsive collapse — below the breakpoint the strip becomes a `<Select>`.
+     * `true` uses defaults; an object tunes the breakpoint / desktop subset /
+     * accessible name.
      */
-    overflow?: "none" | "scroll" | "auto";
+    responsive?: boolean | SegmentedTabsResponsive;
     /**
-     * Responsive collapse — below the breakpoint the strip becomes a `<Select>`
-     * (subsumes the former standalone ResponsiveTabs). `true` uses defaults;
-     * an object tunes the breakpoint / desktop subset / accessible name.
+     * BB.W-DRAG-MORPH — the LIQUID TAB. When `true` (ADDITIVE, default `false`),
+     * the `pill` indicator becomes a physical lozenge you can GRAB and PULL: it
+     * follows the finger ~1:1, squishes on drag velocity, and flings to the nearest
+     * tab on release (`useDragMorph`). The click-selection path is byte-identical;
+     * the drag is opt-in. No-op on `underline` (the ink hairline has no indicator
+     * element to deform).
      */
-    responsive?: boolean | SegmentedTabsResponsive;
+    draggable?: boolean;
     class?: HTMLAttributes["class"];
 }
 type __VLS_Props = SegmentedTabsProps;
 type __VLS_ModelProps = {
-    modelValue: string | string[];
+    modelValue: string;
 };
 type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
 declare var __VLS_50: {
@@ -73,14 +78,14 @@ type __VLS_Slots = {} & {
     option?: (props: typeof __VLS_58) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: string | string[]) => any;
+    "update:modelValue": (value: string) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
-    "onUpdate:modelValue"?: ((value: string | string[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
 }>, {
-    overflow: "none" | "scroll" | "auto";
+    orientation: SegmentedTabsOrientation;
     variant: SegmentedTabsVariant;
+    draggable: boolean;
     responsive: boolean | SegmentedTabsResponsive;
-    multiSelect: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/components/custom/tabs/composables/useTabDragMorph.d.ts

@@ -0,0 +1,42 @@
+import type { ComputedRef, Ref } from "vue";
+import { type UseDragMorphReturn } from "../../../../composables/motion/useDragMorph";
+import type { SegmentedTabOption } from "../SegmentedTabs.vue";
+/**
+ * Package-private composable for `SegmentedTabs.vue` — BB.W-DRAG-MORPH, the LIQUID
+ * TAB (the `:draggable` axis). Carved out of the SFC at BB.W-CARVE4 to hold the
+ * no-god-module bound, mirroring the `useTabIndicator` colocation sibling; the SFC
+ * IMPORTS it and binds `drag.dragStyle`/`drag.dragging` in its template.
+ *
+ * When `:draggable`, the `pill` indicator is wired to `useDragMorph` with the snap
+ * targets resolved off the CENTER-ANCHORED button geometry (the SAME measure
+ * `useTabIndicator` runs — reused, never re-measured). Dragging the indicator follows
+ * the finger, squishes on velocity, and flings to the nearest tab center on release →
+ * `onSnap` writes the `model`. The drag is the `pill` material ONLY (the `underline`
+ * ink hairline has no `indicatorRef` element to deform). The squish reads the SAME
+ * `--tab-indicator-max-stretch` live cap the click squish does (the SOLE cap source);
+ * the drag's `--stretch` write composes the existing reciprocal CSS pairing — no
+ * second squish recipe.
+ */
+export interface UseTabDragMorphParams {
+    /** The active indicator element (the drag follow + squish target). */
+    indicatorRef: Ref<HTMLElement | null>;
+    /** True for the vertical (block-axis) orientation. */
+    isVertical: ComputedRef<boolean>;
+    /** True for the underline material (drag is a no-op there). */
+    isUnderline: ComputedRef<boolean>;
+    /** The `:draggable` prop (ADDITIVE, default false). */
+    draggable: () => boolean;
+    /** The strip's rendered options (the snap targets + the refresh trigger). */
+    stripOptions: ComputedRef<SegmentedTabOption[]>;
+    /** Per-option button refs, index-aligned to `stripOptions`. */
+    buttonRefs: Ref<HTMLElement[]>;
+    /** The single-select model — the fling-to-nearest commits the selection. */
+    model: Ref<string | undefined>;
+}
+export interface UseTabDragMorphReturn {
+    /** True when the drag is live (the `pill` material + the `:draggable` prop). */
+    dragEnabled: ComputedRef<boolean>;
+    /** The `useDragMorph` handle (the SFC binds `dragStyle`/`dragging`). */
+    drag: UseDragMorphReturn;
+}
+export declare function useTabDragMorph(params: UseTabDragMorphParams): UseTabDragMorphReturn;

package/dist/components/custom/tabs/composables/useTabIndicator.d.ts

@@ -2,21 +2,32 @@ import { type Ref, type ComputedRef } from "vue";
 import type { SegmentedTabOption } from "../SegmentedTabs.vue";
 /**
  * Package-private composable for `SegmentedTabs.vue` — owns the JS-measured
- * indicator path: the single- and multi-select slider styles, the offset
- * measure, the model/options re-measure watchers, and the ResizeObserver
- * lifecycle. It ALSO owns the AX.W53 travel-squish: a velocity-driven,
- * volume-preserving `--stretch` scalar the active indicator reads so it
- * STRETCHES along its travel axis as it glides between tabs and settles to fit
- * (the Material 3 ELASTIC / Apple Liquid-Glass register, capped LOW).
+ * single-select indicator path: the slider style, the offset measure, the
+ * model/options re-measure watchers, and the ResizeObserver lifecycle. It ALSO
+ * owns the AX.W53 travel-squish: a velocity-driven, volume-preserving `--stretch`
+ * scalar the active indicator reads so it STRETCHES along its travel axis as it
+ * glides between tabs and settles to fit (the Material 3 ELASTIC / Apple
+ * Liquid-Glass register, capped LOW).
  *
- * The composable is the SOLE writer of the JS slider styles. The measure path
- * runs only on the multi-select OR `@supports not (anchor)` branch — on an
- * anchor-supporting single-select engine the CSS `anchor-name` owns the slider
- * position and that path stays dormant (no RO is constructed, no measure runs).
- * The squish is independent of the position path: it is a transient `--stretch`
- * write driven on EVERY selection (anchor or JS engine) and reads from
- * `--tab-indicator-max-stretch`, so the elastic warp lands on all three
- * variants. Honors `prefers-reduced-motion` (no squish under reduce).
+ * BA.W-TABS — the engine is AXIS-DERIVED (the `vertical` param): the JS slider
+ * writes width/translateX on the inline axis (horizontal) OR height/translateY on
+ * the block axis (vertical). It is CENTER-ANCHORED (the BA-VJS-3 / valuejs-fold A-5
+ * fix): the indicator is positioned by its CENTER == the active button's center
+ * (translate = buttonCenter − indicatorSize/2), so the squish (which scales from
+ * `transform-origin: center`) keeps the indicator center pinned to the label
+ * center — the prior `translateX(offsetLeft)` left-edge write is GONE.
+ *
+ * The composable is the SOLE writer of the JS slider style. The measure path runs
+ * only on the `@supports not (anchor)` branch — on an anchor-supporting engine the
+ * CSS `anchor-name` owns the slider position and that path stays dormant (no RO is
+ * constructed, no measure runs). The squish is independent of the position path: it
+ * is a transient `--stretch` write driven on EVERY selection (anchor or JS engine)
+ * and reads from `--tab-indicator-max-stretch`, and RELEASES AT ARRIVAL (keyed to
+ * the calibrated clock, not a fixed mid-glide timer). Honors
+ * `prefers-reduced-motion` (no squish under reduce). The underline material SLIDES
+ * (no squish — a hairline does not deform), gated by the `vertical`/underline
+ * early-return at the SFC's `squishOnTravel` call shape (the underline has no
+ * `indicatorRef` element).
  */
 export interface UseTabIndicatorParams {
     /** The container scroller root (observed by the ResizeObserver). */
@@ -28,21 +39,19 @@ export interface UseTabIndicatorParams {
     /** The tab options (re-measure on change). */
     options: ComputedRef<SegmentedTabOption[]>;
     /** The defineModel value (re-measure on change). */
-    model: Ref<string | string[] | undefined>;
-    /** True for the multi-select path. */
-    multiSelect: ComputedRef<boolean>;
+    model: Ref<string | undefined>;
     /** Whether the browser supports CSS anchor positioning. */
     anchorSupported: boolean;
-    /** True when ANY JS slider writer is live (gates RO/watcher attach). */
+    /** True when the JS slider writer is live (gates RO/watcher attach). */
     jsSliderActive: ComputedRef<boolean>;
-    /** The active option values (used by the multi-slider measure). */
+    /** The active option values (used by the measure). */
     activeValues: ComputedRef<string[]>;
+    /** True for the vertical (block-axis) orientation. */
+    vertical: ComputedRef<boolean>;
 }
 export interface UseTabIndicatorReturn {
     /** Inline style for the single-select JS slider. */
     singleSliderStyle: Ref<Record<string, string>>;
-    /** Inline styles for each active multi-select slider, keyed by value. */
-    multiSliderStyles: Ref<Record<string, Record<string, string>>>;
     /** Imperatively kick the travel-squish on a selection at `idx`. */
     squishOnTravel: (toIdx: number) => void;
 }

package/dist/components/custom/tabs/constants.d.ts

@@ -6,7 +6,13 @@
  */
 export declare const DEFAULT_INDICATOR_MAX_STRETCH = 1.08;
 /**
- * ms after the stretch opens before it releases back to fit (`--stretch → 1`) — the
- * Material "grow then shrink" close. Rides the same snappy glide clock as the travel.
+ * The travel-progress fraction at which the squish RELEASES — the Material
+ * "grow then shrink" close, keyed to ARRIVAL (BA.W-TABS). The squish opens with
+ * the glide and releases when the indicator is within this fraction of its target
+ * (release-at-arrival), retiring the fixed mid-glide `INDICATOR_RELEASE_MS` timer
+ * (which fired at 60ms — BEFORE the ~100ms 90%-travel point, mid-glide). The
+ * release schedules off the calibrated clock (`--spring-snappy-duration`) scaled
+ * by this fraction, so the stretch peaks during travel and shrinks to fit AT
+ * arrival, never before.
  */
-export declare const INDICATOR_RELEASE_MS = 60;
+export declare const INDICATOR_RELEASE_AT_ARRIVAL = 0.82;

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

@@ -1,2 +1,2 @@
 export { default as SegmentedTabs } from "./SegmentedTabs.vue";
-export type { SegmentedTabOption, SegmentedTabsVariant, SegmentedTabsProps, SegmentedTabsResponsive, } from "./SegmentedTabs.vue";
+export type { SegmentedTabOption, SegmentedTabsVariant, SegmentedTabsOrientation, SegmentedTabsProps, SegmentedTabsResponsive, } from "./SegmentedTabs.vue";

package/dist/components/custom/watercolor-dot/WatercolorDot.vue.d.ts

@@ -13,6 +13,19 @@
 type __VLS_Props = {
     /** CSS color painted as the swatch background (any CSS color form). */
     color: string;
+    /**
+     * Render mode (BA.W-EMISSION / BA-VJS-C2):
+     *   `solid` (default) — the filled organic blob (the swatch background IS the
+     *                       color; the existing register, unchanged).
+     *   `ghost`  — the SAME seeded blob SILHOUETTE rendered as a STROKE: a
+     *              `color` border over a low-alpha `color` fill, the irregular-blob
+     *              outline (NOT a CSS dashed rectangle). A `ghost` of a given
+     *              `color + seed` matches the SAME silhouette the `solid` dot of
+     *              that seed renders — both read the same `useWatercolorBlob`
+     *              border-radius morph; the stroke is the only delta. The
+     *              empty-palette-slot / placeholder affordance.
+     */
+    variant?: "solid" | "ghost";
     /** Run the rAF-driven shape morph (default false → static, hover-morph only). */
     animate?: boolean;
     /** Host tag — `div` (decorative) or `button` (interactive). */
@@ -30,8 +43,9 @@ type __VLS_Slots = {} & {
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
     animate: boolean;
-    seed: string;
     range: [number, number];
+    variant: "solid" | "ghost";
+    seed: string;
     tag: "div" | "button";
     cycleDuration: number;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/components/ui/_shared/index.d.ts

@@ -1,2 +1,4 @@
 export { menuItemVariants } from "./menuItemVariants";
 export type { MenuItemVariants } from "./menuItemVariants";
+export { surfaceClass } from "./useSurfaceAxis";
+export type { Surface, SurfaceTier } from "./useSurfaceAxis";

package/dist/components/ui/_shared/menuItemVariants.d.ts

@@ -24,8 +24,27 @@ import { type VariantProps } from "class-variance-authority";
  *
  * Indicator slot variants reserve the gutter for radio-dot / check / chevron
  * indicator spans the consumer SFCs render absolutely-positioned.
+ *
+ * Surface axis (BA.W-MENU-GLASS) — the menu-row's MATERIAL register, an
+ * EXPRESSION of the shared {glass·veil·opaque} surface-decoration axis
+ * (`_shared/useSurfaceAxis.ts` / `glass/surface-axis.css`), NOT a second axis:
+ * - `glass` (DEFAULT, glass-first canon AX.W54) — the `.glass-menu-row` recipe
+ *   (`src/styles/menu.css`): the hover / focus / `data-highlighted` / open states
+ *   paint the ELEMENT-LEVEL glass-quiet oklab tint (so the row darkens-over-light
+ *   AND lifts-over-dark per W-DARK-MATERIAL's tint arm) + a PRM-gated `translateY`
+ *   hover-lift, the 44px touch floor, the iOS-grade glassy hover-lift plate. The
+ *   flat `bg-accent` utilities are DROPPED on this arm — the cascade-trap-safe
+ *   shape: with no unlayered `hover:bg-accent` utility the ONLY background-painters
+ *   are the `@layer components` `.interactive-item:hover` accent rule and the
+ *   `.glass-menu-row` recipe (imported AFTER utilities.css so it source-order-wins
+ *   at equal specificity+layer — the AZ dock-rail `@layer`-loses-to-utility trap
+ *   pre-empted: never re-add an unlayered flat-accent utility here).
+ * - `accent` — the EXPLICIT flat-accent escape (the prior default's look). A clean
+ *   break, NOT a back-compat alias (BA inv-7): a consumer that wants the flat fill
+ *   opts in via `surface="accent"`.
  */
 export declare const menuItemVariants: (props?: ({
+    surface?: "glass" | "accent" | null | undefined;
     indicator?: "start" | "none" | "start-wide" | null | undefined;
     density?: "comfortable" | "audacious" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;

package/dist/components/ui/_shared/useSurfaceAxis.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The shared surface-decoration axis — three rungs, ONE grammar.
+ *
+ *   glass   — the resolved tier's plain glass rung (default). The translucent
+ *             blur surface, the maximal glass-first register.
+ *   veil    — the borderless/rimless text-legibility plate: the `--glass-bg-quiet`
+ *             fill + blur with the box border AND rim STRIPPED (the boxed look
+ *             reads as a dividing line on a text plate). Reads the same `--glass-*`
+ *             ladder + W55 `--glass-tint-*` seam, so `--glass-level` / the bright
+ *             bucket retune it in lockstep with every glass surface.
+ *   opaque  — the `--glass-level:0` solid-card escape: solid `--card` + `blur(0)`
+ *             through the ONE level knob. The explicit opt-out from the maximal
+ *             glass default.
+ */
+export type Surface = "glass" | "veil" | "opaque";
+/**
+ * The 5-rung glass-ladder tier the surface paints its base over. Mirrors the
+ * `.glass-{wash,quiet,resting,floating,overlay}` ladder. A surface passes the rung
+ * it already paints (Card's `resting`, Dialog/Sheet/Popover's `floating`); the
+ * resolver maps it to the `glass-${tier}` base class. `opaque` is NOT a ladder
+ * rung here — it is a decoration on TOP of a base tier (the `.glass-opaque`
+ * escape keeps the tier's edge/rim), exactly as Card composes it.
+ */
+export type SurfaceTier = "wash" | "quiet" | "resting" | "floating" | "overlay";
+/**
+ * Resolve a (surface, tier) pair to the class string a surface composes. Pairs
+ * with a `:data-surface="surface"` attribute binding on the same element — the
+ * CSS seam (`surface-axis.css`) reads the attr to apply the veil/opaque
+ * decoration UNIFORMLY, while this resolver emits the back-compat decoration
+ * classes (`veil-surface` / `glass-opaque`) so Card's three shared rungs stay
+ * byte-identical and a surface composing the class set alone (no attr) still
+ * paints correctly.
+ *
+ *   surfaceClass("glass",  "floating") → "glass-floating"
+ *   surfaceClass("veil",   "floating") → "glass-floating veil-surface"
+ *   surfaceClass("opaque", "floating") → "glass-floating glass-opaque"
+ *
+ * @param surface the decoration rung (`glass` default · `veil` · `opaque`)
+ * @param tier    the base ladder rung (default `resting`)
+ */
+export declare function surfaceClass(surface?: Surface, tier?: SurfaceTier): string;

package/dist/components/ui/badge/index.d.ts

@@ -1,7 +1,7 @@
 import { type VariantProps } from 'class-variance-authority';
 export { default as Badge } from './Badge.vue';
 export declare const badgeVariants: (props?: ({
-    variant?: "default" | "destructive" | "outline" | "secondary" | "success" | "warning" | "info" | null | undefined;
+    variant?: "default" | "outline" | "destructive" | "secondary" | "success" | "warning" | "info" | null | undefined;
     size?: "sm" | "lg" | "md" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export type BadgeVariants = VariantProps<typeof badgeVariants>;

package/dist/components/ui/button/Button.vue.d.ts

@@ -1,16 +1,19 @@
 import type { ButtonHTMLAttributes, HTMLAttributes } from 'vue';
 import { type PrimitiveProps } from 'reka-ui';
 import { type ButtonVariants } from '.';
+import type { Surface } from '../_shared/useSurfaceAxis';
 interface Props extends PrimitiveProps {
     variant?: ButtonVariants['variant'];
     size?: ButtonVariants['size'];
     class?: HTMLAttributes['class'];
+    surface?: Surface;
+    liquid?: boolean;
     type?: ButtonHTMLAttributes['type'];
     disabled?: ButtonHTMLAttributes['disabled'];
 }
-declare var __VLS_8: {};
+declare var __VLS_13: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_8) => any;
+    default?: (props: typeof __VLS_13) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
     as: import("reka-ui").AsTag | import("vue").Component;

package/dist/components/ui/button/index.d.ts

@@ -1,7 +1,7 @@
 import { type VariantProps } from 'class-variance-authority';
 export { default as Button } from './Button.vue';
 export declare const buttonVariants: (props?: ({
-    variant?: "link" | "default" | "solid" | "primary-audacious" | "gold-audacious" | "destructive" | "outline" | "secondary" | "accent" | "ghost" | "glass" | "glass-wash" | "ai" | null | undefined;
-    size?: "default" | "xs" | "sm" | "lg" | "icon" | "icon-sm" | null | undefined;
+    variant?: "link" | "default" | "glass" | "outline" | "solid" | "primary-audacious" | "gold-audacious" | "destructive" | "secondary" | "accent" | "ghost" | "glass-wash" | "ai" | null | undefined;
+    size?: "default" | "icon" | "xs" | "sm" | "lg" | "icon-sm" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export type ButtonVariants = VariantProps<typeof buttonVariants>;