@mkbabb/glass-ui 6.0.0 → 8.0.0

package/dist/components/number-field/NumberFieldIncrement.vue.d.ts

@@ -1,18 +0,0 @@
-import type { NumberFieldIncrementProps } from 'reka-ui';
-import { type HTMLAttributes } from 'vue';
-type __VLS_Props = NumberFieldIncrementProps & {
-    class?: HTMLAttributes['class'];
-};
-declare var __VLS_14: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_14) => 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/pager-dots/composables/usePagerWorm.d.ts

@@ -1,26 +0,0 @@
-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

@@ -1,15 +0,0 @@
-/** 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/pager-dots/pagerWindow.d.ts

@@ -1,9 +0,0 @@
-export interface PagerWindow {
-    /** The 0-based slide indices to render as dots. */
-    shown: number[];
-    /** The window is clipped at the start (a dimmed leading edge dot). */
-    clippedStart: boolean;
-    /** The window is clipped at the end (a dimmed trailing edge dot). */
-    clippedEnd: boolean;
-}
-export declare function pagerWindow(total: number, activeIndex: number, fit: number): PagerWindow;

package/dist/components/paper-backdrop/PaperBackdrop.vue.d.ts

@@ -1,21 +0,0 @@
-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/paper-backdrop/index.d.ts

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

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

@@ -1,9 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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/valueMarks.css

@@ -1 +0,0 @@
-.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

@@ -1,53 +0,0 @@
-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/pulse/index.d.ts

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

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

@@ -1,24 +0,0 @@
-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;
-    ariaLabel?: 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;
-    placeholder: string;
-    surface: Surface;
-    variant: SearchVariant;
-    ariaLabel: string;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;

package/dist/components/select/SelectScrollDownButton.vue.d.ts

@@ -1,18 +0,0 @@
-import { type HTMLAttributes } from 'vue';
-import { type SelectScrollDownButtonProps } from 'reka-ui';
-type __VLS_Props = SelectScrollDownButtonProps & {
-    class?: HTMLAttributes['class'];
-};
-declare var __VLS_8: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_8) => any;
-};
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, 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/select/SelectScrollUpButton.vue.d.ts

@@ -1,18 +0,0 @@
-import { type HTMLAttributes } from 'vue';
-import { type SelectScrollUpButtonProps } from 'reka-ui';
-type __VLS_Props = SelectScrollUpButtonProps & {
-    class?: HTMLAttributes['class'];
-};
-declare var __VLS_8: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_8) => any;
-};
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, 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/sortable-list/composables/dragController.d.ts

@@ -1,29 +0,0 @@
-import { type ShallowRef } from "vue";
-import type { GhostRenderer } from "./ghostRenderer";
-import type { InstanceHandle, SortableId } from "./types";
-export interface DragControllerDeps {
-    getItems: () => readonly unknown[];
-    getId: (item: unknown) => SortableId;
-    getLabel: (item: unknown) => string;
-    elements: Map<SortableId, Element | null>;
-    handle: InstanceHandle;
-    onReorder: (next: unknown[]) => void;
-    horizontal: boolean;
-    ghost: GhostRenderer;
-    announce: (message: string) => void;
-    focusItem: (id: SortableId) => void;
-}
-export interface DragController {
-    dragId: ShallowRef<SortableId | null>;
-    pos: ShallowRef<{
-        x: number;
-        y: number;
-    } | null>;
-    dropIndex: ShallowRef<number | null>;
-    pointerCaptureActive: ShallowRef<boolean>;
-    beginPointer: (id: SortableId, event: PointerEvent) => void;
-    onKeydown: (id: SortableId, event: KeyboardEvent) => void;
-    cancel: () => void;
-    dispose: () => void;
-}
-export declare function createDragController(deps: DragControllerDeps): DragController;

package/dist/components/sortable-list/composables/dropResolver.d.ts

@@ -1,34 +0,0 @@
-/**
- * Sortable drop resolution — pure collision/measure math over the elements map.
- *
- * No DOM mutation: these read row bounding rects and resolve an insertion index.
- * Walking registered row elements via the elements map (rather than subscribing
- * to each row's box reactively) keeps the cost at O(rows) per pointermove frame
- * and avoids a layout-thrash storm.
- *
- * The module-level instance registry lives here too — it is the cross-list
- * resolution home: `findForeignTarget` hit-tests sibling instances in the same
- * group, unifying the local-drop vs foreign-drop index math behind one resolver.
- */
-import type { InstanceHandle, SortableId } from "./types";
-/**
- * Every live `useSortable` instance registers here for cross-list lookups. On
- * drag move, the source instance looks up any other instance in the same group
- * whose container contains the cursor, and transfers the drop target to it.
- * Entries are removed on scope dispose.
- */
-export declare const instances: Set<InstanceHandle>;
-/**
- * Resolve an insertion index by walking the registered row elements and finding
- * the first row whose axis midpoint is past the cursor. Returns `list.length`
- * (drop at end) when the cursor is past every row.
- */
-export declare function resolveDropIndexIn(elMap: Map<SortableId, Element | null>, list: readonly {
-    id: SortableId;
-}[], clientX: number, clientY: number, horizontal: boolean): number;
-/**
- * Find a sibling instance in the same group whose container bounds contain the
- * cursor — the foreign drop target. Returns null when the source has no group or
- * the cursor is over no sibling.
- */
-export declare function findForeignTarget(sourceHandle: InstanceHandle, clientX: number, clientY: number): InstanceHandle | null;

package/dist/components/sortable-list/composables/ghostRenderer.d.ts

@@ -1,44 +0,0 @@
-/**
- * Sortable drag ghost — the snap-physics + visual clone of the grabbed row.
- *
- * The ghost is a fixed-position DOM clone of the source row, positioned under the
- * grab point so it tracks the cursor rather than teleporting. The clone inherits
- * scoped `data-v-*` attributes + classes so stylesheet selectors continue to
- * match, giving a pixel-faithful preview without any per-consumer markup.
- *
- * `createGhostRenderer()` returns the stateful trio (`createGhost` / `updateGhost`
- * / `destroyGhost`) closing over the live ghost element + its cursor offset.
- */
-/**
- * True when a computed `border-radius` string has any non-zero corner. Computed
- * values resolve to space-separated lengths (e.g. `"0px"`, `"6px"`, `"12px 12px
- * 0px 0px"`) with an optional `/` separating the horizontal/vertical radii of
- * elliptical corners. A radius is "zero" only when every numeric component parses
- * to 0; a non-length token (`%`, `auto`) counts as non-zero so we never miss a
- * rounded corner.
- *
- * Exported (and re-exported from `useSortable`) for the D9 drag-ring regression
- * test — keep it a pure string predicate.
- */
-export declare function isNonZeroRadius(radius: string): boolean;
-/**
- * Resolve the effective VISIBLE corner radius for the dragged content. Returns
- * the source's own computed `border-radius` when it is non-zero; otherwise walks
- * descendants depth-first and returns the first element's non-zero radius (the
- * common case where the SortableItem root is unrounded and the rounded surface
- * lives on an inner child). Returns `null` when nothing in the subtree is rounded
- * — caller leaves the ghost radius untouched.
- */
-export declare function resolveVisibleRadius(source: HTMLElement): string | null;
-export interface GhostRenderer {
-    /**
-     * Build the drag ghost by cloning the source row's DOM and positioning a
-     * fixed copy at its current bounding rect.
-     */
-    createGhost: (source: HTMLElement, clientX: number, clientY: number) => void;
-    /** Track the ghost under the cursor at its captured grab offset. */
-    updateGhost: (clientX: number, clientY: number) => void;
-    /** Remove the ghost from the document. */
-    destroyGhost: () => void;
-}
-export declare function createGhostRenderer(): GhostRenderer;

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

@@ -1 +0,0 @@
-export { useSortable, type UseSortableReturn, type SortableId } from "./useSortable";

package/dist/components/sortable-list/composables/touchGate.d.ts

@@ -1,26 +0,0 @@
-/**
- * Sortable touch-gesture resolver + pointer-capture optimization.
- *
- * `targetIsHandle` gates whether a pointerdown starts a drag (the grip
- * constraint). `acquirePointerCapture` is the optimization layer: a successful
- * `setPointerCapture` routes move/up events to the captured element, but it is
- * NOT the drag's primary path — the document `pointermove`/`pointerup` listeners
- * carry the drag unconditionally (AV.W1.1b). Capture failure is SURFACED (not
- * swallowed) via the returned boolean + a once-per-process dev warning, so a
- * consumer can observe the degraded-but-correct path.
- */
-/**
- * True when the pointerdown target satisfies the grip constraint. `null` selector
- * allows drag from anywhere on the row; otherwise the target must be (or descend
- * from) an element matching the selector.
- */
-export declare function targetIsHandle(target: EventTarget | null, handleSelector: string | null): boolean;
-/**
- * Attempt the `setPointerCapture` optimization on the pointerdown host. Returns
- * the resulting `pointerCaptureActive` state: `true` when a capture is held (or
- * when the host has no `setPointerCapture` method at all — no degradation to
- * signal), `false` ONLY when the method is present but THREW — in which case the
- * drag still runs on the document listeners (the unconditional primary path) and
- * the failure is dev-warned once.
- */
-export declare function acquirePointerCapture(host: Element | null, pointerId: number): boolean;

package/dist/components/sortable-list/composables/transitionTiming.d.ts

@@ -1,50 +0,0 @@
-/**
- * Sortable visual-transition timing — the drop-target class grammar.
- *
- * Owns the drop-hint class names and the single-row insertion-line resolution:
- * exactly ONE class at most per row (never both), so the user sees one insertion
- * line instead of a doubled pair at adjacent edges. The drag-state controller
- * drives these; the row binding reflects them as a reactive class object.
- */
-import type { SortableId } from "./types";
-export declare const DROP_ABOVE_CLASS = "is-sortable-drop-above";
-export declare const DROP_BELOW_CLASS = "is-sortable-drop-below";
-export declare const DRAG_GHOST_CLASS = "sortable-drag-ghost";
-export declare const SOURCE_DRAGGING_CLASS = "is-sortable-dragging";
-/**
- * Drop-target class flags for a single row under a given drop index. ONE class at
- * most — never both — so the user sees exactly one insertion line.
- *
- * Insertion-line convention:
- *   drop === 0           → top of row 0 (DROP_ABOVE on row 0)
- *   drop === k (middle)  → top of row k (DROP_ABOVE on row k)
- *   drop === length      → bottom of last row (DROP_BELOW on last)
- *
- * Two rows adjacent to the insertion line sharing the line visually equals one
- * drawn border (not two) — picking a single row eliminates the prior "doubled
- * and wrong" appearance.
- *
- * `rowIndex` is the row's current index in the list; pass `< 0` (not found) to
- * receive the all-false result.
- */
-export declare function flagsFor(rowIndex: number, drop: number, listLength: number): {
-    above: boolean;
-    below: boolean;
-};
-/**
- * Compose the reactive drop-target class object for a row from the live local +
- * external drop indices. Local and external are mutually exclusive in practice —
- * either this instance owns the drag or a sibling does — but both are honored so a
- * stale value can never double-paint.
- */
-export declare function computeDropClasses(args: {
-    rowIndex: number;
-    listLength: number;
-    /** Local same-list drop index, or null when this instance is not dragging. */
-    localDrop: number | null;
-    /** True while this instance owns an active drag. */
-    isLocalDragging: boolean;
-    /** External (foreign-source) drop index set via the registry, or null. */
-    externalDrop: number | null;
-}): Record<string, boolean>;
-export type { SortableId };

package/dist/components/spa-view/SpaView.vue.d.ts

@@ -1,50 +0,0 @@
-import type { Component } from "vue";
-export interface SpaViewProps {
-    /**
-     * The active view. Either a component (`<component :is>`) or a string key the
-     * default-slot resolves against. When `view`/`is` is set, SpaView renders the
-     * dynamic component directly; when unset, the default slot is the active view
-     * (the consumer drives `:is` inside the slot themselves).
-     */
-    view?: Component | string;
-    /** Alias of `view` (the `:is` ergonomics — same dynamic-component target). */
-    is?: Component | string;
-    /**
-     * The LRU cap — the max number of cached inactive view instances. Threaded
-     * straight onto `<KeepAlive :max>`; when unset, KeepAlive's default (unbounded)
-     * applies. The visual-load-bearing register: a bounded admin shell sets `:max`
-     * to its tab count so the cache never grows without bound.
-     */
-    max?: number;
-    /** KeepAlive include allowlist (component name / RegExp / array — pass-through). */
-    include?: string | RegExp | (string | RegExp)[];
-    /** KeepAlive exclude denylist (component name / RegExp / array — pass-through). */
-    exclude?: string | RegExp | (string | RegExp)[];
-    /**
-     * The Vue <Transition> recipe name driving the out-in cross-fade. Defaults to
-     * `"fade"` — the shared opacity-only compositor recipe (transitions.css). A
-     * consumer overrides it with another `mode="out-in"`-safe recipe name.
-     */
-    transition?: string;
-    /**
-     * The stable key the transition keys off (a re-render WITHOUT a key change is
-     * not a view swap). Defaults to the resolved `view`/`is` target. A consumer
-     * driving the active view from the default slot supplies its own `:view-key`.
-     */
-    viewKey?: string | number;
-}
-declare var __VLS_19: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_19) => any;
-};
-declare const __VLS_base: import("vue").DefineComponent<SpaViewProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SpaViewProps> & Readonly<{}>, {
-    transition: 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/spa-view/index.d.ts

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

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

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

package/dist/components/split-chars/index.d.ts

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

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

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

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

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