@mkbabb/glass-ui 4.0.0 → 4.0.1

package/dist/components/custom/concentric/constants.d.ts

@@ -0,0 +1,43 @@
+import type { RingComponent, RingCenter } from "./composables/ringField";
+import type { OklchStop } from "../../../composables/color";
+/** Compile-time ring-component cap — mirrors the WGSL `MAX_RINGS` #define. */
+export declare const MAX_RINGS = 8;
+/** Compile-time center cap — mirrors the WGSL `MAX_CENTERS` #define. */
+export declare const MAX_CENTERS = 4;
+/** Compile-time palette cap — mirrors the WGSL `MAX_RING_STOPS` #define. */
+export declare const MAX_RING_STOPS = 4;
+/**
+ * The full author schema — the studio's `useConfiguratorState` model. Every field is a
+ * tunable the demo configurator drives; the SFC resolves it into the uniform table.
+ */
+export interface ConcentricConfig {
+    /** The ring origins (1..MAX_CENTERS) — a multi-center sum produces ring interference. */
+    centers: RingCenter[];
+    /** The radial sum-of-sines table (1..MAX_RINGS). */
+    ringComponents: RingComponent[];
+    /** The ellipsoidal-norm axis ratio (a, b) — the 3D-tilt depth implication. */
+    axisRatio: [number, number];
+    /** The ring-travel speed (scales ω). */
+    speed: number;
+    /** The field-value color ramp (the demo themes it); resolved via the ColorResolver. */
+    palette: OklchStop[];
+    /** The ground color (default transparent so it reads over the page; demo sets it). */
+    background: OklchStop | "transparent";
+    /** Pointer adds a transient ring center (a local perturbation about the cursor). */
+    interactive: boolean;
+    /** ONE static frame then park under `prefers-reduced-motion: reduce`. */
+    respectReducedMotion: boolean;
+}
+/**
+ * The warm-cream identity palette (the library default — NOT a themed hue). A three-stop
+ * warm ramp over the warm-cream foreground family, resolved via the ColorResolver: a soft
+ * cream trough, a warm amber mid, a deeper ember crest — so the ring field reads as warm
+ * light interference. A consumer (the demo) themes it through a PRESET, never a token edit.
+ */
+export declare const WARM_IDENTITY_PALETTE: OklchStop[];
+/** The default 5-octave Phillips radial ring ladder. */
+export declare const DEFAULT_RING_COMPONENTS: RingComponent[];
+/** Two ring families offset on the diagonal — the default interference (a moiré beat). */
+export declare const DEFAULT_CENTERS: RingCenter[];
+/** The shipped warm-identity default config. */
+export declare const DEFAULT_CONCENTRIC_CONFIG: ConcentricConfig;

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

@@ -0,0 +1,5 @@
+export { default as Concentric } from "./Concentric.vue";
+export { useConcentric, type ConcentricHandle, type UseConcentricOptions, } from "./composables/useConcentric";
+export { type ConcentricConfig, DEFAULT_CONCENTRIC_CONFIG, DEFAULT_RING_COMPONENTS, DEFAULT_CENTERS, WARM_IDENTITY_PALETTE, MAX_RINGS, MAX_CENTERS, MAX_RING_STOPS, } from "./constants";
+export { type RingComponent, type RingCenter, type Vec2, sampleRingField, ellipsoidalRadius, buildRingLadder, RING_GRAVITY, } from "./composables/ringField";
+export type { OklchStop } from "../../../composables/color";

package/dist/components/custom/concentric/shaders/concentric.glsl.d.ts

@@ -0,0 +1,4 @@
+/** The full-screen-triangle vertex shader (the substrate's standard fullscreen pass). */
+export declare const CONCENTRIC_VERT_GLSL = "#version 300 es\nprecision highp float;\nin vec2 aPosition;\nout vec2 vUv;\nvoid main() {\n  vUv = aPosition;            // [-1,1]\u00B2 domain\n  gl_Position = vec4(aPosition, 0.0, 1.0);\n}";
+/** The concentric fragment source — the aurora-class radial-Fourier field. */
+export declare const CONCENTRIC_FRAG_GLSL = "#version 300 es\nprecision highp float;\n\n#define PI 3.141592653589793\n#define TAU 6.283185307179586\n#define RING_GRAVITY 9.81\n#define MAX_RINGS 8\n#define MAX_CENTERS 4\n#define MAX_RING_STOPS 4\n\nin vec2 vUv;\nout vec4 fragColor;\n\nuniform float uTime;\nuniform float uSpeed;\nuniform vec2  uAxis;          // (a, b) ellipsoidal-norm axis ratio\nuniform float uFieldNorm;     // field \u2192 [0,1] amplitude scale\nuniform float uAspect;\nuniform int   uCenterCount;\nuniform int   uRingCount;\nuniform int   uStopCount;\nuniform float uHasBackground;\nuniform vec3  uRings[MAX_RINGS];     // (amplitude, wavelength, phase)\nuniform vec3  uCenters[MAX_CENTERS]; // (x, y, weight)\nuniform vec3  uPalette[MAX_RING_STOPS]; // linear-sRGB stops\n\n\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}\n\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}\n\n// \u2016p \u2212 c\u2016_e = sqrt((dx/a)\u00B2 + (dy/b)\u00B2) \u2014 transcribes ringField.ts ellipsoidalRadius.\nfloat ellipsoidalRadius(vec2 p, vec2 center, float axisA, float axisB) {\n  float dx = (p.x - center.x) / max(axisA, 1e-4);\n  float dy = (p.y - center.y) / max(axisB, 1e-4);\n  return sqrt(dx * dx + dy * dy);\n}\n\n// f(p,t) \u2014 the multi-center weighted radial sum (transcribes ringField.ts sampleRingField).\nfloat sampleRingField(vec2 p, float t) {\n  float acc = 0.0;\n  for (int j = 0; j < MAX_CENTERS; j++) {\n    if (j >= uCenterCount) break;\n    vec3 cj = uCenters[j];\n    float radius = ellipsoidalRadius(p, cj.xy, uAxis.x, uAxis.y);\n    float centerSum = 0.0;\n    for (int i = 0; i < MAX_RINGS; i++) {\n      if (i >= uRingCount) break;\n      vec3 r = uRings[i];\n      float k = TAU / max(r.y, 1e-4);\n      float omega = sqrt(RING_GRAVITY * k) * uSpeed;\n      float theta = k * radius - omega * t + r.z;\n      centerSum += r.x * sin(theta);\n    }\n    acc += centerSum * cj.z;\n  }\n  return acc;\n}\n\n// Sample the multi-stop palette (linear-sRGB stops, OKLab mix). t in [0,1].\nvec3 samplePaletteLin(float t) {\n  if (uStopCount <= 1) return uPalette[0];\n  float n = float(uStopCount);\n  float ft = clamp(t, 0.0, 1.0) * (n - 1.0);\n  int i0 = int(floor(ft));\n  int i1 = min(i0 + 1, uStopCount - 1);\n  float f = ft - float(i0);\n  // cube-root LMS (the GLSL chunk inlines cbrt as sign(x)\u00B7pow(|x|,1/3) \u2014 no cbrt3 fn).\n  vec3 lmsA = LINEAR_SRGB_TO_LMS * uPalette[i0];\n  vec3 lmsB = LINEAR_SRGB_TO_LMS * uPalette[i1];\n  vec3 labA = LMS_TO_OKLAB * (sign(lmsA) * pow(abs(lmsA), vec3(1.0 / 3.0)));\n  vec3 labB = LMS_TO_OKLAB * (sign(lmsB) * pow(abs(lmsB), vec3(1.0 / 3.0)));\n  return oklabToLinearSrgb(mix(labA, labB, f));\n}\n\nvoid main() {\n  float aspect = max(uAspect, 1e-4);\n  vec2 p = vec2(vUv.x * aspect, vUv.y);\n  float raw = sampleRingField(p, uTime);\n  float v = clamp(0.5 + raw * uFieldNorm, 0.0, 1.0);\n  vec3 lin = samplePaletteLin(v);\n  vec3 rgb = clamp(linearToSrgb(lin), vec3(0.0), vec3(1.0));\n  if (uHasBackground > 0.5) {\n    fragColor = vec4(rgb, 1.0);\n    return;\n  }\n  float alpha = clamp(v * 0.92 + 0.08, 0.0, 1.0);\n  fragColor = vec4(rgb * alpha, alpha);\n}";

package/dist/components/custom/concentric/shaders/concentric.wgsl.d.ts

@@ -0,0 +1 @@
+export declare const CONCENTRIC_WGSL = "\nconst PI: f32 = 3.141592653589793;\nconst TAU: f32 = 6.283185307179586;\nconst RING_GRAVITY: f32 = 9.81;\nconst MAX_RINGS: i32 = 8;\nconst MAX_CENTERS: i32 = 4;\nconst MAX_RING_STOPS: i32 = 4;\n\n// \u2500\u2500 Concentric uniforms (the typed-struct source-of-truth \u2014 see uniformBridgeWGPU.ts) \u2500\u2500\nstruct ConcentricUniforms {\n  // u0: (uTime, uSpeed, uAxisA, uAxisB)\n  u0: vec4<f32>,\n  // ints: (uCenterCount, uRingCount, uStopCount, _pad)\n  ints: vec4<i32>,\n  // bg: (background.rgb (linear), hasBackground)\n  bg: vec4<f32>,\n  // norm: (uFieldNorm, uAspect, _pad, _pad) \u2014 field \u2192 [0,1] scale\n  norm: vec4<f32>,\n  // each ring row: (amplitude, wavelength, phase, _pad)\n  rings: array<vec4<f32>, 8>,\n  // each center row: (x, y, weight, _pad)\n  centers: array<vec4<f32>, 4>,\n  // each palette stop: linear-sRGB rgb + _pad\n  palette: array<vec4<f32>, 4>,\n};\n\n@group(0) @binding(0) var<uniform> u: ConcentricUniforms;\n\n\nfn srgbToLinearCh(c: f32) -> f32 {\n  if (c <= 0.04045) { return c / 12.92; }\n  return pow((c + 0.055) / 1.055, 2.4);\n}\nfn srgbToLinear(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\n\nfn linearToSrgbCh(c: f32) -> f32 {\n  if (c <= 0.0031308) { return c * 12.92; }\n  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\nfn linearToSrgb(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}\n\n// value.js LINEAR_SRGB_TO_LMS, row-major \u2192 WGSL columns (= the transpose).\nconst LINEAR_SRGB_TO_LMS: mat3x3<f32> = mat3x3<f32>(\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, row-major \u2192 WGSL columns.\nconst LMS_TO_OKLAB: mat3x3<f32> = mat3x3<f32>(\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, row-major \u2192 WGSL columns.\nconst OKLAB_TO_LMS: mat3x3<f32> = mat3x3<f32>(\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, row-major \u2192 WGSL columns.\nconst LMS_TO_LINEAR_SRGB: mat3x3<f32> = mat3x3<f32>(\n  4.0767416621, -1.2684380046, -0.0041960863,\n  -3.3077115913, 2.6097574011, -0.7034186147,\n  0.2309699292, -0.3413193965, 1.7076147010\n);\n\nfn cbrt3(v: vec3<f32>) -> vec3<f32> {\n  return sign(v) * pow(abs(v), vec3<f32>(1.0 / 3.0));\n}\n\n// Gamma sRGB \u2192 raw OKLab (L, a, b). Mirrors value.js srgbToOKLab.\nfn srgbToOklab(c: vec3<f32>) -> vec3<f32> {\n  let lin = srgbToLinear(c);\n  let lms = LINEAR_SRGB_TO_LMS * lin;\n  return LMS_TO_OKLAB * cbrt3(lms);\n}\n\n// Raw OKLab (L, a, b) \u2192 linear sRGB. Mirrors value.js oklabToLinearSRGB.\nfn oklabToLinearSrgb(lab: vec3<f32>) -> vec3<f32> {\n  let lms_ = OKLAB_TO_LMS * lab;\n  let lms = lms_ * lms_ * lms_;\n  return LMS_TO_LINEAR_SRGB * lms;\n}\n\n// OKLab \u2192 OKLCh: H in RADIANS, folded to [0, 2pi). Mirrors value.js rawOklabToOklch.\nfn oklabToOklch(lab: vec3<f32>) -> vec3<f32> {\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 vec3<f32>(lab.x, C, H);\n}\n\n// OKLCh (H radians) \u2192 OKLab. Mirrors value.js rawOklchToOklab.\nfn oklchToOklab(lch: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}\n\n// Full-screen-triangle (the pilot idiom): NDC corners (-1,-1),(3,-1),(-1,3) cover the\n// viewport from a single 3-vertex draw \u2014 no vertex buffer.\nstruct VSOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) uv: vec2<f32>,  // domain [-1,1]\u00B2, aspect-corrected x\n};\n\n@vertex\nfn vs_main(@builtin(vertex_index) vi: u32) -> VSOut {\n  var corners = array<vec2<f32>, 3>(\n    vec2<f32>(-1.0, -1.0), vec2<f32>(3.0, -1.0), vec2<f32>(-1.0, 3.0),\n  );\n  let c = corners[vi];\n  var out: VSOut;\n  out.pos = vec4<f32>(c, 0.0, 1.0);\n  // aspect-correct so the rings stay circular under the ellipsoidal norm (NOT squashed\n  // by the canvas aspect): widen the domain x by the aspect ratio.\n  out.uv = vec2<f32>(c.x, c.y);\n  return out;\n}\n\n// The ellipsoidal radial distance \u2016p \u2212 c\u2016_e = sqrt((dx/a)\u00B2 + (dy/b)\u00B2). The single radial\n// metric (transcribes ringField.ts ellipsoidalRadius).\nfn ellipsoidalRadius(p: vec2<f32>, center: vec2<f32>, axisA: f32, axisB: f32) -> f32 {\n  let dx = (p.x - center.x) / max(axisA, 1e-4);\n  let dy = (p.y - center.y) / max(axisB, 1e-4);\n  return sqrt(dx * dx + dy * dy);\n}\n\n// The radial-Fourier ring-interference value f(p,t) \u2014 the multi-center weighted sum of\n// radial sinusoids (transcribes ringField.ts sampleRingField line-for-line).\nfn sampleRingField(p: vec2<f32>, t: f32) -> f32 {\n  var acc = 0.0;\n  let speed = u.u0.y;\n  let axisA = u.u0.z;\n  let axisB = u.u0.w;\n  let centerCount = u.ints.x;\n  let ringCount = u.ints.y;\n  for (var j = 0; j < MAX_CENTERS; j = j + 1) {\n    if (j >= centerCount) { break; }\n    let cj = u.centers[j];\n    let radius = ellipsoidalRadius(p, cj.xy, axisA, axisB);\n    var centerSum = 0.0;\n    for (var i = 0; i < MAX_RINGS; i = i + 1) {\n      if (i >= ringCount) { break; }\n      let r = u.rings[i];\n      let k = TAU / max(r.y, 1e-4);\n      // \u03C9 = \u221A(g\u00B7k); speed scales the travel (the shared dispersion law).\n      let omega = sqrt(RING_GRAVITY * k) * speed;\n      let theta = k * radius - omega * t + r.z;\n      centerSum = centerSum + r.x * sin(theta);\n    }\n    acc = acc + centerSum * cj.z;\n  }\n  return acc;\n}\n\n// Sample the multi-stop palette (linear-sRGB stops, OKLab mix). t in [0,1].\nfn samplePaletteLin(t: f32) -> vec3<f32> {\n  let stopCount = u.ints.z;\n  if (stopCount <= 1) { return u.palette[0].rgb; }\n  let n = f32(stopCount);\n  let ft = clamp(t, 0.0, 1.0) * (n - 1.0);\n  let i0 = i32(floor(ft));\n  let i1 = min(i0 + 1, stopCount - 1);\n  let f = ft - f32(i0);\n  let labA = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i0].rgb);\n  let labB = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i1].rgb);\n  return oklabToLinearSrgb(mix(labA, labB, f));\n}\n\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4<f32> {\n  // aspect-correct the domain x so the rings read circular under the ellipsoidal norm.\n  let aspect = max(u.norm.y, 1e-4);\n  let p = vec2<f32>(in.uv.x * aspect, in.uv.y);\n  let t = u.u0.x;\n\n  let raw = sampleRingField(p, t);\n  // Normalize the field \u2192 [0,1] for the palette ramp (uFieldNorm is the amplitude scale).\n  let v = clamp(0.5 + raw * u.norm.x, 0.0, 1.0);\n\n  let lin = samplePaletteLin(v);\n  let rgb = clamp(linearToSrgb(lin), vec3<f32>(0.0), vec3<f32>(1.0));\n\n  // Premultiplied-alpha output over the (transparent / themed) ground.\n  let hasBg = u.bg.w;\n  if (hasBg > 0.5) {\n    // opaque themed ground: the field paints fully opaque.\n    return vec4<f32>(rgb, 1.0);\n  }\n  // transparent ground: the field's alpha rides its own brightness so the page reads\n  // through the troughs (the ring crests carry the ink; the calm field is faint).\n  let alpha = clamp(v * 0.92 + 0.08, 0.0, 1.0);\n  return vec4<f32>(rgb * alpha, alpha);\n}\n";

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

@@ -9,6 +9,15 @@ import { type ButtonHTMLAttributes, type Component, type HTMLAttributes } from "
  * `as="a"` swaps the host tag, `as-child` merges the dock class onto a slotted
  * child (the reka-ui Primitive idiom). `type` is emitted only on a <button>
  * host (an anchor/RouterLink carries no `type`).
+ *
+ * BB.W-LIQUIDHOVER — the pointer-anchored moving-specular gleam AUTO-ARMS via the
+ * `v-specular` directive (the tier-root delivery wrapping the ONE position-write
+ * core, `createSpecularWriter`). The prior hand-composed `useSpecularTracking` +
+ * `:style="specularStyle"` + `@pointermove="onPointerMove"` triplet RETIRED onto it:
+ * the dock control gleams pointer-following with ZERO call-site wiring. The
+ * `.dock-icon-button` `::before` (material.css) paints + lifts intensity on hover/
+ * active; the directive supplies the position. PRM-aware by construction (the wrapped
+ * core skips the write under reduce; the CSS bracket pins the catch-light static).
  */
 type __VLS_Props = {
     /** Compact variant: auto-sized instead of fixed 2.5rem square. */
@@ -21,15 +30,15 @@ type __VLS_Props = {
     asChild?: boolean;
     class?: HTMLAttributes["class"];
 };
-declare var __VLS_10: {};
+declare var __VLS_8: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_10) => any;
+    default?: (props: typeof __VLS_8) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    type: "button" | "submit" | "reset";
+    type: "button" | "reset" | "submit";
+    compact: boolean;
     asChild: boolean;
     as: string | Component;
-    compact: 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/custom/dock/DockLayerGroup.vue.d.ts

@@ -16,20 +16,28 @@ type __VLS_Props = {
     showRail?: boolean;
     /** Rail placement relative to the layer stack. */
     railPosition?: "start" | "end";
+    /**
+     * BB.W-DRAG-MORPH — pull-to-switch. When `true` (ADDITIVE, default `false`),
+     * the switcher-rail indicator becomes draggable: pull along the rail axis to
+     * the next layer chip, fling-to-nearest on release writes `activeLayer`
+     * (`useDragMorph`, consumer #2). The reka roving tabindex / Arrow keys stay.
+     */
+    draggable?: boolean;
 };
 type __VLS_ModelProps = {
     "active": string;
 };
 type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
-declare var __VLS_32: {};
+declare var __VLS_34: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_32) => any;
+    default?: (props: typeof __VLS_34) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:active": (value: string) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
     "onUpdate:active"?: ((value: string) => any) | undefined;
 }>, {
+    draggable: boolean;
     showRail: boolean;
     railPosition: "start" | "end";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

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

@@ -0,0 +1,75 @@
+import type { Ref } from "vue";
+/**
+ * BB.W-CARVE4 — the dock morph MEASURE/SEAT helpers, carved out of
+ * `dockMorphContext.ts` to hold the no-god-module bound (the aurora→useAurora /
+ * goo-blob→useMetaballRenderer / fourier-field→useFourierField colocation pattern).
+ * The orchestrator stays the morph DRIVER (it owns the `SpringProgress`, the targets
+ * Set, the per-frame `--dock-morph-t` write); these are the PURE geometry + the
+ * reserved-footprint measure + the SYNCHRONOUS PRM seat it composes. `DOCK_SPRING` is
+ * byte-fenced — it lives in `../constants`, never touched here.
+ *
+ * The functions take their element/axis/target dependencies as explicit params (the
+ * orchestrator's closures collapse onto this seam) — no module-level state, so the
+ * extraction is behaviour-identical to the prior inline closures.
+ */
+/** The minimal morph-target shape the measure/seat helpers read (the orchestrator's
+ *  full `MorphTarget` structurally satisfies it). */
+export interface MorphMeasureTarget {
+    containerEl: Ref<HTMLElement | null>;
+    axis: Ref<"horizontal" | "vertical">;
+    /** PER-TARGET swap generation — the seat gates its pipeline on its own id. */
+    txId: number;
+}
+export declare function dimOf(axis: "horizontal" | "vertical"): "width" | "height";
+export declare function morphAxisProp(axis: "horizontal" | "vertical"): "inline-size" | "block-size";
+export declare function getSize(el: HTMLElement, axis: "horizontal" | "vertical"): number;
+export declare function clearMorphVars(el: HTMLElement): void;
+/**
+ * BA-VJS-1 (valuejs-fold A-1) — the OTHER registered targets whose container is a
+ * DOM DESCENDANT of `outerEl` (a nested `<DockLayerGroup>` stack inside the outer
+ * `.dock-layers`). These are the pinned inner spans the outer measure must see at
+ * their OWN intrinsic `max-content`, not their collapsed pin, or the outer
+ * shrink-wraps to ~0.
+ */
+export declare function nestedTargetsWithin(outer: MorphMeasureTarget, outerEl: HTMLElement, targets: Iterable<MorphMeasureTarget>): MorphMeasureTarget[];
+/**
+ * BA-VJS-1 — force ONE nested target to its own-axis `max-content` (clearing its
+ * reserved `--dock-morph-to` footprint so it sizes to content), and return a closure
+ * that RESTORES its exact prior inline state. The restore re-writes the precise
+ * prior `inline-size`/`block-size` inline value (or removes it if there was none),
+ * so the inner's in-flight pin is byte-identical after the outer's measurement —
+ * the inner target's own spring/pin pipeline is never disturbed.
+ */
+export declare function forceNestedMaxContent(n: MorphMeasureTarget): () => void;
+/**
+ * BB.W-DOCK-MORPH-FAMILY (c) — measure the true `to` for ONE target with the
+ * morph axis forced to `max-content` (the same circular-measure escape the rAF
+ * path uses), composing the BA-VJS-1 nested-descendant `max-content` ordering so
+ * a nested group reads its TRUE intrinsic span (never `to:0`). The element is at
+ * the live painted geometry on entry; this forces+reads+restores the axis. PURE
+ * measure — no spring, no pin write.
+ */
+export declare function measureTo(t: MorphMeasureTarget, el: HTMLElement, targets: Iterable<MorphMeasureTarget>): number;
+/** The orchestrator settle callbacks the synchronous seat composes (it clears the
+ *  morph vars + nulls the leaving layer, then parks the root/spring once no target
+ *  is morphing). */
+export interface MorphSeatCallbacks {
+    /** Settle ONE target (clear its morph vars + null its leavingLayer). */
+    settleTarget(t: MorphMeasureTarget): void;
+    /** Park the shared scalar + spring once NO target is morphing. */
+    maybeSettleRoot(): void;
+}
+/**
+ * BB.W-DOCK-MORPH-FAMILY (c) — the SYNCHRONOUS PRM seat. Under
+ * `prefers-reduced-motion: reduce` there is NO morph to play, so the geometry +
+ * the scalar seat at the target in ONE step (the `useDockOrientationMorph.pin()`
+ * precedent transplanted onto the collapse/expand path): measure the true `to`
+ * (composing the BA-VJS-1 nested ordering), write the box at `to` (the
+ * reserved-footprint reads at scale 1), and set `--dock-morph-t` to the endpoint
+ * for THIS swap — then clear the morph state immediately (no rAF measure-defer,
+ * no spring, no morph window). The box NEVER paints the collapsed `from` sliver
+ * with the scalar at 1 (the P0 terminal failure). Endpoint is the per-swap
+ * incoming-ness `1` (the new pane is fully in; the directional `--dock-expand-t`
+ * resolves to the class endpoint with `[data-morphing]` cleared).
+ */
+export declare function seatTargetSync(t: MorphMeasureTarget, id: number, root: HTMLElement | null, targets: Iterable<MorphMeasureTarget>, cb: MorphSeatCallbacks): void;

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

@@ -68,6 +68,19 @@ export interface UseLayerTransitionReturn {
     currentLayer: Ref<string>;
     /** The layer id currently fading out, or null. */
     leavingLayer: Ref<string | null>;
+    /**
+     * BB.W-PERF-PRODUCER A′-4 — `true` while the size morph is in flight (the
+     * reactive twin of the `data-morphing` attr). A floating dock consumer reads
+     * this to hold a reka Popper re-position off the morph's critical frames.
+     */
+    morphing: Ref<boolean>;
+    /**
+     * BB.W-PERF-PRODUCER A′-4 — schedule a reka Popper re-position OFF the
+     * synchronous morph flush. Queued while a morph is live (flushed ONCE on
+     * settle, against the final box), else run on the next rAF. Defers the floating
+     * re-position only — NOT the FLIP measure.
+     */
+    deferReposition(cb: () => void): void;
 }
 /**
  * Coordinates the size morph + crossfade between grid-stacked dock layer panes.

package/dist/components/custom/dot-flow-field/DotFlowField.vue.d.ts

@@ -0,0 +1,38 @@
+import type { FlowFieldConfig } from "./constants";
+/**
+ * DotFlowField — small dots seeded along undulating streamlines, rippling in waves.
+ *
+ * A curl-noise flow field traced by advected particles, where the scalar potential
+ * undulates as a Gerstner/Tessendorf sum-of-sines water-wave field (the cited SOTA
+ * math — `composables/flowField.ts`). WebGPU-FIRST: the compute pass advects N
+ * particles through the analytic ∇⊥ψ velocity, the render pass draws instanced
+ * billboard quads; a Canvas2D point-cloud fallback steps the SAME evaluator where
+ * WebGPU is absent (the ~5-10% tail). It composes `useDotFlowField` → the
+ * `createGpuSubstrate` picker over the ONE canvas lifecycle leaf (offscreen-pause,
+ * live-PRM freeze, consumer-owned DPR) — it never bootstraps its own context.
+ *
+ * The DEFAULT palette is the warm-cream library identity; the reference teal-on-navy
+ * is a DEMO preset (presets-in-consumers — never a library token).
+ */
+type __VLS_Props = {
+    /** The full author schema (the studio's `useConfiguratorState` model). */
+    config?: FlowFieldConfig;
+    /**
+     * The declarative WCAG-2.2.2 pause seam. `v-model:paused` parks the render loop
+     * (the substrate's `manual` suspend) when `true`. Wire `<DockBackgroundToggle>`'s
+     * `@update:paused` to this `v-model`.
+     */
+    paused?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
+    pause: () => void;
+    resume: () => void;
+    wake: () => void;
+    renderAt: (timeSec: number) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:paused": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "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/dot-flow-field/composables/flowField.d.ts

@@ -0,0 +1,41 @@
+/** A 2-vector. */
+export interface Vec2 {
+    x: number;
+    y: number;
+}
+/**
+ * One Gerstner / Tessendorf wave component. `amplitude` A_i, `wavelength` λ_i (so
+ * k_i = 2π/λ_i), `direction` in DEGREES (the unit travel direction), `phase` φ_i.
+ * `ω_i = √(g·k_i)` is derived from the dispersion relation, not stored.
+ */
+export interface WaveComponent {
+    amplitude: number;
+    wavelength: number;
+    /** Travel direction in degrees (0 = +x). */
+    direction: number;
+    phase: number;
+}
+/** Deep-water gravity constant (normalized; scales the dispersion ω). */
+export declare const FLOW_GRAVITY = 9.81;
+/**
+ * The Gerstner-sum velocity v(p,t) = ∇⊥h = (∂h/∂y, −∂h/∂x), ANALYTIC. The single
+ * math source the WGSL kernel transcribes. `windSpeed` scales the dispersion ω;
+ * `windDirection` (deg) is folded into each component's direction by the caller (the
+ * components carry their own absolute direction). Returns the un-normalized flow vector.
+ */
+export declare function gerstnerVelocity(p: Vec2, timeSec: number, waves: readonly WaveComponent[], windSpeed: number): Vec2;
+/** The 2D curl of the scalar fbm potential (the JS twin of `curlFBM`). */
+export declare function curlFBM(p: Vec2): Vec2;
+/**
+ * The COMPOSITE flow velocity v(p,t): the Gerstner sum-of-sines analytic ∇⊥h PLUS the
+ * `curlStrength`-weighted fbm curl-noise braiding term. The SINGLE math source the WGSL
+ * compute kernel transcribes; `proof:flow-field` clause 3 round-trips the two paths.
+ */
+export declare function sampleVelocity(p: Vec2, timeSec: number, waves: readonly WaveComponent[], windSpeed: number, curlStrength: number): Vec2;
+/**
+ * Build the default 6-octave Phillips-spectrum wave ladder about a dominant wind
+ * direction. Amplitudes follow `A_i ∝ exp(−1/(k_i·L)²) / k_i²` (Tessendorf §4), so the
+ * field is energy-realistic. The directions spread about `windDirection` so the
+ * streamlines braid like a river delta (not a flat band).
+ */
+export declare function buildWaveLadder(windDirection: number, octaves?: number): WaveComponent[];

package/dist/components/custom/dot-flow-field/composables/uniformBridgeWGPU.d.ts

@@ -0,0 +1,24 @@
+import type { OklchStop } from "../../../../composables/color";
+import { type FlowFieldConfig } from "../constants";
+export declare const FLOW_COMPUTE_UNIFORM_BYTES: number;
+export interface FlowUniformScratch {
+    buffer: ArrayBuffer;
+    f32: Float32Array;
+    i32: Int32Array;
+}
+export declare function createFlowComputeScratch(): FlowUniformScratch;
+/** The domain half-extent (mirrors the WGSL `uDomainHalf`). */
+export declare const FLOW_DOMAIN_HALF = 0.85;
+/** Pack the compute uniforms in place. */
+export declare function packFlowComputeUniforms(scratch: FlowUniformScratch, config: FlowFieldConfig, timeSec: number, dt: number, particleCount: number): FlowUniformScratch;
+export declare const FLOW_RENDER_UNIFORM_BYTES: number;
+export declare function createFlowRenderScratch(): FlowUniformScratch;
+/** Pack the render uniforms in place. */
+export declare function packFlowRenderUniforms(scratch: FlowUniformScratch, config: FlowFieldConfig, timeSec: number, aspect: number, canvasCssMin: number, palette: OklchStop[]): FlowUniformScratch;
+/** The byte size of one particle in the storage buffer (vec4<f32>). */
+export declare const FLOW_PARTICLE_BYTES = 16;
+/**
+ * Seed the particle storage buffer: each particle is (pos.x, pos.y, age, seed) in the
+ * domain [-half, half]. The seed is deterministic per index so a re-mount is reproducible.
+ */
+export declare function seedParticleBuffer(particleCount: number): Float32Array;

package/dist/components/custom/dot-flow-field/composables/useDotFlowField.d.ts

@@ -0,0 +1,34 @@
+import { type Ref } from "vue";
+import { type GpuBackend } from "../../../../composables/glass/webgpu/useGpuSubstrate";
+import { type OklchStop } from "../../../../composables/color";
+import type { FlowFieldConfig } from "../constants";
+export interface UseDotFlowFieldOptions {
+    config: FlowFieldConfig;
+    /** Resolve the dot-color palette as OKLCh (the demo themes it; default warm-identity). */
+    getPalette: () => OklchStop[];
+    /** `"capture"` → renderAt-only (the deterministic π capture path). Default `"live"`. */
+    mode?: "live" | "capture";
+}
+/** The uniform handle a consumer wires its lifecycle against (backend-agnostic). */
+export interface DotFlowFieldHandle {
+    /** The resolved backend (`"webgpu"` where supported, else the Canvas2D fallback as `"webgl2"`). */
+    readonly backend: GpuBackend;
+    /** Park the loop (the WCAG-2.2.2 pause seam — `DockBackgroundToggle` wires this). */
+    pause: () => void;
+    /** Re-arm the loop. */
+    resume: () => void;
+    /** Re-arm a parked loop on demand (a pointer/setter that re-introduced motion). */
+    wake: () => void;
+    /** Draw one frame out-of-loop (capture / thumbnail). */
+    renderAt: (timeSec: number) => void;
+    /** The live `prefers-reduced-motion: reduce` state. */
+    readonly reducedMotion: boolean;
+    /** Tear down the renderer + release GPU/2D resources. */
+    dispose: () => void;
+}
+/**
+ * Mount the dot-flow-field renderer on `canvasRef`. The WebGPU primary runs the
+ * compute+render two-pass; the Canvas2D fallback steps the SAME `flowField.ts` evaluator
+ * (the ONE math source). Returns the uniform lifecycle handle.
+ */
+export declare function useDotFlowField(canvasRef: Ref<HTMLCanvasElement | null>, options: UseDotFlowFieldOptions): DotFlowFieldHandle;

package/dist/components/custom/dot-flow-field/composables/useFlowParticles.d.ts

@@ -0,0 +1,18 @@
+import type { WebGPUCanvasFrame } from "../../../../composables/glass/webgpu/useWebGPUCanvas";
+import type { OklchStop } from "../../../../composables/color";
+import type { FlowFieldConfig } from "../constants";
+export interface FlowWGPUSetupDeps {
+    canvas: HTMLCanvasElement;
+    config: FlowFieldConfig;
+    /** The resolved (ColorResolver) palette stops as OKLCh — re-read each frame so a live palette edit reaches the buffer. */
+    getPalette: () => OklchStop[];
+    /** Demand-gate (the renderer's quiescence layer — substrate-agnostic). */
+    shouldContinue: () => boolean;
+    /** Reduced-motion read (the substrate owns the query; the renderer maps the clock). */
+    getReducedMotion: () => boolean;
+}
+/**
+ * Build the dot-flow-field `setupWGPU(device, context, format)` callback. Closes over the
+ * config/palette getters + the renderer's demand gate.
+ */
+export declare function createFlowWGPUSetup(deps: FlowWGPUSetupDeps): (device: GPUDevice, context: GPUCanvasContext, format: GPUTextureFormat) => WebGPUCanvasFrame;

package/dist/components/custom/dot-flow-field/constants.d.ts

@@ -0,0 +1,48 @@
+import type { WaveComponent } from "./composables/flowField";
+import type { OklchStop } from "../../../composables/color";
+/** Compile-time particle cap — mirrors the WGSL storage-buffer array bound. */
+export declare const MAX_PARTICLES = 16384;
+/** Compile-time wave-component cap — mirrors the WGSL `MAX_WAVE_COMPONENTS` #define. */
+export declare const MAX_WAVE_COMPONENTS = 8;
+/** Compile-time palette cap — mirrors the WGSL `MAX_FLOW_STOPS` #define. */
+export declare const MAX_FLOW_STOPS = 4;
+/** The default advected-dot count (coarse-pointer/mobile clamps lower). */
+export declare const DEFAULT_PARTICLE_COUNT = 4000;
+/**
+ * The full author schema — the studio's `useConfiguratorState` model. Every field is a
+ * tunable the demo configurator drives; the SFC resolves it into the uniform table.
+ */
+export interface FlowFieldConfig {
+    /** The advected-dot count (500..MAX_PARTICLES). */
+    particleCount: number;
+    /** The Gerstner sum-of-sines table (1..MAX_WAVE_COMPONENTS). */
+    waveComponents: WaveComponent[];
+    /** The dominant wave-travel direction in degrees (the field's overall lean). */
+    windDirection: number;
+    /** The dispersion-driven travel speed (scales ω). */
+    windSpeed: number;
+    /** The fbm curl-noise braiding term weight over the pure Gerstner field (0..1). */
+    curlStrength: number;
+    /** The billboard base radius in px @ 1×. */
+    dotSize: number;
+    /** How much |v| thins the dot (denser-where-calm — the reference's varying size). */
+    dotSizeVelocity: number;
+    /** The dot-color ramp (the demo themes it teal); resolved via the ColorResolver. */
+    palette: OklchStop[];
+    /** The ground color (the demo sets dark navy; default transparent). */
+    background: OklchStop | "transparent";
+    /** Pointer-warp the field (a local velocity perturbation about the cursor). */
+    interactive: boolean;
+    /** ONE static frame then park under `prefers-reduced-motion: reduce`. */
+    respectReducedMotion: boolean;
+}
+/**
+ * The warm-cream identity palette (the library default — NOT teal). A two-stop
+ * warm-amber ramp over the warm-cream foreground family, resolved via the ColorResolver.
+ * A consumer (the demo) themes it teal-on-navy through a PRESET, never a token edit.
+ */
+export declare const WARM_IDENTITY_PALETTE: OklchStop[];
+/** The default 6-octave Phillips wave ladder about a 35° diagonal wind. */
+export declare const DEFAULT_WAVE_COMPONENTS: WaveComponent[];
+/** The shipped warm-identity default config. */
+export declare const DEFAULT_FLOW_CONFIG: FlowFieldConfig;

package/dist/components/custom/dot-flow-field/index.d.ts

@@ -0,0 +1,5 @@
+export { default as DotFlowField } from "./DotFlowField.vue";
+export { useDotFlowField, type DotFlowFieldHandle, type UseDotFlowFieldOptions, } from "./composables/useDotFlowField";
+export { type FlowFieldConfig, DEFAULT_FLOW_CONFIG, DEFAULT_WAVE_COMPONENTS, WARM_IDENTITY_PALETTE, MAX_PARTICLES, MAX_WAVE_COMPONENTS, MAX_FLOW_STOPS, DEFAULT_PARTICLE_COUNT, } from "./constants";
+export { type WaveComponent, type Vec2, sampleVelocity, gerstnerVelocity, curlFBM, buildWaveLadder, FLOW_GRAVITY, } from "./composables/flowField";
+export type { OklchStop } from "../../../composables/color";

package/dist/components/custom/dot-flow-field/shaders/flow-field.compute.wgsl.d.ts

@@ -0,0 +1 @@
+export declare const FLOW_FIELD_COMPUTE_WGSL = "\nconst MAX_WAVE_COMPONENTS: i32 = 8;\nconst PI: f32 = 3.141592653589793;\nconst TAU: f32 = 6.283185307179586;\nconst FLOW_GRAVITY: f32 = 9.81;\nconst CURL_EPS: f32 = 0.012;\nconst FBM_ROT: mat2x2<f32> = mat2x2<f32>(0.8, 0.6, -0.6, 0.8);\n\nstruct Particle {\n  // (pos.x, pos.y, age, seed)\n  data: vec4<f32>,\n};\n\n// \u2500\u2500 Uniforms (the typed-struct source-of-truth \u2014 see uniformBridgeWGPU.ts) \u2500\u2500\nstruct FlowUniforms {\n  // p0: (uTime, uDt, uWindSpeed, uCurlStrength)\n  p0: vec4<f32>,\n  // p1: (uDomainHalf, uReseedJitter, _pad, _pad)\n  p1: vec4<f32>,\n  // ints: (uWaveCount, uParticleCount, _pad, _pad)\n  ints: vec4<i32>,\n  // each wave row: (amplitude, wavelength, directionDeg, phase)\n  waves: array<vec4<f32>, 8>,\n};\n\n@group(0) @binding(0) var<uniform> u: FlowUniforms;\n@group(0) @binding(1) var<storage, read_write> particles: array<Particle>;\n\n// \u2500\u2500 The Gerstner-sum analytic \u2207\u22A5h velocity (transcribes flowField.ts gerstnerVelocity) \u2500\u2500\nfn gerstnerVelocity(p: vec2<f32>, t: f32) -> vec2<f32> {\n  var dhdx = 0.0;\n  var dhdy = 0.0;\n  let windSpeed = u.p0.z;\n  let waveCount = u.ints.x;\n  for (var i = 0; i < MAX_WAVE_COMPONENTS; i = i + 1) {\n    if (i >= waveCount) { break; }\n    let w = u.waves[i];\n    let amplitude = w.x;\n    let wavelength = max(w.y, 1e-4);\n    let dirRad = w.z * PI / 180.0;\n    let phase = w.w;\n    let k = TAU / wavelength;\n    let d = vec2<f32>(cos(dirRad), sin(dirRad));\n    let omega = sqrt(FLOW_GRAVITY * k) * windSpeed;\n    let theta = k * (d.x * p.x + d.y * p.y) - omega * t + phase;\n    let akc = amplitude * k * cos(theta);\n    dhdx = dhdx + akc * d.x;\n    dhdy = dhdy + akc * d.y;\n  }\n  // v = \u2207\u22A5h = (\u2202h/\u2202y, \u2212\u2202h/\u2202x).\n  return vec2<f32>(dhdy, -dhdx);\n}\n\n// \u2500\u2500 Shared curl-noise basis (the WGSL twin of flow.glsl.ts curlFBM) \u2500\u2500\nfn hash21(p: vec2<f32>) -> f32 {\n  var p3 = fract(vec3<f32>(p.x, p.y, p.x) * 0.1031);\n  p3 = p3 + dot(p3, p3.yzx + 33.33);\n  return fract((p3.x + p3.y) * p3.z);\n}\n\nfn valueNoise(p: vec2<f32>) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u2 = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);\n  let a = hash21(i + vec2<f32>(0.0, 0.0));\n  let b = hash21(i + vec2<f32>(1.0, 0.0));\n  let c = hash21(i + vec2<f32>(0.0, 1.0));\n  let d = hash21(i + vec2<f32>(1.0, 1.0));\n  return mix(mix(a, b, u2.x), mix(c, d, u2.x), u2.y);\n}\n\nfn potentialFBM(p0: vec2<f32>) -> f32 {\n  var v = 0.0;\n  var amp = 0.5;\n  var freq = 1.0;\n  var p = p0;\n  for (var i = 0; i < 3; i = i + 1) {\n    v = v + amp * valueNoise(p * freq);\n    p = FBM_ROT * p;\n    freq = freq * 2.0;\n    amp = amp * 0.5;\n  }\n  return v;\n}\n\nfn curlFBM(p: vec2<f32>) -> vec2<f32> {\n  let dx = potentialFBM(p + vec2<f32>(CURL_EPS, 0.0)) - potentialFBM(p - vec2<f32>(CURL_EPS, 0.0));\n  let dy = potentialFBM(p + vec2<f32>(0.0, CURL_EPS)) - potentialFBM(p - vec2<f32>(0.0, CURL_EPS));\n  let g = vec2<f32>(dx, dy) / (2.0 * CURL_EPS);\n  return vec2<f32>(g.y, -g.x);\n}\n\n// The composite flow velocity (transcribes flowField.ts sampleVelocity EXACTLY).\nfn sampleVelocity(p: vec2<f32>, t: f32) -> vec2<f32> {\n  let curlStrength = u.p0.w;\n  var v = gerstnerVelocity(p, t);\n  if (curlStrength > 0.0) {\n    let c = curlFBM(vec2<f32>(p.x * 1.7 + t * 0.15, p.y * 1.7));\n    v = v + c * curlStrength;\n  }\n  return v;\n}\n\n// A particle that leaves the bounds re-spawns at a seed-derived position (so coverage\n// stays steady \u2014 the \u00A73 re-seed-at-edge rule). The seed advances each re-spawn so a\n// re-seeded particle does not pile on the previous spawn.\nfn reseed(seed: f32, age: f32) -> vec2<f32> {\n  let half = u.p1.x;\n  let r1 = hash21(vec2<f32>(seed * 71.13, age * 13.7));\n  let r2 = hash21(vec2<f32>(seed * 19.31 + 4.0, age * 7.3 + 2.0));\n  return (vec2<f32>(r1, r2) * 2.0 - 1.0) * half;\n}\n\n@compute @workgroup_size(64)\nfn cs_main(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let idx = gid.x;\n  let count = u32(u.ints.y);\n  if (idx >= count) { return; } // bounds-guard the dispatch tail\n\n  let t = u.p0.x;\n  let dt = u.p0.y;\n  let half = u.p1.x;\n\n  var pr = particles[idx];\n  var pos = pr.data.xy;\n  var age = pr.data.z;\n  let seed = pr.data.w;\n\n  let v = sampleVelocity(pos, t);\n  // Forward Euler \u2014 p_{n+1} = p_n + v\u00B7dt.\n  pos = pos + v * dt;\n  age = age + dt;\n\n  // Wrap / re-seed at the domain edge (re-spawn from the seed at a fresh position).\n  if (abs(pos.x) > half || abs(pos.y) > half || age > 6.0) {\n    pos = reseed(seed, age);\n    age = 0.0;\n  }\n\n  particles[idx] = Particle(vec4<f32>(pos, age, seed));\n}\n";

package/dist/components/custom/dot-flow-field/shaders/flow-field.glsl.d.ts

@@ -0,0 +1,20 @@
+import type { FlowFieldConfig } from "../constants";
+import { type Vec2 } from "../composables/flowField";
+/** A CPU particle (the Canvas2D-stepped twin of the WGSL storage Particle). */
+export interface CpuParticle {
+    pos: Vec2;
+    age: number;
+    seed: number;
+}
+/**
+ * The CPU particle field — alloc + seed + step + paint, over the Canvas2D substrate.
+ * `step(dt, timeSec)` advects every particle through the SAME `sampleVelocity` evaluator
+ * the WGSL compute kernel transcribes; `paint(ctx)` draws the soft dots. The fallback's
+ * `degraded` parity is the CPU step count vs the GPU's per-particle instancing — the same
+ * flow, a coarser density.
+ */
+export declare function createCpuFlowField(config: FlowFieldConfig): {
+    particles: CpuParticle[];
+    step: (dt: number, timeSec: number) => void;
+    paint: (ctx: CanvasRenderingContext2D, wCss: number, hCss: number, timeSec: number, dotColor: string) => void;
+};

package/dist/components/custom/dot-flow-field/shaders/flow-field.render.wgsl.d.ts

@@ -0,0 +1 @@
+export declare const FLOW_FIELD_RENDER_WGSL = "\nconst PI: f32 = 3.141592653589793;\nconst TAU: f32 = 6.283185307179586;\nconst FLOW_GRAVITY: f32 = 9.81;\nconst MAX_WAVE_COMPONENTS: i32 = 8;\nconst MAX_FLOW_STOPS: i32 = 4;\n\nstruct Particle {\n  // (pos.x, pos.y, age, seed)\n  data: vec4<f32>,\n};\n\n// \u2500\u2500 Render uniforms (the typed-struct source-of-truth \u2014 see uniformBridgeWGPU.ts) \u2500\u2500\nstruct RenderUniforms {\n  // r0: (uTime, uWindSpeed, uCurlStrength, uDomainHalf)\n  r0: vec4<f32>,\n  // r1: (uDotSize, uDotSizeVelocity, uAspect, uVMax)\n  r1: vec4<f32>,\n  // ints: (uWaveCount, uStopCount, uParticleCount, _pad)\n  ints: vec4<i32>,\n  // bg: (background.rgb, hasBackground)\n  bg: vec4<f32>,\n  // each wave row: (amplitude, wavelength, directionDeg, phase)\n  waves: array<vec4<f32>, 8>,\n  // each palette stop: linear-sRGB rgb + _pad\n  palette: array<vec4<f32>, 4>,\n};\n\n@group(0) @binding(0) var<uniform> u: RenderUniforms;\n@group(0) @binding(1) var<storage, read> particles: array<Particle>;\n\n\nfn srgbToLinearCh(c: f32) -> f32 {\n  if (c <= 0.04045) { return c / 12.92; }\n  return pow((c + 0.055) / 1.055, 2.4);\n}\nfn srgbToLinear(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\n\nfn linearToSrgbCh(c: f32) -> f32 {\n  if (c <= 0.0031308) { return c * 12.92; }\n  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\nfn linearToSrgb(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}\n\n// value.js LINEAR_SRGB_TO_LMS, row-major \u2192 WGSL columns (= the transpose).\nconst LINEAR_SRGB_TO_LMS: mat3x3<f32> = mat3x3<f32>(\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, row-major \u2192 WGSL columns.\nconst LMS_TO_OKLAB: mat3x3<f32> = mat3x3<f32>(\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, row-major \u2192 WGSL columns.\nconst OKLAB_TO_LMS: mat3x3<f32> = mat3x3<f32>(\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, row-major \u2192 WGSL columns.\nconst LMS_TO_LINEAR_SRGB: mat3x3<f32> = mat3x3<f32>(\n  4.0767416621, -1.2684380046, -0.0041960863,\n  -3.3077115913, 2.6097574011, -0.7034186147,\n  0.2309699292, -0.3413193965, 1.7076147010\n);\n\nfn cbrt3(v: vec3<f32>) -> vec3<f32> {\n  return sign(v) * pow(abs(v), vec3<f32>(1.0 / 3.0));\n}\n\n// Gamma sRGB \u2192 raw OKLab (L, a, b). Mirrors value.js srgbToOKLab.\nfn srgbToOklab(c: vec3<f32>) -> vec3<f32> {\n  let lin = srgbToLinear(c);\n  let lms = LINEAR_SRGB_TO_LMS * lin;\n  return LMS_TO_OKLAB * cbrt3(lms);\n}\n\n// Raw OKLab (L, a, b) \u2192 linear sRGB. Mirrors value.js oklabToLinearSRGB.\nfn oklabToLinearSrgb(lab: vec3<f32>) -> vec3<f32> {\n  let lms_ = OKLAB_TO_LMS * lab;\n  let lms = lms_ * lms_ * lms_;\n  return LMS_TO_LINEAR_SRGB * lms;\n}\n\n// OKLab \u2192 OKLCh: H in RADIANS, folded to [0, 2pi). Mirrors value.js rawOklabToOklch.\nfn oklabToOklch(lab: vec3<f32>) -> vec3<f32> {\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 vec3<f32>(lab.x, C, H);\n}\n\n// OKLCh (H radians) \u2192 OKLab. Mirrors value.js rawOklchToOklab.\nfn oklchToOklab(lch: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}\n\n// \u2500\u2500 The Gerstner-sum velocity (the SAME transcription as the compute kernel, read here\n//    for the per-particle size + color tint \u2014 denser-where-calm). \u2500\u2500\nfn gerstnerVelocity(p: vec2<f32>, t: f32) -> vec2<f32> {\n  var dhdx = 0.0;\n  var dhdy = 0.0;\n  let windSpeed = u.r0.y;\n  let waveCount = u.ints.x;\n  for (var i = 0; i < MAX_WAVE_COMPONENTS; i = i + 1) {\n    if (i >= waveCount) { break; }\n    let w = u.waves[i];\n    let k = TAU / max(w.y, 1e-4);\n    let dirRad = w.z * PI / 180.0;\n    let d = vec2<f32>(cos(dirRad), sin(dirRad));\n    let omega = sqrt(FLOW_GRAVITY * k) * windSpeed;\n    let theta = k * (d.x * p.x + d.y * p.y) - omega * t + w.w;\n    let akc = w.x * k * cos(theta);\n    dhdx = dhdx + akc * d.x;\n    dhdy = dhdy + akc * d.y;\n  }\n  return vec2<f32>(dhdy, -dhdx);\n}\n\n// Sample the multi-stop palette (linear-sRGB stops, OKLab mix). t in [0,1].\nfn samplePaletteLin(t: f32) -> vec3<f32> {\n  let stopCount = u.ints.y;\n  if (stopCount <= 1) { return u.palette[0].rgb; }\n  let n = f32(stopCount);\n  let ft = clamp(t, 0.0, 1.0) * (n - 1.0);\n  let i0 = i32(floor(ft));\n  let i1 = min(i0 + 1, stopCount - 1);\n  let f = ft - f32(i0);\n  let labA = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i0].rgb);\n  let labB = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i1].rgb);\n  return oklabToLinearSrgb(mix(labA, labB, f));\n}\n\nstruct VSOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) local: vec2<f32>,   // [-1,1] billboard-local coords for the soft circle\n  @location(1) tint: f32,          // velocity-derived color/alpha tint [0,1]\n  @location(2) alphaScale: f32,    // velocity-derived alpha scale (denser-where-calm)\n};\n\n@vertex\nfn vs_main(\n  @builtin(vertex_index) vi: u32,\n  @builtin(instance_index) ii: u32,\n) -> VSOut {\n  // Two-triangle quad corners in billboard-local space.\n  var corners = array<vec2<f32>, 6>(\n    vec2<f32>(-1.0, -1.0), vec2<f32>(1.0, -1.0), vec2<f32>(-1.0, 1.0),\n    vec2<f32>(-1.0, 1.0), vec2<f32>(1.0, -1.0), vec2<f32>(1.0, 1.0),\n  );\n  let local = corners[vi];\n\n  let pr = particles[ii].data;\n  let p = pr.xy;\n  let t = u.r0.x;\n  let half = u.r0.w;\n\n  // Per-particle velocity \u2192 size + tint (denser-where-calm: |v| thins the dot).\n  let v = gerstnerVelocity(p, t);\n  let speed = length(v);\n  let vMax = max(u.r1.w, 1e-4);\n  let speedNorm = clamp(speed / vMax, 0.0, 1.0);\n  let dotSizeVel = u.r1.y;\n  // size_i = base \u00B7 (1 \u2212 speedNorm \u00B7 sizeVel) \u2014 calm = larger dot.\n  let sizeWorld = u.r1.x * (1.0 - speedNorm * dotSizeVel);\n  let alphaScale = 1.0 - speedNorm * 0.35; // calm = denser/brighter\n\n  // Position the quad at the particle in clip space. Domain [-half,half] \u2192 NDC [-1,1];\n  // the quad half-extent rides sizeWorld (in the same domain units, aspect-corrected x).\n  let aspect = u.r1.z;\n  let ndc = p / half;\n  let off = local * sizeWorld / half;\n  let offX = off.x / max(aspect, 1e-4);\n\n  var out: VSOut;\n  out.pos = vec4<f32>(ndc.x + offX, ndc.y + off.y, 0.0, 1.0);\n  out.local = local;\n  out.tint = speedNorm;\n  out.alphaScale = alphaScale;\n  return out;\n}\n\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4<f32> {\n  // Soft circle \u2014 radial smoothstep over the billboard-local radius.\n  let r = length(in.local);\n  let feather = 0.35;\n  let mask = 1.0 - smoothstep(1.0 - feather, 1.0, r);\n  if (mask < 0.002) { return vec4<f32>(0.0); }\n\n  let lin = samplePaletteLin(in.tint);\n  let alpha = mask * in.alphaScale;\n  let rgb = clamp(linearToSrgb(lin), vec3<f32>(0.0), vec3<f32>(1.0));\n  // Premultiplied-alpha output.\n  return vec4<f32>(rgb * alpha, alpha);\n}\n";

package/dist/components/custom/easing/EasingConfigurator.vue.d.ts

@@ -0,0 +1,33 @@
+import type { EasingPickerMode, EasingPickerValue, JumpTerm } from "./composables/useEasingPicker";
+type __VLS_Props = {
+    /** Section label for the configurator layer. */
+    label?: string;
+    /** A token-style sub-label (the mono caption rung). */
+    name?: string;
+    /** The curve-authoring mode. */
+    mode?: EasingPickerMode;
+    /** The initial bezier preset key. */
+    preset?: string;
+    /** The initial step count. */
+    steps?: number;
+    /** The initial step jump term. */
+    term?: JumpTerm;
+};
+type __VLS_ModelProps = {
+    modelValue?: EasingPickerValue;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: EasingPickerValue | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: EasingPickerValue | undefined) => any) | undefined;
+}>, {
+    label: string;
+    name: string;
+    mode: EasingPickerMode;
+    steps: number;
+    preset: string;
+    term: JumpTerm;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/custom/easing/EasingPicker.vue.d.ts

@@ -0,0 +1,49 @@
+import { type EasingPickerMode, type EasingPickerValue, type JumpTerm } from "./composables/useEasingPicker";
+type __VLS_Props = {
+    /** The curve-authoring mode — `"bezier"` (draggable cubic-bezier) or
+     *  `"steps"` (the steppedEase staircase). */
+    mode?: EasingPickerMode;
+    /** The initial bezier preset key. */
+    preset?: string;
+    /** The initial step count. */
+    steps?: number;
+    /** The initial step jump term. */
+    term?: JumpTerm;
+    /** Show the copy-the-literal readout affordance (default true). */
+    readout?: boolean;
+    /** Show the playback travel-dot control (default true). */
+    playback?: boolean;
+    /** A11y label for the canvas. */
+    label?: string;
+};
+type __VLS_ModelProps = {
+    modelValue?: EasingPickerValue;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_73: {
+    value: EasingPickerValue;
+};
+type __VLS_Slots = {} & {
+    footer?: (props: typeof __VLS_73) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: EasingPickerValue | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: EasingPickerValue | undefined) => any) | undefined;
+}>, {
+    label: string;
+    mode: EasingPickerMode;
+    steps: number;
+    preset: string;
+    term: JumpTerm;
+    readout: boolean;
+    playback: 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;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};