@mkbabb/glass-ui 4.1.0 → 5.0.0

package/dist/components/metric-cell/MetricCell.vue.d.ts

@@ -0,0 +1,108 @@
+import type { Component, FunctionalComponent, HTMLAttributes } from "vue";
+import { type MetricValue } from "../metric/coalesce-metric";
+/**
+ * Permissive icon type — Vue's `Component` type ships across multiple
+ * package boundaries (vue / @vue/runtime-core duplication when consumers
+ * symlink-resolve through workspace links). Accept the structural shape
+ * a Vue render expression handles: any `Component`, `FunctionalComponent`,
+ * or a generic object/function. The `<component :is>` binding receives
+ * the value transparently.
+ */
+type IconLike = Component | FunctionalComponent | object | null;
+/**
+ * MetricCell — compact metric card (icon-on-label, stacked value + unit) on
+ * a wash-tier glass surface.
+ *
+ * AC.W8e (glass-ui v1.7.0) — promoted from speedtest's
+ * `<ResultDetailSheet>` 4-card grid (download / upload / ping / jitter).
+ * The original consumer had the same 11-class string repeated four times:
+ *
+ *     <div class="glass-wash rounded-lg p-3">
+ *         <div class="text-micro text-muted-foreground flex items-center gap-1.5">
+ *             <component :is="icon" :size="14" :stroke-width="2" />
+ *             <span>Download</span>
+ *         </div>
+ *         <div class="text-mono-prose font-semibold tabular-nums">
+ *             {{ fmt(row.download, "Mbps") }}
+ *         </div>
+ *     </div>
+ *
+ * The shape is generic enough that any dashboard / detail-sheet / summary
+ * surface composing icon + label + value + unit on a tile hits the same
+ * gestalt; the primitive collapses the 4-site duplication onto one consume.
+ *
+ * Owns:
+ *  - the wash-tier surface (`.glass-wash rounded-lg p-3`) by default; the
+ *    `appearance="bare"` variant drops the surface for consumers that host
+ *    the cell inside a larger panel.
+ *  - the label row (`.text-micro .text-muted-foreground flex items-center
+ *    gap-1.5`) with icon prefix + label text.
+ *  - the value row (`.text-mono-prose .font-semibold .tabular-nums`) with
+ *    optional unit suffix.
+ *  - tabular-numeric digit metrics + lining figures via `tabular-nums`.
+ *
+ * The `compact` appearance trades `text-mono-prose` for `text-mono-caption`
+ * + smaller padding so the cell composes inside dense grids.
+ */
+export type MetricCellAppearance = "dashboard" | "compact" | "bare";
+export interface MetricCellProps {
+    /**
+     * Optional lucide icon component. Renders at 14px stroke-2 inside
+     * the label row. Pass `null` to omit; the `icon` slot overrides.
+     */
+    icon?: IconLike;
+    /** Stroke width for the lucide icon. Defaults to 2. */
+    iconStrokeWidth?: number;
+    /** Icon pixel size — defaults to 14 (matches `text-micro` cap height). */
+    iconSize?: number;
+    /**
+     * Optional accent colour for the LEADING GLYPH ONLY (e.g. a semantic
+     * `var(--chart-download)` viz colour). Tints the icon — the one
+     * deliberate colour event for the cell — while the label, value, and unit
+     * stay neutral ink (the one-color-event proportion rule, AZ.W-SUFFUSE D3).
+     * Unset (default) keeps the glyph the neutral `--muted-foreground` of the
+     * label row.
+     */
+    iconColor?: string;
+    /** Label text — reads through the `label` slot when set. */
+    label?: string;
+    /** Value — primary metric. Reads through the `value` slot when set. A valid
+     *  `0` renders `"0"`, never the placeholder. */
+    value?: MetricValue;
+    /** Unit suffix appended after the value (e.g. "Mbps", "ms"). */
+    unit?: string;
+    /** Placeholder glyph when value is empty/null. Defaults to em-dash (the
+     *  shared `coalesceMetric` default). */
+    placeholder?: string;
+    /**
+     * Visual register.
+     * - `dashboard` (default) — wash-tier surface, `text-mono-prose`
+     *   value, `p-3`.
+     * - `compact` — wash-tier surface, `text-mono-small` value, `p-2`.
+     * - `bare` — no surface, no padding; the cell composes inside a
+     *   pre-styled host.
+     */
+    appearance?: MetricCellAppearance;
+    class?: HTMLAttributes["class"];
+}
+declare var __VLS_1: {}, __VLS_8: {}, __VLS_10: {};
+type __VLS_Slots = {} & {
+    icon?: (props: typeof __VLS_1) => any;
+} & {
+    label?: (props: typeof __VLS_8) => any;
+} & {
+    value?: (props: typeof __VLS_10) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<MetricCellProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MetricCellProps> & Readonly<{}>, {
+    appearance: MetricCellAppearance;
+    iconStrokeWidth: number;
+    iconSize: number;
+}, {}, {}, {}, 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/metric-stack/MetricRow.vue.d.ts

@@ -0,0 +1,120 @@
+import type { HTMLAttributes, Component } from "vue";
+import { type MetricValue } from "../metric/coalesce-metric";
+/**
+ * MetricRow — a single row inside <MetricStack>.
+ *
+ * Reads three subgrid tracks from the parent stack: icon | label | value.
+ * The value track carries a baseline-aligned inline group of value + unit
+ * so the row reads "240 Mbps" as one typographic lockup, not two grid
+ * cells. The optional description slot promotes to a full-row block at
+ * `@container metric-stack (min-width: 32rem)`.
+ *
+ * Owns:
+ *  - the audacious-poster value clamp (`clamp(4.5rem, 34cqi × 3/max(3,
+ *    --digit-count), --type-display-hero)`) — consumers pass digitCount so
+ *    4-digit values shrink proportionally and stay inside the column.
+ *  - the tabular-nums + ss01 + lnum font-feature register on the value
+ *    cell so digits sit on tabular metrics regardless of consumer typography.
+ *  - the optional `aura` slot host: the slot sits at `position: absolute;
+ *    inset: 0` inside `.metric-row__value`, with the host marked
+ *    `position: relative`. Consumers compose <Pulse variant="aura"> there
+ *    when the row is the active metric.
+ *  - per-row tint via `--phase-color` (inline style on `.metric-row` — set
+ *    by the consumer per metric) cascading to value + unit when
+ *    `data-color-tinted="true"`.
+ *
+ * AC.W6d — promoted from speedtest/ResultStack.vue's `.result-row` block.
+ * Consumers stop hand-rolling the subgrid + clamp + aura host CSS and
+ * instead pass props.
+ */
+export interface MetricRowProps {
+    /**
+     * Optional lucide icon component (e.g. `MoveDown`). Renders inside
+     * the icon track at 16×16 by default. Pass `null` to omit; the
+     * slot named `icon` overrides.
+     */
+    icon?: Component | null;
+    /** Stroke width for the lucide icon. */
+    iconStrokeWidth?: number;
+    /** Icon pixel size — defaults to 16. */
+    iconSize?: number;
+    /** Label text — reads through the label slot when set. */
+    label?: string;
+    /** Value text (the audacious-poster hero number). A valid `0` renders
+     *  `"0"`, never the placeholder. */
+    value?: MetricValue;
+    /** Unit suffix — reads through the unit slot when set. */
+    unit?: string;
+    /** Placeholder glyph when value is empty/null. Defaults to "—" (the shared
+     *  `coalesceMetric` default). */
+    placeholder?: string;
+    /**
+     * Per-row phase colour. Sets `--phase-color` inline so descendant
+     * tints (value, unit, aura) consume the colour through the cascade.
+     * Consumers that wire tints through Tailwind tokens may pass
+     * `var(--chart-download)` etc.
+     */
+    phaseColor?: string;
+    /**
+     * Digit-count knob for the value clamp. The value cell shrinks as
+     * `3 / max(3, digitCount)` so 4-digit values still fit the cell.
+     * Pass the rendered string length; defaults to 3.
+     */
+    digitCount?: number;
+    /**
+     * When `true`, descendant value + unit promote from the neutral
+     * `--foreground` colour to `var(--phase-color)`. Drives the
+     * post-complete colour-tint cascade.
+     */
+    colorTinted?: boolean;
+    /**
+     * When `true`, the `aura` slot becomes visible. Consumers wire
+     * this to their active-row gating (e.g. the metric being sampled).
+     */
+    active?: boolean;
+    /**
+     * BC.W-CONTROL-CUSTOM (CP1, the speedtest-AX `data-protagonist` fold) —
+     * marks this row as the ONE focal/protagonist metric per surface. When
+     * `true`, the value lifts to the emphasis register (the heavier
+     * `--metric-row-value-weight-emphasis` rung) and a `data-protagonist`
+     * attribute lands on the row so a consumer can re-tint the focal metric.
+     *
+     * This is the ONE focal emphasis event per surface (the W-SUFFUSE
+     * one-color-event proportion) — exactly one row per <MetricStack> should
+     * be the protagonist. The magnitude stays a `--metric-row-*` token read
+     * with a fallback, so a `:root`/per-row override of the emphasis weight
+     * cascades. A bare (`protagonist`-unset) row is byte-identical.
+     */
+    protagonist?: boolean;
+    class?: HTMLAttributes["class"];
+}
+declare var __VLS_1: {}, __VLS_8: {}, __VLS_10: {}, __VLS_12: {}, __VLS_14: {}, __VLS_16: {};
+type __VLS_Slots = {} & {
+    icon?: (props: typeof __VLS_1) => any;
+} & {
+    label?: (props: typeof __VLS_8) => any;
+} & {
+    aura?: (props: typeof __VLS_10) => any;
+} & {
+    value?: (props: typeof __VLS_12) => any;
+} & {
+    unit?: (props: typeof __VLS_14) => any;
+} & {
+    description?: (props: typeof __VLS_16) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<MetricRowProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MetricRowProps> & Readonly<{}>, {
+    active: boolean;
+    digitCount: number;
+    iconStrokeWidth: number;
+    iconSize: number;
+    colorTinted: boolean;
+    protagonist: 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/notification/Notification.vue.d.ts

@@ -0,0 +1,16 @@
+interface Notification {
+    id: string;
+    tone: 'success' | 'warning' | 'info' | 'destructive';
+    message: string;
+    duration?: number;
+}
+type __VLS_Props = {
+    notifications: Notification[];
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    remove: (id: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onRemove?: ((id: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/pager-dots/composables/usePagerWorm.d.ts

@@ -0,0 +1,26 @@
+import type { ComputedRef, Ref } from "vue";
+export interface UsePagerWormRefs {
+    /** The rail root — the token reads + the resize re-seat anchor to this box. */
+    rootEl: Ref<HTMLElement | null>;
+    /** The worm layer — the bodies/neck's positioning context (the coordinate origin). */
+    wormLayerEl: Ref<HTMLElement | null>;
+    /** The two round pip-bodies + the welling concave neck (the three worm masses). */
+    bodyAEl: Ref<HTMLElement | null>;
+    bodyBEl: Ref<HTMLElement | null>;
+    neckEl: Ref<HTMLElement | null>;
+    /** The bed pip map (keyed by slide index) — the worm reads its painted centers. */
+    bedDotEls: Map<number, HTMLElement>;
+    /** The currently-shown (windowed) slide indices. */
+    shown: ComputedRef<number[]>;
+    /** Whether the rail axis is vertical. */
+    vertical: ComputedRef<boolean>;
+    /** The active 0-based index (the `v-model:active` ref). */
+    active: Ref<number>;
+}
+/**
+ * Wire the pager's two-edge worm — the barbell projection off the lead/trail edges +
+ * the `useLeadTrail` driver + the active/shown/resize watchers. Installs the watchers
+ * + the mount snap; owns no template/style/bed-maps (the SFC keeps those). All motion
+ * is compositor-only; NEVER an animated layout property.
+ */
+export declare function usePagerWorm(refs: UsePagerWormRefs): void;

package/dist/components/pager-dots/constants.d.ts

@@ -0,0 +1,15 @@
+/** Fallback pip diameter (px) when `--pager-dot-size` cannot be read (the worm body D). */
+export declare const DEFAULT_DOT_PX = 13;
+/** Fallback root font-size (px) when resolving a rem `--pager-dot-size`. */
+export declare const DEFAULT_ROOT_PX = 16;
+/** Fallback `--pager-dot-size` in rem (0.8125rem = 13px base pip). */
+export declare const DEFAULT_DOT_REM = 0.8125;
+/** Fallback max worm elongation (px) when `--pager-dot-elongated` cannot be read —
+ *  the clamp on the lead↔trail gap so a multi-hop worm travels bounded, never taffy. */
+export declare const DEFAULT_ELONGATED_PX = 36;
+/** Fallback max-stretch cap (`--pager-worm-max-stretch`) — the LOW velocity-swell
+ *  band (BI.W-PAGER-WORM R10; 1.08–1.2), the 1.45 taffy value retired. */
+export declare const DEFAULT_MAX_STRETCH = 1.2;
+/** The metaball NECK girth (the dumbbell-shoulder bridge height between the two
+ *  pip-bodies, ~0.7·D) — a tighter, gooier waist than the wider carousel. */
+export declare const PAGER_NECK_GIRTH = 0.7;

package/dist/components/popover/Popover.vue.d.ts

@@ -0,0 +1,54 @@
+import type { PopoverRootProps } from "reka-ui";
+import type { Trigger } from "../_shared/axes";
+type __VLS_Props = Omit<PopoverRootProps, "open"> & {
+    /** The trigger axis — click (default) · hover · context. */
+    trigger?: Trigger;
+    /** ms before the fine-hover branch opens (HoverCardRoot). */
+    openDelay?: number;
+    /** ms before the fine-hover branch closes on leave. */
+    closeDelay?: number;
+    /**
+     * Hold the parent `<GlassDock>` open while this popover is visible.
+     * The ONE `watch(open)` below serves BOTH roots — no-op outside a
+     * dock context (the inject falls back to null).
+     */
+    keepDockOpen?: boolean;
+};
+type __VLS_ModelProps = {
+    /**
+     * Public `v-model:open` — `defineModel` with NO default. reka's HoverCardRoot
+     * (and PopoverRoot) evaluate `passive: props.open === void 0` at setup, so a
+     * defaulted `false` would FORCE the controlled path and swallow the uncontrolled
+     * hover cadence. Undefined → passive/uncontrolled (reka owns state, emits
+     * `update:open`); a parent that binds `v-model:open` receives the debounced
+     * `update:open` re-emit (defineModel re-emits when reka writes the ref through
+     * the `v-model:open` binding on the reka root — the outer re-emit is wired, not a
+     * silent no-op).
+     */
+    "open"?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_8: {}, __VLS_17: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+} & {
+    default?: (props: typeof __VLS_17) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean | undefined) => any) | undefined;
+}>, {
+    trigger: Trigger;
+    openDelay: number;
+    closeDelay: number;
+    keepDockOpen: 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/popover/PopoverContent.vue.d.ts

@@ -0,0 +1,53 @@
+import { type HTMLAttributes } from "vue";
+import { type PopoverContentProps } from "reka-ui";
+import { type Surface } from "../_shared/useSurfaceAxis";
+type PopoverRole = "dialog" | "card";
+type __VLS_Props = PopoverContentProps & {
+    class?: HTMLAttributes["class"];
+    portal?: boolean;
+    surface?: Surface;
+    /** `dialog` (default click/context) · `card` (→ role="group"). */
+    role?: PopoverRole;
+    /** Accessible name passthrough for the `role="group"` card surface. */
+    ariaLabel?: string;
+};
+declare var __VLS_14: {}, __VLS_29: {}, __VLS_38: {}, __VLS_53: {}, __VLS_62: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_14) => any;
+} & {
+    default?: (props: typeof __VLS_29) => any;
+} & {
+    default?: (props: typeof __VLS_38) => any;
+} & {
+    default?: (props: typeof __VLS_53) => any;
+} & {
+    default?: (props: typeof __VLS_62) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    escapeKeyDown: (event: KeyboardEvent) => any;
+    pointerDownOutside: (event: import("reka-ui").PointerDownOutsideEvent) => any;
+    focusOutside: (event: import("reka-ui").FocusOutsideEvent) => any;
+    interactOutside: (event: import("reka-ui").PointerDownOutsideEvent | import("reka-ui").FocusOutsideEvent) => any;
+    openAutoFocus: (event: Event) => any;
+    closeAutoFocus: (event: Event) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: import("reka-ui").PointerDownOutsideEvent) => any) | undefined;
+    onFocusOutside?: ((event: import("reka-ui").FocusOutsideEvent) => any) | undefined;
+    onInteractOutside?: ((event: import("reka-ui").PointerDownOutsideEvent | import("reka-ui").FocusOutsideEvent) => any) | undefined;
+    onOpenAutoFocus?: ((event: Event) => any) | undefined;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
+}>, {
+    align: "center" | "start" | "end";
+    surface: Surface;
+    sideOffset: number;
+    portal: 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/popover/PopoverTrigger.vue.d.ts

@@ -0,0 +1,16 @@
+import { type PopoverTriggerProps } from "reka-ui";
+declare var __VLS_8: {}, __VLS_17: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+} & {
+    default?: (props: typeof __VLS_17) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<PopoverTriggerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<PopoverTriggerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/popover/popoverContext.d.ts

@@ -0,0 +1,17 @@
+import type { ComputedRef } from "vue";
+export interface PopoverUnionContext {
+    /**
+     * `true` when the fine-hover HoverCardRoot branch is live; `false` → the
+     * PopoverRoot branch (click / context / coarse-pointer-promoted hover). A
+     * coarse-pointer hover trigger resolves `false` — reka's `excludeTouch`
+     * leaves the hover root structurally dead on touch, so the union promotes it
+     * to the tap-toggle PopoverRoot.
+     */
+    usesHoverRoot: ComputedRef<boolean>;
+}
+/** The typed injection key (exported so an external provider can target it). */
+export declare const POPOVER_UNION_KEY: import("vue").InjectionKey<PopoverUnionContext>;
+/** `<Popover>` provides the resolved-root flag to its compound children. */
+export declare const providePopoverUnion: (ctx: PopoverUnionContext) => void;
+/** Inject the union context; `null` outside a union `<Popover>` (→ click branch). */
+export declare const usePopoverUnion: () => PopoverUnionContext | null;

package/dist/components/progress/Progress.vue.d.ts

@@ -0,0 +1,54 @@
+import { type HTMLAttributes } from "vue";
+import type { ProgressRootProps } from "reka-ui";
+import type { ProgressSegment } from "./useProgressGeometry";
+type ProgressVariant = "default" | "gradient" | "liquid" | "sectioned";
+/**
+ * Progress — the thin variant dispatcher over four orthogonal designs:
+ *   - `default`   → ProgressDefault   (plain rail + translateX intake-pulse)
+ *   - `gradient`  → ProgressGradient  (lifecycle motion grammar + indeterminate)
+ *   - `liquid`    → ProgressLiquid    (the shared .glass-liquid-fill glass cylinder;
+ *                                      the phase-colour meter — BG.W-LIQUID-FILL)
+ *   - `sectioned` → ProgressSectioned (phase-bus cells + spring active fill)
+ *
+ * The dispatcher carries an EXPLICIT prop-boundary contract: incompatible prop
+ * combinations are refused OUT LOUD (a dev throw) rather than silently producing
+ * a wrong paint. The historical break this closes: a consumer passing
+ * `:model-value` to the sectioned variant had it SILENTLY overridden by the
+ * cumulative cell-fill aggregate, so the bar ignored the value the consumer
+ * thought drove it. The contract below makes that misuse a loud error — the
+ * sectioned variant derives its own a11y value from the cells; `modelValue` is
+ * not its truth.
+ */
+type __VLS_Props = ProgressRootProps & {
+    class?: HTMLAttributes["class"];
+    /**
+     * 'default'   = bg-secondary rail + bg-primary indicator.
+     * 'gradient'  = rail respects --progress-track; indicator respects
+     *               --progress-fill; the W4 lifecycle motion grammar layers on.
+     * 'liquid'    = the shared .glass-liquid-fill glass-cylinder meter
+     *               (BG.W-LIQUID-FILL) — the fill tints off --progress-fill
+     *               (or --liquid-fill-tint) with zero per-site glass knowledge.
+     * 'sectioned' = phase-bus (AB.W3.T2). N colour-coded cells with gradient
+     *               seams; the active cell carries a spring fill. The per-cell
+     *               state map is the truth — NOT `modelValue`.
+     */
+    variant?: ProgressVariant;
+    /** Sectioned only — ordered segment list. */
+    segments?: ProgressSegment[];
+    /** Sectioned only — key of the currently active segment. */
+    currentSegmentKey?: string | null;
+    /** Sectioned only — 0..1 fill of the active segment. */
+    activeProgress?: number;
+    /** Gradient only — indeterminate sweep opt-in. */
+    indeterminate?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    variant: ProgressVariant;
+    modelValue: number | null;
+    indeterminate: boolean;
+    segments: ProgressSegment[];
+    currentSegmentKey: string | null;
+    activeProgress: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/progress/ProgressLiquid.vue.d.ts

@@ -0,0 +1,21 @@
+import { type HTMLAttributes } from "vue";
+import { type ProgressRootProps } from "reka-ui";
+/**
+ * Liquid progress variant (BG.W-LIQUID-FILL) — the meter's fill is the ONE shared
+ * `.glass-liquid-fill` register, the glass-cylinder fill EXTRACTED from Slider. The
+ * rail is the recessed `--progress-track` channel; the indicator is a warm glass
+ * cylinder that grows with `modelValue` via `translateX`.
+ *
+ * PHASE-COLOUR COMPOSABLE, ZERO PER-SITE GLASS KNOWLEDGE. The tint rides the ONE
+ * `--liquid-fill-tint` knob, which this variant seeds from the EXISTING
+ * `--progress-fill` token (the progress family's colour contract) in the scoped
+ * block below — so a consumer re-tints the liquid meter by setting `--progress-fill`
+ * (or `--liquid-fill-tint`) with NO knowledge of the blur / rim / under-shadow the
+ * register owns. The thin `Progress` dispatcher routes here for `variant="liquid"`.
+ */
+type __VLS_Props = ProgressRootProps & {
+    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<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,6 @@
+export { default as Progress } from "./Progress.vue";
+export { default as ProgressDefault } from "./ProgressDefault.vue";
+export { default as ProgressGradient } from "./ProgressGradient.vue";
+export { default as ProgressLiquid } from "./ProgressLiquid.vue";
+export { default as ProgressSectioned } from "./ProgressSectioned.vue";
+export { useProgressGeometry, type ProgressSegment, type SectionedCell, } from "./useProgressGeometry";

package/dist/components/scroll-progress-rim/ScrollProgressRim.vue.d.ts

@@ -0,0 +1,19 @@
+import type { ScrollProgressRimCoverage, ScrollProgressRimSegments } from "./types";
+export interface ScrollProgressRimProps {
+    /** Aggregate progress in the same units as `max`. */
+    value: number;
+    /** Aggregate ceiling. @default 1 */
+    max?: number;
+    /** Optional per-item fill values. Each segment is clamped to [0, 1]. */
+    segments?: ScrollProgressRimSegments;
+    /** Which part of the host edge carries progress. @default "full-ring" */
+    coverage?: ScrollProgressRimCoverage;
+    /** CSS color anchors for the rim's spectrum. */
+    stops?: readonly string[];
+}
+declare const __VLS_export: import("vue").DefineComponent<ScrollProgressRimProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ScrollProgressRimProps> & Readonly<{}>, {
+    max: number;
+    coverage: ScrollProgressRimCoverage;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/scroll-progress-rim/index.d.ts

@@ -0,0 +1,3 @@
+export { default as ScrollProgressRim } from "./ScrollProgressRim.vue";
+export type { ScrollProgressRimProps } from "./ScrollProgressRim.vue";
+export type { ScrollProgressRimCoverage, ScrollProgressRimSegments } from "./types";

package/dist/components/scroll-progress-rim/types.d.ts

@@ -0,0 +1,2 @@
+export type ScrollProgressRimCoverage = "full-ring" | "bottom-edge" | "inline-end-edge";
+export type ScrollProgressRimSegments = readonly number[];

package/dist/components/search/FuzzySearch.vue.d.ts

@@ -0,0 +1,22 @@
+import type { Surface } from "../_shared/useSurfaceAxis";
+import { type ControlSize, type SearchVariant } from "./searchVariants";
+import type { FuzzySearchState, SearchableItem } from "./composables/types";
+type __VLS_Props = {
+    state: FuzzySearchState;
+    variant?: SearchVariant;
+    size?: ControlSize;
+    surface?: Surface;
+    placeholder?: string;
+    typeLabel?: (item: SearchableItem) => string;
+};
+declare function focus(): void;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
+    focus: typeof focus;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    size: ControlSize;
+    variant: SearchVariant;
+    surface: Surface;
+    placeholder: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/search/SearchBar.vue.d.ts

@@ -0,0 +1,38 @@
+import { type Component } from "vue";
+import type { Surface } from "../_shared/useSurfaceAxis";
+import { type ControlSize, type SearchVariant } from "./searchVariants";
+type __VLS_Props = {
+    modelValue?: string;
+    placeholder?: string;
+    icon?: Component;
+    tag?: string;
+    size?: ControlSize;
+    surface?: Surface;
+    variant?: SearchVariant;
+};
+declare var __VLS_13: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_13) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+    inputRef: import("vue").Ref<HTMLInputElement | null, HTMLInputElement | null>;
+}, {}, {}, {}, 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;
+}>, {
+    size: ControlSize;
+    variant: SearchVariant;
+    surface: Surface;
+    modelValue: string;
+    placeholder: string;
+    tag: 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/search/searchVariants.d.ts

@@ -0,0 +1,19 @@
+import { type VariantProps } from "class-variance-authority";
+import { type ControlSize, controlSizeClass } from "../_shared/useControlSize";
+/**
+ * The search field-CHROME variant. `inline` is the boxed glass pill (identity over
+ * the `.input-bar` recipe); `bare`/`floating` strip the box to a chromeless field —
+ * the real CVA rung the `!important` cluster was fighting (clean break, no `!`).
+ *
+ *   searchFieldVariants()                    → ""                                          (the boxed pill)
+ *   searchFieldVariants({ variant: "bare" }) → "border-none bg-transparent p-0 rounded-none"
+ */
+export declare const searchFieldVariants: (props?: ({
+    variant?: "floating" | "inline" | "bare" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type SearchVariant = NonNullable<VariantProps<typeof searchFieldVariants>["variant"]>;
+/** The CVA's variant-prop shape — the `/api` discovery surface (the SFCs cannot
+ *  re-export a type, so this CVA home is the type source). */
+export type SearchVariants = VariantProps<typeof searchFieldVariants>;
+export { controlSizeClass };
+export type { ControlSize };