@mkbabb/glass-ui 3.2.0 → 3.4.0

package/dist/aurora.js

@@ -1,74 +1,286 @@
 import { t as e } from "./_plugin-vue_export-helper-C1je1s0u.js";
-import { n as t, r as n, t as r } from "./presets-BpTf63Hp.js";
-import { t as i } from "./useIntersectionPause-CUmANkoc.js";
-import { computed as a, createElementBlock as o, createElementVNode as s, defineComponent as c, normalizeClass as l, normalizeStyle as u, onBeforeUnmount as d, onMounted as f, openBlock as p, readonly as m, ref as h, unref as g, watch as _ } from "vue";
-import { colorUnit2 as v, gamutMapOKLab as y, isInSRGBGamut as b, oklabToLinearSRGB as x, oklabToRgb255 as S, parseCSSColor as C, rawOklabToOklch as w, rawOklchToOklab as T, srgbToOKLab as E } from "@mkbabb/value.js";
-//#region src/components/custom/aurora/shaders/aurora.vert.ts
-var D = "#version 300 es\nin vec2 aPos;\nout vec2 vUv;\nvoid main() {\n  vUv = aPos * 0.5 + 0.5;\n  gl_Position = vec4(aPos, 0.0, 1.0);\n}", O = "#version 300 es\nprecision highp float;\n\nin vec2 vUv;\nout vec4 fragColor;\n\n#define MAX_NUCLEI 6\n#define MAX_STOPS  8\n\n// ── Uniforms ───────────────────────────────────────────────────────────────\nuniform float uTime;\n\n// Palette baked CPU-side to linear-sRGB\nuniform vec3  uPalette[MAX_STOPS];\nuniform int   uStopCount;\n\n// Nuclei (parallel arrays)\nuniform int   uNucleiCount;\nuniform vec2  uNucleiPos[MAX_NUCLEI];\nuniform float uNucleiRadius[MAX_NUCLEI];\nuniform float uNucleiPaletteBias[MAX_NUCLEI];\nuniform float uNucleiValueBias[MAX_NUCLEI];\nuniform float uNucleiDriftRadius[MAX_NUCLEI];\nuniform float uNucleiDriftPhase[MAX_NUCLEI];\n// Anisotropy: per-nucleus elongation (1.0 = isotropic) and major-axis angle (radians).\n// Defaults (1.0 / 0.0) reduce to the original circular Gaussian.\nuniform float uNucleiElong[MAX_NUCLEI];\nuniform float uNucleiAngle[MAX_NUCLEI];\nuniform float uSoftmaxBeta;\nuniform float uValueVariance;\n\n// Warp\nuniform float uWarpAmount;\nuniform float uWarpScale;\nuniform float uWarpDrift;\nuniform int   uWarpMode;      // 0=fbm 1=cellular 2=hybrid\nuniform int   uNoiseOctaves;\n\n// Medium\n// 0 smooth, 1 pastel, 2 watercolor, 3 oil\nuniform int   uMedium;\nuniform int   uFlowPattern;   // 0 none, 1 radial, 2 swirl, 3 diagonal, 4 multi\nuniform vec2  uFlowFocal;\nuniform float uFlowAngle;\nuniform float uFlowCurl;\nuniform vec2  uCursor;          // in 0..1 screen space (matches pN)\nuniform float uCursorStrength;  // 0..1 attraction amount\nuniform float uCursorRadius;    // radius of influence (0.05..0.5)\nuniform float uStrokeAmount;\nuniform float uStrokeScale;\nuniform float uStrokeAnisotropy;\nuniform int   uStrokeLayers;  // 1 or 2 (crosshatch)\nuniform int   uStrokeMode;    // 0 oil (modern gestural), 1 palette-knife, 2 crayon/oil-pastel, 3 modern-chunky\nuniform float uWetEdge;\nuniform float uGranulation;\nuniform float uImpasto;\nuniform float uBrokenColor;\nuniform float uCanvasGrain;\n\n// Motion\nuniform float uNucleiDrift;\nuniform float uPaletteDrift;\nuniform float uBreathDepth;\nuniform float uBreathPeriod;\n\n// Output\nuniform float uSaturation;\nuniform float uPaperGrain;\nuniform float uAlpha;\n\n// ── Time rate ────────────────────────────────────────────────────────────────\n// The authoring coefficients (uNucleiDrift, uPaletteDrift, uWarpDrift) live in a\n// human-friendly 0..~0.05 band — that scale is what the config schema and every\n// demo preset are tuned against. But that band, multiplied straight into uTime\n// (seconds), yields rad/sec rates so small the field reads visually static (one\n// nuclei orbit took ~10 min at the old default). These K_* constants decouple\n// the AUTHORING scale from the RAD/SEC scale: each time term wraps its coefficient\n// in the matching K_, lifting the same authored value to a perceptible period\n// without touching any preset. Tuned so the field reads SLOWLY ALIVE — drift over\n// a ~5–15s window, never a frantic pan. These are downstream of uTime, which the\n// runtime FREEZES under reduced-motion (t = frozenOffset) before the shader sees\n// it, so the lift cannot leak motion into the reduced-motion path.\nconst float K_NUCLEI = 14.0; // nuclei orbit: ~one cycle per ~45s at default 0.01\nconst float K_PAL    = 24.0; // palette hue breathe: ~one cycle per ~33s at default\nconst float K_WARP   = 5.0;  // domain warp scroll: a perceptible fbm-cell traverse\n\n// ── Noise ──────────────────────────────────────────────────────────────────\nfloat hash21(vec2 p) {\n  p = fract(p * vec2(123.34, 456.21));\n  p += dot(p, p + 45.32);\n  return fract(p.x * p.y);\n}\n\nvec2 hash22(vec2 p) {\n  p = vec2(dot(p, vec2(127.1, 311.7)),\n           dot(p, vec2(269.5, 183.3)));\n  return fract(sin(p) * 43758.5453);\n}\n\nfloat vnoise(vec2 p) {\n  vec2 i = floor(p);\n  vec2 f = fract(p);\n  vec2 u = f * f * (3.0 - 2.0 * f);\n  float a = hash21(i);\n  float b = hash21(i + vec2(1.0, 0.0));\n  float c = hash21(i + vec2(0.0, 1.0));\n  float d = hash21(i + vec2(1.0, 1.0));\n  return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);\n}\n\nfloat fbm(vec2 p) {\n  float v = 0.0;\n  float a = 0.5;\n  mat2 r = mat2(0.8, 0.6, -0.6, 0.8);\n  for (int i = 0; i < 5; i++) {\n    if (i >= uNoiseOctaves) break;\n    v += a * vnoise(p);\n    p = r * p * 2.02;\n    a *= 0.5;\n  }\n  return v;\n}\n\n// Cellular / Worley f1\nfloat cellular(vec2 p) {\n  vec2 i = floor(p);\n  vec2 f = fract(p);\n  float m = 1e9;\n  for (int y = -1; y <= 1; y++) {\n    for (int x = -1; x <= 1; x++) {\n      vec2 g = vec2(float(x), float(y));\n      vec2 o = hash22(i + g);\n      vec2 r = g + o - f;\n      m = min(m, dot(r, r));\n    }\n  }\n  return sqrt(m);\n}\n\n// ── Warp ──────────────────────────────────────────────────────────────────\nvec2 domainWarp(vec2 p, float t) {\n  // Quilez canonical double warp\n  vec2 q = vec2(fbm(p * uWarpScale + vec2(0.0, 0.0) + t * uWarpDrift * K_WARP),\n                fbm(p * uWarpScale + vec2(5.2, 1.3) + t * uWarpDrift * K_WARP));\n  vec2 r = vec2(fbm(p * uWarpScale + 4.0 * q + vec2(1.7, 9.2)),\n                fbm(p * uWarpScale + 4.0 * q + vec2(8.3, 2.8)));\n\n  vec2 warp = r;\n  if (uWarpMode == 1) {\n    // cellular — chunky territories (MEADOW block-like)\n    float c1 = cellular(p * uWarpScale * 1.5 + vec2(t * uWarpDrift * K_WARP * 2.0, 0.0));\n    float c2 = cellular(p * uWarpScale * 1.5 + vec2(11.0, 7.0 + t * uWarpDrift * K_WARP * 2.0));\n    warp = vec2(c1, c2);\n  } else if (uWarpMode == 2) {\n    // hybrid — fbm + cellular averaged\n    float c1 = cellular(p * uWarpScale * 1.2);\n    float c2 = cellular(p * uWarpScale * 1.2 + vec2(11.0, 7.0));\n    warp = mix(r, vec2(c1, c2), 0.5);\n  }\n  vec2 warped = p + uWarpAmount * warp;\n\n  // Cursor swirl — rotate p around uCursor with radial falloff.\n  // This warps the underlying color field so the bands sweep around the pointer.\n  if (uCursorStrength > 0.001) {\n    vec2 toP = p - uCursor;\n    float d = length(toP);\n    float r = max(uCursorRadius, 0.01);\n    // Smooth falloff; strong near cursor, zero beyond ~1.5× radius.\n    float w = exp(-(d * d) / (r * r * 0.45));\n    // Max rotation ~120° at cursor center, scaled by strength\n    float ang = w * uCursorStrength * 2.1;\n    float ca = cos(ang), sa = sin(ang);\n    vec2 rotated = vec2(ca * toP.x - sa * toP.y, sa * toP.x + ca * toP.y) + uCursor;\n    // Also pinch slightly toward the cursor (gravity) — adds depth to swirl\n    float pinch = w * uCursorStrength * 0.08;\n    rotated = mix(rotated, uCursor, pinch);\n    // Blend original warped position with cursor-rotated version\n    warped = mix(warped, rotated + uWarpAmount * warp * 0.7, w * uCursorStrength);\n  }\n\n  return warped;\n}\n\n// ── Palette LUT ───────────────────────────────────────────────────────────\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// ── Nuclei field ──────────────────────────────────────────────────────────\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 — slow global paletteId breathe between adjacent stops. The\n  // rate rides K_PAL (perceptible ~30–60s 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\n// ── Flow field ────────────────────────────────────────────────────────────\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 — 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 — 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 — 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 — 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\n// ── Color utils ───────────────────────────────────────────────────────────\nconst vec3 W_LUMA = vec3(0.2126, 0.7152, 0.0722);\n\nvec3 hueShift(vec3 c, float degrees) {\n  float a = radians(degrees);\n  float co = cos(a), si = sin(a);\n  mat3 m = mat3(\n    0.299 + 0.701 * co + 0.168 * si,\n    0.587 - 0.587 * co + 0.330 * si,\n    0.114 - 0.114 * co - 0.497 * si,\n\n    0.299 - 0.299 * co - 0.328 * si,\n    0.587 + 0.413 * co + 0.035 * si,\n    0.114 - 0.114 * co + 0.292 * si,\n\n    0.299 - 0.300 * co + 1.250 * si,\n    0.587 - 0.588 * co - 1.050 * si,\n    0.114 + 0.886 * co - 0.203 * si\n  );\n  return m * c;\n}\n\nvec3 brokenColorJitter(vec3 c, float hueSeed, float valueSeed, float strength) {\n  float amt = clamp(uBrokenColor * strength, 0.0, 1.0);\n  if (amt <= 0.001) return c;\n  float hueDeg = (hueSeed - 0.5) * 32.0 * amt;\n  float valueMul = 1.0 + (valueSeed - 0.5) * 0.28 * amt;\n  return max(hueShift(c, hueDeg) * valueMul, vec3(0.0));\n}\n\nvec3 saturate3(vec3 c, float amt) {\n  float l = dot(c, W_LUMA);\n  return mix(vec3(l), c, amt);\n}\n\n// 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\n// ── Medium overlays ───────────────────────────────────────────────────────\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 — 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 — 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 — 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\n// ── Curved swept brushstroke primitive ────────────────────────────────────\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·K·along0·(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 — 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    — thin-fat-thin (classic brush)\n//   1 load-drag  — fat start, tapers to a point\n//   2 dab        — ellipse-like, round center\n//   3 even       — 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           — endpoints\n//   halfW          — base half-width (world units)\n//   bulge          — signed perpendicular midpoint offset, in world units\n//   shapeType      — 0..3\n//   bristleFreq    — spatial frequency of edge raggedness\n//   bristleAmp     — 0..0.5 fraction of halfW chewed away at edge extrema\n//   streakSeed     — uniqueness seed for internal streaks\n//   colAtMid       — 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    // razor-hard edge with tiny aa\n    cov = 1.0 - smoothstep(0.88, 1.02, 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    capA = 1.0 - smoothstep(rA * 0.85, rA * 1.05, dA);\n    capB = 1.0 - smoothstep(rB * 0.85, rB * 1.05, 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    — 0..0.2 how much internal streaks darken/lighten\n//   impastoAmp   — 0..1 edge catch-light strength\n//   hardness     — 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 — 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 — 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 — 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\n// ── Crayon / oil-pastel — paper tooth × wax pigment ───────────────────────\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.\nvec3 mediumOil_crayon(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 — 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 — 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 — 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):\n  //   0 oil         — balanced modern-abstract/palette-knife hybrid\n  //   1 knife       — palette-knife impasto: razor edges, heavy bristle/shadow\n  //   2 crayon      — soft-edged wax smudges on tooth (no straight segments)\n  //   3 brushwork   — 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 == 2) { // crayon — handled specially below\n    return mediumOil_crayon(col, p, t);\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 — no grid\n  vec2 flow = flowField(p, t);\n\n  vec3 result = col;\n\n  // Layer 1 — 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 — 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 — 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 — fill dabs (very dense, very small) — 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 — 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}\n\n// ── Main ──────────────────────────────────────────────────────────────────\nvoid main() {\n  // Normalized 0..1 coordinates for nuclei, domain warp, and medium sampling.\n  vec2 uv = vUv;\n  vec2 pN = uv;\n\n  float t = uTime;\n\n  // Warp in pN space\n  vec2 p_warp = domainWarp(pN, t);\n\n  // Composition\n  float paletteId; float valueMod;\n  nucleiField(p_warp, t, paletteId, valueMod);\n  vec3 col = samplePalette(paletteId);\n  col *= 1.0 + uValueVariance * valueMod;\n\n  // Breath — slow global luminance wobble\n  float breath = sin(t * 6.2831 / max(uBreathPeriod, 1.0));\n  col *= 1.0 + uBreathDepth * breath * 0.5;\n\n  // Medium\n  if (uMedium == 1) col = mediumPastel(col, pN, t);\n  else if (uMedium == 2) col = mediumWatercolor(col, pN, t);\n  else if (uMedium == 3) col = mediumOil(col, pN, t);\n\n  // Saturation trim\n  col = saturate3(col, uSaturation);\n\n  // Tonemap + film grain\n  col = aces(col);\n  float grain = hash21(gl_FragCoord.xy + t * 17.0);\n  col += (grain - 0.5) * uPaperGrain;\n\n  col = clamp(col * 0.985 + 0.008, 0.0, 1.0);\n  fragColor = vec4(col * uAlpha, uAlpha);\n}\n";
+import { a as t, i as n, n as r, o as i, r as a, t as o } from "./compile-DVgAxagk.js";
+import { n as s, r as c, t as l } from "./presets-1OhFpaIC.js";
+import { a as u, r as d, t as f } from "./color-rkK4RMx2.js";
+import { t as p } from "./useIntersectionPause-DAdVPVp4.js";
+import { computed as m, createElementBlock as h, createElementVNode as g, defineComponent as _, normalizeClass as v, normalizeStyle as y, onBeforeUnmount as b, onMounted as x, openBlock as S, readonly as C, ref as w, unref as ee, watch as T } from "vue";
+import { gamutMapOKLab as E, isInSRGBGamut as D, oklabToLinearSRGB as O, rawOklabToOklch as k, rawOklchToOklab as A, srgbToOKLab as te } from "@mkbabb/value.js";
+//#region src/components/custom/aurora/constants/shaders/aurora.vert.ts
+var ne = "#version 300 es\nin vec2 aPos;\nout vec2 vUv;\nvoid main() {\n  vUv = aPos * 0.5 + 0.5;\n  gl_Position = vec4(aPos, 0.0, 1.0);\n}", re = "// ── Palette LUT ───────────────────────────────────────────────────────────\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// ── Nuclei field ──────────────────────────────────────────────────────────\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 — slow global paletteId breathe between adjacent stops. The\n  // rate rides K_PAL (perceptible ~30–60s 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", ie = "// ── Flow field ────────────────────────────────────────────────────────────\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 — 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 — 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 — 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 — 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", ae = "// 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", oe = "// ── Curved swept brushstroke primitive ────────────────────────────────────\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·K·along0·(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 — 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    — thin-fat-thin (classic brush)\n//   1 load-drag  — fat start, tapers to a point\n//   2 dab        — ellipse-like, round center\n//   3 even       — 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           — endpoints\n//   halfW          — base half-width (world units)\n//   bulge          — signed perpendicular midpoint offset, in world units\n//   shapeType      — 0..3\n//   bristleFreq    — spatial frequency of edge raggedness\n//   bristleAmp     — 0..0.5 fraction of halfW chewed away at edge extrema\n//   streakSeed     — uniqueness seed for internal streaks\n//   colAtMid       — 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    — 0..0.2 how much internal streaks darken/lighten\n//   impastoAmp   — 0..1 edge catch-light strength\n//   hardness     — 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 — 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 — 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 — 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", j = "// ── Medium overlays ───────────────────────────────────────────────────────\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 — 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 — 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 — 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", M = "// ── Crayon / oil-pastel — paper tooth × wax pigment (PEER medium) ─────────\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 — 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 — 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 — 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 — 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) — oil-stroke modes ONLY (crayon is a peer medium,\n  // uMedium==4, dispatched at main()):\n  //   0 oil         — balanced modern-abstract/palette-knife hybrid\n  //   1 knife       — palette-knife impasto: razor edges, heavy bristle/shadow\n  //   3 brushwork   — 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 — no grid\n  vec2 flow = flowField(p, t);\n\n  vec3 result = col;\n\n  // Layer 1 — 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 — 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 — 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 — fill dabs (very dense, very small) — 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 — 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}", N = "\n", P = `#version 300 es
+precision highp float;
+
+in vec2 vUv;
+out vec4 fragColor;
+
+#define MAX_NUCLEI 6
+#define MAX_STOPS  8
+
+// ── Uniforms ───────────────────────────────────────────────────────────────
+uniform float uTime;
+
+// Palette baked CPU-side to linear-sRGB
+uniform vec3  uPalette[MAX_STOPS];
+uniform int   uStopCount;
+
+// Nuclei (parallel arrays)
+uniform int   uNucleiCount;
+uniform vec2  uNucleiPos[MAX_NUCLEI];
+uniform float uNucleiRadius[MAX_NUCLEI];
+uniform float uNucleiPaletteBias[MAX_NUCLEI];
+uniform float uNucleiValueBias[MAX_NUCLEI];
+uniform float uNucleiDriftRadius[MAX_NUCLEI];
+uniform float uNucleiDriftPhase[MAX_NUCLEI];
+// Anisotropy: per-nucleus elongation (1.0 = isotropic) and major-axis angle (radians).
+// Defaults (1.0 / 0.0) reduce to the original circular Gaussian.
+uniform float uNucleiElong[MAX_NUCLEI];
+uniform float uNucleiAngle[MAX_NUCLEI];
+uniform float uSoftmaxBeta;
+uniform float uValueVariance;
+
+// Warp
+uniform float uWarpAmount;
+uniform float uWarpScale;
+uniform float uWarpDrift;
+uniform int   uWarpMode;      // 0=fbm 1=cellular 2=hybrid
+uniform int   uNoiseOctaves;
+
+// Medium
+// 0 smooth, 1 pastel, 2 watercolor, 3 oil, 4 crayon (peer medium — wax pigment
+// on paper tooth; NOT an oil-stroke sub-mode, so it dispatches at main() level).
+uniform int   uMedium;
+uniform int   uFlowPattern;   // 0 none, 1 radial, 2 swirl, 3 diagonal, 4 multi
+uniform vec2  uFlowFocal;
+uniform float uFlowAngle;
+uniform float uFlowCurl;
+uniform vec2  uCursor;          // in 0..1 screen space (matches pN)
+uniform float uCursorStrength;  // 0..1 attraction amount
+uniform float uCursorRadius;    // radius of influence (0.05..0.5)
+uniform float uStrokeAmount;
+uniform float uStrokeScale;
+uniform float uStrokeAnisotropy;
+uniform int   uStrokeLayers;  // 1 or 2 (crosshatch)
+uniform int   uStrokeMode;    // 0 oil (modern gestural), 1 palette-knife, 3 modern-chunky (crayon is uMedium==4, a peer medium)
+uniform float uWetEdge;
+uniform float uGranulation;
+uniform float uImpasto;
+uniform float uBrokenColor;
+uniform float uCanvasGrain;
+
+// Motion
+uniform float uNucleiDrift;
+uniform float uPaletteDrift;
+uniform float uBreathDepth;
+uniform float uBreathPeriod;
+
+// Output
+uniform float uSaturation;
+uniform float uPaperGrain;
+uniform float uAlpha;
+
+// ── Time rate ────────────────────────────────────────────────────────────────
+// The authoring coefficients (uNucleiDrift, uPaletteDrift, uWarpDrift) live in a
+// human-friendly 0..~0.05 band — that scale is what the config schema and every
+// demo preset are tuned against. But that band, multiplied straight into uTime
+// (seconds), yields rad/sec rates so small the field reads visually static (one
+// nuclei orbit took ~10 min at the old default). These K_* constants decouple
+// the AUTHORING scale from the RAD/SEC scale: each time term wraps its coefficient
+// in the matching K_, lifting the same authored value to a perceptible period
+// without touching any preset. Tuned so the field reads SLOWLY ALIVE — drift over
+// a ~5–15s window, never a frantic pan. These are downstream of uTime, which the
+// runtime FREEZES under reduced-motion (t = frozenOffset) before the shader sees
+// it, so the lift cannot leak motion into the reduced-motion path.
+const float K_NUCLEI = 14.0; // nuclei orbit: ~one cycle per ~45s at default 0.01
+const float K_PAL    = 24.0; // palette hue breathe: ~one cycle per ~33s at default
+const float K_WARP   = 5.0;  // domain warp scroll: a perceptible fbm-cell traverse
+
+// ── Noise ──────────────────────────────────────────────────────────────────
+float hash21(vec2 p) {
+  p = fract(p * vec2(123.34, 456.21));
+  p += dot(p, p + 45.32);
+  return fract(p.x * p.y);
+}
+
+vec2 hash22(vec2 p) {
+  p = vec2(dot(p, vec2(127.1, 311.7)),
+           dot(p, vec2(269.5, 183.3)));
+  return fract(sin(p) * 43758.5453);
+}
+
+float vnoise(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  vec2 u = f * f * (3.0 - 2.0 * f);
+  float a = hash21(i);
+  float b = hash21(i + vec2(1.0, 0.0));
+  float c = hash21(i + vec2(0.0, 1.0));
+  float d = hash21(i + vec2(1.0, 1.0));
+  return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);
+}
+
+// The rotated-octave FBM rotation constant — spliced from the shared chunk (AV.W2
+// — the one FBM_ROT). The loop below stays aurora-local (2.02 lacunarity +
+// uniform-driven octaves, per §3a — only the rotation constant converges).
+${t}
+
+float fbm(vec2 p) {
+  float v = 0.0;
+  float a = 0.5;
+  for (int i = 0; i < 5; i++) {
+    if (i >= uNoiseOctaves) break;
+    v += a * vnoise(p);
+    p = FBM_ROT * p * 2.02;
+    a *= 0.5;
+  }
+  return v;
+}
+
+// The sRGB OETF (linearToSrgb) — spliced from the shared procedural-color chunk
+// (AV.W2 — the single OETF source; the AV.W1 local copy is deleted here). Aurora's
+// linear pipeline closes the seam with this transfer before fragColor (the
+// proof:aurora-space-gamma seam).
+${i}
+
+// Interleaved Gradient Noise (Jimenez) — a 1-LSB triangular dither applied in
+// DISPLAY space AFTER the OETF, so 8-bit mid-tone banding on the soft gradient is
+// quantization-dithered at the value being quantized (post-transfer, not linear).
+float ign(vec2 p) {
+    return fract(52.9829189 * fract(dot(p, vec2(0.06711056, 0.00583715))));
+}
+
+// Cellular / Worley f1
+float cellular(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  float m = 1e9;
+  for (int y = -1; y <= 1; y++) {
+    for (int x = -1; x <= 1; x++) {
+      vec2 g = vec2(float(x), float(y));
+      vec2 o = hash22(i + g);
+      vec2 r = g + o - f;
+      m = min(m, dot(r, r));
+    }
+  }
+  return sqrt(m);
+}
+
+// ── Warp ──────────────────────────────────────────────────────────────────
+vec2 domainWarp(vec2 p, float t) {
+  // Quilez canonical double warp
+  vec2 q = vec2(fbm(p * uWarpScale + vec2(0.0, 0.0) + t * uWarpDrift * K_WARP),
+                fbm(p * uWarpScale + vec2(5.2, 1.3) + t * uWarpDrift * K_WARP));
+  vec2 r = vec2(fbm(p * uWarpScale + 4.0 * q + vec2(1.7, 9.2)),
+                fbm(p * uWarpScale + 4.0 * q + vec2(8.3, 2.8)));
+
+  vec2 warp = r;
+  if (uWarpMode == 1) {
+    // cellular — chunky territories (MEADOW block-like)
+    float c1 = cellular(p * uWarpScale * 1.5 + vec2(t * uWarpDrift * K_WARP * 2.0, 0.0));
+    float c2 = cellular(p * uWarpScale * 1.5 + vec2(11.0, 7.0 + t * uWarpDrift * K_WARP * 2.0));
+    warp = vec2(c1, c2);
+  } else if (uWarpMode == 2) {
+    // hybrid — fbm + cellular averaged
+    float c1 = cellular(p * uWarpScale * 1.2);
+    float c2 = cellular(p * uWarpScale * 1.2 + vec2(11.0, 7.0));
+    warp = mix(r, vec2(c1, c2), 0.5);
+  }
+  vec2 warped = p + uWarpAmount * warp;
+
+  // Cursor swirl — rotate p around uCursor with radial falloff.
+  // This warps the underlying color field so the bands sweep around the pointer.
+  if (uCursorStrength > 0.001) {
+    vec2 toP = p - uCursor;
+    float d = length(toP);
+    float r = max(uCursorRadius, 0.01);
+    // Smooth falloff; strong near cursor, zero beyond ~1.5× radius.
+    float w = exp(-(d * d) / (r * r * 0.45));
+    // Max rotation ~120° at cursor center, scaled by strength
+    float ang = w * uCursorStrength * 2.1;
+    float ca = cos(ang), sa = sin(ang);
+    vec2 rotated = vec2(ca * toP.x - sa * toP.y, sa * toP.x + ca * toP.y) + uCursor;
+    // Also pinch slightly toward the cursor (gravity) — adds depth to swirl
+    float pinch = w * uCursorStrength * 0.08;
+    rotated = mix(rotated, uCursor, pinch);
+    // Blend original warped position with cursor-rotated version
+    warped = mix(warped, rotated + uWarpAmount * warp * 0.7, w * uCursorStrength);
+  }
+
+  return warped;
+}
+
+` + re + N + ie + N + "// ── Color utils ───────────────────────────────────────────────────────────\nconst vec3 W_LUMA = vec3(0.2126, 0.7152, 0.0722);\n\nvec3 hueShift(vec3 c, float degrees) {\n  float a = radians(degrees);\n  float co = cos(a), si = sin(a);\n  mat3 m = mat3(\n    0.299 + 0.701 * co + 0.168 * si,\n    0.587 - 0.587 * co + 0.330 * si,\n    0.114 - 0.114 * co - 0.497 * si,\n\n    0.299 - 0.299 * co - 0.328 * si,\n    0.587 + 0.413 * co + 0.035 * si,\n    0.114 - 0.114 * co + 0.292 * si,\n\n    0.299 - 0.300 * co + 1.250 * si,\n    0.587 - 0.588 * co - 1.050 * si,\n    0.114 + 0.886 * co - 0.203 * si\n  );\n  return m * c;\n}\n\nvec3 brokenColorJitter(vec3 c, float hueSeed, float valueSeed, float strength) {\n  float amt = clamp(uBrokenColor * strength, 0.0, 1.0);\n  if (amt <= 0.001) return c;\n  float hueDeg = (hueSeed - 0.5) * 32.0 * amt;\n  float valueMul = 1.0 + (valueSeed - 0.5) * 0.28 * amt;\n  return max(hueShift(c, hueDeg) * valueMul, vec3(0.0));\n}\n\nvec3 saturate3(vec3 c, float amt) {\n  float l = dot(c, W_LUMA);\n  return mix(vec3(l), c, amt);\n}\n\n" + ae + N + j + N + oe + N + M + N + "\n// ── Main ──────────────────────────────────────────────────────────────────\nvoid main() {\n  // Normalized 0..1 coordinates for nuclei, domain warp, and medium sampling.\n  vec2 uv = vUv;\n  vec2 pN = uv;\n\n  float t = uTime;\n\n  // Warp in pN space\n  vec2 p_warp = domainWarp(pN, t);\n\n  // Composition\n  float paletteId; float valueMod;\n  nucleiField(p_warp, t, paletteId, valueMod);\n  vec3 col = samplePalette(paletteId);\n  col *= 1.0 + uValueVariance * valueMod;\n\n  // Breath — slow global luminance wobble\n  float breath = sin(t * 6.2831 / max(uBreathPeriod, 1.0));\n  col *= 1.0 + uBreathDepth * breath * 0.5;\n\n  // Medium — crayon (4) is a peer dispatched here, not a mediumOil sub-mode.\n  if (uMedium == 1) col = mediumPastel(col, pN, t);\n  else if (uMedium == 2) col = mediumWatercolor(col, pN, t);\n  else if (uMedium == 3) col = mediumOil(col, pN, t);\n  else if (uMedium == 4) col = mediumCrayon(col, pN, t);\n\n  // Saturation trim\n  col = saturate3(col, uSaturation);\n\n  // Tonemap + film grain\n  col = aces(col);\n  float grain = hash21(gl_FragCoord.xy + t * 17.0);\n  col += (grain - 0.5) * uPaperGrain;\n\n  col = clamp(col * 0.985 + 0.008, 0.0, 1.0);\n\n  // MANDATORY OETF — closes the seam (mirrors metaball.frag.ts:278). The whole\n  // pipeline above (linear palette LUT, ACES tonemap, grain) runs in LINEAR; without\n  // this transfer the aurora ships ~2.2× too dark (linear 0.5 → ~0.215, not ~0.735).\n  col = linearToSrgb(col);\n\n  // 1-LSB triangular IGN dither in DISPLAY space, AFTER the OETF — breaks 8-bit\n  // mid-tone banding on the soft gradient. Texture-free (the canonical Jimenez IGN).\n  col += (1.0 / 255.0) * (ign(gl_FragCoord.xy) - 0.5);\n\n  // Premultiply operates on DISPLAY-space color (matches the blob: OETF, then premul).\n  fragColor = vec4(col * uAlpha, uAlpha);\n}\n", F = "[Aurora]", I = /* @__PURE__ */ "uTime.uPalette.uStopCount.uNucleiCount.uNucleiPos.uNucleiRadius.uNucleiPaletteBias.uNucleiValueBias.uNucleiDriftRadius.uNucleiDriftPhase.uNucleiElong.uNucleiAngle.uSoftmaxBeta.uValueVariance.uWarpAmount.uWarpScale.uWarpDrift.uWarpMode.uNoiseOctaves.uMedium.uFlowPattern.uFlowFocal.uFlowAngle.uFlowCurl.uCursor.uCursorStrength.uCursorRadius.uStrokeAmount.uStrokeScale.uStrokeAnisotropy.uStrokeLayers.uStrokeMode.uWetEdge.uGranulation.uImpasto.uBrokenColor.uCanvasGrain.uNucleiDrift.uPaletteDrift.uBreathDepth.uBreathPeriod.uSaturation.uPaperGrain.uAlpha".split(".");
+function L(e, t, n) {
+	let i = o(e, e.VERTEX_SHADER, t, F), a = o(e, e.FRAGMENT_SHADER, n, F), s = r(e, i, a, F);
+	e.useProgram(s);
+	let c = e.createVertexArray();
+	e.bindVertexArray(c);
+	let l = e.createBuffer();
+	e.bindBuffer(e.ARRAY_BUFFER, l), e.bufferData(e.ARRAY_BUFFER, new Float32Array([
+		-1,
+		-1,
+		3,
+		-1,
+		-1,
+		3
+	]), e.STATIC_DRAW);
+	let u = e.getAttribLocation(s, "aPos");
+	e.enableVertexAttribArray(u), e.vertexAttribPointer(u, 2, e.FLOAT, !1, 0, 0);
+	let d = {};
+	for (let t of I) d[t] = e.getUniformLocation(s, t);
+	return {
+		program: s,
+		vs: i,
+		fs: a,
+		uniforms: d,
+		geometry: {
+			vao: c,
+			buf: l
+		}
+	};
+}
 //#endregion
 //#region src/components/custom/aurora/composables/color.ts
-function k(e) {
-	let [t, n, r] = T(e.L, e.C, e.h), [i, a, o] = x(t, n, r);
-	return [
-		Math.max(0, i),
-		Math.max(0, a),
-		Math.max(0, o)
-	];
-}
-function A(e, t = 8, n) {
+function R(e, t = 8, n) {
 	let r = n ?? new Float32Array(t * 3), i = Math.min(e.length, t);
 	for (let t = 0; t < i; t++) {
-		let [n, i, a] = k(e[t]);
+		let [n, i, a] = u(e[t]);
 		r[t * 3 + 0] = n, r[t * 3 + 1] = i, r[t * 3 + 2] = a;
 	}
 	for (let e = i; e < t; e++) r[e * 3 + 0] = 0, r[e * 3 + 1] = 0, r[e * 3 + 2] = 0;
 	return r;
 }
-function j(e) {
+function z(e) {
 	if (e.length === 0) return "transparent";
-	if (e.length === 1) return M(e[0]);
+	if (e.length === 1) return d(e[0]);
 	let t = e.length;
 	return `linear-gradient(135deg, ${e.map((e, n) => {
 		let r = Math.round(n / (t - 1) * 100);
-		return `${M(e)} ${r}%`;
+		return `${d(e)} ${r}%`;
 	}).join(", ")})`;
 }
-function M(e) {
-	let [t, n, r] = T(e.L, e.C, e.h), [i, a, o] = S(t, n, r), s = (e) => Math.round(e).toString(16).padStart(2, "0");
-	return `#${s(i)}${s(a)}${s(o)}`;
-}
-function N(e) {
-	let t = e.replace("#", ""), n = parseInt(t.slice(0, 2), 16), r = parseInt(t.slice(2, 4), 16), i = parseInt(t.slice(4, 6), 16), [a, o, s] = E(n / 255, r / 255, i / 255), [c, l, u] = w(a, o, s);
+function B(e) {
+	let t = e.replace("#", ""), n = parseInt(t.slice(0, 2), 16), r = parseInt(t.slice(2, 4), 16), i = parseInt(t.slice(4, 6), 16), [a, o, s] = te(n / 255, r / 255, i / 255), [c, l, u] = k(a, o, s);
 	return {
 		L: c,
 		C: l,
 		h: u
 	};
 }
-function P(e) {
-	let t = v(C(e), "rgb").value, [n, r, i] = E(Number(t.r), Number(t.g), Number(t.b)), [a, o, s] = w(n, r, i);
-	return {
-		L: a,
-		C: o,
-		h: s
-	};
-}
-var F = [.35, .95];
-function I(e, t = {}) {
-	let n = typeof e == "string" ? P(e) : e, { stopCount: r = 4, harmony: i = "analogous", lightnessSpread: a = .32, chromaFalloff: o = .85, hueSpread: s = 28 } = t, c = Math.max(2, Math.min(8, Math.round(r))), [l, u] = F, d = n.L - a / 2, f = n.L + a / 2;
-	d < l && (f += l - d, d = l), f > u && (d -= f - u, f = u), d = Math.max(l, d), f = Math.min(u, f);
-	let p = [];
+var V = [.35, .95];
+function H(e, t = {}) {
+	let n = typeof e == "string" ? f(e) : e, { stopCount: r = 4, harmony: i = "analogous", lightnessSpread: a = .32, chromaFalloff: o = .85, hueSpread: s = 28 } = t, c = Math.max(2, Math.min(8, Math.round(r))), [l, u] = V, d = n.L - a / 2, p = n.L + a / 2;
+	d < l && (p += l - d, d = l), p > u && (d -= p - u, p = u), d = Math.max(l, d), p = Math.min(u, p);
+	let m = [];
 	for (let e = 0; e < c; e++) {
-		let t = c === 1 ? 0 : e / (c - 1), r = d + (f - d) * t, a = n.C * (1 - (1 - o) * t), l = L(n.h, i, s, t);
-		p.push(R({
+		let t = c === 1 ? 0 : e / (c - 1), r = d + (p - d) * t, a = n.C * (1 - (1 - o) * t), l = U(n.h, i, s, t);
+		m.push(W({
 			L: r,
 			C: a,
 			h: l
 		}));
 	}
-	return p;
+	return m;
 }
-function L(e, t, n, r) {
+function U(e, t, n, r) {
 	let i = (e) => (e % 360 + 360) % 360;
 	switch (t) {
 		case "monochrome": return i(e);
@@ -77,11 +289,11 @@ function L(e, t, n, r) {
 		default: return i(e + n * (r - .5) * 2);
 	}
 }
-function R(e) {
-	let [t, n, r] = T(e.L, e.C, e.h), [i, a, o] = y(t, n, r), [s, c, l] = w(i, a, o), u = c;
+function W(e) {
+	let [t, n, r] = A(e.L, e.C, e.h), [i, a, o] = E(t, n, r), [s, c, l] = k(i, a, o), u = c;
 	for (let e = 0; e < 6; e++) {
-		let [e, t, n] = T(s, u, l), [r, i, a] = x(e, t, n);
-		if (b(r, i, a)) break;
+		let [e, t, n] = A(s, u, l), [r, i, a] = O(e, t, n);
+		if (D(r, i, a)) break;
 		u *= .999;
 	}
 	return {
@@ -91,69 +303,63 @@ function R(e) {
 	};
 }
 //#endregion
-//#region src/components/custom/aurora/composables/runtime.ts
-var z = {
+//#region src/components/custom/aurora/composables/uniformBridge.ts
+var G = {
 	smooth: 0,
 	pastel: 1,
 	watercolor: 2,
-	oil: 3
-}, B = {
+	oil: 3,
+	crayon: 4
+}, K = {
 	none: 0,
 	radial: 1,
 	swirl: 2,
 	diagonal: 3,
 	multi: 4
-}, V = {
+}, se = {
 	fbm: 0,
 	cellular: 1,
 	hybrid: 2
-}, H = {
+}, q = {
 	oil: 0,
 	knife: 1,
-	crayon: 2,
 	chunky: 3
-}, U = .22, W = .18, G = .992, K = .001;
-function q(e) {
-	return e.mode === "capture" ? !0 : e.initStrategy === "eager";
+};
+function ce(e) {
+	return e.medium === "oil" && e.strokeMode === "crayon" ? G.crayon : G[e.medium];
 }
-function J(e) {
-	return typeof e.preserveDrawingBuffer == "boolean" ? e.preserveDrawingBuffer : e.mode === "capture";
+function le(e) {
+	return e.strokeMode === "crayon" ? q.oil : q[e.strokeMode];
 }
-function Y(e, t, n) {
-	let r = e.createShader(t);
-	if (e.shaderSource(r, n), e.compileShader(r), !e.getShaderParameter(r, e.COMPILE_STATUS)) {
-		let t = e.getShaderInfoLog(r) ?? "unknown";
-		throw e.deleteShader(r), Error(`[Aurora] shader compile failed:\n${t}`);
-	}
-	return r;
-}
-function ee(e, t, n) {
-	let r = e.createProgram();
-	if (e.attachShader(r, t), e.attachShader(r, n), e.linkProgram(r), !e.getProgramParameter(r, e.LINK_STATUS)) {
-		let t = e.getProgramInfoLog(r) ?? "unknown";
-		throw e.deleteProgram(r), Error(`[Aurora] program link failed:\n${t}`);
-	}
-	return r;
+function ue(e, t, n, r) {
+	let i = (e) => 1 - e, a = {
+		palette: new Float32Array(24),
+		pos: new Float32Array(12),
+		rad: new Float32Array(6),
+		pb: new Float32Array(6),
+		vb: new Float32Array(6),
+		dr: new Float32Array(6),
+		dp: new Float32Array(6),
+		elong: new Float32Array(6),
+		angle: new Float32Array(6)
+	};
+	return function(o) {
+		e.useProgram(t), R(o.palette, 8, a.palette), e.uniform3fv(n.uPalette, a.palette), e.uniform1i(n.uStopCount, Math.min(o.palette.length, 8));
+		let s = Math.min(o.nuclei.length, 6);
+		e.uniform1i(n.uNucleiCount, s);
+		for (let e = 0; e < s; e++) {
+			let t = o.nuclei[e];
+			a.pos[e * 2 + 0] = t.x, a.pos[e * 2 + 1] = i(t.y), a.rad[e] = t.radius, a.pb[e] = t.paletteBias, a.vb[e] = t.valueBias, a.dr[e] = t.driftRadius, a.dp[e] = t.driftPhase, a.elong[e] = t.elongation ?? 1, a.angle[e] = -(t.angle ?? 0) * Math.PI / 180;
+		}
+		for (let e = s; e < 6; e++) a.pos[e * 2 + 0] = 0, a.pos[e * 2 + 1] = 0, a.rad[e] = 0, a.pb[e] = 0, a.vb[e] = 0, a.dr[e] = 0, a.dp[e] = 0, a.elong[e] = 1, a.angle[e] = 0;
+		e.uniform2fv(n.uNucleiPos, a.pos), e.uniform1fv(n.uNucleiRadius, a.rad), e.uniform1fv(n.uNucleiPaletteBias, a.pb), e.uniform1fv(n.uNucleiValueBias, a.vb), e.uniform1fv(n.uNucleiDriftRadius, a.dr), e.uniform1fv(n.uNucleiDriftPhase, a.dp), e.uniform1fv(n.uNucleiElong, a.elong), e.uniform1fv(n.uNucleiAngle, a.angle), e.uniform1f(n.uSoftmaxBeta, o.softmaxBeta), e.uniform1f(n.uValueVariance, o.valueVariance), e.uniform1f(n.uWarpAmount, o.warpAmount), e.uniform1f(n.uWarpScale, o.warpScale), e.uniform1f(n.uWarpDrift, o.warpDrift), e.uniform1i(n.uWarpMode, se[o.warpMode]), e.uniform1i(n.uNoiseOctaves, o.noiseOctaves), e.uniform1i(n.uMedium, ce(o)), e.uniform1i(n.uFlowPattern, K[o.flow.pattern]), e.uniform2f(n.uFlowFocal, o.flow.focalX, i(o.flow.focalY)), e.uniform1f(n.uFlowAngle, o.flow.angle), e.uniform1f(n.uFlowCurl, o.flow.curl), e.uniform2f(n.uCursor, r.x, i(r.y)), e.uniform1f(n.uCursorStrength, r.strength), e.uniform1f(n.uCursorRadius, r.radius), e.uniform1f(n.uStrokeAmount, o.strokeAmount), e.uniform1f(n.uStrokeScale, o.strokeScale), e.uniform1f(n.uStrokeAnisotropy, o.strokeAnisotropy), e.uniform1i(n.uStrokeLayers, o.strokeLayers), e.uniform1i(n.uStrokeMode, le(o)), e.uniform1f(n.uWetEdge, o.wetEdge), e.uniform1f(n.uGranulation, o.granulation), e.uniform1f(n.uImpasto, o.impasto), e.uniform1f(n.uBrokenColor, o.brokenColor), e.uniform1f(n.uCanvasGrain, o.canvasGrain), e.uniform1f(n.uNucleiDrift, o.nucleiDrift), e.uniform1f(n.uPaletteDrift, o.paletteDrift), e.uniform1f(n.uBreathDepth, o.breathDepth), e.uniform1f(n.uBreathPeriod, o.breathPeriod), e.uniform1f(n.uSaturation, o.saturation), e.uniform1f(n.uPaperGrain, o.paperGrain), e.uniform1f(n.uAlpha, o.alpha);
+	};
 }
-var te = /* @__PURE__ */ "uTime.uPalette.uStopCount.uNucleiCount.uNucleiPos.uNucleiRadius.uNucleiPaletteBias.uNucleiValueBias.uNucleiDriftRadius.uNucleiDriftPhase.uNucleiElong.uNucleiAngle.uSoftmaxBeta.uValueVariance.uWarpAmount.uWarpScale.uWarpDrift.uWarpMode.uNoiseOctaves.uMedium.uFlowPattern.uFlowFocal.uFlowAngle.uFlowCurl.uCursor.uCursorStrength.uCursorRadius.uStrokeAmount.uStrokeScale.uStrokeAnisotropy.uStrokeLayers.uStrokeMode.uWetEdge.uGranulation.uImpasto.uBrokenColor.uCanvasGrain.uNucleiDrift.uPaletteDrift.uBreathDepth.uBreathPeriod.uSaturation.uPaperGrain.uAlpha".split(".");
-function X(e, t, n = {}) {
-	let r = J(n), i = t, a = /* @__PURE__ */ new Set();
-	n.mode === "capture" && a.add("manual");
-	let o = () => a.size === 0, s = typeof window < "u" && window.matchMedia ? window.matchMedia("(prefers-reduced-motion: reduce)").matches : !1, c = performance.now(), l = 0, u = null;
-	function d(e) {
-		let t = o();
-		a.add(e), t && !o() && (cancelAnimationFrame(l), l = 0);
-	}
-	function f(e) {
-		let t = !o();
-		a.delete(e), t && o() && u && (c = performance.now() - 1e3, u());
-	}
-	let p = typeof document < "u";
-	function m() {
-		document.hidden ? d("tab-hidden") : f("tab-hidden");
-	}
-	p && document.addEventListener("visibilitychange", m);
-	let h = {
+//#endregion
+//#region src/components/custom/aurora/composables/cursorModel.ts
+var J = .22, de = .18, fe = .992;
+function pe() {
+	return {
 		x: .5,
 		y: .5,
 		targetX: .5,
@@ -161,127 +367,104 @@ function X(e, t, n = {}) {
 		strength: 0,
 		targetStrength: 0,
 		radius: .25
-	}, g = null, _ = !1;
-	function v(e, t, n = .8) {
-		h.targetX = e, h.targetY = t, h.targetStrength = n, g?.wake();
-	}
-	function y() {
-		h.targetStrength = 0, g?.wake();
-	}
-	function b(e) {
-		h.radius = e, g?.wake();
+	};
+}
+function me(e) {
+	e.x += (e.targetX - e.x) * J, e.y += (e.targetY - e.y) * J, e.strength += (e.targetStrength - e.strength) * de, e.targetStrength *= fe;
+}
+function he(e) {
+	return e.targetStrength > .001 || e.strength > .001 || Math.abs(e.x - e.targetX) > .001 || Math.abs(e.y - e.targetY) > .001;
+}
+//#endregion
+//#region src/components/custom/aurora/composables/frameLoop.ts
+function ge(e) {
+	let { gl: t, prog: n, uniforms: r, cursor: i, getConfig: a, getReducedMotion: o } = e, s = (e) => 1 - e;
+	function c(e) {
+		t.useProgram(n), t.uniform2f(r.uCursor, i.x, s(i.y)), t.uniform1f(r.uCursorStrength, i.strength), t.uniform1f(r.uCursorRadius, i.radius), t.uniform1f(r.uTime, e), t.clear(t.COLOR_BUFFER_BIT), t.drawArrays(t.TRIANGLES, 0, 3);
 	}
-	function x(e) {
-		s = e, g?.wake();
+	function l() {
+		if (o()) return !1;
+		let e = a();
+		return e.nucleiDrift !== 0 || e.paletteDrift !== 0 || e.breathDepth !== 0 || e.warpDrift !== 0 ? !0 : he(i);
 	}
-	function S() {
-		if (g || _) return;
-		let t = e.getContext("webgl2", {
+	return {
+		frame: (e) => {
+			me(i), c(e);
+		},
+		needsAnimation: l
+	};
+}
+//#endregion
+//#region src/components/custom/aurora/composables/runtime.ts
+function _e(e) {
+	return e.mode === "capture" ? !0 : e.initStrategy === "eager";
+}
+function Y(e) {
+	return typeof e.preserveDrawingBuffer == "boolean" ? e.preserveDrawingBuffer : e.mode === "capture";
+}
+function X(e, t, r = {}) {
+	let i = Y(r), o = t, s = pe(), c = null, l = a(e, {
+		mode: r.mode === "capture" ? "capture" : "live",
+		contextAttrs: {
 			antialias: !1,
 			alpha: !0,
 			premultipliedAlpha: !0,
-			preserveDrawingBuffer: r
-		});
-		if (!t) throw Error("[Aurora] WebGL2 unavailable");
-		let n = Y(t, t.VERTEX_SHADER, D), a = Y(t, t.FRAGMENT_SHADER, O), d = ee(t, n, a);
-		t.useProgram(d);
-		let f = t.createVertexArray();
-		t.bindVertexArray(f);
-		let p = t.createBuffer();
-		t.bindBuffer(t.ARRAY_BUFFER, p), t.bufferData(t.ARRAY_BUFFER, new Float32Array([
-			-1,
-			-1,
-			3,
-			-1,
-			-1,
-			3
-		]), t.STATIC_DRAW);
-		let m = t.getAttribLocation(d, "aPos");
-		t.enableVertexAttribArray(m), t.vertexAttribPointer(m, 2, t.FLOAT, !1, 0, 0);
-		let v = {};
-		for (let e of te) v[e] = t.getUniformLocation(d, e);
-		function y() {
-			let n = Math.min(window.devicePixelRatio || 1, 2), r = e.clientWidth || e.parentElement?.clientWidth || 1, i = e.clientHeight || e.parentElement?.clientHeight || 1, a = Math.max(1, Math.floor(r * n)), o = Math.max(1, Math.floor(i * n));
-			e.width = a, e.height = o, t.viewport(0, 0, a, o), t.useProgram(d);
-		}
-		let b = new ResizeObserver(() => y());
-		b.observe(e), requestAnimationFrame(() => {
-			y(), requestAnimationFrame(y);
-		});
-		let x = {
-			palette: new Float32Array(24),
-			pos: new Float32Array(12),
-			rad: new Float32Array(6),
-			pb: new Float32Array(6),
-			vb: new Float32Array(6),
-			dr: new Float32Array(6),
-			dp: new Float32Array(6),
-			elong: new Float32Array(6),
-			angle: new Float32Array(6)
-		};
-		function S(e) {
-			i = e, t.useProgram(d), A(e.palette, 8, x.palette), t.uniform3fv(v.uPalette, x.palette), t.uniform1i(v.uStopCount, Math.min(e.palette.length, 8));
-			let n = Math.min(e.nuclei.length, 6);
-			t.uniform1i(v.uNucleiCount, n);
-			for (let t = 0; t < n; t++) {
-				let n = e.nuclei[t];
-				x.pos[t * 2 + 0] = n.x, x.pos[t * 2 + 1] = 1 - n.y, x.rad[t] = n.radius, x.pb[t] = n.paletteBias, x.vb[t] = n.valueBias, x.dr[t] = n.driftRadius, x.dp[t] = n.driftPhase, x.elong[t] = n.elongation ?? 1, x.angle[t] = -(n.angle ?? 0) * Math.PI / 180;
+			preserveDrawingBuffer: i
+		},
+		setup: (t) => {
+			let { program: r, vs: i, fs: a, uniforms: u, geometry: d } = L(t, ne, P);
+			function f() {
+				let i = n(), a = e.clientWidth || e.parentElement?.clientWidth || 1, o = e.clientHeight || e.parentElement?.clientHeight || 1, s = Math.max(1, Math.floor(a * i)), c = Math.max(1, Math.floor(o * i));
+				e.width = s, e.height = c, t.viewport(0, 0, s, c), t.useProgram(r);
 			}
-			for (let e = n; e < 6; e++) x.pos[e * 2 + 0] = 0, x.pos[e * 2 + 1] = 0, x.rad[e] = 0, x.pb[e] = 0, x.vb[e] = 0, x.dr[e] = 0, x.dp[e] = 0, x.elong[e] = 1, x.angle[e] = 0;
-			t.uniform2fv(v.uNucleiPos, x.pos), t.uniform1fv(v.uNucleiRadius, x.rad), t.uniform1fv(v.uNucleiPaletteBias, x.pb), t.uniform1fv(v.uNucleiValueBias, x.vb), t.uniform1fv(v.uNucleiDriftRadius, x.dr), t.uniform1fv(v.uNucleiDriftPhase, x.dp), t.uniform1fv(v.uNucleiElong, x.elong), t.uniform1fv(v.uNucleiAngle, x.angle), t.uniform1f(v.uSoftmaxBeta, e.softmaxBeta), t.uniform1f(v.uValueVariance, e.valueVariance), t.uniform1f(v.uWarpAmount, e.warpAmount), t.uniform1f(v.uWarpScale, e.warpScale), t.uniform1f(v.uWarpDrift, e.warpDrift), t.uniform1i(v.uWarpMode, V[e.warpMode]), t.uniform1i(v.uNoiseOctaves, e.noiseOctaves), t.uniform1i(v.uMedium, z[e.medium]), t.uniform1i(v.uFlowPattern, B[e.flow.pattern]), t.uniform2f(v.uFlowFocal, e.flow.focalX, 1 - e.flow.focalY), t.uniform1f(v.uFlowAngle, e.flow.angle), t.uniform1f(v.uFlowCurl, e.flow.curl), t.uniform2f(v.uCursor, h.x, 1 - h.y), t.uniform1f(v.uCursorStrength, h.strength), t.uniform1f(v.uCursorRadius, h.radius), t.uniform1f(v.uStrokeAmount, e.strokeAmount), t.uniform1f(v.uStrokeScale, e.strokeScale), t.uniform1f(v.uStrokeAnisotropy, e.strokeAnisotropy), t.uniform1i(v.uStrokeLayers, e.strokeLayers), t.uniform1i(v.uStrokeMode, H[e.strokeMode]), t.uniform1f(v.uWetEdge, e.wetEdge), t.uniform1f(v.uGranulation, e.granulation), t.uniform1f(v.uImpasto, e.impasto), t.uniform1f(v.uBrokenColor, e.brokenColor), t.uniform1f(v.uCanvasGrain, e.canvasGrain), t.uniform1f(v.uNucleiDrift, e.nucleiDrift), t.uniform1f(v.uPaletteDrift, e.paletteDrift), t.uniform1f(v.uBreathDepth, e.breathDepth), t.uniform1f(v.uBreathPeriod, e.breathPeriod), t.uniform1f(v.uSaturation, e.saturation), t.uniform1f(v.uPaperGrain, e.paperGrain), t.uniform1f(v.uAlpha, e.alpha);
-		}
-		S(i), y(), t.clearColor(0, 0, 0, 0), t.disable(t.DEPTH_TEST), t.enable(t.BLEND), t.blendFunc(t.ONE, t.ONE_MINUS_SRC_ALPHA);
-		function C() {
-			h.x += (h.targetX - h.x) * U, h.y += (h.targetY - h.y) * U, h.strength += (h.targetStrength - h.strength) * W, h.targetStrength *= G;
-		}
-		function w(e) {
-			t.useProgram(d), t.uniform2f(v.uCursor, h.x, 1 - h.y), t.uniform1f(v.uCursorStrength, h.strength), t.uniform1f(v.uCursorRadius, h.radius), t.uniform1f(v.uTime, e), t.clear(t.COLOR_BUFFER_BIT), t.drawArrays(t.TRIANGLES, 0, 3);
-		}
-		function T() {
-			return s ? !1 : i.nucleiDrift !== 0 || i.paletteDrift !== 0 || i.breathDepth !== 0 || i.warpDrift !== 0 ? !0 : h.targetStrength > K || h.strength > K || Math.abs(h.x - h.targetX) > K || Math.abs(h.y - h.targetY) > K;
-		}
-		function E() {
-			if (!o()) return;
-			let e = s ? 3.7 : (performance.now() - c) / 1e3;
-			C(), w(e), l = T() ? requestAnimationFrame(E) : 0;
-		}
-		u = E, o() && (l = requestAnimationFrame(E));
-		function k() {
-			o() && !l && (l = requestAnimationFrame(E));
-		}
-		function j(e) {
-			w(e);
-		}
-		function M() {
-			cancelAnimationFrame(l), l = 0, u = null, b.disconnect(), t.deleteProgram(d), t.deleteShader(n), t.deleteShader(a), t.deleteBuffer(p), t.deleteVertexArray(f);
-			let e = t.getExtension("WEBGL_lose_context");
-			e && e.loseContext();
+			let p = ue(t, r, u, s), m = ge({
+				gl: t,
+				prog: r,
+				uniforms: u,
+				cursor: s,
+				getConfig: () => o,
+				getReducedMotion: () => l.reducedMotion
+			});
+			return t.clearColor(0, 0, 0, 0), t.disable(t.DEPTH_TEST), t.enable(t.BLEND), t.blendFunc(t.ONE, t.ONE_MINUS_SRC_ALPHA), c = (e) => {
+				o = e, p(e);
+			}, c(o), requestAnimationFrame(() => {
+				f(), requestAnimationFrame(f);
+			}), {
+				frame: m.frame,
+				shouldContinue: m.needsAnimation,
+				resize: f,
+				time: (e) => l.reducedMotion ? 3.7 : e,
+				teardown: () => {
+					t.deleteProgram(r), t.deleteShader(i), t.deleteShader(a), t.deleteBuffer(d.buf), t.deleteVertexArray(d.vao);
+				}
+			};
 		}
-		g = {
-			setConfig: S,
-			renderAt: j,
-			wake: k,
-			dispose: M
-		};
+	});
+	function u(e, t, n = .8) {
+		s.targetX = e, s.targetY = t, s.targetStrength = n, l.wake();
+	}
+	function d() {
+		s.targetStrength = 0, l.wake();
+	}
+	function f(e) {
+		s.radius = e, l.wake();
 	}
-	function C() {
-		p && document.removeEventListener("visibilitychange", m), a.clear();
+	function p(e) {
+		l.wake();
 	}
-	return q(n) && S(), {
-		arm: S,
+	return r.mode !== "capture" && _e(r) && l.arm(), {
+		arm: () => l.arm(),
 		update: (e) => {
-			i = e, g?.setConfig(e), g?.wake();
+			o = e, c?.(e), l.wake();
 		},
-		setCursor: v,
-		clearCursor: y,
-		setCursorRadius: b,
-		setReducedMotion: x,
-		pause: (e = "manual") => d(e),
-		resume: (e = "manual") => f(e),
-		renderAt: (e) => g?.renderAt(e),
-		dispose: () => {
-			g ? g.dispose() : _ = !0, C();
-		}
+		setCursor: u,
+		clearCursor: d,
+		setCursorRadius: f,
+		setReducedMotion: p,
+		pause: (e = "manual") => l.suspend(e),
+		resume: (e = "manual") => l.resume(e),
+		renderAt: (e) => l.renderAt(e),
+		dispose: () => l.dispose()
 	};
 }
 //#endregion
@@ -291,7 +474,7 @@ function Z(e) {
 }
 //#endregion
 //#region src/components/custom/aurora/composables/useAurora.ts
-function ne(e) {
+function ve(e) {
 	if (typeof window > "u") return () => {};
 	if (typeof window.requestIdleCallback == "function") {
 		let t = window.requestIdleCallback(() => e(), { timeout: 2e3 });
@@ -309,11 +492,11 @@ function ne(e) {
 	};
 }
 function Q(e, t, n = {}, r = {}) {
-	let a = Z(t), o = r.renderMode === "css", s = null, c = null, l = null, u = null, p = null, g = null, v = !1, y = h(!1), b = n.mode === "capture" || n.initStrategy === "eager";
-	function x() {
-		g && s && s.setReducedMotion(g.matches);
+	let i = Z(t), a = r.renderMode === "css", o = null, s = null, c = null, l = null, u = null, d = null, f = !1, m = w(!1), h = n.mode === "capture" || n.initStrategy === "eager";
+	function g() {
+		d && o && o.setReducedMotion(d.matches);
 	}
-	function S(e) {
+	function _(e) {
 		let t = e instanceof Error ? e : Error(String(e));
 		if (n.onInitError) {
 			n.onInitError(t);
@@ -321,58 +504,58 @@ function Q(e, t, n = {}, r = {}) {
 		}
 		Promise.reject(t);
 	}
-	function C() {
-		if (!(v || !s)) {
-			v = !0;
+	function v() {
+		if (!(f || !o)) {
+			f = !0;
 			try {
-				s.arm();
+				o.arm();
 			} catch (e) {
-				S(e);
+				_(e);
 				return;
 			}
-			y.value = !0, g = window.matchMedia("(prefers-reduced-motion: reduce)"), g.addEventListener("change", x), c = _(a, (e) => s?.update(e), { deep: !0 });
+			m.value = !0, d = window.matchMedia("(prefers-reduced-motion: reduce)"), d.addEventListener("change", g), s = T(i, (e) => o?.update(e), { deep: !0 });
 		}
 	}
-	return f(() => {
+	return x(() => {
 		let t = e.value;
-		if (!t || o) return;
+		if (!t || a) return;
 		try {
-			s = X(t, a(), {
+			o = X(t, i(), {
 				initStrategy: "deferred",
 				...n
 			});
 		} catch (e) {
-			S(e);
+			_(e);
 			return;
 		}
-		if (b) {
-			C();
+		if (h) {
+			v();
 			return;
 		}
-		p = i(e, {
-			pause: () => s?.pause("off-screen"),
-			resume: () => s?.resume("off-screen")
+		u = p(e, {
+			pause: () => o?.pause("off-screen"),
+			resume: () => o?.resume("off-screen")
 		}, { pauseWhenHidden: !1 });
-		let r = p.isIntersecting;
-		l = _(r, (e) => {
-			!e || v || u || (u = ne(() => {
-				u = null, r.value && C();
+		let r = u.isIntersecting;
+		c = T(r, (e) => {
+			!e || f || l || (l = ve(() => {
+				l = null, r.value && v();
 			}));
 		}, { immediate: !0 });
-	}), d(() => {
-		u?.(), l?.(), c?.(), p?.dispose(), g?.removeEventListener("change", x), s?.dispose(), s = null;
+	}), b(() => {
+		l?.(), c?.(), s?.(), u?.dispose(), d?.removeEventListener("change", g), o?.dispose(), o = null;
 	}), {
-		setCursor: (e, t, n) => s?.setCursor(e, t, n),
-		clearCursor: () => s?.clearCursor(),
-		setCursorRadius: (e) => s?.setCursorRadius(e),
-		renderAt: (e) => s?.renderAt(e),
-		pause: () => s?.pause(),
-		resume: () => s?.resume(),
-		isArmed: m(y)
+		setCursor: (e, t, n) => o?.setCursor(e, t, n),
+		clearCursor: () => o?.clearCursor(),
+		setCursorRadius: (e) => o?.setCursorRadius(e),
+		renderAt: (e) => o?.renderAt(e),
+		pause: () => o?.pause(),
+		resume: () => o?.resume(),
+		isArmed: C(m)
 	};
 }
 //#endregion
-//#region src/components/custom/aurora/renderMode.ts
+//#region src/components/custom/aurora/constants/renderMode.ts
 function $(e) {
 	if (e !== "auto") return e;
 	if (typeof navigator > "u" || typeof window > "u") return "webgl";
@@ -381,48 +564,48 @@ function $(e) {
 }
 //#endregion
 //#region src/components/custom/aurora/Aurora.vue
-var re = /* @__PURE__ */ e(/* @__PURE__ */ c({
+var ye = /* @__PURE__ */ e(/* @__PURE__ */ _({
 	__name: "Aurora",
 	props: {
-		config: { default: () => r },
+		config: { default: () => l },
 		runtimeOptions: {},
 		onInitError: {},
 		renderMode: { default: "auto" },
 		opacityCeiling: { default: 1 }
 	},
 	setup(e, { expose: t }) {
-		let n = e, r = $(n.renderMode), i = a(() => Math.max(0, Math.min(1, n.opacityCeiling))), c = h(null), d = Q(c, () => n.config, a(() => ({
+		let n = e, r = $(n.renderMode), i = m(() => Math.max(0, Math.min(1, n.opacityCeiling))), a = w(null), o = Q(a, () => n.config, m(() => ({
 			...n.runtimeOptions ?? {},
 			...n.onInitError ? { onInitError: n.onInitError } : {}
-		})).value, { renderMode: r }), f = a(() => j(n.config.palette));
+		})).value, { renderMode: r }), s = m(() => z(n.config.palette));
 		return t({
 			config: n.config,
-			canvasRef: c,
-			setCursor: d.setCursor,
-			clearCursor: d.clearCursor,
-			setCursorRadius: d.setCursorRadius,
-			renderAt: d.renderAt,
-			pause: d.pause,
-			resume: d.resume,
-			isArmed: d.isArmed
-		}), (e, t) => (p(), o("div", {
+			canvasRef: a,
+			setCursor: o.setCursor,
+			clearCursor: o.clearCursor,
+			setCursorRadius: o.setCursorRadius,
+			renderAt: o.renderAt,
+			pause: o.pause,
+			resume: o.resume,
+			isArmed: o.isArmed
+		}), (e, t) => (S(), h("div", {
 			class: "aurora-root block h-full w-full overflow-hidden",
-			style: u({ "--aurora-opacity-ceiling": i.value })
-		}, [s("div", {
+			style: y({ "--aurora-opacity-ceiling": i.value })
+		}, [g("div", {
 			class: "aurora-placeholder h-full w-full",
 			"aria-hidden": "true",
-			style: u({ backgroundImage: f.value })
-		}, null, 4), s("canvas", {
+			style: y({ backgroundImage: s.value })
+		}, null, 4), g("canvas", {
 			ref_key: "canvasRef",
-			ref: c,
+			ref: a,
 			"aria-hidden": "true",
-			class: l(["aurora-canvas block h-full w-full", { "aurora-canvas--armed": g(d).isArmed.value }])
+			class: v(["aurora-canvas block h-full w-full", { "aurora-canvas--armed": ee(o).isArmed.value }])
 		}, null, 2)], 4));
 	}
-}), [["__scopeId", "data-v-80ea8f7d"]]);
+}), [["__scopeId", "data-v-c5277232"]]);
 //#endregion
 //#region src/components/custom/aurora/composables/useCursorInteraction.ts
-function ie(e, t, n) {
+function be(e, t, n) {
 	let r = Z(t), i = n.hitFraction ?? .35, a = null, o = null;
 	function s(e, t) {
 		let n = t.getBoundingClientRect();
@@ -451,38 +634,38 @@ function ie(e, t, n) {
 		}
 		return i > 1e-4 ? n / i : .5;
 	}
-	function p() {
+	function d() {
 		if (r().nuclei.length === 0) return .5;
 		let e = r().nuclei.map((e) => e.radius).sort((e, t) => e - t);
 		return e[Math.floor(e.length / 2)];
 	}
-	function m(e, t) {
+	function f(e, t) {
 		return {
 			x: e,
 			y: t,
-			radius: p(),
+			radius: d(),
 			paletteBias: u(e, t),
 			valueBias: 0,
 			driftRadius: .012,
 			driftPhase: Math.random() * Math.PI * 2
 		};
 	}
-	function h(t) {
+	function p(t) {
 		let i = e.value;
 		if (!i) return;
 		let { x: o, y: c } = s(t, i);
 		a !== null && (r().nuclei[a].x = Math.max(0, Math.min(1, o)), r().nuclei[a].y = Math.max(0, Math.min(1, c))), n.setCursor(o, c, 1);
 	}
-	function g() {
+	function m() {
 		a === null && n.clearCursor();
 	}
-	function _(t) {
+	function h(t) {
 		let n = e.value;
 		if (!n) return;
 		let { x: i, y: c } = s(t, n), u = l(i, c);
 		if (t.altKey && u === null) {
 			if (r().nuclei.length >= 6) return;
-			r().nuclei.push(m(i, c)), t.preventDefault();
+			r().nuclei.push(f(i, c)), t.preventDefault();
 			return;
 		}
 		if ((t.shiftKey || t.button === 2) && u !== null) {
@@ -492,7 +675,7 @@ function ie(e, t, n) {
 		}
 		u !== null && t.button === 0 && (a = u, o = t.pointerId, n.setPointerCapture(t.pointerId), t.preventDefault());
 	}
-	function v(t) {
+	function g(t) {
 		let n = e.value;
 		if (n && o !== null && t.pointerId === o) {
 			try {
@@ -501,7 +684,7 @@ function ie(e, t, n) {
 			o = null, a = null;
 		}
 	}
-	function y(t) {
+	function _(t) {
 		let n = e.value;
 		if (!n) return;
 		let i = {
@@ -510,13 +693,13 @@ function ie(e, t, n) {
 		}, a = n.getBoundingClientRect(), o = l((i.clientX - a.left) / Math.max(a.width, 1), (i.clientY - a.top) / Math.max(a.height, 1));
 		o !== null && r().nuclei.length > 1 && (r().nuclei.splice(o, 1), t.preventDefault());
 	}
-	return f(() => {
+	return x(() => {
 		let t = e.value;
-		t && (t.addEventListener("pointermove", h), t.addEventListener("pointerleave", g), t.addEventListener("pointerdown", _), t.addEventListener("pointerup", v), t.addEventListener("pointercancel", v), t.addEventListener("contextmenu", y));
-	}), d(() => {
+		t && (t.addEventListener("pointermove", p), t.addEventListener("pointerleave", m), t.addEventListener("pointerdown", h), t.addEventListener("pointerup", g), t.addEventListener("pointercancel", g), t.addEventListener("contextmenu", _));
+	}), b(() => {
 		let t = e.value;
-		t && (t.removeEventListener("pointermove", h), t.removeEventListener("pointerleave", g), t.removeEventListener("pointerdown", _), t.removeEventListener("pointerup", v), t.removeEventListener("pointercancel", v), t.removeEventListener("contextmenu", y));
+		t && (t.removeEventListener("pointermove", p), t.removeEventListener("pointerleave", m), t.removeEventListener("pointerdown", h), t.removeEventListener("pointerup", g), t.removeEventListener("pointercancel", g), t.removeEventListener("contextmenu", _));
 	}), { isDragging: () => a };
 }
 //#endregion
-export { re as Aurora, r as DEFAULT_AURORA_CONFIG, t as MAX_NUCLEI, n as MAX_STOPS, X as createAurora, P as cssToOklch, I as deriveAurora, A as flattenPalette, N as hexToOklchStop, M as oklchStopToHex, k as oklchToLinear, j as paletteToCssGradient, $ as resolveRenderMode, Q as useAurora, ie as useCursorInteraction };
+export { ye as Aurora, l as DEFAULT_AURORA_CONFIG, s as MAX_NUCLEI, c as MAX_STOPS, X as createAurora, f as cssToOklch, H as deriveAurora, R as flattenPalette, B as hexToOklchStop, d as oklchStopToHex, u as oklchToLinear, z as paletteToCssGradient, $ as resolveRenderMode, Q as useAurora, be as useCursorInteraction };