@mkbabb/glass-ui 4.1.0 → 5.0.0

package/dist/coalesce-metric-B8o7zT9u.js

@@ -0,0 +1,13 @@
+//#region src/components/metric/coalesce-metric.ts
+var e = "—";
+function t(e, t = "—") {
+	return e == null || e === "" ? {
+		display: t,
+		isEmpty: !0
+	} : {
+		display: String(e),
+		isEmpty: !1
+	};
+}
+//#endregion
+export { t as n, e as t };

package/dist/collapsible.d.ts

@@ -1 +1 @@
-export * from "./components/ui/collapsible";
+export * from "./components/collapsible";

package/dist/collapsible.js

@@ -1,2 +1,2 @@
-import { n as e, r as t, t as n } from "./CollapsibleContent-68dEXIAl.js";
+import { n as e, r as t, t as n } from "./CollapsibleContent-DiHcB_HH.js";
 export { t as Collapsible, n as CollapsibleContent, e as CollapsibleTrigger };

package/dist/color-Bp5jmv4Z.js

@@ -0,0 +1,86 @@
+import { colorUnit2 as e, gamutMapOKLab as t, interpolateHue as n, isInSRGBGamut as r, oklabToLinearSRGB as i, oklabToRgb255 as a, parseCSSColor as o, rawOklabToOklch as s, rawOklchToOklab as c, srgbToOKLab as l } from "@mkbabb/value.js";
+//#region src/composables/color/index.ts
+function u(e) {
+	let [t, n, r] = c(e.L, e.C, e.h), [a, o, s] = i(t, n, r);
+	return [
+		Math.max(0, a),
+		Math.max(0, o),
+		Math.max(0, s)
+	];
+}
+function d(e, t, n) {
+	if (!Number.isFinite(e) || !Number.isFinite(t) || !Number.isFinite(n)) throw Error(`warmCatchLight: non-finite OKLCh anchor (L=${e}, C=${t}, h=${n})`);
+	return u({
+		L: e,
+		C: t,
+		h: n
+	});
+}
+function f(e) {
+	let [t, n, r] = c(e.L, e.C, e.h), [i, o, s] = a(t, n, r), l = (e) => Math.min(1, Math.max(0, e / 255));
+	return [
+		l(i),
+		l(o),
+		l(s)
+	];
+}
+function p(t) {
+	let n = e(o(t), "rgb").value, [r, i, a] = l(Number(n.r), Number(n.g), Number(n.b)), [c, u, d] = s(r, i, a);
+	return {
+		L: c,
+		C: u,
+		h: d
+	};
+}
+function m(e) {
+	let [t, n, r] = c(e.L, e.C, e.h), [i, o, s] = a(t, n, r), l = (e) => Math.round(e).toString(16).padStart(2, "0");
+	return `#${l(i)}${l(o)}${l(s)}`;
+}
+var h = (e) => f(p(e)), g = {
+	complementary: "longer",
+	"split-complementary": "longer",
+	analogous: "shorter",
+	monochrome: "shorter",
+	triad: "increasing",
+	tetradic: "increasing"
+}, _ = (e) => (e % 360 + 360) % 360;
+function v(e, t, r, i) {
+	let a = g[t], o = (e, t) => _(n(_(e) / 360, _(t) / 360, i, a) * 360);
+	switch (t) {
+		case "monochrome": return _(e);
+		case "complementary": return o(e, e + 180);
+		case "split-complementary": return o(e + 150, e + 210);
+		case "triad": return o(e, e + 240);
+		case "tetradic": return o(e, e + 270);
+		default: return o(e - r, e + r);
+	}
+}
+function y(e) {
+	let [n, a, o] = c(e.L, e.C, e.h), [l, u, d] = t(n, a, o), [f, p, m] = s(l, u, d), h = p;
+	for (let e = 0; e < 6; e++) {
+		let [e, t, n] = c(f, h, m), [a, o, s] = i(e, t, n);
+		if (r(a, o, s)) break;
+		h *= .999;
+	}
+	return {
+		L: f,
+		C: h,
+		h: m
+	};
+}
+function b(e, t = {}) {
+	let n = typeof e == "string" ? p(e) : e, { stopCount: r = 3, harmony: i = "analogous", lightnessSpread: a = .18, hueSpread: o = 24, chromaBump: s = .03, chromaCeiling: c, bodyLightness: l, lightnessFloor: u } = t, d = l === void 0 ? n.L - a / 2 : l, f = u === void 0 ? .05 : u, m = Math.max(2, Math.min(4, Math.round(r))), h = [];
+	for (let e = 0; e < m; e++) {
+		let t = m === 1 ? 0 : e / (m - 1), r = d + a * t, l = Math.max(0, n.C + s * Math.sin(Math.PI * t));
+		c !== void 0 && (l = Math.min(l, c));
+		let u = v(n.h, i, o, t);
+		h.push(y({
+			L: Math.min(.98, Math.max(f, r)),
+			C: l,
+			h: u
+		}));
+	}
+	return h;
+}
+//#endregion
+export { y as a, u as c, v as i, d as l, h as n, m as o, b as r, f as s, p as t };

package/dist/color-swatch.d.ts

@@ -1 +1 @@
-export * from "./components/custom/color-swatch";
+export * from "./components/color-swatch";

package/dist/color-swatch.js

@@ -1,6 +1,6 @@
-import { t as e } from "./cn-DJXf4yaB.js";
+import { t as e } from "./class-names-5jotTFzp.js";
 import { computed as t, createCommentVNode as n, createElementBlock as r, createElementVNode as i, defineComponent as a, mergeModels as o, mergeProps as s, normalizeClass as c, normalizeStyle as l, openBlock as u, toDisplayString as d, unref as f, useModel as p } from "vue";
-//#region src/components/custom/color-swatch/ColorSwatch.vue?vue&type=script&setup=true&lang.ts
+//#region src/components/color-swatch/ColorSwatch.vue?vue&type=script&setup=true&lang.ts
 var m = ["value"], h = {
 	key: 0,
 	class: "color-swatch__hex text-mono-caption tabular-nums uppercase text-muted-foreground"

package/dist/color.js

@@ -1,2 +1,3 @@
-import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c, u as l } from "./color-Cs0-oxYL.js";
-export { c as cssToOklch, i as defaultBlobColorResolver, o as deriveBlobPalette, n as deriveHue, e as gamutMapStop, a as oklchStopToHex, s as oklchToGammaRgb, t as oklchToLinear, l as useAccentTone, r as warmCatchLight };
+import { t as e } from "./useAccentTone-D25DxviG.js";
+import { a as t, c as n, i as r, l as i, n as a, o, r as s, s as c, t as l } from "./color-Bp5jmv4Z.js";
+export { l as cssToOklch, a as defaultBlobColorResolver, s as deriveBlobPalette, r as deriveHue, t as gamutMapStop, o as oklchStopToHex, c as oklchToGammaRgb, n as oklchToLinear, e as useAccentTone, i as warmCatchLight };

package/dist/command.d.ts

@@ -1 +1 @@
-export * from "./components/ui/command";
+export * from "./components/command";

package/dist/command.js

@@ -1,2 +1,2 @@
-import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c } from "./CommandShortcut-D3yxgHNn.js";
+import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c } from "./CommandShortcut-fmdbsEJL.js";
 export { r as Command, t as CommandDialog, s as CommandEmpty, a as CommandGroup, e as CommandInput, n as CommandItem, o as CommandList, i as CommandSeparator, c as CommandShortcut };

package/dist/completion-seal.d.ts

@@ -1 +1 @@
-export * from "./components/custom/completion-seal";
+export * from "./components/completion-seal";

package/dist/completion-seal.js

@@ -1,16 +1,16 @@
-import { t as e } from "./cn-DJXf4yaB.js";
-import { computed as t, createCommentVNode as n, createElementBlock as r, defineComponent as i, normalizeClass as a, onMounted as o, openBlock as s, readonly as c, ref as l, toDisplayString as u, toRef as d, unref as f, watch as p } from "vue";
-//#region src/components/custom/completion-seal/composables/useCompletionSeal.ts
-function m() {
+import { t as e } from "./class-names-5jotTFzp.js";
+import { Fragment as t, computed as n, createCommentVNode as r, createElementBlock as i, createElementVNode as a, defineComponent as o, normalizeClass as s, onMounted as c, openBlock as l, readonly as u, ref as d, toDisplayString as f, toRef as p, unref as m, watch as h } from "vue";
+//#region src/components/completion-seal/composables/useCompletionSeal.ts
+function g() {
 	return typeof window < "u" && typeof window.matchMedia == "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
 }
-function h(e) {
+function _(e) {
 	if (e != null) return typeof e == "function" ? e() : e.value;
 }
-function g(e = {}) {
-	let { play: n, respectReducedMotion: r = !0 } = e, i = l(!1), a = l(!1), s = t(() => r && m());
-	function u() {
-		if (s.value) {
+function v(e = {}) {
+	let { play: t, respectReducedMotion: r = !0 } = e, i = d(!1), a = d(!1), o = n(() => r && g());
+	function s() {
+		if (o.value) {
 			i.value = !1, a.value = !0;
 			return;
 		}
@@ -18,72 +18,106 @@ function g(e = {}) {
 			i.value = !0, a.value = !0;
 		}) : (i.value = !0, a.value = !0);
 	}
-	return n == null ? o(u) : (o(() => {
-		h(n) && u();
-	}), p(() => h(n), (e, t) => {
-		e && !t && u();
+	return t == null ? c(s) : (c(() => {
+		_(t) && s();
+	}), h(() => _(t), (e, t) => {
+		e && !t && s();
 	})), {
-		playing: c(i),
-		drawn: c(a),
-		reduced: c(s),
-		draw: u
+		playing: u(i),
+		drawn: u(a),
+		reduced: u(o),
+		draw: s
 	};
 }
-var _ = "0 0 64 64", v = {
+var y = "0 0 64 64", b = {
 	check: "M16 33 L28 45 L48 19",
 	wordmark: "M14 30 L26 42 L50 16 M14 50 L50 50"
-}, y = {
+}, x = {
 	cx: 32,
 	cy: 32,
 	r: 24
-}, b = [
+}, S = {
+	cx: 32,
+	cy: 32,
+	r: 21
+}, C = [
 	"data-shape",
+	"data-best",
 	"data-play",
 	"data-drawn"
-], x = ["viewBox"], S = [
+], w = ["viewBox"], T = [
+	"cx",
+	"cy",
+	"r"
+], E = [
 	"cx",
 	"cy",
 	"r"
-], C = ["d"], w = {
+], D = ["d"], O = [
+	"cx",
+	"cy",
+	"r"
+], k = ["d"], A = {
 	key: 0,
 	class: "sr-only"
-}, T = /* @__PURE__ */ i({
+}, j = /* @__PURE__ */ o({
 	name: "CompletionSeal",
 	__name: "CompletionSeal",
 	props: {
 		shape: {},
 		label: {},
 		play: { type: Boolean },
+		personalBest: { type: Boolean },
 		class: {}
 	},
-	setup(i) {
-		let o = i, c = t(() => o.shape ?? "check"), l = t(() => c.value === "wordmark" ? v.wordmark : v.check), { playing: p, drawn: m } = g({ play: o.play === void 0 ? void 0 : d(o, "play") });
-		return (t, i) => (s(), r("div", {
-			class: a(["completion-seal", f(e)(o.class)]),
-			"data-shape": c.value,
-			"data-play": f(p) ? "" : void 0,
-			"data-drawn": f(m) ? "" : void 0,
+	setup(o) {
+		let c = o, u = n(() => c.shape ?? "check"), d = n(() => u.value === "wordmark" ? b.wordmark : b.check), { playing: h, drawn: g } = v({ play: c.play === void 0 ? void 0 : p(c, "play") });
+		return (n, o) => (l(), i("div", {
+			class: s(["completion-seal", m(e)(c.class)]),
+			"data-shape": u.value,
+			"data-best": c.personalBest ? "" : void 0,
+			"data-play": m(h) ? "" : void 0,
+			"data-drawn": m(g) ? "" : void 0,
 			role: "status",
 			"aria-live": "polite"
-		}, [(s(), r("svg", {
+		}, [(l(), i("svg", {
 			class: "completion-seal__svg",
-			viewBox: f(_),
+			viewBox: m(y),
 			"aria-hidden": "true",
 			focusable: "false"
-		}, [c.value === "ring" ? (s(), r("circle", {
-			key: 0,
+		}, [u.value === "disc" ? (l(), i(t, { key: 0 }, [
+			a("circle", {
+				class: "completion-seal__disc",
+				cx: m(S).cx,
+				cy: m(S).cy,
+				r: m(S).r
+			}, null, 8, T),
+			a("circle", {
+				class: "completion-seal__mark completion-seal__ring",
+				cx: m(x).cx,
+				cy: m(x).cy,
+				r: m(x).r,
+				pathLength: "100"
+			}, null, 8, E),
+			a("path", {
+				class: "completion-seal__mark completion-seal__check",
+				d: m(b).check,
+				pathLength: "100"
+			}, null, 8, D)
+		], 64)) : u.value === "ring" ? (l(), i("circle", {
+			key: 1,
 			class: "completion-seal__mark",
-			cx: f(y).cx,
-			cy: f(y).cy,
-			r: f(y).r,
+			cx: m(x).cx,
+			cy: m(x).cy,
+			r: m(x).r,
 			pathLength: "100"
-		}, null, 8, S)) : (s(), r("path", {
-			key: 1,
+		}, null, 8, O)) : (l(), i("path", {
+			key: 2,
 			class: "completion-seal__mark",
-			d: l.value,
+			d: d.value,
 			pathLength: "100"
-		}, null, 8, C))], 8, x)), o.label ? (s(), r("span", w, u(o.label), 1)) : n("", !0)], 10, b));
+		}, null, 8, k))], 8, w)), c.label ? (l(), i("span", A, f(c.label), 1)) : r("", !0)], 10, C));
 	}
 });
 //#endregion
-export { T as CompletionSeal, g as useCompletionSeal };
+export { j as CompletionSeal, v as useCompletionSeal };

package/dist/components/_shared/axes.d.ts

@@ -0,0 +1,21 @@
+export type { Surface, SurfaceTier } from "./useSurfaceAxis";
+/** The scale axis — one honest ordinal; rung names ≡ the `--control-h-*` token cohort. */
+export declare const SIZES: readonly ["xs", "sm", "md", "lg", "xl"];
+export type Size = (typeof SIZES)[number];
+/** The layout axis — the inline `"horizontal" | "vertical"` copies factor onto this, zero value change. */
+export declare const ORIENTATIONS: readonly ["horizontal", "vertical"];
+export type Orientation = (typeof ORIENTATIONS)[number];
+/** The motion-weight axis — opt-DOWN, not opt-in (liquid-weight universal). */
+export declare const MOTIONS: readonly ["full", "reduced", "off"];
+export type Motion = (typeof MOTIONS)[number];
+/** The surface-decoration axis — mirrors `useSurfaceAxis`'s `Surface` (gate-asserted ≡). */
+export declare const SURFACES: readonly ["glass", "veil", "opaque"];
+/** The tone axis — the semantic status register (`--<tone>` token cohort); NEVER a `variant` member. */
+export declare const TONES: readonly ["neutral", "success", "warning", "info", "destructive"];
+export type Tone = (typeof TONES)[number];
+/** The overlay-placement axis — Sheet's side-slide + Dialog center fold onto ONE placement. */
+export declare const PLACEMENTS: readonly ["center", "top", "right", "bottom", "left"];
+export type Placement = (typeof PLACEMENTS)[number];
+/** The overlay-trigger axis — click | hover | context (the sealed Popover Kronecker fold). */
+export declare const TRIGGERS: readonly ["click", "hover", "context"];
+export type Trigger = (typeof TRIGGERS)[number];

package/dist/components/_shared/class-names.d.ts

@@ -0,0 +1,27 @@
+import { type ClassValue } from "clsx";
+/**
+ * `cn()` — class-name compositor for glass-ui components.
+ *
+ * Rationale (W3.b.2 / A5 §3 Split 6): `tailwind-merge` ships ~22 KB
+ * gzipped of full Tailwind config to resolve every conflict pair across
+ * the framework. Glass-ui exercises a small, stable subset of Tailwind
+ * utilities; the conflict surface is enumerable. We replace twMerge with
+ * a hand-rolled deduplicator that handles the ~30 conflict pairs glass-ui
+ * actually relies on, paying ~0.5 KB gzipped instead.
+ *
+ * Semantics: clsx normalises the variadic argument shape (strings,
+ * arrays, conditional objects, falsy filtering). The deduplicator then
+ * walks the joined string left-to-right, computes each token's
+ * conflict-key (the CSS-property bucket the utility writes to), and
+ * keeps only the last token per bucket. Variant prefixes like
+ * `hover:`, `md:`, `dark:`, `[&::after]:` carry their own conflict
+ * scope: a bucket-key incorporates the prefix so `text-sm md:text-lg`
+ * keeps both. `!`-important tokens scope identically to their
+ * non-important twin (`!p-2 p-4` keeps `p-4` — last-write-wins ignores
+ * importance, mirroring twMerge's behaviour for the cases glass-ui hits).
+ *
+ * Tokens that don't match a known bucket pass through untouched (custom
+ * classes, arbitrary-value utilities like `[&::after]:hidden`, anything
+ * not in the conflict table).
+ */
+export declare function cn(...inputs: ClassValue[]): string;

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

@@ -0,0 +1,6 @@
+export { menuItemVariants } from "./menuItemVariants";
+export type { MenuItemVariants } from "./menuItemVariants";
+export { surfaceClass, decorationClass } from "./useSurfaceAxis";
+export type { Surface, SurfaceTier } from "./useSurfaceAxis";
+export { controlSizeClass, switchSizeClass } from "./useControlSize";
+export type { ControlSize } from "./useControlSize";

package/dist/components/_shared/menuItemVariants.d.ts

@@ -0,0 +1,51 @@
+import { type VariantProps } from "class-variance-authority";
+/**
+ * `menuItemVariants` — canonical CVA shared by 9 menu-family + picker-family
+ * primitives. Promotes the four-state contract (hover / focus / data-highlighted /
+ * data-disabled) above reka-ui's base classes so consumer-side overrides win
+ * via `cn()`'s tailwind-merge ordering.
+ *
+ * Substrate composition:
+ * - `interactive-item` (utilities.css) provides `border-radius: var(--radius-lg)`,
+ *   the active-scale (`:active { transform: scale(0.98); }`), the focus-visible
+ *   box-shadow ring, and the `data-disabled` paint extension (V.W3 patch — the
+ *   :disabled pseudo doesn't fire on reka-ui's `data-disabled="true"` attr,
+ *   so utilities.css now paints both).
+ *
+ * Three input modes paint identical hover/focus accent:
+ * - `:hover` — pointer hover.
+ * - `:focus` — keyboard focus (also handled at the substrate via :focus-visible).
+ * - `[data-highlighted]` — reka-ui's internal navigation highlight (Combobox /
+ *   Command / Select families emit this attr instead of relying on browser focus).
+ *
+ * The CVA composes ABOVE reka-ui's base classes (R4 §4.2 pre-empt): consumer
+ * SFCs call `menuItemVariants(...)` last in the `cn()` chain so any radius /
+ * background / spacing the upstream library writes is overridden.
+ *
+ * Indicator slot variants reserve the gutter for radio-dot / check / chevron
+ * indicator spans the consumer SFCs render absolutely-positioned.
+ *
+ * Surface axis (BA.W-MENU-GLASS) — the menu-row's MATERIAL register, an
+ * EXPRESSION of the shared {glass·veil·opaque} surface-decoration axis
+ * (`_shared/useSurfaceAxis.ts` / `glass/surface-axis.css`), NOT a second axis:
+ * - `glass` (DEFAULT, glass-first canon AX.W54) — the `.glass-menu-row` recipe
+ *   (`src/styles/menu.css`): the hover / focus / `data-highlighted` / open states
+ *   paint the ELEMENT-LEVEL glass-quiet oklab tint (so the row darkens-over-light
+ *   AND lifts-over-dark per W-DARK-MATERIAL's tint arm) + a PRM-gated `translateY`
+ *   hover-lift, the 44px touch floor, the iOS-grade glassy hover-lift plate. The
+ *   flat `bg-accent` utilities are DROPPED on this arm — the cascade-trap-safe
+ *   shape: with no unlayered `hover:bg-accent` utility the ONLY background-painters
+ *   are the `@layer components` `.interactive-item:hover` accent rule and the
+ *   `.glass-menu-row` recipe (imported AFTER utilities.css so it source-order-wins
+ *   at equal specificity+layer — the AZ dock-rail `@layer`-loses-to-utility trap
+ *   pre-empted: never re-add an unlayered flat-accent utility here).
+ * - `accent` — the EXPLICIT flat-accent escape (the prior default's look). A clean
+ *   break, NOT a back-compat alias (BA inv-7): a consumer that wants the flat fill
+ *   opts in via `surface="accent"`.
+ */
+export declare const menuItemVariants: (props?: ({
+    surface?: "glass" | "accent" | null | undefined;
+    indicator?: "start" | "none" | "start-wide" | null | undefined;
+    size?: "md" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type MenuItemVariants = VariantProps<typeof menuItemVariants>;

package/dist/components/_shared/useControlSize.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The shared control-size axis — three rungs, ONE grammar. The meaningful
+ * control-size hierarchy rungs the input register needs (Button's `xs`/icon rungs
+ * are Button-specific — an input has no icon-only register, so they are NOT here).
+ *
+ *   sm      — the quieter/secondary control: the `--control-h-sm` height +
+ *             `--control-text-sm` font (shorter + quieter).
+ *   md      — the canonical golden pill: the `--control-h-md` height +
+ *             `--control-text` font (byte-identical to HEAD).
+ *   lg      — the primary/emphatic control: the `--control-h-lg` height with the
+ *             base `--control-text` font (taller, same workhorse weight — matching
+ *             Button's `lg`, where only the height grows).
+ */
+export type ControlSize = "sm" | "md" | "lg";
+/**
+ * Resolve a `ControlSize` to the element-level token-override class string the
+ * `.input-pill` recipe reads. The `md` rung emits NO override (so the recipe
+ * falls back to the cohort `--control-h-md` / `--control-text` — byte-identical to
+ * HEAD); `sm`/`lg` re-point `--control-pill-h` / `--control-pill-text` to the
+ * chosen cohort rung.
+ *
+ *   controlSizeClass()        → ""                                              (golden md rung)
+ *   controlSizeClass("sm")    → "[--control-pill-h:var(--control-h-sm)] [--control-pill-text:var(--control-text-sm)]"
+ *   controlSizeClass("lg")    → "[--control-pill-h:var(--control-h-lg)]"
+ *
+ * @param size the control-size rung (`sm` · `md` · `lg`)
+ */
+export declare function controlSizeClass(size?: ControlSize): string;
+/**
+ * The Switch geometry rung. A Switch is a control-height-DERIVED geometry (the
+ * track/thumb/throw are NOT the bare cohort height — a switch track is shorter
+ * than an input), so it derives its `--switch-track-h` from the chosen
+ * `--control-h-*` rung (×0.6, the iOS proportion) and the rest of the
+ * `--switch-*` quad follows in Switch.vue:
+ *
+ *   --switch-thumb   = --switch-track-h − 0.25rem   (the 2px×2 track border)
+ *   --switch-track-w = --switch-track-h × 11/6      (the iOS track aspect)
+ *   --switch-throw   = --switch-track-w − --switch-thumb − 0.25rem
+ *
+ * The `md` rung (`--control-h-md`) resolves the HEAD `h-6 w-11` track +
+ * `h-5 w-5` thumb + `translate-x-5` throw EXACTLY (byte-identical). `sm`/`lg`
+ * re-point the anchor `--switch-track-h` so the whole quad scales in lockstep.
+ *
+ * @param size the control-size rung (`sm` · `md` · `lg`)
+ */
+export declare function switchSizeClass(size?: ControlSize): string;

package/dist/components/_shared/useMotionAxis.d.ts

@@ -0,0 +1,41 @@
+import { type MaybeRefOrGetter } from "vue";
+import type { Motion } from "./axes";
+/**
+ * Resolve a prop `Motion` value (default `full`) DOWN under live PRM. The prop may
+ * only clamp DOWN — PRM forces `full`/`reduced` → `reduced` (never an escalation),
+ * `off` is preserved (the prop went below PRM, which is legal).
+ */
+export declare function resolveMotion(motion: Motion | undefined): Motion;
+/**
+ * The resolved-motion state a carrier reads. `armed` gates the JS gesture
+ * enrichment (drag/press/spring-mount/liquid-drag); `dataMotion`/`hostStyle` are the
+ * `:data-motion`/`:style` binds the carrier spreads onto its root (both undefined at
+ * the `full` default — the zero-delta no-op floor).
+ */
+export interface MotionAxis {
+    /** The PRM-clamped resolved rung (`full`/`reduced`/`off`). */
+    readonly resolved: Motion;
+    /** True iff resolved `full` — the JS gesture enrichment is armed. */
+    readonly armed: boolean;
+    /** `undefined` at `full` (no attr); the rung string otherwise. */
+    readonly dataMotion: "reduced" | "off" | undefined;
+    /** `undefined` unless `off` (then `{ "--motion-weight": "0" }`). */
+    readonly hostStyle: Record<string, string> | undefined;
+}
+/**
+ * The reactive motion resolver — the ONE seam every carrier threads. Pass the
+ * component's `motion` prop (a ref/getter/value); read `.armed` to gate JS
+ * enrichments, bind `.dataMotion` to `:data-motion`, spread `.hostStyle` into the
+ * root `:style`. All four derive from the ONE `resolveMotion` clamp so PRM
+ * precedence + the zero-delta default are single-sourced.
+ *
+ *   const motion = useMotionAxis(() => props.motion)
+ *   // <Root :data-motion="motion.dataMotion.value" :style="motion.hostStyle.value">
+ *   // if (motion.armed.value) { …arm the drag/press/spring enrichment… }
+ */
+export declare function useMotionAxis(motion: MaybeRefOrGetter<Motion | undefined>): {
+    resolved: import("vue").ComputedRef<"full" | "reduced" | "off">;
+    armed: import("vue").ComputedRef<boolean>;
+    dataMotion: import("vue").ComputedRef<"reduced" | "off" | undefined>;
+    hostStyle: import("vue").ComputedRef<Record<string, string> | undefined>;
+};

package/dist/components/_shared/useSurfaceAxis.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The shared surface-decoration axis — three rungs, ONE grammar.
+ *
+ *   glass   — the resolved tier's plain glass rung (default). The translucent
+ *             blur surface, the maximal glass-first register.
+ *   veil    — the borderless/rimless text-legibility plate: the `--glass-bg-quiet`
+ *             fill + blur with the box border AND rim STRIPPED (the boxed look
+ *             reads as a dividing line on a text plate). Reads the same `--glass-*`
+ *             ladder + W55 `--glass-tint-*` seam, so `--glass-level` / the bright
+ *             bucket retune it in lockstep with every glass surface.
+ *   opaque  — the `--glass-level:0` solid-card escape: solid `--card` + `blur(0)`
+ *             through the ONE level knob. The explicit opt-out from the maximal
+ *             glass default.
+ *
+ * (BE.W-CLEAR-VARIANT's `clear` member was RETIRED at BI.W-CLEAR-FOLD — a full
+ * mechanism with zero binding consumers; the substrate-without-consumer invariant
+ * J-inv-10 retires it. proof:surface-axis W9 (member-consumption) gate-locks the
+ * union against a future dead member riding vacuously.)
+ */
+export type Surface = "glass" | "veil" | "opaque";
+/**
+ * The 5-rung glass-ladder tier the surface paints its base over. Mirrors the
+ * `.glass-{wash,quiet,resting,floating,overlay}` ladder. A surface passes the rung
+ * it already paints (Card's `resting`, Dialog/Sheet/Popover's `floating`); the
+ * resolver maps it to the `glass-${tier}` base class. `opaque` is NOT a ladder
+ * rung here — it is a decoration on TOP of a base tier (the `.glass-opaque`
+ * escape keeps the tier's edge/rim), exactly as Card composes it.
+ */
+export type SurfaceTier = "wash" | "quiet" | "resting" | "floating" | "overlay";
+/**
+ * Resolve a (surface, tier) pair to the class string a surface composes. Pairs
+ * with a `:data-surface="surface"` attribute binding on the same element — the
+ * CSS seam (`surface-axis.css`) reads the attr to apply the veil/opaque
+ * decoration UNIFORMLY, while this resolver emits the back-compat decoration
+ * classes (`veil-surface` / `glass-opaque`) so Card's three shared rungs stay
+ * byte-identical and a surface composing the class set alone (no attr) still
+ * paints correctly.
+ *
+ *   surfaceClass("glass",  "floating") → "glass-floating"
+ *   surfaceClass("veil",   "floating") → "glass-floating veil-surface"
+ *   surfaceClass("opaque", "floating") → "glass-floating glass-opaque"
+ *
+ * @param surface the decoration rung (`glass` default · `veil` · `opaque`)
+ * @param tier    the base ladder rung (default `resting`)
+ */
+export declare function surfaceClass(surface?: Surface, tier?: SurfaceTier): string;
+/**
+ * Resolve ONLY the decoration class for a surface — no base-tier prefix
+ * (BI.W-SURFACE-EXTRACT). The SINGLE source of the veil/opaque decoration
+ * string; `surfaceClass()` (above) composes it after the base tier. This KILLS
+ * the `surfaceClass(x).replace(/^glass-.../, "")` tier-strip DRY wart every
+ * reka-portaled overlay hand-rolled to strip the base tier off `surfaceClass`'s
+ * output (the `^glass-<tier>` prefix, whitespace-trimmed): a
+ * surface that already composes its OWN base tier (Card `glass-${tier}`,
+ * Dialog/Sheet/Popover's baked `glass-floating`, the drawer recipe) reaches
+ * for the decoration ALONE through this function — ONE regex-free source.
+ *
+ *   decorationClass("glass")  → ""              (the identity — the bare tier paints)
+ *   decorationClass("veil")   → "veil-surface"
+ *   decorationClass("opaque") → "glass-opaque"
+ *
+ * @param surface the decoration rung (`glass` default · `veil` · `opaque`)
+ */
+export declare function decorationClass(surface?: Surface): string;

package/dist/components/alert/Alert.vue.d.ts

@@ -0,0 +1,19 @@
+import type { HTMLAttributes } from 'vue';
+import { type AlertVariants } from './';
+type __VLS_Props = {
+    class?: HTMLAttributes['class'];
+    tone?: AlertVariants['tone'];
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,8 @@
+import { type VariantProps } from 'class-variance-authority';
+export { default as Alert } from './Alert.vue';
+export { default as AlertDescription } from './AlertDescription.vue';
+export { default as AlertTitle } from './AlertTitle.vue';
+export declare const alertVariants: (props?: ({
+    tone?: "neutral" | "success" | "warning" | "info" | "destructive" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type AlertVariants = VariantProps<typeof alertVariants>;