@mkbabb/glass-ui 3.8.0 → 3.10.0

package/dist/{badge-DHQrc_GQ.js → badge-CaoFJzRb.js}

@@ -27,21 +27,21 @@ var c = ["data-variant", "data-size"], l = /* @__PURE__ */ n({
 			}), s.class))
 		}, [a(l.$slots, "default")], 10, c));
 	}
-}), u = s("focus-ring inline-flex items-center gap-1.5 rounded-badge border font-semibold transition-control wrap-anywhere [&_svg:not([class*=size-])]:size-3.5 [&_svg]:shrink-0 [&_svg]:pointer-events-none", {
+}), u = s("focus-ring inline-flex items-center gap-1.5 rounded-badge border font-semibold transition-control wrap-anywhere [&_svg:not([class*=size-])]:size-[var(--ui-glyph-sm)] [&_svg]:shrink-0 [&_svg]:pointer-events-none", {
 	variants: {
 		variant: {
 			default: "border-transparent bg-primary text-primary-foreground hover:bg-primary/80",
 			secondary: "border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80",
-			destructive: "border-transparent bg-destructive text-destructive-foreground hover:bg-destructive/80",
+			destructive: "border-transparent bg-destructive text-destructive-foreground hover:bg-destructive/80 dark:bg-[hsl(0_70%_45%)] dark:hover:bg-[hsl(0_70%_45%)]/85",
 			outline: "text-foreground",
 			success: "border-transparent bg-success text-success-foreground hover:bg-success/80",
 			warning: "border-transparent bg-warning text-warning-foreground hover:bg-warning/80",
 			info: "border-transparent bg-info text-info-foreground hover:bg-info/80"
 		},
 		size: {
-			sm: "text-xs leading-4 px-2 py-0.5",
-			md: "text-sm leading-5 px-2.5 py-1",
-			lg: "text-base leading-6 px-3 py-1.5"
+			sm: "text-[length:var(--control-text-sm)] leading-4 px-2 py-0.5",
+			md: "text-[length:var(--control-text)] leading-5 px-2.5 py-1",
+			lg: "text-[length:calc(var(--type-body)*var(--ui-scale))] leading-6 px-3 py-1.5"
 		}
 	},
 	defaultVariants: {

package/dist/badge.js

@@ -1,2 +1,2 @@
-import { n as e, t } from "./badge-DHQrc_GQ.js";
+import { n as e, t } from "./badge-CaoFJzRb.js";
 export { e as Badge, t as badgeVariants };

package/dist/{button-CAywcrhO.js → button-DN39cGqL.js}

@@ -46,29 +46,30 @@ var d = /* @__PURE__ */ r({
 			"class"
 		]));
 	}
-}), f = u("btn-pill tap-squish focus-ring whitespace-nowrap text-sm font-medium cursor-pointer active:scale-[var(--scale-press-btn)] disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-disabled [&_svg:not([class*=size-])]:size-4 [&_svg]:shrink-0 [&_svg]:pointer-events-none", {
+}), f = u("btn-pill tap-squish focus-ring whitespace-nowrap text-[length:var(--control-text)] font-medium cursor-pointer active:scale-[var(--scale-press-btn)] disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-disabled [&_svg:not([class*=size-])]:size-[var(--ui-glyph)] [&_svg]:shrink-0 [&_svg]:pointer-events-none", {
 	variants: {
 		variant: {
-			default: "bg-primary text-primary-foreground hover:bg-primary/90 active:bg-primary/80 aria-pressed:bg-primary/85",
-			"primary-audacious": "btn-audacious bg-primary text-primary-foreground hover:scale-[var(--scale-hover)] aria-pressed:scale-[var(--scale-press-btn)]",
-			"gold-audacious": "btn-audacious btn-audacious-gold text-foreground hover:text-white active:text-white aria-pressed:text-white hover:scale-[var(--scale-hover)] aria-pressed:scale-[var(--scale-press-btn)]",
+			default: "glass-wash btn-glass text-foreground hover:bg-[var(--glass-bg-resting)] hover:border-[var(--glass-border-resting)] active:bg-[var(--glass-bg-floating)] active:border-[var(--glass-border-floating)] aria-pressed:bg-[color-mix(in_srgb,var(--foreground)_10%,var(--glass-bg-resting))]",
+			solid: "bg-primary text-primary-foreground hover:bg-primary/90 active:bg-primary/80 aria-pressed:bg-primary/85",
+			"primary-audacious": "btn-audacious bg-primary text-primary-foreground hover:scale-[var(--scale-hover-btn)] aria-pressed:scale-[var(--scale-press-btn)]",
+			"gold-audacious": "btn-audacious btn-audacious-gold text-foreground hover:text-white active:text-white aria-pressed:text-white hover:scale-[var(--scale-hover-btn)] aria-pressed:scale-[var(--scale-press-btn)]",
 			destructive: "bg-destructive text-destructive-foreground hover:bg-destructive/90 active:bg-destructive/80 aria-pressed:bg-destructive/85",
 			outline: "border border-input bg-background hover:bg-accent hover:text-accent-foreground active:bg-accent/80 aria-pressed:bg-accent aria-pressed:text-accent-foreground",
 			secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80 active:bg-secondary/70 aria-pressed:bg-secondary/60",
 			accent: "bg-accent text-accent-foreground border border-border/40 hover:bg-accent/80 active:bg-accent/70 aria-pressed:bg-accent/60",
 			ghost: "bg-transparent text-foreground/70 hover:bg-foreground/8 hover:text-foreground active:bg-foreground/12 aria-pressed:bg-foreground/10 aria-pressed:text-foreground",
-			glass: "glass-wash text-foreground hover:bg-[var(--glass-bg-resting)] hover:border-[var(--glass-border-resting)] active:bg-[var(--glass-bg-floating)] active:border-[var(--glass-border-floating)] aria-pressed:bg-[color-mix(in_srgb,var(--foreground)_10%,var(--glass-bg-resting))]",
-			"glass-wash": "glass-wash text-foreground/70 hover:bg-foreground/[0.04] hover:border-[var(--surface-tint-22)] hover:text-foreground active:bg-foreground/[0.08] aria-pressed:bg-foreground/[0.1] aria-pressed:text-foreground",
+			glass: "glass-wash btn-glass text-foreground hover:bg-[var(--glass-bg-resting)] hover:border-[var(--glass-border-resting)] active:bg-[var(--glass-bg-floating)] active:border-[var(--glass-border-floating)] aria-pressed:bg-[color-mix(in_srgb,var(--foreground)_10%,var(--glass-bg-resting))]",
+			"glass-wash": "glass-wash btn-glass text-foreground/70 hover:bg-foreground/[0.04] hover:border-[var(--surface-tint-22)] hover:text-foreground active:bg-foreground/[0.08] aria-pressed:bg-foreground/[0.1] aria-pressed:text-foreground",
 			ai: "bg-amber-500/15 text-amber-700 hover:bg-amber-500/25 active:bg-amber-500/35 dark:text-amber-400 aria-pressed:bg-amber-500/30",
 			link: "text-primary underline-offset-4 hover:underline active:opacity-80 active:scale-100"
 		},
 		size: {
-			default: "h-10 px-4 py-2 has-[>svg]:px-3",
-			xs: "h-7 rounded-pill px-2 text-xs",
-			sm: "h-9 rounded-pill px-3",
-			lg: "h-11 rounded-pill px-8 has-[>svg]:px-5",
-			icon: "h-10 w-10 p-0",
-			"icon-sm": "h-7 w-7 p-0"
+			default: "h-[var(--control-h-md)] px-4 py-2 has-[>svg]:px-3",
+			xs: "h-[var(--control-h-xs)] rounded-pill px-2 text-[length:var(--control-text-sm)]",
+			sm: "h-[var(--control-h-sm)] rounded-pill px-3",
+			lg: "h-[var(--control-h-lg)] rounded-pill px-8 has-[>svg]:px-5",
+			icon: "h-[var(--control-h-md)] w-[var(--control-h-md)] p-0",
+			"icon-sm": "h-[var(--control-h-xs)] w-[var(--control-h-xs)] p-0"
 		}
 	},
 	defaultVariants: {

package/dist/button.js

@@ -1,2 +1,2 @@
-import { n as e, t } from "./button-CAywcrhO.js";
+import { n as e, t } from "./button-DN39cGqL.js";
 export { e as Button, t as buttonVariants };

package/dist/card.js

@@ -1,2 +1,2 @@
-import { a as e, i as t, n, o as r, r as i, s as a, t as o } from "./CardAction-q2qHCJFG.js";
+import { a as e, i as t, n, o as r, r as i, s as a, t as o } from "./CardAction-DuArVky-.js";
 export { a as Card, o as CardAction, i as CardContent, t as CardDescription, n as CardFooter, r as CardHeader, e as CardTitle };

package/dist/carousel.js

@@ -3,7 +3,7 @@ import { t } from "./createLucideIcon-B6uNAU9G.js";
 import { t as n } from "./chevron-down-BSkTP2aL.js";
 import { t as r } from "./chevron-right-sDM0Yvrf.js";
 import { t as i } from "./chevron-up-CCOD_FTz.js";
-import { n as a } from "./button-CAywcrhO.js";
+import { n as a } from "./button-DN39cGqL.js";
 import { t as o } from "./_plugin-vue_export-helper-ok8pgSl5.js";
 import { Fragment as s, computed as c, createBlock as l, createCommentVNode as u, createElementBlock as d, createElementVNode as f, createVNode as p, defineComponent as m, mergeProps as h, normalizeClass as g, onMounted as _, openBlock as v, ref as y, renderList as b, renderSlot as x, resolveDynamicComponent as S, toDisplayString as C, unref as w, watch as T, withCtx as E } from "vue";
 import { createInjectionState as D } from "@vueuse/core";

package/dist/color.js

@@ -1,2 +1,2 @@
-import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c } from "./color-DMLTunJK.js";
+import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c } from "./color-C5ls_QF7.js";
 export { c as cssToOklch, i as defaultBlobColorResolver, o as deriveBlobPalette, n as deriveHue, e as gamutMapStop, a as oklchStopToHex, s as oklchToGammaRgb, t as oklchToLinear, r as warmCatchLight };

package/dist/command.js

@@ -1,2 +1,2 @@
-import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c } from "./CommandShortcut-SzWRhROC.js";
+import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c } from "./CommandShortcut-CefCj5mt.js";
 export { r as Command, t as CommandDialog, s as CommandEmpty, a as CommandGroup, e as CommandInput, n as CommandItem, o as CommandList, i as CommandSeparator, c as CommandShortcut };

package/dist/{compile-BBTRjvQS.js → compile-BOXjLUxu.js}

@@ -1,15 +1,15 @@
 //#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) {
+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 aurora's samplePalette splices. tRaw is the raw inter-stop\n// parameter [0,1]; the smoothstep ease + the huePath branch live HERE so the ramp is\n// one source. increasing(2)/decreasing(3) take the OKLCh hue-arc (rainbow sweep);\n// every other method takes the OKLab-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}";
+function a(e, t, n) {
 	return Math.max(t, Math.min(n, e));
 }
-function d() {
+function o() {
 	let e = typeof window < "u" && window.devicePixelRatio || 1;
 	return Math.min(e, 2);
 }
 //#endregion
 //#region src/composables/glass/webgl/createCanvasLifecycle.ts
-function f(e) {
+function s(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;
@@ -32,7 +32,7 @@ function f(e) {
 	}
 	function v(e = "manual") {
 		let t = !o();
-		a.delete(e), t && o() && u && l && (c = performance.now() - 1e3, m());
+		a.delete(e), t && o() && u && l && (c = performance.now() - 1e3, r(), m());
 	}
 	let y = typeof document < "u";
 	function b() {
@@ -90,9 +90,9 @@ function f(e) {
 }
 //#endregion
 //#region src/composables/glass/webgl/useWebGLCanvas.ts
-function p(e, t) {
+function c(e, t) {
 	let { setup: n, contextAttrs: r } = t, i = null, a = null, o = null;
-	function s() {
+	function c() {
 		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)), {
@@ -104,41 +104,41 @@ function p(e, t) {
 			}
 		};
 	}
-	let c = null, l = null;
-	function u(e) {
-		e.preventDefault(), i = null, o = null, l?.();
+	let l = null, u = null;
+	function d(e) {
+		e.preventDefault(), i = null, o = null, u?.();
 	}
-	let d = f({
+	let f = s({
 		canvas: e,
 		mode: t.mode,
 		respectReducedMotion: t.respectReducedMotion,
-		buildContext: s,
+		buildContext: c,
 		resize: () => o?.resize(),
 		bindContextEvents: (t, n) => {
-			c = t, l = n, e.addEventListener("webglcontextlost", u, !1), e.addEventListener("webglcontextrestored", c, !1);
+			l = t, u = n, e.addEventListener("webglcontextlost", d, !1), e.addEventListener("webglcontextrestored", l, !1);
 		},
 		unbindContextEvents: () => {
-			e.removeEventListener("webglcontextlost", u, !1), c && e.removeEventListener("webglcontextrestored", c, !1);
+			e.removeEventListener("webglcontextlost", d, !1), l && e.removeEventListener("webglcontextrestored", l, !1);
 		}
 	});
 	return {
-		arm: d.arm,
-		suspend: d.suspend,
-		resume: d.resume,
-		wake: d.wake,
-		renderAt: d.renderAt,
-		dispose: d.dispose,
+		arm: f.arm,
+		suspend: f.suspend,
+		resume: f.resume,
+		wake: f.wake,
+		renderAt: f.renderAt,
+		dispose: f.dispose,
 		get gl() {
 			return i;
 		},
 		get reducedMotion() {
-			return d.reducedMotion;
+			return f.reducedMotion;
 		}
 	};
 }
 //#endregion
 //#region src/composables/glass/webgl/compile.ts
-function m(e, t, n, r = "[glass-ui:webgl]") {
+function l(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";
@@ -146,7 +146,7 @@ function m(e, t, n, r = "[glass-ui:webgl]") {
 	}
 	return i;
 }
-function h(e, t, n, r = "[glass-ui:webgl]") {
+function u(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";
@@ -155,4 +155,4 @@ function h(e, t, n, r = "[glass-ui:webgl]") {
 	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 };
+export { o as a, n as c, a as i, r as l, u as n, t as o, c as r, e as s, l as t, i as u };

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

@@ -118,8 +118,25 @@ export declare const DEFAULT_ATOMS: AuroraAtoms;
 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
- * clamped overrides, so the empty atom set resolves to exactly `DEFAULT_AURORA_CONFIG`
- * and every atom combination yields a config respecting every `budget.ts` cap.
+ * TOTAL function: clones the BASE config and applies ONLY the present atoms as clamped
+ * overrides, so the empty atom set resolves to exactly the base and every atom
+ * combination yields a config respecting every `budget.ts` cap.
+ *
+ * `base` defaults to the wispy-sky `DEFAULT_AURORA_CONFIG` (so `resolveAtoms(DEFAULT_ATOMS)`
+ * deep-equals it — the machine-asserted default-preserving contract). A consumer that
+ * REFINES a richer config (the live atoms studio seeding FROM the active preset) passes the
+ * preset config as `base`, so the ~21 non-atom fields the ≤7-knob projection does NOT carry
+ * (the hero's stroke params, the per-preset palette specifics beyond the seed) SURVIVE the
+ * atom touch — the first atom edit refines the preset rather than clobbering it to the
+ * wispy-sky default (the W-AUR-STUDIO D4 atoms-trap fix).
+ */
+export declare function resolveAtoms(atoms?: AuroraAtoms, base?: AuroraConfig): AuroraConfig;
+/**
+ * Project a full `AuroraConfig` back onto the ≤7 Tier-1 atoms. The minimal recovered
+ * set is seed / colorEnergy / zones-count / noise / medium(+amount) / motion; `harmony`
+ * and `zones.arrangement` take their door defaults (not recoverable — lossy by design).
+ * `configToAtoms(resolveAtoms(a))` recovers the energy/noise/medium/motion/zone-count
+ * axes of `a` within the projection's resolution (the round-trip the seed-from-preset
+ * fix needs + the gate asserts).
  */
-export declare function resolveAtoms(atoms?: AuroraAtoms): AuroraConfig;
+export declare function configToAtoms(cfg: AuroraConfig): AuroraAtoms;

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

@@ -72,15 +72,6 @@ export interface AuroraRuntimeOptions {
      * `instance.arm()` on the deferred path — rethrows from `arm()`.
      */
     onInitError?: (err: Error) => void;
-    /**
-     * AW.W7b — the WebGPU backend route. When a `GPUDevice` is supplied (the
-     * `resolveRenderModeAsync` probe resolved a non-fallback adapter), the runtime
-     * routes to `createGPUCanvas` drawing the SAME single-pass aurora over WebGPU;
-     * otherwise the WebGL2 fragment path is the universal fallback. `useAurora` runs
-     * the probe past first paint (the CSS placeholder paints first) and threads the
-     * device here. `null`/absent → the WebGL2 path (the zero-regression default).
-     */
-    gpuDevice?: GPUDevice | null;
 }
 /**
  * The concrete `createAurora` return shape. It IS an {@link AuroraInstance}

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

@@ -84,17 +84,6 @@ export declare function resolveStrokeModeId(cfg: AuroraConfig): number;
  * `strokeOrient` (default `"flow"`).
  */
 export declare function resolveStrokeOrientId(cfg: AuroraConfig): number;
-export declare const WGPU_UNIFORM_FLOATS = 20;
-export declare const WGPU_FIELD_FLOATS: number;
-/**
- * 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, 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/renderMode.d.ts

@@ -7,34 +7,6 @@
  * low-power / reduced-motion / save-data devices.
  */
 export type AuroraRenderMode = "webgl" | "css" | "auto";
-/**
- * AW.W7b — the resolved render SUBSTRATE after the async WebGPU probe. `"webgpu"` is
- * the capability-gated enhancement; `"webgl"` the universal fallback; `"css"` the
- * 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.
@@ -56,7 +28,3 @@ export declare const WEBGPU_PARITY = false;
  * the consumer remounts to re-evaluate, matching the deferred-arm contract).
  */
 export declare function resolveRenderMode(mode: AuroraRenderMode): "webgl" | "css";
-export declare function resolveRenderModeAsync(mode: AuroraRenderMode): Promise<{
-    substrate: AuroraSubstrate;
-    device: GPUDevice | null;
-}>;

package/dist/components/custom/aurora/constants/shaders/brush.glsl.d.ts

@@ -1 +1 @@
-export declare const AURORA_BRUSH_GLSL = "// \u2500\u2500 Curved swept brushstroke primitive \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// A stroke is a curved spine from A to B with quadratic bulge K (sideways offset\n// at midpoint). Width varies along length via a shape profile. Edge is ragged\n// (bristle-modulated), ends are rounded blobs, inside has streak modulation.\n//\n// For pixel p, we invert an approximate projection onto the curved spine:\n//   1) project p onto straight AB axis -> along0, cross0\n//   2) at parameter along0, spine offset = 4\u00B7K\u00B7along0\u00B7(1-along0) perpendicular\n//   3) cross = cross0 - spineOffset, refine along one iteration\n// Coverage blends paint atop col based on per-stroke color sampled from the\n// underlying base at spine midpoint \u2014 so overlapping strokes from different\n// palette regions meet at hard, ragged demarcations.\n\nstruct StrokeHit {\n  float coverage;  // 0..1\n  vec3  color;\n  float alongT;    // 0..1 along spine, for internal modulation\n  float crossN;    // cross distance / current half-width, signed\n  float edgeN;     // distance to edge in half-widths (0 = at edge, 1 = at spine)\n};\n\nStrokeHit noHit() { return StrokeHit(0.0, vec3(0.0), 0.0, 0.0, 0.0); }\n\nvec2 rotateDir(vec2 dir, float angle) {\n  float ca = cos(angle), sa = sin(angle);\n  return vec2(dir.x * ca - dir.y * sa, dir.x * sa + dir.y * ca);\n}\n\nvec2 safeDir(vec2 dir) {\n  float len = length(dir);\n  return len > 1e-4 ? dir / len : vec2(1.0, 0.0);\n}\n\n// Shape profile along the stroke. type:\n//   0 tapered    \u2014 thin-fat-thin (classic brush)\n//   1 load-drag  \u2014 fat start, tapers to a point\n//   2 dab        \u2014 ellipse-like, round center\n//   3 even       \u2014 near-constant, slight end taper\n//   4 comma      \u2014 van-Gogh atomic dab: ASYMMETRIC taper, fat near one end and\n//                  drawn to a fine point at the other (the divisionist crescent\n//                  mark). The width peak sits off-centre (~0.32) so the two ends\n//                  taper at DIFFERENT rates \u2014 a loaded round head + a dragged tail.\nfloat strokeShape(float t, int type) {\n  t = clamp(t, 0.0, 1.0);\n  if (type == 1) {\n    // loaded at t=0, tapering\n    return pow(1.0 - t, 0.55) * smoothstep(0.0, 0.08, t);\n  } else if (type == 2) {\n    // dab / blob\n    float d = t - 0.5;\n    return exp(-d * d * 12.0);\n  } else if (type == 3) {\n    // mostly even, slight end softening\n    return smoothstep(0.0, 0.08, t) * smoothstep(1.0, 0.92, t) * 0.95 + 0.05;\n  } else if (type == 4) {\n    // comma / crescent \u2014 width peaks at ~0.32 then drags to a fine tail. The two\n    // sides of the peak fall at different exponents (a fat round head, a long thin\n    // tail), so the mark reads as a directional van-Gogh comma, not a symmetric oval.\n    float peak = 0.32;\n    float head = smoothstep(0.0, peak, t);                            // rounded loaded head\n    float tail = pow(clamp((1.0 - t) / (1.0 - peak), 0.0, 1.0), 1.6); // dragged thin tail\n    return clamp(min(head, tail) * 1.04, 0.0, 1.0);\n  }\n  // 0 tapered\n  return smoothstep(0.0, 0.22, t) * smoothstep(1.0, 0.78, t);\n}\n\n// A single curved stroke.\n//   a, b           \u2014 endpoints\n//   halfW          \u2014 base half-width (world units)\n//   bulge          \u2014 signed perpendicular midpoint offset, in world units\n//   shapeType      \u2014 0..3\n//   bristleFreq    \u2014 spatial frequency of edge raggedness\n//   bristleAmp     \u2014 0..0.5 fraction of halfW chewed away at edge extrema\n//   streakSeed     \u2014 uniqueness seed for internal streaks\n//   colAtMid       \u2014 pre-sampled color at midpoint\nStrokeHit curvedStroke(vec2 p, vec2 a, vec2 b, float halfW,\n                       float bulge, int shapeType,\n                       float bristleFreq, float bristleAmp,\n                       float streakSeed, vec3 colAtMid) {\n  vec2 ab = b - a;\n  float L = length(ab);\n  if (L < 1e-5) return noHit();\n  vec2 tang = ab / L;\n  vec2 norm = vec2(-tang.y, tang.x);\n\n  vec2 rel = p - a;\n  float along0 = dot(rel, tang) / L;      // straight projection 0..1 along AB\n  float cross0 = dot(rel, norm);          // signed cross\n\n  // Spine sideways offset due to bulge (parabolic)\n  float bend = 4.0 * bulge * along0 * (1.0 - along0);\n  float cross1 = cross0 - bend;\n\n  // One refinement step: as the spine bends, the closest-point along shifts.\n  // Spine tangent differs from straight tangent; first-order correction:\n  float dBend = 4.0 * bulge * (1.0 - 2.0 * along0);  // d(bend)/d(along)\n  float along1 = along0 + (cross1 * dBend) / (L * (1.0 + dBend * dBend / (L * L)));\n\n  // Bristle-ragged edge: half-width gets chewed by 1D noise along the spine\n  float edgeNoise = fbm(vec2(along1 * bristleFreq, streakSeed * 7.3)) - 0.5;\n  float edgeNoise2 = fbm(vec2(along1 * bristleFreq * 2.3, streakSeed * 3.1 + 17.0)) - 0.5;\n  float edgeMod = 1.0 - bristleAmp * (0.6 + 0.4 * edgeNoise) * (0.5 + edgeNoise2);\n\n  // Width profile along the stroke\n  float shape = strokeShape(along1, shapeType);\n  float halfWNow = halfW * shape * edgeMod;\n\n  // Inside-segment coverage\n  float cov = 0.0;\n  if (along1 >= 0.0 && along1 <= 1.0 && halfWNow > 1e-6) {\n    float cn = abs(cross1) / halfWNow;\n    // fwidth-derived AA: half-width from the field's screen-space gradient so the\n    // edge holds ~1px regardless of zoom/DPR (mirrors metaball.frag.ts:252-255).\n    float aaC = max(fwidth(cn), 1e-6);\n    cov = 1.0 - smoothstep(1.0 - aaC, 1.0 + aaC, cn);\n  }\n\n  // End-cap blobs (rounded tips, not perpendicular cuts)\n  float capA = 0.0, capB = 0.0;\n  {\n    vec2 capCenterA = a + norm * (bulge * 0.0); // at a\n    vec2 capCenterB = a + tang * L + norm * bend * 0.0 + norm * 0.0; // at b; bend is 0 at endpoints\n    capCenterB = b;\n    float endShapeA = strokeShape(0.02, shapeType);\n    float endShapeB = strokeShape(0.98, shapeType);\n    float rA = halfW * endShapeA * (0.9 + 0.2 * fbm(vec2(streakSeed * 13.0)));\n    float rB = halfW * endShapeB * (0.9 + 0.2 * fbm(vec2(streakSeed * 19.0 + 5.0)));\n    float dA = length(p - capCenterA);\n    float dB = length(p - capCenterB);\n    // fwidth-derived AA on the clean Euclidean cap distances (mirrors metaball.frag.ts:252-255).\n    float aaA = max(fwidth(dA), 1e-6);\n    float aaB = max(fwidth(dB), 1e-6);\n    capA = 1.0 - smoothstep(rA - aaA, rA + aaA, dA);\n    capB = 1.0 - smoothstep(rB - aaB, rB + aaB, dB);\n    // Only apply caps if we're BEYOND the segment; otherwise the segment wins.\n    capA *= (along1 < 0.05) ? 1.0 : 0.0;\n    capB *= (along1 > 0.95) ? 1.0 : 0.0;\n  }\n\n  float coverage = max(cov, max(capA, capB));\n  if (coverage < 0.002) return noHit();\n\n  // Edge distance (for impasto later): 0 at edge, 1 at spine\n  float edgeDist = halfWNow > 1e-6 ? clamp(1.0 - abs(cross1) / halfWNow, 0.0, 1.0) : 0.0;\n\n  return StrokeHit(\n    coverage,\n    colAtMid,\n    clamp(along1, 0.0, 1.0),\n    halfWNow > 1e-6 ? cross1 / halfWNow : 0.0,\n    edgeDist\n  );\n}\n\n// The painterly STROKE mediums (those that deposit via paintStrokeLayers/paintOver):\n// oil (3), van-Gogh (5), oil-pastel (6). For these the stroke OVER-composite runs in\n// OKLab so overlapping complementaries mix through a chromatic path, not the linear-\n// RGB grey mud; the smooth/atmospheric pole never reaches paintOver so it pays nothing.\nbool isPainterlyStroke() {\n  return uMedium == 3 || uMedium == 5 || uMedium == 6;\n}\n\n// OKLab OVER-composite: lerp L,a,b of the over-color toward the under-color (the\n// Ottosson matrices spliced from procedural-color.glsl.ts \u2014 no new color math). Two\n// complementary-hued strokes overlapping transition through OKLab, where the midpoint\n// holds chroma, instead of the linear mix() that desaturates toward grey (slice 8 F2).\nvec3 paintOverOklab(vec3 under, vec3 over, float alpha) {\n  vec3 labU = linOklab(under);\n  vec3 labO = linOklab(over);\n  return max(oklabToLinearSrgb(mix(labU, labO, alpha)), vec3(0.0));\n}\n\n// Composite stroke over col with internal streaking + ACCUMULATE paint HEIGHT.\n//   streakAmp    \u2014 0..0.2 how much internal streaks darken/lighten\n//   impastoAmp   \u2014 0..1 paint-thickness contribution (the height the relight reads)\n//   hardness     \u2014 0..1 how crisp the compositing transition is (1 = razor, 0 = creamy)\n//\n// AW.W4.2 \u2014 the fixed-RGB edge rim (the phantom upper-left light) is RETIRED. Each\n// stroke now deposits PAINT HEIGHT into the height accumulator (coverage x per-stroke\n// thickness, perturbed by the bristle/streak fbm for ridges/grooves); mediumOil\n// derives a normal from the accumulated height gradient (dFdx/dFdy) and relights it\n// once with the movable uLightDir source (relightImpasto), in linear before aces().\n//\n// AX.W13 \u2014 the internal streak now perturbs HUE + CHROMA in OKLCh (not value-only),\n// so a single stroke carries a small hue gradient (broken color at the ATOM level \u2014\n// adjacent strokes shimmer like real impasto, not flat stamped swatches; slice 8 F5);\n// and the OVER-composite runs in OKLab on the painterly stroke mediums so overlapping\n// complementaries mix as pigment, not the linear-mix grey (slice 8 F2).\n//   impastoFloor \u2014 the per-stroke height-crown floor: oil's 0.4+0.6*edgeN reads\n//                  floor=0.4 (the crown tapers to 40% at the stroke edge); the van-Gogh\n//                  profile passes floor=1.0 so each atomic dab catches a FULL-height\n//                  glint (scope item 1d). The crown magnitude is floor + (1-floor)*edgeN.\nvoid paintOver(inout vec3 col, inout float height, StrokeHit s,\n               float streakFreq, float streakAmp,\n               float impastoAmp, float hardness, float streakSeed,\n               float impastoFloor) {\n  if (s.coverage < 0.002) return;\n  float strokeOpacity = clamp(uStrokeAmount, 0.0, 1.0);\n  if (strokeOpacity <= 0.001) return;\n  vec3 c = s.color;\n\n  // Internal streaks \u2014 fbm along spine, modulated by cross position. Gives\n  // the loaded-brush look: some bristles carry more pigment than others.\n  float streakA = fbm(vec2(s.alongT * streakFreq, s.crossN * 2.7 + streakSeed));\n  float streakB = fbm(vec2(s.alongT * streakFreq * 0.6 + streakSeed * 3.7, s.crossN * 4.1));\n  float streak = 0.6 * (streakA - 0.5) + 0.4 * (streakB - 0.5);\n\n  // \u2500\u2500 WITHIN-stroke OKLCh broken color (AX.W13, slice 8 F5). The streak fBm perturbs\n  // the stroke's HUE + CHROMA along alongT/crossN, seeded per-stroke, so a single\n  // stroke reads a small hue gradient (the atom-level broken-color shimmer). Value is\n  // carried by the same streak so the loaded-brush light/dark survives. Gated to the\n  // painterly stroke mediums + uBrokenColor (the smooth pole keeps the cheap value-only\n  // streak). A second decorrelated fBm drives the hue axis so hue \u2260 a scaled value.\n  float hueStreak = fbm(vec2(s.alongT * streakFreq * 0.45 + streakSeed * 5.3,\n                             s.crossN * 1.9 + streakSeed * 1.7)) - 0.5;\n  if (isPainterlyStroke() && uBrokenColor > 0.001) {\n    vec3 lch = oklabToOklch(linOklab(c));\n    // \u00B1~10\u00B0 within-stroke hue swing + \u00B1~9% chroma, scaled by uBrokenColor. Smaller\n    // than the per-stroke cell jitter (brokenColorJitter) \u2014 this is the intra-stroke\n    // gradient layered on top of the per-cell pigment patch.\n    lch.z += hueStreak * (20.0 * PI / 180.0) * uBrokenColor;\n    lch.y = max(lch.y * (1.0 + (streak) * 0.18 * uBrokenColor), 0.0);\n    c = max(oklabToLinearSrgb(oklchToOklab(lch)), vec3(0.0));\n  }\n  // Value streak (the loaded-brush light/dark across the bristles) \u2014 kept for every\n  // medium that reaches paintOver (the smooth pole never does).\n  c *= 1.0 + streak * streakAmp * 2.0;\n\n  // Subtle value variance across width (hollow-center catch-light)\n  float crossShade = smoothstep(0.0, 0.4, s.edgeN) * (1.0 - smoothstep(0.65, 1.0, s.edgeN));\n  c *= 1.0 + crossShade * 0.05;\n\n  float softLimit = mix(0.35, 0.98, hardness);\n  float alpha = smoothstep(0.0, 1.0 - softLimit, s.coverage) * strokeOpacity;\n  // OKLab OVER-composite on the painterly stroke mediums (overlap mixes as pigment,\n  // not grey); the smooth pole never reaches paintOver, so it keeps the cheap path.\n  col = isPainterlyStroke() ? paintOverOklab(col, c, alpha) : mix(col, c, alpha);\n\n  // \u2500\u2500 Accumulate paint HEIGHT (AW.W4.2). Thickness peaks at the stroke spine and\n  // falls toward the impastoFloor at the edge (edgeN: 0=edge, 1=spine), perturbed by\n  // the bristle streak so ridges/grooves form. The relight reads the gradient of this\n  // field. The van-Gogh profile's floor=1.0 gives every atomic dab a full-height crown.\n  float ridge = 0.7 + 0.3 * (streak + 0.5);\n  float crown = impastoFloor + (1.0 - impastoFloor) * s.edgeN;\n  height += s.coverage * impastoAmp * crown * ridge * alpha;\n}\n\n// AW.W4.2 \u2014 relight the accumulated paint height. Derive a normal from the height\n// gradient (dFdx/dFdy \u2014 derivatives are in-pattern; fwidth is already used for AA),\n// then apply diffuse + Blinn specular from the movable uLightDir/uLightColor source.\n// LINEAR-space lighting BEFORE aces() (the tonemap/OETF stay locked); thin strokes\n// inherit a low shininess, thick impasto raises it (high-height ridges catch a sharp\n// glint). canvasBase is the tooth height so the canvas weave also catches the light.\nvec3 relightImpasto(vec3 col, float height, float canvasBase) {\n  float h = height + canvasBase;\n  // Height-gradient normal. heightScale trades relief depth for surface flatness.\n  float heightScale = 6.0;\n  vec3 N = normalize(vec3(-dFdx(h) * 40.0, -dFdy(h) * 40.0, 1.0 / heightScale));\n  vec3 L = normalize(uLightDir);\n  vec3 V = vec3(0.0, 0.0, 1.0);            // view straight on\n  vec3 H = normalize(L + V);\n  float diff = max(dot(N, L), 0.0);\n  // Thick impasto \u2192 high shininess (sharp glint); thin paint \u2192 broad soft sheen.\n  float shininess = mix(8.0, 64.0, clamp(height * 2.0, 0.0, 1.0));\n  float spec = pow(max(dot(N, H), 0.0), shininess);\n  // Modulate the lit terms by how much paint sits here (no relief on bare ground).\n  float relief = clamp(h * 1.5, 0.0, 1.0);\n  vec3 lit = col * (1.0 + uImpasto * relief * (diff - 0.5) * 0.5 * uLightColor);\n  lit += uImpasto * relief * spec * 0.6 * uLightColor;\n  return lit;\n}\n\n// Best-of-9-neighbor placement: sample 3x3 surrounding cells and take the\n// stroke that covers this pixel most. Breaks the grid by per-cell jitter and\n// sparse density via noise thresholding.\n//   energyGrade \u2014 the SBR energy-grade magnitude (0 = none, the oil/oil-pastel\n//                 baseline; 1 = the full van-Gogh Starry-Night cascade \u2014 long\n//                 confident strokes in the lights/coherent zones, short dabs in\n//                 the darks/flat zones). The van-Gogh profile carries 1.0 (the\n//                 energy grade is a PROFILE field, not a buried uMedium==5 branch).\nStrokeHit bestOil(vec2 p, float cellSize, float lenMul, float halfWMul,\n                  float jitterAmt, float density, int shapeType,\n                  float bristleAmp, vec2 flow, float t, float seed,\n                  float energyGrade) {\n  vec2 cell = floor(p / cellSize);\n\n  StrokeHit best = noHit();\n  // 3x3 neighborhood\n  for (int dy = -1; dy <= 1; dy++) {\n    for (int dx = -1; dx <= 1; dx++) {\n      vec2 cc = cell + vec2(float(dx), float(dy));\n      vec2 hh = hash22(cc + seed) - 0.5;\n      // Density gate \u2014 noise threshold; sparse placement.\n      float gate = hash21(cc * 1.7 + seed * 0.3);\n      if (gate > density) continue;\n\n      vec2 center = (cc + 0.5 + hh * jitterAmt) * cellSize;\n\n      // Per-stroke direction source \u2014 the AW.W4.1 strokeOrient switch:\n      //   uStrokeOrient==0 (flow)   \u2014 the layer-provided hand-authored flowField.\n      //   uStrokeOrient==1 (tensor) \u2014 the structure-tensor minor eigenvector at the\n      //                               cell center (the color field's edge-tangent),\n      //                               so strokes hug the color zones (van Gogh).\n      // coh carries the per-cell coherence A for the W4.3 energy grading (long\n      // confident strokes where structure is coherent, stubby dabs in flat zones).\n      vec2 f;\n      float coh = 1.0;\n      if (uStrokeOrient == 1) {\n        vec3 tf = structureTensorField(center, t, safeDir(flow));\n        f = safeDir(tf.xy);\n        coh = tf.z;\n      } else {\n        f = safeDir(flow);\n      }\n      // Per-stroke deterministic local perturbation so alternate stroke layers stay\n      // live. Tensor strokes get LESS angular jitter (the field already orients them).\n      float jScale = (uStrokeOrient == 1) ? 0.4 : 1.0;\n      float angJ = (hash21(cc + seed + 11.0) - 0.5) * 0.9 * jScale;  // +/- 0.45/0.18 rad\n      float localCurl = (fbm(center * (2.6 + seed * 0.11) + seed * 1.9) - 0.5) * 0.55 * uFlowCurl;\n      vec2 dir = rotateDir(f, angJ + localCurl);\n\n      // AX.W13 \u2014 the SBR energy grade is a PROFILE field (energyGrade), not a buried\n      // uMedium==5 branch. The van-Gogh profile passes energyGrade=1.0 (the full\n      // Starry-Night cascade); oil/oil-pastel pass 0.0 (uniform length). The grade\n      // modulates stroke length by local luminance (bright \u2192 long confident strokes,\n      // dark \u2192 short dabs, the Kolmogorov/Batchelor congruence) AND by coherence\n      // (coherent zones \u2192 long, flat \u2192 stubby), lerped in by energyGrade so a profile\n      // can dial the cascade from off (0) to full (1).\n      float energy = 1.0;\n      if (energyGrade > 0.001) {\n        float luma = clamp(dot(sampleBase(center, t), W_LUMA), 0.0, 1.0);\n        float graded = mix(0.5, 1.5, luma) * mix(0.6, 1.0, coh);\n        energy = mix(1.0, graded, energyGrade);\n      }\n\n      float lenV = cellSize * lenMul * (0.65 + 0.55 * hash21(cc + seed + 23.0)) * energy;\n      float halfW = cellSize * halfWMul * (0.70 + 0.55 * hash21(cc + seed + 41.0));\n      float bulge = (hash21(cc + seed + 53.0) - 0.5) * lenV * 0.35;\n\n      vec2 a = center - dir * (lenV * 0.5);\n      vec2 b = center + dir * (lenV * 0.5);\n\n      vec3 colMid = brokenColorJitter(\n        sampleBase(center, t),\n        hash21(cc + seed + 89.0),\n        hash21(cc * 2.3 + seed + 97.0),\n        1.0\n      );\n\n      StrokeHit h = curvedStroke(p, a, b, halfW, bulge, shapeType,\n                                 7.0, bristleAmp,\n                                 hash21(cc + seed + 67.0), colMid);\n      if (h.coverage > best.coverage) best = h;\n    }\n  }\n  return best;\n}\n";
+export declare const AURORA_BRUSH_GLSL = "// \u2500\u2500 Curved swept brushstroke primitive \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// A stroke is a curved spine from A to B with quadratic bulge K (sideways offset\n// at midpoint). Width varies along length via a shape profile. Edge is ragged\n// (bristle-modulated), ends are rounded blobs, inside has streak modulation.\n//\n// For pixel p, we invert an approximate projection onto the curved spine:\n//   1) project p onto straight AB axis -> along0, cross0\n//   2) at parameter along0, spine offset = 4\u00B7K\u00B7along0\u00B7(1-along0) perpendicular\n//   3) cross = cross0 - spineOffset, refine along one iteration\n// Coverage blends paint atop col based on per-stroke color sampled from the\n// underlying base at spine midpoint \u2014 so overlapping strokes from different\n// palette regions meet at hard, ragged demarcations.\n\nstruct StrokeHit {\n  float coverage;  // 0..1\n  vec3  color;\n  float alongT;    // 0..1 along spine, for internal modulation\n  float crossN;    // cross distance / current half-width, signed\n  float edgeN;     // distance to edge in half-widths (0 = at edge, 1 = at spine)\n};\n\nStrokeHit noHit() { return StrokeHit(0.0, vec3(0.0), 0.0, 0.0, 0.0); }\n\nvec2 rotateDir(vec2 dir, float angle) {\n  float ca = cos(angle), sa = sin(angle);\n  return vec2(dir.x * ca - dir.y * sa, dir.x * sa + dir.y * ca);\n}\n\nvec2 safeDir(vec2 dir) {\n  float len = length(dir);\n  return len > 1e-4 ? dir / len : vec2(1.0, 0.0);\n}\n\n// Shape profile along the stroke. type:\n//   0 tapered    \u2014 thin-fat-thin (classic brush)\n//   1 load-drag  \u2014 fat start, tapers to a point\n//   2 dab        \u2014 ellipse-like, round center\n//   3 even       \u2014 near-constant, slight end taper\n//   4 comma      \u2014 van-Gogh atomic dab: ASYMMETRIC taper, fat near one end and\n//                  drawn to a fine point at the other (the divisionist crescent\n//                  mark). The width peak sits off-centre (~0.32) so the two ends\n//                  taper at DIFFERENT rates \u2014 a loaded round head + a dragged tail.\nfloat strokeShape(float t, int type) {\n  t = clamp(t, 0.0, 1.0);\n  if (type == 1) {\n    // loaded at t=0, tapering\n    return pow(1.0 - t, 0.55) * smoothstep(0.0, 0.08, t);\n  } else if (type == 2) {\n    // dab / blob\n    float d = t - 0.5;\n    return exp(-d * d * 12.0);\n  } else if (type == 3) {\n    // mostly even, slight end softening\n    return smoothstep(0.0, 0.08, t) * smoothstep(1.0, 0.92, t) * 0.95 + 0.05;\n  } else if (type == 4) {\n    // comma / crescent \u2014 width peaks at ~0.32 then drags to a fine tail. The two\n    // sides of the peak fall at different exponents (a fat round head, a long thin\n    // tail), so the mark reads as a directional van-Gogh comma, not a symmetric oval.\n    float peak = 0.32;\n    float head = smoothstep(0.0, peak, t);                            // rounded loaded head\n    float tail = pow(clamp((1.0 - t) / (1.0 - peak), 0.0, 1.0), 1.6); // dragged thin tail\n    return clamp(min(head, tail) * 1.04, 0.0, 1.0);\n  }\n  // 0 tapered\n  return smoothstep(0.0, 0.22, t) * smoothstep(1.0, 0.78, t);\n}\n\n// A single curved stroke.\n//   a, b           \u2014 endpoints\n//   halfW          \u2014 base half-width (world units)\n//   bulge          \u2014 signed perpendicular midpoint offset, in world units\n//   shapeType      \u2014 0..3\n//   bristleFreq    \u2014 spatial frequency of edge raggedness\n//   bristleAmp     \u2014 0..0.5 fraction of halfW chewed away at edge extrema\n//   streakSeed     \u2014 uniqueness seed for internal streaks\n//   colAtMid       \u2014 pre-sampled color at midpoint\nStrokeHit curvedStroke(vec2 p, vec2 a, vec2 b, float halfW,\n                       float bulge, int shapeType,\n                       float bristleFreq, float bristleAmp,\n                       float streakSeed, vec3 colAtMid) {\n  vec2 ab = b - a;\n  float L = length(ab);\n  if (L < 1e-5) return noHit();\n  vec2 tang = ab / L;\n  vec2 norm = vec2(-tang.y, tang.x);\n\n  vec2 rel = p - a;\n  float along0 = dot(rel, tang) / L;      // straight projection 0..1 along AB\n  float cross0 = dot(rel, norm);          // signed cross\n\n  // Spine sideways offset due to bulge (parabolic)\n  float bend = 4.0 * bulge * along0 * (1.0 - along0);\n  float cross1 = cross0 - bend;\n\n  // One refinement step: as the spine bends, the closest-point along shifts.\n  // Spine tangent differs from straight tangent; first-order correction:\n  float dBend = 4.0 * bulge * (1.0 - 2.0 * along0);  // d(bend)/d(along)\n  float along1 = along0 + (cross1 * dBend) / (L * (1.0 + dBend * dBend / (L * L)));\n\n  // Bristle-ragged edge: half-width gets chewed by 1D noise along the spine\n  float edgeNoise = fbm(vec2(along1 * bristleFreq, streakSeed * 7.3)) - 0.5;\n  float edgeNoise2 = fbm(vec2(along1 * bristleFreq * 2.3, streakSeed * 3.1 + 17.0)) - 0.5;\n  float edgeMod = 1.0 - bristleAmp * (0.6 + 0.4 * edgeNoise) * (0.5 + edgeNoise2);\n\n  // Width profile along the stroke\n  float shape = strokeShape(along1, shapeType);\n  float halfWNow = halfW * shape * edgeMod;\n\n  // Inside-segment coverage\n  float cov = 0.0;\n  if (along1 >= 0.0 && along1 <= 1.0 && halfWNow > 1e-6) {\n    float cn = abs(cross1) / halfWNow;\n    // fwidth-derived AA: half-width from the field's screen-space gradient so the\n    // edge holds ~1px regardless of zoom/DPR (mirrors metaball.frag.ts:252-255).\n    float aaC = max(fwidth(cn), 1e-6);\n    cov = 1.0 - smoothstep(1.0 - aaC, 1.0 + aaC, cn);\n  }\n\n  // End-cap blobs (rounded tips, not perpendicular cuts)\n  float capA = 0.0, capB = 0.0;\n  {\n    vec2 capCenterA = a + norm * (bulge * 0.0); // at a\n    vec2 capCenterB = a + tang * L + norm * bend * 0.0 + norm * 0.0; // at b; bend is 0 at endpoints\n    capCenterB = b;\n    float endShapeA = strokeShape(0.02, shapeType);\n    float endShapeB = strokeShape(0.98, shapeType);\n    float rA = halfW * endShapeA * (0.9 + 0.2 * fbm(vec2(streakSeed * 13.0)));\n    float rB = halfW * endShapeB * (0.9 + 0.2 * fbm(vec2(streakSeed * 19.0 + 5.0)));\n    float dA = length(p - capCenterA);\n    float dB = length(p - capCenterB);\n    // fwidth-derived AA on the clean Euclidean cap distances (mirrors metaball.frag.ts:252-255).\n    float aaA = max(fwidth(dA), 1e-6);\n    float aaB = max(fwidth(dB), 1e-6);\n    capA = 1.0 - smoothstep(rA - aaA, rA + aaA, dA);\n    capB = 1.0 - smoothstep(rB - aaB, rB + aaB, dB);\n    // Only apply caps if we're BEYOND the segment; otherwise the segment wins.\n    capA *= (along1 < 0.05) ? 1.0 : 0.0;\n    capB *= (along1 > 0.95) ? 1.0 : 0.0;\n  }\n\n  float coverage = max(cov, max(capA, capB));\n  if (coverage < 0.002) return noHit();\n\n  // Edge distance (for impasto later): 0 at edge, 1 at spine\n  float edgeDist = halfWNow > 1e-6 ? clamp(1.0 - abs(cross1) / halfWNow, 0.0, 1.0) : 0.0;\n\n  return StrokeHit(\n    coverage,\n    colAtMid,\n    clamp(along1, 0.0, 1.0),\n    halfWNow > 1e-6 ? cross1 / halfWNow : 0.0,\n    edgeDist\n  );\n}\n\n// The painterly STROKE mediums (those that deposit via paintStrokeLayers/paintOver):\n// oil (3), van-Gogh (5), oil-pastel (6). For these the stroke OVER-composite runs in\n// OKLab so overlapping complementaries mix through a chromatic path, not the linear-\n// RGB grey mud; the smooth/atmospheric pole never reaches paintOver so it pays nothing.\nbool isPainterlyStroke() {\n  return uMedium == 3 || uMedium == 5 || uMedium == 6;\n}\n\n// OKLab OVER-composite: lerp L,a,b of the over-color toward the under-color (the\n// Ottosson matrices spliced from procedural-color.glsl.ts \u2014 no new color math). Two\n// complementary-hued strokes overlapping transition through OKLab, where the midpoint\n// holds chroma, instead of the linear mix() that desaturates toward grey (slice 8 F2).\nvec3 paintOverOklab(vec3 under, vec3 over, float alpha) {\n  vec3 labU = linOklab(under);\n  vec3 labO = linOklab(over);\n  return max(oklabToLinearSrgb(mix(labU, labO, alpha)), vec3(0.0));\n}\n\n// Composite stroke over col with internal streaking + ACCUMULATE paint HEIGHT.\n//   streakAmp    \u2014 0..0.2 how much internal streaks darken/lighten\n//   impastoAmp   \u2014 0..1 paint-thickness contribution (the height the relight reads)\n//   hardness     \u2014 0..1 how crisp the compositing transition is (1 = razor, 0 = creamy)\n//\n// AW.W4.2 \u2014 the fixed-RGB edge rim (the phantom upper-left light) is RETIRED. Each\n// stroke now deposits PAINT HEIGHT into the height accumulator (coverage x per-stroke\n// thickness, perturbed by the bristle/streak fbm for ridges/grooves); mediumOil\n// derives a normal from the accumulated height gradient (dFdx/dFdy) and relights it\n// once with the movable uLightDir source (relightImpasto), in linear before aces().\n//\n// AX.W13 \u2014 the internal streak now perturbs HUE + CHROMA in OKLCh (not value-only),\n// so a single stroke carries a small hue gradient (broken color at the ATOM level \u2014\n// adjacent strokes shimmer like real impasto, not flat stamped swatches; slice 8 F5);\n// and the OVER-composite runs in OKLab on the painterly stroke mediums so overlapping\n// complementaries mix as pigment, not the linear-mix grey (slice 8 F2).\n//   impastoFloor \u2014 the per-stroke height-crown floor: oil's 0.4+0.6*edgeN reads\n//                  floor=0.4 (the crown tapers to 40% at the stroke edge); the van-Gogh\n//                  profile passes floor=1.0 so each atomic dab catches a FULL-height\n//                  glint (scope item 1d). The crown magnitude is floor + (1-floor)*edgeN.\nvoid paintOver(inout vec3 col, inout float height, StrokeHit s,\n               float streakFreq, float streakAmp,\n               float impastoAmp, float hardness, float streakSeed,\n               float impastoFloor) {\n  if (s.coverage < 0.002) return;\n  float strokeOpacity = clamp(uStrokeAmount, 0.0, 1.0);\n  if (strokeOpacity <= 0.001) return;\n  vec3 c = s.color;\n\n  // Internal streaks \u2014 fbm along spine, modulated by cross position. Gives\n  // the loaded-brush look: some bristles carry more pigment than others.\n  float streakA = fbm(vec2(s.alongT * streakFreq, s.crossN * 2.7 + streakSeed));\n  float streakB = fbm(vec2(s.alongT * streakFreq * 0.6 + streakSeed * 3.7, s.crossN * 4.1));\n  float streak = 0.6 * (streakA - 0.5) + 0.4 * (streakB - 0.5);\n\n  // \u2500\u2500 WITHIN-stroke OKLCh broken color (AX.W13, slice 8 F5). The streak fBm perturbs\n  // the stroke's HUE + CHROMA along alongT/crossN, seeded per-stroke, so a single\n  // stroke reads a small hue gradient (the atom-level broken-color shimmer). Value is\n  // carried by the same streak so the loaded-brush light/dark survives. Gated to the\n  // painterly stroke mediums + uBrokenColor (the smooth pole keeps the cheap value-only\n  // streak). A second decorrelated fBm drives the hue axis so hue \u2260 a scaled value.\n  float hueStreak = fbm(vec2(s.alongT * streakFreq * 0.45 + streakSeed * 5.3,\n                             s.crossN * 1.9 + streakSeed * 1.7)) - 0.5;\n  if (isPainterlyStroke() && uBrokenColor > 0.001) {\n    vec3 lch = oklabToOklch(linOklab(c));\n    // \u00B1~10\u00B0 within-stroke hue swing + \u00B1~9% chroma, scaled by uBrokenColor. Smaller\n    // than the per-stroke cell jitter (brokenColorJitter) \u2014 this is the intra-stroke\n    // gradient layered on top of the per-cell pigment patch.\n    lch.z += hueStreak * (20.0 * PI / 180.0) * uBrokenColor;\n    lch.y = max(lch.y * (1.0 + (streak) * 0.18 * uBrokenColor), 0.0);\n    c = max(oklabToLinearSrgb(oklchToOklab(lch)), vec3(0.0));\n  }\n  // Value streak (the loaded-brush light/dark across the bristles) \u2014 kept for every\n  // medium that reaches paintOver (the smooth pole never does). The along-spine value\n  // modulation is the loaded-brush light/dark that gives each stroke its OWN directional\n  // luminance band \u2014 the structure-tensor signal a low-contrast color field (a uniform-hue\n  // oil field) has no other source for (the \u00A74.2 anisotropy lift on the flat-palette case).\n  c *= 1.0 + streak * streakAmp * 3.2;\n\n  // Cross-stroke ridge/valley shading \u2014 a catch-light along the spine centre, darkening to\n  // the stroke edges. This is the strongest DIRECTIONAL luminance cue: it carves a bright\n  // ridge down the stroke's length and dark grooves between adjacent strokes, so a field of\n  // parallel strokes reads as parallel light/dark bands (the high-A van-Gogh signature) even\n  // where the underlying colour is flat. s.edgeN is 0 at the edge, 1 at the spine.\n  float ridgeShade = smoothstep(0.0, 0.55, s.edgeN);\n  c *= 1.0 + (ridgeShade - 0.5) * 0.30;\n\n  float softLimit = mix(0.35, 0.98, hardness);\n  float alpha = smoothstep(0.0, 1.0 - softLimit, s.coverage) * strokeOpacity;\n  // OKLab OVER-composite on the painterly stroke mediums (overlap mixes as pigment,\n  // not grey); the smooth pole never reaches paintOver, so it keeps the cheap path.\n  col = isPainterlyStroke() ? paintOverOklab(col, c, alpha) : mix(col, c, alpha);\n\n  // \u2500\u2500 Accumulate paint HEIGHT (AW.W4.2). Thickness peaks at the stroke spine and\n  // falls toward the impastoFloor at the edge (edgeN: 0=edge, 1=spine), perturbed by\n  // the bristle streak so ridges/grooves form. The relight reads the gradient of this\n  // field. The van-Gogh profile's floor=1.0 gives every atomic dab a full-height crown.\n  float ridge = 0.7 + 0.3 * (streak + 0.5);\n  float crown = impastoFloor + (1.0 - impastoFloor) * s.edgeN;\n  height += s.coverage * impastoAmp * crown * ridge * alpha;\n}\n\n// AW.W4.2 \u2014 relight the accumulated paint height. Derive a normal from the height\n// gradient (dFdx/dFdy \u2014 derivatives are in-pattern; fwidth is already used for AA),\n// then apply diffuse + Blinn specular from the movable uLightDir/uLightColor source.\n// LINEAR-space lighting BEFORE aces() (the tonemap/OETF stay locked); thin strokes\n// inherit a low shininess, thick impasto raises it (high-height ridges catch a sharp\n// glint). canvasBase is the tooth height so the canvas weave also catches the light.\nvec3 relightImpasto(vec3 col, float height, float canvasBase) {\n  float h = height + canvasBase;\n  // Height-gradient normal. heightScale trades relief depth for surface flatness.\n  float heightScale = 6.0;\n  vec3 N = normalize(vec3(-dFdx(h) * 40.0, -dFdy(h) * 40.0, 1.0 / heightScale));\n  vec3 L = normalize(uLightDir);\n  vec3 V = vec3(0.0, 0.0, 1.0);            // view straight on\n  vec3 H = normalize(L + V);\n  float diff = max(dot(N, L), 0.0);\n  // Thick impasto \u2192 high shininess (sharp glint); thin paint \u2192 broad soft sheen.\n  float shininess = mix(8.0, 64.0, clamp(height * 2.0, 0.0, 1.0));\n  float spec = pow(max(dot(N, H), 0.0), shininess);\n  // Modulate the lit terms by how much paint sits here (no relief on bare ground).\n  float relief = clamp(h * 1.5, 0.0, 1.0);\n  vec3 lit = col * (1.0 + uImpasto * relief * (diff - 0.5) * 0.5 * uLightColor);\n  // The specular glint is gated to ACCUMULATED-thick paint (height\u00B2) \u2014 a per-fine-stroke\n  // sharp glint on every thin fill dab read as bright isotropic SPECKLE that buried the\n  // directional stroke bands (the \u00A74.2 anisotropy / \u00A74.3 slope sink on the low-contrast\n  // oil field). Only where real impasto has built up does the raked glint fire, so the\n  // highlight tracks the macro ridges, not the fine speckle.\n  float specGate = clamp(height, 0.0, 1.0);\n  lit += uImpasto * relief * spec * specGate * 0.5 * uLightColor;\n  return lit;\n}\n\n// Best-of-9-neighbor placement: sample 3x3 surrounding cells and take the\n// stroke that covers this pixel most. Breaks the grid by per-cell jitter and\n// sparse density via noise thresholding.\n//   energyGrade \u2014 the SBR energy-grade magnitude (0 = none, the oil/oil-pastel\n//                 baseline; 1 = the full van-Gogh Starry-Night cascade \u2014 long\n//                 confident strokes in the lights/coherent zones, short dabs in\n//                 the darks/flat zones). The van-Gogh profile carries 1.0 (the\n//                 energy grade is a PROFILE field, not a buried uMedium==5 branch).\nStrokeHit bestOil(vec2 p, float cellSize, float lenMul, float halfWMul,\n                  float jitterAmt, float density, int shapeType,\n                  float bristleAmp, vec2 flow, float t, float seed,\n                  float energyGrade) {\n  vec2 cell = floor(p / cellSize);\n\n  StrokeHit best = noHit();\n  // 3x3 neighborhood\n  for (int dy = -1; dy <= 1; dy++) {\n    for (int dx = -1; dx <= 1; dx++) {\n      vec2 cc = cell + vec2(float(dx), float(dy));\n      vec2 hh = hash22(cc + seed) - 0.5;\n      // Density gate \u2014 noise threshold; sparse placement.\n      float gate = hash21(cc * 1.7 + seed * 0.3);\n      if (gate > density) continue;\n\n      vec2 center = (cc + 0.5 + hh * jitterAmt) * cellSize;\n\n      // Per-stroke direction source \u2014 the AW.W4.1 strokeOrient switch:\n      //   uStrokeOrient==0 (flow)   \u2014 the layer-provided hand-authored flowField.\n      //   uStrokeOrient==1 (tensor) \u2014 the structure-tensor minor eigenvector at the\n      //                               cell center (the color field's edge-tangent),\n      //                               so strokes hug the color zones (van Gogh).\n      // coh carries the per-cell coherence A for the W4.3 energy grading (long\n      // confident strokes where structure is coherent, stubby dabs in flat zones).\n      vec2 f;\n      float coh = 1.0;\n      if (uStrokeOrient == 1) {\n        vec3 tf = structureTensorField(center, t, safeDir(flow));\n        f = safeDir(tf.xy);\n        coh = tf.z;\n      } else {\n        f = safeDir(flow);\n      }\n      // Per-stroke deterministic local perturbation so alternate stroke layers stay\n      // live. Tensor strokes get FAR less angular jitter (the field already orients them\n      // \u2014 over-jittering the tensor strokes scatters their directions and the rendered\n      // field reads isotropic, the \u00A74.2 anisotropy floor). The flow-oriented (non-tensor)\n      // strokes keep the full jitter (they have no per-cell orientation source).\n      float jScale = (uStrokeOrient == 1) ? 0.15 : 1.0;\n      float angJ = (hash21(cc + seed + 11.0) - 0.5) * 0.9 * jScale;  // +/- 0.45/0.07 rad\n      float curlScale = (uStrokeOrient == 1) ? 0.30 : 1.0;\n      float localCurl = (fbm(center * (2.6 + seed * 0.11) + seed * 1.9) - 0.5) * 0.55 * uFlowCurl * curlScale;\n      vec2 dir = rotateDir(f, angJ + localCurl);\n\n      // AX.W13 \u2014 the SBR energy grade is a PROFILE field (energyGrade), not a buried\n      // uMedium==5 branch. The van-Gogh profile passes energyGrade=1.0 (the full\n      // Starry-Night cascade); oil/oil-pastel pass 0.0 (uniform length). The grade\n      // modulates stroke length by local luminance (bright \u2192 long confident strokes,\n      // dark \u2192 short dabs, the Kolmogorov/Batchelor congruence) AND by coherence\n      // (coherent zones \u2192 long, flat \u2192 stubby), lerped in by energyGrade so a profile\n      // can dial the cascade from off (0) to full (1).\n      float energy = 1.0;\n      if (energyGrade > 0.001) {\n        float luma = clamp(dot(sampleBase(center, t), W_LUMA), 0.0, 1.0);\n        float graded = mix(0.5, 1.5, luma) * mix(0.6, 1.0, coh);\n        energy = mix(1.0, graded, energyGrade);\n      }\n\n      float lenV = cellSize * lenMul * (0.65 + 0.55 * hash21(cc + seed + 23.0)) * energy;\n      float halfW = cellSize * halfWMul * (0.70 + 0.55 * hash21(cc + seed + 41.0));\n      float bulge = (hash21(cc + seed + 53.0) - 0.5) * lenV * 0.35;\n\n      vec2 a = center - dir * (lenV * 0.5);\n      vec2 b = center + dir * (lenV * 0.5);\n\n      vec3 colMid = brokenColorJitter(\n        sampleBase(center, t),\n        hash21(cc + seed + 89.0),\n        hash21(cc * 2.3 + seed + 97.0),\n        1.0\n      );\n\n      StrokeHit h = curvedStroke(p, a, b, halfW, bulge, shapeType,\n                                 7.0, bristleAmp,\n                                 hash21(cc + seed + 67.0), colMid);\n      if (h.coverage > best.coverage) best = h;\n    }\n  }\n  return best;\n}\n";