@mkbabb/glass-ui 7.0.0 → 8.0.0

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;

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,14 +1,21 @@
 import type { HTMLAttributes } from "vue";
-import type { FeedbackSize, StatusDotState } from "../_shared/feedback";
+import type { StatusDotSize, StatusDotState } from "./states.js";
 type __VLS_Props = {
     state?: StatusDotState;
-    size?: FeedbackSize;
+    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: FeedbackSize;
+    size: StatusDotSize;
+    motion: "full" | "off";
     state: StatusDotState;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;

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

@@ -1,2 +1,3 @@
-export { default as StatusDot } from "./StatusDot.vue";
-export type { FeedbackSize as StatusDotSize, StatusDotState, } from "../_shared/feedback";
+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,17 +1,37 @@
 import { type HTMLAttributes } from "vue";
-import type { Surface as SurfaceAxis, SurfaceTier } from "../_shared/axes";
-import type { PrimitiveProps } from "../_shared/primitive";
+import type { Surface as SurfaceAxis, SurfaceTier } from "../_shared/axes.js";
+import type { PrimitiveProps } from "../_shared/primitive.js";
 export type SurfaceDecoration = SurfaceAxis;
-export type SurfaceMaterial = "content" | "elevated" | "functional" | "overlay";
-export type SurfaceSpecular = "off" | "subtle" | "full";
+/**
+ * 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"> {
-    material?: SurfaceMaterial;
+    /** The ONE prominence axis: wash | quiet | resting | floating | overlay. */
     tier?: SurfaceTier;
+    /** Decoration, orthogonal to prominence: glass | veil | opaque. */
     surface?: SurfaceDecoration;
+    /** Thickness ON the resolved tier — never a tier jump. */
     deep?: boolean;
-    shadow?: boolean;
-    grain?: boolean;
-    specular?: SurfaceSpecular;
     class?: HTMLAttributes["class"];
 }
 declare var __VLS_8: {};
@@ -19,13 +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("../_shared/primitive").AsTag | import("vue").Component;
-    surface: SurfaceDecoration;
+    as: import("../_shared/primitive.js").AsTag | import("vue").Component;
     deep: boolean;
-    material: SurfaceMaterial;
-    grain: boolean;
-    specular: SurfaceSpecular;
+    tier: SurfaceTier;
+    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, type SurfaceDecoration, type SurfaceMaterial, type SurfaceSpecular, } from "./Surface.vue";
-export type { SurfaceTier } from "../_shared/axes";
+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,23 +1,18 @@
 import { type HTMLAttributes } from "vue";
-import type { ControlSize } from "../_shared/control-size";
-import type { FormFieldProps } from "../_shared/primitive";
-export interface SwitchProps extends FormFieldProps {
-    modelValue?: boolean | null;
+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;
-    disabled?: boolean;
     id?: string;
-    value?: string;
+    value?: SelectionValue;
     class?: HTMLAttributes["class"];
-    size?: ControlSize;
-    invalid?: boolean;
 }
 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;
-}>, {
-    size: ControlSize;
-    invalid: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

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

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";

package/dist/components/tabs/SegmentedTabs.vue.d.ts

@@ -1,13 +1,12 @@
 import { type HTMLAttributes } from "vue";
-import { type TabActivation } from "./composables/useTabRovingFocus";
-import type { Motion } from "../_shared/axes";
+import type { TabActivation } from "./composables/useTabRovingFocus.js";
+import type { Motion } from "../_shared/axes.js";
 /** The canonical tab/option shape — one descriptor across both materials. */
 export interface SegmentedTabOption {
     label: string;
     value: string;
     icon?: string;
     disabled?: boolean;
-    tooltip?: string;
     /**
      * The `id` of the tabpanel this option reveals. When set and semantics resolve to
      * `tabs`, it is emitted as the tab's `aria-controls`, completing the APG
@@ -16,7 +15,7 @@ export interface SegmentedTabOption {
      */
     controls?: string;
 }
-/** The two materials: `pill` is the default glass-track slider; `underline` is the paper ink hairline. */
+/** The two materials: `pill` is the default glass eyeglass; `underline` is the paper ink hairline. */
 export type SegmentedTabsVariant = "pill" | "underline";
 /** The interaction semantic, independent of material. `toggle` exposes a
  *  group of pressed buttons; `tabs` exposes a tablist with selected tabs. */
@@ -49,8 +48,10 @@ export interface SegmentedTabsProps {
     /** Accessible name shared by the desktop strip and responsive Select. */
     ariaLabel?: string;
     /**
-     * The material — `pill` (DEFAULT, the glass-track slider) or `underline`
-     * (the paper ink-hairline rule).
+     * The material — `pill` (DEFAULT, the glass eyeglass) or `underline` (the paper
+     * ink-hairline rule). TWO, and the eyeglass is not a third: it is what `pill`
+     * IS. A "million variants that are essentially the same thing" is the failure
+     * mode this axis exists to refuse.
      */
     variant?: SegmentedTabsVariant;
     /**
@@ -87,17 +88,12 @@ type __VLS_ModelProps = {
     modelValue: string;
 };
 type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
-declare var __VLS_50: {
-    option: SegmentedTabOption;
-    active: boolean;
-}, __VLS_58: {
+declare var __VLS_32: {
     option: SegmentedTabOption;
     active: boolean;
 };
 type __VLS_Slots = {} & {
-    option?: (props: typeof __VLS_50) => any;
-} & {
-    option?: (props: typeof __VLS_58) => any;
+    option?: (props: typeof __VLS_32) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:modelValue": (value: string) => any;

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

@@ -1,6 +1,6 @@
 import type { ComputedRef, Ref } from "vue";
-import { type UseDragMorphReturn } from "../../../composables/motion/morph/useDragMorph";
-import type { SegmentedTabOption } from "../SegmentedTabs.vue";
+import { type UseDragMorphReturn } from "../../../composables/motion/morph/useDragMorph.js";
+import type { SegmentedTabOption } from "../SegmentedTabs.vue.js";
 /**
  * Package-private composable for `SegmentedTabs.vue` — the LIQUID
  * TAB (the `:draggable` axis). A composable held under the

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

@@ -1,5 +1,5 @@
 import type { ComputedRef, Ref } from "vue";
-import type { SegmentedTabOption, SegmentedTabsResponsive } from "../SegmentedTabs.vue";
+import type { SegmentedTabOption, SegmentedTabsResponsive } from "../SegmentedTabs.vue.js";
 /**
  * Package-private composable for `SegmentedTabs.vue` (the
  * roving-focus/responsive carve). The responsive-collapse concern

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

@@ -1,13 +1,21 @@
 import type { ComputedRef, Ref } from "vue";
+import type { SelectionValue } from "../../_shared/selection.js";
 /**
  * The minimal roving option shape reads only `value` + `disabled`, decoupling it
  * from `SegmentedTabOption` so the shared
  * headless `useSelectionGroup` can compose it VERBATIM over its generic option
  * type). Any richer option (the tabs' `SegmentedTabOption`) is structurally
  * assignable.
+ *
+ * Generic in the value scalar, defaulting to `string` (BK #84 C-1). The machine
+ * only compares values with `===` and interpolates them into a reset key, so it is
+ * indifferent to which scalar it carries — but a callback parameter is
+ * contravariant, so `select` could not simply be widened in place without breaking
+ * every narrower caller. The type variable is what lets `<ToggleGroup>` pass
+ * `SelectionValue` and `<SegmentedTabs>` keep `string`, from one machine.
  */
-export interface RovingSelectionOption {
-    value: string;
+export interface RovingSelectionOption<V extends SelectionValue = string> {
+    value: V;
     disabled?: boolean;
 }
 export type TabActivation = "automatic" | "manual";
@@ -26,11 +34,11 @@ export type TabActivation = "automatic" | "manual";
  * wraps, and disabled options are skipped. This keyboard contract is never gated by
  * pointer motion.
  */
-export interface UseTabRovingFocusParams {
+export interface UseTabRovingFocusParams<V extends SelectionValue = string> {
     /** The options the strip renders (index-aligned to `buttonRefs`). */
-    stripOptions: ComputedRef<readonly RovingSelectionOption[]>;
+    stripOptions: ComputedRef<readonly RovingSelectionOption<V>[]>;
     /** The value the strip renders (the ONE tabstop anchor). */
-    stripValue: ComputedRef<string | undefined>;
+    stripValue: ComputedRef<V | undefined>;
     /** True for the vertical (block-axis) orientation — flips the arrow axis. */
     isVertical: ComputedRef<boolean>;
     /** Automatic selection-follows-focus or manual Enter/Space activation. */
@@ -38,7 +46,7 @@ export interface UseTabRovingFocusParams {
     /** Per-option button refs, index-aligned to `stripOptions`. */
     buttonRefs: Ref<HTMLElement[]>;
     /** The SFC's selection handler (focus-follows activation → model write + squish). */
-    select: (value: string, idx: number) => void;
+    select: (value: V, idx: number) => void;
 }
 export interface UseTabRovingFocusReturn {
     /** The selected index in the rendered strip. */
@@ -48,4 +56,4 @@ export interface UseTabRovingFocusReturn {
     /** The strip-root keydown handler (axis-derived arrows + Home/End). */
     onStripKeydown: (e: KeyboardEvent) => void;
 }
-export declare function useTabRovingFocus(params: UseTabRovingFocusParams): UseTabRovingFocusReturn;
+export declare function useTabRovingFocus<V extends SelectionValue = string>(params: UseTabRovingFocusParams<V>): UseTabRovingFocusReturn;

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

@@ -1,2 +1,2 @@
-export { default as SegmentedTabs } from "./SegmentedTabs.vue";
-export type { SegmentedTabOption, SegmentedTabsVariant, SegmentedTabsSemantics, SegmentedTabsActivation, SegmentedTabsOrientation, SegmentedTabsProps, SegmentedTabsResponsive, } from "./SegmentedTabs.vue";
+export { default as SegmentedTabs } from "./SegmentedTabs.vue.js";
+export type { SegmentedTabOption, SegmentedTabsVariant, SegmentedTabsSemantics, SegmentedTabsActivation, SegmentedTabsOrientation, SegmentedTabsProps, SegmentedTabsResponsive, } from "./SegmentedTabs.vue.js";

package/dist/components/tabs/styles/drag.css

@@ -1 +1 @@
-.glass-drag-grabbable { cursor: grab; touch-action: none; } .glass-drag-lift { cursor: grabbing; will-change: transform; } .segmented-tabs:not(.segmented-tabs--underline):has( .segmented-indicator.glass-drag-grabbable ) .segmented-tab[aria-pressed="true"] { pointer-events: none; } .segmented-indicator.glass-drag-lift { z-index: 30; }
+.glass-drag-grabbable{cursor: grab;touch-action: none;}.glass-drag-lift{cursor: grabbing;will-change: transform;}.segmented-tabs:has(.segmented-indicator.glass-drag-grabbable) .segmented-tab[data-active]{pointer-events: none;}.segmented-indicator.glass-drag-lift{z-index: 30;}