@mkbabb/glass-ui 6.0.0 → 8.0.0

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

@@ -1,46 +1,2 @@
-import { type VariantProps } from 'class-variance-authority';
-export { default as Slider } from './Slider.vue';
-/**
- * Slider variant + size axes.
- *
- * The CVA emits Tailwind arbitrary CSS-variable classes on the SliderRoot.
- * The SFC's scoped CSS keys off `[data-variant]` for substrate-recipe
- * selectors — variant determines how `.slider-track`, `.slider-range`, and
- * `.slider-thumb` paint. The size axis lifts pure geometry via CSS vars
- * (`--slider-track-height`, `--slider-thumb-size`) the SFC defaults read.
- *
- * Exactly two canonical recipes ship:
- *   standard — the CONTINUOUS GLASS CYLINDER with NO VISIBLE THUMB AT ALL (the
- *              user's binding bar, USER-AUDIT-2026-06-10 §B3): you pull the TRACK
- *              itself. A THICK glass capsule track; the filled `.slider-range`
- *              glass cylinder (the W52 liquid-glass material — backdrop + edge rim,
- *              tinted to `--primary`) is pulled along it, and its leading EDGE IS
- *              the handle — the only affordance is the fill edge + the cursor/touch
- *              response. The reka `<SliderThumb>` STAYS MOUNTED (a11y/keyboard/drag/
- *              value-follow native on it) but paints INVISIBLE: width 0, opacity 0,
- *              transparent — no distinct disc/cap/ring over the continuous
- *              cylinder. Keyboard focus rings the TRACK (the W-PRIM-POLISH focus
- *              register), not the invisible thumb; hover/held lift the track FILL's
- *              edge rim; the iOS press spring gives the whole fill a felt squish.
- *              This is the general-purpose glass scrubber and the default.
- *   spectrum — the value.js gradient-track color slider: a tall capsule whose
- *              background is a consumer-supplied `--slider-track-bg`
- *              linear-gradient (the LCH/hue ramp), a transparent range, and a
- *              THIN VISIBLE squircle thumb the HEIGHT of the track (the iOS/value.js
- *              color-picker idiom — a slim vertical bar, `w-3`-thin per the value.js
- *              reference; `corner-shape: superellipse()` via `--corner-shape-thumb`,
- *              @supports-gated over a generous proportional round fallback that
- *              reads squircle-adjacent cross-engine). This is the aurora/blob
- *              color-picking surface — its thumb IS visible (it is the handle).
- *
- * Sizes — the standard cylinder is the thick glass capsule (the invisible thumb's
- * value-follow inset still rides the size token for the 44px coarse hit-halo):
- *   sm — 12px track
- *   md — 20px track (default)
- *   lg — 28px track
- */
-export declare const sliderVariants: (props?: ({
-    variant?: "standard" | "spectrum" | null | undefined;
-    size?: "sm" | "md" | "lg" | null | undefined;
-} & import("class-variance-authority/types").ClassProp) | undefined) => string;
-export type SliderVariants = VariantProps<typeof sliderVariants>;
+export { default as Slider } from './Slider.vue.js';
+export type { SliderProps, SliderSize, SliderVariant } from './types.js';

package/dist/components/slider/styles.css

@@ -0,0 +1 @@
+@property --glass-slider-track-background{syntax: "*";inherits: true;}.glass-slider{--slider-range-origin: left center;position: relative;display: flex;inline-size: 100%;align-items: center;touch-action: none;user-select: none;transition: color var(--duration-fast) var(--ease-standard);}.glass-slider[data-inverted],.glass-slider:dir(rtl){--slider-range-origin: right center;}.glass-slider:dir(rtl)[data-inverted]{--slider-range-origin: left center;}.glass-slider[data-size="sm"]{--slider-track-height: 0.75rem;--slider-thumb-size: 0.5rem;}.glass-slider[data-size="md"]{--slider-track-height: 1.25rem;--slider-thumb-size: 1rem;}.glass-slider[data-size="lg"]{--slider-track-height: 1.75rem;--slider-thumb-size: 1.5rem;}.glass-slider[data-variant="spectrum"]{--slider-track-height: calc(var(--slider-thumb-size,1rem) * 1.5);}@media (pointer: coarse){.glass-slider{--slider-target-floor: max( var(--slider-track-height,0.375rem),var(--slider-touch-target,1.5rem) );min-block-size: var(--slider-target-floor);min-inline-size: var(--slider-target-floor);}}.slider-track{width: 100%;flex-grow: 1;height: var(--slider-track-height,0.375rem);background: var(--glass-slider-track-background,var(--muted-medium));transition: background var(--duration-fast) var(--ease-standard),border-color var(--duration-fast) var(--ease-standard);}.slider-range{position: absolute;height: 100%;--liquid-fill-tint: var(--slider-range-bg,var(--glass-capsule-warm));}.slider-thumb{display: block;width: 0;height: var(--slider-track-height,0.375rem);opacity: 0;background: transparent;border: none;box-shadow: none;transition: transform var(--spring-press-duration) var(--spring-press);}.glass-slider:not([data-variant="spectrum"]):hover .slider-range{--liquid-fill-strength: 100%;}.glass-slider:not([data-variant="spectrum"]):has(:focus-visible) .slider-track{box-shadow: var(--focus-ring-shadow);}.glass-slider[data-held] .slider-range,.glass-slider:active .slider-range{--smear: calc(var(--atom-drag-v,0) * var(--motion-weight,0.618));transform: scale( calc(1.02 + 0.16 * var(--smear)),calc(0.94 - 0.06 * var(--smear)) );transform-origin: var(--slider-range-origin);transition: transform var(--spring-press-duration) var(--spring-press);}.glass-slider:not(:active):not([data-held]) .slider-range{transition: transform var(--duration-normal) var(--ease-cartoon-punch),--glass-veil-rung var(--spring-dock-duration) var(--ease-standard),box-shadow var(--duration-fast) var(--ease-standard);}@media (prefers-reduced-motion: reduce){.glass-slider:active .slider-range,.glass-slider[data-held] .slider-range{--motion-weight: 0;transform: scale(1,0.97);}}.glass-slider[data-disabled] .slider-range{opacity: var(--opacity-disabled);}.glass-slider[data-invalid] .slider-track{box-shadow: inset 0 0 0 1px var(--destructive);}.glass-slider[data-invalid]:has(:focus-visible) .slider-track{box-shadow: var(--focus-ring-shadow),inset 0 0 0 1px var(--destructive);}.glass-slider[data-variant="spectrum"][data-held] .slider-thumb{box-shadow: 0 0 0 6px var(--surface-tint-15),var(--shadow-sm);}.glass-slider[data-variant="spectrum"] .slider-track{background: var(--glass-slider-track-background,var(--secondary));}.glass-slider[data-variant="spectrum"] .slider-thumb{width: calc(var(--slider-thumb-size,1rem) * 0.75);height: var(--slider-track-height,0.375rem);opacity: 1;background: transparent;border: 2px solid var(--background);border-radius: calc(var(--slider-thumb-size,1rem) * 0.4);box-shadow: var(--shadow-sm);}@supports (corner-shape: superellipse(2)){.glass-slider[data-variant="spectrum"] .slider-thumb{corner-shape: var(--corner-shape-thumb);}}.glass-slider[data-variant="spectrum"]:hover .slider-thumb{box-shadow: 0 0 0 4px var(--surface-tint-8),var(--shadow-sm);}.glass-slider[data-variant="spectrum"] .slider-thumb:focus-visible{outline: none;box-shadow: var(--focus-ring-shadow),var(--shadow-sm);}.glass-slider[data-orientation="vertical"]{flex-direction: column;width: var(--slider-track-height,0.375rem);height: 12rem;}.glass-slider[data-orientation="vertical"] .slider-track{width: var(--slider-track-height,0.375rem);height: 100%;}.glass-slider[data-orientation="vertical"] .slider-range{width: 100%;height: auto;}.glass-slider[data-orientation="vertical"]:active .slider-range,.glass-slider[data-orientation="vertical"][data-held] .slider-range{--smear: calc(var(--atom-drag-v,0) * var(--motion-weight,0.618));transform: scale( calc(0.94 - 0.06 * var(--smear)),calc(1.02 + 0.16 * var(--smear)) );transform-origin: center bottom;}.glass-slider[data-orientation="vertical"][data-inverted] .slider-range{transform-origin: center top;}.glass-slider[data-orientation="vertical"][data-variant="spectrum"] .slider-thumb{width: var(--slider-track-height,0.375rem);height: calc(var(--slider-thumb-size,1rem) * 0.75);}@media (prefers-reduced-motion: reduce){.glass-slider[data-orientation="vertical"]:active .slider-range,.glass-slider[data-orientation="vertical"][data-held] .slider-range{transform: scale(0.97,1);}}@media (forced-colors: active){.slider-track{background: Canvas;border: 1px solid CanvasText;}.slider-range{background: Highlight;}.glass-slider[data-variant="spectrum"] .slider-thumb{border-color: CanvasText;forced-color-adjust: none;background: Highlight;}.glass-loupe{background: Canvas;border: 1px solid CanvasText;}}.glass-loupe{--loupe-k-max: 2.6;--loupe-k-min: 1.15;--loupe-k: calc( var(--loupe-k-max) - (var(--loupe-k-max) - var(--loupe-k-min)) * var(--flex-vel,0) );--loupe-vel: var(--flex-vel,0);--loupe-span: calc(var(--slider-track-height,1.25rem) * 6);position: fixed;z-index: calc(var(--z-overlay) - 1);inline-size: var(--loupe-span);block-size: calc(var(--slider-track-height,1.25rem) * var(--loupe-k-max));inset-block-start: var(--loupe-top,0);inset-inline-start: var(--loupe-left,0);translate: -50% -100%;scale: 0.13;transform-origin: 50% 100%;transition: scale var(--spring-present-duration) var(--spring-present),opacity var(--spring-present-duration) var(--ease-standard);opacity: 0;overflow: hidden;border-radius: var(--radius-pill);pointer-events: none;box-shadow: var(--glass-material-rim),var(--glass-under-shadow-quiet);}.glass-loupe[data-engaged]{scale: 1;opacity: 1;}.glass-loupe:not([data-engaged]){transition: scale var(--spring-present-exit-duration) var(--ease-standard),opacity var(--spring-present-exit-duration) var(--ease-standard);}.glass-loupe-clone{--s: 3;position: absolute;inset-block-start: 50%;inset-inline-start: 0;inline-size: calc(var(--loupe-track-w,0px) * var(--s));block-size: calc(var(--slider-track-height,1.25rem) * var(--s));border-radius: calc(var(--radius-pill) * var(--s));overflow: hidden;background: var(--glass-slider-track-background,var(--muted-medium));transform: translate( calc(var(--loupe-span) / 2 - var(--loupe-k) * var(--loupe-x,0px)),-50% ) scale(calc(var(--loupe-k) / var(--s)));transform-origin: 0 50%;filter: blur(calc(var(--loupe-vel,0) * 0.75px));transition: filter var(--duration-normal) var(--ease-standard);}.glass-loupe-fill{position: absolute;inset-block: 0;inset-inline-start: 0;inline-size: var(--loupe-fill-w,0px);background: var(--slider-range-bg,var(--glass-capsule-warm));}.glass-loupe-mark{position: absolute;inset-block: 0;inset-inline-start: 50%;inline-size: 2px;translate: -50% 0;background: var(--foreground);opacity: 0.24;}@media (prefers-reduced-motion: reduce){.glass-loupe{transition-duration: 0.01ms;}.glass-loupe-clone{filter: none;}}

package/dist/components/slider/types.d.ts

@@ -0,0 +1,34 @@
+import type { HTMLAttributes } from "vue";
+import type { Motion, Orientation } from "../_shared/axes.js";
+import type { Direction, FormFieldProps } from "../_shared/primitive.js";
+/**
+ * `scrubber` is the continuous-cylinder recipe — one glass segment whose leading edge
+ * IS the handle, with no visible thumb. `spectrum` is the gradient colour-picker
+ * recipe with a visible slim squircle handle.
+ */
+export type SliderVariant = "scrubber" | "spectrum";
+export type SliderSize = "sm" | "md" | "lg";
+export interface SliderProps extends FormFieldProps {
+    modelValue?: number[] | null;
+    defaultValue?: number[];
+    disabled?: boolean;
+    orientation?: Orientation;
+    dir?: Direction;
+    inverted?: boolean;
+    min?: number;
+    max?: number;
+    step?: number;
+    minStepsBetweenThumbs?: number;
+    class?: HTMLAttributes["class"];
+    variant?: SliderVariant;
+    size?: SliderSize;
+    /** Decorative checkpoints in the numeric domain; they never snap the value. */
+    marks?: readonly number[];
+    invalid?: boolean;
+    motion?: Motion;
+    /**
+     * Humane readout for assistive tech — the string a screen reader hears instead of
+     * the raw number. Authored per thumb onto `aria-valuetext`; reka mints none.
+     */
+    valueText?: (value: number, index: number) => string;
+}

package/dist/components/sortable-list/SortableItem.vue.d.ts

@@ -1,4 +1,4 @@
-import type { SortableId } from "./composables/types";
+import type { SortableId } from "./types.js";
 type __VLS_Props = {
     id: SortableId;
     disabled?: boolean;

package/dist/components/sortable-list/SortableList.vue.d.ts

@@ -1,4 +1,4 @@
-import { type SortableId } from "./composables/useSortable";
+import type { SortableId } from "./types.js";
 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. */
@@ -8,7 +8,6 @@ declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_se
         label?: string;
         group?: string;
         handleSelector?: string | null;
-        axis?: "x" | "y";
     } & {
         onInsert?: ((index: number, item: unknown) => any) | undefined;
         onReorder?: ((next: T[]) => any) | undefined;
@@ -28,7 +27,7 @@ declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_se
     };
     emit: ((evt: "insert", index: number, item: unknown) => void) & ((evt: "reorder", next: T[]) => void);
 }>) => import("vue").VNode & {
-    __ctx?: Awaited<typeof __VLS_setup>;
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -1,5 +1,5 @@
 import type { ComputedRef } from "vue";
-import type { SortableId, SortableRowBinding, UseSortableReturn } from "./composables/types";
+import type { SortableId, SortableRowBinding, UseSortableReturn } from "./types.js";
 export declare const provideSortableContext: (ctx: UseSortableReturn) => void;
 export declare const useSortableContext: () => UseSortableReturn;
 export interface SortableItemContext {

package/dist/components/sortable-list/drag.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The sortable drag transaction — propose / commit / cancel, and the vacancy.
+ *
+ * THE VACANCY IS THE INDICATOR. There is no drawn insertion line, no caret, no bar:
+ * the rows between the source and the proposed position translate by one row's block
+ * size, which opens a gap exactly where the row would land, and the lifted row's own
+ * (unpainted) slot travels into it. One spatial account, one copy of the row, nothing
+ * to keep in sync — the 7.0.0 gold shimmer bar had a mass 9.4× the indicator rung and
+ * still could not say where an EMPTY list would receive.
+ *
+ * THE TRANSACTION IS PRESERVED BYTE-FOR-BYTE. The four announcements, the focus
+ * retention, the single `reorder` emit, the O(rows) midpoint scan and the cross-list
+ * transfer are the good half of this component and are not redesigned here. What
+ * changed around them: a gesture must EARN the transaction (8px or the hold) before
+ * a single word is announced, and the ghost is now taken before the source is marked.
+ *
+ * THE ROWS CARRY THEIR OWN CLOCK. `.sortable-item` transitions `transform` on the
+ * dock curve unconditionally, so opening the vacancy and closing it are the same
+ * mechanism read in two directions — there is no "parting mode" to enter and leave,
+ * and clearing a transform animates home instead of snapping.
+ */
+import type { InstanceHandle, SortableId } from "./types.js";
+import { type ShallowRef } from "vue";
+/** A viewport top-left — where a plate is, or where it is going. */
+interface Origin {
+    x: number;
+    y: number;
+}
+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;
+    announce: (message: string) => void;
+    focusItem: (id: SortableId) => void;
+}
+export interface DragController {
+    dragId: ShallowRef<SortableId | null>;
+    dropIndex: ShallowRef<number | null>;
+    beginPointer: (id: SortableId, event: PointerEvent) => void;
+    onKeydown: (id: SortableId, event: KeyboardEvent) => void;
+    /** A sibling instance parts THIS list's rows for an incoming subject. */
+    partForExternal: (index: number | null, block: number | null) => void;
+    /** Where a subject arriving at `index` comes to rest — the releasing list's ask. */
+    vacancyOrigin: (index: number) => Origin | null;
+    cancel: () => void;
+    dispose: () => void;
+}
+export declare function createDragController(deps: DragControllerDeps): DragController;
+export {};

package/dist/components/sortable-list/ghost.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The drag ghost — the lifted row, promoted from cell to floating glass plate.
+ *
+ * TWO ELEMENTS, TWO JOBS, AND THAT IS WHY THERE IS NO TIMER HERE. The outer plate
+ * owns the FOLLOW channel: one `translate3d`, never transitioned, so the plate stays
+ * welded to the finger (MOTION-CANON §4:334). The inner clone owns the PROMOTION
+ * channel: scale and tilt, transitioned on the press curve. Writing both on one
+ * element would force the follow to share the promotion's transition — the lag the
+ * canon forbids — or force a timer to strip the transition mid-gesture.
+ *
+ * THE CLONE IS TAKEN BEFORE THE SOURCE IS MARKED. The 7.0.0 ghost was stamped
+ * `.is-sortable-dragging` on the source and THEN cloned, so the clone inherited the
+ * source's own 0.35 fade at equal specificity and the whole authored lift kit painted
+ * at 35% — invisible, and structurally so. Order is the fix; nothing else was needed.
+ *
+ * The corner is AUTHORED, not hunted: the plate's radius is a role token, so the
+ * 26-line `getComputedStyle` descendant walk that used to guess it is gone.
+ */
+export interface Ghost {
+    /** The plate element, for measurement at release. */
+    readonly plate: HTMLElement;
+    /** Move the plate to a viewport position (its top-left). Compositor only. */
+    follow: (x: number, y: number) => void;
+    /** Re-derive the tilt from the live horizontal velocity. */
+    tilt: (velocityX: number) => void;
+    /** Current top-left, as last written. */
+    position: () => {
+        x: number;
+        y: number;
+    };
+    /** Release the promotion (radius, frost, swell) — the landing half of the flight. */
+    land: () => void;
+    /** Remove the plate from the document. */
+    destroy: () => void;
+}
+/**
+ * Build the ghost from a source row. `rect` is the source's resting box, measured by
+ * the caller BEFORE any state is written to the DOM.
+ */
+export declare function createGhost(source: HTMLElement, rect: DOMRect): Ghost;

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

@@ -1,4 +1,4 @@
-export { default as SortableList } from "./SortableList.vue";
-export { default as SortableItem } from "./SortableItem.vue";
-export { default as SortableHandle } from "./SortableHandle.vue";
-export type { SortableId } from "./composables/types";
+export { default as SortableList } from "./SortableList.vue.js";
+export { default as SortableItem } from "./SortableItem.vue.js";
+export { default as SortableHandle } from "./SortableHandle.vue.js";
+export type { SortableId } from "./types.js";

package/dist/components/sortable-list/motion.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Sortable motion — the gesture's clocks, and the ONE rAF spring path in the family.
+ *
+ * THE SPLIT, STATED ONCE, BECAUSE IT IS THE WHOLE DESIGN:
+ *   · PARTING and PROMOTION are CSS transitions on the GENERATED spring curves
+ *     (`--spring-dock` / `--spring-press` + their duration readers). They are
+ *     compositor-only writes with a known endpoint, so the curve IS the spring and
+ *     the `a11y-overrides.css` reduced-motion blanket already governs them.
+ *   · FOLLOW is 1:1 finger attachment — linear, zero easing, no spring. MOTION-CANON
+ *     §4:334: "Springs belong to entrances, exits, and releases — never between a
+ *     finger and the thing it is holding."
+ *   · THE RELEASE FLIGHT is the one leg a CSS transition cannot express, because its
+ *     initial condition is the gesture's own VELOCITY. That is the single rAF spring
+ *     path here, and it carries the LOCAL reduced-motion gate — the CSS blanket stops
+ *     CSS clocks, it does not stop a JS integrator.
+ *
+ * Every response/damping pair is read from `springPresets` BY NAME. No literal, no
+ * second register: three values have circulated for "dock" across canon, disk and
+ * memory, and the name is the only one of the three that cannot go stale.
+ */
+import { springPreset } from "../../composables/motion/spring/springPresets.js";
+/**
+ * THE ACTIVATION HOLD, DERIVED — never minted.
+ *
+ * A stationary press becomes a lift when it outlasts the slowest motion the library
+ * can make: `world`, the recession row, is that ceiling by construction (it is the
+ * longest response in the table, and the table is the whole register). A press that
+ * outlives it is no longer plausibly a tap. The figure therefore MOVES when the
+ * register moves, which is the property a minted 400ms could never have — CWT-2 §3
+ * ruled exactly this ("no canon rung for hold durations; law it or derive").
+ */
+export declare const ACTIVATION_HOLD_MS: number;
+/**
+ * THE ACTIVATION SLOP, in px. The series rung above coarse-tap jitter (5–10px): below
+ * it the gesture is a click and the transaction never opens.
+ */
+export declare const ACTIVATION_SLOP_PX = 8;
+/** Reduced motion, read LIVE — a JS integrator has no cascade to be stopped by. */
+export declare function prefersReducedMotion(): boolean;
+/**
+ * A small ring buffer over the last few pointer samples. Release velocity is the
+ * chord across the window rather than the last frame's delta, so one stalled frame
+ * cannot fling the ghost.
+ */
+export declare class VelocitySampler {
+    private readonly ring;
+    private readonly size;
+    push(x: number, y: number, t?: number): void;
+    reset(): void;
+    /** px/s across the sample window; `{x:0,y:0}` when the window is degenerate. */
+    velocity(): {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Velocity-derived tilt on the shared tanh register, capped at the existing ceiling.
+ * A static rotation is width-dependent and says nothing; this one says how hard the
+ * row is being thrown.
+ */
+export declare function tiltFor(velocityX: number): number;
+/** A running release flight: `stop()` ends it, `promise` settles when it lands. */
+export interface Flight {
+    stop: () => void;
+}
+/**
+ * Fly a value 0 → 1 on a named spring row, seeded with the gesture's own release
+ * velocity. THE ONE rAF SPRING PATH — and therefore the one carrying the local
+ * reduced-motion gate: under `reduce` the flight collapses to a single frame at the
+ * endpoint, which is the honest cut (not a shortened animation).
+ *
+ * `velocityAlongPath` is px/s projected onto the flight vector; it is converted to
+ * the spring's own units (1 = the whole distance) by the distance itself.
+ */
+export declare function flyProgress(rowName: Parameters<typeof springPreset>[0], distance: number, velocityAlongPath: number, onFrame: (t: number) => void, onLand: () => void): Flight;

package/dist/components/sortable-list/resolve.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Sortable drop resolution — pure collision math over a rect cache taken at LIFT.
+ *
+ * THE CACHE IS NOT AN OPTIMISATION, IT IS THE CORRECTNESS FIX (E4). The parting
+ * animation writes `transform` on the very rows the midpoint scan reads, and
+ * `getBoundingClientRect()` reports the TRANSFORMED box — so a live per-frame scan
+ * resolves against geometry the previous frame's resolution produced. That loop
+ * oscillates at the boundary between two rows. Rows are snapshotted ONCE at lift, in
+ * their RESTING layout, and every frame resolves against that snapshot: one input,
+ * one output, no feedback path. The O(rows) walk stays O(rows) and stops touching
+ * layout mid-gesture.
+ *
+ * A scroll or a resize during a drag invalidates the snapshot, so both re-take it.
+ */
+import type { InstanceHandle, SortableId } from "./types.js";
+/**
+ * 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>;
+/**
+ * One row's resting geometry. The ORIGIN is stored, never the midpoint: the scan wants
+ * a midpoint and the release flight wants a landing corner, and two stored numbers for
+ * one measurement is how they drift apart. The midpoint is derived where it is used.
+ */
+export interface RowRect {
+    readonly id: SortableId;
+    readonly top: number;
+    readonly left: number;
+    readonly block: number;
+}
+/** The resting snapshot of one list, plus the container box the cursor is tested against. */
+export interface ListRects {
+    readonly rows: readonly RowRect[];
+    /** Distance between consecutive row starts — the block size a vacancy opens by. */
+    readonly pitch: number;
+}
+/**
+ * Snapshot a list's resting row geometry. Rows already carrying a parting transform
+ * are read through it (`offsetTop`-free): the caller takes the snapshot before any
+ * transform is written, which is what `lift` does.
+ */
+export declare function snapshotRows(elements: Map<SortableId, Element | null>, order: readonly SortableId[]): ListRects;
+/**
+ * Resolve an insertion BOUNDARY (0…rows.length) by walking the resting snapshot for
+ * the first row whose midpoint is past the cursor.
+ */
+export declare function resolveBoundary(rects: ListRects, clientY: number): 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/types.d.ts → types.d.ts}

@@ -9,15 +9,15 @@ export interface SortableOptions<T> {
     onInsert?: (index: number, item: unknown) => void;
     group?: string;
     handleSelector?: string | null;
-    axis?: "x" | "y";
 }
 export interface SortableRowBinding {
     ref: (el: unknown) => void;
     dataAttrs: Record<string, string>;
-    class: ComputedRef<Record<string, boolean>>;
     disabled: ComputedRef<boolean>;
     onPointerdown: (event: PointerEvent) => void;
     onKeydown: (event: KeyboardEvent) => void;
+    /** Release the row's registration — called from the row's unmount. */
+    release: () => void;
 }
 export interface SortableContainerBinding {
     ref: (el: unknown) => void;
@@ -28,12 +28,7 @@ export interface UseSortableReturn {
     container: SortableContainerBinding;
     isDragging: ComputedRef<boolean>;
     dragId: ComputedRef<SortableId | null>;
-    dragPosition: ComputedRef<{
-        x: number;
-        y: number;
-    } | null>;
     dropIndex: ComputedRef<number | null>;
-    pointerCaptureActive: ComputedRef<boolean>;
     announcement: ComputedRef<string>;
     getItemLabel: (id: SortableId) => string;
 }
@@ -45,6 +40,18 @@ export interface InstanceHandle {
     getId: (item: unknown) => SortableId;
     getElements: () => Map<SortableId, Element | null>;
     setExternalDropIndex: (index: number | null) => void;
+    /** The travelling subject's block size, so a receiving list can size its vacancy. */
+    setExternalSubjectBlock: (block: number | null) => void;
+    /**
+     * Where a subject arriving at `index` comes to rest, in viewport coordinates — the
+     * endpoint of the release flight. The RECEIVER answers it because the receiver owns
+     * the gap; the releasing list has already closed behind the subject. `null` while
+     * this list is unarmed or unmounted.
+     */
+    getVacancyOrigin: (index: number) => {
+        x: number;
+        y: number;
+    } | null;
     acceptExternal: (index: number, item: unknown) => void;
     focusItem: (id: SortableId) => void;
 }

package/dist/components/sortable-list/{composables/useSortable.d.ts → useSortable.d.ts}

@@ -1,5 +1,3 @@
-import { isNonZeroRadius } from "./ghostRenderer";
-import type { SortableOptions, UseSortableReturn } from "./types";
+import type { SortableOptions, UseSortableReturn } from "./types.js";
 export declare function useSortable<T>(options: SortableOptions<T>): UseSortableReturn;
-export { isNonZeroRadius };
-export type { SortableId, SortableContainerBinding, UseSortableReturn } from "./types";
+export type { SortableId, SortableContainerBinding, UseSortableReturn } from "./types.js";

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

@@ -1,18 +1,22 @@
-import { type HTMLAttributes } from "vue";
-type Variant = "active" | "paused" | "idle" | "error" | "custom";
-type Size = "xs" | "sm" | "md";
+import type { HTMLAttributes } from "vue";
+import type { StatusDotSize, StatusDotState } from "./states.js";
 type __VLS_Props = {
-    variant?: Variant;
-    color?: string;
-    pulse?: boolean;
-    size?: Size;
+    state?: StatusDotState;
+    size?: StatusDotSize;
+    /**
+     * Liveness axis. `"full"` runs the breathing pulse ring on the live
+     * `active` state (liquid-weight universal — the default); `"off"` opts
+     * down to a static mark. Reduced-motion always wins regardless.
+     */
+    motion?: "full" | "off";
+    /** Accessible identity. Omit when adjacent text already names the state. */
     label?: string;
     class?: HTMLAttributes["class"];
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    size: Size;
-    variant: Variant;
-    pulse: boolean;
+    size: StatusDotSize;
+    motion: "full" | "off";
+    state: StatusDotState;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -1 +1,3 @@
-export { default as StatusDot } from "./StatusDot.vue";
+export { default as StatusDot } from "./StatusDot.vue.js";
+export { STATUS_DOT_STATES } from "./states.js";
+export type { StatusDotSize, StatusDotState } from "./states.js";

package/dist/components/status-dot/states.d.ts

@@ -0,0 +1,4 @@
+import type { Size } from "../_shared/axes.js";
+export declare const STATUS_DOT_STATES: readonly ["active", "idle", "online", "success", "warning", "error", "unknown"];
+export type StatusDotState = (typeof STATUS_DOT_STATES)[number];
+export type StatusDotSize = Extract<Size, "sm" | "md" | "lg">;

package/dist/components/surface/Surface.vue.d.ts

@@ -1,26 +1,37 @@
 import { type HTMLAttributes } from "vue";
-import { type PrimitiveProps } from "reka-ui";
-import { type Surface as SurfaceKind, type SurfaceTier } from "../_shared/useSurfaceAxis";
-export interface SurfaceProps extends PrimitiveProps {
-    /** The base glass-ladder rung the plate paints over. Default `resting`. */
+import type { Surface as SurfaceAxis, SurfaceTier } from "../_shared/axes.js";
+import type { PrimitiveProps } from "../_shared/primitive.js";
+export type SurfaceDecoration = SurfaceAxis;
+/**
+ * The plate primitive. ONE prominence axis, three knobs, four emitted
+ * attributes.
+ *
+ * `material` / `SurfaceMaterial` / `MATERIAL_TIERS` are DELETED, not aliased: a
+ * four-member bijection onto four of the five tiers is `tier` under a second
+ * name, `wash` was unreachable through it, and `tier` silently beat it anyway.
+ * Zero external consumers passed it — censused across six sibling repos.
+ *
+ * `shadow` / `grain` / `specular` are deleted with the three silent JS gates
+ * that armed them. On an opaque plate the element-level `backdrop-filter: none`
+ * already wins by cascade; a hidden gate that no-ops a prop on a fourth prop's
+ * value is a rule the cascade was already keeping. `shadow` survives where it
+ * has a real grammar — as CARD's own prop, stamping card's own `data-shadow`.
+ *
+ * The FOURTH such gate went with them: `deep` used to be armed only when
+ * `surface === "glass"`, which is the same rule the cascade was already keeping
+ * from the other side. `[data-surface="opaque"]` sets `--glass-level: 0` (so the
+ * deep composition resolves `blur(0)`) AND `backdrop-filter: none` at the
+ * element; `[data-surface="veil"]` paints its own `--veil-clarity`, derived from
+ * the quiet radius, which never reads the bridged rung tokens. Both withhold the
+ * depth in PAINT, so `deep` is forwarded honestly and nothing arms it in script.
+ */
+export interface SurfaceProps extends Omit<PrimitiveProps, "asChild"> {
+    /** The ONE prominence axis: wash | quiet | resting | floating | overlay. */
     tier?: SurfaceTier;
-    /** The surface-decoration rung (the ONE shared axis): `glass` (default, the
-     *  plain tier rung) · `veil` (borderless/rimless text-legibility plate) ·
-     *  `opaque` (the `--glass-level:0` solid-card escape) · `clear` (the
-     *  scrim-coupled maximally-translucent Apple-Clear plate). Resolved through
-     *  `decorationClass()` — the ONE decoration source. */
-    surface?: SurfaceKind;
-    /** The BB.W-DEEP-GLASS opt-in maximal iOS-27 tier (Apple saturate-1.5/blur-16px):
-     *  a `.glass-deep` decoration ON the `floating` base rung. Default `false` — a
-     *  bare plate rides the calm content default. */
+    /** Decoration, orthogonal to prominence: glass | veil | opaque. */
+    surface?: SurfaceDecoration;
+    /** Thickness ON the resolved tier — never a tier jump. */
     deep?: boolean;
-    /** Surface drop shadow via `--shadow-card`. `veil` strips it by design (the
-     *  rimless plate is shadowless). Default `false` (the minimal bare plate). */
-    shadow?: boolean;
-    /** The `::after` paper-grain overlay. Default `false`. When off, the grain
-     *  pseudo is hidden (`[&::after]:hidden`) — a scroll pane / cartoon plate opts
-     *  out (the grain conflicts with overflow:auto repaints / the cast). */
-    grain?: boolean;
     class?: HTMLAttributes["class"];
 }
 declare var __VLS_8: {};
@@ -28,12 +39,10 @@ type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_8) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<SurfaceProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SurfaceProps> & Readonly<{}>, {
-    shadow: boolean;
-    as: import("reka-ui").AsTag | import("vue").Component;
-    surface: SurfaceKind;
+    as: import("../_shared/primitive.js").AsTag | import("vue").Component;
     deep: boolean;
     tier: SurfaceTier;
-    grain: boolean;
+    surface: SurfaceDecoration;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

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

@@ -1,2 +1,2 @@
-export { default as Surface, type SurfaceProps } from "./Surface.vue";
-export { decorationClass, surfaceClass } from "../_shared/useSurfaceAxis";
+export { default as Surface, type SurfaceProps, type SurfaceDecoration, } from "./Surface.vue.js";
+export type { SurfaceTier } from "../_shared/axes.js";

package/dist/components/switch/Switch.vue.d.ts

@@ -1,14 +1,18 @@
-import { type HTMLAttributes } from 'vue';
-import { type SwitchRootProps } from 'reka-ui';
-import { type ControlSize } from '../_shared/useControlSize';
-type __VLS_Props = SwitchRootProps & {
-    class?: HTMLAttributes['class'];
-    size?: ControlSize;
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (payload: boolean) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:modelValue"?: ((payload: boolean) => any) | undefined;
+import { type HTMLAttributes } from "vue";
+import { type ControlProps } from "../_shared/control.js";
+import type { FormFieldProps, PrimitiveProps } from "../_shared/primitive.js";
+import type { SelectionValue } from "../_shared/selection.js";
+export interface SwitchProps extends PrimitiveProps, FormFieldProps, ControlProps {
+    modelValue?: boolean;
+    defaultValue?: boolean;
+    id?: string;
+    value?: SelectionValue;
+    class?: HTMLAttributes["class"];
+}
+declare const __VLS_export: import("vue").DefineComponent<SwitchProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<SwitchProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -1 +1,2 @@
-export { default as Switch } from './Switch.vue';
+export { default as Switch } from "./Switch.vue.js";
+export type { SwitchProps } from "./Switch.vue.js";

package/dist/components/table/Table.vue.d.ts

@@ -1,4 +1,4 @@
-import type { HTMLAttributes } from "vue";
+import { type HTMLAttributes } from "vue";
 type __VLS_Props = {
     class?: HTMLAttributes["class"];
     role?: HTMLAttributes["role"];

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

@@ -1,8 +1,8 @@
-export { default as Table } from "./Table.vue";
-export { default as TableBody } from "./TableBody.vue";
-export { default as TableCell } from "./TableCell.vue";
-export { default as TableHead } from "./TableHead.vue";
-export { default as TableHeader } from "./TableHeader.vue";
-export { default as TableRow } from "./TableRow.vue";
-export { default as TableCaption } from "./TableCaption.vue";
-export { default as TableEmpty } from "./TableEmpty.vue";
+export { default as Table } from "./Table.vue.js";
+export { default as TableBody } from "./TableBody.vue.js";
+export { default as TableCell } from "./TableCell.vue.js";
+export { default as TableHead } from "./TableHead.vue.js";
+export { default as TableHeader } from "./TableHeader.vue.js";
+export { default as TableRow } from "./TableRow.vue.js";
+export { default as TableCaption } from "./TableCaption.vue.js";
+export { default as TableEmpty } from "./TableEmpty.vue.js";