@mkbabb/glass-ui 4.2.0 → 6.0.0

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/metric-stack/MetricStack.vue.d.ts

@@ -0,0 +1,92 @@
+import type { Component, HTMLAttributes } from "vue";
+/**
+ * MetricStack — the layout shell that hosts a stack of <MetricRow> children.
+ *
+ * Owns:
+ *  - container-query host (`container-type: inline-size`) with a configurable
+ *    `container-name` so each row can rebind layout against the same name.
+ *  - 3-column subgrid track template (`icon | label | value`). All
+ *    rows inherit via `grid-template-columns: subgrid`. The value+unit
+ *    lockup lives inside the `value` track as one baseline-aligned
+ *    inline group — the row reads "240 Mbps" as one typographic unit.
+ *  - the `--phase-color` cascade origin — consumers can retint individual
+ *    rows by setting `--phase-color` at the row-level inline style.
+ *  - the audacious-poster row register (the value clamp + tabular-nums
+ *    + ss01 register live at MetricRow; the stack reserves a min-block-size
+ *    to pre-allocate against the row hero clamp so the surface doesn't CLS
+ *    while the values fade in).
+ *
+ * AC.W6d — promoted from speedtest/ResultStack.vue. The W3.5 era
+ * `.results-stack` rules absorb directly. Consumers configure their phase
+ * colours per row + describe their digit-counts so the value clamp shrinks
+ * proportionally as 4-digit values arrive.
+ *
+ * The `as` prop lets the stack render as a Vue `<TransitionGroup>` (with
+ * `tag="div"`) when the consumer needs per-row enter/leave animation
+ * while preserving the immediate-child subgrid contract. Pass the
+ * component (e.g. `TransitionGroup`) plus the relevant transition props
+ * (`name`, `appear`, etc.) — they're forwarded via `v-bind="$attrs"`.
+ */
+export interface MetricStackProps {
+    /**
+     * Container-name handle for the inline-size container. Children
+     * can `@container <name>` against this for responsive
+     * promotion (e.g. the description row appearing at ≥ 32rem).
+     */
+    containerName?: string;
+    /**
+     * Variant tag mirrored to a `data-variant` attribute. Optional;
+     * consumers use it to differentiate row-count + scale multipliers
+     * (e.g. speedtest's `dpi` variant lifts `--result-row-scale: 1.25`).
+     */
+    variant?: string;
+    /**
+     * Typographic register, mirrored to a `data-register` attribute.
+     *
+     *  - `"audacious"` (default) — the poster-scale hero register: the
+     *    value clamp peaks at `--type-display-hero` (~287px). This is the
+     *    register for a single giant number the user watches climb. The
+     *    default writes NOTHING, so every existing consumer is untouched.
+     *  - `"result"` — a compact, scannable ledger register: the value
+     *    clamp peaks at `3.5rem`, the binding `cqi` arm drops to `11cqi`.
+     *    This is the register for a multi-row stack of FINISHED values
+     *    (e.g. speedtest's complete-screen `ResultStack`), where all rows
+     *    plus surrounding chrome must seat inside a bounded card. The
+     *    `min-block-size` pre-allocation re-derives to match the compact
+     *    rows so the stack reserves no dead air.
+     */
+    register?: "audacious" | "result";
+    /**
+     * Row count for the min-block-size pre-allocation. Defaults to 4
+     * (the speedtest 4-metric default). The pre-allocation clamp reads
+     * `clamp(4rem * rows, 48cqi, 7rem * rows)` so the panel reserves
+     * a sane height even before the rows hydrate.
+     */
+    rows?: number;
+    /**
+     * Render-as tag. Defaults to `"div"`. Pass a Vue component
+     * (e.g. `TransitionGroup`) when per-row enter/leave animation is
+     * required and the subgrid contract must hold (the rendered root
+     * is the grid container; rows are immediate children).
+     */
+    as?: string | Component;
+    class?: HTMLAttributes["class"];
+}
+declare var __VLS_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;
+    rows: number;
+    register: "audacious" | "result";
+}, {}, {}, {}, 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/PagerDots.vue.d.ts

@@ -0,0 +1,48 @@
+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;
+    /**
+     * The ARIA register. `"tabs"` (default, byte-identical) is the carousel
+     * panel-nav register (`role="tablist"`/`role="tab"` + `aria-selected`);
+     * `"group"` is the full-viewport deck PRESENTATION register
+     * (`role="group"`/`aria-current`) the `<DeckPager>` selects. ONE windowing
+     * oracle, two aria registers — the `pagerWindow` math is NEVER re-forked.
+     */
+    pattern?: "tabs" | "group";
+    /** 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;
+}>, {
+    pattern: "tabs" | "group";
+    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/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/paper-backdrop/PaperBackdrop.vue.d.ts

@@ -0,0 +1,21 @@
+import { type HTMLAttributes } from "vue";
+/**
+ * Turbulence-texture register on `<PaperBackdrop>`. `"clean"` is the default
+ * 0.65-baseFrequency / 4-octave grain; `"aged"` swaps to the 0.5-baseFrequency
+ * / 5-octave variant via the `--paper-aged-texture` CSS custom property.
+ * Consumers extend the register by adding their own `--paper-*-texture` vars
+ * at `:root` and applying via raw `class="paper-grain-overlay"` plus an inline
+ * `style` override — the texture-system canonical cascade per DESIGN.md.
+ */
+export type PaperBackdropFrequency = "clean" | "aged";
+export interface PaperBackdropProps {
+    /** Override grain opacity (defaults to --glass-grain-opacity). */
+    opacity?: number | string;
+    /** Override turbulence frequency (advisory only — swaps the texture var). */
+    frequency?: PaperBackdropFrequency;
+    /** Additional class names. */
+    class?: HTMLAttributes["class"];
+}
+declare const __VLS_export: import("vue").DefineComponent<PaperBackdropProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<PaperBackdropProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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;
+}>, {
+    surface: Surface;
+    sideOffset: number;
+    align: "end" | "start" | "center";
+    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,19 @@
+import { type HTMLAttributes } from "vue";
+import type { ProgressRootProps } from "reka-ui";
+type ProgressVariant = "default" | "gradient" | "liquid";
+type __VLS_Props = ProgressRootProps & {
+    class?: HTMLAttributes["class"];
+    variant?: ProgressVariant;
+    /** Decorative checkpoints in the same 0..max domain as modelValue. */
+    marks?: readonly 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<{}>, {
+    modelValue: number | null;
+    variant: ProgressVariant;
+    indeterminate: boolean;
+    marks: readonly number[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,9 @@
+import { type HTMLAttributes } from "vue";
+import { type ProgressRootProps } from "reka-ui";
+type __VLS_Props = ProgressRootProps & {
+    class?: HTMLAttributes["class"];
+    marks?: readonly number[];
+};
+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/ProgressGradient.vue.d.ts

@@ -0,0 +1,26 @@
+import { type HTMLAttributes } from "vue";
+import { type ProgressRootProps } from "reka-ui";
+/**
+ * Gradient progress variant — the rail respects `--progress-track`, the indicator
+ * respects `--progress-fill` (free-form CSS, including gradients), and the W4
+ * lifecycle motion grammar layers on top: an intake pulse on the rising edge, a
+ * leading-edge crescendo past 85%, a discharge glow at 100%, and an optional
+ * indeterminate sweep. The thin `Progress` dispatcher routes here for
+ * `variant="gradient"`.
+ */
+type __VLS_Props = ProgressRootProps & {
+    class?: HTMLAttributes["class"];
+    marks?: readonly number[];
+    /**
+     * AI.W4-M.1 — indeterminate sweep. When true, the rail runs a slow
+     * left-to-right gradient pan (`--motion-duration-progress-indeterminate`, 4s
+     * default) and the indicator hides. Reka's ProgressRoot already supports the
+     * indeterminate shape via a null modelValue; the prop here is an explicit
+     * opt-in for consumers that want the sweep without managing the modelValue
+     * lifecycle. PRM retires the sweep to a static rail.
+     */
+    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<{}>, {}, {}, {}, {}, 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,22 @@
+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"];
+    marks?: readonly number[];
+};
+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 @@
+export { default as Progress } from "./Progress.vue";

package/dist/components/progress/valueMarks.css

@@ -0,0 +1 @@
+.progress-value-marks { position: absolute; inset: 0; pointer-events: none; } .progress-value-mark { position: absolute; inset-block-start: 50%; inset-inline-start: var(--value-mark-position); width: var(--value-mark-size, 0.375rem); aspect-ratio: 1; border-radius: 50%; background: var( --value-mark-color, color-mix(in srgb, var(--foreground) 34%, transparent) ); transform: translate(-50%, -50%); } [dir="rtl"] .progress-value-mark { transform: translate(50%, -50%); } .progress-value-fill { position: relative; z-index: 1; transform: translateX(calc(-100% + var(--progress-value-percent))); } [dir="rtl"] .progress-value-fill { transform: translateX(calc(100% - var(--progress-value-percent))); }

package/dist/components/pulse/Pulse.vue.d.ts

@@ -0,0 +1,53 @@
+import type { HTMLAttributes } from 'vue';
+/**
+ * Pulse — three variants:
+ *  - `dots`  : three-glyph loading indicator (default)
+ *  - `ring`  : single ring spinner
+ *  - `aura`  : ambient surface-scope halo (AB.W3.T1). Paints an
+ *              absolutely-positioned radial gradient that breathes
+ *              (scale + opacity) inside the parent surface. The host
+ *              element MUST be `position: relative` and own a
+ *              `border-radius` — the aura inherits both. The host
+ *              also controls colour via `--pulse-aura-color`
+ *              (default `currentColor`).
+ *
+ * `aura` is the AB.W3 Living-UI primitive: consumers compose it on
+ * an existing surface (a button, a hero pill, a result-row value
+ * span, a timeline marker) without hand-rolling pulse keyframes.
+ * The shipped tokens (--animate-ambient-pulse-*) parameterise the
+ * cycle so consumers do not redefine the breathing rhythm per site.
+ *
+ * Reduced motion: the `breath` keyframe collapses to a static halo
+ * at media-query level (animations.css). The depth/colour stays
+ * visible; only the scale + opacity cycle disables.
+ */
+type PulseVariant = 'dots' | 'ring' | 'aura';
+type PulseSpeed = 'slow' | 'normal' | 'fast';
+type PulseIntensity = 'subtle' | 'normal' | 'vivid';
+type __VLS_Props = {
+    variant?: PulseVariant;
+    count?: number;
+    speed?: PulseSpeed;
+    /**
+     * Aura-only — amplitude of the breathing cycle. `subtle` reads
+     * as a quiet halo, `vivid` reads as a celebratory pulse. Default
+     * `normal`.
+     */
+    intensity?: PulseIntensity;
+    /**
+     * Aura-only — one-shot mode. When `true`, the aura plays a
+     * single breath then collapses. Used for the completion pulse
+     * (no permanent celebratory throbbing per the W3 contract).
+     */
+    once?: 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<{}>, {
+    speed: PulseSpeed;
+    variant: PulseVariant;
+    count: number;
+    intensity: PulseIntensity;
+    once: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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;