@mkbabb/glass-ui 4.0.1 → 4.1.0

package/dist/uniformBridgeWGPU-CtAKl45L.js

@@ -0,0 +1,1204 @@
+import { a as e, n as t, o as n, r, s as i, t as a } from "./procedural-color.wgsl-m7Zgv35j.js";
+import { n as o, t as s } from "./prng-B-d9eYX8.js";
+import { onUnmounted as c, readonly as l, ref as u, watch as d } from "vue";
+import { SpringProgress as f } from "@mkbabb/keyframes.js";
+//#region src/components/custom/goo-blob/types.ts
+var p = {
+	geometry: {
+		canvasSize: 200,
+		bodyRadius: .22,
+		satelliteCount: 3,
+		satelliteRadius: .082,
+		orbitRadius: .17,
+		eccentricity: .05
+	},
+	satellites: {
+		mergeDuration: 1800,
+		absorbedDuration: [2e3, 4e3],
+		emergeDuration: 2200,
+		orbitDuration: [8e3, 14e3]
+	},
+	membrane: {
+		smoothK: .05,
+		merge: "circular",
+		noiseAmp: .038,
+		noiseFreq: 3.5,
+		noiseSpeed: .08,
+		warpAmp: .35,
+		pulseFreq: .3,
+		pulseAmp: .008
+	},
+	color: {
+		paletteStops: [
+			"#b5947f",
+			"#d4b27d",
+			"#dad6b1"
+		],
+		hueRange: 5,
+		satShift: 0,
+		brightnessShift: 0,
+		colorNoiseFreq: 2,
+		colorNoiseSpeed: .05
+	},
+	surface: {
+		lit: !0,
+		shadow: !0,
+		shadowSoftness: 16,
+		rimColor: "#8c694e",
+		lightDir: [
+			.4,
+			.7,
+			.6
+		],
+		specStrength: .16,
+		specShininess: 20,
+		rimPower: 2.5,
+		rimStrength: .32,
+		iridescence: .09,
+		iridHue: 85,
+		iridSpeed: .06,
+		sssScale: .1,
+		sssPower: 2,
+		coreGlow: .06
+	},
+	interaction: {
+		pointerAttraction: .35,
+		pointerStrength: .1,
+		stretch: .5,
+		clickImpulse: .5
+	},
+	variant: "meatball",
+	quality: "full",
+	tempo: 1
+}, m = Symbol("blobConfig"), h = 1 / 1.6, g = {
+	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
+	}
+}, _ = (e, t, n) => e + (t - e) * n;
+function v({ valence: e, arousal: t }) {
+	return {
+		orbitSpeedScale: _(.4, 2.2, t),
+		wobbleScale: _(.5, 2, t),
+		pulseFreq: _(.15, 1.5, t),
+		pulseAmp: _(.008, .05, t),
+		noiseAmp: _(.015, .045, t),
+		hueRange: _(3, 25, t * .6 + (e * .5 + .5) * .4),
+		satShift: _(-.05, .1, e * .5 + .5),
+		brightnessShift: _(-.03, .08, e * .5 + .5),
+		smoothK: _(.85, 1.35, t),
+		pointerAttraction: _(-.2, .6, e * .5 + .5) * (.7 + .15 * t),
+		mergeRate: _(2, .3, t),
+		iridScale: _(.55, 1.35, t)
+	};
+}
+var y = {
+	idle: v(g.idle),
+	happy: v(g.happy),
+	curious: v(g.curious),
+	sleepy: v(g.sleepy),
+	excited: v(g.excited)
+}, b = {
+	idle: 1500,
+	happy: 1200,
+	curious: 800,
+	sleepy: 2500,
+	excited: 600
+}, x = 6e3, S = .35, C = .85, w = .2, T = .015, E = .02, D = .01, O = .015, k = .75, A = 2e3, j = /* @__PURE__ */ "uResolution.uTime.uBaseColor.uPointer.uPointerActive.uPointerAttraction.uPointerStrength.uBodyRadius.uPulsePhase.uPulseAmp.uNoiseAmp.uNoiseFreq.uNoiseSpeed.uWarpAmp.uSmoothK.uMerge.uStage.uMaxReach.uLit.uRimColor.uLightDir.uSpecStrength.uSpecShininess.uRimPower.uRimStrength.uShadow.uShadowSoftness.uIridescence.uIridHue.uIridSpeed.uSssScale.uSssPower.uCoreGlow.uHueRange.uSatShift.uBrightnessShift.uColorNoiseFreq.uColorNoiseSpeed.uStopCount.uSatCount.uTrailCount.uVelocity.uStretch".split(".");
+//#endregion
+//#region src/components/custom/goo-blob/composables/easing.ts
+function M(e) {
+	return e < .5 ? 2 * e * e : 1 - 2 * (1 - e) * (1 - e);
+}
+function N(e) {
+	return e * e;
+}
+function P(e) {
+	return 1 - (1 - e) * (1 - e);
+}
+//#endregion
+//#region src/components/custom/goo-blob/composables/useBlobMood.ts
+function F(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 I() {
+	let e = u("idle"), t = u({ ...y.idle }), n = { ...y.idle }, r = { ...y.idle }, i = 0, a = 0, o = !1, s = 0, c = !1, d = !1, f = 0;
+	function p(s, l = {}) {
+		(l.source ?? "manual") === "manual" && (c = !0), !(s === e.value && !o) && (e.value = s, n = { ...t.value }, r = y[s], a = b[s], i = 0, o = !0);
+	}
+	function m(e) {
+		f = e.idleMs;
+		let t = e.pointerActive && !d;
+		if (d = e.pointerActive, c && (e.clicked || t) && (c = !1), !c) {
+			if (e.clicked) {
+				s = 900, p("excited", { source: "auto" });
+				return;
+			}
+			s > 0 || (e.pointerActive ? p("curious", { source: "auto" }) : e.idleMs > 6e3 ? p("sleepy", { source: "auto" }) : p("idle", { source: "auto" }));
+		}
+	}
+	function h() {
+		return o || s > 0 || c && e.value !== "idle" ? !1 : !(!c && e.value !== "sleepy" && f < 6e3);
+	}
+	function g() {
+		return o || s > 0 || c || e.value === "sleepy" ? Infinity : Math.max(0, x - f);
+	}
+	function _(e) {
+		if (s > 0 && (s = Math.max(0, s - e)), !o) return;
+		i += e;
+		let c = Math.min(i / a, 1), l = M(c);
+		t.value = F(n, r, l), c >= 1 && (o = !1);
+	}
+	return {
+		currentMood: l(e),
+		params: l(t),
+		setMood: p,
+		update: m,
+		tick: _,
+		isSettled: h,
+		nextAutoMoodMs: g
+	};
+}
+//#endregion
+//#region src/components/custom/goo-blob/composables/useBlobPointer.ts
+function L(e) {
+	let t = u({
+		x: 0,
+		y: 0
+	}), n = u({
+		x: 0,
+		y: 0
+	}), r = u(!1), i = u(0), a = 0, o = 0, s = {
+		response: .18,
+		dampingFraction: 1
+	}, p = new f(s), m = new f(s), h = Array.from({ length: 15 }, () => ({
+		x: 0,
+		y: 0,
+		radius: 0
+	})), g = 0, _ = 0, v = 0, y = 0;
+	function b(t) {
+		let n = e.value;
+		if (!n) return;
+		let i = n.getBoundingClientRect();
+		a = (t.clientX - i.left) / i.width * 2 - 1, o = (t.clientY - i.top) / i.height * 2 - 1, r.value = !0;
+	}
+	function x() {
+		r.value = !1;
+	}
+	let C = null;
+	d(e, (e) => {
+		C &&= (C(), null), e && (e.addEventListener("pointermove", b), e.addEventListener("pointerleave", x), C = () => {
+			e.removeEventListener("pointermove", b), e.removeEventListener("pointerleave", x);
+		});
+	}, { immediate: !0 }), c(() => C?.());
+	function w(e = 16) {
+		let s = Math.min(e, 50), c = s / 1e3;
+		r.value ? k = 0 : k += Math.min(e, 50);
+		let l = r.value ? a : 0, u = r.value ? o : 0;
+		if (p.target = l, m.target = u, p.tickDt(s), m.tickDt(s), t.value = {
+			x: p.value,
+			y: m.value
+		}, n.value = {
+			x: p.velocity,
+			y: m.velocity
+		}, v !== 0 || y !== 0) {
+			let e = -324 * v - 2 * S * 18 * y;
+			y += e * c, v += y * c, v < -.9 && (v = -.9), Math.abs(v) < 1e-4 && Math.abs(y) < 1e-4 && (v = 0, y = 0);
+		}
+		i.value = v;
+		let d = Math.hypot(p.velocity, m.velocity);
+		r.value || d > .05 ? (g = (g + 1) % 15, h[g].x = p.value, h[g].y = m.value, _ = Math.min(_ + 1, 15)) : _ > 0 && (_ = Math.max(0, _ - 1));
+	}
+	function T(e) {
+		let t = [];
+		for (let n = 0; n < _; n++) {
+			let r = h[(g - n + 30) % 15];
+			t.push({
+				x: r.x,
+				y: r.y,
+				radius: e * (1 - n / 15)
+			});
+		}
+		return {
+			sources: t,
+			count: _
+		};
+	}
+	let E = !1;
+	function D(e) {
+		y += e * 18, E = !0;
+	}
+	function O() {
+		let e = E;
+		return E = !1, e;
+	}
+	let k = 0;
+	function A() {
+		p.reset(0, 0), m.reset(0, 0), p.target = 0, m.target = 0, t.value = {
+			x: 0,
+			y: 0
+		}, n.value = {
+			x: 0,
+			y: 0
+		}, v = 0, y = 0, i.value = 0, _ = 0;
+	}
+	function j() {
+		return !(r.value || Math.hypot(p.velocity, m.velocity) > .001 || Math.abs(p.value) > .001 || Math.abs(m.value) > .001 || _ > 0 || v !== 0 || y !== 0);
+	}
+	return {
+		pointer: l(t),
+		velocity: l(n),
+		active: l(r),
+		pulse: l(i),
+		idleMs: () => k,
+		tick: w,
+		trailSources: T,
+		click: D,
+		consumeClick: O,
+		rest: A,
+		isAtRest: j
+	};
+}
+//#endregion
+//#region src/components/custom/goo-blob/composables/useBlobSatellites.ts
+function R(e, t, n) {
+	return t + e() * (n - t);
+}
+function z(e) {
+	return e < 0 ? 0 : e > 1 ? 1 : e;
+}
+function B(e, t, n) {
+	return e + (t - e) * n;
+}
+function V(e, t, n, r, i) {
+	let a = t / 4 * Math.PI * 2 + (e() - .5) * Math.PI, o = n * (C + e() * w), 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: T + e() * E,
+		wobbleFreq1: .08 + e() * .22,
+		wobbleAmp2: D + e() * O,
+		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
+	};
+}
+function H(e, t, n, r) {
+	e.phase = t, e.phaseStart = n, e.phaseDuration = r;
+}
+function U(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 W(e, t, n, r, i) {
+	e.timeOrigin = i, e.angularSpeed = .08 + t() * .16, e.phaseOffset = t() * Math.PI * 2;
+	let a = n * (C + t() * w), o = r * (.3 + t() * .7);
+	e.baseRadiusX = a * (1 - o), e.baseRadiusY = a * (1 + o), e.wobbleAmp1 = T + t() * E, e.wobbleFreq1 = .08 + t() * .22, e.wobbleAmp2 = D + t() * O, 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;
+}
+function G(e, t) {
+	let n = o(s(t + "goo")), r = [], i = [], a = [], c = -Infinity, l = e.geometry.orbitRadius;
+	function u() {
+		let t = e.geometry.orbitRadius;
+		if (t !== l && l > 0) {
+			let e = t / l;
+			for (let t of r) t.baseRadiusX *= e, t.baseRadiusY *= e;
+			l = t;
+		}
+	}
+	function d(t) {
+		let o = e.geometry.satelliteCount;
+		for (; r.length < o;) r.push(V(n, r.length, e.geometry.orbitRadius, e.geometry.eccentricity, t)), i.push({
+			x: 0,
+			y: 0,
+			radius: e.geometry.satelliteRadius,
+			opacity: 0
+		}), a.push({
+			x: 0,
+			y: 0,
+			start: 0
+		});
+		r.length > o && (r.length = o, i.length = o, a.length = o);
+	}
+	function f(t, o) {
+		d(t), u();
+		let s = r.length, l = o.mergeRate, f = e.geometry.satelliteRadius, p = e.satellites.mergeDuration, m = e.satellites.emergeDuration, h = e.satellites.orbitDuration, g = e.satellites.absorbedDuration;
+		for (let u = 0; u < s; u++) {
+			let s = r[u], d = t - s.phaseStart, _ = z(s.phaseDuration > 0 ? d / s.phaseDuration : 1);
+			switch (s.phase) {
+				case "orbiting":
+					if (_ >= 1) if (t - c < 3e3 * l) s.phaseStart = t, s.phaseDuration = R(n, h[0], h[1]);
+					else {
+						let e = U(s, t, o.orbitSpeedScale, o.wobbleScale);
+						s.startX = e.x, s.startY = e.y;
+						let n = Math.hypot(e.x, e.y), r = n > .01 ? .08 / n : 0;
+						s.endX = e.x * r, s.endY = e.y * r, H(s, "merging", t, p), c = t;
+					}
+					break;
+				case "merging":
+					_ >= 1 && H(s, "absorbed", t, R(n, g[0], g[1]));
+					break;
+				case "absorbed":
+					if (_ >= 1) {
+						W(s, n, e.geometry.orbitRadius, e.geometry.eccentricity, t);
+						let r = U(s, t + 3e3, o.orbitSpeedScale, o.wobbleScale);
+						s.endX = r.x, s.endY = r.y;
+						let i = Math.hypot(r.x, r.y), a = i > .01 ? .08 / i : 0;
+						s.startX = r.x * a, s.startY = r.y * a, H(s, "emerging", t, m);
+					}
+					break;
+				case "emerging":
+					if (_ >= 1) {
+						let e = a[u];
+						e.x = s.endX, e.y = s.endY, e.start = t, s.timeOrigin = t, s.phaseOffset = Math.atan2(s.endY, s.endX), H(s, "orbiting", t, R(n, h[0], h[1]));
+					}
+					break;
+			}
+			let v, y, b, x;
+			switch (s.phase) {
+				case "orbiting": {
+					let e = U(s, t, o.orbitSpeedScale, o.wobbleScale), n = a[u], r = t - n.start;
+					if (n.start > 0 && r < 2e3) {
+						let t = z(r / A), i = t * t * (3 - 2 * t);
+						v = B(n.x, e.x, i), y = B(n.y, e.y, i);
+					} else v = e.x, y = e.y;
+					b = k, x = 1;
+					break;
+				}
+				case "merging": {
+					let e = N(z((t - s.phaseStart) / s.phaseDuration));
+					v = B(s.startX, s.endX, e), y = B(s.startY, s.endY, e);
+					let n = z((t - s.phaseStart) / s.phaseDuration);
+					b = n > .85 ? B(k, 0, (n - .85) / .15) : k, x = B(1, .65, e);
+					break;
+				}
+				case "absorbed":
+					v = 0, y = 0, b = 0, x = .5;
+					break;
+				case "emerging": {
+					let e = P(z((t - s.phaseStart) / s.phaseDuration));
+					v = B(s.startX, s.endX, e), y = B(s.startY, s.endY, e);
+					let n = z((t - s.phaseStart) / s.phaseDuration);
+					b = n < .1 ? B(0, k, n / .1) : k, x = B(.65, 1, e);
+					break;
+				}
+			}
+			let S = i[u];
+			S.x = v, S.y = y, S.radius = f * x, S.opacity = b;
+		}
+	}
+	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 = o(s(e + "goo"));
+	}
+	function h() {
+		for (let e of r) if (e.phase !== "orbiting") return !1;
+		return !0;
+	}
+	function g(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,
+		isQuiescent: h,
+		nextEventMs: g
+	};
+}
+//#endregion
+//#region src/components/custom/goo-blob/shaders/sdf-body.glsl.ts
+var K = "// --- 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}", q = "// --- 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).", J = 1.8, Y = .42, X = `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 *= ${J.toFixed(1)};
+        amp *= ${Y.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 *= ${J.toFixed(1)};
+        amp *= ${Y.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);
+}
+`, ee = "// 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}", te = "#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).\nuniform float uStage;\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// 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", Z = "\n", ne = te + Z + q + Z + `${e}
+
+` + X + Z + K + Z + `
+// --- 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).
+${n}
+${i}
+
+` + ee + Z + "\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\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\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    // ── BC.W-GOOBLOB-PLAIN — the STAGE-1 stripped floor (variant=blob). ──\n    // The minimal verifiable floor: SDF + smin (the meatball field, already in\n    // d/alpha above) + fwidth-AA (the crisp alpha) + warm-cream fill. NO surface\n    // normal, NO Fresnel, NO lit glint, NO iridescence, NO fake-SSS, NO shadow —\n    // deliberately FLAT. It returns BEFORE the STAGE-2 dressing, the GLSL twin of\n    // the WGSL primary's uStage > 0.5 branch. The teaching contrast: the \"it\n    // renders, it meatballs\" floor STAGE 2 layers the lit/shadow onto via the SAME\n    // uStage/uLit uniforms.\n    if (uStage > 0.5) {\n        oklch = gamutClampOklch(oklch);\n        vec3 lin1 = oklabToLinearSrgb(oklchToOklab(oklch));\n        vec3 rgb1 = clamp(linearToSrgb(lin1), 0.0, 1.0);\n        float ign1 = fract(52.9829189 * fract(dot(gl_FragCoord.xy, vec2(0.06711056, 0.00583715))));\n        rgb1 = clamp(rgb1 + (ign1 - 0.5) / 255.0, 0.0, 1.0);\n        fragColor = vec4(rgb1 * 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    // 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/custom/goo-blob/composables/uploadBlobUniforms.ts
+function re(e, t, n, r, i, a, o, s, c) {
+	let { U: l, satPosLocs: u, satRadLocs: d, satOpLocs: f, trailPosLocs: p, trailRadLocs: m, paletteLocs: g } = r, { params: _, rgb: v, simTimeMs: y, timeSec: b, resolveColor: x, rimColor: S, paletteStops: C } = c, { geometry: w, membrane: T, color: E, surface: D, interaction: O } = a;
+	e.useProgram(t), e.bindVertexArray(n), e.uniform2f(l.uResolution, i.width, i.height), e.uniform1f(l.uTime, y / 1e3), e.uniform3f(l.uBaseColor, v[0], v[1], v[2]);
+	let k = C, A = Math.min(k.length, 4);
+	e.uniform1i(l.uStopCount, A);
+	for (let t = 0; t < 4; t++) {
+		let n = g[t] ?? null, r = k[t];
+		if (r) {
+			let t = x(r);
+			e.uniform3f(n, t[0], t[1], t[2]);
+		} else e.uniform3f(n, v[0], v[1], v[2]);
+	}
+	let j = o.pointer.value, M = O.pointerAttraction + _.pointerAttraction;
+	e.uniform2f(l.uPointer, j.x * .5 * h, j.y * .5 * h), e.uniform1f(l.uPointerActive, +!!o.active.value), e.uniform1f(l.uPointerAttraction, M), e.uniform1f(l.uPointerStrength, O.pointerStrength * h);
+	let N = Math.max(0, Math.min(1, M)), P = o.velocity.value;
+	e.uniform2f(l.uVelocity, P.x * .5 * h, P.y * .5 * h), e.uniform1f(l.uStretch, O.stretch);
+	let F = o.trailSources(w.satelliteRadius * .7 * N);
+	e.uniform1i(l.uTrailCount, F.count);
+	for (let t = 0; t < 15; t++) {
+		let n = p[t] ?? null, r = m[t] ?? null, i = F.sources[t];
+		i ? (e.uniform2f(n, i.x * .5 * h, i.y * .5 * h), e.uniform1f(r, i.radius * h)) : (e.uniform2f(n, 0, 0), e.uniform1f(r, 0));
+	}
+	e.uniform1f(l.uBodyRadius, w.bodyRadius * h), e.uniform1f(l.uPulsePhase, b * T.pulseFreq * _.pulseFreq * Math.PI * 2);
+	let I = o.pulse.value * O.clickImpulse;
+	e.uniform1f(l.uPulseAmp, (T.pulseAmp * _.pulseAmp / .015 + I) * h), e.uniform1f(l.uNoiseAmp, T.noiseAmp * _.noiseAmp / .025 * h), e.uniform1f(l.uNoiseFreq, T.noiseFreq), e.uniform1f(l.uNoiseSpeed, T.noiseSpeed), e.uniform1f(l.uWarpAmp, T.warpAmp);
+	let L = w.orbitRadius * 1.2 * (1 + w.eccentricity), R = T.smoothK * _.smoothK, z = Math.max(0, L - w.satelliteRadius - w.bodyRadius), B = R > 0 ? Math.min(1.25, 1 + z / R) : 1;
+	e.uniform1f(l.uSmoothK, R * B * h), e.uniform1f(l.uMerge, +(T.merge === "circular")), e.uniform1f(l.uStage, +(a.variant === "blob"));
+	let V = L + w.satelliteRadius, H = (Math.max(w.bodyRadius, V) + R * B + T.noiseAmp * _.noiseAmp / .025 + Math.abs(o.pulse.value) * O.clickImpulse) * h + .1;
+	e.uniform1f(l.uMaxReach, H), e.uniform1f(l.uHueRange, E.hueRange + _.hueRange), e.uniform1f(l.uSatShift, E.satShift + _.satShift), e.uniform1f(l.uBrightnessShift, E.brightnessShift + _.brightnessShift), e.uniform1f(l.uColorNoiseFreq, E.colorNoiseFreq), e.uniform1f(l.uColorNoiseSpeed, E.colorNoiseSpeed);
+	let U = a.variant !== "blob";
+	e.uniform1f(l.uLit, U && D.lit ? 1 : 0);
+	let W = x(S);
+	e.uniform3f(l.uRimColor, W[0], W[1], W[2]), e.uniform3f(l.uLightDir, D.lightDir[0], D.lightDir[1], D.lightDir[2]), e.uniform1f(l.uSpecStrength, D.specStrength), e.uniform1f(l.uSpecShininess, D.specShininess), e.uniform1f(l.uRimPower, D.rimPower), e.uniform1f(l.uRimStrength, D.rimStrength), e.uniform1f(l.uShadow, U && D.shadow ? 1 : 0), e.uniform1f(l.uShadowSoftness, D.shadowSoftness), e.uniform1f(l.uIridescence, D.iridescence * _.iridScale), e.uniform1f(l.uIridHue, D.iridHue * (Math.PI / 180)), e.uniform1f(l.uIridSpeed, D.iridSpeed), e.uniform1f(l.uSssScale, D.sssScale * _.iridScale), e.uniform1f(l.uSssPower, D.sssPower), e.uniform1f(l.uCoreGlow, D.coreGlow);
+	let G = s.sources;
+	e.uniform1i(l.uSatCount, G.length);
+	for (let t = 0; t < 4; t++) {
+		let n = u[t] ?? null, r = d[t] ?? null, i = f[t] ?? null, a = G[t];
+		a ? (e.uniform2f(n, a.x * h, a.y * h), e.uniform1f(r, a.radius * h), 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/custom/goo-blob/shaders/metaball.wgsl.ts
+var ie = `
+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 ${a}.
+${a}
+
+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);
+}
+
+${t}
+${r}
+
+// OKLCh gamut clamp + palette sample + breath (BC.W-CARVE6 → metaball-palette.wgsl)
+// — spliced AFTER ${r} (its matrix source).
+
+// ── 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;
+  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 early-out — transparent WRITE (not a discard).
+  if (dot(uv, uv) > uMaxReach * uMaxReach) {
+    return vec4<f32>(0.0);
+  }
+
+  // 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. ──
+  let aa = max(fwidth(d), 1e-6);
+  let alpha = 1.0 - smoothstep(-aa, aa, d);
+
+  // ── 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.
+  if (uStage > 0.5) {
+    let okl1 = gamutClampOklch(oklch);
+    var lin1 = oklabToLinearSrgb(oklchToOklab(okl1));
+    var rgb1 = clamp(linearToSrgb(lin1), vec3<f32>(0.0), vec3<f32>(1.0));
+    let fc1 = in.pos.xy;
+    let ign1 = fract(52.9829189 * fract(dot(fc1, vec2<f32>(0.06711056, 0.00583715))));
+    rgb1 = clamp(rgb1 + (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));
+
+  // 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);
+}
+`, Q = 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 ae() {
+	let e = new ArrayBuffer(Q);
+	return {
+		buffer: e,
+		f32: new Float32Array(e),
+		i32: new Int32Array(e)
+	};
+}
+function oe(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: g, membrane: _, color: v, surface: y, interaction: b } = n, x = r.pointer.value, S = b.pointerAttraction + c.pointerAttraction, C = Math.max(0, Math.min(1, S)), w = r.velocity.value, T = r.pulse.value * b.clickImpulse, E = (_.pulseAmp * c.pulseAmp / .015 + T) * h, D = d * _.pulseFreq * c.pulseFreq * Math.PI * 2, O = _.noiseAmp * c.noiseAmp / .025 * h, k = g.orbitRadius * 1.2 * (1 + g.eccentricity), A = _.smoothK * c.smoothK, j = Math.max(0, k - g.satelliteRadius - g.bodyRadius), M = A > 0 ? Math.min(1.25, 1 + j / A) : 1, N = A * M * h, P = k + g.satelliteRadius, F = (Math.max(g.bodyRadius, P) + A * M + _.noiseAmp * c.noiseAmp / .025 + Math.abs(r.pulse.value) * b.clickImpulse) * h + .1;
+	o[$.s0 + 0] = u / 1e3, o[$.s0 + 1] = g.bodyRadius * h, o[$.s0 + 2] = D, o[$.s0 + 3] = E, o[$.s1 + 0] = O, o[$.s1 + 1] = _.noiseFreq, o[$.s1 + 2] = _.noiseSpeed, o[$.s1 + 3] = _.warpAmp;
+	let I = n.variant !== "blob";
+	o[$.s2 + 0] = N, o[$.s2 + 1] = +(_.merge === "circular"), o[$.s2 + 2] = F, o[$.s2 + 3] = I && y.lit ? 1 : 0, o[$.s3 + 0] = y.specStrength, o[$.s3 + 1] = y.specShininess, o[$.s3 + 2] = y.rimPower, o[$.s3 + 3] = y.rimStrength, o[$.s4 + 0] = y.iridescence * c.iridScale, o[$.s4 + 1] = y.iridHue * (Math.PI / 180), o[$.s4 + 2] = y.iridSpeed, o[$.s4 + 3] = y.sssScale * c.iridScale, o[$.s5 + 0] = y.sssPower, o[$.s5 + 1] = y.coreGlow, o[$.s5 + 2] = v.hueRange + c.hueRange, o[$.s5 + 3] = v.satShift + c.satShift, o[$.s6 + 0] = v.brightnessShift + c.brightnessShift, o[$.s6 + 1] = v.colorNoiseFreq, o[$.s6 + 2] = v.colorNoiseSpeed, o[$.s6 + 3] = b.stretch, o[$.s7 + 0] = +!!r.active.value, o[$.s7 + 1] = S, o[$.s7 + 2] = b.pointerStrength * h, o[$.s7 + 3] = +(n.variant === "blob"), o[$.ptr + 0] = x.x * .5 * h, o[$.ptr + 1] = x.y * .5 * h, o[$.ptr + 2] = w.x * .5 * h, o[$.ptr + 3] = w.y * .5 * h, o[$.base + 0] = l[0], o[$.base + 1] = l[1], o[$.base + 2] = l[2], o[$.base + 3] = 0;
+	let L = f(p);
+	o[$.rim + 0] = L[0], o[$.rim + 1] = L[1], o[$.rim + 2] = L[2], o[$.rim + 3] = 0, o[$.light + 0] = y.lightDir[0], o[$.light + 1] = y.lightDir[1], o[$.light + 2] = y.lightDir[2], o[$.light + 3] = 0, o[$.res + 0] = t.width, o[$.res + 1] = t.height, o[$.res + 2] = I && y.shadow ? 1 : 0, o[$.res + 3] = y.shadowSoftness;
+	let R = m, z = Math.min(R.length, 4);
+	for (let e = 0; e < 4; e++) {
+		let t = $.palette + e * 4, n = R[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 B = i.sources;
+	for (let e = 0; e < 4; e++) {
+		let t = $.satPos + e * 4, n = B[e];
+		n ? (o[t + 0] = n.x * h, o[t + 1] = n.y * h, o[t + 2] = n.radius * h, o[t + 3] = n.opacity) : (o[t + 0] = 0, o[t + 1] = 0, o[t + 2] = 0, o[t + 3] = 0);
+	}
+	let V = r.trailSources(g.satelliteRadius * .7 * C);
+	for (let e = 0; e < 15; e++) {
+		let t = $.trailPos + e * 4, n = V.sources[e];
+		n ? (o[t + 0] = n.x * .5 * h, o[t + 1] = n.y * .5 * h, o[t + 2] = n.radius * h) : (o[t + 0] = 0, o[t + 1] = 0, o[t + 2] = 0), o[t + 3] = 0;
+	}
+	return s[$.ints + 0] = z, s[$.ints + 1] = B.length, s[$.ints + 2] = V.count, s[$.ints + 3] = 0, e;
+}
+//#endregion
+export { re as a, L as c, p as d, m as f, ie as i, I as l, ae as n, ne as o, oe as r, G as s, Q as t, j as u };