@mkbabb/glass-ui 3.7.0 → 3.8.0

package/dist/components/custom/dock/composables/useLayerTransition.d.ts

@@ -2,78 +2,32 @@ import type { Ref } from "vue";
 export interface UseLayerTransitionOptions {
     /** The container element that owns the stacked layer panes. */
     containerEl: Ref<HTMLElement | null>;
-    /** The currently active layer id */
+    /** The currently active layer id. */
     activeLayer: Ref<string>;
     /**
-     * Animation axis. `"horizontal"` animates `width`; `"vertical"` animates
-     * `height`. Defaults to horizontal when omitted.
+     * Animation axis. `"horizontal"` morphs the inline axis; `"vertical"` morphs
+     * the block axis. Defaults to horizontal when omitted.
      */
     axis?: Ref<"horizontal" | "vertical">;
     /**
-     * AW.W3 — typed directional View-Transitions. Maps a swap `(from, to)` to
-     * the `types` array passed to `startViewTransition`, so
-     * `:active-view-transition-type(<t>)` CSS can author DIRECTION-specific
-     * curves (snappier exit, softer entry-overshoot — the iOS-feel asymmetry).
-     * The outer collapsed↔expanded pair resolves `dock-expand` / `dock-collapse`;
-     * the inner DockLayerGroup pane swap resolves `layer-forward` / `layer-back`.
-     * Omit to run the single symmetric curve. Feature-detected — degrades to the
-     * symmetric curve on an engine without the `types` overload (Firefox 144).
+     * Retained for API parity with the prior VT-typed signature (consumed by
+     * `GlassDock` + `DockLayerGroup`). The single-scalar morph runs ONE symmetric
+     * spring on every engine, so the direction hint is no longer a curve fork — it
+     * is accepted and ignored. Kept so the call sites need no edit.
      */
     directionTypes?: (from: string, to: string) => string[];
 }
 export interface UseLayerTransitionReturn {
-    /** Attach to @transitionend on the container */
+    /** Attach to `@transitionend` on the container (kept for call-site parity). */
     onTransitionEnd(e: TransitionEvent): void;
-    /** The currently active layer id (post-swap) */
+    /** The currently active layer id (post-swap). */
     currentLayer: Ref<string>;
-    /** The layer id currently fading out, or null */
+    /** The layer id currently fading out, or null. */
     leavingLayer: Ref<string | null>;
 }
 /**
- * Coordinates the crossfade + size animation between grid-stacked dock layer
- * panes. Reusable at any nesting level (the inner `<DockLayerGroup>` pair AND
- * the outer GlassDock collapsed↔expanded pair).
- *
- * AQ.W6 §Design 7 — the swap FORKS on View-Transitions support:
- *
- * - **Native path** (`document.startViewTransition` present): the layer swap is
- *   wrapped in `startViewTransition(() => mutate())`. The browser snapshots the
- *   container + panes (tagged `view-transition-name` in `dock.css`) and morphs
- *   the size + crossfades the pane content with ZERO `getBoundingClientRect`
- *   reads. No pin/measure/re-pin dance, no inline size, no rAF.
- *
- * - **Fallback path** (no `startViewTransition`): the axis-aware FLIP, KEPT as
- *   the sole feature-detected fallback (no alias — one path or the other runs per
- *   swap, never both). It is now the ONLY driver that writes inline size on a
- *   non-VT engine (AV.W9.0 retired the `interpolate-size`/`calc-size` CSS arm that
- *   used to second-drive width on Chrome 129+ and freeze the dock):
- *   1. Capture current container size (or the live spring's pixel value on a
- *      retarget)
- *   2. Pin container to that size
- *   3. nextTick → rAF: swap classes (old → leaving, new → active) AND measure new
- *      natural size in ONE frame origin
- *   4. Drive size off ONE `SpringProgress` clock in PIXEL space (its `value` IS
- *      the live width/height)
- *   5. On settle, clear inline size + restore the CSS transition
- *
- *   AV.W9.2 — velocity-continuity: an interrupted swap (a re-toggle while the
- *   spring is still live) RE-SEATS the existing solver's target from its current
- *   `(value, velocity)` instead of dispose+reconstruct-from-rest, so the morph is
- *   continuous through a retarget (the iOS interruptible-spring contract).
- *
- * AV.W7 perf folds:
- *   - F3 — on-demand `will-change`: the morphing box gets `will-change:<dim>`
- *     ONLY for the gesture's duration (set just before the spring drives it,
- *     cleared to `auto` on settle/`transitionend`). NEVER a standing hint — a
- *     permanent `will-change` holds a compositor layer + VRAM for an idle dock.
- *   - F5 — inheritance-bomb guard (CONVENTION): this driver animates ONLY the
- *     element's own `width`/`height` (the spring's pixel-space `value`) and the
- *     pane opacity rides a class-driven CSS transition on the SEPARATE
- *     `.dock-layer-item-host`. NO INHERITED custom property (`--phase-color` /
- *     `--shadow-color`) is TWEENED per frame here — animating an inherited
- *     custom property forces a whole-subtree style recalc every frame (the
- *     inheritance bomb). Phase/shadow colors are SET on a discrete state change,
- *     never interpolated frame-by-frame. Keep new motion on `transform`/`opacity`
- *     /`width`/`height`; route any color shift through a discrete class swap.
+ * Coordinates the size morph + crossfade between grid-stacked dock layer panes.
+ * Reusable at any nesting level (the inner `<DockLayerGroup>` pair AND the outer
+ * `GlassDock` collapsed↔expanded pair).
  */
 export declare function useLayerTransition(options: UseLayerTransitionOptions): UseLayerTransitionReturn;

package/dist/components/custom/dock/index.d.ts

@@ -7,4 +7,6 @@ export { default as DockTabButton } from "./DockTabButton.vue";
 export { default as DockSelectTrigger } from "./DockSelectTrigger.vue";
 export { default as DockDropdownTrigger } from "./DockDropdownTrigger.vue";
 export type { UseDockStateOptions, UseDockStateReturn, DockState } from "./composables";
+export { useLayerTransition } from "./composables";
+export type { UseLayerTransitionOptions, UseLayerTransitionReturn, } from "./composables";
 export { DOCK_CONTEXT_KEY, useDockContext, useOptionalDockContext, provideDockContext, type DockContext, type DockOrientation, } from "./composables/dockContext";

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

@@ -32,6 +32,15 @@ type __VLS_Props = {
     config?: BlobConfig;
     /** Extra seed string mixed into the satellite PRNG for a unique-but-reproducible system. */
     seed?: string;
+    /**
+     * AX.W16 — the declarative WCAG-2.2.2 pause seam. `v-model:paused` parks the
+     * render loop (the substrate's `manual` suspend) when `true` and restarts it when
+     * `false`. This is the EXACT shape `<DockBackgroundToggle>` wears — wire its
+     * `@update:paused` to this `v-model` and the blob's animation stops/starts for ALL
+     * users. The imperative `pause()`/`resume()` defineExpose handles bind the SAME
+     * renderer seam (no parallel pause path); the prop owns the default.
+     */
+    paused?: boolean;
 };
 declare function nudge(): void;
 declare function setMood(m: BlobMood): void;
@@ -41,10 +50,14 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
     setMood: typeof setMood;
     pulse: typeof pulse;
     currentMood: Readonly<import("vue").Ref<BlobMood, BlobMood>>;
+    pause: () => void;
+    resume: () => void;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     click: () => any;
+    "update:paused": (value: boolean) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     onClick?: (() => any) | undefined;
+    "onUpdate:paused"?: ((value: boolean) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -22,5 +22,9 @@ export declare function useBlobMood(): {
     setMood: (mood: BlobMood) => void;
     update: (interaction: MoodInteraction) => void;
     tick: (dt: number) => void;
+    /** AX.W16 — the quiescence at-rest predicate the renderer's demand gate reads. */
+    isSettled: () => boolean;
+    /** AX.W16 — wall-ms to the next auto-mood retarget (the wake horizon). */
+    nextAutoMoodMs: () => number;
 };
 export type BlobMoodSystem = ReturnType<typeof useBlobMood>;

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

@@ -55,5 +55,7 @@ export declare function useBlobPointer(el: Ref<HTMLElement | null>): {
     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

@@ -1,22 +1,37 @@
 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";
 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, BlobMerge, 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// 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}";
+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\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";
+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

@@ -2,6 +2,13 @@ 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;
@@ -55,6 +62,7 @@ export interface BlobConfig {
     satelliteCount: number;
     satelliteRadius: number;
     orbitRadius: number;
+    quality: BlobQuality;
     tempo: number;
     smoothK: number;
     /** Smin merge variant — `quadratic` (default) | `circular` (rounder menisci). */

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

@@ -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,12 +48,13 @@ 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;
+    /** 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_10: {};
@@ -51,7 +67,7 @@ declare const __VLS_base: import("vue").DefineComponent<Props, {}, {}, {}, {}, i
     tier: CardTier;
     surface: CardSurface;
     grain: boolean;
-    hover: 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/index.d.ts

@@ -1,4 +1,4 @@
-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";

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/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,

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;

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

@@ -45,4 +45,18 @@ export interface Canvas2DHandle {
     /** The live `prefers-reduced-motion: reduce` state (consumers read it to skip stepping). */
     readonly reducedMotion: boolean;
 }
-export declare function createCanvas2D(options: Canvas2DOptions): Canvas2DHandle;
+/**
+ * The Canvas2D lifecycle substrate — the park/freeze/dispose twin of
+ * `useWebGLCanvas`. Returns an imperative {@link Canvas2DHandle} (the same
+ * handle idiom the WebGL twin uses — an imperative canvas seam is NOT a
+ * ref-bundle). `useCanvasLifecycle` is the alias-of-record for the
+ * lifecycle-only framing; both name the same factory.
+ */
+export declare function useCanvas2D(options: Canvas2DOptions): Canvas2DHandle;
+/**
+ * Alias-of-record for {@link useCanvas2D} — the lifecycle-only framing (the
+ * park/freeze/dispose machinery, paralleling the WebGL substrate's
+ * `createCanvasLifecycle`). Same factory, same handle; reach for this name when
+ * the lifecycle (not the 2D drawing) is the consumer's emphasis.
+ */
+export declare const useCanvasLifecycle: typeof useCanvas2D;

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

@@ -1,3 +1,5 @@
 export { useGlassRenderer, createGlassFilter, destroyGlassFilter, type GlassTier, type GlassFilterState, type UseGlassRendererReturn, } from "./useGlassRenderer";
-export { createCanvas2D } from "./canvas2d";
+export { useSpecularTracking } from "./useSpecularTracking";
+export type { UseSpecularTracking } from "./useSpecularTracking";
+export { useCanvas2D, useCanvasLifecycle, resolveCanvasColor } from "./canvas2d";
 export type { Canvas2DFrame, Canvas2DHandle, Canvas2DOptions, Canvas2DSuspendReason, } from "./canvas2d";

package/dist/composables/glass/useSpecularTracking.d.ts

@@ -0,0 +1,33 @@
+import { ref, type CSSProperties } from "vue";
+/**
+ * `useSpecularTracking` — the pointer-anchored moving-specular write seam
+ * (AX.W09). The single DRY home for the catch-light position write that was
+ * hand-copied VERBATIM in `Card.vue` and `DockIconButton.vue`.
+ *
+ * On pointer-move it writes the cursor position (`--mouse-x`/`--mouse-y`, as
+ * percentages of the host box) onto the host's inline style; the unified
+ * `.glass-material::before` recipe (`glass.css`) MAPS that host write onto its
+ * typed `--specular-x`/`--specular-y` channel and paints the travelling glow.
+ *
+ * VOCAB (HARDENING §G #28): `--mouse-x`/`--mouse-y` is the HOST WRITE this seam
+ * owns; `--specular-x`/`--specular-y` is the CSS-internal MAPPED channel the
+ * recipe reads. The host writes `--mouse-x/y`; the recipe maps it.
+ *
+ * The catch-light MAGNITUDE rides the `--glass-specular-intensity-{rest,hover,
+ * active}` token cohort (tokens.css) the recipe reads — this seam only feeds the
+ * position. The recipe's rest rung is `0` (dormant) so an UNWIRED surface is
+ * clean; calling this seam is the wire-or-omit opt-in that wakes the lens on
+ * hover/active.
+ *
+ * PRM-aware: under `prefers-reduced-motion: reduce` the seam DOES NOT write the
+ * position (the CSS half pins the catch-light static at the centred `50%`
+ * fallback). The write is style-only — no reflow, no re-render — and inert until
+ * the user actually moves the pointer over a wired host.
+ */
+export interface UseSpecularTracking {
+    /** Bind to the host element's `:style`. Carries the `--mouse-x/--mouse-y` write. */
+    specularStyle: ReturnType<typeof ref<CSSProperties>>;
+    /** Bind to the host's `@pointermove`. Writes the cursor position (PRM-gated). */
+    onPointerMove: (event: PointerEvent) => void;
+}
+export declare function useSpecularTracking(): UseSpecularTracking;

package/dist/composables/glass/webgl/createCanvasLifecycle.d.ts

@@ -1,4 +1,4 @@
-export type CanvasSuspendReason = "tab-hidden" | "off-screen" | "manual";
+export type CanvasSuspendReason = "tab-hidden" | "off-screen" | "off-screen-io" | "manual";
 /** The per-frame hooks a backend's `buildContext` returns to the lifecycle core. */
 export interface CanvasFrameHooks {
     /** Draw one frame at `timeSec`. */

package/dist/composables/glass/webgl/shaders/procedural-color.glsl.d.ts

@@ -1,6 +1,10 @@
 export declare const OETF_GLSL = "\nfloat srgbToLinearCh(float c) {\n    return c <= 0.04045 ? c / 12.92 : pow((c + 0.055) / 1.055, 2.4);\n}\nvec3 srgbToLinear(vec3 c) {\n    return vec3(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\n\nfloat linearToSrgbCh(float c) {\n    return c <= 0.0031308 ? c * 12.92 : 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\nvec3 linearToSrgb(vec3 c) {\n    return vec3(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}";
 export declare const FBM_ROT_GLSL = "const mat2 FBM_ROT = mat2(0.8, 0.6, -0.6, 0.8);";
 export declare const OKLCH_MATRICES_GLSL = "\n// value.js LINEAR_SRGB_TO_LMS (constants.ts), row-major; written here as GLSL\n// columns (= the transpose) so mat3 * vec3 evaluates the row-major M\u00B7v.\nconst mat3 LINEAR_SRGB_TO_LMS = mat3(\n    0.4122214708, 0.2119034982, 0.0883024619,\n    0.5363325363, 0.6806995451, 0.2817188376,\n    0.0514459929, 0.1073969566, 0.6299787005\n);\n\n// value.js srgbToOKLab's INLINE LMS\u2192OKLab coefficients (gamut.ts lines 295-297 \u2014\n// these differ at the ~1e-9 digit from LMS_TO_OKLAB_MATRIX; use the inline ones to\n// mirror the exact value.js path), row-major \u2192 GLSL columns.\nconst mat3 LMS_TO_OKLAB = mat3(\n    0.2104542553, 1.9779984951, 0.0259040371,\n    0.7936177850, -2.4285922050, 0.7827717662,\n    -0.0040720468, 0.4505937099, -0.8086757660\n);\n\n// value.js OKLAB_TO_LMS_COEFF (constants.ts), row-major \u2192 GLSL columns. Rows:\n// l = [1, 0.3963377774, 0.2158037573], m = [1, -0.1055613458, -0.0638541728],\n// s = [1, -0.0894841775, -1.2914855480].\nconst mat3 OKLAB_TO_LMS = mat3(\n    1.0, 1.0, 1.0,\n    0.3963377774, -0.1055613458, -0.0894841775,\n    0.2158037573, -0.0638541728, -1.2914855480\n);\n\n// value.js LMS_TO_LINEAR_SRGB (constants.ts), row-major \u2192 GLSL columns.\nconst mat3 LMS_TO_LINEAR_SRGB = mat3(\n    4.0767416621, -1.2684380046, -0.0041960863,\n    -3.3077115913, 2.6097574011, -0.7034186147,\n    0.2309699292, -0.3413193965, 1.7076147010\n);\n\n// Gamma sRGB \u2192 raw OKLab (L, a, b). Mirrors value.js srgbToOKLab.\nvec3 srgbToOklab(vec3 c) {\n    vec3 lin = srgbToLinear(c);\n    vec3 lms = LINEAR_SRGB_TO_LMS * lin;\n    vec3 lmsCbrt = sign(lms) * pow(abs(lms), vec3(1.0 / 3.0));\n    return LMS_TO_OKLAB * lmsCbrt;\n}\n\n// Raw OKLab (L, a, b) \u2192 linear sRGB. Mirrors value.js oklabToLinearSRGB.\nvec3 oklabToLinearSrgb(vec3 lab) {\n    vec3 lms_ = OKLAB_TO_LMS * lab;\n    vec3 lms = lms_ * lms_ * lms_;\n    return LMS_TO_LINEAR_SRGB * lms;\n}\n\n// OKLab \u2192 OKLCh: H in RADIANS. Mirrors value.js rawOklabToOklch (which returns\n// degrees; we stay in radians and only fold to [0, 2pi)).\nvec3 oklabToOklch(vec3 lab) {\n    float C = length(lab.yz);\n    float H = atan(lab.z, lab.y);\n    if (H < 0.0) H += 2.0 * PI;\n    return vec3(lab.x, C, H);\n}\n\n// OKLCh (H radians) \u2192 OKLab. Mirrors value.js rawOklchToOklab.\nvec3 oklchToOklab(vec3 lch) {\n    return vec3(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}";
+export declare const PALETTE_RAMP_GLSL = "\n// value.js interpolateHue in the NORMALIZED-TURNS domain (h_rad/TAU \u2192 turns, the\n// exact .5/+1.0 branch per method, fract() wrap, *TAU back). A radians-native port\n// (PI thresholds / +TAU wrap) diverges 180\u00B0 at the antipode. methods: 0 shorter,\n// 1 longer, 2 increasing, 3 decreasing.\nfloat interpolateHueTurns(float h0, float h1, float t, int method) {\n  float TAU = 2.0 * PI;\n  float a = h0 / TAU;\n  float b = h1 / TAU;\n  float i = b - a;\n  if (method == 0) {              // shorter\n    if (i > 0.5) a += 1.0; else if (i < -0.5) b += 1.0;\n  } else if (method == 1) {       // longer\n    if (i > 0.0 && i < 0.5) a += 1.0; else if (i > -0.5 && i <= 0.0) b += 1.0;\n  } else if (method == 2) {       // increasing\n    if (i < 0.0) b += 1.0;\n  } else {                        // decreasing\n    if (i > 0.0) a += 1.0;\n  }\n  float r = a + t * (b - a);\n  r = fract(r);                   // (r % 1 + 1) % 1 \u2014 fract is non-negative in GLSL\n  return r * TAU;                 // back to radians\n}\n\n// Linear-sRGB endpoint pair \u2192 OKLab-rectangular interpolation \u2192 linear sRGB. Holds\n// chroma across the ramp (no grey midpoint). The default/shorter ramp path.\nvec3 mixPaletteOklab(vec3 linA, vec3 linB, float t) {\n  vec3 labA = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linA) * pow(abs(LINEAR_SRGB_TO_LMS * linA), vec3(1.0 / 3.0)));\n  vec3 labB = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linB) * pow(abs(LINEAR_SRGB_TO_LMS * linB), vec3(1.0 / 3.0)));\n  vec3 lab = mix(labA, labB, t);\n  return oklabToLinearSrgb(lab);\n}\n\n// Linear-sRGB endpoint pair \u2192 OKLCh interpolation along the huePath arc \u2192 linear\n// sRGB. L and C lerp; H walks the chosen arc. The deliberate-rainbow path.\nvec3 mixPaletteOklchArc(vec3 linA, vec3 linB, float t, int method) {\n  vec3 labA = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linA) * pow(abs(LINEAR_SRGB_TO_LMS * linA), vec3(1.0 / 3.0)));\n  vec3 labB = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linB) * pow(abs(LINEAR_SRGB_TO_LMS * linB), vec3(1.0 / 3.0)));\n  vec3 lchA = oklabToOklch(labA);\n  vec3 lchB = oklabToOklch(labB);\n  float L = mix(lchA.x, lchB.x, t);\n  float C = mix(lchA.y, lchB.y, t);\n  float H = interpolateHueTurns(lchA.z, lchB.z, t, method);\n  return oklabToLinearSrgb(oklchToOklab(vec3(L, C, H)));\n}\n\n// The ramp dispatcher both samplePalette ports splice. tRaw is the raw inter-stop\n// parameter [0,1]; the smoothstep ease + the huePath branch live HERE so the GLSL\n// and WGSL ramps are character-for-character one source. increasing(2)/decreasing(3)\n// take the OKLCh hue-arc (rainbow sweep); every other method takes the OKLab-\n// rectangular straight line (no hue detour).\nvec3 samplePaletteRamp(vec3 a, vec3 b, float tRaw, int huePath) {\n  float t = smoothstep(0.0, 1.0, tRaw);\n  if (huePath == 2 || huePath == 3) {\n    return mixPaletteOklchArc(a, b, t, huePath);\n  }\n  return mixPaletteOklab(a, b, t);\n}";
+export declare const PCG_HASH_GLSL = "\n// Jarzynski PCG2D \u2014 uvec2 \u2192 uvec2 permuted-congruential hash (JCGT 2020).\nuvec2 pcg2d(uvec2 v) {\n  v = v * 1664525u + 1013904223u;\n  v.x += v.y * 1664525u;\n  v.y += v.x * 1664525u;\n  v = v ^ (v >> 16u);\n  v.x += v.y * 1664525u;\n  v.y += v.x * 1664525u;\n  v = v ^ (v >> 16u);\n  return v;\n}\n\n// Float\u2192[0,1) scalar hash: bit-reinterpret the lattice coordinate, pcg2d it, take the\n// high word back to [0,1). Integer-bit \u2014 no sin() periodicity, no float-fract lattice.\nfloat pcgHash2(vec2 p) {\n  uvec2 u = floatBitsToUint(p);\n  return float(pcg2d(u).x) * (1.0 / 4294967296.0);\n}\n\n// Integer-lattice gradient: pcg2d the integer cell, fold the hash to an angle, return\n// the unit gradient vector. The gradient basis (not a scalar value) is what makes the\n// noise zero at the nodes (no value-noise plateaus).\nvec2 pcgGrad2(ivec2 cell) {\n  uvec2 h = pcg2d(uvec2(cell));\n  float ang = float(h.x) * (1.0 / 4294967296.0) * 6.28318530717958647692;\n  return vec2(cos(ang), sin(ang));\n}\n\n// 2D SIMPLEX gradient noise (Gustavson skew). The skew transform F2/G2 maps the square\n// lattice onto a simplex (triangular) grid \u2014 no axis-aligned directional bias. Each of\n// the three simplex corners contributes grad\u00B7offset shaped by a radial (0.5 - r\u00B2)\u2074\n// falloff. Output is ~[-1, 1]; callers remap to [0,1] via 0.5 + 0.5*gnoise.\nfloat gnoise(vec2 p) {\n  const float F2 = 0.36602540378443864676; // (sqrt(3) - 1) / 2\n  const float G2 = 0.21132486540518711775; // (3 - sqrt(3)) / 6\n  float s = (p.x + p.y) * F2;\n  vec2 i = floor(p + s);\n  float tt = (i.x + i.y) * G2;\n  vec2 x0 = p - (i - tt);                    // offset from the simplex origin corner\n  ivec2 i1 = (x0.x > x0.y) ? ivec2(1, 0) : ivec2(0, 1);\n  vec2 x1 = x0 - vec2(i1) + G2;\n  vec2 x2 = x0 - 1.0 + 2.0 * G2;\n  ivec2 ii = ivec2(i);\n  float n = 0.0;\n  float t0 = 0.5 - dot(x0, x0);\n  if (t0 > 0.0) { t0 *= t0; n += t0 * t0 * dot(pcgGrad2(ii), x0); }\n  float t1 = 0.5 - dot(x1, x1);\n  if (t1 > 0.0) { t1 *= t1; n += t1 * t1 * dot(pcgGrad2(ii + i1), x1); }\n  float t2 = 0.5 - dot(x2, x2);\n  if (t2 > 0.0) { t2 *= t2; n += t2 * t2 * dot(pcgGrad2(ii + ivec2(1, 1)), x2); }\n  return 70.0 * n;                           // normalize to ~[-1, 1]\n}";
 export declare const OETF_WGSL = "\nfn srgbToLinearCh(c: f32) -> f32 {\n    return select(pow((c + 0.055) / 1.055, 2.4), c / 12.92, c <= 0.04045);\n}\nfn srgbToLinear(c: vec3f) -> vec3f {\n    return vec3f(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\nfn linearToSrgbCh(c: f32) -> f32 {\n    return select(1.055 * pow(c, 1.0 / 2.4) - 0.055, c * 12.92, c <= 0.0031308);\n}\nfn linearToSrgb(c: vec3f) -> vec3f {\n    return vec3f(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}";
 export declare const FBM_ROT_WGSL = "const FBM_ROT: mat2x2f = mat2x2f(0.8, 0.6, -0.6, 0.8);";
 export declare const OKLCH_MATRICES_WGSL = "\nconst LINEAR_SRGB_TO_LMS: mat3x3f = mat3x3f(\n    0.4122214708, 0.2119034982, 0.0883024619,\n    0.5363325363, 0.6806995451, 0.2817188376,\n    0.0514459929, 0.1073969566, 0.6299787005\n);\nconst LMS_TO_OKLAB: mat3x3f = mat3x3f(\n    0.2104542553, 1.9779984951, 0.0259040371,\n    0.7936177850, -2.4285922050, 0.7827717662,\n    -0.0040720468, 0.4505937099, -0.8086757660\n);\nconst OKLAB_TO_LMS: mat3x3f = mat3x3f(\n    1.0, 1.0, 1.0,\n    0.3963377774, -0.1055613458, -0.0894841775,\n    0.2158037573, -0.0638541728, -1.2914855480\n);\nconst LMS_TO_LINEAR_SRGB: mat3x3f = mat3x3f(\n    4.0767416621, -1.2684380046, -0.0041960863,\n    -3.3077115913, 2.6097574011, -0.7034186147,\n    0.2309699292, -0.3413193965, 1.7076147010\n);\n\nfn srgbToOklab(c: vec3f) -> vec3f {\n    let lin = srgbToLinear(c);\n    let lms = LINEAR_SRGB_TO_LMS * lin;\n    let lmsCbrt = sign(lms) * pow(abs(lms), vec3f(1.0 / 3.0));\n    return LMS_TO_OKLAB * lmsCbrt;\n}\nfn oklabToLinearSrgb(lab: vec3f) -> vec3f {\n    let lms_ = OKLAB_TO_LMS * lab;\n    let lms = lms_ * lms_ * lms_;\n    return LMS_TO_LINEAR_SRGB * lms;\n}\nfn oklabToOklch(lab: vec3f) -> vec3f {\n    let C = length(lab.yz);\n    var H = atan2(lab.z, lab.y);\n    if (H < 0.0) { H = H + 2.0 * PI; }\n    return vec3f(lab.x, C, H);\n}\nfn oklchToOklab(lch: vec3f) -> vec3f {\n    return vec3f(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}";
+export declare const PALETTE_RAMP_WGSL = "\nfn interpolateHueTurns(h0: f32, h1: f32, t: f32, method: i32) -> f32 {\n  let TAU = 2.0 * PI;\n  var a = h0 / TAU;\n  var b = h1 / TAU;\n  let i = b - a;\n  if (method == 0) {              // shorter\n    if (i > 0.5) { a = a + 1.0; } else if (i < -0.5) { b = b + 1.0; }\n  } else if (method == 1) {       // longer\n    if (i > 0.0 && i < 0.5) { a = a + 1.0; } else if (i > -0.5 && i <= 0.0) { b = b + 1.0; }\n  } else if (method == 2) {       // increasing\n    if (i < 0.0) { b = b + 1.0; }\n  } else {                        // decreasing\n    if (i > 0.0) { a = a + 1.0; }\n  }\n  let r = fract(a + t * (b - a));\n  return r * TAU;\n}\n\nfn mixPaletteOklab(linA: vec3f, linB: vec3f, t: f32) -> vec3f {\n  let labA = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linA) * pow(abs(LINEAR_SRGB_TO_LMS * linA), vec3f(1.0 / 3.0)));\n  let labB = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linB) * pow(abs(LINEAR_SRGB_TO_LMS * linB), vec3f(1.0 / 3.0)));\n  let lab = mix(labA, labB, vec3f(t));\n  return oklabToLinearSrgb(lab);\n}\n\nfn mixPaletteOklchArc(linA: vec3f, linB: vec3f, t: f32, method: i32) -> vec3f {\n  let labA = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linA) * pow(abs(LINEAR_SRGB_TO_LMS * linA), vec3f(1.0 / 3.0)));\n  let labB = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linB) * pow(abs(LINEAR_SRGB_TO_LMS * linB), vec3f(1.0 / 3.0)));\n  let lchA = oklabToOklch(labA);\n  let lchB = oklabToOklch(labB);\n  let L = mix(lchA.x, lchB.x, t);\n  let C = mix(lchA.y, lchB.y, t);\n  let H = interpolateHueTurns(lchA.z, lchB.z, t, method);\n  return oklabToLinearSrgb(oklchToOklab(vec3f(L, C, H)));\n}\n\nfn samplePaletteRamp(a: vec3f, b: vec3f, tRaw: f32, huePath: i32) -> vec3f {\n  let t = smoothstep(0.0, 1.0, tRaw);\n  if (huePath == 2 || huePath == 3) {\n    return mixPaletteOklchArc(a, b, t, huePath);\n  }\n  return mixPaletteOklab(a, b, t);\n}";
+export declare const PCG_HASH_WGSL = "\nfn pcg2d(v0: vec2u) -> vec2u {\n  var v = v0 * 1664525u + vec2u(1013904223u);\n  v.x = v.x + v.y * 1664525u;\n  v.y = v.y + v.x * 1664525u;\n  v = v ^ (v >> vec2u(16u));\n  v.x = v.x + v.y * 1664525u;\n  v.y = v.y + v.x * 1664525u;\n  v = v ^ (v >> vec2u(16u));\n  return v;\n}\n\nfn pcgHash2(p: vec2f) -> f32 {\n  let u = bitcast<vec2u>(p);\n  return f32(pcg2d(u).x) * (1.0 / 4294967296.0);\n}\n\nfn pcgGrad2(cell: vec2i) -> vec2f {\n  let h = pcg2d(bitcast<vec2u>(cell));\n  let ang = f32(h.x) * (1.0 / 4294967296.0) * 6.28318530717958647692;\n  return vec2f(cos(ang), sin(ang));\n}\n\nfn gnoise(p: vec2f) -> f32 {\n  let F2 = 0.36602540378443864676;\n  let G2 = 0.21132486540518711775;\n  let s = (p.x + p.y) * F2;\n  let i = floor(p + vec2f(s));\n  let tt = (i.x + i.y) * G2;\n  let x0 = p - (i - vec2f(tt));\n  var i1 = vec2i(0, 1);\n  if (x0.x > x0.y) { i1 = vec2i(1, 0); }\n  let x1 = x0 - vec2f(i1) + vec2f(G2);\n  let x2 = x0 - vec2f(1.0) + vec2f(2.0 * G2);\n  let ii = vec2i(i);\n  var n = 0.0;\n  var t0 = 0.5 - dot(x0, x0);\n  if (t0 > 0.0) { t0 = t0 * t0; n = n + t0 * t0 * dot(pcgGrad2(ii), x0); }\n  var t1 = 0.5 - dot(x1, x1);\n  if (t1 > 0.0) { t1 = t1 * t1; n = n + t1 * t1 * dot(pcgGrad2(ii + i1), x1); }\n  var t2 = 0.5 - dot(x2, x2);\n  if (t2 > 0.0) { t2 = t2 * t2; n = n + t2 * t2 * dot(pcgGrad2(ii + vec2i(1, 1)), x2); }\n  return 70.0 * n;\n}";

package/dist/composables/glass/webgl/useWebGLCanvas.d.ts

@@ -1,4 +1,4 @@
-export type WebGLSuspendReason = "tab-hidden" | "off-screen" | "manual";
+export type WebGLSuspendReason = "tab-hidden" | "off-screen" | "off-screen-io" | "manual";
 /** The per-frame hooks a consumer's `setup(gl)` returns. */
 export interface WebGLCanvasFrame {
     /** Draw one frame at `timeSec`. The consumer uploads its uniforms + draws. */

package/dist/composables/motion/core/index.d.ts

@@ -8,3 +8,4 @@ export * from "../useYieldToMain";
 export * from "../usePrioritizedTask";
 export * from "../useViewTransition";
 export * from "../vReveal";
+export * from "../useTextHighlight";

package/dist/configurator.js

@@ -1,2 +1,2 @@
-import { a as e, i as t, n, o as r, r as i, s as a, t as o } from "./useConfiguratorState-B24TcgIn.js";
+import { a as e, i as t, n, o as r, r as i, s as a, t as o } from "./useConfiguratorState-CMff4GzH.js";
 export { e as CONFIGURATOR_DENSITY_KEY, t as Configurator, i as ConfiguratorLayer, n as ConfiguratorRow, r as provideConfiguratorDensity, o as useConfiguratorState, a as useOptionalConfiguratorDensity };

package/dist/confirm-dialog.js

@@ -1,6 +1,6 @@
 import { t as e } from "./createLucideIcon-B6uNAU9G.js";
 import { n as t } from "./button-CAywcrhO.js";
-import { t as n } from "./_plugin-vue_export-helper-gLzyemvl.js";
+import { t as n } from "./_plugin-vue_export-helper-ok8pgSl5.js";
 import { Transition as r, createBlock as i, createCommentVNode as a, createElementBlock as o, createElementVNode as s, createTextVNode as c, createVNode as l, defineComponent as u, mergeModels as d, openBlock as f, renderSlot as p, toDisplayString as m, unref as h, useModel as g, withCtx as _, withKeys as v, withModifiers as y } from "vue";
 var b = e("loader-circle", [["path", {
 	d: "M21 12a9 9 0 1 1-6.219-8.56",