@mkbabb/glass-ui 3.1.1 → 3.3.0

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

@@ -1,23 +1,34 @@
 /**
- * Aurora v4.1 runtime — port of bundle `runtime.js` to TypeScript.
+ * Aurora v4.1 runtime — the GL-lifecycle orchestrator over the `useWebGLCanvas`
+ * substrate (AU.W6, the DEC-AT-1 transposition).
  *
- * Compiles the shader, owns the WebGL2 context and RAF loop, translates a
- * reactive `AuroraConfig` into uniforms, and exposes an imperative cursor API
- * plus a side-effect-safe `renderAt(t)` method for capture baking.
+ * This module composes four cohesive seams atop the substrate:
+ *   - glSetup       — compile/link + geometry + the uniform location cache
+ *   - uniformBridge — the reactive-config → GL-uniform translation + enum dispatch
+ *   - cursorModel   — the eased pointer-attraction state + advance
+ *   - frameLoop     — the per-frame draw + the render-demand gate
  *
- * Y-origin convention: config authoring is CSS-top-origin (0 = top). The
- * runtime flips Y at the uniform boundary (see AUTHOR_Y_ORIGIN_IS_TOP marks).
+ * It owns ONLY the aurora-specific glue: threading the seams through the
+ * substrate's `setup`/`frame`/`shouldContinue`/`resize`/`time`/`teardown`
+ * callbacks, the reduced-motion frozen-t, the DPR policy, and the imperative
+ * setters/pause/resume. The generic WebGL2 lifecycle — context creation, the
+ * three-reason suspend/resume model, the demand-driven rAF loop, the tab-visibility
+ * owner, the ResizeObserver, and the webglcontextlost/restored robustness — lives
+ * in the substrate.
+ *
+ * Y-origin convention: config authoring is CSS-top-origin (0 = top). The seams
+ * flip Y at the uniform boundary (`flipY` in uniformBridge/frameLoop).
  */
-import { type AuroraConfig, type AuroraInstance } from "../presets";
+import type { AuroraConfig, AuroraInstance } from "../constants/presets";
 export type AuroraRuntimeMode = "live" | "capture";
 /**
- * The three independent reasons the RAF loop may be suspended. The runtime
- * tracks them in a `Set<SuspendReason>` rather than one boolean, so the loop
- * runs IFF the set is empty and each reason is cleared ONLY by the source that
- * set it. This makes resume-while-still-suspended structurally unreachable — a
- * `resume("tab-hidden")` cannot lift an `"off-screen"` suspension.
+ * The three independent reasons the rAF loop may be suspended. Owned by the
+ * `useWebGLCanvas` substrate as a `Set<reason>`: the loop runs IFF the set is
+ * empty and each reason is cleared ONLY by the source that set it. This makes
+ * resume-while-still-suspended structurally unreachable — a `resume("tab-hidden")`
+ * cannot lift an `"off-screen"` suspension.
  *
- * - `"tab-hidden"` — the runtime's own `document.visibilitychange` owner.
+ * - `"tab-hidden"` — the substrate's `document.visibilitychange` owner.
  * - `"off-screen"` — viewport-intersection, driven by `useIntersectionPause`.
  * - `"manual"` — the public `pause()`/`resume()` API (and capture-mode seed).
  */
@@ -26,15 +37,14 @@ export type SuspendReason = "tab-hidden" | "off-screen" | "manual";
  * When the expensive WebGL path (context creation, shader compile + GPU link,
  * first uniform upload, rAF arm) actually runs.
  *
- * - `"deferred"` (default) — `createAurora` constructs a cheap, un-armed
- *   instance and returns immediately; the GL work is invoked later via
- *   `instance.arm()`. The Vue wrapper `useAurora` schedules `arm()` past first
- *   paint on an idle tick, gated on canvas visibility — so the shader
- *   compile-link never lands on the consumer's first-paint critical path.
- * - `"eager"` — `createAurora` arms synchronously before returning, exactly
- *   as a pre-lazy-arm runtime did. Capture / thumbnail-baking consumers need
- *   this: `renderAt` must draw a real frame the instant `createAurora`
- *   returns. `mode: "capture"` forces eager regardless of this field.
+ * - `"deferred"` (default) — `createAurora` constructs a cheap, un-armed instance
+ *   and returns immediately; the GL work is invoked later via `instance.arm()`.
+ *   The Vue wrapper `useAurora` schedules `arm()` past first paint on an idle
+ *   tick, gated on canvas visibility — so the shader compile-link never lands on
+ *   the consumer's first-paint critical path.
+ * - `"eager"` — `createAurora` arms synchronously before returning. Capture /
+ *   thumbnail-baking consumers need this: `renderAt` must draw a real frame the
+ *   instant `createAurora` returns. `mode: "capture"` forces eager regardless.
  */
 export type AuroraInitStrategy = "eager" | "deferred";
 export interface AuroraRuntimeOptions {
@@ -49,25 +59,25 @@ export interface AuroraRuntimeOptions {
     /**
      * Init-failure handler. A WebGL2/shader-compile/link failure is a
      * library-internal contract violation (O invariant 24). On the EAGER path
-     * `createAurora` throws synchronously and `useAurora` rethrows by default
-     * so the signal reaches the consumer's error boundary / dev console. On
-     * the DEFERRED path the failure happens on an idle tick — outside any
-     * mount-time boundary — so the runtime routes it here, and `useAurora`
-     * re-surfaces it on the microtask queue (so it still reaches the dev
-     * console / `app.config.errorHandler`) when no handler is supplied.
-     * Provide this callback to opt into silent handling on either path.
+     * `createAurora` throws synchronously and `useAurora` rethrows by default so
+     * the signal reaches the consumer's error boundary / dev console. On the
+     * DEFERRED path the failure happens on an idle tick — outside any mount-time
+     * boundary — so the runtime routes it here, and `useAurora` re-surfaces it on
+     * the microtask queue (so it still reaches the dev console /
+     * `app.config.errorHandler`) when no handler is supplied. Provide this
+     * callback to opt into silent handling on either path.
      *
-     * NOTE: this is the `useAurora` Vue-wrapper contract surface. The
-     * imperative `createAurora(...)` runtime throws on eager init failure and
-     * — for `instance.arm()` on the deferred path — rethrows from `arm()`.
+     * NOTE: this is the `useAurora` Vue-wrapper contract surface. The imperative
+     * `createAurora(...)` runtime throws on eager init failure and — for
+     * `instance.arm()` on the deferred path — rethrows from `arm()`.
      */
     onInitError?: (err: Error) => void;
 }
 /**
  * The concrete `createAurora` return shape. It IS an {@link AuroraInstance}
- * (structurally assignable — every member matches) but widens `pause`/`resume`
- * to carry an optional {@link SuspendReason}, defaulting to `"manual"`. The
- * Vue wrapper passes `"off-screen"` for the intersection seam; a bare
+ * (structurally assignable — every member matches) but widens `pause`/`resume` to
+ * carry an optional {@link SuspendReason}, defaulting to `"manual"`. The Vue
+ * wrapper passes `"off-screen"` for the intersection seam; a bare
  * `pause()`/`resume()` reads identically to the `AuroraInstance` contract.
  */
 export interface AuroraRuntime extends Omit<AuroraInstance, "pause" | "resume"> {

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;
@@ -25,7 +22,7 @@ export interface AuroraNucleus {
     paletteBias: number;
     /** -0.3..0.3 — lightness pull within the nucleus's zone of influence. */
     valueBias: number;
-    /** 0..0.03 — orbit amplitude for slow drift. */
+    /** 0..0.08 — orbit amplitude for slow drift (the visible-travel gate). */
     driftRadius: number;
     /** 0..2π — phase seed. */
     driftPhase: 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,9 +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 { cssToOklch, flattenPalette, hexToOklchStop, oklchStopToHex, oklchToLinear, paletteToCssGradient, } from "./composables/color";
+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/Configurator.vue.d.ts

@@ -13,6 +13,16 @@ import { type ConfiguratorDensity } from "./density";
  *              overflow.
  */
 export type ConfiguratorScrollMode = "auto" | "always" | "never";
+/**
+ * Which side the aside (preset row + controls) sits on at `lg`+ width.
+ *
+ * `right` (default) is the inspector idiom — stage left, controls right.
+ * `left` is a reversible, taste-level flip: the aside renders on the
+ * left while DOM/tab order stays stage→aside (the flip is grid-column
+ * placement + border-side only, no source reorder — no a11y regression).
+ * Below `lg` the layout is a single column and the side has no meaning.
+ */
+export type ConfiguratorAsideSide = "left" | "right";
 /**
  * Generic preset descriptor. Consumers pass `T` as the live config shape.
  * The primitive carries no preset semantics beyond `key + label` for
@@ -51,6 +61,22 @@ declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_se
          * `gap-1.5 py-2` recipe exactly.
          */
         density?: ConfiguratorDensity;
+        /**
+         * Which side the aside sits on at `lg`+ width. Default `"right"`
+         * (the inspector idiom). `"left"` flips the visual column via
+         * grid-column placement + border-side swap only — DOM/tab order
+         * stays stage→aside. No effect below `lg` (single-column).
+         */
+        asideSide?: ConfiguratorAsideSide;
+        /**
+         * Aside width band at `lg`+ width, as a CSS length pair driving
+         * `minmax(--configurator-aside-min, --configurator-aside-max)`. The
+         * prop sets the two inline custom properties; consumers may instead
+         * (or also) set `--configurator-aside-min` / `--configurator-aside-max`
+         * via the cascade. Default band is `280px`/`360px`. Pass a single
+         * length to pin the band (`min === max`), or a `[min, max]` pair.
+         */
+        asideWidth?: string | readonly [min: string, max: string];
         /** Optional outer container override. */
         class?: HTMLAttributes["class"];
     } & {

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/configurator/index.d.ts

@@ -1,6 +1,6 @@
 export { default as Configurator } from "./Configurator.vue";
 export { default as ConfiguratorLayer } from "./ConfiguratorLayer.vue";
 export { default as ConfiguratorRow } from "./ConfiguratorRow.vue";
-export type { ConfiguratorPreset, ConfiguratorScrollMode, } from "./Configurator.vue";
+export type { ConfiguratorAsideSide, ConfiguratorPreset, ConfiguratorScrollMode, } from "./Configurator.vue";
 export { CONFIGURATOR_DENSITY_KEY, provideConfiguratorDensity, useOptionalConfiguratorDensity, type ConfiguratorDensity, } from "./density";
 export { useConfiguratorState, type ConfiguratorCloneMode, type ConfiguratorState, type ConfiguratorStateOptions, } from "./useConfiguratorState";

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

@@ -1,23 +1,34 @@
-import { type ButtonHTMLAttributes, type HTMLAttributes } from "vue";
+import { type ButtonHTMLAttributes, type Component, type HTMLAttributes } from "vue";
 /**
  * <DockIconButton> — fixed-square icon button for use inside GlassDock.
  *
  * Emits the dock icon-button class contract. Interactive styling is owned by
  * src/styles/dock.css so all dock controls share one public style authority.
+ *
+ * Use `as`/`as-child` to render as a <RouterLink> or <a> without a wrapper:
+ * `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`).
  */
 type __VLS_Props = {
     /** Compact variant: auto-sized instead of fixed 2.5rem square. */
     compact?: boolean;
     /** Button type attribute (default: "button" to prevent form submission). */
     type?: ButtonHTMLAttributes["type"];
+    /** Host tag/component (reka-ui Primitive `as`; default "button"). */
+    as?: string | Component;
+    /** Merge props onto a slotted child instead of rendering a host tag. */
+    asChild?: boolean;
     class?: HTMLAttributes["class"];
 };
-declare var __VLS_1: {};
+declare var __VLS_10: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_1) => 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;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

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;