@mkbabb/glass-ui 4.0.0 → 4.1.0

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

@@ -19,20 +19,7 @@ export declare function readInteractionConfig(canvas: HTMLCanvasElement): {
         jitter: number;
     };
 };
-/**
- * Advance the gravity-well one `dt` (AY.W-CON2). A transient held-pointer force
- * composed inside `stepField` (NO new rAF): ease `well.strength` toward
- * `well.target` (1 held / 0 released) at `cfg.ramp`/s; while active, add an
- * inverse-square pull toward the held point onto each node within `cfg.reach`
- * (the `max(d, soften)` no-singularity floor + the `cfg.maxSpeed` no-slingshot
- * clamp); ALWAYS ease every node's |v| back toward `speed` (the field-cools
- * invariant — so a released well re-settles). No-ops (entirely skipped) when
- * `field.well` is undefined → the default render is byte-identical to HEAD.
- *
- * `dt` is clamped to {@link WARP_DT_CLAMP} (the same park-resume guard the warp
- * uses) so a tab-throttle gap cannot slingshot the field in one giant step.
- */
-export declare function stepWell(field: ConstellationField, k: number, speed: number, dt: number): void;
+export { stepWell } from "./constellationWell";
 /**
  * The nearest DRIFTING node to `(px, py)` in canvas-local px — a linear O(count)
  * min-d² scan (count 64 default — negligible; matches the O(count²) edge pass).
@@ -130,3 +117,25 @@ export declare function makePinnedDrift(override?: {
  * rests at the leg's end, the next leg arming after `minIdle + rng()*jitter`.
  */
 export declare function stepPinnedDrift(field: ConstellationField, now: number, rng: () => number): void;
+/** The flick-burst threshold (the shared usePointerVelocityField `burst` 0..1) above which
+ *  a fast flick fires the focal warp + a transient ripple (a slow drag never fires). */
+export declare const BURST_FIRE_THRESHOLD = 0.45;
+/**
+ * Fire a focal BURST off a flick (the §E "reads velocity AND acceleration" mandate). A high
+ * `burst` (from the shared `usePointerVelocityField`, the eased flick impulse) warps the
+ * focal node toward the cursor (the warp spring snaps it) AND drops an expanding ripple at
+ * the focal — the lattice "snaps the focal toward the cursor and drops an expanding ring"
+ * (the WGSL ripple instance / the accent-ring overlay). A slow drag (`burst` below the
+ * threshold) never fires (a steady hover is the gentle gather, not a snap). Returns true
+ * when a burst fired. Composes the EXISTING `warpTo` + the ripple list — no new mechanic,
+ * no second rAF (the warp rides the substrate's ONE clock); PRM is enforced by the CALLER
+ * (the shared field's `tick(0)` zeroes `burst` under reduce, so this never fires).
+ */
+export declare function fireBurst(field: ConstellationField, pointer: {
+    x: number;
+    y: number;
+}, burst: number, ripples: {
+    x: number;
+    y: number;
+    start: number;
+}[]): boolean;

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

@@ -0,0 +1,25 @@
+import type { ConstellationField, ConstellationPalette } from "./constellationField";
+import { DEFAULT_PALETTE } from "./constants";
+/** R5-8 — the visual-SIZE draw scale: `max(k, kFloor)`. The instanced disc/segment
+ *  geometry sizes on this; positions/reach stay on TRUE `field.k`. Exported so a
+ *  consumer skin floors its own marks on the same axis. */
+export declare function kVisOf(field: ConstellationField): number;
+export { DEFAULT_PALETTE };
+/**
+ * Resolve the FULL neutral palette + legibility weights off a canvas's resolved custom
+ * properties (the `--constellation-*` set). The colors AND the alpha multipliers route
+ * through the same `getComputedStyle` probe, so a dark-mode flip re-resolves BOTH the
+ * `:root`/`.dark` color arms AND the per-mode alpha defaults in one read. SSR-safe
+ * (returns the warm-cream defaults with no `window`).
+ */
+export declare function readPalette(canvas: HTMLCanvasElement): ConstellationPalette;
+/**
+ * Parse a CSS color string (the `--constellation-*` hsl/hex literals the palette carries)
+ * into a linear-ish premultiplied-ready RGBA in `[0,1]` for the GPU uniform write. A small
+ * sRGB parser: it reads `#rgb`/`#rrggbb`/`#rrggbbaa`, `rgb()/rgba()`, and `hsl()/hsla()` —
+ * the forms the `--constellation-*` token authoring uses (PLAIN-hsl per arm). The shader
+ * outputs premultiplied alpha over the transparent clear, so the render loop multiplies the
+ * `a` into the uniform color at upload (kept here so there is ONE color parse seam). Falls
+ * back to opaque warm-ink on an unparseable value (never a NaN garbage write).
+ */
+export declare function parseColorRGBA(input: string): [number, number, number, number];

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

@@ -5,6 +5,35 @@ export interface ConstellationNode {
     vy: number;
     r: number;
     dim: boolean;
+    /**
+     * BC.W-VIZ-CONSTELLATION — the seeded parallax DEPTH (`z ∈ [0,1]`, §6). The pointer
+     * offsets the node's SCREEN position by `parallax · z · (pointer − center)` so the flat
+     * lattice reads as having depth (the Awwwards "living network" register). Seeded in
+     * `seedField`; perturbs the GPU node-position write only (never a layout property). A
+     * field literal that omits it is treated as `z = 0.5` (the mid-plane, no parallax bias).
+     */
+    z?: number;
+}
+/**
+ * BC.W-VIZ-CONSTELLATION — ONE edge of the proximity graph, the row the CPU all-pairs scan
+ * (`buildEdges`) writes each frame into the instanced-lines storage buffer. `a`/`b` are the
+ * two endpoint positions in canvas-local CSS px; `alpha` is the distance-falloff weight
+ * (`1 − d²/reach²`, the `drawEdges` math) the segment-quad fragment multiplies; `accent`
+ * (0/1) flags the accented-node tether (the flagged-node edge tint); `focus` (0/1) flags
+ * the pointer-web tether (the cursor's incident edges). The WGSL/GLSL render transcribes
+ * the SHAPE, never re-derives the scan (the ONE math source stays JS).
+ */
+export interface ConstellationEdge {
+    ax: number;
+    ay: number;
+    bx: number;
+    by: number;
+    /** The distance-falloff weight `1 − d²/reach²` (the drawEdges math). */
+    alpha: number;
+    /** 1 when the edge is incident on the accented node (the tether tint), else 0. */
+    accent: number;
+    /** 1 when the edge is a pointer-web tether (the cursor's incident edge), else 0. */
+    focus: number;
 }
 export interface ConstellationRipple {
     x: number;
@@ -274,6 +303,15 @@ export interface ConstellationProps {
     link?: number;
     /** Drift speed. Default 0.16. */
     speed?: number;
+    /**
+     * BC.W-VIZ-CONSTELLATION (§6) — the pointer-PARALLAX depth. Each node carries a seeded
+     * depth `z ∈ [0,1]`; the pointer offsets node screen positions by `parallax · z ·
+     * (pointer − center)` so the flat lattice reads as having depth (the Awwwards "living
+     * network" register). Additive default-on at a SUB-PERCEPTUAL 0.08 (a hair of depth, not
+     * a behavior break); 0 = the flat lattice. GPU-only (perturbs the node-position write,
+     * never a layout property). Frozen under reduced-motion / `freeze`.
+     */
+    parallax?: number;
     /**
      * AY.W-COHERE E3 — the per-instance outer-envelope RECESSION knob (the aurora
      * `opacityCeiling` / fourier `intensity` sibling — ONE recession vocabulary

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

@@ -0,0 +1,15 @@
+import type { ConstellationField } from "./constellationField";
+/**
+ * Advance the gravity-well one `dt` (AY.W-CON2). A transient held-pointer force
+ * composed inside `stepField` (NO new rAF): ease `well.strength` toward
+ * `well.target` (1 held / 0 released) at `cfg.ramp`/s; while active, add an
+ * inverse-square pull toward the held point onto each node within `cfg.reach`
+ * (the `max(d, soften)` no-singularity floor + the `cfg.maxSpeed` no-slingshot
+ * clamp); ALWAYS ease every node's |v| back toward `speed` (the field-cools
+ * invariant — so a released well re-settles). No-ops (entirely skipped) when
+ * `field.well` is undefined → the default render is byte-identical to HEAD.
+ *
+ * `dt` is clamped to {@link WELL_DT_CLAMP} (the same park-resume guard the warp
+ * uses) so a tab-throttle gap cannot slingshot the field in one giant step.
+ */
+export declare function stepWell(field: ConstellationField, k: number, speed: number, dt: number): void;

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

@@ -1,6 +1,6 @@
 export { default as Constellation } from "./Constellation.vue";
-export { seedField, stepField, refitField, BASE_WIDTH, } from "./constellationField";
-export { DEFAULT_K_FLOOR } from "./constants";
-export { stepWell, nearestNode, readInteractionConfig, warpStep, warpTo, setWarpTarget, warpSettled, pickWanderTarget, stepPinnedDrift, makePinnedDrift, DEFAULT_WELL_CONFIG, DEFAULT_WANDER_IDLE, DEFAULT_WANDER_JITTER, DEFAULT_PINNED_DRIFT_FRAC, DEFAULT_PINNED_DRIFT_DUR, DEFAULT_PINNED_DRIFT_IDLE, DEFAULT_PINNED_DRIFT_JITTER, WARP_RESPONSE, WARP_ZETA, } from "./constellationInteraction";
-export { kVisOf, readPalette, drawEdges, drawNodes, drawPointerWeb, drawRipples, DEFAULT_PALETTE, } from "./constellationDraw";
-export type { ConstellationNode, ConstellationRipple, ConstellationPointer, ConstellationPalette, ConstellationField, ConstellationWarp, ConstellationWarpConfig, ConstellationWander, ConstellationWell, ConstellationWellConfig, ConstellationPinnedDrift, ConstellationProps, } from "./constellationTypes";
+export { seedField, stepField, refitField, buildEdges, appendPointerWeb, parallaxNodePos, BASE_WIDTH, } from "./constellationField";
+export { DEFAULT_K_FLOOR, DEFAULT_PARALLAX, MAX_NODES, MAX_DEGREE, E_MAX, } from "./constants";
+export { stepWell, nearestNode, readInteractionConfig, warpStep, warpTo, setWarpTarget, warpSettled, pickWanderTarget, stepPinnedDrift, makePinnedDrift, DEFAULT_WELL_CONFIG, DEFAULT_WANDER_IDLE, DEFAULT_WANDER_JITTER, DEFAULT_PINNED_DRIFT_FRAC, DEFAULT_PINNED_DRIFT_DUR, DEFAULT_PINNED_DRIFT_IDLE, DEFAULT_PINNED_DRIFT_JITTER, WARP_RESPONSE, WARP_ZETA, fireBurst, BURST_FIRE_THRESHOLD, } from "./constellationInteraction";
+export { kVisOf, readPalette, parseColorRGBA, DEFAULT_PALETTE, } from "./constellationRender";
+export type { ConstellationNode, ConstellationEdge, ConstellationRipple, ConstellationPointer, ConstellationPalette, ConstellationField, ConstellationWarp, ConstellationWarpConfig, ConstellationWander, ConstellationWell, ConstellationWellConfig, ConstellationPinnedDrift, ConstellationProps, } from "./constellationTypes";

package/dist/components/custom/constellation/shaders/constellation-lines.glsl.d.ts

@@ -0,0 +1,2 @@
+export declare const CONSTELLATION_LINES_VERT_GLSL = "#version 300 es\nprecision highp float;\n\n// per-instance edge rows \u2014 vertexAttribDivisor(1).\nlayout(location = 0) in vec4 aAB;  // (a.x, a.y, b.x, b.y)\nlayout(location = 1) in vec4 aW;   // (alpha, accent, focus, _pad)\n\nuniform vec2 uResolution;\nuniform float uDpr;\nuniform float uKVis;\nuniform float uLineWidth;\n\nout float vLineCoord;\nout float vAlpha;\nout float vAccent;\nout float vFocus;\n\nvoid main() {\n  vec2 quad[6] = vec2[6](\n    vec2(-1.0, -1.0), vec2(1.0, -1.0), vec2(-1.0, 1.0),\n    vec2(-1.0,  1.0), vec2(1.0, -1.0), vec2(1.0,  1.0)\n  );\n  vec2 alongQuad = quad[gl_VertexID];\n\n  vec2 a = aAB.xy;\n  vec2 b = aAB.zw;\n  vec2 dir = normalize(b - a + vec2(1e-6, 0.0));\n  vec2 ortho = vec2(-dir.y, dir.x);\n  // accent tether reads a touch heavier (1.1\u00D7).\n  float halfWPx = uLineWidth * uKVis * uDpr * 0.5 * mix(1.0, 1.1, aW.y);\n  vec2 p = mix(a, b, alongQuad.x * 0.5 + 0.5) + ortho * alongQuad.y * halfWPx;\n\n  vec2 ndc = vec2(\n    p.x / max(uResolution.x, 1.0) * 2.0 - 1.0,\n    1.0 - p.y / max(uResolution.y, 1.0) * 2.0\n  );\n\n  gl_Position = vec4(ndc, 0.0, 1.0);\n  vLineCoord = alongQuad.y;\n  vAlpha = aW.x;\n  vAccent = aW.y;\n  vFocus = aW.z;\n}\n";
+export declare const CONSTELLATION_LINES_FRAG_GLSL = "#version 300 es\nprecision highp float;\n\nuniform vec4 uLine;     // premultiplied-ready rgba\nuniform vec4 uAccent;\nuniform float uAlphaGlobal;       // --constellation-alpha\nuniform float uOpacityCeiling;\nuniform float uEdgeAlpha;\nuniform float uEdgeFocusAlpha;\nuniform float uEdgeAccentAlpha;\nuniform float uEdgeFloor;\n\nin float vLineCoord;\nin float vAlpha;\nin float vAccent;\nin float vFocus;\nout vec4 fragColor;\n\nvoid main() {\n  float aaBand = 0.6;\n  float cross = 1.0 - smoothstep(1.0 - aaBand, 1.0, abs(vLineCoord));\n  if (cross <= 0.0) { discard; }\n\n  float dim = uAlphaGlobal * uOpacityCeiling;\n  vec4 col = uLine;\n  float weight = (uEdgeAlpha * vAlpha + uEdgeFloor) * dim;\n  if (vAccent > 0.5) {\n    col = uAccent;\n    weight = uEdgeAccentAlpha * vAlpha * dim;\n  } else if (vFocus > 0.5) {\n    col = uLine;\n    weight = uEdgeFocusAlpha * uAlphaGlobal * uOpacityCeiling * vAlpha;\n  }\n\n  float a = col.a * weight * cross;\n  if (a <= 0.0) { discard; }\n  fragColor = vec4(col.rgb * a, a);\n}\n";

package/dist/components/custom/constellation/shaders/constellation-lines.wgsl.d.ts

@@ -0,0 +1 @@
+export declare const CONSTELLATION_LINES_WGSL = "\nstruct Edge {\n  // vec4 0: (a.x, a.y, b.x, b.y)\n  ab: vec4<f32>,\n  // vec4 1: (alpha, accent, focus, _pad)\n  w: vec4<f32>,\n};\n\nstruct ConstellationUniforms {\n  // u0: (resolution.x, resolution.y, dpr, kVis)\n  u0: vec4<f32>,\n  // u1: (time, lineWidth, opacityCeiling, alpha)\n  u1: vec4<f32>,\n  // uEdge: (edgeAlpha, edgeFocusAlpha, edgeAccentAlpha, edgeFloor)\n  uEdge: vec4<f32>,\n  uNode: vec4<f32>,\n  uNodeDim: vec4<f32>,\n  uLine: vec4<f32>,\n  uAccent: vec4<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u: ConstellationUniforms;\n@group(0) @binding(1) var<storage, read> edges: array<Edge>;\n\nstruct VSOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) lineCoord: f32,  // [-1,1] cross-line \u2192 fragment AA\n  @location(1) alpha: f32,      // distance-falloff weight\n  @location(2) accent: f32,     // accent flag (the flagged-node tether tint)\n  @location(3) focus: f32,      // focus flag (the pointer-web tether)\n};\n\n@vertex\nfn vs_main(\n  @builtin(vertex_index) vIdx: u32,\n  @builtin(instance_index) iIdx: u32,\n) -> VSOut {\n  var QUAD = 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 alongQuad = QUAD[vIdx];\n\n  let e = edges[iIdx];\n  let a = e.ab.xy;\n  let b = e.ab.zw;\n  let res = u.u0.xy;\n  let dpr = u.u0.z;\n  let kVis = u.u0.w;\n  let lineW = u.u1.y;\n\n  // Screen-space segment direction + orthogonal (the half-width offset axis).\n  let dir = normalize(b - a + vec2<f32>(1e-6, 0.0));\n  let ortho = vec2<f32>(-dir.y, dir.x);\n  // Lerp along the segment (alongQuad.x \u2208 [-1,1] \u2192 [0,1]); offset by ortho \u00D7 half-width.\n  // The accent tether reads a touch heavier (1.1\u00D7 the neutral width).\n  let halfWPx = lineW * kVis * dpr * 0.5 * mix(1.0, 1.1, e.w.y);\n  let p = mix(a, b, alongQuad.x * 0.5 + 0.5) + ortho * (alongQuad.y) * halfWPx;\n\n  // px (y-down) \u2192 clip (y-up).\n  let ndc = vec2<f32>(\n    p.x / max(res.x, 1.0) * 2.0 - 1.0,\n    1.0 - p.y / max(res.y, 1.0) * 2.0,\n  );\n\n  var out: VSOut;\n  out.pos = vec4<f32>(ndc, 0.0, 1.0);\n  out.lineCoord = alongQuad.y;\n  out.alpha = e.w.x;\n  out.accent = e.w.y;\n  out.focus = e.w.z;\n  return out;\n}\n\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4<f32> {\n  // Cross-line AA \u2014 a smoothstep on |lineCoord| so the hairline edge is crisp.\n  let aaBand = 0.6;\n  let cross = 1.0 - smoothstep(1.0 - aaBand, 1.0, abs(in.lineCoord));\n  if (cross <= 0.0) { discard; }\n\n  let dim = u.u1.w * u.u1.z; // alpha \u00B7 opacityCeiling\n  // Resolve the edge class: accent tether \u00B7 focus pointer-web \u00B7 neutral ambient.\n  var col = u.uLine;\n  var weight = (u.uEdge.x * in.alpha + u.uEdge.w) * dim; // edgeAlpha\u00B7falloff + edgeFloor\n  if (in.accent > 0.5) {\n    col = u.uAccent;\n    weight = u.uEdge.z * in.alpha * dim; // edgeAccentAlpha\n  } else if (in.focus > 0.5) {\n    col = u.uLine;\n    weight = u.uEdge.y * u.u1.w * u.u1.z * in.alpha; // edgeFocusAlpha \u00B7 alpha \u00B7 ceiling\n  }\n\n  let a = col.a * weight * cross;\n  if (a <= 0.0) { discard; }\n  return vec4<f32>(col.rgb * a, a);\n}\n";

package/dist/components/custom/constellation/shaders/constellation-points.glsl.d.ts

@@ -0,0 +1,2 @@
+export declare const CONSTELLATION_POINTS_VERT_GLSL = "#version 300 es\nprecision highp float;\n\n// per-instance node row (x, y, radius, dim) \u2014 vertexAttribDivisor(1).\nlayout(location = 0) in vec4 aNode;\n\nuniform vec2 uResolution;\nuniform float uDpr;\nuniform float uKVis;\n\nout vec2 vUv;   // [-1,1] billboard-local \u2192 fragment SDF coord\nout float vDim;\n\nvoid main() {\n  // Two-triangle quad corners (the SAME order as the WGSL QUAD).\n  vec2 quad[6] = vec2[6](\n    vec2(-1.0, -1.0), vec2(1.0, -1.0), vec2(-1.0, 1.0),\n    vec2(-1.0,  1.0), vec2(1.0, -1.0), vec2(1.0,  1.0)\n  );\n  vec2 corner = quad[gl_VertexID];\n\n  vec2 centerPx = aNode.xy;\n  // px (y-down) \u2192 clip (y-up).\n  vec2 centerNdc = vec2(\n    centerPx.x / max(uResolution.x, 1.0) * 2.0 - 1.0,\n    1.0 - centerPx.y / max(uResolution.y, 1.0) * 2.0\n  );\n  // half-extent: radius\u00B7kVis CSS px \u2192 backing-store px (\u00B7dpr) \u2192 NDC half (\u00B72/res).\n  // (half is a GLSL reserved word \u2014 name it halfExt.)\n  float radPx = aNode.z * uKVis * uDpr;\n  vec2 halfExt = vec2(\n    radPx / max(uResolution.x, 1.0) * 2.0,\n    radPx / max(uResolution.y, 1.0) * 2.0\n  );\n\n  gl_Position = vec4(centerNdc + corner * halfExt, 0.0, 1.0);\n  vUv = corner;\n  vDim = aNode.w;\n}\n";
+export declare const CONSTELLATION_POINTS_FRAG_GLSL = "#version 300 es\nprecision highp float;\n\nuniform vec4 uNode;      // premultiplied-ready rgba\nuniform vec4 uNodeDim;\nuniform float uOpacityCeiling;\n\nin vec2 vUv;\nin float vDim;\nout vec4 fragColor;\n\nvoid main() {\n  // SDF: distance to the unit-circle edge (0 at the rim, neg inside).\n  float d = length(vUv) - 1.0;\n  // fwidth(d) \u2014 the pixel footprint, the resolution-independent AA width.\n  float aa = max(fwidth(d), 1e-4);\n  float coverage = 1.0 - smoothstep(-aa, aa, d);\n  if (coverage <= 0.0) { discard; }\n  vec4 col = mix(uNode, uNodeDim, vDim);\n  float a = col.a * coverage * uOpacityCeiling;\n  fragColor = vec4(col.rgb * a, a); // premultiplied\n}\n";

package/dist/components/custom/constellation/shaders/constellation-points.wgsl.d.ts

@@ -0,0 +1 @@
+export declare const CONSTELLATION_POINTS_WGSL = "\n// \u2500\u2500 Node storage row + uniforms (the typed-struct source-of-truth \u2014 uniformBridgeWGPU.ts) \u2500\u2500\nstruct Node {\n  // (pos.x, pos.y, radius, dim)\n  data: vec4<f32>,\n};\n\nstruct ConstellationUniforms {\n  // u0: (resolution.x, resolution.y, dpr, kVis)\n  u0: vec4<f32>,\n  // u1: (time, lineWidth, opacityCeiling, alpha)\n  u1: vec4<f32>,\n  // uEdge: (edgeAlpha, edgeFocusAlpha, edgeAccentAlpha, edgeFloor)\n  uEdge: vec4<f32>,\n  // colours (premultiplied-ready rgba)\n  uNode: vec4<f32>,\n  uNodeDim: vec4<f32>,\n  uLine: vec4<f32>,\n  uAccent: vec4<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u: ConstellationUniforms;\n@group(0) @binding(1) var<storage, read> nodes: array<Node>;\n\nstruct VSOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) uv: vec2<f32>,   // [-1,1] billboard-local \u2192 fragment SDF coord\n  @location(1) dim: f32,        // 0 = full node, 1 = dim node\n};\n\n@vertex\nfn vs_main(\n  @builtin(vertex_index) vIdx: u32,\n  @builtin(instance_index) iIdx: u32,\n) -> VSOut {\n  // Two-triangle quad corners in billboard-local space.\n  var QUAD = 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 corner = QUAD[vIdx];\n\n  let node = nodes[iIdx].data;\n  let res = u.u0.xy;\n  let dpr = u.u0.z;\n  let kVis = u.u0.w;\n\n  // center: node px \u2192 clip space (y-flip \u2014 px is y-down, clip is y-up).\n  let centerPx = node.xy;\n  let centerNdc = vec2<f32>(\n    centerPx.x / max(res.x, 1.0) * 2.0 - 1.0,\n    1.0 - centerPx.y / max(res.y, 1.0) * 2.0,\n  );\n  // half-extent: radius\u00B7kVis in CSS px \u2192 backing-store px (\u00B7dpr) \u2192 NDC half (\u00B72/res).\n  // (the DPR-aware crispness leg \u2014 the disc samples at device resolution.)\n  // (half is a WGSL reserved keyword \u2014 name it halfExt.)\n  let radPx = node.z * kVis * dpr;\n  let halfExt = vec2<f32>(radPx / max(res.x, 1.0) * 2.0, radPx / max(res.y, 1.0) * 2.0);\n\n  var out: VSOut;\n  out.pos = vec4<f32>(centerNdc + corner * halfExt, 0.0, 1.0);\n  out.uv = corner;\n  out.dim = node.w;\n  return out;\n}\n\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4<f32> {\n  // SDF: distance to the unit-circle edge in billboard-local space (0 at the rim, neg inside).\n  let d = length(in.uv) - 1.0;\n  // fwidth(d) = |dpdx(d)| + |dpdy(d)| \u2014 the pixel footprint of the SDF, the resolution-\n  // independent AA width (~1px band at ANY DPR/zoom/size).\n  let aa = max(fwidth(d), 1e-4);\n  let coverage = 1.0 - smoothstep(-aa, aa, d);\n  if (coverage <= 0.0) { discard; }\n  let col = mix(u.uNode, u.uNodeDim, in.dim);\n  let a = col.a * coverage * u.u1.z;  // \u00B7opacityCeiling\n  // premultiplied-alpha output.\n  return vec4<f32>(col.rgb * a, a);\n}\n";

package/dist/components/custom/deck/DeckPager.vue.d.ts

@@ -0,0 +1,29 @@
+type __VLS_Props = {
+    /** Total slide count. */
+    total: number;
+    /** Window to `fit` dots centered on the active dot. Off → show every dot. */
+    windowFit?: number;
+    /** Encapsulate the rail in the glass pager pill chassis. Default false —
+        a deck owns its own ambient glass host, so the dots sit FLUSH on it. */
+    ring?: boolean;
+    /** Accessible name for the rail group. */
+    ariaLabel?: string;
+};
+type __VLS_ModelProps = {
+    /** v-model:index — the active 0-based slide index. */
+    "index"?: number;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:index": (value: number) => any;
+} & {
+    select: (index: number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onSelect?: ((index: number) => any) | undefined;
+    "onUpdate:index"?: ((value: number) => any) | undefined;
+}>, {
+    ariaLabel: string;
+    ring: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/custom/deck/composables/useDeck.d.ts

@@ -0,0 +1,27 @@
+import { type ComputedRef, type Ref } from "vue";
+export interface DeckCore {
+    /** The 0-based active slide index (clamped to [0, total-1]). */
+    index: Ref<number>;
+    /** The total slide count. */
+    total: number;
+    /** 1-based completion as a percentage (slide 1 of N → 100/N), for a bar. */
+    progress: ComputedRef<number>;
+    /** The accessible "Slide N of M" announcement off the live index (§3 — the
+        portable aria-live seam; surface it in an `sr-only` polite region). */
+    liveMessage: ComputedRef<string>;
+    go: (i: number) => void;
+    next: () => void;
+    prev: () => void;
+    first: () => void;
+    last: () => void;
+}
+export interface UseDeckOptions {
+    /** The initial 0-based index (clamped). Default 0. */
+    initial?: number;
+    /** Fired AFTER a navigation commits, with the new + previous index. */
+    onChange?: (to: number, from: number) => void;
+    /** Resolve a per-slide accessible name for the live announcement (e.g. the
+        manifest title). When set, `liveMessage` reads "Slide N of M: <name>". */
+    label?: (index: number) => string;
+}
+export declare function useDeck(total: number, opts?: UseDeckOptions): DeckCore;

package/dist/components/custom/deck/composables/useDeckKeyboard.d.ts

@@ -0,0 +1,25 @@
+import { type MaybeRefOrGetter } from "vue";
+/** The minimal move surface the handler drives (a structural subset of DeckCore,
+    so the consumer can pass its `DeckCore` directly). */
+export interface DeckMoves {
+    next(): void;
+    prev(): void;
+    first(): void;
+    last(): void;
+    go(i: number): void;
+}
+export interface DeckKeyOptions {
+    /** Override the focused-control test (defaults to `target.closest(controls)`). */
+    isControl?: (target: EventTarget | null) => boolean;
+}
+/** Handle ONE keydown against the deck. Returns true if it navigated (and called
+    `preventDefault`), false if the key was left for the page/control. */
+export declare function handleDeckKey(e: KeyboardEvent, deck: DeckMoves, opts?: DeckKeyOptions): boolean;
+export interface UseDeckKeyboardOptions extends DeckKeyOptions {
+    /** The element the listener binds to. Default `window` (deck-global paging). */
+    target?: MaybeRefOrGetter<EventTarget | null | undefined>;
+}
+/** Bind the focus-guarded deck keyboard contract to a target (default `window`)
+    for the component lifetime. The `target` may be a ref/getter so a not-yet-mounted
+    element resolves at `onMounted`. */
+export declare function useDeckKeyboard(deck: DeckMoves, opts?: UseDeckKeyboardOptions): void;

package/dist/components/custom/deck/composables/useDeckSpring.d.ts

@@ -0,0 +1,22 @@
+/** The deck spring preset, re-exported from the colocated constants for consumers
+    sampling the same `(response, ζ)` row. */
+export { DECK_SPRING } from "../constants";
+/**
+ * Count-up easing. Defaults to a monotone cubic-out so a still render (or a failed
+ * engine chunk) is always faithful; replaced in-place with the engine's
+ * `springTimingFunction(.smooth)` once keyframes.js resolves. Callers read
+ * `deckEase.fn` each frame, so the swap is picked up live with no re-wiring.
+ */
+export declare const deckEase: {
+    fn: (t: number) => number;
+};
+/**
+ * Swap `deckEase.fn` to the engine's matching JS easing once keyframes.js resolves.
+ * Idempotent. No-op off-DOM (SSR / export tooling) and a silent no-op if the engine
+ * chunk fails — the count-up keeps its monotone cubic fallback.
+ *
+ * The slide transition needs no JS write: `--spring-deck: var(--spring-smooth)`
+ * (glass-ui's `.smooth` `linear()` token) resolves the declarative half at first
+ * paint.
+ */
+export declare function installDeckSpring(): void;

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

@@ -0,0 +1,14 @@
+/** SwiftUI `.smooth` — the deck's slide-transition + count-up curve: a calm settle
+    with a barely-there micro-overshoot, the right cadence for a content deck (the
+    page change reads as a settle, not a bounce). It is the SAME family the
+    `--spring-smooth` token derives from (`springLinearStops()` output), so the deck
+    inherits the constellation's iOS curve instead of forking a third easing
+    vocabulary — `--spring-deck: var(--spring-smooth)`. */
+export declare const DECK_SPRING: {
+    readonly response: 0.5;
+    readonly dampingFraction: 0.85;
+};
+/** The focused-control selector the keyboard handler tests: when a control (button
+    / link / field) is focused, Space + digit jumps reach that control's native
+    activation instead of being stolen for navigation (the C6 correctness fix). */
+export declare const CONTROL_SELECTOR = "button, a, input, textarea, select, [role=button]";

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

@@ -0,0 +1,8 @@
+export { useDeck } from "./composables/useDeck";
+export type { DeckCore, UseDeckOptions } from "./composables/useDeck";
+export { useDeckKeyboard, handleDeckKey } from "./composables/useDeckKeyboard";
+export type { DeckMoves, DeckKeyOptions, UseDeckKeyboardOptions, } from "./composables/useDeckKeyboard";
+export { installDeckSpring, deckEase, DECK_SPRING, } from "./composables/useDeckSpring";
+export { default as DeckPager } from "./DeckPager.vue";
+export { CONTROL_SELECTOR } from "./constants";
+export type { PagerWindow } from "../pager-dots/pagerWindow";

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

@@ -9,10 +9,30 @@ 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. */
     compact?: boolean;
+    /**
+     * Selected/toggled state (BC.W-DOCK-ENGINE cross-repo fold — fourier-M #10).
+     * The icon button is otherwise STATELESS (hover/press only); a consumer
+     * building a selectable dock control (a filter toggle, a mode picker) had to
+     * hand-roll the active register. Setting `active` stamps `aria-pressed` (the
+     * load-bearing AT-selectable semantic) + `data-active` (the CSS hook reading
+     * the existing `--dock-control-active-bg` "selected reads as glass" tier —
+     * NEVER a saturated brand hue, per W-REGISTER-IOS). Ergonomic sugar over the
+     * shipped register; no new token, no new paint.
+     */
+    active?: boolean;
     /** Button type attribute (default: "button" to prevent form submission). */
     type?: ButtonHTMLAttributes["type"];
     /** Host tag/component (reka-ui Primitive `as`; default "button"). */
@@ -21,15 +41,16 @@ 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";
+    active: boolean;
+    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/DockStack.vue.d.ts

@@ -0,0 +1,65 @@
+import { type Component } from "vue";
+import type { DockStackItem } from "./constants";
+/**
+ * <DockStack> — BC.W-DOCK-STACK-RAIL. The macOS Dock hover-expand STACK (the clean-break
+ * rebuild of the retired divider-carousel `DockRail`). It renders in `GlassDock`'s `#rail`
+ * slot, over the KEPT `.glass-dock-frame` non-clipping escape, so it extends BEYOND the
+ * dock edge into its own gutter WITHOUT touching the dock box (the box-INVIOLATE
+ * discipline — `deltaW = deltaH = 0`).
+ *
+ * THE STACK. A `core` anchor item (the always-visible glyph, sitting in the dock(1)) +
+ * `items: readonly DockStackItem[]` (the members). On hover (pointer-enter) OR focus of
+ * the core item, the members FAN OUT next to the rail — a column (vertical dock) / row
+ * (horizontal dock) of FULLY-VISIBLE glass icons springing open beside the line, each on
+ * the iOS liquid clock, staggered by `--dock-stack-stagger * var(--i)` in reading order.
+ * The hover-collapse reverses on the no-overshoot `--ease-out`. Every member is a clear
+ * `--glass-bg-floating` glass icon — NEVER a shadowed half-tucked chip (the "NOT shadowed"
+ * verbatim ask). At rest only the core (1) shows; expanded, the n members.
+ *
+ * 3 CONFIGURABLE, SCROLLABLE, N-STACK. `visibleCount` (default 3) members fan at rest;
+ * an >visibleCount stack routes the fanned column through `<FadingScroll>` (the one
+ * scroll-fade port) so the n-stack is reachable by scrolling the rail, NOT by overflowing
+ * the dock box.
+ *
+ * THE HOVER-HYSTERESIS (REUSED, not re-forked — AZ.W-DOCK-FLICKER). The pointer-enter
+ * commits the open only after the `HOVER_INTENT_MS` intent-dwell (the SAME constant the
+ * dock-collapse hysteresis reads), so a sweeping-edge enter does not flash the stack open.
+ * Focus opens immediately (keyboard intent is explicit); blur/leave closes.
+ *
+ * ONE REGISTRY (R2 KEPT). The members write the consumer-owned `v-model:selected`; this
+ * primitive owns NO internal `ref()`/`reactive()` shadow of the active member. The hover
+ * `expanded` is a transient UI state (optionally `v-model:expanded` controlled), NOT a
+ * selection shadow.
+ */
+type __VLS_Props = {
+    /** The stack members — the fan-out contents (NOT facet chips; the macOS stack). */
+    items: readonly DockStackItem[];
+    /** The core anchor glyph (the always-visible dock(1) item). Default: a layers glyph. */
+    core?: Component;
+    /** The core's accessible label (the stack's name). */
+    coreLabel?: string;
+    /** Members visible at rest before scrolling (the verbatim "3 configurable"). */
+    visibleCount?: number;
+    /** Which dock edge the stack anchors to. */
+    position?: "start" | "end";
+};
+type __VLS_ModelProps = {
+    "selected"?: string;
+    "expanded"?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (id: string) => any;
+    "update:selected": (value: string | undefined) => any;
+    "update:expanded": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onSelect?: ((id: string) => any) | undefined;
+    "onUpdate:selected"?: ((value: string | undefined) => any) | undefined;
+    "onUpdate:expanded"?: ((value: boolean) => any) | undefined;
+}>, {
+    position: "start" | "end";
+    visibleCount: number;
+    coreLabel: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -1,5 +1,5 @@
 import { type DockProps } from "./composables/useDockShellProps";
-declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {}, __VLS_7: {};
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {}, __VLS_7: {}, __VLS_9: {};
 type __VLS_Slots = {} & {
     persistent?: (props: typeof __VLS_1) => any;
 } & {
@@ -7,7 +7,9 @@ type __VLS_Slots = {} & {
 } & {
     collapsed?: (props: typeof __VLS_5) => any;
 } & {
-    rail?: (props: typeof __VLS_7) => any;
+    search?: (props: typeof __VLS_7) => any;
+} & {
+    rail?: (props: typeof __VLS_9) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<DockProps, {
     expanded: import("vue").Ref<boolean, boolean>;