@mkbabb/glass-ui 6.0.0 → 8.0.0

package/dist/aurora.js

@@ -1,23 +1,130 @@
-import { t as e } from "./_plugin-vue_export-helper-C1je1s0u.js";
-import { t } from "./usePointerVelocityField-BdvnO0py.js";
-import { d as n, s as r } from "./pointerFieldMappings-CZojkgKj.js";
-import { t as i } from "./useScrollProgress-DZI4nf4v.js";
-import { t as a } from "./useIntersectionPause-B-dbxl9w.js";
-import { cssToOklch as o, deriveHue as s, gamutMapStop as c, oklchStopToHex as l, oklchToLinear as u, warmCatchLight as d } from "./color.js";
-import { a as f, c as p, d as m, f as h, i as g, m as _, n as v, o as y, p as b, r as x, s as S, t as C, u as ee } from "./procedural-color.wgsl-B9mLK7v0.js";
-import { t as te } from "./flow.glsl-DEGFGE11.js";
-import { a as ne, n as w, o as re } from "./rendererStatus-C2-zC2Q-.js";
-import { n as ie, t as ae } from "./compile-DK3Fri1B.js";
-import { computed as T, createElementBlock as oe, createElementVNode as se, defineComponent as ce, getCurrentInstance as le, normalizeClass as ue, normalizeStyle as de, onBeforeUnmount as E, onMounted as D, openBlock as fe, readonly as O, ref as pe, shallowRef as me, unref as he, watch as k } from "vue";
-import { interpolateHue as ge, oklabToLinearSRGB as _e, rawOklabToOklch as ve, rawOklchToOklab as ye, srgbToOKLab as be } from "@mkbabb/value.js";
+import { t as e } from "./_plugin-vue_export-helper-B3ysoDQm.js";
+import { t } from "./usePointerVelocityField-DsIf7yyq.js";
+import { d as n, s as r } from "./pointerFieldMappings-DP5tla5z.js";
+import { t as i } from "./useScrollProgress-Bq-KPaKM.js";
+import { t as a } from "./useIntersectionPause-CzKR3EyP.js";
+import { t as o } from "./value-DMhh2R94.js";
+import { cssToOklch as s, deriveHue as c, gamutMapStop as l, oklchStopToHex as u, oklchToLinear as d, warmCatchLight as f } from "./color.js";
+import { a as p, c as m, d as h, f as g, i as _, l as v, n as y, o as b, p as x, r as S, s as C, t as w, u as T } from "./color.wgsl-B0N3mKMb.js";
+import { a as E, n as D, o as ee } from "./rendererStatus-BxUlBLVy.js";
+import { n as te, t as O } from "./compile-D7VYG3gi.js";
+import { computed as k, createElementBlock as ne, createElementVNode as A, defineComponent as re, getCurrentInstance as ie, normalizeClass as ae, normalizeStyle as oe, onBeforeUnmount as se, onMounted as ce, openBlock as le, readonly as ue, ref as de, shallowRef as fe, unref as j, watch as M } from "vue";
+import { interpolateHue as pe } from "@mkbabb/value.js/color";
+//#region src/components/aurora/composables/textureUpload.ts
+var me = {
+	premultiplyAlpha: "none",
+	colorSpaceConversion: "none"
+};
+function he(e) {
+	return createImageBitmap(e, me);
+}
+async function ge(e) {
+	return typeof e == "string" ? he(await (await fetch(e)).blob()) : e instanceof Blob ? he(e) : e;
+}
+function N() {
+	let e = new ImageData(1, 1);
+	return e.data.set([
+		128,
+		128,
+		128,
+		255
+	]), e;
+}
+function _e(e) {
+	return e instanceof HTMLImageElement ? {
+		width: e.naturalWidth,
+		height: e.naturalHeight
+	} : {
+		width: e.width,
+		height: e.height
+	};
+}
+function ve(e, t, n = {}) {
+	let { linearFilter: r = !0, clampToEdge: i = !0 } = n, a = e.createTexture();
+	e.bindTexture(e.TEXTURE_2D, a), e.pixelStorei(e.UNPACK_PREMULTIPLY_ALPHA_WEBGL, !1), e.pixelStorei(e.UNPACK_COLORSPACE_CONVERSION_WEBGL, e.NONE), e.pixelStorei(e.UNPACK_FLIP_Y_WEBGL, !1), e.texImage2D(e.TEXTURE_2D, 0, e.RGBA, e.RGBA, e.UNSIGNED_BYTE, t);
+	let o = r ? e.LINEAR : e.NEAREST;
+	e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MIN_FILTER, o), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MAG_FILTER, o);
+	let s = i ? e.CLAMP_TO_EDGE : e.REPEAT;
+	return e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_S, s), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_T, s), e.pixelStorei(e.UNPACK_COLORSPACE_CONVERSION_WEBGL, e.BROWSER_DEFAULT_WEBGL), a;
+}
+function P(e, t) {
+	let { width: n, height: r } = _e(t), i = e.createTexture({
+		label: "[texture-upload] image",
+		size: [
+			n,
+			r,
+			1
+		],
+		format: "rgba8unorm",
+		usage: 22
+	});
+	return e.queue.copyExternalImageToTexture({
+		source: t,
+		flipY: !1
+	}, {
+		texture: i,
+		premultipliedAlpha: !1
+	}, [
+		n,
+		r,
+		1
+	]), {
+		texture: i,
+		width: n,
+		height: r
+	};
+}
+//#endregion
+//#region src/components/aurora/composables/auroraImageSource.ts
+function ye(e) {
+	let t = null, n = null, r;
+	return {
+		getDecodedImage: () => t,
+		setImageUploader(e) {
+			n = e, e && t && e(t);
+		},
+		ensureDecoded(i) {
+			i.source !== "image" || i.src == null || i.src !== r && (r = i.src, ge(i.src).then((r) => {
+				t = r, n?.(r), e.wake();
+			}).catch((t) => {
+				e.onError?.(t instanceof Error ? t : Error(String(t)));
+			}));
+		}
+	};
+}
+function be(e, t, n) {
+	let r = null;
+	e.activeTexture(e.TEXTURE0);
+	let i = (n) => {
+		e.useProgram(t), e.activeTexture(e.TEXTURE0), r && e.deleteTexture(r), r = ve(e, n);
+	};
+	return i(n.getDecodedImage() ?? N()), n.setImageUploader(i), () => {
+		r && e.deleteTexture(r), n.setImageUploader(null);
+	};
+}
+//#endregion
+//#region src/components/aurora/constants/renderMode.ts
+function F() {
+	let e;
+	try {
+		e = h();
+	} catch {
+		return !1;
+	}
+	return e === null ? !1 : e.includes("swiftshader") || e.includes("llvmpipe") || e.includes("software") || e.includes("basic render") || e.includes("microsoft basic");
+}
+function I(e, t = {}) {
+	return e !== "css" && !t.forceWebGLUnderSoftwareRaster && F() ? "css" : e === "auto" ? "webgl" : e;
+}
+//#endregion
 //#region src/components/aurora/constants/shaders/aurora.vert.ts
-var xe = "#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}", Se = "// ── 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 runs in perceptual space. AX.W11 — the ramp\n// itself (the smoothstep ease + the OKLab-rectangular-vs-OKLCh-hue-arc dispatch on\n// uHuePath) is the shared samplePaletteRamp from procedural-color.glsl, the SAME\n// source the WebGPU twin splices; samplePalette here only selects the bracketing\n// stop pair + the raw inter-stop t and hands them to the shared ramp.\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  return samplePaletteRamp(uPalette[i0], uPalette[i1], t, uHuePath);\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", Ce = "// ── Flow field ────────────────────────────────────────────────────────────\n// Structure-tensor prototype (body defined post-sampleBase in the mediums block).\n// Returns vec4(dir.x, dir.y, coherence, packedGrad) — the minor-eigenvector tangent + A + the\n// metal-gradient .w lane (BG.W-AUR-METAL-FINISH widened vec3→vec4). The forward decl MUST match\n// the vec4 definition or WebKit's compiler rejects the mismatched signature (L1b).\nvec4 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", we = "// Khronos PBR-Neutral tonemap (hue + saturation preserving)\nvec3 aces(vec3 color) {\n  const float startCompression = 0.8 - 0.04;\n  const float desaturation = 0.15;\n  float x = min(color.r, min(color.g, color.b));\n  float offset = x < 0.08 ? x - 6.25 * x * x : 0.04;\n  color -= offset;\n  float peak = max(color.r, max(color.g, color.b));\n  if (peak < startCompression) return clamp(color, 0.0, 1.0);\n  float d = 1.0 - startCompression;\n  float newPeak = 1.0 - d * d / (peak + d - startCompression);\n  color *= newPeak / peak;\n  float g = 1.0 - 1.0 / (desaturation * (peak - newPeak) + 1.0);\n  return clamp(mix(color, newPeak * vec3(1.0), g), 0.0, 1.0);\n}\n", Te = "// ── 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\n//   4 comma      — van-Gogh atomic dab: ASYMMETRIC taper, fat near one end and\n//                  drawn to a fine point at the other (the divisionist crescent\n//                  mark). The width peak sits off-centre (~0.32) so the two ends\n//                  taper at DIFFERENT rates — a loaded round head + a dragged tail.\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  } else if (type == 4) {\n    // comma / crescent — width peaks at ~0.32 then drags to a fine tail. The two\n    // sides of the peak fall at different exponents (a fat round head, a long thin\n    // tail), so the mark reads as a directional van-Gogh comma, not a symmetric oval.\n    float peak = 0.32;\n    float head = smoothstep(0.0, peak, t);                            // rounded loaded head\n    float tail = pow(clamp((1.0 - t) / (1.0 - peak), 0.0, 1.0), 1.6); // dragged thin tail\n    return clamp(min(head, tail) * 1.04, 0.0, 1.0);\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// The painterly STROKE mediums (those that deposit via paintStrokeLayers/paintOver):\n// oil (3), van-Gogh (5), oil-pastel (6). For these the stroke OVER-composite runs in\n// OKLab so overlapping complementaries mix through a chromatic path, not the linear-\n// RGB grey mud; the smooth/atmospheric pole never reaches paintOver so it pays nothing.\nbool isPainterlyStroke() {\n  return uMedium == 3 || uMedium == 5 || uMedium == 6;\n}\n\n// OKLab OVER-composite: lerp L,a,b of the over-color toward the under-color (the\n// Ottosson matrices spliced from procedural-color.glsl.ts — no new color math). Two\n// complementary-hued strokes overlapping transition through OKLab, where the midpoint\n// holds chroma, instead of the linear mix() that desaturates toward grey (slice 8 F2).\nvec3 paintOverOklab(vec3 under, vec3 over, float alpha) {\n  vec3 labU = linOklab(under);\n  vec3 labO = linOklab(over);\n  return max(oklabToLinearSrgb(mix(labU, labO, alpha)), vec3(0.0));\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().\n//\n// AX.W13 — the internal streak now perturbs HUE + CHROMA in OKLCh (not value-only),\n// so a single stroke carries a small hue gradient (broken color at the ATOM level —\n// adjacent strokes shimmer like real impasto, not flat stamped swatches; slice 8 F5);\n// and the OVER-composite runs in OKLab on the painterly stroke mediums so overlapping\n// complementaries mix as pigment, not the linear-mix grey (slice 8 F2).\n//   impastoFloor — the per-stroke height-crown floor: oil's 0.4+0.6*edgeN reads\n//                  floor=0.4 (the crown tapers to 40% at the stroke edge); the van-Gogh\n//                  profile passes floor=1.0 so each atomic dab catches a FULL-height\n//                  glint (scope item 1d). The crown magnitude is floor + (1-floor)*edgeN.\nvoid paintOver(inout vec3 col, inout float height, StrokeHit s,\n               float streakFreq, float streakAmp,\n               float impastoAmp, float hardness, float streakSeed,\n               float impastoFloor) {\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\n  // ── WITHIN-stroke OKLCh broken color (AX.W13, slice 8 F5). The streak fBm perturbs\n  // the stroke's HUE + CHROMA along alongT/crossN, seeded per-stroke, so a single\n  // stroke reads a small hue gradient (the atom-level broken-color shimmer). Value is\n  // carried by the same streak so the loaded-brush light/dark survives. Gated to the\n  // painterly stroke mediums + uBrokenColor (the smooth pole keeps the cheap value-only\n  // streak). A second decorrelated fBm drives the hue axis so hue ≠ a scaled value.\n  float hueStreak = fbm(vec2(s.alongT * streakFreq * 0.45 + streakSeed * 5.3,\n                             s.crossN * 1.9 + streakSeed * 1.7)) - 0.5;\n  if (isPainterlyStroke() && uBrokenColor > 0.001) {\n    vec3 lch = oklabToOklch(linOklab(c));\n    // ±~10° within-stroke hue swing + ±~9% chroma, scaled by uBrokenColor. Smaller\n    // than the per-stroke cell jitter (brokenColorJitter) — this is the intra-stroke\n    // gradient layered on top of the per-cell pigment patch.\n    lch.z += hueStreak * (20.0 * PI / 180.0) * uBrokenColor;\n    lch.y = max(lch.y * (1.0 + (streak) * 0.18 * uBrokenColor), 0.0);\n    c = max(oklabToLinearSrgb(oklchToOklab(lch)), vec3(0.0));\n  }\n  // Value streak (the loaded-brush light/dark across the bristles) — kept for every\n  // medium that reaches paintOver (the smooth pole never does). The along-spine value\n  // modulation is the loaded-brush light/dark that gives each stroke its OWN directional\n  // luminance band — the structure-tensor signal a low-contrast color field (a uniform-hue\n  // oil field) has no other source for (the §4.2 anisotropy lift on the flat-palette case).\n  c *= 1.0 + streak * streakAmp * 3.2;\n\n  // Cross-stroke ridge/valley shading — a catch-light along the spine centre, darkening to\n  // the stroke edges. This is the strongest DIRECTIONAL luminance cue: it carves a bright\n  // ridge down the stroke's length and dark grooves between adjacent strokes, so a field of\n  // parallel strokes reads as parallel light/dark bands (the high-A van-Gogh signature) even\n  // where the underlying colour is flat. s.edgeN is 0 at the edge, 1 at the spine.\n  float ridgeShade = smoothstep(0.0, 0.55, s.edgeN);\n  c *= 1.0 + (ridgeShade - 0.5) * 0.30;\n\n  float softLimit = mix(0.35, 0.98, hardness);\n  float alpha = smoothstep(0.0, 1.0 - softLimit, s.coverage) * strokeOpacity;\n  // OKLab OVER-composite on the painterly stroke mediums (overlap mixes as pigment,\n  // not grey); the smooth pole never reaches paintOver, so it keeps the cheap path.\n  col = isPainterlyStroke() ? paintOverOklab(col, c, alpha) : mix(col, c, alpha);\n\n  // ── Accumulate paint HEIGHT (AW.W4.2). Thickness peaks at the stroke spine and\n  // falls toward the impastoFloor at the edge (edgeN: 0=edge, 1=spine), perturbed by\n  // the bristle streak so ridges/grooves form. The relight reads the gradient of this\n  // field. The van-Gogh profile's floor=1.0 gives every atomic dab a full-height crown.\n  float ridge = 0.7 + 0.3 * (streak + 0.5);\n  float crown = impastoFloor + (1.0 - impastoFloor) * s.edgeN;\n  height += s.coverage * impastoAmp * crown * 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  // The specular glint is gated to ACCUMULATED-thick paint (height²) — a per-fine-stroke\n  // sharp glint on every thin fill dab read as bright isotropic SPECKLE that buried the\n  // directional stroke bands (the §4.2 anisotropy / §4.3 slope sink on the low-contrast\n  // oil field). Only where real impasto has built up does the raked glint fire, so the\n  // highlight tracks the macro ridges, not the fine speckle.\n  float specGate = clamp(height, 0.0, 1.0);\n  lit += uImpasto * relief * spec * specGate * 0.5 * 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.\n//   energyGrade — the SBR energy-grade magnitude (0 = none, the oil/oil-pastel\n//                 baseline; 1 = the full van-Gogh Starry-Night cascade — long\n//                 confident strokes in the lights/coherent zones, short dabs in\n//                 the darks/flat zones). The van-Gogh profile carries 1.0 (the\n//                 energy grade is a PROFILE field, not a buried uMedium==5 branch).\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                  float energyGrade) {\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        // vec4 (the metal-finish widen) — .xy tangent + .z coherence; the .w gradient lane\n        // is unused here. A vec3 local would be a type-mismatch WebKit rejects (L1c).\n        vec4 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 FAR less angular jitter (the field already orients them\n      // — over-jittering the tensor strokes scatters their directions and the rendered\n      // field reads isotropic, the §4.2 anisotropy floor). The flow-oriented (non-tensor)\n      // strokes keep the full jitter (they have no per-cell orientation source).\n      float jScale = (uStrokeOrient == 1) ? 0.15 : 1.0;\n      float angJ = (hash21(cc + seed + 11.0) - 0.5) * 0.9 * jScale;  // +/- 0.45/0.07 rad\n      float curlScale = (uStrokeOrient == 1) ? 0.30 : 1.0;\n      float localCurl = (fbm(center * (2.6 + seed * 0.11) + seed * 1.9) - 0.5) * 0.55 * uFlowCurl * curlScale;\n      vec2 dir = rotateDir(f, angJ + localCurl);\n\n      // AX.W13 — the SBR energy grade is a PROFILE field (energyGrade), not a buried\n      // uMedium==5 branch. The van-Gogh profile passes energyGrade=1.0 (the full\n      // Starry-Night cascade); oil/oil-pastel pass 0.0 (uniform length). The grade\n      // modulates stroke length by local luminance (bright → long confident strokes,\n      // dark → short dabs, the Kolmogorov/Batchelor congruence) AND by coherence\n      // (coherent zones → long, flat → stubby), lerped in by energyGrade so a profile\n      // can dial the cascade from off (0) to full (1).\n      float energy = 1.0;\n      if (energyGrade > 0.001) {\n        float luma = clamp(dot(sampleBase(center, t), W_LUMA), 0.0, 1.0);\n        float graded = mix(0.5, 1.5, luma) * mix(0.6, 1.0, coh);\n        energy = mix(1.0, graded, energyGrade);\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", Ee = "// ── Van-Gogh — DEDICATED atomic-dab body (W-AUR-VANGOGH-REBUILD) ─────────────\n// REBUILT FROM FIRST PRINCIPLES. The prior path routed van-Gogh through the shared\n// oil paintStrokeMedium cascade — four DENSE layers of LONG-THIN tensor-oriented\n// strokes (lenMul up to 5.2, widMul 0.22) hugging a continuous coherent field. Packed\n// that tight, thin strokes that follow continuous iso-bands MERGE into smooth flowing\n// filaments — the \"marbled flow-bands\" read (a spirograph/fingerprint, not impasto),\n// AND the per-cell 8-tap structure tensor × 4 layers × 9 cells = ~324 sampleBase/pixel\n// made it run at ~4fps. Van Gogh's sky is NOT continuous flow — it is DISCRETE, SHORT,\n// LOADED comma dabs, separated by visible ground, queued into swirl ROWS.\n//\n// The rebuild is a purpose-built two-layer DAB pass, disjoint from the oil cascade:\n//   • orientation from the analytic SWIRL flowField (van-Gogh skies ARE swirl rows) +\n//     per-cell angular jitter — NOT the expensive per-cell tensor (the lag source, and\n//     the marble source: a jittered discrete dab can NOT merge into a continuous\n//     filament the way a tensor-locked thin stroke does).\n//   • SHORT comma dabs (len/wid ≈ 2.6 : 1 — a loaded crescent mark, not a 10:1\n//     filament), so each reads as a SEPARABLE atom.\n//   • SPARSE placement with visible inter-dab ground (density ≈ 0.42), over a darkened\n//     swirl underpainting (the Starry-Night visible ground the bright dabs read over).\n//   • a single sampleBase per cell + OKLCh broken-color jitter (pigment shimmer);\n//     full-height impasto crown per dab (each catches its own raked glint).\n// This is ~2 layers × 9 cells × ~1 sampleBase ≈ 20/pixel (a ~16× cost cut, ~60fps), and\n// jittered short dabs CANNOT marble.\n\n// One atomic comma dab — a CLEAN analytic crescent SDF (NOT the oil curvedStroke).\n// The oil curvedStroke's spine-projection + rounded end-caps + fwidth-AA + bristle\n// edge each leave a thin sub-pixel skirt, and a field of those skirts over open ground\n// abuts into a faint network of SEAM LINES. A van-Gogh dab needs none of that\n// machinery — it is a short oriented capsule (rounded line segment) whose half-width\n// tapers along its length (the loaded-head → dragged-tail comma). The capsule SDF is\n// derivative-free (smoothstep AA against the analytic distance), so no fwidth skirt, no\n// best-of-9 seam. Returns a StrokeHit (coverage/color/alongT/edgeN) for paintOver.\n//   cellSize — dab cell pitch (UV units); lenMul/widMul — dab aspect off the cell;\n//   density  — placement gate (sparse → visible gaps); seed — layer decorrelation.\nStrokeHit vangoghDab(vec2 p, float cellSize, float lenMul, float widMul,\n                     float density, float jitterAmt, float angJitter,\n                     vec2 flow, float t, float seed) {\n  vec2 cell = floor(p / cellSize);\n  StrokeHit best = noHit();\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      // Sparse density gate — leaves visible canvas ground between dabs (atomicity).\n      if (hash21(cc * 1.7 + seed * 0.3) > density) continue;\n      vec2 jit = (hash22(cc + seed) - 0.5) * jitterAmt;\n      vec2 center = (cc + 0.5 + jit) * cellSize;\n\n      // Orientation: the analytic swirl flow at the cell center + per-cell angular\n      // jitter (so adjacent dabs FAN — the divisionist scatter that keeps the dabs from\n      // locking into perfectly-concentric rows) + a flow-noise curl wobble.\n      float ang = (hash21(cc + seed + 11.0) - 0.5) * angJitter;\n      float curl = (fbm(center * 3.1 + seed * 1.9) - 0.5) * (0.18 + 0.3 * uFlowCurl);\n      vec2 dir = rotateDir(safeDir(flow), ang + curl);\n\n      // SHORT comma — len ≈ the cell pitch (a contained dab, not a tiling filament).\n      float len = cellSize * lenMul * (0.82 + 0.30 * hash21(cc + seed + 23.0));\n      float halfW = max(cellSize * widMul * (0.86 + 0.28 * hash21(cc + seed + 41.0)), 0.010);\n\n      // Local dab frame: along = projection onto the dab axis (centred 0), perp = cross.\n      vec2 rel = p - center;\n      float along = dot(rel, dir);\n      float perp  = dot(rel, vec2(-dir.y, dir.x));\n      // The comma TAPER: half-width peaks ~1/3 from the loaded head and drags to a fine\n      // tail (the asymmetric crescent). u in [0,1] along the dab from head to tail.\n      float halfLen = len * 0.5;\n      float u = clamp((along + halfLen) / max(len, 1e-5), 0.0, 1.0);\n      float head = smoothstep(0.0, 0.30, u);                 // rounded loaded head\n      float tail = pow(clamp((1.0 - u) / 0.70, 0.0, 1.0), 1.3); // dragged thin tail\n      float prof = clamp(min(head, tail) * 1.05, 0.0, 1.0);\n      float wNow = halfW * prof;\n      // A gentle comma CURVE — bow the spine sideways so the mark reads as a crescent.\n      float bowAmt = (hash21(cc + seed + 53.0) - 0.5) * halfW * 1.4;\n      float spine = bowAmt * sin(u * PI);                    // 0 at ends, max mid\n      float d = abs(perp - spine);\n      // Derivative-free AA: a fixed fraction of the dab width (no fwidth skirt). Coverage\n      // is 1 in the dab body, smoothly 0 at the edge; outside the [head,tail] span wNow→0\n      // so the dab self-terminates with no end-cap blob.\n      float aa = max(halfW * 0.45, 0.002);\n      float cov = (wNow > 1e-5) ? (1.0 - smoothstep(wNow - aa, wNow + aa, d)) : 0.0;\n      if (cov < 0.004) continue;\n\n      // One sampleBase per cell + OKLCh broken-color jitter (pigment patch shimmer). The\n      // dab pigment is chroma-boosted (saturate3 1.22) AND value-lifted (×1.14) at the\n      // SOURCE — the loaded brush mark deposits BRIGHTER + more saturated pigment than the\n      // base field, so the loaded-mark pixels lift BOTH the §4.1 colourfulness AND the field\n      // mean-luma. The higher mean raises the gap-fraction threshold (meanLum·0.6) so the\n      // moderate-depth inter-dab ground falls below it (the gap-fraction atomicity read is\n      // DECOUPLED from the ground floor depth — the ground can stay only moderately dark, so\n      // the §4.3 slope is NOT over-steepened, while the bright dabs manufacture the gap). The\n      // dark ground is untouched, so this lifts C + gap WITHOUT a band-conflicting deep ground.\n      vec3 colMid = brokenColorJitter(\n        saturate3(sampleBase(center, t), 1.22),\n        hash21(cc + seed + 89.0),\n        hash21(cc * 2.3 + seed + 97.0),\n        1.0\n      );\n\n      // edgeN: 1 at the spine, 0 at the edge (the impasto crown reads it).\n      float edgeN = (wNow > 1e-5) ? clamp(1.0 - d / wNow, 0.0, 1.0) : 0.0;\n      if (cov > best.coverage) {\n        best = StrokeHit(cov, colMid, u, (wNow > 1e-5 ? (perp - spine) / wNow : 0.0), edgeN);\n      }\n    }\n  }\n  return best;\n}\n\nvec3 mediumVangogh(vec3 col, vec2 p, float t) {\n  vec3 result = col;\n  float height = 0.0;\n\n  // The swirl flow basis (van-Gogh sky = swirl rows). Computed ONCE per pixel.\n  vec2 flow = flowField(p, t);\n\n  // Dab cell pitch in UV [0,1]. CHUNKY, SEPARABLE marks — the big layer is ~1/14 of\n  // the frame so it reads as a distinct loaded brush dab (not a fine speckle, not a\n  // screen-spanning filament). uStrokeScale (authored ~110) modulates the pitch\n  // INVERSELY (higher = finer dabs) around the ~0.07 chunky default; clamped so the\n  // dab never collapses to noise or balloons past one screen. uStrokeAnisotropy\n  // stretches the comma aspect (longer, more directional marks).\n  float pitch = clamp(7.0 / max(uStrokeScale, 20.0), 0.044, 0.12);\n  // The dab LENGTH ≈ the cell pitch (lenAniso ~1.2-1.7) so a dab sits WITHIN its cell\n  // and leaves visible ground around it — a longer dab (lenMul > 2) spans neighbour\n  // cells and tiles the field into continuous coverage (no gaps, the gap-fraction floor\n  // miss + the marble). Narrow width keeps it a directional crescent, not a wide shard.\n  // lenAniso/widAniso — the comma aspect. The W-AUR-VANGOGH-CONFIG reconcile lengthened\n  // the comma (1.25-1.75 → 1.5-2.0) and THINNED it (0.40-0.30 → 0.32-0.24): the rebuilt\n  // dabs measured §4.2 structure-tensor anisotropy A=0.699, BELOW the reference band\n  // floor 0.732 (the dabs read slightly too short-fat → locally isotropic, dragging mean\n  // A down). A LONGER, THINNER comma hugs the swirl-flow tangent more strongly so the\n  // rendered field reads coherent the way the tensor metric measures it (A lift), while\n  // the thinner width LEAVES MORE inter-dab ground (the gap-fraction atomicity read is\n  // preserved, not closed). The length stays ≈ the cell pitch so each dab remains a\n  // CONTAINED separable mark, not a tiling filament.\n  float lenAniso = mix(2.1, 2.7, uStrokeAnisotropy);   // comma length / cell pitch (a contained dab)\n  float widAniso = mix(0.23, 0.16, uStrokeAnisotropy); // comma width / cell pitch (a thin loaded crescent)\n\n  // Layer 1 — the big swirl-row dabs: the loaded gestural marks, SPARSE so the dark\n  // underpainting shows BETWEEN them (the atomicity read — visible inter-dab ground).\n  // hardness 0.74 — the loaded brush deposits with a SOFT shoulder, so adjacent dabs\n  // feather instead of razor-clipping into hard polygon shards. jitterAmt 0.85 fully\n  // scatters the cell centres so the placement GRID never reads as a periodic seam.\n  // angJitter EASED 0.55 → 0.38 (the reconcile A lift): a tighter angular spread keeps\n  // adjacent dabs more flow-aligned (coherent) while the per-cell curl wobble still\n  // breaks the perfectly-concentric-rows read (the dabs FAN gently, not lock to a grid).\n  // angJitter eased 0.38 → 0.26 + hardness 0.74 → 0.84 (the §4.2 A lift): a tighter angular\n  // spread keeps adjacent dabs strongly flow-aligned (the structure-tensor coherence) and a\n  // sharper edge gives each dab a STRONGER directional gradient (a soft dab's faint edge\n  // reads weakly anisotropic). The per-cell curl wobble still breaks the perfectly-\n  // concentric-rows read, so the dabs FAN gently rather than locking to a grid.\n  StrokeHit dBig = vangoghDab(p, pitch, lenAniso, widAniso,\n                              0.30, 0.50, 0.08, flow, t, 1.3);\n  // streakFreq raised 14 → 34 (the §4.3 slope fix): a high-frequency streak runs ALONG the\n  // dab spine, injecting fine-scale luma energy that flattens the too-steep β WITHOUT\n  // adding new isotropic marks (the along-spine streak stays directional, so the §4.2\n  // anisotropy the long-thin dab carries is preserved — the band-conflict resolution).\n  paintOver(result, height, dBig, 48.0, 0.34,\n            uImpasto * 0.75 * uStrokeAmount, 0.84, 1.3, 1.0 /* full crown */);\n\n  // Layer 2 — two-thirds-pitch accent dabs (the divisionist sparkle between the big\n  // marks — denser placement but still contained dabs, so dark canvas survives between).\n  // angJitter eased 0.5 → 0.34 (same A-lift reasoning — the accent dabs queue along the\n  // flow rather than scattering isotropically); hardness 0.78 → 0.86 sharpens the gradient.\n  StrokeHit dSml = vangoghDab(p + vec2(-5.1, 8.4), pitch * 0.62, lenAniso * 0.95,\n                              widAniso * 0.95, 0.36, 0.60, 0.20, flow, t, 4.1);\n  paintOver(result, height, dSml, 42.0, 0.22,\n            uImpasto * 0.55 * uStrokeAmount, 0.86, 4.1, 1.0);\n\n  // Layer 3 — the FINE divisionist flecks (W-AUR-VANGOGH-CONFIG reconcile). The two-layer\n  // field read as a few BIG cobalt dabs over a smooth empty teal ground (the side-by-side\n  // against starry-night-crop.png: the painting is DENSE small varied flecks, not sparse\n  // large marks). The flecks are LONG·THIN directional commas hugging the swirl tangent\n  // (the A-preserving fleck — short fat flecks read isotropic and drag §4.2 down). Sparse\n  // density 0.30 keeps the inter-fleck ground open (the gap-fraction atomicity read).\n  // The flecks are FINE (≈0.42× pitch) directional commas, tightly flow-aligned (angJitter\n  // 0.22) and SPARSE (0.30) — the divisionist sparkle between the loaded marks that keeps\n  // the inter-dab ground open (atomicity) while adding the small-mark mid-band energy. Thin\n  // + flow-aligned so the §4.2 anisotropy the long dabs carry survives the added small marks.\n  StrokeHit dFleck = vangoghDab(p + vec2(8.7, -3.2), pitch * 0.42, lenAniso * 1.0,\n                                widAniso * 0.68, 0.30, 0.85, 0.22, flow, t, 7.7);\n  paintOver(result, height, dFleck, 30.0, 0.16,\n            uImpasto * 0.40 * uStrokeAmount, 0.80, 7.7, 1.0);\n\n  // ── Flow-aligned GROUND swirl-GROOVING (W-AUR-VANGOGH-CONFIG reconcile) ──\n  // The bare ground between the dabs was a SMOOTH low-frequency teal gradient — the §4.3\n  // power-spectrum slope ran too STEEP (β≈−2.0: too much low-frequency nuclei-field energy\n  // vs the high band). Van Gogh's actual sky has the swirl BRUSHWORK everywhere, so groove\n  // the OPEN GROUND with a flow-aligned ripple. It is SUBTRACTIVE-biased (it only darkens,\n  // never brightens the ground), so it DEEPENS the inter-dab valleys (MORE gap-fraction —\n  // atomicity preserved/strengthened) while injecting the across-flow mid-band luma energy\n  // that flattens β. Gated to the open ground (low height) via the (1-height) gate so it\n  // never lifts/erodes the loaded dab bodies (the dab read is untouched). Across the swirl\n  // FLOW axis so the grooves run WITH the sky's brushwork direction.\n  // The ground swirl-combing — a FIXED-global-angle directional grain on the open ground.\n  // A flow-FOLLOWING comb varies its direction with the swirl across the readback window,\n  // so its blurred structure tensor averages toward isotropic (no §4.2 lift). A comb at one\n  // GLOBAL angle (van-Gogh's dominant diagonal stroke grain) is COHERENT over the whole\n  // window ⇒ every open-ground pixel reads the SAME direction (the §4.2 mean-anisotropy lift\n  // the swirl comb could not reach). Two resolved bands (≈22 + ≈44 across the global axis ⇒\n  // ~21px + ~11px at 464px, both in the §4.3 fit window) also feed the β flatten. Gated to\n  // the open ground (low height) so the loaded dabs are untouched; SUBTRACTIVE-biased so the\n  // inter-dab valleys deepen (gap-fraction preserved, not filled).\n  vec2 gdir = normalize(vec2(0.82, 0.57));   // the dominant global stroke grain axis\n  float gacross = dot(p, vec2(-gdir.y, gdir.x));\n  float groundGate = 1.0 - smoothstep(0.05, 0.28, height);\n  float groove = sin(gacross * 22.0) + 0.5 * sin(gacross * 44.0 + 1.3);\n  result *= 1.0 - 0.16 * groundGate * (0.5 - 0.5 * groove);\n\n  // Canvas tooth (fine linen weave — base relief the raking light catches).\n  float tooth1 = vnoise(p * 220.0);\n  float tooth2 = vnoise(p * 220.0 * vec2(0.6, 2.4) + 37.0);\n  float tooth  = (0.6 * tooth1 + 0.4 * tooth2) - 0.5;\n  result *= 1.0 + tooth * 0.06 * uCanvasGrain;\n\n  // Relight the accumulated impasto height (raking light catches each dab's crown —\n  // the visible impasto ridge that makes a dab read as a RAISED loaded mark).\n  float canvasBase = tooth * 0.06 * 0.5;\n  result = relightImpasto(result, height, canvasBase);\n\n  // The visible Starry-Night GROUND — the open canvas between dabs (low accumulated\n  // height) darkens toward the deep underpainting, so the bright impasto dabs read as\n  // SEPARABLE atomic marks over a darker field (the dab↔ground contrast the user's\n  // \"reads as strokes\" bar needs, AND the painterly-statistics gap-fraction floor — the\n  // dark inter-dab ground must register as a measurable fraction of the field). 0.30\n  // floor over a WIDER smoothstep (0..0.40): deep enough that the open gaps read as the\n  // dark Starry-Night sky between marks (clearing the 4% gap floor) while the gradual\n  // ramp keeps the gaps reading as flowing underpainting, not the hard black ink LINES a\n  // narrow near-black step (0.26 / 0.0..0.32) produced.\n  // The smoothstep FLOOR starts at 0.10 (not 0): a dab's faint AA coverage TAIL deposits\n  // a sliver of height, and where many tails align along the swirl flow those slivers\n  // accumulate into a faint continuous height ridge that read as thin curved LINES in the\n  // ground. Holding the ground full-dark until a real dab CORE (height > 0.10) lifts out\n  // keeps the open field clean — only the loaded dab bodies emerge, the tails stay ground.\n  result *= mix(0.115, 1.0, smoothstep(0.085, 0.31, height));\n\n  // The van-Gogh chroma — a light OKLCh punch. EASED to 0.92 (off 1.04) in the\n  // W-AUR-VANGOGH-CONFIG reconcile: the rebuilt discrete-dab register's per-dab OKLCh\n  // broken-color jitter (the ±16° hue + ±chroma swing per cell) lifts the field's\n  // colourfulness on its own, so the prior 1.04 punch on TOP overshot the §4.1\n  // reference band (rendered C=100.5 vs the painting's measured 70.67 ± 15/+25 →\n  // ceiling 95.67 — neon, not Starry Night's rich-but-not-garish blue/gold). The 0.92\n  // demote pulls the rendered colourfulness back IN-band while the broken-color jitter\n  // keeps the per-dab pigment variation (the discrete-stroke read is untouched — this\n  // is a chroma scale, not a dab-geometry change). Band-anchored on the real painting\n  // (proof:aurora-arresting), NOT a widened band.\n  result = saturate3(result, 1.0);\n  return result;\n}\n\n", De = "StrokeProfile profileFor(int medium, int mode) {\n  // The oil baseline (mode 0) — balanced modern-abstract/palette-knife hybrid.\n  StrokeProfile prof = StrokeProfile(\n    0,      // shapeType — tapered\n    0.25,   // bristleAmp\n    9.0,    // streakFreq\n    0.09,   // streakAmp\n    0.9,    // impastoAmp\n    0.80,   // hardness\n    340.0,  // toothScale — W-AUR-VANGOGH-CONFIG reconcile: FINER 240 → 340. Oil's §4.3 β sat\n            //               right AT the −1.45 band ceiling (±0.02 frame variance straddling\n            //               it, surfaced once the vangogh bands went green and the spec reached\n            //               the oil β assert). MEASURED on the live GPU: ADDING fine high-\n            //               frequency tooth energy steepens oil's power-spectrum slope (more\n            //               negative — coarsening it the other way pushed β SHALLOWER to\n            //               −1.33). A finer, stronger tooth moves β to a safe distance inside\n            //               the −5/3 band [−1.85, −1.45]. Oil-only (oil-pastel sets 280).\n    0.14,   // toothAmp — raised 0.09 → 0.14 (same oil-β steepen: more fine-grain high band).\n    1.03,   // pigmentSat\n    0.65,   // densityBig\n    0.78,   // densityMed\n    0.90,   // densitySml\n    0.0,    // energyGrade — oil is uniform-length (no Starry-Night cascade)\n    0.4,    // impastoFloor — oil's 0.4+0.6·edgeN crown falloff\n    0.92,   // densityFill — oil fills DENSELY with the directional low-relief fill so the\n            //               flat-colour regions between the macro strokes are TEXTURED with\n            //               flow-aligned fine strokes (the §4.2 anisotropy needs every pixel\n            //               to carry directional gradient; a flat untextured region reads as\n            //               an isotropic/degenerate tensor and drags mean A down). The fill\n            //               is now directional + low-streak, so dense coverage textures\n            //               WITHOUT the prior round-dab speckle.\n    1.0     // groundFloor — oil keeps the full base (no ground darken; fills everywhere)\n  );\n\n  // W-AUR-VANGOGH-REBUILD — the van-Gogh medium NO LONGER routes through this oil\n  // StrokeProfile cascade. It is a DEDICATED atomic-dab body (mediumVangogh / vangoghDab\n  // below) — the prior profile-driven cascade (four dense layers of long-thin\n  // tensor-oriented strokes) merged into the \"marbled flow-bands\" read and ran at ~4fps.\n  // profileFor now serves ONLY the oil + oil-pastel stroke mediums; the MEDIUM_VANGOGH\n  // case is removed (no caller). MEDIUM_VANGOGH stays #define'd (the main() dispatch +\n  // isPainterlyStroke still key off uMedium==5).\n\n  // ── Oil-pastel — broad smeared directional strokes deposited via the brush engine\n  // (slice 8 F1). Creamy soft edges (low hardness), heavy build-up, and a chroma punch.\n  // Distinct from the dry-crayon tooth-multiply (mediumCrayon): oil-pastel LAYS strokes.\n  if (medium == MEDIUM_OILPASTEL) {\n    prof.shapeType   = 0;     // tapered directional smear — a round dab reads locally\n                              // isotropic (steep β / low A); the creamy oil-pastel mark\n                              // is a broad DIRECTIONAL smear, which carries the §4.2\n                              // coherence + adds the directional mid-band the §4.3 slope\n                              // needs (the round-dab profile rolled β off to −2.8)\n    prof.bristleAmp  = 0.10;  // smooth creamy edges (waxy pastel, not bristle)\n    prof.streakFreq  = 18.0;  // finer internal smear — adds the mid/high-band the smooth\n                              // round-dab profile lacked (the β-too-steep fix); the\n                              // directional along-spine streak flattens the §4.3 slope\n                              // without crossing the strokes\n    prof.streakAmp   = 0.20;\n    prof.impastoAmp  = 0.7;   // build-up, but flatter than oil impasto\n    prof.hardness    = 0.42;  // CREAMY — soft compositing, strokes blend on overlap\n    prof.toothScale  = 280.0;\n    prof.toothAmp    = 0.12;  // the pastel tooth reads stronger\n    prof.pigmentSat  = 0.80;  // the waxy chroma — eased off 1.16 so the rendered C clears\n                              // the §4.1 band ceiling with margin while the K-M subtractive\n                              // overlap path (paintOverOklab) keeps the chroma OFF the grey floor\n    prof.hardness    = 0.58;  // creamy but the strokes still REGISTER — a too-soft blend\n                              // (0.42) smeared the marks into the smooth colour zones and\n                              // the field rolled off too steep (β≈−2.9, a near-gradient);\n                              // a crisper deposit keeps the mid/high-band the −5/3 slope needs\n    prof.densityBig  = 0.62;  // broad directional coverage — but NOT over-dense: too many\n                              // overlapping creamy strokes point in slightly-varied\n                              // directions and the local §4.2 coherence DROPS (over-dense\n                              // measured A=0.57 < the 0.62-density A=0.63). The mid-density\n                              // flow-aligned deposit is the coherence sweet spot.\n    prof.densityMed  = 0.78;\n    prof.densitySml  = 0.90;\n    prof.energyGrade = 0.80;  // a strong Starry-Night length cascade — varies stroke length\n                              // by luma/coherence so the dab-size energy spreads across\n                              // scales (the −5/3 cascade the uniform-length 0.0 grade lacked,\n                              // the §4.3 β-too-steep fix). Not the full van-Gogh 1.0 (oil-\n                              // pastel keeps its creamy broad character).\n    prof.impastoFloor = 0.55; // a softer crown than van-Gogh's full-height glint\n    return prof;\n  }\n\n  // ── Oil sub-modes (mode dispatch on the oil medium).\n  if (mode == 1) {           // palette knife — razor edges, heavy impasto\n    prof.shapeType  = 3;     // flat, even\n    prof.bristleAmp = 0.12;\n    prof.streakFreq = 4.0;  prof.streakAmp = 0.05;\n    prof.impastoAmp = 1.6;\n    prof.hardness   = 0.95;\n    prof.toothAmp   = 0.04;\n    prof.densityBig = 0.80; prof.densityMed = 0.88; prof.densitySml = 0.70;\n  } else if (mode == 3) {    // thick brushwork — heavy bristle brush\n    prof.shapeType  = 0;     // tapered\n    prof.bristleAmp = 0.32;\n    prof.streakFreq = 14.0; prof.streakAmp = 0.14;\n    prof.impastoAmp = 1.2;\n    prof.hardness   = 0.85;\n    prof.toothAmp   = 0.07;\n  }\n  return prof;\n}\n", Oe = "\n// ── Gradient pack (BG.W-AUR-METAL-FINISH) ──────────────────────────────────\n// structureTensorField re-plumbs its already-computed luma gradient (Gx,Gy) out through\n// the vec4 return's .w lane so the metal medium pays ZERO extra taps (a second Sobel is\n// 8 sampleBase() taps). 12 bits per bounded component ([-4,4]) into one f32, exact under\n// highp; the .xy/.z crayon/kuwahara callers are transparent to the widen.\nfloat packGrad(float gx, float gy) {\n  float qx = floor(clamp(gx * 0.125 + 0.5, 0.0, 1.0) * 4095.0);\n  float qy = floor(clamp(gy * 0.125 + 0.5, 0.0, 1.0) * 4095.0);\n  return qx + qy * 4096.0;\n}\nvec2 unpackGrad(float packed) {\n  float qy = floor(packed * (1.0 / 4096.0));\n  float qx = packed - qy * 4096.0;\n  return (vec2(qx, qy) * (1.0 / 4095.0) - 0.5) * 8.0;\n}\n", ke = "#define MEDIUM_METAL 8\n#define MEDIUM_METALGRAD 9\n\n// ── Metal — the two-term anisotropic BRDF over the field's own relief (uMedium==8/9,\n// BG.W-AUR-METAL-FINISH) ─────────────────────────────────────────────────────────\n// Metal is a MUTUALLY-EXCLUSIVE medium (NOT a finish axis) — the field re-lights as\n// warm folded metal: the luma HEIGHT field (the packed structure-tensor gradient →\n// the surface normal) catches an anisotropic Blinn streak (brushed metal, the streak\n// runs ALONG the coherent edge-tangent) plus a sharp crest, both raked by a cursor-\n// synthesized light that reads on BOTH backends (uCursor is in-struct — a phantom\n// uLightDir read would be flat on the WGSL primary). The catch is the ACHROMATIC-WARM\n// anchor (AURORA_CATCH_LIGHT_ANCHOR ≈ [1.0,0.97,0.90], never a cold chrome-blue). The\n// body keeps the field HUE (technicolor valley base); the height rides the relief.\n// ZERO new taps — structureTensorField ALREADY computed the gradient (unpacked from .w).\nconst vec3  METAL_CATCH_WARM       = vec3(1.0, 0.97, 0.90); // AURORA_CATCH_LIGHT_ANCHOR\nconst float METAL_HEIGHT_SCALE     = 2.2;   // gradient → normal tilt (× uMetalHeightScale)\nconst float METAL_LIGHT_Z          = 0.55;  // synth-light z (toward viewer)\nconst vec2  METAL_IDLE_RAKE        = vec2(0.32, 0.34); // upper-right idle rake bias\nconst float METAL_SHININESS_ANISO  = 6.0;   // anisotropic streak exponent (brushed)\nconst float METAL_SHININESS_CREST  = 40.0;  // crest specular exponent (sharp)\nconst float METAL_COHERENCE_FLOOR  = 0.22;  // streak gates on edge coherence A\nconst float METAL_BODY_FLOOR       = 0.42;  // diffuse valley floor (dark side reads)\nconst float METAL_GRADIENT_FLATTEN = 0.55;  // metal-gradient pre-flatten toward luma\nconst float METAL_SPARKLE_DENSITY  = 240.0; // metal-gradient per-cell flake grid\nconst float METAL_SPARKLE_THRESH   = 0.72;  // only some cells flake\nconst float METAL_SPARKLE_AMP      = 0.6;   // flake glint amplitude\n\n// The shared metal BRDF core — takes the ALREADY-computed structureTensorField vec4 so\n// the caller pays ZERO extra taps (metal-gradient reuses the same stf). WebKit-fenced:\n// every pow base is clamped to [0,1], the exponents are compile-time constants.\nvec3 metalShade(vec3 baseCol, vec2 p, vec4 stf) {\n  vec2 tangent = stf.xy;\n  float A = stf.z;\n  vec2 grad = unpackGrad(stf.w);\n  // Height-field normal: N = normalize(vec3(grad * scale, 1)). The luma relief tilts\n  // the surface; the flat field reads near vec3(0,0,1) (facing the viewer).\n  vec3 N = normalize(vec3(grad * (METAL_HEIGHT_SCALE * uMetalHeightScale), 1.0));\n  vec3 V = vec3(0.0, 0.0, 1.0);\n  // Cursor-synthesized rake light (in-struct on BOTH backends — never uLightDir). The\n  // idle bias keeps a still field lit from the upper-right; a moving cursor rakes it.\n  vec3 L = normalize(vec3((uCursor - p) + METAL_IDLE_RAKE, METAL_LIGHT_Z));\n  vec3 H = normalize(L + V);\n  // Anisotropic streak — brushed metal: the highlight runs ALONG the edge-tangent, so\n  // it is a function of the H-component PERPENDICULAR to the tangent (sinTH).\n  float tH = dot(normalize(tangent), H.xy);\n  float sinTH = sqrt(clamp(1.0 - tH * tH, 0.0, 1.0));\n  float streak = pow(clamp(sinTH, 0.0, 1.0), METAL_SHININESS_ANISO);\n  float crest  = pow(clamp(dot(N, H), 0.0, 1.0), METAL_SHININESS_CREST);\n  float spec = streak * crest;\n  // Coherence gate — the anisotropic streak reads only where the field has a real edge\n  // (a flat zone has no brush direction; A≈0 → no streak).\n  spec *= smoothstep(0.0, METAL_COHERENCE_FLOOR, A);\n  // Technicolor valley base — the body keeps the FIELD hue; the diffuse term rides the\n  // height relief so the ridges brighten and the pits fall toward the floor.\n  float diff = clamp(dot(N, L), 0.0, 1.0);\n  vec3 body = baseCol * (METAL_BODY_FLOOR + (1.0 - METAL_BODY_FLOOR) * diff);\n  // The catch is the achromatic-warm anchor, scaled by the polish knob.\n  return body + METAL_CATCH_WARM * (spec * clamp(uMetalPolish, 0.0, 4.0));\n}\n\nvec3 mediumMetal(vec3 col, vec2 p, float t) {\n  vec4 stf = structureTensorField(p, t, flowField(p, t));\n  return metalShade(col, p, stf);\n}\n\n// metal-gradient (uMedium==9) — the SAME BRDF over a pre-flattened/gradient base + a\n// twinkle-in-place flake sparkle (position FIXED per cell, PHASE-animated, gated on\n// facing — flake glint, never a boil).\nvec3 mediumMetalGradient(vec3 col, vec2 p, float t) {\n  vec4 stf = structureTensorField(p, t, flowField(p, t));\n  // Pre-flatten toward luma (the smoother gradient-metallic base) — same BRDF, calmer body.\n  // NB: flat is a GLSL reserved interpolation qualifier — WebKit's compiler REJECTS it as an\n  // identifier (ANGLE tolerates it); named flatCol so the WebKit aurora shader compiles (L1a).\n  vec3 flatCol = mix(col, vec3(dot(col, W_LUMA)), METAL_GRADIENT_FLATTEN);\n  vec3 metal = metalShade(flatCol, p, stf);\n  // The height-field normal facing (recomputed from the same packed gradient — ZERO taps).\n  vec2 grad = unpackGrad(stf.w);\n  float facing = normalize(vec3(grad * (METAL_HEIGHT_SCALE * uMetalHeightScale), 1.0)).z;\n  // Twinkle-in-place: a fixed per-cell flake seed, phase-animated glint gated on facing.\n  vec2 cell = floor(p * METAL_SPARKLE_DENSITY);\n  float seed = hash21(cell);\n  float tw = pow(clamp(sin(t + seed * 6.2831853), 0.0, 1.0), 40.0);\n  float flakeGate = step(METAL_SPARKLE_THRESH, seed);\n  metal += METAL_CATCH_WARM * (tw * flakeGate * clamp(facing, 0.0, 1.0) * METAL_SPARKLE_AMP);\n  return metal;\n}\n", Ae = "// ── 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" + Oe + "\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// coherence A = (λ1-λ2)/(λ1+λ2); flat zones relax toward fallbackDir by (1-A). The\n// single-pass small-tap WebGL2 form. Returns vec4(tangent.xy, A, packGrad(Gx,Gy)) —\n// the .w lane carries the metal medium's gradient (BG.W-AUR-METAL-FINISH; the .xy/.z\n// callers are byte-unchanged).\nvec4 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  // The blend weight is a low-power curve (A^0.35) so even MODERATE-coherence zones queue\n  // strongly along the tangent (a flowing van-Gogh band reads coherent the way the\n  // structure-tensor metric measures it; a linear A under-orients the mid-band and the\n  // rendered field reads too isotropic — the §4.2 anisotropy lift). The flat-zone (A≈0)\n  // relax to the fallback survives (0^0.35=0), so tensor noise never reads as jitter.\n  float blendW = pow(A, 0.28);\n  vec2 dir = normalize(mix(fallbackDir, tangent, blendW) + 1e-6);\n  return vec4(dir, A, packGrad(Gx, Gy));\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", je = "// ── Medium id constants (mirror uniformBridge.ts MEDIUM_ID — the uMedium ladder) ──\n// The StrokeProfile selector (AX.W12 + AX.W13) dispatches on the medium id: oil,\n// van-Gogh, and oil-pastel each AUTHOR a first-class profile in profileFor.\n#define MEDIUM_OIL 3\n#define MEDIUM_CRAYON 4\n#define MEDIUM_VANGOGH 5\n#define MEDIUM_OILPASTEL 6\n\n// ── Crayon — DRY wax pigment on paper tooth (first-class medium, uMedium==4) ──\n// Crayon is not strokes. It's dry pigment crumbs dragged across paper tooth — the\n// DRY tooth-multiply model: anisotropic tooth noise multiplied into the base, a hard\n// SCUMBLE that lets the lower color show through the broken upper layer, and stable\n// OKLCh broken-color pigment patches. NO sheen, NO burnish film — that waxy gloss is\n// the OIL-PASTEL deposition's signature (mediumOilPastel), distinct from dry crayon\n// (AX.W13 slice 8 F1 — the split). Crayon shares the SUBSTRATE (the structure-tensor\n// orientation, the tooth noise, OKLCh brokenColorJitter), not the dispatch body.\nvec3 mediumCrayon(vec3 col, vec2 p, float t) {\n  // Orient the deposition along the structure-tensor edge-tangent (the bridge forces\n  // tensor for crayon, so read the tensor field directly).\n  vec2 flow = structureTensorField(p, t, flowField(p, t)).xy;\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 dry 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 tooth = 0.55 * t1 + 0.30 * t2 + 0.15 * t3;\n\n  // ── DRY TOOTH-MULTIPLY — the crayon multiplies the tooth relief into the base\n  // color (dark in the pits, bright on the ridges). The pressure (uStrokeAmount) sets\n  // how hard the multiply bites. This is the DRY model — no pigment build-up, no sheen.\n  float pressure = clamp(uStrokeAmount, 0.0, 1.0);\n  float bite = mix(0.18, 0.46, pressure);        // multiply strength\n  vec3 result = col * (1.0 - bite * (0.5 - tooth));\n\n  // ── HARD SCUMBLE — a broken upper layer that lets the lower color show through the\n  // gaps. A coarse mask gates a HARD (high-contrast) dragged pass so the dry crayon\n  // reads as broken pigment crumbs, not a smooth wash. Drag follows the tensor flow.\n  float scumbleMask = smoothstep(0.42, 0.78, vnoise(vec2(pr.x * scale * 0.55, pr.y * scale * 0.22) + 7.0));\n  float scumbleCoverage = scumbleMask * pressure * 0.7;     // hard broken upper layer\n  vec3 paper = col * mix(0.80, 0.94, pressure);             // the paper showing through\n  result = mix(paper, result, scumbleCoverage);\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  // Crayon is saturation-amplified (the wax chroma punch — but DRY, no sheen).\n  result = saturate3(result, 1.08);\n\n  return result;\n}\n\n// ── StrokeProfile — the oil-stroke parameter vector (AX.W12, slice 8 F6) ──────\n// The SBR \"stroke = parameter vector\" canon (facet 11): the per-mode if-ladder knobs\n// become struct FIELDS — logic-as-DATA, not an imperative branch. profileFor(medium,\n// mode) populates the profile for a (medium, mode) pair; paintStrokeLayers(profile) runs\n// the four-layer bestOil/paintOver cascade off it. A new medium (the W13 van-Gogh /\n// oil-pastel profiles) AUTHORS a profile entry — it never edits a monolith.\nstruct StrokeProfile {\n  int   shapeType;   // 0 tapered, 1 load-drag, 2 dab, 3 even, 4 comma/crescent\n  float bristleAmp;  // edge raggedness 0..0.5\n  float streakFreq;  // internal-streak spatial frequency\n  float streakAmp;   // internal-streak amplitude\n  float impastoAmp;  // paint-thickness contribution (the relight reads the height)\n  float hardness;    // edge-compositing crispness 0..1\n  float toothScale;  // canvas-tooth (linen weave) spatial frequency\n  float toothAmp;    // canvas-tooth amplitude\n  float pigmentSat;  // pigment saturation boost (OKLCh chroma scale)\n  float densityBig;  // layer-1 (big gestural) placement density gate\n  float densityMed;  // layer-2 (medium body) placement density gate\n  float densitySml;  // layer-3 (small dabs) placement density gate\n  float energyGrade; // AX.W13 — SBR energy-grade magnitude (0 off; 1 the van-Gogh\n                     // Starry-Night length cascade). The energy grade is a PROFILE\n                     // field, NOT a buried uMedium==5 bestOil branch (slice 8 F0).\n  float impastoFloor;// AX.W13 — the per-stroke height-crown floor (0.4 oil falloff;\n                     // 1.0 van-Gogh FULL-height crown so each dab catches its glint).\n  float densityFill; // AX.W13 — layer-4 fill-dab density. Oil/oil-pastel fill the\n                     // bald spots (0.95, full coverage); van-Gogh sets it LOW so the\n                     // sparse atomic dabs keep their visible inter-stroke ground gaps\n                     // (the atomicity read — a 0.95 fill would close every gap to a smear).\n  float groundFloor; // AX.W13 — the bare-ground darken floor. The gaps between strokes\n                     // (low accumulated height) multiply toward this floor, so van-Gogh's\n                     // sparse atomic dabs read over a visibly darker underpainting (the\n                     // Starry-Night visible ground). Oil/oil-pastel keep 1.0 (no darken).\n};\n\n// The (medium, mode) -> StrokeProfile selector. The if-ladder's knobs are the profile's\n// fields; a new medium adds a CASE here (never an edit to a dispatch body). mode is the\n// uStrokeMode oil-stroke sub-mode (0 oil, 1 palette-knife, 3 brushwork). crayon\n// (uMedium==4) is a PEER tooth-multiply medium that never reaches the stroke cascade.\n// The painterly STROKE mediums are oil (MEDIUM_OIL), van-Gogh (MEDIUM_VANGOGH) and\n// oil-pastel (MEDIUM_OILPASTEL) — each AUTHORS its own profile entry below.\n" + De + "\n// The single parameterized four-layer stroke cascade (AX.W12). The four hand-unrolled\n// bestOil/paintOver invocations collapse into ONE body driven by the profile + the\n// uniform-derived per-layer scale/anisotropy multipliers (which are mode-INVARIANT — the\n// per-layer offsets, seeds, and len/wid muls are fixed across modes, so they stay here as\n// the cascade's structure; only the profile's knobs differentiate the medium). The\n// mode passes through for the two mode-special-cased shapes (knife layer-3 dabs +\n// layer-4 fill shape), which are placement details of the cascade, not profile knobs.\nvoid paintStrokeLayers(inout vec3 col, inout float height, StrokeProfile prof,\n                       int mode, vec2 p, float t) {\n  // Scales & multipliers from uniforms (mode-invariant cascade structure).\n  float baseScale = max(uStrokeScale * 0.006, 0.008);\n  // Three primary layers: big gestural, medium body, small dabs.\n  // W-AUR-STUDIO D5 — the −5/3 radii respacing was MEASURED + REVERTED (recorded, not\n  // silently struck). The φ-adjacent geometric candidate (2.4 / 1.45 / 0.87, a fixed\n  // ≈1.66× step) moved oil-pastel β −2.534 → −2.413 — TOWARD the −5/3 band but NOT into\n  // it (floor −1.85), so the keep-iff-into-band gate failed. The single-pass WebGL2 path\n  // is the true limiter (HC-aurora §5): the oil-pastel β + the oil/oil-pastel anisotropy\n  // residual stays the oil/oil-pastel stroke-cascade ceiling. BB.W-AUR-KUWAHARA DECIDED the\n  // booking: the SOFT anisotropic-Kuwahara finish ships as the OPT-IN mediumKuwahara() body\n  // (uMedium==7) the consumer selects — NOT a re-tune of these oil/oil-pastel knobs. The\n  // hand-set 2.4 / 1.1 / 0.45 stays — it is van-Gogh's landed-band spacing.\n  float sBig = baseScale * 2.4;\n  float sMed = baseScale * 1.1;\n  float sSml = baseScale * 0.45;\n\n  // Strokes are elongated HARD (long·thin) so the rendered field reads strongly\n  // directional — the §4.2 structure-tensor anisotropy lift. A short fat dab is locally\n  // isotropic and drags the measured A down; a long thin stroke that hugs the tensor\n  // tangent is what gives Starry Night its A≈0.83. The width muls are pulled tighter to\n  // keep the long·thin aspect.\n  float lenMulBig = mix(3.0, 5.2, uStrokeAnisotropy);\n  float widMulBig = mix(0.42, 0.22, uStrokeAnisotropy);\n  float lenMulMed = mix(2.8, 4.8, uStrokeAnisotropy);\n  float widMulMed = mix(0.40, 0.21, uStrokeAnisotropy);\n  float lenMulSml = mix(2.2, 3.6, uStrokeAnisotropy);\n  float widMulSml = mix(0.36, 0.23, uStrokeAnisotropy);\n\n  float jitterAmt = 0.75;   // large jitter — no grid\n  vec2 flow = flowField(p, t);\n\n  // Layer 1 — big gestural strokes (sparse, shaping)\n  StrokeHit hBig = bestOil(p, sBig, lenMulBig, widMulBig, jitterAmt * 0.55,\n                           prof.densityBig, prof.shapeType, prof.bristleAmp, flow, t, 1.3,\n                           prof.energyGrade);\n  paintOver(col, height, hBig, prof.streakFreq * 0.7, prof.streakAmp,\n            uImpasto * prof.impastoAmp * uStrokeAmount, prof.hardness, 1.3, prof.impastoFloor);\n\n  // Layer 2 — medium body strokes\n  StrokeHit hMed = bestOil(p + vec2(11.3, 3.7), sMed, lenMulMed, widMulMed,\n                           jitterAmt, prof.densityMed, prof.shapeType, prof.bristleAmp, flow, t, 2.7,\n                           prof.energyGrade);\n  paintOver(col, height, hMed, prof.streakFreq, prof.streakAmp,\n            uImpasto * prof.impastoAmp * uStrokeAmount, prof.hardness, 2.7, prof.impastoFloor);\n\n  // Layer 3 — small strokes (more frequent, smaller). Even the knife layer-3 stays the\n  // medium's DIRECTIONAL shape, not a round dab — the round-dab sparkle was a fine-scale\n  // isotropic speckle that dragged the §4.2 anisotropy down + rolled the §4.3 slope shallow.\n  int smlShape = prof.shapeType;\n  StrokeHit hSml = bestOil(p + vec2(-5.1, 8.4), sSml, lenMulSml, widMulSml,\n                           jitterAmt * 0.9, prof.densitySml, smlShape,\n                           prof.bristleAmp * 0.85, flow, t, 4.1, prof.energyGrade);\n  paintOver(col, height, hSml, prof.streakFreq * 1.4, prof.streakAmp * 0.6,\n            uImpasto * prof.impastoAmp * 0.45 * uStrokeAmount, prof.hardness, 4.1, prof.impastoFloor);\n\n  // Layer 4 — fill strokes (dense, fine) — cover bald spots. The density is\n  // PROFILE-driven (prof.densityFill): oil/oil-pastel fill to full coverage; van-Gogh\n  // keeps it sparse so the bare-ground gaps between its atomic dabs survive. The fill is\n  // ELONGATED + flow-oriented (NOT a round dab) — a dense round-dab fill is locally\n  // isotropic and was the dominant §4.2 anisotropy sink; an oriented fine stroke keeps the\n  // fill directional so the whole field reads coherent.\n  float sFill = baseScale * 0.22;\n  float lenMulFill = mix(2.0, 3.2, uStrokeAnisotropy);\n  float widMulFill = mix(0.34, 0.24, uStrokeAnisotropy);\n  int fillShape = (mode == 1) ? 3 : prof.shapeType; // knife=even; others inherit the medium's directional shape\n  StrokeHit hFill = bestOil(p + vec2(3.9, -6.2), sFill, lenMulFill, widMulFill,\n                            jitterAmt * 0.8, prof.densityFill, fillShape,\n                            prof.bristleAmp * 0.6, flow, t, 8.9, prof.energyGrade);\n  // The fill is a low-relief, low-streak base coat — it covers bald spots WITHOUT adding\n  // fine bright speckle (a high-impasto/high-streak fill caught a per-dab glint that read\n  // as isotropic noise over the directional macro strokes — the §4.2/§4.3 sink). Its\n  // positional jitter is tamed too so the fill strokes stay flow-aligned, not scattered.\n  paintOver(col, height, hFill, prof.streakFreq * 1.2, prof.streakAmp * 0.35,\n            uImpasto * prof.impastoAmp * 0.18 * uStrokeAmount, prof.hardness * 0.9, 8.9, prof.impastoFloor);\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, prof.densityMed * 0.7, prof.shapeType, prof.bristleAmp, flow2, t, 6.5,\n                           prof.energyGrade);\n    paintOver(col, height, hX, prof.streakFreq, prof.streakAmp * 0.85,\n              uImpasto * prof.impastoAmp * 0.55 * uStrokeAmount, prof.hardness, 6.5, prof.impastoFloor);\n  }\n}\n\n// The shared stroke-medium SUBSTRATE finish (AX.W12 + AX.W13): paint the four-layer\n// cascade off the profile, then canvas-tooth + relight + saturation. The three painterly\n// STROKE mediums (oil / van-Gogh / oil-pastel) each AUTHOR their own profile and call\n// this — the substrate is shared, the PROFILE (not a dispatch-body fork) differentiates\n// the medium (slice 8 F6). mode passes through for the cascade's mode-special-cased shapes.\nvec3 paintStrokeMedium(vec3 col, vec2 p, float t, StrokeProfile prof, int mode) {\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  paintStrokeLayers(result, height, prof, mode, p, t);\n\n  // Canvas tooth — linen weave\n  float tooth1 = vnoise(p * prof.toothScale);\n  float tooth2 = vnoise(p * prof.toothScale * vec2(0.6, 2.4) + 37.0);\n  float tooth  = (0.6 * tooth1 + 0.4 * tooth2) - 0.5;\n  result *= 1.0 + tooth * prof.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 * prof.toothAmp * 0.5;\n  result = relightImpasto(result, height, canvasBase);\n\n  // AX.W13 — the visible ground. The bare-ground gaps (low accumulated stroke height)\n  // multiply toward prof.groundFloor, so van-Gogh's sparse atomic dabs read as separable\n  // marks over a darker underpainting (oil/oil-pastel keep groundFloor=1.0 → no-op). The\n  // smoothstep keeps the impasto dabs (high height) at full value; only the open ground\n  // between them darkens.\n  result *= mix(prof.groundFloor, 1.0, smoothstep(0.0, 0.38, height));\n\n  // Pigment saturation boost\n  result = saturate3(result, prof.pigmentSat);\n\n  return result;\n}\n\nvec3 mediumOil(vec3 col, vec2 p, float t) {\n  // The oil medium is a thin body: fetch the oil profile (mode-dispatched), paint via\n  // the shared stroke substrate.  uStrokeMode: 0 oil (gestural), 1 knife, 3 brushwork.\n  int mode = uStrokeMode;\n  StrokeProfile prof = profileFor(MEDIUM_OIL, mode);\n  return paintStrokeMedium(col, p, t, prof, mode);\n}\n\n#define MEDIUM_KUWAHARA 7\n\n// ── Kuwahara — the anisotropic generalized Kuwahara painterly finish (uMedium==7,\n// BB.W-AUR-KUWAHARA) ───────────────────────────────────────────────────────────────\n// The SOTA edge-preserving painterly smoothing: the generalized/anisotropic Kuwahara of\n// Kyprianidis 2010, the SOFT polynomial-weighted variant (NOT the pre-2010 hard argmin,\n// which BANDS the flat field into an 8-spoke pinwheel — the §4.2 anti-regression). Aurora\n// is a PROCEDURAL field (no input texture), so the operator runs over sampleBase() directly:\n// an elliptical kernel oriented along the structure tensor (elongated along the edge-tangent,\n// narrowed by the anisotropy), divided into 8 overlapping sectors via smooth weights; the\n// output is the variance-weighted blend of the sector means (1/(1+var^q) — low-variance\n// sectors dominate, the SOFT criterion → flat oil-paint patches with crisp zone boundaries).\n// Single-pass small-radius WebGL2 form: 4 rings × 8 angular taps = 32 procedural samples\n// (cost-bounded; the offscreen-park / PRM freeze the substrate owns is untouched).\nvec3 mediumKuwahara(vec3 col, vec2 p, float t) {\n  // Orient the kernel along the structure-tensor edge-tangent + read the coherence A\n  // (the field widened vec3→vec4 for metal's gradient; kuwahara reads only .xy/.z).\n  vec4 stf = structureTensorField(p, t, flowField(p, t));\n  vec2 tangent = stf.xy;\n  float A = stf.z;\n  // The ellipse axes: major along the tangent, minor across. Anisotropy squeezes the\n  // minor axis (coherent zones → long-thin patch along the colour band; flat zones →\n  // near-circular so the operator degrades gracefully to the isotropic Kuwahara). The\n  // base radius rides uStrokeScale so the painterly patch size tracks the studio knob.\n  float radius = clamp(0.010 + uStrokeScale * 0.00018, 0.006, 0.024);\n  float aniso = mix(1.0, 0.34, clamp(A, 0.0, 1.0)); // minor/major axis ratio\n  vec2 ax = tangent;                  // major-axis unit vector (edge-tangent)\n  vec2 ay = vec2(-tangent.y, tangent.x); // minor-axis unit vector (edge-normal)\n\n  // 8 sectors, soft polynomial weights. Each sector i centers on angle i·45°; a sample's\n  // sector weight is a smooth gaussian-of-angular-distance so sectors OVERLAP (no hard\n  // argmin → no pinwheel banding). The center sample seeds all sectors equally.\n  const int SECTORS = 8;\n  vec3  m[8];   // per-sector weighted colour sum\n  vec3  s[8];   // per-sector weighted colour² sum (for variance)\n  float w[8];   // per-sector weight sum\n  for (int i = 0; i < SECTORS; i++) { m[i] = vec3(0.0); s[i] = vec3(0.0); w[i] = 0.0; }\n\n  // 4 rings × 8 angular taps over the elliptical disc. Each tap: sample the procedural\n  // field, then deposit into the sectors by the soft angular weight × the radial falloff.\n  const int RINGS = 4;\n  const int TAPS  = 8;\n  for (int r = 1; r <= RINGS; r++) {\n    float rr = float(r) / float(RINGS);          // 0.25 .. 1.0\n    float radial = 1.0 - 0.6 * rr;               // inner taps weigh more (gaussian-ish)\n    for (int a = 0; a < TAPS; a++) {\n      float ang = 6.2831853 * float(a) / float(TAPS);\n      // Elliptical offset: major axis full radius, minor axis squeezed by aniso.\n      vec2 dirE = ax * cos(ang) + ay * (sin(ang) * aniso);\n      vec2 off  = dirE * (radius * rr);\n      vec3 c = sampleBase(p + off, t);\n      // The sample's angular bin (its sector) — soft, so it spills into neighbours.\n      for (int k = 0; k < SECTORS; k++) {\n        float sectorAng = 6.2831853 * float(k) / float(SECTORS);\n        // Smallest signed angular distance to the sector center.\n        float d = ang - sectorAng;\n        d = atan(sin(d), cos(d));                 // wrap to [-π, π]\n        float sw = exp(-d * d * 2.2) * radial;    // gaussian angular weight × radial\n        m[k] += c * sw;\n        s[k] += c * c * sw;\n        w[k] += sw;\n      }\n    }\n  }\n\n  // Per-sector mean + scalar luma-variance, then the SOFT variance-weighted blend.\n  vec3  accum = vec3(0.0);\n  float accumW = 0.0;\n  for (int k = 0; k < SECTORS; k++) {\n    float wk = max(w[k], 1e-4);\n    vec3  mean = m[k] / wk;\n    vec3  var3 = max(s[k] / wk - mean * mean, vec3(0.0));\n    float variance = dot(var3, W_LUMA);           // perceptual scalar variance\n    // SOFT criterion: low-variance sectors (flat, inside a colour zone) dominate; a\n    // high-variance sector (straddling an edge) is suppressed. q controls the sharpness;\n    // a finite q (not argmin) keeps the blend continuous → no pinwheel spoke.\n    float sectorW = 1.0 / (1.0 + pow(variance * 320.0, 4.0));\n    accum  += mean * sectorW;\n    accumW += sectorW;\n  }\n  vec3 result = accum / max(accumW, 1e-4);\n\n  // The center sample anchors the result in near-flat zones (where every sector reads the\n  // same colour) so the operator is a no-op there — the smoothing only BITES at edges.\n  vec3 center = sampleBase(p, t);\n  result = mix(center, result, clamp(0.35 + 0.65 * A, 0.0, 1.0));\n\n  // A faint canvas tooth + pigment-saturation lift so the flattened patches read as\n  // oil-paint, not a posterized blur (the painterly identity the smoothing alone lacks).\n  float tooth = vnoise(p * 300.0) - 0.5;\n  result *= 1.0 + tooth * 0.06 * uCanvasGrain;\n  result = saturate3(result, 1.04);\n\n  // Blend toward the incoming col by uStrokeAmount so the studio amount knob controls\n  // the finish strength (uStrokeAmount=0 → the raw field passes through; default → full).\n  return mix(col, result, clamp(uStrokeAmount, 0.0, 1.0));\n}\n\n" + ke + Ee + "// AX.W13 — the oil-pastel medium (uMedium==6) is a DISTINCT stroke-deposition body,\n// split out of the dry-crayon tooth-multiply (mediumCrayon) (slice 8 F1). It DEPOSITS\n// broad smeared directional strokes via the same brush engine with a creamy soft\n// hardness, heavy pigment build-up where strokes overlap, and a chroma punch — the\n// stroke-deposition model that gives oil-pastel its depth and less-uniform read.\n// Shares the SUBSTRATE (the stroke cascade + tooth + relight) with oil/van-Gogh, NOT\n// the dispatch body of dry crayon. The bridge forces tensor orientation.\nvec3 mediumOilPastel(vec3 col, vec2 p, float t) {\n  StrokeProfile prof = profileFor(MEDIUM_OILPASTEL, 0);\n  return paintStrokeMedium(col, p, t, prof, 0);\n}", A = "\n", Me = `#version 300 es
+var xe = "#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}", Se = "\nconst float CURL_EPS = 0.012;\n\n// Scalar fbm potential psi — the host's noise basis, wrapped so the curl operator is\n// basis-agnostic. A host carrying its own fbm defines this as: return fbm(p);\nfloat potentialFBM(vec2 p);\n\n// ∇×ψ in 2D — the divergence-free flow direction. Central finite differences of the\n// scalar potential give the partials; the cross-pairing (∂y, −∂x) is the 2D curl.\nvec2 curlFBM(vec2 p) {\n  float dx = potentialFBM(p + vec2(CURL_EPS, 0.0)) - potentialFBM(p - vec2(CURL_EPS, 0.0));\n  float dy = potentialFBM(p + vec2(0.0, CURL_EPS)) - potentialFBM(p - vec2(0.0, CURL_EPS));\n  // ψ-gradient is (dx, dy)/(2·eps); the curl rotates it 90°: (∂ψ/∂y, −∂ψ/∂x).\n  vec2 g = vec2(dx, dy) / (2.0 * CURL_EPS);\n  return vec2(g.y, -g.x);\n}\n", Ce = "// ── Palette LUT (OKLCh/OKLab interpolation) ──────────────────────────────\n// The endpoints stay CPU-baked to LINEAR sRGB (the Aras precompute pattern); only\n// the between-endpoint interpolation runs in perceptual space. The ramp\n// itself (the smoothstep ease + the OKLab-rectangular-vs-OKLCh-hue-arc dispatch on\n// uHuePath) is the shared samplePaletteRamp from procedural-color.glsl, the SAME\n// source the WebGPU twin splices; samplePalette here only selects the bracketing\n// stop pair + the raw inter-stop t and hands them to the shared ramp.\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  return samplePaletteRamp(uPalette[i0], uPalette[i1], t, uHuePath);\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", we = "// ── Flow field ────────────────────────────────────────────────────────────\n// Structure-tensor prototype (body defined post-sampleBase in the mediums block).\n// Returns vec4(dir.x, dir.y, coherence, packedGrad) — the minor-eigenvector tangent + A + the\n// metal-gradient .w lane in the widened vec3→vec4 return. The forward declaration must match\n// the vec4 definition or WebKit's compiler rejects the mismatched signature (L1b).\nvec4 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. 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  return dir;\n}\n", Te = "// Khronos PBR-Neutral tonemap (hue + saturation preserving)\nvec3 aces(vec3 color) {\n  const float startCompression = 0.8 - 0.04;\n  const float desaturation = 0.15;\n  float x = min(color.r, min(color.g, color.b));\n  float offset = x < 0.08 ? x - 6.25 * x * x : 0.04;\n  color -= offset;\n  float peak = max(color.r, max(color.g, color.b));\n  if (peak < startCompression) return clamp(color, 0.0, 1.0);\n  float d = 1.0 - startCompression;\n  float newPeak = 1.0 - d * d / (peak + d - startCompression);\n  color *= newPeak / peak;\n  float g = 1.0 - 1.0 / (desaturation * (peak - newPeak) + 1.0);\n  return clamp(mix(color, newPeak * vec3(1.0), g), 0.0, 1.0);\n}\n", Ee = "// ── 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\n//   4 comma      — van-Gogh atomic dab: ASYMMETRIC taper, fat near one end and\n//                  drawn to a fine point at the other (the divisionist crescent\n//                  mark). The width peak sits off-centre (~0.32) so the two ends\n//                  taper at DIFFERENT rates — a loaded round head + a dragged tail.\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  } else if (type == 4) {\n    // comma / crescent — width peaks at ~0.32 then drags to a fine tail. The two\n    // sides of the peak fall at different exponents (a fat round head, a long thin\n    // tail), so the mark reads as a directional van-Gogh comma, not a symmetric oval.\n    float peak = 0.32;\n    float head = smoothstep(0.0, peak, t);                            // rounded loaded head\n    float tail = pow(clamp((1.0 - t) / (1.0 - peak), 0.0, 1.0), 1.6); // dragged thin tail\n    return clamp(min(head, tail) * 1.04, 0.0, 1.0);\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// The painterly STROKE mediums (those that deposit via paintStrokeLayers/paintOver):\n// oil (3), van-Gogh (5), oil-pastel (6). For these the stroke OVER-composite runs in\n// OKLab so overlapping complementaries mix through a chromatic path, not the linear-\n// RGB grey mud; the smooth/atmospheric pole never reaches paintOver so it pays nothing.\nbool isPainterlyStroke() {\n  return uMedium == 3 || uMedium == 5 || uMedium == 6;\n}\n\n// OKLab OVER-composite: lerp L,a,b of the over-color toward the under-color (the\n// Ottosson matrices spliced from procedural-color.glsl.ts — no new color math). Two\n// complementary-hued strokes overlapping transition through OKLab, where the midpoint\n// holds chroma, instead of the linear mix() that desaturates toward grey.\nvec3 paintOverOklab(vec3 under, vec3 over, float alpha) {\n  vec3 labU = linOklab(under);\n  vec3 labO = linOklab(over);\n  return max(oklabToLinearSrgb(mix(labU, labO, alpha)), vec3(0.0));\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// 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().\n//\n// The internal streak perturbs hue and chroma in OKLCh, not value only,\n// so a single stroke carries a small hue gradient (broken color at the ATOM level —\n// adjacent strokes shimmer like real impasto, not flat stamped swatches);\n// and the OVER-composite runs in OKLab on the painterly stroke mediums so overlapping\n// complementaries mix as pigment, not the linear-mix grey.\n//   impastoFloor — the per-stroke height-crown floor: oil's 0.4+0.6*edgeN reads\n//                  floor=0.4 (the crown tapers to 40% at the stroke edge); the van-Gogh\n//                  profile passes floor=1.0 so each atomic dab catches a FULL-height\n//                  glint (scope item 1d). The crown magnitude is floor + (1-floor)*edgeN.\nvoid paintOver(inout vec3 col, inout float height, StrokeHit s,\n               float streakFreq, float streakAmp,\n               float impastoAmp, float hardness, float streakSeed,\n               float impastoFloor) {\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\n  // ── Within-stroke OKLCh broken color. The streak fBm perturbs\n  // the stroke's HUE + CHROMA along alongT/crossN, seeded per-stroke, so a single\n  // stroke reads a small hue gradient (the atom-level broken-color shimmer). Value is\n  // carried by the same streak so the loaded-brush light/dark survives. Gated to the\n  // painterly stroke mediums + uBrokenColor (the smooth pole keeps the cheap value-only\n  // streak). A second decorrelated fBm drives the hue axis so hue ≠ a scaled value.\n  float hueStreak = fbm(vec2(s.alongT * streakFreq * 0.45 + streakSeed * 5.3,\n                             s.crossN * 1.9 + streakSeed * 1.7)) - 0.5;\n  if (isPainterlyStroke() && uBrokenColor > 0.001) {\n    vec3 lch = oklabToOklch(linOklab(c));\n    // ±~10° within-stroke hue swing + ±~9% chroma, scaled by uBrokenColor. Smaller\n    // than the per-stroke cell jitter (brokenColorJitter) — this is the intra-stroke\n    // gradient layered on top of the per-cell pigment patch.\n    lch.z += hueStreak * (20.0 * PI / 180.0) * uBrokenColor;\n    lch.y = max(lch.y * (1.0 + (streak) * 0.18 * uBrokenColor), 0.0);\n    c = max(oklabToLinearSrgb(oklchToOklab(lch)), vec3(0.0));\n  }\n  // Value streak (the loaded-brush light/dark across the bristles) — kept for every\n  // medium that reaches paintOver (the smooth pole never does). The along-spine value\n  // modulation is the loaded-brush light/dark that gives each stroke its OWN directional\n  // luminance band — the structure-tensor signal a low-contrast color field (a uniform-hue\n  // oil field) has no other source for (the §4.2 anisotropy lift on the flat-palette case).\n  c *= 1.0 + streak * streakAmp * 3.2;\n\n  // Cross-stroke ridge/valley shading — a catch-light along the spine centre, darkening to\n  // the stroke edges. This is the strongest DIRECTIONAL luminance cue: it carves a bright\n  // ridge down the stroke's length and dark grooves between adjacent strokes, so a field of\n  // parallel strokes reads as parallel light/dark bands (the high-A van-Gogh signature) even\n  // where the underlying colour is flat. s.edgeN is 0 at the edge, 1 at the spine.\n  float ridgeShade = smoothstep(0.0, 0.55, s.edgeN);\n  c *= 1.0 + (ridgeShade - 0.5) * 0.30;\n\n  float softLimit = mix(0.35, 0.98, hardness);\n  float alpha = smoothstep(0.0, 1.0 - softLimit, s.coverage) * strokeOpacity;\n  // OKLab OVER-composite on the painterly stroke mediums (overlap mixes as pigment,\n  // not grey); the smooth pole never reaches paintOver, so it keeps the cheap path.\n  col = isPainterlyStroke() ? paintOverOklab(col, c, alpha) : mix(col, c, alpha);\n\n  // ── Accumulate paint height. Thickness peaks at the stroke spine and\n  // falls toward the impastoFloor at the edge (edgeN: 0=edge, 1=spine), perturbed by\n  // the bristle streak so ridges/grooves form. The relight reads the gradient of this\n  // field. The van-Gogh profile's floor=1.0 gives every atomic dab a full-height crown.\n  float ridge = 0.7 + 0.3 * (streak + 0.5);\n  float crown = impastoFloor + (1.0 - impastoFloor) * s.edgeN;\n  height += s.coverage * impastoAmp * crown * ridge * alpha;\n}\n\n// 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  // The specular glint is gated to ACCUMULATED-thick paint (height²) — a per-fine-stroke\n  // sharp glint on every thin fill dab read as bright isotropic SPECKLE that buried the\n  // directional stroke bands (the §4.2 anisotropy / §4.3 slope sink on the low-contrast\n  // oil field). Only where real impasto has built up does the raked glint fire, so the\n  // highlight tracks the macro ridges, not the fine speckle.\n  float specGate = clamp(height, 0.0, 1.0);\n  lit += uImpasto * relief * spec * specGate * 0.5 * 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.\n//   energyGrade — the SBR energy-grade magnitude (0 = none, the oil/oil-pastel\n//                 baseline; 1 = the full van-Gogh Starry-Night cascade — long\n//                 confident strokes in the lights/coherent zones, short dabs in\n//                 the darks/flat zones). The van-Gogh profile carries 1.0 (the\n//                 energy grade is a PROFILE field, not a buried uMedium==5 branch).\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                  float energyGrade) {\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 from the 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 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        // vec4 (the metal-finish widen) — .xy tangent + .z coherence; the .w gradient lane\n        // is unused here. A vec3 local would be a type-mismatch WebKit rejects (L1c).\n        vec4 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 FAR less angular jitter (the field already orients them\n      // — over-jittering the tensor strokes scatters their directions and the rendered\n      // field reads isotropic, the §4.2 anisotropy floor). The flow-oriented (non-tensor)\n      // strokes keep the full jitter (they have no per-cell orientation source).\n      float jScale = (uStrokeOrient == 1) ? 0.15 : 1.0;\n      float angJ = (hash21(cc + seed + 11.0) - 0.5) * 0.9 * jScale;  // +/- 0.45/0.07 rad\n      float curlScale = (uStrokeOrient == 1) ? 0.30 : 1.0;\n      float localCurl = (fbm(center * (2.6 + seed * 0.11) + seed * 1.9) - 0.5) * 0.55 * uFlowCurl * curlScale;\n      vec2 dir = rotateDir(f, angJ + localCurl);\n\n      // The SBR energy grade is a profile field (energyGrade), not a buried\n      // uMedium==5 branch. The van-Gogh profile passes energyGrade=1.0 (the full\n      // Starry-Night cascade); oil/oil-pastel pass 0.0 (uniform length). The grade\n      // modulates stroke length by local luminance (bright → long confident strokes,\n      // dark → short dabs, the Kolmogorov/Batchelor congruence) AND by coherence\n      // (coherent zones → long, flat → stubby), lerped in by energyGrade so a profile\n      // can dial the cascade from off (0) to full (1).\n      float energy = 1.0;\n      if (energyGrade > 0.001) {\n        float luma = clamp(dot(sampleBase(center, t), W_LUMA), 0.0, 1.0);\n        float graded = mix(0.5, 1.5, luma) * mix(0.6, 1.0, coh);\n        energy = mix(1.0, graded, energyGrade);\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", De = "// ── Van Gogh atomic-dab body ─────────────────────────────────────────────\n// Van-Gogh does NOT route through the shared\n// oil paintStrokeMedium cascade — four DENSE layers of LONG-THIN tensor-oriented\n// strokes (lenMul up to 5.2, widMul 0.22) hugging a continuous coherent field. Packed\n// that tight, thin strokes that follow continuous iso-bands MERGE into smooth flowing\n// filaments — the \"marbled flow-bands\" read (a spirograph/fingerprint, not impasto),\n// AND the per-cell 8-tap structure tensor × 4 layers × 9 cells = ~324 sampleBase/pixel\n// runs at ~4fps. Van Gogh's sky is NOT continuous flow — it is DISCRETE, SHORT,\n// LOADED comma dabs, separated by visible ground, queued into swirl ROWS.\n//\n// This is a purpose-built two-layer DAB pass, disjoint from the oil cascade:\n//   • orientation from the analytic SWIRL flowField (van-Gogh skies ARE swirl rows) +\n//     per-cell angular jitter — NOT the expensive per-cell tensor (the lag source, and\n//     the marble source: a jittered discrete dab can NOT merge into a continuous\n//     filament the way a tensor-locked thin stroke does).\n//   • SHORT comma dabs (len/wid ≈ 2.6 : 1 — a loaded crescent mark, not a 10:1\n//     filament), so each reads as a SEPARABLE atom.\n//   • SPARSE placement with visible inter-dab ground (density ≈ 0.42), over a darkened\n//     swirl underpainting (the Starry-Night visible ground the bright dabs read over).\n//   • a single sampleBase per cell + OKLCh broken-color jitter (pigment shimmer);\n//     full-height impasto crown per dab (each catches its own raked glint).\n// This is ~2 layers × 9 cells × ~1 sampleBase ≈ 20/pixel (a ~16× cost cut, ~60fps), and\n// jittered short dabs CANNOT marble.\n\n// One atomic comma dab — a CLEAN analytic crescent SDF (NOT the oil curvedStroke).\n// The oil curvedStroke's spine-projection + rounded end-caps + fwidth-AA + bristle\n// edge each leave a thin sub-pixel skirt, and a field of those skirts over open ground\n// abuts into a faint network of SEAM LINES. A van-Gogh dab needs none of that\n// machinery — it is a short oriented capsule (rounded line segment) whose half-width\n// tapers along its length (the loaded-head → dragged-tail comma). The capsule SDF is\n// derivative-free (smoothstep AA against the analytic distance), so no fwidth skirt, no\n// best-of-9 seam. Returns a StrokeHit (coverage/color/alongT/edgeN) for paintOver.\n//   cellSize — dab cell pitch (UV units); lenMul/widMul — dab aspect off the cell;\n//   density  — placement gate (sparse → visible gaps); seed — layer decorrelation.\nStrokeHit vangoghDab(vec2 p, float cellSize, float lenMul, float widMul,\n                     float density, float jitterAmt, float angJitter,\n                     vec2 flow, float t, float seed) {\n  vec2 cell = floor(p / cellSize);\n  StrokeHit best = noHit();\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      // Sparse density gate — leaves visible canvas ground between dabs (atomicity).\n      if (hash21(cc * 1.7 + seed * 0.3) > density) continue;\n      vec2 jit = (hash22(cc + seed) - 0.5) * jitterAmt;\n      vec2 center = (cc + 0.5 + jit) * cellSize;\n\n      // Orientation: the analytic swirl flow at the cell center + per-cell angular\n      // jitter (so adjacent dabs FAN — the divisionist scatter that keeps the dabs from\n      // locking into perfectly-concentric rows) + a flow-noise curl wobble.\n      float ang = (hash21(cc + seed + 11.0) - 0.5) * angJitter;\n      float curl = (fbm(center * 3.1 + seed * 1.9) - 0.5) * (0.18 + 0.3 * uFlowCurl);\n      vec2 dir = rotateDir(safeDir(flow), ang + curl);\n\n      // SHORT comma — len ≈ the cell pitch (a contained dab, not a tiling filament).\n      float len = cellSize * lenMul * (0.82 + 0.30 * hash21(cc + seed + 23.0));\n      float halfW = max(cellSize * widMul * (0.86 + 0.28 * hash21(cc + seed + 41.0)), 0.010);\n\n      // Local dab frame: along = projection onto the dab axis (centred 0), perp = cross.\n      vec2 rel = p - center;\n      float along = dot(rel, dir);\n      float perp  = dot(rel, vec2(-dir.y, dir.x));\n      // The comma TAPER: half-width peaks ~1/3 from the loaded head and drags to a fine\n      // tail (the asymmetric crescent). u in [0,1] along the dab from head to tail.\n      float halfLen = len * 0.5;\n      float u = clamp((along + halfLen) / max(len, 1e-5), 0.0, 1.0);\n      float head = smoothstep(0.0, 0.30, u);                 // rounded loaded head\n      float tail = pow(clamp((1.0 - u) / 0.70, 0.0, 1.0), 1.3); // dragged thin tail\n      float prof = clamp(min(head, tail) * 1.05, 0.0, 1.0);\n      float wNow = halfW * prof;\n      // A gentle comma CURVE — bow the spine sideways so the mark reads as a crescent.\n      float bowAmt = (hash21(cc + seed + 53.0) - 0.5) * halfW * 1.4;\n      float spine = bowAmt * sin(u * PI);                    // 0 at ends, max mid\n      float d = abs(perp - spine);\n      // Derivative-free AA: a fixed fraction of the dab width (no fwidth skirt). Coverage\n      // is 1 in the dab body, smoothly 0 at the edge; outside the [head,tail] span wNow→0\n      // so the dab self-terminates with no end-cap blob.\n      float aa = max(halfW * 0.45, 0.002);\n      float cov = (wNow > 1e-5) ? (1.0 - smoothstep(wNow - aa, wNow + aa, d)) : 0.0;\n      if (cov < 0.004) continue;\n\n      // One sampleBase per cell + OKLCh broken-color jitter (pigment patch shimmer). The\n      // dab pigment is chroma-boosted (saturate3 1.22) AND value-lifted (×1.14) at the\n      // SOURCE — the loaded brush mark deposits BRIGHTER + more saturated pigment than the\n      // base field, so the loaded-mark pixels lift BOTH the §4.1 colourfulness AND the field\n      // mean-luma. The higher mean raises the gap-fraction threshold (meanLum·0.6) so the\n      // moderate-depth inter-dab ground falls below it (the gap-fraction atomicity read is\n      // DECOUPLED from the ground floor depth — the ground can stay only moderately dark, so\n      // the §4.3 slope is NOT over-steepened, while the bright dabs manufacture the gap). The\n      // dark ground is untouched, so this lifts C + gap WITHOUT a band-conflicting deep ground.\n      vec3 colMid = brokenColorJitter(\n        saturate3(sampleBase(center, t), 1.22),\n        hash21(cc + seed + 89.0),\n        hash21(cc * 2.3 + seed + 97.0),\n        1.0\n      );\n\n      // edgeN: 1 at the spine, 0 at the edge (the impasto crown reads it).\n      float edgeN = (wNow > 1e-5) ? clamp(1.0 - d / wNow, 0.0, 1.0) : 0.0;\n      if (cov > best.coverage) {\n        best = StrokeHit(cov, colMid, u, (wNow > 1e-5 ? (perp - spine) / wNow : 0.0), edgeN);\n      }\n    }\n  }\n  return best;\n}\n\nvec3 mediumVangogh(vec3 col, vec2 p, float t) {\n  vec3 result = col;\n  float height = 0.0;\n\n  // The swirl flow basis (van-Gogh sky = swirl rows). Computed ONCE per pixel.\n  vec2 flow = flowField(p, t);\n\n  // Dab cell pitch in UV [0,1]. CHUNKY, SEPARABLE marks — the big layer is ~1/14 of\n  // the frame so it reads as a distinct loaded brush dab (not a fine speckle, not a\n  // screen-spanning filament). uStrokeScale (authored ~110) modulates the pitch\n  // INVERSELY (higher = finer dabs) around the ~0.07 chunky default; clamped so the\n  // dab never collapses to noise or balloons past one screen. uStrokeAnisotropy\n  // stretches the comma aspect (longer, more directional marks).\n  float pitch = clamp(7.0 / max(uStrokeScale, 20.0), 0.044, 0.12);\n  // The dab LENGTH ≈ the cell pitch (lenAniso ~1.2-1.7) so a dab sits WITHIN its cell\n  // and leaves visible ground around it — a longer dab (lenMul > 2) spans neighbour\n  // cells and tiles the field into continuous coverage (no gaps, the gap-fraction floor\n  // miss + the marble). Narrow width keeps it a directional crescent, not a wide shard.\n  // lenAniso/widAniso — the comma aspect. The current profile lengthens\n  // the comma (1.25-1.75 → 1.5-2.0) and THINNED it (0.40-0.30 → 0.32-0.24): the rebuilt\n  // dabs measured §4.2 structure-tensor anisotropy A=0.699, BELOW the reference band\n  // floor 0.732 (the dabs read slightly too short-fat → locally isotropic, dragging mean\n  // A down). A LONGER, THINNER comma hugs the swirl-flow tangent more strongly so the\n  // rendered field reads coherent the way the tensor metric measures it (A lift), while\n  // the thinner width LEAVES MORE inter-dab ground (the gap-fraction atomicity read is\n  // preserved, not closed). The length stays ≈ the cell pitch so each dab remains a\n  // CONTAINED separable mark, not a tiling filament.\n  float lenAniso = mix(2.1, 2.7, uStrokeAnisotropy);   // comma length / cell pitch (a contained dab)\n  float widAniso = mix(0.23, 0.16, uStrokeAnisotropy); // comma width / cell pitch (a thin loaded crescent)\n\n  // Layer 1 — the big swirl-row dabs: the loaded gestural marks, SPARSE so the dark\n  // underpainting shows BETWEEN them (the atomicity read — visible inter-dab ground).\n  // hardness 0.74 — the loaded brush deposits with a SOFT shoulder, so adjacent dabs\n  // feather instead of razor-clipping into hard polygon shards. jitterAmt 0.85 fully\n  // scatters the cell centres so the placement GRID never reads as a periodic seam.\n  // angJitter EASED 0.55 → 0.38 (the reconcile A lift): a tighter angular spread keeps\n  // adjacent dabs more flow-aligned (coherent) while the per-cell curl wobble still\n  // breaks the perfectly-concentric-rows read (the dabs FAN gently, not lock to a grid).\n  // angJitter eased 0.38 → 0.26 + hardness 0.74 → 0.84 (the §4.2 A lift): a tighter angular\n  // spread keeps adjacent dabs strongly flow-aligned (the structure-tensor coherence) and a\n  // sharper edge gives each dab a STRONGER directional gradient (a soft dab's faint edge\n  // reads weakly anisotropic). The per-cell curl wobble still breaks the perfectly-\n  // concentric-rows read, so the dabs FAN gently rather than locking to a grid.\n  StrokeHit dBig = vangoghDab(p, pitch, lenAniso, widAniso,\n                              0.30, 0.50, 0.08, flow, t, 1.3);\n  // streakFreq raised 14 → 34 (the §4.3 slope fix): a high-frequency streak runs ALONG the\n  // dab spine, injecting fine-scale luma energy that flattens the too-steep β WITHOUT\n  // adding new isotropic marks (the along-spine streak stays directional, so the §4.2\n  // anisotropy the long-thin dab carries is preserved — the band-conflict resolution).\n  paintOver(result, height, dBig, 48.0, 0.34,\n            uImpasto * 0.75 * uStrokeAmount, 0.84, 1.3, 1.0 /* full crown */);\n\n  // Layer 2 — two-thirds-pitch accent dabs (the divisionist sparkle between the big\n  // marks — denser placement but still contained dabs, so dark canvas survives between).\n  // angJitter eased 0.5 → 0.34 (same A-lift reasoning — the accent dabs queue along the\n  // flow rather than scattering isotropically); hardness 0.78 → 0.86 sharpens the gradient.\n  StrokeHit dSml = vangoghDab(p + vec2(-5.1, 8.4), pitch * 0.62, lenAniso * 0.95,\n                              widAniso * 0.95, 0.36, 0.60, 0.20, flow, t, 4.1);\n  paintOver(result, height, dSml, 42.0, 0.22,\n            uImpasto * 0.55 * uStrokeAmount, 0.86, 4.1, 1.0);\n\n  // Layer 3 — fine divisionist flecks. The two-layer\n  // field read as a few BIG cobalt dabs over a smooth empty teal ground (the side-by-side\n  // against starry-night-crop.png: the painting is DENSE small varied flecks, not sparse\n  // large marks). The flecks are LONG·THIN directional commas hugging the swirl tangent\n  // (the A-preserving fleck — short fat flecks read isotropic and drag §4.2 down). Sparse\n  // density 0.30 keeps the inter-fleck ground open (the gap-fraction atomicity read).\n  // The flecks are FINE (≈0.42× pitch) directional commas, tightly flow-aligned (angJitter\n  // 0.22) and SPARSE (0.30) — the divisionist sparkle between the loaded marks that keeps\n  // the inter-dab ground open (atomicity) while adding the small-mark mid-band energy. Thin\n  // + flow-aligned so the §4.2 anisotropy the long dabs carry survives the added small marks.\n  StrokeHit dFleck = vangoghDab(p + vec2(8.7, -3.2), pitch * 0.42, lenAniso * 1.0,\n                                widAniso * 0.68, 0.30, 0.85, 0.22, flow, t, 7.7);\n  paintOver(result, height, dFleck, 30.0, 0.16,\n            uImpasto * 0.40 * uStrokeAmount, 0.80, 7.7, 1.0);\n\n  // ── Flow-aligned ground swirl grooving ─────────────────────────\n  // The bare ground between the dabs was a SMOOTH low-frequency teal gradient — the §4.3\n  // power-spectrum slope ran too STEEP (β≈−2.0: too much low-frequency nuclei-field energy\n  // vs the high band). Van Gogh's actual sky has the swirl BRUSHWORK everywhere, so groove\n  // the OPEN GROUND with a flow-aligned ripple. It is SUBTRACTIVE-biased (it only darkens,\n  // never brightens the ground), so it DEEPENS the inter-dab valleys (MORE gap-fraction —\n  // atomicity preserved/strengthened) while injecting the across-flow mid-band luma energy\n  // that flattens β. Gated to the open ground (low height) via the (1-height) gate so it\n  // never lifts/erodes the loaded dab bodies (the dab read is untouched). Across the swirl\n  // FLOW axis so the grooves run WITH the sky's brushwork direction.\n  // The ground swirl-combing — a FIXED-global-angle directional grain on the open ground.\n  // A flow-FOLLOWING comb varies its direction with the swirl across the readback window,\n  // so its blurred structure tensor averages toward isotropic (no §4.2 lift). A comb at one\n  // GLOBAL angle (van-Gogh's dominant diagonal stroke grain) is COHERENT over the whole\n  // window ⇒ every open-ground pixel reads the SAME direction (the §4.2 mean-anisotropy lift\n  // the swirl comb could not reach). Two resolved bands (≈22 + ≈44 across the global axis ⇒\n  // ~21px + ~11px at 464px, both in the §4.3 fit window) also feed the β flatten. Gated to\n  // the open ground (low height) so the loaded dabs are untouched; SUBTRACTIVE-biased so the\n  // inter-dab valleys deepen (gap-fraction preserved, not filled).\n  vec2 gdir = normalize(vec2(0.82, 0.57));   // the dominant global stroke grain axis\n  float gacross = dot(p, vec2(-gdir.y, gdir.x));\n  float groundGate = 1.0 - smoothstep(0.05, 0.28, height);\n  float groove = sin(gacross * 22.0) + 0.5 * sin(gacross * 44.0 + 1.3);\n  result *= 1.0 - 0.16 * groundGate * (0.5 - 0.5 * groove);\n\n  // Canvas tooth (fine linen weave — base relief the raking light catches).\n  float tooth1 = vnoise(p * 220.0);\n  float tooth2 = vnoise(p * 220.0 * vec2(0.6, 2.4) + 37.0);\n  float tooth  = (0.6 * tooth1 + 0.4 * tooth2) - 0.5;\n  result *= 1.0 + tooth * 0.06 * uCanvasGrain;\n\n  // Relight the accumulated impasto height (raking light catches each dab's crown —\n  // the visible impasto ridge that makes a dab read as a RAISED loaded mark).\n  float canvasBase = tooth * 0.06 * 0.5;\n  result = relightImpasto(result, height, canvasBase);\n\n  // The visible Starry-Night GROUND — the open canvas between dabs (low accumulated\n  // height) darkens toward the deep underpainting, so the bright impasto dabs read as\n  // SEPARABLE atomic marks over a darker field (the dab↔ground contrast the user's\n  // \"reads as strokes\" bar needs, AND the painterly-statistics gap-fraction floor — the\n  // dark inter-dab ground must register as a measurable fraction of the field). 0.30\n  // floor over a WIDER smoothstep (0..0.40): deep enough that the open gaps read as the\n  // dark Starry-Night sky between marks (clearing the 4% gap floor) while the gradual\n  // ramp keeps the gaps reading as flowing underpainting, not the hard black ink LINES a\n  // narrow near-black step (0.26 / 0.0..0.32) produced.\n  // The smoothstep FLOOR starts at 0.10 (not 0): a dab's faint AA coverage TAIL deposits\n  // a sliver of height, and where many tails align along the swirl flow those slivers\n  // accumulate into a faint continuous height ridge that read as thin curved LINES in the\n  // ground. Holding the ground full-dark until a real dab CORE (height > 0.10) lifts out\n  // keeps the open field clean — only the loaded dab bodies emerge, the tails stay ground.\n  result *= mix(0.115, 1.0, smoothstep(0.085, 0.31, height));\n\n  // The van-Gogh chroma — a light OKLCh punch at 0.92 in the\n  // The discrete-dab profile's per-dab OKLCh\n  // broken-color jitter (the ±16° hue + ±chroma swing per cell) lifts the field's\n  // colourfulness on its own, so a 1.04 punch on TOP overshoots the\n  // reference band (rendered C=100.5 vs the painting's measured 70.67 ± 15/+25 →\n  // ceiling 95.67 — neon, not Starry Night's rich-but-not-garish blue/gold). The 0.92\n  // demote pulls the rendered colourfulness back IN-band while the broken-color jitter\n  // keeps the per-dab pigment variation (the discrete-stroke read is untouched — this\n  // is a chroma scale, not a dab-geometry change). Band-anchored on the real painting\n  // not a widened band.\n  result = saturate3(result, 1.0);\n  return result;\n}\n\n", Oe = "StrokeProfile profileFor(int medium, int mode) {\n  // The oil baseline (mode 0) — balanced modern-abstract/palette-knife hybrid.\n  StrokeProfile prof = StrokeProfile(\n    0,      // shapeType — tapered\n    0.25,   // bristleAmp\n    9.0,    // streakFreq\n    0.09,   // streakAmp\n    0.9,    // impastoAmp\n    0.80,   // hardness\n    340.0,  // toothScale — finer 240 → 340. Oil's β sat\n            //               right AT the −1.45 band ceiling (±0.02 frame variance straddling\n            //               it, surfaced once the vangogh bands went green and the spec reached\n            //               the oil β assert). MEASURED on the live GPU: ADDING fine high-\n            //               frequency tooth energy steepens oil's power-spectrum slope (more\n            //               negative — coarsening it the other way pushed β SHALLOWER to\n            //               −1.33). A finer, stronger tooth moves β to a safe distance inside\n            //               the −5/3 band [−1.85, −1.45]. Oil-only (oil-pastel sets 280).\n    0.14,   // toothAmp — raised 0.09 → 0.14 (same oil-β steepen: more fine-grain high band).\n    1.03,   // pigmentSat\n    0.65,   // densityBig\n    0.78,   // densityMed\n    0.90,   // densitySml\n    0.0,    // energyGrade — oil is uniform-length (no Starry-Night cascade)\n    0.4,    // impastoFloor — oil's 0.4+0.6·edgeN crown falloff\n    0.92,   // densityFill — oil fills DENSELY with the directional low-relief fill so the\n            //               flat-colour regions between the macro strokes are TEXTURED with\n            //               flow-aligned fine strokes (the §4.2 anisotropy needs every pixel\n            //               to carry directional gradient; a flat untextured region reads as\n            //               an isotropic/degenerate tensor and drags mean A down). The fill\n            //               is now directional + low-streak, so dense coverage textures\n            //               WITHOUT the round-dab speckle.\n    1.0     // groundFloor — oil keeps the full base (no ground darken; fills everywhere)\n  );\n\n  // The Van Gogh medium does NOT route through this oil\n  // StrokeProfile cascade. It is a DEDICATED atomic-dab body (mediumVangogh / vangoghDab\n  // below) — a profile-driven cascade (four dense layers of long-thin\n  // tensor-oriented strokes) merges into the \"marbled flow-bands\" read and runs at ~4fps.\n  // profileFor now serves ONLY the oil + oil-pastel stroke mediums; the MEDIUM_VANGOGH\n  // case is removed (no caller). MEDIUM_VANGOGH stays #define'd (the main() dispatch +\n  // isPainterlyStroke still key off uMedium==5).\n\n  // ── Oil-pastel — broad smeared directional strokes deposited via the brush engine\n  // Creamy soft edges (low hardness), heavy build-up, and a chroma punch.\n  // Distinct from the dry-crayon tooth-multiply (mediumCrayon): oil-pastel LAYS strokes.\n  if (medium == MEDIUM_OILPASTEL) {\n    prof.shapeType   = 0;     // tapered directional smear — a round dab reads locally\n                              // isotropic (steep β / low A); the creamy oil-pastel mark\n                              // is a broad DIRECTIONAL smear, which carries the §4.2\n                              // coherence + adds the directional mid-band the §4.3 slope\n                              // needs (the round-dab profile rolled β off to −2.8)\n    prof.bristleAmp  = 0.10;  // smooth creamy edges (waxy pastel, not bristle)\n    prof.streakFreq  = 18.0;  // finer internal smear — adds the mid/high-band the smooth\n                              // round-dab profile lacked (the β-too-steep fix); the\n                              // directional along-spine streak flattens the §4.3 slope\n                              // without crossing the strokes\n    prof.streakAmp   = 0.20;\n    prof.impastoAmp  = 0.7;   // build-up, but flatter than oil impasto\n    prof.hardness    = 0.42;  // CREAMY — soft compositing, strokes blend on overlap\n    prof.toothScale  = 280.0;\n    prof.toothAmp    = 0.12;  // the pastel tooth reads stronger\n    prof.pigmentSat  = 0.80;  // the waxy chroma — kept low so the rendered C clears\n                              // the §4.1 band ceiling with margin while the K-M subtractive\n                              // overlap path (paintOverOklab) keeps the chroma OFF the grey floor\n    prof.hardness    = 0.58;  // creamy but the strokes still REGISTER — a too-soft blend\n                              // (0.42) smeared the marks into the smooth colour zones and\n                              // the field rolled off too steep (β≈−2.9, a near-gradient);\n                              // a crisper deposit keeps the mid/high-band the −5/3 slope needs\n    prof.densityBig  = 0.62;  // broad directional coverage — but NOT over-dense: too many\n                              // overlapping creamy strokes point in slightly-varied\n                              // directions and the local §4.2 coherence DROPS (over-dense\n                              // measured A=0.57 < the 0.62-density A=0.63). The mid-density\n                              // flow-aligned deposit is the coherence sweet spot.\n    prof.densityMed  = 0.78;\n    prof.densitySml  = 0.90;\n    prof.energyGrade = 0.80;  // a strong Starry-Night length cascade — varies stroke length\n                              // by luma/coherence so the dab-size energy spreads across\n                              // scales (the −5/3 cascade the uniform-length 0.0 grade lacked,\n                              // the §4.3 β-too-steep fix). Not the full van-Gogh 1.0 (oil-\n                              // pastel keeps its creamy broad character).\n    prof.impastoFloor = 0.55; // a softer crown than van-Gogh's full-height glint\n    return prof;\n  }\n\n  // ── Oil sub-modes (mode dispatch on the oil medium).\n  if (mode == 1) {           // palette knife — razor edges, heavy impasto\n    prof.shapeType  = 3;     // flat, even\n    prof.bristleAmp = 0.12;\n    prof.streakFreq = 4.0;  prof.streakAmp = 0.05;\n    prof.impastoAmp = 1.6;\n    prof.hardness   = 0.95;\n    prof.toothAmp   = 0.04;\n    prof.densityBig = 0.80; prof.densityMed = 0.88; prof.densitySml = 0.70;\n  } else if (mode == 3) {    // thick brushwork — heavy bristle brush\n    prof.shapeType  = 0;     // tapered\n    prof.bristleAmp = 0.32;\n    prof.streakFreq = 14.0; prof.streakAmp = 0.14;\n    prof.impastoAmp = 1.2;\n    prof.hardness   = 0.85;\n    prof.toothAmp   = 0.07;\n  }\n  return prof;\n}\n", ke = "\n// ── Gradient pack ──────────────────────────────────\n// structureTensorField re-plumbs its already-computed luma gradient (Gx,Gy) out through\n// the vec4 return value's .w lane so the metal medium pays ZERO extra taps (a second Sobel is\n// 8 sampleBase() taps). 12 bits per bounded component ([-4,4]) into one f32, exact under\n// highp; the .xy/.z crayon/kuwahara callers are transparent to the widen.\nfloat packGrad(float gx, float gy) {\n  float qx = floor(clamp(gx * 0.125 + 0.5, 0.0, 1.0) * 4095.0);\n  float qy = floor(clamp(gy * 0.125 + 0.5, 0.0, 1.0) * 4095.0);\n  return qx + qy * 4096.0;\n}\nvec2 unpackGrad(float packed) {\n  float qy = floor(packed * (1.0 / 4096.0));\n  float qx = packed - qy * 4096.0;\n  return (vec2(qx, qy) * (1.0 / 4095.0) - 0.5) * 8.0;\n}\n", Ae = "#define MEDIUM_METAL 8\n#define MEDIUM_METALGRAD 9\n\n// ── Metal — two-term anisotropic BRDF over the field relief (uMedium==8/9) ──\n// Metal is a MUTUALLY-EXCLUSIVE medium (NOT a finish axis) — the field re-lights as\n// warm folded metal: the luma HEIGHT field (the packed structure-tensor gradient →\n// the surface normal) catches an anisotropic Blinn streak (brushed metal, the streak\n// runs ALONG the coherent edge-tangent) plus a sharp crest, both raked by a cursor-\n// synthesized light that reads on BOTH backends (uCursor is in-struct — a phantom\n// uLightDir read would be flat on the WGSL primary). The catch is the ACHROMATIC-WARM\n// anchor (AURORA_CATCH_LIGHT_ANCHOR ≈ [1.0,0.97,0.90], never a cold chrome-blue). The\n// body keeps the field HUE (technicolor valley base); the height rides the relief.\n// ZERO new taps — structureTensorField already computed the gradient (unpacked from .w).\nconst vec3  METAL_CATCH_WARM       = vec3(1.0, 0.97, 0.90); // AURORA_CATCH_LIGHT_ANCHOR\nconst float METAL_HEIGHT_SCALE     = 2.2;   // gradient → normal tilt (× uMetalHeightScale)\nconst float METAL_LIGHT_Z          = 0.55;  // synth-light z (toward viewer)\nconst vec2  METAL_IDLE_RAKE        = vec2(0.32, 0.34); // upper-right idle rake bias\nconst float METAL_SHININESS_ANISO  = 6.0;   // anisotropic streak exponent (brushed)\nconst float METAL_SHININESS_CREST  = 40.0;  // crest specular exponent (sharp)\nconst float METAL_COHERENCE_FLOOR  = 0.22;  // streak gates on edge coherence A\nconst float METAL_BODY_FLOOR       = 0.42;  // diffuse valley floor (dark side reads)\nconst float METAL_GRADIENT_FLATTEN = 0.55;  // metal-gradient pre-flatten toward luma\nconst float METAL_SPARKLE_DENSITY  = 240.0; // metal-gradient per-cell flake grid\nconst float METAL_SPARKLE_THRESH   = 0.72;  // only some cells flake\nconst float METAL_SPARKLE_AMP      = 0.6;   // flake glint amplitude\n\n// The shared metal BRDF core — takes the ALREADY-computed structureTensorField vec4 so\n// the caller pays ZERO extra taps (metal-gradient reuses the same stf). WebKit-fenced:\n// every pow base is clamped to [0,1], the exponents are compile-time constants.\nvec3 metalShade(vec3 baseCol, vec2 p, vec4 stf) {\n  vec2 tangent = stf.xy;\n  float A = stf.z;\n  vec2 grad = unpackGrad(stf.w);\n  // Height-field normal: N = normalize(vec3(grad * scale, 1)). The luma relief tilts\n  // the surface; the flat field reads near vec3(0,0,1) (facing the viewer).\n  vec3 N = normalize(vec3(grad * (METAL_HEIGHT_SCALE * uMetalHeightScale), 1.0));\n  vec3 V = vec3(0.0, 0.0, 1.0);\n  // Cursor-synthesized rake light (in-struct on BOTH backends — never uLightDir). The\n  // idle bias keeps a still field lit from the upper-right; a moving cursor rakes it.\n  vec3 L = normalize(vec3((uCursor - p) + METAL_IDLE_RAKE, METAL_LIGHT_Z));\n  vec3 H = normalize(L + V);\n  // Anisotropic streak — brushed metal: the highlight runs ALONG the edge-tangent, so\n  // it is a function of the H-component PERPENDICULAR to the tangent (sinTH).\n  float tH = dot(normalize(tangent), H.xy);\n  float sinTH = sqrt(clamp(1.0 - tH * tH, 0.0, 1.0));\n  float streak = pow(clamp(sinTH, 0.0, 1.0), METAL_SHININESS_ANISO);\n  float crest  = pow(clamp(dot(N, H), 0.0, 1.0), METAL_SHININESS_CREST);\n  float spec = streak * crest;\n  // Coherence gate — the anisotropic streak reads only where the field has a real edge\n  // (a flat zone has no brush direction; A≈0 → no streak).\n  spec *= smoothstep(0.0, METAL_COHERENCE_FLOOR, A);\n  // Technicolor valley base — the body keeps the FIELD hue; the diffuse term rides the\n  // height relief so the ridges brighten and the pits fall toward the floor.\n  float diff = clamp(dot(N, L), 0.0, 1.0);\n  vec3 body = baseCol * (METAL_BODY_FLOOR + (1.0 - METAL_BODY_FLOOR) * diff);\n  // The catch is the achromatic-warm anchor, scaled by the polish knob.\n  return body + METAL_CATCH_WARM * (spec * clamp(uMetalPolish, 0.0, 4.0));\n}\n\nvec3 mediumMetal(vec3 col, vec2 p, float t) {\n  vec4 stf = structureTensorField(p, t, flowField(p, t));\n  return metalShade(col, p, stf);\n}\n\n// metal-gradient (uMedium==9) — the SAME BRDF over a pre-flattened/gradient base + a\n// twinkle-in-place flake sparkle (position FIXED per cell, PHASE-animated, gated on\n// facing — flake glint, never a boil).\nvec3 mediumMetalGradient(vec3 col, vec2 p, float t) {\n  vec4 stf = structureTensorField(p, t, flowField(p, t));\n  // Pre-flatten toward luma (the smoother gradient-metallic base) — same BRDF, calmer body.\n  // NB: flat is a GLSL reserved interpolation qualifier — WebKit's compiler REJECTS it as an\n  // identifier (ANGLE tolerates it); named flatCol so the WebKit aurora shader compiles (L1a).\n  vec3 flatCol = mix(col, vec3(dot(col, W_LUMA)), METAL_GRADIENT_FLATTEN);\n  vec3 metal = metalShade(flatCol, p, stf);\n  // The height-field normal facing (recomputed from the same packed gradient — ZERO taps).\n  vec2 grad = unpackGrad(stf.w);\n  float facing = normalize(vec3(grad * (METAL_HEIGHT_SCALE * uMetalHeightScale), 1.0)).z;\n  // Twinkle-in-place: a fixed per-cell flake seed, phase-animated glint gated on facing.\n  vec2 cell = floor(p * METAL_SPARKLE_DENSITY);\n  float seed = hash21(cell);\n  float tw = pow(clamp(sin(t + seed * 6.2831853), 0.0, 1.0), 40.0);\n  float flakeGate = step(METAL_SPARKLE_THRESH, seed);\n  metal += METAL_CATCH_WARM * (tw * flakeGate * clamp(facing, 0.0, 1.0) * METAL_SPARKLE_AMP);\n  return metal;\n}\n", je = "// ── 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" + ke + "\n// ── Structure tensor / edge-tangent flow ───────────────────────────────────\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// coherence A = (λ1-λ2)/(λ1+λ2); flat zones relax toward fallbackDir by (1-A). The\n// single-pass small-tap WebGL2 form. Returns vec4(tangent.xy, A, packGrad(Gx,Gy)) —\n// The .w lane carries the metal medium's gradient; the .xy/.z callers are unchanged.\nvec4 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  // The blend weight is a low-power curve (A^0.35) so even MODERATE-coherence zones queue\n  // strongly along the tangent (a flowing van-Gogh band reads coherent the way the\n  // structure-tensor metric measures it; a linear A under-orients the mid-band and the\n  // rendered field reads too isotropic — the §4.2 anisotropy lift). The flat-zone (A≈0)\n  // relax to the fallback survives (0^0.35=0), so tensor noise never reads as jitter.\n  float blendW = pow(A, 0.28);\n  vec2 dir = normalize(mix(fallbackDir, tangent, blendW) + 1e-6);\n  return vec4(dir, A, packGrad(Gx, Gy));\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 = "// ── Medium id constants (mirror uniformBridge.ts MEDIUM_ID — the uMedium ladder) ──\n// The StrokeProfile selector dispatches on the medium id: oil,\n// van-Gogh, and oil-pastel each AUTHOR a first-class profile in profileFor.\n#define MEDIUM_OIL 3\n#define MEDIUM_CRAYON 4\n#define MEDIUM_VANGOGH 5\n#define MEDIUM_OILPASTEL 6\n\n// ── Crayon — DRY wax pigment on paper tooth (first-class medium, uMedium==4) ──\n// Crayon is not strokes. It's dry pigment crumbs dragged across paper tooth — the\n// DRY tooth-multiply model: anisotropic tooth noise multiplied into the base, a hard\n// SCUMBLE that lets the lower color show through the broken upper layer, and stable\n// OKLCh broken-color pigment patches. NO sheen, NO burnish film — that waxy gloss is\n// the OIL-PASTEL deposition's signature (mediumOilPastel), distinct from dry crayon\n// split. Crayon shares the substrate (the structure-tensor\n// orientation, the tooth noise, OKLCh brokenColorJitter), not the dispatch body.\nvec3 mediumCrayon(vec3 col, vec2 p, float t) {\n  // Orient the deposition along the structure-tensor edge-tangent (the bridge forces\n  // tensor for crayon, so read the tensor field directly).\n  vec2 flow = structureTensorField(p, t, flowField(p, t)).xy;\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 dry 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 tooth = 0.55 * t1 + 0.30 * t2 + 0.15 * t3;\n\n  // ── DRY TOOTH-MULTIPLY — the crayon multiplies the tooth relief into the base\n  // color (dark in the pits, bright on the ridges). The pressure (uStrokeAmount) sets\n  // how hard the multiply bites. This is the DRY model — no pigment build-up, no sheen.\n  float pressure = clamp(uStrokeAmount, 0.0, 1.0);\n  float bite = mix(0.18, 0.46, pressure);        // multiply strength\n  vec3 result = col * (1.0 - bite * (0.5 - tooth));\n\n  // ── HARD SCUMBLE — a broken upper layer that lets the lower color show through the\n  // gaps. A coarse mask gates a HARD (high-contrast) dragged pass so the dry crayon\n  // reads as broken pigment crumbs, not a smooth wash. Drag follows the tensor flow.\n  float scumbleMask = smoothstep(0.42, 0.78, vnoise(vec2(pr.x * scale * 0.55, pr.y * scale * 0.22) + 7.0));\n  float scumbleCoverage = scumbleMask * pressure * 0.7;     // hard broken upper layer\n  vec3 paper = col * mix(0.80, 0.94, pressure);             // the paper showing through\n  result = mix(paper, result, scumbleCoverage);\n\n  // ── Broken-color pigment: stable wax/pigment patches in OKLCh, 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  // Crayon is saturation-amplified (the wax chroma punch — but DRY, no sheen).\n  result = saturate3(result, 1.08);\n\n  return result;\n}\n\n// ── StrokeProfile — the oil-stroke parameter vector ────────────────────────\n// The SBR \"stroke = parameter vector\" canon (facet 11): the per-mode if-ladder knobs\n// become struct FIELDS — logic-as-DATA, not an imperative branch. profileFor(medium,\n// mode) populates the profile for a (medium, mode) pair; paintStrokeLayers(profile) runs\n// the four-layer bestOil/paintOver cascade off it. A new medium, such as van-Gogh or\n// oil-pastel, authors a profile entry; it never edits a monolith.\nstruct StrokeProfile {\n  int   shapeType;   // 0 tapered, 1 load-drag, 2 dab, 3 even, 4 comma/crescent\n  float bristleAmp;  // edge raggedness 0..0.5\n  float streakFreq;  // internal-streak spatial frequency\n  float streakAmp;   // internal-streak amplitude\n  float impastoAmp;  // paint-thickness contribution (the relight reads the height)\n  float hardness;    // edge-compositing crispness 0..1\n  float toothScale;  // canvas-tooth (linen weave) spatial frequency\n  float toothAmp;    // canvas-tooth amplitude\n  float pigmentSat;  // pigment saturation boost (OKLCh chroma scale)\n  float densityBig;  // layer-1 (big gestural) placement density gate\n  float densityMed;  // layer-2 (medium body) placement density gate\n  float densitySml;  // layer-3 (small dabs) placement density gate\n  float energyGrade; // SBR energy-grade magnitude (0 off; 1 the van-Gogh\n                     // Starry-Night length cascade). The energy grade is a PROFILE\n                     // field, NOT a buried uMedium==5 bestOil branch.\n  float impastoFloor;// Per-stroke height-crown floor (0.4 oil falloff;\n                     // 1.0 van-Gogh FULL-height crown so each dab catches its glint).\n  float densityFill; // Layer-4 fill-dab density. Oil/oil-pastel fill the\n                     // bald spots (0.95, full coverage); van-Gogh sets it LOW so the\n                     // sparse atomic dabs keep their visible inter-stroke ground gaps\n                     // (the atomicity read — a 0.95 fill would close every gap to a smear).\n  float groundFloor; // Bare-ground darken floor. The gaps between strokes\n                     // (low accumulated height) multiply toward this floor, so van-Gogh's\n                     // sparse atomic dabs read over a visibly darker underpainting (the\n                     // Starry-Night visible ground). Oil/oil-pastel keep 1.0 (no darken).\n};\n\n// The (medium, mode) -> StrokeProfile selector. The if-ladder's knobs are the profile's\n// fields; a new medium adds a CASE here (never an edit to a dispatch body). mode is the\n// uStrokeMode oil-stroke sub-mode (0 oil, 1 palette-knife, 3 brushwork). crayon\n// (uMedium==4) is a PEER tooth-multiply medium that never reaches the stroke cascade.\n// The painterly STROKE mediums are oil (MEDIUM_OIL), van-Gogh (MEDIUM_VANGOGH) and\n// oil-pastel (MEDIUM_OILPASTEL) — each AUTHORS its own profile entry below.\n" + Oe + "\n// The single parameterized four-layer stroke cascade. The four hand-unrolled\n// bestOil/paintOver invocations collapse into ONE body driven by the profile + the\n// uniform-derived per-layer scale/anisotropy multipliers (which are mode-INVARIANT — the\n// per-layer offsets, seeds, and len/wid muls are fixed across modes, so they stay here as\n// the cascade's structure; only the profile's knobs differentiate the medium). The\n// mode passes through for the two mode-special-cased shapes (knife layer-3 dabs +\n// layer-4 fill shape), which are placement details of the cascade, not profile knobs.\nvoid paintStrokeLayers(inout vec3 col, inout float height, StrokeProfile prof,\n                       int mode, vec2 p, float t) {\n  // Scales & multipliers from uniforms (mode-invariant cascade structure).\n  float baseScale = max(uStrokeScale * 0.006, 0.008);\n  // Three primary layers: big gestural, medium body, small dabs.\n  // The −5/3 radii respacing was measured and reverted, not\n  // silently struck). The φ-adjacent geometric candidate (2.4, 1.45, 0.87, a fixed\n  // ≈1.66× step) moved oil-pastel β −2.534 → −2.413 — TOWARD the −5/3 band but NOT into\n  // it (floor −1.85), so the keep-iff-into-band gate failed. The single-pass WebGL2 path\n  // is the true limiter (HC-aurora §5): the oil-pastel β + the oil/oil-pastel anisotropy\n  // residual stays the oil/oil-pastel stroke-cascade ceiling. The soft\n  // anisotropic-Kuwahara finish therefore remains the opt-in mediumKuwahara() body\n  // (uMedium==7) the consumer selects — NOT a re-tune of these oil/oil-pastel knobs. The\n  // hand-set 2.4, 1.1, 0.45 stays — it is van-Gogh's landed-band spacing.\n  float sBig = baseScale * 2.4;\n  float sMed = baseScale * 1.1;\n  float sSml = baseScale * 0.45;\n\n  // Strokes are elongated HARD (long·thin) so the rendered field reads strongly\n  // directional — the §4.2 structure-tensor anisotropy lift. A short fat dab is locally\n  // isotropic and drags the measured A down; a long thin stroke that hugs the tensor\n  // tangent is what gives Starry Night its A≈0.83. The width muls are pulled tighter to\n  // keep the long·thin aspect.\n  float lenMulBig = mix(3.0, 5.2, uStrokeAnisotropy);\n  float widMulBig = mix(0.42, 0.22, uStrokeAnisotropy);\n  float lenMulMed = mix(2.8, 4.8, uStrokeAnisotropy);\n  float widMulMed = mix(0.40, 0.21, uStrokeAnisotropy);\n  float lenMulSml = mix(2.2, 3.6, uStrokeAnisotropy);\n  float widMulSml = mix(0.36, 0.23, uStrokeAnisotropy);\n\n  float jitterAmt = 0.75;   // large jitter — no grid\n  vec2 flow = flowField(p, t);\n\n  // Layer 1 — big gestural strokes (sparse, shaping)\n  StrokeHit hBig = bestOil(p, sBig, lenMulBig, widMulBig, jitterAmt * 0.55,\n                           prof.densityBig, prof.shapeType, prof.bristleAmp, flow, t, 1.3,\n                           prof.energyGrade);\n  paintOver(col, height, hBig, prof.streakFreq * 0.7, prof.streakAmp,\n            uImpasto * prof.impastoAmp * uStrokeAmount, prof.hardness, 1.3, prof.impastoFloor);\n\n  // Layer 2 — medium body strokes\n  StrokeHit hMed = bestOil(p + vec2(11.3, 3.7), sMed, lenMulMed, widMulMed,\n                           jitterAmt, prof.densityMed, prof.shapeType, prof.bristleAmp, flow, t, 2.7,\n                           prof.energyGrade);\n  paintOver(col, height, hMed, prof.streakFreq, prof.streakAmp,\n            uImpasto * prof.impastoAmp * uStrokeAmount, prof.hardness, 2.7, prof.impastoFloor);\n\n  // Layer 3 — small strokes (more frequent, smaller). Even the knife layer-3 stays the\n  // medium's DIRECTIONAL shape, not a round dab — the round-dab sparkle was a fine-scale\n  // isotropic speckle that dragged the §4.2 anisotropy down + rolled the §4.3 slope shallow.\n  int smlShape = prof.shapeType;\n  StrokeHit hSml = bestOil(p + vec2(-5.1, 8.4), sSml, lenMulSml, widMulSml,\n                           jitterAmt * 0.9, prof.densitySml, smlShape,\n                           prof.bristleAmp * 0.85, flow, t, 4.1, prof.energyGrade);\n  paintOver(col, height, hSml, prof.streakFreq * 1.4, prof.streakAmp * 0.6,\n            uImpasto * prof.impastoAmp * 0.45 * uStrokeAmount, prof.hardness, 4.1, prof.impastoFloor);\n\n  // Layer 4 — fill strokes (dense, fine) — cover bald spots. The density is\n  // PROFILE-driven (prof.densityFill): oil/oil-pastel fill to full coverage; van-Gogh\n  // keeps it sparse so the bare-ground gaps between its atomic dabs survive. The fill is\n  // ELONGATED + flow-oriented (NOT a round dab) — a dense round-dab fill is locally\n  // isotropic and was the dominant §4.2 anisotropy sink; an oriented fine stroke keeps the\n  // fill directional so the whole field reads coherent.\n  float sFill = baseScale * 0.22;\n  float lenMulFill = mix(2.0, 3.2, uStrokeAnisotropy);\n  float widMulFill = mix(0.34, 0.24, uStrokeAnisotropy);\n  int fillShape = (mode == 1) ? 3 : prof.shapeType; // knife=even; others inherit the medium's directional shape\n  StrokeHit hFill = bestOil(p + vec2(3.9, -6.2), sFill, lenMulFill, widMulFill,\n                            jitterAmt * 0.8, prof.densityFill, fillShape,\n                            prof.bristleAmp * 0.6, flow, t, 8.9, prof.energyGrade);\n  // The fill is a low-relief, low-streak base coat — it covers bald spots WITHOUT adding\n  // fine bright speckle (a high-impasto/high-streak fill caught a per-dab glint that read\n  // as isotropic noise over the directional macro strokes — the §4.2/§4.3 sink). Its\n  // positional jitter is tamed too so the fill strokes stay flow-aligned, not scattered.\n  paintOver(col, height, hFill, prof.streakFreq * 1.2, prof.streakAmp * 0.35,\n            uImpasto * prof.impastoAmp * 0.18 * uStrokeAmount, prof.hardness * 0.9, 8.9, prof.impastoFloor);\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, prof.densityMed * 0.7, prof.shapeType, prof.bristleAmp, flow2, t, 6.5,\n                           prof.energyGrade);\n    paintOver(col, height, hX, prof.streakFreq, prof.streakAmp * 0.85,\n              uImpasto * prof.impastoAmp * 0.55 * uStrokeAmount, prof.hardness, 6.5, prof.impastoFloor);\n  }\n}\n\n// The shared stroke-medium substrate finish paints the four-layer\n// cascade off the profile, then canvas-tooth + relight + saturation. The three painterly\n// STROKE mediums (oil, van-Gogh, oil-pastel) each AUTHOR their own profile and call\n// this — the substrate is shared, the PROFILE (not a dispatch-body fork) differentiates\n// the medium. mode passes through for the cascade's mode-special-cased shapes.\nvec3 paintStrokeMedium(vec3 col, vec2 p, float t, StrokeProfile prof, int mode) {\n  vec3 result = col;\n  // 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  paintStrokeLayers(result, height, prof, mode, p, t);\n\n  // Canvas tooth — linen weave\n  float tooth1 = vnoise(p * prof.toothScale);\n  float tooth2 = vnoise(p * prof.toothScale * vec2(0.6, 2.4) + 37.0);\n  float tooth  = (0.6 * tooth1 + 0.4 * tooth2) - 0.5;\n  result *= 1.0 + tooth * prof.toothAmp * uCanvasGrain;\n\n  // 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 * prof.toothAmp * 0.5;\n  result = relightImpasto(result, height, canvasBase);\n\n  // Preserve visible ground. The bare-ground gaps (low accumulated stroke height)\n  // multiply toward prof.groundFloor, so van-Gogh's sparse atomic dabs read as separable\n  // marks over a darker underpainting (oil/oil-pastel keep groundFloor=1.0 → no-op). The\n  // smoothstep keeps the impasto dabs (high height) at full value; only the open ground\n  // between them darkens.\n  result *= mix(prof.groundFloor, 1.0, smoothstep(0.0, 0.38, height));\n\n  // Pigment saturation boost\n  result = saturate3(result, prof.pigmentSat);\n\n  return result;\n}\n\nvec3 mediumOil(vec3 col, vec2 p, float t) {\n  // The oil medium is a thin body: fetch the oil profile (mode-dispatched), paint via\n  // the shared stroke substrate. uStrokeMode: 0 oil (gestural), 1 knife, 3 brushwork.\n  int mode = uStrokeMode;\n  StrokeProfile prof = profileFor(MEDIUM_OIL, mode);\n  return paintStrokeMedium(col, p, t, prof, mode);\n}\n\n#define MEDIUM_KUWAHARA 7\n\n// ── Kuwahara — anisotropic generalized painterly finish (uMedium==7) ───────\n// The SOTA edge-preserving painterly smoothing: the generalized/anisotropic Kuwahara of\n// Kyprianidis 2010, the SOFT polynomial-weighted variant (NOT the pre-2010 hard argmin,\n// which BANDS the flat field into an 8-spoke pinwheel — the §4.2 anti-regression). Aurora\n// is a PROCEDURAL field (no input texture), so the operator runs over sampleBase() directly:\n// an elliptical kernel oriented along the structure tensor (elongated along the edge-tangent,\n// narrowed by the anisotropy), divided into 8 overlapping sectors via smooth weights; the\n// output is the variance-weighted blend of the sector means (1/(1+var^q) — low-variance\n// sectors dominate, the SOFT criterion → flat oil-paint patches with crisp zone boundaries).\n// Single-pass small-radius WebGL2 form: 4 rings × 8 angular taps = 32 procedural samples\n// (cost-bounded; the offscreen-park, PRM freeze the substrate owns is untouched).\nvec3 mediumKuwahara(vec3 col, vec2 p, float t) {\n  // Orient the kernel along the structure-tensor edge-tangent + read the coherence A\n  // (the field widened vec3→vec4 for metal's gradient; Kuwahara reads only .xy/.z).\n  vec4 stf = structureTensorField(p, t, flowField(p, t));\n  vec2 tangent = stf.xy;\n  float A = stf.z;\n  // The ellipse axes: major along the tangent, minor across. Anisotropy squeezes the\n  // minor axis (coherent zones → long-thin patch along the colour band; flat zones →\n  // near-circular so the operator degrades gracefully to the isotropic Kuwahara). The\n  // base radius rides uStrokeScale so the painterly patch size tracks the studio knob.\n  float radius = clamp(0.010 + uStrokeScale * 0.00018, 0.006, 0.024);\n  float aniso = mix(1.0, 0.34, clamp(A, 0.0, 1.0)); // minor/major axis ratio\n  vec2 ax = tangent;                  // major-axis unit vector (edge-tangent)\n  vec2 ay = vec2(-tangent.y, tangent.x); // minor-axis unit vector (edge-normal)\n\n  // 8 sectors, soft polynomial weights. Each sector i centers on angle i·45°; a sample's\n  // sector weight is a smooth gaussian-of-angular-distance so sectors OVERLAP (no hard\n  // argmin → no pinwheel banding). The center sample seeds all sectors equally.\n  const int SECTORS = 8;\n  vec3  m[8];   // per-sector weighted colour sum\n  vec3  s[8];   // per-sector weighted colour² sum (for variance)\n  float w[8];   // per-sector weight sum\n  for (int i = 0; i < SECTORS; i++) { m[i] = vec3(0.0); s[i] = vec3(0.0); w[i] = 0.0; }\n\n  // 4 rings × 8 angular taps over the elliptical disc. Each tap: sample the procedural\n  // field, then deposit into the sectors by the soft angular weight × the radial falloff.\n  const int RINGS = 4;\n  const int TAPS  = 8;\n  for (int r = 1; r <= RINGS; r++) {\n    float rr = float(r) / float(RINGS);          // 0.25 .. 1.0\n    float radial = 1.0 - 0.6 * rr;               // inner taps weigh more (gaussian-ish)\n    for (int a = 0; a < TAPS; a++) {\n      float ang = 6.2831853 * float(a) / float(TAPS);\n      // Elliptical offset: major axis full radius, minor axis squeezed by aniso.\n      vec2 dirE = ax * cos(ang) + ay * (sin(ang) * aniso);\n      vec2 off  = dirE * (radius * rr);\n      vec3 c = sampleBase(p + off, t);\n      // The sample's angular bin (its sector) — soft, so it spills into neighbours.\n      for (int k = 0; k < SECTORS; k++) {\n        float sectorAng = 6.2831853 * float(k) / float(SECTORS);\n        // Smallest signed angular distance to the sector center.\n        float d = ang - sectorAng;\n        d = atan(sin(d), cos(d));                 // wrap to [-π, π]\n        float sw = exp(-d * d * 2.2) * radial;    // gaussian angular weight × radial\n        m[k] += c * sw;\n        s[k] += c * c * sw;\n        w[k] += sw;\n      }\n    }\n  }\n\n  // Per-sector mean + scalar luma-variance, then the SOFT variance-weighted blend.\n  vec3  accum = vec3(0.0);\n  float accumW = 0.0;\n  for (int k = 0; k < SECTORS; k++) {\n    float wk = max(w[k], 1e-4);\n    vec3  mean = m[k] / wk;\n    vec3  var3 = max(s[k] / wk - mean * mean, vec3(0.0));\n    float variance = dot(var3, W_LUMA);           // perceptual scalar variance\n    // SOFT criterion: low-variance sectors (flat, inside a colour zone) dominate; a\n    // high-variance sector (straddling an edge) is suppressed. q controls the sharpness;\n    // a finite q (not argmin) keeps the blend continuous → no pinwheel spoke.\n    float sectorW = 1.0 / (1.0 + pow(variance * 320.0, 4.0));\n    accum  += mean * sectorW;\n    accumW += sectorW;\n  }\n  vec3 result = accum / max(accumW, 1e-4);\n\n  // The center sample anchors the result in near-flat zones (where every sector reads the\n  // same colour) so the operator is a no-op there — the smoothing only BITES at edges.\n  vec3 center = sampleBase(p, t);\n  result = mix(center, result, clamp(0.35 + 0.65 * A, 0.0, 1.0));\n\n  // A faint canvas tooth + pigment-saturation lift so the flattened patches read as\n  // oil-paint, not a posterized blur (the painterly identity the smoothing alone lacks).\n  float tooth = vnoise(p * 300.0) - 0.5;\n  result *= 1.0 + tooth * 0.06 * uCanvasGrain;\n  result = saturate3(result, 1.04);\n\n  // Blend toward the incoming col by uStrokeAmount so the studio amount knob controls\n  // the finish strength (uStrokeAmount=0 → the raw field passes through; default → full).\n  return mix(col, result, clamp(uStrokeAmount, 0.0, 1.0));\n}\n\n" + Ae + De + "// The oil-pastel medium (uMedium==6) is a distinct stroke-deposition body,\n// separate from the dry-crayon tooth-multiply (mediumCrayon). It DEPOSITS\n// broad smeared directional strokes via the same brush engine with a creamy soft\n// hardness, heavy pigment build-up where strokes overlap, and a chroma punch — the\n// stroke-deposition model that gives oil-pastel its depth and less-uniform read.\n// Shares the SUBSTRATE (the stroke cascade + tooth + relight) with oil/van-Gogh, NOT\n// the dispatch body of dry crayon. The bridge forces tensor orientation.\nvec3 mediumOilPastel(vec3 col, vec2 p, float t) {\n  StrokeProfile prof = profileFor(MEDIUM_OILPASTEL, 0);\n  return paintStrokeMedium(col, p, t, prof, 0);\n}", L = "\n", Ne = `#version 300 es
 precision highp float;
 
 in vec2 vUv;
 out vec4 fragColor;
 
-#define MAX_NUCLEI 6
+#define MAX_NUCLEI 8
 #define MAX_STOPS  8
 
 // ── Uniforms ───────────────────────────────────────────────────────────────
@@ -36,7 +143,7 @@ uniform float uNucleiValueBias[MAX_NUCLEI];
 uniform float uNucleiDriftRadius[MAX_NUCLEI];
 uniform float uNucleiDriftPhase[MAX_NUCLEI];
 // Anisotropy: per-nucleus elongation (1.0 = isotropic) and major-axis angle (radians).
-// Defaults (1.0 / 0.0) reduce to the original circular Gaussian.
+// Defaults (1.0, 0.0) reduce to the original circular Gaussian.
 uniform float uNucleiElong[MAX_NUCLEI];
 uniform float uNucleiAngle[MAX_NUCLEI];
 uniform float uSoftmaxBeta;
@@ -46,37 +153,31 @@ uniform float uValueVariance;
 uniform float uWarpAmount;
 uniform float uWarpScale;
 uniform float uWarpDrift;
-uniform int   uWarpMode;      // 0=fbm 1=cellular 2=hybrid 3=curl (BB.B1 — opt-in Bridson flow warp)
+uniform int   uWarpMode;      // 0=fbm 1=cellular 2=hybrid 3=curl (opt-in Bridson flow warp)
 uniform int   uNoiseOctaves;
 
 // Medium
 // 0 smooth, 1 pastel, 2 watercolor, 3 oil, 4 crayon (peer medium — wax pigment
 // on paper tooth; NOT an oil-stroke sub-mode, so it dispatches at main() level).
 uniform int   uMedium;
-// Hue-arc method for the OKLCh palette interpolation (W5). Mirrors value.js's
+// Hue-arc method for OKLCh palette interpolation. 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 int   uFlowPattern;   // 0 none, 1 radial, 2 swirl, 3 diagonal, 4 multi, 5 tensor/ETF
 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
+// 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;
@@ -85,17 +186,16 @@ uniform float uImpasto;
 uniform float uBrokenColor;
 uniform float uCanvasGrain;
 
-// BG.W-AUR-METAL-FINISH — the metal-medium knobs (uMedium==8/9). uMetalPolish scales
+// Metal-medium knobs (uMedium==8/9). uMetalPolish scales
 // the specular catch intensity; uMetalHeightScale scales the luma-relief → normal tilt.
 // On the WGSL primary these ride the free cursor.z/.w pad lanes (uniformBridgeWGPU); the
-// .frag carries them as their own uniforms. Written 0 on a non-metal config → no-op.
+// The fragment shader carries them as uniforms. Non-metal configs write 0.
 uniform float uMetalPolish;
 uniform float uMetalHeightScale;
 
-// AW.W4.2 — the impasto relight axis. A movable directional source lighting the
+// The impasto relight axis is 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.
+// The cursor drives uLightDir; the upper-left default supplies the still pose.
 uniform vec3  uLightDir;    // unit direction (x,y in screen space, z toward viewer)
 uniform vec3  uLightColor;  // warm-white tint (linear)
 
@@ -110,7 +210,7 @@ uniform float uSaturation;
 uniform float uPaperGrain;
 uniform float uAlpha;
 
-// BD.W-AUR-VIVIDNESS — the §3 chroma-floor strength (0 = off / pre-floor identity,
+// Chroma-floor strength (0 = off,
 // 1 = the vivid default). The shader lifts any pale zone's OKLab chroma toward
 // uVividness * VIVID_TARGET, hue-preserving, warm-anchored below the near-gray epsilon.
 uniform float uVividness;
@@ -120,7 +220,7 @@ uniform float uVividness;
 // human-friendly 0..~0.05 band — that scale is what the config schema and every
 // demo preset are tuned against. But that band, multiplied straight into uTime
 // (seconds), yields rad/sec rates so small the field reads visually static (one
-// nuclei orbit took ~10 min at the old default). These K_* constants decouple
+// nuclei orbit would otherwise take minutes). These K_* constants decouple
 // the AUTHORING scale from the RAD/SEC scale: each time term wraps its coefficient
 // in the matching K_, lifting the same authored value to a perceptible period
 // without touching any preset. Tuned so the field reads SLOWLY ALIVE — drift over
@@ -155,10 +255,10 @@ float vnoise(vec2 p) {
   return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);
 }
 
-// The rotated-octave FBM rotation constant — spliced from the shared chunk (AV.W2
-// — the one FBM_ROT). The loop below stays aurora-local (2.02 lacunarity +
+// The rotated-octave FBM rotation constant is spliced from the shared chunk
+// as the sole FBM_ROT. The loop below stays aurora-local (2.02 lacunarity +
 // uniform-driven octaves, per §3a — only the rotation constant converges).
-${ee}
+${p}
 
 float fbm(vec2 p) {
   float v = 0.0;
@@ -172,52 +272,51 @@ float fbm(vec2 p) {
   return v;
 }
 
-// BB.B1 — the shared curl-noise flow chunk (curlFBM), spliced from the single source
-// procedural surfaces share (the AV.W2 shared-chunk precedent, applied to FLOW). The
+// The shared curl-noise flow chunk (curlFBM) is spliced from the single source
+// procedural surfaces share (the shared-chunk precedent, applied to FLOW). The
 // chunk owns ONLY the basis-agnostic curl operator; the host owns the noise basis —
 // aurora wraps its OWN fbm as the scalar potential (so curl rides the same 2.02-
 // lacunarity loop the rest of the warp uses). The curl operator is consumed ONLY on
 // the OPT-IN warpMode == "curl" branch (uWarpMode == 3) — the default warp paths are
 // byte-untouched (no curl call), so every existing aurora gate stays byte-equivalent.
-${te}
+${Se}
 
 // The scalar fbm potential ψ for curlFBM — aurora's own fbm. The splice above
 // forward-declares potentialFBM; this defines it (ES 3.00 allows the prototype).
 float potentialFBM(vec2 p) { return fbm(p); }
 
-// AX.W12 — the painterly-medium organic noise basis (Jarzynski PCG2D integer-bit hash
+// The painterly-medium organic noise basis (Jarzynski PCG2D integer-bit hash
 // + 2D simplex gradient noise), SPLICED from the shared procedural-color chunk (the
 // single hash source).
 // The painterly mediums (mediumOil's tooth/granulation) opt into pcgHash2/gnoise for
 // organic paper/pigment grain; the smooth/atmospheric pole KEEPS its cheap value-noise
-// fbm above (the cost-tiering is preserved per AX.W12 §3a — this is an ADDITIVE basis,
+// fbm above (the cost tiering is preserved: this is an additive basis,
 // not a blanket upgrade). The aurora-local hash21/vnoise/fbm loop stays (legitimately
 // divergent per the chunk's §3a).
-${_}
+${v}
 
-// The sRGB OETF (linearToSrgb) — spliced from the shared procedural-color chunk
-// (AV.W2 — the single OETF source; the AV.W1 local copy is deleted here). Aurora's
-// linear pipeline closes the seam with this transfer before fragColor (the
-// proof:aurora-space-gamma seam).
-${m}
+// The sRGB OETF (linearToSrgb) is spliced from the shared procedural-color chunk,
+// the sole OETF source; the local copy is deleted here. Aurora's linear pipeline
+// closes the color-space seam with this transfer before fragColor.
+${b}
 
-// W5 — the four Ottosson OKLab/OKLCh matrices + their space fns, spliced from the
+// 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;
-${h}
+${C}
 
-// ── OKLCh palette ramp (W5 interp · AX.W11 single-sourced twin) ───────────────
+// ── OKLCh palette ramp (single-sourced twin) ───────────────────────────────
 // 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 (deliberate rainbow travel via
 // uHuePath increasing/decreasing) sweeps the hue wheel without flipping.
 //
-// AX.W11 — the ramp (interpolateHueTurns + mixPaletteOklab + mixPaletteOklchArc +
+// The ramp (interpolateHueTurns + mixPaletteOklab + mixPaletteOklchArc +
 // the smoothstep-eased samplePaletteRamp dispatcher) is SPLICED from the shared
 // procedural-color chunk (the single ramp source). composition.glsl.ts's
 // samplePalette calls samplePaletteRamp.
-${b}
+${m}
 
 // 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
@@ -226,7 +325,7 @@ float ign(vec2 p) {
     return fract(52.9829189 * fract(dot(p, vec2(0.06711056, 0.00583715))));
 }
 
-// Cellular / Worley f1
+// Cellular, Worley f1
 float cellular(vec2 p) {
   vec2 i = floor(p);
   vec2 f = fract(p);
@@ -262,7 +361,7 @@ vec2 domainWarp(vec2 p, float t) {
     float c2 = cellular(p * uWarpScale * 1.2 + vec2(11.0, 7.0));
     warp = mix(r, vec2(c1, c2), 0.5);
   } else if (uWarpMode == 3) {
-    // BB.B1 — curl (Bridson flow warp). The divergence-free curl of an fbm potential
+    // Curl (Bridson flow warp). The divergence-free curl of an fbm potential
     // advects the field along a source-free swirl — folds + stretches like fluid
     // advection, never the source-y bulge a raw fbm gradient produces. The potential
     // scrolls on the same warp-drift clock; curlFBM is the shared chunk's operator.
@@ -293,13 +392,13 @@ vec2 domainWarp(vec2 p, float t) {
   return warped;
 }
 
-` + Se + A + Ce + 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// BD.W-AUR-VIVIDNESS — the §3 chroma FLOOR. Operate in OKLab: lightness + hue are\n// untouched, chroma is lifted toward the floor. A pale zone BLOOMS to transmission-fit;\n// a vivid zone (already above the floor) is byte-untouched. The near-gray hue guard is\n// STRUCTURAL: below VIVID_EPS the (a,b) direction is precision noise, so the lift\n// synthesizes along the WARM anchor (amber, both components positive) — NEVER the noisy\n// near-zero vector, NEVER a cold/teal hue. uVividness:0 returns c identically (the gated\n// byte-identity opt-out). Mode factor: a dark route lifts the floor a touch (a dim field\n// needs more chroma to read vivid through glass) — derived from the field's own L.\nconst float VIVID_TARGET = 0.115;\nconst float VIVID_EPS = 0.012;\n// The warm amber anchor in OKLab (a,b): OKLCh hue 70°, unit chroma. cos/sin(70°) — both\n// POSITIVE (warm yellow-orange). The near-gray fallback direction, the warm-floor law.\nconst vec2 VIVID_WARM_ANCHOR = vec2(0.34202, 0.93969);\nvec3 vividnessFloor(vec3 c) {\n  if (uVividness <= 0.0001) return c;\n  vec3 lab = linOklab(c);\n  float C = length(lab.yz);\n  // Mode-aware: dim fields (low L) get a slightly higher target so they read vivid\n  // through glass. mix factor is gentle (1.0 .. 1.18) so light routes are unaffected.\n  float modeLift = mix(1.18, 1.0, clamp(lab.x * 1.4, 0.0, 1.0));\n  float Cmin = uVividness * VIVID_TARGET * modeLift;\n  vec2 hueDir = (C > VIVID_EPS) ? lab.yz / C : VIVID_WARM_ANCHOR;\n  lab.yz = hueDir * max(C, Cmin);\n  return max(oklabToLinearSrgb(lab), vec3(0.0));\n}\n\n" + we + A + Ae + A + Te + A + je + 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 dispatch (AX.W13 — each is a FIRST-CLASS body, no shared dispatch):\n  //   1 pastel · 2 watercolor · 3 oil · 4 crayon (DRY tooth-multiply) ·\n  //   5 van-Gogh (atomic comma/crescent dabs) · 6 oil-pastel (stroke deposition) ·\n  //   7 kuwahara (anisotropic-Kuwahara edge-preserving painterly finish — BB.W-AUR-KUWAHARA).\n  // van-Gogh is no longer a mediumOil passthrough; oil-pastel and crayon no longer\n  // share a body — they share the SUBSTRATE (the tooth/placement helpers), not the\n  // dispatch body (slice 8 F0/F1). Kuwahara is OPT-IN (default-off — no preset selects\n  // it unless a config explicitly sets medium:\"kuwahara\"); the smooth default + the\n  // van-Gogh HERO + the existing painterly bodies are byte-unchanged by its addition.\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 = mediumOilPastel(col, pN, t);\n  else if (uMedium == 7) col = mediumKuwahara(col, pN, t);\n  // BG.W-AUR-METAL-FINISH — the mutually-exclusive metal mediums (opt-in, uMedium==8/9;\n  // the smooth default + every existing medium are byte-unchanged by these arms).\n  else if (uMedium == 8) col = mediumMetal(col, pN, t);\n  else if (uMedium == 9) col = mediumMetalGradient(col, pN, t);\n\n  // Saturation trim\n  col = saturate3(col, uSaturation);\n\n  // BD.W-AUR-VIVIDNESS — the §3 chroma floor (warm-anchored, hue-preserving). Lifts a\n  // pale zone toward the transmissive floor so warm glass over the field reads\n  // transmissive-not-gray; a vivid zone is untouched; uVividness:0 is a no-op.\n  col = vividnessFloor(col);\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", Ne = `#version 300 es
+` + Ce + L + we + "\n// ── Color utils (OKLCh; 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 — 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). Van-Gogh and oil-pastel consume\n// this seam for per-stroke pigment jitter.\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 — 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// The chroma floor operates in OKLab: lightness + hue are\n// untouched, chroma is lifted toward the floor. A pale zone BLOOMS to transmission-fit;\n// a vivid zone (already above the floor) is byte-untouched. The near-gray hue guard is\n// STRUCTURAL: below VIVID_EPS the (a,b) direction is precision noise, so the lift\n// synthesizes along the WARM anchor (amber, both components positive) — NEVER the noisy\n// near-zero vector, NEVER a cold/teal hue. uVividness:0 returns c identically (the gated\n// byte-identity opt-out). Mode factor: a dark route lifts the floor a touch (a dim field\n// needs more chroma to read vivid through glass) — derived from the field's own L.\nconst float VIVID_TARGET = 0.115;\nconst float VIVID_EPS = 0.012;\n// The warm amber anchor in OKLab (a,b): OKLCh hue 70°, unit chroma. cos/sin(70°) — both\n// POSITIVE (warm yellow-orange). The near-gray fallback direction, the warm-floor law.\nconst vec2 VIVID_WARM_ANCHOR = vec2(0.34202, 0.93969);\nvec3 vividnessFloor(vec3 c) {\n  if (uVividness <= 0.0001) return c;\n  vec3 lab = linOklab(c);\n  float C = length(lab.yz);\n  // Mode-aware: dim fields (low L) get a slightly higher target so they read vivid\n  // through glass. The mix factor is gentle (1.0–1.18) so light routes are unaffected.\n  float modeLift = mix(1.18, 1.0, clamp(lab.x * 1.4, 0.0, 1.0));\n  float Cmin = uVividness * VIVID_TARGET * modeLift;\n  vec2 hueDir = (C > VIVID_EPS) ? lab.yz / C : VIVID_WARM_ANCHOR;\n  lab.yz = hueDir * max(C, Cmin);\n  return max(oklabToLinearSrgb(lab), vec3(0.0));\n}\n\n" + Te + L + je + L + Ee + L + Me + "\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 dispatch: each is a first-class body with no shared dispatch.\n  //   1 pastel · 2 watercolor · 3 oil · 4 crayon (DRY tooth-multiply) ·\n  //   5 van-Gogh (atomic comma/crescent dabs) · 6 oil-pastel (stroke deposition) ·\n  //   7 kuwahara (anisotropic-Kuwahara edge-preserving painterly finish).\n  // van-Gogh is no longer a mediumOil passthrough; oil-pastel and crayon no longer\n  // share a body — they share the SUBSTRATE (the tooth/placement helpers), not the\n  // dispatch body. Kuwahara is OPT-IN (default-off — no preset selects\n  // it unless a config explicitly sets medium:\"kuwahara\"); the smooth default + the\n  // van-Gogh HERO + the existing painterly bodies are byte-unchanged by its addition.\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 = mediumOilPastel(col, pN, t);\n  else if (uMedium == 7) col = mediumKuwahara(col, pN, t);\n  // The mutually exclusive metal mediums are opt-in at uMedium==8/9;\n  // the smooth default + every existing medium are byte-unchanged by these arms).\n  else if (uMedium == 8) col = mediumMetal(col, pN, t);\n  else if (uMedium == 9) col = mediumMetalGradient(col, pN, t);\n\n  // Cursor-local luminance lean. Position, radius, and the CPU-folded strength are the\n  // same four packed values on WebGL2 and WebGPU; absent interactivity writes strength 0.\n  vec2 cursorDelta = pN - uCursor;\n  float cursorRadius = max(uCursorRadius, 0.01);\n  float cursorLean = exp(-dot(cursorDelta, cursorDelta) / (cursorRadius * cursorRadius * 0.5));\n  col *= 1.0 + 0.12 * cursorLean * uCursorStrength;\n\n  // Saturation trim\n  col = saturate3(col, uSaturation);\n\n  // The chroma floor is warm-anchored and hue-preserving. It lifts a\n  // pale zone toward the transmissive floor so warm glass over the field reads\n  // transmissive-not-gray; a vivid zone is untouched; uVividness:0 is a no-op.\n  col = vividnessFloor(col);\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", Pe = `#version 300 es
 precision highp float;
 
 in vec2 vUv;
 out vec4 fragColor;
 
-#define MAX_NUCLEI 6
+#define MAX_NUCLEI 8
 #define BLUR_RINGS 3
 #define BLUR_SECTORS 8
 const float PI = 3.141592653589793;
@@ -358,7 +457,7 @@ float vnoise(vec2 p) {
   float d = hash21(i + vec2(1.0, 1.0));
   return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);
 }
-${ee}
+${p}
 float fbm(vec2 p) {
   float v = 0.0;
   float a = 0.5;
@@ -375,8 +474,8 @@ float ign(vec2 p) {
   return fract(52.9829189 * fract(dot(p, vec2(0.06711056, 0.00583715))));
 }
 
-${m}
-${h}
+${b}
+${C}
 
 // linear-sRGB → raw OKLab (the vividnessFloor helper — mirrors aurora.frag's linOklab).
 vec3 linOklab(vec3 lin) {
@@ -512,6 +611,11 @@ void main() {
   float radius = mix(uBlurMin, uBlurMax, zone);
   vec3 col = zoneBlur(uv, radius);
 
+  vec2 cursorDelta = uv - uCursor;
+  float cursorRadius = max(uCursorRadius, 0.01);
+  float cursorLean = exp(-dot(cursorDelta, cursorDelta) / (cursorRadius * cursorRadius * 0.5));
+  col *= 1.0 + 0.12 * cursorLean * uCursorStrength;
+
   // Saturation trim + the source-agnostic vividness floor (a washed photo blooms).
   col = saturate3(col, uSaturation);
   col = vividnessFloor(col);
@@ -529,147 +633,59 @@ void main() {
   // Premultiply on display-space color (matches the palette path: OETF, then premul).
   fragColor = vec4(col * uAlpha, uAlpha);
 }
-`, Pe = {
-	premultiplyAlpha: "none",
-	colorSpaceConversion: "none"
-};
-function Fe(e) {
-	return createImageBitmap(e, Pe);
-}
-async function Ie(e) {
-	return typeof e == "string" ? Fe(await (await fetch(e)).blob()) : e instanceof Blob ? Fe(e) : e;
-}
-function Le() {
-	let e = new ImageData(1, 1);
-	return e.data.set([
-		128,
-		128,
-		128,
-		255
-	]), e;
-}
-function Re(e) {
-	return e instanceof HTMLImageElement ? {
-		width: e.naturalWidth,
-		height: e.naturalHeight
-	} : {
-		width: e.width,
-		height: e.height
+`, R = .001, Fe = 1e-4;
+function z(e, t, i) {
+	let a = n(e);
+	if (i > 0) {
+		let t = e.acceleration.value, n = e.velocity.value, r = -(t.x * n.x + t.y * n.y);
+		r > 0 && (a.burst = Math.min(1, a.burst + r * 3));
+	}
+	let o = r(a, t);
+	return {
+		x: o.cx,
+		y: o.cy,
+		strength: o.strength,
+		radius: o.radius
 	};
 }
-function ze(e, t, n = {}) {
-	let { linearFilter: r = !0, clampToEdge: i = !0 } = n, a = e.createTexture();
-	e.bindTexture(e.TEXTURE_2D, a), e.pixelStorei(e.UNPACK_PREMULTIPLY_ALPHA_WEBGL, !1), e.pixelStorei(e.UNPACK_COLORSPACE_CONVERSION_WEBGL, e.NONE), e.pixelStorei(e.UNPACK_FLIP_Y_WEBGL, !1), e.texImage2D(e.TEXTURE_2D, 0, e.RGBA, e.RGBA, e.UNSIGNED_BYTE, t);
-	let o = r ? e.LINEAR : e.NEAREST;
-	e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MIN_FILTER, o), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MAG_FILTER, o);
-	let s = i ? e.CLAMP_TO_EDGE : e.REPEAT;
-	return e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_S, s), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_T, s), e.pixelStorei(e.UNPACK_COLORSPACE_CONVERSION_WEBGL, e.BROWSER_DEFAULT_WEBGL), a;
+function B(e) {
+	let t = e.attractorVelocity.value;
+	return e.engagement.value > R || e.speed.value > R || e.burst.value > R || Math.hypot(t.x, t.y) > Fe;
 }
-var Be = 2;
-function Ve(e, t) {
-	let { width: n, height: r } = Re(t), i = e.createTexture({
-		label: "[texture-upload] image",
-		size: [
-			n,
-			r,
-			1
-		],
-		format: "rgba8unorm",
-		usage: Be | 20
-	});
-	return e.queue.copyExternalImageToTexture({
-		source: t,
-		flipY: !1
-	}, {
-		texture: i,
-		premultipliedAlpha: !1
-	}, [
-		n,
-		r,
-		1
-	]), {
-		texture: i,
-		width: n,
-		height: r
+function Ie(e) {
+	let { gl: t, prog: n, uniforms: r, pointerField: i, getCursorScalars: a, getConfig: o, getReducedMotion: s, getRenderTime: c } = e, l = (e) => 1 - e, u = null, d = {
+		x: .5,
+		y: .5,
+		strength: 0,
+		radius: .25
 	};
-}
-//#endregion
-//#region src/components/aurora/composables/auroraImageSource.ts
-function He(e) {
-	let t = null, n = null, r;
-	return {
-		getDecodedImage: () => t,
-		setImageUploader(e) {
-			n = e, e && t && e(t);
-		},
-		ensureDecoded(i) {
-			i.source !== "image" || i.src == null || i.src !== r && (r = i.src, Ie(i.src).then((r) => {
-				t = r, n?.(r), e.wake();
-			}).catch((t) => {
-				e.onError?.(t instanceof Error ? t : Error(String(t)));
-			}));
+	function f() {
+		return +!s();
+	}
+	function p(e) {
+		let i = c(e);
+		if (t.useProgram(n), t.uniform2f(r.uCursor, d.x, l(d.y)), t.uniform1f(r.uCursorStrength, d.strength), t.uniform1f(r.uCursorRadius, d.radius), t.uniform1f(r.uTime, i), o().interactivity?.light) {
+			let e = f(), n = i * .25, a = Math.cos(n) * .5, o = Math.sin(n) * .5, s = (d.x - .5) * 2, c = (.5 - d.y) * 2, l = d.strength * e;
+			a = a * (1 - l) + s * l, o = o * (1 - l) + c * l, t.uniform3f(r.uLightDir, a * e + (1 - e) * -.5, o * e + (1 - e) * .6, .62);
 		}
-	};
-}
-function Ue(e, t, n) {
-	let r = null;
-	e.activeTexture(e.TEXTURE0);
-	let i = (n) => {
-		e.useProgram(t), e.activeTexture(e.TEXTURE0), r && e.deleteTexture(r), r = ze(e, n);
-	};
-	return i(n.getDecodedImage() ?? Le()), n.setImageUploader(i), () => {
-		r && e.deleteTexture(r), n.setImageUploader(null);
-	};
-}
-//#endregion
-//#region src/components/aurora/constants/renderMode.ts
-function j() {
-	let e;
-	try {
-		e = y();
-	} catch {
-		return !1;
+		t.clear(t.COLOR_BUFFER_BIT), t.drawArrays(t.TRIANGLES, 0, 3);
+	}
+	function m() {
+		if (s()) return !1;
+		let e = o();
+		return e.nucleiDrift !== 0 || e.paletteDrift !== 0 || e.breathDepth !== 0 || e.warpDrift !== 0 || B(i);
 	}
-	return e === null ? !1 : e.includes("swiftshader") || e.includes("llvmpipe") || e.includes("software") || e.includes("basic render") || e.includes("microsoft basic");
-}
-function M(e, t = {}) {
-	return e !== "css" && !t.forceWebGLUnderSoftwareRaster && j() ? "css" : e === "auto" ? "webgl" : e;
-}
-//#endregion
-//#region src/components/aurora/composables/glSetup.ts
-var N = "[Aurora]", We = /* @__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.uMetalPolish.uMetalHeightScale.uNucleiDrift.uPaletteDrift.uBreathDepth.uBreathPeriod.uSaturation.uPaperGrain.uAlpha.uVividness.uImage.uBlurMin.uBlurMax.uImageAspect".split(".");
-function Ge(e, t, n) {
-	let r = ae(e, e.VERTEX_SHADER, t, N), i = ae(e, e.FRAGMENT_SHADER, n, N), a = ie(e, r, i, N);
-	e.useProgram(a);
-	let o = e.createVertexArray();
-	e.bindVertexArray(o);
-	let s = e.createBuffer();
-	e.bindBuffer(e.ARRAY_BUFFER, s), e.bufferData(e.ARRAY_BUFFER, new Float32Array([
-		-1,
-		-1,
-		3,
-		-1,
-		-1,
-		3
-	]), e.STATIC_DRAW);
-	let c = e.getAttribLocation(a, "aPos");
-	e.enableVertexAttribArray(c), e.vertexAttribPointer(c, 2, e.FLOAT, !1, 0, 0);
-	let l = {};
-	for (let t of We) l[t] = e.getUniformLocation(a, t);
 	return {
-		program: a,
-		vs: r,
-		fs: i,
-		uniforms: l,
-		geometry: {
-			vao: o,
-			buf: s
-		}
+		frame: (e) => {
+			let t = f(), n = u === null ? 0 : Math.max(0, (e - u) * 1e3);
+			u = e, i.tick(t === 0 ? 0 : n), d = z(i, a(), t), p(e);
+		},
+		needsAnimation: m
 	};
 }
 //#endregion
 //#region src/components/aurora/constants/presets.ts
-var Ke = 6, qe = 8, Je = 1, Ye = .115, Xe = .004, Ze = .06, P = {
+var Le = 8, Re = 8, ze = 1, Be = .115, Ve = .004, He = .06, V = {
 	palette: [
 		{
 			L: .64,
@@ -737,7 +753,7 @@ var Ke = 6, qe = 8, Je = 1, Ye = .115, Xe = .004, Ze = .06, P = {
 	paperGrain: .008,
 	alpha: 1,
 	vividness: 1
-}, Qe = {
+}, Ue = {
 	medium: "crayon",
 	strokeOrient: "tensor",
 	granulation: .3,
@@ -753,64 +769,63 @@ var Ke = 6, qe = 8, Je = 1, Ye = .115, Xe = .004, Ze = .06, P = {
 };
 //#endregion
 //#region src/components/aurora/composables/color.ts
-function F(e, t = 8, n) {
+function H(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] = d(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 $e(e) {
+function We(e) {
 	if (e.length === 0) return "transparent";
-	if (e.length === 1) return l(e[0]);
+	if (e.length === 1) return u(e[0]);
 	let t = e.length;
 	return `linear-gradient(135deg, ${e.map((e, n) => {
 		let r = Math.round(n / (t - 1) * 100);
-		return `${l(e)} ${r}%`;
+		return `${u(e)} ${r}%`;
 	}).join(", ")})`;
 }
-function et(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] = be(n / 255, r / 255, i / 255), [c, l, u] = ve(a, o, s);
-	return {
-		L: c,
-		C: l,
-		h: u
-	};
+function Ge(e) {
+	return s(e);
 }
-var tt = [.35, .95], nt = [.18, .42];
-function rt(e, t) {
-	return e ? [Math.max(0, Math.min(1, e[0])), Math.max(0, Math.min(1, e[1]))] : t === "dark" ? nt : tt;
+var Ke = [.35, .95], qe = [.18, .42];
+function Je(e, t) {
+	return e ? [Math.max(0, Math.min(1, e[0])), Math.max(0, Math.min(1, e[1]))] : t === "dark" ? qe : Ke;
 }
-function I(e, t = {}) {
-	let n = typeof e == "string" ? o(e) : e, { stopCount: r = 4, harmony: i = "analogous", lightnessSpread: a = .32, chromaFalloff: l = .85, hueSpread: u = 28, lightnessEasing: d = "linear", chromaEasing: f = "bell", temperatureShift: p = 0, avoidHues: m, scheme: h, lBand: g } = t, _ = Math.max(2, Math.min(8, Math.round(r))), [v, y] = rt(g, h), b = n.L - a / 2, x = n.L + a / 2;
+function Ye(e, t = {}) {
+	let n = typeof e == "string" ? s(e) : e, { stopCount: r = 4, harmony: i = "analogous", lightnessSpread: a = .32, chromaFalloff: o = .85, hueSpread: u = 28, lightnessEasing: d = "linear", chromaEasing: f = "bell", temperatureShift: p = 0, avoidHues: m, scheme: h, lBand: g } = t, _ = Math.max(2, Math.min(8, Math.round(r))), [v, y] = Je(g, h), b = n.L - a / 2, x = n.L + a / 2;
 	b < v && (x += v - b, b = v), x > y && (b -= x - y, x = y), b = Math.max(v, b), x = Math.min(y, x);
 	let S = [], C = -Infinity;
 	for (let e = 0; e < _; e++) {
-		let t = _ === 1 ? 0 : e / (_ - 1), r = b + (x - b) * L(t, d), a = n.C * l, o;
-		if (f === "bell") o = a + (n.C - a) * at(t);
+		let t = _ === 1 ? 0 : e / (_ - 1), r = b + (x - b) * Ze(t, d), a = n.C * o, s;
+		if (f === "bell") s = a + (n.C - a) * Qe(t);
 		else {
-			let e = f === "sine" ? L(t, "sine") : t;
-			o = n.C - (n.C - a) * e;
+			let e = f === "sine" ? Ze(t, "sine") : t;
+			s = n.C - (n.C - a) * e;
 		}
-		let h = s(n.h, i, u, t);
-		p > 0 && (h = lt(h, t, p)), m && m.length > 0 && (h = dt(h, m));
-		let g = it(c({
+		let h = c(n.h, i, u, t);
+		p > 0 && (h = nt(h, t, p)), m && m.length > 0 && (h = at(h, m));
+		let g = Xe(l({
 			L: r,
-			C: o,
+			C: s,
 			h
 		}), C);
 		C = g.L, S.push(g);
 	}
 	return S;
 }
-function it(e, t) {
+function Xe(e, t) {
 	if (e.L >= t) return e;
 	let { h: n } = e, r = t, i = e.C;
 	for (let e = 0; e < 48; e++) {
-		let [e, t, a] = ye(r, i, n), [o, s, c] = _e(e, t, a);
-		if (Math.max(o, s, c) <= 1) break;
+		let [e, t, a] = d({
+			L: r,
+			C: i,
+			h: n
+		});
+		if (Math.max(e, t, a) <= 1) break;
 		i *= .99;
 	}
 	return {
@@ -819,36 +834,36 @@ function it(e, t) {
 		h: n
 	};
 }
-function L(e, t) {
+function Ze(e, t) {
 	return t === "sine" ? .5 - .5 * Math.cos(Math.PI * e) : e;
 }
-function at(e) {
+function Qe(e) {
 	return Math.sin(Math.PI * e);
 }
-var ot = 70, st = 250, ct = 22;
-function lt(e, t, n) {
+var $e = 70, et = 250, tt = 22;
+function nt(e, t, n) {
 	let r = (t - .5) * 2;
 	if (r === 0 || n === 0) return e;
-	let i = (ge(e, r >= 0 ? ot : st, 1, "shorter") - e + 540) % 360 - 180;
-	return ((e + Math.sign(i) * Math.min(Math.abs(r) * n * ct, Math.abs(i))) % 360 + 360) % 360;
+	let i = (o("applyTemperature", pe(e, r >= 0 ? $e : et, 1, "shorter")) - e + 540) % 360 - 180;
+	return ((e + Math.sign(i) * Math.min(Math.abs(r) * n * tt, Math.abs(i))) % 360 + 360) % 360;
 }
-var R = (e) => (e % 360 + 360) % 360;
-function ut(e, t, n) {
-	let r = R(e), i = R(t), a = R(n);
+var U = (e) => (e % 360 + 360) % 360;
+function rt(e, t, n) {
+	let r = U(e), i = U(t), a = U(n);
 	return i <= a ? r >= i && r <= a : r >= i || r <= a;
 }
-function z(e, t) {
-	let n = Math.abs(R(e) - R(t)) % 360;
+function it(e, t) {
+	let n = Math.abs(U(e) - U(t)) % 360;
 	return n > 180 ? 360 - n : n;
 }
-function dt(e, t) {
-	let n = .5, r = R(e);
+function at(e, t) {
+	let n = .5, r = U(e);
 	for (let e = 0; e < t.length + 2; e++) {
 		let e = !1;
 		for (let [i, a] of t) {
-			if (!ut(r, i, a)) continue;
-			let t = R(i - n), o = R(a + n);
-			r = z(r, t) <= z(r, o) ? t : o, e = !0;
+			if (!rt(r, i, a)) continue;
+			let t = U(i - n), o = U(a + n);
+			r = it(r, t) <= it(r, o) ? t : o, e = !0;
 		}
 		if (!e) return r;
 	}
@@ -856,15 +871,12 @@ function dt(e, t) {
 }
 //#endregion
 //#region src/components/aurora/composables/uniformBridge.ts
-var ft = {
+var ot = {
 	x: .5,
 	y: .5,
 	strength: 0,
-	radius: .25,
-	velX: 0,
-	velY: 0,
-	burst: 0
-}, B = {
+	radius: .25
+}, st = {
 	smooth: 0,
 	pastel: 1,
 	watercolor: 2,
@@ -875,144 +887,146 @@ var ft = {
 	kuwahara: 7,
 	metal: 8,
 	"metal-gradient": 9
-}, V = {
+}, ct = {
 	shorter: 0,
 	longer: 1,
 	increasing: 2,
 	decreasing: 3
-}, pt = {
+}, lt = {
 	none: 0,
 	radial: 1,
 	swirl: 2,
 	diagonal: 3,
 	multi: 4,
 	tensor: 5
-}, H = {
+}, ut = {
 	flow: 0,
 	tensor: 1
-}, mt = {
+}, dt = {
 	fbm: 0,
 	cellular: 1,
 	hybrid: 2,
 	curl: 3
-}, ht = {
+}, ft = {
 	oil: 0,
 	knife: 1,
 	chunky: 3
-}, U = {
+}, W = {
 	L: .985,
 	C: .0125,
 	h: 77.5
 };
+function pt(e) {
+	return e === void 0 ? f(W.L, W.C, W.h) : Array.isArray(e) ? e : f(e.L, e.C, e.h);
+}
+function mt(e) {
+	return st[e.medium];
+}
+function ht(e) {
+	return ft[e.strokeMode];
+}
 function gt(e) {
-	return e === void 0 ? d(U.L, U.C, U.h) : Array.isArray(e) ? e : d(e.L, e.C, e.h);
-}
-function _t(e) {
-	return B[e.medium];
-}
-function vt(e) {
-	return ht[e.strokeMode];
-}
-function yt(e) {
-	return e.medium === "vangogh" || e.medium === "oil-pastel" || e.medium === "crayon" || e.medium === "kuwahara" ? H.tensor : H[e.strokeOrient ?? "flow"];
-}
-function bt(e, t, n) {
-	let r = (e) => 1 - e, i = {
-		palette: new Float32Array(24),
-		pos: new Float32Array(12),
-		rad: new Float32Array(6),
-		pb: new Float32Array(6),
-		vb: new Float32Array(6),
-		dr: new Float32Array(6),
-		dp: new Float32Array(6),
-		elong: new Float32Array(6),
-		angle: new Float32Array(6)
+	return e.medium === "vangogh" || e.medium === "oil-pastel" || e.medium === "crayon" || e.medium === "kuwahara" ? ut.tensor : ut[e.strokeOrient ?? "flow"];
+}
+function _t(e, t, n, r = !1) {
+	let i = (e) => 1 - e, a = {
+		palette: /* @__PURE__ */ new Float32Array(24),
+		pos: /* @__PURE__ */ new Float32Array(16),
+		rad: /* @__PURE__ */ new Float32Array(8),
+		pb: /* @__PURE__ */ new Float32Array(8),
+		vb: /* @__PURE__ */ new Float32Array(8),
+		dr: /* @__PURE__ */ new Float32Array(8),
+		dp: /* @__PURE__ */ new Float32Array(8),
+		elong: /* @__PURE__ */ new Float32Array(8),
+		angle: /* @__PURE__ */ new Float32Array(8)
 	};
-	return function(a) {
-		e.useProgram(t), F(a.palette, 8, i.palette), e.uniform3fv(n.uPalette, i.palette), e.uniform1i(n.uStopCount, Math.min(a.palette.length, 8));
-		let o = Math.min(a.nuclei.length, 6);
-		e.uniform1i(n.uNucleiCount, o);
-		for (let e = 0; e < o; e++) {
-			let t = a.nuclei[e];
-			i.pos[e * 2 + 0] = t.x, i.pos[e * 2 + 1] = r(t.y), i.rad[e] = t.radius, i.pb[e] = t.paletteBias, i.vb[e] = t.valueBias, i.dr[e] = t.driftRadius, i.dp[e] = t.driftPhase, i.elong[e] = t.elongation ?? 1, i.angle[e] = -(t.angle ?? 0) * Math.PI / 180;
+	return function(o) {
+		e.useProgram(t), H(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, 8);
+		e.uniform1i(n.uNucleiCount, s);
+		for (let e = 0; e < s; e++) {
+			let t = o.nuclei[e];
+			a.pos[e * 2 + 0] = t.x, a.pos[e * 2 + 1] = i(t.y), a.rad[e] = t.radius, a.pb[e] = t.paletteBias, a.vb[e] = t.valueBias, a.dr[e] = t.driftRadius, a.dp[e] = t.driftPhase, a.elong[e] = t.elongation ?? 1, a.angle[e] = -(t.angle ?? 0) * Math.PI / 180;
 		}
-		for (let e = o; e < 6; e++) i.pos[e * 2 + 0] = 0, i.pos[e * 2 + 1] = 0, i.rad[e] = 0, i.pb[e] = 0, i.vb[e] = 0, i.dr[e] = 0, i.dp[e] = 0, i.elong[e] = 1, i.angle[e] = 0;
-		e.uniform2fv(n.uNucleiPos, i.pos), e.uniform1fv(n.uNucleiRadius, i.rad), e.uniform1fv(n.uNucleiPaletteBias, i.pb), e.uniform1fv(n.uNucleiValueBias, i.vb), e.uniform1fv(n.uNucleiDriftRadius, i.dr), e.uniform1fv(n.uNucleiDriftPhase, i.dp), e.uniform1fv(n.uNucleiElong, i.elong), e.uniform1fv(n.uNucleiAngle, i.angle), e.uniform1f(n.uSoftmaxBeta, a.softmaxBeta), e.uniform1f(n.uValueVariance, a.valueVariance), e.uniform1f(n.uWarpAmount, a.warpAmount), e.uniform1f(n.uWarpScale, a.warpScale), e.uniform1f(n.uWarpDrift, a.warpDrift), e.uniform1i(n.uWarpMode, mt[a.warpMode]), e.uniform1i(n.uNoiseOctaves, a.noiseOctaves), e.uniform1i(n.uMedium, _t(a)), e.uniform1i(n.uHuePath, V[a.huePath ?? "shorter"]), e.uniform1i(n.uFlowPattern, pt[a.flow.pattern]), e.uniform2f(n.uFlowFocal, a.flow.focalX, r(a.flow.focalY)), e.uniform1f(n.uFlowAngle, a.flow.angle), e.uniform1f(n.uFlowCurl, a.flow.curl);
-		let s = ft;
-		e.uniform2f(n.uCursor, s.x, r(s.y)), e.uniform1f(n.uCursorStrength, s.strength), e.uniform1f(n.uCursorRadius, s.radius), e.uniform2f(n.uCursorVelocity, s.velX, -s.velY), e.uniform1f(n.uCursorBurst, s.burst), e.uniform1f(n.uStrokeAmount, a.strokeAmount), e.uniform1f(n.uStrokeScale, a.strokeScale), e.uniform1f(n.uStrokeAnisotropy, a.strokeAnisotropy), e.uniform1i(n.uStrokeLayers, a.strokeLayers), e.uniform1i(n.uStrokeMode, vt(a)), e.uniform1i(n.uStrokeOrient, yt(a));
+		for (let e = s; e < 8; 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, dt[o.warpMode]), e.uniform1i(n.uNoiseOctaves, o.noiseOctaves), e.uniform1i(n.uMedium, mt(o)), e.uniform1i(n.uHuePath, ct[o.huePath ?? "shorter"]), e.uniform1i(n.uFlowPattern, lt[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);
+		let c = ot;
+		e.uniform2f(n.uCursor, c.x, i(c.y)), e.uniform1f(n.uCursorStrength, c.strength), e.uniform1f(n.uCursorRadius, c.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, ht(o)), e.uniform1i(n.uStrokeOrient, gt(o));
 		{
-			let t = a.lightDir ?? [
+			let t = o.lightDir ?? [
 				-.5,
 				.6,
 				.62
-			], r = gt(a.lightColor);
+			], r = pt(o.lightColor);
 			e.uniform3f(n.uLightDir, t[0], t[1], t[2]), e.uniform3f(n.uLightColor, r[0], r[1], r[2]);
 		}
-		e.uniform1f(n.uWetEdge, a.wetEdge), e.uniform1f(n.uGranulation, a.granulation), e.uniform1f(n.uImpasto, a.impasto), e.uniform1f(n.uBrokenColor, a.brokenColor), e.uniform1f(n.uCanvasGrain, a.canvasGrain), e.uniform1f(n.uMetalPolish, a.metalPolish ?? 1), e.uniform1f(n.uMetalHeightScale, a.metalHeightScale ?? 1), e.uniform1f(n.uNucleiDrift, a.nucleiDrift), e.uniform1f(n.uPaletteDrift, a.paletteDrift), e.uniform1f(n.uBreathDepth, a.breathDepth), e.uniform1f(n.uBreathPeriod, a.breathPeriod), e.uniform1f(n.uSaturation, a.saturation), e.uniform1f(n.uPaperGrain, a.paperGrain), e.uniform1f(n.uAlpha, a.alpha), e.uniform1f(n.uVividness, a.vividness ?? 1), e.uniform1i(n.uImage, 0), e.uniform1f(n.uBlurMin, a.imageBlur?.min ?? .004), e.uniform1f(n.uBlurMax, a.imageBlur?.max ?? .06);
-		let c = e.drawingBufferHeight > 0 ? e.drawingBufferWidth / e.drawingBufferHeight : 1;
-		e.uniform1f(n.uImageAspect, c);
+		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.uMetalPolish, o.metalPolish ?? 1), e.uniform1f(n.uMetalHeightScale, o.metalHeightScale ?? 1), 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, r ? 1 : o.alpha), e.uniform1f(n.uVividness, o.vividness ?? 1), e.uniform1i(n.uImage, 0), e.uniform1f(n.uBlurMin, o.imageBlur?.min ?? .004), e.uniform1f(n.uBlurMax, o.imageBlur?.max ?? .06);
+		let l = e.drawingBufferHeight > 0 ? e.drawingBufferWidth / e.drawingBufferHeight : 1;
+		e.uniform1f(n.uImageAspect, l);
 	};
 }
 //#endregion
-//#region src/components/aurora/composables/frameLoop.ts
-var W = .001, xt = 1e-4;
-function G(e, t, i) {
-	let a = r(n(e), t), o = a.burst;
-	if (i > 0) {
-		let t = e.acceleration.value, n = e.velocity.value, r = -(t.x * n.x + t.y * n.y);
-		r > 0 && (o = Math.min(1, o + r * 3));
-	}
+//#region src/components/aurora/composables/glSetup.ts
+var G = "[Aurora]", vt = /* @__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.uStrokeAmount.uStrokeScale.uStrokeAnisotropy.uStrokeLayers.uStrokeMode.uStrokeOrient.uLightDir.uLightColor.uWetEdge.uGranulation.uImpasto.uBrokenColor.uCanvasGrain.uMetalPolish.uMetalHeightScale.uNucleiDrift.uPaletteDrift.uBreathDepth.uBreathPeriod.uSaturation.uPaperGrain.uAlpha.uVividness.uImage.uBlurMin.uBlurMax.uImageAspect".split(".");
+function yt(e, t, n) {
+	let r = O(e, e.VERTEX_SHADER, t, G), i = O(e, e.FRAGMENT_SHADER, n, G), a = te(e, r, i, G);
+	e.useProgram(a);
+	let o = e.createVertexArray();
+	e.bindVertexArray(o);
+	let s = e.createBuffer();
+	e.bindBuffer(e.ARRAY_BUFFER, s), e.bufferData(e.ARRAY_BUFFER, new Float32Array([
+		-1,
+		-1,
+		3,
+		-1,
+		-1,
+		3
+	]), e.STATIC_DRAW);
+	let c = e.getAttribLocation(a, "aPos");
+	e.enableVertexAttribArray(c), e.vertexAttribPointer(c, 2, e.FLOAT, !1, 0, 0);
+	let l = {};
+	for (let t of vt) l[t] = e.getUniformLocation(a, t);
 	return {
-		x: a.cx,
-		y: a.cy,
-		strength: a.strength,
-		radius: a.radius,
-		velX: a.velX,
-		velY: a.velY,
-		burst: o
+		program: a,
+		vs: r,
+		fs: i,
+		uniforms: l,
+		geometry: {
+			vao: o,
+			buf: s
+		}
 	};
 }
-function K(e) {
-	let t = e.attractorVelocity.value;
-	return e.engagement.value > W || e.speed.value > W || e.burst.value > W || Math.hypot(t.x, t.y) > xt;
-}
-function St(e) {
-	let { gl: t, prog: n, uniforms: r, pointerField: i, getCursorScalars: a, getConfig: o, getReducedMotion: s } = e, c = (e) => 1 - e, l = null, u = {
-		x: .5,
-		y: .5,
-		strength: 0,
-		radius: .25,
-		velX: 0,
-		velY: 0,
-		burst: 0
-	};
-	function d() {
-		return +!s();
-	}
-	function f(e) {
-		if (t.useProgram(n), t.uniform2f(r.uCursor, u.x, c(u.y)), t.uniform1f(r.uCursorStrength, u.strength), t.uniform1f(r.uCursorRadius, u.radius), t.uniform2f(r.uCursorVelocity, u.velX, -u.velY), t.uniform1f(r.uCursorBurst, u.burst), t.uniform1f(r.uTime, e), o().interactivity?.light) {
-			let n = d(), i = e * .25, a = Math.cos(i) * .5, o = Math.sin(i) * .5, s = (u.x - .5) * 2, c = (.5 - u.y) * 2, l = u.strength * n;
-			a = a * (1 - l) + s * l, o = o * (1 - l) + c * l, t.uniform3f(r.uLightDir, a * n + (1 - n) * -.5, o * n + (1 - n) * .6, .62);
-		}
-		t.clear(t.COLOR_BUFFER_BIT), t.drawArrays(t.TRIANGLES, 0, 3);
-	}
-	function p() {
-		if (s()) return !1;
-		let e = o();
-		return e.nucleiDrift !== 0 || e.paletteDrift !== 0 || e.breathDepth !== 0 || e.warpDrift !== 0 ? !0 : K(i);
-	}
-	return {
-		frame: (e) => {
-			let t = d(), n = l === null ? 0 : Math.max(0, (e - l) * 1e3);
-			l = e, i.tick(t === 0 ? 0 : n), u = G(i, a(), t), f(e);
-		},
-		needsAnimation: p
+function bt(e) {
+	return (t) => {
+		let n = e.getConfig().source === "image", { program: r, vs: i, fs: a, uniforms: o, geometry: s } = yt(t, xe, n ? Pe : Ne), c = n ? be(t, r, e.imageCoordinator) : null, l = (e) => {
+			t.viewport(0, 0, e.w, e.h), t.useProgram(r);
+		}, u = _t(t, r, o, e.opaquePresentation), d = (e) => u(e);
+		e.registerConfigUploader(d), d(e.getConfig());
+		let f = Ie({
+			gl: t,
+			prog: r,
+			uniforms: o,
+			pointerField: e.pointerField,
+			getCursorScalars: e.getCursorScalars,
+			getConfig: e.getConfig,
+			getReducedMotion: e.getReducedMotion,
+			getRenderTime: e.getRenderTime
+		});
+		return t.clearColor(0, 0, 0, +!!e.opaquePresentation), t.disable(t.DEPTH_TEST), e.opaquePresentation ? t.disable(t.BLEND) : (t.enable(t.BLEND), t.blendFunc(t.ONE, t.ONE_MINUS_SRC_ALPHA)), {
+			frame: f.frame,
+			shouldContinue: f.needsAnimation,
+			resize: l,
+			teardown: () => {
+				e.registerConfigUploader(null), t.deleteProgram(r), t.deleteShader(i), t.deleteShader(a), t.deleteBuffer(s.buf), t.deleteVertexArray(s.vao), c?.();
+			}
+		};
 	};
 }
 //#endregion
 //#region src/components/aurora/constants/shaders/aurora.wgsl.ts
-var Ct = `
-const MAX_NUCLEI: i32 = 6;
+var xt = `
+const MAX_NUCLEI: i32 = 8;
 const MAX_STOPS: i32 = 8;
 const PI: f32 = 3.141592653589793;
 
@@ -1029,10 +1043,10 @@ struct Uniforms {
   // scalars2: (uAlpha, uNucleiDrift, uPaletteDrift, uBreathDepth)
   scalars2: vec4<f32>,
   // scalars3: (uBreathPeriod, uCursorStrength, uCursorRadius, uVividness)
-  // BD.W-AUR-VIVIDNESS — the .w pad lane now carries the §3 chroma-floor strength.
+  // The .w pad lane now carries the chroma-floor strength.
   scalars3: vec4<f32>,
   // cursor: (uCursor.x, uCursor.y, uMetalPolish, uMetalHeightScale)
-  // BG.W-AUR-METAL-FINISH — the two free pad lanes carry the metal-medium knobs (the
+  // The two free pad lanes carry the metal-medium knobs (the
   // metal light is cursor-synthesized so it reads in-struct on the WGSL primary too).
   cursor: vec4<f32>,
   // ints: (uStopCount, uNucleiCount, uWarpMode, uNoiseOctaves)
@@ -1040,10 +1054,10 @@ struct Uniforms {
   // ints1: (uMedium, uHuePath, _, _)
   ints1: vec4<i32>,
   palette: array<vec4<f32>, 8>,
-  nuc0: array<vec4<f32>, 6>,
-  nuc1: array<vec4<f32>, 6>,
-  nuc2: array<vec4<f32>, 6>,
-  // BC.W-VIZ-AURORA (T4) — the painterly-medium scalar lanes. APPENDED after the
+  nuc0: array<vec4<f32>, 8>,
+  nuc1: array<vec4<f32>, 8>,
+  nuc2: array<vec4<f32>, 8>,
+  // The painterly-medium scalar lanes are appended after the
   // arrays so EVERY existing offset (and the smooth-default parity capture) is
   // byte-identical (these lanes are written 0 on a smooth config). scalars4:
   // (uStrokeAmount, uStrokeScale, uStrokeAnisotropy, uCanvasGrain). scalars5:
@@ -1062,7 +1076,7 @@ const K_NUCLEI: f32 = 14.0;
 const K_PAL: f32 = 24.0;
 const K_WARP: f32 = 5.0;
 
-// ── Noise (aurora-local hash21/vnoise/fbm — legitimately divergent per AV.W2 §3a) ──
+// ── Noise (Aurora-local hash21/vnoise/fbm, deliberately distinct) ──────────
 fn hash21(p0: vec2<f32>) -> f32 {
   var p = fract(p0 * vec2<f32>(123.34, 456.21));
   p = p + dot(p, p + 45.32);
@@ -1086,7 +1100,7 @@ fn vnoise(p: vec2<f32>) -> f32 {
   return mix(mix(a, b, uu.x), mix(c, d, uu.x), uu.y);
 }
 
-${C}
+${w}
 
 fn fbm(p0: vec2<f32>) -> f32 {
   var v = 0.0;
@@ -1102,16 +1116,31 @@ fn fbm(p0: vec2<f32>) -> f32 {
   return v;
 }
 
-${v}
-${x}
-${g}
+fn potentialFBM(p: vec2f) -> f32 { return fbm(p); }
+
+const CURL_EPS: f32 = 0.012;
+
+// ∇×ψ in 2D — the divergence-free flow direction. Central finite differences of the
+// scalar potential give the partials; the cross-pairing (∂y, −∂x) is the 2D curl.
+fn curlFBM(p: vec2f) -> vec2f {
+  let dx = potentialFBM(p + vec2f(CURL_EPS, 0.0)) - potentialFBM(p - vec2f(CURL_EPS, 0.0));
+  let dy = potentialFBM(p + vec2f(0.0, CURL_EPS)) - potentialFBM(p - vec2f(0.0, CURL_EPS));
+  // ψ-gradient is (dx, dy)/(2·eps); the curl rotates it 90°: (∂ψ/∂y, −∂ψ/∂x).
+  let g = vec2f(dx, dy) / (2.0 * CURL_EPS);
+  return vec2f(g.y, -g.x);
+}
+
+
+${y}
+${S}
+${_}
 
 // Interleaved Gradient Noise (Jimenez) — display-space 1-LSB dither.
 fn ign(p: vec2<f32>) -> f32 {
   return fract(52.9829189 * fract(dot(p, vec2<f32>(0.06711056, 0.00583715))));
 }
 
-// Cellular / Worley f1.
+// Cellular, Worley f1.
 fn cellular(p: vec2<f32>) -> f32 {
   let i = floor(p);
   let f = fract(p);
@@ -1127,7 +1156,7 @@ fn cellular(p: vec2<f32>) -> f32 {
   return sqrt(m);
 }
 
-// ── Warp (Quilez double warp + the three warp modes + the cursor swirl) ──
+// ── Warp (Quilez double warp + the four warp modes + the cursor swirl) ──
 fn domainWarp(p: vec2<f32>, t: f32) -> vec2<f32> {
   let warpScale = u.scalars1.x;
   let warpDrift = u.scalars1.y;
@@ -1153,6 +1182,9 @@ fn domainWarp(p: vec2<f32>, t: f32) -> vec2<f32> {
     let c1 = cellular(p * warpScale * 1.2);
     let c2 = cellular(p * warpScale * 1.2 + vec2<f32>(11.0, 7.0));
     warp = mix(r, vec2<f32>(c1, c2), 0.5);
+  } else if (warpMode == 3) {
+    let fp = p * warpScale + vec2<f32>(t * warpDrift * K_WARP);
+    warp = curlFBM(fp);
   }
   var warped = p + warpAmount * warp;
 
@@ -1241,7 +1273,7 @@ fn saturate3(c: vec3<f32>, amt: f32) -> vec3<f32> {
   return max(oklabToLinearSrgb(oklchToOklab(lch)), vec3<f32>(0.0));
 }
 
-// BD.W-AUR-VIVIDNESS — the §3 chroma FLOOR, the WGSL twin of the GLSL vividnessFloor.
+// The chroma floor, the WGSL twin of the GLSL vividnessFloor.
 // OKLab chroma lifted toward the floor, hue + L preserved; below VIVID_EPS the (a,b)
 // direction is precision noise so the lift synthesizes along the WARM anchor (amber,
 // both components positive) — never teal/navy. vividness (scalars3.w) == 0 is a no-op
@@ -1280,7 +1312,7 @@ fn aces(color0: vec3<f32>) -> vec3<f32> {
   return clamp(mix(color, newPeak * vec3<f32>(1.0), g), vec3<f32>(0.0), vec3<f32>(1.0));
 }
 
-// ── BC.W-VIZ-AURORA (T4) — the painterly-medium bodies (the keystone WGSL port) ──
+// ── Painterly-medium bodies (the keystone WGSL port) ───────────────────────
 // Spliced HERE, after every helper the mediums consume is defined (domainWarp,
 // nucleiField, samplePalette, linOklab, saturate3, oklabToOklch/oklchToOklab,
 // hash21/vnoise/fbm) and before the vertex/fragment stages. applyMedium(col,p,t)
@@ -1298,17 +1330,17 @@ fn mGranulation() -> f32 { return u.scalars5.y; }
 fn mBrokenColor() -> f32 { return u.scalars5.z; }
 fn mKuwaharaQ() -> f32 { return u.scalars5.w; }
 fn mKuwaharaRadius() -> f32 { return u.kuwahara.x; }
-// BG.W-AUR-METAL-FINISH — the metal-medium knobs ride the FREE cursor.z/.w pad lanes
+// The metal-medium knobs ride the free cursor.z/.w pad lanes
 // (uniformBridgeWGPU packs them; written 0 on a non-metal config → no-op). These read
 // the IN-STRUCT cursor — the metal light is cursor-synthesized so it crosses to WGSL
-// (a phantom uLightDir read would be flat on the primary — uLightDir is .frag-only).
+// (a phantom uLightDir read would be flat on the primary; uLightDir is fragment-only).
 fn mMetalPolish() -> f32 { return u.cursor.z; }
 fn mMetalHeightScale() -> f32 { return u.cursor.w; }
 
-// ── Gradient pack (BG.W-AUR-METAL-FINISH; the WGSL twin) ────────────────────
+// ── Gradient pack (the WGSL twin) ──────────────────────────────────────────
 // structureTensorField re-plumbs its already-computed luma gradient (Gx,Gy) out
-// through the return's .w lane so the metal medium pays ZERO extra taps. 12 bits per
-// bounded component ([-4,4]) into one f32; the crayon/kuwahara callers read only .xy/.z.
+// through the return value's .w lane so the metal medium pays ZERO extra taps. 12 bits per
+// bounded component ([-4,4]) fit into one f32; the crayon/kuwahara callers read only .xy/.z.
 fn packGrad(gx: f32, gy: f32) -> f32 {
   let qx = floor(clamp(gx * 0.125 + 0.5, 0.0, 1.0) * 4095.0);
   let qy = floor(clamp(gy * 0.125 + 0.5, 0.0, 1.0) * 4095.0);
@@ -1340,10 +1372,10 @@ fn brokenColorJitter(c: vec3<f32>, hueSeed: f32, valueSeed: f32, strength: f32)
   return max(oklabToLinearSrgb(oklchToOklab(lch)), vec3<f32>(0.0));
 }
 
-// ── Structure-tensor / edge-tangent-flow (AW.W4.1; the WGSL twin) ───────────
+// ── Structure tensor / edge-tangent flow (the WGSL twin) ───────────────────
 // Returns vec4(tangent.x, tangent.y, A, packGrad(Gx,Gy)) — the minor-eigenvector
-// edge-tangent + coherence + the metal medium's packed gradient (BG.W-AUR-METAL-FINISH;
-// the .xy/.z crayon/kuwahara callers are byte-unchanged).
+// edge-tangent + coherence + the metal medium's packed gradient. The .xy/.z
+// crayon/kuwahara callers are byte-unchanged.
 fn structureTensorField(p: vec2<f32>, t: f32, fallbackDir: vec2<f32>) -> vec4<f32> {
   let e = 0.0035;
   let l00 = dot(sampleBase(p + vec2<f32>(-e, -e), t), W_LUMA);
@@ -1630,18 +1662,18 @@ fn mediumMetalGradient(col: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {
 // (pastel/watercolor/crayon) + kuwahara + metal port their own bodies; the
 // oil/vangogh/oil-pastel STROKE cascade renders the anisotropic-Kuwahara PAINTERLY
 // finish here (a real oil-paint read, never the smooth core — the "NO FALLBACKS on
-// Safari" mandate; the full per-dab Starry-Night stroke WGSL is the booked
-// W-AURORA-WGPU-MEDIUMS-STROKES tail).
+// Safari" mandate; the full per-dab Starry-Night stroke WGSL remains a separate
+// full-fidelity port).
 fn applyMedium(col: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {
   let medium = u.ints1.x;
   if (medium == 1) { return mediumPastel(col, p, t); }
   if (medium == 2) { return mediumWatercolor(col, p, t); }
   if (medium == 4) { return mediumCrayon(col, p, t); }
-  // BG.W-AUR-METAL-FINISH — metal DUAL-PORTS (a .frag-only metal is invisible on the
-  // WGSL primary of both browsers); 8 metal, 9 metal-gradient.
+  // Metal uses both renderer paths; a fragment-only implementation is invisible on the
+  // WGSL primary. IDs 8 and 9 select metal and metal-gradient respectively.
   if (medium == 8) { return mediumMetal(col, p, t); }
   if (medium == 9) { return mediumMetalGradient(col, p, t); }
-  // oil(3) / vangogh(5) / oil-pastel(6) / kuwahara(7) all render the painterly
+  // oil(3), vangogh(5), oil-pastel(6), kuwahara(7) all render the painterly
   // anisotropic-Kuwahara finish on the WGSL primary (the WebGL2 fallback carries the
   // full per-dab stroke cascade for oil/vangogh/oil-pastel).
   if (medium == 3 || medium == 5 || medium == 6 || medium == 7) {
@@ -1695,17 +1727,23 @@ fn fs_main(in: VSOut) -> @location(0) vec4<f32> {
   let breath = sin(t * 6.2831 / max(breathPeriod, 1.0));
   col = col * (1.0 + breathDepth * breath * 0.5);
 
-  // BC.W-VIZ-AURORA (T4) — the painterly-medium dispatch. uMedium 0 (smooth) is a
-  // no-op pass-through so the DEFAULT smooth config is byte-identical to the prior
-  // WGSL primary (the parity capture); uMedium 1-7 render the ported painterly
+  // Painterly-medium dispatch. uMedium 0 (smooth) is a
+  // no-op pass-through so the DEFAULT smooth config renders unchanged
+  // (the parity capture); uMedium 1-7 render the painterly
   // bodies (pastel/watercolor/crayon/kuwahara) or the anisotropic-Kuwahara finish
   // (oil/vangogh/oil-pastel) — never a silent smooth degrade on Safari 26.
   col = applyMedium(col, pN, t);
 
+  // Cursor-local luminance lean, byte-parallel with the GLSL path.
+  let cursorDelta = pN - u.cursor.xy;
+  let cursorRadius = max(u.scalars3.z, 0.01);
+  let cursorLean = exp(-dot(cursorDelta, cursorDelta) / (cursorRadius * cursorRadius * 0.5));
+  col = col * (1.0 + 0.12 * cursorLean * u.scalars3.y);
+
   // Saturation trim.
   col = saturate3(col, saturation);
 
-  // BD.W-AUR-VIVIDNESS — the §3 chroma floor (warm-anchored, hue-preserving). The WGSL
+  // The chroma floor is warm-anchored and hue-preserving. The WGSL
   // twin of the GLSL call; vividness:0 is a no-op so the smooth/pale default stays gated.
   col = vividnessFloor(col, vividness);
 
@@ -1727,14 +1765,14 @@ fn fs_main(in: VSOut) -> @location(0) vec4<f32> {
   // Premultiply on DISPLAY-space color (matches the WebGL2 path: OETF, then premul).
   return vec4<f32>(col * alpha, alpha);
 }
-`, wt = `
-const MAX_NUCLEI: i32 = 6;
+`, St = `
+const MAX_NUCLEI: i32 = 8;
 const PI: f32 = 3.141592653589793;
 const BLUR_RINGS: i32 = 3;
 const BLUR_SECTORS: i32 = 8;
 
 // The image program's OWN uniform struct (packed vec4 lanes — trivial std140/WGSL
-// alignment). DISTINCT from the palette program's 576-byte struct (a separate program).
+// alignment). DISTINCT from the palette program's 672-byte struct (a separate program).
 struct ImageUniforms {
   // scalars0: (uTime, uWarpAmount, uWarpScale, uWarpDrift)
   scalars0: vec4<f32>,
@@ -1749,8 +1787,8 @@ struct ImageUniforms {
   // ints: (uNucleiCount, uNoiseOctaves, _, _)
   ints: vec4<i32>,
   // nuc0[i] = (pos.x, pos.y, radius, valueBias); nuc1[i] = (driftRadius, driftPhase, elong, angle)
-  nuc0: array<vec4<f32>, 6>,
-  nuc1: array<vec4<f32>, 6>,
+  nuc0: array<vec4<f32>, 8>,
+  nuc1: array<vec4<f32>, 8>,
 };
 
 @group(0) @binding(0) var<uniform> u: ImageUniforms;
@@ -1776,7 +1814,7 @@ fn vnoise(p: vec2<f32>) -> f32 {
   let d = hash21(i + vec2<f32>(1.0, 1.0));
   return mix(mix(a, b, uu.x), mix(c, d, uu.x), uu.y);
 }
-${C}
+${w}
 fn fbm(p0: vec2<f32>) -> f32 {
   var v = 0.0;
   var a = 0.5;
@@ -1794,8 +1832,8 @@ fn ign(p: vec2<f32>) -> f32 {
   return fract(52.9829189 * fract(dot(p, vec2<f32>(0.06711056, 0.00583715))));
 }
 
-${v}
-${x}
+${y}
+${S}
 
 fn linOklab(lin: vec3<f32>) -> vec3<f32> {
   let lms = LINEAR_SRGB_TO_LMS * lin;
@@ -1957,6 +1995,11 @@ fn fs_main(in: VSOut) -> @location(0) vec4<f32> {
   let radius = mix(blurMin, blurMax, zone);
   var col = zoneBlur(uv, radius);
 
+  let cursorDelta = uv - u.cursor.xy;
+  let cursorRadius = max(u.scalars1.w, 0.01);
+  let cursorLean = exp(-dot(cursorDelta, cursorDelta) / (cursorRadius * cursorRadius * 0.5));
+  col = col * (1.0 + 0.12 * cursorLean * u.scalars1.z);
+
   col = saturate3(col, saturation);
   col = vividnessFloor(col, vividness);
 
@@ -1971,7 +2014,7 @@ fn fs_main(in: VSOut) -> @location(0) vec4<f32> {
 
   return vec4<f32>(col * alpha, alpha);
 }
-`, q = {
+`, K = {
 	scalars0: 0,
 	scalars1: 4,
 	scalars2: 8,
@@ -1981,40 +2024,40 @@ fn fs_main(in: VSOut) -> @location(0) vec4<f32> {
 	ints1: 24,
 	palette: 28,
 	nuc0: 60,
-	nuc1: 84,
-	nuc2: 108,
-	scalars4: 132,
-	scalars5: 136,
-	kuwahara: 140
-}, Tt = .01, Et = 8, Dt = 4, Ot = (e) => 1 - e;
-function kt() {
-	let e = /* @__PURE__ */ new ArrayBuffer(576);
+	nuc1: 92,
+	nuc2: 124,
+	scalars4: 156,
+	scalars5: 160,
+	kuwahara: 164
+}, Ct = .01, wt = 8, Tt = 4, Et = (e) => 1 - e;
+function Dt() {
+	let e = /* @__PURE__ */ new ArrayBuffer(672);
 	return {
 		buffer: e,
 		f32: new Float32Array(e),
 		i32: new Int32Array(e),
-		paletteScratch: new Float32Array(24)
+		paletteScratch: /* @__PURE__ */ new Float32Array(24)
 	};
 }
-function At(e, t, n, r) {
-	let { f32: i, i32: a, paletteScratch: o } = e;
-	i[q.scalars0 + 0] = r, i[q.scalars0 + 1] = t.softmaxBeta, i[q.scalars0 + 2] = t.valueVariance, i[q.scalars0 + 3] = t.warpAmount, i[q.scalars1 + 0] = t.warpScale, i[q.scalars1 + 1] = t.warpDrift, i[q.scalars1 + 2] = t.saturation, i[q.scalars1 + 3] = t.paperGrain, i[q.scalars2 + 0] = t.alpha, i[q.scalars2 + 1] = t.nucleiDrift, i[q.scalars2 + 2] = t.paletteDrift, i[q.scalars2 + 3] = t.breathDepth, i[q.scalars3 + 0] = t.breathPeriod, i[q.scalars3 + 1] = n.strength, i[q.scalars3 + 2] = n.radius, i[q.scalars3 + 3] = t.vividness ?? 1, i[q.cursor + 0] = n.x, i[q.cursor + 1] = Ot(n.y), i[q.cursor + 2] = t.metalPolish ?? 1, i[q.cursor + 3] = t.metalHeightScale ?? 1, a[q.ints0 + 0] = Math.min(t.palette.length, 8);
-	let s = Math.min(t.nuclei.length, 6);
-	a[q.ints0 + 1] = s, a[q.ints0 + 2] = mt[t.warpMode], a[q.ints0 + 3] = t.noiseOctaves, a[q.ints1 + 0] = B[t.medium], a[q.ints1 + 1] = V[t.huePath ?? "shorter"], a[q.ints1 + 2] = 0, a[q.ints1 + 3] = 0, F(t.palette, 8, o);
+function Ot(e, t, n, r, i = t.alpha) {
+	let { f32: a, i32: o, paletteScratch: s } = e;
+	a[K.scalars0 + 0] = r, a[K.scalars0 + 1] = t.softmaxBeta, a[K.scalars0 + 2] = t.valueVariance, a[K.scalars0 + 3] = t.warpAmount, a[K.scalars1 + 0] = t.warpScale, a[K.scalars1 + 1] = t.warpDrift, a[K.scalars1 + 2] = t.saturation, a[K.scalars1 + 3] = t.paperGrain, a[K.scalars2 + 0] = i, a[K.scalars2 + 1] = t.nucleiDrift, a[K.scalars2 + 2] = t.paletteDrift, a[K.scalars2 + 3] = t.breathDepth, a[K.scalars3 + 0] = t.breathPeriod, a[K.scalars3 + 1] = n.strength, a[K.scalars3 + 2] = n.radius, a[K.scalars3 + 3] = t.vividness ?? 1, a[K.cursor + 0] = n.x, a[K.cursor + 1] = Et(n.y), a[K.cursor + 2] = t.metalPolish ?? 1, a[K.cursor + 3] = t.metalHeightScale ?? 1, o[K.ints0 + 0] = Math.min(t.palette.length, 8);
+	let c = Math.min(t.nuclei.length, 8);
+	o[K.ints0 + 1] = c, o[K.ints0 + 2] = dt[t.warpMode], o[K.ints0 + 3] = t.noiseOctaves, o[K.ints1 + 0] = st[t.medium], o[K.ints1 + 1] = ct[t.huePath ?? "shorter"], o[K.ints1 + 2] = 0, o[K.ints1 + 3] = 0, H(t.palette, 8, s);
 	for (let e = 0; e < 8; e++) {
-		let t = q.palette + e * 4;
-		i[t + 0] = o[e * 3 + 0], i[t + 1] = o[e * 3 + 1], i[t + 2] = o[e * 3 + 2], i[t + 3] = 0;
+		let t = K.palette + e * 4;
+		a[t + 0] = s[e * 3 + 0], a[t + 1] = s[e * 3 + 1], a[t + 2] = s[e * 3 + 2], a[t + 3] = 0;
 	}
-	for (let e = 0; e < 6; e++) {
-		let n = q.nuc0 + e * 4, r = q.nuc1 + e * 4, a = q.nuc2 + e * 4;
-		if (e < s) {
+	for (let e = 0; e < 8; e++) {
+		let n = K.nuc0 + e * 4, r = K.nuc1 + e * 4, i = K.nuc2 + e * 4;
+		if (e < c) {
 			let o = t.nuclei[e];
-			i[n + 0] = o.x, i[n + 1] = Ot(o.y), i[n + 2] = o.radius, i[n + 3] = o.paletteBias, i[r + 0] = o.valueBias, i[r + 1] = o.driftRadius, i[r + 2] = o.driftPhase, i[r + 3] = o.elongation ?? 1, i[a + 0] = -(o.angle ?? 0) * Math.PI / 180, i[a + 1] = 0, i[a + 2] = 0, i[a + 3] = 0;
-		} else i[n + 0] = 0, i[n + 1] = 0, i[n + 2] = 0, i[n + 3] = 0, i[r + 0] = 0, i[r + 1] = 0, i[r + 2] = 0, i[r + 3] = 1, i[a + 0] = 0, i[a + 1] = 0, i[a + 2] = 0, i[a + 3] = 0;
+			a[n + 0] = o.x, a[n + 1] = Et(o.y), a[n + 2] = o.radius, a[n + 3] = o.paletteBias, a[r + 0] = o.valueBias, a[r + 1] = o.driftRadius, a[r + 2] = o.driftPhase, a[r + 3] = o.elongation ?? 1, a[i + 0] = -(o.angle ?? 0) * Math.PI / 180, a[i + 1] = 0, a[i + 2] = 0, a[i + 3] = 0;
+		} else a[n + 0] = 0, a[n + 1] = 0, a[n + 2] = 0, a[n + 3] = 0, a[r + 0] = 0, a[r + 1] = 0, a[r + 2] = 0, a[r + 3] = 1, a[i + 0] = 0, a[i + 1] = 0, a[i + 2] = 0, a[i + 3] = 0;
 	}
-	return i[q.scalars4 + 0] = t.strokeAmount, i[q.scalars4 + 1] = t.strokeScale, i[q.scalars4 + 2] = t.strokeAnisotropy, i[q.scalars4 + 3] = t.canvasGrain, i[q.scalars5 + 0] = t.wetEdge, i[q.scalars5 + 1] = t.granulation, i[q.scalars5 + 2] = t.brokenColor, i[q.scalars5 + 3] = t.kuwaharaQ ?? Dt, i[q.kuwahara + 0] = t.kuwaharaRadius ?? Tt, i[q.kuwahara + 1] = Et, i[q.kuwahara + 2] = 0, i[q.kuwahara + 3] = 0, e;
+	return a[K.scalars4 + 0] = t.strokeAmount, a[K.scalars4 + 1] = t.strokeScale, a[K.scalars4 + 2] = t.strokeAnisotropy, a[K.scalars4 + 3] = t.canvasGrain, a[K.scalars5 + 0] = t.wetEdge, a[K.scalars5 + 1] = t.granulation, a[K.scalars5 + 2] = t.brokenColor, a[K.scalars5 + 3] = t.kuwaharaQ ?? Tt, a[K.kuwahara + 0] = t.kuwaharaRadius ?? Ct, a[K.kuwahara + 1] = wt, a[K.kuwahara + 2] = 0, a[K.kuwahara + 3] = 0, e;
 }
-var J = {
+var q = {
 	scalars0: 0,
 	scalars1: 4,
 	scalars2: 8,
@@ -2022,154 +2065,155 @@ var J = {
 	cursor: 16,
 	ints: 20,
 	nuc0: 24,
-	nuc1: 48
-}, jt = (e) => 1 - e;
-function Mt() {
-	let e = /* @__PURE__ */ new ArrayBuffer(288);
+	nuc1: 56
+}, kt = (e) => 1 - e;
+function At() {
+	let e = /* @__PURE__ */ new ArrayBuffer(352);
 	return {
 		buffer: e,
 		f32: new Float32Array(e),
 		i32: new Int32Array(e)
 	};
 }
-function Nt(e, t, n, r, i) {
-	let { f32: a, i32: o } = e;
-	a[J.scalars0 + 0] = r, a[J.scalars0 + 1] = t.warpAmount, a[J.scalars0 + 2] = t.warpScale, a[J.scalars0 + 3] = t.warpDrift, a[J.scalars1 + 0] = t.softmaxBeta, a[J.scalars1 + 1] = t.nucleiDrift, a[J.scalars1 + 2] = n.strength, a[J.scalars1 + 3] = n.radius, a[J.scalars2 + 0] = t.saturation, a[J.scalars2 + 1] = t.paperGrain, a[J.scalars2 + 2] = t.alpha, a[J.scalars2 + 3] = t.vividness ?? 1, a[J.image + 0] = t.imageBlur?.min ?? .004, a[J.image + 1] = t.imageBlur?.max ?? .06, a[J.image + 2] = i, a[J.image + 3] = 0, a[J.cursor + 0] = n.x, a[J.cursor + 1] = jt(n.y), a[J.cursor + 2] = 0, a[J.cursor + 3] = 0;
-	let s = Math.min(t.nuclei.length, 6);
-	o[J.ints + 0] = s, o[J.ints + 1] = t.noiseOctaves, o[J.ints + 2] = 0, o[J.ints + 3] = 0;
-	for (let e = 0; e < 6; e++) {
-		let n = J.nuc0 + e * 4, r = J.nuc1 + e * 4;
-		if (e < s) {
+function jt(e, t, n, r, i, a = t.alpha) {
+	let { f32: o, i32: s } = e;
+	o[q.scalars0 + 0] = r, o[q.scalars0 + 1] = t.warpAmount, o[q.scalars0 + 2] = t.warpScale, o[q.scalars0 + 3] = t.warpDrift, o[q.scalars1 + 0] = t.softmaxBeta, o[q.scalars1 + 1] = t.nucleiDrift, o[q.scalars1 + 2] = n.strength, o[q.scalars1 + 3] = n.radius, o[q.scalars2 + 0] = t.saturation, o[q.scalars2 + 1] = t.paperGrain, o[q.scalars2 + 2] = a, o[q.scalars2 + 3] = t.vividness ?? 1, o[q.image + 0] = t.imageBlur?.min ?? .004, o[q.image + 1] = t.imageBlur?.max ?? .06, o[q.image + 2] = i, o[q.image + 3] = 0, o[q.cursor + 0] = n.x, o[q.cursor + 1] = kt(n.y), o[q.cursor + 2] = 0, o[q.cursor + 3] = 0;
+	let c = Math.min(t.nuclei.length, 8);
+	s[q.ints + 0] = c, s[q.ints + 1] = t.noiseOctaves, s[q.ints + 2] = 0, s[q.ints + 3] = 0;
+	for (let e = 0; e < 8; e++) {
+		let n = q.nuc0 + e * 4, r = q.nuc1 + e * 4;
+		if (e < c) {
 			let i = t.nuclei[e];
-			a[n + 0] = i.x, a[n + 1] = jt(i.y), a[n + 2] = i.radius, a[n + 3] = i.valueBias, a[r + 0] = i.driftRadius, a[r + 1] = i.driftPhase, a[r + 2] = i.elongation ?? 1, a[r + 3] = -(i.angle ?? 0) * Math.PI / 180;
-		} else a[n + 0] = 0, a[n + 1] = 0, a[n + 2] = 0, a[n + 3] = 0, a[r + 0] = 0, a[r + 1] = 0, a[r + 2] = 1, a[r + 3] = 0;
+			o[n + 0] = i.x, o[n + 1] = kt(i.y), o[n + 2] = i.radius, o[n + 3] = i.valueBias, o[r + 0] = i.driftRadius, o[r + 1] = i.driftPhase, o[r + 2] = i.elongation ?? 1, o[r + 3] = -(i.angle ?? 0) * Math.PI / 180;
+		} else o[n + 0] = 0, o[n + 1] = 0, o[n + 2] = 0, o[n + 3] = 0, o[r + 0] = 0, o[r + 1] = 0, o[r + 2] = 1, o[r + 3] = 0;
 	}
 	return e;
 }
 //#endregion
 //#region src/components/aurora/composables/wgpuSetup.ts
-var Pt = 64, Ft = 8, Y = 2;
-function It(e) {
-	let { canvas: t, getCursorScalars: n, getConfig: r, getReducedMotion: i, pointerField: a, getDecodedImage: o, registerImageUploader: s } = e, c = null;
-	return function(e, l, u) {
-		if (r().source === "image") return Lt(e, l, u, {
+var J = 2, Mt = {
+	color: {
+		srcFactor: "one",
+		dstFactor: "one-minus-src-alpha",
+		operation: "add"
+	},
+	alpha: {
+		srcFactor: "one",
+		dstFactor: "one-minus-src-alpha",
+		operation: "add"
+	}
+};
+function Nt(e) {
+	let { canvas: t, opaquePresentation: n, getCursorScalars: r, getConfig: i, getReducedMotion: a, getRenderTime: o, pointerField: s, getDecodedImage: c, registerImageUploader: l } = e, u = null;
+	return function(e, d, f) {
+		if (i().source === "image") return Pt(e, d, f, {
 			canvas: t,
-			getCursorScalars: n,
-			getConfig: r,
-			getReducedMotion: i,
-			pointerField: a,
-			getDecodedImage: o,
-			registerImageUploader: s
+			opaquePresentation: n,
+			getCursorScalars: r,
+			getConfig: i,
+			getReducedMotion: a,
+			getRenderTime: o,
+			pointerField: s,
+			getDecodedImage: c,
+			registerImageUploader: l
 		});
-		let d = e.createShaderModule({
+		let p = e.createShaderModule({
 			label: "[Aurora] aurora.wgsl",
-			code: Ct
-		}), f = e.createBuffer({
+			code: xt
+		}), m = e.createBuffer({
 			label: "[Aurora] uniforms",
-			size: 576,
-			usage: Pt | Ft
-		}), p = e.createBindGroupLayout({
+			size: 672,
+			usage: 72
+		}), h = e.createBindGroupLayout({
 			label: "[Aurora] bind-group-0",
 			entries: [{
 				binding: 0,
-				visibility: Y,
+				visibility: J,
 				buffer: { type: "uniform" }
 			}]
-		}), m = e.createRenderPipeline({
+		}), g = e.createRenderPipeline({
 			label: "[Aurora] pipeline",
-			layout: e.createPipelineLayout({ bindGroupLayouts: [p] }),
+			layout: e.createPipelineLayout({ bindGroupLayouts: [h] }),
 			vertex: {
-				module: d,
+				module: p,
 				entryPoint: "vs_main"
 			},
 			fragment: {
-				module: d,
+				module: p,
 				entryPoint: "fs_main",
 				targets: [{
-					format: u,
-					blend: {
-						color: {
-							srcFactor: "one",
-							dstFactor: "one-minus-src-alpha",
-							operation: "add"
-						},
-						alpha: {
-							srcFactor: "one",
-							dstFactor: "one-minus-src-alpha",
-							operation: "add"
-						}
-					}
+					format: f,
+					blend: n ? void 0 : Mt
 				}]
 			},
 			primitive: { topology: "triangle-list" }
-		}), h = e.createBindGroup({
+		}), _ = e.createBindGroup({
 			label: "[Aurora] bind-group",
-			layout: p,
+			layout: h,
 			entries: [{
 				binding: 0,
-				resource: { buffer: f }
+				resource: { buffer: m }
 			}]
-		}), g = kt();
-		function _(e) {}
-		function v(t) {
-			let o = +!i(), s = c === null ? 0 : Math.max(0, (t - c) * 1e3);
-			c = t, a.tick(o === 0 ? 0 : s);
-			let u = G(a, n(), o);
-			At(g, r(), u, t), e.queue.writeBuffer(f, 0, g.buffer);
-			let d = l.getCurrentTexture().createView(), p = e.createCommandEncoder({ label: "[Aurora] frame" }), _ = p.beginRenderPass({ colorAttachments: [{
-				view: d,
+		}), v = Dt();
+		function y(e) {}
+		function b(t) {
+			let c = +!a(), l = u === null ? 0 : Math.max(0, (t - u) * 1e3);
+			u = t, s.tick(c === 0 ? 0 : l);
+			let f = z(s, r(), c), p = i();
+			Ot(v, p, f, o(t), n ? 1 : p.alpha), e.queue.writeBuffer(m, 0, v.buffer);
+			let h = d.getCurrentTexture().createView(), y = e.createCommandEncoder({ label: "[Aurora] frame" }), b = y.beginRenderPass({ colorAttachments: [{
+				view: h,
 				clearValue: {
 					r: 0,
 					g: 0,
 					b: 0,
-					a: 0
+					a: +!!n
 				},
 				loadOp: "clear",
 				storeOp: "store"
 			}] });
-			_.setPipeline(m), _.setBindGroup(0, h), _.draw(3, 1, 0, 0), _.end(), e.queue.submit([p.finish()]);
+			b.setPipeline(g), b.setBindGroup(0, _), b.draw(3, 1, 0, 0), b.end(), e.queue.submit([y.finish()]);
 		}
-		function y() {
-			if (i()) return !1;
-			let e = r();
-			return e.nucleiDrift !== 0 || e.paletteDrift !== 0 || e.breathDepth !== 0 || e.warpDrift !== 0 ? !0 : K(a);
+		function x() {
+			if (a()) return !1;
+			let e = i();
+			return e.nucleiDrift !== 0 || e.paletteDrift !== 0 || e.breathDepth !== 0 || e.warpDrift !== 0 || B(s);
 		}
 		return {
-			frame: v,
-			shouldContinue: y,
-			resize: _,
-			time: (e) => i() ? 3.7 : e,
+			frame: b,
+			shouldContinue: x,
+			resize: y,
 			teardown: () => {
-				f.destroy();
+				m.destroy();
 			}
 		};
 	};
 }
-function Lt(e, t, n, r) {
-	let { canvas: i, getCursorScalars: a, getConfig: o, getReducedMotion: s, pointerField: c, getDecodedImage: l, registerImageUploader: u } = r, d = null, f = e.createShaderModule({
+function Pt(e, t, n, r) {
+	let { canvas: i, opaquePresentation: a, getCursorScalars: o, getConfig: s, getReducedMotion: c, getRenderTime: l, pointerField: u, getDecodedImage: d, registerImageUploader: f } = r, p = null, m = e.createShaderModule({
 		label: "[Aurora] aurora-image.wgsl",
-		code: wt
-	}), p = e.createBuffer({
+		code: St
+	}), h = e.createBuffer({
 		label: "[Aurora] image uniforms",
-		size: 288,
-		usage: Pt | Ft
-	}), m = e.createSampler({
+		size: 352,
+		usage: 72
+	}), g = e.createSampler({
 		label: "[Aurora] image sampler",
 		magFilter: "linear",
 		minFilter: "linear",
 		addressModeU: "clamp-to-edge",
 		addressModeV: "clamp-to-edge"
-	}), h = e.createBindGroupLayout({
+	}), _ = e.createBindGroupLayout({
 		label: "[Aurora] image bind-group-0",
 		entries: [
 			{
 				binding: 0,
-				visibility: Y,
+				visibility: J,
 				buffer: { type: "uniform" }
 			},
 			{
 				binding: 1,
-				visibility: Y,
+				visibility: J,
 				texture: {
 					sampleType: "float",
 					viewDimension: "2d"
@@ -2177,222 +2221,231 @@ function Lt(e, t, n, r) {
 			},
 			{
 				binding: 2,
-				visibility: Y,
+				visibility: J,
 				sampler: { type: "filtering" }
 			}
 		]
-	}), g = e.createRenderPipeline({
+	}), v = e.createRenderPipeline({
 		label: "[Aurora] image pipeline",
-		layout: e.createPipelineLayout({ bindGroupLayouts: [h] }),
+		layout: e.createPipelineLayout({ bindGroupLayouts: [_] }),
 		vertex: {
-			module: f,
+			module: m,
 			entryPoint: "vs_main"
 		},
 		fragment: {
-			module: f,
+			module: m,
 			entryPoint: "fs_main",
 			targets: [{
 				format: n,
-				blend: {
-					color: {
-						srcFactor: "one",
-						dstFactor: "one-minus-src-alpha",
-						operation: "add"
-					},
-					alpha: {
-						srcFactor: "one",
-						dstFactor: "one-minus-src-alpha",
-						operation: "add"
-					}
-				}
+				blend: a ? void 0 : Mt
 			}]
 		},
 		primitive: { topology: "triangle-list" }
-	}), _ = Ve(e, l() ?? Le()).texture;
-	function v() {
+	}), y = P(e, d() ?? N()).texture;
+	function b() {
 		return e.createBindGroup({
 			label: "[Aurora] image bind-group",
-			layout: h,
+			layout: _,
 			entries: [
 				{
 					binding: 0,
-					resource: { buffer: p }
+					resource: { buffer: h }
 				},
 				{
 					binding: 1,
-					resource: _.createView()
+					resource: y.createView()
 				},
 				{
 					binding: 2,
-					resource: m
+					resource: g
 				}
 			]
 		});
 	}
-	let y = v();
-	u((t) => {
-		_.destroy(), _ = Ve(e, t).texture, y = v();
+	let x = b();
+	f((t) => {
+		y.destroy(), y = P(e, t).texture, x = b();
 	});
-	let b = Mt();
-	function x(e) {}
-	function S(n) {
-		let r = +!s(), l = d === null ? 0 : Math.max(0, (n - d) * 1e3);
-		d = n, c.tick(r === 0 ? 0 : l);
-		let u = G(c, a(), r), f = i.height > 0 ? i.width / i.height : 1;
-		Nt(b, o(), u, n, f), e.queue.writeBuffer(p, 0, b.buffer);
-		let m = t.getCurrentTexture().createView(), h = e.createCommandEncoder({ label: "[Aurora] image frame" }), _ = h.beginRenderPass({ colorAttachments: [{
-			view: m,
+	let S = At();
+	function C(e) {}
+	function w(n) {
+		let r = +!c(), d = p === null ? 0 : Math.max(0, (n - p) * 1e3);
+		p = n, u.tick(r === 0 ? 0 : d);
+		let f = z(u, o(), r), m = i.height > 0 ? i.width / i.height : 1, g = s();
+		jt(S, g, f, l(n), m, a ? 1 : g.alpha), e.queue.writeBuffer(h, 0, S.buffer);
+		let _ = t.getCurrentTexture().createView(), y = e.createCommandEncoder({ label: "[Aurora] image frame" }), b = y.beginRenderPass({ colorAttachments: [{
+			view: _,
 			clearValue: {
 				r: 0,
 				g: 0,
 				b: 0,
-				a: 0
+				a: +!!a
 			},
 			loadOp: "clear",
 			storeOp: "store"
 		}] });
-		_.setPipeline(g), _.setBindGroup(0, y), _.draw(3, 1, 0, 0), _.end(), e.queue.submit([h.finish()]);
+		b.setPipeline(v), b.setBindGroup(0, x), b.draw(3, 1, 0, 0), b.end(), e.queue.submit([y.finish()]);
 	}
-	function C() {
-		if (s()) return !1;
-		let e = o();
-		return e.nucleiDrift !== 0 || e.warpDrift !== 0 || e.paletteDrift !== 0 ? !0 : K(c);
+	function T() {
+		if (c()) return !1;
+		let e = s();
+		return e.nucleiDrift !== 0 || e.warpDrift !== 0 || e.paletteDrift !== 0 || B(u);
 	}
 	return {
-		frame: S,
-		shouldContinue: C,
-		resize: x,
-		time: (e) => s() ? 3.7 : e,
+		frame: w,
+		shouldContinue: T,
+		resize: C,
 		teardown: () => {
-			u(null), _.destroy(), p.destroy();
+			f(null), y.destroy(), h.destroy();
 		}
 	};
 }
 //#endregion
 //#region src/components/aurora/composables/runtime.ts
-function Rt(e) {
-	return e.mode === "capture" ? !0 : e.initStrategy === "eager";
+function Ft(e) {
+	return e.mode === "capture" || e.initStrategy === "eager";
 }
-function zt(e) {
+function It(e) {
 	return typeof e.preserveDrawingBuffer == "boolean" ? e.preserveDrawingBuffer : e.mode === "capture";
 }
-function Bt(e, n, r = {}) {
-	let i = zt(r), a = !r.forceWebGLUnderSoftwareRaster && j(), o = n, s = t({
+function Lt(e = "live") {
+	let t = e !== "capture";
+	return {
+		opaque: t,
+		alphaMode: t ? "opaque" : "premultiplied",
+		contextAlpha: !t
+	};
+}
+var Rt = (e) => Math.min(1, Math.max(0, e));
+function Y(e) {
+	return e.interactivity?.swirl === !0 || e.medium !== "smooth" && e.interactivity?.light === !0;
+}
+var zt = 3.7;
+function Bt(e, t, n, r) {
+	return r ? zt : e.interactivity?.scroll === !0 ? t + Math.min(1, Math.max(0, n)) * e.breathPeriod : t;
+}
+function Vt(e, n, r = {}) {
+	let i = It(r), a = Lt(r.mode), o = e.style.opacity, s = (t) => {
+		a.opaque && (e.style.opacity = String(Rt(t)));
+	};
+	s(n.alpha);
+	let c = !r.forceWebGLUnderSoftwareRaster && F(), l = n, u = 0, d = t({
 		mass: 1,
 		damping: .9,
 		attractorResponse: .28,
 		leadGain: .08,
 		halfLifeMs: 110
-	}), c = .8, l = .25, u = () => ({
-		strength: c,
-		radius: l
-	}), d = null, m = He({
-		wake: () => h.wake(),
+	}), f = .8, p = .25, m = () => {
+		let e = l.interactivity, t = Y(l);
+		return {
+			strength: t ? f : 0,
+			radius: p,
+			amplitude: t ? Math.min(1, Math.max(0, e?.amplitude ?? .5)) : 0
+		};
+	}, h = null, g = ye({
+		wake: () => b.wake(),
 		onError: r.onInitError
-	}), h = a ? {
-		arm: () => {},
+	}), _ = c ? /* @__PURE__ */ Error("[Aurora] GPU animation is unavailable under software rasterization") : null, v = !1;
+	function y() {
+		!_ || v || (v = !0, r.onInitError?.(_));
+	}
+	let b = c ? {
+		backend: "webgl2",
+		arm: y,
+		armAsync: () => (y(), Promise.reject(_)),
+		presize: () => {},
 		suspend: () => {},
 		resume: () => {},
 		wake: () => {},
 		renderAt: () => {},
 		dispose: () => {},
 		reducedMotion: !1
-	} : f(e, {
+	} : T(e, {
 		mode: r.mode === "capture" ? "capture" : "live",
-		dprPolicy: p,
+		alphaMode: a.alphaMode,
+		dprPolicy: x,
 		revealBloom: r.revealBloom ?? !1,
 		contextAttrs: {
 			antialias: !1,
-			alpha: !0,
-			premultipliedAlpha: !0,
+			alpha: a.contextAlpha,
+			premultipliedAlpha: a.contextAlpha,
 			preserveDrawingBuffer: i
 		},
-		setupWGPU: It({
+		setupWGPU: Nt({
 			canvas: e,
-			getCursorScalars: u,
-			getConfig: () => o,
-			getReducedMotion: () => h.reducedMotion,
-			pointerField: s,
-			getDecodedImage: () => m.getDecodedImage(),
-			registerImageUploader: (e) => m.setImageUploader(e)
+			opaquePresentation: a.opaque,
+			getCursorScalars: m,
+			getConfig: () => l,
+			getReducedMotion: () => b.reducedMotion,
+			getRenderTime: (e) => Bt(l, e, u, b.reducedMotion),
+			pointerField: d,
+			getDecodedImage: () => g.getDecodedImage(),
+			registerImageUploader: (e) => g.setImageUploader(e)
 		}),
-		setupGL: (t) => {
-			let n = o.source === "image", { program: r, vs: i, fs: a, uniforms: c, geometry: l } = Ge(t, xe, n ? Ne : Me), f = n ? Ue(t, r, m) : null;
-			function p(n) {
-				t.viewport(0, 0, n?.w ?? e.width, n?.h ?? e.height), t.useProgram(r);
+		setupGL: bt({
+			opaquePresentation: a.opaque,
+			getConfig: () => l,
+			getReducedMotion: () => b.reducedMotion,
+			getRenderTime: (e) => Bt(l, e, u, b.reducedMotion),
+			getCursorScalars: m,
+			pointerField: d,
+			imageCoordinator: g,
+			registerConfigUploader: (e) => {
+				h = e;
 			}
-			let g = bt(t, r, c), _ = St({
-				gl: t,
-				prog: r,
-				uniforms: c,
-				pointerField: s,
-				getCursorScalars: u,
-				getConfig: () => o,
-				getReducedMotion: () => h.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), d = (e) => {
-				o = e, g(e);
-			}, d(o), {
-				frame: _.frame,
-				shouldContinue: _.needsAnimation,
-				resize: p,
-				time: (e) => h.reducedMotion ? 3.7 : e,
-				teardown: () => {
-					t.deleteProgram(r), t.deleteShader(i), t.deleteShader(a), t.deleteBuffer(l.buf), t.deleteVertexArray(l.vao), f?.();
-				}
-			};
-		},
+		}),
 		onInitError: r.onInitError ? (e) => r.onInitError?.(e instanceof Error ? e : Error(String(e))) : void 0,
 		onStatus: r.onRendererStatus
 	});
-	a && r.onRendererStatus?.(w());
-	function g(e, t, n = .8) {
-		c = n, s.setActive(!0), s.setPointer(e, t), h.wake();
+	_ && r.onRendererStatus?.(ee("webgl2", "Software renderer", _));
+	function S(e, t, n = .8) {
+		Y(l) && (f = n, d.setActive(!0), d.setPointer(e, t), b.wake());
 	}
-	function _() {
-		s.setActive(!1), h.wake();
+	function C() {
+		d.setActive(!1), b.wake();
 	}
-	function v(e) {
-		l = e, h.wake();
+	function w(e) {
+		p = e, b.wake();
 	}
-	function y(e) {
-		h.wake();
+	function E(e) {
+		let t = Math.min(1, Math.max(0, e));
+		t !== u && (u = t, l.interactivity?.scroll === !0 && !b.reducedMotion && b.wake());
 	}
-	function b() {
-		h.armAsync ? h.armAsync().catch((e) => {
-			r.onInitError?.(e instanceof Error ? e : Error(String(e)));
-		}) : h.arm();
+	function D() {
+		b.armAsync().catch(() => void 0);
 	}
-	function x() {
-		return h.armAsync ? h.armAsync() : (h.arm(), Promise.resolve());
+	function te() {
+		return b.armAsync();
 	}
-	return m.ensureDecoded(o), r.mode !== "capture" && Rt(r) && b(), {
-		arm: () => b(),
-		armAsync: () => x(),
+	return g.ensureDecoded(l), r.mode !== "capture" && Ft(r) && D(), {
+		arm: () => D(),
+		armAsync: () => te(),
 		update: (e) => {
-			o = e, d?.(e), m.ensureDecoded(e), h.wake();
+			l = e, s(e.alpha), Y(e) || d.setActive(!1), h?.(e), g.ensureDecoded(e), b.wake();
 		},
-		setCursor: g,
-		clearCursor: _,
-		setCursorRadius: v,
-		setReducedMotion: y,
+		setCursor: S,
+		clearCursor: C,
+		setCursorRadius: w,
+		setScrollProgress: E,
 		get reducedMotion() {
-			return h.reducedMotion;
+			return b.reducedMotion;
 		},
-		pause: (e = "manual") => h.suspend(e),
-		resume: (e = "manual") => h.resume(e),
-		renderAt: (e) => h.renderAt(e),
-		dispose: () => h.dispose()
+		pause: (e = "manual") => b.suspend(e),
+		resume: (e = "manual") => b.resume(e),
+		renderAt: (e) => b.renderAt(e),
+		dispose: () => {
+			b.dispose(), a.opaque && (e.style.opacity = o);
+		}
 	};
 }
 //#endregion
 //#region src/components/aurora/composables/configSource.ts
-function Vt(e) {
+function Ht(e) {
 	return typeof e == "function" ? e : e && typeof e == "object" && "value" in e ? () => e.value : () => e;
 }
 //#endregion
 //#region src/components/aurora/composables/useAurora.ts
-function Ht(e) {
+function Ut(e) {
 	if (typeof window > "u") return () => {};
 	if (typeof window.requestIdleCallback == "function") {
 		let t = window.requestIdleCallback(() => e(), { timeout: 2e3 });
@@ -2409,63 +2462,61 @@ function Ht(e) {
 		r = !0, cancelAnimationFrame(t), n !== void 0 && clearTimeout(n);
 	};
 }
-function Ut(e, t, n = {}, r = {}) {
-	let o = Vt(t), s = r.renderMode === "css", c = null, l = null, u = null, d = null, f = null, p = null, m = null, h = !1, g = pe(!1), _ = me(s ? w() : ne("webgl2")), v = n.mode === "capture" || n.initStrategy === "eager";
-	function y() {
-		m && c && c.setReducedMotion(m.matches);
-	}
-	function b(e) {
+function Wt(e, t, n = {}, r = {}) {
+	let o = Ht(t), s = r.renderMode === "css", c = null, l = null, u = null, d = null, f = null, p = null, m = !1, h = de(!1), g = fe(s ? D() : E("webgl2")), _ = i({
+		target: e,
+		trackExit: !0,
+		enabled: k(() => !s && o().interactivity?.scroll === !0)
+	});
+	d = M(_, (e) => c?.setScrollProgress(e), { flush: "sync" });
+	let v = n.mode === "capture" || n.initStrategy === "eager";
+	function y(e) {
 		let t = e instanceof Error ? e : Error(String(e));
-		_.value = re(_.value.engine, _.value.adapter, t), n.onInitError?.(t);
+		g.value = ee(g.value.engine, g.value.adapter, t), n.onInitError?.(t);
 	}
-	function x() {
-		if (!(h || !c)) {
-			h = !0;
-			try {
-				c.arm();
-			} catch (e) {
-				b(e);
-				return;
-			}
-			g.value = !0, c.update(o()), typeof window.matchMedia == "function" && (m = window.matchMedia("(prefers-reduced-motion: reduce)"), m.addEventListener("change", y)), l = k(o, (e) => c?.update(e), { deep: !0 }), o().interactivity?.scroll && e.value && (d = k(i({
-				target: e,
-				trackExit: !0
-			}), (e) => {
-				!c || c.reducedMotion || c.setCursorRadius(.2 + e * .25);
-			}));
+	async function b() {
+		if (m || !c) return;
+		m = !0;
+		let e = c;
+		try {
+			await e.armAsync();
+		} catch (e) {
+			g.value.phase !== "error" && y(e);
+			return;
 		}
+		c !== e || g.value.engine === "css" || (h.value = !0, e.update(o()), e.setScrollProgress(_.value), l = M(o, (t) => e.update(t), { deep: !0 }));
 	}
-	return D(() => {
+	return ce(() => {
 		let t = e.value;
 		if (!t || s) return;
 		try {
-			c = Bt(t, o(), {
+			c = Vt(t, o(), {
 				initStrategy: "deferred",
 				...n,
 				onRendererStatus: (e) => {
-					_.value = e, n.onRendererStatus?.(e);
+					g.value = e, h.value = e.phase === "ready", n.onRendererStatus?.(e);
 				}
 			});
 		} catch (e) {
-			b(e);
+			y(e);
 			return;
 		}
 		if (v) {
-			x();
+			b();
 			return;
 		}
 		p = a(e, {
-			pause: () => c?.pause("off-screen"),
-			resume: () => c?.resume("off-screen")
+			pause: () => c?.pause("off-screen-io"),
+			resume: () => c?.resume("off-screen-io")
 		}, { pauseWhenHidden: !1 });
 		let r = p.isIntersecting;
-		u = k(r, (e) => {
-			!e || h || f || (f = Ht(() => {
-				f = null, r.value && x();
+		u = M(r, (e) => {
+			!e || m || f || (f = Ut(() => {
+				f = null, r.value && b();
 			}));
 		}, { immediate: !0 });
-	}), E(() => {
-		f?.(), u?.(), l?.(), d?.(), p?.dispose(), m?.removeEventListener("change", y), c?.dispose(), c = null;
+	}), se(() => {
+		f?.(), u?.(), l?.(), d?.(), p?.dispose(), c?.dispose(), c = null;
 	}), {
 		setCursor: (e, t, n) => c?.setCursor(e, t, n),
 		clearCursor: () => c?.clearCursor(),
@@ -2473,8 +2524,8 @@ function Ut(e, t, n = {}, r = {}) {
 		renderAt: (e) => c?.renderAt(e),
 		pause: () => c?.pause(),
 		resume: () => c?.resume(),
-		isArmed: O(g),
-		rendererStatus: O(_)
+		isArmed: ue(h),
+		rendererStatus: ue(g)
 	};
 }
 //#endregion
@@ -2483,7 +2534,7 @@ function X(e) {
 	let t = Math.max(0, Math.min(1, e));
 	return t <= .0031308 ? t * 12.92 : 1.055 * t ** (1 / 2.4) - .055;
 }
-function Wt([e, t, n]) {
+function Gt([e, t, n]) {
 	let r = .76, i = Math.min(e, Math.min(t, n)), a = i < .08 ? i - 6.25 * i * i : .04, o = e - a, s = t - a, c = n - a, l = Math.max(o, Math.max(s, c)), u = (e) => Math.max(0, Math.min(1, e));
 	if (l < r) return [
 		u(o),
@@ -2499,10 +2550,10 @@ function Wt([e, t, n]) {
 		u(c + (f - c) * m)
 	];
 }
-function Gt([e, t, n]) {
+function Kt([e, t, n]) {
 	return .2126 * e + .7152 * t + .0722 * n;
 }
-function Kt(e, t) {
+function qt(e, t) {
 	let n = e.length;
 	if (n === 0) return [
 		0,
@@ -2517,7 +2568,7 @@ function Kt(e, t) {
 		s[2] + (c[2] - s[2]) * o
 	];
 }
-function qt(e, t, n, r) {
+function Jt(e, t, n, r) {
 	let i = 0, a = 0, o = 0;
 	for (let s of e) {
 		let e = n - s.x, c = r - s.y, l = (s.angle ?? 0) * Math.PI / 180, u = Math.cos(l), d = Math.sin(l), f = u * e + d * c, p = -d * e + u * c, m = f / Math.max(s.elongation ?? 1, .01), h = p, g = m * m + h * h, _ = Math.max(s.radius, .01), v = Math.exp(-t * g / (_ * _));
@@ -2529,13 +2580,13 @@ function qt(e, t, n, r) {
 		valueMod: a / s
 	};
 }
-function Jt(e, t, n) {
-	let r = e.palette.map((e) => u(e)), { paletteId: i, valueMod: a } = qt(e.nuclei, e.softmaxBeta, t, n), o = Kt(r, i), s = 1 + e.valueVariance * a, c = [
+function Z(e, t, n) {
+	let r = e.palette.map((e) => d(e)), { paletteId: i, valueMod: a } = Jt(e.nuclei, e.softmaxBeta, t, n), o = qt(r, i), s = 1 + e.valueVariance * a, c = [
 		o[0] * s,
 		o[1] * s,
 		o[2] * s
 	];
-	return c = Wt(c), c = [
+	return c = Gt(c), c = [
 		Math.max(0, Math.min(1, c[0] * .985 + .008)),
 		Math.max(0, Math.min(1, c[1] * .985 + .008)),
 		Math.max(0, Math.min(1, c[2] * .985 + .008))
@@ -2550,7 +2601,7 @@ function Yt([e, t, n]) {
 	return `rgb(${r(e)}, ${r(t)}, ${r(n)})`;
 }
 function Xt(e) {
-	return Gt(e.map((e) => {
+	return Kt(e.map((e) => {
 		let t = Math.max(0, Math.min(1, e));
 		return t <= .04045 ? t / 12.92 : ((t + .055) / 1.055) ** 2.4;
 	}));
@@ -2568,7 +2619,7 @@ function Zt(e, t = {}) {
 		0
 	];
 	for (let t = 0; t < n; t++) for (let s = 0; s < n; s++) {
-		let c = (s + .5) / n, l = (t + .5) / n, u = Jt(e, c, l);
+		let c = (s + .5) / n, l = (t + .5) / n, u = Z(e, c, l);
 		r.push({
 			x: c,
 			y: l,
@@ -2638,10 +2689,10 @@ function Qt(e, t) {
 }
 //#endregion
 //#region src/components/aurora/Aurora.vue?vue&type=script&setup=true&lang.ts
-var $t = ["data-aurora-substrate"], en = /* @__PURE__ */ e(/* @__PURE__ */ ce({
+var $t = ["data-aurora-substrate"], en = /*#__PURE__*/ e(/* @__PURE__ */ re({
 	__name: "Aurora",
 	props: {
-		config: { default: () => P },
+		config: { default: () => V },
 		runtimeOptions: {},
 		onInitError: {},
 		renderMode: { default: "auto" },
@@ -2649,15 +2700,15 @@ var $t = ["data-aurora-substrate"], en = /* @__PURE__ */ e(/* @__PURE__ */ ce({
 	},
 	emits: ["rendererStatus"],
 	setup(e, { expose: t, emit: n }) {
-		let r = n, i = e, a = M(i.renderMode, { forceWebGLUnderSoftwareRaster: i.runtimeOptions?.forceWebGLUnderSoftwareRaster ?? !1 }), o = T(() => Math.max(0, Math.min(1, i.opacityCeiling))), s = pe(null), c = le(), l = c?.appContext.config.errorHandler, u = l ? (e) => l(e, c?.proxy ?? null, "Aurora initialization") : void 0, d = Ut(s, () => i.config, {
+		let r = n, i = e, a = I(i.renderMode, { forceWebGLUnderSoftwareRaster: i.runtimeOptions?.forceWebGLUnderSoftwareRaster ?? !1 }), o = k(() => Math.max(0, Math.min(1, i.opacityCeiling))), s = de(null), c = ie(), l = c?.appContext.config.errorHandler, u = l ? (e) => l(e, c?.proxy ?? null, "Aurora initialization") : void 0, d = Wt(s, () => i.config, {
 			...i.runtimeOptions ?? {},
 			onInitError: i.onInitError ?? i.runtimeOptions?.onInitError ?? u
 		}, { renderMode: a });
-		k(d.rendererStatus, (e) => r("rendererStatus", e), {
+		M(d.rendererStatus, (e) => r("rendererStatus", e), {
 			immediate: !0,
 			flush: "sync"
 		});
-		let f = T(() => Zt(i.config)), p = T(() => f.value.backgroundImage), m = T(() => f.value.backgroundColor);
+		let f = k(() => Zt(i.config)), p = k(() => f.value.backgroundImage), m = k(() => f.value.backgroundColor);
 		return t({
 			config: i.config,
 			canvasRef: s,
@@ -2669,29 +2720,29 @@ var $t = ["data-aurora-substrate"], en = /* @__PURE__ */ e(/* @__PURE__ */ ce({
 			resume: d.resume,
 			isArmed: d.isArmed,
 			rendererStatus: d.rendererStatus
-		}), (e, t) => (fe(), oe("div", {
+		}), (e, t) => (le(), ne("div", {
 			class: "aurora-root block h-full w-full overflow-hidden",
-			"data-aurora-substrate": he(a),
-			style: de({ "--aurora-opacity-ceiling": o.value })
-		}, [se("div", {
-			class: "aurora-placeholder h-full w-full",
+			"data-aurora-substrate": j(a),
+			style: oe({ opacity: o.value })
+		}, [A("div", {
+			class: "aurora-placeholder h-full min-h-0 w-full",
 			"aria-hidden": "true",
-			style: de({
+			style: oe({
 				backgroundImage: p.value,
 				backgroundColor: m.value
 			})
-		}, null, 4), se("canvas", {
+		}, null, 4), A("div", { class: ae(["aurora-canvas-layer h-full min-h-0 w-full", { "aurora-canvas-layer--armed": j(d).isArmed.value }]) }, [A("canvas", {
 			ref_key: "canvasRef",
 			ref: s,
 			"aria-hidden": "true",
-			class: ue(["aurora-canvas block h-full w-full", { "aurora-canvas--armed": he(d).isArmed.value }])
-		}, null, 2)], 12, $t));
+			class: ae(["aurora-canvas block h-full w-full", { "aurora-canvas--armed": j(d).isArmed.value }])
+		}, null, 2)], 2)], 12, $t));
 	}
-}), [["__scopeId", "data-v-7453c302"]]);
+}), [["__scopeId", "data-v-aebed9bd"]]);
 //#endregion
 //#region src/components/aurora/composables/useCursorInteraction.ts
 function tn(e, t, n) {
-	let r = Vt(t), i = n.hitFraction ?? .35, a = null, o = null;
+	let r = Ht(t), i = n.hitFraction ?? .35, a = null, o = null;
 	function s(e, t) {
 		let n = t.getBoundingClientRect();
 		return {
@@ -2749,7 +2800,7 @@ function tn(e, t, n) {
 		if (!n) return;
 		let { x: i, y: c } = s(t, n), u = l(i, c);
 		if (t.altKey && u === null) {
-			if (r().nuclei.length >= 6) return;
+			if (r().nuclei.length >= 8) return;
 			r().nuclei.push(f(i, c)), t.preventDefault();
 			return;
 		}
@@ -2778,20 +2829,20 @@ function tn(e, t, n) {
 		}, a = n.getBoundingClientRect(), o = l((i.clientX - a.left) / Math.max(a.width, 1), (i.clientY - a.top) / Math.max(a.height, 1));
 		o !== null && r().nuclei.length > 1 && (r().nuclei.splice(o, 1), t.preventDefault());
 	}
-	return D(() => {
+	return ce(() => {
 		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", _));
-	}), E(() => {
+	}), se(() => {
 		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", _));
 	}), { isDragging: () => a };
 }
 //#endregion
 //#region src/components/aurora/composables/atoms-fields.ts
-function Z(e, t, n) {
+function Q(e, t, n) {
 	return e + (t - e) * n;
 }
-var Q = {
+var $ = {
 	saturation: {
 		calm: .85,
 		vivid: 1.2
@@ -2831,9 +2882,69 @@ var Q = {
 		warpDrift: .008,
 		breathDepth: .05
 	}
-};
-function rn(e, t, n) {
-	let r = S(n, 0, 1);
+}, rn = .61803398875;
+function an(e, t = "composed") {
+	let n = Math.max(1, Math.min(8, Math.round(e))), r = [
+		[.33, .33],
+		[.67, .67],
+		[.67, .33],
+		[.33, .67],
+		[.5, .33],
+		[.5, .67],
+		[.33, .5],
+		[.67, .5]
+	], i = (e) => {
+		if (t === "scattered") {
+			let t = e * rn * Math.PI * 2, r = .12 + .3 * Math.sqrt((e + .5) / n);
+			return [g(.5 + r * Math.cos(t), .1, .9), g(.5 + r * Math.sin(t), .1, .9)];
+		}
+		if (t === "centred") {
+			if (n === 1) return [.5, .5];
+			let t = e / n * Math.PI * 2;
+			return [.5 + .12 * Math.cos(t), .5 + .12 * Math.sin(t)];
+		}
+		return r[e % r.length];
+	};
+	return Array.from({ length: n }, (e, t) => {
+		let [r, a] = i(t);
+		return {
+			x: r,
+			y: a,
+			radius: .5,
+			paletteBias: n === 1 ? 0 : t / (n - 1),
+			valueBias: (t % 2 == 0 ? 1 : -1) * .05,
+			driftRadius: .045,
+			driftPhase: t * 2.4 % (Math.PI * 2)
+		};
+	});
+}
+var on = .03;
+function sn(e, t, n) {
+	let r = e.length;
+	if (r === 0 || t <= 0) return;
+	let i = e.reduce((e, t) => e + t.C, 0) / r, a = Math.min(.22, i * 1.5), o = (e, t, n) => l({
+		L: e,
+		C: t,
+		h: n
+	}).C;
+	if (e.forEach((e, n) => {
+		let r = n % 2 == 0 ? a : on;
+		e.C = o(e.L, g(Q(e.C, r, t), 0, .4), e.h);
+	}), !n) return;
+	let s = 0;
+	for (let t = 1; t < r; t++) e[t].L < e[s].L && (s = t);
+	let c = e[s];
+	c.C = o(c.L, on, c.h);
+}
+function cn(e) {
+	return e < .4 ? "fbm" : e < .75 ? "hybrid" : "cellular";
+}
+function ln(e, t) {
+	let n = g(t, 0, 1);
+	e.warpAmount = g(Q(.2, .6, n), 0, .6), e.warpScale = g(Q(1, 2.6, n), .5, 3), e.warpMode = cn(n), e.noiseOctaves = n < .5 ? 3 : n < .85 ? 4 : 5;
+}
+function un(e, t, n) {
+	let r = g(n, 0, 1);
 	switch (t) {
 		case "watercolor":
 			e.wetEdge = r, e.granulation = r * .8;
@@ -2856,138 +2967,92 @@ function rn(e, t, n) {
 			break;
 	}
 }
-function an(e, t) {
+function dn(e, t) {
 	switch (t) {
-		case "watercolor": return S(e.wetEdge, 0, 1);
+		case "watercolor": return g(e.wetEdge, 0, 1);
 		case "oil":
 		case "vangogh":
 		case "pastel":
 		case "oil-pastel":
 		case "crayon":
-		case "kuwahara": return S(e.strokeAmount, 0, 1);
+		case "kuwahara": return g(e.strokeAmount, 0, 1);
 		case "metal":
-		case "metal-gradient": return S((e.metalPolish ?? 1) / 4, 0, 1);
+		case "metal-gradient": return g((e.metalPolish ?? 1) / 4, 0, 1);
 	}
 }
-function on(e) {
+function fn(e) {
 	return e.nucleiDrift + e.paletteDrift + e.warpDrift > .001 ? "drifting" : e.breathDepth > .001 ? "breathing" : "still";
 }
-function sn(e, t, n) {
-	return n === t ? 0 : S((e - t) / (n - t), 0, 1);
+function pn(e, t, n) {
+	return n === t ? 0 : g((e - t) / (n - t), 0, 1);
 }
 //#endregion
 //#region src/components/aurora/composables/atoms.ts
-var cn = {}, ln = .61803398875;
-function un(e, t = "composed") {
-	let n = Math.max(1, Math.min(6, Math.round(e))), r = [
-		[.33, .33],
-		[.67, .67],
-		[.67, .33],
-		[.33, .67],
-		[.5, .5],
-		[.5, .33]
-	], i = (e) => {
-		switch (t) {
-			case "scattered": {
-				let t = e * ln * Math.PI * 2, r = .12 + .3 * Math.sqrt((e + .5) / n);
-				return [S(.5 + r * Math.cos(t), .1, .9), S(.5 + r * Math.sin(t), .1, .9)];
-			}
-			case "centred": {
-				if (n === 1) return [.5, .5];
-				let t = e / n * Math.PI * 2, r = .12;
-				return [.5 + r * Math.cos(t), .5 + r * Math.sin(t)];
-			}
-			default: return r[e % r.length];
-		}
-	};
-	return Array.from({ length: n }, (e, t) => {
-		let [r, a] = i(t);
-		return {
-			x: r,
-			y: a,
-			radius: .5,
-			paletteBias: n === 1 ? 0 : t / (n - 1),
-			valueBias: (t % 2 == 0 ? 1 : -1) * .05,
-			driftRadius: .045,
-			driftPhase: t * 2.4 % (Math.PI * 2)
-		};
-	});
-}
-var $ = .03;
-function dn(e, t, n) {
-	let r = e.length;
-	if (r === 0 || t <= 0) return;
-	let i = e.reduce((e, t) => e + t.C, 0) / r, a = Math.min(.22, i * 1.5), o = (e, t, n) => c({
-		L: e,
-		C: t,
-		h: n
-	}).C;
-	if (e.forEach((e, n) => {
-		let r = n % 2 == 0 ? a : $, i = S(Z(e.C, r, t), 0, .4);
-		e.C = o(e.L, i, e.h);
-	}), n) {
-		let t = 0;
-		for (let n = 1; n < r; n++) e[n].L < e[t].L && (t = n);
-		let n = e[t];
-		n.C = o(n.L, $, n.h);
-	}
-}
-function fn(e) {
-	return e < .4 ? "fbm" : e < .75 ? "hybrid" : "cellular";
-}
-function pn(e, t) {
-	let n = S(t, 0, 1);
-	e.warpAmount = S(Z(.2, .6, n), 0, .6), e.warpScale = S(Z(1, 2.6, n), .5, 3), e.warpMode = fn(n), e.noiseOctaves = n < .5 ? 3 : n < .85 ? 4 : 5;
-}
-function mn(e = cn, t = P) {
+var mn = {};
+function hn(e = mn, t = V) {
 	let n = {
 		...t,
 		palette: t.palette.map((e) => ({ ...e })),
 		nuclei: t.nuclei.map((e) => ({ ...e })),
 		flow: { ...t.flow }
-	}, r = e.colorEnergy === void 0 ? void 0 : S(e.colorEnergy, 0, 1);
+	}, r = e.colorEnergy === void 0 ? void 0 : g(e.colorEnergy, 0, 1);
 	if (e.seed !== void 0) {
-		let t = e.hueSpread === void 0 ? r === void 0 ? void 0 : Z(Q.hueSpread.calm, Q.hueSpread.vivid, r) : S(e.hueSpread, 0, 180);
-		n.palette = I(e.seed, {
+		let t = e.hueSpread === void 0 ? r === void 0 ? void 0 : Q($.hueSpread.calm, $.hueSpread.vivid, r) : g(e.hueSpread, 0, 180);
+		n.palette = Ye(e.seed, {
 			harmony: e.harmony ?? "analogous",
 			stopCount: 4,
-			temperatureShift: r === void 0 ? 0 : Z(Q.temperatureShift.calm, Q.temperatureShift.vivid, r),
+			temperatureShift: r === void 0 ? 0 : Q($.temperatureShift.calm, $.temperatureShift.vivid, r),
 			...t === void 0 ? {} : { hueSpread: t },
 			...e.lightnessScheme === void 0 ? {} : { scheme: e.lightnessScheme },
 			...e.lBand === void 0 ? {} : { lBand: e.lBand }
-		}), e.chromaVariance !== void 0 && e.chromaVariance > 0 && dn(n.palette, S(e.chromaVariance, 0, 1), e.chromaCounterpoint ?? !1);
+		}), e.chromaVariance !== void 0 && e.chromaVariance > 0 && sn(n.palette, g(e.chromaVariance, 0, 1), e.chromaCounterpoint ?? !1);
 	}
-	if (r !== void 0 && (n.saturation = S(Z(Q.saturation.calm, Q.saturation.vivid, r), .6, 1.3), n.valueVariance = S(Z(Q.valueVariance.calm, Q.valueVariance.vivid, r), 0, .3), n.breathDepth = S(Z(Q.breathDepth.calm, Q.breathDepth.vivid, r), 0, .15)), e.zones !== void 0 && (n.nuclei = un(e.zones.count, e.zones.arrangement ?? "composed")), e.noise !== void 0 && pn(n, e.noise), e.medium !== void 0 && (n.medium = e.medium.kind, (e.medium.kind === "vangogh" || e.medium.kind === "oil-pastel") && (n.strokeOrient = "tensor"), e.medium.kind !== "smooth" && e.medium.amount !== void 0 && rn(n, e.medium.kind, e.medium.amount)), e.motion !== void 0) {
+	if (r !== void 0 && (n.saturation = g(Q($.saturation.calm, $.saturation.vivid, r), .6, 1.3), n.valueVariance = g(Q($.valueVariance.calm, $.valueVariance.vivid, r), 0, .3), n.breathDepth = g(Q($.breathDepth.calm, $.breathDepth.vivid, r), 0, .15)), e.zones !== void 0 && (n.nuclei = an(e.zones.count, e.zones.arrangement ?? "composed")), e.noise !== void 0 && ln(n, e.noise), e.medium !== void 0 && (n.medium = e.medium.kind, (e.medium.kind === "vangogh" || e.medium.kind === "oil-pastel") && (n.strokeOrient = "tensor"), e.medium.kind !== "smooth" && e.medium.amount !== void 0 && un(n, e.medium.kind, e.medium.amount)), e.motion !== void 0) {
 		let t = nn[e.motion];
-		n.nucleiDrift = S(t.nucleiDrift, 0, .05), n.paletteDrift = S(t.paletteDrift, 0, .04), n.warpDrift = S(t.warpDrift, 0, .015), n.breathDepth = S(e.motion === "still" ? 0 : Math.max(n.breathDepth, t.breathDepth), 0, .15);
+		n.nucleiDrift = g(t.nucleiDrift, 0, .05), n.paletteDrift = g(t.paletteDrift, 0, .04), n.warpDrift = g(t.warpDrift, 0, .015), n.breathDepth = g(e.motion === "still" ? 0 : Math.max(n.breathDepth, t.breathDepth), 0, .15);
 	}
 	if (e.interactivity !== void 0) {
-		let t = e.interactivity;
+		let t = e.interactivity, r = e.medium?.kind !== void 0 && e.medium.kind !== "smooth" ? e.interactivity.light : void 0;
 		n.interactivity = {
-			...t,
+			...r === void 0 ? {} : { light: r },
+			...t.scroll === void 0 ? {} : { scroll: t.scroll },
 			swirl: t.swirl ?? !0,
-			amplitude: t.amplitude === void 0 ? .5 : S(t.amplitude, 0, 1)
+			amplitude: t.amplitude === void 0 ? .5 : g(t.amplitude, 0, 1)
 		};
 	}
 	return n;
 }
-function hn(e) {
-	let t = e.medium, n = t === "smooth" ? { kind: t } : {
-		kind: t,
-		amount: an(e, t)
-	};
-	return {
-		seed: e.palette.length > 0 ? l(e.palette[0]) : "#3a7bd5",
+function gn(e) {
+	let t = e.medium, n = e.interactivity, r = n && (n.scroll !== void 0 || n.swirl !== void 0 || n.amplitude !== void 0) ? {
+		...n.scroll === void 0 ? {} : { scroll: n.scroll },
+		...n.swirl === void 0 ? {} : { swirl: n.swirl },
+		...n.amplitude === void 0 ? {} : { amplitude: n.amplitude }
+	} : void 0, i = {
+		seed: e.palette.length > 0 ? u(e.palette[0]) : "#3a7bd5",
 		harmony: "analogous",
-		colorEnergy: sn(e.saturation, Q.saturation.calm, Q.saturation.vivid),
+		colorEnergy: pn(e.saturation, $.saturation.calm, $.saturation.vivid),
 		zones: {
-			count: Math.max(1, Math.min(6, e.nuclei.length)),
+			count: Math.max(1, Math.min(8, e.nuclei.length)),
 			arrangement: "composed"
 		},
-		noise: sn(e.warpAmount, .2, .6),
-		medium: n,
-		motion: on(e)
+		noise: pn(e.warpAmount, .2, .6),
+		motion: fn(e)
+	};
+	return t === "smooth" ? {
+		...i,
+		medium: { kind: t },
+		...r ? { interactivity: r } : {}
+	} : {
+		...i,
+		medium: {
+			kind: t,
+			amount: dn(e, t)
+		},
+		...r || n?.light !== void 0 ? { interactivity: {
+			...r,
+			...n?.light === void 0 ? {} : { light: n.light }
+		} } : {}
 	};
 }
 //#endregion
-export { en as Aurora, cn as DEFAULT_ATOMS, P as DEFAULT_AURORA_CONFIG, Je as DEFAULT_VIVIDNESS, Ze as IMAGE_BLUR_MAX_DEFAULT, Xe as IMAGE_BLUR_MIN_DEFAULT, Ke as MAX_NUCLEI, qe as MAX_STOPS, Qe as PAPER_WASH_GROUND, Ye as VIVID_TARGET, Zt as auroraFallbackGround, hn as configToAtoms, Bt as createAurora, o as cssToOklch, I as deriveAurora, F as flattenPalette, et as hexToOklchStop, j as isSoftwareWebGLRenderer, qt as nucleiFieldStatic, un as nucleiPrior, l as oklchStopToHex, u as oklchToLinear, $e as paletteToCssGradient, Gt as relativeLuminance, mn as resolveAtoms, M as resolveRenderMode, Jt as sampleAuroraField, Ut as useAurora, tn as useCursorInteraction };
+export { en as Aurora, mn as DEFAULT_ATOMS, V as DEFAULT_AURORA_CONFIG, ze as DEFAULT_VIVIDNESS, He as IMAGE_BLUR_MAX_DEFAULT, Ve as IMAGE_BLUR_MIN_DEFAULT, Le as MAX_NUCLEI, Re as MAX_STOPS, Ue as PAPER_WASH_GROUND, Be as VIVID_TARGET, Zt as auroraFallbackGround, gn as configToAtoms, Vt as createAurora, s as cssToOklch, Ye as deriveAurora, H as flattenPalette, Ge as hexToOklchStop, F as isSoftwareWebGLRenderer, Jt as nucleiFieldStatic, an as nucleiPrior, u as oklchStopToHex, d as oklchToLinear, We as paletteToCssGradient, Kt as relativeLuminance, hn as resolveAtoms, I as resolveRenderMode, Z as sampleAuroraField, Wt as useAurora, tn as useCursorInteraction };