@mkbabb/glass-ui 3.5.1 → 3.7.0

package/dist/aurora.js

@@ -1,12 +1,13 @@
-import { t as e } from "./_plugin-vue_export-helper-C1je1s0u.js";
-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";
+import { t as e } from "./_plugin-vue_export-helper-gLzyemvl.js";
+import { a as t, c as n, d as r, f as i, i as a, l as o, n as s, o as c, r as l, s as u, t as d, u as f } from "./compile-iM4IUB66.js";
+import { n as p, r as m, t as h } from "./presets-BKVyQfbt.js";
+import { a as g, c as _, i as v, o as y, t as b } from "./color-DjJCAQ6f.js";
+import { t as x } from "./useIntersectionPause-Cc-H9ees.js";
+import { t as ee } from "./useScrollProgress-CAH8Ofwt.js";
+import { computed as S, createElementBlock as C, createElementVNode as w, defineComponent as te, normalizeClass as ne, normalizeStyle as T, onBeforeUnmount as E, onMounted as D, openBlock as re, readonly as ie, ref as O, unref as ae, watch as k } from "vue";
+import { rawOklabToOklch as oe, srgbToOKLab as se } 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
+var ce = "#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}", le = "// ── Palette LUT (W5 — OKLCh/OKLab interpolation) ──────────────────────────────\n// The endpoints stay CPU-baked to LINEAR sRGB (the Aras precompute pattern); only\n// the BETWEEN-endpoint interpolation moves to perceptual space. OKLab-rectangular\n// for the default ramp (holds chroma, no grey midpoint); the OKLCh hue-arc only on\n// uHuePath increasing/decreasing (deliberate rainbow travel). The prior linear\n// mix() (the muddy-midtone source) is GONE.\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  vec3 a = uPalette[i0];\n  vec3 b = uPalette[i1];\n  // increasing(2)/decreasing(3) request the OKLCh hue-arc (rainbow sweep); every\n  // other method takes the OKLab-rectangular straight line (no hue detour).\n  if (uHuePath == 2 || uHuePath == 3) {\n    return mixPaletteOklchArc(a, b, t, uHuePath);\n  }\n  return mixPaletteOklab(a, b, 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", ue = "// ── Flow field ────────────────────────────────────────────────────────────\n// Structure-tensor prototype (body defined post-sampleBase in the mediums block).\n// Returns vec3(dir.x, dir.y, coherence) — the minor-eigenvector tangent + A.\nvec3 structureTensorField(vec2 p, float t, vec2 fallbackDir);\n\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  } else if (uFlowPattern == 5) {\n    // tensor / ETF — the color field's OWN edge-tangent flow (AW.W4.1). The\n    // diagonal angle seeds the smooth fallback the coherence-weighted blend\n    // relaxes toward in low-structure zones. Returns directly (no curl/cursor\n    // post-mix — the tensor field already carries the structure orientation;\n    // the cursor warp still drives the underlying color field in domainWarp).\n    float a = radians(uFlowAngle);\n    vec2 fallback = vec2(cos(a), sin(a));\n    return structureTensorField(p, t, fallback).xy;\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  // AW.W8.1 — velocity-reactive swirl-BURST: a fast flick (uCursorBurst, decaying\n  // over ~1s) injects a transient flow bias along the pointer velocity, distinct from\n  // the steady attraction above (the stateless swirl is SUPERSEDED by this form). The\n  // burst is gated by the master tempo scalar on the CPU side (it decays to 0 under\n  // PRM/pause), so this term cannot leak motion under reduced-motion.\n  if (uCursorBurst > 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.7));\n    // Bias the flow toward the velocity direction, scaled by the decaying burst.\n    vec2 velDir = uCursorVelocity / max(length(uCursorVelocity), 1e-4);\n    float a0 = atan(dir.y, dir.x);\n    float a1 = atan(velDir.y, velDir.x);\n    float da = atan(sin(a1 - a0), cos(a1 - a0));\n    float a = a0 + da * w * uCursorBurst * 0.8;\n    dir = vec2(cos(a), sin(a));\n  }\n  return dir;\n}\n", de = "// 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", fe = "// ── 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 + ACCUMULATE paint HEIGHT.\n//   streakAmp    — 0..0.2 how much internal streaks darken/lighten\n//   impastoAmp   — 0..1 paint-thickness contribution (the height the relight reads)\n//   hardness     — 0..1 how crisp the compositing transition is (1 = razor, 0 = creamy)\n//\n// AW.W4.2 — the fixed-RGB edge rim (the phantom upper-left light) is RETIRED. Each\n// stroke now deposits PAINT HEIGHT into the height accumulator (coverage x per-stroke\n// thickness, perturbed by the bristle/streak fbm for ridges/grooves); mediumOil\n// derives a normal from the accumulated height gradient (dFdx/dFdy) and relights it\n// once with the movable uLightDir source (relightImpasto), in linear before aces().\nvoid paintOver(inout vec3 col, inout float height, StrokeHit s,\n               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  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  // ── Accumulate paint HEIGHT (AW.W4.2). Thickness peaks at the stroke spine and\n  // falls to zero at the edge (edgeN: 0=edge, 1=spine), perturbed by the bristle\n  // streak so ridges/grooves form. The relight reads the gradient of this field.\n  float ridge = 0.7 + 0.3 * (streak + 0.5);\n  height += s.coverage * impastoAmp * (0.4 + 0.6 * s.edgeN) * ridge * alpha;\n}\n\n// AW.W4.2 — relight the accumulated paint height. Derive a normal from the height\n// gradient (dFdx/dFdy — derivatives are in-pattern; fwidth is already used for AA),\n// then apply diffuse + Blinn specular from the movable uLightDir/uLightColor source.\n// LINEAR-space lighting BEFORE aces() (the tonemap/OETF stay locked); thin strokes\n// inherit a low shininess, thick impasto raises it (high-height ridges catch a sharp\n// glint). canvasBase is the tooth height so the canvas weave also catches the light.\nvec3 relightImpasto(vec3 col, float height, float canvasBase) {\n  float h = height + canvasBase;\n  // Height-gradient normal. heightScale trades relief depth for surface flatness.\n  float heightScale = 6.0;\n  vec3 N = normalize(vec3(-dFdx(h) * 40.0, -dFdy(h) * 40.0, 1.0 / heightScale));\n  vec3 L = normalize(uLightDir);\n  vec3 V = vec3(0.0, 0.0, 1.0);            // view straight on\n  vec3 H = normalize(L + V);\n  float diff = max(dot(N, L), 0.0);\n  // Thick impasto → high shininess (sharp glint); thin paint → broad soft sheen.\n  float shininess = mix(8.0, 64.0, clamp(height * 2.0, 0.0, 1.0));\n  float spec = pow(max(dot(N, H), 0.0), shininess);\n  // Modulate the lit terms by how much paint sits here (no relief on bare ground).\n  float relief = clamp(h * 1.5, 0.0, 1.0);\n  vec3 lit = col * (1.0 + uImpasto * relief * (diff - 0.5) * 0.5 * uLightColor);\n  lit += uImpasto * relief * spec * 0.6 * uLightColor;\n  return lit;\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 source — the AW.W4.1 strokeOrient switch:\n      //   uStrokeOrient==0 (flow)   — the layer-provided hand-authored flowField.\n      //   uStrokeOrient==1 (tensor) — the structure-tensor minor eigenvector at the\n      //                               cell center (the color field's edge-tangent),\n      //                               so strokes hug the color zones (van Gogh).\n      // coh carries the per-cell coherence A for the W4.3 energy grading (long\n      // confident strokes where structure is coherent, stubby dabs in flat zones).\n      vec2 f;\n      float coh = 1.0;\n      if (uStrokeOrient == 1) {\n        vec3 tf = structureTensorField(center, t, safeDir(flow));\n        f = safeDir(tf.xy);\n        coh = tf.z;\n      } else {\n        f = safeDir(flow);\n      }\n      // Per-stroke deterministic local perturbation so alternate stroke layers stay\n      // live. Tensor strokes get LESS angular jitter (the field already orients them).\n      float jScale = (uStrokeOrient == 1) ? 0.4 : 1.0;\n      float angJ = (hash21(cc + seed + 11.0) - 0.5) * 0.9 * jScale;  // +/- 0.45/0.18 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      // AW.W4.3 — energy-graded length/density for the van-Gogh cascade: in vangogh\n      // mode (uMedium==5) modulate the stroke length by local luminance (bright →\n      // long confident strokes, dark → short dabs, the Starry-Night Kolmogorov/\n      // Batchelor congruence) AND by coherence (coherent zones → long, flat → stubby).\n      float energy = 1.0;\n      if (uMedium == 5) {\n        float luma = clamp(dot(sampleBase(center, t), W_LUMA), 0.0, 1.0);\n        // long in the lights + coherent zones; short dabs in the darks + flat zones.\n        energy = mix(0.5, 1.5, luma) * mix(0.6, 1.0, coh);\n      }\n\n      float lenV = cellSize * lenMul * (0.65 + 0.55 * hash21(cc + seed + 23.0)) * energy;\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", pe = "// ── 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\n// ── Structure-tensor / edge-tangent-flow (AW.W4.1) ─────────────────────────\n// The keystone of the painterly engine: derive stroke orientation from the COLOR\n// FIELD's OWN structure, not a hand-authored flow pattern. A 3x3 Sobel over\n// luma(sampleBase) yields the gradient (Gx,Gy); the 2x2 structure tensor\n// J = [[Gx², GxGy],[GxGy, Gy²]] eigen-decomposes closed-form into the MINOR\n// eigenvector (the edge-TANGENT — least color change, the stroke direction; the\n// MAJOR eigenvector is the gradient/edge-NORMAL and would make strokes cross the\n// bands) and the coherence A = (λ1-λ2)/(λ1+λ2). Low-coherence (flat) zones relax\n// toward the smooth fallbackDir by (1-A) so tensor noise never reads as jitter.\n// Single-pass small-tap WebGL2 form; the Gaussian-smoothed multi-tap + LIC smear\n// is the AW.W7 WebGPU multi-pass fold. Returns vec3(tangent.x, tangent.y, A).\nvec3 structureTensorField(vec2 p, float t, vec2 fallbackDir) {\n  float e = 0.0035; // small-tap neighborhood (edge-mask scale)\n  // 3x3 luma samples.\n  float l00 = dot(sampleBase(p + vec2(-e, -e), t), W_LUMA);\n  float l10 = dot(sampleBase(p + vec2( 0.0, -e), t), W_LUMA);\n  float l20 = dot(sampleBase(p + vec2( e, -e), t), W_LUMA);\n  float l01 = dot(sampleBase(p + vec2(-e, 0.0), t), W_LUMA);\n  float l21 = dot(sampleBase(p + vec2( e, 0.0), t), W_LUMA);\n  float l02 = dot(sampleBase(p + vec2(-e, e), t), W_LUMA);\n  float l12 = dot(sampleBase(p + vec2( 0.0, e), t), W_LUMA);\n  float l22 = dot(sampleBase(p + vec2( e, e), t), W_LUMA);\n  // Sobel derivatives.\n  float Gx = (l20 + 2.0 * l21 + l22) - (l00 + 2.0 * l01 + l02);\n  float Gy = (l02 + 2.0 * l12 + l22) - (l00 + 2.0 * l10 + l20);\n  // Structure tensor components.\n  float Jxx = Gx * Gx;\n  float Jyy = Gy * Gy;\n  float Jxy = Gx * Gy;\n  // Closed-form 2x2 eigenvalues: λ = 0.5(tr ± sqrt((Jxx-Jyy)² + 4Jxy²)).\n  float tr = Jxx + Jyy;\n  float disc = sqrt(max((Jxx - Jyy) * (Jxx - Jyy) + 4.0 * Jxy * Jxy, 0.0));\n  float lambdaMaj = 0.5 * (tr + disc);\n  float lambdaMin = 0.5 * (tr - disc);\n  // The MAJOR eigenvector points along the gradient (the edge NORMAL); the MINOR\n  // is its perpendicular — the edge TANGENT (the stroke direction). The principal\n  // angle is θ = 0.5·atan2(2·Jxy, Jxx-Jyy); this form is robust at Jxy≈0 (where the\n  // (λ-Jyy, Jxy) eigenvector formula collapses to a zero vector). The tangent is at\n  // θ + 90°. Guard the fully-isotropic (no-gradient) degenerate case → fallback dir.\n  vec2 tangent;\n  if (disc < 1e-7) {\n    tangent = fallbackDir;\n  } else {\n    float theta = 0.5 * atan(2.0 * Jxy, Jxx - Jyy); // major (gradient) angle\n    tangent = vec2(-sin(theta), cos(theta));          // perpendicular = tangent\n  }\n  // Coherence A in [0,1] — high where one eigenvalue dominates (a strong edge),\n  // ~0 in flat zones. Relax toward the smooth fallback by (1 - A).\n  float A = (lambdaMaj - lambdaMin) / (lambdaMaj + lambdaMin + 1e-6);\n  A = clamp(A, 0.0, 1.0);\n  // Coherence-weighted blend: full tensor in coherent zones, smooth in flat ones.\n  // Resolve the 180° sign ambiguity toward the fallback so the blend is continuous.\n  if (dot(tangent, fallbackDir) < 0.0) tangent = -tangent;\n  vec2 dir = normalize(mix(fallbackDir, tangent, A) + 1e-6);\n  return vec3(dir, A);\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", me = "// ── 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().\n// AW.W4.4 — GENUINE oil pastel: pigment DEPOSITED on the paper tooth, a broken\n// SCUMBLE upper layer letting the paper/lower color show through, and a waxy BURNISH\n// film whose sheen grows with layer count. Reworked from the old tooth-multiply\n// gradient into a material-truth deposition model. Oriented along the ETF field\n// (W4.1); OKLCh broken color (W5). The oil-pastel first-class medium (uMedium==6)\n// AND the legacy crayon peer (uMedium==4) both dispatch this single body.\nvec3 mediumCrayon(vec3 col, vec2 p, float t) {\n  // Orient the deposition streaks along the structure-tensor edge-tangent. The\n  // painterly mediums force uStrokeOrient==tensor, so read the tensor field directly;\n  // fall back to flowField for the legacy crayon strokeMode route.\n  vec2 flow = (uStrokeOrient == 1)\n    ? structureTensorField(p, t, flowField(p, t)).xy\n    : 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  float aniso = mix(0.45, 0.95, uStrokeAnisotropy);\n  float scale = max(uStrokeScale * 1.6, 180.0);\n\n  // ── Paper TOOTH height field — the relief the pigment rides. Anisotropic\n  // (squished along flow, coarse cross-flow). Peaks = ridges, valleys = paper pits.\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 paperHeight = 0.55 * t1 + 0.30 * t2 + 0.15 * t3;\n\n  // ── DEPOSITION — pigment lands on the tooth PEAKS and skips the valleys. Light\n  // pressure (low uStrokeAmount) shows paper through the valleys; heavy pressure\n  // fills them. deposit in [0,1] is the per-pixel pigment coverage.\n  float pressure = clamp(uStrokeAmount, 0.0, 1.0);\n  float toothFloor = mix(0.62, 0.18, pressure);  // heavy pressure lowers the floor\n  float deposit = smoothstep(toothFloor, toothFloor + 0.35, paperHeight);\n\n  // ── SCUMBLE — a broken UPPER layer at coverage < 1 (the signature oil-pastel\n  // move). A coarse mask gates a lighter dragged stroke over the deposition so the\n  // LOWER color shows through the gaps. Drag direction follows the tensor flow.\n  float scumbleMask = smoothstep(0.35, 0.85, vnoise(vec2(pr.x * scale * 0.55, pr.y * scale * 0.22) + 7.0));\n  float scumbleCoverage = scumbleMask * pressure * 0.6;  // < 1 — paper/lower shows\n\n  // The lower color is the base; the deposited pigment is the base lifted into the\n  // tooth. Mix the base toward the deposited layer by the deposition coverage, then\n  // let the scumble break the upper layer so the lower reads through the gaps.\n  vec3 paper = col * 0.92;                       // the paper-showing-through tone\n  vec3 deposited = col;                          // the pigment-on-tooth tone\n  vec3 result = mix(paper, deposited, deposit);\n  // Scumble: a broken pass of the deposited color at < 1 coverage.\n  result = mix(result, deposited * (0.96 + 0.08 * t1), scumbleCoverage);\n\n  // ── WAXY BURNISH FILM — a low-roughness BROAD specular lobe whose sheen grows\n  // with the pigment build-up (burnish), distinct from oil's sharp glint. Reads the\n  // paper-height gradient as a soft normal and lights it with the movable uLightDir.\n  float waxNormalZ = 2.4;\n  vec3 N = normalize(vec3(-dFdx(paperHeight) * 30.0, -dFdy(paperHeight) * 30.0, waxNormalZ));\n  vec3 L = normalize(uLightDir);\n  vec3 V = vec3(0.0, 0.0, 1.0);\n  vec3 H = normalize(L + V);\n  float burnish = deposit * (0.5 + 0.5 * scumbleMask); // sheen grows with build-up\n  float sheen = pow(max(dot(N, H), 0.0), 6.0);          // broad waxy lobe\n  result += burnish * sheen * 0.10 * uLightColor;\n\n  // ── Broken-color pigment: stable wax/pigment patches in OKLCh (W5), not 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  // Oil pastel is saturation-amplified (the waxy chroma punch).\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  // AW.W4.2 — accumulated paint HEIGHT across the stroke layers. The relight reads\n  // its gradient for the normal; the canvas tooth seeds the base relief.\n  float height = 0.0;\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, height, 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, height, 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, height, 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, height, 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, height, 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  // AW.W4.2 — relight the accumulated paint height with the movable uLightDir\n  // source (diffuse + Blinn specular, in LINEAR before aces()). The canvas tooth\n  // is the base relief term so the weave also catches the raking light.\n  float canvasBase = tooth * toothAmp * 0.5;\n  result = relightImpasto(result, height, canvasBase);\n\n  // Pigment saturation boost\n  result = saturate3(result, pigmentSat);\n\n  return result;\n}\n\n// AW.W4.3 — the van-Gogh atomic-stroke medium. Composes the oil stroke engine\n// (mediumOil) with the W4.1 ETF orientation (forced tensor via the bridge), the\n// W4.3 energy grading (gated by uMedium==5 inside bestOil — long confident strokes\n// in the lights/coherent zones, short dabs in the darks/flat zones, the Starry-Night\n// Kolmogorov/Batchelor cascade), the W5 OKLCh per-stroke pigment jitter (already in\n// bestOil's brokenColorJitter), and the W4.2 real impasto relight. No subject matter\n// — the \"source image\" is the generated nuclei field, so strokes trace its iso-bands.\nvec3 mediumVangogh(vec3 col, vec2 p, float t) {\n  return mediumOil(col, p, t);\n}", A = "\n", he = `#version 300 es
 precision highp float;
 
 in vec2 vUv;
@@ -48,24 +49,45 @@ uniform int   uNoiseOctaves;
 // 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
+// Hue-arc method for the OKLCh palette interpolation (W5). Mirrors value.js's
+// HueInterpolationMethod: 0 shorter, 1 longer, 2 increasing, 3 decreasing. Only
+// consulted when the hue-arc path is requested; OKLab-rectangular ramps (the
+// default for adjacent-hue stops) ignore it.
+uniform int   uHuePath;
+uniform int   uFlowPattern;   // 0 none, 1 radial, 2 swirl, 3 diagonal, 4 multi, 5 tensor/ETF (W4.1)
 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)
+// AW.W8.1 — the velocity-reactive flow: a fast flick injects a transient swirl-burst
+// (uCursorBurst, decaying over ~1s) along the pointer velocity (uCursorVelocity),
+// distinct from the steady uCursorStrength attraction. Both are PRM-gated (the cursor
+// write-path early-outs on reduced-motion, and the master tempo scalar zeroes them).
+uniform vec2  uCursorVelocity;  // smoothed pointer velocity (normalized-screen/move)
+uniform float uCursorBurst;     // 0..1 transient flick burst
 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)
+// AW.W4.1 — the stroke-orientation source: 0 flow (hand-authored flowField), 1
+// tensor (the structure-tensor minor eigenvector — the color field's edge-tangent).
+uniform int   uStrokeOrient;
 uniform float uWetEdge;
 uniform float uGranulation;
 uniform float uImpasto;
 uniform float uBrokenColor;
 uniform float uCanvasGrain;
 
+// AW.W4.2 — the impasto relight axis. A movable directional source lighting the
+// accumulated paint-height field (diffuse + Blinn specular, in LINEAR before aces()).
+// AW.W8 drives uLightDir from the cursor (cursor-as-light). Default = upper-left so
+// the still default reads identically to the prior fixed rim.
+uniform vec3  uLightDir;    // unit direction (x,y in screen space, z toward viewer)
+uniform vec3  uLightColor;  // warm-white tint (linear)
+
 // Motion
 uniform float uNucleiDrift;
 uniform float uPaletteDrift;
@@ -120,7 +142,7 @@ float vnoise(vec2 p) {
 // 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}
+${u}
 
 float fbm(vec2 p) {
   float v = 0.0;
@@ -138,7 +160,65 @@ float fbm(vec2 p) {
 // (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}
+${o}
+
+// W5 — the four Ottosson OKLab/OKLCh matrices + their space fns, spliced from the
+// SAME shared chunk the goo-blob uses (zero new payload, 1e-6-verified). PI is
+// defined first because the chunk's oklabToOklch folds the hue into [0, 2pi).
+const float PI = 3.141592653589793;
+${r}
+
+// ── OKLCh palette interpolation (W5) ─────────────────────────────────────────
+// The muddy-midtone kill: distant-hue stops interpolated by a plain linear mix()
+// desaturate toward grey at the midpoint. The OKLab-rectangular lerp (L,a,b) holds
+// chroma across the ramp; the OKLCh hue-arc form (used only for deliberate rainbow
+// travel via uHuePath increasing/decreasing) sweeps the hue wheel without flipping.
+
+// value.js's interpolateHue, transcribed in the NORMALIZED-TURNS domain (h_rad/TAU
+// → turns, the exact .5/+1.0 branch per method, fract() wrap, *TAU back). A
+// radians-native port (PI thresholds / +TAU wrap) diverges 180° at the antipode.
+// methods: 0 shorter, 1 longer, 2 increasing, 3 decreasing.
+float interpolateHueTurns(float h0, float h1, float t, int method) {
+  // h0/h1 are radians in [0, 2pi); convert to turns [0,1).
+  float TAU = 2.0 * PI;
+  float a = h0 / TAU;
+  float b = h1 / TAU;
+  float i = b - a;
+  if (method == 0) {              // shorter
+    if (i > 0.5) a += 1.0; else if (i < -0.5) b += 1.0;
+  } else if (method == 1) {       // longer
+    if (i > 0.0 && i < 0.5) a += 1.0; else if (i > -0.5 && i <= 0.0) b += 1.0;
+  } else if (method == 2) {       // increasing
+    if (i < 0.0) b += 1.0;
+  } else {                        // decreasing
+    if (i > 0.0) a += 1.0;
+  }
+  float r = a + t * (b - a);
+  r = fract(r);                   // (r % 1 + 1) % 1 — fract is non-negative in GLSL
+  return r * TAU;                 // back to radians
+}
+
+// Linear-sRGB endpoint pair → OKLab-rectangular interpolation → linear sRGB. Holds
+// chroma across the ramp (no grey midpoint). Used for the default/shorter ramp path.
+vec3 mixPaletteOklab(vec3 linA, vec3 linB, float t) {
+  vec3 labA = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linA) * pow(abs(LINEAR_SRGB_TO_LMS * linA), vec3(1.0 / 3.0)));
+  vec3 labB = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linB) * pow(abs(LINEAR_SRGB_TO_LMS * linB), vec3(1.0 / 3.0)));
+  vec3 lab = mix(labA, labB, t);
+  return oklabToLinearSrgb(lab);
+}
+
+// Linear-sRGB endpoint pair → OKLCh interpolation along the uHuePath arc → linear
+// sRGB. L and C lerp; H walks the chosen arc. The deliberate-rainbow path.
+vec3 mixPaletteOklchArc(vec3 linA, vec3 linB, float t, int method) {
+  vec3 labA = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linA) * pow(abs(LINEAR_SRGB_TO_LMS * linA), vec3(1.0 / 3.0)));
+  vec3 labB = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linB) * pow(abs(LINEAR_SRGB_TO_LMS * linB), vec3(1.0 / 3.0)));
+  vec3 lchA = oklabToOklch(labA);
+  vec3 lchB = oklabToOklch(labB);
+  float L = mix(lchA.x, lchB.x, t);
+  float C = mix(lchA.y, lchB.y, t);
+  float H = interpolateHueTurns(lchA.z, lchB.z, t, method);
+  return oklabToLinearSrgb(oklchToOklab(vec3(L, C, H)));
+}
 
 // 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
@@ -207,14 +287,63 @@ vec2 domainWarp(vec2 p, float t) {
   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([
+` + le + A + ue + A + "// ── Color utils (OKLCh — W5; the sRGB YIQ hueShift matrix is DELETED) ──────────\nconst vec3 W_LUMA = vec3(0.2126, 0.7152, 0.0722);\n\n// Linear sRGB → OKLab (the cbrt-LMS path; the goo-blob's srgbToOklab takes gamma,\n// here the color field is already linear so we skip the OETF inverse).\nvec3 linOklab(vec3 lin) {\n  vec3 lms = LINEAR_SRGB_TO_LMS * lin;\n  return LMS_TO_OKLAB * (sign(lms) * pow(abs(lms), vec3(1.0 / 3.0)));\n}\n\n// Broken color (W5) — hue + chroma jitter at fixed PERCEPTUAL lightness, in OKLCh.\n// Broken color is hue variation at constant VALUE, which only OKLCh makes true (the\n// prior YIQ-style sRGB rotation muddied value). This is the seam AW.W4's van-Gogh /\n// oil-pastel per-stroke pigment jitter consumes (the pigment-variation read).\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  vec3 lch = oklabToOklch(linOklab(c));\n  // ±~16° hue swing + ±~12% chroma swing; L held so value reads constant.\n  lch.z += (hueSeed - 0.5) * (32.0 * PI / 180.0) * amt;\n  lch.y = max(lch.y * (1.0 + (valueSeed - 0.5) * 0.28 * amt), 0.0);\n  return max(oklabToLinearSrgb(oklchToOklab(lch)), vec3(0.0));\n}\n\n// Saturation (W5) — chroma scale at fixed L/H in OKLCh (the perceptual saturation,\n// replacing the luma-mix sRGB form). amt=1 is identity; amt<1 desaturates toward\n// the achromatic axis with NO lightness shift (the muddy-luma-mix grey is gone).\nvec3 saturate3(vec3 c, float amt) {\n  vec3 lch = oklabToOklch(linOklab(c));\n  lch.y = max(lch.y * amt, 0.0);\n  return max(oklabToLinearSrgb(oklchToOklab(lch)), vec3(0.0));\n}\n\n" + de + A + pe + A + fe + A + me + A + "\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  // AW.W4.3/W4.4 — vangogh (5) is the energy-graded atomic-stroke medium;\n  // oil-pastel (6) is the reworked deposition+scumble+waxy model. The legacy crayon\n  // peer (4) and oil-pastel (6) share the reworked mediumCrayon body (no duplicate).\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  else if (uMedium == 5) col = mediumVangogh(col, pN, t);\n  else if (uMedium == 6) 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";
+//#endregion
+//#region src/composables/glass/createGPUCanvas.ts
+function ge(e, t) {
+	let { device: n, setup: r } = t, i = typeof navigator < "u" && navigator.gpu ? navigator.gpu.getPreferredCanvasFormat() : "bgra8unorm", o = null, s = null, c = n;
+	function l() {
+		let a = e.getContext("webgpu");
+		if (!a) throw Error("[createGPUCanvas] WebGPU canvas context unavailable");
+		return o = a, o.configure({
+			device: n,
+			format: i,
+			alphaMode: t.alphaMode ?? "premultiplied"
+		}), s = r({
+			device: n,
+			context: o,
+			format: i
+		}), {
+			frame: s.frame,
+			shouldContinue: s.shouldContinue,
+			time: s.time,
+			teardown: () => {
+				s?.teardown?.(), o?.unconfigure(), o = null, s = null, c = null;
+			}
+		};
+	}
+	let u = a({
+		canvas: e,
+		mode: t.mode,
+		respectReducedMotion: t.respectReducedMotion,
+		buildContext: l,
+		resize: () => s?.resize()
+	});
+	return {
+		arm: u.arm,
+		suspend: u.suspend,
+		resume: u.resume,
+		wake: u.wake,
+		renderAt: u.renderAt,
+		dispose: u.dispose,
+		get device() {
+			return c;
+		},
+		get reducedMotion() {
+			return u.reducedMotion;
+		}
+	};
+}
+//#endregion
+//#region src/components/custom/aurora/composables/glSetup.ts
+var j = "[Aurora]", _e = /* @__PURE__ */ "uTime.uPalette.uStopCount.uNucleiCount.uNucleiPos.uNucleiRadius.uNucleiPaletteBias.uNucleiValueBias.uNucleiDriftRadius.uNucleiDriftPhase.uNucleiElong.uNucleiAngle.uSoftmaxBeta.uValueVariance.uWarpAmount.uWarpScale.uWarpDrift.uWarpMode.uNoiseOctaves.uMedium.uHuePath.uFlowPattern.uFlowFocal.uFlowAngle.uFlowCurl.uCursor.uCursorStrength.uCursorRadius.uCursorVelocity.uCursorBurst.uStrokeAmount.uStrokeScale.uStrokeAnisotropy.uStrokeLayers.uStrokeMode.uStrokeOrient.uLightDir.uLightColor.uWetEdge.uGranulation.uImpasto.uBrokenColor.uCanvasGrain.uNucleiDrift.uPaletteDrift.uBreathDepth.uBreathPeriod.uSaturation.uPaperGrain.uAlpha".split(".");
+function M(e, t, n) {
+	let r = d(e, e.VERTEX_SHADER, t, j), i = d(e, e.FRAGMENT_SHADER, n, j), a = s(e, r, i, j);
+	e.useProgram(a);
+	let o = e.createVertexArray();
+	e.bindVertexArray(o);
+	let c = e.createBuffer();
+	e.bindBuffer(e.ARRAY_BUFFER, c), e.bufferData(e.ARRAY_BUFFER, new Float32Array([
 		-1,
 		-1,
 		3,
@@ -222,116 +351,227 @@ function L(e, t, n) {
 		-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);
+	let l = e.getAttribLocation(a, "aPos");
+	e.enableVertexAttribArray(l), e.vertexAttribPointer(l, 2, e.FLOAT, !1, 0, 0);
+	let u = {};
+	for (let t of _e) u[t] = e.getUniformLocation(a, t);
 	return {
-		program: s,
-		vs: i,
-		fs: a,
-		uniforms: d,
+		program: a,
+		vs: r,
+		fs: i,
+		uniforms: u,
 		geometry: {
-			vao: c,
-			buf: l
+			vao: o,
+			buf: c
 		}
 	};
 }
 //#endregion
 //#region src/components/custom/aurora/composables/color.ts
-function R(e, t = 8, n) {
+function N(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] = u(e[t]);
+		let [n, i, a] = _(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 z(e) {
+function P(e) {
 	if (e.length === 0) return "transparent";
-	if (e.length === 1) return d(e[0]);
+	if (e.length === 1) return y(e[0]);
 	let t = e.length;
 	return `linear-gradient(135deg, ${e.map((e, n) => {
 		let r = Math.round(n / (t - 1) * 100);
-		return `${d(e)} ${r}%`;
+		return `${y(e)} ${r}%`;
 	}).join(", ")})`;
 }
-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);
+function F(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] = se(n / 255, r / 255, i / 255), [c, l, u] = oe(a, o, s);
 	return {
 		L: c,
 		C: l,
 		h: u
 	};
 }
-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 + (p - d) * t, a = n.C * (1 - (1 - o) * t), l = U(n.h, i, s, t);
-		m.push(W({
+var I = [.35, .95];
+function L(e, t = {}) {
+	let n = typeof e == "string" ? b(e) : e, { stopCount: r = 4, harmony: i = "analogous", lightnessSpread: a = .32, chromaFalloff: o = .85, hueSpread: s = 28, lightnessEasing: c = "linear", chromaEasing: l = "bell", temperatureShift: u = 0 } = t, d = Math.max(2, Math.min(8, Math.round(r))), [f, p] = I, m = n.L - a / 2, h = n.L + a / 2;
+	m < f && (h += f - m, m = f), h > p && (m -= h - p, h = p), m = Math.max(f, m), h = Math.min(p, h);
+	let _ = [];
+	for (let e = 0; e < d; e++) {
+		let t = d === 1 ? 0 : e / (d - 1), r = m + (h - m) * R(t, c), a = n.C * o, f;
+		if (l === "bell") f = a + (n.C - a) * ve(t);
+		else {
+			let e = l === "sine" ? R(t, "sine") : t;
+			f = n.C - (n.C - a) * e;
+		}
+		let p = v(n.h, i, s, t);
+		u > 0 && (p = ye(p, t, u)), _.push(g({
 			L: r,
-			C: a,
-			h: l
+			C: f,
+			h: p
 		}));
 	}
-	return m;
+	return _;
 }
-function U(e, t, n, r) {
-	let i = (e) => (e % 360 + 360) % 360;
-	switch (t) {
-		case "monochrome": return i(e);
-		case "complementary": return i(e + 180 * r);
-		case "triad": return i(e + 240 * r);
-		default: return i(e + n * (r - .5) * 2);
-	}
+function R(e, t) {
+	return t === "sine" ? .5 - .5 * Math.cos(Math.PI * e) : e;
+}
+function ve(e) {
+	return Math.sin(Math.PI * e);
 }
-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] = A(s, u, l), [r, i, a] = O(e, t, n);
-		if (D(r, i, a)) break;
-		u *= .999;
+function ye(e, t, n) {
+	return ((e) => (e % 360 + 360) % 360)(e + (t - .5) * 2 * n * 22);
+}
+function be(e) {
+	let t = [.33, .67], n = [
+		[t[0], t[0]],
+		[t[1], t[1]],
+		[t[1], t[0]],
+		[t[0], t[1]],
+		[.5, .5],
+		[.5, t[0]]
+	], r = Math.max(1, Math.min(n.length, e));
+	return Array.from({ length: r }, (e, t) => {
+		let [i, a] = n[t];
+		return {
+			x: i,
+			y: a,
+			radius: .5,
+			paletteBias: r === 1 ? 0 : t / (r - 1),
+			valueBias: (t % 2 == 0 ? 1 : -1) * .05,
+			driftRadius: .045,
+			driftPhase: t * 2.4 % (Math.PI * 2)
+		};
+	});
+}
+var xe = {
+	atmospheric: {
+		harmony: "analogous",
+		medium: "smooth",
+		temperatureShift: .3,
+		chromaEasing: "bell",
+		saturation: .95,
+		warpAmount: .55,
+		valueVariance: .08,
+		breathDepth: .06,
+		zones: 2
+	},
+	painterly: {
+		harmony: "split-complementary",
+		medium: "oil",
+		temperatureShift: .6,
+		chromaEasing: "bell",
+		saturation: 1.05,
+		warpAmount: .45,
+		valueVariance: .12,
+		breathDepth: .04,
+		zones: 3
+	},
+	vivid: {
+		harmony: "triad",
+		medium: "watercolor",
+		temperatureShift: .2,
+		chromaEasing: "linear",
+		saturation: 1.2,
+		warpAmount: .5,
+		valueVariance: .14,
+		breathDepth: .05,
+		zones: 3
+	},
+	muted: {
+		harmony: "monochrome",
+		medium: "pastel",
+		temperatureShift: .15,
+		chromaEasing: "bell",
+		saturation: .78,
+		warpAmount: .4,
+		valueVariance: .06,
+		breathDepth: .03,
+		zones: 2
 	}
+};
+function Se(e, t = "atmospheric") {
+	let n = xe[t], r = L(e, {
+		harmony: n.harmony,
+		temperatureShift: n.temperatureShift,
+		chromaEasing: n.chromaEasing,
+		stopCount: 4
+	});
 	return {
-		L: s,
-		C: u,
-		h: l
+		...h,
+		palette: r,
+		nuclei: be(n.zones),
+		medium: n.medium,
+		saturation: n.saturation,
+		warpAmount: n.warpAmount,
+		valueVariance: n.valueVariance,
+		breathDepth: n.breathDepth
 	};
 }
 //#endregion
 //#region src/components/custom/aurora/composables/uniformBridge.ts
-var G = {
+var z = {
 	smooth: 0,
 	pastel: 1,
 	watercolor: 2,
 	oil: 3,
-	crayon: 4
-}, K = {
+	crayon: 4,
+	vangogh: 5,
+	"oil-pastel": 6
+}, Ce = {
+	shorter: 0,
+	longer: 1,
+	increasing: 2,
+	decreasing: 3
+}, we = {
 	none: 0,
 	radial: 1,
 	swirl: 2,
 	diagonal: 3,
-	multi: 4
-}, se = {
+	multi: 4,
+	tensor: 5
+}, B = {
+	flow: 0,
+	tensor: 1
+}, V = {
 	fbm: 0,
 	cellular: 1,
 	hybrid: 2
-}, q = {
+}, H = {
 	oil: 0,
 	knife: 1,
 	chunky: 3
 };
-function ce(e) {
-	return e.medium === "oil" && e.strokeMode === "crayon" ? G.crayon : G[e.medium];
+function U(e) {
+	return e.medium === "oil" && e.strokeMode === "crayon" ? z.crayon : z[e.medium];
+}
+function Te(e) {
+	return e.strokeMode === "crayon" ? H.oil : H[e.strokeMode];
 }
-function le(e) {
-	return e.strokeMode === "crayon" ? q.oil : q[e.strokeMode];
+function Ee(e) {
+	return e.medium === "vangogh" || e.medium === "oil-pastel" ? B.tensor : B[e.strokeOrient ?? "flow"];
 }
-function ue(e, t, n, r) {
+var W = 16, De = W + 32 + 48;
+function Oe(e, t, n) {
+	n.fill(0), n[0] = t, n[1] = Math.min(e.palette.length, 8), n[2] = Math.min(e.nuclei.length, 6), n[3] = e.softmaxBeta, n[4] = e.valueVariance, n[5] = e.warpAmount, n[6] = e.warpScale, n[7] = e.warpDrift, n[8] = V[e.warpMode], n[9] = e.noiseOctaves, n[10] = U(e), n[11] = e.breathDepth, n[12] = e.breathPeriod, n[13] = e.saturation, n[14] = e.paperGrain, n[15] = e.alpha;
+	let r = N(e.palette, 8), i = W;
+	for (let e = 0; e < 8; e++) n[i + e * 4 + 0] = r[e * 3 + 0], n[i + e * 4 + 1] = r[e * 3 + 1], n[i + e * 4 + 2] = r[e * 3 + 2];
+	i = W + 32;
+	let a = Math.min(e.nuclei.length, 6);
+	for (let t = 0; t < a; t++) {
+		let r = e.nuclei[t];
+		n[i + t * 4 + 0] = r.x, n[i + t * 4 + 1] = 1 - r.y, n[i + t * 4 + 2] = r.radius, n[i + t * 4 + 3] = r.paletteBias;
+	}
+	i = W + 32 + 24;
+	for (let t = 0; t < a; t++) {
+		let r = e.nuclei[t];
+		n[i + t * 4 + 0] = r.valueBias, n[i + t * 4 + 1] = r.elongation ?? 1, n[i + t * 4 + 2] = -(r.angle ?? 0) * Math.PI / 180, n[i + t * 4 + 3] = r.driftRadius;
+	}
+	return n;
+}
+function G(e, t, n, r) {
 	let i = (e) => 1 - e, a = {
 		palette: new Float32Array(24),
 		pos: new Float32Array(12),
@@ -344,7 +584,7 @@ function ue(e, t, n, r) {
 		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));
+		e.useProgram(t), N(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++) {
@@ -352,13 +592,26 @@ function ue(e, t, n, r) {
 			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);
+		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, V[o.warpMode]), e.uniform1i(n.uNoiseOctaves, o.noiseOctaves), e.uniform1i(n.uMedium, U(o)), e.uniform1i(n.uHuePath, Ce[o.huePath ?? "shorter"]), e.uniform1i(n.uFlowPattern, we[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.uniform2f(n.uCursorVelocity, r.velX, -r.velY), e.uniform1f(n.uCursorBurst, r.burst), 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, Te(o)), e.uniform1i(n.uStrokeOrient, Ee(o));
+		{
+			let t = o.lightDir ?? [
+				-.5,
+				.6,
+				.62
+			], r = o.lightColor ?? [
+				1,
+				.95,
+				.88
+			];
+			e.uniform3f(n.uLightDir, t[0], t[1], t[2]), e.uniform3f(n.uLightColor, r[0], r[1], r[2]);
+		}
+		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);
 	};
 }
 //#endregion
 //#region src/components/custom/aurora/composables/cursorModel.ts
-var J = .22, de = .18, fe = .992;
-function pe() {
+var K = .22, ke = .18, Ae = .992, je = .96, q = .3;
+function Me() {
 	return {
 		x: .5,
 		y: .5,
@@ -366,115 +619,394 @@ function pe() {
 		targetY: .5,
 		strength: 0,
 		targetStrength: 0,
-		radius: .25
+		radius: .25,
+		velX: 0,
+		velY: 0,
+		burst: 0
 	};
 }
-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 J(e, t = 1) {
+	let n = Math.max(0, Math.min(1, t));
+	e.x += (e.targetX - e.x) * K, e.y += (e.targetY - e.y) * K, e.strength += (e.targetStrength - e.strength) * ke, e.targetStrength *= Ae, e.velX *= (1 - q) * n, e.velY *= (1 - q) * n, e.burst *= je * n;
 }
-function he(e) {
+function Ne(e, t, n) {
+	let r = .12, i = Math.max(-r, Math.min(r, t)), a = Math.max(-r, Math.min(r, n));
+	e.velX += (i - e.velX) * q, e.velY += (a - e.velY) * q;
+	let o = Math.hypot(i, a);
+	e.burst = Math.min(1, e.burst + o * 4);
+}
+function Pe(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) {
+function Fe(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 c() {
+		return +!o();
 	}
-	function l() {
+	function l(e) {
+		if (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.uniform2f(r.uCursorVelocity, i.velX, -i.velY), t.uniform1f(r.uCursorBurst, i.burst), t.uniform1f(r.uTime, e), a().interactivity?.light) {
+			let n = c(), a = e * .25, o = Math.cos(a) * .5, s = Math.sin(a) * .5, l = (i.x - .5) * 2, u = (.5 - i.y) * 2, d = i.strength * n;
+			o = o * (1 - d) + l * d, s = s * (1 - d) + u * d, t.uniform3f(r.uLightDir, o * n + (1 - n) * -.5, s * n + (1 - n) * .6, .62);
+		}
+		t.clear(t.COLOR_BUFFER_BIT), t.drawArrays(t.TRIANGLES, 0, 3);
+	}
+	function u() {
 		if (o()) return !1;
 		let e = a();
-		return e.nucleiDrift !== 0 || e.paletteDrift !== 0 || e.breathDepth !== 0 || e.warpDrift !== 0 ? !0 : he(i);
+		return e.nucleiDrift !== 0 || e.paletteDrift !== 0 || e.breathDepth !== 0 || e.warpDrift !== 0 || e.interactivity?.light && i.burst > .001 ? !0 : Pe(i);
 	}
 	return {
 		frame: (e) => {
-			me(i), c(e);
+			J(i, c()), l(e);
 		},
-		needsAnimation: l
+		needsAnimation: u
+	};
+}
+var Ie = "\nstruct VSOut {\n  @builtin(position) pos: vec4f,\n  @location(0) uv: vec2f,\n};\n\n@vertex\nfn vs_main(@builtin(vertex_index) vi: u32) -> VSOut {\n  // Full-screen triangle (matches the WebGL2 [-1,-1, 3,-1, -1,3] quad).\n  var p = array<vec2f, 3>(vec2f(-1.0, -1.0), vec2f(3.0, -1.0), vec2f(-1.0, 3.0));\n  var out: VSOut;\n  let xy = p[vi];\n  out.pos = vec4f(xy, 0.0, 1.0);\n  out.uv = 0.5 * (xy + vec2f(1.0));\n  return out;\n}", Le = `
+const PI: f32 = 3.141592653589793;
+const W_LUMA: vec3f = vec3f(0.2126, 0.7152, 0.0722);
+const MAX_NUCLEI: u32 = 6u;
+const MAX_STOPS: u32 = 8u;
+
+// The std140 uniform struct — the WebGPU write path packs an AuroraConfig here.
+struct Uniforms {
+  time: f32,
+  stopCount: i32,
+  nucleiCount: i32,
+  softmaxBeta: f32,
+  valueVariance: f32,
+  warpAmount: f32,
+  warpScale: f32,
+  warpDrift: f32,
+  warpMode: i32,
+  noiseOctaves: i32,
+  medium: i32,
+  breathDepth: f32,
+  breathPeriod: f32,
+  saturation: f32,
+  paperGrain: f32,
+  alpha: f32,
+  palette: array<vec4f, 8>,      // .xyz = linear-sRGB stop
+  nucleiPos: array<vec4f, 6>,    // .xy pos, .z radius, .w paletteBias
+  nucleiMod: array<vec4f, 6>,    // .x valueBias, .y elong, .z angle, .w driftRadius
+};
+
+@group(0) @binding(0) var<uniform> U: Uniforms;
+
+${f}
+${n}
+${i}
+
+fn hash21(p0: vec2f) -> f32 {
+  var p = fract(p0 * vec2f(123.34, 456.21));
+  p = p + dot(p, p + 45.32);
+  return fract(p.x * p.y);
+}
+fn vnoise(p: vec2f) -> f32 {
+  let i = floor(p);
+  let f = fract(p);
+  let u = f * f * (3.0 - 2.0 * f);
+  let a = hash21(i);
+  let b = hash21(i + vec2f(1.0, 0.0));
+  let c = hash21(i + vec2f(0.0, 1.0));
+  let d = hash21(i + vec2f(1.0, 1.0));
+  return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);
+}
+fn fbm(p0: vec2f) -> f32 {
+  var v = 0.0;
+  var a = 0.5;
+  var p = p0;
+  for (var i = 0; i < 5; i = i + 1) {
+    if (i >= U.noiseOctaves) { break; }
+    v = v + a * vnoise(p);
+    p = FBM_ROT * p * 2.02;
+    a = a * 0.5;
+  }
+  return v;
+}
+
+fn samplePalette(id: f32) -> vec3f {
+  // Nearest-pair OKLab interpolation across the stops (mirrors the GLSL default ramp).
+  let n = U.stopCount;
+  if (n <= 1) { return U.palette[0].xyz; }
+  let t = clamp(id, 0.0, 1.0) * f32(n - 1);
+  let i0 = i32(floor(t));
+  let i1 = min(i0 + 1, n - 1);
+  let f = t - f32(i0);
+  let labA = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * U.palette[i0].xyz) * pow(abs(LINEAR_SRGB_TO_LMS * U.palette[i0].xyz), vec3f(1.0 / 3.0)));
+  let labB = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * U.palette[i1].xyz) * pow(abs(LINEAR_SRGB_TO_LMS * U.palette[i1].xyz), vec3f(1.0 / 3.0)));
+  return oklabToLinearSrgb(mix(labA, labB, f));
+}
+
+fn domainWarp(p: vec2f, t: f32) -> vec2f {
+  let drift = t * U.warpDrift * 5.0;
+  let q = vec2f(
+    fbm(p * U.warpScale + vec2f(drift, 0.0)),
+    fbm(p * U.warpScale + vec2f(5.2, 1.3 + drift))
+  );
+  let r = vec2f(
+    fbm(p * U.warpScale + 4.0 * q + vec2f(1.7, 9.2)),
+    fbm(p * U.warpScale + 4.0 * q + vec2f(8.3, 2.8))
+  );
+  return p + U.warpAmount * r;
+}
+
+fn nucleiField(p: vec2f, t: f32) -> vec2f {
+  // Returns (paletteId, valueMod) — softmax over the nuclei (isotropic; the WebGPU
+  // twin keeps the parity-floor isotropic Gaussian).
+  var accumId = 0.0;
+  var accumVal = 0.0;
+  var w = 0.0;
+  let n = U.nucleiCount;
+  for (var i = 0; i < 6; i = i + 1) {
+    if (i >= n) { break; }
+    let pos = U.nucleiPos[i].xy;
+    let rad = max(U.nucleiPos[i].z, 0.01);
+    let d2 = dot(p - pos, p - pos);
+    let wi = exp((-U.softmaxBeta * d2) / (rad * rad));
+    accumId = accumId + wi * U.nucleiPos[i].w;
+    accumVal = accumVal + wi * U.nucleiMod[i].x;
+    w = w + wi;
+  }
+  if (w < 1e-4) { return vec2f(0.5, 0.0); }
+  return vec2f(accumId / w, accumVal / w);
+}
+
+// ACES (Narkowicz) — matches the GLSL tonemap.
+fn aces(x: vec3f) -> vec3f {
+  let a = 2.51; let b = 0.03; let c = 2.43; let d = 0.59; let e = 0.14;
+  return clamp((x * (a * x + b)) / (x * (c * x + d) + e), vec3f(0.0), vec3f(1.0));
+}
+
+@fragment
+fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
+  let t = U.time;
+  let pw = domainWarp(uv, t);
+  let nf = nucleiField(pw, t);
+  var col = samplePalette(nf.x);
+  col = col * (1.0 + U.valueVariance * nf.y);
+
+  // Breath.
+  let breath = sin(t * 6.2831 / max(U.breathPeriod, 1.0));
+  col = col * (1.0 + U.breathDepth * breath * 0.5);
+
+  // (The WebGPU smooth pole; the painterly mediums run the W7c multi-pass passes.)
+  col = aces(col);
+  col = linearToSrgb(col);                // the mandatory OETF (linear → display).
+  return vec4f(col * U.alpha, U.alpha);   // premultiply AFTER the OETF (parity).
+}`, Re = Ie + "\n" + Le;
+//#endregion
+//#region src/components/custom/aurora/composables/gpuRuntime.ts
+function ze(e) {
+	let { canvas: t, getConfig: n, cursor: r, getReducedMotion: i, frozenOffset: a } = e;
+	return function({ device: e, context: o, format: s }) {
+		let l = e.createShaderModule({ code: Re }), u = e.createRenderPipeline({
+			layout: "auto",
+			vertex: {
+				module: l,
+				entryPoint: "vs_main"
+			},
+			fragment: {
+				module: l,
+				entryPoint: "fs_main",
+				targets: [{
+					format: s,
+					blend: {
+						color: {
+							srcFactor: "one",
+							dstFactor: "one-minus-src-alpha"
+						},
+						alpha: {
+							srcFactor: "one",
+							dstFactor: "one-minus-src-alpha"
+						}
+					}
+				}]
+			},
+			primitive: { topology: "triangle-list" }
+		}), d = new Float32Array(De), f = e.createBuffer({
+			size: d.byteLength,
+			usage: 72
+		}), p = e.createBindGroup({
+			layout: u.getBindGroupLayout(0),
+			entries: [{
+				binding: 0,
+				resource: { buffer: f }
+			}]
+		});
+		function m() {
+			let e = c(), n = t.clientWidth || t.parentElement?.clientWidth || 1, r = t.clientHeight || t.parentElement?.clientHeight || 1;
+			t.width = Math.max(1, Math.floor(n * e)), t.height = Math.max(1, Math.floor(r * e));
+		}
+		function h(t) {
+			J(r), Oe(n(), t, d), e.queue.writeBuffer(f, 0, d);
+			let i = e.createCommandEncoder(), a = o.getCurrentTexture().createView(), s = i.beginRenderPass({ colorAttachments: [{
+				view: a,
+				clearValue: {
+					r: 0,
+					g: 0,
+					b: 0,
+					a: 0
+				},
+				loadOp: "clear",
+				storeOp: "store"
+			}] });
+			s.setPipeline(u), s.setBindGroup(0, p), s.draw(3), s.end(), e.queue.submit([i.finish()]);
+		}
+		function g() {
+			if (i()) return !1;
+			let e = n();
+			return e.nucleiDrift !== 0 || e.paletteDrift !== 0 || e.breathDepth !== 0 || e.warpDrift !== 0;
+		}
+		return {
+			frame: h,
+			shouldContinue: g,
+			resize: m,
+			time: (e) => i() ? a : e,
+			teardown: () => {
+				f.destroy();
+			}
+		};
 	};
 }
 //#endregion
 //#region src/components/custom/aurora/composables/runtime.ts
-function _e(e) {
+function Be(e) {
 	return e.mode === "capture" ? !0 : e.initStrategy === "eager";
 }
-function Y(e) {
+function Ve(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",
+function Y(e, t, n = {}) {
+	let r = Ve(n), i = t, a = 3.7, o = Me(), s = null, u = n.gpuDevice ? ge(e, {
+		device: n.gpuDevice,
+		mode: n.mode === "capture" ? "capture" : "live",
+		alphaMode: "premultiplied",
+		setup: ze({
+			canvas: e,
+			getConfig: () => i,
+			cursor: o,
+			getReducedMotion: () => u.reducedMotion,
+			frozenOffset: a
+		})
+	}) : l(e, {
+		mode: n.mode === "capture" ? "capture" : "live",
 		contextAttrs: {
 			antialias: !1,
 			alpha: !0,
 			premultipliedAlpha: !0,
-			preserveDrawingBuffer: i
+			preserveDrawingBuffer: r
 		},
 		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);
+			let { program: n, vs: r, fs: l, uniforms: d, geometry: f } = M(t, ce, he);
+			function p() {
+				let r = c(), i = e.clientWidth || e.parentElement?.clientWidth || 1, a = e.clientHeight || e.parentElement?.clientHeight || 1, o = Math.max(1, Math.floor(i * r)), s = Math.max(1, Math.floor(a * r));
+				e.width = o, e.height = s, t.viewport(0, 0, o, s), t.useProgram(n);
 			}
-			let p = ue(t, r, u, s), m = ge({
+			let m = G(t, n, d, o), h = Fe({
 				gl: t,
-				prog: r,
-				uniforms: u,
-				cursor: s,
-				getConfig: () => o,
-				getReducedMotion: () => l.reducedMotion
+				prog: n,
+				uniforms: d,
+				cursor: o,
+				getConfig: () => i,
+				getReducedMotion: () => u.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);
+			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), s = (e) => {
+				i = e, m(e);
+			}, s(i), requestAnimationFrame(() => {
+				p(), requestAnimationFrame(p);
 			}), {
-				frame: m.frame,
-				shouldContinue: m.needsAnimation,
-				resize: f,
-				time: (e) => l.reducedMotion ? 3.7 : e,
+				frame: h.frame,
+				shouldContinue: h.needsAnimation,
+				resize: p,
+				time: (e) => u.reducedMotion ? a : e,
 				teardown: () => {
-					t.deleteProgram(r), t.deleteShader(i), t.deleteShader(a), t.deleteBuffer(d.buf), t.deleteVertexArray(d.vao);
+					t.deleteProgram(n), t.deleteShader(r), t.deleteShader(l), t.deleteBuffer(f.buf), t.deleteVertexArray(f.vao);
 				}
 			};
 		}
 	});
-	function u(e, t, n = .8) {
-		s.targetX = e, s.targetY = t, s.targetStrength = n, l.wake();
+	function d(e, t, n = .8) {
+		o.targetX = e, o.targetY = t, o.targetStrength = n, u.wake();
+	}
+	function f(e, t) {
+		u.reducedMotion || (Ne(o, e, t), u.wake());
 	}
-	function d() {
-		s.targetStrength = 0, l.wake();
+	function p() {
+		o.targetStrength = 0, u.wake();
 	}
-	function f(e) {
-		s.radius = e, l.wake();
+	function m(e) {
+		o.radius = e, u.wake();
 	}
-	function p(e) {
-		l.wake();
+	function h(e) {
+		u.wake();
 	}
-	return r.mode !== "capture" && _e(r) && l.arm(), {
-		arm: () => l.arm(),
+	return n.mode !== "capture" && Be(n) && u.arm(), {
+		arm: () => u.arm(),
 		update: (e) => {
-			o = e, c?.(e), l.wake();
+			i = e, s?.(e), u.wake();
+		},
+		setCursor: d,
+		clearCursor: p,
+		setCursorRadius: m,
+		setReducedMotion: h,
+		injectCursorVelocity: f,
+		get reducedMotion() {
+			return u.reducedMotion;
 		},
-		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()
+		pause: (e = "manual") => u.suspend(e),
+		resume: (e = "manual") => u.resume(e),
+		renderAt: (e) => u.renderAt(e),
+		dispose: () => u.dispose()
 	};
 }
 //#endregion
 //#region src/components/custom/aurora/composables/configSource.ts
-function Z(e) {
+function X(e) {
 	return typeof e == "function" ? e : e && typeof e == "object" && "value" in e ? () => e.value : () => e;
 }
 //#endregion
+//#region src/components/custom/aurora/constants/renderMode.ts
+function Z(e) {
+	if (e !== "auto") return e;
+	if (typeof navigator > "u" || typeof window > "u") return "webgl";
+	let t = typeof navigator.hardwareConcurrency == "number" && navigator.hardwareConcurrency <= 4, n = typeof window.matchMedia == "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches, r = navigator.connection?.saveData === !0;
+	return t || n || r ? "css" : "webgl";
+}
+function He(e) {
+	let t = e;
+	return typeof t.isFallbackAdapter == "boolean" ? t.isFallbackAdapter : e.info?.isFallbackAdapter === !0;
+}
+async function Ue(e) {
+	if (Z(e) === "css") return {
+		substrate: "css",
+		device: null
+	};
+	if (typeof navigator > "u" || !navigator.gpu) return {
+		substrate: "webgl",
+		device: null
+	};
+	try {
+		let e = await navigator.gpu.requestAdapter({ powerPreference: "high-performance" });
+		return !e || He(e) ? {
+			substrate: "webgl",
+			device: null
+		} : {
+			substrate: "webgpu",
+			device: await e.requestDevice()
+		};
+	} catch {
+		return {
+			substrate: "webgl",
+			device: null
+		};
+	}
+}
+//#endregion
 //#region src/components/custom/aurora/composables/useAurora.ts
-function ve(e) {
+function We(e) {
 	if (typeof window > "u") return () => {};
 	if (typeof window.requestIdleCallback == "function") {
 		let t = window.requestIdleCallback(() => e(), { timeout: 2e3 });
@@ -492,9 +1024,9 @@ function ve(e) {
 	};
 }
 function Q(e, t, n = {}, r = {}) {
-	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";
+	let i = X(t), a = r.renderMode === "css", o = null, s = null, c = null, l = null, u = null, d = null, f = null, p = !1, m = O(!1), h = n.mode === "capture" || n.initStrategy === "eager";
 	function g() {
-		d && o && o.setReducedMotion(d.matches);
+		f && o && o.setReducedMotion(f.matches);
 	}
 	function _(e) {
 		let t = e instanceof Error ? e : Error(String(e));
@@ -505,22 +1037,27 @@ function Q(e, t, n = {}, r = {}) {
 		Promise.reject(t);
 	}
 	function v() {
-		if (!(f || !o)) {
-			f = !0;
+		if (!(p || !o)) {
+			p = !0;
 			try {
 				o.arm();
 			} catch (e) {
 				_(e);
 				return;
 			}
-			m.value = !0, d = window.matchMedia("(prefers-reduced-motion: reduce)"), d.addEventListener("change", g), s = T(i, (e) => o?.update(e), { deep: !0 });
+			m.value = !0, f = window.matchMedia("(prefers-reduced-motion: reduce)"), f.addEventListener("change", g), s = k(i, (e) => o?.update(e), { deep: !0 }), i().interactivity?.scroll && e.value && (l = k(ee({
+				target: e,
+				trackExit: !0
+			}), (e) => {
+				!o || o.reducedMotion || o.setCursorRadius(.2 + e * .25);
+			}));
 		}
 	}
-	return x(() => {
+	return D(() => {
 		let t = e.value;
 		if (!t || a) return;
 		try {
-			o = X(t, i(), {
+			o = Y(t, i(), {
 				initStrategy: "deferred",
 				...n
 			});
@@ -532,150 +1069,152 @@ function Q(e, t, n = {}, r = {}) {
 			v();
 			return;
 		}
-		u = p(e, {
+		d = x(e, {
 			pause: () => o?.pause("off-screen"),
 			resume: () => o?.resume("off-screen")
 		}, { pauseWhenHidden: !1 });
-		let r = u.isIntersecting;
-		c = T(r, (e) => {
-			!e || f || l || (l = ve(() => {
-				l = null, r.value && v();
+		let r = d.isIntersecting;
+		c = k(r, (t) => {
+			!t || p || u || (u = We(() => {
+				u = null, r.value && Ue("webgl").then(({ substrate: t, device: a }) => {
+					p || (t === "webgpu" && a && o && e.value && (o.dispose(), o = Y(e.value, i(), {
+						initStrategy: "deferred",
+						...n,
+						gpuDevice: a
+					})), r.value && v());
+				}).catch(() => {
+					r.value && v();
+				});
 			}));
 		}, { immediate: !0 });
-	}), b(() => {
-		l?.(), c?.(), s?.(), u?.dispose(), d?.removeEventListener("change", g), o?.dispose(), o = null;
+	}), E(() => {
+		u?.(), c?.(), s?.(), l?.(), d?.dispose(), f?.removeEventListener("change", g), o?.dispose(), o = null;
 	}), {
 		setCursor: (e, t, n) => o?.setCursor(e, t, n),
 		clearCursor: () => o?.clearCursor(),
 		setCursorRadius: (e) => o?.setCursorRadius(e),
+		injectCursorVelocity: (e, t) => o?.injectCursorVelocity(e, t),
 		renderAt: (e) => o?.renderAt(e),
 		pause: () => o?.pause(),
 		resume: () => o?.resume(),
-		isArmed: C(m)
+		isArmed: ie(m)
 	};
 }
 //#endregion
-//#region src/components/custom/aurora/constants/renderMode.ts
-function $(e) {
-	if (e !== "auto") return e;
-	if (typeof navigator > "u" || typeof window > "u") return "webgl";
-	let t = typeof navigator.hardwareConcurrency == "number" && navigator.hardwareConcurrency <= 4, n = typeof window.matchMedia == "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches, r = navigator.connection?.saveData === !0;
-	return t || n || r ? "css" : "webgl";
-}
-//#endregion
 //#region src/components/custom/aurora/Aurora.vue
-var ye = /* @__PURE__ */ e(/* @__PURE__ */ _({
+var Ge = /* @__PURE__ */ e(/* @__PURE__ */ te({
 	__name: "Aurora",
 	props: {
-		config: { default: () => l },
+		config: { default: () => h },
 		runtimeOptions: {},
 		onInitError: {},
 		renderMode: { default: "auto" },
 		opacityCeiling: { default: 1 }
 	},
 	setup(e, { expose: t }) {
-		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(() => ({
+		let n = e, r = Z(n.renderMode), i = S(() => Math.max(0, Math.min(1, n.opacityCeiling))), a = O(null), o = Q(a, () => n.config, S(() => ({
 			...n.runtimeOptions ?? {},
 			...n.onInitError ? { onInitError: n.onInitError } : {}
-		})).value, { renderMode: r }), s = m(() => z(n.config.palette));
+		})).value, { renderMode: r }), s = S(() => P(n.config.palette));
 		return t({
 			config: n.config,
 			canvasRef: a,
 			setCursor: o.setCursor,
 			clearCursor: o.clearCursor,
 			setCursorRadius: o.setCursorRadius,
+			injectCursorVelocity: o.injectCursorVelocity,
 			renderAt: o.renderAt,
 			pause: o.pause,
 			resume: o.resume,
 			isArmed: o.isArmed
-		}), (e, t) => (S(), h("div", {
+		}), (e, t) => (re(), C("div", {
 			class: "aurora-root block h-full w-full overflow-hidden",
-			style: y({ "--aurora-opacity-ceiling": i.value })
-		}, [g("div", {
+			style: T({ "--aurora-opacity-ceiling": i.value })
+		}, [w("div", {
 			class: "aurora-placeholder h-full w-full",
 			"aria-hidden": "true",
-			style: y({ backgroundImage: s.value })
-		}, null, 4), g("canvas", {
+			style: T({ backgroundImage: s.value })
+		}, null, 4), w("canvas", {
 			ref_key: "canvasRef",
 			ref: a,
 			"aria-hidden": "true",
-			class: v(["aurora-canvas block h-full w-full", { "aurora-canvas--armed": ee(o).isArmed.value }])
+			class: ne(["aurora-canvas block h-full w-full", { "aurora-canvas--armed": ae(o).isArmed.value }])
 		}, null, 2)], 4));
 	}
-}), [["__scopeId", "data-v-c5277232"]]);
+}), [["__scopeId", "data-v-59e84382"]]);
 //#endregion
 //#region src/components/custom/aurora/composables/useCursorInteraction.ts
-function be(e, t, n) {
-	let r = Z(t), i = n.hitFraction ?? .35, a = null, o = null;
-	function s(e, t) {
+function Ke(e, t, n) {
+	let r = X(t), i = n.hitFraction ?? .35, a = null, o = null, s = null, c = null;
+	function l(e, t) {
 		let n = t.getBoundingClientRect();
 		return {
 			x: (e.clientX - n.left) / Math.max(n.width, 1),
 			y: (e.clientY - n.top) / Math.max(n.height, 1)
 		};
 	}
-	function c(e, t, n) {
+	function u(e, t, n) {
 		let r = t - e.x, i = n - e.y, a = (e.angle ?? 0) * Math.PI / 180, o = Math.cos(a), s = Math.sin(a), c = o * r + s * i, l = -s * r + o * i, u = c / Math.max(e.elongation ?? 1, .01), d = l;
 		return u * u + d * d;
 	}
-	function l(e, t) {
+	function d(e, t) {
 		let n = null, a = Infinity;
 		for (let o = 0; o < r().nuclei.length; o++) {
-			let s = r().nuclei[o], l = c(s, e, t), u = s.radius * i;
-			l < u * u && l < a && (a = l, n = o);
+			let s = r().nuclei[o], c = u(s, e, t), l = s.radius * i;
+			c < l * l && c < a && (a = c, n = o);
 		}
 		return n;
 	}
-	function u(e, t) {
+	function f(e, t) {
 		let n = 0, i = 0;
 		for (let a of r().nuclei) {
-			let o = c(a, e, t), s = Math.max(a.radius, .01), l = Math.exp(-r().softmaxBeta * o / (s * s));
-			n += l * a.paletteBias, i += l;
+			let o = u(a, e, t), s = Math.max(a.radius, .01), c = Math.exp(-r().softmaxBeta * o / (s * s));
+			n += c * a.paletteBias, i += c;
 		}
 		return i > 1e-4 ? n / i : .5;
 	}
-	function d() {
+	function p() {
 		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 f(e, t) {
+	function m(e, t) {
 		return {
 			x: e,
 			y: t,
-			radius: d(),
-			paletteBias: u(e, t),
+			radius: p(),
+			paletteBias: f(e, t),
 			valueBias: 0,
 			driftRadius: .012,
 			driftPhase: Math.random() * Math.PI * 2
 		};
 	}
-	function p(t) {
+	function h(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);
+		let { x: o, y: u } = l(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, u))), n.setCursor(o, u, 1), n.injectVelocity && s !== null && c !== null && n.injectVelocity(o - s, u - c), s = o, c = u;
 	}
-	function m() {
-		a === null && n.clearCursor();
+	function g() {
+		s = null, c = null, a === null && n.clearCursor();
 	}
-	function h(t) {
+	function _(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) {
+		let { x: i, y: s } = l(t, n), c = d(i, s);
+		if (t.altKey && c === null) {
 			if (r().nuclei.length >= 6) return;
-			r().nuclei.push(f(i, c)), t.preventDefault();
+			r().nuclei.push(m(i, s)), t.preventDefault();
 			return;
 		}
-		if ((t.shiftKey || t.button === 2) && u !== null) {
+		if ((t.shiftKey || t.button === 2) && c !== null) {
 			if (r().nuclei.length <= 1) return;
-			r().nuclei.splice(u, 1), t.preventDefault();
+			r().nuclei.splice(c, 1), t.preventDefault();
 			return;
 		}
-		u !== null && t.button === 0 && (a = u, o = t.pointerId, n.setPointerCapture(t.pointerId), t.preventDefault());
+		c !== null && t.button === 0 && (a = c, o = t.pointerId, n.setPointerCapture(t.pointerId), t.preventDefault());
 	}
-	function g(t) {
+	function v(t) {
 		let n = e.value;
 		if (n && o !== null && t.pointerId === o) {
 			try {
@@ -684,22 +1223,124 @@ function be(e, t, n) {
 			o = null, a = null;
 		}
 	}
-	function _(t) {
+	function y(t) {
 		let n = e.value;
 		if (!n) return;
 		let i = {
 			clientX: t.clientX,
 			clientY: t.clientY
-		}, a = n.getBoundingClientRect(), o = l((i.clientX - a.left) / Math.max(a.width, 1), (i.clientY - a.top) / Math.max(a.height, 1));
+		}, a = n.getBoundingClientRect(), o = d((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 x(() => {
+	return D(() => {
 		let t = e.value;
-		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(() => {
+		t && (t.addEventListener("pointermove", h), t.addEventListener("pointerleave", g), t.addEventListener("pointerdown", _), t.addEventListener("pointerup", v), t.addEventListener("pointercancel", v), t.addEventListener("contextmenu", y));
+	}), E(() => {
 		let t = e.value;
-		t && (t.removeEventListener("pointermove", p), t.removeEventListener("pointerleave", m), t.removeEventListener("pointerdown", h), t.removeEventListener("pointerup", g), t.removeEventListener("pointercancel", g), t.removeEventListener("contextmenu", _));
+		t && (t.removeEventListener("pointermove", h), t.removeEventListener("pointerleave", g), t.removeEventListener("pointerdown", _), t.removeEventListener("pointerup", v), t.removeEventListener("pointercancel", v), t.removeEventListener("contextmenu", y));
 	}), { isDragging: () => a };
 }
 //#endregion
-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 };
+//#region src/components/custom/aurora/composables/atoms.ts
+var $ = {}, qe = {
+	calm: {
+		saturation: .85,
+		warpAmount: .4,
+		valueVariance: .06,
+		breathDepth: .03
+	},
+	balanced: {
+		saturation: 1,
+		warpAmount: .5,
+		valueVariance: .08,
+		breathDepth: .05
+	},
+	vivid: {
+		saturation: 1.2,
+		warpAmount: .58,
+		valueVariance: .14,
+		breathDepth: .08
+	}
+}, Je = {
+	still: {
+		nucleiDrift: 0,
+		paletteDrift: 0,
+		warpDrift: 0,
+		breathDepth: 0
+	},
+	breathing: {
+		nucleiDrift: 0,
+		paletteDrift: 0,
+		warpDrift: 0,
+		breathDepth: .05
+	},
+	drifting: {
+		nucleiDrift: .015,
+		paletteDrift: .015,
+		warpDrift: .008,
+		breathDepth: .05
+	}
+};
+function Ye(e) {
+	let t = [.33, .67], n = [
+		[t[0], t[0]],
+		[t[1], t[1]],
+		[t[1], t[0]],
+		[t[0], t[1]],
+		[.5, .5],
+		[.5, t[0]]
+	], r = Math.max(1, Math.min(6, n.length, Math.round(e)));
+	return Array.from({ length: r }, (e, t) => {
+		let [i, a] = n[t];
+		return {
+			x: i,
+			y: a,
+			radius: .5,
+			paletteBias: r === 1 ? 0 : t / (r - 1),
+			valueBias: (t % 2 == 0 ? 1 : -1) * .05,
+			driftRadius: .045,
+			driftPhase: t * 2.4 % (Math.PI * 2)
+		};
+	});
+}
+function Xe(e, n, r) {
+	let i = t(r, 0, 1);
+	switch (n) {
+		case "watercolor":
+			e.wetEdge = i, e.granulation = i * .8;
+			break;
+		case "pastel":
+			e.strokeAmount = i, e.canvasGrain = i * .05;
+			break;
+		case "oil":
+		case "vangogh":
+			e.strokeAmount = i, e.impasto = i, e.canvasGrain = i * .06;
+			break;
+		case "oil-pastel":
+			e.strokeAmount = i, e.canvasGrain = i * .05;
+			break;
+		default: break;
+	}
+}
+function Ze(e = $) {
+	let n = {
+		...h,
+		palette: h.palette.map((e) => ({ ...e })),
+		nuclei: h.nuclei.map((e) => ({ ...e })),
+		flow: { ...h.flow }
+	};
+	if (e.seed !== void 0 && (n.palette = L(e.seed, {
+		harmony: e.harmony ?? "analogous",
+		stopCount: 4
+	})), e.mood !== void 0) {
+		let r = qe[e.mood];
+		n.saturation = t(r.saturation, .6, 1.3), n.warpAmount = t(r.warpAmount, 0, .6), n.valueVariance = t(r.valueVariance, 0, .3), n.breathDepth = t(r.breathDepth, 0, .15);
+	}
+	if (e.medium !== void 0 && (n.medium = e.medium, (e.medium === "vangogh" || e.medium === "oil-pastel") && (n.strokeOrient = "tensor")), e.textureAmount !== void 0 && Xe(n, n.medium, e.textureAmount), e.motion !== void 0) {
+		let r = Je[e.motion];
+		n.nucleiDrift = t(r.nucleiDrift, 0, .05), n.paletteDrift = t(r.paletteDrift, 0, .04), n.warpDrift = t(r.warpDrift, 0, .015), n.breathDepth = t(e.motion === "still" ? 0 : Math.max(n.breathDepth, r.breathDepth), 0, .15);
+	}
+	return e.zones !== void 0 && (n.nuclei = Ye(e.zones)), e.interactivity !== void 0 && (n.interactivity = { ...e.interactivity }), n;
+}
+//#endregion
+export { Ge as Aurora, $ as DEFAULT_ATOMS, h as DEFAULT_AURORA_CONFIG, p as MAX_NUCLEI, m as MAX_STOPS, Y as createAurora, b as cssToOklch, L as deriveAurora, Se as deriveScene, N as flattenPalette, F as hexToOklchStop, y as oklchStopToHex, _ as oklchToLinear, P as paletteToCssGradient, Ze as resolveAtoms, Z as resolveRenderMode, Q as useAurora, Ke as useCursorInteraction };