@mkbabb/glass-ui 3.2.0 → 3.4.0

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

@@ -0,0 +1,67 @@
+/**
+ * Aurora uniform bridge — the reactive-config → GL-uniform translation seam.
+ *
+ * Owns the sealed enum↔shader-int dispatch maps and the per-config uniform upload.
+ * Each map is `as const` constrained by a `satisfies Record<Union, number>` so a
+ * NEW union member is a COMPILE error until it gets a slot — no silent stale-Record
+ * gap where a fresh enum value uploads `undefined`.
+ *
+ * Crayon is a PEER medium (`uMedium == 4`), NOT a stroke mode: the shader hoists it
+ * out of `mediumOil()` (wax-on-tooth, not oil strokes). So `MEDIUM_ID` carries the
+ * peer `crayon: 4` slot and `STROKE_MODE_ID` no longer maps `crayon` — a
+ * `strokeMode === "crayon"` config resolves to the crayon peer medium via
+ * `resolveMediumId` and uploads a benign `uStrokeMode` (oil).
+ *
+ * The pre-allocated upload buffers live in the bridge: a slider drag refills them
+ * in place rather than allocating ~8 Float32Arrays per frame.
+ */
+import type { UniformLocations } from "./glSetup";
+import type { CursorState } from "./cursorModel";
+import { type AuroraConfig } from "../constants/presets";
+export declare const MEDIUM_ID: {
+    readonly smooth: 0;
+    readonly pastel: 1;
+    readonly watercolor: 2;
+    readonly oil: 3;
+    readonly crayon: 4;
+};
+export declare const FLOW_ID: {
+    readonly none: 0;
+    readonly radial: 1;
+    readonly swirl: 2;
+    readonly diagonal: 3;
+    readonly multi: 4;
+};
+export declare const WARP_ID: {
+    readonly fbm: 0;
+    readonly cellular: 1;
+    readonly hybrid: 2;
+};
+export declare const STROKE_MODE_ID: {
+    readonly oil: 0;
+    readonly knife: 1;
+    readonly chunky: 3;
+};
+/**
+ * The effective `uMedium` int for a config. The only non-identity case: a
+ * `medium: "oil"` + `strokeMode: "crayon"` config selects the crayon PEER
+ * (`uMedium == 4`) rather than oil — behavior-preserving with the pre-hoist
+ * `mediumOil()` `mode == 2` branch (same pixel output, dispatched one level up).
+ */
+export declare function resolveMediumId(cfg: AuroraConfig): number;
+/**
+ * The `uStrokeMode` int for a config. Crayon is not an oil stroke (it routes to
+ * the crayon peer medium where `uStrokeMode` is unread), so it uploads the benign
+ * oil default; the other modes map directly.
+ */
+export declare function resolveStrokeModeId(cfg: AuroraConfig): number;
+/**
+ * Build the per-config uniform uploader bound to a program's uniform location
+ * cache + cursor state. Returns `uploadConfig` — call it to push a fresh
+ * `AuroraConfig` into the live program. The cursor uniforms are initialised here
+ * and re-sent per frame by the frame loop.
+ *
+ * Y-origin: config authoring is CSS-top-origin (0 = top); the bridge flips Y at
+ * the uniform boundary (`flipY`).
+ */
+export declare function createUniformBridge(gl: WebGL2RenderingContext, prog: WebGLProgram, U: UniformLocations, cursor: CursorState): (cfg: AuroraConfig) => void;

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

@@ -1,7 +1,7 @@
 import { type Ref } from "vue";
 import { type AuroraRuntimeOptions } from "./runtime";
 import { type ConfigSource } from "./configSource";
-import type { AuroraConfig } from "../presets";
+import type { AuroraConfig } from "../constants/presets";
 /**
  * Adaptive-substrate options threaded down from `Aurora.vue` (AM.W1). The
  * render mode is the RESOLVED concrete substrate (`"auto"` already collapsed
@@ -63,5 +63,18 @@ export interface UseAuroraReturn {
  * placeholder under the canvas so the consumer's first paint is never blocked
  * on the shader. Capture / `initStrategy: "eager"` consumers arm synchronously
  * inside `createAurora` and skip the defer entirely.
+ *
+ * Init-failure contract (O invariant 24 — "fails explicitly by default"). A
+ * WebGL2/shader-compile/link failure is a library-internal contract violation.
+ * On the DEFERRED path the failure lands on an idle tick, OUTSIDE any
+ * mount-time error boundary, so the consumer MUST handle it through exactly one
+ * of three paths:
+ *   1. pass an `onInitError(err)` handler in `runtimeOptions` (the explicit
+ *      opt-in — receives the error directly), OR
+ *   2. install a Vue global `app.config.errorHandler` (the re-surfaced
+ *      microtask rejection reaches it), OR
+ *   3. knowingly accept the unhandled rejection (the dev console still gets it).
+ * Armed deferred with NO `onInitError`, `useAurora` dev-warns ONCE so the
+ * silent-by-omission case is visible. WebGL2-unavailable still throws HARD.
  */
 export declare function useAurora(canvasRef: Ref<HTMLCanvasElement | null>, configSource: ConfigSource<AuroraConfig>, runtimeOptions?: AuroraRuntimeOptions, adaptiveOptions?: UseAuroraAdaptiveOptions): UseAuroraReturn;

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

@@ -1,6 +1,6 @@
 import { type Ref } from "vue";
 import { type ConfigSource } from "./configSource";
-import type { AuroraConfig } from "../presets";
+import type { AuroraConfig } from "../constants/presets";
 export interface CursorInteractionOptions {
     /** Fires `setCursor(x,y,strength)` for continuous swirl. */
     setCursor: (x: number, y: number, strength?: number) => void;

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

@@ -0,0 +1,50 @@
+/**
+ * AV.W7 F6 — the WebGL-surface perf BUDGET constants (the named ceilings).
+ *
+ * Promotes the formerly-magic `Math.min(dpr, 2)` literal that lived inline in
+ * the aurora + goo-blob `resize()` paths (the `2` was un-named in both) to ONE
+ * named ceiling, and adds the consumer-preset budget caps the SOTA crosswalk
+ * §2.F F6 calls for. A preset that exceeds a cap is CLAMPED at upload, so a
+ * consumer cannot blow the frame/VRAM budget by over-authoring a config.
+ *
+ * Token-first (the wave precept): these are the CPU-side numeric ceilings.
+ * They are NOT magic numbers scattered across runtimes — every WebGL surface
+ * reads the same export, so a tuning change lands in one place.
+ */
+/**
+ * The device-pixel-ratio clamp. A retina/4K display reports `devicePixelRatio`
+ * 2–3+; rendering a full-viewport `backdrop-filter`-adjacent WebGL surface at
+ * 3× is ~2.25× the fill of 2× for no perceptible gain on a drift background.
+ * Cap the backing-store resolution at 2× — the single biggest VRAM/fill lever
+ * after the offscreen-park. Consumed by aurora's + goo-blob's `resize()`.
+ */
+export declare const AV_DPR_MAX = 2;
+/**
+ * The maximum animated metaball nuclei (the goo-blob body + its satellites, or
+ * an aurora field's count). The goo-blob shader hard-caps satellites at 4; this
+ * is the authored-config soft cap (body + ≤2 satellites is the budget-safe
+ * register, ≤3 the ceiling). A preset above this is clamped at upload.
+ */
+export declare const AV_MAX_BLOBS = 3;
+/**
+ * The maximum palette colors a budget-safe field mixes per frame. Aurora's
+ * shader caps palette stops at {@link MAX_STOPS} (8) for authoring range; this
+ * is the PERF budget — 3–4 colors is the band where the per-pixel mix stays
+ * cheap. Above this the gradient cost grows without perceptible richness.
+ */
+export declare const AV_MAX_COLORS = 4;
+/**
+ * The drift-loop duration band, in seconds. An animation that loops faster than
+ * {@link AV_LOOP_DURATION_MIN_S} reads as nervous (and never lets the eye rest →
+ * no battery reprieve); slower than {@link AV_LOOP_DURATION_MAX_S} reads as
+ * static. The 8–15s band is the SOTA-named budget-safe drift window.
+ */
+export declare const AV_LOOP_DURATION_MIN_S = 8;
+export declare const AV_LOOP_DURATION_MAX_S = 15;
+/** Clamp a numeric value into an inclusive `[min, max]` band. */
+export declare function clampBudget(value: number, min: number, max: number): number;
+/**
+ * Resolve the budget-clamped backing-store DPR for a surface. SSR-safe (returns
+ * `1` when `window` is absent). The single CPU-side reader of {@link AV_DPR_MAX}.
+ */
+export declare function resolveBudgetDpr(): number;

package/dist/components/custom/aurora/{presets.d.ts → constants/presets.d.ts}

@@ -10,11 +10,8 @@
  * shape + a minimum-viable DEFAULT_AURORA_CONFIG for the component's own
  * type-check ergonomics.
  */
-export interface OklchStop {
-    L: number;
-    C: number;
-    h: number;
-}
+import type { OklchStop } from "../../../../composables/color";
+export type { OklchStop };
 export interface AuroraNucleus {
     /** 0..1 in CSS-top-origin space (0 = top, 1 = bottom). Runtime flips Y. */
     x: number;

package/dist/components/custom/aurora/constants/shaders/aurora.frag.d.ts

@@ -0,0 +1 @@
+export declare const FRAGMENT_SRC: string;

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

@@ -0,0 +1 @@
+export declare const AURORA_BRUSH_GLSL = "// \u2500\u2500 Curved swept brushstroke primitive \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// A stroke is a curved spine from A to B with quadratic bulge K (sideways offset\n// at midpoint). Width varies along length via a shape profile. Edge is ragged\n// (bristle-modulated), ends are rounded blobs, inside has streak modulation.\n//\n// For pixel p, we invert an approximate projection onto the curved spine:\n//   1) project p onto straight AB axis -> along0, cross0\n//   2) at parameter along0, spine offset = 4\u00B7K\u00B7along0\u00B7(1-along0) perpendicular\n//   3) cross = cross0 - spineOffset, refine along one iteration\n// Coverage blends paint atop col based on per-stroke color sampled from the\n// underlying base at spine midpoint \u2014 so overlapping strokes from different\n// palette regions meet at hard, ragged demarcations.\n\nstruct StrokeHit {\n  float coverage;  // 0..1\n  vec3  color;\n  float alongT;    // 0..1 along spine, for internal modulation\n  float crossN;    // cross distance / current half-width, signed\n  float edgeN;     // distance to edge in half-widths (0 = at edge, 1 = at spine)\n};\n\nStrokeHit noHit() { return StrokeHit(0.0, vec3(0.0), 0.0, 0.0, 0.0); }\n\nvec2 rotateDir(vec2 dir, float angle) {\n  float ca = cos(angle), sa = sin(angle);\n  return vec2(dir.x * ca - dir.y * sa, dir.x * sa + dir.y * ca);\n}\n\nvec2 safeDir(vec2 dir) {\n  float len = length(dir);\n  return len > 1e-4 ? dir / len : vec2(1.0, 0.0);\n}\n\n// Shape profile along the stroke. type:\n//   0 tapered    \u2014 thin-fat-thin (classic brush)\n//   1 load-drag  \u2014 fat start, tapers to a point\n//   2 dab        \u2014 ellipse-like, round center\n//   3 even       \u2014 near-constant, slight end taper\nfloat strokeShape(float t, int type) {\n  t = clamp(t, 0.0, 1.0);\n  if (type == 1) {\n    // loaded at t=0, tapering\n    return pow(1.0 - t, 0.55) * smoothstep(0.0, 0.08, t);\n  } else if (type == 2) {\n    // dab / blob\n    float d = t - 0.5;\n    return exp(-d * d * 12.0);\n  } else if (type == 3) {\n    // mostly even, slight end softening\n    return smoothstep(0.0, 0.08, t) * smoothstep(1.0, 0.92, t) * 0.95 + 0.05;\n  }\n  // 0 tapered\n  return smoothstep(0.0, 0.22, t) * smoothstep(1.0, 0.78, t);\n}\n\n// A single curved stroke.\n//   a, b           \u2014 endpoints\n//   halfW          \u2014 base half-width (world units)\n//   bulge          \u2014 signed perpendicular midpoint offset, in world units\n//   shapeType      \u2014 0..3\n//   bristleFreq    \u2014 spatial frequency of edge raggedness\n//   bristleAmp     \u2014 0..0.5 fraction of halfW chewed away at edge extrema\n//   streakSeed     \u2014 uniqueness seed for internal streaks\n//   colAtMid       \u2014 pre-sampled color at midpoint\nStrokeHit curvedStroke(vec2 p, vec2 a, vec2 b, float halfW,\n                       float bulge, int shapeType,\n                       float bristleFreq, float bristleAmp,\n                       float streakSeed, vec3 colAtMid) {\n  vec2 ab = b - a;\n  float L = length(ab);\n  if (L < 1e-5) return noHit();\n  vec2 tang = ab / L;\n  vec2 norm = vec2(-tang.y, tang.x);\n\n  vec2 rel = p - a;\n  float along0 = dot(rel, tang) / L;      // straight projection 0..1 along AB\n  float cross0 = dot(rel, norm);          // signed cross\n\n  // Spine sideways offset due to bulge (parabolic)\n  float bend = 4.0 * bulge * along0 * (1.0 - along0);\n  float cross1 = cross0 - bend;\n\n  // One refinement step: as the spine bends, the closest-point along shifts.\n  // Spine tangent differs from straight tangent; first-order correction:\n  float dBend = 4.0 * bulge * (1.0 - 2.0 * along0);  // d(bend)/d(along)\n  float along1 = along0 + (cross1 * dBend) / (L * (1.0 + dBend * dBend / (L * L)));\n\n  // Bristle-ragged edge: half-width gets chewed by 1D noise along the spine\n  float edgeNoise = fbm(vec2(along1 * bristleFreq, streakSeed * 7.3)) - 0.5;\n  float edgeNoise2 = fbm(vec2(along1 * bristleFreq * 2.3, streakSeed * 3.1 + 17.0)) - 0.5;\n  float edgeMod = 1.0 - bristleAmp * (0.6 + 0.4 * edgeNoise) * (0.5 + edgeNoise2);\n\n  // Width profile along the stroke\n  float shape = strokeShape(along1, shapeType);\n  float halfWNow = halfW * shape * edgeMod;\n\n  // Inside-segment coverage\n  float cov = 0.0;\n  if (along1 >= 0.0 && along1 <= 1.0 && halfWNow > 1e-6) {\n    float cn = abs(cross1) / halfWNow;\n    // fwidth-derived AA: half-width from the field's screen-space gradient so the\n    // edge holds ~1px regardless of zoom/DPR (mirrors metaball.frag.ts:252-255).\n    float aaC = max(fwidth(cn), 1e-6);\n    cov = 1.0 - smoothstep(1.0 - aaC, 1.0 + aaC, cn);\n  }\n\n  // End-cap blobs (rounded tips, not perpendicular cuts)\n  float capA = 0.0, capB = 0.0;\n  {\n    vec2 capCenterA = a + norm * (bulge * 0.0); // at a\n    vec2 capCenterB = a + tang * L + norm * bend * 0.0 + norm * 0.0; // at b; bend is 0 at endpoints\n    capCenterB = b;\n    float endShapeA = strokeShape(0.02, shapeType);\n    float endShapeB = strokeShape(0.98, shapeType);\n    float rA = halfW * endShapeA * (0.9 + 0.2 * fbm(vec2(streakSeed * 13.0)));\n    float rB = halfW * endShapeB * (0.9 + 0.2 * fbm(vec2(streakSeed * 19.0 + 5.0)));\n    float dA = length(p - capCenterA);\n    float dB = length(p - capCenterB);\n    // fwidth-derived AA on the clean Euclidean cap distances (mirrors metaball.frag.ts:252-255).\n    float aaA = max(fwidth(dA), 1e-6);\n    float aaB = max(fwidth(dB), 1e-6);\n    capA = 1.0 - smoothstep(rA - aaA, rA + aaA, dA);\n    capB = 1.0 - smoothstep(rB - aaB, rB + aaB, dB);\n    // Only apply caps if we're BEYOND the segment; otherwise the segment wins.\n    capA *= (along1 < 0.05) ? 1.0 : 0.0;\n    capB *= (along1 > 0.95) ? 1.0 : 0.0;\n  }\n\n  float coverage = max(cov, max(capA, capB));\n  if (coverage < 0.002) return noHit();\n\n  // Edge distance (for impasto later): 0 at edge, 1 at spine\n  float edgeDist = halfWNow > 1e-6 ? clamp(1.0 - abs(cross1) / halfWNow, 0.0, 1.0) : 0.0;\n\n  return StrokeHit(\n    coverage,\n    colAtMid,\n    clamp(along1, 0.0, 1.0),\n    halfWNow > 1e-6 ? cross1 / halfWNow : 0.0,\n    edgeDist\n  );\n}\n\n// Composite stroke over col with internal streaking + impasto edge highlight.\n//   streakAmp    \u2014 0..0.2 how much internal streaks darken/lighten\n//   impastoAmp   \u2014 0..1 edge catch-light strength\n//   hardness     \u2014 0..1 how crisp the compositing transition is (1 = razor, 0 = creamy)\nvoid paintOver(inout vec3 col, StrokeHit s, float streakFreq, float streakAmp,\n               float impastoAmp, float hardness, float streakSeed) {\n  if (s.coverage < 0.002) return;\n  float strokeOpacity = clamp(uStrokeAmount, 0.0, 1.0);\n  if (strokeOpacity <= 0.001) return;\n  vec3 c = s.color;\n\n  // Internal streaks \u2014 fbm along spine, modulated by cross position. Gives\n  // the loaded-brush look: some bristles carry more pigment than others.\n  float streakA = fbm(vec2(s.alongT * streakFreq, s.crossN * 2.7 + streakSeed));\n  float streakB = fbm(vec2(s.alongT * streakFreq * 0.6 + streakSeed * 3.7, s.crossN * 4.1));\n  float streak = 0.6 * (streakA - 0.5) + 0.4 * (streakB - 0.5);\n  c *= 1.0 + streak * streakAmp * 2.0;\n\n  // Subtle value variance across width (hollow-center catch-light)\n  float crossShade = smoothstep(0.0, 0.4, s.edgeN) * (1.0 - smoothstep(0.65, 1.0, s.edgeN));\n  c *= 1.0 + crossShade * 0.05;\n\n  // Impasto edge highlight \u2014 bright rim on one side of the stroke\n  float rim = smoothstep(0.85, 1.0, 1.0 - s.edgeN) * step(0.0, s.crossN);\n  c += impastoAmp * rim * vec3(0.18, 0.15, 0.11);\n  // Shadow on the other side (darker, cooler)\n  float shadow = smoothstep(0.85, 1.0, 1.0 - s.edgeN) * step(0.0, -s.crossN);\n  c -= impastoAmp * shadow * 0.25 * vec3(0.10, 0.09, 0.07);\n\n  float softLimit = mix(0.35, 0.98, hardness);\n  float alpha = smoothstep(0.0, 1.0 - softLimit, s.coverage) * strokeOpacity;\n  col = mix(col, c, alpha);\n}\n\n// Best-of-9-neighbor placement: sample 3x3 surrounding cells and take the\n// stroke that covers this pixel most. Breaks the grid by per-cell jitter and\n// sparse density via noise thresholding.\nStrokeHit bestOil(vec2 p, float cellSize, float lenMul, float halfWMul,\n                  float jitterAmt, float density, int shapeType,\n                  float bristleAmp, vec2 flow, float t, float seed) {\n  vec2 cell = floor(p / cellSize);\n\n  StrokeHit best = noHit();\n  // 3x3 neighborhood\n  for (int dy = -1; dy <= 1; dy++) {\n    for (int dx = -1; dx <= 1; dx++) {\n      vec2 cc = cell + vec2(float(dx), float(dy));\n      vec2 hh = hash22(cc + seed) - 0.5;\n      // Density gate \u2014 noise threshold; sparse placement.\n      float gate = hash21(cc * 1.7 + seed * 0.3);\n      if (gate > density) continue;\n\n      vec2 center = (cc + 0.5 + hh * jitterAmt) * cellSize;\n\n      // Per-stroke direction: consume the layer-provided flow, then add only\n      // deterministic local perturbation so alternate stroke layers stay live.\n      vec2 f = safeDir(flow);\n      float angJ = (hash21(cc + seed + 11.0) - 0.5) * 0.9;  // +/- 0.45 rad\n      float localCurl = (fbm(center * (2.6 + seed * 0.11) + seed * 1.9) - 0.5) * 0.55 * uFlowCurl;\n      vec2 dir = rotateDir(f, angJ + localCurl);\n\n      float lenV = cellSize * lenMul * (0.65 + 0.55 * hash21(cc + seed + 23.0));\n      float halfW = cellSize * halfWMul * (0.70 + 0.55 * hash21(cc + seed + 41.0));\n      float bulge = (hash21(cc + seed + 53.0) - 0.5) * lenV * 0.35;\n\n      vec2 a = center - dir * (lenV * 0.5);\n      vec2 b = center + dir * (lenV * 0.5);\n\n      vec3 colMid = brokenColorJitter(\n        sampleBase(center, t),\n        hash21(cc + seed + 89.0),\n        hash21(cc * 2.3 + seed + 97.0),\n        1.0\n      );\n\n      StrokeHit h = curvedStroke(p, a, b, halfW, bulge, shapeType,\n                                 7.0, bristleAmp,\n                                 hash21(cc + seed + 67.0), colMid);\n      if (h.coverage > best.coverage) best = h;\n    }\n  }\n  return best;\n}\n";

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

@@ -0,0 +1 @@
+export declare const AURORA_COMPOSITION_GLSL = "// \u2500\u2500 Palette LUT \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nvec3 samplePalette(float id) {\n  id = clamp(id, 0.0, 1.0);\n  float scaled = id * float(uStopCount - 1);\n  int i0 = int(floor(scaled));\n  int i1 = min(i0 + 1, uStopCount - 1);\n  float t = fract(scaled);\n  t = smoothstep(0.0, 1.0, t);\n  return mix(uPalette[i0], uPalette[i1], t);\n}\n\n// \u2500\u2500 Nuclei field \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nvoid nucleiField(vec2 p, float t, out float paletteId, out float valueMod) {\n  float accumBias  = 0.0;\n  float accumValue = 0.0;\n  float accumW     = 0.0;\n  for (int i = 0; i < MAX_NUCLEI; i++) {\n    if (i >= uNucleiCount) break;\n    vec2 posI = uNucleiPos[i]\n              + uNucleiDriftRadius[i] * vec2(\n                  cos(t * uNucleiDrift * K_NUCLEI + uNucleiDriftPhase[i]),\n                  sin(t * uNucleiDrift * K_NUCLEI + uNucleiDriftPhase[i] * 1.13)\n                );\n    vec2 diff = p - posI;\n    // Anisotropic Gaussian: rotate diff into the nucleus's local frame\n    // (major axis along uNucleiAngle), then scale the major-axis component by\n    // 1/elongation so the squared distance describes an ellipse. Defaults\n    // 1.0/0.0 reduce to the isotropic dot(diff, diff).\n    float ca = cos(uNucleiAngle[i]);\n    float sa = sin(uNucleiAngle[i]);\n    vec2  local = vec2( ca * diff.x + sa * diff.y,\n                       -sa * diff.x + ca * diff.y);\n    float along  = local.x / max(uNucleiElong[i], 0.01);\n    float across = local.y;\n    float d2 = along * along + across * across;\n    float r = max(uNucleiRadius[i], 0.01);\n    float w = exp(-uSoftmaxBeta * d2 / (r * r));\n    accumBias  += w * uNucleiPaletteBias[i];\n    accumValue += w * uNucleiValueBias[i];\n    accumW     += w;\n  }\n  paletteId = accumBias  / max(accumW, 1e-4);\n  valueMod  = accumValue / max(accumW, 1e-4);\n\n  // Palette drift \u2014 slow global paletteId breathe between adjacent stops. The\n  // rate rides K_PAL (perceptible ~30\u201360s hue cycle at the default coefficient);\n  // the amplitude lifts the authored coefficient into a 0.03..0.06 paletteId band\n  // so the palette visibly travels rather than dithering within one stop.\n  float palAmp = clamp(uPaletteDrift * 6.0, 0.0, 0.06);\n  paletteId += palAmp * sin(t * uPaletteDrift * K_PAL);\n  paletteId = clamp(paletteId, 0.0, 1.0);\n}\n";

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

@@ -0,0 +1 @@
+export declare const AURORA_FLOW_GLSL = "// \u2500\u2500 Flow field \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nvec2 flowField(vec2 p, float t) {\n  vec2 dir = vec2(1.0, 0.0);\n  if (uFlowPattern == 1) {\n    // radial\n    dir = normalize(p - uFlowFocal + 1e-4);\n  } else if (uFlowPattern == 2) {\n    // swirl \u2014 tangent to radial\n    vec2 rad = normalize(p - uFlowFocal + 1e-4);\n    dir = vec2(-rad.y, rad.x);\n  } else if (uFlowPattern == 3) {\n    // diagonal\n    float a = radians(uFlowAngle);\n    dir = vec2(cos(a), sin(a));\n  } else if (uFlowPattern == 4) {\n    // multi \u2014 curl-noise driven\n    float n = fbm(p * 2.0 + t * 0.02);\n    float a = n * 6.2831;\n    dir = vec2(cos(a), sin(a));\n  }\n  // curl \u2014 perturb by noise. Radial gets much less curl so rays stay clean.\n  if (uFlowCurl > 0.0) {\n    float n = fbm(p * 3.0) - 0.5;\n    float curlAmt = uFlowCurl;\n    if (uFlowPattern == 1) curlAmt *= 0.25;  // radial: preserve ray clarity\n    if (uFlowPattern == 2) curlAmt *= 0.55;  // swirl: allow moderate curl\n    float a = atan(dir.y, dir.x) + n * 3.14159 * curlAmt;\n    dir = vec2(cos(a), sin(a));\n  }\n  // cursor influence \u2014 swirl around the cursor position\n  if (uCursorStrength > 0.001) {\n    vec2 toCur = uCursor - p;\n    float d = length(toCur);\n    float r = max(uCursorRadius, 0.01);\n    float w = exp(-(d * d) / (r * r * 0.5));\n    // swirl tangent\n    vec2 tangent = vec2(-toCur.y, toCur.x) / max(d, 1e-4);\n    float a0 = atan(dir.y, dir.x);\n    float a1 = atan(tangent.y, tangent.x);\n    // blend angle\n    float da = a1 - a0;\n    da = atan(sin(da), cos(da)); // wrap to [-pi, pi]\n    float a = a0 + da * w * uCursorStrength;\n    dir = vec2(cos(a), sin(a));\n  }\n  return dir;\n}\n";

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

@@ -0,0 +1,2 @@
+export declare const AURORA_MEDIUMS_PRE_BRUSH_GLSL = "// \u2500\u2500 Medium overlays \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n// A quick re-computation of base color for edge-mask sampling\nvec3 sampleBase(vec2 p, float t) {\n  vec2 pw = domainWarp(p, t);\n  float id; float vm;\n  nucleiField(pw, t, id, vm);\n  vec3 c = samplePalette(id);\n  c *= 1.0 + uValueVariance * vm;\n  return c;\n}\n\nvec3 mediumWatercolor(vec3 col, vec2 p, float t) {\n  // Wet-edge cauliflowers via luma-gradient magnitude\n  float eps = 0.004;\n  vec3 cx1 = sampleBase(p + vec2(eps, 0.0), t);\n  vec3 cx2 = sampleBase(p - vec2(eps, 0.0), t);\n  vec3 cy1 = sampleBase(p + vec2(0.0, eps), t);\n  vec3 cy2 = sampleBase(p - vec2(0.0, eps), t);\n  float gx = dot(cx1 - cx2, W_LUMA);\n  float gy = dot(cy1 - cy2, W_LUMA);\n  float edge = sqrt(gx * gx + gy * gy) / (2.0 * eps);\n  float mask = smoothstep(0.0, 2.5, edge);\n  col *= mix(1.0, 0.78, mask * uWetEdge);\n\n  // Granulation \u2014 pigment settles in paper tooth\n  float paper = 0.5 * vnoise(p * 160.0) + 0.5 * vnoise(p * 360.0);\n  float pigLoad = 1.0 - dot(col, W_LUMA);\n  col *= 1.0 - uGranulation * pigLoad * (paper - 0.5);\n\n  // Wash banding \u2014 faint horizontal wet gradient\n  float band = fbm(vec2(p.x * 1.5, p.y * 0.4));\n  col *= 1.0 + 0.04 * (band - 0.5);\n  return col;\n}\n\nvec3 mediumPastel(vec3 col, vec2 p, float t) {\n  vec2 flow = flowField(p, t);\n  vec2 perp = vec2(-flow.y, flow.x);\n  float along  = dot(p, flow) * uStrokeScale;\n  float across = dot(p, perp) * uStrokeScale;\n  across += 0.03 * (vnoise(p * 260.0) - 0.5);\n\n  float aniso = mix(1.0, 0.18, uStrokeAnisotropy);\n  float stroke = fbm(vec2(along * aniso, across));\n  col *= mix(1.0, 0.82 + 0.32 * stroke, uStrokeAmount);\n\n  // Pastel tooth \u2014 tiny high-frequency grain\n  float tooth = vnoise(p * 800.0);\n  col *= 1.0 - 0.08 * uStrokeAmount * (tooth - 0.5);\n  return col;\n}\n";
+export declare const AURORA_MEDIUMS_POST_BRUSH_GLSL = "// \u2500\u2500 Crayon / oil-pastel \u2014 paper tooth \u00D7 wax pigment (PEER medium) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// Crayon is not strokes. It's pigment crumbs dragged across paper tooth.\n// Model: heavy 2D tooth noise at multiple scales, anisotropically stretched\n// along flow direction, multiplied into the base color. Add a slow \"waxy\n// film\" that slightly unifies hues, and occasional darker \"pressed\" spots\n// where the crayon dug in. NO straight segments. Dispatched at main() level as\n// a peer of pastel/watercolor/oil \u2014 never a branch inside mediumOil().\nvec3 mediumCrayon(vec3 col, vec2 p, float t) {\n  vec2 flow = flowField(p, t);\n  float ang = atan(flow.y, flow.x);\n  float ca = cos(-ang), sa = sin(-ang);\n  vec2 pr = vec2(p.x * ca - p.y * sa, p.x * sa + p.y * ca);\n\n  // Anisotropic tooth \u2014 squished along flow, coarse cross flow.\n  float aniso = mix(0.45, 0.95, uStrokeAnisotropy);\n  float scale = max(uStrokeScale * 1.6, 180.0);\n\n  float t1 = vnoise(vec2(pr.x * scale * aniso, pr.y * scale));\n  float t2 = vnoise(vec2(pr.x * scale * aniso * 0.4, pr.y * scale * 0.4) + 11.0);\n  float t3 = vnoise(vec2(pr.x * scale * aniso * 2.1, pr.y * scale * 2.1) + 23.0);\n  float tooth = 0.55 * t1 + 0.30 * t2 + 0.15 * t3;\n  // Center at 0, amplify\n  tooth = (tooth - 0.5) * 1.4;\n\n  // Multiplicative darkening where tooth is low (pigment skipped paper valleys)\n  float lay = 1.0 + tooth * 0.32 * uStrokeAmount;\n  vec3 result = col * lay;\n\n  // Occasional pressed-in crumbs \u2014 rare darker crumbs\n  float crumbs = smoothstep(0.78, 0.95, vnoise(pr * scale * 3.0));\n  result *= 1.0 - crumbs * 0.18 * uStrokeAmount;\n\n  // Waxy highlight film \u2014 slight lightening on tooth peaks\n  float waxy = smoothstep(0.55, 0.85, t1);\n  result += waxy * 0.04 * vec3(1.0);\n\n  // Paper tooth overlay (subtler than oil's canvas)\n  float paperTooth = vnoise(p * 340.0) - 0.5;\n  result *= 1.0 + paperTooth * 0.14 * uCanvasGrain;\n\n  // Broken-color pigment: stable wax/pigment patches, not temporal flicker.\n  vec2 pigmentCell = floor(pr * max(scale * 0.18, 32.0));\n  float pigmentMask = smoothstep(0.28, 0.82, vnoise(pr * scale * 0.21 + 19.0));\n  result = brokenColorJitter(\n    result,\n    hash21(pigmentCell + 17.0),\n    hash21(pigmentCell * 2.1 + 31.0),\n    0.45 + 0.55 * pigmentMask\n  );\n\n  // Crayon is saturation-amplified\n  result = saturate3(result, 1.12);\n\n  return result;\n}\n\nvec3 mediumOil(vec3 col, vec2 p, float t) {\n  // Mode knobs (uStrokeMode) \u2014 oil-stroke modes ONLY (crayon is a peer medium,\n  // uMedium==4, dispatched at main()):\n  //   0 oil         \u2014 balanced modern-abstract/palette-knife hybrid\n  //   1 knife       \u2014 palette-knife impasto: razor edges, heavy bristle/shadow\n  //   3 brushwork   \u2014 thick bristle brush\n  int mode = uStrokeMode;\n\n  // Per-mode parameters\n  int  shapeType   = 0;     // tapered\n  float bristleAmp = 0.25;  // 0..0.5\n  float streakFreq = 9.0;\n  float streakAmp  = 0.09;\n  float impastoAmp = 0.9;\n  float hardness   = 0.80;  // edge compositing\n  float toothScale = 240.0;\n  float toothAmp   = 0.09;\n  float pigmentSat = 1.03;\n  float densityBig = 0.65;\n  float densityMed = 0.78;\n  float densitySml = 0.90;\n\n  if (mode == 1) {        // palette knife\n    shapeType = 3;        // flat, even\n    bristleAmp = 0.12;\n    streakFreq = 4.0;  streakAmp = 0.05;\n    impastoAmp = 1.6;\n    hardness   = 0.95;\n    toothAmp   = 0.04;\n    densityBig = 0.80; densityMed = 0.88; densitySml = 0.70;\n  } else if (mode == 3) { // thick brushwork\n    shapeType = 0;        // tapered\n    bristleAmp = 0.32;\n    streakFreq = 14.0; streakAmp = 0.14;\n    impastoAmp = 1.2;\n    hardness   = 0.85;\n    toothAmp   = 0.07;\n  }\n\n  // Scales & multipliers from uniforms\n  float baseScale = max(uStrokeScale * 0.006, 0.008);\n  // Three layers: big gestural, medium body, small dabs\n  float sBig = baseScale * 2.4;\n  float sMed = baseScale * 1.1;\n  float sSml = baseScale * 0.45;\n\n  float lenMulBig = mix(2.2, 3.8, uStrokeAnisotropy);\n  float widMulBig = mix(0.55, 0.32, uStrokeAnisotropy);\n  float lenMulMed = mix(2.0, 3.4, uStrokeAnisotropy);\n  float widMulMed = mix(0.50, 0.30, uStrokeAnisotropy);\n  float lenMulSml = mix(1.6, 2.6, uStrokeAnisotropy);\n  float widMulSml = mix(0.45, 0.32, uStrokeAnisotropy);\n\n  float jitterAmt = 0.75;   // large jitter \u2014 no grid\n  vec2 flow = flowField(p, t);\n\n  vec3 result = col;\n\n  // Layer 1 \u2014 big gestural strokes (sparse, shaping)\n  StrokeHit hBig = bestOil(p, sBig, lenMulBig, widMulBig, jitterAmt * 0.55,\n                           densityBig, shapeType, bristleAmp, flow, t, 1.3);\n  paintOver(result, hBig, streakFreq * 0.7, streakAmp,\n            uImpasto * impastoAmp * uStrokeAmount, hardness, 1.3);\n\n  // Layer 2 \u2014 medium body strokes\n  StrokeHit hMed = bestOil(p + vec2(11.3, 3.7), sMed, lenMulMed, widMulMed,\n                           jitterAmt, densityMed, shapeType, bristleAmp, flow, t, 2.7);\n  paintOver(result, hMed, streakFreq, streakAmp,\n            uImpasto * impastoAmp * uStrokeAmount, hardness, 2.7);\n\n  // Layer 3 \u2014 small dabs (more frequent, smaller)\n  int smlShape = (mode == 1) ? 2 : shapeType; // knife uses dabs for sparkle\n  StrokeHit hSml = bestOil(p + vec2(-5.1, 8.4), sSml, lenMulSml, widMulSml,\n                           jitterAmt * 1.3, densitySml, smlShape,\n                           bristleAmp * 0.85, flow, t, 4.1);\n  paintOver(result, hSml, streakFreq * 1.4, streakAmp * 0.8,\n            uImpasto * impastoAmp * 0.65 * uStrokeAmount, hardness, 4.1);\n\n  // Layer 4 \u2014 fill dabs (very dense, very small) \u2014 covers bald spots\n  float sFill = baseScale * 0.22;\n  float lenMulFill = mix(1.4, 2.0, uStrokeAnisotropy);\n  float widMulFill = mix(0.50, 0.38, uStrokeAnisotropy);\n  int fillShape = (mode == 1) ? 3 : 2; // knife=even, others=dab (round fills)\n  StrokeHit hFill = bestOil(p + vec2(3.9, -6.2), sFill, lenMulFill, widMulFill,\n                            jitterAmt * 1.5, 0.95, fillShape,\n                            bristleAmp * 0.6, flow, t, 8.9);\n  paintOver(result, hFill, streakFreq * 1.8, streakAmp * 0.6,\n            uImpasto * impastoAmp * 0.4 * uStrokeAmount, hardness * 0.9, 8.9);\n\n  // Optional crosshatch layer\n  if (uStrokeLayers == 2) {\n    vec2 flow2 = vec2(-flow.y, flow.x);\n    StrokeHit hX = bestOil(p + vec2(7.3, -2.1), sMed, lenMulMed * 0.9, widMulMed,\n                           jitterAmt, densityMed * 0.7, shapeType, bristleAmp, flow2, t, 6.5);\n    paintOver(result, hX, streakFreq, streakAmp * 0.85,\n              uImpasto * impastoAmp * 0.55 * uStrokeAmount, hardness, 6.5);\n  }\n\n  // Canvas tooth \u2014 linen weave\n  float tooth1 = vnoise(p * toothScale);\n  float tooth2 = vnoise(p * toothScale * vec2(0.6, 2.4) + 37.0);\n  float tooth  = (0.6 * tooth1 + 0.4 * tooth2) - 0.5;\n  result *= 1.0 + tooth * toothAmp * uCanvasGrain;\n\n  // Pigment saturation boost\n  result = saturate3(result, pigmentSat);\n\n  return result;\n}";

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

@@ -0,0 +1 @@
+export declare const AURORA_TONEMAP_GLSL = "// ACES approximation\nvec3 aces(vec3 x) {\n  float a = 2.51;\n  float b = 0.03;\n  float c = 2.43;\n  float d = 0.59;\n  float e = 0.14;\n  return clamp((x * (a * x + b)) / (x * (c * x + d) + e), 0.0, 1.0);\n}\n";

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

@@ -1,10 +1,10 @@
 export { default as Aurora } from "./Aurora.vue";
-export { resolveRenderMode, type AuroraRenderMode } from "./renderMode";
+export { resolveRenderMode, type AuroraRenderMode } from "./constants/renderMode";
 export { useAurora } from "./composables/useAurora";
 export type { UseAuroraReturn } from "./composables/useAurora";
 export { useCursorInteraction } from "./composables/useCursorInteraction";
 export { createAurora } from "./composables/runtime";
 export type { AuroraRuntimeMode, AuroraRuntimeOptions } from "./composables/runtime";
-export { DEFAULT_AURORA_CONFIG, MAX_NUCLEI, MAX_STOPS, type AuroraConfig, type AuroraCursorApi, type AuroraFlow, type AuroraInstance, type AuroraMedium, type AuroraNucleus, type FlowPattern, type OklchStop, type StrokeMode, type WarpMode, } from "./presets";
+export { DEFAULT_AURORA_CONFIG, MAX_NUCLEI, MAX_STOPS, type AuroraConfig, type AuroraCursorApi, type AuroraFlow, type AuroraInstance, type AuroraMedium, type AuroraNucleus, type FlowPattern, type OklchStop, type StrokeMode, type WarpMode, } from "./constants/presets";
 export { cssToOklch, deriveAurora, flattenPalette, hexToOklchStop, oklchStopToHex, oklchToLinear, paletteToCssGradient, } from "./composables/color";
 export type { AuroraHarmony, DeriveAuroraOptions } from "./composables/color";

package/dist/components/custom/configurator/ConfiguratorLayer.vue.d.ts

@@ -38,25 +38,32 @@ type __VLS_Props = {
     sub?: string;
     /** Optional id used by external state (e.g., a sibling tab row). */
     id?: string;
-    /** Controlled open state. Pair with `@update:open`. */
-    open?: boolean;
     /** Uncontrolled initial state. */
     defaultOpen?: boolean;
+    /**
+     * Opt-in inter-row hairline. When set, sibling rows inside the body
+     * are separated by a `border-border/30` top rule (the first row stays
+     * flush). Default `false` keeps the body gap-only (pre-AU.W9 visual).
+     */
+    dividers?: boolean;
     class?: HTMLAttributes["class"];
     /** Body wrapper class override. */
     bodyClass?: HTMLAttributes["class"];
 };
+type __VLS_ModelProps = {
+    "open"?: boolean | undefined;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
 declare var __VLS_6: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_6) => any;
 };
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-    "update:open": (value: boolean) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean | undefined) => any) | undefined;
 }>, {
     defaultOpen: boolean;
-    open: 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/configurator/density.d.ts

@@ -1,4 +1,4 @@
-import { type ComputedRef, type InjectionKey } from "vue";
+import type { ComputedRef } from "vue";
 /**
  * Density axis for `<Configurator>` + `<ConfiguratorRow>` (N.W2 Lane A).
  *
@@ -15,16 +15,11 @@ import { type ComputedRef, type InjectionKey } from "vue";
  * for-bit preserved.
  */
 export type ConfiguratorDensity = "mobile" | "compact" | "comfortable" | "spacious";
-/**
- * Provide / inject key for the cascading density value. Carries a
- * `ComputedRef<ConfiguratorDensity>` so descendants stay reactive when
- * the host swaps density (e.g., viewport-driven mobile/desktop branch).
- */
-export declare const CONFIGURATOR_DENSITY_KEY: InjectionKey<ComputedRef<ConfiguratorDensity>>;
+export declare const CONFIGURATOR_DENSITY_KEY: import("vue").InjectionKey<ComputedRef<ConfiguratorDensity>>;
 export declare function provideConfiguratorDensity(density: ComputedRef<ConfiguratorDensity>): void;
 /**
  * Befitting silent default — returns `null` when there is no ancestor
  * `<Configurator>`. The consumer null-coalesces to `undefined` so the
  * `:data-density` binding emits no attribute (pre-N.W2 visual preserved).
  */
-export declare function useOptionalConfiguratorDensity(): ComputedRef<ConfiguratorDensity> | null;
+export declare const useOptionalConfiguratorDensity: () => ComputedRef<ConfiguratorDensity> | null;

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

@@ -0,0 +1,46 @@
+/**
+ * <DockBackgroundToggle> — the WCAG 2.2.2 (Pause, Stop, Hide), Level A pause/play
+ * control for a continuously-running AV background (Aurora / GooBlob).
+ *
+ * WCAG 2.2.2 is OBLIGATORY for any auto-starting, >5s, non-essential motion and
+ * the control must be available to ALL users — it is NOT gated behind
+ * `prefers-reduced-motion` (which the substrate handles separately via the G1
+ * freeze). This is the USER-driven stop control any user can reach.
+ *
+ * Binding contract (KISS — it binds an EXISTING renderer seam, adds no parallel
+ * pause path): the consumer holds the paused state and wires it to the renderer's
+ * `pause()`/`resume()`. The toggle is a thin `v-model:paused` control over a
+ * `<DockIconButton>` host (the dock is the natural home for a background control):
+ *
+ * ```vue
+ * <script setup>
+ * const blob = ref<InstanceType<typeof GooBlob>>();
+ * const paused = ref(false);
+ * watch(paused, (p) => (p ? blob.value?.pause() : blob.value?.resume()));
+ * <\/script>
+ * <DockBackgroundToggle v-model:paused="paused" />
+ * ```
+ *
+ * The control reflects state via `aria-pressed` (pressed ⇒ paused) and swaps the
+ * Pause↔Play glyph + the accessible label, so a screen reader announces both the
+ * action and the current state.
+ */
+type __VLS_Props = {
+    /** Whether the background is currently paused (the controlled state). */
+    paused?: boolean;
+    /** Accessible label when RUNNING (the action: pause). */
+    pauseLabel?: string;
+    /** Accessible label when PAUSED (the action: play/resume). */
+    playLabel?: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, 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;
+}>, {
+    paused: boolean;
+    pauseLabel: string;
+    playLabel: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -21,12 +21,12 @@ type __VLS_Props = {
     asChild?: boolean;
     class?: HTMLAttributes["class"];
 };
-declare var __VLS_8: {};
+declare var __VLS_10: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_8) => any;
+    default?: (props: typeof __VLS_10) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    type: "button" | "reset" | "submit";
+    type: "button" | "submit" | "reset";
     asChild: boolean;
     as: string | Component;
     compact: boolean;

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

@@ -21,9 +21,9 @@ type __VLS_ModelProps = {
     "active": string;
 };
 type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
-declare var __VLS_6: {};
+declare var __VLS_32: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_6) => any;
+    default?: (props: typeof __VLS_32) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:active": (value: string) => any;

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

@@ -5,8 +5,6 @@ type __VLS_Props = {
     fitContent?: boolean;
     position?: "fixed" | "inline" | "sticky";
     alwaysExpanded?: boolean;
-    /** Allow expanded content to wrap to multiple lines. */
-    wrap?: boolean;
     /**
      * Visual/behavioral preset.
      *   `dock`             — the horizontal floating dock (default).
@@ -46,10 +44,16 @@ type __VLS_Props = {
     /**
      * Overflow strategy when the expanded content exceeds the dock's
      * axis cap (`--dock-max-inline-size` horizontally,
-     * `--dock-max-block-size` vertically).
+     * `--dock-max-block-size` vertically). The ONE knob governing every
+     * overflow behaviour (AT.W7-dock-a clean break — collapsed from the
+     * prior `wrap` boolean + `overflow` pair + `containerName` clip-lift,
+     * which all touched overflow divergently).
      *   `"grow"`   — content grows to fit then overflows visibly past
-     *                the cap (the historical default; nothing clips or
-     *                scrolls).
+     *                the cap (the default; nothing clips or scrolls).
+     *   `"wrap"`   — expanded content wraps to multiple lines/rows (the
+     *                `.dock-overflow-wrap` recipe — a multi-row pill that narrows
+     *                to the viewport gutter on small screens and snaps
+     *                back to a single nowrap row past `--dock-overflow-bp`).
      *   `"scroll"` — the dock becomes the scroll port. Horizontal docks
      *                scroll the active layer on the inline axis
      *                (`.dock-scroll-x`); vertical rails scroll on the
@@ -58,18 +62,19 @@ type __VLS_Props = {
      *                scroll edge; the scrollbar is hidden. The axis is
      *                chosen automatically from `orientation`.
      */
-    overflow?: "grow" | "scroll";
+    overflow?: "grow" | "wrap" | "scroll";
     /**
      * When set, the dock root establishes an inline-size container query
-     * subject (`container-type: inline-size; container-name: <value>`)
-     * and lifts its `overflow: hidden` clip so descendants can wrap or
-     * report intrinsic widths at narrow viewports. Consumers query the
-     * named container via `@container <value> (...)` rules.
+     * subject (`container-type: inline-size; container-name: <value>`) so
+     * descendants can query the named container via `@container <value>
+     * (...)` rules. ORTHOGONAL to the `overflow` clip: opting into a
+     * container subject does NOT silently change the dock's clip shell
+     * (AT.W7-dock-a — the prior clip-lift was folded out; use
+     * `overflow="wrap"` to allow multi-line content).
      *
-     * Without this prop the dock retains its default `overflow: hidden`
-     * shell — the pre-T behaviour. T.B audit §1.3 cornerstone: the
-     * cluster's container subject must live on the dock primitive, never
-     * on a descendant whose intrinsic size the dock relies on.
+     * T.B audit §1.3 cornerstone: the cluster's container subject must
+     * live on the dock primitive, never on a descendant whose intrinsic
+     * size the dock relies on.
      */
     containerName?: string;
 };
@@ -92,16 +97,15 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
     release: () => void;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
     position: "fixed" | "inline" | "sticky";
-    overflow: "grow" | "scroll";
-    variant: "dock" | "rail" | "instrument-strip";
+    overflow: "grow" | "wrap" | "scroll";
     orientation: "horizontal" | "vertical";
-    wrap: boolean;
+    variant: "dock" | "rail" | "instrument-strip";
     density: DockDensity;
+    shape: "pill" | "rounded";
     collapseDelay: number;
     alwaysExpanded: boolean;
     startCollapsed: boolean;
     fitContent: boolean;
-    shape: "pill" | "rounded";
 }, {}, {}, {}, 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/composables/dockContext.d.ts

@@ -1,4 +1,4 @@
-import { type ComputedRef, type InjectionKey } from "vue";
+import type { ComputedRef } from "vue";
 export type DockOrientation = "horizontal" | "vertical";
 /**
  * Dock context surfaces the dock id + orientation + held-state coordination
@@ -32,9 +32,9 @@ export interface DockContext {
     /** Reactive `keepOpenCount > 0` flag; descendants reflect via `data-held`. */
     held: ComputedRef<boolean>;
 }
-export declare const DOCK_CONTEXT_KEY: InjectionKey<DockContext>;
+export declare const DOCK_CONTEXT_KEY: import("vue").InjectionKey<DockContext>;
 export declare function provideDockContext(context: DockContext): void;
 /** Strict — throws when used outside `<GlassDock>`. */
-export declare function useDockContext(): DockContext;
+export declare const useDockContext: () => DockContext;
 /** Befitting silent default for primitives that may render outside a dock. */
-export declare function useOptionalDockContext(): DockContext | null;
+export declare const useOptionalDockContext: () => DockContext | null;

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

@@ -1,4 +1,4 @@
-import { type Component, type InjectionKey, type Ref } from "vue";
+import type { Component, Ref } from "vue";
 /**
  * DockLayerGroup context — DI surface for `<DockLayer>` children registering
  * with their parent `<DockLayerGroup>` for the switcher rail + crossfade
@@ -18,12 +18,19 @@ export interface DockLayerDescriptor {
 export interface DockLayerGroupContext {
     register(desc: DockLayerDescriptor): void;
     unregister(id: string): void;
-    currentLayerId: Ref<string>;
-    leavingLayerId: Ref<string | null>;
+    /**
+     * AU.W8b.6 — group-orchestrated layer state, exposed READ-ONLY. The
+     * `<DockLayerGroup>` (via `useLayerTransition`) owns the writable refs and
+     * provides `readonly()` projections; a `<DockLayer>` child can read but
+     * never write this state. A child `currentLayerId.value = …` is a compile
+     * error (see `__tests__/dockLayerContext.readonly.test-d.ts`).
+     */
+    currentLayerId: Readonly<Ref<string>>;
+    leavingLayerId: Readonly<Ref<string | null>>;
 }
-export declare const DOCK_LAYER_GROUP_KEY: InjectionKey<DockLayerGroupContext>;
+export declare const DOCK_LAYER_GROUP_KEY: import("vue").InjectionKey<DockLayerGroupContext>;
 export declare function provideDockLayerGroupContext(context: DockLayerGroupContext): void;
 /** Strict — throws when used outside `<DockLayerGroup>`. */
-export declare function useDockLayerGroupContext(): DockLayerGroupContext;
+export declare const useDockLayerGroupContext: () => DockLayerGroupContext;
 /** Befitting silent default; reserved for future consumers. */
-export declare function useOptionalDockLayerGroupContext(): DockLayerGroupContext | null;
+export declare const useOptionalDockLayerGroupContext: () => DockLayerGroupContext | null;

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

@@ -31,14 +31,38 @@ export interface UseLayerTransitionReturn {
  *   the size + crossfades the pane content with ZERO `getBoundingClientRect`
  *   reads. No pin/measure/re-pin dance, no inline size, no rAF.
  *
- * - **Fallback path** (no `startViewTransition`): the existing axis-aware FLIP
- *   runs verbatim, KEPT as the sole feature-detected fallback (no alias — one
- *   path or the other runs per swap, never both):
- *   1. Capture current container size
+ * - **Fallback path** (no `startViewTransition`): the axis-aware FLIP, KEPT as
+ *   the sole feature-detected fallback (no alias — one path or the other runs per
+ *   swap, never both). It is now the ONLY driver that writes inline size on a
+ *   non-VT engine (AV.W9.0 retired the `interpolate-size`/`calc-size` CSS arm that
+ *   used to second-drive width on Chrome 129+ and freeze the dock):
+ *   1. Capture current container size (or the live spring's pixel value on a
+ *      retarget)
  *   2. Pin container to that size
- *   3. Swap classes: old layer → leaving, new layer → active
- *   4. nextTick: measure new natural size, re-pin to old
- *   5. Animate to new size via CSS transition
- *   6. On transitionend(size), clear inline size
+ *   3. nextTick → rAF: swap classes (old → leaving, new → active) AND measure new
+ *      natural size in ONE frame origin
+ *   4. Drive size off ONE `SpringProgress` clock in PIXEL space (its `value` IS
+ *      the live width/height)
+ *   5. On settle, clear inline size + restore the CSS transition
+ *
+ *   AV.W9.2 — velocity-continuity: an interrupted swap (a re-toggle while the
+ *   spring is still live) RE-SEATS the existing solver's target from its current
+ *   `(value, velocity)` instead of dispose+reconstruct-from-rest, so the morph is
+ *   continuous through a retarget (the iOS interruptible-spring contract).
+ *
+ * AV.W7 perf folds:
+ *   - F3 — on-demand `will-change`: the morphing box gets `will-change:<dim>`
+ *     ONLY for the gesture's duration (set just before the spring drives it,
+ *     cleared to `auto` on settle/`transitionend`). NEVER a standing hint — a
+ *     permanent `will-change` holds a compositor layer + VRAM for an idle dock.
+ *   - F5 — inheritance-bomb guard (CONVENTION): this driver animates ONLY the
+ *     element's own `width`/`height` (the spring's pixel-space `value`) and the
+ *     pane opacity rides a class-driven CSS transition on the SEPARATE
+ *     `.dock-layer-item-host`. NO INHERITED custom property (`--phase-color` /
+ *     `--shadow-color`) is TWEENED per frame here — animating an inherited
+ *     custom property forces a whole-subtree style recalc every frame (the
+ *     inheritance bomb). Phase/shadow colors are SET on a discrete state change,
+ *     never interpolated frame-by-frame. Keep new motion on `transform`/`opacity`
+ *     /`width`/`height`; route any color shift through a discrete class swap.
  */
 export declare function useLayerTransition(options: UseLayerTransitionOptions): UseLayerTransitionReturn;

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

@@ -2,6 +2,7 @@ export { default as GlassDock } from "./GlassDock.vue";
 export { default as DockLayerGroup } from "./DockLayerGroup.vue";
 export { default as DockLayer } from "./DockLayer.vue";
 export { default as DockIconButton } from "./DockIconButton.vue";
+export { default as DockBackgroundToggle } from "./DockBackgroundToggle.vue";
 export { default as DockTabButton } from "./DockTabButton.vue";
 export { default as DockSelectTrigger } from "./DockSelectTrigger.vue";
 export { default as DockDropdownTrigger } from "./DockDropdownTrigger.vue";

package/dist/components/custom/expandable-container/ExpandableContainer.vue.d.ts

@@ -2,6 +2,10 @@ declare const _default: typeof __VLS_export;
 export default _default;
 declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
     buttonPosition?: "left" | "right";
+    /** Accessible name for the expand (fullscreen) button. */
+    expandLabel?: string;
+    /** Accessible name for the collapse (exit fullscreen) button. */
+    collapseLabel?: string;
 } & {
     /**
      * Two-way `open` model so consumers can drive fullscreen externally
@@ -13,6 +17,10 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
     "update:open": (value: boolean) => any;
 }, string, import("vue").PublicProps, Readonly<{
     buttonPosition?: "left" | "right";
+    /** Accessible name for the expand (fullscreen) button. */
+    expandLabel?: string;
+    /** Accessible name for the collapse (exit fullscreen) button. */
+    collapseLabel?: string;
 } & {
     /**
      * Two-way `open` model so consumers can drive fullscreen externally
@@ -24,6 +32,8 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
     "onUpdate:open"?: ((value: boolean) => any) | undefined;
 }>, {
     buttonPosition: "left" | "right";
+    expandLabel: string;
+    collapseLabel: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
     default?: (props: {
         fullscreen: boolean;