@mkbabb/glass-ui 0.3.0 → 2.0.0

package/dist/components/custom/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;
+    rows: number;
+    containerName: string;
+    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/custom/metric-stack/index.d.ts

@@ -0,0 +1,4 @@
+export { default as MetricStack } from "./MetricStack.vue";
+export { default as MetricRow } from "./MetricRow.vue";
+export type { MetricStackProps } from "./MetricStack.vue";
+export type { MetricRowProps } from "./MetricRow.vue";

package/dist/components/custom/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/custom/paper-backdrop/index.d.ts

@@ -0,0 +1,2 @@
+export { default as PaperBackdrop } from "./PaperBackdrop.vue";
+export type { PaperBackdropFrequency, PaperBackdropProps } from "./PaperBackdrop.vue";

package/dist/components/custom/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<{}>, {
+    variant: PulseVariant;
+    speed: PulseSpeed;
+    count: number;
+    once: boolean;
+    intensity: PulseIntensity;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

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

package/dist/components/custom/responsive-tabs/ResponsiveTabs.vue.d.ts

@@ -0,0 +1,67 @@
+import type { HTMLAttributes } from "vue";
+import { type TabOption } from "../tabs";
+/**
+ * ResponsiveTabs — single consume that renders as `<Select>` below the
+ * configured breakpoint and `<UnderlineTabs>` at/above it.
+ *
+ * AC.W8e (glass-ui v1.7.0) — promoted from speedtest's 3-site duplicated
+ * mobile-Select / desktop-UnderlineTabs swap (AdminDataView,
+ * AdminDashboardLayout, PublicDashboardLayout). Each site rolled its own
+ * `sm:hidden` / `hidden sm:block` pair; the primitive collapses the
+ * duplication onto a single matchMedia-driven swap. The dual-mount CSS
+ * pattern is preserved at the JSDOM/SSR level by initializing
+ * `isDesktop` from `window.matchMedia(...)`'s `matches` (or `true` when
+ * `window` is absent, matching server-rendered desktop-first).
+ *
+ * The `breakpoint` prop is a CSS length consumed inside the
+ * `(min-width: <breakpoint>)` media query — pass `"640px"` (the Tailwind
+ * `sm:` rung default), `"720px"` (speedtest's grid-engagement rung), or
+ * any other value the consumer needs.
+ *
+ * The select trigger inherits `glass-ui`'s canonical `text-small w-auto
+ * min-w-input-sm` chrome so the mobile control reads at the small text
+ * register. UnderlineTabs receives the `text-body` register and forwards
+ * any consumer-passed `class`.
+ *
+ * Consumer-side reactive selection flows through `modelValue` /
+ * `update:modelValue` symmetrically across both controls; the primitive
+ * exposes one model so the consumer doesn't bind two.
+ */
+export interface ResponsiveTabsProps {
+    /** Tab options — shared between mobile select + desktop tabs. */
+    options: TabOption[];
+    /**
+     * Optional subset for desktop tabs. If a consumer has a mobile-only
+     * tab (e.g. speedtest AdminDataView's "Filters" tab which is
+     * desktop-sidebar-rendered), pass the desktop-relevant subset here.
+     * Falls back to `options` when unset.
+     */
+    desktopOptions?: TabOption[] | null;
+    /**
+     * Currently-active value. Bound through `v-model`; the consumer
+     * receives `update:modelValue` whenever either control changes.
+     */
+    modelValue: string;
+    /**
+     * CSS length string for the media query breakpoint. Mobile-control
+     * (Select) below; desktop-control (UnderlineTabs) at/above.
+     * Defaults to `"640px"` (Tailwind `sm:`).
+     */
+    breakpoint?: string;
+    /** Class merged onto both controls' chrome. */
+    class?: HTMLAttributes["class"];
+    /** Class merged onto the desktop UnderlineTabs only. */
+    desktopClass?: HTMLAttributes["class"];
+    /** Class merged onto the mobile SelectTrigger only. */
+    mobileTriggerClass?: HTMLAttributes["class"];
+}
+declare const __VLS_export: import("vue").DefineComponent<ResponsiveTabsProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<ResponsiveTabsProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    desktopOptions: TabOption[] | null;
+    breakpoint: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

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

package/dist/components/custom/scrolling-text/ScrollingText.vue.d.ts

@@ -0,0 +1,20 @@
+import { type HTMLAttributes } from "vue";
+type __VLS_Props = {
+    /** Optional text content. Use the default slot for richer markup. */
+    text?: string;
+    /** Forwarded class string (merged via `cn`). */
+    class?: HTMLAttributes["class"];
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: 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 __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/scrolling-text/index.d.ts

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

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

@@ -0,0 +1,16 @@
+import type { FuzzySearchState, SearchableItem } from "./composables/types";
+type __VLS_Props = {
+    state: FuzzySearchState;
+    variant?: "sidebar" | "floating";
+    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<{}>, {
+    placeholder: string;
+    variant: "sidebar" | "floating";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,30 @@
+import { type Component } from "vue";
+type __VLS_Props = {
+    modelValue?: string;
+    placeholder?: string;
+    icon?: Component;
+    tag?: string;
+};
+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;
+}>, {
+    placeholder: string;
+    modelValue: 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/custom/search/composables/fuzzySearchIndex.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Generic fuzzy search index — builds a flat searchable index from items
+ * and scores queries with VSCode-style fuzzy matching.
+ * Pure functions, no Vue reactivity.
+ */
+import type { SearchableItem, SearchResult } from "./types";
+interface IndexEntry<T extends SearchableItem> {
+    item: T;
+    /** Pre-lowercased fields, built once at index time. */
+    _lc: {
+        label: string;
+        text: string;
+        type: string;
+    };
+}
+/** Opaque index handle. */
+export type SearchIndex<T extends SearchableItem = SearchableItem> = IndexEntry<T>[];
+/**
+ * Scores a fuzzy subsequence match of `pattern` against `text`.
+ * Every character in `pattern` must appear in `text` in order.
+ * Returns null if no match, otherwise { score, matches }.
+ *
+ * Scoring bonuses:
+ *   +8  match at index 0 (start of string)
+ *   +7  match after a word separator (space, -, _, ., /, \, :)
+ *   +6  camelCase boundary (lowercase -> uppercase)
+ *   +5  consecutive characters in a run
+ *   +3  pattern index === text index (prefix alignment)
+ *   +1  base per-character match
+ *  -0.1 per excess character in text (prefer tighter matches)
+ */
+export declare function fuzzyMatch(pattern: string, text: string): {
+    score: number;
+    matches: number[];
+} | null;
+/** Build a search index from a list of items. */
+export declare function buildIndex<T extends SearchableItem>(items: T[]): SearchIndex<T>;
+/** Search the index for items matching `query`. */
+export declare function searchIndex<T extends SearchableItem>(index: SearchIndex<T>, query: string, maxResults?: number): SearchResult<T>[];
+/** Clear search caches. Pass an index to clear only that instance. */
+export declare function clearSearchCache(index?: SearchIndex): void;
+export {};

package/dist/components/custom/search/composables/types.d.ts

@@ -0,0 +1,31 @@
+import type { Ref, ComputedRef } from "vue";
+/** A searchable item — the generic unit of the fuzzy search index. */
+export interface SearchableItem {
+    id: string;
+    /** Primary display label (title, heading, name). */
+    label: string;
+    /** Full-text content to search against. */
+    text: string;
+    /** Optional type tag for badge display (e.g. "section", "code"). */
+    type?: string;
+}
+/** A single fuzzy match result with score and highlight positions. */
+export interface SearchResult<T extends SearchableItem = SearchableItem> {
+    item: T;
+    score: number;
+    /** Character positions in `item.label` that matched the query. */
+    matchIndices: number[];
+}
+/** Reactive state returned by `useFuzzySearch`. */
+export interface FuzzySearchState<T extends SearchableItem = SearchableItem> {
+    query: Ref<string>;
+    results: ComputedRef<SearchResult<T>[]>;
+    selectedIndex: Ref<number>;
+    isOpen: Ref<boolean>;
+    isExpanded: Ref<boolean>;
+    onKeydown(e: KeyboardEvent): void;
+    selectResult(result: SearchResult<T>): void;
+    toggleExpanded(): void;
+    close(): void;
+    open(): void;
+}

package/dist/components/custom/search/composables/useFuzzySearch.d.ts

@@ -0,0 +1,12 @@
+import type { SearchableItem, SearchResult, FuzzySearchState } from "./types";
+export interface UseFuzzySearchOptions<T extends SearchableItem = SearchableItem> {
+    /** Reactive or static list of searchable items. */
+    items: T[] | (() => T[]);
+    /** Debounce delay in ms (default: 120). */
+    debounceMs?: number;
+    /** Maximum results to return (default: 30). */
+    maxResults?: number;
+    /** Callback when a result is selected (Enter or click). */
+    onSelect?: (result: SearchResult<T>) => void;
+}
+export declare function useFuzzySearch<T extends SearchableItem = SearchableItem>(options: UseFuzzySearchOptions<T>): FuzzySearchState<T>;

package/dist/components/custom/sortable-list/SortableHandle.vue.d.ts

@@ -0,0 +1,32 @@
+/**
+ * SortableHandle — marks an element as a drag grip.
+ *
+ * Inside a <SortableItem>, any `[data-sortable-handle]`
+ * descendant is the only pointerdown surface that starts a
+ * drag. Consumers can either use this component or add the
+ * data attribute directly on their own element. Using this
+ * wrapper gives you sensible default cursor + touch-action CSS.
+ *
+ * The default slot renders inside the handle — typically a
+ * grip glyph like `⋮⋮`.
+ */
+import type { Component } from "vue";
+type __VLS_Props = {
+    /** Root element tag. Default `"span"`. */
+    as?: string | Component;
+};
+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, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    as: string | Component;
+}, {}, {}, {}, 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/sortable-list/SortableItem.vue.d.ts

@@ -0,0 +1,38 @@
+/**
+ * SortableItem — a draggable row within a <SortableList>.
+ *
+ * Injects the sortable context, registers itself by its
+ * stable `id`, and binds the returned ref / pointerdown / data
+ * attrs / drop-target classes on its root element. The default
+ * slot renders the row's content; styling is the consumer's
+ * concern.
+ *
+ * The root is a `<div>` by default but consumers can swap via
+ * the `as` prop if they need a semantic element (`<li>`, etc).
+ * The binding spread works on any native element.
+ */
+import { type Component } from "vue";
+import type { SortableId } from "../../../composables/sortable";
+type __VLS_Props = {
+    /** Stable id for this row — must match the parent list. */
+    id: SortableId;
+    /** Root element tag. Default `"div"`. */
+    as?: string | Component;
+};
+declare var __VLS_10: {
+    isBeingDragged: boolean;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_10) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    as: string | Component;
+}, {}, {}, {}, 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/sortable-list/SortableList.vue.d.ts

@@ -0,0 +1,76 @@
+/**
+ * SortableList — headless root of the sortable composition.
+ *
+ * Calls `useSortable` against the consumer's reactive items +
+ * reorder callback, then provides the composable's return value
+ * to descendant <SortableItem> + <SortableHandle> via
+ * provide/inject. The root is a configurable element that
+ * receives the sortable container binding so cross-list drop
+ * detection can hit-test it.
+ *
+ * Drag ghost is auto-generated by cloning the source row's DOM
+ * — no per-consumer markup required. The clone inherits scoped
+ * `data-v-*` attributes so stylesheet selectors still match,
+ * giving a pixel-faithful preview.
+ *
+ * Cross-list drops: pass the same `group` id to two or more
+ * `<SortableList>` instances and they'll accept items from each
+ * other. The `@insert` event fires on the target with
+ * `(index, item)` whenever a foreign item lands on it; the
+ * source's `@reorder` emits with the item removed.
+ *
+ * Slots:
+ *   - default — list rows wrapped in `<SortableItem>` components.
+ */
+import { type Component } from "vue";
+import { type SortableId } from "../../../composables/sortable";
+declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
+        /** The reactive list being reordered. */
+        items: readonly T[];
+        /** Extract a stable id from an item. */
+        getId: (item: T) => SortableId;
+        /**
+         * Cross-list group id. Instances that share a group
+         * accept drops from each other. Undefined (default)
+         * isolates this instance to its own items.
+         */
+        group?: string;
+        /**
+         * Handle selector. `null` enables drag-from-anywhere.
+         * Default `[data-sortable-handle]` matches what the
+         * <SortableHandle> component emits.
+         */
+        handleSelector?: string | null;
+        /** Axis constraint for drop resolution. Default `"y"`. */
+        axis?: "x" | "y";
+        /** Root element tag. Default `"div"`. */
+        as?: string | Component;
+    } & {
+        onInsert?: ((index: number, item: unknown) => any) | undefined;
+        onReorder?: ((next: T[]) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        isDragging: import("vue").ComputedRef<boolean>;
+        dragId: import("vue").ComputedRef<SortableId | null>;
+    }>) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {
+            isDragging: boolean;
+            dragId: SortableId | null;
+        }) => any;
+    };
+    emit: ((evt: "insert", index: number, item: unknown) => void) & ((evt: "reorder", next: T[]) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/custom/sortable-list/context.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Shared provide/inject key + paired helpers for the <SortableList> hierarchy.
+ *
+ * Lives in its own module so SortableItem + SortableHandle can
+ * both import the symbol without triggering a component cycle
+ * through their .vue files.
+ *
+ * P.W2 Lane B — canonical typed-key + helper-pair DI shape per
+ * invariant 25. Strict-only by intent: <SortableItem> is meaningless
+ * without a parent <SortableList>, so an optional counterpart would
+ * be invalid per Pδ §2.2 + invariant 25's "per intent" clause.
+ *
+ * Paired helpers:
+ *  - `provideSortableContext(sortable)` — wraps the raw provide call.
+ *  - `useSortableContext()` — strict; throws when used outside <SortableList>.
+ *
+ * No `useOptionalSortableContext()` is shipped — a <SortableItem>
+ * rendered outside a <SortableList> has no registration target and
+ * cannot function. The optional helper would be dead code.
+ */
+import { type InjectionKey } from "vue";
+import type { UseSortableReturn } from "../../../composables/sortable";
+export declare const SORTABLE_CONTEXT: InjectionKey<UseSortableReturn>;
+export declare function provideSortableContext(sortable: UseSortableReturn): void;
+/** Strict — throws when used outside `<SortableList>`. */
+export declare function useSortableContext(): UseSortableReturn;

package/dist/components/custom/sortable-list/index.d.ts

@@ -0,0 +1,4 @@
+export { default as SortableList } from "./SortableList.vue";
+export { default as SortableItem } from "./SortableItem.vue";
+export { default as SortableHandle } from "./SortableHandle.vue";
+export { SORTABLE_CONTEXT, provideSortableContext, useSortableContext, } from "./context";

package/dist/components/custom/stacked-icons/StackedIconGroup.vue.d.ts

@@ -0,0 +1,30 @@
+import type { StackedIconGroupProps } from './types';
+declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<StackedIconGroupProps<T>> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        icon?: (props: {
+            item: T;
+            index: number;
+        }) => any;
+    } & {
+        overflow?: (props: {
+            count: number;
+        }) => any;
+    } & {
+        info?: (props: {}) => any;
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/custom/stacked-icons/index.d.ts

@@ -0,0 +1,2 @@
+export { default as StackedIconGroup } from "./StackedIconGroup.vue";
+export type { StackedIconGroupProps } from "./types";

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

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