@mkbabb/glass-ui 0.3.0 → 2.0.0

package/dist/components/custom/status-dot/StatusDot.vue.d.ts

@@ -0,0 +1,18 @@
+import { type HTMLAttributes } from "vue";
+type Variant = "active" | "paused" | "idle" | "error" | "custom";
+type Size = "xs" | "sm" | "md";
+type __VLS_Props = {
+    variant?: Variant;
+    color?: string;
+    pulse?: boolean;
+    size?: Size;
+    label?: string;
+    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<{}>, {
+    size: Size;
+    variant: Variant;
+    pulse: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/custom/status-dot/index.d.ts

@@ -0,0 +1 @@
+export { default as StatusDot } from "./StatusDot.vue";

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

@@ -0,0 +1,24 @@
+import { type HTMLAttributes } from "vue";
+export interface TabOption {
+    label: string;
+    value: string;
+}
+type __VLS_Props = {
+    options: TabOption[];
+    modelValue: string;
+    /** "default" = subtle muted slider; "pill" = solid foreground pill */
+    variant?: "default" | "pill";
+    /** Tab-row overflow — see `<BouncyToggle>`. */
+    overflow?: "none" | "scroll" | "auto";
+    class?: HTMLAttributes["class"];
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    overflow: "none" | "scroll" | "auto";
+    variant: "default" | "pill";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,56 @@
+import { type HTMLAttributes } from "vue";
+export interface ToggleOption {
+    label: string;
+    value: string;
+    icon?: string;
+    disabled?: boolean;
+    tooltip?: string;
+}
+export interface BouncyToggleProps {
+    options: ToggleOption[];
+    modelValue: string | string[];
+    multiSelect?: boolean;
+    /** "default" = subtle muted slider; "pill" = solid foreground pill */
+    variant?: "default" | "pill";
+    /**
+     * Tab-row overflow handling.
+     * - `"none"` (default) — inline-grid with `1fr` tracks; tabs share width
+     *   and clip when content exceeds the parent.
+     * - `"scroll"` — flex row with intrinsic-width tracks + `.scroll-fade-mask`
+     *   + `.scrollbar-hidden`; tab text never truncates and overflowing tabs
+     *   scroll horizontally with edge fades.
+     * - `"auto"` — flex row with intrinsic widths and a horizontal scroll
+     *   fallback (no fade); useful when the parent already owns the affordance.
+     */
+    overflow?: "none" | "scroll" | "auto";
+    class?: HTMLAttributes["class"];
+}
+declare var __VLS_19: {
+    option: ToggleOption;
+    active: boolean;
+}, __VLS_27: {
+    option: ToggleOption;
+    active: boolean;
+};
+type __VLS_Slots = {} & {
+    option?: (props: typeof __VLS_19) => any;
+} & {
+    option?: (props: typeof __VLS_27) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<BouncyToggleProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string | string[]) => any;
+}, string, import("vue").PublicProps, Readonly<BouncyToggleProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | string[]) => any) | undefined;
+}>, {
+    overflow: "none" | "scroll" | "auto";
+    variant: "default" | "pill";
+    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;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,17 @@
+import { type HTMLAttributes } from "vue";
+export interface TabOption {
+    label: string;
+    value: string;
+}
+type __VLS_Props = {
+    options: TabOption[];
+    modelValue: string;
+    class?: HTMLAttributes["class"];
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/custom/timeline/ContinuousTimeline.vue.d.ts

@@ -0,0 +1,118 @@
+import type { TimelineSegment } from "./types";
+/**
+ * <ContinuousTimeline> — ONE rounded-pill rail substrate with N
+ * absolute-positioned region children spanning prev-boundary →
+ * current-boundary. Internal variant SFC dispatched from
+ * <GlassTimeline variant="continuous">.
+ *
+ * AA.W1 / A4 §S-17 + AB.W2.T1+T4. Used by multi-phase progress UIs where
+ * the phases are conceptually one progression bar (speedtest ping →
+ * download → upload).
+ *
+ * AB.W2.T4 (A4 §nested-interactive — Option C): the progressbar rail and
+ * the interactive marker buttons are rendered as SIBLINGS, not as
+ * parent/child. `.continuous-track[role="progressbar"]` is a
+ * non-interactive aggregate-progress surface; `.continuous-markers
+ * ul[role="list"]` is the focusable marker overlay.
+ *
+ * AB.W2.T2 (A4 §B2.c): each marker button is wrapped in <HoverPopover>
+ * so hover surfaces a color-coded popover with the segment's
+ * `{ label, value, description, state }`. Consumers override the
+ * popover body via the scoped `#popoverContent` slot.
+ *
+ * AB.W2.T3 (A2 §B2.b): the `currentSegmentKey` prop 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. Hover affects the popover only; the
+ * underlying current marker survives hover-leave.
+ *
+ * NON-SCOPED <style> CONTRACT (O.W3 Lane A — Rβ §3.1): the
+ * `.timeline-popover` rules live in a non-scoped <style> block at the
+ * bottom of THIS SFC because HoverCardPortal escapes scoped CSS. The
+ * rules must live in a component that participates in the continuous
+ * render path; this is that component.
+ *
+ * AI.W1-δ `#detail` slot (post-RD-3 §4): the continuous variant emits an
+ * optional `#detail` scoped slot rendered as a sibling of the rail wrap,
+ * payload-rich with `{ segment, source, currentKey, hoveredKey }`. The
+ * primitive owns the effective-segment resolution (hovered ?? current);
+ * consumers own the choreography (e.g., a `<Transition mode="out-in">`
+ * fade-swap keyed on the segment's stable key). The slot mount carries
+ * a `min-height` reservation via `--timeline-detail-min-height` so
+ * idle ↔ active transitions do not reflow the surrounding layout.
+ * Speedtest's `PhaseTimelineDetailPanel` is the canonical consumer
+ * (absorbed in AI.W1-δ).
+ */
+type __VLS_Props = {
+    segments?: TimelineSegment[];
+    /**
+     * Optional aria-label for the rail (role=progressbar). Falls back
+     * to a comma-joined list of segment labels when omitted.
+     */
+    ariaLabel?: string;
+    /**
+     * AB.W2.T3 — current segment key. Stamps `data-current="true"`
+     * on the matching marker (and `data-completed="true"` on prior
+     * markers, derived from each segment's `state`). Hover affects
+     * the popover only; the current marker survives hover-leave so
+     * the panel's current-phase binding does not flicker.
+     */
+    currentSegmentKey?: string;
+    /**
+     * AB.W2.T2 — disable the default per-marker HoverPopover.
+     * Useful when a consumer wants to fully own the hover affordance
+     * (e.g. anchor a single popover externally). The dot still emits
+     * `hover` / `click` events.
+     */
+    disablePopover?: boolean;
+};
+declare var __VLS_11: {
+    segment: TimelineSegment;
+}, __VLS_13: {
+    segment: TimelineSegment | null;
+    source: "idle" | "current" | "hovered";
+    currentKey: string | null;
+    hoveredKey: string | null;
+};
+type __VLS_Slots = {} & {
+    popoverContent?: (props: typeof __VLS_11) => any;
+} & {
+    detail?: (props: typeof __VLS_13) => 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;
+    hoverEnd: (payload: {
+        key: string;
+        segment: TimelineSegment;
+    }) => 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;
+    onHoverEnd?: ((payload: {
+        key: string;
+        segment: TimelineSegment;
+    }) => any) | undefined;
+}>, {
+    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/custom/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;
+    "update:modelValue": (v: number) => any;
+    hover: (payload: {
+        key: string;
+        segment: TimelineSegment;
+    }) => 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;
+    "onUpdate:modelValue"?: ((v: number) => any) | undefined;
+    onHover?: ((payload: {
+        key: string;
+        segment: TimelineSegment;
+    }) => 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/custom/timeline/ScrubberTimeline.vue.d.ts

@@ -0,0 +1,29 @@
+/**
+ * <ScrubberTimeline> — single-track normalized 0..1 scrubber.
+ *
+ * Internal variant SFC dispatched from <GlassTimeline variant="scrubber">.
+ * Owns the pre-Z.W2 single-track contract: pointer-capture drag, keyboard
+ * a11y (role=slider + arrow-key step + shift-step), `label` tooltip caret.
+ *
+ * AA.A4 §S-16 — the `aria-valuenow` binding coerces `Number(modelValue ?? 0)`
+ * so a numeric attribute always renders (axe `aria-required-attr` regression).
+ */
+type __VLS_Props = {
+    /** 0..1 scrubber position. */
+    modelValue?: number;
+    /** Tooltip caret text. */
+    label?: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (v: number) => any;
+    scrubStart: () => any;
+    scrubEnd: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((v: number) => any) | undefined;
+    onScrubStart?: (() => any) | undefined;
+    onScrubEnd?: (() => any) | undefined;
+}>, {
+    modelValue: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/custom/timeline/SegmentedTimeline.vue.d.ts

@@ -0,0 +1,46 @@
+import type { TimelineSegment } from "./types";
+/**
+ * <SegmentedTimeline> — adjacent gradient bands with boundary dots.
+ *
+ * Internal variant SFC dispatched from <GlassTimeline variant="segmented">.
+ * Per Z.W2.T1 / A2 §B5. Speedtest consumes this as a 3-cell
+ * (ping/download/upload) progress timeline; gradient endpoints map to
+ * per-phase chart-color tokens. Visual shape: N rectangles in a row.
+ *
+ * Each cell owns its own gradient background and per-state fill; the
+ * boundary dot is a button anchored to the right edge of each cell
+ * (the boundary between this cell and the next, or the timeline
+ * terminus).
+ */
+type __VLS_Props = {
+    segments?: TimelineSegment[];
+};
+declare const __VLS_export: 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;
+    hoverEnd: (payload: {
+        key: string;
+        segment: TimelineSegment;
+    }) => 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;
+    onHoverEnd?: ((payload: {
+        key: string;
+        segment: TimelineSegment;
+    }) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/custom/timeline/geometry.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Timeline shared geometry — pure math + payload helpers used by ≥ 2 of
+ * the variant SFCs (ScrubberTimeline / SegmentedTimeline / ContinuousTimeline).
+ *
+ * Split out of the prior monolithic `GlassTimeline.vue` per O.W3 Lane A —
+ * the geometry was identical across the segmented + continuous variants,
+ * and the popover-payload helper is consumed only by the continuous variant
+ * today but its shape (the AA-canonical `{ label, value, description, state }`
+ * envelope) is documented as the shared per-segment hover-payload contract.
+ *
+ * All exports are pure functions or type aliases — no Vue runtime imports,
+ * no side effects. The factory `createContinuousGeometry(segmentsRef)`
+ * returns the `totalWeight` + region/boundary helpers bound to a live
+ * `Ref<TimelineSegment[]>`, so the continuous SFC can drop them straight
+ * into its `<script setup>`.
+ */
+import { type ComputedRef, type Ref } from "vue";
+import type { TimelineSegment } from "./types";
+/**
+ * Resolve a segment's gradient declaration to a CSS background expression.
+ * - `string` (raw CSS): consumed verbatim — caller controls direction.
+ * - `{from, to}` pair: expanded to `linear-gradient(90deg, from, to)`.
+ * - undefined: falls through to the `--timeline-segment-default-gradient`
+ *   token (consumer can override on the primitive or via a section-tone).
+ */
+export declare function gradientFor(seg: TimelineSegment): string;
+/**
+ * Fill percentage per state. Explicit `progress` wins; otherwise the
+ * canonical mapping (pending=0, active=0.5, completed=1). Clamped to
+ * [0, 1] so consumers can't paint past the segment box.
+ */
+export declare function fillFor(seg: TimelineSegment): number;
+/** Resolve a segment's positive weight; defaults to 1. */
+export declare function segmentWeight(seg: TimelineSegment): number;
+/**
+ * Bind continuous-variant geometry helpers to a live `Ref<TimelineSegment[]>`.
+ * Returns the `totalWeight` ComputedRef + per-index region geometry
+ * (regionLeft, regionWidth, boundaryX) + the rail's aggregate aria-valuenow
+ * computation. The continuous SFC pulls these into its `<script setup>`.
+ */
+export declare function createContinuousGeometry(segments: Ref<TimelineSegment[]>): {
+    totalWeight: ComputedRef<number>;
+    regionLeft: (i: number) => number;
+    regionWidth: (i: number) => number;
+    boundaryX: (i: number) => number;
+    continuousAriaValueNow: ComputedRef<number>;
+};
+/**
+ * Build the ONE rail-spanning stitched gradient for the continuous
+ * variant. Each phase's colour is anchored as a stop at the CENTRE of
+ * its weight-share so the pure hue sits mid-phase and the hues cross-
+ * fade smoothly through every boundary. The first and last stops are
+ * pinned to 0% / 100% so the bar's ends saturate fully (no washed
+ * leading/trailing edge). Returns a `linear-gradient(90deg, …)` string
+ * sized to the FULL rail width.
+ */
+export declare function stitchedRailGradient(segments: TimelineSegment[]): string;
+/**
+ * Per-region windowing parameters for the stitched rail gradient. The
+ * region paints the FULL-rail gradient (`stitchedRailGradient`) but only
+ * its own slice is visible inside the region box. To window correctly
+ * the region's `background-size-x` is scaled to `1 / regionWidth` of the
+ * region box (so the full gradient spans `regionWidth` of the rail) and
+ * the `background-position-x` is offset so the region's left edge aligns
+ * with the rail-fraction `regionLeft`.
+ *
+ * `sizeX`     — CSS `background-size` x value, e.g. `"333.333%"`.
+ * `positionX` — CSS `background-position` x value, e.g. `"50%"`.
+ *
+ * background-position interpolates the image's `(size - box)` overflow,
+ * so the position fraction is `regionLeft / (1 - regionWidth)` (guarded
+ * for the degenerate single-region `regionWidth == 1` case).
+ */
+export declare function stitchedRegionWindow(regionLeft: number, regionWidth: number): {
+    sizeX: string;
+    positionX: string;
+};
+/**
+ * Continuous-variant active-region fill width (0..1, applied as a clip
+ * mask on the region's right edge for partial-fill animation). For
+ * `completed` returns 1; for `pending` returns 0; for `active` returns
+ * `fillFor(seg)` (which honours explicit `progress` overrides).
+ */
+export declare function continuousFillWidth(seg: TimelineSegment): number;
+/**
+ * AB.W2.T2 — default popover content payload shape.
+ *
+ * Reads `value` shape if the consumer supplied the AA-canonical
+ * `{ label, value, description, state }` payload (the speedtest
+ * PhaseDetail), otherwise falls back to the segment's own label/state.
+ * The slot scope exposes the full segment so consumers can override
+ * entirely.
+ */
+export interface DefaultPopoverPayload {
+    label?: string;
+    value?: unknown;
+    description?: string;
+    state?: string;
+}
+export declare function popoverPayloadFor(seg: TimelineSegment): DefaultPopoverPayload;

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

@@ -0,0 +1,2 @@
+export { default as GlassTimeline } from "./GlassTimeline.vue";
+export type { TimelineSegment, TimelineSegmentGradient, TimelineSegmentState, } from "./types";

package/dist/components/custom/timeline/types.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Timeline primitive types — segmented + continuous variants.
+ *
+ * Per Z.W2.T1 / A2 §B5 + AA.W1 / A4 §S-17. The default `scrubber` variant
+ * (single-track YouTube-style scrubber) keeps its original numeric model;
+ * `segmented` (Z.W2) renders adjacent gradient bands with hover/click dots;
+ * `continuous` (AA.W1) renders ONE pill rail with N absolute-positioned
+ * region children. Both array-variants consume the same `TimelineSegment[]`
+ * data shape — only the rendering geometry differs.
+ */
+/** Per-segment lifecycle. Drives fill + dot states. */
+export type TimelineSegmentState = "pending" | "active" | "completed";
+/**
+ * Gradient endpoints. Either a raw CSS expression (linear-gradient(...))
+ * or a `{ from, to }` token pair the primitive expands into a 90deg
+ * left-to-right linear-gradient. Accepts CSS color, color-mix(...), or
+ * `var(--token)` references.
+ */
+export interface TimelineSegmentGradient {
+    from: string;
+    to: string;
+}
+export interface TimelineSegment {
+    /** Stable identifier emitted on hover/click. Must be unique per timeline. */
+    key: string;
+    /** Display name. Surfaces in the boundary-dot tooltip. */
+    label: string;
+    /** Lifecycle state — drives fill percentage + dot affordance. */
+    state: TimelineSegmentState;
+    /**
+     * Optional progress within the segment (0..1). When omitted, falls
+     * back to: 1 for `completed`, 0 for `pending`, 0.5 for `active`.
+     * Reduced-motion consumers may pin this to `1`/`0` to suppress mid-
+     * segment animation while retaining final-state visibility.
+     */
+    progress?: number;
+    /**
+     * Per-segment gradient. Either a `{from, to}` pair (default 90deg
+     * left-to-right) or a raw CSS gradient string the primitive consumes
+     * verbatim. Falls back to a section-tone via the
+     * `--timeline-segment-default-gradient` token when omitted.
+     */
+    gradient?: TimelineSegmentGradient | string;
+    /**
+     * Optional payload surfaced via the `hover` / `click` events. Common
+     * shapes: formatted value strings ("145.3 Mbps"), per-phase metric
+     * objects, or `null` for pending segments.
+     */
+    value?: unknown;
+    /**
+     * Optional relative weight for the `continuous` variant region width
+     * (default `1` — equal share). Per-segment widths are computed as
+     * `weight / sum(weights)`. Ignored by the `segmented` variant (which
+     * uses CSS flex distribution via `--timeline-segment-flex`).
+     */
+    weight?: number;
+}

package/dist/components/custom/toggle-chip/ToggleChip.vue.d.ts

@@ -0,0 +1,39 @@
+/**
+ * ToggleChip — accessible toggleable "chip" or "cell" selector, built
+ * on reka-ui's Toggle root so it carries proper `aria-pressed` and
+ * keyboard semantics. Pair with `variant="chip"` for inline horizontal
+ * selectors or `variant="cell"` for square icon + label cards.
+ *
+ * Usage:
+ *   <ToggleChip v-model:pressed="isActive" variant="chip">
+ *     Label
+ *   </ToggleChip>
+ *
+ * When multiple chips share an exclusive selection, wire them up via
+ * `pressed` / `@update:pressed` rather than reaching for ToggleGroup —
+ * this component is deliberately unopinionated about selection mode.
+ */
+import type { HTMLAttributes } from "vue";
+import { type ToggleProps } from "reka-ui";
+import { type ToggleChipVariants } from ".";
+type __VLS_Props = ToggleProps & {
+    variant?: ToggleChipVariants["variant"];
+    class?: HTMLAttributes["class"];
+};
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => 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/custom/toggle-chip/index.d.ts

@@ -0,0 +1,17 @@
+import { type VariantProps } from "class-variance-authority";
+export { default as ToggleChip } from "./ToggleChip.vue";
+/**
+ * Shared toggleable "chip" / "cell" primitive for selector grids.
+ *
+ * `chip` — inline horizontal token (e.g. tag pickers, tool-filter rows).
+ * `cell` — square card that stacks an icon/preview over a label
+ *          (e.g. pose pickers, palette swatches, emotion pickers).
+ *
+ * The `data-state="on"` attribute is set by the reka-ui Toggle root
+ * when pressed, so selected styling hangs off the data attribute and
+ * doesn't need a class-binding at the call site.
+ */
+export declare const toggleChipVariants: (props?: ({
+    variant?: "cell" | "chip" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type ToggleChipVariants = VariantProps<typeof toggleChipVariants>;