@mkbabb/glass-ui 4.2.0 → 5.0.0

package/dist/components/split-chars/SplitChars.vue.d.ts

@@ -0,0 +1,53 @@
+/**
+ * SplitChars — the component face of the per-glyph split. It renders the `text`
+ * prop into per-glyph `.char` spans (each carrying `--char-index`), wraps them in
+ * the shipped `.char-stagger` host (so the library CSS staggers them into a
+ * kinetic entrance on the per-spring `--spring-smooth` clock), and — by
+ * construction — keeps the word as ONE accessible name: the wrapper carries
+ * `aria-label="{text}"`, every glyph span is `aria-hidden`. AT hears "Fourier",
+ * never the spell-out.
+ *
+ * Usage:
+ *   <SplitChars text="Fourier" />
+ *   <SplitChars text="Hello World" by="word" as="h1" />
+ *
+ * The `text` PROP is the single source for BOTH the split AND the label — there
+ * is NO default slot (a slot would split arbitrary markup, so the accessible name
+ * would be ambiguous). The split re-runs on a `text` change (the watcher →
+ * `split()`). Engine-free: it composes `useCharStagger` (vue-only) + the shipped
+ * CSS; it adds NO animation engine and NO PRM logic (it inherits the recipe's
+ * carve — the split is structural, only the CSS `fade-in` is PRM-gated).
+ */
+import { type Component, type HTMLAttributes } from "vue";
+import { type UseCharStaggerOptions } from "../../composables/motion/useCharStagger";
+type __VLS_Props = {
+    /** The word to split — REQUIRED. It is the single source for both the
+     *  per-glyph split AND the accessible label (the load-bearing a11y fact). */
+    text: string;
+    /** The split unit. Default `"char"`. */
+    by?: UseCharStaggerOptions["by"];
+    /** Host tag/component (reka-ui Primitive `as`; default `"span"`) — set
+     *  `as="h1"` to render the kinetic word as a heading. */
+    as?: string | Component;
+    /**
+     * Whether to compose the shipped `.char-stagger` host recipe (default
+     * `true` → byte-identical to the historical behaviour). Set `false` to
+     * DROP `.char-stagger` so the recipe's mount-bound `fade-in` never fires
+     * — the load-bearing reason is "no mount-fire-before-reveal": when a
+     * caller owns the entrance itself (an IntersectionObserver-gated reveal,
+     * a replay harness), the `.char-stagger` `animation: fade-in … backwards`
+     * that binds on MOUNT would flash the glyphs in before the caller's
+     * reveal claims them. `:stagger=false` yields the bare `.char` spans
+     * (still carrying `--char-index`/`--char-total`) so the caller's own CSS
+     * owns the per-glyph entrance. The word stays ONE accessible name either
+     * way (the a11y contract is on the wrapper, not the recipe class). */
+    stagger?: boolean;
+    class?: HTMLAttributes["class"];
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    as: string | Component;
+    by: "char" | "word" | "grapheme";
+    stagger: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/stacked-icons/types.d.ts

@@ -0,0 +1,19 @@
+export interface StackedIconGroupProps<TItem> {
+    /** Items to display */
+    items: TItem[];
+    /** Max visible icons before showing +N overflow */
+    maxVisible?: number;
+    /** Stack orientation (BI.W-SYNONYM-RENAMES — the `direction` synonym renamed to
+     *  the shared `orientation` axis vocabulary; horizontal|vertical, zero value change). */
+    orientation?: "horizontal" | "vertical";
+    /** Reverse the visual order */
+    reversed?: boolean;
+    /** Icon size */
+    size?: "sm" | "md" | "lg";
+    /** Expand icons on group hover */
+    expandOnHover?: boolean;
+    /** Root element tag */
+    as?: string;
+    /** Key extraction function for v-for */
+    keyFn?: (item: TItem, index: number) => string | number;
+}

package/dist/components/surface/Surface.vue.d.ts

@@ -0,0 +1,45 @@
+import { type HTMLAttributes } from "vue";
+import { type PrimitiveProps } from "reka-ui";
+import { type Surface as SurfaceKind, type SurfaceTier } from "../_shared/useSurfaceAxis";
+export interface SurfaceProps extends PrimitiveProps {
+    /** The base glass-ladder rung the plate paints over. Default `resting`. */
+    tier?: SurfaceTier;
+    /** The surface-decoration rung (the ONE shared axis): `glass` (default, the
+     *  plain tier rung) · `veil` (borderless/rimless text-legibility plate) ·
+     *  `opaque` (the `--glass-level:0` solid-card escape) · `clear` (the
+     *  scrim-coupled maximally-translucent Apple-Clear plate). Resolved through
+     *  `decorationClass()` — the ONE decoration source. */
+    surface?: SurfaceKind;
+    /** The BB.W-DEEP-GLASS opt-in maximal iOS-27 tier (Apple saturate-1.5/blur-16px):
+     *  a `.glass-deep` decoration ON the `floating` base rung. Default `false` — a
+     *  bare plate rides the calm content default. */
+    deep?: boolean;
+    /** Surface drop shadow via `--shadow-card`. `veil` strips it by design (the
+     *  rimless plate is shadowless). Default `false` (the minimal bare plate). */
+    shadow?: boolean;
+    /** The `::after` paper-grain overlay. Default `false`. When off, the grain
+     *  pseudo is hidden (`[&::after]:hidden`) — a scroll pane / cartoon plate opts
+     *  out (the grain conflicts with overflow:auto repaints / the cast). */
+    grain?: boolean;
+    class?: HTMLAttributes["class"];
+}
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<SurfaceProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SurfaceProps> & Readonly<{}>, {
+    shadow: boolean;
+    surface: SurfaceKind;
+    as: import("reka-ui").AsTag | import("vue").Component;
+    deep: boolean;
+    tier: SurfaceTier;
+    grain: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/surface/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Surface, type SurfaceProps } from "./Surface.vue";
+export { decorationClass, surfaceClass } from "../_shared/useSurfaceAxis";

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

@@ -0,0 +1,101 @@
+import { type HTMLAttributes } from "vue";
+import type { Motion } from "../_shared/axes";
+/** The canonical tab/option shape — one descriptor across both materials. */
+export interface SegmentedTabOption {
+    label: string;
+    value: string;
+    icon?: string;
+    disabled?: boolean;
+    tooltip?: string;
+}
+/** 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
+     * strip collapses to a `<Select>`; at/above it renders the tab strip.
+     * Defaults to `"640px"` (Tailwind `sm:`).
+     */
+    breakpoint?: string;
+    /**
+     * Optional subset shown in the desktop strip (the mobile Select keeps the
+     * full option list). Falls back to `options`.
+     */
+    desktopOptions?: SegmentedTabOption[] | null;
+    /** Accessible name for the mobile `<SelectTrigger>`. */
+    ariaLabel?: string;
+    /** Class merged onto the mobile `<SelectTrigger>` only. */
+    triggerClass?: HTMLAttributes["class"];
+}
+export interface SegmentedTabsProps {
+    options: SegmentedTabOption[];
+    /**
+     * The material — `pill` (DEFAULT, the glass-track slider) or `underline`
+     * (the paper ink-hairline rule).
+     */
+    variant?: SegmentedTabsVariant;
+    /**
+     * Orientation — `horizontal` (default) or `vertical`. Axis-derived on the
+     * one indicator engine.
+     */
+    orientation?: SegmentedTabsOrientation;
+    /**
+     * Responsive collapse — below the breakpoint the strip becomes a `<Select>`.
+     * `true` uses defaults; an object tunes the breakpoint / desktop subset /
+     * accessible name.
+     */
+    responsive?: boolean | SegmentedTabsResponsive;
+    /**
+     * BH.W-MOTION-AXIS — the ONE motion-weight axis (the `draggable` boolean's
+     * clean-break successor). `full` (default) arms the LIQUID TAB: the `pill` indicator
+     * is 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`),
+     * ADDITIVE OVER the click/keyboard path (which stays byte-identical + fully operable
+     * — the drag is a pointer ENHANCEMENT, never the sole selection mechanism, WCAG
+     * 2.1.1). `reduced`/`off` opt DOWN to the click-only strip (the drag unbinds; the
+     * roving-tabindex keyboard contract stays — motion off, meaning never off). No-op on
+     * `underline` (the ink hairline has no indicator element to deform). PRM forces
+     * `full → reduced` regardless (a11y absolute).
+     */
+    motion?: Motion;
+    class?: HTMLAttributes["class"];
+}
+type __VLS_Props = SegmentedTabsProps;
+type __VLS_ModelProps = {
+    modelValue: string;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_50: {
+    option: SegmentedTabOption;
+    active: boolean;
+}, __VLS_58: {
+    option: SegmentedTabOption;
+    active: boolean;
+};
+type __VLS_Slots = {} & {
+    option?: (props: typeof __VLS_50) => any;
+} & {
+    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) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    orientation: SegmentedTabsOrientation;
+    variant: SegmentedTabsVariant;
+    responsive: boolean | SegmentedTabsResponsive;
+}, {}, {}, {}, 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/tabs/composables/useEyeglassLive.d.ts

@@ -0,0 +1,17 @@
+import { type ComputedRef, type Ref } from "vue";
+export interface UseEyeglassLiveParams {
+    /** The active indicator element (the `--eyeglass-live-t` write target; the nested
+     *  `.segmented-indicator__plate` reads the inherited scalar). */
+    indicatorRef: Ref<HTMLElement | null>;
+    /** True when the eyeglass loupe register is engaged (pill material, non-underline).
+     *  When false the composable seats settled and never energizes. */
+    enabled: ComputedRef<boolean>;
+}
+export interface UseEyeglassLive {
+    /** Energize to LIVE (proud), hold the dwell, then decay to SETTLED. Fired on
+     *  pointer-down (the §1 pre-motion bloom) AND on select (the keyboard path). */
+    energize(): void;
+    /** Force the scalar to SETTLED instantly (mount / disable). */
+    settle(): void;
+}
+export declare function useEyeglassLive(params: UseEyeglassLiveParams): UseEyeglassLive;

package/dist/components/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/tabs/composables/useTabResponsive.d.ts

@@ -0,0 +1,43 @@
+import type { ComputedRef, Ref } from "vue";
+import type { SegmentedTabOption, SegmentedTabsResponsive } from "../SegmentedTabs.vue";
+/**
+ * Package-private composable for `SegmentedTabs.vue` — BG.W-COLOCATE (the WS4
+ * roving-focus/responsive carve; ratchet-drain #13). The responsive-collapse concern
+ * (the `<Select>`-below-the-breakpoint fold) lives here, carved out of the SFC to hold
+ * the no-god-module bound — the `useTabIndicator`/`useTabDragMorph` colocation-sibling
+ * pattern. The SFC IMPORTS it and binds `stripValue`/`stripOptions`/`showMobileSelect`
+ * in its template + feeds `stripValue`/`stripOptions` to the indicator/roving concerns.
+ *
+ * Owns the `matchMedia((min-width: <breakpoint>))` lifecycle END-TO-END (the
+ * `onMounted`/`onBeforeUnmount` wiring lives HERE — a composable is a legitimate
+ * lifecycle-hook owner), so the SFC never re-declares the `mql` listener. Byte-behaviour
+ * identical to the prior inline block (the SSR/desktop-first default, the mobile-only
+ * model fall-back, the accessible name resolution).
+ */
+export interface UseTabResponsiveParams {
+    /** The `:responsive` prop — `false` | `true` | a tuning object. */
+    responsive: () => boolean | SegmentedTabsResponsive;
+    /** The full option list (the mobile `<Select>` keeps ALL options). */
+    options: ComputedRef<SegmentedTabOption[]>;
+    /** The single-select model (the strip value the collapse falls back off). */
+    model: Ref<string | undefined>;
+}
+export interface UseTabResponsiveReturn {
+    /** The resolved responsive config, or `null` when `:responsive` is off. */
+    responsiveCfg: ComputedRef<SegmentedTabsResponsive | null>;
+    /** The collapse breakpoint CSS length (default `"640px"`). */
+    breakpoint: ComputedRef<string>;
+    /** The desktop-strip option subset (falls back to the full list). */
+    desktopOptions: ComputedRef<SegmentedTabOption[]>;
+    /** `true` at/above the breakpoint (the matchMedia state; SSR-default `true`). */
+    isDesktop: Ref<boolean>;
+    /** The value the STRIP renders (falls back off a mobile-only model). */
+    stripValue: ComputedRef<string | undefined>;
+    /** The options the STRIP renders (desktop subset when responsive, else full). */
+    stripOptions: ComputedRef<SegmentedTabOption[]>;
+    /** The accessible name for the mobile `<SelectTrigger>`. */
+    mobileAriaLabel: ComputedRef<string>;
+    /** `true` when the mobile `<Select>` should render (responsive + below breakpoint). */
+    showMobileSelect: ComputedRef<boolean>;
+}
+export declare function useTabResponsive(params: UseTabResponsiveParams): UseTabResponsiveReturn;

package/dist/components/tabs/composables/useTabRovingFocus.d.ts

@@ -0,0 +1,51 @@
+import type { ComputedRef, Ref } from "vue";
+/**
+ * The minimal roving option shape — the machine reads ONLY `value` + `disabled`
+ * (BI.W-DOCK-CONTROLS decoupled it from `SegmentedTabOption` so the shared
+ * headless `useSelectionGroup` can compose it VERBATIM over its generic option
+ * type). Any richer option (the tabs' `SegmentedTabOption`) is structurally
+ * assignable.
+ */
+export interface RovingSelectionOption {
+    value: string;
+    disabled?: boolean;
+}
+/**
+ * Package-private composable for `SegmentedTabs.vue` — BG.W-COLOCATE (the WS4
+ * roving-focus/responsive carve; ratchet-drain #13). The WAI-ARIA tablist/toolbar
+ * roving-tabindex keyboard machine lives here, carved out of the SFC to hold the
+ * no-god-module bound. BI.W-DOCK-CONTROLS composes it VERBATIM inside the shared
+ * headless `useSelectionGroup` (the dock IS SegmentedTabs/ToggleGroup wearing
+ * chrome — ONE roving machine, never re-forked). The SFC IMPORTS it and binds
+ * `:tabindex="rovingTabindex(idx)"` + `@keydown="onStripKeydown"` in its template.
+ *
+ * EXACTLY ONE tab in the focus order (the active tab `tabindex="0"`, the rest `-1`);
+ * the arrow keys move focus + activate (selection-follows-focus). The arrow AXIS is
+ * derived off `isVertical` (ArrowRight/Left horizontal, ArrowDown/Up vertical),
+ * Home/End jump, wrapping at the ends, skipping disabled. This is the keyboard contract
+ * EVERY strip owes — NOT gated on `:draggable` (a draggable tab that is keyboard-broken
+ * is the worse failure). The keyboard activation IS a selection → the SFC's `select(...)`
+ * path (with its `squishOnTravel`), passed in as a callback (byte-behaviour identical to
+ * the prior inline block).
+ */
+export interface UseTabRovingFocusParams {
+    /** The options the strip renders (index-aligned to `buttonRefs`). */
+    stripOptions: ComputedRef<readonly RovingSelectionOption[]>;
+    /** The value the strip renders (the ONE tabstop anchor). */
+    stripValue: ComputedRef<string | undefined>;
+    /** True for the vertical (block-axis) orientation — flips the arrow axis. */
+    isVertical: ComputedRef<boolean>;
+    /** Per-option button refs, index-aligned to `stripOptions`. */
+    buttonRefs: Ref<HTMLElement[]>;
+    /** The SFC's selection handler (focus-follows activation → model write + squish). */
+    select: (value: string, idx: number) => void;
+}
+export interface UseTabRovingFocusReturn {
+    /** The active index in the rendered strip — the ONE tabstop. */
+    activeIndex: ComputedRef<number>;
+    /** The roving tabindex for option `idx`: `0` for the active tab, `-1` otherwise. */
+    rovingTabindex: (idx: number) => number;
+    /** The strip-root keydown handler (axis-derived arrows + Home/End). */
+    onStripKeydown: (e: KeyboardEvent) => void;
+}
+export declare function useTabRovingFocus(params: UseTabRovingFocusParams): UseTabRovingFocusReturn;

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

@@ -0,0 +1 @@
+export { DEFAULT_INDICATOR_MAX_STRETCH, DEFAULT_INDICATOR_BLOB_MAX, INDICATOR_RELEASE_AT_ARRIVAL, } from "../../composables/motion/useSelectionIndicator";

package/dist/components/timeline/ContinuousMarkers.vue.d.ts

@@ -0,0 +1,49 @@
+import type { TimelineSegment } from "./types";
+/**
+ * <ContinuousMarkers> — the interactive marker overlay of the
+ * continuous-variant timeline. DECK-PRIVATE child of <ContinuousTimeline>
+ * (not a public export). Renders the sibling `<ul role="list">` overlay
+ * carrying one focusable button per segment boundary, each (by default)
+ * wrapped in <HoverPopover>. Lives OUTSIDE the rail's `overflow: hidden`
+ * clip and is a SIBLING of the progressbar rail (Option C structural
+ * split, AB.W2.T4).
+ *
+ * The split is a pure transposition out of the prior monolithic
+ * ContinuousTimeline.vue: same DOM, same class names, same data
+ * attributes, same scoped CSS rules. The orchestrator owns the hovered-key
+ * state + the `#detail` resolution; this child emits the raw
+ * hover/hoverEnd/click signals (popover-open-change drives hover/hoverEnd
+ * on the default path; raw mouseenter/leave on the bare-fallback path) and
+ * forwards the consumer's `#popoverContent` slot through the
+ * `popoverContent` slot.
+ */
+type __VLS_Props = {
+    segments: TimelineSegment[];
+    markersAriaLabel: string;
+    currentSegmentKey?: string;
+    disablePopover?: boolean;
+    boundaryX: (i: number) => number;
+};
+declare var __VLS_21: {
+    segment: TimelineSegment;
+};
+type __VLS_Slots = {} & {
+    popoverContent?: (props: typeof __VLS_21) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (seg: TimelineSegment) => any;
+    hover: (seg: TimelineSegment) => any;
+    hoverEnd: (seg: TimelineSegment) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClick?: ((seg: TimelineSegment) => any) | undefined;
+    onHover?: ((seg: TimelineSegment) => any) | undefined;
+    onHoverEnd?: ((seg: TimelineSegment) => any) | undefined;
+}>, {}, {}, {}, {}, 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/timeline/GlassTimeline.vue.d.ts

@@ -0,0 +1,114 @@
+import type { TimelineSegment } from "./types";
+/**
+ * <GlassTimeline> — dispatcher SFC for three structurally-distinct
+ * timeline variants. Public surface UNCHANGED from the pre-O.W3 god-module.
+ *
+ * - `variant="scrubber"` (default): single-track normalized 0..1 scrubber
+ *   with full keyboard a11y (role=slider + arrow-key step + shift-step).
+ *   Delegates to `<ScrubberTimeline>`.
+ *
+ * - `variant="segmented"` (Z.W2.T1 / A2 §B5): adjacent gradient bands,
+ *   one per phase, with boundary dots that emit `hover` + `click` events
+ *   carrying the segment key + payload. Delegates to `<SegmentedTimeline>`.
+ *
+ * - `variant="continuous"` (AA.W1 / A4 §S-17): ONE rounded-pill rail
+ *   substrate with N absolute-positioned region children. Delegates to
+ *   `<ContinuousTimeline>`. The continuous variant owns the popover
+ *   portal CSS contract (non-scoped <style> block; see ContinuousTimeline).
+ *
+ * Per-segment gradient: either `{from, to}` (expanded as 90deg L→R linear
+ * gradient) or a raw CSS gradient string consumed verbatim. Falls back
+ * to `--timeline-segment-default-gradient` when omitted.
+ *
+ * O.W3 Lane A — this dispatcher replaces the prior 1049-line monolith.
+ * The three variant SFCs + `geometry.ts` shared math live alongside in
+ * the same package. Consumer imports through
+ * `@mkbabb/glass-ui/timeline` are unchanged.
+ */
+type __VLS_Props = {
+    /** Variant — default `scrubber`. */
+    variant?: "scrubber" | "segmented" | "continuous";
+    /** 0..1 scrubber position. Required for scrubber variant. */
+    modelValue?: number;
+    /** Tooltip caret text (scrubber variant only). */
+    label?: string;
+    /** Phase descriptors (segmented + continuous variants). */
+    segments?: TimelineSegment[];
+    /**
+     * Optional aria-label for the continuous variant's rail
+     * (role=progressbar). Falls back to a comma-joined list of segment
+     * labels when omitted.
+     */
+    ariaLabel?: string;
+    /**
+     * AB.W2.T3 (A2 §B2.b) — current segment key (continuous variant).
+     * Stamps `data-current="true"` on the matching marker so consumers
+     * (panel / W3 raised-rivet styling) can distinguish the active
+     * phase from the transient hovered phase.
+     */
+    currentSegmentKey?: string;
+    /**
+     * AB.W2.T2 (A4 §B2.c) — disable the default per-marker
+     * HoverPopover (continuous variant). The dot still emits
+     * `hover` / `click` events.
+     */
+    disablePopover?: boolean;
+};
+declare var __VLS_13: {
+    segment: TimelineSegment;
+}, __VLS_16: {
+    segment: TimelineSegment | null;
+    source: "idle" | "current" | "hovered";
+    currentKey: string | null;
+    hoveredKey: string | null;
+};
+type __VLS_Slots = {} & {
+    popoverContent?: (props: typeof __VLS_13) => any;
+} & {
+    detail?: (props: typeof __VLS_16) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (payload: {
+        key: string;
+        segment: TimelineSegment;
+    }) => any;
+    hover: (payload: {
+        key: string;
+        segment: TimelineSegment;
+    }) => any;
+    "update:modelValue": (v: number) => any;
+    hoverEnd: (payload: {
+        key: string;
+        segment: TimelineSegment;
+    }) => any;
+    scrubStart: () => any;
+    scrubEnd: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClick?: ((payload: {
+        key: string;
+        segment: TimelineSegment;
+    }) => any) | undefined;
+    onHover?: ((payload: {
+        key: string;
+        segment: TimelineSegment;
+    }) => any) | undefined;
+    "onUpdate:modelValue"?: ((v: number) => any) | undefined;
+    onHoverEnd?: ((payload: {
+        key: string;
+        segment: TimelineSegment;
+    }) => any) | undefined;
+    onScrubStart?: (() => any) | undefined;
+    onScrubEnd?: (() => any) | undefined;
+}>, {
+    variant: "scrubber" | "segmented" | "continuous";
+    modelValue: number;
+    disablePopover: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/toast/Toast.vue.d.ts

@@ -0,0 +1,107 @@
+import { type HTMLAttributes } from 'vue';
+import { type ToastRootProps } from 'reka-ui';
+import { type Surface } from '../_shared/useSurfaceAxis';
+import type { Tone } from '../_shared/axes';
+interface ToastProps extends ToastRootProps {
+    class?: HTMLAttributes['class'];
+    tone?: Tone;
+    surface?: Surface;
+}
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<ToastProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    pause: () => any;
+    "update:open": (value: boolean) => any;
+    escapeKeyDown: (event: KeyboardEvent) => any;
+    resume: () => any;
+    swipeStart: (event: {
+        currentTarget: EventTarget & HTMLElement;
+    } & Omit<CustomEvent<{
+        originalEvent: PointerEvent;
+        delta: {
+            x: number;
+            y: number;
+        };
+    }>, "currentTarget">) => any;
+    swipeMove: (event: {
+        currentTarget: EventTarget & HTMLElement;
+    } & Omit<CustomEvent<{
+        originalEvent: PointerEvent;
+        delta: {
+            x: number;
+            y: number;
+        };
+    }>, "currentTarget">) => any;
+    swipeCancel: (event: {
+        currentTarget: EventTarget & HTMLElement;
+    } & Omit<CustomEvent<{
+        originalEvent: PointerEvent;
+        delta: {
+            x: number;
+            y: number;
+        };
+    }>, "currentTarget">) => any;
+    swipeEnd: (event: {
+        currentTarget: EventTarget & HTMLElement;
+    } & Omit<CustomEvent<{
+        originalEvent: PointerEvent;
+        delta: {
+            x: number;
+            y: number;
+        };
+    }>, "currentTarget">) => any;
+}, string, import("vue").PublicProps, Readonly<ToastProps> & Readonly<{
+    onPause?: (() => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onResume?: (() => any) | undefined;
+    onSwipeStart?: ((event: {
+        currentTarget: EventTarget & HTMLElement;
+    } & Omit<CustomEvent<{
+        originalEvent: PointerEvent;
+        delta: {
+            x: number;
+            y: number;
+        };
+    }>, "currentTarget">) => any) | undefined;
+    onSwipeMove?: ((event: {
+        currentTarget: EventTarget & HTMLElement;
+    } & Omit<CustomEvent<{
+        originalEvent: PointerEvent;
+        delta: {
+            x: number;
+            y: number;
+        };
+    }>, "currentTarget">) => any) | undefined;
+    onSwipeCancel?: ((event: {
+        currentTarget: EventTarget & HTMLElement;
+    } & Omit<CustomEvent<{
+        originalEvent: PointerEvent;
+        delta: {
+            x: number;
+            y: number;
+        };
+    }>, "currentTarget">) => any) | undefined;
+    onSwipeEnd?: ((event: {
+        currentTarget: EventTarget & HTMLElement;
+    } & Omit<CustomEvent<{
+        originalEvent: PointerEvent;
+        delta: {
+            x: number;
+            y: number;
+        };
+    }>, "currentTarget">) => any) | undefined;
+}>, {
+    tone: Tone;
+    surface: Surface;
+}, {}, {}, {}, 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;
+    };
+};