@mkbabb/glass-ui 3.7.0 → 3.8.0

package/dist/compile-BBTRjvQS.js

@@ -0,0 +1,158 @@
+//#region src/composables/glass/webgl/shaders/procedural-color.glsl.ts
+var e = "\nfloat srgbToLinearCh(float c) {\n    return c <= 0.04045 ? c / 12.92 : pow((c + 0.055) / 1.055, 2.4);\n}\nvec3 srgbToLinear(vec3 c) {\n    return vec3(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\n\nfloat linearToSrgbCh(float c) {\n    return c <= 0.0031308 ? c * 12.92 : 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\nvec3 linearToSrgb(vec3 c) {\n    return vec3(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}", t = "const mat2 FBM_ROT = mat2(0.8, 0.6, -0.6, 0.8);", n = "\n// value.js LINEAR_SRGB_TO_LMS (constants.ts), row-major; written here as GLSL\n// columns (= the transpose) so mat3 * vec3 evaluates the row-major M·v.\nconst mat3 LINEAR_SRGB_TO_LMS = mat3(\n    0.4122214708, 0.2119034982, 0.0883024619,\n    0.5363325363, 0.6806995451, 0.2817188376,\n    0.0514459929, 0.1073969566, 0.6299787005\n);\n\n// value.js srgbToOKLab's INLINE LMS→OKLab coefficients (gamut.ts lines 295-297 —\n// these differ at the ~1e-9 digit from LMS_TO_OKLAB_MATRIX; use the inline ones to\n// mirror the exact value.js path), row-major → GLSL columns.\nconst mat3 LMS_TO_OKLAB = mat3(\n    0.2104542553, 1.9779984951, 0.0259040371,\n    0.7936177850, -2.4285922050, 0.7827717662,\n    -0.0040720468, 0.4505937099, -0.8086757660\n);\n\n// value.js OKLAB_TO_LMS_COEFF (constants.ts), row-major → GLSL columns. Rows:\n// l = [1, 0.3963377774, 0.2158037573], m = [1, -0.1055613458, -0.0638541728],\n// s = [1, -0.0894841775, -1.2914855480].\nconst mat3 OKLAB_TO_LMS = mat3(\n    1.0, 1.0, 1.0,\n    0.3963377774, -0.1055613458, -0.0894841775,\n    0.2158037573, -0.0638541728, -1.2914855480\n);\n\n// value.js LMS_TO_LINEAR_SRGB (constants.ts), row-major → GLSL columns.\nconst mat3 LMS_TO_LINEAR_SRGB = mat3(\n    4.0767416621, -1.2684380046, -0.0041960863,\n    -3.3077115913, 2.6097574011, -0.7034186147,\n    0.2309699292, -0.3413193965, 1.7076147010\n);\n\n// Gamma sRGB → raw OKLab (L, a, b). Mirrors value.js srgbToOKLab.\nvec3 srgbToOklab(vec3 c) {\n    vec3 lin = srgbToLinear(c);\n    vec3 lms = LINEAR_SRGB_TO_LMS * lin;\n    vec3 lmsCbrt = sign(lms) * pow(abs(lms), vec3(1.0 / 3.0));\n    return LMS_TO_OKLAB * lmsCbrt;\n}\n\n// Raw OKLab (L, a, b) → linear sRGB. Mirrors value.js oklabToLinearSRGB.\nvec3 oklabToLinearSrgb(vec3 lab) {\n    vec3 lms_ = OKLAB_TO_LMS * lab;\n    vec3 lms = lms_ * lms_ * lms_;\n    return LMS_TO_LINEAR_SRGB * lms;\n}\n\n// OKLab → OKLCh: H in RADIANS. Mirrors value.js rawOklabToOklch (which returns\n// degrees; we stay in radians and only fold to [0, 2pi)).\nvec3 oklabToOklch(vec3 lab) {\n    float C = length(lab.yz);\n    float H = atan(lab.z, lab.y);\n    if (H < 0.0) H += 2.0 * PI;\n    return vec3(lab.x, C, H);\n}\n\n// OKLCh (H radians) → OKLab. Mirrors value.js rawOklchToOklab.\nvec3 oklchToOklab(vec3 lch) {\n    return vec3(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}", r = "\n// value.js interpolateHue in the NORMALIZED-TURNS domain (h_rad/TAU → turns, the\n// exact .5/+1.0 branch per method, fract() wrap, *TAU back). A radians-native port\n// (PI thresholds / +TAU wrap) diverges 180° at the antipode. methods: 0 shorter,\n// 1 longer, 2 increasing, 3 decreasing.\nfloat interpolateHueTurns(float h0, float h1, float t, int method) {\n  float TAU = 2.0 * PI;\n  float a = h0 / TAU;\n  float b = h1 / TAU;\n  float i = b - a;\n  if (method == 0) {              // shorter\n    if (i > 0.5) a += 1.0; else if (i < -0.5) b += 1.0;\n  } else if (method == 1) {       // longer\n    if (i > 0.0 && i < 0.5) a += 1.0; else if (i > -0.5 && i <= 0.0) b += 1.0;\n  } else if (method == 2) {       // increasing\n    if (i < 0.0) b += 1.0;\n  } else {                        // decreasing\n    if (i > 0.0) a += 1.0;\n  }\n  float r = a + t * (b - a);\n  r = fract(r);                   // (r % 1 + 1) % 1 — fract is non-negative in GLSL\n  return r * TAU;                 // back to radians\n}\n\n// Linear-sRGB endpoint pair → OKLab-rectangular interpolation → linear sRGB. Holds\n// chroma across the ramp (no grey midpoint). The default/shorter ramp path.\nvec3 mixPaletteOklab(vec3 linA, vec3 linB, float t) {\n  vec3 labA = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linA) * pow(abs(LINEAR_SRGB_TO_LMS * linA), vec3(1.0 / 3.0)));\n  vec3 labB = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linB) * pow(abs(LINEAR_SRGB_TO_LMS * linB), vec3(1.0 / 3.0)));\n  vec3 lab = mix(labA, labB, t);\n  return oklabToLinearSrgb(lab);\n}\n\n// Linear-sRGB endpoint pair → OKLCh interpolation along the huePath arc → linear\n// sRGB. L and C lerp; H walks the chosen arc. The deliberate-rainbow path.\nvec3 mixPaletteOklchArc(vec3 linA, vec3 linB, float t, int method) {\n  vec3 labA = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linA) * pow(abs(LINEAR_SRGB_TO_LMS * linA), vec3(1.0 / 3.0)));\n  vec3 labB = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linB) * pow(abs(LINEAR_SRGB_TO_LMS * linB), vec3(1.0 / 3.0)));\n  vec3 lchA = oklabToOklch(labA);\n  vec3 lchB = oklabToOklch(labB);\n  float L = mix(lchA.x, lchB.x, t);\n  float C = mix(lchA.y, lchB.y, t);\n  float H = interpolateHueTurns(lchA.z, lchB.z, t, method);\n  return oklabToLinearSrgb(oklchToOklab(vec3(L, C, H)));\n}\n\n// The ramp dispatcher both samplePalette ports splice. tRaw is the raw inter-stop\n// parameter [0,1]; the smoothstep ease + the huePath branch live HERE so the GLSL\n// and WGSL ramps are character-for-character one source. increasing(2)/decreasing(3)\n// take the OKLCh hue-arc (rainbow sweep); every other method takes the OKLab-\n// rectangular straight line (no hue detour).\nvec3 samplePaletteRamp(vec3 a, vec3 b, float tRaw, int huePath) {\n  float t = smoothstep(0.0, 1.0, tRaw);\n  if (huePath == 2 || huePath == 3) {\n    return mixPaletteOklchArc(a, b, t, huePath);\n  }\n  return mixPaletteOklab(a, b, t);\n}", i = "\n// Jarzynski PCG2D — uvec2 → uvec2 permuted-congruential hash (JCGT 2020).\nuvec2 pcg2d(uvec2 v) {\n  v = v * 1664525u + 1013904223u;\n  v.x += v.y * 1664525u;\n  v.y += v.x * 1664525u;\n  v = v ^ (v >> 16u);\n  v.x += v.y * 1664525u;\n  v.y += v.x * 1664525u;\n  v = v ^ (v >> 16u);\n  return v;\n}\n\n// Float→[0,1) scalar hash: bit-reinterpret the lattice coordinate, pcg2d it, take the\n// high word back to [0,1). Integer-bit — no sin() periodicity, no float-fract lattice.\nfloat pcgHash2(vec2 p) {\n  uvec2 u = floatBitsToUint(p);\n  return float(pcg2d(u).x) * (1.0 / 4294967296.0);\n}\n\n// Integer-lattice gradient: pcg2d the integer cell, fold the hash to an angle, return\n// the unit gradient vector. The gradient basis (not a scalar value) is what makes the\n// noise zero at the nodes (no value-noise plateaus).\nvec2 pcgGrad2(ivec2 cell) {\n  uvec2 h = pcg2d(uvec2(cell));\n  float ang = float(h.x) * (1.0 / 4294967296.0) * 6.28318530717958647692;\n  return vec2(cos(ang), sin(ang));\n}\n\n// 2D SIMPLEX gradient noise (Gustavson skew). The skew transform F2/G2 maps the square\n// lattice onto a simplex (triangular) grid — no axis-aligned directional bias. Each of\n// the three simplex corners contributes grad·offset shaped by a radial (0.5 - r²)⁴\n// falloff. Output is ~[-1, 1]; callers remap to [0,1] via 0.5 + 0.5*gnoise.\nfloat gnoise(vec2 p) {\n  const float F2 = 0.36602540378443864676; // (sqrt(3) - 1) / 2\n  const float G2 = 0.21132486540518711775; // (3 - sqrt(3)) / 6\n  float s = (p.x + p.y) * F2;\n  vec2 i = floor(p + s);\n  float tt = (i.x + i.y) * G2;\n  vec2 x0 = p - (i - tt);                    // offset from the simplex origin corner\n  ivec2 i1 = (x0.x > x0.y) ? ivec2(1, 0) : ivec2(0, 1);\n  vec2 x1 = x0 - vec2(i1) + G2;\n  vec2 x2 = x0 - 1.0 + 2.0 * G2;\n  ivec2 ii = ivec2(i);\n  float n = 0.0;\n  float t0 = 0.5 - dot(x0, x0);\n  if (t0 > 0.0) { t0 *= t0; n += t0 * t0 * dot(pcgGrad2(ii), x0); }\n  float t1 = 0.5 - dot(x1, x1);\n  if (t1 > 0.0) { t1 *= t1; n += t1 * t1 * dot(pcgGrad2(ii + i1), x1); }\n  float t2 = 0.5 - dot(x2, x2);\n  if (t2 > 0.0) { t2 *= t2; n += t2 * t2 * dot(pcgGrad2(ii + ivec2(1, 1)), x2); }\n  return 70.0 * n;                           // normalize to ~[-1, 1]\n}", a = "\nfn srgbToLinearCh(c: f32) -> f32 {\n    return select(pow((c + 0.055) / 1.055, 2.4), c / 12.92, c <= 0.04045);\n}\nfn srgbToLinear(c: vec3f) -> vec3f {\n    return vec3f(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\nfn linearToSrgbCh(c: f32) -> f32 {\n    return select(1.055 * pow(c, 1.0 / 2.4) - 0.055, c * 12.92, c <= 0.0031308);\n}\nfn linearToSrgb(c: vec3f) -> vec3f {\n    return vec3f(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}", o = "const FBM_ROT: mat2x2f = mat2x2f(0.8, 0.6, -0.6, 0.8);", s = "\nconst LINEAR_SRGB_TO_LMS: mat3x3f = mat3x3f(\n    0.4122214708, 0.2119034982, 0.0883024619,\n    0.5363325363, 0.6806995451, 0.2817188376,\n    0.0514459929, 0.1073969566, 0.6299787005\n);\nconst LMS_TO_OKLAB: mat3x3f = mat3x3f(\n    0.2104542553, 1.9779984951, 0.0259040371,\n    0.7936177850, -2.4285922050, 0.7827717662,\n    -0.0040720468, 0.4505937099, -0.8086757660\n);\nconst OKLAB_TO_LMS: mat3x3f = mat3x3f(\n    1.0, 1.0, 1.0,\n    0.3963377774, -0.1055613458, -0.0894841775,\n    0.2158037573, -0.0638541728, -1.2914855480\n);\nconst LMS_TO_LINEAR_SRGB: mat3x3f = mat3x3f(\n    4.0767416621, -1.2684380046, -0.0041960863,\n    -3.3077115913, 2.6097574011, -0.7034186147,\n    0.2309699292, -0.3413193965, 1.7076147010\n);\n\nfn srgbToOklab(c: vec3f) -> vec3f {\n    let lin = srgbToLinear(c);\n    let lms = LINEAR_SRGB_TO_LMS * lin;\n    let lmsCbrt = sign(lms) * pow(abs(lms), vec3f(1.0 / 3.0));\n    return LMS_TO_OKLAB * lmsCbrt;\n}\nfn oklabToLinearSrgb(lab: vec3f) -> vec3f {\n    let lms_ = OKLAB_TO_LMS * lab;\n    let lms = lms_ * lms_ * lms_;\n    return LMS_TO_LINEAR_SRGB * lms;\n}\nfn oklabToOklch(lab: vec3f) -> vec3f {\n    let C = length(lab.yz);\n    var H = atan2(lab.z, lab.y);\n    if (H < 0.0) { H = H + 2.0 * PI; }\n    return vec3f(lab.x, C, H);\n}\nfn oklchToOklab(lch: vec3f) -> vec3f {\n    return vec3f(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}", c = "\nfn interpolateHueTurns(h0: f32, h1: f32, t: f32, method: i32) -> f32 {\n  let TAU = 2.0 * PI;\n  var a = h0 / TAU;\n  var b = h1 / TAU;\n  let i = b - a;\n  if (method == 0) {              // shorter\n    if (i > 0.5) { a = a + 1.0; } else if (i < -0.5) { b = b + 1.0; }\n  } else if (method == 1) {       // longer\n    if (i > 0.0 && i < 0.5) { a = a + 1.0; } else if (i > -0.5 && i <= 0.0) { b = b + 1.0; }\n  } else if (method == 2) {       // increasing\n    if (i < 0.0) { b = b + 1.0; }\n  } else {                        // decreasing\n    if (i > 0.0) { a = a + 1.0; }\n  }\n  let r = fract(a + t * (b - a));\n  return r * TAU;\n}\n\nfn mixPaletteOklab(linA: vec3f, linB: vec3f, t: f32) -> vec3f {\n  let labA = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linA) * pow(abs(LINEAR_SRGB_TO_LMS * linA), vec3f(1.0 / 3.0)));\n  let labB = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linB) * pow(abs(LINEAR_SRGB_TO_LMS * linB), vec3f(1.0 / 3.0)));\n  let lab = mix(labA, labB, vec3f(t));\n  return oklabToLinearSrgb(lab);\n}\n\nfn mixPaletteOklchArc(linA: vec3f, linB: vec3f, t: f32, method: i32) -> vec3f {\n  let labA = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linA) * pow(abs(LINEAR_SRGB_TO_LMS * linA), vec3f(1.0 / 3.0)));\n  let labB = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linB) * pow(abs(LINEAR_SRGB_TO_LMS * linB), vec3f(1.0 / 3.0)));\n  let lchA = oklabToOklch(labA);\n  let lchB = oklabToOklch(labB);\n  let L = mix(lchA.x, lchB.x, t);\n  let C = mix(lchA.y, lchB.y, t);\n  let H = interpolateHueTurns(lchA.z, lchB.z, t, method);\n  return oklabToLinearSrgb(oklchToOklab(vec3f(L, C, H)));\n}\n\nfn samplePaletteRamp(a: vec3f, b: vec3f, tRaw: f32, huePath: i32) -> vec3f {\n  let t = smoothstep(0.0, 1.0, tRaw);\n  if (huePath == 2 || huePath == 3) {\n    return mixPaletteOklchArc(a, b, t, huePath);\n  }\n  return mixPaletteOklab(a, b, t);\n}", l = "\nfn pcg2d(v0: vec2u) -> vec2u {\n  var v = v0 * 1664525u + vec2u(1013904223u);\n  v.x = v.x + v.y * 1664525u;\n  v.y = v.y + v.x * 1664525u;\n  v = v ^ (v >> vec2u(16u));\n  v.x = v.x + v.y * 1664525u;\n  v.y = v.y + v.x * 1664525u;\n  v = v ^ (v >> vec2u(16u));\n  return v;\n}\n\nfn pcgHash2(p: vec2f) -> f32 {\n  let u = bitcast<vec2u>(p);\n  return f32(pcg2d(u).x) * (1.0 / 4294967296.0);\n}\n\nfn pcgGrad2(cell: vec2i) -> vec2f {\n  let h = pcg2d(bitcast<vec2u>(cell));\n  let ang = f32(h.x) * (1.0 / 4294967296.0) * 6.28318530717958647692;\n  return vec2f(cos(ang), sin(ang));\n}\n\nfn gnoise(p: vec2f) -> f32 {\n  let F2 = 0.36602540378443864676;\n  let G2 = 0.21132486540518711775;\n  let s = (p.x + p.y) * F2;\n  let i = floor(p + vec2f(s));\n  let tt = (i.x + i.y) * G2;\n  let x0 = p - (i - vec2f(tt));\n  var i1 = vec2i(0, 1);\n  if (x0.x > x0.y) { i1 = vec2i(1, 0); }\n  let x1 = x0 - vec2f(i1) + vec2f(G2);\n  let x2 = x0 - vec2f(1.0) + vec2f(2.0 * G2);\n  let ii = vec2i(i);\n  var n = 0.0;\n  var t0 = 0.5 - dot(x0, x0);\n  if (t0 > 0.0) { t0 = t0 * t0; n = n + t0 * t0 * dot(pcgGrad2(ii), x0); }\n  var t1 = 0.5 - dot(x1, x1);\n  if (t1 > 0.0) { t1 = t1 * t1; n = n + t1 * t1 * dot(pcgGrad2(ii + i1), x1); }\n  var t2 = 0.5 - dot(x2, x2);\n  if (t2 > 0.0) { t2 = t2 * t2; n = n + t2 * t2 * dot(pcgGrad2(ii + vec2i(1, 1)), x2); }\n  return 70.0 * n;\n}";
+function u(e, t, n) {
+	return Math.max(t, Math.min(n, e));
+}
+function d() {
+	let e = typeof window < "u" && window.devicePixelRatio || 1;
+	return Math.min(e, 2);
+}
+//#endregion
+//#region src/composables/glass/webgl/createCanvasLifecycle.ts
+function f(e) {
+	let { canvas: t, buildContext: n, resize: r } = e, i = e.respectReducedMotion ?? e.mode !== "capture", a = /* @__PURE__ */ new Set();
+	e.mode === "capture" && a.add("manual");
+	let o = () => a.size === 0, s = 0, c = typeof performance < "u" ? performance.now() : 0, l = null, u = !1, d = !1, f = i && typeof window < "u" && window.matchMedia ? window.matchMedia("(prefers-reduced-motion: reduce)") : null, p = f?.matches ?? !1;
+	function m() {
+		if (!o() || !l) return;
+		let e = (performance.now() - c) / 1e3, t = l.time ? l.time(e) : e;
+		l.frame(t), s = !p && l.shouldContinue() ? requestAnimationFrame(m) : 0;
+	}
+	function h() {
+		u && o() && !s && l && (s = requestAnimationFrame(m));
+	}
+	function g() {
+		let e = f?.matches ?? !1;
+		e !== p && (p = e, e || (c = performance.now()), h());
+	}
+	f?.addEventListener("change", g);
+	function _(e = "manual") {
+		let t = o();
+		a.add(e), t && !o() && (cancelAnimationFrame(s), s = 0);
+	}
+	function v(e = "manual") {
+		let t = !o();
+		a.delete(e), t && o() && u && l && (c = performance.now() - 1e3, m());
+	}
+	let y = typeof document < "u";
+	function b() {
+		document.hidden ? _("tab-hidden") : v("tab-hidden");
+	}
+	y && document.addEventListener("visibilitychange", b), y && document.hidden && a.add("tab-hidden");
+	let x = null;
+	function S(e) {
+		e.skipped ? _("off-screen") : v("off-screen");
+	}
+	function C() {
+		if (x) return;
+		let e = t.parentElement;
+		e && (x = e, e.addEventListener("contentvisibilityautostatechange", S));
+	}
+	function w() {
+		x?.removeEventListener("contentvisibilityautostatechange", S), x = null;
+	}
+	function T() {
+		l = n(), r();
+	}
+	function E() {
+		u || d || (e.bindContextEvents?.(() => {
+			d || (T(), o() && h());
+		}, () => {
+			l = null, cancelAnimationFrame(s), s = 0;
+		}), T(), C(), u = !0, c = performance.now(), o() && (s = requestAnimationFrame(m)));
+	}
+	function D(e) {
+		u || E(), l?.frame(e);
+	}
+	function O() {
+		d = !0, cancelAnimationFrame(s), s = 0, y && document.removeEventListener("visibilitychange", b), f?.removeEventListener("change", g), w(), e.unbindContextEvents?.(), l?.teardown?.(), l = null, a.clear();
+	}
+	return e.mode === "capture" && E(), {
+		arm: E,
+		suspend: _,
+		resume: v,
+		wake: h,
+		renderAt: D,
+		dispose: O,
+		get armed() {
+			return u;
+		},
+		get disposed() {
+			return d;
+		},
+		get running() {
+			return o();
+		},
+		get reducedMotion() {
+			return p;
+		}
+	};
+}
+//#endregion
+//#region src/composables/glass/webgl/useWebGLCanvas.ts
+function p(e, t) {
+	let { setup: n, contextAttrs: r } = t, i = null, a = null, o = null;
+	function s() {
+		let t = e.getContext("webgl2", r ?? void 0);
+		if (!t) throw Error("[useWebGLCanvas] WebGL2 unavailable");
+		return i = t, o = n(i), a || (a = new ResizeObserver(() => o?.resize()), a.observe(e)), {
+			frame: o.frame,
+			shouldContinue: o.shouldContinue,
+			time: o.time,
+			teardown: () => {
+				o?.teardown?.(), i?.getExtension("WEBGL_lose_context")?.loseContext(), a?.disconnect(), a = null, i = null, o = null;
+			}
+		};
+	}
+	let c = null, l = null;
+	function u(e) {
+		e.preventDefault(), i = null, o = null, l?.();
+	}
+	let d = f({
+		canvas: e,
+		mode: t.mode,
+		respectReducedMotion: t.respectReducedMotion,
+		buildContext: s,
+		resize: () => o?.resize(),
+		bindContextEvents: (t, n) => {
+			c = t, l = n, e.addEventListener("webglcontextlost", u, !1), e.addEventListener("webglcontextrestored", c, !1);
+		},
+		unbindContextEvents: () => {
+			e.removeEventListener("webglcontextlost", u, !1), c && e.removeEventListener("webglcontextrestored", c, !1);
+		}
+	});
+	return {
+		arm: d.arm,
+		suspend: d.suspend,
+		resume: d.resume,
+		wake: d.wake,
+		renderAt: d.renderAt,
+		dispose: d.dispose,
+		get gl() {
+			return i;
+		},
+		get reducedMotion() {
+			return d.reducedMotion;
+		}
+	};
+}
+//#endregion
+//#region src/composables/glass/webgl/compile.ts
+function m(e, t, n, r = "[glass-ui:webgl]") {
+	let i = e.createShader(t);
+	if (e.shaderSource(i, n), e.compileShader(i), !e.getShaderParameter(i, e.COMPILE_STATUS)) {
+		let t = e.getShaderInfoLog(i) ?? "unknown";
+		throw e.deleteShader(i), Error(`${r} shader compile failed:\n${t}`);
+	}
+	return i;
+}
+function h(e, t, n, r = "[glass-ui:webgl]") {
+	let i = e.createProgram();
+	if (e.attachShader(i, t), e.attachShader(i, n), e.linkProgram(i), !e.getProgramParameter(i, e.LINK_STATUS)) {
+		let t = e.getProgramInfoLog(i) ?? "unknown";
+		throw e.deleteProgram(i), Error(`${r} program link failed:\n${t}`);
+	}
+	return i;
+}
+//#endregion
+export { u as a, o as c, n as d, s as f, l as g, i as h, f as i, e as l, c as m, h as n, d as o, r as p, p as r, t as s, m as t, a as u };

package/dist/components/custom/aurora/composables/atoms.d.ts

@@ -1,15 +1,23 @@
 /**
- * AW.W6 — the aurora "atoms of control" door: a PURE, TOTAL mapper from ≤7 intuitive
- * atoms to the full `AuroraConfig`. The thin consumer surface over the ~28-field
- * author schema (the Stripe/paper.design two-tier model) — nothing is removed from
- * `AuroraConfig`; the full schema stays whole as the progressive-disclosure
- * "Advanced" escape hatch. `resolveAtoms` is the NEW door, NOT a parallel config path.
+ * AX.W10 — the aurora "atoms of control" door: the ONE consumer-facing surface
+ * over the ~28-field author schema. `AuroraConfig` is the INTERNAL author schema
+ * (the full escape hatch a preset author types against); `resolveAtoms` is the
+ * SIMPLIFIED door the live config UI + every consumer drives.
+ *
+ * The atoms are the user's named control elements (§2.7) — COLOR, ZONES, NOISE,
+ * MEDIUM(+texture), MOTION — ≤7 intuitive knobs, each normalized and total
+ * (Burley's "Principled" 5-rule discipline: intuitive, few, normalized, robust for
+ * EVERY combination). Each atom maps to a co-varying cluster of config fields so one
+ * knob moves the entangled axes together (a single COLOR-energy knob co-varies
+ * saturation + valueVariance + breath + the warm/cool temperature, because moving any
+ * one alone reads as a defect).
  *
  * Contract (machine-asserted by proof:aurora-atoms-roundtrip):
- *   - TOTAL — every atom combination produces a VALID in-range `AuroraConfig`
- *     respecting every `budget.ts` cap (no NaN, no out-of-range field).
+ *   - TOTAL — every atom combination (incl. out-of-range/adversarial inputs) produces
+ *     a VALID in-range `AuroraConfig` respecting every `budget.ts` cap (no NaN, no
+ *     out-of-range field). Clamp/saturate, never garbage.
  *   - DEFAULT-PRESERVING — `resolveAtoms(DEFAULT_ATOMS)` deep-equals
- *     `DEFAULT_AURORA_CONFIG` (the wispy-sky default survives the new door).
+ *     `DEFAULT_AURORA_CONFIG` (the wispy-sky default survives the door).
  *
  * Mechanism: clone `DEFAULT_AURORA_CONFIG` and apply ONLY the atoms that are PRESENT
  * as clamped overrides. An absent atom keeps the default's value, so the empty atom
@@ -17,40 +25,97 @@
  */
 import { type AuroraConfig, type AuroraMedium, type OklchStop } from "../constants/presets";
 import { type AuroraHarmony } from "./color";
-/** The mood/energy poles — one slider fans to the co-varying energy axes. */
-export type AuroraMoodAtom = "calm" | "balanced" | "vivid";
 /** The motion atom — the three motion registers. */
 export type AuroraMotionAtom = "still" | "breathing" | "drifting";
 /**
- * The Tier-1 atoms of control (≤7). EVERY atom is OPTIONAL — an absent atom keeps the
- * wispy-sky default's value for the fields it would drive, so `DEFAULT_ATOMS` (the
- * empty set) resolves to `DEFAULT_AURORA_CONFIG`. The full `AuroraConfig` stays whole
- * as the progressive-disclosure "Advanced" tier.
+ * The ZONES arrangement character — selects the nuclei placement prior. NOT a bare
+ * integer count: the same count reads as a different field per arrangement.
+ * - `scattered` — radial-ish spread off the centre (loose, atmospheric).
+ * - `composed`  — the rule-of-thirds prior (the deliberate, balanced field).
+ * - `centred`   — a tight central cluster (one dominant glow, calm).
+ */
+export type AuroraZoneArrangement = "scattered" | "composed" | "centred";
+/** The ZONES atom — a count + an arrangement character (default `composed`). */
+export interface AuroraZones {
+    /** 1..MAX_NUCLEI — the number of color zones (nuclei). Clamped. */
+    count: number;
+    /** The placement prior. Default `composed` (rule-of-thirds). */
+    arrangement?: AuroraZoneArrangement;
+}
+/**
+ * The MEDIUM atom — the painterly medium + (only for a TEXTURED medium) its dominant
+ * texture amount. `amount` is STRUCTURALLY ABSENT for `smooth`: a smooth medium has
+ * no dominant texture knob, so the door does not offer/accept one (no silent-inert
+ * arm). For a textured medium `amount` (0..1) drives the medium's signature knob.
+ */
+export type AuroraMediumAtom = {
+    kind: "smooth";
+} | {
+    kind: Exclude<AuroraMedium, "smooth">;
+    amount?: number;
+};
+/**
+ * The interactivity atom — ONLY the wired axes ship. `light` (cursor-as-light) and
+ * `scroll` (scroll-coupled palette/breath) are wired downstream
+ * (`frameLoop.ts`/`useAurora.ts`); the declared-but-unwired `flow`/`wake` axes are
+ * EXCISED from the shipped atom shape (no declared-but-dead axis — excise-or-wire).
+ */
+export interface AuroraInteractivityAtom {
+    /** cursor drives the impasto light direction (cursor-as-light + idle orbit). */
+    light?: boolean;
+    /** palette/breath progress couples to scroll (via useScrollProgress). */
+    scroll?: boolean;
+}
+/**
+ * The Tier-1 atoms of control (≤7) — the user's named control elements. EVERY atom is
+ * OPTIONAL; an absent atom keeps the wispy-sky default for the fields it would drive,
+ * so `DEFAULT_ATOMS` (the empty set) resolves to `DEFAULT_AURORA_CONFIG`.
  */
 export interface AuroraAtoms {
     /** A seed color (CSS string or an OklchStop anchor) → drives the derived palette. */
     seed?: string | OklchStop;
     /** The hue scheme across the derived ramp. Default `analogous` (when a seed is set). */
     harmony?: AuroraHarmony;
-    /** calm ↔ vivid (one knob) — fans to saturation + warpAmount + valueVariance + breath. */
-    mood?: AuroraMoodAtom;
-    /** The painterly medium. */
-    medium?: AuroraMedium;
-    /** 0..1 — the medium's dominant texture knob (strokeAmount / wetEdge / canvasGrain). */
-    textureAmount?: number;
+    /**
+     * 0..1 — the color ENERGY knob. One scalar co-varies the entangled chroma/value
+     * cluster: saturation, valueVariance, breath, AND the warm-light/cool-shadow
+     * temperature on the derived palette. 0 = calm/muted, 1 = vivid/charged. A
+     * continuous curve, not a 3-point named LUT.
+     */
+    colorEnergy?: number;
+    /** The color zones (nuclei) — a count + an arrangement character. */
+    zones?: AuroraZones;
+    /**
+     * 0..1 — the NOISE knob. One scalar fans to the organic-boundary cluster:
+     * warpAmount (how much the zones distort), warpScale (the distortion frequency),
+     * warpMode (smooth fBm → cellular as it climbs), and noiseOctaves (detail). 0 =
+     * clean isotropic zones, 1 = turbulent organic edges.
+     */
+    noise?: number;
+    /** The painterly medium + (textured mediums only) its dominant texture amount. */
+    medium?: AuroraMediumAtom;
     /** still | breathing | drifting — the three motion registers. */
     motion?: AuroraMotionAtom;
-    /** 2..6 — the number of color zones (nuclei), auto-arranged on a rule-of-thirds prior. */
-    zones?: number;
-    /** The pointer/scroll interactivity axes (default OFF — declared at W6, wired at W8). */
-    interactivity?: AuroraConfig["interactivity"];
+    /** The pointer/scroll interactivity axes (default OFF). Only `light`/`scroll` ship. */
+    interactivity?: AuroraInteractivityAtom;
 }
 /**
  * The default atoms — the EMPTY set. `resolveAtoms(DEFAULT_ATOMS)` deep-equals the
  * wispy-sky `DEFAULT_AURORA_CONFIG` (machine-asserted). The user explicitly asked the
- * default to be preserved; the empty-atom pass-through is how the new door honors it.
+ * default to be preserved; the empty-atom pass-through is how the door honors it.
  */
 export declare const DEFAULT_ATOMS: AuroraAtoms;
+/**
+ * The deterministic nuclei prior for `count` zones under an `arrangement` character.
+ * ONE home for the rule-of-thirds prior (the AW duplicated prior pair is gone). Total:
+ * clamps `count` to `[1, MAX_NUCLEI]`; every arrangement yields a valid in-range nuclei
+ * array.
+ *
+ * - `composed`  — the rule-of-thirds anchor table (the deliberate balanced field).
+ * - `scattered` — a golden-angle (φ⁻¹) low-discrepancy spread off-centre (loose).
+ * - `centred`   — a tight cluster around the centre (one dominant glow).
+ */
+export declare function nucleiPrior(count: number, arrangement?: AuroraZoneArrangement): AuroraConfig["nuclei"];
 /**
  * Expand the ≤7 Tier-1 atoms into a full, valid, in-range `AuroraConfig`. A PURE,
  * TOTAL function: clones the wispy-sky default and applies ONLY the present atoms as

package/dist/components/custom/aurora/composables/color.d.ts

@@ -1,4 +1,3 @@
-import { type AuroraConfig } from "../constants/presets";
 import { type ColorHarmony, type OklchStop } from "../../../../composables/color";
 export { cssToOklch, oklchStopToHex, oklchToLinear, } from "../../../../composables/color";
 export type { OklchStop } from "../../../../composables/color";
@@ -79,14 +78,3 @@ export interface DeriveAuroraOptions {
  * @param options ramp shape — stop count, harmony, L/C/h spreads.
  */
 export declare function deriveAurora(seed: string | OklchStop, options?: DeriveAuroraOptions): OklchStop[];
-/** Atmospheric mood words for {@link deriveScene}. */
-export type AuroraMood = "atmospheric" | "painterly" | "vivid" | "muted";
-/**
- * Seed ONE color + a mood word into a WHOLE `AuroraConfig` — palette (via
- * `deriveAurora`), nuclei layout (a rule-of-thirds/golden prior), medium, and the
- * motion/output knobs the mood implies. A SUPERSET front door over `deriveAurora`:
- * a consumer hands a seed + `"painterly"` and gets a coherent backdrop, not just a
- * palette. The base is the wispy-sky `DEFAULT_AURORA_CONFIG` (every field the mood
- * does not touch stays the library default).
- */
-export declare function deriveScene(seed: string | OklchStop, mood?: AuroraMood): AuroraConfig;

package/dist/components/custom/aurora/composables/uniformBridge.d.ts

@@ -6,15 +6,16 @@
  * NEW union member is a COMPILE error until it gets a slot — no silent stale-Record
  * gap where a fresh enum value uploads `undefined`.
  *
- * Crayon is a PEER medium (`uMedium == 4`), NOT a stroke mode: the shader hoists it
- * out of `mediumOil()` (wax-on-tooth, not oil strokes). So `MEDIUM_ID` carries the
- * peer `crayon: 4` slot and `STROKE_MODE_ID` no longer maps `crayon` — a
- * `strokeMode === "crayon"` config resolves to the crayon peer medium via
- * `resolveMediumId` and uploads a benign `uStrokeMode` (oil).
+ * Crayon is a FIRST-CLASS medium (`uMedium == 4`, AX.W13), NOT a stroke mode: the
+ * shader has a dedicated `mediumCrayon()` body (DRY wax-on-tooth). `MEDIUM_ID` carries
+ * the `crayon: 4` slot and `StrokeMode` no longer has a `crayon` member — the legacy
+ * `oil` + `strokeMode:"crayon"` peer-route is REMOVED (clean break); a crayon surface
+ * selects `medium:"crayon"`.
  *
  * The pre-allocated upload buffers live in the bridge: a slider drag refills them
  * in place rather than allocating ~8 Float32Arrays per frame.
  */
+import type { OklchStop } from "../../../../composables/color";
 import type { UniformLocations } from "./glSetup";
 import type { CursorState } from "./cursorModel";
 import { type AuroraConfig } from "../constants/presets";
@@ -55,35 +56,45 @@ export declare const STROKE_MODE_ID: {
     readonly knife: 1;
     readonly chunky: 3;
 };
+export declare const AURORA_CATCH_LIGHT_ANCHOR: OklchStop;
 /**
- * The effective `uMedium` int for a config. The only non-identity case: a
- * `medium: "oil"` + `strokeMode: "crayon"` config selects the crayon PEER
- * (`uMedium == 4`) rather than oil — behavior-preserving with the pre-hoist
- * `mediumOil()` `mode == 2` branch (same pixel output, dispatched one level up).
+ * Resolve a config's `lightColor` to a LINEAR-light `[r,g,b]` triple. Accepts either
+ * a raw linear triple (the array form, passed through) OR an `{L,C,h}` OKLCh anchor
+ * (derived through the shared `warmCatchLight` helper). Omitted = the canonical aurora
+ * warm-white from `AURORA_CATCH_LIGHT_ANCHOR`.
+ */
+export declare function resolveLightColor(lightColor: [number, number, number] | OklchStop | undefined): [number, number, number];
+/**
+ * The effective `uMedium` int for a config. AX.W13 — a pure identity map over the
+ * medium union (the `oil` + `strokeMode:"crayon"` peer-route is REMOVED; crayon is its
+ * own first-class `medium:"crayon"`). `medium` is total over `MEDIUM_ID` (the
+ * `satisfies` guarantees it), so this never resolves `undefined`.
  */
 export declare function resolveMediumId(cfg: AuroraConfig): number;
 /**
- * The `uStrokeMode` int for a config. Crayon is not an oil stroke (it routes to
- * the crayon peer medium where `uStrokeMode` is unread), so it uploads the benign
- * oil default; the other modes map directly.
+ * The `uStrokeMode` int for a config. AX.W13 — `strokeMode` is total over
+ * `STROKE_MODE_ID` (no `crayon` special-case), so this is a direct map.
  */
 export declare function resolveStrokeModeId(cfg: AuroraConfig): number;
 /**
- * AW.W4.1/W4.3/W4.4 — the `uStrokeOrient` int for a config. The painterly mediums
- * (`vangogh`, `oil-pastel`) FORCE the structure-tensor orientation regardless of
- * the config's `strokeOrient` field — their brushwork must hug the color zones (the
- * congruent-to-real-Van-Gogh contract). Every other medium honors the config's
- * `strokeOrient` (default `"flow"` — the pre-W4 path renders identically).
+ * AX.W13 — the `uStrokeOrient` int for a config. The painterly mediums (`vangogh`,
+ * `oil-pastel`, `crayon`) FORCE the structure-tensor orientation regardless of the
+ * config's `strokeOrient` field — their marks must hug the color zones (the
+ * congruent-to-real-works contract). Every other medium honors the config's
+ * `strokeOrient` (default `"flow"`).
  */
 export declare function resolveStrokeOrientId(cfg: AuroraConfig): number;
-export declare const WGPU_UNIFORM_FLOATS: number;
+export declare const WGPU_UNIFORM_FLOATS = 20;
+export declare const WGPU_FIELD_FLOATS: number;
 /**
- * Pack an `AuroraConfig` + cursor into the std140 WGSL Uniforms layout (the WebGPU
- * write path). Fills `out` in place (the caller owns one reused buffer so a slider
- * drag does not churn the GC). The WebGL2 fallback path is unaffected (it keeps its
- * `gl.uniform*` calls). The float layout MUST mirror aurora.wgsl.ts `struct Uniforms`.
+ * Pack an `AuroraConfig` into the SPLIT WebGPU buffers (AX.W07). `uniformOut` takes the
+ * 16 constant-indexed scalars (the f32-packed counts the shader i32()-casts); `fieldOut`
+ * takes the palette + nuclei vec4 arrays for the storage `Field` buffer. Both are filled
+ * in place (the caller owns the reused buffers so a slider drag does not churn the GC).
+ * The WebGL2 fallback path is unaffected (it keeps its `gl.uniform*` calls). The float
+ * layouts MUST mirror aurora.wgsl.ts `struct Uniforms` + `struct Field`.
  */
-export declare function packGPUUniforms(cfg: AuroraConfig, timeSec: number, out: Float32Array): Float32Array;
+export declare function packGPUUniforms(cfg: AuroraConfig, timeSec: number, uniformOut: Float32Array, fieldOut: Float32Array): void;
 /**
  * Build the per-config uniform uploader bound to a program's uniform location
  * cache + cursor state. Returns `uploadConfig` — call it to push a fresh

package/dist/components/custom/aurora/constants/presets.d.ts

@@ -39,9 +39,9 @@ export interface AuroraNucleus {
      */
     angle?: number;
 }
-export type AuroraMedium = "smooth" | "pastel" | "watercolor" | "oil" | "vangogh" | "oil-pastel";
-/** Applied only when `medium === "oil"`. Routes inside the shader. */
-export type StrokeMode = "oil" | "knife" | "crayon" | "chunky";
+export type AuroraMedium = "smooth" | "pastel" | "watercolor" | "oil" | "crayon" | "vangogh" | "oil-pastel";
+/** Oil-stroke sub-mode. Applied only when `medium === "oil"`. Routes inside the shader. */
+export type StrokeMode = "oil" | "knife" | "chunky";
 export type FlowPattern = "none" | "radial" | "swirl" | "diagonal" | "multi" | "tensor";
 /**
  * AW.W4.1 — how a stroke's orientation is sourced. `flow` keeps the hand-authored
@@ -124,11 +124,14 @@ export interface AuroraConfig {
      */
     lightDir?: [number, number, number];
     /**
-     * AW.W4.2 — the relight tint (linear-light RGB). Optional; omitted = a warm
-     * white (the canonical impasto catch-light). The diffuse + Blinn-specular terms
-     * modulate by this.
+     * AW.W4.2 / AX.W11 — the relight tint (the impasto catch-light). Optional;
+     * omitted = the canonical warm-white the shared `warmCatchLight` OKLCh helper
+     * derives (the `(0.985, 0.0125, 77.5°)` anchor — perceptually the prior eyeballed
+     * warm-white, now on the OKLCh core). Author it either as a raw LINEAR-light
+     * `[r,g,b]` triple OR as an `{L,C,h}` OKLCh anchor (the bridge derives the linear
+     * triple via `warmCatchLight`). The diffuse + Blinn-specular terms modulate by it.
      */
-    lightColor?: [number, number, number];
+    lightColor?: [number, number, number] | OklchStop;
     nucleiDrift: number;
     paletteDrift: number;
     breathDepth: number;

package/dist/components/custom/aurora/constants/renderMode.d.ts

@@ -13,6 +13,28 @@ export type AuroraRenderMode = "webgl" | "css" | "auto";
  * placeholder floor.
  */
 export type AuroraSubstrate = "webgpu" | "webgl" | "css";
+/**
+ * AX.W07 — the WebGPU-parity lever (internal, NOT a consumer prop — consumers should
+ * not know the WGSL twin exists). The shared W07↔W14 switch:
+ *
+ *   - W07 sets it `false`. The WGSL twin's two device-proven black-canvas defects (the
+ *     int-in-float counts + the `var<uniform>` dynamic-index Metal miscompile) are FIXED
+ *     at their root in this wave, but the twin is STILL reduced-parity by design even
+ *     unblocked (isotropic-only nuclei, fbm-only warp, NO flow/cursor/lighting/mediums/
+ *     strokes/grain, a straight-OKLab palette vs the GLSL OKLCh hue-arc). So a
+ *     WebGPU-capable machine is served the TESTED universal WebGL2 path (DESIGN.md
+ *     invariant 8 — the correct single-pass renderer) rather than the reduced-parity twin:
+ *     `resolveRenderModeAsync` returns `{ substrate: "webgl", device: null }` while this
+ *     is `false`. This is a knowingly-DEGRADED-by-design phased outcome (SPEC.md
+ *     §DEGRADED).
+ *   - W14 (band C · AURORA) owns the flip — and ONLY for the OPT-IN Kuwahara painterly
+ *     finish over a parity-floor field, never to auto-default a capable machine (the
+ *     §4 note 14 DELETE-the-auto-default disposition). W14 is the NAMED restoration wave.
+ *
+ * The gate forces the WebGPU path internally regardless of this lever (it tests the
+ * SHADER, not the default routing); only the LIVE default routing reads it.
+ */
+export declare const WEBGPU_PARITY = false;
 /**
  * Resolve `"auto"` to a concrete substrate per device tier. `"webgl"` and
  * `"css"` pass through unchanged.

package/dist/components/custom/aurora/constants/shaders/aurora.wgsl.d.ts

@@ -1,7 +1,7 @@
 declare const WGSL_MAX_NUCLEI = 6;
 declare const WGSL_MAX_STOPS = 8;
 export declare const AURORA_VERTEX_WGSL = "\nstruct VSOut {\n  @builtin(position) pos: vec4f,\n  @location(0) uv: vec2f,\n};\n\n@vertex\nfn vs_main(@builtin(vertex_index) vi: u32) -> VSOut {\n  // Full-screen triangle (matches the WebGL2 [-1,-1, 3,-1, -1,3] quad).\n  var p = array<vec2f, 3>(vec2f(-1.0, -1.0), vec2f(3.0, -1.0), vec2f(-1.0, 3.0));\n  var out: VSOut;\n  let xy = p[vi];\n  out.pos = vec4f(xy, 0.0, 1.0);\n  out.uv = 0.5 * (xy + vec2f(1.0));\n  return out;\n}";
-export declare const AURORA_FRAGMENT_WGSL = "\nconst PI: f32 = 3.141592653589793;\nconst W_LUMA: vec3f = vec3f(0.2126, 0.7152, 0.0722);\nconst MAX_NUCLEI: u32 = 6u;\nconst MAX_STOPS: u32 = 8u;\n\n// The std140 uniform struct \u2014 the WebGPU write path packs an AuroraConfig here.\nstruct Uniforms {\n  time: f32,\n  stopCount: i32,\n  nucleiCount: i32,\n  softmaxBeta: f32,\n  valueVariance: f32,\n  warpAmount: f32,\n  warpScale: f32,\n  warpDrift: f32,\n  warpMode: i32,\n  noiseOctaves: i32,\n  medium: i32,\n  breathDepth: f32,\n  breathPeriod: f32,\n  saturation: f32,\n  paperGrain: f32,\n  alpha: f32,\n  palette: array<vec4f, 8>,      // .xyz = linear-sRGB stop\n  nucleiPos: array<vec4f, 6>,    // .xy pos, .z radius, .w paletteBias\n  nucleiMod: array<vec4f, 6>,    // .x valueBias, .y elong, .z angle, .w driftRadius\n};\n\n@group(0) @binding(0) var<uniform> U: Uniforms;\n\n\nfn srgbToLinearCh(c: f32) -> f32 {\n    return select(pow((c + 0.055) / 1.055, 2.4), c / 12.92, c <= 0.04045);\n}\nfn srgbToLinear(c: vec3f) -> vec3f {\n    return vec3f(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\nfn linearToSrgbCh(c: f32) -> f32 {\n    return select(1.055 * pow(c, 1.0 / 2.4) - 0.055, c * 12.92, c <= 0.0031308);\n}\nfn linearToSrgb(c: vec3f) -> vec3f {\n    return vec3f(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}\nconst FBM_ROT: mat2x2f = mat2x2f(0.8, 0.6, -0.6, 0.8);\n\nconst LINEAR_SRGB_TO_LMS: mat3x3f = mat3x3f(\n    0.4122214708, 0.2119034982, 0.0883024619,\n    0.5363325363, 0.6806995451, 0.2817188376,\n    0.0514459929, 0.1073969566, 0.6299787005\n);\nconst LMS_TO_OKLAB: mat3x3f = mat3x3f(\n    0.2104542553, 1.9779984951, 0.0259040371,\n    0.7936177850, -2.4285922050, 0.7827717662,\n    -0.0040720468, 0.4505937099, -0.8086757660\n);\nconst OKLAB_TO_LMS: mat3x3f = mat3x3f(\n    1.0, 1.0, 1.0,\n    0.3963377774, -0.1055613458, -0.0894841775,\n    0.2158037573, -0.0638541728, -1.2914855480\n);\nconst LMS_TO_LINEAR_SRGB: mat3x3f = mat3x3f(\n    4.0767416621, -1.2684380046, -0.0041960863,\n    -3.3077115913, 2.6097574011, -0.7034186147,\n    0.2309699292, -0.3413193965, 1.7076147010\n);\n\nfn srgbToOklab(c: vec3f) -> vec3f {\n    let lin = srgbToLinear(c);\n    let lms = LINEAR_SRGB_TO_LMS * lin;\n    let lmsCbrt = sign(lms) * pow(abs(lms), vec3f(1.0 / 3.0));\n    return LMS_TO_OKLAB * lmsCbrt;\n}\nfn oklabToLinearSrgb(lab: vec3f) -> vec3f {\n    let lms_ = OKLAB_TO_LMS * lab;\n    let lms = lms_ * lms_ * lms_;\n    return LMS_TO_LINEAR_SRGB * lms;\n}\nfn oklabToOklch(lab: vec3f) -> vec3f {\n    let C = length(lab.yz);\n    var H = atan2(lab.z, lab.y);\n    if (H < 0.0) { H = H + 2.0 * PI; }\n    return vec3f(lab.x, C, H);\n}\nfn oklchToOklab(lch: vec3f) -> vec3f {\n    return vec3f(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}\n\nfn hash21(p0: vec2f) -> f32 {\n  var p = fract(p0 * vec2f(123.34, 456.21));\n  p = p + dot(p, p + 45.32);\n  return fract(p.x * p.y);\n}\nfn vnoise(p: vec2f) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u = f * f * (3.0 - 2.0 * f);\n  let a = hash21(i);\n  let b = hash21(i + vec2f(1.0, 0.0));\n  let c = hash21(i + vec2f(0.0, 1.0));\n  let d = hash21(i + vec2f(1.0, 1.0));\n  return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);\n}\nfn fbm(p0: vec2f) -> f32 {\n  var v = 0.0;\n  var a = 0.5;\n  var p = p0;\n  for (var i = 0; i < 5; i = i + 1) {\n    if (i >= U.noiseOctaves) { break; }\n    v = v + a * vnoise(p);\n    p = FBM_ROT * p * 2.02;\n    a = a * 0.5;\n  }\n  return v;\n}\n\nfn samplePalette(id: f32) -> vec3f {\n  // Nearest-pair OKLab interpolation across the stops (mirrors the GLSL default ramp).\n  let n = U.stopCount;\n  if (n <= 1) { return U.palette[0].xyz; }\n  let t = clamp(id, 0.0, 1.0) * f32(n - 1);\n  let i0 = i32(floor(t));\n  let i1 = min(i0 + 1, n - 1);\n  let f = t - f32(i0);\n  let labA = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * U.palette[i0].xyz) * pow(abs(LINEAR_SRGB_TO_LMS * U.palette[i0].xyz), vec3f(1.0 / 3.0)));\n  let labB = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * U.palette[i1].xyz) * pow(abs(LINEAR_SRGB_TO_LMS * U.palette[i1].xyz), vec3f(1.0 / 3.0)));\n  return oklabToLinearSrgb(mix(labA, labB, f));\n}\n\nfn domainWarp(p: vec2f, t: f32) -> vec2f {\n  let drift = t * U.warpDrift * 5.0;\n  let q = vec2f(\n    fbm(p * U.warpScale + vec2f(drift, 0.0)),\n    fbm(p * U.warpScale + vec2f(5.2, 1.3 + drift))\n  );\n  let r = vec2f(\n    fbm(p * U.warpScale + 4.0 * q + vec2f(1.7, 9.2)),\n    fbm(p * U.warpScale + 4.0 * q + vec2f(8.3, 2.8))\n  );\n  return p + U.warpAmount * r;\n}\n\nfn nucleiField(p: vec2f, t: f32) -> vec2f {\n  // Returns (paletteId, valueMod) \u2014 softmax over the nuclei (isotropic; the WebGPU\n  // twin keeps the parity-floor isotropic Gaussian).\n  var accumId = 0.0;\n  var accumVal = 0.0;\n  var w = 0.0;\n  let n = U.nucleiCount;\n  for (var i = 0; i < 6; i = i + 1) {\n    if (i >= n) { break; }\n    let pos = U.nucleiPos[i].xy;\n    let rad = max(U.nucleiPos[i].z, 0.01);\n    let d2 = dot(p - pos, p - pos);\n    let wi = exp((-U.softmaxBeta * d2) / (rad * rad));\n    accumId = accumId + wi * U.nucleiPos[i].w;\n    accumVal = accumVal + wi * U.nucleiMod[i].x;\n    w = w + wi;\n  }\n  if (w < 1e-4) { return vec2f(0.5, 0.0); }\n  return vec2f(accumId / w, accumVal / w);\n}\n\n// ACES (Narkowicz) \u2014 matches the GLSL tonemap.\nfn aces(x: vec3f) -> vec3f {\n  let a = 2.51; let b = 0.03; let c = 2.43; let d = 0.59; let e = 0.14;\n  return clamp((x * (a * x + b)) / (x * (c * x + d) + e), vec3f(0.0), vec3f(1.0));\n}\n\n@fragment\nfn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {\n  let t = U.time;\n  let pw = domainWarp(uv, t);\n  let nf = nucleiField(pw, t);\n  var col = samplePalette(nf.x);\n  col = col * (1.0 + U.valueVariance * nf.y);\n\n  // Breath.\n  let breath = sin(t * 6.2831 / max(U.breathPeriod, 1.0));\n  col = col * (1.0 + U.breathDepth * breath * 0.5);\n\n  // (The WebGPU smooth pole; the painterly mediums run the W7c multi-pass passes.)\n  col = aces(col);\n  col = linearToSrgb(col);                // the mandatory OETF (linear \u2192 display).\n  return vec4f(col * U.alpha, U.alpha);   // premultiply AFTER the OETF (parity).\n}";
+export declare const AURORA_FRAGMENT_WGSL = "\nconst PI: f32 = 3.141592653589793;\nconst W_LUMA: vec3f = vec3f(0.2126, 0.7152, 0.0722);\nconst MAX_NUCLEI: u32 = 6u;\nconst MAX_STOPS: u32 = 8u;\n\n// The uniform struct \u2014 ONLY constant-indexed scalars (safe in the uniform address\n// space). The five count/enum fields are f32 (AX.W07 1a): the WebGPU write path packs\n// them as floats and the shader i32-casts at each use, so WGSL never reads a float\n// bit-pattern as a raw i32. The dynamically-indexed arrays moved OUT to struct Field\n// below (AX.W07 1b).\nstruct Uniforms {\n  time: f32,\n  stopCount: f32,\n  nucleiCount: f32,\n  softmaxBeta: f32,\n  valueVariance: f32,\n  warpAmount: f32,\n  warpScale: f32,\n  warpDrift: f32,\n  warpMode: f32,\n  noiseOctaves: f32,\n  medium: f32,\n  breathDepth: f32,\n  breathPeriod: f32,\n  saturation: f32,\n  paperGrain: f32,\n  alpha: f32,\n  // AX.W11 \u2014 the huePath enum (f32-packed, i32()-cast in samplePalette) carries the\n  // shared ramp's OKLab-rectangular-vs-OKLCh-hue-arc dispatch into the WebGPU twin so\n  // a huePath:'increasing' rainbow config arcs identically to the WebGL2 oracle. The\n  // CPU pad keeps the buffer vec4-aligned (WGPU_UNIFORM_FLOATS rounds to 20).\n  huePath: f32,\n};\n\n// The dynamically-indexed arrays \u2014 bound var<storage, read> (AX.W07 1b). A runtime\n// palette/nuclei index into a var<uniform> array<vec4f> returns [0,0,0,0] on Metal\n// (MSL forbids dynamic indexing of constant); storage is always-legal. The vec4 stride\n// is std140-identical to the uniform layout, so the move is byte-exact.\nstruct Field {\n  palette: array<vec4f, 8>,      // .xyz = linear-sRGB stop\n  nucleiPos: array<vec4f, 6>,    // .xy pos, .z radius, .w paletteBias\n  nucleiMod: array<vec4f, 6>,    // .x valueBias, .y elong, .z angle, .w driftRadius\n};\n\n@group(0) @binding(0) var<uniform> U: Uniforms;\n@group(0) @binding(1) var<storage, read> F: Field;\n\n\nfn srgbToLinearCh(c: f32) -> f32 {\n    return select(pow((c + 0.055) / 1.055, 2.4), c / 12.92, c <= 0.04045);\n}\nfn srgbToLinear(c: vec3f) -> vec3f {\n    return vec3f(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\nfn linearToSrgbCh(c: f32) -> f32 {\n    return select(1.055 * pow(c, 1.0 / 2.4) - 0.055, c * 12.92, c <= 0.0031308);\n}\nfn linearToSrgb(c: vec3f) -> vec3f {\n    return vec3f(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}\nconst FBM_ROT: mat2x2f = mat2x2f(0.8, 0.6, -0.6, 0.8);\n\nconst LINEAR_SRGB_TO_LMS: mat3x3f = mat3x3f(\n    0.4122214708, 0.2119034982, 0.0883024619,\n    0.5363325363, 0.6806995451, 0.2817188376,\n    0.0514459929, 0.1073969566, 0.6299787005\n);\nconst LMS_TO_OKLAB: mat3x3f = mat3x3f(\n    0.2104542553, 1.9779984951, 0.0259040371,\n    0.7936177850, -2.4285922050, 0.7827717662,\n    -0.0040720468, 0.4505937099, -0.8086757660\n);\nconst OKLAB_TO_LMS: mat3x3f = mat3x3f(\n    1.0, 1.0, 1.0,\n    0.3963377774, -0.1055613458, -0.0894841775,\n    0.2158037573, -0.0638541728, -1.2914855480\n);\nconst LMS_TO_LINEAR_SRGB: mat3x3f = mat3x3f(\n    4.0767416621, -1.2684380046, -0.0041960863,\n    -3.3077115913, 2.6097574011, -0.7034186147,\n    0.2309699292, -0.3413193965, 1.7076147010\n);\n\nfn srgbToOklab(c: vec3f) -> vec3f {\n    let lin = srgbToLinear(c);\n    let lms = LINEAR_SRGB_TO_LMS * lin;\n    let lmsCbrt = sign(lms) * pow(abs(lms), vec3f(1.0 / 3.0));\n    return LMS_TO_OKLAB * lmsCbrt;\n}\nfn oklabToLinearSrgb(lab: vec3f) -> vec3f {\n    let lms_ = OKLAB_TO_LMS * lab;\n    let lms = lms_ * lms_ * lms_;\n    return LMS_TO_LINEAR_SRGB * lms;\n}\nfn oklabToOklch(lab: vec3f) -> vec3f {\n    let C = length(lab.yz);\n    var H = atan2(lab.z, lab.y);\n    if (H < 0.0) { H = H + 2.0 * PI; }\n    return vec3f(lab.x, C, H);\n}\nfn oklchToOklab(lch: vec3f) -> vec3f {\n    return vec3f(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}\n\nfn interpolateHueTurns(h0: f32, h1: f32, t: f32, method: i32) -> f32 {\n  let TAU = 2.0 * PI;\n  var a = h0 / TAU;\n  var b = h1 / TAU;\n  let i = b - a;\n  if (method == 0) {              // shorter\n    if (i > 0.5) { a = a + 1.0; } else if (i < -0.5) { b = b + 1.0; }\n  } else if (method == 1) {       // longer\n    if (i > 0.0 && i < 0.5) { a = a + 1.0; } else if (i > -0.5 && i <= 0.0) { b = b + 1.0; }\n  } else if (method == 2) {       // increasing\n    if (i < 0.0) { b = b + 1.0; }\n  } else {                        // decreasing\n    if (i > 0.0) { a = a + 1.0; }\n  }\n  let r = fract(a + t * (b - a));\n  return r * TAU;\n}\n\nfn mixPaletteOklab(linA: vec3f, linB: vec3f, t: f32) -> vec3f {\n  let labA = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linA) * pow(abs(LINEAR_SRGB_TO_LMS * linA), vec3f(1.0 / 3.0)));\n  let labB = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linB) * pow(abs(LINEAR_SRGB_TO_LMS * linB), vec3f(1.0 / 3.0)));\n  let lab = mix(labA, labB, vec3f(t));\n  return oklabToLinearSrgb(lab);\n}\n\nfn mixPaletteOklchArc(linA: vec3f, linB: vec3f, t: f32, method: i32) -> vec3f {\n  let labA = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linA) * pow(abs(LINEAR_SRGB_TO_LMS * linA), vec3f(1.0 / 3.0)));\n  let labB = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linB) * pow(abs(LINEAR_SRGB_TO_LMS * linB), vec3f(1.0 / 3.0)));\n  let lchA = oklabToOklch(labA);\n  let lchB = oklabToOklch(labB);\n  let L = mix(lchA.x, lchB.x, t);\n  let C = mix(lchA.y, lchB.y, t);\n  let H = interpolateHueTurns(lchA.z, lchB.z, t, method);\n  return oklabToLinearSrgb(oklchToOklab(vec3f(L, C, H)));\n}\n\nfn samplePaletteRamp(a: vec3f, b: vec3f, tRaw: f32, huePath: i32) -> vec3f {\n  let t = smoothstep(0.0, 1.0, tRaw);\n  if (huePath == 2 || huePath == 3) {\n    return mixPaletteOklchArc(a, b, t, huePath);\n  }\n  return mixPaletteOklab(a, b, t);\n}\n\n// AX.W12 \u2014 the painterly-medium organic noise basis (PCG2D integer-bit hash + 2D\n// simplex gradient noise), SPLICED from the shared procedural-color chunk \u2014 the EXACT\n// twin of the GLSL leaf aurora.frag.ts splices, so the hash can NEVER drift between\n// backends (proof:aurora-noise-hash-equivalence locks the twins to 1e-6). The WebGPU\n// single-pass fs_main below stays the smooth pole (it runs no medium body \u2014 the\n// painterly mediums are the W7c/W14 multi-pass), so the leaf is single-sourced HERE for\n// the twin-equivalence contract; the W14 painterly passes consume it.\n\nfn pcg2d(v0: vec2u) -> vec2u {\n  var v = v0 * 1664525u + vec2u(1013904223u);\n  v.x = v.x + v.y * 1664525u;\n  v.y = v.y + v.x * 1664525u;\n  v = v ^ (v >> vec2u(16u));\n  v.x = v.x + v.y * 1664525u;\n  v.y = v.y + v.x * 1664525u;\n  v = v ^ (v >> vec2u(16u));\n  return v;\n}\n\nfn pcgHash2(p: vec2f) -> f32 {\n  let u = bitcast<vec2u>(p);\n  return f32(pcg2d(u).x) * (1.0 / 4294967296.0);\n}\n\nfn pcgGrad2(cell: vec2i) -> vec2f {\n  let h = pcg2d(bitcast<vec2u>(cell));\n  let ang = f32(h.x) * (1.0 / 4294967296.0) * 6.28318530717958647692;\n  return vec2f(cos(ang), sin(ang));\n}\n\nfn gnoise(p: vec2f) -> f32 {\n  let F2 = 0.36602540378443864676;\n  let G2 = 0.21132486540518711775;\n  let s = (p.x + p.y) * F2;\n  let i = floor(p + vec2f(s));\n  let tt = (i.x + i.y) * G2;\n  let x0 = p - (i - vec2f(tt));\n  var i1 = vec2i(0, 1);\n  if (x0.x > x0.y) { i1 = vec2i(1, 0); }\n  let x1 = x0 - vec2f(i1) + vec2f(G2);\n  let x2 = x0 - vec2f(1.0) + vec2f(2.0 * G2);\n  let ii = vec2i(i);\n  var n = 0.0;\n  var t0 = 0.5 - dot(x0, x0);\n  if (t0 > 0.0) { t0 = t0 * t0; n = n + t0 * t0 * dot(pcgGrad2(ii), x0); }\n  var t1 = 0.5 - dot(x1, x1);\n  if (t1 > 0.0) { t1 = t1 * t1; n = n + t1 * t1 * dot(pcgGrad2(ii + i1), x1); }\n  var t2 = 0.5 - dot(x2, x2);\n  if (t2 > 0.0) { t2 = t2 * t2; n = n + t2 * t2 * dot(pcgGrad2(ii + vec2i(1, 1)), x2); }\n  return 70.0 * n;\n}\n\nfn hash21(p0: vec2f) -> f32 {\n  var p = fract(p0 * vec2f(123.34, 456.21));\n  p = p + dot(p, p + 45.32);\n  return fract(p.x * p.y);\n}\nfn vnoise(p: vec2f) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u = f * f * (3.0 - 2.0 * f);\n  let a = hash21(i);\n  let b = hash21(i + vec2f(1.0, 0.0));\n  let c = hash21(i + vec2f(0.0, 1.0));\n  let d = hash21(i + vec2f(1.0, 1.0));\n  return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);\n}\nfn fbm(p0: vec2f) -> f32 {\n  var v = 0.0;\n  var a = 0.5;\n  var p = p0;\n  let octaves = i32(U.noiseOctaves);   // AX.W07 1a \u2014 i32()-cast the f32-packed count.\n  for (var i = 0; i < 5; i = i + 1) {\n    if (i >= octaves) { break; }\n    v = v + a * vnoise(p);\n    p = FBM_ROT * p * 2.02;\n    a = a * 0.5;\n  }\n  return v;\n}\n\nfn samplePalette(id: f32) -> vec3f {\n  // AX.W11 \u2014 splice the SHARED samplePaletteRamp (the smoothstep ease + the OKLab-\n  // rectangular-vs-OKLCh-hue-arc huePath dispatch), the EXACT twin the GLSL oracle\n  // splices. The body here only selects the bracketing stop pair + the raw inter-stop\n  // t (the W07 storage-Field dynamic index), then hands them to the shared ramp.\n  let n = i32(U.stopCount);            // AX.W07 1a \u2014 i32()-cast the f32-packed count.\n  if (n <= 1) { return F.palette[0].xyz; }\n  let t = clamp(id, 0.0, 1.0) * f32(n - 1);\n  let i0 = i32(floor(t));\n  let i1 = min(i0 + 1, n - 1);\n  let f = t - f32(i0);\n  // AX.W07 1b \u2014 read the palette from the storage Field (dynamic i0/i1 index);\n  // AX.W11 \u2014 i32()-cast the f32-packed huePath enum (parity with the count casts).\n  return samplePaletteRamp(F.palette[i0].xyz, F.palette[i1].xyz, f, i32(U.huePath));\n}\n\nfn domainWarp(p: vec2f, t: f32) -> vec2f {\n  let drift = t * U.warpDrift * 5.0;\n  let q = vec2f(\n    fbm(p * U.warpScale + vec2f(drift, 0.0)),\n    fbm(p * U.warpScale + vec2f(5.2, 1.3 + drift))\n  );\n  let r = vec2f(\n    fbm(p * U.warpScale + 4.0 * q + vec2f(1.7, 9.2)),\n    fbm(p * U.warpScale + 4.0 * q + vec2f(8.3, 2.8))\n  );\n  return p + U.warpAmount * r;\n}\n\nfn nucleiField(p: vec2f, t: f32) -> vec2f {\n  // Returns (paletteId, valueMod) \u2014 softmax over the nuclei (isotropic; the WebGPU\n  // twin keeps the parity-floor isotropic Gaussian).\n  var accumId = 0.0;\n  var accumVal = 0.0;\n  var w = 0.0;\n  let n = i32(U.nucleiCount);          // AX.W07 1a \u2014 i32()-cast the f32-packed count.\n  for (var i = 0; i < 6; i = i + 1) {\n    if (i >= n) { break; }\n    // AX.W07 1b \u2014 read the nuclei from the storage Field (dynamic i index).\n    let pos = F.nucleiPos[i].xy;\n    let rad = max(F.nucleiPos[i].z, 0.01);\n    let d2 = dot(p - pos, p - pos);\n    let wi = exp((-U.softmaxBeta * d2) / (rad * rad));\n    accumId = accumId + wi * F.nucleiPos[i].w;\n    accumVal = accumVal + wi * F.nucleiMod[i].x;\n    w = w + wi;\n  }\n  if (w < 1e-4) { return vec2f(0.5, 0.0); }\n  return vec2f(accumId / w, accumVal / w);\n}\n\n// ACES (Narkowicz) \u2014 matches the GLSL tonemap.\nfn aces(x: vec3f) -> vec3f {\n  let a = 2.51; let b = 0.03; let c = 2.43; let d = 0.59; let e = 0.14;\n  return clamp((x * (a * x + b)) / (x * (c * x + d) + e), vec3f(0.0), vec3f(1.0));\n}\n\n@fragment\nfn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {\n  let t = U.time;\n  let pw = domainWarp(uv, t);\n  let nf = nucleiField(pw, t);\n  var col = samplePalette(nf.x);\n  col = col * (1.0 + U.valueVariance * nf.y);\n\n  // Breath.\n  let breath = sin(t * 6.2831 / max(U.breathPeriod, 1.0));\n  col = col * (1.0 + U.breathDepth * breath * 0.5);\n\n  // (The WebGPU smooth pole; the painterly mediums run the W7c multi-pass passes.)\n  col = aces(col);\n  col = linearToSrgb(col);                // the mandatory OETF (linear \u2192 display).\n  return vec4f(col * U.alpha, U.alpha);   // premultiply AFTER the OETF (parity).\n}";
 /** The assembled WGSL module string (vertex + fragment) for createGPUCanvas. */
 export declare const AURORA_WGSL: string;
 export { WGSL_MAX_NUCLEI, WGSL_MAX_STOPS };