@mkbabb/glass-ui 3.6.0 → 3.8.0

package/dist/components/custom/goo-blob/composables/useBlobPointer.d.ts

@@ -1,8 +1,31 @@
 import { type Ref } from "vue";
+/** Compile-time trail length — mirrors `TRAIL_N` in metaball.frag.ts. */
+export declare const TRAIL_N = 15;
+/** A single trail sample — a decaying-radius metaball source the shader smin-merges. */
+export interface TrailSample {
+    x: number;
+    y: number;
+    radius: number;
+}
 /**
- * Tracks the pointer over a host element, normalised to [-1, 1] relative to the
- * element centre, and smooths it per frame via `tick()`. On pointer-leave the
- * smoothed position decays back toward centre.
+ * The blob pointer/interaction machine (W10). Tracks the pointer over a host
+ * element (normalised to [-1, 1] about the element centre) and resolves it with a
+ * FRAME-RATE-INDEPENDENT critically-damped spring fed the renderer's per-frame
+ * `dtMs` (NOT a fixed-α lerp — the prior `SMOOTH_FACTOR = 0.12` was framerate
+ * dependent). The spring is `@mkbabb/keyframes.js` `SpringProgress` driven through
+ * its `tick(dt)` seam by the SUBSTRATE's single rAF — it does NOT call
+ * `SpringProgress.play()` (that would start a parallel rAF, the
+ * single-substrate-loop violation `proof:blob-interaction-prm` forbids).
+ *
+ * Exposes the smoothed `pointer` position AND its `velocity` (the spring's own
+ * per-frame velocity, units/s in normalized space), plus a decaying-radius `trail`
+ * buffer (the elastic pseudopod reaching toward the cursor and snapping back).
+ *
+ * Under `prefers-reduced-motion` the substrate freezes the rAF, so `tick` is not
+ * called and every axis holds its rest value — there is NO parallel matchMedia
+ * here (the substrate owns PRM). The deterministic rest pose: the spring at the
+ * pointer target (or centre when inactive), zero velocity, the trail collapsed
+ * onto the body.
  */
 export declare function useBlobPointer(el: Ref<HTMLElement | null>): {
     pointer: Readonly<Ref<{
@@ -12,7 +35,27 @@ export declare function useBlobPointer(el: Ref<HTMLElement | null>): {
         readonly x: number;
         readonly y: number;
     }>>;
+    velocity: Readonly<Ref<{
+        readonly x: number;
+        readonly y: number;
+    }, {
+        readonly x: number;
+        readonly y: number;
+    }>>;
     active: Readonly<Ref<boolean, boolean>>;
-    tick: () => void;
+    /** The live click-impulse pulse value (folds into uPulseAmp). */
+    pulse: Readonly<Ref<number, number>>;
+    /** ms since the last pointer activity (W11.c mood idle drift). */
+    idleMs: () => number;
+    tick: (dtMs?: number) => void;
+    trailSources: (baseRadius: number) => {
+        sources: TrailSample[];
+        count: number;
+    };
+    click: (amp: number) => void;
+    consumeClick: () => boolean;
+    rest: () => void;
+    /** AX.W16 — the quiescence at-rest predicate the renderer's demand gate reads. */
+    isAtRest: () => boolean;
 };
 export type BlobPointer = ReturnType<typeof useBlobPointer>;

package/dist/components/custom/goo-blob/composables/useBlobSatellites.d.ts

@@ -9,5 +9,7 @@ export declare function useBlobSatellites(config: BlobConfig, initialColor: stri
     tick: (now: number, mood: MoodParams) => void;
     nudge: () => void;
     reseed: (color: string) => void;
+    isQuiescent: () => boolean;
+    nextEventMs: (now: number) => number;
 };
 export type BlobSatelliteSystem = ReturnType<typeof useBlobSatellites>;

package/dist/components/custom/goo-blob/composables/useMetaballRenderer.d.ts

@@ -6,17 +6,32 @@ import type { BlobPointer } from "./useBlobPointer";
 import type { BlobSatelliteSystem } from "./useBlobSatellites";
 export interface UseMetaballRendererOptions {
     canvasRef: Ref<HTMLCanvasElement | null>;
+    /** The base color, ALREADY un-wrapped to a CONCRETE string by the SFC (DOM-free). */
     color: Ref<string>;
+    /**
+     * The Fresnel rim color, ALREADY un-wrapped to a CONCRETE string by the SFC
+     * (AX.W16 — the renderer no longer reaches the DOM for the `var()`-cascade read;
+     * the SFC's `resolveTokenColor` leaf does ALL un-wrapping before the renderer sees
+     * it). A `var(--token)` rim arrives here already resolved to `rgb(...)`.
+     */
+    rimColor: Ref<string>;
+    /**
+     * The multi-stop palette, ALREADY un-wrapped to CONCRETE strings by the SFC
+     * (AX.W16). EMPTY falls back to the base color (uStopCount <= 1).
+     */
+    paletteStops: Ref<string[]>;
     mood: BlobMoodSystem;
     pointer: BlobPointer;
     satellites: BlobSatelliteSystem;
     config: BlobConfig;
     /**
-     * The injected color seam (DEC-AT-2). Resolves a CSS color string to a GAMMA-
-     * sRGB triple in [0,1] fed straight into the shader's base-color uniform — the
-     * faithful AU.W7 lift paints gamma. REQUIRED: a no-resolver mount throws (the
+     * The injected color seam (DEC-AT-2). Resolves a CONCRETE CSS color string to a
+     * GAMMA-sRGB triple in [0,1] fed straight into the shader's base-color uniform —
+     * the faithful AU.W7 lift paints gamma. REQUIRED: a no-resolver mount throws (the
      * loud failure, not a silent gray) instructing the consumer to pass
-     * `defaultBlobColorResolver` from `@mkbabb/glass-ui/color` (or their own).
+     * `defaultBlobColorResolver` from `@mkbabb/glass-ui/color` (or their own). The
+     * renderer is DOM-FREE: it never un-wraps a `var(--token)` — the SFC's
+     * `resolveTokenColor` leaf does that BEFORE handing strings here (inv-K-3 seam).
      */
     colorResolver: ColorResolver;
 }

package/dist/components/custom/goo-blob/index.d.ts

@@ -1,5 +1,5 @@
 export { default as GooBlob } from "./GooBlob.vue";
-export type { BlobMood, MoodParams, MetaballSource, BlobConfig, SatellitePhase, SatelliteInternal, } from "./types";
+export type { BlobMood, BlobMerge, BlobQuality, MoodParams, MetaballSource, BlobConfig, SatellitePhase, SatelliteInternal, } from "./types";
 export { BLOB_CONFIG_DEFAULTS, BLOB_CONFIG_KEY } from "./types";
 export { useBlobMood, type BlobMoodSystem } from "./composables/useBlobMood";
 export { useBlobPointer, type BlobPointer } from "./composables/useBlobPointer";

package/dist/components/custom/goo-blob/shaders/sdf-body.glsl.d.ts

@@ -1 +1 @@
-export declare const METABALL_SDF_GLSL = "// --- SDF ---\n\nfloat sdCircle(vec2 p, vec2 center, float radius) {\n    return length(p - center) - radius;\n}\n\n// Edit #2 \u2014 Inigo Quilez quadratic polynomial smin (same uSmoothK uniform). The\n// quadratic h*h*k*0.25 form has a cleaner C1 seam than the prior cubic smin.\nfloat smin(float a, float b, float k) {\n    float h = max(k - abs(a - b), 0.0) / k;\n    return min(a, b) - h * h * k * 0.25;\n}";
+export declare const METABALL_SDF_GLSL = "// --- SDF ---\n\nfloat sdCircle(vec2 p, vec2 center, float radius) {\n    return length(p - center) - radius;\n}\n\n// AX.W15 \u2014 the VALUE+GRADIENT circle: returns vec3(d, dd/dx, dd/dy). The circle\n// gradient is the UNIT radial direction (p - center)/length(p - center) (the\n// eikonal property holds EXACTLY for a circle), guarded at the degenerate centre.\n// This is the keystone of the analytic-gradient smin: carrying the gradient\n// through the scene field DELETES the per-pixel 4-tap normal (4 full sceneDist\n// evals, each running 3-octave FBM + the sat/trail loops).\nvec3 sdgCircle(vec2 p, vec2 center, float radius) {\n    vec2 d = p - center;\n    float len = length(d);\n    vec2 grad = len > 1e-6 ? d / len : vec2(0.0, 1.0);\n    return vec3(len - radius, grad);\n}\n\n// IQ 2024 quadratic-polynomial smin, NORMALIZED so k is a blend band in distance\n// units. The k *= 4.0 pre-scale makes the h*h*k*0.25 poly's effective blend width\n// equal to k (the un-normalized form's width was 0.25*k).\nfloat sminQuadratic(float a, float b, float k) {\n    k *= 4.0;\n    float h = max(k - abs(a - b), 0.0) / k;\n    return min(a, b) - h * h * k * 0.25;\n}\n\n// IQ circular smin \u2014 a quarter-circle fillet at the seam (rounder than the\n// quadratic). The k *= 1.0/(1.0-sqrt(0.5)) factor normalizes k to the same\n// blend-band units so the merge axis swaps shape without re-tuning uSmoothK.\nfloat sminCircular(float a, float b, float k) {\n    k *= 1.0 / (1.0 - sqrt(0.5));\n    float h = max(k - abs(a - b), 0.0) / k;\n    return min(a, b) - k * 0.5 * (1.0 + h - sqrt(1.0 - h * (h - 2.0)));\n}\n\n// Config-gated merge dispatch \u2014 uMerge 0 = quadratic, 1 = circular.\nfloat smin(float a, float b, float k) {\n    if (uMerge > 0.5) return sminCircular(a, b, k);\n    return sminQuadratic(a, b, k);\n}\n\n// AX.W15 \u2014 the VALUE+GRADIENT smin. a/b are vec3(dist, grad.xy); the blended\n// gradient is mix(a.yz, b.yz, w) with the interpolation weight w the distance\n// blend uses (IQ's vec2-smin insight). This propagates the analytic gradient\n// through the merge so the surface normal reads the field gradient DIRECTLY \u2014 no\n// finite-difference tap. The blend weight matches each variant.\nvec3 sminQuadraticG(vec3 a, vec3 b, float k) {\n    k *= 4.0;\n    float h = max(k - abs(a.x - b.x), 0.0) / k;\n    float m = h * h * k * 0.25;\n    // h-weight that selects which surface dominates (0 \u2192 a, 1 \u2192 b).\n    float w = (a.x < b.x) ? 0.5 * h * h : 1.0 - 0.5 * h * h;\n    float dist = min(a.x, b.x) - m;\n    vec2 grad = mix(a.yz, b.yz, w);\n    return vec3(dist, grad);\n}\n\nvec3 sminCircularG(vec3 a, vec3 b, float k) {\n    k *= 1.0 / (1.0 - sqrt(0.5));\n    float h = max(k - abs(a.x - b.x), 0.0) / k;\n    float m = k * 0.5 * (1.0 + h - sqrt(1.0 - h * (h - 2.0)));\n    float w = (a.x < b.x) ? 0.5 * h : 1.0 - 0.5 * h;\n    float dist = min(a.x, b.x) - m;\n    vec2 grad = mix(a.yz, b.yz, w);\n    return vec3(dist, grad);\n}\n\nvec3 sminG(vec3 a, vec3 b, float k) {\n    if (uMerge > 0.5) return sminCircularG(a, b, k);\n    return sminQuadraticG(a, b, k);\n}";

package/dist/components/custom/goo-blob/shaders/watercolor-edges.glsl.d.ts

@@ -1,2 +1,2 @@
-export declare const METABALL_EDGE_NOISE_PRE_GLSL = "// --- Noise ---\n\nfloat hash21(vec2 p) {\n    vec3 p3 = fract(vec3(p.xyx) * 0.1031);\n    p3 += dot(p3, p3.yzx + 33.33);\n    return fract((p3.x + p3.y) * p3.z);\n}\n\nfloat valueNoise(vec2 p) {\n    vec2 i = floor(p);\n    vec2 f = fract(p);\n    f = f * f * (3.0 - 2.0 * f);\n\n    float a = hash21(i);\n    float b = hash21(i + vec2(1.0, 0.0));\n    float c = hash21(i + vec2(0.0, 1.0));\n    float d = hash21(i + vec2(1.0, 1.0));\n\n    return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);\n}\n\n// Edit #3 \u2014 rotated-octave FBM: a fixed ~0.5 rad 2x2 rotation between octaves\n// breaks the axis-aligned banding the un-rotated lattice noise produces. The\n// rotation CONSTANT is spliced from the shared chunk (AV.W2 \u2014 the one FBM_ROT);\n// the loop below stays blob-local (param octaves + 2.0 lacunarity, per \u00A73a).";
-export declare const METABALL_EDGE_NOISE_POST_GLSL = "float fbm(vec2 p, int octaves) {\n    float value = 0.0;\n    float amp = 0.5;\n    float freq = 1.0;\n    for (int i = 0; i < 4; i++) {\n        if (i >= octaves) break;\n        value += amp * valueNoise(p * freq);\n        p = FBM_ROT * p;\n        freq *= 2.0;\n        amp *= 0.5;\n    }\n    return value;\n}\n";
+export declare const METABALL_EDGE_NOISE_PRE_GLSL = "// --- Noise ---\n\nfloat hash21(vec2 p) {\n    vec3 p3 = fract(vec3(p.xyx) * 0.1031);\n    p3 += dot(p3, p3.yzx + 33.33);\n    return fract((p3.x + p3.y) * p3.z);\n}\n\n// IQ analytic-derivative gradient noise \u2014 value in .x, ANALYTIC gradient\n// (d/dx, d/dy) in .yz, from one eval. The quintic fade has a continuous 2nd\n// derivative so the gradient is smooth (a cubic smoothstep fade would crease it).\n// (Inigo Quilez, https://iquilezles.org/articles/gradientnoise/.)\nvec3 noised(vec2 p) {\n    vec2 i = floor(p);\n    vec2 f = fract(p);\n\n    // Quintic fade + its derivative.\n    vec2 u = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);\n    vec2 du = 30.0 * f * f * (f * (f - 2.0) + 1.0);\n\n    // Per-corner gradient vectors from the hash (centred to [-1, 1]).\n    vec2 ga = -1.0 + 2.0 * vec2(hash21(i + vec2(0.0, 0.0)), hash21(i + vec2(7.3, 0.0)));\n    vec2 gb = -1.0 + 2.0 * vec2(hash21(i + vec2(1.0, 0.0)), hash21(i + vec2(8.3, 0.0)));\n    vec2 gc = -1.0 + 2.0 * vec2(hash21(i + vec2(0.0, 1.0)), hash21(i + vec2(7.3, 1.0)));\n    vec2 gd = -1.0 + 2.0 * vec2(hash21(i + vec2(1.0, 1.0)), hash21(i + vec2(8.3, 1.0)));\n\n    float va = dot(ga, f - vec2(0.0, 0.0));\n    float vb = dot(gb, f - vec2(1.0, 0.0));\n    float vc = dot(gc, f - vec2(0.0, 1.0));\n    float vd = dot(gd, f - vec2(1.0, 1.0));\n\n    // Value, remapped to [0,1] so it drops in for the prior valueNoise.\n    float n = va + u.x * (vb - va) + u.y * (vc - va) + u.x * u.y * (va - vb - vc + vd);\n    float value = 0.5 + 0.5 * n;\n\n    // Analytic gradient (chain rule through the bilinear blend + the fade).\n    vec2 grad =\n        ga + u.x * (gb - ga) + u.y * (gc - ga) + u.x * u.y * (ga - gb - gc + gd) +\n        du * (vec2(u.y, u.x) * (va - vb - vc + vd) + vec2(vb, vc) - va);\n    return vec3(value, 0.5 * grad);\n}\n\n// Rotated-octave FBM over the analytic gradient noise: a fixed ~0.5 rad 2x2\n// rotation between octaves breaks the axis-aligned banding. The rotation CONSTANT\n// is spliced from the shared chunk (AV.W2 \u2014 the one FBM_ROT); the loops below\n// stay blob-local (param octaves + the LIQUID lacunarity/persistence, per \u00A73a).";
+export declare const METABALL_EDGE_NOISE_POST_GLSL: string;

package/dist/components/custom/goo-blob/types.d.ts

@@ -1,5 +1,14 @@
 import type { InjectionKey } from "vue";
 export type BlobMood = "idle" | "happy" | "curious" | "sleepy" | "excited";
+/** Smin merge variant — `quadratic` (cheap, creased) | `circular` (rounder menisci). */
+export type BlobMerge = "quadratic" | "circular";
+/**
+ * Render-quality axis (AX.W16) — `full` (default) renders the metaball pass at the
+ * clamped DPR; `half` renders the backing store at HALF resolution and lets the
+ * browser bilinear-upsample on composite (~4× fragment savings for weak GPUs — the
+ * blob is the ideal candidate: the soft FBM/AA edge hides the interpolation).
+ */
+export type BlobQuality = "full" | "half";
 export interface MoodParams {
     orbitSpeedScale: number;
     wobbleScale: number;
@@ -12,6 +21,8 @@ export interface MoodParams {
     smoothK: number;
     pointerAttraction: number;
     mergeRate: number;
+    /** Mood-driven iridescence/SSS intensity multiplier (excited > 1, sleepy < 1). */
+    iridScale: number;
 }
 export interface MetaballSource {
     x: number;
@@ -51,10 +62,19 @@ export interface BlobConfig {
     satelliteCount: number;
     satelliteRadius: number;
     orbitRadius: number;
+    quality: BlobQuality;
+    tempo: number;
     smoothK: number;
+    /** Smin merge variant — `quadratic` (default) | `circular` (rounder menisci). */
+    merge: BlobMerge;
     noiseAmp: number;
     noiseFreq: number;
     noiseSpeed: number;
+    /**
+     * Domain-warp strength on the FBM edge displacement (0 = plain fbm, the
+     * pre-warp look; ~0.6 = a marbled organic membrane). Taste-first low default.
+     */
+    warpAmp: number;
     pulseFreq: number;
     pulseAmp: number;
     hueRange: number;
@@ -62,8 +82,36 @@ export interface BlobConfig {
     brightnessShift: number;
     colorNoiseFreq: number;
     colorNoiseSpeed: number;
+    paletteStops: string[];
+    /** Warm-pearl rim sheen weight (0 = off). */
+    iridescence: number;
+    /** Base hue (degrees) the warm-biased cosine palette centres on. */
+    iridHue: number;
+    /** Animated-thickness scroll speed for the iridescent shimmer. */
+    iridSpeed: number;
+    /** Fast-SSS back-light weight. */
+    sssScale: number;
+    /** Fast-SSS exponent. */
+    sssPower: number;
+    /** Thickness-driven inner-luminosity (core glow) lift. */
+    coreGlow: number;
+    lit: boolean;
+    /** CSS color for the Fresnel rim tint (resolved through the ColorResolver). */
+    rimColor: string;
+    /** Light direction [x, y, z] (normalized in-shader). */
+    lightDir: [number, number, number];
+    specStrength: number;
+    /** Specular exponent (16-64 — a tight glint). */
+    specShininess: number;
+    /** Fresnel/Schlick exponent (~2-3). */
+    rimPower: number;
+    rimStrength: number;
     pointerAttraction: number;
     pointerStrength: number;
+    /** Velocity-driven volume-preserving squash-and-stretch magnitude (0 = off). */
+    stretch: number;
+    /** Click spring-impulse amplitude (a one-shot bouncy pulse on the body radius). */
+    clickImpulse: number;
     eccentricity: number;
     orbitSpeedScale: number;
     wobbleScale: number;

package/dist/components/custom/metric-cell/MetricCell.vue.d.ts

@@ -83,9 +83,9 @@ type __VLS_Slots = {} & {
 };
 declare const __VLS_base: import("vue").DefineComponent<MetricCellProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MetricCellProps> & Readonly<{}>, {
     placeholder: string;
+    appearance: MetricCellAppearance;
     iconStrokeWidth: number;
     iconSize: number;
-    appearance: MetricCellAppearance;
 }, {}, {}, {}, 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/custom/metric-stack/MetricStack.vue.d.ts

@@ -78,8 +78,8 @@ type __VLS_Slots = {} & {
 };
 declare const __VLS_base: import("vue").DefineComponent<MetricStackProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MetricStackProps> & Readonly<{}>, {
     as: string | Component;
-    rows: number;
     containerName: string;
+    rows: number;
     register: "audacious" | "result";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist/components/ui/_shared/ModalOverlay.vue.d.ts

@@ -77,8 +77,8 @@ type __VLS_Slots = {} & {
 };
 declare const __VLS_base: import("vue").DefineComponent<ModalOverlayProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ModalOverlayProps> & Readonly<{}>, {
     animate: "fade" | "scale" | "slide" | "none";
-    scrim: "glass" | "clear" | "dim";
     layout: "centered" | "edge" | "scroll";
+    scrim: "glass" | "clear" | "dim";
 }, {}, {}, {}, 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/ui/alert/index.d.ts

@@ -3,6 +3,6 @@ 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?: ({
-    variant?: "default" | "destructive" | null | undefined;
+    variant?: "default" | "destructive" | "success" | "warning" | "info" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export type AlertVariants = VariantProps<typeof alertVariants>;

package/dist/components/ui/card/Card.vue.d.ts

@@ -1,4 +1,4 @@
-import type { HTMLAttributes } from "vue";
+import { type HTMLAttributes } from "vue";
 import { type PrimitiveProps } from "reka-ui";
 /**
  * The five-tier glass surface ladder. Maps 1:1 to `.glass-{tier}` in glass.css
@@ -20,6 +20,21 @@ export type CardTier = "wash" | "quiet" | "resting" | "floating" | "overlay";
  *              ANY tier; the retired `<CartoonCard>` was `tier="quiet" surface="cartoon"`.
  */
 export type CardSurface = "glass" | "cartoon";
+/**
+ * Specular catch-light register (AX.W09) — the pointer-anchored moving lens on a
+ * glass card.
+ *
+ *   off    — NO catch-light (default). The clean resting panel: a data/content
+ *            `surface="glass"` card over any backplate reads flat — no centred
+ *            white bloom, no pointer wiring. The §24 three-consumer-confirmed
+ *            default for the common content-card case.
+ *   subtle — the token-ladder lens: the pointer-anchored catch-light wakes on
+ *            hover/active at the SUBTLE `--glass-specular-intensity-*` magnitudes.
+ *            The explicit opt-in for a hero/chrome surface.
+ *   full   — the brighter pre-tune rung set, for the busy-backdrop case the recipe
+ *            was originally authored over (a local intensity-token override).
+ */
+export type CardSpecular = "off" | "subtle" | "full";
 interface Props extends PrimitiveProps {
     /** Surface tier; selects one rung of the glass ladder. Default `resting`. */
     tier?: CardTier;
@@ -33,11 +48,18 @@ interface Props extends PrimitiveProps {
     /** `::after` paper-grain overlay. Off for scroll panes (the grain conflicts
      *  with overflow:auto repaints). */
     grain?: boolean;
+    /** Specular catch-light register (AX.W09). `off` (default) keeps the card
+     *  CLEAN — no pointer-anchored lens, clean over any backplate (the §24
+     *  three-consumer-confirmed default for a data/content card). `subtle` wakes
+     *  the pointer-anchored moving catch-light at the token-ladder magnitudes (a
+     *  hero/chrome opt-in); `full` runs the brighter pre-tune rung set for a busy
+     *  backdrop. Only `glass` surfaces wire it; `cartoon` owns its own sticker lift. */
+    specular?: CardSpecular;
     class?: HTMLAttributes["class"];
 }
-declare var __VLS_8: {};
+declare var __VLS_10: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_8) => any;
+    default?: (props: typeof __VLS_10) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
     shadow: boolean;
@@ -45,6 +67,7 @@ declare const __VLS_base: import("vue").DefineComponent<Props, {}, {}, {}, {}, i
     tier: CardTier;
     surface: CardSurface;
     grain: boolean;
+    specular: CardSpecular;
 }, {}, {}, {}, 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/ui/card/CardAction.vue.d.ts

@@ -0,0 +1,24 @@
+import type { HTMLAttributes } from "vue";
+/**
+ * <CardAction> — the shadcn-2025 top-right action slot of the Card family.
+ * When present inside a <CardHeader>, the header reflows to a two-column grid
+ * (title/description column + this action column) via the `@container/card-header`
+ * `has-data-[slot=card-action]` query on CardHeader. Self-aligns to the start of
+ * the header's first two rows, justified to the end.
+ */
+type __VLS_Props = {
+    class?: HTMLAttributes["class"];
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/ui/card/index.d.ts

@@ -1,6 +1,7 @@
-export { default as Card, type CardTier, type CardSurface } from "./Card.vue";
+export { default as Card, type CardTier, type CardSurface, type CardSpecular, } from "./Card.vue";
 export { default as CardHeader } from "./CardHeader.vue";
 export { default as CardTitle } from "./CardTitle.vue";
 export { default as CardDescription } from "./CardDescription.vue";
 export { default as CardContent } from "./CardContent.vue";
 export { default as CardFooter } from "./CardFooter.vue";
+export { default as CardAction } from "./CardAction.vue";

package/dist/components/ui/collapsible/CollapsibleTrigger.vue.d.ts

@@ -1,9 +1,13 @@
+import { type HTMLAttributes } from 'vue';
 import { type CollapsibleTriggerProps } from 'reka-ui';
+type __VLS_Props = CollapsibleTriggerProps & {
+    class?: HTMLAttributes['class'];
+};
 declare var __VLS_8: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_8) => any;
 };
-declare const __VLS_base: import("vue").DefineComponent<CollapsibleTriggerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<CollapsibleTriggerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, 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;

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

@@ -1,10 +1,20 @@
 import { type HTMLAttributes } from "vue";
 import { type ProgressRootProps } from "reka-ui";
 /**
- * Default progress variant — `bg-secondary` rail + `bg-primary` indicator with a
- * `translateX(-%)` intake-pulse. The plainest rung; no lifecycle motion grammar
- * (that lives on the gradient variant). The thin `Progress` dispatcher routes
- * here for `variant="default"`.
+ * Default progress variant — a `--progress-track` rail + a `--progress-fill`
+ * indicator with a `translateX(-%)` intake-pulse. The plainest rung; no lifecycle
+ * motion grammar (that lives on the gradient variant). The thin `Progress`
+ * dispatcher routes here for `variant="default"`.
+ *
+ * Token-read parity with the `gradient` variant (AX.W24 F1): the rail/indicator
+ * colour read `--progress-track`/`--progress-fill` (fallbacks `var(--secondary)`/
+ * `var(--primary)`) as Tailwind arbitrary properties — `bg-[var(--token,…)]` /
+ * `[background:var(--token,…)]` — NOT the `bg-secondary`/`bg-primary` utility
+ * classes. A `bg-primary` utility lives in `@layer utilities`, which ALWAYS
+ * outranks the `@layer components` `.glass-progress-rail` recipe regardless of
+ * source order, so a `:root { --progress-fill }` (or `.glass-progress-rail`'s
+ * token-set) override was a silent no-op on the default variant. Reading the token
+ * at source makes the `default` variant token-retintable for EVERY consumer.
  */
 type __VLS_Props = ProgressRootProps & {
     class?: HTMLAttributes["class"];

package/dist/components/ui/slider/Slider.vue.d.ts

@@ -21,6 +21,8 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:modelValue"?: ((payload: number[] | undefined) => any) | undefined;
     onValueCommit?: ((payload: number[]) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+}>, {
+    keepDockOpen: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/components/ui/tabs/TabsList.vue.d.ts

@@ -2,12 +2,22 @@ import { type HTMLAttributes } from 'vue';
 import { type TabsListProps } from 'reka-ui';
 type __VLS_Props = TabsListProps & {
     class?: HTMLAttributes['class'];
+    /**
+     * AW.W25 — render the spring `TabsIndicator` pill behind the triggers so
+     * the base default `<Tabs>` matches its own indicator primitive (the
+     * polished pill previously lived only in custom BouncyTabs; the base
+     * under-delivered vs its own `TabsIndicator.vue`). Default `true`. Set
+     * `:indicator="false"` for a list that drives its own active-state vocab.
+     */
+    indicator?: boolean;
 };
-declare var __VLS_8: {};
+declare var __VLS_13: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_8) => any;
+    default?: (props: typeof __VLS_13) => 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_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    indicator: boolean;
+}, {}, {}, {}, 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;

package/dist/components/ui/toast/Toast.vue.d.ts

@@ -1,13 +1,13 @@
 import { type HTMLAttributes } from 'vue';
 import { type ToastRootProps } from 'reka-ui';
+import type { ToastVariant } from './use-toast';
 interface ToastProps extends ToastRootProps {
     class?: HTMLAttributes['class'];
-    variant?: 'default' | 'destructive';
-    onOpenChange?: ((value: boolean) => void) | undefined;
+    variant?: ToastVariant;
 }
-declare var __VLS_21: {};
+declare var __VLS_8: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_21) => any;
+    default?: (props: typeof __VLS_8) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<ToastProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:open": (value: boolean) => any;
@@ -92,7 +92,7 @@ declare const __VLS_base: import("vue").DefineComponent<ToastProps, {}, {}, {},
         };
     }>, "currentTarget">) => any) | undefined;
 }>, {
-    variant: "default" | "destructive";
+    variant: ToastVariant;
 }, {}, {}, {}, 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/ui/toast/use-toast.d.ts

@@ -1,5 +1,5 @@
 import type { Component, VNode } from 'vue';
-export type ToastVariant = 'default' | 'destructive';
+export type ToastVariant = 'default' | 'destructive' | 'success' | 'warning' | 'info';
 export interface Toast {
     id: string;
     title?: string;

package/dist/composables/color/index.d.ts

@@ -20,6 +20,25 @@ export type ColorResolver = (css: string) => [number, number, number];
  * keeps them off the GPU). The equivalence canary asserts the COMPOSED path.
  */
 export declare function oklchToLinear(stop: OklchStop): [number, number, number];
+/**
+ * Warm-white catch-light → LINEAR-sRGB triple (AX.W11). The OKLCh-principled light
+ * tint the painterly relight (aurora's impasto sheen, the blob's `warmCream`) adds
+ * in LINEAR light — one shared OKLCh derivation both surfaces' light models route
+ * through instead of an eyeballed sRGB-ish literal. Just `oklchToLinear({L,C,h})`
+ * with a self-documenting name (the warm-light/cool-shadow temperature-coupling rule
+ * the literature prescribes is "the catch-light is a warm, near-white OKLCh anchor").
+ *
+ * Aurora's default anchor is `(0.985, 0.0125, 77.5°)` — the OKLCh anchor that
+ * reproduces the prior eyeballed `[1.0, 0.95, 0.88]` warm-white to <1e-3 linear (so
+ * the live relight reads identically; the seam fix is invisible to the eye). The
+ * blob's `warmCream` anchor is `(0.97, 0.03, 85°)` — a deeper, more-saturated cream;
+ * W15 re-routes the blob default through THIS helper at that anchor (the cross-surface
+ * unification: ONE OKLCh derive, each surface its own principled anchor).
+ *
+ * An invalid (non-finite) anchor THROWS — a library-internal contract violation, not
+ * a silent grey return (the fail-explicit precept; a stale anchor must surface loud).
+ */
+export declare function warmCatchLight(L: number, C: number, hDeg: number): [number, number, number];
 /**
  * OKLCh stop → GAMMA-sRGB in [0,1] — the blob's faithful-lift exit (DEC-AT-7's W7
  * GAMMA space). value.js's `oklabToRgb255` returns gamma-encoded 0..255 (HSV/sRGB,
@@ -47,3 +66,53 @@ export declare function oklchStopToHex(s: OklchStop): string;
  * gray default); value.js supplies its own, the demo story uses this one.
  */
 export declare const defaultBlobColorResolver: ColorResolver;
+/**
+ * Harmony schemes for the OKLCh palette derivers. Each maps the seed hue onto the
+ * derived stops differently:
+ * - `analogous` — neighbouring hues (seed ± a small spread).
+ * - `complementary` — seed → +180° along the LONG arc (stays saturated; the short
+ *   arc cuts through grey on a warm→cool pair).
+ * - `split-complementary` — the two hues flanking the complement (±150/210).
+ * - `triad` — seed + its two 120° partners.
+ * - `tetradic` — seed + the three 90° partners.
+ * - `monochrome` — every stop holds the seed hue; only L and C travel.
+ */
+export type ColorHarmony = "analogous" | "complementary" | "split-complementary" | "triad" | "tetradic" | "monochrome";
+/**
+ * Hue per harmony, walked across the ramp parameter `t` (0..1) THROUGH value.js's
+ * `interpolateHue` in the NORMALIZED-TURNS domain (`/360` in, `*360` out — value.js
+ * takes turns [0,1], NOT degrees; the `.5` short-arc threshold is a half-TURN). The
+ * single canonical hue-walk both backdrops consume.
+ */
+export declare function deriveHue(anchorHue: number, harmony: ColorHarmony, hueSpread: number, t: number): number;
+/**
+ * Gamut-map one OklchStop through value.js's Ottosson core
+ * (`rawOklchToOklab → gamutMapOKLab → rawOklabToOklch`) with a bounded inward-chroma
+ * nudge for the over-1 hull-placement escape. Hue is preserved exactly; the result
+ * is in-sRGB to the pipeline's tolerance. The single gamut-mapper both backdrops use.
+ */
+export declare function gamutMapStop(stop: OklchStop): OklchStop;
+/** Tuning for {@link deriveBlobPalette}. */
+export interface DeriveBlobPaletteOptions {
+    /** Number of stops to produce. Default 3; clamped to [2, 4]. */
+    stopCount?: number;
+    /** Hue scheme across the stops. Default `analogous`. */
+    harmony?: ColorHarmony;
+    /** Total L travel across the stops, in OKLCh L units. Default ~0.18. */
+    lightnessSpread?: number;
+    /** Hue walk in degrees for analogous; ignored by monochrome. Default ~24. */
+    hueSpread?: number;
+    /** Midpoint chroma-bump (keeps a vivid pair off the grey midpoint). Default ~0.03. */
+    chromaBump?: number;
+}
+/**
+ * Seed ONE color into a harmonious, gamut-safe 2-4-stop OKLCh palette for the blob
+ * — the blob-side twin of `deriveAurora`, consuming the SHARED `ColorHarmony`
+ * vocabulary (no forked `deriveHue`). The body takes the deepest/most-saturated
+ * stop; satellites take the lighter in-family stops. Every stop is gamut-mapped.
+ * Deterministic + DOM-free (SSR-safe; `cssToOklch` parses via value.js).
+ *
+ * @param seed any CSS color string OR an `OklchStop` anchor.
+ * @param options stop count, harmony, spreads.
+ */
+export declare function deriveBlobPalette(seed: string | OklchStop, options?: DeriveBlobPaletteOptions): OklchStop[];

package/dist/composables/dom/index.d.ts

@@ -1,9 +1,9 @@
 export * from "./useResizeObserver";
 export * from "./useTouchGate";
 export * from "./useTokenColor";
+export * from "./useResolveTokenColor";
 export * from "./useClipboard";
 export * from "./useUserInvalidAria";
-export * from "./useTextHighlight";
 export * from "./useBreakpoint";
 export * from "./useIdleReady";
 export * from "./useViewportReady";

package/dist/composables/dom/useResolveTokenColor.d.ts

@@ -0,0 +1,27 @@
+/** A bounded LRU-ish cache for the un-wrap (clears wholesale past the cap). */
+export interface ResolveTokenColorCache {
+    resolve: (css: string, el: HTMLElement | null) => string;
+    /** Drop every cached entry — call on a cascade change (dark-mode flip) so a token re-resolves. */
+    invalidate: () => void;
+}
+/**
+ * Un-wrap a `var(--token)` color to a concrete `rgb(...)` via a single cached cascade
+ * read; a literal (no `var()`) passes straight through. Paints `css` onto the element's
+ * `color` property — a `var(--token)` painted on a real CSS property resolves through
+ * the cascade, so `getComputedStyle(el).color` returns the concrete `rgb(...)` — then
+ * restores the prior value. SSR-safe (returns `css` unchanged when `window`/`el` are
+ * absent).
+ *
+ * @param css the color string (a `var(--token)` wrapper or a literal)
+ * @param el  the element to resolve the cascade against (the host wrapper)
+ * @returns the concrete color string the `ColorResolver` can parse
+ */
+export declare function resolveTokenColor(css: string, el: HTMLElement | null): string;
+/**
+ * Build a bounded cache around `resolveTokenColor` — the un-wrap (a forced sync
+ * reflow) runs once per unique color string. `invalidate()` drops every entry so a
+ * token re-resolves on a dark-mode flip (the SFC observes `<html>.class` and calls it).
+ *
+ * @param maxEntries the cache cap before a wholesale clear (default 256)
+ */
+export declare function createTokenColorCache(maxEntries?: number): ResolveTokenColorCache;

package/dist/composables/glass/canvas2d/index.d.ts

@@ -1,2 +1,3 @@
-export { createCanvas2D } from "./useCanvas2D";
+export { useCanvas2D, useCanvasLifecycle } from "./useCanvas2D";
 export type { Canvas2DFrame, Canvas2DHandle, Canvas2DOptions, Canvas2DSuspendReason, } from "./useCanvas2D";
+export { resolveCanvasColor } from "./resolveCanvasColor";

package/dist/composables/glass/canvas2d/resolveCanvasColor.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Resolve a CSS custom property or color value to a Canvas2D-VALID
+ * `rgb()`/`rgba()` string.
+ *
+ * @param cssVar a `--custom-property` NAME (resolved as `var(<name>)`) OR a full
+ *   CSS color value (`light-dark(...)`, `color-mix(...)`, `var(...)`, `oklch()`,
+ *   `hsl()`, hex, a named color). A bare `--token` is wrapped as `var(--token)`.
+ * @param el an element ON the cascade — the canvas host or any descendant. The
+ *   probe is appended here so it inherits `el`'s `color-scheme` + `--token`
+ *   cascade; the resolved color reflects the live theme at `el`.
+ * @returns the browser-resolved `rgb()`/`rgba()` string, ready to hand straight
+ *   to `ctx.strokeStyle`/`ctx.fillStyle`. On SSR / no-DOM, returns the input
+ *   `cssVar` unchanged (the befitting-silent fallback).
+ *
+ * @example
+ * // A `light-dark()` `--foreground` token that Canvas2D would reject raw:
+ * ctx.strokeStyle = resolveCanvasColor("--foreground", canvas);
+ * // → "rgb(28, 25, 23)" in light, "rgb(250, 250, 249)" in dark — NOT black.
+ */
+export declare function resolveCanvasColor(cssVar: string, el: HTMLElement): string;