@mkbabb/glass-ui 3.5.0 → 3.6.0

package/dist/{button-i8Ek5vvg.js → button-BcMzVrqs.js}

@@ -54,8 +54,8 @@ var d = /* @__PURE__ */ r({
 			secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80 active:bg-secondary/70 aria-pressed:bg-secondary/60",
 			accent: "bg-accent text-accent-foreground border border-border/40 hover:bg-accent/80 active:bg-accent/70 aria-pressed:bg-accent/60",
 			ghost: "bg-transparent text-foreground/70 hover:bg-foreground/8 hover:text-foreground active:bg-foreground/12 aria-pressed:bg-foreground/10 aria-pressed:text-foreground",
-			glass: "glass-wash glass-specular-track text-foreground hover:bg-[var(--glass-bg-resting)] hover:border-[var(--glass-border-resting)] active:bg-[var(--glass-bg-floating)] active:border-[var(--glass-border-floating)] aria-pressed:bg-[color-mix(in_srgb,var(--foreground)_10%,var(--glass-bg-resting))]",
-			"glass-wash": "glass-wash glass-specular-track text-foreground/70 hover:bg-foreground/[0.04] hover:border-[var(--surface-tint-22)] hover:text-foreground active:bg-foreground/[0.08] aria-pressed:bg-foreground/[0.1] aria-pressed:text-foreground",
+			glass: "glass-wash text-foreground hover:bg-[var(--glass-bg-resting)] hover:border-[var(--glass-border-resting)] active:bg-[var(--glass-bg-floating)] active:border-[var(--glass-border-floating)] aria-pressed:bg-[color-mix(in_srgb,var(--foreground)_10%,var(--glass-bg-resting))]",
+			"glass-wash": "glass-wash text-foreground/70 hover:bg-foreground/[0.04] hover:border-[var(--surface-tint-22)] hover:text-foreground active:bg-foreground/[0.08] aria-pressed:bg-foreground/[0.1] aria-pressed:text-foreground",
 			ai: "bg-amber-500/15 text-amber-700 hover:bg-amber-500/25 active:bg-amber-500/35 dark:text-amber-400 aria-pressed:bg-amber-500/30",
 			link: "text-primary underline-offset-4 hover:underline active:opacity-80 active:scale-100"
 		},

package/dist/button.js

@@ -1,2 +1,2 @@
-import { n as e, t } from "./button-i8Ek5vvg.js";
+import { n as e, t } from "./button-BcMzVrqs.js";
 export { e as Button, t as buttonVariants };

package/dist/carousel.js

@@ -3,7 +3,7 @@ import { t } from "./createLucideIcon-DuDoe_ra.js";
 import { t as n } from "./chevron-down-pBY8sYfV.js";
 import { t as r } from "./chevron-right-BjeKC22V.js";
 import { t as i } from "./chevron-up-DBeNHUm1.js";
-import { n as a } from "./button-i8Ek5vvg.js";
+import { n as a } from "./button-BcMzVrqs.js";
 import { Fragment as o, computed as s, createBlock as c, createCommentVNode as l, createElementBlock as u, createElementVNode as d, createVNode as f, defineComponent as p, mergeProps as m, normalizeClass as h, onMounted as g, openBlock as _, ref as v, renderList as y, renderSlot as b, resolveDynamicComponent as x, toDisplayString as S, unref as C, watch as w, withCtx as T } from "vue";
 import { createInjectionState as E } from "@vueuse/core";
 import D from "embla-carousel-vue";

package/dist/color.js

@@ -1,2 +1,2 @@
-import { a as e, i as t, n, r, t as i } from "./color-rkK4RMx2.js";
+import { a as e, i as t, n, r, t as i } from "./color-DS-iLRVM.js";
 export { i as cssToOklch, n as defaultBlobColorResolver, r as oklchStopToHex, t as oklchToGammaRgb, e as oklchToLinear };

package/dist/components/custom/aurora/composables/color.d.ts

@@ -1,3 +1,4 @@
+import { type AuroraConfig } from "../constants/presets";
 import { type OklchStop } from "../../../../composables/color";
 export { cssToOklch, oklchStopToHex, oklchToLinear, } from "../../../../composables/color";
 export type { OklchStop } from "../../../../composables/color";
@@ -29,11 +30,22 @@ export declare function hexToOklchStop(hex: string): OklchStop;
  * derived stops differently:
  * - `analogous` — the ramp walks the seed hue ± a small spread (neighbouring
  *   hues; the painterly default).
- * - `complementary` — stops split between the seed hue and its opposite (+180°).
+ * - `complementary` — stops travel from the seed hue toward its opposite (+180°)
+ *   along the LONG arc (keeps the ramp saturated; the short arc cuts through grey
+ *   on a warm→cool pair — the muddy-midtone defect).
+ * - `split-complementary` — anchor + the two hues flanking the complement (±150/210).
  * - `triad` — stops distributed across the seed hue and its two 120° partners.
+ * - `tetradic` — anchor + the three 90° partners (90/180/270).
  * - `monochrome` — every stop holds the seed hue; only L and C travel.
  */
-export type AuroraHarmony = "analogous" | "complementary" | "triad" | "monochrome";
+export type AuroraHarmony = "analogous" | "complementary" | "split-complementary" | "triad" | "tetradic" | "monochrome";
+/**
+ * Eased L/C journey shapes for the derived ramp. `bell` (the W5 default for chroma)
+ * peaks the chroma in the mids and desaturates the extremes — the painterly
+ * "saturated body, calm edges" curve. `linear` is the prior monotone falloff
+ * (the named pre-W5 branch — NOT a back-compat alias, a first-class choice).
+ */
+export type DeriveEasing = "linear" | "sine" | "bell";
 export interface DeriveAuroraOptions {
     /** Number of stops to produce. Default 4; clamped to [2, MAX_STOPS]. */
     stopCount?: number;
@@ -45,6 +57,16 @@ export interface DeriveAuroraOptions {
     chromaFalloff?: number;
     /** Hue walk in degrees for analogous; ignored by monochrome. Default ~28. */
     hueSpread?: number;
+    /** L-ramp easing across the band. Default `linear` (monotone ascent). */
+    lightnessEasing?: DeriveEasing;
+    /** C-ramp easing. Default `bell` (peak in the mids — the W5 painterly default). */
+    chromaEasing?: DeriveEasing;
+    /**
+     * Warm-light / cool-shadow temperature coupling (0..1). A hue delta that warms
+     * the lights and cools the shadows — the single most-cited painting rule, the
+     * fold that makes the oil/oil-pastel mediums read as mixed paint. Default 0.
+     */
+    temperatureShift?: number;
 }
 /**
  * Seed ONE color into a harmonious, gamut-safe N-stop aurora palette.
@@ -63,3 +85,14 @@ export interface DeriveAuroraOptions {
  * @param options ramp shape — stop count, harmony, L/C/h spreads.
  */
 export declare function deriveAurora(seed: string | OklchStop, options?: DeriveAuroraOptions): OklchStop[];
+/** Atmospheric mood words for {@link deriveScene}. */
+export type AuroraMood = "atmospheric" | "painterly" | "vivid" | "muted";
+/**
+ * Seed ONE color + a mood word into a WHOLE `AuroraConfig` — palette (via
+ * `deriveAurora`), nuclei layout (a rule-of-thirds/golden prior), medium, and the
+ * motion/output knobs the mood implies. A SUPERSET front door over `deriveAurora`:
+ * a consumer hands a seed + `"painterly"` and gets a coherent backdrop, not just a
+ * palette. The base is the wispy-sky `DEFAULT_AURORA_CONFIG` (every field the mood
+ * does not touch stays the library default).
+ */
+export declare function deriveScene(seed: string | OklchStop, mood?: AuroraMood): AuroraConfig;

package/dist/components/custom/aurora/composables/glSetup.d.ts

@@ -9,7 +9,7 @@
  * shader-uniform boundary: a NEW uniform name must be added here, and the cache is
  * keyed off it, so a fresh uniform always gets a location slot.
  */
-export declare const UNIFORM_NAMES: readonly ["uTime", "uPalette", "uStopCount", "uNucleiCount", "uNucleiPos", "uNucleiRadius", "uNucleiPaletteBias", "uNucleiValueBias", "uNucleiDriftRadius", "uNucleiDriftPhase", "uNucleiElong", "uNucleiAngle", "uSoftmaxBeta", "uValueVariance", "uWarpAmount", "uWarpScale", "uWarpDrift", "uWarpMode", "uNoiseOctaves", "uMedium", "uFlowPattern", "uFlowFocal", "uFlowAngle", "uFlowCurl", "uCursor", "uCursorStrength", "uCursorRadius", "uStrokeAmount", "uStrokeScale", "uStrokeAnisotropy", "uStrokeLayers", "uStrokeMode", "uWetEdge", "uGranulation", "uImpasto", "uBrokenColor", "uCanvasGrain", "uNucleiDrift", "uPaletteDrift", "uBreathDepth", "uBreathPeriod", "uSaturation", "uPaperGrain", "uAlpha"];
+export declare const UNIFORM_NAMES: readonly ["uTime", "uPalette", "uStopCount", "uNucleiCount", "uNucleiPos", "uNucleiRadius", "uNucleiPaletteBias", "uNucleiValueBias", "uNucleiDriftRadius", "uNucleiDriftPhase", "uNucleiElong", "uNucleiAngle", "uSoftmaxBeta", "uValueVariance", "uWarpAmount", "uWarpScale", "uWarpDrift", "uWarpMode", "uNoiseOctaves", "uMedium", "uHuePath", "uFlowPattern", "uFlowFocal", "uFlowAngle", "uFlowCurl", "uCursor", "uCursorStrength", "uCursorRadius", "uStrokeAmount", "uStrokeScale", "uStrokeAnisotropy", "uStrokeLayers", "uStrokeMode", "uWetEdge", "uGranulation", "uImpasto", "uBrokenColor", "uCanvasGrain", "uNucleiDrift", "uPaletteDrift", "uBreathDepth", "uBreathPeriod", "uSaturation", "uPaperGrain", "uAlpha"];
 export type UniformName = (typeof UNIFORM_NAMES)[number];
 export type UniformLocations = Record<UniformName, WebGLUniformLocation | null>;
 export interface GlProgram {

package/dist/components/custom/aurora/composables/uniformBridge.d.ts

@@ -25,6 +25,12 @@ export declare const MEDIUM_ID: {
     readonly oil: 3;
     readonly crayon: 4;
 };
+export declare const HUE_PATH_ID: {
+    readonly shorter: 0;
+    readonly longer: 1;
+    readonly increasing: 2;
+    readonly decreasing: 3;
+};
 export declare const FLOW_ID: {
     readonly none: 0;
     readonly radial: 1;

package/dist/components/custom/aurora/constants/presets.d.ts

@@ -12,6 +12,8 @@
  */
 import type { OklchStop } from "../../../../composables/color";
 export type { OklchStop };
+import type { HueInterpolationMethod } from "@mkbabb/value.js";
+export type AuroraHuePath = HueInterpolationMethod;
 export interface AuroraNucleus {
     /** 0..1 in CSS-top-origin space (0 = top, 1 = bottom). Runtime flips Y. */
     x: number;
@@ -63,6 +65,13 @@ export interface AuroraConfig {
     warpMode: WarpMode;
     noiseOctaves: 3 | 4 | 5;
     medium: AuroraMedium;
+    /**
+     * W5 — the hue-arc method for the OKLCh palette interpolation. Optional;
+     * omitted = `"shorter"` (the OKLab-rectangular ramp — the muddy-midtone-free
+     * default). `"increasing"`/`"decreasing"` request the OKLCh hue-arc for a
+     * deliberate rainbow sweep across the stops. Aliased on `/api` as `AuroraHuePath`.
+     */
+    huePath?: AuroraHuePath;
     flow: AuroraFlow;
     strokeAmount: number;
     strokeScale: number;

package/dist/components/custom/aurora/constants/shaders/composition.glsl.d.ts

@@ -1 +1 @@
-export declare const AURORA_COMPOSITION_GLSL = "// \u2500\u2500 Palette LUT \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nvec3 samplePalette(float id) {\n  id = clamp(id, 0.0, 1.0);\n  float scaled = id * float(uStopCount - 1);\n  int i0 = int(floor(scaled));\n  int i1 = min(i0 + 1, uStopCount - 1);\n  float t = fract(scaled);\n  t = smoothstep(0.0, 1.0, t);\n  return mix(uPalette[i0], uPalette[i1], t);\n}\n\n// \u2500\u2500 Nuclei field \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nvoid nucleiField(vec2 p, float t, out float paletteId, out float valueMod) {\n  float accumBias  = 0.0;\n  float accumValue = 0.0;\n  float accumW     = 0.0;\n  for (int i = 0; i < MAX_NUCLEI; i++) {\n    if (i >= uNucleiCount) break;\n    vec2 posI = uNucleiPos[i]\n              + uNucleiDriftRadius[i] * vec2(\n                  cos(t * uNucleiDrift * K_NUCLEI + uNucleiDriftPhase[i]),\n                  sin(t * uNucleiDrift * K_NUCLEI + uNucleiDriftPhase[i] * 1.13)\n                );\n    vec2 diff = p - posI;\n    // Anisotropic Gaussian: rotate diff into the nucleus's local frame\n    // (major axis along uNucleiAngle), then scale the major-axis component by\n    // 1/elongation so the squared distance describes an ellipse. Defaults\n    // 1.0/0.0 reduce to the isotropic dot(diff, diff).\n    float ca = cos(uNucleiAngle[i]);\n    float sa = sin(uNucleiAngle[i]);\n    vec2  local = vec2( ca * diff.x + sa * diff.y,\n                       -sa * diff.x + ca * diff.y);\n    float along  = local.x / max(uNucleiElong[i], 0.01);\n    float across = local.y;\n    float d2 = along * along + across * across;\n    float r = max(uNucleiRadius[i], 0.01);\n    float w = exp(-uSoftmaxBeta * d2 / (r * r));\n    accumBias  += w * uNucleiPaletteBias[i];\n    accumValue += w * uNucleiValueBias[i];\n    accumW     += w;\n  }\n  paletteId = accumBias  / max(accumW, 1e-4);\n  valueMod  = accumValue / max(accumW, 1e-4);\n\n  // Palette drift \u2014 slow global paletteId breathe between adjacent stops. The\n  // rate rides K_PAL (perceptible ~30\u201360s hue cycle at the default coefficient);\n  // the amplitude lifts the authored coefficient into a 0.03..0.06 paletteId band\n  // so the palette visibly travels rather than dithering within one stop.\n  float palAmp = clamp(uPaletteDrift * 6.0, 0.0, 0.06);\n  paletteId += palAmp * sin(t * uPaletteDrift * K_PAL);\n  paletteId = clamp(paletteId, 0.0, 1.0);\n}\n";
+export declare const AURORA_COMPOSITION_GLSL = "// \u2500\u2500 Palette LUT (W5 \u2014 OKLCh/OKLab interpolation) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// The endpoints stay CPU-baked to LINEAR sRGB (the Aras precompute pattern); only\n// the BETWEEN-endpoint interpolation moves to perceptual space. OKLab-rectangular\n// for the default ramp (holds chroma, no grey midpoint); the OKLCh hue-arc only on\n// uHuePath increasing/decreasing (deliberate rainbow travel). The prior linear\n// mix() (the muddy-midtone source) is GONE.\nvec3 samplePalette(float id) {\n  id = clamp(id, 0.0, 1.0);\n  float scaled = id * float(uStopCount - 1);\n  int i0 = int(floor(scaled));\n  int i1 = min(i0 + 1, uStopCount - 1);\n  float t = fract(scaled);\n  t = smoothstep(0.0, 1.0, t);\n  vec3 a = uPalette[i0];\n  vec3 b = uPalette[i1];\n  // increasing(2)/decreasing(3) request the OKLCh hue-arc (rainbow sweep); every\n  // other method takes the OKLab-rectangular straight line (no hue detour).\n  if (uHuePath == 2 || uHuePath == 3) {\n    return mixPaletteOklchArc(a, b, t, uHuePath);\n  }\n  return mixPaletteOklab(a, b, t);\n}\n\n// \u2500\u2500 Nuclei field \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nvoid nucleiField(vec2 p, float t, out float paletteId, out float valueMod) {\n  float accumBias  = 0.0;\n  float accumValue = 0.0;\n  float accumW     = 0.0;\n  for (int i = 0; i < MAX_NUCLEI; i++) {\n    if (i >= uNucleiCount) break;\n    vec2 posI = uNucleiPos[i]\n              + uNucleiDriftRadius[i] * vec2(\n                  cos(t * uNucleiDrift * K_NUCLEI + uNucleiDriftPhase[i]),\n                  sin(t * uNucleiDrift * K_NUCLEI + uNucleiDriftPhase[i] * 1.13)\n                );\n    vec2 diff = p - posI;\n    // Anisotropic Gaussian: rotate diff into the nucleus's local frame\n    // (major axis along uNucleiAngle), then scale the major-axis component by\n    // 1/elongation so the squared distance describes an ellipse. Defaults\n    // 1.0/0.0 reduce to the isotropic dot(diff, diff).\n    float ca = cos(uNucleiAngle[i]);\n    float sa = sin(uNucleiAngle[i]);\n    vec2  local = vec2( ca * diff.x + sa * diff.y,\n                       -sa * diff.x + ca * diff.y);\n    float along  = local.x / max(uNucleiElong[i], 0.01);\n    float across = local.y;\n    float d2 = along * along + across * across;\n    float r = max(uNucleiRadius[i], 0.01);\n    float w = exp(-uSoftmaxBeta * d2 / (r * r));\n    accumBias  += w * uNucleiPaletteBias[i];\n    accumValue += w * uNucleiValueBias[i];\n    accumW     += w;\n  }\n  paletteId = accumBias  / max(accumW, 1e-4);\n  valueMod  = accumValue / max(accumW, 1e-4);\n\n  // Palette drift \u2014 slow global paletteId breathe between adjacent stops. The\n  // rate rides K_PAL (perceptible ~30\u201360s hue cycle at the default coefficient);\n  // the amplitude lifts the authored coefficient into a 0.03..0.06 paletteId band\n  // so the palette visibly travels rather than dithering within one stop.\n  float palAmp = clamp(uPaletteDrift * 6.0, 0.0, 0.06);\n  paletteId += palAmp * sin(t * uPaletteDrift * K_PAL);\n  paletteId = clamp(paletteId, 0.0, 1.0);\n}\n";

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

@@ -6,5 +6,6 @@ export { useCursorInteraction } from "./composables/useCursorInteraction";
 export { createAurora } from "./composables/runtime";
 export type { AuroraRuntimeMode, AuroraRuntimeOptions } from "./composables/runtime";
 export { DEFAULT_AURORA_CONFIG, MAX_NUCLEI, MAX_STOPS, type AuroraConfig, type AuroraCursorApi, type AuroraFlow, type AuroraInstance, type AuroraMedium, type AuroraNucleus, type FlowPattern, type OklchStop, type StrokeMode, type WarpMode, } from "./constants/presets";
-export { cssToOklch, deriveAurora, flattenPalette, hexToOklchStop, oklchStopToHex, oklchToLinear, paletteToCssGradient, } from "./composables/color";
-export type { AuroraHarmony, DeriveAuroraOptions } from "./composables/color";
+export { cssToOklch, deriveAurora, deriveScene, flattenPalette, hexToOklchStop, oklchStopToHex, oklchToLinear, paletteToCssGradient, } from "./composables/color";
+export type { AuroraHarmony, AuroraMood, DeriveAuroraOptions, DeriveEasing, } from "./composables/color";
+export type { AuroraHuePath } from "./constants/presets";

package/dist/components/custom/constellation/Constellation.vue.d.ts

@@ -0,0 +1,45 @@
+import { type HTMLAttributes } from "vue";
+import { type ConstellationField } from "./constellationField";
+/**
+ * Constellation — a slow, geometric proximity-graph lattice on a Canvas2D
+ * surface. Nodes drift + bounce; near nodes link with distance-falloff
+ * hairlines; the web leans toward the cursor and taps ripple. It composes the
+ * `useCanvas2D` substrate, so it inherits the offscreen / tab-hidden /
+ * reduced-motion freeze for free (no hand-rolled RAF-park).
+ *
+ * The lattice ships NEUTRAL. A branded skin (a focal ring, a callout label) is
+ * the consumer's `drawOverlay(ctx, field, now)` pass — it runs AFTER the four
+ * neutral passes and receives the live field so it can pin itself to a real
+ * node. Zero deck-domain content lives in the component.
+ *
+ * Palette reads `--constellation-node` / `--constellation-node-dim` /
+ * `--constellation-line` off the canvas (neutral fallbacks), so a consumer
+ * override or a dark-mode flip re-tints the lattice.
+ */
+type __VLS_Props = {
+    /** Node count. Default 64. */
+    count?: number;
+    /** Link distance in px (the falloff reach). Default 132. */
+    link?: number;
+    /** Drift speed. Default 0.16. */
+    speed?: number;
+    /**
+     * Seed for a REPRODUCIBLE field. A `number` or `string` (hashed) seeds the
+     * shared `mulberry32`; omit for a fresh `Math.random` field each mount.
+     */
+    seed?: number | string;
+    /** Steer-toward-cursor + tap ripples. Default true; auto-off under reduced-motion. */
+    pointerReactive?: boolean;
+    class?: HTMLAttributes["class"];
+    /**
+     * The skin seam. Runs after the neutral passes with the live field, so a
+     * consumer paints its own focal mark pinned to a real node. The branded
+     * content (a domain accent, a callout label) lives HERE, in the consumer.
+     */
+    drawOverlay?: (ctx: CanvasRenderingContext2D, field: ConstellationField, now: number) => void;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
+    field: ConstellationField;
+}, {}, {}, {}, 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/constellation/constellationField.d.ts

@@ -0,0 +1,85 @@
+/** Reference width the `k` scale factor is keyed to (CSS px). */
+export declare const BASE_WIDTH = 1280;
+export interface ConstellationNode {
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    r: number;
+    dim: boolean;
+}
+export interface ConstellationRipple {
+    x: number;
+    y: number;
+    /** `performance.now()` at first draw; -1 until stamped. */
+    start: number;
+}
+/** The pointer position in canvas-local CSS px (`-1` = inactive). */
+export interface ConstellationPointer {
+    x: number;
+    y: number;
+}
+/** The neutral palette resolved off the canvas custom properties. */
+export interface ConstellationPalette {
+    node: string;
+    nodeDim: string;
+    line: string;
+}
+/**
+ * The field state the component exposes to its `drawOverlay` consumer so a
+ * skin can pin itself to a real field node. `k` is the `width / BASE_WIDTH`
+ * scale, `dpr` the device-pixel ratio applied by the substrate.
+ */
+export interface ConstellationField {
+    nodes: ConstellationNode[];
+    /** The host canvas — for `getComputedStyle` token reads in an overlay. */
+    canvas: HTMLCanvasElement | null;
+    w: number;
+    h: number;
+    k: number;
+    dpr: number;
+}
+/**
+ * The `<Constellation>` consumer prop surface (the public type a consumer types
+ * a wrapper against). The `drawOverlay` seam is the branded-skin injection — it
+ * runs AFTER the neutral passes with the live field.
+ */
+export interface ConstellationProps {
+    /** Node count. Default 64. */
+    count?: number;
+    /** Link distance in px (the falloff reach). Default 132. */
+    link?: number;
+    /** Drift speed. Default 0.16. */
+    speed?: number;
+    /** Seed for a reproducible field (number or hashed string); omit for `Math.random`. */
+    seed?: number | string;
+    /** Steer-toward-cursor + tap ripples. Default true; auto-off under reduced-motion. */
+    pointerReactive?: boolean;
+    class?: string;
+    /** The skin seam — paints the consumer's focal mark on the live field. */
+    drawOverlay?: (ctx: CanvasRenderingContext2D, field: ConstellationField, now: number) => void;
+}
+export declare const DEFAULT_PALETTE: ConstellationPalette;
+/** Resolve the neutral palette off a canvas's resolved custom properties. */
+export declare function readPalette(canvas: HTMLCanvasElement): ConstellationPalette;
+/**
+ * Seed `count` drifting nodes inside `w × h`. `rng` is a `() => number` in
+ * `[0, 1)` (the glass-ui `mulberry32`/`Math.random`); a seeded `rng` lays out a
+ * reproducible field. No node is pinned — every node drifts (pinning a focal
+ * node is consumer skin, not field mechanics).
+ */
+export declare function seedField(rng: () => number, count: number, w: number, h: number, speed: number): ConstellationNode[];
+/**
+ * Advance the field one step: drift + wall-bounce every node, then (if the
+ * pointer is live) lean nodes within reach toward the cursor WITHOUT changing
+ * their speed (the slow geometric drift is preserved). `k` is the scale factor.
+ */
+export declare function stepField(field: ConstellationField, k: number, speed: number, pointer: ConstellationPointer | null): void;
+/** Pass 1 — hairline edges between any two nodes within `link` px (alpha falls off with distance). */
+export declare function drawEdges(ctx: CanvasRenderingContext2D, field: ConstellationField, link: number, palette: ConstellationPalette): void;
+/** Pass 2 — ambient node dots. */
+export declare function drawNodes(ctx: CanvasRenderingContext2D, field: ConstellationField, palette: ConstellationPalette): void;
+/** Pass 3 — the cursor joins the web: faint links to nodes within reach + a soft cursor node. */
+export declare function drawPointerWeb(ctx: CanvasRenderingContext2D, field: ConstellationField, link: number, palette: ConstellationPalette, pointer: ConstellationPointer | null): void;
+/** Pass 4 — tap ripples: expanding rings that fade over ~0.9s; consumed entries are spliced. */
+export declare function drawRipples(ctx: CanvasRenderingContext2D, field: ConstellationField, now: number, ripples: ConstellationRipple[], palette: ConstellationPalette): void;

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

@@ -0,0 +1,3 @@
+export { default as Constellation } from "./Constellation.vue";
+export { seedField, stepField, readPalette, drawEdges, drawNodes, drawPointerWeb, drawRipples, BASE_WIDTH, DEFAULT_PALETTE, } from "./constellationField";
+export type { ConstellationNode, ConstellationRipple, ConstellationPointer, ConstellationPalette, ConstellationField, ConstellationProps, } from "./constellationField";

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/composables/glass/canvas2d/index.d.ts

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

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

@@ -0,0 +1,48 @@
+import { type MaybeRefOrGetter } from "vue";
+/** The suspend reasons that gate the loop. Twins the WebGL substrate's union. */
+export type Canvas2DSuspendReason = "tab-hidden" | "off-screen" | "manual";
+/** The per-frame hooks a consumer's `setup(ctx)` returns. */
+export interface Canvas2DFrame {
+    /**
+     * Draw one frame. `ctx` is pre-transformed for CSS px (the dpr scale is
+     * applied by the substrate's resize), `now` is `performance.now()` ms. The
+     * consumer steps + clears + paints — the substrate clears nothing.
+     */
+    render: (ctx: CanvasRenderingContext2D, now: number) => void;
+    /** Release per-instance resources. Runs on dispose. */
+    teardown?: () => void;
+}
+export interface Canvas2DOptions {
+    /** The canvas element ref (or getter). The substrate observes + sizes it. */
+    canvas: MaybeRefOrGetter<HTMLCanvasElement | null>;
+    /** Build per-instance state on a fresh 2D context; returns the frame hooks. */
+    setup: (ctx: CanvasRenderingContext2D) => Canvas2DFrame;
+    /** Auto-`arm()` once the canvas resolves (default `true`). */
+    autoStart?: boolean;
+    /**
+     * Honor `prefers-reduced-motion: reduce` by painting ONE static frame then
+     * parking the loop. Live-monitored via a `matchMedia` `change` listener;
+     * re-arms (one static frame) on un-reduce. Default `true`.
+     */
+    respectReducedMotion?: boolean;
+    /** `getContext("2d", …)` attributes. */
+    contextAttrs?: CanvasRenderingContext2DSettings;
+    /** IntersectionObserver `rootMargin` for the offscreen seam. Default `200px`. */
+    rootMargin?: string;
+}
+export interface Canvas2DHandle {
+    /** Run the cheap init (2D context + `setup` + arm the loop). Idempotent; no-op post-dispose. */
+    arm: () => void;
+    suspend: (reason?: Canvas2DSuspendReason) => void;
+    resume: (reason?: Canvas2DSuspendReason) => void;
+    /** Re-arm a parked loop on demand (a setter that re-introduced motion calls this). */
+    wake: () => void;
+    dispose: () => void;
+    /** `true` while the suspend set is empty (the loop is live). */
+    isRunning: () => boolean;
+    /** The live 2D context (null before arm / after dispose). */
+    readonly ctx: CanvasRenderingContext2D | null;
+    /** The live `prefers-reduced-motion: reduce` state (consumers read it to skip stepping). */
+    readonly reducedMotion: boolean;
+}
+export declare function createCanvas2D(options: Canvas2DOptions): Canvas2DHandle;

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

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

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

@@ -1,5 +1,6 @@
 export * from "../constants";
 export * from "../useStaggerReveal";
+export * from "../useStagger";
 export * from "../useScrollProgress";
 export * from "../useRAFLoop";
 export * from "../useIntersectionPause";

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

@@ -4,4 +4,5 @@ export * from "./useSpringMount";
 export * from "./useSpringPress";
 export * from "./useNumericTransition";
 export * from "./useAnimatedNumber";
+export * from "./useAnimatedNumberMap";
 export * from "./useCountup";

package/dist/composables/motion/useAnimatedNumberMap.d.ts

@@ -0,0 +1,29 @@
+import { type ComputedRef } from "vue";
+import { type UseAnimatedNumberOptions } from "./useAnimatedNumber";
+export interface UseAnimatedNumberMapOptions extends UseAnimatedNumberOptions {
+}
+/**
+ * Fan out N independent `useAnimatedNumber` instances into a `Record<K, ...>`.
+ *
+ * Each key gets one rAF-smoothed `ComputedRef<number | null>`. The smoothing
+ * options apply identically across the set; consumers that need per-key
+ * options should call `useAnimatedNumber` per key directly.
+ *
+ * The `null` propagation is preserved: when `source(key)` resolves to `null`,
+ * the corresponding ref returns `null` rather than freezing on the last
+ * smoothed sample. This matches the per-metric `raw → smoothed` contract.
+ *
+ * @example
+ * const keys = ["ping", "jitter", "download", "upload"] as const;
+ * const smoothed = useAnimatedNumberMap({
+ *     keys,
+ *     source: (k) => computed(() => store.resultFor(k).value ?? null),
+ *     damping: DAMPING.domPill,
+ *     snapThreshold: SNAP_THRESHOLD.dom,
+ * });
+ * // smoothed.ping.value, smoothed.jitter.value, ...
+ */
+export declare function useAnimatedNumberMap<K extends string>(options: {
+    keys: readonly K[];
+    source: (key: K) => ComputedRef<number | null>;
+} & UseAnimatedNumberMapOptions): Record<K, ComputedRef<number | null>>;

package/dist/composables/motion/useStagger.d.ts

@@ -0,0 +1,50 @@
+import { type Ref } from "vue";
+export interface UseStaggerOptions {
+    /** Count of staggered slots. Each slot maps to one boolean in `revealed`. */
+    items: number;
+    /**
+     * Delay between consecutive reveals.
+     *
+     * Default 80ms — mirrors the `--motion-stagger-default` token in
+     * `tokens.css` (AJ-W4-κ canon). Consumers driving per-row CSS
+     * `animation-delay` cascades on the same surface should also read
+     * `--motion-stagger-default` so the JS-driven cascade (this composable)
+     * and the CSS-driven cascade stay in lockstep.
+     *
+     * The two adjacent canon tiers are:
+     *   - `--motion-stagger-tight: 40ms` — dense row cascades
+     *   - `--motion-stagger-relaxed: 120ms` — wide series cascades
+     */
+    delayMs?: number;
+    /** Delay before the first reveal fires. Default 0. */
+    initialDelayMs?: number;
+    /** Auto-start on creation. Default true. */
+    immediate?: boolean;
+    /**
+     * When true, honour `prefers-reduced-motion: reduce` by flipping every
+     * slot true synchronously instead of cascading the timeline. Mirrors
+     * the canonical opt-in on `useAnimatedNumber` and the global
+     * `transitions.css` / `utilities.css` reduced-motion brackets. SSR
+     * environments (no `window.matchMedia`) treat the option as a no-op.
+     * Default true.
+     */
+    respectReducedMotion?: boolean;
+}
+export interface UseStaggerControls {
+    /** Per-slot reveal state. `revealed.value[i]` flips true at `initialDelayMs + i * delayMs`. */
+    revealed: Ref<boolean[]>;
+    /** Re-arm the cascade. Resets `revealed` to all-false then fires the timeline. */
+    start: () => void;
+    /** Reset to all-false. Cancels any pending reveals. */
+    reset: () => void;
+    /** True once every slot has flipped. */
+    isComplete: Ref<boolean>;
+}
+/**
+ * Drive a fixed-count staggered reveal off a single timer cascade.
+ *
+ * @example
+ * const { revealed, start } = useStagger({ items: visible.value.length, delayMs: 80, initialDelayMs: 80, immediate: false });
+ * watch(allComplete, (done, prev) => { if (done && !prev) start(); });
+ */
+export declare function useStagger(options: UseStaggerOptions): UseStaggerControls;

package/dist/confirm-dialog.js

@@ -1,5 +1,5 @@
 import { t as e } from "./createLucideIcon-DuDoe_ra.js";
-import { n as t } from "./button-i8Ek5vvg.js";
+import { n as t } from "./button-BcMzVrqs.js";
 import { t as n } from "./_plugin-vue_export-helper-C1je1s0u.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", {

package/dist/constellation.d.ts

@@ -0,0 +1 @@
+export * from "./components/custom/constellation";