@mkbabb/glass-ui 3.5.1 → 3.7.0

package/dist/components/custom/dock/GlassDock.vue.d.ts

@@ -28,8 +28,38 @@ type __VLS_Props = {
      *                        chassis vocabulary. AJ-W1-δ / G-AJ-D7.
      */
     variant?: "dock" | "rail" | "instrument-strip";
-    /** Corner treatment for vertical rail/tool-palette docks. */
-    shape?: "pill" | "rounded";
+    /**
+     * Corner treatment.
+     *   `"pill"`    — the stadium silhouette (default).
+     *   `"rounded"` — a finite rounded radius (`--radius-xl`).
+     *   `"card"`    — the AW.W3b big-dock card shell: a finite concentric
+     *                 radius (`--dock-card-radius`, default `--radius-3xl`)
+     *                 ABOVE 2xl, below pill — does NOT collapse to a stadium.
+     *                 Collapsed it returns to a pill; the pill↔card swap
+     *                 morphs on the `--dock-motion-resize` spring. A `@supports
+     *                 (corner-shape: squircle)` enhancement reads better at the
+     *                 large radius (the border-radius arc is the contract).
+     *
+     * `"pill"`/`"rounded"` previously bound ONLY under the vertical rail
+     * variant — on a horizontal dock the prop silently no-op'd. AW.W3b adds
+     * the horizontal-root shape rules (closing that documented-but-dead prop),
+     * so `shape` now paints on a horizontal dock too.
+     */
+    shape?: "pill" | "rounded" | "card";
+    /**
+     * In-cap arrangement. `"linear"` (default) lays the active layer out as a
+     * linear row/column. `"grid"` makes the active layer a self-wrapping tile
+     * grid (Launchpad/Stage-Manager track symmetry — `auto-fill` columns of
+     * `--dock-tile-min`). ORTHOGONAL to `overflow` (the OVER-cap strategy):
+     * `layout` is the IN-cap arrangement.
+     *
+     * Hard contract: a `layout="grid"` dock is `alwaysExpanded` (a 2D panel
+     * does not read as a collapsible pill, and no width morph means no
+     * per-frame grid reflow). The canonical pairing is
+     * `shape="card" layout="grid"` (the props stay independent — no
+     * auto-implication of `shape`).
+     */
+    layout?: "linear" | "grid";
     /**
      * Layout axis of the dock. `"horizontal"` (default) lays items out
      * left-to-right and animates `width`; `"vertical"` lays items out
@@ -101,7 +131,8 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
     orientation: "horizontal" | "vertical";
     variant: "dock" | "rail" | "instrument-strip";
     density: DockDensity;
-    shape: "pill" | "rounded";
+    shape: "pill" | "rounded" | "card";
+    layout: "linear" | "grid";
     collapseDelay: number;
     alwaysExpanded: boolean;
     startCollapsed: boolean;

package/dist/components/custom/fourier-field/FourierField.vue.d.ts

@@ -0,0 +1,38 @@
+import { type ColorResolver } from "../../../composables/color";
+/**
+ * FourierField — a Fourier epicycle field on a Canvas2D surface, a sibling
+ * primitive to Aurora and GooBlob. A seeded elliptic spectrum reconstructs a
+ * slow, never-ending closed curve via the inverse DFT; a fading comet trail
+ * chases the curve's head, and (in the `hero` preset) the nested epicycle
+ * circles and arms draw underneath in a harmonious second hue. It composes the
+ * `useCanvas2D` substrate, so it inherits the offscreen / tab-hidden /
+ * reduced-motion freeze for free — no hand-rolled RAF-park.
+ *
+ * Color resolves through the same INJECTED `colorResolver` seam as GooBlob: the
+ * field paints the gamma-sRGB triple it returns. The prop is REQUIRED — pass
+ * `defaultBlobColorResolver` from `@mkbabb/glass-ui/color` so a `var()` /
+ * `light-dark()` token, an `oklch()` / `hsl()` / hex string all resolve. A
+ * `var()` token is first resolved to a concrete `rgb()` against the host's
+ * inherited color-scheme, then re-resolved on a color change AND on a dark-mode
+ * toggle so the field retints with the theme.
+ *
+ * `variant` is the configuration BUNDLE, not a recolour of one curve: `hero`
+ * draws a few big phasors with the epicycles ON and a warm trail feel; `final`
+ * draws a denser elliptic spectrum with the epicycles OFF. One engine, two
+ * presets. The hue itself always comes from the consumer's `color`.
+ */
+type __VLS_Props = {
+    /** Configuration bundle. `hero` = epicycles on, fewer harmonics; `final` = epicycles off, denser. Default `hero`. */
+    variant?: "hero" | "final";
+    /** Base CSS color (any form the resolver understands; a `var()`/`light-dark()` token resolves against the host). */
+    color: string;
+    /** REQUIRED color seam — resolves a concrete color to a gamma-sRGB [r,g,b] triple in [0,1]. */
+    colorResolver: ColorResolver;
+    /** Extra seed mixed into the spectrum PRNG for a unique-but-reproducible curve. Default "". */
+    seed?: string;
+    /** When true, paint ONE static deterministic best-frame and never animate (the capture/export lever). Default false. */
+    freeze?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/custom/fourier-field/index.d.ts

@@ -0,0 +1,2 @@
+export { default as FourierField } from "./FourierField.vue";
+export { comp, evalFourier, positionsAt, makeEllipticSpectrum, type BasisComponent, type EllipticSpectrumOptions, } from "./math";

package/dist/components/custom/fourier-field/math.d.ts

@@ -0,0 +1,57 @@
+/**
+ * One Fourier phasor. `index` is the integer frequency (a counter-rotating pair
+ * is `+1` and `-1`); `coefficient` is the complex coefficient `[re, im]`;
+ * `amplitude`/`phase` are its polar form (carried for callers that prefer the
+ * polar read — the reconstruction uses the rectangular `coefficient`).
+ */
+export interface BasisComponent {
+    index: number;
+    coefficient: [number, number];
+    amplitude: number;
+    phase: number;
+}
+/**
+ * Build a {@link BasisComponent} from a frequency index and its rectangular
+ * coefficient `(re, im)`, deriving the polar `amplitude`/`phase`.
+ */
+export declare function comp(index: number, re: number, im: number): BasisComponent;
+/**
+ * Sum `c_k * exp(2*pi*i*k*t)` — the curve point at parameter `t`. `maxTerms`
+ * truncates the series (the partial-sum read). Returns the complex value as
+ * `[re, im]` (the curve's `[x, y]` before view-fit).
+ */
+export declare function evalFourier(components: BasisComponent[], t: number, maxTerms?: number): [number, number];
+/**
+ * The epicycle chain at parameter `t`: the running tip of each phasor stacked on
+ * the last, starting at the origin. `positions[0]` is `[0, 0]`; the final entry
+ * is the curve point ({@link evalFourier} at the same `t`). `maxCircles`
+ * truncates the chain (draw fewer arms than the spectrum carries).
+ */
+export declare function positionsAt(components: BasisComponent[], t: number, maxCircles?: number): [number, number][];
+/** Tuning for {@link makeEllipticSpectrum}. */
+export interface EllipticSpectrumOptions {
+    /**
+     * How many smaller higher-order harmonics to layer on top of the dominant
+     * counter-rotating pair (the dominant pair is always present). Default 4.
+     * The `final` preset passes a larger count for a denser, busier curve.
+     */
+    harmonics?: number;
+    /**
+     * Peak magnitude of the higher-order harmonics relative to the dominant
+     * phasor. Smaller keeps the curve a clean, smooth ellipse with a little
+     * character; larger crinkles it. Default ~0.22.
+     */
+    harmonicScale?: number;
+}
+/**
+ * Emit a procedural elliptic spectrum: a DOMINANT counter-rotating pair (index
+ * `+1` and `-1`) of UNEQUAL magnitude — the inequality is what draws a tilted
+ * ellipse rather than a circle — plus a few smaller higher-order harmonics with
+ * random small magnitudes and phases for character. Lower orders carry more
+ * weight (a `1 / order` falloff), so the curve stays large, smooth and
+ * few-big-phasor; the `harmonics` knob lifts it to the denser `final` look.
+ *
+ * Deterministic in `rng`: the same seeded `() => number` yields the same
+ * spectrum, so a frozen frame reproduces exactly.
+ */
+export declare function makeEllipticSpectrum(rng: () => number, opts?: EllipticSpectrumOptions): BasisComponent[];

package/dist/components/custom/goo-blob/GooBlob.vue.d.ts

@@ -35,9 +35,11 @@ type __VLS_Props = {
 };
 declare function nudge(): void;
 declare function setMood(m: BlobMood): void;
+declare function pulse(): void;
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
     nudge: typeof nudge;
     setMood: typeof setMood;
+    pulse: typeof pulse;
     currentMood: Readonly<import("vue").Ref<BlobMood, BlobMood>>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     click: () => any;

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

@@ -1,14 +1,26 @@
 import { type Ref } from "vue";
 import type { BlobMood, MoodParams } from "../types";
+/** The interaction signals `update` reads to drive the auto-mood arc. */
+export interface MoodInteraction {
+    /** The pointer is over the blob (drives `curious`). */
+    pointerActive: boolean;
+    /** A click landed this frame (drives a one-shot `excited`). */
+    clicked: boolean;
+    /** ms since the last pointer activity (drives `sleepy` past IDLE_SLEEP_MS). */
+    idleMs: number;
+}
 /**
  * Animates the blob's mood parameters — a cross-fade between named mood targets
- * driven per frame by `tick(dt)`. `setMood` retargets; `params` is the eased
- * current value the renderer reads.
+ * driven per frame by `tick(dt)`. `setMood` retargets; `update(interaction)` wires
+ * `setMood` internally from the AW.W10 pointer/idle state (curious on approach,
+ * excited on click, sleepy after inactivity); `params` is the eased current value
+ * the renderer reads.
  */
 export declare function useBlobMood(): {
     currentMood: Readonly<Ref<BlobMood>>;
     params: Readonly<Ref<MoodParams>>;
     setMood: (mood: BlobMood) => void;
+    update: (interaction: MoodInteraction) => void;
     tick: (dt: number) => void;
 };
 export type BlobMoodSystem = ReturnType<typeof useBlobMood>;

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,25 @@ 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;
 };
 export type BlobPointer = ReturnType<typeof useBlobPointer>;

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

@@ -1,6 +1,6 @@
 import { type Ref } from "vue";
 import type { ColorResolver } from "../../../../composables/color";
-import type { BlobConfig } from "../types";
+import { type BlobConfig } from "../types";
 import type { BlobMoodSystem } from "./useBlobMood";
 import type { BlobPointer } from "./useBlobPointer";
 import type { BlobSatelliteSystem } from "./useBlobSatellites";

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, 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// 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}";

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 + 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 * noised(p * freq).x;\n        p = FBM_ROT * p;\n        freq *= 2.0;\n        amp *= 0.5;\n    }\n    return value;\n}\n\n// One domain-warp pass: offset the sample point by a low-frequency FBM of itself\n// (the IQ fbm(p + W*fbm(p)) marbling). warpAmp (uniform-driven) is the warp\n// strength; warpAmp == 0.0 degrades to plain fbm (the pre-warp look).\nfloat fbmWarped(vec2 p, int octaves, float warpAmp) {\n    if (warpAmp <= 0.0) return fbm(p, octaves);\n    vec2 q = vec2(fbm(p + vec2(0.0, 0.0), octaves), fbm(p + vec2(5.2, 1.3), octaves));\n    return fbm(p + warpAmp * (q - 0.5), octaves);\n}\n";

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

@@ -1,5 +1,7 @@
 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";
 export interface MoodParams {
     orbitSpeedScale: number;
     wobbleScale: number;
@@ -12,6 +14,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 +55,18 @@ export interface BlobConfig {
     satelliteCount: number;
     satelliteRadius: number;
     orbitRadius: number;
+    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 +74,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
@@ -33,11 +33,17 @@ interface Props extends PrimitiveProps {
     /** `::after` paper-grain overlay. Off for scroll panes (the grain conflicts
      *  with overflow:auto repaints). */
     grain?: boolean;
+    /** Opt-in interactive register (AW.W24). A glass card with `hover` wakes the
+     *  dormant pointer-anchored specular catch-light: it tracks the cursor across
+     *  the surface (the AV.W15 moving-glass illuminate) instead of the centred
+     *  var() floor. Static cards (default) keep the centred catch-light and never
+     *  attach the listener. `cartoon` surfaces own their own sticker lift. */
+    hover?: boolean;
     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 +51,7 @@ declare const __VLS_base: import("vue").DefineComponent<Props, {}, {}, {}, {}, i
     tier: CardTier;
     surface: CardSurface;
     grain: boolean;
+    hover: boolean;
 }, {}, {}, {}, 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

@@ -4,3 +4,4 @@ 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/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

@@ -47,3 +47,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/glass/canvas2d/index.d.ts

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