@mkbabb/glass-ui 4.2.0 → 5.0.0

package/dist/blob.js

@@ -0,0 +1,1582 @@
+import { t as e } from "./_plugin-vue_export-helper-C1je1s0u.js";
+import { t } from "./useResolveTokenColor-DVT5kwv6.js";
+import { t as n } from "./usePointerVelocityField-CwXyeW0Z.js";
+import { t as r } from "./useIntersectionPause-Cmt5Tnv9.js";
+import { a as i, n as a, o, r as s, s as c, t as l } from "./procedural-color.wgsl-ByduxnzV.js";
+import { a as u, t as d } from "./useGpuSubstrate-DcY584kE.js";
+import { n as f, t as p } from "./compile-C55K3P9g.js";
+import { s as m, t as h } from "./color-Bp5jmv4Z.js";
+import { a as g, i as _, n as v, o as y, r as b, t as x } from "./presets-B07HzyKd.js";
+import { n as S, t as C } from "./prng-B0PLRmR6.js";
+import { computed as w, createElementBlock as T, createElementVNode as E, defineComponent as D, inject as O, normalizeStyle as k, onScopeDispose as A, onUnmounted as j, openBlock as M, readonly as N, ref as P, useTemplateRef as F, watch as I } from "vue";
+import { SpringProgress as L } from "@mkbabb/keyframes.js";
+//#region src/components/blob/constants.ts
+var R = 1 / 1.6, z = {
+	idle: {
+		valence: 0,
+		arousal: .35
+	},
+	happy: {
+		valence: .8,
+		arousal: .6
+	},
+	curious: {
+		valence: .3,
+		arousal: .5
+	},
+	sleepy: {
+		valence: -.1,
+		arousal: .1
+	},
+	excited: {
+		valence: .7,
+		arousal: 1
+	}
+}, B = (e, t, n) => e + (t - e) * n;
+function V({ valence: e, arousal: t }) {
+	return {
+		orbitSpeedScale: B(.4, 2.2, t),
+		wobbleScale: B(.5, 2, t),
+		pulseFreq: B(.15, 1.5, t),
+		pulseAmp: B(.008, .05, t),
+		noiseAmp: B(.015, .045, t),
+		hueRange: B(3, 25, t * .6 + (e * .5 + .5) * .4),
+		satShift: B(-.05, .1, e * .5 + .5),
+		brightnessShift: B(-.03, .08, e * .5 + .5),
+		smoothK: B(.85, 1.35, t),
+		pointerAttraction: B(-.2, .6, e * .5 + .5) * (.7 + .15 * t),
+		mergeRate: B(2, .3, t),
+		iridScale: B(.55, 1.35, t)
+	};
+}
+var H = {
+	idle: V(z.idle),
+	happy: V(z.happy),
+	curious: V(z.curious),
+	sleepy: V(z.sleepy),
+	excited: V(z.excited)
+}, U = {
+	idle: 1500,
+	happy: 1200,
+	curious: 800,
+	sleepy: 2500,
+	excited: 600
+}, ee = 6e3, W = .35, te = .85, ne = .2, re = .015, G = .02, K = .01, q = .015, J = .75, ie = 2e3, ae = .4, oe = .18, se = 5200, ce = /* @__PURE__ */ "uResolution.uTime.uBaseColor.uPointer.uPointerActive.uPointerAttraction.uPointerStrength.uBodyRadius.uPulsePhase.uPulseAmp.uNoiseAmp.uNoiseFreq.uNoiseSpeed.uWarpAmp.uSmoothK.uMerge.uStage.uMorphT.uMaxReach.uLit.uRimColor.uLightDir.uSpecStrength.uSpecShininess.uRimPower.uRimStrength.uShadow.uShadowSoftness.uIridescence.uIridHue.uIridSpeed.uSssScale.uSssPower.uCoreGlow.uHueRange.uSatShift.uBrightnessShift.uColorNoiseFreq.uColorNoiseSpeed.uStopCount.uSatCount.uSatColorActive.uTrailCount.uVelocity.uStretch".split(".");
+//#endregion
+//#region src/components/blob/composables/easing.ts
+function le(e) {
+	return e < .5 ? 2 * e * e : 1 - 2 * (1 - e) * (1 - e);
+}
+function ue(e) {
+	return e * e;
+}
+function de(e) {
+	return 1 - (1 - e) * (1 - e);
+}
+function fe(e) {
+	let t = e < 0 ? 0 : e > 1 ? 1 : e;
+	if (t < .3) {
+		let e = t / .3;
+		return -.06 * Math.sin(e * Math.PI);
+	}
+	if (t < .55) {
+		let e = (t - .3) / .25;
+		return (1 - (1 - e) * (1 - e) * (1 - e)) * 1.12;
+	}
+	let n = (t - .55) / .45;
+	return 1 + Math.cos(n * Math.PI) * .12 * (1 - n);
+}
+//#endregion
+//#region src/components/blob/composables/useBlobMood.ts
+function pe(e, t, n) {
+	let r = (e, t) => e + (t - e) * n;
+	return {
+		orbitSpeedScale: r(e.orbitSpeedScale, t.orbitSpeedScale),
+		wobbleScale: r(e.wobbleScale, t.wobbleScale),
+		pulseFreq: r(e.pulseFreq, t.pulseFreq),
+		pulseAmp: r(e.pulseAmp, t.pulseAmp),
+		noiseAmp: r(e.noiseAmp, t.noiseAmp),
+		hueRange: r(e.hueRange, t.hueRange),
+		satShift: r(e.satShift, t.satShift),
+		brightnessShift: r(e.brightnessShift, t.brightnessShift),
+		smoothK: r(e.smoothK, t.smoothK),
+		pointerAttraction: r(e.pointerAttraction, t.pointerAttraction),
+		mergeRate: r(e.mergeRate, t.mergeRate),
+		iridScale: r(e.iridScale, t.iridScale)
+	};
+}
+function me() {
+	let e = P("idle"), t = P({ ...H.idle }), n = { ...H.idle }, r = { ...H.idle }, i = 0, a = 0, o = !1, s = 0, c = !1, l = !1, u = 0;
+	function d(s, l = {}) {
+		(l.source ?? "manual") === "manual" && (c = !0), !(s === e.value && !o) && (e.value = s, n = { ...t.value }, r = H[s], a = U[s], i = 0, o = !0);
+	}
+	function f(e) {
+		u = e.idleMs;
+		let t = e.pointerActive && !l;
+		if (l = e.pointerActive, c && (e.clicked || t) && (c = !1), !c) {
+			if (e.clicked) {
+				s = 900, d("excited", { source: "auto" });
+				return;
+			}
+			s > 0 || (e.pointerActive ? d("curious", { source: "auto" }) : e.idleMs > 6e3 ? d("sleepy", { source: "auto" }) : d("idle", { source: "auto" }));
+		}
+	}
+	function p() {
+		return o || s > 0 || c && e.value !== "idle" ? !1 : !(!c && e.value !== "sleepy" && u < 6e3);
+	}
+	function m() {
+		return o || s > 0 || c || e.value === "sleepy" ? Infinity : Math.max(0, ee - u);
+	}
+	function h(e) {
+		if (s > 0 && (s = Math.max(0, s - e)), !o) return;
+		i += e;
+		let c = Math.min(i / a, 1), l = le(c);
+		t.value = pe(n, r, l), c >= 1 && (o = !1);
+	}
+	return {
+		currentMood: N(e),
+		params: N(t),
+		setMood: d,
+		update: f,
+		tick: h,
+		isSettled: p,
+		nextAutoMoodMs: m
+	};
+}
+//#endregion
+//#region src/components/blob/composables/useBlobPointer.ts
+function he(e, t = {}) {
+	let { hitRadius: n } = t, r = P({
+		x: 0,
+		y: 0
+	}), i = P({
+		x: 0,
+		y: 0
+	}), a = P(!1), o = P(0), s = 0, c = 0, l = {
+		response: .18,
+		dampingFraction: 1
+	}, u = new L(l), d = new L(l), f = Array.from({ length: 15 }, () => ({
+		x: 0,
+		y: 0,
+		radius: 0
+	})), p = 0, m = 0, h = 0, g = 0;
+	function _() {
+		return (n ? n() : Infinity) * (1 + Math.max(0, h));
+	}
+	function v(t, n) {
+		let r = e.value;
+		if (!r) return !1;
+		let i = r.getBoundingClientRect();
+		if (i.width === 0 || i.height === 0) return !1;
+		let a = (t - i.left) / i.width * 2 - 1, o = (n - i.top) / i.height * 2 - 1;
+		return Math.hypot(a, o) <= _();
+	}
+	function y(t) {
+		let n = e.value;
+		if (!n) return;
+		let r = n.getBoundingClientRect();
+		s = (t.clientX - r.left) / r.width * 2 - 1, c = (t.clientY - r.top) / r.height * 2 - 1, a.value = Math.hypot(s, c) <= _();
+	}
+	function b() {
+		a.value = !1;
+	}
+	let x = null;
+	I(e, (e) => {
+		x &&= (x(), null), e && (e.addEventListener("pointermove", y), e.addEventListener("pointerleave", b), x = () => {
+			e.removeEventListener("pointermove", y), e.removeEventListener("pointerleave", b);
+		});
+	}, { immediate: !0 }), j(() => x?.());
+	function S(e = 16) {
+		let t = Math.min(e, 50), n = t / 1e3;
+		a.value ? D = 0 : D += Math.min(e, 50);
+		let l = a.value ? s : 0, _ = a.value ? c : 0;
+		if (u.target = l, d.target = _, u.tickDt(t), d.tickDt(t), r.value = {
+			x: u.value,
+			y: d.value
+		}, i.value = {
+			x: u.velocity,
+			y: d.velocity
+		}, h !== 0 || g !== 0) {
+			let e = -324 * h - 2 * W * 18 * g;
+			g += e * n, h += g * n, h < -.9 && (h = -.9), Math.abs(h) < 1e-4 && Math.abs(g) < 1e-4 && (h = 0, g = 0);
+		}
+		o.value = h;
+		let v = Math.hypot(u.velocity, d.velocity);
+		a.value || v > .05 ? (p = (p + 1) % 15, f[p].x = u.value, f[p].y = d.value, m = Math.min(m + 1, 15)) : m > 0 && (m = Math.max(0, m - 1));
+	}
+	function C(e) {
+		let t = [];
+		for (let n = 0; n < m; n++) {
+			let r = f[(p - n + 30) % 15];
+			t.push({
+				x: r.x,
+				y: r.y,
+				radius: e * (1 - n / 15)
+			});
+		}
+		return {
+			sources: t,
+			count: m
+		};
+	}
+	let w = !1;
+	function T(e) {
+		g += e * 18, w = !0;
+	}
+	function E() {
+		let e = w;
+		return w = !1, e;
+	}
+	let D = 0;
+	function O() {
+		u.reset(0, 0), d.reset(0, 0), u.target = 0, d.target = 0, r.value = {
+			x: 0,
+			y: 0
+		}, i.value = {
+			x: 0,
+			y: 0
+		}, h = 0, g = 0, o.value = 0, m = 0;
+	}
+	function k() {
+		return !(a.value || Math.hypot(u.velocity, d.velocity) > .001 || Math.abs(u.value) > .001 || Math.abs(d.value) > .001 || m > 0 || h !== 0 || g !== 0);
+	}
+	return {
+		pointer: N(r),
+		velocity: N(i),
+		active: N(a),
+		rawPointer: () => ({
+			x: s,
+			y: c
+		}),
+		pulse: N(o),
+		idleMs: () => D,
+		tick: S,
+		trailSources: C,
+		click: T,
+		consumeClick: E,
+		rest: O,
+		isAtRest: k,
+		hitTest: v
+	};
+}
+//#endregion
+//#region src/components/blob/composables/satelliteKinematics.ts
+function ge(e, t, n, r, i) {
+	let a = t / 4 * Math.PI * 2 + (e() - .5) * Math.PI, o = n * (te + e() * ne), s = r * (.3 + e() * .7);
+	return {
+		phase: "orbiting",
+		phaseStart: i,
+		phaseDuration: 6e3 + e() * 1e4,
+		timeOrigin: i,
+		angularSpeed: .08 + e() * .16,
+		phaseOffset: a,
+		baseRadiusX: o * (1 - s),
+		baseRadiusY: o * (1 + s),
+		wobbleAmp1: re + e() * G,
+		wobbleFreq1: .08 + e() * .22,
+		wobbleAmp2: K + e() * q,
+		wobbleFreq2: .18 + e() * .32,
+		pertXAmp: .03 + e() * .05,
+		pertXFreq: .06 + e() * .18,
+		pertXPhase: e() * Math.PI * 2,
+		pertYAmp: .03 + e() * .05,
+		pertYFreq: .07 + e() * .17,
+		pertYPhase: e() * Math.PI * 2,
+		startX: 0,
+		startY: 0,
+		endX: 0,
+		endY: 0,
+		fissioning: !1,
+		snapFired: !1
+	};
+}
+function _e(e, t, n, r) {
+	let i = (t - e.timeOrigin) / 1e3, a = e.angularSpeed * n * i + e.phaseOffset, o = r * (e.wobbleAmp1 * Math.sin(e.wobbleFreq1 * i) + e.wobbleAmp2 * Math.sin(e.wobbleFreq2 * i + 1.3));
+	return {
+		x: (e.baseRadiusX + o) * Math.cos(a) + e.pertXAmp * Math.sin(e.pertXFreq * i + e.pertXPhase),
+		y: (e.baseRadiusY + o) * Math.sin(a) + e.pertYAmp * Math.cos(e.pertYFreq * i + e.pertYPhase)
+	};
+}
+function ve(e, t, n, r, i) {
+	e.timeOrigin = i, e.angularSpeed = .08 + t() * .16, e.phaseOffset = t() * Math.PI * 2;
+	let a = n * (te + t() * ne), o = r * (.3 + t() * .7);
+	e.baseRadiusX = a * (1 - o), e.baseRadiusY = a * (1 + o), e.wobbleAmp1 = re + t() * G, e.wobbleFreq1 = .08 + t() * .22, e.wobbleAmp2 = K + t() * q, e.wobbleFreq2 = .18 + t() * .32, e.pertXAmp = .03 + t() * .05, e.pertXFreq = .06 + t() * .18, e.pertXPhase = t() * Math.PI * 2, e.pertYAmp = .03 + t() * .05, e.pertYFreq = .07 + t() * .17, e.pertYPhase = t() * Math.PI * 2;
+}
+//#endregion
+//#region src/components/blob/composables/useBlobSatellites.ts
+function ye(e, t, n) {
+	return t + e() * (n - t);
+}
+function Y(e) {
+	return e < 0 ? 0 : e > 1 ? 1 : e;
+}
+function X(e, t, n) {
+	return e + (t - e) * n;
+}
+function Z(e, t, n, r) {
+	e.phase = t, e.phaseStart = n, e.phaseDuration = r;
+}
+function be(e, t) {
+	let n = S(C(t + "goo")), r = [], i = [], a = [], o = -Infinity, s = e.geometry.orbitRadius, c = -1, l = null;
+	function u() {
+		let t = e.geometry.orbitRadius;
+		if (t !== s && s > 0) {
+			let e = t / s;
+			for (let t of r) t.baseRadiusX *= e, t.baseRadiusY *= e;
+			s = t;
+		}
+	}
+	function d(t) {
+		let o = e.geometry.satelliteCount;
+		for (; r.length < o;) r.push(ge(n, r.length, e.geometry.orbitRadius, e.geometry.eccentricity, t)), i.push({
+			x: 0,
+			y: 0,
+			radius: e.geometry.satelliteRadius,
+			opacity: 0,
+			fissioning: !1
+		}), a.push({
+			x: 0,
+			y: 0,
+			start: 0
+		});
+		r.length > o && (r.length = o, i.length = o, a.length = o);
+	}
+	function f(t, s) {
+		d(t), u();
+		let f = r.length, p = s.mergeRate, m = e.geometry.satelliteRadius, h = e.satellites.mergeDuration, g = e.satellites.emergeDuration, _ = e.satellites.orbitDuration, v = e.satellites.absorbedDuration, y = e.surface.fissionAmp ?? 0, b = Math.max(0, Math.min(1, (2 - p) / 1.7)), x = Math.max(0, Math.min(1, y * (.4 + .6 * b))), S = ae - oe;
+		for (let u = 0; u < f; u++) {
+			let d = r[u], f = t - d.phaseStart, y = Y(d.phaseDuration > 0 ? f / d.phaseDuration : 1);
+			switch (d.phase) {
+				case "orbiting":
+					if (y >= 1) if (t - o < 3e3 * p) d.phaseStart = t, d.phaseDuration = ye(n, _[0], _[1]);
+					else if (x > 0 && c < 0 && n() < x * .75) d.phaseOffset = d.angularSpeed * s.orbitSpeedScale * ((t - d.timeOrigin) / 1e3) + d.phaseOffset, d.timeOrigin = t, d.fissioning = !0, d.snapFired = !1, c = u, Z(d, "fissioning", t, se), o = t;
+					else {
+						let e = _e(d, t, s.orbitSpeedScale, s.wobbleScale);
+						d.startX = e.x, d.startY = e.y;
+						let n = Math.hypot(e.x, e.y), r = n > .01 ? .08 / n : 0;
+						d.endX = e.x * r, d.endY = e.y * r, Z(d, "merging", t, h), o = t;
+					}
+					break;
+				case "fissioning":
+					y >= 1 && (d.fissioning = !1, c === u && (c = -1), d.timeOrigin = t, Z(d, "orbiting", t, ye(n, _[0], _[1])));
+					break;
+				case "merging":
+					y >= 1 && Z(d, "absorbed", t, ye(n, v[0], v[1]));
+					break;
+				case "absorbed":
+					if (y >= 1) {
+						ve(d, n, e.geometry.orbitRadius, e.geometry.eccentricity, t);
+						let r = _e(d, t + 3e3, s.orbitSpeedScale, s.wobbleScale);
+						d.endX = r.x, d.endY = r.y;
+						let i = Math.hypot(r.x, r.y), a = i > .01 ? .08 / i : 0;
+						d.startX = r.x * a, d.startY = r.y * a, Z(d, "emerging", t, g);
+					}
+					break;
+				case "emerging":
+					if (y >= 1) {
+						let e = a[u];
+						e.x = d.endX, e.y = d.endY, e.start = t, d.timeOrigin = t, d.phaseOffset = Math.atan2(d.endY, d.endX), Z(d, "orbiting", t, ye(n, _[0], _[1]));
+					}
+					break;
+			}
+			let b, C, w, T;
+			switch (d.phase) {
+				case "orbiting": {
+					let e = _e(d, t, s.orbitSpeedScale, s.wobbleScale), n = a[u], r = t - n.start;
+					if (n.start > 0 && r < 2e3) {
+						let t = Y(r / ie), i = t * t * (3 - 2 * t);
+						b = X(n.x, e.x, i), C = X(n.y, e.y, i);
+					} else b = e.x, C = e.y;
+					w = J, T = 1;
+					break;
+				}
+				case "merging": {
+					let e = ue(Y((t - d.phaseStart) / d.phaseDuration));
+					b = X(d.startX, d.endX, e), C = X(d.startY, d.endY, e);
+					let n = Y((t - d.phaseStart) / d.phaseDuration);
+					w = n > .85 ? X(J, 0, (n - .85) / .15) : J, T = X(1, .65, e);
+					break;
+				}
+				case "absorbed":
+					b = 0, C = 0, w = 0, T = .5;
+					break;
+				case "emerging": {
+					let e = de(Y((t - d.phaseStart) / d.phaseDuration));
+					b = X(d.startX, d.endX, e), C = X(d.startY, d.endY, e);
+					let n = Y((t - d.phaseStart) / d.phaseDuration);
+					w = n < .1 ? X(0, J, n / .1) : J, T = X(.65, 1, e);
+					break;
+				}
+				case "fissioning": {
+					let e = Y((t - d.phaseStart) / d.phaseDuration), n = fe(e), r = oe + S * n, i = _e(d, t, s.orbitSpeedScale, s.wobbleScale), a = Math.hypot(i.x, i.y), o = a > 1e-4 ? i.x / a : Math.cos(d.phaseOffset), c = a > 1e-4 ? i.y / a : Math.sin(d.phaseOffset);
+					b = o * r, C = c * r, w = J, T = X(.78, 1, Y(n)), !d.snapFired && e >= .42 && (d.snapFired = !0, l?.(Math.min(.4, .18 + .22 * x)));
+					break;
+				}
+			}
+			let E = i[u];
+			E.x = b, E.y = C, E.radius = m * T, E.opacity = w, E.fissioning = d.fissioning;
+		}
+	}
+	function p() {
+		for (let e of r) e.phaseOffset += (n() - .5) * .6, e.pertXPhase += n() * Math.PI, e.pertYPhase += n() * Math.PI;
+	}
+	function m(e) {
+		n = S(C(e + "goo"));
+	}
+	function h(e) {
+		l = e;
+	}
+	function g() {
+		for (let e of r) if (e.phase !== "orbiting") return !1;
+		return !0;
+	}
+	function _(e) {
+		let t = Infinity;
+		for (let e of r) {
+			let n = e.phaseStart + e.phaseDuration;
+			n < t && (t = n);
+		}
+		return t === Infinity ? e + 3e4 : t;
+	}
+	return {
+		sources: i,
+		tick: f,
+		nudge: p,
+		reseed: m,
+		onPinch: h,
+		isQuiescent: g,
+		nextEventMs: _
+	};
+}
+//#endregion
+//#region src/components/blob/shaders/metaball.vert.ts
+var xe = "#version 300 es\n\nin vec2 aPosition;\nout vec2 vUv;\n\nvoid main() {\n    vUv = 0.5 * (aPosition + 1.0);\n    gl_Position = vec4(aPosition, 0.0, 1.0);\n}", Se = "// --- SDF ---\n\nfloat sdCircle(vec2 p, vec2 center, float radius) {\n    return length(p - center) - radius;\n}\n\n// AX.W15 — the VALUE+GRADIENT circle: returns vec3(d, dd/dx, dd/dy). The circle\n// gradient is the UNIT radial direction (p - center)/length(p - center) (the\n// eikonal property holds EXACTLY for a circle), guarded at the degenerate centre.\n// This is the keystone of the analytic-gradient smin: carrying the gradient\n// through the scene field DELETES the per-pixel 4-tap normal (4 full sceneDist\n// evals, each running 3-octave FBM + the sat/trail loops).\nvec3 sdgCircle(vec2 p, vec2 center, float radius) {\n    vec2 d = p - center;\n    float len = length(d);\n    vec2 grad = len > 1e-6 ? d / len : vec2(0.0, 1.0);\n    return vec3(len - radius, grad);\n}\n\n// IQ 2024 quadratic-polynomial smin, NORMALIZED so k is a blend band in distance\n// units. The k *= 4.0 pre-scale makes the h*h*k*0.25 poly's effective blend width\n// equal to k (the un-normalized form's width was 0.25*k).\nfloat sminQuadratic(float a, float b, float k) {\n    k *= 4.0;\n    float h = max(k - abs(a - b), 0.0) / k;\n    return min(a, b) - h * h * k * 0.25;\n}\n\n// IQ circular smin — a quarter-circle fillet at the seam (rounder than the\n// quadratic). The k *= 1.0/(1.0-sqrt(0.5)) factor normalizes k to the same\n// blend-band units so the merge axis swaps shape without re-tuning uSmoothK.\nfloat sminCircular(float a, float b, float k) {\n    k *= 1.0 / (1.0 - sqrt(0.5));\n    float h = max(k - abs(a - b), 0.0) / k;\n    return min(a, b) - k * 0.5 * (1.0 + h - sqrt(1.0 - h * (h - 2.0)));\n}\n\n// Config-gated merge dispatch — uMerge 0 = quadratic, 1 = circular.\nfloat smin(float a, float b, float k) {\n    if (uMerge > 0.5) return sminCircular(a, b, k);\n    return sminQuadratic(a, b, k);\n}\n\n// AX.W15 — the VALUE+GRADIENT smin. a/b are vec3(dist, grad.xy); the blended\n// gradient is mix(a.yz, b.yz, w) with the interpolation weight w the distance\n// blend uses (IQ's vec2-smin insight). This propagates the analytic gradient\n// through the merge so the surface normal reads the field gradient DIRECTLY — no\n// finite-difference tap. The blend weight matches each variant.\nvec3 sminQuadraticG(vec3 a, vec3 b, float k) {\n    k *= 4.0;\n    float h = max(k - abs(a.x - b.x), 0.0) / k;\n    float m = h * h * k * 0.25;\n    // h-weight that selects which surface dominates (0 → a, 1 → b).\n    float w = (a.x < b.x) ? 0.5 * h * h : 1.0 - 0.5 * h * h;\n    float dist = min(a.x, b.x) - m;\n    vec2 grad = mix(a.yz, b.yz, w);\n    return vec3(dist, grad);\n}\n\nvec3 sminCircularG(vec3 a, vec3 b, float k) {\n    k *= 1.0 / (1.0 - sqrt(0.5));\n    float h = max(k - abs(a.x - b.x), 0.0) / k;\n    float m = k * 0.5 * (1.0 + h - sqrt(1.0 - h * (h - 2.0)));\n    float w = (a.x < b.x) ? 0.5 * h : 1.0 - 0.5 * h;\n    float dist = min(a.x, b.x) - m;\n    vec2 grad = mix(a.yz, b.yz, w);\n    return vec3(dist, grad);\n}\n\nvec3 sminG(vec3 a, vec3 b, float k) {\n    if (uMerge > 0.5) return sminCircularG(a, b, k);\n    return sminQuadraticG(a, b, k);\n}", Ce = "// --- Noise ---\n\nfloat hash21(vec2 p) {\n    vec3 p3 = fract(vec3(p.xyx) * 0.1031);\n    p3 += dot(p3, p3.yzx + 33.33);\n    return fract((p3.x + p3.y) * p3.z);\n}\n\n// IQ analytic-derivative gradient noise — value in .x, ANALYTIC gradient\n// (d/dx, d/dy) in .yz, from one eval. The quintic fade has a continuous 2nd\n// derivative so the gradient is smooth (a cubic smoothstep fade would crease it).\n// (Inigo Quilez, https://iquilezles.org/articles/gradientnoise/.)\nvec3 noised(vec2 p) {\n    vec2 i = floor(p);\n    vec2 f = fract(p);\n\n    // Quintic fade + its derivative.\n    vec2 u = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);\n    vec2 du = 30.0 * f * f * (f * (f - 2.0) + 1.0);\n\n    // Per-corner gradient vectors from the hash (centred to [-1, 1]).\n    vec2 ga = -1.0 + 2.0 * vec2(hash21(i + vec2(0.0, 0.0)), hash21(i + vec2(7.3, 0.0)));\n    vec2 gb = -1.0 + 2.0 * vec2(hash21(i + vec2(1.0, 0.0)), hash21(i + vec2(8.3, 0.0)));\n    vec2 gc = -1.0 + 2.0 * vec2(hash21(i + vec2(0.0, 1.0)), hash21(i + vec2(7.3, 1.0)));\n    vec2 gd = -1.0 + 2.0 * vec2(hash21(i + vec2(1.0, 1.0)), hash21(i + vec2(8.3, 1.0)));\n\n    float va = dot(ga, f - vec2(0.0, 0.0));\n    float vb = dot(gb, f - vec2(1.0, 0.0));\n    float vc = dot(gc, f - vec2(0.0, 1.0));\n    float vd = dot(gd, f - vec2(1.0, 1.0));\n\n    // Value, remapped to [0,1] so it drops in for the prior valueNoise.\n    float n = va + u.x * (vb - va) + u.y * (vc - va) + u.x * u.y * (va - vb - vc + vd);\n    float value = 0.5 + 0.5 * n;\n\n    // Analytic gradient (chain rule through the bilinear blend + the fade).\n    vec2 grad =\n        ga + u.x * (gb - ga) + u.y * (gc - ga) + u.x * u.y * (ga - gb - gc + gd) +\n        du * (vec2(u.y, u.x) * (va - vb - vc + vd) + vec2(vb, vc) - va);\n    return vec3(value, 0.5 * grad);\n}\n\n// Rotated-octave FBM over the analytic gradient noise: a fixed ~0.5 rad 2x2\n// rotation between octaves breaks the axis-aligned banding. The rotation CONSTANT\n// is spliced from the shared chunk (AV.W2 — the one FBM_ROT); the loops below\n// stay blob-local (param octaves + the LIQUID lacunarity/persistence, per §3a).", we = 1.8, Te = .42, Ee = `float fbm(vec2 p, int octaves) {
+    float value = 0.0;
+    float amp = 0.5;
+    float freq = 1.0;
+    for (int i = 0; i < 4; i++) {
+        if (i >= octaves) break;
+        value += amp * noised(p * freq).x;
+        p = FBM_ROT * p;
+        freq *= ${we.toFixed(1)};
+        amp *= ${Te.toFixed(2)};
+    }
+    return value;
+}
+
+// AX.W15 — FBM with ANALYTIC GRADIENT. Returns vec3(value, ∂/∂x, ∂/∂y). The
+// gradient accumulates noised()'s analytic gradient per octave, chain-ruled
+// through the per-octave frequency scale AND the FBM_ROT rotation: octave i samples
+// at R^i · (freq·p), so the gradient w.r.t. the ORIGINAL p picks up freq and
+// the accumulated rotation transpose (R^T)^i. The keystone feed for the
+// analytic surface normal — it DELETES the per-pixel 4-tap finite difference.
+vec3 fbmG(vec2 p, int octaves) {
+    float value = 0.0;
+    vec2 grad = vec2(0.0);
+    float amp = 0.5;
+    float freq = 1.0;
+    // The accumulated octave rotation R^i — its transpose maps the i-th octave's
+    // local gradient back into the ORIGINAL p frame. Seeded at identity (octave 0).
+    mat2 rotAccum = mat2(1.0, 0.0, 0.0, 1.0);
+    vec2 pp = p;
+    for (int i = 0; i < 4; i++) {
+        if (i >= octaves) break;
+        vec3 n = noised(pp * freq);
+        value += amp * n.x;
+        // d(value)/dp = amp · freq · (R^i)^T · noised.yz  (the rotated chain rule).
+        grad += amp * freq * (transpose(rotAccum) * n.yz);
+        pp = FBM_ROT * pp;
+        freq *= ${we.toFixed(1)};
+        amp *= ${Te.toFixed(2)};
+        rotAccum = FBM_ROT * rotAccum;
+    }
+    return vec3(value, grad);
+}
+
+// One domain-warp pass with the ANALYTIC GRADIENT carried (warp-Jacobian
+// APPROXIMATION per the SOTA deepening [2]: the warp is low-frequency, so the
+// gradient of the OUTER fbm dominates and the warp-offset Jacobian is dropped —
+// the error is sub-perceptible and full autodiff is overfit for one blob).
+vec3 fbmWarpedG(vec2 p, int octaves, float warpAmp) {
+    if (warpAmp <= 0.0) return fbmG(p, octaves);
+    vec2 q = vec2(fbm(p + vec2(0.0, 0.0), octaves), fbm(p + vec2(5.2, 1.3), octaves));
+    return fbmG(p + warpAmp * (q - 0.5), octaves);
+}
+`, De = "// Edit #4's gamut step — hue-preserving inward chroma clamp. If the linear result\n// is out of [0,1], bisect chroma toward 0 (L + h fixed) until in gamut. Preserves\n// hue exactly (only C shrinks). 16 steps resolve C to < 2^-16 of its span.\nbool inGamut(vec3 lin) {\n    return all(greaterThanEqual(lin, vec3(0.0))) && all(lessThanEqual(lin, vec3(1.0)));\n}\nvec3 gamutClampOklch(vec3 lch) {\n    vec3 lin = oklabToLinearSrgb(oklchToOklab(lch));\n    if (inGamut(lin)) return lch;\n    float lo = 0.0;\n    float hi = lch.y;\n    for (int i = 0; i < 16; i++) {\n        float mid = 0.5 * (lo + hi);\n        vec3 test = vec3(lch.x, mid, lch.z);\n        if (inGamut(oklabToLinearSrgb(oklchToOklab(test)))) {\n            lo = mid;\n        } else {\n            hi = mid;\n        }\n    }\n    return vec3(lch.x, lo, lch.z);\n}", Oe = "#version 300 es\nprecision highp float;\n\nin vec2 vUv;\nout vec4 fragColor;\n\nuniform vec2 uResolution;\nuniform float uTime;\nuniform vec3 uBaseColor;\n\n// Multi-stop palette (W11.b) — 2-4 in-family OKLCh stops (uploaded GAMMA sRGB, like\n// uBaseColor). uStopCount <= 1 falls back to uBaseColor (the single-color default,\n// zero regression). MAX_BLOB_STOPS is a compile-time #define.\n#define MAX_BLOB_STOPS 4\nuniform int uStopCount;\nuniform vec3 uPalette[MAX_BLOB_STOPS];\n\n// Pointer\nuniform vec2 uPointer;\nuniform float uPointerActive;\nuniform float uPointerAttraction;\nuniform float uPointerStrength;\n\n// Main body\nuniform float uBodyRadius;\n\n// Pulsation\nuniform float uPulsePhase;\nuniform float uPulseAmp;\n\n// Surface noise\nuniform float uNoiseAmp;\nuniform float uNoiseFreq;\nuniform float uNoiseSpeed;\n\n// Gooey\nuniform float uSmoothK;\nuniform float uMerge;   // 0 = quadratic smin, 1 = circular smin (rounder menisci)\n\n// BC.W-GOOBLOB-PLAIN — the STAGE-1 gate. 1.0 = the plain shadowless lightless\n// fill-only floor (variant=\"blob\"); 0.0 = the full lit pipeline (variant=\"meatball\" /\n// STAGE 2). The WebGL2 fallback transcribes the SAME stripped branch the WGSL primary\n// gates (research/viz/goo-blob.md §5 — the GLSL twin).\n// BD.W-GOO-CAROUSEL-DECK — uStage is now DERIVED from uMorphT (uStage = uMorphT<=0 ?\n// 1 : 0) at upload; the SHADING morph (below) reads uMorphT directly.\nuniform float uStage;\n\n// BD.W-GOO-CAROUSEL-DECK — the blob to meatball SHADING-MORPH scalar. 0.0 = the flat blob\n// fill (byte-identical to the STAGE-1 floor), 1.0 = the fully-dressed lit meatball; the\n// in-between LERPS the surface shading (NOT the geometry — the smin field is shared). The\n// renderer resolves it from config.morphT (variant to endpoint back-compat: blob to 0,\n// meatball to 1). A consumer ANIMATING morphT 0 to 1 gets the live morph.\nuniform float uMorphT;\n\n// AX.W16 (arm 5) — the PRE-FBM bounding-discard radius (UV space). main() early-outs\n// to a transparent write for any fragment OUTSIDE this radius BEFORE the two 3-octave\n// FBM calls + the OKLCh round-trip. The renderer uploads it PADDED by every\n// outward-expanding term (body + eccentric orbit + sat radius + smin band + FBM edge\n// amplitude + click-pulse + a lean/squash safety pad) so it NEVER clips the wet\n// meniscus (IQ: inflate the bound to match any outward op).\nuniform float uMaxReach;\n\n// Membrane — domain-warp strength on the FBM edge displacement (0 = plain fbm).\nuniform float uWarpAmp;\n\n// Lit glass surface (W9.b) — gated behind uLit so the flat fill stays default.\nuniform float uLit;             // 0 = flat fill (default), 1 = lit droplet\nuniform vec3 uRimColor;         // Fresnel rim tint (GAMMA sRGB, via the /color leaf)\nuniform vec3 uLightDir;         // normalized light direction (x, y, z)\nuniform float uSpecStrength;    // Blinn-Phong specular weight\nuniform float uSpecShininess;   // specular exponent (16-64, tight glint)\nuniform float uRimPower;        // Fresnel/Schlick exponent (~2-3)\nuniform float uRimStrength;     // Fresnel rim weight\n\n// BC.W-GOOBLOB-MEATBALL — the procedural 2D SDF soft-shadow march (T2, the GLSL twin of\n// the WGSL res.z/res.w lanes). uShadow gates the IQ rmshadows soft contact shadow that\n// FOLLOWS the irregular silhouette; uShadowSoftness is the penumbra hardness (4-48).\nuniform float uShadow;          // 0 = no shadow, 1 = the soft contact shadow ON\nuniform float uShadowSoftness;  // penumbra hardness (inverse light-source size, 4-48)\n\n// Iridescence + fake subsurface (W11.a) — translucent-gel read.\nuniform float uIridescence;     // warm-pearl rim sheen weight (0 = off)\nuniform float uIridHue;         // base hue (radians) the cosine palette biases toward (warm)\nuniform float uIridSpeed;       // animated-thickness scroll for the iridescent t\nuniform float uSssScale;        // fast-SSS back-light weight\nuniform float uSssPower;        // fast-SSS exponent\nuniform float uCoreGlow;        // thickness-driven inner-luminosity lift\n\n// Color perturbation (perceptually uniform — OKLCh L/C/h)\nuniform float uHueRange;        // degrees of hue swing (converted to radians)\nuniform float uSatShift;        // OKLCh chroma swing\nuniform float uBrightnessShift; // OKLCh lightness bias\nuniform float uColorNoiseFreq;\nuniform float uColorNoiseSpeed;\n\n// Satellites (max 4)\n#define MAX_SATS 4\nuniform int uSatCount;\nuniform vec2 uSatPos[MAX_SATS];\nuniform float uSatRadius[MAX_SATS];\nuniform float uSatOpacity[MAX_SATS];\n\n// F9.R1 (BG.W-BLOB-SATELLITE-SHADE) — the per-satellite EXPLICIT-SHADE seam (the GL\n// color-seam widen the value.js hero blob asked for; the BA-VJS-5 / C-1 residual, the\n// W-GOO-REDRESS arm-B book discharged). uSatColorActive == 0 is the DEFAULT (the derived\n// palette shade — byte-identical to HEAD): blendSatColor() early-returns and touches\n// nothing. When a consumer supplies explicit per-satellite shades (uSatColor[i], GAMMA\n// sRGB, at uSatColorAmt[i] weight — typically 1) the fragment blends the base palette\n// OKLCh toward each satellite's shade, weighted by that satellite's smin-field proximity\n// at this pixel. The body keeps the derived base (the ask is per-SATELLITE).\nuniform int uSatColorActive;\nuniform vec3 uSatColor[MAX_SATS];\nuniform float uSatColorAmt[MAX_SATS];\n\n// Pointer trail (W10) — a decaying-radius pseudopod toward the cursor. uTrail is a\n// COMPILE-TIME-SIZED array (GLSL ES 3.00 forbids a uniform-sized array) with a\n// DYNAMIC break on uTrailCount, mirroring the satellite loop. Later samples paint\n// smaller metaballs (r *= 1 - i/N) so the trail tapers into a tail.\n#define TRAIL_N 15\nuniform int uTrailCount;\nuniform vec2 uTrailPos[TRAIL_N];\nuniform float uTrailRadius[TRAIL_N];\n\n// Velocity-driven volume-preserving squash-and-stretch (W10).\nuniform vec2 uVelocity;   // smoothed pointer velocity (motion direction + speed)\nuniform float uStretch;   // squash-stretch magnitude (0 = off)\n\nconst float PI = 3.141592653589793;\n", Q = "\n", ke = Oe + Q + Ce + Q + `${i}
+
+` + Ee + Q + Se + Q + `
+// --- Color (Ottosson OKLab/OKLCh — value.js EXACT constants, transposed) ---
+//
+// The OETF (srgbToLinear/linearToSrgb) + the four Ottosson matrices + their space
+// conversions are SPLICED from the shared chunk (AV.W2 —
+// src/composables/glass/webgl/shaders/procedural-color.glsl.ts). They live there
+// ONCE so the OETF can never diverge from aurora's; the line-for-line TS port
+// (__tests__/metaball-color.glsl-port.ts) mirrors that chunk. The gamut-clamp
+// below stays blob-local (aurora has no in-shader OKLCh path).
+${o}
+${c}
+
+` + De + Q + "\n// AX.W15 — de-synced breath. The body throb was a single sin(uPulsePhase) — a\n// mechanical pulse that re-syncs every cycle. Three DETUNED sines at IRRATIONAL\n// frequency ratios (1, 0.13/0.09 ≈ 1.444, 0.31) never re-phase, so the membrane\n// breathes like a living creature (an asymmetric slower-exhale calm band) rather\n// than a metronome. Normalized so the composite stays in ~[-1, 1].\nfloat breath(float phase) {\n    return (sin(phase)\n          + 0.5 * sin(phase * 1.4444 + 1.7)\n          + 0.28 * sin(phase * 0.31 + 4.1)) / 1.78;\n}\n\n// AX.W15 — the composite SDF field WITH its ANALYTIC GRADIENT, returned as\n// vec3(dist, ∂d/∂x, ∂d/∂y). The domain-warped body membrane smin-merged with the\n// satellites + trail; the gradient propagates through sminG's mix(a.yz, b.yz, h)\n// so the surface normal reads the field gradient DIRECTLY (the 4-tap finite\n// difference is DELETED — its 4 full evals per lit pixel are gone).\n//\n// The ANISOTROPIC SQUASH (W10 volume-preserving stretch) is a linear map\n// bodyUv = D·R·uv (R rotates world→(motion-axis, perp); D = diag(1/sa, sa)). The\n// body field's gradient is computed in bodyUv space, so it MUST be transformed back\n// to uv space by M^T = R^T·D (the inverse-transpose handling the SOTA-deepening [2]\n// warns the 4-tap did implicitly by sampling in screen space).\nvec3 sceneDistG(vec2 uv) {\n    // De-synced pulsing body radius.\n    float bodyR = uBodyRadius + breath(uPulsePhase) * uPulseAmp;\n\n    // Velocity-driven VOLUME-PRESERVING squash-and-stretch (W10), SATURATED (AX.W46\n    // D5). sa is the stretch along motion, EXACTLY 1/sa perpendicular (area-preserving).\n    // The basis (ax, perp) is captured so the gradient can be transformed back below.\n    //\n    // The W10 form sa = 1 + speed*uStretch rode an UNBOUNDED critically-damped spring\n    // velocity (O(5-8)/s on a fast flick) -> sa ~ 1.78-2.25x elongation, a violent\n    // taffy-pull. A tanh saturation sa = 1 + tanh(speed*k)*uStretch caps the elongation\n    // at 1 + uStretch (~1.5x at the default stretch 0.5) no matter how fast the flick —\n    // the fastest flick reads as a lively bounce, never a rubber-band snap (the standard\n    // volume-preserving squash-and-stretch restraint). k = 1.6 keeps the tanh in its\n    // near-linear regime for a slow drag (the gentle squash still reads) and saturates\n    // only the fast flick.\n    vec2 bodyUv = uv;\n    vec2 ax = vec2(1.0, 0.0);\n    vec2 perp = vec2(0.0, 1.0);\n    float sa = 1.0;\n    float speed = length(uVelocity);\n    bool squashed = uStretch > 0.0 && speed > 1e-4;\n    if (squashed) {\n        ax = uVelocity / speed;\n        perp = vec2(-ax.y, ax.x);\n        sa = 1.0 + tanh(speed * 1.6) * uStretch;\n        bodyUv = vec2(dot(uv, ax) / sa, dot(uv, perp) * sa);\n    }\n\n    // Domain-warped FBM displacement WITH its analytic gradient (the warp-Jacobian\n    // approximation per [2]). disp = (noiseVal - 0.5) · uNoiseAmp; its gradient in\n    // bodyUv space is uNoiseAmp · uNoiseFreq · fbmGrad (the uNoiseFreq chain factor\n    // from the bodyUv·uNoiseFreq argument).\n    vec3 fbmv = fbmWarpedG(bodyUv * uNoiseFreq + uTime * uNoiseSpeed, 3, uWarpAmp);\n    float bodyDisplacement = (fbmv.x - 0.5) * uNoiseAmp;\n    vec2 dispGradBody = uNoiseAmp * uNoiseFreq * fbmv.yz;\n\n    // Body circle WITH gradient (in bodyUv space). The displaced radius subtracts\n    // the displacement, so the body gradient is circleGrad - dispGrad (sign per\n    // [2]: d = circleDist - displacement ⇒ grad = circleGrad - dispGrad).\n    vec3 bodyG = sdgCircle(bodyUv, vec2(0.0), bodyR + bodyDisplacement);\n    vec2 bodyGradBody = bodyG.yz - dispGradBody;\n\n    // Transform the body gradient back to uv space: g_uv = R^T · D · g_body, i.e.\n    // scale by D = diag(1/sa, sa) in the (ax, perp) frame then reconstruct in world.\n    vec2 bodyGradUv;\n    if (squashed) {\n        vec2 scaled = vec2(bodyGradBody.x / sa, bodyGradBody.y * sa);\n        bodyGradUv = scaled.x * ax + scaled.y * perp;\n    } else {\n        bodyGradUv = bodyGradBody;\n    }\n    vec3 d = vec3(bodyG.x, bodyGradUv);\n\n    // Satellites — smin-merged into the body (uMerge selects quadratic/circular).\n    for (int i = 0; i < MAX_SATS; i++) {\n        if (i >= uSatCount) break;\n        vec3 satG = sdgCircle(uv, uSatPos[i], uSatRadius[i]);\n        satG.x += (1.0 - uSatOpacity[i]) * 0.3;\n        d = sminG(d, satG, uSmoothK);\n    }\n\n    // Pointer trail — a decaying-radius pseudopod reaching toward the cursor,\n    // smin-merged so it stretches an elastic limb and snaps back.\n    for (int i = 0; i < TRAIL_N; i++) {\n        if (i >= uTrailCount) break;\n        vec3 trailG = sdgCircle(uv, uTrailPos[i], uTrailRadius[i]);\n        d = sminG(d, trailG, uSmoothK);\n    }\n    return d;\n}\n\n// AX.W15 — the analytic surface normal. The field gradient grad2d arrives\n// DIRECTLY from sceneDistG (no 4-tap). The smin field is sub-unit (the CD family\n// |grad| ≤ 1) so the gradient is NOT unit-length — normalize() before the dome\n// lift (the unit contract is on the FINAL lifted normal N, not the raw field\n// gradient). The Z dome: 'interior' is the normalized depth inward from the rim\n// (-d/bodyR); z = sqrt(1 - (1 - interior)^2) is the unit half-sphere profile (flat\n// centre, steep rim). N tilts outward along the field gradient near the rim and\n// points at the viewer deep inside.\nvec3 surfaceNormalFromGrad(vec2 grad2d, float d, float bodyR) {\n    vec2 g = normalize(grad2d + vec2(1e-6));\n    float interior = clamp(-d / max(bodyR, 1e-4), 0.0, 1.0);\n    float z = sqrt(max(0.0, 1.0 - (1.0 - interior) * (1.0 - interior)));\n    return normalize(vec3(g * (1.0 - z), z) + vec3(0.0, 0.0, 1e-6));\n}\n\n// BC.W-GOOBLOB-MEATBALL — the 2D SDF soft-shadow march (IQ rmshadows improved-penumbra,\n// research/viz/goo-blob.md §2.3, §5). The GLSL twin of the WGSL softShadow2D — a procedural\n// soft contact shadow FOLLOWING the irregular metaball silhouette (NOT a hard disc/box\n// shadow). Marches from ro along rd (the in-plane projection of uLightDir),\n// accumulating the closest miss via the Aaltonen penumbra (y = h*h/(2*ph) + d =\n// sqrt(h*h - y*y)) that kills the banding the naive res = min(res, h/(w*t)) shows. CHEAP:\n// 24 steps, re-uses the SAME sceneDistG().x field (NO separate field re-eval, NO FBO/\n// multi-pass — the procedural field needs none). w is the penumbra hardness (inverse\n// light-source size -> uShadowSoftness). Derivative-FREE. Returns 1.0 (lit) -> 0.0 (occluded).\nfloat softShadow2D(vec2 ro, vec2 rd, float mint, float maxt, float w) {\n    float res = 1.0;\n    float ph = 1e20;\n    float t = mint;\n    for (int i = 0; i < 24; i++) {\n        if (t >= maxt) break;\n        float h = sceneDistG(ro + rd * t).x;\n        if (h < 0.001) return 0.0;\n        float y = h * h / (2.0 * ph);\n        float dd = sqrt(max(h * h - y * y, 0.0));\n        res = min(res, dd / (w * max(0.001, t - y)));\n        ph = h;\n        t += h;\n    }\n    return clamp(res, 0.0, 1.0);\n}\n\n// W11.b — sample the multi-stop palette at t in [0,1], interpolating adjacent\n// stops in OKLab with a MIDPOINT CHROMA-BUMP (a linear OKLab mix of a vivid pair\n// dips chroma through grey; the bump lifts it back). Falls back to uBaseColor when\n// uStopCount <= 1. Returns an OKLCh stop [L, C, h(rad)].\nvec3 samplePaletteOklch(float t) {\n    if (uStopCount <= 1) return oklabToOklch(srgbToOklab(uBaseColor));\n    float n = float(uStopCount);\n    float ft = clamp(t, 0.0, 1.0) * (n - 1.0);\n    int i0 = int(floor(ft));\n    int i1 = min(i0 + 1, uStopCount - 1);\n    float f = ft - float(i0);\n    // Fetch adjacent stops (uPalette is gamma sRGB) → OKLab.\n    vec3 labA = srgbToOklab(uPalette[i0]);\n    vec3 labB = srgbToOklab(uPalette[i1]);\n    vec3 lab = mix(labA, labB, f);\n    vec3 lch = oklabToOklch(lab);\n    // Midpoint chroma-bump: a bell (peaks at f=0.5) lifts C off the grey midpoint.\n    lch.y += 0.03 * sin(PI * f);\n    return lch;\n}\n\n// F9.R1 (BG.W-BLOB-SATELLITE-SHADE) — the per-satellite explicit-shade blend. The GL\n// color-seam widen value.js's hero blob asked for (the BA-VJS-5 / C-1 residual, the\n// W-GOO-REDRESS arm-B book discharged). DEFAULT OFF: uSatColorActive == 0 returns oklch\n// UNCHANGED (uniform control flow, zero cost, byte-identical to HEAD). When ON, each\n// satellite carrying a positive uSatColorAmt tints the fragments in its smin-field\n// neighbourhood toward its explicit shade — mixed in OKLab (the samplePaletteOklch\n// convention; no hue wrap). The proximity weight rides the SAME opacity-inflated distance\n// the sceneDistG satellite term uses, so a fading satellite's tint fades with it. The\n// body keeps the derived palette base (no uBodyColor fork — the ask is per-SATELLITE).\nvec3 blendSatColor(vec3 oklch, vec2 uv) {\n    if (uSatColorActive == 0) return oklch;\n    vec3 lab = oklchToOklab(oklch);\n    for (int i = 0; i < MAX_SATS; i++) {\n        if (i >= uSatCount) break;\n        float amt = clamp(uSatColorAmt[i], 0.0, 1.0);\n        if (amt <= 0.0) continue;\n        // Proximity: 1 well inside satellite i, fading to 0 across the smin band. The\n        // opacity-inflated distance matches sceneDistG's satellite term.\n        float di = sdCircle(uv, uSatPos[i], uSatRadius[i]) + (1.0 - uSatOpacity[i]) * 0.3;\n        float w = (1.0 - smoothstep(-uSatRadius[i], uSmoothK, di)) * amt;\n        lab = mix(lab, srgbToOklab(uSatColor[i]), clamp(w, 0.0, 1.0));\n    }\n    return oklabToOklch(lab);\n}\n\nvoid main() {\n    vec2 uv = vUv - 0.5;\n\n    // AX.W16 (arm 5) — PRE-FBM bounding early-out. The oversized canvas (1.6x the\n    // wrapper) runs the full fragment ALU — two 3-octave FBM evals + the OKLCh\n    // round-trip + the lit/iridescence/SSS block — on a large transparent border\n    // otherwise (~60% of the canvas is outside the droplet reach). Any fragment beyond\n    // uMaxReach (the PADDED worst-case painted reach, uploaded so it never clips the\n    // wet meniscus) writes transparent and returns BEFORE any of that work. This is a\n    // transparent WRITE, NOT a GLSL discard: the pass is a pure premultiplied blend\n    // with no depth, and discard disables the tiled-renderer fast path on mobile GPUs.\n    // No fwidth is computed before the return, so there is no\n    // derivative-in-non-uniform-control-flow hazard (the kept pixels compute their own\n    // fwidth normally below). The pad covers the pointer-lean uv shift, so testing the\n    // pre-deform uv is safe.\n    if (dot(uv, uv) > uMaxReach * uMaxReach) {\n        fragColor = vec4(0.0);\n        return;\n    }\n\n    // Pointer deformation — honor the SIGN of uPointerAttraction (W10): a positive\n    // attraction leans the body IN toward the cursor, a negative shies it AWAY. The\n    // signed influence flows straight into the UV shift (no hardcoded repulsion).\n    //\n    // AY.W-BLOB-CONFIG D2 — the SIGN was INVERTED in the rendered result. The\n    // sample-shift sign here was uv -= dir*influence; the live readback (an attraction\n    // sweep over a HELD pointer) measured the body shifting MORE toward the cursor as\n    // attraction went MORE NEGATIVE (a=-1 -> +0.081, a=0 -> +0.063, a=+1 -> +0.042) —\n    // exactly inverted: a shy-away -1 LUNGED at the cursor, a lean-in +1 pulled back.\n    // pointerDir = uPointer - uv is the toward-pointer direction in SAMPLE space; to\n    // MOVE the rendered body TOWARD the pointer the sample must shift ALONG pointerDir\n    // (sample the field from where the pointer is), so the sign is uv += dir*influence.\n    // A positive attraction now shifts the body toward the cursor (leans in), a negative\n    // shifts it away (shies) — the sign the comment + the demo slider always promised,\n    // now true in the render.\n    //\n    // AX.W46 D5 — the falloff radius NARROWS 0.65 → 0.5 (the calm-lean reconciliation).\n    // The W15 REDRESS widened it to 0.65 to clear a synthetic floor; the live π-lane\n    // read the result as a LUNGE. The drama lives in the STRENGTH (pointerStrength,\n    // dropped to 0.18 in types.ts), NOT the falloff — the falloff's job is purely to keep\n    // the lean COHERENT across the creature so the body, satellites and trail all tilt\n    // toward the cursor as ONE. At 0.5 the body (sitting ≈0.2 uv from the cursor on a\n    // hover-flick) is still well inside the cutoff, so the whole creature tilts as one —\n    // a gentle, coherent \"it notices you\" lean rather than the body lunging a body-width.\n    if (uPointerActive > 0.5) {\n        vec2 pointerDir = uPointer - uv;\n        float pointerDist = length(pointerDir);\n        float influence = smoothstep(0.5, 0.0, pointerDist) * uPointerAttraction * uPointerStrength;\n        uv += normalize(pointerDir + 1e-6) * influence;\n    }\n\n    // The de-synced pulsing body radius — also reused below for the inner-glow scale.\n    float bodyR = uBodyRadius + breath(uPulsePhase) * uPulseAmp;\n\n    // Composite domain-warped membrane field WITH its analytic gradient (AX.W15).\n    vec3 scene = sceneDistG(uv);\n    float d = scene.x;\n    vec2 fieldGrad = scene.yz;\n\n    // Edit #1 — fwidth-based anti-aliased edge: derive the smoothstep half-width\n    // from the SDF screen-space gradient so the edge stays ~1px regardless of zoom.\n    float aa = max(fwidth(d), 1e-6);\n    float alpha = 1.0 - smoothstep(-aa, aa, d);\n\n    if (alpha < 0.001) {\n        fragColor = vec4(0.0);\n        return;\n    }\n\n    // Edit #4 — perceptually-uniform OKLCh variation. Gamma base → linear → OKLab\n    // → OKLCh; perturb L/C/h; OKLCh → OKLab → linear; hue-preserving gamut clamp.\n    // The base is the multi-stop palette sample (W11.b) — distributed across the\n    // body/satellites by the color noise field — or uBaseColor when single-stop.\n    float colorNoise = fbm(uv * uColorNoiseFreq + uTime * uColorNoiseSpeed, 3);\n    vec3 oklch = samplePaletteOklch(colorNoise);\n    // F9.R1 — per-satellite explicit shade (default no-op at uSatColorActive == 0).\n    oklch = blendSatColor(oklch, uv);\n\n    oklch.z += (colorNoise - 0.5) * uHueRange * (PI / 180.0);     // hue swing, radians\n    oklch.y = max(oklch.y + (colorNoise - 0.5) * uSatShift, 0.0); // chroma swing\n    oklch.x = clamp(oklch.x + uBrightnessShift, 0.0, 1.0);        // lightness bias\n\n    // ── BD.W-GOO-CAROUSEL-DECK — the blob to meatball SHADING MORPH (uMorphT). ──\n    // The user #1 ask: the goo should MORPH BLOB and MEATBALL from one to another\n    // — a CONTINUOUS in-between, not a hard variant cut. The KEY FACT: the body\n    // GEOMETRY is IDENTICAL across blob/meatball (the smin SDF field, the satellites,\n    // the fwidth-AA — all computed ABOVE, before this gate). ONLY the SURFACE shading\n    // (flat fill vs lit/shadow/iridescence/SSS) differs. So the morph is a uMorphT\n    // scalar LERPING the SHADING — NOT a geometry rebuild, NOT a path interpolation.\n    //\n    //   uMorphT = 0  -> the flat warm-cream blob (the STAGE-1 floor, byte-identical to\n    //                   the old uStage > 0.5 early-return);\n    //   uMorphT = 1  -> the lit meatball (the full STAGE-2 dressing, byte-identical to\n    //                   the old else path);\n    //   0 < uMorphT < 1 -> the CONTINUOUS in-between (the morph the user asked for).\n    //\n    // uMorphT resolves from variant for back-compat (blob -> 0, meatball -> 1); a\n    // consumer ANIMATING config.morphT 0..1 gets the live morph. The smin field is\n    // byte-UNTOUCHED (the geometry is shared — that is the whole point).\n    //\n    // The flat color is computed ALWAYS (cheap); the EXPENSIVE dressing (the soft-shadow\n    // secondary march) is gated uMorphT > 0.0 so a pure blob pays ZERO shadow-march\n    // cost (the SLOW-fix discipline — a flat blob is as cheap as the old early-return).\n    float morphT = clamp(uMorphT, 0.0, 1.0);\n\n    // STAGE-1 flat fill — the warm-cream blob color, off the PRE-dressing oklch (the\n    // dressing mutates oklch below, so the flat read must snapshot it here).\n    vec3 flatOkl = gamutClampOklch(oklch);\n    vec3 flatLin = oklabToLinearSrgb(oklchToOklab(flatOkl));\n    vec3 flatRgb = clamp(linearToSrgb(flatLin), 0.0, 1.0);\n\n    // If we are fully flat (a pure blob, morphT == 0), emit the flat fill + dither and\n    // return — the byte-identical STAGE-1 floor, zero dressing cost.\n    if (morphT <= 0.0) {\n        float ign1 = fract(52.9829189 * fract(dot(gl_FragCoord.xy, vec2(0.06711056, 0.00583715))));\n        flatRgb = clamp(flatRgb + (ign1 - 0.5) / 255.0, 0.0, 1.0);\n        fragColor = vec4(flatRgb * alpha, alpha);\n        return;\n    }\n\n    // Surface normal — from the ANALYTIC field gradient (AX.W15: the 4-tap is\n    // deleted). Computed ONCE here and reused by the iridescence (W11.a), the\n    // fake-SSS (W11.a), and the lit glass block (W9.b).\n    vec3 N = surfaceNormalFromGrad(fieldGrad, d, bodyR);\n    vec3 V = vec3(0.0, 0.0, 1.0);\n    float thickness = clamp(-d / max(bodyR, 1e-4), 0.0, 1.0); // 0 at rim, ~1 deep in\n    float fres = pow(1.0 - max(dot(N, V), 0.0), 2.5);          // rim-weighted angle\n\n    // ── W11.a iridescence — warm-biased IQ cosine palette driving OKLCh HUE ──\n    //\n    // A thin-film-like sheen on the RIM (fres-weighted), NOT the cold-blue default:\n    // an IQ cosine palette (a + b*cos(2pi(c*t + d))) maps the Fresnel/edge angle +\n    // the FBM color field + an animated thickness onto a HUE OFFSET biased to the\n    // warm arc (uIridHue), with the chroma clamped to a warm-pearl band so the rim\n    // reads cream/gold (congruent with the warm-cream-glass identity). Mixed into\n    // OKLCh BEFORE the gamut clamp. Default LOW.\n    if (uIridescence > 0.0) {\n        float t = fres + 0.3 * colorNoise + uTime * uIridSpeed;\n        // Cosine palette in HUE space, centred on the warm uIridHue (~0.18 turn of\n        // warm sweep so the sheen shimmers gold→peach, never swinging to cold blue).\n        float iridHue = uIridHue + 0.18 * PI * cos(2.0 * PI * t);\n        float w = fres * uIridescence;          // rim-weighted blend\n        oklch.z = mix(oklch.z, iridHue, w);\n        // Warm-pearl chroma cap: lift chroma toward a pale-pearl band, clamped.\n        oklch.y = min(oklch.y + 0.04 * w, oklch.y + 0.08);\n        oklch.x = min(oklch.x + 0.05 * w, 1.0); // a touch brighter at the sheen\n    }\n\n    // ── W11.a fake subsurface translucency — thickness inner-glow + back-light ──\n    //\n    // A bright translucent CORE fading to a light-leaking EDGE (the -d ramp) plus\n    // the fast-SSS back-light (light wrapping through the thin rim). Both lift OKLCh\n    // L and warm the hue, consuming the W9 normal. In OKLCh before the gamut clamp.\n    if (uCoreGlow > 0.0 || uSssScale > 0.0) {\n        // Beer-Lambert inner luminosity (AX.W15): a SATURATING 1 - exp(-k·thickness)\n        // curve — a flat thick core with a fast warm rim falloff — NOT the linear\n        // coreGlow·thickness ramp (which over-brightens deep interiors). k ≈ 3 reads\n        // as glass depth.\n        oklch.x = min(oklch.x + uCoreGlow * (1.0 - exp(-3.0 * thickness)), 1.0);\n        // Fast-SSS back-light: light wrapping through the thin (low-thickness) rim.\n        vec3 L = normalize(uLightDir + vec3(1e-6));\n        float back = pow(clamp(dot(V, -(L + N * thickness)), 0.0, 1.0), uSssPower);\n        float sss = back * uSssScale * (1.0 - thickness);\n        oklch.x = min(oklch.x + sss, 1.0);\n        // Warm the THIN leaking rim only (scale by 1 - thickness): the SSS hue-warm\n        // shift rides the rim, not the core (AX.W15 — only the thin rim warms).\n        oklch.z += sss * 0.1 * (1.0 - thickness);\n    }\n\n    // ── BC.W-GOOBLOB-MEATBALL — the soft contact shadow (T2, the GLSL twin). A procedural\n    //    soft shadow FOLLOWING the irregular silhouette: march from this fragment's uv\n    //    toward the in-plane projection of uLightDir; where the metaball field occludes the\n    //    light, DARKEN the OKLCh L — a soft grounded contact band under the dome\n    //    (PROCEDURAL, silhouette-following, unlike the static CSS gel-dome drop-shadow).\n    //    Rim-weighted (1 - thickness) so the lit interior stays bright. Gated uShadow > 0.5;\n    //    variant=blob (STAGE 1) ships shadowless via the uStage early-return above. ──\n    if (uShadow > 0.5) {\n        vec2 L2 = normalize(uLightDir.xy + vec2(1e-6));\n        float sh = softShadow2D(uv, L2, max(aa, 0.004), bodyR * 1.5, max(uShadowSoftness, 4.0));\n        // The contact band sits on the LOWER rim (the side AWAY from the light), gated by\n        // the away-facing rim weight + a thin-rim Gaussian band (peak thickness ≈ 0.18) so\n        // the deep-lit interior + the light-facing edge stay BRIGHT (the warm-cream body\n        // mean + the proof:blob-warm-default floor hold). The 0.20 cap is a soft grounding.\n        float away = clamp(-dot(normalize(fieldGrad + vec2(1e-6)), L2), 0.0, 1.0);\n        float band = exp(-pow((thickness - 0.18) / 0.16, 2.0));\n        float shadowDarken = (1.0 - sh) * away * band * 0.20;\n        oklch.x = max(oklch.x - shadowDarken, 0.0);\n    }\n\n    oklch = gamutClampOklch(oklch);\n\n    vec3 lin = oklabToLinearSrgb(oklchToOklab(oklch));\n\n    // ── W9.b lit glass surface — Blinn-Phong glint + Fresnel rim, in LINEAR ──\n    //\n    // The lit terms enter lin in LINEAR space BEFORE the OETF (linearToSrgb)\n    // and BEFORE the * alpha premultiply — a post-OETF apply double-gammas the\n    // highlight and fringes the premultiplied edge (the named A5/A2 trap). The\n    // prior flat inner-glow lift is SUBSUMED by the Fresnel rim (the curvature\n    // read now comes from the surface normal, not a flat smoothstep). Gated behind\n    // uLit so the flat fill stays the default (zero regression).\n    if (uLit > 0.5) {\n        // N, V, thickness are already computed in main() (reused by iridescence/SSS).\n        vec3 L = normalize(uLightDir + vec3(1e-6)); // light direction\n        vec3 H = normalize(L + V);                  // Blinn-Phong half-vector\n\n        // Warm-cream specular glint — a near-white OKLCh TINT (L~0.97, C~0.03,\n        // hue~85°) routed through the SAME spliced OKLCh matrices, NOT hardcoded\n        // sRGB white (pure white reads cheap-CG). Linearized for the linear add.\n        vec3 warmCream = oklabToLinearSrgb(oklchToOklab(vec3(0.97, 0.03, radians(85.0))));\n\n        // ENERGY-CONSERVING Blinn-Phong (AX.W15 [9]): the (shininess+2)/8 factor\n        // DECOUPLES shininess from strength (without it, raising shininess dims the\n        // glint, so the two knobs fight). SPECULAR ANTIALIASING: the FBM membrane\n        // makes the normal vary fast, so a tight glint (16-64) STROBES on small\n        // dock-grid blobs. Widen the effective lobe where the normal varies\n        // (Toksvig-style fwidth clamp) — drop shininess, NOT raise it. nVar reads\n        // the screen-space normal derivative; a high-variance pixel softens the\n        // exponent so the glint stays stable.\n        float nVar = length(fwidth(N));\n        float shininess = uSpecShininess / (1.0 + 24.0 * nVar);\n        float energyNorm = (shininess + 2.0) / 8.0;\n        float spec = pow(max(dot(N, H), 0.0), shininess) * uSpecStrength * energyNorm;\n\n        // Fresnel/Schlick rim — fed uRimColor (the --foreground warm rim via the\n        // /color leaf). FOREGROUND-AWARE MIN-CONTRAST GUARD (AX.W15 [10]):\n        // a var(--primary) blob in dark mode resolves a rim near the BODY color, so\n        // the rim washes out (no contrast). When the rim's luminance sits too close\n        // to the body's, the guard CHROMA-REDUCES and L-LIFTS the rim stop (a\n        // perceptual move, NOT a re-tint) so the curved rim always reads. Computed in\n        // OKLCh so the lift is perceptual.\n        vec3 rimOkl = oklabToOklch(srgbToOklab(uRimColor));\n        float bodyL = oklch.x; // the post-perturb body lightness\n        float dL = abs(rimOkl.x - bodyL);\n        // If the rim is within 0.22 L of the body, push it AWAY (lift if the body is\n        // dark, the dark-mode primary case; the chroma-reduce keeps it neutral-warm).\n        float lack = clamp((0.22 - dL) / 0.22, 0.0, 1.0);\n        rimOkl.x = clamp(mix(rimOkl.x, (bodyL < 0.5 ? 0.92 : 0.18), lack), 0.0, 1.0);\n        rimOkl.y *= mix(1.0, 0.5, lack); // chroma-reduce toward a pale pearl\n        vec3 rimLin = oklabToLinearSrgb(oklchToOklab(rimOkl));\n\n        float rimFres = pow(1.0 - max(dot(N, V), 0.0), uRimPower);\n        float rim = rimFres * uRimStrength * (1.0 - 0.6 * thickness);\n\n        // Combine the two warm highlights and add in LINEAR. max(spec, rim*scale)\n        // keeps the glint from stacking on the rim into a blown hotspot.\n        //\n        // AX.W46 D4 — CLAMP the linear highlight below unity before the add (the\n        // belt-and-braces guard the re-derived specStrength makes rarely-binding but\n        // never lets a worst-case normal blow to a hard white spot). The energy-\n        // conserving Blinn-Phong CAN still spike on a grazing normal where the Toksvig\n        // widen has not kicked in; capping the highlight magnitude at 0.85 (a contained\n        // warm gleam, sub-unity) means the OETF clamp below can never crush a\n        // pure-white pixel over the dome. The cap is on the highlight ALONE (not the\n        // composited lin), so the body color underneath is untouched — it caps only\n        // the additive catch-light's energy.\n        vec3 highlight = max(warmCream * spec, rimLin * rim);\n        highlight = min(highlight, vec3(0.85));\n        lin += highlight;\n    }\n\n    vec3 rgb = clamp(linearToSrgb(lin), 0.0, 1.0); // MANDATORY OETF — closes the seam\n\n    // ── BD.W-GOO-CAROUSEL-DECK — the blob to meatball SHADING MORPH compose. ──\n    // rgb is the fully-dressed meatball surface; flatRgb (snapshotted before the\n    // dressing) is the flat blob fill. The morph is a CONTINUOUS lerp between them on\n    // morphT — at morphT==1 it is byte-identical to the dressed meatball, and the\n    // morphT==0 case already returned the flat fill above. The geometry (alpha/silhouette)\n    // is shared, so only the SURFACE shading interpolates (the morph from one to\n    // another). The dither below applies to the composited result.\n    rgb = mix(flatRgb, rgb, morphT);\n\n    // IGN dither (AX.W15 [2][9]) — the low-chroma warm-cream dome BANDS on 8-bit\n    // panels (visible Mach steps in the smooth L roll). Interleaved-gradient noise at\n    // 1/255, applied AFTER linearToSrgb and BEFORE the *alpha premultiply (aurora\n    // ships the same splice). A triangular ±0.5 LSB dither decorrelates the steps.\n    float ign = fract(52.9829189 * fract(dot(gl_FragCoord.xy, vec2(0.06711056, 0.00583715))));\n    rgb = clamp(rgb + (ign - 0.5) / 255.0, 0.0, 1.0);\n\n    // Edit #8 — premultiply AFTER the OETF: straight-alpha gamma → premultiplied.\n    fragColor = vec4(rgb * alpha, alpha);\n}";
+//#endregion
+//#region src/components/blob/composables/uploadBlobUniforms.ts
+function Ae(e, t, n, r, i, a, o, s, c) {
+	let { U: l, satPosLocs: u, satRadLocs: d, satOpLocs: f, satColorLocs: p, satColorAmtLocs: m, trailPosLocs: h, trailRadLocs: g, paletteLocs: _ } = r, { params: v, rgb: y, simTimeMs: b, timeSec: x, resolveColor: S, rimColor: C, paletteStops: w } = c, { geometry: T, membrane: E, color: D, surface: O, interaction: k } = a;
+	e.useProgram(t), e.bindVertexArray(n), e.uniform2f(l.uResolution, i.width, i.height), e.uniform1f(l.uTime, b / 1e3), e.uniform3f(l.uBaseColor, y[0], y[1], y[2]);
+	let A = w, j = Math.min(A.length, 4);
+	e.uniform1i(l.uStopCount, j);
+	for (let t = 0; t < 4; t++) {
+		let n = _[t] ?? null, r = A[t];
+		if (r) {
+			let t = S(r);
+			e.uniform3f(n, t[0], t[1], t[2]);
+		} else e.uniform3f(n, y[0], y[1], y[2]);
+	}
+	let M = c.satColors ?? [], N = +!!M.some((e) => !!e);
+	e.uniform1i(l.uSatColorActive, N);
+	for (let t = 0; t < 4; t++) {
+		let n = p[t] ?? null, r = m[t] ?? null, i = M[t];
+		if (i) {
+			let t = S(i);
+			e.uniform3f(n, t[0], t[1], t[2]), e.uniform1f(r, 1);
+		} else e.uniform3f(n, y[0], y[1], y[2]), e.uniform1f(r, 0);
+	}
+	let P = o.pointer.value, F = k.pointerAttraction + v.pointerAttraction;
+	e.uniform2f(l.uPointer, P.x * .5 * R, P.y * .5 * R), e.uniform1f(l.uPointerActive, +!!o.active.value), e.uniform1f(l.uPointerAttraction, F), e.uniform1f(l.uPointerStrength, k.pointerStrength * R);
+	let I = Math.max(0, Math.min(1, F)), L = o.velocity.value;
+	e.uniform2f(l.uVelocity, L.x * .5 * R, L.y * .5 * R), e.uniform1f(l.uStretch, k.stretch);
+	let z = o.trailSources(T.satelliteRadius * .7 * I);
+	e.uniform1i(l.uTrailCount, z.count);
+	for (let t = 0; t < 15; t++) {
+		let n = h[t] ?? null, r = g[t] ?? null, i = z.sources[t];
+		i ? (e.uniform2f(n, i.x * .5 * R, i.y * .5 * R), e.uniform1f(r, i.radius * R)) : (e.uniform2f(n, 0, 0), e.uniform1f(r, 0));
+	}
+	e.uniform1f(l.uBodyRadius, T.bodyRadius * R), e.uniform1f(l.uPulsePhase, x * E.pulseFreq * v.pulseFreq * Math.PI * 2);
+	let B = o.pulse.value * k.clickImpulse;
+	e.uniform1f(l.uPulseAmp, (E.pulseAmp * v.pulseAmp / .015 + B) * R), e.uniform1f(l.uNoiseAmp, E.noiseAmp * v.noiseAmp / .025 * R), e.uniform1f(l.uNoiseFreq, E.noiseFreq), e.uniform1f(l.uNoiseSpeed, E.noiseSpeed), e.uniform1f(l.uWarpAmp, E.warpAmp);
+	let V = T.orbitRadius * 1.2 * (1 + T.eccentricity), H = E.smoothK * v.smoothK, U = Math.max(0, V - T.satelliteRadius - T.bodyRadius), ee = H > 0 ? Math.min(1.25, 1 + U / H) : 1;
+	e.uniform1f(l.uSmoothK, H * ee * R), e.uniform1f(l.uMerge, +(E.merge === "circular"));
+	let W = typeof a.morphT == "number" ? Math.max(0, Math.min(1, a.morphT)) : a.variant === "blob" ? 0 : 1;
+	e.uniform1f(l.uMorphT, W), e.uniform1f(l.uStage, +(W <= 0));
+	let te = (a.surface.fissionAmp ?? 0) > 0 ? ae * 1.12 : 0, ne = Math.max(V, te) + T.satelliteRadius, re = (Math.max(T.bodyRadius, ne) + H * ee + E.noiseAmp * v.noiseAmp / .025 + Math.abs(o.pulse.value) * k.clickImpulse) * R + .1;
+	e.uniform1f(l.uMaxReach, re), e.uniform1f(l.uHueRange, D.hueRange + v.hueRange), e.uniform1f(l.uSatShift, D.satShift + v.satShift), e.uniform1f(l.uBrightnessShift, D.brightnessShift + v.brightnessShift), e.uniform1f(l.uColorNoiseFreq, D.colorNoiseFreq), e.uniform1f(l.uColorNoiseSpeed, D.colorNoiseSpeed);
+	let G = W > 0;
+	e.uniform1f(l.uLit, G && O.lit ? 1 : 0);
+	let K = S(C);
+	e.uniform3f(l.uRimColor, K[0], K[1], K[2]), e.uniform3f(l.uLightDir, O.lightDir[0], O.lightDir[1], O.lightDir[2]), e.uniform1f(l.uSpecStrength, O.specStrength), e.uniform1f(l.uSpecShininess, O.specShininess), e.uniform1f(l.uRimPower, O.rimPower), e.uniform1f(l.uRimStrength, O.rimStrength), e.uniform1f(l.uShadow, G && O.shadow ? 1 : 0), e.uniform1f(l.uShadowSoftness, O.shadowSoftness), e.uniform1f(l.uIridescence, O.iridescence * v.iridScale), e.uniform1f(l.uIridHue, O.iridHue * (Math.PI / 180)), e.uniform1f(l.uIridSpeed, O.iridSpeed), e.uniform1f(l.uSssScale, O.sssScale * v.iridScale), e.uniform1f(l.uSssPower, O.sssPower), e.uniform1f(l.uCoreGlow, O.coreGlow);
+	let q = s.sources;
+	e.uniform1i(l.uSatCount, q.length);
+	for (let t = 0; t < 4; t++) {
+		let n = u[t] ?? null, r = d[t] ?? null, i = f[t] ?? null, a = q[t];
+		a ? (e.uniform2f(n, a.x * R, a.y * R), e.uniform1f(r, a.radius * R), e.uniform1f(i, a.opacity)) : (e.uniform2f(n, 0, 0), e.uniform1f(r, 0), e.uniform1f(i, 0));
+	}
+	e.clearColor(0, 0, 0, 0), e.clear(e.COLOR_BUFFER_BIT), e.drawArrays(e.TRIANGLES, 0, 6), e.bindVertexArray(null);
+}
+//#endregion
+//#region src/components/blob/composables/buildMetaballProgram.ts
+var je = "[GooBlob]";
+function Me(e) {
+	let t = p(e, e.VERTEX_SHADER, xe, je), n = p(e, e.FRAGMENT_SHADER, ke, je), r = f(e, t, n, je);
+	e.useProgram(r);
+	let i = e.createVertexArray();
+	e.bindVertexArray(i);
+	let a = e.createBuffer();
+	e.bindBuffer(e.ARRAY_BUFFER, a), e.bufferData(e.ARRAY_BUFFER, new Float32Array([
+		-1,
+		-1,
+		1,
+		-1,
+		-1,
+		1,
+		-1,
+		1,
+		1,
+		-1,
+		1,
+		1
+	]), e.STATIC_DRAW);
+	let o = e.getAttribLocation(r, "aPosition");
+	e.enableVertexAttribArray(o), e.vertexAttribPointer(o, 2, e.FLOAT, !1, 0, 0);
+	let s = {};
+	for (let t of ce) s[t] = e.getUniformLocation(r, t);
+	let c = [], l = [], u = [], d = [], m = [];
+	for (let t = 0; t < 4; t++) c.push(e.getUniformLocation(r, `uSatPos[${t}]`)), l.push(e.getUniformLocation(r, `uSatRadius[${t}]`)), u.push(e.getUniformLocation(r, `uSatOpacity[${t}]`)), d.push(e.getUniformLocation(r, `uSatColor[${t}]`)), m.push(e.getUniformLocation(r, `uSatColorAmt[${t}]`));
+	let h = [], g = [];
+	for (let t = 0; t < 15; t++) h.push(e.getUniformLocation(r, `uTrailPos[${t}]`)), g.push(e.getUniformLocation(r, `uTrailRadius[${t}]`));
+	let _ = [];
+	for (let t = 0; t < 4; t++) _.push(e.getUniformLocation(r, `uPalette[${t}]`));
+	return e.enable(e.BLEND), e.blendFunc(e.ONE, e.ONE_MINUS_SRC_ALPHA), {
+		prog: r,
+		vs: t,
+		fs: n,
+		vao: i,
+		buf: a,
+		locs: {
+			U: s,
+			satPosLocs: c,
+			satRadLocs: l,
+			satOpLocs: u,
+			satColorLocs: d,
+			satColorAmtLocs: m,
+			trailPosLocs: h,
+			trailRadLocs: g,
+			paletteLocs: _
+		}
+	};
+}
+//#endregion
+//#region src/components/blob/shaders/metaball.wgsl.ts
+var Ne = `
+const MAX_SATS: i32 = 4;
+const TRAIL_N: i32 = 15;
+const MAX_BLOB_STOPS: i32 = 4;
+const PI: f32 = 3.141592653589793;
+
+// ── Uniforms (the typed-struct source-of-truth — see uniformBridgeWGPU.ts) ──
+// Scalars packed into vec4 lanes; per-satellite / per-trail / per-palette rows packed
+// into a vec4 so the array stride is the natural 16 bytes (no std140 stride trap — the
+// parity-blowout suspect the wave's §Triumvirate names).
+struct Uniforms {
+  // s0: (uTime, uBodyRadius, uPulsePhase, uPulseAmp)
+  s0: vec4<f32>,
+  // s1: (uNoiseAmp, uNoiseFreq, uNoiseSpeed, uWarpAmp)
+  s1: vec4<f32>,
+  // s2: (uSmoothK, uMerge, uMaxReach, uLit)
+  s2: vec4<f32>,
+  // s3: (uSpecStrength, uSpecShininess, uRimPower, uRimStrength)
+  s3: vec4<f32>,
+  // s4: (uIridescence, uIridHue, uIridSpeed, uSssScale)
+  s4: vec4<f32>,
+  // s5: (uSssPower, uCoreGlow, uHueRange, uSatShift)
+  s5: vec4<f32>,
+  // s6: (uBrightnessShift, uColorNoiseFreq, uColorNoiseSpeed, uStretch)
+  s6: vec4<f32>,
+  // s7: (uPointerActive, uPointerAttraction, uPointerStrength, uStage)
+  // BC.W-GOOBLOB-PLAIN — uStage gates the STAGE-1 stripped floor: 1.0 = the plain
+  // shadowless lightless fill-only floor (variant="blob"); 0.0 = the full lit
+  // pipeline (variant="meatball" / STAGE 2). It rides the spare s7.w lane the typed-
+  // struct SoT (uniformBridgeWGPU.ts) reserved.
+  s7: vec4<f32>,
+  // ptr: (uPointer.x, uPointer.y, uVelocity.x, uVelocity.y)
+  ptr: vec4<f32>,
+  // base: (uBaseColor.rgb, _pad)
+  base: vec4<f32>,
+  // rim: (uRimColor.rgb, _pad)
+  rim: vec4<f32>,
+  // light: (uLightDir.xyz, _pad)
+  light: vec4<f32>,
+  // res: (uResolution.x, uResolution.y, uShadow, uShadowSoftness)
+  // BC.W-GOOBLOB-MEATBALL — the soft-shadow march rides the spare res.z/res.w lanes the
+  // typed-struct SoT (uniformBridgeWGPU.ts) reserved (the EXTEND, never a re-fork): res.z
+  // = uShadow (1.0 = the variant=meatball shadow ON), res.w = uShadowSoftness (the
+  // penumbra hardness, inverse light-source size → 4-48).
+  res: vec4<f32>,
+  // ints: (uStopCount, uSatCount, uTrailCount, _pad)
+  ints: vec4<i32>,
+  palette: array<vec4<f32>, 4>,
+  satPos: array<vec4<f32>, 4>,   // (pos.x, pos.y, radius, opacity)
+  trailPos: array<vec4<f32>, 15>, // (pos.x, pos.y, radius, _pad)
+};
+
+@group(0) @binding(0) var<uniform> u: Uniforms;
+
+// Noise + FBM (BC.W-CARVE6 -> metaball-noise.wgsl) — spliced AFTER the FBM_ROT_WGSL chunk
+// below. NB: do NOT name the chunk with a template-interpolation form in a WGSL comment —
+// it injects the whole multi-line chunk into this // comment line and breaks the parse
+// (BD.W-VIZ-BROKEN-FIX D3c).
+${l}
+
+const FBM_LACUNARITY: f32 = 1.8;
+const FBM_GAIN: f32 = 0.42;
+
+// ── Noise (blob-LOCAL 3D-p3 hash + IQ analytic-derivative gradient noise) ──
+fn hash21(p: vec2<f32>) -> f32 {
+  var p3 = fract(vec3<f32>(p.x, p.y, p.x) * 0.1031);
+  p3 = p3 + dot(p3, p3.yzx + 33.33);
+  return fract((p3.x + p3.y) * p3.z);
+}
+
+// IQ analytic-derivative gradient noise — value in .x, ANALYTIC gradient (d/dx, d/dy) in
+// .yz, from one eval. The quintic fade has a continuous 2nd derivative.
+fn noised(p: vec2<f32>) -> vec3<f32> {
+  let i = floor(p);
+  let f = fract(p);
+  let uu = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);
+  let du = 30.0 * f * f * (f * (f - 2.0) + 1.0);
+
+  let ga = -1.0 + 2.0 * vec2<f32>(hash21(i + vec2<f32>(0.0, 0.0)), hash21(i + vec2<f32>(7.3, 0.0)));
+  let gb = -1.0 + 2.0 * vec2<f32>(hash21(i + vec2<f32>(1.0, 0.0)), hash21(i + vec2<f32>(8.3, 0.0)));
+  let gc = -1.0 + 2.0 * vec2<f32>(hash21(i + vec2<f32>(0.0, 1.0)), hash21(i + vec2<f32>(7.3, 1.0)));
+  let gd = -1.0 + 2.0 * vec2<f32>(hash21(i + vec2<f32>(1.0, 1.0)), hash21(i + vec2<f32>(8.3, 1.0)));
+
+  let va = dot(ga, f - vec2<f32>(0.0, 0.0));
+  let vb = dot(gb, f - vec2<f32>(1.0, 0.0));
+  let vc = dot(gc, f - vec2<f32>(0.0, 1.0));
+  let vd = dot(gd, f - vec2<f32>(1.0, 1.0));
+
+  let n = va + uu.x * (vb - va) + uu.y * (vc - va) + uu.x * uu.y * (va - vb - vc + vd);
+  let value = 0.5 + 0.5 * n;
+
+  let grad =
+    ga + uu.x * (gb - ga) + uu.y * (gc - ga) + uu.x * uu.y * (ga - gb - gc + gd) +
+    du * (vec2<f32>(uu.y, uu.x) * (va - vb - vc + vd) + vec2<f32>(vb, vc) - va);
+  return vec3<f32>(value, 0.5 * grad);
+}
+
+fn fbm(p0: vec2<f32>, octaves: i32) -> f32 {
+  var value = 0.0;
+  var amp = 0.5;
+  var freq = 1.0;
+  var p = p0;
+  for (var i = 0; i < 4; i = i + 1) {
+    if (i >= octaves) { break; }
+    value = value + amp * noised(p * freq).x;
+    p = FBM_ROT * p;
+    freq = freq * FBM_LACUNARITY;
+    amp = amp * FBM_GAIN;
+  }
+  return value;
+}
+
+// FBM with ANALYTIC GRADIENT — value in .x, ∂/∂x, ∂/∂y in .yz. The gradient accumulates
+// noised()'s analytic gradient per octave, chain-ruled through the per-octave frequency
+// scale AND the FBM_ROT rotation (the keystone feed for the analytic surface normal).
+fn fbmG(p: vec2<f32>, octaves: i32) -> vec3<f32> {
+  var value = 0.0;
+  var grad = vec2<f32>(0.0, 0.0);
+  var amp = 0.5;
+  var freq = 1.0;
+  var rotAccum = mat2x2<f32>(1.0, 0.0, 0.0, 1.0);
+  var pp = p;
+  for (var i = 0; i < 4; i = i + 1) {
+    if (i >= octaves) { break; }
+    let n = noised(pp * freq);
+    value = value + amp * n.x;
+    grad = grad + amp * freq * (transpose(rotAccum) * n.yz);
+    pp = FBM_ROT * pp;
+    freq = freq * FBM_LACUNARITY;
+    amp = amp * FBM_GAIN;
+    rotAccum = FBM_ROT * rotAccum;
+  }
+  return vec3<f32>(value, grad);
+}
+
+// One domain-warp pass with the ANALYTIC GRADIENT carried (warp-Jacobian approximation).
+fn fbmWarpedG(p: vec2<f32>, octaves: i32, warpAmp: f32) -> vec3<f32> {
+  if (warpAmp <= 0.0) { return fbmG(p, octaves); }
+  let q = vec2<f32>(fbm(p + vec2<f32>(0.0, 0.0), octaves),
+                    fbm(p + vec2<f32>(5.2, 1.3), octaves));
+  return fbmG(p + warpAmp * (q - 0.5), octaves);
+}
+
+
+// ── SDF body (value+gradient circle + the IQ normalized smin, value+gradient form) ──
+fn sdgCircle(p: vec2<f32>, center: vec2<f32>, radius: f32) -> vec3<f32> {
+  let d = p - center;
+  let len = length(d);
+  var grad = vec2<f32>(0.0, 1.0);
+  if (len > 1e-6) { grad = d / len; }
+  return vec3<f32>(len - radius, grad);
+}
+
+fn sminQuadraticG(a: vec3<f32>, b: vec3<f32>, k0: f32) -> vec3<f32> {
+  let k = k0 * 4.0;
+  let h = max(k - abs(a.x - b.x), 0.0) / k;
+  let m = h * h * k * 0.25;
+  var w = 1.0 - 0.5 * h * h;
+  if (a.x < b.x) { w = 0.5 * h * h; }
+  let dist = min(a.x, b.x) - m;
+  let grad = mix(a.yz, b.yz, w);
+  return vec3<f32>(dist, grad);
+}
+
+fn sminCircularG(a: vec3<f32>, b: vec3<f32>, k0: f32) -> vec3<f32> {
+  let k = k0 * (1.0 / (1.0 - sqrt(0.5)));
+  let h = max(k - abs(a.x - b.x), 0.0) / k;
+  let m = k * 0.5 * (1.0 + h - sqrt(1.0 - h * (h - 2.0)));
+  var w = 1.0 - 0.5 * h;
+  if (a.x < b.x) { w = 0.5 * h; }
+  let dist = min(a.x, b.x) - m;
+  let grad = mix(a.yz, b.yz, w);
+  return vec3<f32>(dist, grad);
+}
+
+fn sminG(a: vec3<f32>, b: vec3<f32>, k: f32) -> vec3<f32> {
+  if (u.s2.y > 0.5) { return sminCircularG(a, b, k); }
+  return sminQuadraticG(a, b, k);
+}
+
+${a}
+${s}
+
+// OKLCh gamut clamp + palette sample + breath (BC.W-CARVE6 -> metaball-palette.wgsl)
+// — spliced AFTER the OKLCH_MATRICES_WGSL chunk above (its matrix source). NB: do NOT
+// write the chunk's identifier with a template-interpolation form in a WGSL comment — it
+// would inject the whole multi-line matrices chunk INTO this // comment line and break the
+// parse at the first injected newline (BD.W-VIZ-BROKEN-FIX D3c — the live WGSL syntax error
+// that silently fell every metaball/goo-dot to the WebGL2 net, masking the WGSL primary).
+
+// ── OKLCh gamut clamp (hue-preserving inward chroma clamp — blob-local) ──
+fn inGamut(lin: vec3<f32>) -> bool {
+  return all(lin >= vec3<f32>(0.0)) && all(lin <= vec3<f32>(1.0));
+}
+fn gamutClampOklch(lch: vec3<f32>) -> vec3<f32> {
+  let lin = oklabToLinearSrgb(oklchToOklab(lch));
+  if (inGamut(lin)) { return lch; }
+  var lo = 0.0;
+  var hi = lch.y;
+  for (var i = 0; i < 16; i = i + 1) {
+    let mid = 0.5 * (lo + hi);
+    let test = vec3<f32>(lch.x, mid, lch.z);
+    if (inGamut(oklabToLinearSrgb(oklchToOklab(test)))) { lo = mid; } else { hi = mid; }
+  }
+  return vec3<f32>(lch.x, lo, lch.z);
+}
+
+// W11.b — sample the multi-stop palette at t, OKLab mix + midpoint chroma-bump. Returns
+// an OKLCh stop [L, C, h(rad)]. Falls back to uBaseColor when uStopCount <= 1.
+fn samplePaletteOklch(t: f32) -> vec3<f32> {
+  let uStopCount = u.ints.x;
+  if (uStopCount <= 1) { return oklabToOklch(srgbToOklab(u.base.rgb)); }
+  let n = f32(uStopCount);
+  let ft = clamp(t, 0.0, 1.0) * (n - 1.0);
+  let i0 = i32(floor(ft));
+  let i1 = min(i0 + 1, uStopCount - 1);
+  let f = ft - f32(i0);
+  let labA = srgbToOklab(u.palette[i0].rgb);
+  let labB = srgbToOklab(u.palette[i1].rgb);
+  let lab = mix(labA, labB, f);
+  var lch = oklabToOklch(lab);
+  lch.y = lch.y + 0.03 * sin(PI * f);
+  return lch;
+}
+
+// AX.W15 — de-synced breath (three DETUNED sines at irrational ratios).
+fn breath(phase: f32) -> f32 {
+  return (sin(phase) + 0.5 * sin(phase * 1.4444 + 1.7) + 0.28 * sin(phase * 0.31 + 4.1)) / 1.78;
+}
+
+
+// AX.W15 — the composite SDF field WITH its ANALYTIC GRADIENT vec3(dist, ∂/∂x, ∂/∂y).
+fn sceneDistG(uv: vec2<f32>) -> vec3<f32> {
+  let uBodyRadius = u.s0.y;
+  let uPulsePhase = u.s0.z;
+  let uPulseAmp = u.s0.w;
+  let uNoiseAmp = u.s1.x;
+  let uNoiseFreq = u.s1.y;
+  let uNoiseSpeed = u.s1.z;
+  let uWarpAmp = u.s1.w;
+  let uSmoothK = u.s2.x;
+  let uTime = u.s0.x;
+  let uVelocity = u.ptr.zw;
+  let uStretch = u.s6.w;
+  let uSatCount = u.ints.y;
+  let uTrailCount = u.ints.z;
+
+  let bodyR = uBodyRadius + breath(uPulsePhase) * uPulseAmp;
+
+  // Velocity-driven VOLUME-PRESERVING squash-and-stretch (tanh-saturated).
+  var bodyUv = uv;
+  var ax = vec2<f32>(1.0, 0.0);
+  var perp = vec2<f32>(0.0, 1.0);
+  var sa = 1.0;
+  let speed = length(uVelocity);
+  let squashed = uStretch > 0.0 && speed > 1e-4;
+  if (squashed) {
+    ax = uVelocity / speed;
+    perp = vec2<f32>(-ax.y, ax.x);
+    sa = 1.0 + tanh(speed * 1.6) * uStretch;
+    bodyUv = vec2<f32>(dot(uv, ax) / sa, dot(uv, perp) * sa);
+  }
+
+  // Domain-warped FBM displacement WITH its analytic gradient.
+  let fbmv = fbmWarpedG(bodyUv * uNoiseFreq + uTime * uNoiseSpeed, 3, uWarpAmp);
+  let bodyDisplacement = (fbmv.x - 0.5) * uNoiseAmp;
+  let dispGradBody = uNoiseAmp * uNoiseFreq * fbmv.yz;
+
+  let bodyG = sdgCircle(bodyUv, vec2<f32>(0.0), bodyR + bodyDisplacement);
+  let bodyGradBody = bodyG.yz - dispGradBody;
+
+  var bodyGradUv: vec2<f32>;
+  if (squashed) {
+    let scaled = vec2<f32>(bodyGradBody.x / sa, bodyGradBody.y * sa);
+    bodyGradUv = scaled.x * ax + scaled.y * perp;
+  } else {
+    bodyGradUv = bodyGradBody;
+  }
+  var d = vec3<f32>(bodyG.x, bodyGradUv);
+
+  // Satellites — smin-merged into the body.
+  for (var i = 0; i < MAX_SATS; i = i + 1) {
+    if (i >= uSatCount) { break; }
+    let s = u.satPos[i];
+    var satG = sdgCircle(uv, s.xy, s.z);
+    satG.x = satG.x + (1.0 - s.w) * 0.3;
+    d = sminG(d, satG, uSmoothK);
+  }
+
+  // Pointer trail — a decaying-radius pseudopod.
+  for (var i = 0; i < TRAIL_N; i = i + 1) {
+    if (i >= uTrailCount) { break; }
+    let tp = u.trailPos[i];
+    let trailG = sdgCircle(uv, tp.xy, tp.z);
+    d = sminG(d, trailG, uSmoothK);
+  }
+  return d;
+}
+
+// AX.W15 — the analytic surface normal from the field gradient.
+fn surfaceNormalFromGrad(grad2d: vec2<f32>, d: f32, bodyR: f32) -> vec3<f32> {
+  let g = normalize(grad2d + vec2<f32>(1e-6));
+  let interior = clamp(-d / max(bodyR, 1e-4), 0.0, 1.0);
+  let z = sqrt(max(0.0, 1.0 - (1.0 - interior) * (1.0 - interior)));
+  return normalize(vec3<f32>(g * (1.0 - z), z) + vec3<f32>(0.0, 0.0, 1e-6));
+}
+
+// ── BC.W-GOOBLOB-MEATBALL — the 2D SDF soft-shadow march (IQ rmshadows improved-penumbra,
+//    research/viz/goo-blob.md §2.3). A procedural soft contact shadow that FOLLOWS the
+//    irregular metaball silhouette (NOT a hard disc / box shadow). Marches a ray from ro
+//    along rd (the in-plane projection of uLightDir), accumulating the closest miss via
+//    the Aaltonen penumbra (y = h*h/(2*ph) + d = sqrt(h*h - y*y)) that kills the
+//    banding the naive res = min(res, h/(w*t)) shows. CHEAP: 24 steps, re-uses the SAME
+//    sceneDistG().x field (NO separate field re-eval, NO FBO/multi-pass — the procedural
+//    field needs none, §2.3). w is the penumbra hardness (inverse light-source size →
+//    uShadowSoftness). It is derivative-FREE (no fwidth/dpdx/dpdy), so it is fragment-safe
+//    here. Returns 1.0 (fully lit) → 0.0 (fully occluded). ──
+fn softShadow2D(ro: vec2<f32>, rd: vec2<f32>, mint: f32, maxt: f32, w: f32) -> f32 {
+  var res = 1.0;
+  var ph = 1e20;
+  var t = mint;
+  for (var i = 0; i < 24; i = i + 1) {
+    if (t >= maxt) { break; }
+    let h = sceneDistG(ro + rd * t).x;
+    if (h < 0.001) { return 0.0; }
+    let y = h * h / (2.0 * ph);
+    let dd = sqrt(max(h * h - y * y, 0.0));
+    res = min(res, dd / (w * max(0.001, t - y)));
+    ph = h;
+    t = t + h;
+  }
+  return clamp(res, 0.0, 1.0);
+}
+
+// ── Full-screen triangle vertex stage (the pilot idiom — no vertex buffer) ──
+struct VSOut {
+  @builtin(position) pos: vec4<f32>,
+  @location(0) uv: vec2<f32>,
+};
+
+@vertex
+fn vs_main(@builtin(vertex_index) vi: u32) -> VSOut {
+  var p = vec2<f32>(-1.0, -1.0);
+  if (vi == 1u) { p = vec2<f32>(3.0, -1.0); }
+  else if (vi == 2u) { p = vec2<f32>(-1.0, 3.0); }
+  var out: VSOut;
+  out.pos = vec4<f32>(p, 0.0, 1.0);
+  // vUv = aPos * 0.5 + 0.5 (the metaball.vert convention).
+  out.uv = p * 0.5 + 0.5;
+  return out;
+}
+
+// ── Fragment stage (the main() transcription) ──
+@fragment
+fn fs_main(in: VSOut) -> @location(0) vec4<f32> {
+  let uTime = u.s0.x;
+  let uBodyRadius = u.s0.y;
+  let uPulsePhase = u.s0.z;
+  let uPulseAmp = u.s0.w;
+  let uMaxReach = u.s2.z;
+  let uLit = u.s2.w;
+  let uPointerActive = u.s7.x;
+  let uPointerAttraction = u.s7.y;
+  let uPointerStrength = u.s7.z;
+  // BC.W-GOOBLOB-PLAIN — the STAGE-1 gate (1.0 = the plain shadowless fill-only floor).
+  let uStage = u.s7.w;
+  // BD.W-GOO-CAROUSEL-DECK — the blob to meatball SHADING-MORPH scalar (the base.w pad
+  // lane; the typed-struct SoT writes it). 0 = flat blob, 1 = lit meatball, in-between
+  // lerps the surface shading (the smin geometry is shared).
+  let uMorphT = clamp(u.base.w, 0.0, 1.0);
+  let uPointer = u.ptr.xy;
+  let uHueRange = u.s5.z;
+  let uSatShift = u.s5.w;
+  let uBrightnessShift = u.s6.x;
+  let uColorNoiseFreq = u.s6.y;
+  let uColorNoiseSpeed = u.s6.z;
+  let uIridescence = u.s4.x;
+  let uIridHue = u.s4.y;
+  let uIridSpeed = u.s4.z;
+  let uSssScale = u.s4.w;
+  let uSssPower = u.s5.x;
+  let uCoreGlow = u.s5.y;
+  let uSpecStrength = u.s3.x;
+  let uSpecShininess = u.s3.y;
+  let uRimPower = u.s3.z;
+  let uRimStrength = u.s3.w;
+  let uLightDir = u.light.xyz;
+  let uRimColor = u.rim.rgb;
+  // BC.W-GOOBLOB-MEATBALL — the soft-shadow gate + penumbra hardness (res.z/res.w lanes).
+  let uShadow = u.res.z;
+  let uShadowSoftness = u.res.w;
+
+  var uv = in.uv - 0.5;
+
+  // PRE-FBM bounding test (BD.W-VIZ-BROKEN-FIX D3c — the uniformity fix). The GLSL fallback
+  // EARLY-RETURNS transparent here (a perf skip of the FBM border); WGSL CANNOT — an early
+  // return predicated on the per-fragment uv makes the fwidth(d)/fwidth(Nh) calls below
+  // reachable only through non-uniform control flow, which the WGSL uniformity analyzer
+  // REJECTS (fwidth must only be called from uniform control flow) so the metaball WGSL
+  // module never compiled and every GooBlob + goo-dot fell silently to the WebGL2 net (the
+  // "broken TOTALLY" the user reports, the un-exercised Safari-primary surface). So the
+  // bound is folded into the FINAL alpha (a flag, NOT a control-flow return): the derivative
+  // builtins stay in UNIFORM control flow, and an outside fragment writes transparent at the
+  // end — gestalt-identical to the GLSL early-out, just without the WGSL-illegal pre-
+  // derivative return. sceneDistG is derivative-FREE so running it on the border costs only
+  // ALU (no correctness hazard); the real GPU swallows it.
+  let inBounds = dot(uv, uv) <= uMaxReach * uMaxReach;
+
+  // Pointer deformation — sign per AY.W-BLOB-CONFIG D2.
+  if (uPointerActive > 0.5) {
+    let pointerDir = uPointer - uv;
+    let pointerDist = length(pointerDir);
+    let influence = smoothstep(0.5, 0.0, pointerDist) * uPointerAttraction * uPointerStrength;
+    uv = uv + normalize(pointerDir + vec2<f32>(1e-6)) * influence;
+  }
+
+  let bodyR = uBodyRadius + breath(uPulsePhase) * uPulseAmp;
+
+  // Composite domain-warped membrane field WITH its analytic gradient.
+  let scene = sceneDistG(uv);
+  let d = scene.x;
+  let fieldGrad = scene.yz;
+
+  // ── fwidth SITE #1 (metaball.frag.ts line 266) — AA-edge half-width from the SDF
+  //    screen-space gradient. The WGSL fragment-stage fwidth() transcription. In UNIFORM
+  //    control flow (no early return precedes it — the bounding test above is a flag). ──
+  let aa = max(fwidth(d), 1e-6);
+  // The bounding test (D3c) folds in here: an out-of-bounds fragment is forced transparent
+  // (the GLSL early-out's transparent WRITE, expressed as an alpha gate, not a return).
+  let alpha = (1.0 - smoothstep(-aa, aa, d)) * select(0.0, 1.0, inBounds);
+
+  // ── BC.W-GOOBLOB-MEATBALL — the WGSL uniformity STRUCTURAL fix (the meatball-armer).
+  //    The Toksvig screen-space derivative (fwidth SITE #2) is hoisted HERE, into the SAME
+  //    uniform control flow fwidth(d) above already arms in (top-level fs_main, before the
+  //    per-fragment alpha < 0.001 early-return and the uLit/uShadow non-uniform branches).
+  //    WGSL uniformity analysis rejects a fwidth() reached only through a return predicated
+  //    on a per-fragment value (the alpha < 0.001 early-out) nested under further branches
+  //    — exactly the BB residual that kept the normal-derivative inside the lit branch from
+  //    compiling, so the WGSL primary never armed and GooBlob fell to the WebGL2 net. Nh is
+  //    the uniform-flow surface normal computed for this derivative ONLY (byte-identical to
+  //    the lit block's own N = surfaceNormalFromGrad(...) below — the SAME inputs, so
+  //    nVar = length(fwidth(Nh)) IS the Toksvig clamp the lit block reads); the named lit-
+  //    block N stays AFTER the uStage early-return (the STAGE-1 floor reaches no lit work).
+  //    nVar is a pure uniform-flow value the lit block READS — no derivative in non-uniform
+  //    flow; the math is byte-identical to the GLSL fallback's Toksvig clamp, only its
+  //    EVALUATION POINT moved. The shadow march (T2) reuses d (the same sceneDistG().x).
+  let Nh = surfaceNormalFromGrad(fieldGrad, d, bodyR);
+  // ── fwidth SITE #2 (metaball.frag.ts line 364) — Toksvig normal-variance specular
+  //    clamp, the WGSL fragment-stage fwidth() of the surface normal. NOW in uniform
+  //    control flow (the structural fix), so the WGSL primary ARMS + paints the full lit
+  //    creature instead of falling to the stripped WebGL2 fallback. ──
+  let nVar = length(fwidth(Nh));
+
+  if (alpha < 0.001) {
+    return vec4<f32>(0.0);
+  }
+
+  // Edit #4 — perceptually-uniform OKLCh variation.
+  let colorNoise = fbm(uv * uColorNoiseFreq + uTime * uColorNoiseSpeed, 3);
+  var oklch = samplePaletteOklch(colorNoise);
+
+  oklch.z = oklch.z + (colorNoise - 0.5) * uHueRange * (PI / 180.0);
+  oklch.y = max(oklch.y + (colorNoise - 0.5) * uSatShift, 0.0);
+  oklch.x = clamp(oklch.x + uBrightnessShift, 0.0, 1.0);
+
+  // ── BC.W-GOOBLOB-PLAIN — the STAGE-1 stripped floor (variant=blob). ──
+  // The minimal verifiable floor: SDF + smin (the meatball field, already in d/
+  // alpha above) + fwidth-AA (the crisp alpha above) + warm-cream fill. NO surface
+  // normal, NO Fresnel, NO lit glint, NO iridescence, NO fake-SSS, NO shadow —
+  // deliberately FLAT. It returns BEFORE any of the STAGE-2 dressing is reached. The
+  // STAGE-1 path simply never READS the hoisted Nh/nVar or the lit/shadow blocks; the
+  // normal-derivative is now in UNIFORM control flow above (BC.W-GOOBLOB-MEATBALL — the
+  // structural armer), so BOTH the STAGE-1 floor AND the STAGE-2 lit path arm on Metal
+  // (the BB residual that kept STAGE 2 falling to the WebGL2 net is CLOSED). The
+  // teaching contrast: this is the "it renders, it meatballs, it works on Safari"
+  // floor STAGE 2 layers the lit/shadow onto via the SAME uniforms.
+  // BD.W-GOO-CAROUSEL-DECK — the flat blob fill is snapshotted from the PRE-dressing
+  // oklch (the dressing mutates oklch below). At morphT <= 0 (a pure blob) emit the
+  // flat fill + dither and return — the byte-identical STAGE-1 floor, zero dressing cost.
+  let flatOkl = gamutClampOklch(oklch);
+  let flatLin = oklabToLinearSrgb(oklchToOklab(flatOkl));
+  let flatRgbBase = clamp(linearToSrgb(flatLin), vec3<f32>(0.0), vec3<f32>(1.0));
+  if (uMorphT <= 0.0) {
+    let fc1 = in.pos.xy;
+    let ign1 = fract(52.9829189 * fract(dot(fc1, vec2<f32>(0.06711056, 0.00583715))));
+    let rgb1 = clamp(flatRgbBase + (ign1 - 0.5) / 255.0, vec3<f32>(0.0), vec3<f32>(1.0));
+    return vec4<f32>(rgb1 * alpha, alpha);
+  }
+
+  // The named surface normal the lit/iridescence/SSS blocks read (byte-identical inputs to
+  // the hoisted Nh above — the Toksvig nVar = length(fwidth(Nh)) IS this N's screen-space
+  // variance). It sits AFTER the uStage early-return so the STAGE-1 floor reaches no lit work.
+  let N = surfaceNormalFromGrad(fieldGrad, d, bodyR);
+  let V = vec3<f32>(0.0, 0.0, 1.0);
+  let thickness = clamp(-d / max(bodyR, 1e-4), 0.0, 1.0);
+  let fres = pow(1.0 - max(dot(N, V), 0.0), 2.5);
+
+  // ── W11.a iridescence — warm-biased IQ cosine palette driving OKLCh HUE ──
+  if (uIridescence > 0.0) {
+    let t = fres + 0.3 * colorNoise + uTime * uIridSpeed;
+    let iridHue = uIridHue + 0.18 * PI * cos(2.0 * PI * t);
+    let w = fres * uIridescence;
+    oklch.z = mix(oklch.z, iridHue, w);
+    oklch.y = min(oklch.y + 0.04 * w, oklch.y + 0.08);
+    oklch.x = min(oklch.x + 0.05 * w, 1.0);
+  }
+
+  // ── W11.a fake subsurface translucency — thickness inner-glow + back-light ──
+  if (uCoreGlow > 0.0 || uSssScale > 0.0) {
+    oklch.x = min(oklch.x + uCoreGlow * (1.0 - exp(-3.0 * thickness)), 1.0);
+    let L = normalize(uLightDir + vec3<f32>(1e-6));
+    let back = pow(clamp(dot(V, -(L + N * thickness)), 0.0, 1.0), uSssPower);
+    let sss = back * uSssScale * (1.0 - thickness);
+    oklch.x = min(oklch.x + sss, 1.0);
+    oklch.z = oklch.z + sss * 0.1 * (1.0 - thickness);
+  }
+
+  // ── BC.W-GOOBLOB-MEATBALL — the soft contact shadow (T2). A procedural soft shadow that
+  //    FOLLOWS the irregular silhouette: march from this fragment's uv toward the in-plane
+  //    projection of uLightDir; where the metaball field occludes the light (the body
+  //    shadows itself opposite the light, a satellite shadows the body across the neck), the
+  //    march returns < 1 and DARKENS the OKLCh L — a soft grounded contact band UNDER the
+  //    dome, congruent with (but PROCEDURAL, silhouette-following, unlike) the CSS gel-dome
+  //    drop-shadow. Concentrated on the AWAY-facing lower rim (an away-facing weight × a
+  //    thin-rim Gaussian band) so the deep-lit interior + the light-facing edge stay bright
+  //    and the grounded shadow reads at the lower silhouette edge — the warm-cream body mean
+  //    holds. Gated uShadow > 0.5; variant=blob (STAGE 1) ships shadowless. ──
+  if (uShadow > 0.5) {
+    let L2 = normalize(uLightDir.xy + vec2<f32>(1e-6));
+    // w increases with the inverse light-source size → uShadowSoftness (a harder penumbra at a
+    // higher value). Start the march just off the surface so a fragment never self-shadows
+    // at t=0; cap the reach at the body span.
+    let sh = softShadow2D(uv, L2, max(aa, 0.004), bodyR * 1.5, max(uShadowSoftness, 4.0));
+    // The contact band sits on the LOWER rim (the side AWAY from the light) — gated by
+    // dot(fieldGrad, L2) < 0 (the rim facing away from L2) AND the thin-rim weight
+    // (a Gaussian band peaking at thickness ≈ 0.18 so the deep-lit interior + the
+    // light-facing edge stay BRIGHT — the warm-cream body mean holds). The 0.20 cap keeps
+    // it a soft GROUNDING whisper, never a gouge (the warm-cream identity + the
+    // proof:blob-warm-default floor hold).
+    let away = clamp(-dot(normalize(fieldGrad + vec2<f32>(1e-6)), L2), 0.0, 1.0);
+    let band = exp(-pow((thickness - 0.18) / 0.16, 2.0));
+    let shadowDarken = (1.0 - sh) * away * band * 0.20;
+    oklch.x = max(oklch.x - shadowDarken, 0.0);
+  }
+
+  oklch = gamutClampOklch(oklch);
+
+  var lin = oklabToLinearSrgb(oklchToOklab(oklch));
+
+  // ── W9.b lit glass surface — Blinn-Phong glint + Fresnel rim, in LINEAR ──
+  if (uLit > 0.5) {
+    let L = normalize(uLightDir + vec3<f32>(1e-6));
+    let H = normalize(L + V);
+
+    let warmCream = oklabToLinearSrgb(oklchToOklab(vec3<f32>(0.97, 0.03, radians(85.0))));
+
+    // ── fwidth SITE #2 — Toksvig normal-variance specular clamp. nVar is the HOISTED
+    //    length(fwidth(N)) (BC.W-GOOBLOB-MEATBALL — computed once at the top of fs_main
+    //    in uniform control flow, so the WGSL primary ARMS on Metal). The math is
+    //    byte-identical to the GLSL fallback (length(fwidth(N))); only its evaluation
+    //    point moved out of this non-uniform if (uLit > 0.5) branch. ──
+    let shininess = uSpecShininess / (1.0 + 24.0 * nVar);
+    let energyNorm = (shininess + 2.0) / 8.0;
+    let spec = pow(max(dot(N, H), 0.0), shininess) * uSpecStrength * energyNorm;
+
+    var rimOkl = oklabToOklch(srgbToOklab(uRimColor));
+    let bodyL = oklch.x;
+    let dL = abs(rimOkl.x - bodyL);
+    let lack = clamp((0.22 - dL) / 0.22, 0.0, 1.0);
+    // target is a WGSL RESERVED word (W3C WGSL 16.2) so a "var target" declaration is an
+    // invalid identifier: the shader module fails to compile and the WGSL primary never
+    // arms (the GooBlob reserved-keyword bug BC.W-WEBGPU-EVERYWHERE W7 catches). Renamed to
+    // a valid identifier; the math + the value are byte-identical.
+    var targetL = 0.18;
+    if (bodyL < 0.5) { targetL = 0.92; }
+    rimOkl.x = clamp(mix(rimOkl.x, targetL, lack), 0.0, 1.0);
+    rimOkl.y = rimOkl.y * mix(1.0, 0.5, lack);
+    let rimLin = oklabToLinearSrgb(oklchToOklab(rimOkl));
+
+    let rimFres = pow(1.0 - max(dot(N, V), 0.0), uRimPower);
+    let rim = rimFres * uRimStrength * (1.0 - 0.6 * thickness);
+
+    var highlight = max(warmCream * spec, rimLin * rim);
+    highlight = min(highlight, vec3<f32>(0.85));
+    lin = lin + highlight;
+  }
+
+  var rgb = clamp(linearToSrgb(lin), vec3<f32>(0.0), vec3<f32>(1.0));
+
+  // BD.W-GOO-CAROUSEL-DECK — the blob↔meatball SHADING-MORPH compose: lerp the flat blob
+  // fill -> the dressed meatball surface on uMorphT (the geometry/alpha is shared; only
+  // the surface shading interpolates). morphT == 1 is byte-identical to the dressed
+  // meatball; the morphT == 0 case already returned the flat fill above.
+  rgb = mix(flatRgbBase, rgb, uMorphT);
+
+  // IGN dither — 1-LSB triangular dither in DISPLAY space, AFTER linearToSrgb.
+  let fragCoord = in.pos.xy;
+  let ign = fract(52.9829189 * fract(dot(fragCoord, vec2<f32>(0.06711056, 0.00583715))));
+  rgb = clamp(rgb + (ign - 0.5) / 255.0, vec3<f32>(0.0), vec3<f32>(1.0));
+
+  // premultiply AFTER the OETF: straight-alpha gamma → premultiplied.
+  return vec4<f32>(rgb * alpha, alpha);
+}
+`, Pe = 592, $ = {
+	s0: 0,
+	s1: 4,
+	s2: 8,
+	s3: 12,
+	s4: 16,
+	s5: 20,
+	s6: 24,
+	s7: 28,
+	ptr: 32,
+	base: 36,
+	rim: 40,
+	light: 44,
+	res: 48,
+	ints: 52,
+	palette: 56,
+	satPos: 72,
+	trailPos: 88
+};
+function Fe() {
+	let e = new ArrayBuffer(Pe);
+	return {
+		buffer: e,
+		f32: new Float32Array(e),
+		i32: new Int32Array(e)
+	};
+}
+function Ie(e, t, n, r, i, a) {
+	let { f32: o, i32: s } = e, { params: c, rgb: l, simTimeMs: u, timeSec: d, resolveColor: f, rimColor: p, paletteStops: m } = a, { geometry: h, membrane: g, color: _, surface: v, interaction: y } = n, b = r.pointer.value, x = y.pointerAttraction + c.pointerAttraction, S = Math.max(0, Math.min(1, x)), C = r.velocity.value, w = r.pulse.value * y.clickImpulse, T = (g.pulseAmp * c.pulseAmp / .015 + w) * R, E = d * g.pulseFreq * c.pulseFreq * Math.PI * 2, D = g.noiseAmp * c.noiseAmp / .025 * R, O = h.orbitRadius * 1.2 * (1 + h.eccentricity), k = g.smoothK * c.smoothK, A = Math.max(0, O - h.satelliteRadius - h.bodyRadius), j = k > 0 ? Math.min(1.25, 1 + A / k) : 1, M = k * j * R, N = (n.surface.fissionAmp ?? 0) > 0 ? ae * 1.12 : 0, P = Math.max(O, N) + h.satelliteRadius, F = (Math.max(h.bodyRadius, P) + k * j + g.noiseAmp * c.noiseAmp / .025 + Math.abs(r.pulse.value) * y.clickImpulse) * R + .1;
+	o[$.s0 + 0] = u / 1e3, o[$.s0 + 1] = h.bodyRadius * R, o[$.s0 + 2] = E, o[$.s0 + 3] = T, o[$.s1 + 0] = D, o[$.s1 + 1] = g.noiseFreq, o[$.s1 + 2] = g.noiseSpeed, o[$.s1 + 3] = g.warpAmp;
+	let I = typeof n.morphT == "number" ? Math.max(0, Math.min(1, n.morphT)) : n.variant === "blob" ? 0 : 1, L = I > 0;
+	o[$.s2 + 0] = M, o[$.s2 + 1] = +(g.merge === "circular"), o[$.s2 + 2] = F, o[$.s2 + 3] = L && v.lit ? 1 : 0, o[$.s3 + 0] = v.specStrength, o[$.s3 + 1] = v.specShininess, o[$.s3 + 2] = v.rimPower, o[$.s3 + 3] = v.rimStrength, o[$.s4 + 0] = v.iridescence * c.iridScale, o[$.s4 + 1] = v.iridHue * (Math.PI / 180), o[$.s4 + 2] = v.iridSpeed, o[$.s4 + 3] = v.sssScale * c.iridScale, o[$.s5 + 0] = v.sssPower, o[$.s5 + 1] = v.coreGlow, o[$.s5 + 2] = _.hueRange + c.hueRange, o[$.s5 + 3] = _.satShift + c.satShift, o[$.s6 + 0] = _.brightnessShift + c.brightnessShift, o[$.s6 + 1] = _.colorNoiseFreq, o[$.s6 + 2] = _.colorNoiseSpeed, o[$.s6 + 3] = y.stretch, o[$.s7 + 0] = +!!r.active.value, o[$.s7 + 1] = x, o[$.s7 + 2] = y.pointerStrength * R, o[$.s7 + 3] = +(I <= 0), o[$.ptr + 0] = b.x * .5 * R, o[$.ptr + 1] = b.y * .5 * R, o[$.ptr + 2] = C.x * .5 * R, o[$.ptr + 3] = C.y * .5 * R, o[$.base + 0] = l[0], o[$.base + 1] = l[1], o[$.base + 2] = l[2], o[$.base + 3] = I;
+	let z = f(p);
+	o[$.rim + 0] = z[0], o[$.rim + 1] = z[1], o[$.rim + 2] = z[2], o[$.rim + 3] = 0, o[$.light + 0] = v.lightDir[0], o[$.light + 1] = v.lightDir[1], o[$.light + 2] = v.lightDir[2], o[$.light + 3] = 0, o[$.res + 0] = t.width, o[$.res + 1] = t.height, o[$.res + 2] = L && v.shadow ? 1 : 0, o[$.res + 3] = v.shadowSoftness;
+	let B = m, V = Math.min(B.length, 4);
+	for (let e = 0; e < 4; e++) {
+		let t = $.palette + e * 4, n = B[e];
+		if (n) {
+			let e = f(n);
+			o[t + 0] = e[0], o[t + 1] = e[1], o[t + 2] = e[2];
+		} else o[t + 0] = l[0], o[t + 1] = l[1], o[t + 2] = l[2];
+		o[t + 3] = 0;
+	}
+	let H = i.sources;
+	for (let e = 0; e < 4; e++) {
+		let t = $.satPos + e * 4, n = H[e];
+		n ? (o[t + 0] = n.x * R, o[t + 1] = n.y * R, o[t + 2] = n.radius * R, o[t + 3] = n.opacity) : (o[t + 0] = 0, o[t + 1] = 0, o[t + 2] = 0, o[t + 3] = 0);
+	}
+	let U = r.trailSources(h.satelliteRadius * .7 * S);
+	for (let e = 0; e < 15; e++) {
+		let t = $.trailPos + e * 4, n = U.sources[e];
+		n ? (o[t + 0] = n.x * .5 * R, o[t + 1] = n.y * .5 * R, o[t + 2] = n.radius * R) : (o[t + 0] = 0, o[t + 1] = 0, o[t + 2] = 0), o[t + 3] = 0;
+	}
+	return s[$.ints + 0] = V, s[$.ints + 1] = H.length, s[$.ints + 2] = U.count, s[$.ints + 3] = 0, e;
+}
+//#endregion
+//#region src/components/blob/composables/wgpuSetup.ts
+var Le = 64, Re = 8, ze = 2;
+function Be(e) {
+	let { canvas: t, config: n, pointer: r, satellites: i, resolveFrame: a, shouldContinue: o } = e;
+	return function(e, s, c) {
+		let l = e.createShaderModule({
+			label: "[GooBlob] metaball.wgsl",
+			code: Ne
+		}), u = e.createBuffer({
+			label: "[GooBlob] uniforms",
+			size: Pe,
+			usage: Le | Re
+		}), d = e.createBindGroupLayout({
+			label: "[GooBlob] bind-group-0",
+			entries: [{
+				binding: 0,
+				visibility: ze,
+				buffer: { type: "uniform" }
+			}]
+		}), f = e.createRenderPipeline({
+			label: "[GooBlob] pipeline",
+			layout: e.createPipelineLayout({ bindGroupLayouts: [d] }),
+			vertex: {
+				module: l,
+				entryPoint: "vs_main"
+			},
+			fragment: {
+				module: l,
+				entryPoint: "fs_main",
+				targets: [{
+					format: c,
+					blend: {
+						color: {
+							srcFactor: "one",
+							dstFactor: "one-minus-src-alpha",
+							operation: "add"
+						},
+						alpha: {
+							srcFactor: "one",
+							dstFactor: "one-minus-src-alpha",
+							operation: "add"
+						}
+					}
+				}]
+			},
+			primitive: { topology: "triangle-list" }
+		}), p = e.createBindGroup({
+			label: "[GooBlob] bind-group",
+			layout: d,
+			entries: [{
+				binding: 0,
+				resource: { buffer: u }
+			}]
+		}), m = Fe();
+		function h(e) {}
+		function g(o) {
+			let c = a(o);
+			if (!c) return;
+			Ie(m, t, n, r, i, c), e.queue.writeBuffer(u, 0, m.buffer);
+			let l = s.getCurrentTexture().createView(), d = e.createCommandEncoder({ label: "[GooBlob] frame" }), h = d.beginRenderPass({ colorAttachments: [{
+				view: l,
+				clearValue: {
+					r: 0,
+					g: 0,
+					b: 0,
+					a: 0
+				},
+				loadOp: "clear",
+				storeOp: "store"
+			}] });
+			h.setPipeline(f), h.setBindGroup(0, p), h.draw(3, 1, 0, 0), h.end(), e.queue.submit([d.finish()]);
+		}
+		return {
+			frame: g,
+			shouldContinue: o,
+			resize: h,
+			teardown: () => {
+				u.destroy();
+			}
+		};
+	};
+}
+//#endregion
+//#region src/components/blob/composables/useMetaballRenderer.ts
+function Ve(e) {
+	let { canvasRef: t, color: i, rimColor: a, paletteStops: o, satelliteColors: s, mood: c, pointer: l, satellites: f, config: p } = e, g = 0, _ = 0, v = n();
+	f.onPinch((e) => l.click(e));
+	let y = /* @__PURE__ */ new Map();
+	function b(e) {
+		let t = y.get(e);
+		if (t) return t;
+		let n = m(h(e));
+		return y.size > 256 && y.clear(), y.set(e, n), n;
+	}
+	let x = null, S = !1, C = P(!1), w = null;
+	function T() {
+		w !== null && (clearTimeout(w), w = null);
+	}
+	function E(e) {
+		if (T(), typeof setTimeout > "u") return;
+		let t = Math.min(Math.max(e - _, 16), 3e4);
+		w = setTimeout(() => {
+			w = null, x?.wake();
+		}, t);
+	}
+	r(t, {
+		pause: () => x?.suspend("off-screen-io"),
+		resume: () => x?.resume("off-screen-io")
+	}, {
+		rootMargin: "200px",
+		pauseWhenHidden: !1
+	});
+	function D(e) {
+		let t = g ? (e - g) * 1e3 : 16;
+		g = e;
+		let n = Math.max(0, Math.min(t, 50)), r = x?.reducedMotion ?? !1, u = r || S ? 0 : p.tempo, d = u * n;
+		if (_ += d, v.setActive(l.active.value), u > 0 && l.active.value) {
+			let e = l.rawPointer();
+			v.setPointer(e.x * .5 + .5, e.y * .5 + .5);
+		}
+		v.tick(u === 0 ? 0 : n);
+		let m = v.acceleration.value, h = v.velocity.value, y = -(m.x * h.x + m.y * h.y);
+		return y > 0 && u > 0 && l.click(Math.min(.5, y * 4 + v.burst.value * .2)), r || c.update({
+			pointerActive: l.active.value,
+			clicked: l.consumeClick(),
+			idleMs: l.idleMs()
+		}), c.tick(d), r ? l.rest() : l.tick(d), f.tick(_, c.params.value), {
+			params: c.params.value,
+			rgb: b(i.value),
+			simTimeMs: _,
+			timeSec: e,
+			resolveColor: b,
+			rimColor: a.value,
+			paletteStops: o.value,
+			satColors: s?.value
+		};
+	}
+	function O() {
+		let e = c.isSettled() && l.isAtRest() && f.isQuiescent();
+		if (C.value = e, S) return !1;
+		if (!e) return T(), !0;
+		let t = f.nextEventMs(_), n = c.nextAutoMoodMs(), r = Number.isFinite(n) ? _ + n : Infinity;
+		return E(Math.min(t, r)), !1;
+	}
+	let k = () => u() * (p.quality === "half" ? .5 : 1);
+	function A(t) {
+		x = d(t, {
+			dprPolicy: k,
+			revealBloom: e.revealBloom ?? !0,
+			contextAttrs: {
+				alpha: !0,
+				premultipliedAlpha: !0,
+				antialias: !1,
+				preserveDrawingBuffer: !1
+			},
+			setupWGPU: Be({
+				canvas: t,
+				config: p,
+				pointer: l,
+				satellites: f,
+				resolveFrame: D,
+				shouldContinue: O,
+				getReducedMotion: () => x?.reducedMotion ?? !1
+			}),
+			setupGL: (e) => {
+				let { prog: n, vs: r, fs: i, vao: a, buf: o, locs: s } = Me(e);
+				function c(n) {
+					e.viewport(0, 0, n?.w ?? t.width, n?.h ?? t.height);
+				}
+				function u(r) {
+					Ae(e, n, a, s, t, p, l, f, D(r));
+				}
+				return {
+					frame: u,
+					shouldContinue: O,
+					resize: c,
+					teardown: () => {
+						e.deleteProgram(n), e.deleteShader(r), e.deleteShader(i), e.deleteBuffer(o), e.deleteVertexArray(a);
+					}
+				};
+			}
+		}), x.armAsync();
+	}
+	return I(t, (e) => {
+		e && !x && A(e);
+	}, { immediate: !0 }), I(i, () => x?.wake()), I(o, () => x?.wake(), { deep: !0 }), j(() => {
+		T(), x?.dispose(), x = null;
+	}), {
+		pause: () => {
+			S = !0, x?.suspend("manual");
+		},
+		resume: () => {
+			S = !1, x?.resume("manual");
+		},
+		wake: () => x?.wake(),
+		settled: C
+	};
+}
+//#endregion
+//#region src/components/blob/Blob.vue?vue&type=script&setup=true&lang.ts
+var He = 1.3, Ue = /* @__PURE__ */ e(/* @__PURE__ */ D({
+	__name: "Blob",
+	props: {
+		color: {},
+		config: {},
+		variant: {},
+		seed: { default: "" },
+		paused: {
+			type: Boolean,
+			default: !1
+		}
+	},
+	emits: ["click", "update:paused"],
+	setup(e, { expose: n, emit: r }) {
+		let i = r, a = O(y, null), o = e.config ?? a;
+		if (!o) throw Error("[glass-ui] Blob: no blob config. Pass an explicit `config` prop (e.g. BLOB_CONFIG_DEFAULTS) or provide(BLOB_CONFIG_KEY, cfg) from an ancestor. There is no silent defaults synthesis.");
+		let s = () => e.config ?? a ?? o, c = new Proxy(o, { get(t, n, r) {
+			return n === "variant" && e.variant != null ? e.variant : Reflect.get(t, n, r);
+		} }), l = F("canvasRef"), u = F("wrapperRef"), d = F("hitLayerRef"), f = Math.min(1, Math.max(.25, o.geometry.bodyRadius / R * He)), p = `${(f * 50).toFixed(2)}%`, m = me(), h = he(d, { hitRadius: () => f }), g = be(o, e.color + e.seed), _ = t(), v = P(e.color), b = P(o.surface.rimColor), x = P([...o.color.paletteStops]), S = P([...o.color.satelliteColors ?? []]);
+		function C() {
+			let t = u.value, n = s();
+			_.invalidate(), v.value = _.resolve(e.color, t), b.value = _.resolve(n.surface.rimColor, t), x.value = n.color.paletteStops.map((e) => _.resolve(e, t)), S.value = (n.color.satelliteColors ?? []).map((e) => _.resolve(e, t));
+		}
+		let D = Ve({
+			canvasRef: l,
+			color: v,
+			rimColor: b,
+			paletteStops: x,
+			satelliteColors: S,
+			mood: m,
+			pointer: h,
+			satellites: g,
+			config: c
+		});
+		I(u, C, { immediate: !0 });
+		let j = null;
+		typeof document < "u" && (j = new MutationObserver(C), j.observe(document.documentElement, {
+			attributes: !0,
+			attributeFilter: ["class"]
+		})), I(w(() => e.color), (t) => {
+			C(), g.reseed(t + e.seed);
+		}), I(() => {
+			let e = s();
+			return [
+				e.color.paletteStops.join("|"),
+				(e.color.satelliteColors ?? []).join("|"),
+				e.surface.rimColor
+			];
+		}, () => C(), { deep: !0 }), I(() => h.active.value, (e) => {
+			e && D.wake();
+		}), I(() => e.paused, (e) => e ? D.pause() : D.resume(), { immediate: !0 }), A(() => {
+			j?.disconnect(), j = null;
+		});
+		function N() {
+			g.nudge();
+		}
+		function L(e) {
+			m.setMood(e, { source: "manual" });
+		}
+		function z() {
+			h.click(o.interaction.clickImpulse);
+		}
+		function B(e) {
+			h.hitTest(e.clientX, e.clientY) && (z(), i("click"));
+		}
+		return n({
+			nudge: N,
+			setMood: L,
+			pulse: z,
+			currentMood: m.currentMood,
+			pause: D.pause,
+			resume: D.resume,
+			settled: D.settled
+		}), (t, n) => (M(), T("div", {
+			ref_key: "wrapperRef",
+			ref: u,
+			class: "goo-blob-wrapper",
+			style: k({ "--blob-color": e.color })
+		}, [E("canvas", {
+			ref_key: "canvasRef",
+			ref: l,
+			class: "goo-blob-canvas",
+			"aria-hidden": "true",
+			"data-testid": "goo-blob-canvas"
+		}, null, 512), E("div", {
+			ref_key: "hitLayerRef",
+			ref: d,
+			class: "goo-blob-hit",
+			style: k({ "--blob-hit-radius": p }),
+			"data-testid": "goo-blob-hit",
+			onClick: B
+		}, null, 4)], 4));
+	}
+}), [["__scopeId", "data-v-c78535cc"]]);
+//#endregion
+export { g as BLOB_CONFIG_DEFAULTS, y as BLOB_CONFIG_KEY, x as BLOB_HERO, Ue as Blob, v as LIGHTNESS_FLOOR_BRACKET, b as LIGHTNESS_FLOOR_DEFAULT, _ as clampLightnessFloor, me as useBlobMood, he as useBlobPointer, be as useBlobSatellites, Ve as useMetaballRenderer };