@mkbabb/glass-ui 6.0.0 → 7.0.0

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

@@ -1 +1 @@
-export declare const AURORA_WGSL = "\nconst MAX_NUCLEI: i32 = 6;\nconst MAX_STOPS: i32 = 8;\nconst PI: f32 = 3.141592653589793;\n\n// \u2500\u2500 Uniforms (the typed-struct source-of-truth \u2014 see aurora.wgsl.uniforms.ts) \u2500\u2500\n// Scalars are packed into vec4 lanes to keep the std140/WGSL 16-byte struct alignment\n// trivial. nuc0[i] = (pos.x, pos.y, radius, paletteBias); nuc1[i] = (valueBias,\n// driftRadius, driftPhase, elong); nuc2[i] = (angle, _, _, _). palette[i].rgb is the\n// CPU-baked linear-sRGB stop.\nstruct Uniforms {\n  // scalars0: (uTime, uSoftmaxBeta, uValueVariance, uWarpAmount)\n  scalars0: vec4<f32>,\n  // scalars1: (uWarpScale, uWarpDrift, uSaturation, uPaperGrain)\n  scalars1: vec4<f32>,\n  // scalars2: (uAlpha, uNucleiDrift, uPaletteDrift, uBreathDepth)\n  scalars2: vec4<f32>,\n  // scalars3: (uBreathPeriod, uCursorStrength, uCursorRadius, uVividness)\n  // BD.W-AUR-VIVIDNESS \u2014 the .w pad lane now carries the \u00A73 chroma-floor strength.\n  scalars3: vec4<f32>,\n  // cursor: (uCursor.x, uCursor.y, uMetalPolish, uMetalHeightScale)\n  // BG.W-AUR-METAL-FINISH \u2014 the two free pad lanes carry the metal-medium knobs (the\n  // metal light is cursor-synthesized so it reads in-struct on the WGSL primary too).\n  cursor: vec4<f32>,\n  // ints: (uStopCount, uNucleiCount, uWarpMode, uNoiseOctaves)\n  ints0: vec4<i32>,\n  // ints1: (uMedium, uHuePath, _, _)\n  ints1: vec4<i32>,\n  palette: array<vec4<f32>, 8>,\n  nuc0: array<vec4<f32>, 6>,\n  nuc1: array<vec4<f32>, 6>,\n  nuc2: array<vec4<f32>, 6>,\n  // BC.W-VIZ-AURORA (T4) \u2014 the painterly-medium scalar lanes. APPENDED after the\n  // arrays so EVERY existing offset (and the smooth-default parity capture) is\n  // byte-identical (these lanes are written 0 on a smooth config). scalars4:\n  // (uStrokeAmount, uStrokeScale, uStrokeAnisotropy, uCanvasGrain). scalars5:\n  // (uWetEdge, uGranulation, uBrokenColor, uKuwaharaQ). kuwahara: (uKuwaharaRadius,\n  // uKuwaharaSectors, _, _) \u2014 the Kuwahara radius/sectors/q in lockstep with\n  // packAuroraWGPUUniforms (the typed-struct discipline).\n  scalars4: vec4<f32>,\n  scalars5: vec4<f32>,\n  kuwahara: vec4<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u: Uniforms;\n\n// \u2500\u2500 Authoring-scale \u2192 rad/sec lifts (byte-identical to aurora.frag.ts) \u2500\u2500\nconst K_NUCLEI: f32 = 14.0;\nconst K_PAL: f32 = 24.0;\nconst K_WARP: f32 = 5.0;\n\n// \u2500\u2500 Noise (aurora-local hash21/vnoise/fbm \u2014 legitimately divergent per AV.W2 \u00A73a) \u2500\u2500\nfn hash21(p0: vec2<f32>) -> f32 {\n  var p = fract(p0 * vec2<f32>(123.34, 456.21));\n  p = p + dot(p, p + 45.32);\n  return fract(p.x * p.y);\n}\n\nfn hash22(p0: vec2<f32>) -> vec2<f32> {\n  let p = vec2<f32>(dot(p0, vec2<f32>(127.1, 311.7)),\n                    dot(p0, vec2<f32>(269.5, 183.3)));\n  return fract(sin(p) * 43758.5453);\n}\n\nfn vnoise(p: vec2<f32>) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let uu = f * f * (3.0 - 2.0 * f);\n  let a = hash21(i);\n  let b = hash21(i + vec2<f32>(1.0, 0.0));\n  let c = hash21(i + vec2<f32>(0.0, 1.0));\n  let d = hash21(i + vec2<f32>(1.0, 1.0));\n  return mix(mix(a, b, uu.x), mix(c, d, uu.x), uu.y);\n}\n\nconst FBM_ROT: mat2x2<f32> = mat2x2<f32>(0.8, 0.6, -0.6, 0.8);\n\nfn fbm(p0: vec2<f32>) -> f32 {\n  var v = 0.0;\n  var a = 0.5;\n  var p = p0;\n  let octaves = u.ints0.w;\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\n\nfn srgbToLinearCh(c: f32) -> f32 {\n  if (c <= 0.04045) { return c / 12.92; }\n  return pow((c + 0.055) / 1.055, 2.4);\n}\nfn srgbToLinear(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\n\nfn linearToSrgbCh(c: f32) -> f32 {\n  if (c <= 0.0031308) { return c * 12.92; }\n  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\nfn linearToSrgb(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}\n\n// value.js LINEAR_SRGB_TO_LMS, row-major \u2192 WGSL columns (= the transpose).\nconst LINEAR_SRGB_TO_LMS: mat3x3<f32> = mat3x3<f32>(\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\u2192OKLab coefficients, row-major \u2192 WGSL columns.\nconst LMS_TO_OKLAB: mat3x3<f32> = mat3x3<f32>(\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, row-major \u2192 WGSL columns.\nconst OKLAB_TO_LMS: mat3x3<f32> = mat3x3<f32>(\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, row-major \u2192 WGSL columns.\nconst LMS_TO_LINEAR_SRGB: mat3x3<f32> = mat3x3<f32>(\n  4.0767416621, -1.2684380046, -0.0041960863,\n  -3.3077115913, 2.6097574011, -0.7034186147,\n  0.2309699292, -0.3413193965, 1.7076147010\n);\n\nfn cbrt3(v: vec3<f32>) -> vec3<f32> {\n  return sign(v) * pow(abs(v), vec3<f32>(1.0 / 3.0));\n}\n\n// Gamma sRGB \u2192 raw OKLab (L, a, b). Mirrors value.js srgbToOKLab.\nfn srgbToOklab(c: vec3<f32>) -> vec3<f32> {\n  let lin = srgbToLinear(c);\n  let lms = LINEAR_SRGB_TO_LMS * lin;\n  return LMS_TO_OKLAB * cbrt3(lms);\n}\n\n// Raw OKLab (L, a, b) \u2192 linear sRGB. Mirrors value.js oklabToLinearSRGB.\nfn oklabToLinearSrgb(lab: vec3<f32>) -> vec3<f32> {\n  let lms_ = OKLAB_TO_LMS * lab;\n  let lms = lms_ * lms_ * lms_;\n  return LMS_TO_LINEAR_SRGB * lms;\n}\n\n// OKLab \u2192 OKLCh: H in RADIANS, folded to [0, 2pi). Mirrors value.js rawOklabToOklch.\nfn oklabToOklch(lab: vec3<f32>) -> vec3<f32> {\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 vec3<f32>(lab.x, C, H);\n}\n\n// OKLCh (H radians) \u2192 OKLab. Mirrors value.js rawOklchToOklab.\nfn oklchToOklab(lch: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}\n\n// value.js interpolateHue in the NORMALIZED-TURNS domain. methods: 0 shorter,\n// 1 longer, 2 increasing, 3 decreasing.\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  var r = a + t * (b - a);\n  r = fract(r);                   // fract is non-negative in WGSL\n  return r * TAU;                 // back to radians\n}\n\n// Linear-sRGB endpoint pair \u2192 OKLab-rectangular interpolation \u2192 linear sRGB.\nfn mixPaletteOklab(linA: vec3<f32>, linB: vec3<f32>, t: f32) -> vec3<f32> {\n  let labA = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * linA);\n  let labB = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * linB);\n  let lab = mix(labA, labB, t);\n  return oklabToLinearSrgb(lab);\n}\n\n// Linear-sRGB endpoint pair \u2192 OKLCh hue-arc interpolation \u2192 linear sRGB.\nfn mixPaletteOklchArc(linA: vec3<f32>, linB: vec3<f32>, t: f32, method: i32) -> vec3<f32> {\n  let labA = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * linA);\n  let labB = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * linB);\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(vec3<f32>(L, C, H)));\n}\n\n// The ramp dispatcher (the samplePalette splices it). 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; every other method\n// takes the OKLab-rectangular straight line.\nfn samplePaletteRamp(a: vec3<f32>, b: vec3<f32>, tRaw: f32, huePath: i32) -> vec3<f32> {\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// Interleaved Gradient Noise (Jimenez) \u2014 display-space 1-LSB dither.\nfn ign(p: vec2<f32>) -> f32 {\n  return fract(52.9829189 * fract(dot(p, vec2<f32>(0.06711056, 0.00583715))));\n}\n\n// Cellular / Worley f1.\nfn cellular(p: vec2<f32>) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  var m = 1e9;\n  for (var y = -1; y <= 1; y = y + 1) {\n    for (var x = -1; x <= 1; x = x + 1) {\n      let g = vec2<f32>(f32(x), f32(y));\n      let o = hash22(i + g);\n      let r = g + o - f;\n      m = min(m, dot(r, r));\n    }\n  }\n  return sqrt(m);\n}\n\n// \u2500\u2500 Warp (Quilez double warp + the three warp modes + the cursor swirl) \u2500\u2500\nfn domainWarp(p: vec2<f32>, t: f32) -> vec2<f32> {\n  let warpScale = u.scalars1.x;\n  let warpDrift = u.scalars1.y;\n  let warpAmount = u.scalars0.w;\n  let warpMode = u.ints0.z;\n  let cursorStrength = u.scalars3.y;\n  let cursorRadius = u.scalars3.z;\n  let cursor = u.cursor.xy;\n\n  let q = vec2<f32>(fbm(p * warpScale + vec2<f32>(0.0, 0.0) + t * warpDrift * K_WARP),\n                    fbm(p * warpScale + vec2<f32>(5.2, 1.3) + t * warpDrift * K_WARP));\n  let r = vec2<f32>(fbm(p * warpScale + 4.0 * q + vec2<f32>(1.7, 9.2)),\n                    fbm(p * warpScale + 4.0 * q + vec2<f32>(8.3, 2.8)));\n\n  var warp = r;\n  if (warpMode == 1) {\n    // cellular \u2014 chunky territories\n    let c1 = cellular(p * warpScale * 1.5 + vec2<f32>(t * warpDrift * K_WARP * 2.0, 0.0));\n    let c2 = cellular(p * warpScale * 1.5 + vec2<f32>(11.0, 7.0 + t * warpDrift * K_WARP * 2.0));\n    warp = vec2<f32>(c1, c2);\n  } else if (warpMode == 2) {\n    // hybrid \u2014 fbm + cellular averaged\n    let c1 = cellular(p * warpScale * 1.2);\n    let c2 = cellular(p * warpScale * 1.2 + vec2<f32>(11.0, 7.0));\n    warp = mix(r, vec2<f32>(c1, c2), 0.5);\n  }\n  var warped = p + warpAmount * warp;\n\n  // Cursor swirl \u2014 rotate p around the cursor with radial falloff.\n  if (cursorStrength > 0.001) {\n    let toP = p - cursor;\n    let d = length(toP);\n    let rr = max(cursorRadius, 0.01);\n    let w = exp(-(d * d) / (rr * rr * 0.45));\n    let ang = w * cursorStrength * 2.1;\n    let ca = cos(ang);\n    let sa = sin(ang);\n    var rotated = vec2<f32>(ca * toP.x - sa * toP.y, sa * toP.x + ca * toP.y) + cursor;\n    let pinch = w * cursorStrength * 0.08;\n    rotated = mix(rotated, cursor, pinch);\n    warped = mix(warped, rotated + warpAmount * warp * 0.7, w * cursorStrength);\n  }\n  return warped;\n}\n\n// \u2500\u2500 Palette LUT \u2500\u2500\nfn samplePalette(id0: f32) -> vec3<f32> {\n  let id = clamp(id0, 0.0, 1.0);\n  let stopCount = u.ints0.x;\n  let scaled = id * f32(stopCount - 1);\n  let i0 = i32(floor(scaled));\n  let i1 = min(i0 + 1, stopCount - 1);\n  let t = fract(scaled);\n  return samplePaletteRamp(u.palette[i0].rgb, u.palette[i1].rgb, t, u.ints1.y);\n}\n\n// \u2500\u2500 Nuclei field (anisotropic Gaussian softmax + drift + palette drift) \u2500\u2500\nstruct NucleiResult { paletteId: f32, valueMod: f32 };\n\nfn nucleiField(p: vec2<f32>, t: f32) -> NucleiResult {\n  let nucleiCount = u.ints0.y;\n  let nucleiDrift = u.scalars2.y;\n  let paletteDrift = u.scalars2.z;\n  let softmaxBeta = u.scalars0.y;\n\n  var accumBias = 0.0;\n  var accumValue = 0.0;\n  var accumW = 0.0;\n  for (var i = 0; i < MAX_NUCLEI; i = i + 1) {\n    if (i >= nucleiCount) { break; }\n    let n0 = u.nuc0[i];   // pos.x, pos.y, radius, paletteBias\n    let n1 = u.nuc1[i];   // valueBias, driftRadius, driftPhase, elong\n    let angle = u.nuc2[i].x;\n    let driftRadius = n1.y;\n    let driftPhase = n1.z;\n    let posI = n0.xy + driftRadius * vec2<f32>(\n      cos(t * nucleiDrift * K_NUCLEI + driftPhase),\n      sin(t * nucleiDrift * K_NUCLEI + driftPhase * 1.13)\n    );\n    let diff = p - posI;\n    let ca = cos(angle);\n    let sa = sin(angle);\n    let local = vec2<f32>(ca * diff.x + sa * diff.y, -sa * diff.x + ca * diff.y);\n    let along = local.x / max(n1.w, 0.01);\n    let across = local.y;\n    let d2 = along * along + across * across;\n    let r = max(n0.z, 0.01);\n    let w = exp(-softmaxBeta * d2 / (r * r));\n    accumBias = accumBias + w * n0.w;\n    accumValue = accumValue + w * n1.x;\n    accumW = accumW + w;\n  }\n  var paletteId = accumBias / max(accumW, 1e-4);\n  let valueMod = accumValue / max(accumW, 1e-4);\n\n  let palAmp = clamp(paletteDrift * 6.0, 0.0, 0.06);\n  paletteId = paletteId + palAmp * sin(t * paletteDrift * K_PAL);\n  paletteId = clamp(paletteId, 0.0, 1.0);\n  return NucleiResult(paletteId, valueMod);\n}\n\n// \u2500\u2500 Color utils (OKLCh saturation) \u2500\u2500\nfn linOklab(lin: vec3<f32>) -> vec3<f32> {\n  let lms = LINEAR_SRGB_TO_LMS * lin;\n  return LMS_TO_OKLAB * cbrt3(lms);\n}\n\nfn saturate3(c: vec3<f32>, amt: f32) -> vec3<f32> {\n  var lch = oklabToOklch(linOklab(c));\n  lch.y = max(lch.y * amt, 0.0);\n  return max(oklabToLinearSrgb(oklchToOklab(lch)), vec3<f32>(0.0));\n}\n\n// BD.W-AUR-VIVIDNESS \u2014 the \u00A73 chroma FLOOR, the WGSL twin of the GLSL vividnessFloor.\n// OKLab chroma lifted toward the floor, hue + L preserved; below VIVID_EPS the (a,b)\n// direction is precision noise so the lift synthesizes along the WARM anchor (amber,\n// both components positive) \u2014 never teal/navy. vividness (scalars3.w) == 0 is a no-op\n// (the byte-identity opt-out). Mode factor lifts a dim field a touch (read through glass).\nconst VIVID_TARGET: f32 = 0.115;\nconst VIVID_EPS: f32 = 0.012;\nconst VIVID_WARM_ANCHOR: vec2<f32> = vec2<f32>(0.34202, 0.93969);\nfn vividnessFloor(c: vec3<f32>, vividness: f32) -> vec3<f32> {\n  if (vividness <= 0.0001) { return c; }\n  var lab = linOklab(c);\n  let C = length(lab.yz);\n  let modeLift = mix(1.18, 1.0, clamp(lab.x * 1.4, 0.0, 1.0));\n  let Cmin = vividness * VIVID_TARGET * modeLift;\n  var hueDir = VIVID_WARM_ANCHOR;\n  if (C > VIVID_EPS) { hueDir = lab.yz / C; }\n  let yz = hueDir * max(C, Cmin);\n  lab = vec3<f32>(lab.x, yz.x, yz.y);\n  return max(oklabToLinearSrgb(lab), vec3<f32>(0.0));\n}\n\n// \u2500\u2500 PBR-Neutral tonemap (named aces() in the GLSL \u2014 the tonemap slot) \u2500\u2500\nfn aces(color0: vec3<f32>) -> vec3<f32> {\n  let startCompression = 0.8 - 0.04;\n  let desaturation = 0.15;\n  var color = color0;\n  let x = min(color.r, min(color.g, color.b));\n  var offset = 0.04;\n  if (x < 0.08) { offset = x - 6.25 * x * x; }\n  color = color - offset;\n  let peak = max(color.r, max(color.g, color.b));\n  if (peak < startCompression) { return clamp(color, vec3<f32>(0.0), vec3<f32>(1.0)); }\n  let d = 1.0 - startCompression;\n  let newPeak = 1.0 - d * d / (peak + d - startCompression);\n  color = color * (newPeak / peak);\n  let g = 1.0 - 1.0 / (desaturation * (peak - newPeak) + 1.0);\n  return clamp(mix(color, newPeak * vec3<f32>(1.0), g), vec3<f32>(0.0), vec3<f32>(1.0));\n}\n\n// \u2500\u2500 BC.W-VIZ-AURORA (T4) \u2014 the painterly-medium bodies (the keystone WGSL port) \u2500\u2500\n// Spliced HERE, after every helper the mediums consume is defined (domainWarp,\n// nucleiField, samplePalette, linOklab, saturate3, oklabToOklch/oklchToOklab,\n// hash21/vnoise/fbm) and before the vertex/fragment stages. applyMedium(col,p,t)\n// is the dispatch the fragment stage calls.\n\n// \u2500\u2500 Painterly luma + medium scalar accessors \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\nconst W_LUMA: vec3<f32> = vec3<f32>(0.2126, 0.7152, 0.0722);\n\nfn mStrokeAmount() -> f32 { return u.scalars4.x; }\nfn mStrokeScale() -> f32 { return u.scalars4.y; }\nfn mStrokeAnisotropy() -> f32 { return u.scalars4.z; }\nfn mCanvasGrain() -> f32 { return u.scalars4.w; }\nfn mWetEdge() -> f32 { return u.scalars5.x; }\nfn mGranulation() -> f32 { return u.scalars5.y; }\nfn mBrokenColor() -> f32 { return u.scalars5.z; }\nfn mKuwaharaQ() -> f32 { return u.scalars5.w; }\nfn mKuwaharaRadius() -> f32 { return u.kuwahara.x; }\n// BG.W-AUR-METAL-FINISH \u2014 the metal-medium knobs ride the FREE cursor.z/.w pad lanes\n// (uniformBridgeWGPU packs them; written 0 on a non-metal config \u2192 no-op). These read\n// the IN-STRUCT cursor \u2014 the metal light is cursor-synthesized so it crosses to WGSL\n// (a phantom uLightDir read would be flat on the primary \u2014 uLightDir is .frag-only).\nfn mMetalPolish() -> f32 { return u.cursor.z; }\nfn mMetalHeightScale() -> f32 { return u.cursor.w; }\n\n// \u2500\u2500 Gradient pack (BG.W-AUR-METAL-FINISH; the WGSL twin) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// structureTensorField re-plumbs its already-computed luma gradient (Gx,Gy) out\n// through the return's .w lane so the metal medium pays ZERO extra taps. 12 bits per\n// bounded component ([-4,4]) into one f32; the crayon/kuwahara callers read only .xy/.z.\nfn packGrad(gx: f32, gy: f32) -> f32 {\n  let qx = floor(clamp(gx * 0.125 + 0.5, 0.0, 1.0) * 4095.0);\n  let qy = floor(clamp(gy * 0.125 + 0.5, 0.0, 1.0) * 4095.0);\n  return qx + qy * 4096.0;\n}\nfn unpackGrad(packed: f32) -> vec2<f32> {\n  let qy = floor(packed * (1.0 / 4096.0));\n  let qx = packed - qy * 4096.0;\n  return (vec2<f32>(qx, qy) * (1.0 / 4095.0) - 0.5) * 8.0;\n}\n\n// \u2500\u2500 Base color re-sample (the edge-mask operator the mediums Sobel/sector-sample) \u2500\u2500\n// The WGSL twin of mediums.glsl.ts sampleBase: warp -> nuclei field -> palette -> value.\nfn sampleBase(p: vec2<f32>, t: f32) -> vec3<f32> {\n  let pw = domainWarp(p, t);\n  let nf = nucleiField(pw, t);\n  var c = samplePalette(nf.paletteId);\n  c = c * (1.0 + u.scalars0.z * nf.valueMod);\n  return c;\n}\n\n// \u2500\u2500 Broken color (hue + chroma jitter at constant OKLCh L) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nfn brokenColorJitter(c: vec3<f32>, hueSeed: f32, valueSeed: f32, strength: f32) -> vec3<f32> {\n  let amt = clamp(mBrokenColor() * strength, 0.0, 1.0);\n  if (amt <= 0.001) { return c; }\n  var lch = oklabToOklch(linOklab(c));\n  lch.z = lch.z + (hueSeed - 0.5) * (32.0 * PI / 180.0) * amt;\n  lch.y = max(lch.y * (1.0 + (valueSeed - 0.5) * 0.28 * amt), 0.0);\n  return max(oklabToLinearSrgb(oklchToOklab(lch)), vec3<f32>(0.0));\n}\n\n// \u2500\u2500 Structure-tensor / edge-tangent-flow (AW.W4.1; the WGSL twin) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// Returns vec4(tangent.x, tangent.y, A, packGrad(Gx,Gy)) \u2014 the minor-eigenvector\n// edge-tangent + coherence + the metal medium's packed gradient (BG.W-AUR-METAL-FINISH;\n// the .xy/.z crayon/kuwahara callers are byte-unchanged).\nfn structureTensorField(p: vec2<f32>, t: f32, fallbackDir: vec2<f32>) -> vec4<f32> {\n  let e = 0.0035;\n  let l00 = dot(sampleBase(p + vec2<f32>(-e, -e), t), W_LUMA);\n  let l10 = dot(sampleBase(p + vec2<f32>(0.0, -e), t), W_LUMA);\n  let l20 = dot(sampleBase(p + vec2<f32>( e, -e), t), W_LUMA);\n  let l01 = dot(sampleBase(p + vec2<f32>(-e, 0.0), t), W_LUMA);\n  let l21 = dot(sampleBase(p + vec2<f32>( e, 0.0), t), W_LUMA);\n  let l02 = dot(sampleBase(p + vec2<f32>(-e, e), t), W_LUMA);\n  let l12 = dot(sampleBase(p + vec2<f32>(0.0, e), t), W_LUMA);\n  let l22 = dot(sampleBase(p + vec2<f32>( e, e), t), W_LUMA);\n  let Gx = (l20 + 2.0 * l21 + l22) - (l00 + 2.0 * l01 + l02);\n  let Gy = (l02 + 2.0 * l12 + l22) - (l00 + 2.0 * l10 + l20);\n  let Jxx = Gx * Gx;\n  let Jyy = Gy * Gy;\n  let Jxy = Gx * Gy;\n  let tr = Jxx + Jyy;\n  let disc = sqrt(max((Jxx - Jyy) * (Jxx - Jyy) + 4.0 * Jxy * Jxy, 0.0));\n  let lambdaMaj = 0.5 * (tr + disc);\n  let lambdaMin = 0.5 * (tr - disc);\n  var tangent: vec2<f32>;\n  if (disc < 1e-7) {\n    tangent = fallbackDir;\n  } else {\n    let theta = 0.5 * atan2(2.0 * Jxy, Jxx - Jyy);\n    tangent = vec2<f32>(-sin(theta), cos(theta));\n  }\n  var A = (lambdaMaj - lambdaMin) / (lambdaMaj + lambdaMin + 1e-6);\n  A = clamp(A, 0.0, 1.0);\n  if (dot(tangent, fallbackDir) < 0.0) { tangent = -tangent; }\n  let blendW = pow(A, 0.28);\n  let dir = normalize(mix(fallbackDir, tangent, blendW) + vec2<f32>(1e-6, 1e-6));\n  return vec4<f32>(dir, A, packGrad(Gx, Gy));\n}\n\n// \u2500\u2500 Flow field (the WGSL twin \u2014 the simple flow seed the medium fallback dirs use) \u2500\u2500\nfn flowField(p: vec2<f32>, t: f32) -> vec2<f32> {\n  // Curl-noise-driven swirl (the medium-default dir; the full radial/swirl/diagonal\n  // dispatch rides uniforms the WGSL struct does not carry \u2014 the procedural mediums\n  // use this multi/curl seed as the fallback the structure tensor relaxes toward).\n  let n = fbm(p * 2.0 + vec2<f32>(t * 0.02, t * 0.02));\n  let a = n * 6.2831853;\n  var dir = vec2<f32>(cos(a), sin(a));\n  // Cursor swirl bias (matches the GLSL flow cursor term \u2014 the steady attraction).\n  let cursorStrength = u.scalars3.y;\n  let cursorRadius = u.scalars3.z;\n  let cursor = u.cursor.xy;\n  if (cursorStrength > 0.001) {\n    let toCur = cursor - p;\n    let d = length(toCur);\n    let r = max(cursorRadius, 0.01);\n    let w = exp(-(d * d) / (r * r * 0.5));\n    let tangent = vec2<f32>(-toCur.y, toCur.x) / max(d, 1e-4);\n    let a0 = atan2(dir.y, dir.x);\n    let a1 = atan2(tangent.y, tangent.x);\n    var da = a1 - a0;\n    da = atan2(sin(da), cos(da));\n    let aa = a0 + da * w * cursorStrength;\n    dir = vec2<f32>(cos(aa), sin(aa));\n  }\n  return dir;\n}\n\n// \u2500\u2500 Watercolor \u2014 wet-edge cauliflowers + granulation + wash banding \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nfn mediumWatercolor(col0: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {\n  var col = col0;\n  let eps = 0.004;\n  let cx1 = sampleBase(p + vec2<f32>(eps, 0.0), t);\n  let cx2 = sampleBase(p - vec2<f32>(eps, 0.0), t);\n  let cy1 = sampleBase(p + vec2<f32>(0.0, eps), t);\n  let cy2 = sampleBase(p - vec2<f32>(0.0, eps), t);\n  let gx = dot(cx1 - cx2, W_LUMA);\n  let gy = dot(cy1 - cy2, W_LUMA);\n  let edge = sqrt(gx * gx + gy * gy) / (2.0 * eps);\n  let mask = smoothstep(0.0, 2.5, edge);\n  col = col * mix(1.0, 0.78, mask * mWetEdge());\n\n  let paper = 0.5 * vnoise(p * 160.0) + 0.5 * vnoise(p * 360.0);\n  let pigLoad = 1.0 - dot(col, W_LUMA);\n  col = col * (1.0 - mGranulation() * pigLoad * (paper - 0.5));\n\n  let band = fbm(vec2<f32>(p.x * 1.5, p.y * 0.4));\n  col = col * (1.0 + 0.04 * (band - 0.5));\n  return col;\n}\n\n// \u2500\u2500 Pastel \u2014 anisotropic stroke noise along the flow + tooth grain \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nfn mediumPastel(col0: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {\n  var col = col0;\n  let flow = flowField(p, t);\n  let perp = vec2<f32>(-flow.y, flow.x);\n  let strokeScale = mStrokeScale();\n  let along = dot(p, flow) * strokeScale;\n  var across = dot(p, perp) * strokeScale;\n  across = across + 0.03 * (vnoise(p * 260.0) - 0.5);\n\n  let aniso = mix(1.0, 0.18, mStrokeAnisotropy());\n  let stroke = fbm(vec2<f32>(along * aniso, across));\n  col = col * mix(1.0, 0.82 + 0.32 * stroke, mStrokeAmount());\n\n  let tooth = vnoise(p * 800.0);\n  col = col * (1.0 - 0.08 * mStrokeAmount() * (tooth - 0.5));\n  return col;\n}\n\n// \u2500\u2500 Crayon \u2014 DRY wax pigment on paper tooth (the tooth-multiply + scumble) \u2500\u2500\nfn mediumCrayon(col0: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {\n  let flow = structureTensorField(p, t, flowField(p, t)).xy;\n  let ang = atan2(flow.y, flow.x);\n  let ca = cos(-ang);\n  let sa = sin(-ang);\n  let pr = vec2<f32>(p.x * ca - p.y * sa, p.x * sa + p.y * ca);\n\n  let aniso = mix(0.45, 0.95, mStrokeAnisotropy());\n  let scale = max(mStrokeScale() * 1.6, 180.0);\n\n  let t1 = vnoise(vec2<f32>(pr.x * scale * aniso, pr.y * scale));\n  let t2 = vnoise(vec2<f32>(pr.x * scale * aniso * 0.4, pr.y * scale * 0.4) + vec2<f32>(11.0, 11.0));\n  let t3 = vnoise(vec2<f32>(pr.x * scale * aniso * 2.1, pr.y * scale * 2.1) + vec2<f32>(23.0, 23.0));\n  let tooth = 0.55 * t1 + 0.30 * t2 + 0.15 * t3;\n\n  let pressure = clamp(mStrokeAmount(), 0.0, 1.0);\n  let bite = mix(0.18, 0.46, pressure);\n  var result = col0 * (1.0 - bite * (0.5 - tooth));\n\n  let scumbleMask = smoothstep(0.42, 0.78, vnoise(vec2<f32>(pr.x * scale * 0.55, pr.y * scale * 0.22) + vec2<f32>(7.0, 7.0)));\n  let scumbleCoverage = scumbleMask * pressure * 0.7;\n  let paper = col0 * mix(0.80, 0.94, pressure);\n  result = mix(paper, result, scumbleCoverage);\n\n  let pigmentCell = floor(pr * max(scale * 0.18, 32.0));\n  let pigmentMask = smoothstep(0.28, 0.82, vnoise(pr * scale * 0.21 + vec2<f32>(19.0, 19.0)));\n  result = brokenColorJitter(\n    result,\n    hash21(pigmentCell + vec2<f32>(17.0, 17.0)),\n    hash21(pigmentCell * 2.1 + vec2<f32>(31.0, 31.0)),\n    0.45 + 0.55 * pigmentMask\n  );\n\n  result = saturate3(result, 1.08);\n  return result;\n}\n\n// \u2500\u2500 Kuwahara \u2014 the SOFT anisotropic generalized Kuwahara painterly finish \u2500\u2500\u2500\u2500\n// THE KEYSTONE (Kyprianidis 2010). Aurora is a PROCEDURAL field (no input texture) so the\n// operator runs over sampleBase directly: an elliptical kernel oriented along the structure\n// tensor (elongated along the edge-tangent, narrowed across by the anisotropy), 8 OVERLAPPING\n// sectors via SMOOTH gaussian-angular weights, blended by 1/(1+var^q) (the SOFT criterion \u2192\n// no 8-spoke pinwheel by construction). 4 rings \u00D7 8 angular taps = 32 procedural samples.\nfn mediumKuwahara(col0: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {\n  let stf = structureTensorField(p, t, flowField(p, t));\n  let tangent = stf.xy;\n  let A = stf.z;\n  // The studio knob drives the patch radius; clamp into the procedural patch band.\n  let radius = clamp(mKuwaharaRadius() + mStrokeScale() * 0.00018, 0.006, 0.024);\n  let aniso = mix(1.0, 0.34, clamp(A, 0.0, 1.0));\n  let ax = tangent;\n  let ay = vec2<f32>(-tangent.y, tangent.x);\n\n  // Per-sector weighted sums (8 sectors). WGSL has no runtime-indexed local arrays of\n  // vectors as cleanly as GLSL, so unroll the sector accumulators explicitly.\n  var mSum: array<vec3<f32>, 8>;\n  var sSum: array<vec3<f32>, 8>;\n  var wSum: array<f32, 8>;\n  for (var i = 0; i < 8; i = i + 1) {\n    mSum[i] = vec3<f32>(0.0);\n    sSum[i] = vec3<f32>(0.0);\n    wSum[i] = 0.0;\n  }\n\n  let RINGS = 4;\n  let TAPS = 8;\n  for (var r = 1; r <= RINGS; r = r + 1) {\n    let rr = f32(r) / f32(RINGS);\n    let radial = 1.0 - 0.6 * rr;\n    for (var a = 0; a < TAPS; a = a + 1) {\n      let ang = 6.2831853 * f32(a) / f32(TAPS);\n      let dirE = ax * cos(ang) + ay * (sin(ang) * aniso);\n      let off = dirE * (radius * rr);\n      let c = sampleBase(p + off, t);\n      for (var k = 0; k < 8; k = k + 1) {\n        let sectorAng = 6.2831853 * f32(k) / 8.0;\n        var d = ang - sectorAng;\n        d = atan2(sin(d), cos(d));\n        let sw = exp(-d * d * 2.2) * radial;\n        mSum[k] = mSum[k] + c * sw;\n        sSum[k] = sSum[k] + c * c * sw;\n        wSum[k] = wSum[k] + sw;\n      }\n    }\n  }\n\n  let q = max(mKuwaharaQ(), 1.0);\n  var accum = vec3<f32>(0.0);\n  var accumW = 0.0;\n  for (var k = 0; k < 8; k = k + 1) {\n    let wk = max(wSum[k], 1e-4);\n    let mean = mSum[k] / wk;\n    let var3 = max(sSum[k] / wk - mean * mean, vec3<f32>(0.0));\n    let variance = dot(var3, W_LUMA);\n    let sectorW = 1.0 / (1.0 + pow(variance * 320.0, q));\n    accum = accum + mean * sectorW;\n    accumW = accumW + sectorW;\n  }\n  var result = accum / max(accumW, 1e-4);\n\n  // Anchor in near-flat zones so the smoothing only bites at edges.\n  let center = sampleBase(p, t);\n  result = mix(center, result, clamp(0.35 + 0.65 * A, 0.0, 1.0));\n\n  // Faint canvas tooth + pigment-saturation so the flattened patches read as oil paint.\n  let tooth = vnoise(p * 300.0) - 0.5;\n  result = result * (1.0 + tooth * 0.06 * mCanvasGrain());\n  result = saturate3(result, 1.04);\n\n  return mix(col0, result, clamp(mStrokeAmount(), 0.0, 1.0));\n}\n\n// \u2500\u2500 Metal \u2014 the two-term anisotropic BRDF (uMedium==8/9; the WGSL twin) \u2500\u2500\u2500\u2500\u2500\u2500\n// The field re-lights as warm folded metal: the luma HEIGHT field (the packed\n// structure-tensor gradient \u2192 the surface normal) catches an anisotropic Blinn streak\n// (brushed metal, running ALONG the coherent edge-tangent) plus a sharp crest, both\n// raked by the IN-STRUCT cursor-synth light (crosses to WGSL \u2014 never uLightDir). The\n// catch is the achromatic-warm anchor (never a cold chrome-blue). ZERO extra taps \u2014\n// the gradient is unpacked from the tensor's .w lane the caller already computed.\nconst METAL_CATCH_WARM: vec3<f32> = vec3<f32>(1.0, 0.97, 0.90);\nconst METAL_HEIGHT_SCALE: f32 = 2.2;\nconst METAL_LIGHT_Z: f32 = 0.55;\nconst METAL_IDLE_RAKE: vec2<f32> = vec2<f32>(0.32, 0.34);\nconst METAL_SHININESS_ANISO: f32 = 6.0;\nconst METAL_SHININESS_CREST: f32 = 40.0;\nconst METAL_COHERENCE_FLOOR: f32 = 0.22;\nconst METAL_BODY_FLOOR: f32 = 0.42;\nconst METAL_GRADIENT_FLATTEN: f32 = 0.55;\nconst METAL_SPARKLE_DENSITY: f32 = 240.0;\nconst METAL_SPARKLE_THRESH: f32 = 0.72;\nconst METAL_SPARKLE_AMP: f32 = 0.6;\n\nfn metalShade(baseCol: vec3<f32>, p: vec2<f32>, stf: vec4<f32>) -> vec3<f32> {\n  let tangent = stf.xy;\n  let A = stf.z;\n  let grad = unpackGrad(stf.w);\n  let N = normalize(vec3<f32>(grad * (METAL_HEIGHT_SCALE * mMetalHeightScale()), 1.0));\n  let V = vec3<f32>(0.0, 0.0, 1.0);\n  // Cursor-synth rake light (u.cursor is in-struct \u2014 crosses to WGSL).\n  let L = normalize(vec3<f32>((u.cursor.xy - p) + METAL_IDLE_RAKE, METAL_LIGHT_Z));\n  let H = normalize(L + V);\n  // Anisotropic streak \u2014 brushed metal along the edge-tangent.\n  let tH = dot(normalize(tangent), H.xy);\n  let sinTH = sqrt(clamp(1.0 - tH * tH, 0.0, 1.0));\n  let streak = pow(clamp(sinTH, 0.0, 1.0), METAL_SHININESS_ANISO);\n  let crest = pow(clamp(dot(N, H), 0.0, 1.0), METAL_SHININESS_CREST);\n  var spec = streak * crest;\n  spec = spec * smoothstep(0.0, METAL_COHERENCE_FLOOR, A);\n  // Technicolor valley base \u2014 the body keeps the FIELD hue; luma rides the relief.\n  let diff = clamp(dot(N, L), 0.0, 1.0);\n  let body = baseCol * (METAL_BODY_FLOOR + (1.0 - METAL_BODY_FLOOR) * diff);\n  return body + METAL_CATCH_WARM * (spec * clamp(mMetalPolish(), 0.0, 4.0));\n}\n\nfn mediumMetal(col: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {\n  let stf = structureTensorField(p, t, flowField(p, t));\n  return metalShade(col, p, stf);\n}\n\n// metal-gradient (uMedium==9) \u2014 the SAME BRDF over a pre-flattened base + the\n// twinkle-in-place flake sparkle (position FIXED per cell, phase-animated, facing-gated).\nfn mediumMetalGradient(col: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {\n  let stf = structureTensorField(p, t, flowField(p, t));\n  let flat = mix(col, vec3<f32>(dot(col, W_LUMA)), METAL_GRADIENT_FLATTEN);\n  var metal = metalShade(flat, p, stf);\n  let grad = unpackGrad(stf.w);\n  let facing = normalize(vec3<f32>(grad * (METAL_HEIGHT_SCALE * mMetalHeightScale()), 1.0)).z;\n  let cell = floor(p * METAL_SPARKLE_DENSITY);\n  let seed = hash21(cell);\n  let tw = pow(clamp(sin(t + seed * 6.2831853), 0.0, 1.0), 40.0);\n  let flakeGate = step(METAL_SPARKLE_THRESH, seed);\n  metal = metal + METAL_CATCH_WARM * (tw * flakeGate * clamp(facing, 0.0, 1.0) * METAL_SPARKLE_AMP);\n  return metal;\n}\n\n// \u2500\u2500 Medium dispatch (the WGSL twin of the GLSL main() if-ladder) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// uMedium: 0 smooth \u00B7 1 pastel \u00B7 2 watercolor \u00B7 3 oil \u00B7 4 crayon \u00B7 5 vangogh \u00B7\n// 6 oil-pastel \u00B7 7 kuwahara \u00B7 8 metal \u00B7 9 metal-gradient. The cheap peer mediums\n// (pastel/watercolor/crayon) + kuwahara + metal port their own bodies; the\n// oil/vangogh/oil-pastel STROKE cascade renders the anisotropic-Kuwahara PAINTERLY\n// finish here (a real oil-paint read, never the smooth core \u2014 the \"NO FALLBACKS on\n// Safari\" mandate; the full per-dab Starry-Night stroke WGSL is the booked\n// W-AURORA-WGPU-MEDIUMS-STROKES tail).\nfn applyMedium(col: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {\n  let medium = u.ints1.x;\n  if (medium == 1) { return mediumPastel(col, p, t); }\n  if (medium == 2) { return mediumWatercolor(col, p, t); }\n  if (medium == 4) { return mediumCrayon(col, p, t); }\n  // BG.W-AUR-METAL-FINISH \u2014 metal DUAL-PORTS (a .frag-only metal is invisible on the\n  // WGSL primary of both browsers); 8 metal, 9 metal-gradient.\n  if (medium == 8) { return mediumMetal(col, p, t); }\n  if (medium == 9) { return mediumMetalGradient(col, p, t); }\n  // oil(3) / vangogh(5) / oil-pastel(6) / kuwahara(7) all render the painterly\n  // anisotropic-Kuwahara finish on the WGSL primary (the WebGL2 fallback carries the\n  // full per-dab stroke cascade for oil/vangogh/oil-pastel).\n  if (medium == 3 || medium == 5 || medium == 6 || medium == 7) {\n    return mediumKuwahara(col, p, t);\n  }\n  return col;\n}\n\n\n// \u2500\u2500 Full-screen triangle vertex stage (the pilot idiom \u2014 no vertex buffer) \u2500\u2500\nstruct VSOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) uv: vec2<f32>,\n};\n\n@vertex\nfn vs_main(@builtin(vertex_index) vi: u32) -> VSOut {\n  // NDC corners of the covering triangle (-1,-1), (3,-1), (-1,3).\n  var p = vec2<f32>(-1.0, -1.0);\n  if (vi == 1u) { p = vec2<f32>(3.0, -1.0); }\n  else if (vi == 2u) { p = vec2<f32>(-1.0, 3.0); }\n  var out: VSOut;\n  out.pos = vec4<f32>(p, 0.0, 1.0);\n  // vUv = aPos * 0.5 + 0.5 (the aurora.vert convention).\n  out.uv = p * 0.5 + 0.5;\n  return out;\n}\n\n// \u2500\u2500 Fragment stage (the main() transcription) \u2500\u2500\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4<f32> {\n  let t = u.scalars0.x;\n  let valueVariance = u.scalars0.z;\n  let breathDepth = u.scalars2.w;\n  let breathPeriod = u.scalars3.x;\n  let saturation = u.scalars1.z;\n  let paperGrain = u.scalars1.w;\n  let alpha = u.scalars2.x;\n  let vividness = u.scalars3.w;\n\n  let uv = in.uv;\n  let pN = uv;\n\n  let p_warp = domainWarp(pN, t);\n\n  let nf = nucleiField(p_warp, t);\n  var col = samplePalette(nf.paletteId);\n  col = col * (1.0 + valueVariance * nf.valueMod);\n\n  // Breath \u2014 slow global luminance wobble.\n  let breath = sin(t * 6.2831 / max(breathPeriod, 1.0));\n  col = col * (1.0 + breathDepth * breath * 0.5);\n\n  // BC.W-VIZ-AURORA (T4) \u2014 the painterly-medium dispatch. uMedium 0 (smooth) is a\n  // no-op pass-through so the DEFAULT smooth config is byte-identical to the prior\n  // WGSL primary (the parity capture); uMedium 1-7 render the ported painterly\n  // bodies (pastel/watercolor/crayon/kuwahara) or the anisotropic-Kuwahara finish\n  // (oil/vangogh/oil-pastel) \u2014 never a silent smooth degrade on Safari 26.\n  col = applyMedium(col, pN, t);\n\n  // Saturation trim.\n  col = saturate3(col, saturation);\n\n  // BD.W-AUR-VIVIDNESS \u2014 the \u00A73 chroma floor (warm-anchored, hue-preserving). The WGSL\n  // twin of the GLSL call; vividness:0 is a no-op so the smooth/pale default stays gated.\n  col = vividnessFloor(col, vividness);\n\n  // Tonemap + film grain.\n  col = aces(col);\n  // gl_FragCoord.xy \u2192 the device-pixel position (the WGSL @builtin(position)).\n  let fragCoord = in.pos.xy;\n  let grain = hash21(fragCoord + t * 17.0);\n  col = col + (grain - 0.5) * paperGrain;\n\n  col = clamp(col * 0.985 + 0.008, vec3<f32>(0.0), vec3<f32>(1.0));\n\n  // MANDATORY OETF \u2014 closes the seam (the whole pipeline above runs in LINEAR).\n  col = linearToSrgb(col);\n\n  // 1-LSB triangular IGN dither in DISPLAY space, AFTER the OETF.\n  col = col + (1.0 / 255.0) * (ign(fragCoord) - 0.5);\n\n  // Premultiply on DISPLAY-space color (matches the WebGL2 path: OETF, then premul).\n  return vec4<f32>(col * alpha, alpha);\n}\n";
+export declare const AURORA_WGSL = "\nconst MAX_NUCLEI: i32 = 8;\nconst MAX_STOPS: i32 = 8;\nconst PI: f32 = 3.141592653589793;\n\n// \u2500\u2500 Uniforms (the typed-struct source-of-truth \u2014 see aurora.wgsl.uniforms.ts) \u2500\u2500\n// Scalars are packed into vec4 lanes to keep the std140/WGSL 16-byte struct alignment\n// trivial. nuc0[i] = (pos.x, pos.y, radius, paletteBias); nuc1[i] = (valueBias,\n// driftRadius, driftPhase, elong); nuc2[i] = (angle, _, _, _). palette[i].rgb is the\n// CPU-baked linear-sRGB stop.\nstruct Uniforms {\n  // scalars0: (uTime, uSoftmaxBeta, uValueVariance, uWarpAmount)\n  scalars0: vec4<f32>,\n  // scalars1: (uWarpScale, uWarpDrift, uSaturation, uPaperGrain)\n  scalars1: vec4<f32>,\n  // scalars2: (uAlpha, uNucleiDrift, uPaletteDrift, uBreathDepth)\n  scalars2: vec4<f32>,\n  // scalars3: (uBreathPeriod, uCursorStrength, uCursorRadius, uVividness)\n  // The .w pad lane now carries the chroma-floor strength.\n  scalars3: vec4<f32>,\n  // cursor: (uCursor.x, uCursor.y, uMetalPolish, uMetalHeightScale)\n  // The two free pad lanes carry the metal-medium knobs (the\n  // metal light is cursor-synthesized so it reads in-struct on the WGSL primary too).\n  cursor: vec4<f32>,\n  // ints: (uStopCount, uNucleiCount, uWarpMode, uNoiseOctaves)\n  ints0: vec4<i32>,\n  // ints1: (uMedium, uHuePath, _, _)\n  ints1: vec4<i32>,\n  palette: array<vec4<f32>, 8>,\n  nuc0: array<vec4<f32>, 8>,\n  nuc1: array<vec4<f32>, 8>,\n  nuc2: array<vec4<f32>, 8>,\n  // The painterly-medium scalar lanes are appended after the\n  // arrays so EVERY existing offset (and the smooth-default parity capture) is\n  // byte-identical (these lanes are written 0 on a smooth config). scalars4:\n  // (uStrokeAmount, uStrokeScale, uStrokeAnisotropy, uCanvasGrain). scalars5:\n  // (uWetEdge, uGranulation, uBrokenColor, uKuwaharaQ). kuwahara: (uKuwaharaRadius,\n  // uKuwaharaSectors, _, _) \u2014 the Kuwahara radius/sectors/q in lockstep with\n  // packAuroraWGPUUniforms (the typed-struct discipline).\n  scalars4: vec4<f32>,\n  scalars5: vec4<f32>,\n  kuwahara: vec4<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u: Uniforms;\n\n// \u2500\u2500 Authoring-scale \u2192 rad/sec lifts (byte-identical to aurora.frag.ts) \u2500\u2500\nconst K_NUCLEI: f32 = 14.0;\nconst K_PAL: f32 = 24.0;\nconst K_WARP: f32 = 5.0;\n\n// \u2500\u2500 Noise (Aurora-local hash21/vnoise/fbm, deliberately distinct) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nfn hash21(p0: vec2<f32>) -> f32 {\n  var p = fract(p0 * vec2<f32>(123.34, 456.21));\n  p = p + dot(p, p + 45.32);\n  return fract(p.x * p.y);\n}\n\nfn hash22(p0: vec2<f32>) -> vec2<f32> {\n  let p = vec2<f32>(dot(p0, vec2<f32>(127.1, 311.7)),\n                    dot(p0, vec2<f32>(269.5, 183.3)));\n  return fract(sin(p) * 43758.5453);\n}\n\nfn vnoise(p: vec2<f32>) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let uu = f * f * (3.0 - 2.0 * f);\n  let a = hash21(i);\n  let b = hash21(i + vec2<f32>(1.0, 0.0));\n  let c = hash21(i + vec2<f32>(0.0, 1.0));\n  let d = hash21(i + vec2<f32>(1.0, 1.0));\n  return mix(mix(a, b, uu.x), mix(c, d, uu.x), uu.y);\n}\n\nconst FBM_ROT: mat2x2<f32> = mat2x2<f32>(0.8, 0.6, -0.6, 0.8);\n\nfn fbm(p0: vec2<f32>) -> f32 {\n  var v = 0.0;\n  var a = 0.5;\n  var p = p0;\n  let octaves = u.ints0.w;\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 potentialFBM(p: vec2f) -> f32 { return fbm(p); }\n\nconst CURL_EPS: f32 = 0.012;\n\n// \u2207\u00D7\u03C8 in 2D \u2014 the divergence-free flow direction. Central finite differences of the\n// scalar potential give the partials; the cross-pairing (\u2202y, \u2212\u2202x) is the 2D curl.\nfn curlFBM(p: vec2f) -> vec2f {\n  let dx = potentialFBM(p + vec2f(CURL_EPS, 0.0)) - potentialFBM(p - vec2f(CURL_EPS, 0.0));\n  let dy = potentialFBM(p + vec2f(0.0, CURL_EPS)) - potentialFBM(p - vec2f(0.0, CURL_EPS));\n  // \u03C8-gradient is (dx, dy)/(2\u00B7eps); the curl rotates it 90\u00B0: (\u2202\u03C8/\u2202y, \u2212\u2202\u03C8/\u2202x).\n  let g = vec2f(dx, dy) / (2.0 * CURL_EPS);\n  return vec2f(g.y, -g.x);\n}\n\n\n\nfn srgbToLinearCh(c: f32) -> f32 {\n  if (c <= 0.04045) { return c / 12.92; }\n  return pow((c + 0.055) / 1.055, 2.4);\n}\nfn srgbToLinear(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\n\nfn linearToSrgbCh(c: f32) -> f32 {\n  if (c <= 0.0031308) { return c * 12.92; }\n  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\nfn linearToSrgb(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}\n\n// value.js LINEAR_SRGB_TO_LMS, row-major \u2192 WGSL columns (= the transpose).\nconst LINEAR_SRGB_TO_LMS: mat3x3<f32> = mat3x3<f32>(\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\u2192OKLab coefficients, row-major \u2192 WGSL columns.\nconst LMS_TO_OKLAB: mat3x3<f32> = mat3x3<f32>(\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, row-major \u2192 WGSL columns.\nconst OKLAB_TO_LMS: mat3x3<f32> = mat3x3<f32>(\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, row-major \u2192 WGSL columns.\nconst LMS_TO_LINEAR_SRGB: mat3x3<f32> = mat3x3<f32>(\n  4.0767416621, -1.2684380046, -0.0041960863,\n  -3.3077115913, 2.6097574011, -0.7034186147,\n  0.2309699292, -0.3413193965, 1.7076147010\n);\n\nfn cbrt3(v: vec3<f32>) -> vec3<f32> {\n  return sign(v) * pow(abs(v), vec3<f32>(1.0 / 3.0));\n}\n\n// Gamma sRGB \u2192 raw OKLab (L, a, b). Mirrors value.js srgbToOKLab.\nfn srgbToOklab(c: vec3<f32>) -> vec3<f32> {\n  let lin = srgbToLinear(c);\n  let lms = LINEAR_SRGB_TO_LMS * lin;\n  return LMS_TO_OKLAB * cbrt3(lms);\n}\n\n// Raw OKLab (L, a, b) \u2192 linear sRGB. Mirrors value.js oklabToLinearSRGB.\nfn oklabToLinearSrgb(lab: vec3<f32>) -> vec3<f32> {\n  let lms_ = OKLAB_TO_LMS * lab;\n  let lms = lms_ * lms_ * lms_;\n  return LMS_TO_LINEAR_SRGB * lms;\n}\n\n// OKLab \u2192 OKLCh: H in RADIANS, folded to [0, 2pi). Mirrors value.js rawOklabToOklch.\nfn oklabToOklch(lab: vec3<f32>) -> vec3<f32> {\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 vec3<f32>(lab.x, C, H);\n}\n\n// OKLCh (H radians) \u2192 OKLab. Mirrors value.js rawOklchToOklab.\nfn oklchToOklab(lch: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}\n\n// value.js interpolateHue in the NORMALIZED-TURNS domain. methods: 0 shorter,\n// 1 longer, 2 increasing, 3 decreasing.\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  var r = a + t * (b - a);\n  r = fract(r);                   // fract is non-negative in WGSL\n  return r * TAU;                 // back to radians\n}\n\n// Linear-sRGB endpoint pair \u2192 OKLab-rectangular interpolation \u2192 linear sRGB.\nfn mixPaletteOklab(linA: vec3<f32>, linB: vec3<f32>, t: f32) -> vec3<f32> {\n  let labA = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * linA);\n  let labB = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * linB);\n  let lab = mix(labA, labB, t);\n  return oklabToLinearSrgb(lab);\n}\n\n// Linear-sRGB endpoint pair \u2192 OKLCh hue-arc interpolation \u2192 linear sRGB.\nfn mixPaletteOklchArc(linA: vec3<f32>, linB: vec3<f32>, t: f32, method: i32) -> vec3<f32> {\n  let labA = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * linA);\n  let labB = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * linB);\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(vec3<f32>(L, C, H)));\n}\n\n// The ramp dispatcher (the samplePalette splices it). 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; every other method\n// takes the OKLab-rectangular straight line.\nfn samplePaletteRamp(a: vec3<f32>, b: vec3<f32>, tRaw: f32, huePath: i32) -> vec3<f32> {\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// Interleaved Gradient Noise (Jimenez) \u2014 display-space 1-LSB dither.\nfn ign(p: vec2<f32>) -> f32 {\n  return fract(52.9829189 * fract(dot(p, vec2<f32>(0.06711056, 0.00583715))));\n}\n\n// Cellular, Worley f1.\nfn cellular(p: vec2<f32>) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  var m = 1e9;\n  for (var y = -1; y <= 1; y = y + 1) {\n    for (var x = -1; x <= 1; x = x + 1) {\n      let g = vec2<f32>(f32(x), f32(y));\n      let o = hash22(i + g);\n      let r = g + o - f;\n      m = min(m, dot(r, r));\n    }\n  }\n  return sqrt(m);\n}\n\n// \u2500\u2500 Warp (Quilez double warp + the four warp modes + the cursor swirl) \u2500\u2500\nfn domainWarp(p: vec2<f32>, t: f32) -> vec2<f32> {\n  let warpScale = u.scalars1.x;\n  let warpDrift = u.scalars1.y;\n  let warpAmount = u.scalars0.w;\n  let warpMode = u.ints0.z;\n  let cursorStrength = u.scalars3.y;\n  let cursorRadius = u.scalars3.z;\n  let cursor = u.cursor.xy;\n\n  let q = vec2<f32>(fbm(p * warpScale + vec2<f32>(0.0, 0.0) + t * warpDrift * K_WARP),\n                    fbm(p * warpScale + vec2<f32>(5.2, 1.3) + t * warpDrift * K_WARP));\n  let r = vec2<f32>(fbm(p * warpScale + 4.0 * q + vec2<f32>(1.7, 9.2)),\n                    fbm(p * warpScale + 4.0 * q + vec2<f32>(8.3, 2.8)));\n\n  var warp = r;\n  if (warpMode == 1) {\n    // cellular \u2014 chunky territories\n    let c1 = cellular(p * warpScale * 1.5 + vec2<f32>(t * warpDrift * K_WARP * 2.0, 0.0));\n    let c2 = cellular(p * warpScale * 1.5 + vec2<f32>(11.0, 7.0 + t * warpDrift * K_WARP * 2.0));\n    warp = vec2<f32>(c1, c2);\n  } else if (warpMode == 2) {\n    // hybrid \u2014 fbm + cellular averaged\n    let c1 = cellular(p * warpScale * 1.2);\n    let c2 = cellular(p * warpScale * 1.2 + vec2<f32>(11.0, 7.0));\n    warp = mix(r, vec2<f32>(c1, c2), 0.5);\n  } else if (warpMode == 3) {\n    let fp = p * warpScale + vec2<f32>(t * warpDrift * K_WARP);\n    warp = curlFBM(fp);\n  }\n  var warped = p + warpAmount * warp;\n\n  // Cursor swirl \u2014 rotate p around the cursor with radial falloff.\n  if (cursorStrength > 0.001) {\n    let toP = p - cursor;\n    let d = length(toP);\n    let rr = max(cursorRadius, 0.01);\n    let w = exp(-(d * d) / (rr * rr * 0.45));\n    let ang = w * cursorStrength * 2.1;\n    let ca = cos(ang);\n    let sa = sin(ang);\n    var rotated = vec2<f32>(ca * toP.x - sa * toP.y, sa * toP.x + ca * toP.y) + cursor;\n    let pinch = w * cursorStrength * 0.08;\n    rotated = mix(rotated, cursor, pinch);\n    warped = mix(warped, rotated + warpAmount * warp * 0.7, w * cursorStrength);\n  }\n  return warped;\n}\n\n// \u2500\u2500 Palette LUT \u2500\u2500\nfn samplePalette(id0: f32) -> vec3<f32> {\n  let id = clamp(id0, 0.0, 1.0);\n  let stopCount = u.ints0.x;\n  let scaled = id * f32(stopCount - 1);\n  let i0 = i32(floor(scaled));\n  let i1 = min(i0 + 1, stopCount - 1);\n  let t = fract(scaled);\n  return samplePaletteRamp(u.palette[i0].rgb, u.palette[i1].rgb, t, u.ints1.y);\n}\n\n// \u2500\u2500 Nuclei field (anisotropic Gaussian softmax + drift + palette drift) \u2500\u2500\nstruct NucleiResult { paletteId: f32, valueMod: f32 };\n\nfn nucleiField(p: vec2<f32>, t: f32) -> NucleiResult {\n  let nucleiCount = u.ints0.y;\n  let nucleiDrift = u.scalars2.y;\n  let paletteDrift = u.scalars2.z;\n  let softmaxBeta = u.scalars0.y;\n\n  var accumBias = 0.0;\n  var accumValue = 0.0;\n  var accumW = 0.0;\n  for (var i = 0; i < MAX_NUCLEI; i = i + 1) {\n    if (i >= nucleiCount) { break; }\n    let n0 = u.nuc0[i];   // pos.x, pos.y, radius, paletteBias\n    let n1 = u.nuc1[i];   // valueBias, driftRadius, driftPhase, elong\n    let angle = u.nuc2[i].x;\n    let driftRadius = n1.y;\n    let driftPhase = n1.z;\n    let posI = n0.xy + driftRadius * vec2<f32>(\n      cos(t * nucleiDrift * K_NUCLEI + driftPhase),\n      sin(t * nucleiDrift * K_NUCLEI + driftPhase * 1.13)\n    );\n    let diff = p - posI;\n    let ca = cos(angle);\n    let sa = sin(angle);\n    let local = vec2<f32>(ca * diff.x + sa * diff.y, -sa * diff.x + ca * diff.y);\n    let along = local.x / max(n1.w, 0.01);\n    let across = local.y;\n    let d2 = along * along + across * across;\n    let r = max(n0.z, 0.01);\n    let w = exp(-softmaxBeta * d2 / (r * r));\n    accumBias = accumBias + w * n0.w;\n    accumValue = accumValue + w * n1.x;\n    accumW = accumW + w;\n  }\n  var paletteId = accumBias / max(accumW, 1e-4);\n  let valueMod = accumValue / max(accumW, 1e-4);\n\n  let palAmp = clamp(paletteDrift * 6.0, 0.0, 0.06);\n  paletteId = paletteId + palAmp * sin(t * paletteDrift * K_PAL);\n  paletteId = clamp(paletteId, 0.0, 1.0);\n  return NucleiResult(paletteId, valueMod);\n}\n\n// \u2500\u2500 Color utils (OKLCh saturation) \u2500\u2500\nfn linOklab(lin: vec3<f32>) -> vec3<f32> {\n  let lms = LINEAR_SRGB_TO_LMS * lin;\n  return LMS_TO_OKLAB * cbrt3(lms);\n}\n\nfn saturate3(c: vec3<f32>, amt: f32) -> vec3<f32> {\n  var lch = oklabToOklch(linOklab(c));\n  lch.y = max(lch.y * amt, 0.0);\n  return max(oklabToLinearSrgb(oklchToOklab(lch)), vec3<f32>(0.0));\n}\n\n// The chroma floor, the WGSL twin of the GLSL vividnessFloor.\n// OKLab chroma lifted toward the floor, hue + L preserved; below VIVID_EPS the (a,b)\n// direction is precision noise so the lift synthesizes along the WARM anchor (amber,\n// both components positive) \u2014 never teal/navy. vividness (scalars3.w) == 0 is a no-op\n// (the byte-identity opt-out). Mode factor lifts a dim field a touch (read through glass).\nconst VIVID_TARGET: f32 = 0.115;\nconst VIVID_EPS: f32 = 0.012;\nconst VIVID_WARM_ANCHOR: vec2<f32> = vec2<f32>(0.34202, 0.93969);\nfn vividnessFloor(c: vec3<f32>, vividness: f32) -> vec3<f32> {\n  if (vividness <= 0.0001) { return c; }\n  var lab = linOklab(c);\n  let C = length(lab.yz);\n  let modeLift = mix(1.18, 1.0, clamp(lab.x * 1.4, 0.0, 1.0));\n  let Cmin = vividness * VIVID_TARGET * modeLift;\n  var hueDir = VIVID_WARM_ANCHOR;\n  if (C > VIVID_EPS) { hueDir = lab.yz / C; }\n  let yz = hueDir * max(C, Cmin);\n  lab = vec3<f32>(lab.x, yz.x, yz.y);\n  return max(oklabToLinearSrgb(lab), vec3<f32>(0.0));\n}\n\n// \u2500\u2500 PBR-Neutral tonemap (named aces() in the GLSL \u2014 the tonemap slot) \u2500\u2500\nfn aces(color0: vec3<f32>) -> vec3<f32> {\n  let startCompression = 0.8 - 0.04;\n  let desaturation = 0.15;\n  var color = color0;\n  let x = min(color.r, min(color.g, color.b));\n  var offset = 0.04;\n  if (x < 0.08) { offset = x - 6.25 * x * x; }\n  color = color - offset;\n  let peak = max(color.r, max(color.g, color.b));\n  if (peak < startCompression) { return clamp(color, vec3<f32>(0.0), vec3<f32>(1.0)); }\n  let d = 1.0 - startCompression;\n  let newPeak = 1.0 - d * d / (peak + d - startCompression);\n  color = color * (newPeak / peak);\n  let g = 1.0 - 1.0 / (desaturation * (peak - newPeak) + 1.0);\n  return clamp(mix(color, newPeak * vec3<f32>(1.0), g), vec3<f32>(0.0), vec3<f32>(1.0));\n}\n\n// \u2500\u2500 Painterly-medium bodies (the keystone WGSL port) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// Spliced HERE, after every helper the mediums consume is defined (domainWarp,\n// nucleiField, samplePalette, linOklab, saturate3, oklabToOklch/oklchToOklab,\n// hash21/vnoise/fbm) and before the vertex/fragment stages. applyMedium(col,p,t)\n// is the dispatch the fragment stage calls.\n\n// \u2500\u2500 Painterly luma + medium scalar accessors \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\nconst W_LUMA: vec3<f32> = vec3<f32>(0.2126, 0.7152, 0.0722);\n\nfn mStrokeAmount() -> f32 { return u.scalars4.x; }\nfn mStrokeScale() -> f32 { return u.scalars4.y; }\nfn mStrokeAnisotropy() -> f32 { return u.scalars4.z; }\nfn mCanvasGrain() -> f32 { return u.scalars4.w; }\nfn mWetEdge() -> f32 { return u.scalars5.x; }\nfn mGranulation() -> f32 { return u.scalars5.y; }\nfn mBrokenColor() -> f32 { return u.scalars5.z; }\nfn mKuwaharaQ() -> f32 { return u.scalars5.w; }\nfn mKuwaharaRadius() -> f32 { return u.kuwahara.x; }\n// The metal-medium knobs ride the free cursor.z/.w pad lanes\n// (uniformBridgeWGPU packs them; written 0 on a non-metal config \u2192 no-op). These read\n// the IN-STRUCT cursor \u2014 the metal light is cursor-synthesized so it crosses to WGSL\n// (a phantom uLightDir read would be flat on the primary; uLightDir is fragment-only).\nfn mMetalPolish() -> f32 { return u.cursor.z; }\nfn mMetalHeightScale() -> f32 { return u.cursor.w; }\n\n// \u2500\u2500 Gradient pack (the WGSL twin) \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\u2500\u2500\u2500\u2500\u2500\u2500\n// structureTensorField re-plumbs its already-computed luma gradient (Gx,Gy) out\n// through the return value's .w lane so the metal medium pays ZERO extra taps. 12 bits per\n// bounded component ([-4,4]) fit into one f32; the crayon/kuwahara callers read only .xy/.z.\nfn packGrad(gx: f32, gy: f32) -> f32 {\n  let qx = floor(clamp(gx * 0.125 + 0.5, 0.0, 1.0) * 4095.0);\n  let qy = floor(clamp(gy * 0.125 + 0.5, 0.0, 1.0) * 4095.0);\n  return qx + qy * 4096.0;\n}\nfn unpackGrad(packed: f32) -> vec2<f32> {\n  let qy = floor(packed * (1.0 / 4096.0));\n  let qx = packed - qy * 4096.0;\n  return (vec2<f32>(qx, qy) * (1.0 / 4095.0) - 0.5) * 8.0;\n}\n\n// \u2500\u2500 Base color re-sample (the edge-mask operator the mediums Sobel/sector-sample) \u2500\u2500\n// The WGSL twin of mediums.glsl.ts sampleBase: warp -> nuclei field -> palette -> value.\nfn sampleBase(p: vec2<f32>, t: f32) -> vec3<f32> {\n  let pw = domainWarp(p, t);\n  let nf = nucleiField(pw, t);\n  var c = samplePalette(nf.paletteId);\n  c = c * (1.0 + u.scalars0.z * nf.valueMod);\n  return c;\n}\n\n// \u2500\u2500 Broken color (hue + chroma jitter at constant OKLCh L) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nfn brokenColorJitter(c: vec3<f32>, hueSeed: f32, valueSeed: f32, strength: f32) -> vec3<f32> {\n  let amt = clamp(mBrokenColor() * strength, 0.0, 1.0);\n  if (amt <= 0.001) { return c; }\n  var lch = oklabToOklch(linOklab(c));\n  lch.z = lch.z + (hueSeed - 0.5) * (32.0 * PI / 180.0) * amt;\n  lch.y = max(lch.y * (1.0 + (valueSeed - 0.5) * 0.28 * amt), 0.0);\n  return max(oklabToLinearSrgb(oklchToOklab(lch)), vec3<f32>(0.0));\n}\n\n// \u2500\u2500 Structure tensor / edge-tangent flow (the WGSL twin) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// Returns vec4(tangent.x, tangent.y, A, packGrad(Gx,Gy)) \u2014 the minor-eigenvector\n// edge-tangent + coherence + the metal medium's packed gradient. The .xy/.z\n// crayon/kuwahara callers are byte-unchanged.\nfn structureTensorField(p: vec2<f32>, t: f32, fallbackDir: vec2<f32>) -> vec4<f32> {\n  let e = 0.0035;\n  let l00 = dot(sampleBase(p + vec2<f32>(-e, -e), t), W_LUMA);\n  let l10 = dot(sampleBase(p + vec2<f32>(0.0, -e), t), W_LUMA);\n  let l20 = dot(sampleBase(p + vec2<f32>( e, -e), t), W_LUMA);\n  let l01 = dot(sampleBase(p + vec2<f32>(-e, 0.0), t), W_LUMA);\n  let l21 = dot(sampleBase(p + vec2<f32>( e, 0.0), t), W_LUMA);\n  let l02 = dot(sampleBase(p + vec2<f32>(-e, e), t), W_LUMA);\n  let l12 = dot(sampleBase(p + vec2<f32>(0.0, e), t), W_LUMA);\n  let l22 = dot(sampleBase(p + vec2<f32>( e, e), t), W_LUMA);\n  let Gx = (l20 + 2.0 * l21 + l22) - (l00 + 2.0 * l01 + l02);\n  let Gy = (l02 + 2.0 * l12 + l22) - (l00 + 2.0 * l10 + l20);\n  let Jxx = Gx * Gx;\n  let Jyy = Gy * Gy;\n  let Jxy = Gx * Gy;\n  let tr = Jxx + Jyy;\n  let disc = sqrt(max((Jxx - Jyy) * (Jxx - Jyy) + 4.0 * Jxy * Jxy, 0.0));\n  let lambdaMaj = 0.5 * (tr + disc);\n  let lambdaMin = 0.5 * (tr - disc);\n  var tangent: vec2<f32>;\n  if (disc < 1e-7) {\n    tangent = fallbackDir;\n  } else {\n    let theta = 0.5 * atan2(2.0 * Jxy, Jxx - Jyy);\n    tangent = vec2<f32>(-sin(theta), cos(theta));\n  }\n  var A = (lambdaMaj - lambdaMin) / (lambdaMaj + lambdaMin + 1e-6);\n  A = clamp(A, 0.0, 1.0);\n  if (dot(tangent, fallbackDir) < 0.0) { tangent = -tangent; }\n  let blendW = pow(A, 0.28);\n  let dir = normalize(mix(fallbackDir, tangent, blendW) + vec2<f32>(1e-6, 1e-6));\n  return vec4<f32>(dir, A, packGrad(Gx, Gy));\n}\n\n// \u2500\u2500 Flow field (the WGSL twin \u2014 the simple flow seed the medium fallback dirs use) \u2500\u2500\nfn flowField(p: vec2<f32>, t: f32) -> vec2<f32> {\n  // Curl-noise-driven swirl (the medium-default dir; the full radial/swirl/diagonal\n  // dispatch rides uniforms the WGSL struct does not carry \u2014 the procedural mediums\n  // use this multi/curl seed as the fallback the structure tensor relaxes toward).\n  let n = fbm(p * 2.0 + vec2<f32>(t * 0.02, t * 0.02));\n  let a = n * 6.2831853;\n  var dir = vec2<f32>(cos(a), sin(a));\n  // Cursor swirl bias (matches the GLSL flow cursor term \u2014 the steady attraction).\n  let cursorStrength = u.scalars3.y;\n  let cursorRadius = u.scalars3.z;\n  let cursor = u.cursor.xy;\n  if (cursorStrength > 0.001) {\n    let toCur = cursor - p;\n    let d = length(toCur);\n    let r = max(cursorRadius, 0.01);\n    let w = exp(-(d * d) / (r * r * 0.5));\n    let tangent = vec2<f32>(-toCur.y, toCur.x) / max(d, 1e-4);\n    let a0 = atan2(dir.y, dir.x);\n    let a1 = atan2(tangent.y, tangent.x);\n    var da = a1 - a0;\n    da = atan2(sin(da), cos(da));\n    let aa = a0 + da * w * cursorStrength;\n    dir = vec2<f32>(cos(aa), sin(aa));\n  }\n  return dir;\n}\n\n// \u2500\u2500 Watercolor \u2014 wet-edge cauliflowers + granulation + wash banding \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nfn mediumWatercolor(col0: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {\n  var col = col0;\n  let eps = 0.004;\n  let cx1 = sampleBase(p + vec2<f32>(eps, 0.0), t);\n  let cx2 = sampleBase(p - vec2<f32>(eps, 0.0), t);\n  let cy1 = sampleBase(p + vec2<f32>(0.0, eps), t);\n  let cy2 = sampleBase(p - vec2<f32>(0.0, eps), t);\n  let gx = dot(cx1 - cx2, W_LUMA);\n  let gy = dot(cy1 - cy2, W_LUMA);\n  let edge = sqrt(gx * gx + gy * gy) / (2.0 * eps);\n  let mask = smoothstep(0.0, 2.5, edge);\n  col = col * mix(1.0, 0.78, mask * mWetEdge());\n\n  let paper = 0.5 * vnoise(p * 160.0) + 0.5 * vnoise(p * 360.0);\n  let pigLoad = 1.0 - dot(col, W_LUMA);\n  col = col * (1.0 - mGranulation() * pigLoad * (paper - 0.5));\n\n  let band = fbm(vec2<f32>(p.x * 1.5, p.y * 0.4));\n  col = col * (1.0 + 0.04 * (band - 0.5));\n  return col;\n}\n\n// \u2500\u2500 Pastel \u2014 anisotropic stroke noise along the flow + tooth grain \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nfn mediumPastel(col0: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {\n  var col = col0;\n  let flow = flowField(p, t);\n  let perp = vec2<f32>(-flow.y, flow.x);\n  let strokeScale = mStrokeScale();\n  let along = dot(p, flow) * strokeScale;\n  var across = dot(p, perp) * strokeScale;\n  across = across + 0.03 * (vnoise(p * 260.0) - 0.5);\n\n  let aniso = mix(1.0, 0.18, mStrokeAnisotropy());\n  let stroke = fbm(vec2<f32>(along * aniso, across));\n  col = col * mix(1.0, 0.82 + 0.32 * stroke, mStrokeAmount());\n\n  let tooth = vnoise(p * 800.0);\n  col = col * (1.0 - 0.08 * mStrokeAmount() * (tooth - 0.5));\n  return col;\n}\n\n// \u2500\u2500 Crayon \u2014 DRY wax pigment on paper tooth (the tooth-multiply + scumble) \u2500\u2500\nfn mediumCrayon(col0: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {\n  let flow = structureTensorField(p, t, flowField(p, t)).xy;\n  let ang = atan2(flow.y, flow.x);\n  let ca = cos(-ang);\n  let sa = sin(-ang);\n  let pr = vec2<f32>(p.x * ca - p.y * sa, p.x * sa + p.y * ca);\n\n  let aniso = mix(0.45, 0.95, mStrokeAnisotropy());\n  let scale = max(mStrokeScale() * 1.6, 180.0);\n\n  let t1 = vnoise(vec2<f32>(pr.x * scale * aniso, pr.y * scale));\n  let t2 = vnoise(vec2<f32>(pr.x * scale * aniso * 0.4, pr.y * scale * 0.4) + vec2<f32>(11.0, 11.0));\n  let t3 = vnoise(vec2<f32>(pr.x * scale * aniso * 2.1, pr.y * scale * 2.1) + vec2<f32>(23.0, 23.0));\n  let tooth = 0.55 * t1 + 0.30 * t2 + 0.15 * t3;\n\n  let pressure = clamp(mStrokeAmount(), 0.0, 1.0);\n  let bite = mix(0.18, 0.46, pressure);\n  var result = col0 * (1.0 - bite * (0.5 - tooth));\n\n  let scumbleMask = smoothstep(0.42, 0.78, vnoise(vec2<f32>(pr.x * scale * 0.55, pr.y * scale * 0.22) + vec2<f32>(7.0, 7.0)));\n  let scumbleCoverage = scumbleMask * pressure * 0.7;\n  let paper = col0 * mix(0.80, 0.94, pressure);\n  result = mix(paper, result, scumbleCoverage);\n\n  let pigmentCell = floor(pr * max(scale * 0.18, 32.0));\n  let pigmentMask = smoothstep(0.28, 0.82, vnoise(pr * scale * 0.21 + vec2<f32>(19.0, 19.0)));\n  result = brokenColorJitter(\n    result,\n    hash21(pigmentCell + vec2<f32>(17.0, 17.0)),\n    hash21(pigmentCell * 2.1 + vec2<f32>(31.0, 31.0)),\n    0.45 + 0.55 * pigmentMask\n  );\n\n  result = saturate3(result, 1.08);\n  return result;\n}\n\n// \u2500\u2500 Kuwahara \u2014 the SOFT anisotropic generalized Kuwahara painterly finish \u2500\u2500\u2500\u2500\n// THE KEYSTONE (Kyprianidis 2010). Aurora is a PROCEDURAL field (no input texture) so the\n// operator runs over sampleBase directly: an elliptical kernel oriented along the structure\n// tensor (elongated along the edge-tangent, narrowed across by the anisotropy), 8 OVERLAPPING\n// sectors via SMOOTH gaussian-angular weights, blended by 1/(1+var^q) (the SOFT criterion \u2192\n// no 8-spoke pinwheel by construction). 4 rings \u00D7 8 angular taps = 32 procedural samples.\nfn mediumKuwahara(col0: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {\n  let stf = structureTensorField(p, t, flowField(p, t));\n  let tangent = stf.xy;\n  let A = stf.z;\n  // The studio knob drives the patch radius; clamp into the procedural patch band.\n  let radius = clamp(mKuwaharaRadius() + mStrokeScale() * 0.00018, 0.006, 0.024);\n  let aniso = mix(1.0, 0.34, clamp(A, 0.0, 1.0));\n  let ax = tangent;\n  let ay = vec2<f32>(-tangent.y, tangent.x);\n\n  // Per-sector weighted sums (8 sectors). WGSL has no runtime-indexed local arrays of\n  // vectors as cleanly as GLSL, so unroll the sector accumulators explicitly.\n  var mSum: array<vec3<f32>, 8>;\n  var sSum: array<vec3<f32>, 8>;\n  var wSum: array<f32, 8>;\n  for (var i = 0; i < 8; i = i + 1) {\n    mSum[i] = vec3<f32>(0.0);\n    sSum[i] = vec3<f32>(0.0);\n    wSum[i] = 0.0;\n  }\n\n  let RINGS = 4;\n  let TAPS = 8;\n  for (var r = 1; r <= RINGS; r = r + 1) {\n    let rr = f32(r) / f32(RINGS);\n    let radial = 1.0 - 0.6 * rr;\n    for (var a = 0; a < TAPS; a = a + 1) {\n      let ang = 6.2831853 * f32(a) / f32(TAPS);\n      let dirE = ax * cos(ang) + ay * (sin(ang) * aniso);\n      let off = dirE * (radius * rr);\n      let c = sampleBase(p + off, t);\n      for (var k = 0; k < 8; k = k + 1) {\n        let sectorAng = 6.2831853 * f32(k) / 8.0;\n        var d = ang - sectorAng;\n        d = atan2(sin(d), cos(d));\n        let sw = exp(-d * d * 2.2) * radial;\n        mSum[k] = mSum[k] + c * sw;\n        sSum[k] = sSum[k] + c * c * sw;\n        wSum[k] = wSum[k] + sw;\n      }\n    }\n  }\n\n  let q = max(mKuwaharaQ(), 1.0);\n  var accum = vec3<f32>(0.0);\n  var accumW = 0.0;\n  for (var k = 0; k < 8; k = k + 1) {\n    let wk = max(wSum[k], 1e-4);\n    let mean = mSum[k] / wk;\n    let var3 = max(sSum[k] / wk - mean * mean, vec3<f32>(0.0));\n    let variance = dot(var3, W_LUMA);\n    let sectorW = 1.0 / (1.0 + pow(variance * 320.0, q));\n    accum = accum + mean * sectorW;\n    accumW = accumW + sectorW;\n  }\n  var result = accum / max(accumW, 1e-4);\n\n  // Anchor in near-flat zones so the smoothing only bites at edges.\n  let center = sampleBase(p, t);\n  result = mix(center, result, clamp(0.35 + 0.65 * A, 0.0, 1.0));\n\n  // Faint canvas tooth + pigment-saturation so the flattened patches read as oil paint.\n  let tooth = vnoise(p * 300.0) - 0.5;\n  result = result * (1.0 + tooth * 0.06 * mCanvasGrain());\n  result = saturate3(result, 1.04);\n\n  return mix(col0, result, clamp(mStrokeAmount(), 0.0, 1.0));\n}\n\n// \u2500\u2500 Metal \u2014 the two-term anisotropic BRDF (uMedium==8/9; the WGSL twin) \u2500\u2500\u2500\u2500\u2500\u2500\n// The field re-lights as warm folded metal: the luma HEIGHT field (the packed\n// structure-tensor gradient \u2192 the surface normal) catches an anisotropic Blinn streak\n// (brushed metal, running ALONG the coherent edge-tangent) plus a sharp crest, both\n// raked by the IN-STRUCT cursor-synth light (crosses to WGSL \u2014 never uLightDir). The\n// catch is the achromatic-warm anchor (never a cold chrome-blue). ZERO extra taps \u2014\n// the gradient is unpacked from the tensor's .w lane the caller already computed.\nconst METAL_CATCH_WARM: vec3<f32> = vec3<f32>(1.0, 0.97, 0.90);\nconst METAL_HEIGHT_SCALE: f32 = 2.2;\nconst METAL_LIGHT_Z: f32 = 0.55;\nconst METAL_IDLE_RAKE: vec2<f32> = vec2<f32>(0.32, 0.34);\nconst METAL_SHININESS_ANISO: f32 = 6.0;\nconst METAL_SHININESS_CREST: f32 = 40.0;\nconst METAL_COHERENCE_FLOOR: f32 = 0.22;\nconst METAL_BODY_FLOOR: f32 = 0.42;\nconst METAL_GRADIENT_FLATTEN: f32 = 0.55;\nconst METAL_SPARKLE_DENSITY: f32 = 240.0;\nconst METAL_SPARKLE_THRESH: f32 = 0.72;\nconst METAL_SPARKLE_AMP: f32 = 0.6;\n\nfn metalShade(baseCol: vec3<f32>, p: vec2<f32>, stf: vec4<f32>) -> vec3<f32> {\n  let tangent = stf.xy;\n  let A = stf.z;\n  let grad = unpackGrad(stf.w);\n  let N = normalize(vec3<f32>(grad * (METAL_HEIGHT_SCALE * mMetalHeightScale()), 1.0));\n  let V = vec3<f32>(0.0, 0.0, 1.0);\n  // Cursor-synth rake light (u.cursor is in-struct \u2014 crosses to WGSL).\n  let L = normalize(vec3<f32>((u.cursor.xy - p) + METAL_IDLE_RAKE, METAL_LIGHT_Z));\n  let H = normalize(L + V);\n  // Anisotropic streak \u2014 brushed metal along the edge-tangent.\n  let tH = dot(normalize(tangent), H.xy);\n  let sinTH = sqrt(clamp(1.0 - tH * tH, 0.0, 1.0));\n  let streak = pow(clamp(sinTH, 0.0, 1.0), METAL_SHININESS_ANISO);\n  let crest = pow(clamp(dot(N, H), 0.0, 1.0), METAL_SHININESS_CREST);\n  var spec = streak * crest;\n  spec = spec * smoothstep(0.0, METAL_COHERENCE_FLOOR, A);\n  // Technicolor valley base \u2014 the body keeps the FIELD hue; luma rides the relief.\n  let diff = clamp(dot(N, L), 0.0, 1.0);\n  let body = baseCol * (METAL_BODY_FLOOR + (1.0 - METAL_BODY_FLOOR) * diff);\n  return body + METAL_CATCH_WARM * (spec * clamp(mMetalPolish(), 0.0, 4.0));\n}\n\nfn mediumMetal(col: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {\n  let stf = structureTensorField(p, t, flowField(p, t));\n  return metalShade(col, p, stf);\n}\n\n// metal-gradient (uMedium==9) \u2014 the SAME BRDF over a pre-flattened base + the\n// twinkle-in-place flake sparkle (position FIXED per cell, phase-animated, facing-gated).\nfn mediumMetalGradient(col: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {\n  let stf = structureTensorField(p, t, flowField(p, t));\n  let flat = mix(col, vec3<f32>(dot(col, W_LUMA)), METAL_GRADIENT_FLATTEN);\n  var metal = metalShade(flat, p, stf);\n  let grad = unpackGrad(stf.w);\n  let facing = normalize(vec3<f32>(grad * (METAL_HEIGHT_SCALE * mMetalHeightScale()), 1.0)).z;\n  let cell = floor(p * METAL_SPARKLE_DENSITY);\n  let seed = hash21(cell);\n  let tw = pow(clamp(sin(t + seed * 6.2831853), 0.0, 1.0), 40.0);\n  let flakeGate = step(METAL_SPARKLE_THRESH, seed);\n  metal = metal + METAL_CATCH_WARM * (tw * flakeGate * clamp(facing, 0.0, 1.0) * METAL_SPARKLE_AMP);\n  return metal;\n}\n\n// \u2500\u2500 Medium dispatch (the WGSL twin of the GLSL main() if-ladder) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// uMedium: 0 smooth \u00B7 1 pastel \u00B7 2 watercolor \u00B7 3 oil \u00B7 4 crayon \u00B7 5 vangogh \u00B7\n// 6 oil-pastel \u00B7 7 kuwahara \u00B7 8 metal \u00B7 9 metal-gradient. The cheap peer mediums\n// (pastel/watercolor/crayon) + kuwahara + metal port their own bodies; the\n// oil/vangogh/oil-pastel STROKE cascade renders the anisotropic-Kuwahara PAINTERLY\n// finish here (a real oil-paint read, never the smooth core \u2014 the \"NO FALLBACKS on\n// Safari\" mandate; the full per-dab Starry-Night stroke WGSL remains a separate\n// full-fidelity port).\nfn applyMedium(col: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {\n  let medium = u.ints1.x;\n  if (medium == 1) { return mediumPastel(col, p, t); }\n  if (medium == 2) { return mediumWatercolor(col, p, t); }\n  if (medium == 4) { return mediumCrayon(col, p, t); }\n  // Metal uses both renderer paths; a fragment-only implementation is invisible on the\n  // WGSL primary. IDs 8 and 9 select metal and metal-gradient respectively.\n  if (medium == 8) { return mediumMetal(col, p, t); }\n  if (medium == 9) { return mediumMetalGradient(col, p, t); }\n  // oil(3), vangogh(5), oil-pastel(6), kuwahara(7) all render the painterly\n  // anisotropic-Kuwahara finish on the WGSL primary (the WebGL2 fallback carries the\n  // full per-dab stroke cascade for oil/vangogh/oil-pastel).\n  if (medium == 3 || medium == 5 || medium == 6 || medium == 7) {\n    return mediumKuwahara(col, p, t);\n  }\n  return col;\n}\n\n\n// \u2500\u2500 Full-screen triangle vertex stage (the pilot idiom \u2014 no vertex buffer) \u2500\u2500\nstruct VSOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) uv: vec2<f32>,\n};\n\n@vertex\nfn vs_main(@builtin(vertex_index) vi: u32) -> VSOut {\n  // NDC corners of the covering triangle (-1,-1), (3,-1), (-1,3).\n  var p = vec2<f32>(-1.0, -1.0);\n  if (vi == 1u) { p = vec2<f32>(3.0, -1.0); }\n  else if (vi == 2u) { p = vec2<f32>(-1.0, 3.0); }\n  var out: VSOut;\n  out.pos = vec4<f32>(p, 0.0, 1.0);\n  // vUv = aPos * 0.5 + 0.5 (the aurora.vert convention).\n  out.uv = p * 0.5 + 0.5;\n  return out;\n}\n\n// \u2500\u2500 Fragment stage (the main() transcription) \u2500\u2500\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4<f32> {\n  let t = u.scalars0.x;\n  let valueVariance = u.scalars0.z;\n  let breathDepth = u.scalars2.w;\n  let breathPeriod = u.scalars3.x;\n  let saturation = u.scalars1.z;\n  let paperGrain = u.scalars1.w;\n  let alpha = u.scalars2.x;\n  let vividness = u.scalars3.w;\n\n  let uv = in.uv;\n  let pN = uv;\n\n  let p_warp = domainWarp(pN, t);\n\n  let nf = nucleiField(p_warp, t);\n  var col = samplePalette(nf.paletteId);\n  col = col * (1.0 + valueVariance * nf.valueMod);\n\n  // Breath \u2014 slow global luminance wobble.\n  let breath = sin(t * 6.2831 / max(breathPeriod, 1.0));\n  col = col * (1.0 + breathDepth * breath * 0.5);\n\n  // Painterly-medium dispatch. uMedium 0 (smooth) is a\n  // no-op pass-through so the DEFAULT smooth config renders unchanged\n  // (the parity capture); uMedium 1-7 render the painterly\n  // bodies (pastel/watercolor/crayon/kuwahara) or the anisotropic-Kuwahara finish\n  // (oil/vangogh/oil-pastel) \u2014 never a silent smooth degrade on Safari 26.\n  col = applyMedium(col, pN, t);\n\n  // Cursor-local luminance lean, byte-parallel with the GLSL path.\n  let cursorDelta = pN - u.cursor.xy;\n  let cursorRadius = max(u.scalars3.z, 0.01);\n  let cursorLean = exp(-dot(cursorDelta, cursorDelta) / (cursorRadius * cursorRadius * 0.5));\n  col = col * (1.0 + 0.12 * cursorLean * u.scalars3.y);\n\n  // Saturation trim.\n  col = saturate3(col, saturation);\n\n  // The chroma floor is warm-anchored and hue-preserving. The WGSL\n  // twin of the GLSL call; vividness:0 is a no-op so the smooth/pale default stays gated.\n  col = vividnessFloor(col, vividness);\n\n  // Tonemap + film grain.\n  col = aces(col);\n  // gl_FragCoord.xy \u2192 the device-pixel position (the WGSL @builtin(position)).\n  let fragCoord = in.pos.xy;\n  let grain = hash21(fragCoord + t * 17.0);\n  col = col + (grain - 0.5) * paperGrain;\n\n  col = clamp(col * 0.985 + 0.008, vec3<f32>(0.0), vec3<f32>(1.0));\n\n  // MANDATORY OETF \u2014 closes the seam (the whole pipeline above runs in LINEAR).\n  col = linearToSrgb(col);\n\n  // 1-LSB triangular IGN dither in DISPLAY space, AFTER the OETF.\n  col = col + (1.0 / 255.0) * (ign(fragCoord) - 0.5);\n\n  // Premultiply on DISPLAY-space color (matches the WebGL2 path: OETF, then premul).\n  return vec4<f32>(col * alpha, alpha);\n}\n";

package/dist/components/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). 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        // vec4 (the metal-finish widen) \u2014 .xy tangent + .z coherence; the .w gradient lane\n        // is unused here. A vec3 local would be a type-mismatch WebKit rejects (L1c).\n        vec4 tf = structureTensorField(center, t, safeDir(flow));\n        f = safeDir(tf.xy);\n        coh = tf.z;\n      } else {\n        f = safeDir(flow);\n      }\n      // Per-stroke deterministic local perturbation so alternate stroke layers stay\n      // live. Tensor strokes get FAR less angular jitter (the field already orients them\n      // \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";
+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.\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// The fixed-RGB edge rim (the phantom upper-left light) is retired. Each\n// stroke now deposits PAINT HEIGHT into the height accumulator (coverage x per-stroke\n// thickness, perturbed by the bristle/streak fbm for ridges/grooves); mediumOil\n// derives a normal from the accumulated height gradient (dFdx/dFdy) and relights it\n// once with the movable uLightDir source (relightImpasto), in linear before aces().\n//\n// The internal streak perturbs hue and chroma in OKLCh, not value only,\n// so a single stroke carries a small hue gradient (broken color at the ATOM level \u2014\n// adjacent strokes shimmer like real impasto, not flat stamped swatches);\n// and the OVER-composite runs in OKLab on the painterly stroke mediums so overlapping\n// complementaries mix as pigment, not the linear-mix grey.\n//   impastoFloor \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. 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. Thickness peaks at the stroke spine and\n  // falls toward the impastoFloor at the edge (edgeN: 0=edge, 1=spine), perturbed by\n  // the bristle streak so ridges/grooves form. The relight reads the gradient of this\n  // field. The van-Gogh profile's floor=1.0 gives every atomic dab a full-height crown.\n  float ridge = 0.7 + 0.3 * (streak + 0.5);\n  float crown = impastoFloor + (1.0 - impastoFloor) * s.edgeN;\n  height += s.coverage * impastoAmp * crown * ridge * alpha;\n}\n\n// Relight the accumulated paint height. Derive a normal from the height\n// gradient (dFdx/dFdy \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 from the 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 energy grading (long\n      // confident strokes where structure is coherent, stubby dabs in flat zones).\n      vec2 f;\n      float coh = 1.0;\n      if (uStrokeOrient == 1) {\n        // vec4 (the metal-finish widen) \u2014 .xy tangent + .z coherence; the .w gradient lane\n        // is unused here. A vec3 local would be a type-mismatch WebKit rejects (L1c).\n        vec4 tf = structureTensorField(center, t, safeDir(flow));\n        f = safeDir(tf.xy);\n        coh = tf.z;\n      } else {\n        f = safeDir(flow);\n      }\n      // Per-stroke deterministic local perturbation so alternate stroke layers stay\n      // live. Tensor strokes get FAR less angular jitter (the field already orients them\n      // \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      // 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";

package/dist/components/aurora/constants/shaders/composition.glsl.d.ts

@@ -1 +1 @@
-export declare const AURORA_COMPOSITION_GLSL = "// \u2500\u2500 Palette LUT (W5 \u2014 OKLCh/OKLab interpolation) \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// The endpoints stay CPU-baked to LINEAR sRGB (the Aras precompute pattern); only\n// the BETWEEN-endpoint interpolation runs in perceptual space. AX.W11 \u2014 the ramp\n// itself (the smoothstep ease + the OKLab-rectangular-vs-OKLCh-hue-arc dispatch on\n// uHuePath) is the shared samplePaletteRamp from procedural-color.glsl, the SAME\n// source the WebGPU twin splices; samplePalette here only selects the bracketing\n// stop pair + the raw inter-stop t and hands them to the shared ramp.\nvec3 samplePalette(float id) {\n  id = clamp(id, 0.0, 1.0);\n  float scaled = id * float(uStopCount - 1);\n  int i0 = int(floor(scaled));\n  int i1 = min(i0 + 1, uStopCount - 1);\n  float t = fract(scaled);\n  return samplePaletteRamp(uPalette[i0], uPalette[i1], t, uHuePath);\n}\n\n// \u2500\u2500 Nuclei field \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\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nvoid nucleiField(vec2 p, float t, out float paletteId, out float valueMod) {\n  float accumBias  = 0.0;\n  float accumValue = 0.0;\n  float accumW     = 0.0;\n  for (int i = 0; i < MAX_NUCLEI; i++) {\n    if (i >= uNucleiCount) break;\n    vec2 posI = uNucleiPos[i]\n              + uNucleiDriftRadius[i] * vec2(\n                  cos(t * uNucleiDrift * K_NUCLEI + uNucleiDriftPhase[i]),\n                  sin(t * uNucleiDrift * K_NUCLEI + uNucleiDriftPhase[i] * 1.13)\n                );\n    vec2 diff = p - posI;\n    // Anisotropic Gaussian: rotate diff into the nucleus's local frame\n    // (major axis along uNucleiAngle), then scale the major-axis component by\n    // 1/elongation so the squared distance describes an ellipse. Defaults\n    // 1.0/0.0 reduce to the isotropic dot(diff, diff).\n    float ca = cos(uNucleiAngle[i]);\n    float sa = sin(uNucleiAngle[i]);\n    vec2  local = vec2( ca * diff.x + sa * diff.y,\n                       -sa * diff.x + ca * diff.y);\n    float along  = local.x / max(uNucleiElong[i], 0.01);\n    float across = local.y;\n    float d2 = along * along + across * across;\n    float r = max(uNucleiRadius[i], 0.01);\n    float w = exp(-uSoftmaxBeta * d2 / (r * r));\n    accumBias  += w * uNucleiPaletteBias[i];\n    accumValue += w * uNucleiValueBias[i];\n    accumW     += w;\n  }\n  paletteId = accumBias  / max(accumW, 1e-4);\n  valueMod  = accumValue / max(accumW, 1e-4);\n\n  // Palette drift \u2014 slow global paletteId breathe between adjacent stops. The\n  // rate rides K_PAL (perceptible ~30\u201360s hue cycle at the default coefficient);\n  // the amplitude lifts the authored coefficient into a 0.03..0.06 paletteId band\n  // so the palette visibly travels rather than dithering within one stop.\n  float palAmp = clamp(uPaletteDrift * 6.0, 0.0, 0.06);\n  paletteId += palAmp * sin(t * uPaletteDrift * K_PAL);\n  paletteId = clamp(paletteId, 0.0, 1.0);\n}\n";
+export declare const AURORA_COMPOSITION_GLSL = "// \u2500\u2500 Palette LUT (OKLCh/OKLab interpolation) \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// The endpoints stay CPU-baked to LINEAR sRGB (the Aras precompute pattern); only\n// the between-endpoint interpolation runs in perceptual space. The ramp\n// itself (the smoothstep ease + the OKLab-rectangular-vs-OKLCh-hue-arc dispatch on\n// uHuePath) is the shared samplePaletteRamp from procedural-color.glsl, the SAME\n// source the WebGPU twin splices; samplePalette here only selects the bracketing\n// stop pair + the raw inter-stop t and hands them to the shared ramp.\nvec3 samplePalette(float id) {\n  id = clamp(id, 0.0, 1.0);\n  float scaled = id * float(uStopCount - 1);\n  int i0 = int(floor(scaled));\n  int i1 = min(i0 + 1, uStopCount - 1);\n  float t = fract(scaled);\n  return samplePaletteRamp(uPalette[i0], uPalette[i1], t, uHuePath);\n}\n\n// \u2500\u2500 Nuclei field \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\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nvoid nucleiField(vec2 p, float t, out float paletteId, out float valueMod) {\n  float accumBias  = 0.0;\n  float accumValue = 0.0;\n  float accumW     = 0.0;\n  for (int i = 0; i < MAX_NUCLEI; i++) {\n    if (i >= uNucleiCount) break;\n    vec2 posI = uNucleiPos[i]\n              + uNucleiDriftRadius[i] * vec2(\n                  cos(t * uNucleiDrift * K_NUCLEI + uNucleiDriftPhase[i]),\n                  sin(t * uNucleiDrift * K_NUCLEI + uNucleiDriftPhase[i] * 1.13)\n                );\n    vec2 diff = p - posI;\n    // Anisotropic Gaussian: rotate diff into the nucleus's local frame\n    // (major axis along uNucleiAngle), then scale the major-axis component by\n    // 1/elongation so the squared distance describes an ellipse. Defaults\n    // 1.0/0.0 reduce to the isotropic dot(diff, diff).\n    float ca = cos(uNucleiAngle[i]);\n    float sa = sin(uNucleiAngle[i]);\n    vec2  local = vec2( ca * diff.x + sa * diff.y,\n                       -sa * diff.x + ca * diff.y);\n    float along  = local.x / max(uNucleiElong[i], 0.01);\n    float across = local.y;\n    float d2 = along * along + across * across;\n    float r = max(uNucleiRadius[i], 0.01);\n    float w = exp(-uSoftmaxBeta * d2 / (r * r));\n    accumBias  += w * uNucleiPaletteBias[i];\n    accumValue += w * uNucleiValueBias[i];\n    accumW     += w;\n  }\n  paletteId = accumBias  / max(accumW, 1e-4);\n  valueMod  = accumValue / max(accumW, 1e-4);\n\n  // Palette drift \u2014 slow global paletteId breathe between adjacent stops. The\n  // rate rides K_PAL (perceptible ~30\u201360s hue cycle at the default coefficient);\n  // the amplitude lifts the authored coefficient into a 0.03..0.06 paletteId band\n  // so the palette visibly travels rather than dithering within one stop.\n  float palAmp = clamp(uPaletteDrift * 6.0, 0.0, 0.06);\n  paletteId += palAmp * sin(t * uPaletteDrift * K_PAL);\n  paletteId = clamp(paletteId, 0.0, 1.0);\n}\n";

package/dist/components/aurora/constants/shaders/flow.glsl.d.ts

@@ -1 +1 @@
-export declare const AURORA_FLOW_GLSL = "// \u2500\u2500 Flow field \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\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// Structure-tensor prototype (body defined post-sampleBase in the mediums block).\n// Returns vec4(dir.x, dir.y, coherence, packedGrad) \u2014 the minor-eigenvector tangent + A + the\n// metal-gradient .w lane (BG.W-AUR-METAL-FINISH widened vec3\u2192vec4). The forward decl MUST match\n// the vec4 definition or WebKit's compiler rejects the mismatched signature (L1b).\nvec4 structureTensorField(vec2 p, float t, vec2 fallbackDir);\n\nvec2 flowField(vec2 p, float t) {\n  vec2 dir = vec2(1.0, 0.0);\n  if (uFlowPattern == 1) {\n    // radial\n    dir = normalize(p - uFlowFocal + 1e-4);\n  } else if (uFlowPattern == 2) {\n    // swirl \u2014 tangent to radial\n    vec2 rad = normalize(p - uFlowFocal + 1e-4);\n    dir = vec2(-rad.y, rad.x);\n  } else if (uFlowPattern == 3) {\n    // diagonal\n    float a = radians(uFlowAngle);\n    dir = vec2(cos(a), sin(a));\n  } else if (uFlowPattern == 4) {\n    // multi \u2014 curl-noise driven\n    float n = fbm(p * 2.0 + t * 0.02);\n    float a = n * 6.2831;\n    dir = vec2(cos(a), sin(a));\n  } else if (uFlowPattern == 5) {\n    // tensor / ETF \u2014 the color field's OWN edge-tangent flow (AW.W4.1). The\n    // diagonal angle seeds the smooth fallback the coherence-weighted blend\n    // relaxes toward in low-structure zones. Returns directly (no curl/cursor\n    // post-mix \u2014 the tensor field already carries the structure orientation;\n    // the cursor warp still drives the underlying color field in domainWarp).\n    float a = radians(uFlowAngle);\n    vec2 fallback = vec2(cos(a), sin(a));\n    return structureTensorField(p, t, fallback).xy;\n  }\n  // curl \u2014 perturb by noise. Radial gets much less curl so rays stay clean.\n  if (uFlowCurl > 0.0) {\n    float n = fbm(p * 3.0) - 0.5;\n    float curlAmt = uFlowCurl;\n    if (uFlowPattern == 1) curlAmt *= 0.25;  // radial: preserve ray clarity\n    if (uFlowPattern == 2) curlAmt *= 0.55;  // swirl: allow moderate curl\n    float a = atan(dir.y, dir.x) + n * 3.14159 * curlAmt;\n    dir = vec2(cos(a), sin(a));\n  }\n  // cursor influence \u2014 swirl around the cursor position\n  if (uCursorStrength > 0.001) {\n    vec2 toCur = uCursor - p;\n    float d = length(toCur);\n    float r = max(uCursorRadius, 0.01);\n    float w = exp(-(d * d) / (r * r * 0.5));\n    // swirl tangent\n    vec2 tangent = vec2(-toCur.y, toCur.x) / max(d, 1e-4);\n    float a0 = atan(dir.y, dir.x);\n    float a1 = atan(tangent.y, tangent.x);\n    // blend angle\n    float da = a1 - a0;\n    da = atan(sin(da), cos(da)); // wrap to [-pi, pi]\n    float a = a0 + da * w * uCursorStrength;\n    dir = vec2(cos(a), sin(a));\n  }\n  // AW.W8.1 \u2014 velocity-reactive swirl-BURST: a fast flick (uCursorBurst, decaying\n  // over ~1s) injects a transient flow bias along the pointer velocity, distinct from\n  // the steady attraction above (the stateless swirl is SUPERSEDED by this form). The\n  // burst is gated by the master tempo scalar on the CPU side (it decays to 0 under\n  // PRM/pause), so this term cannot leak motion under reduced-motion.\n  if (uCursorBurst > 0.001) {\n    vec2 toCur = uCursor - p;\n    float d = length(toCur);\n    float r = max(uCursorRadius, 0.01);\n    float w = exp(-(d * d) / (r * r * 0.7));\n    // Bias the flow toward the velocity direction, scaled by the decaying burst.\n    vec2 velDir = uCursorVelocity / max(length(uCursorVelocity), 1e-4);\n    float a0 = atan(dir.y, dir.x);\n    float a1 = atan(velDir.y, velDir.x);\n    float da = atan(sin(a1 - a0), cos(a1 - a0));\n    float a = a0 + da * w * uCursorBurst * 0.8;\n    dir = vec2(cos(a), sin(a));\n  }\n  return dir;\n}\n";
+export declare const AURORA_FLOW_GLSL = "// \u2500\u2500 Flow field \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\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// Structure-tensor prototype (body defined post-sampleBase in the mediums block).\n// Returns vec4(dir.x, dir.y, coherence, packedGrad) \u2014 the minor-eigenvector tangent + A + the\n// metal-gradient .w lane in the widened vec3\u2192vec4 return. The forward declaration must match\n// the vec4 definition or WebKit's compiler rejects the mismatched signature (L1b).\nvec4 structureTensorField(vec2 p, float t, vec2 fallbackDir);\n\nvec2 flowField(vec2 p, float t) {\n  vec2 dir = vec2(1.0, 0.0);\n  if (uFlowPattern == 1) {\n    // radial\n    dir = normalize(p - uFlowFocal + 1e-4);\n  } else if (uFlowPattern == 2) {\n    // swirl \u2014 tangent to radial\n    vec2 rad = normalize(p - uFlowFocal + 1e-4);\n    dir = vec2(-rad.y, rad.x);\n  } else if (uFlowPattern == 3) {\n    // diagonal\n    float a = radians(uFlowAngle);\n    dir = vec2(cos(a), sin(a));\n  } else if (uFlowPattern == 4) {\n    // multi \u2014 curl-noise driven\n    float n = fbm(p * 2.0 + t * 0.02);\n    float a = n * 6.2831;\n    dir = vec2(cos(a), sin(a));\n  } else if (uFlowPattern == 5) {\n    // Tensor / ETF: the color field's own edge-tangent flow. The\n    // diagonal angle seeds the smooth fallback the coherence-weighted blend\n    // relaxes toward in low-structure zones. Returns directly (no curl/cursor\n    // post-mix \u2014 the tensor field already carries the structure orientation;\n    // the cursor warp still drives the underlying color field in domainWarp).\n    float a = radians(uFlowAngle);\n    vec2 fallback = vec2(cos(a), sin(a));\n    return structureTensorField(p, t, fallback).xy;\n  }\n  // curl \u2014 perturb by noise. Radial gets much less curl so rays stay clean.\n  if (uFlowCurl > 0.0) {\n    float n = fbm(p * 3.0) - 0.5;\n    float curlAmt = uFlowCurl;\n    if (uFlowPattern == 1) curlAmt *= 0.25;  // radial: preserve ray clarity\n    if (uFlowPattern == 2) curlAmt *= 0.55;  // swirl: allow moderate curl\n    float a = atan(dir.y, dir.x) + n * 3.14159 * curlAmt;\n    dir = vec2(cos(a), sin(a));\n  }\n  // cursor influence \u2014 swirl around the cursor position\n  if (uCursorStrength > 0.001) {\n    vec2 toCur = uCursor - p;\n    float d = length(toCur);\n    float r = max(uCursorRadius, 0.01);\n    float w = exp(-(d * d) / (r * r * 0.5));\n    // swirl tangent\n    vec2 tangent = vec2(-toCur.y, toCur.x) / max(d, 1e-4);\n    float a0 = atan(dir.y, dir.x);\n    float a1 = atan(tangent.y, tangent.x);\n    // blend angle\n    float da = a1 - a0;\n    da = atan(sin(da), cos(da)); // wrap to [-pi, pi]\n    float a = a0 + da * w * uCursorStrength;\n    dir = vec2(cos(a), sin(a));\n  }\n  return dir;\n}\n";

package/dist/components/aurora/constants/shaders/metal-medium.glsl.d.ts

@@ -1,2 +1,2 @@
-export declare const AURORA_METAL_PACK_GLSL = "\n// \u2500\u2500 Gradient pack (BG.W-AUR-METAL-FINISH) \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// structureTensorField re-plumbs its already-computed luma gradient (Gx,Gy) out through\n// the vec4 return's .w lane so the metal medium pays ZERO extra taps (a second Sobel is\n// 8 sampleBase() taps). 12 bits per bounded component ([-4,4]) into one f32, exact under\n// highp; the .xy/.z crayon/kuwahara callers are transparent to the widen.\nfloat packGrad(float gx, float gy) {\n  float qx = floor(clamp(gx * 0.125 + 0.5, 0.0, 1.0) * 4095.0);\n  float qy = floor(clamp(gy * 0.125 + 0.5, 0.0, 1.0) * 4095.0);\n  return qx + qy * 4096.0;\n}\nvec2 unpackGrad(float packed) {\n  float qy = floor(packed * (1.0 / 4096.0));\n  float qx = packed - qy * 4096.0;\n  return (vec2(qx, qy) * (1.0 / 4095.0) - 0.5) * 8.0;\n}\n";
-export declare const AURORA_METAL_MEDIUM_GLSL = "#define MEDIUM_METAL 8\n#define MEDIUM_METALGRAD 9\n\n// \u2500\u2500 Metal \u2014 the two-term anisotropic BRDF over the field's own relief (uMedium==8/9,\n// BG.W-AUR-METAL-FINISH) \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\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// Metal is a MUTUALLY-EXCLUSIVE medium (NOT a finish axis) \u2014 the field re-lights as\n// warm folded metal: the luma HEIGHT field (the packed structure-tensor gradient \u2192\n// the surface normal) catches an anisotropic Blinn streak (brushed metal, the streak\n// runs ALONG the coherent edge-tangent) plus a sharp crest, both raked by a cursor-\n// synthesized light that reads on BOTH backends (uCursor is in-struct \u2014 a phantom\n// uLightDir read would be flat on the WGSL primary). The catch is the ACHROMATIC-WARM\n// anchor (AURORA_CATCH_LIGHT_ANCHOR \u2248 [1.0,0.97,0.90], never a cold chrome-blue). The\n// body keeps the field HUE (technicolor valley base); the height rides the relief.\n// ZERO new taps \u2014 structureTensorField ALREADY computed the gradient (unpacked from .w).\nconst vec3  METAL_CATCH_WARM       = vec3(1.0, 0.97, 0.90); // AURORA_CATCH_LIGHT_ANCHOR\nconst float METAL_HEIGHT_SCALE     = 2.2;   // gradient \u2192 normal tilt (\u00D7 uMetalHeightScale)\nconst float METAL_LIGHT_Z          = 0.55;  // synth-light z (toward viewer)\nconst vec2  METAL_IDLE_RAKE        = vec2(0.32, 0.34); // upper-right idle rake bias\nconst float METAL_SHININESS_ANISO  = 6.0;   // anisotropic streak exponent (brushed)\nconst float METAL_SHININESS_CREST  = 40.0;  // crest specular exponent (sharp)\nconst float METAL_COHERENCE_FLOOR  = 0.22;  // streak gates on edge coherence A\nconst float METAL_BODY_FLOOR       = 0.42;  // diffuse valley floor (dark side reads)\nconst float METAL_GRADIENT_FLATTEN = 0.55;  // metal-gradient pre-flatten toward luma\nconst float METAL_SPARKLE_DENSITY  = 240.0; // metal-gradient per-cell flake grid\nconst float METAL_SPARKLE_THRESH   = 0.72;  // only some cells flake\nconst float METAL_SPARKLE_AMP      = 0.6;   // flake glint amplitude\n\n// The shared metal BRDF core \u2014 takes the ALREADY-computed structureTensorField vec4 so\n// the caller pays ZERO extra taps (metal-gradient reuses the same stf). WebKit-fenced:\n// every pow base is clamped to [0,1], the exponents are compile-time constants.\nvec3 metalShade(vec3 baseCol, vec2 p, vec4 stf) {\n  vec2 tangent = stf.xy;\n  float A = stf.z;\n  vec2 grad = unpackGrad(stf.w);\n  // Height-field normal: N = normalize(vec3(grad * scale, 1)). The luma relief tilts\n  // the surface; the flat field reads near vec3(0,0,1) (facing the viewer).\n  vec3 N = normalize(vec3(grad * (METAL_HEIGHT_SCALE * uMetalHeightScale), 1.0));\n  vec3 V = vec3(0.0, 0.0, 1.0);\n  // Cursor-synthesized rake light (in-struct on BOTH backends \u2014 never uLightDir). The\n  // idle bias keeps a still field lit from the upper-right; a moving cursor rakes it.\n  vec3 L = normalize(vec3((uCursor - p) + METAL_IDLE_RAKE, METAL_LIGHT_Z));\n  vec3 H = normalize(L + V);\n  // Anisotropic streak \u2014 brushed metal: the highlight runs ALONG the edge-tangent, so\n  // it is a function of the H-component PERPENDICULAR to the tangent (sinTH).\n  float tH = dot(normalize(tangent), H.xy);\n  float sinTH = sqrt(clamp(1.0 - tH * tH, 0.0, 1.0));\n  float streak = pow(clamp(sinTH, 0.0, 1.0), METAL_SHININESS_ANISO);\n  float crest  = pow(clamp(dot(N, H), 0.0, 1.0), METAL_SHININESS_CREST);\n  float spec = streak * crest;\n  // Coherence gate \u2014 the anisotropic streak reads only where the field has a real edge\n  // (a flat zone has no brush direction; A\u22480 \u2192 no streak).\n  spec *= smoothstep(0.0, METAL_COHERENCE_FLOOR, A);\n  // Technicolor valley base \u2014 the body keeps the FIELD hue; the diffuse term rides the\n  // height relief so the ridges brighten and the pits fall toward the floor.\n  float diff = clamp(dot(N, L), 0.0, 1.0);\n  vec3 body = baseCol * (METAL_BODY_FLOOR + (1.0 - METAL_BODY_FLOOR) * diff);\n  // The catch is the achromatic-warm anchor, scaled by the polish knob.\n  return body + METAL_CATCH_WARM * (spec * clamp(uMetalPolish, 0.0, 4.0));\n}\n\nvec3 mediumMetal(vec3 col, vec2 p, float t) {\n  vec4 stf = structureTensorField(p, t, flowField(p, t));\n  return metalShade(col, p, stf);\n}\n\n// metal-gradient (uMedium==9) \u2014 the SAME BRDF over a pre-flattened/gradient base + a\n// twinkle-in-place flake sparkle (position FIXED per cell, PHASE-animated, gated on\n// facing \u2014 flake glint, never a boil).\nvec3 mediumMetalGradient(vec3 col, vec2 p, float t) {\n  vec4 stf = structureTensorField(p, t, flowField(p, t));\n  // Pre-flatten toward luma (the smoother gradient-metallic base) \u2014 same BRDF, calmer body.\n  // NB: flat is a GLSL reserved interpolation qualifier \u2014 WebKit's compiler REJECTS it as an\n  // identifier (ANGLE tolerates it); named flatCol so the WebKit aurora shader compiles (L1a).\n  vec3 flatCol = mix(col, vec3(dot(col, W_LUMA)), METAL_GRADIENT_FLATTEN);\n  vec3 metal = metalShade(flatCol, p, stf);\n  // The height-field normal facing (recomputed from the same packed gradient \u2014 ZERO taps).\n  vec2 grad = unpackGrad(stf.w);\n  float facing = normalize(vec3(grad * (METAL_HEIGHT_SCALE * uMetalHeightScale), 1.0)).z;\n  // Twinkle-in-place: a fixed per-cell flake seed, phase-animated glint gated on facing.\n  vec2 cell = floor(p * METAL_SPARKLE_DENSITY);\n  float seed = hash21(cell);\n  float tw = pow(clamp(sin(t + seed * 6.2831853), 0.0, 1.0), 40.0);\n  float flakeGate = step(METAL_SPARKLE_THRESH, seed);\n  metal += METAL_CATCH_WARM * (tw * flakeGate * clamp(facing, 0.0, 1.0) * METAL_SPARKLE_AMP);\n  return metal;\n}\n";
+export declare const AURORA_METAL_PACK_GLSL = "\n// \u2500\u2500 Gradient pack \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// structureTensorField re-plumbs its already-computed luma gradient (Gx,Gy) out through\n// the vec4 return value's .w lane so the metal medium pays ZERO extra taps (a second Sobel is\n// 8 sampleBase() taps). 12 bits per bounded component ([-4,4]) into one f32, exact under\n// highp; the .xy/.z crayon/kuwahara callers are transparent to the widen.\nfloat packGrad(float gx, float gy) {\n  float qx = floor(clamp(gx * 0.125 + 0.5, 0.0, 1.0) * 4095.0);\n  float qy = floor(clamp(gy * 0.125 + 0.5, 0.0, 1.0) * 4095.0);\n  return qx + qy * 4096.0;\n}\nvec2 unpackGrad(float packed) {\n  float qy = floor(packed * (1.0 / 4096.0));\n  float qx = packed - qy * 4096.0;\n  return (vec2(qx, qy) * (1.0 / 4095.0) - 0.5) * 8.0;\n}\n";
+export declare const AURORA_METAL_MEDIUM_GLSL = "#define MEDIUM_METAL 8\n#define MEDIUM_METALGRAD 9\n\n// \u2500\u2500 Metal \u2014 two-term anisotropic BRDF over the field relief (uMedium==8/9) \u2500\u2500\n// Metal is a MUTUALLY-EXCLUSIVE medium (NOT a finish axis) \u2014 the field re-lights as\n// warm folded metal: the luma HEIGHT field (the packed structure-tensor gradient \u2192\n// the surface normal) catches an anisotropic Blinn streak (brushed metal, the streak\n// runs ALONG the coherent edge-tangent) plus a sharp crest, both raked by a cursor-\n// synthesized light that reads on BOTH backends (uCursor is in-struct \u2014 a phantom\n// uLightDir read would be flat on the WGSL primary). The catch is the ACHROMATIC-WARM\n// anchor (AURORA_CATCH_LIGHT_ANCHOR \u2248 [1.0,0.97,0.90], never a cold chrome-blue). The\n// body keeps the field HUE (technicolor valley base); the height rides the relief.\n// ZERO new taps \u2014 structureTensorField already computed the gradient (unpacked from .w).\nconst vec3  METAL_CATCH_WARM       = vec3(1.0, 0.97, 0.90); // AURORA_CATCH_LIGHT_ANCHOR\nconst float METAL_HEIGHT_SCALE     = 2.2;   // gradient \u2192 normal tilt (\u00D7 uMetalHeightScale)\nconst float METAL_LIGHT_Z          = 0.55;  // synth-light z (toward viewer)\nconst vec2  METAL_IDLE_RAKE        = vec2(0.32, 0.34); // upper-right idle rake bias\nconst float METAL_SHININESS_ANISO  = 6.0;   // anisotropic streak exponent (brushed)\nconst float METAL_SHININESS_CREST  = 40.0;  // crest specular exponent (sharp)\nconst float METAL_COHERENCE_FLOOR  = 0.22;  // streak gates on edge coherence A\nconst float METAL_BODY_FLOOR       = 0.42;  // diffuse valley floor (dark side reads)\nconst float METAL_GRADIENT_FLATTEN = 0.55;  // metal-gradient pre-flatten toward luma\nconst float METAL_SPARKLE_DENSITY  = 240.0; // metal-gradient per-cell flake grid\nconst float METAL_SPARKLE_THRESH   = 0.72;  // only some cells flake\nconst float METAL_SPARKLE_AMP      = 0.6;   // flake glint amplitude\n\n// The shared metal BRDF core \u2014 takes the ALREADY-computed structureTensorField vec4 so\n// the caller pays ZERO extra taps (metal-gradient reuses the same stf). WebKit-fenced:\n// every pow base is clamped to [0,1], the exponents are compile-time constants.\nvec3 metalShade(vec3 baseCol, vec2 p, vec4 stf) {\n  vec2 tangent = stf.xy;\n  float A = stf.z;\n  vec2 grad = unpackGrad(stf.w);\n  // Height-field normal: N = normalize(vec3(grad * scale, 1)). The luma relief tilts\n  // the surface; the flat field reads near vec3(0,0,1) (facing the viewer).\n  vec3 N = normalize(vec3(grad * (METAL_HEIGHT_SCALE * uMetalHeightScale), 1.0));\n  vec3 V = vec3(0.0, 0.0, 1.0);\n  // Cursor-synthesized rake light (in-struct on BOTH backends \u2014 never uLightDir). The\n  // idle bias keeps a still field lit from the upper-right; a moving cursor rakes it.\n  vec3 L = normalize(vec3((uCursor - p) + METAL_IDLE_RAKE, METAL_LIGHT_Z));\n  vec3 H = normalize(L + V);\n  // Anisotropic streak \u2014 brushed metal: the highlight runs ALONG the edge-tangent, so\n  // it is a function of the H-component PERPENDICULAR to the tangent (sinTH).\n  float tH = dot(normalize(tangent), H.xy);\n  float sinTH = sqrt(clamp(1.0 - tH * tH, 0.0, 1.0));\n  float streak = pow(clamp(sinTH, 0.0, 1.0), METAL_SHININESS_ANISO);\n  float crest  = pow(clamp(dot(N, H), 0.0, 1.0), METAL_SHININESS_CREST);\n  float spec = streak * crest;\n  // Coherence gate \u2014 the anisotropic streak reads only where the field has a real edge\n  // (a flat zone has no brush direction; A\u22480 \u2192 no streak).\n  spec *= smoothstep(0.0, METAL_COHERENCE_FLOOR, A);\n  // Technicolor valley base \u2014 the body keeps the FIELD hue; the diffuse term rides the\n  // height relief so the ridges brighten and the pits fall toward the floor.\n  float diff = clamp(dot(N, L), 0.0, 1.0);\n  vec3 body = baseCol * (METAL_BODY_FLOOR + (1.0 - METAL_BODY_FLOOR) * diff);\n  // The catch is the achromatic-warm anchor, scaled by the polish knob.\n  return body + METAL_CATCH_WARM * (spec * clamp(uMetalPolish, 0.0, 4.0));\n}\n\nvec3 mediumMetal(vec3 col, vec2 p, float t) {\n  vec4 stf = structureTensorField(p, t, flowField(p, t));\n  return metalShade(col, p, stf);\n}\n\n// metal-gradient (uMedium==9) \u2014 the SAME BRDF over a pre-flattened/gradient base + a\n// twinkle-in-place flake sparkle (position FIXED per cell, PHASE-animated, gated on\n// facing \u2014 flake glint, never a boil).\nvec3 mediumMetalGradient(vec3 col, vec2 p, float t) {\n  vec4 stf = structureTensorField(p, t, flowField(p, t));\n  // Pre-flatten toward luma (the smoother gradient-metallic base) \u2014 same BRDF, calmer body.\n  // NB: flat is a GLSL reserved interpolation qualifier \u2014 WebKit's compiler REJECTS it as an\n  // identifier (ANGLE tolerates it); named flatCol so the WebKit aurora shader compiles (L1a).\n  vec3 flatCol = mix(col, vec3(dot(col, W_LUMA)), METAL_GRADIENT_FLATTEN);\n  vec3 metal = metalShade(flatCol, p, stf);\n  // The height-field normal facing (recomputed from the same packed gradient \u2014 ZERO taps).\n  vec2 grad = unpackGrad(stf.w);\n  float facing = normalize(vec3(grad * (METAL_HEIGHT_SCALE * uMetalHeightScale), 1.0)).z;\n  // Twinkle-in-place: a fixed per-cell flake seed, phase-animated glint gated on facing.\n  vec2 cell = floor(p * METAL_SPARKLE_DENSITY);\n  float seed = hash21(cell);\n  float tw = pow(clamp(sin(t + seed * 6.2831853), 0.0, 1.0), 40.0);\n  float flakeGate = step(METAL_SPARKLE_THRESH, seed);\n  metal += METAL_CATCH_WARM * (tw * flakeGate * clamp(facing, 0.0, 1.0) * METAL_SPARKLE_AMP);\n  return metal;\n}\n";

package/dist/components/aurora/constants/shaders/oil-modes.glsl.d.ts

@@ -1 +1 @@
-export declare const AURORA_OIL_MODES_GLSL = "StrokeProfile profileFor(int medium, int mode) {\n  // The oil baseline (mode 0) \u2014 balanced modern-abstract/palette-knife hybrid.\n  StrokeProfile prof = StrokeProfile(\n    0,      // shapeType \u2014 tapered\n    0.25,   // bristleAmp\n    9.0,    // streakFreq\n    0.09,   // streakAmp\n    0.9,    // impastoAmp\n    0.80,   // hardness\n    340.0,  // toothScale \u2014 W-AUR-VANGOGH-CONFIG reconcile: FINER 240 \u2192 340. Oil's \u00A74.3 \u03B2 sat\n            //               right AT the \u22121.45 band ceiling (\u00B10.02 frame variance straddling\n            //               it, surfaced once the vangogh bands went green and the spec reached\n            //               the oil \u03B2 assert). MEASURED on the live GPU: ADDING fine high-\n            //               frequency tooth energy steepens oil's power-spectrum slope (more\n            //               negative \u2014 coarsening it the other way pushed \u03B2 SHALLOWER to\n            //               \u22121.33). A finer, stronger tooth moves \u03B2 to a safe distance inside\n            //               the \u22125/3 band [\u22121.85, \u22121.45]. Oil-only (oil-pastel sets 280).\n    0.14,   // toothAmp \u2014 raised 0.09 \u2192 0.14 (same oil-\u03B2 steepen: more fine-grain high band).\n    1.03,   // pigmentSat\n    0.65,   // densityBig\n    0.78,   // densityMed\n    0.90,   // densitySml\n    0.0,    // energyGrade \u2014 oil is uniform-length (no Starry-Night cascade)\n    0.4,    // impastoFloor \u2014 oil's 0.4+0.6\u00B7edgeN crown falloff\n    0.92,   // densityFill \u2014 oil fills DENSELY with the directional low-relief fill so the\n            //               flat-colour regions between the macro strokes are TEXTURED with\n            //               flow-aligned fine strokes (the \u00A74.2 anisotropy needs every pixel\n            //               to carry directional gradient; a flat untextured region reads as\n            //               an isotropic/degenerate tensor and drags mean A down). The fill\n            //               is now directional + low-streak, so dense coverage textures\n            //               WITHOUT the prior round-dab speckle.\n    1.0     // groundFloor \u2014 oil keeps the full base (no ground darken; fills everywhere)\n  );\n\n  // W-AUR-VANGOGH-REBUILD \u2014 the van-Gogh medium NO LONGER routes through this oil\n  // StrokeProfile cascade. It is a DEDICATED atomic-dab body (mediumVangogh / vangoghDab\n  // below) \u2014 the prior profile-driven cascade (four dense layers of long-thin\n  // tensor-oriented strokes) merged into the \"marbled flow-bands\" read and ran at ~4fps.\n  // profileFor now serves ONLY the oil + oil-pastel stroke mediums; the MEDIUM_VANGOGH\n  // case is removed (no caller). MEDIUM_VANGOGH stays #define'd (the main() dispatch +\n  // isPainterlyStroke still key off uMedium==5).\n\n  // \u2500\u2500 Oil-pastel \u2014 broad smeared directional strokes deposited via the brush engine\n  // (slice 8 F1). Creamy soft edges (low hardness), heavy build-up, and a chroma punch.\n  // Distinct from the dry-crayon tooth-multiply (mediumCrayon): oil-pastel LAYS strokes.\n  if (medium == MEDIUM_OILPASTEL) {\n    prof.shapeType   = 0;     // tapered directional smear \u2014 a round dab reads locally\n                              // isotropic (steep \u03B2 / low A); the creamy oil-pastel mark\n                              // is a broad DIRECTIONAL smear, which carries the \u00A74.2\n                              // coherence + adds the directional mid-band the \u00A74.3 slope\n                              // needs (the round-dab profile rolled \u03B2 off to \u22122.8)\n    prof.bristleAmp  = 0.10;  // smooth creamy edges (waxy pastel, not bristle)\n    prof.streakFreq  = 18.0;  // finer internal smear \u2014 adds the mid/high-band the smooth\n                              // round-dab profile lacked (the \u03B2-too-steep fix); the\n                              // directional along-spine streak flattens the \u00A74.3 slope\n                              // without crossing the strokes\n    prof.streakAmp   = 0.20;\n    prof.impastoAmp  = 0.7;   // build-up, but flatter than oil impasto\n    prof.hardness    = 0.42;  // CREAMY \u2014 soft compositing, strokes blend on overlap\n    prof.toothScale  = 280.0;\n    prof.toothAmp    = 0.12;  // the pastel tooth reads stronger\n    prof.pigmentSat  = 0.80;  // the waxy chroma \u2014 eased off 1.16 so the rendered C clears\n                              // the \u00A74.1 band ceiling with margin while the K-M subtractive\n                              // overlap path (paintOverOklab) keeps the chroma OFF the grey floor\n    prof.hardness    = 0.58;  // creamy but the strokes still REGISTER \u2014 a too-soft blend\n                              // (0.42) smeared the marks into the smooth colour zones and\n                              // the field rolled off too steep (\u03B2\u2248\u22122.9, a near-gradient);\n                              // a crisper deposit keeps the mid/high-band the \u22125/3 slope needs\n    prof.densityBig  = 0.62;  // broad directional coverage \u2014 but NOT over-dense: too many\n                              // overlapping creamy strokes point in slightly-varied\n                              // directions and the local \u00A74.2 coherence DROPS (over-dense\n                              // measured A=0.57 < the 0.62-density A=0.63). The mid-density\n                              // flow-aligned deposit is the coherence sweet spot.\n    prof.densityMed  = 0.78;\n    prof.densitySml  = 0.90;\n    prof.energyGrade = 0.80;  // a strong Starry-Night length cascade \u2014 varies stroke length\n                              // by luma/coherence so the dab-size energy spreads across\n                              // scales (the \u22125/3 cascade the uniform-length 0.0 grade lacked,\n                              // the \u00A74.3 \u03B2-too-steep fix). Not the full van-Gogh 1.0 (oil-\n                              // pastel keeps its creamy broad character).\n    prof.impastoFloor = 0.55; // a softer crown than van-Gogh's full-height glint\n    return prof;\n  }\n\n  // \u2500\u2500 Oil sub-modes (mode dispatch on the oil medium).\n  if (mode == 1) {           // palette knife \u2014 razor edges, heavy impasto\n    prof.shapeType  = 3;     // flat, even\n    prof.bristleAmp = 0.12;\n    prof.streakFreq = 4.0;  prof.streakAmp = 0.05;\n    prof.impastoAmp = 1.6;\n    prof.hardness   = 0.95;\n    prof.toothAmp   = 0.04;\n    prof.densityBig = 0.80; prof.densityMed = 0.88; prof.densitySml = 0.70;\n  } else if (mode == 3) {    // thick brushwork \u2014 heavy bristle brush\n    prof.shapeType  = 0;     // tapered\n    prof.bristleAmp = 0.32;\n    prof.streakFreq = 14.0; prof.streakAmp = 0.14;\n    prof.impastoAmp = 1.2;\n    prof.hardness   = 0.85;\n    prof.toothAmp   = 0.07;\n  }\n  return prof;\n}\n";
+export declare const AURORA_OIL_MODES_GLSL = "StrokeProfile profileFor(int medium, int mode) {\n  // The oil baseline (mode 0) \u2014 balanced modern-abstract/palette-knife hybrid.\n  StrokeProfile prof = StrokeProfile(\n    0,      // shapeType \u2014 tapered\n    0.25,   // bristleAmp\n    9.0,    // streakFreq\n    0.09,   // streakAmp\n    0.9,    // impastoAmp\n    0.80,   // hardness\n    340.0,  // toothScale \u2014 finer 240 \u2192 340. Oil's \u03B2 sat\n            //               right AT the \u22121.45 band ceiling (\u00B10.02 frame variance straddling\n            //               it, surfaced once the vangogh bands went green and the spec reached\n            //               the oil \u03B2 assert). MEASURED on the live GPU: ADDING fine high-\n            //               frequency tooth energy steepens oil's power-spectrum slope (more\n            //               negative \u2014 coarsening it the other way pushed \u03B2 SHALLOWER to\n            //               \u22121.33). A finer, stronger tooth moves \u03B2 to a safe distance inside\n            //               the \u22125/3 band [\u22121.85, \u22121.45]. Oil-only (oil-pastel sets 280).\n    0.14,   // toothAmp \u2014 raised 0.09 \u2192 0.14 (same oil-\u03B2 steepen: more fine-grain high band).\n    1.03,   // pigmentSat\n    0.65,   // densityBig\n    0.78,   // densityMed\n    0.90,   // densitySml\n    0.0,    // energyGrade \u2014 oil is uniform-length (no Starry-Night cascade)\n    0.4,    // impastoFloor \u2014 oil's 0.4+0.6\u00B7edgeN crown falloff\n    0.92,   // densityFill \u2014 oil fills DENSELY with the directional low-relief fill so the\n            //               flat-colour regions between the macro strokes are TEXTURED with\n            //               flow-aligned fine strokes (the \u00A74.2 anisotropy needs every pixel\n            //               to carry directional gradient; a flat untextured region reads as\n            //               an isotropic/degenerate tensor and drags mean A down). The fill\n            //               is now directional + low-streak, so dense coverage textures\n            //               WITHOUT the round-dab speckle.\n    1.0     // groundFloor \u2014 oil keeps the full base (no ground darken; fills everywhere)\n  );\n\n  // The Van Gogh medium does NOT route through this oil\n  // StrokeProfile cascade. It is a DEDICATED atomic-dab body (mediumVangogh / vangoghDab\n  // below) \u2014 a profile-driven cascade (four dense layers of long-thin\n  // tensor-oriented strokes) merges into the \"marbled flow-bands\" read and runs at ~4fps.\n  // profileFor now serves ONLY the oil + oil-pastel stroke mediums; the MEDIUM_VANGOGH\n  // case is removed (no caller). MEDIUM_VANGOGH stays #define'd (the main() dispatch +\n  // isPainterlyStroke still key off uMedium==5).\n\n  // \u2500\u2500 Oil-pastel \u2014 broad smeared directional strokes deposited via the brush engine\n  // Creamy soft edges (low hardness), heavy build-up, and a chroma punch.\n  // Distinct from the dry-crayon tooth-multiply (mediumCrayon): oil-pastel LAYS strokes.\n  if (medium == MEDIUM_OILPASTEL) {\n    prof.shapeType   = 0;     // tapered directional smear \u2014 a round dab reads locally\n                              // isotropic (steep \u03B2 / low A); the creamy oil-pastel mark\n                              // is a broad DIRECTIONAL smear, which carries the \u00A74.2\n                              // coherence + adds the directional mid-band the \u00A74.3 slope\n                              // needs (the round-dab profile rolled \u03B2 off to \u22122.8)\n    prof.bristleAmp  = 0.10;  // smooth creamy edges (waxy pastel, not bristle)\n    prof.streakFreq  = 18.0;  // finer internal smear \u2014 adds the mid/high-band the smooth\n                              // round-dab profile lacked (the \u03B2-too-steep fix); the\n                              // directional along-spine streak flattens the \u00A74.3 slope\n                              // without crossing the strokes\n    prof.streakAmp   = 0.20;\n    prof.impastoAmp  = 0.7;   // build-up, but flatter than oil impasto\n    prof.hardness    = 0.42;  // CREAMY \u2014 soft compositing, strokes blend on overlap\n    prof.toothScale  = 280.0;\n    prof.toothAmp    = 0.12;  // the pastel tooth reads stronger\n    prof.pigmentSat  = 0.80;  // the waxy chroma \u2014 kept low so the rendered C clears\n                              // the \u00A74.1 band ceiling with margin while the K-M subtractive\n                              // overlap path (paintOverOklab) keeps the chroma OFF the grey floor\n    prof.hardness    = 0.58;  // creamy but the strokes still REGISTER \u2014 a too-soft blend\n                              // (0.42) smeared the marks into the smooth colour zones and\n                              // the field rolled off too steep (\u03B2\u2248\u22122.9, a near-gradient);\n                              // a crisper deposit keeps the mid/high-band the \u22125/3 slope needs\n    prof.densityBig  = 0.62;  // broad directional coverage \u2014 but NOT over-dense: too many\n                              // overlapping creamy strokes point in slightly-varied\n                              // directions and the local \u00A74.2 coherence DROPS (over-dense\n                              // measured A=0.57 < the 0.62-density A=0.63). The mid-density\n                              // flow-aligned deposit is the coherence sweet spot.\n    prof.densityMed  = 0.78;\n    prof.densitySml  = 0.90;\n    prof.energyGrade = 0.80;  // a strong Starry-Night length cascade \u2014 varies stroke length\n                              // by luma/coherence so the dab-size energy spreads across\n                              // scales (the \u22125/3 cascade the uniform-length 0.0 grade lacked,\n                              // the \u00A74.3 \u03B2-too-steep fix). Not the full van-Gogh 1.0 (oil-\n                              // pastel keeps its creamy broad character).\n    prof.impastoFloor = 0.55; // a softer crown than van-Gogh's full-height glint\n    return prof;\n  }\n\n  // \u2500\u2500 Oil sub-modes (mode dispatch on the oil medium).\n  if (mode == 1) {           // palette knife \u2014 razor edges, heavy impasto\n    prof.shapeType  = 3;     // flat, even\n    prof.bristleAmp = 0.12;\n    prof.streakFreq = 4.0;  prof.streakAmp = 0.05;\n    prof.impastoAmp = 1.6;\n    prof.hardness   = 0.95;\n    prof.toothAmp   = 0.04;\n    prof.densityBig = 0.80; prof.densityMed = 0.88; prof.densitySml = 0.70;\n  } else if (mode == 3) {    // thick brushwork \u2014 heavy bristle brush\n    prof.shapeType  = 0;     // tapered\n    prof.bristleAmp = 0.32;\n    prof.streakFreq = 14.0; prof.streakAmp = 0.14;\n    prof.impastoAmp = 1.2;\n    prof.hardness   = 0.85;\n    prof.toothAmp   = 0.07;\n  }\n  return prof;\n}\n";

package/dist/components/aurora/constants/shaders/vangogh-medium.glsl.d.ts

@@ -1 +1 @@
-export declare const AURORA_VANGOGH_MEDIUM_GLSL = "// \u2500\u2500 Van-Gogh \u2014 DEDICATED atomic-dab body (W-AUR-VANGOGH-REBUILD) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// REBUILT FROM FIRST PRINCIPLES. The prior path routed van-Gogh through the shared\n// oil paintStrokeMedium cascade \u2014 four DENSE layers of LONG-THIN tensor-oriented\n// strokes (lenMul up to 5.2, widMul 0.22) hugging a continuous coherent field. Packed\n// that tight, thin strokes that follow continuous iso-bands MERGE into smooth flowing\n// filaments \u2014 the \"marbled flow-bands\" read (a spirograph/fingerprint, not impasto),\n// AND the per-cell 8-tap structure tensor \u00D7 4 layers \u00D7 9 cells = ~324 sampleBase/pixel\n// made it run at ~4fps. Van Gogh's sky is NOT continuous flow \u2014 it is DISCRETE, SHORT,\n// LOADED comma dabs, separated by visible ground, queued into swirl ROWS.\n//\n// The rebuild is a purpose-built two-layer DAB pass, disjoint from the oil cascade:\n//   \u2022 orientation from the analytic SWIRL flowField (van-Gogh skies ARE swirl rows) +\n//     per-cell angular jitter \u2014 NOT the expensive per-cell tensor (the lag source, and\n//     the marble source: a jittered discrete dab can NOT merge into a continuous\n//     filament the way a tensor-locked thin stroke does).\n//   \u2022 SHORT comma dabs (len/wid \u2248 2.6 : 1 \u2014 a loaded crescent mark, not a 10:1\n//     filament), so each reads as a SEPARABLE atom.\n//   \u2022 SPARSE placement with visible inter-dab ground (density \u2248 0.42), over a darkened\n//     swirl underpainting (the Starry-Night visible ground the bright dabs read over).\n//   \u2022 a single sampleBase per cell + OKLCh broken-color jitter (pigment shimmer);\n//     full-height impasto crown per dab (each catches its own raked glint).\n// This is ~2 layers \u00D7 9 cells \u00D7 ~1 sampleBase \u2248 20/pixel (a ~16\u00D7 cost cut, ~60fps), and\n// jittered short dabs CANNOT marble.\n\n// One atomic comma dab \u2014 a CLEAN analytic crescent SDF (NOT the oil curvedStroke).\n// The oil curvedStroke's spine-projection + rounded end-caps + fwidth-AA + bristle\n// edge each leave a thin sub-pixel skirt, and a field of those skirts over open ground\n// abuts into a faint network of SEAM LINES. A van-Gogh dab needs none of that\n// machinery \u2014 it is a short oriented capsule (rounded line segment) whose half-width\n// tapers along its length (the loaded-head \u2192 dragged-tail comma). The capsule SDF is\n// derivative-free (smoothstep AA against the analytic distance), so no fwidth skirt, no\n// best-of-9 seam. Returns a StrokeHit (coverage/color/alongT/edgeN) for paintOver.\n//   cellSize \u2014 dab cell pitch (UV units); lenMul/widMul \u2014 dab aspect off the cell;\n//   density  \u2014 placement gate (sparse \u2192 visible gaps); seed \u2014 layer decorrelation.\nStrokeHit vangoghDab(vec2 p, float cellSize, float lenMul, float widMul,\n                     float density, float jitterAmt, float angJitter,\n                     vec2 flow, float t, float seed) {\n  vec2 cell = floor(p / cellSize);\n  StrokeHit best = noHit();\n  for (int dy = -1; dy <= 1; dy++) {\n    for (int dx = -1; dx <= 1; dx++) {\n      vec2 cc = cell + vec2(float(dx), float(dy));\n      // Sparse density gate \u2014 leaves visible canvas ground between dabs (atomicity).\n      if (hash21(cc * 1.7 + seed * 0.3) > density) continue;\n      vec2 jit = (hash22(cc + seed) - 0.5) * jitterAmt;\n      vec2 center = (cc + 0.5 + jit) * cellSize;\n\n      // Orientation: the analytic swirl flow at the cell center + per-cell angular\n      // jitter (so adjacent dabs FAN \u2014 the divisionist scatter that keeps the dabs from\n      // locking into perfectly-concentric rows) + a flow-noise curl wobble.\n      float ang = (hash21(cc + seed + 11.0) - 0.5) * angJitter;\n      float curl = (fbm(center * 3.1 + seed * 1.9) - 0.5) * (0.18 + 0.3 * uFlowCurl);\n      vec2 dir = rotateDir(safeDir(flow), ang + curl);\n\n      // SHORT comma \u2014 len \u2248 the cell pitch (a contained dab, not a tiling filament).\n      float len = cellSize * lenMul * (0.82 + 0.30 * hash21(cc + seed + 23.0));\n      float halfW = max(cellSize * widMul * (0.86 + 0.28 * hash21(cc + seed + 41.0)), 0.010);\n\n      // Local dab frame: along = projection onto the dab axis (centred 0), perp = cross.\n      vec2 rel = p - center;\n      float along = dot(rel, dir);\n      float perp  = dot(rel, vec2(-dir.y, dir.x));\n      // The comma TAPER: half-width peaks ~1/3 from the loaded head and drags to a fine\n      // tail (the asymmetric crescent). u in [0,1] along the dab from head to tail.\n      float halfLen = len * 0.5;\n      float u = clamp((along + halfLen) / max(len, 1e-5), 0.0, 1.0);\n      float head = smoothstep(0.0, 0.30, u);                 // rounded loaded head\n      float tail = pow(clamp((1.0 - u) / 0.70, 0.0, 1.0), 1.3); // dragged thin tail\n      float prof = clamp(min(head, tail) * 1.05, 0.0, 1.0);\n      float wNow = halfW * prof;\n      // A gentle comma CURVE \u2014 bow the spine sideways so the mark reads as a crescent.\n      float bowAmt = (hash21(cc + seed + 53.0) - 0.5) * halfW * 1.4;\n      float spine = bowAmt * sin(u * PI);                    // 0 at ends, max mid\n      float d = abs(perp - spine);\n      // Derivative-free AA: a fixed fraction of the dab width (no fwidth skirt). Coverage\n      // is 1 in the dab body, smoothly 0 at the edge; outside the [head,tail] span wNow\u21920\n      // so the dab self-terminates with no end-cap blob.\n      float aa = max(halfW * 0.45, 0.002);\n      float cov = (wNow > 1e-5) ? (1.0 - smoothstep(wNow - aa, wNow + aa, d)) : 0.0;\n      if (cov < 0.004) continue;\n\n      // One sampleBase per cell + OKLCh broken-color jitter (pigment patch shimmer). The\n      // dab pigment is chroma-boosted (saturate3 1.22) AND value-lifted (\u00D71.14) at the\n      // SOURCE \u2014 the loaded brush mark deposits BRIGHTER + more saturated pigment than the\n      // base field, so the loaded-mark pixels lift BOTH the \u00A74.1 colourfulness AND the field\n      // mean-luma. The higher mean raises the gap-fraction threshold (meanLum\u00B70.6) so the\n      // moderate-depth inter-dab ground falls below it (the gap-fraction atomicity read is\n      // DECOUPLED from the ground floor depth \u2014 the ground can stay only moderately dark, so\n      // the \u00A74.3 slope is NOT over-steepened, while the bright dabs manufacture the gap). The\n      // dark ground is untouched, so this lifts C + gap WITHOUT a band-conflicting deep ground.\n      vec3 colMid = brokenColorJitter(\n        saturate3(sampleBase(center, t), 1.22),\n        hash21(cc + seed + 89.0),\n        hash21(cc * 2.3 + seed + 97.0),\n        1.0\n      );\n\n      // edgeN: 1 at the spine, 0 at the edge (the impasto crown reads it).\n      float edgeN = (wNow > 1e-5) ? clamp(1.0 - d / wNow, 0.0, 1.0) : 0.0;\n      if (cov > best.coverage) {\n        best = StrokeHit(cov, colMid, u, (wNow > 1e-5 ? (perp - spine) / wNow : 0.0), edgeN);\n      }\n    }\n  }\n  return best;\n}\n\nvec3 mediumVangogh(vec3 col, vec2 p, float t) {\n  vec3 result = col;\n  float height = 0.0;\n\n  // The swirl flow basis (van-Gogh sky = swirl rows). Computed ONCE per pixel.\n  vec2 flow = flowField(p, t);\n\n  // Dab cell pitch in UV [0,1]. CHUNKY, SEPARABLE marks \u2014 the big layer is ~1/14 of\n  // the frame so it reads as a distinct loaded brush dab (not a fine speckle, not a\n  // screen-spanning filament). uStrokeScale (authored ~110) modulates the pitch\n  // INVERSELY (higher = finer dabs) around the ~0.07 chunky default; clamped so the\n  // dab never collapses to noise or balloons past one screen. uStrokeAnisotropy\n  // stretches the comma aspect (longer, more directional marks).\n  float pitch = clamp(7.0 / max(uStrokeScale, 20.0), 0.044, 0.12);\n  // The dab LENGTH \u2248 the cell pitch (lenAniso ~1.2-1.7) so a dab sits WITHIN its cell\n  // and leaves visible ground around it \u2014 a longer dab (lenMul > 2) spans neighbour\n  // cells and tiles the field into continuous coverage (no gaps, the gap-fraction floor\n  // miss + the marble). Narrow width keeps it a directional crescent, not a wide shard.\n  // lenAniso/widAniso \u2014 the comma aspect. The W-AUR-VANGOGH-CONFIG reconcile lengthened\n  // the comma (1.25-1.75 \u2192 1.5-2.0) and THINNED it (0.40-0.30 \u2192 0.32-0.24): the rebuilt\n  // dabs measured \u00A74.2 structure-tensor anisotropy A=0.699, BELOW the reference band\n  // floor 0.732 (the dabs read slightly too short-fat \u2192 locally isotropic, dragging mean\n  // A down). A LONGER, THINNER comma hugs the swirl-flow tangent more strongly so the\n  // rendered field reads coherent the way the tensor metric measures it (A lift), while\n  // the thinner width LEAVES MORE inter-dab ground (the gap-fraction atomicity read is\n  // preserved, not closed). The length stays \u2248 the cell pitch so each dab remains a\n  // CONTAINED separable mark, not a tiling filament.\n  float lenAniso = mix(2.1, 2.7, uStrokeAnisotropy);   // comma length / cell pitch (a contained dab)\n  float widAniso = mix(0.23, 0.16, uStrokeAnisotropy); // comma width / cell pitch (a thin loaded crescent)\n\n  // Layer 1 \u2014 the big swirl-row dabs: the loaded gestural marks, SPARSE so the dark\n  // underpainting shows BETWEEN them (the atomicity read \u2014 visible inter-dab ground).\n  // hardness 0.74 \u2014 the loaded brush deposits with a SOFT shoulder, so adjacent dabs\n  // feather instead of razor-clipping into hard polygon shards. jitterAmt 0.85 fully\n  // scatters the cell centres so the placement GRID never reads as a periodic seam.\n  // angJitter EASED 0.55 \u2192 0.38 (the reconcile A lift): a tighter angular spread keeps\n  // adjacent dabs more flow-aligned (coherent) while the per-cell curl wobble still\n  // breaks the perfectly-concentric-rows read (the dabs FAN gently, not lock to a grid).\n  // angJitter eased 0.38 \u2192 0.26 + hardness 0.74 \u2192 0.84 (the \u00A74.2 A lift): a tighter angular\n  // spread keeps adjacent dabs strongly flow-aligned (the structure-tensor coherence) and a\n  // sharper edge gives each dab a STRONGER directional gradient (a soft dab's faint edge\n  // reads weakly anisotropic). The per-cell curl wobble still breaks the perfectly-\n  // concentric-rows read, so the dabs FAN gently rather than locking to a grid.\n  StrokeHit dBig = vangoghDab(p, pitch, lenAniso, widAniso,\n                              0.30, 0.50, 0.08, flow, t, 1.3);\n  // streakFreq raised 14 \u2192 34 (the \u00A74.3 slope fix): a high-frequency streak runs ALONG the\n  // dab spine, injecting fine-scale luma energy that flattens the too-steep \u03B2 WITHOUT\n  // adding new isotropic marks (the along-spine streak stays directional, so the \u00A74.2\n  // anisotropy the long-thin dab carries is preserved \u2014 the band-conflict resolution).\n  paintOver(result, height, dBig, 48.0, 0.34,\n            uImpasto * 0.75 * uStrokeAmount, 0.84, 1.3, 1.0 /* full crown */);\n\n  // Layer 2 \u2014 two-thirds-pitch accent dabs (the divisionist sparkle between the big\n  // marks \u2014 denser placement but still contained dabs, so dark canvas survives between).\n  // angJitter eased 0.5 \u2192 0.34 (same A-lift reasoning \u2014 the accent dabs queue along the\n  // flow rather than scattering isotropically); hardness 0.78 \u2192 0.86 sharpens the gradient.\n  StrokeHit dSml = vangoghDab(p + vec2(-5.1, 8.4), pitch * 0.62, lenAniso * 0.95,\n                              widAniso * 0.95, 0.36, 0.60, 0.20, flow, t, 4.1);\n  paintOver(result, height, dSml, 42.0, 0.22,\n            uImpasto * 0.55 * uStrokeAmount, 0.86, 4.1, 1.0);\n\n  // Layer 3 \u2014 the FINE divisionist flecks (W-AUR-VANGOGH-CONFIG reconcile). The two-layer\n  // field read as a few BIG cobalt dabs over a smooth empty teal ground (the side-by-side\n  // against starry-night-crop.png: the painting is DENSE small varied flecks, not sparse\n  // large marks). The flecks are LONG\u00B7THIN directional commas hugging the swirl tangent\n  // (the A-preserving fleck \u2014 short fat flecks read isotropic and drag \u00A74.2 down). Sparse\n  // density 0.30 keeps the inter-fleck ground open (the gap-fraction atomicity read).\n  // The flecks are FINE (\u22480.42\u00D7 pitch) directional commas, tightly flow-aligned (angJitter\n  // 0.22) and SPARSE (0.30) \u2014 the divisionist sparkle between the loaded marks that keeps\n  // the inter-dab ground open (atomicity) while adding the small-mark mid-band energy. Thin\n  // + flow-aligned so the \u00A74.2 anisotropy the long dabs carry survives the added small marks.\n  StrokeHit dFleck = vangoghDab(p + vec2(8.7, -3.2), pitch * 0.42, lenAniso * 1.0,\n                                widAniso * 0.68, 0.30, 0.85, 0.22, flow, t, 7.7);\n  paintOver(result, height, dFleck, 30.0, 0.16,\n            uImpasto * 0.40 * uStrokeAmount, 0.80, 7.7, 1.0);\n\n  // \u2500\u2500 Flow-aligned GROUND swirl-GROOVING (W-AUR-VANGOGH-CONFIG reconcile) \u2500\u2500\n  // The bare ground between the dabs was a SMOOTH low-frequency teal gradient \u2014 the \u00A74.3\n  // power-spectrum slope ran too STEEP (\u03B2\u2248\u22122.0: too much low-frequency nuclei-field energy\n  // vs the high band). Van Gogh's actual sky has the swirl BRUSHWORK everywhere, so groove\n  // the OPEN GROUND with a flow-aligned ripple. It is SUBTRACTIVE-biased (it only darkens,\n  // never brightens the ground), so it DEEPENS the inter-dab valleys (MORE gap-fraction \u2014\n  // atomicity preserved/strengthened) while injecting the across-flow mid-band luma energy\n  // that flattens \u03B2. Gated to the open ground (low height) via the (1-height) gate so it\n  // never lifts/erodes the loaded dab bodies (the dab read is untouched). Across the swirl\n  // FLOW axis so the grooves run WITH the sky's brushwork direction.\n  // The ground swirl-combing \u2014 a FIXED-global-angle directional grain on the open ground.\n  // A flow-FOLLOWING comb varies its direction with the swirl across the readback window,\n  // so its blurred structure tensor averages toward isotropic (no \u00A74.2 lift). A comb at one\n  // GLOBAL angle (van-Gogh's dominant diagonal stroke grain) is COHERENT over the whole\n  // window \u21D2 every open-ground pixel reads the SAME direction (the \u00A74.2 mean-anisotropy lift\n  // the swirl comb could not reach). Two resolved bands (\u224822 + \u224844 across the global axis \u21D2\n  // ~21px + ~11px at 464px, both in the \u00A74.3 fit window) also feed the \u03B2 flatten. Gated to\n  // the open ground (low height) so the loaded dabs are untouched; SUBTRACTIVE-biased so the\n  // inter-dab valleys deepen (gap-fraction preserved, not filled).\n  vec2 gdir = normalize(vec2(0.82, 0.57));   // the dominant global stroke grain axis\n  float gacross = dot(p, vec2(-gdir.y, gdir.x));\n  float groundGate = 1.0 - smoothstep(0.05, 0.28, height);\n  float groove = sin(gacross * 22.0) + 0.5 * sin(gacross * 44.0 + 1.3);\n  result *= 1.0 - 0.16 * groundGate * (0.5 - 0.5 * groove);\n\n  // Canvas tooth (fine linen weave \u2014 base relief the raking light catches).\n  float tooth1 = vnoise(p * 220.0);\n  float tooth2 = vnoise(p * 220.0 * vec2(0.6, 2.4) + 37.0);\n  float tooth  = (0.6 * tooth1 + 0.4 * tooth2) - 0.5;\n  result *= 1.0 + tooth * 0.06 * uCanvasGrain;\n\n  // Relight the accumulated impasto height (raking light catches each dab's crown \u2014\n  // the visible impasto ridge that makes a dab read as a RAISED loaded mark).\n  float canvasBase = tooth * 0.06 * 0.5;\n  result = relightImpasto(result, height, canvasBase);\n\n  // The visible Starry-Night GROUND \u2014 the open canvas between dabs (low accumulated\n  // height) darkens toward the deep underpainting, so the bright impasto dabs read as\n  // SEPARABLE atomic marks over a darker field (the dab\u2194ground contrast the user's\n  // \"reads as strokes\" bar needs, AND the painterly-statistics gap-fraction floor \u2014 the\n  // dark inter-dab ground must register as a measurable fraction of the field). 0.30\n  // floor over a WIDER smoothstep (0..0.40): deep enough that the open gaps read as the\n  // dark Starry-Night sky between marks (clearing the 4% gap floor) while the gradual\n  // ramp keeps the gaps reading as flowing underpainting, not the hard black ink LINES a\n  // narrow near-black step (0.26 / 0.0..0.32) produced.\n  // The smoothstep FLOOR starts at 0.10 (not 0): a dab's faint AA coverage TAIL deposits\n  // a sliver of height, and where many tails align along the swirl flow those slivers\n  // accumulate into a faint continuous height ridge that read as thin curved LINES in the\n  // ground. Holding the ground full-dark until a real dab CORE (height > 0.10) lifts out\n  // keeps the open field clean \u2014 only the loaded dab bodies emerge, the tails stay ground.\n  result *= mix(0.115, 1.0, smoothstep(0.085, 0.31, height));\n\n  // The van-Gogh chroma \u2014 a light OKLCh punch. EASED to 0.92 (off 1.04) in the\n  // W-AUR-VANGOGH-CONFIG reconcile: the rebuilt discrete-dab register's per-dab OKLCh\n  // broken-color jitter (the \u00B116\u00B0 hue + \u00B1chroma swing per cell) lifts the field's\n  // colourfulness on its own, so the prior 1.04 punch on TOP overshot the \u00A74.1\n  // reference band (rendered C=100.5 vs the painting's measured 70.67 \u00B1 15/+25 \u2192\n  // ceiling 95.67 \u2014 neon, not Starry Night's rich-but-not-garish blue/gold). The 0.92\n  // demote pulls the rendered colourfulness back IN-band while the broken-color jitter\n  // keeps the per-dab pigment variation (the discrete-stroke read is untouched \u2014 this\n  // is a chroma scale, not a dab-geometry change). Band-anchored on the real painting\n  // (proof:aurora-arresting), NOT a widened band.\n  result = saturate3(result, 1.0);\n  return result;\n}\n\n";
+export declare const AURORA_VANGOGH_MEDIUM_GLSL = "// \u2500\u2500 Van Gogh atomic-dab body \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\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// Van-Gogh does NOT route through the shared\n// oil paintStrokeMedium cascade \u2014 four DENSE layers of LONG-THIN tensor-oriented\n// strokes (lenMul up to 5.2, widMul 0.22) hugging a continuous coherent field. Packed\n// that tight, thin strokes that follow continuous iso-bands MERGE into smooth flowing\n// filaments \u2014 the \"marbled flow-bands\" read (a spirograph/fingerprint, not impasto),\n// AND the per-cell 8-tap structure tensor \u00D7 4 layers \u00D7 9 cells = ~324 sampleBase/pixel\n// runs at ~4fps. Van Gogh's sky is NOT continuous flow \u2014 it is DISCRETE, SHORT,\n// LOADED comma dabs, separated by visible ground, queued into swirl ROWS.\n//\n// This is a purpose-built two-layer DAB pass, disjoint from the oil cascade:\n//   \u2022 orientation from the analytic SWIRL flowField (van-Gogh skies ARE swirl rows) +\n//     per-cell angular jitter \u2014 NOT the expensive per-cell tensor (the lag source, and\n//     the marble source: a jittered discrete dab can NOT merge into a continuous\n//     filament the way a tensor-locked thin stroke does).\n//   \u2022 SHORT comma dabs (len/wid \u2248 2.6 : 1 \u2014 a loaded crescent mark, not a 10:1\n//     filament), so each reads as a SEPARABLE atom.\n//   \u2022 SPARSE placement with visible inter-dab ground (density \u2248 0.42), over a darkened\n//     swirl underpainting (the Starry-Night visible ground the bright dabs read over).\n//   \u2022 a single sampleBase per cell + OKLCh broken-color jitter (pigment shimmer);\n//     full-height impasto crown per dab (each catches its own raked glint).\n// This is ~2 layers \u00D7 9 cells \u00D7 ~1 sampleBase \u2248 20/pixel (a ~16\u00D7 cost cut, ~60fps), and\n// jittered short dabs CANNOT marble.\n\n// One atomic comma dab \u2014 a CLEAN analytic crescent SDF (NOT the oil curvedStroke).\n// The oil curvedStroke's spine-projection + rounded end-caps + fwidth-AA + bristle\n// edge each leave a thin sub-pixel skirt, and a field of those skirts over open ground\n// abuts into a faint network of SEAM LINES. A van-Gogh dab needs none of that\n// machinery \u2014 it is a short oriented capsule (rounded line segment) whose half-width\n// tapers along its length (the loaded-head \u2192 dragged-tail comma). The capsule SDF is\n// derivative-free (smoothstep AA against the analytic distance), so no fwidth skirt, no\n// best-of-9 seam. Returns a StrokeHit (coverage/color/alongT/edgeN) for paintOver.\n//   cellSize \u2014 dab cell pitch (UV units); lenMul/widMul \u2014 dab aspect off the cell;\n//   density  \u2014 placement gate (sparse \u2192 visible gaps); seed \u2014 layer decorrelation.\nStrokeHit vangoghDab(vec2 p, float cellSize, float lenMul, float widMul,\n                     float density, float jitterAmt, float angJitter,\n                     vec2 flow, float t, float seed) {\n  vec2 cell = floor(p / cellSize);\n  StrokeHit best = noHit();\n  for (int dy = -1; dy <= 1; dy++) {\n    for (int dx = -1; dx <= 1; dx++) {\n      vec2 cc = cell + vec2(float(dx), float(dy));\n      // Sparse density gate \u2014 leaves visible canvas ground between dabs (atomicity).\n      if (hash21(cc * 1.7 + seed * 0.3) > density) continue;\n      vec2 jit = (hash22(cc + seed) - 0.5) * jitterAmt;\n      vec2 center = (cc + 0.5 + jit) * cellSize;\n\n      // Orientation: the analytic swirl flow at the cell center + per-cell angular\n      // jitter (so adjacent dabs FAN \u2014 the divisionist scatter that keeps the dabs from\n      // locking into perfectly-concentric rows) + a flow-noise curl wobble.\n      float ang = (hash21(cc + seed + 11.0) - 0.5) * angJitter;\n      float curl = (fbm(center * 3.1 + seed * 1.9) - 0.5) * (0.18 + 0.3 * uFlowCurl);\n      vec2 dir = rotateDir(safeDir(flow), ang + curl);\n\n      // SHORT comma \u2014 len \u2248 the cell pitch (a contained dab, not a tiling filament).\n      float len = cellSize * lenMul * (0.82 + 0.30 * hash21(cc + seed + 23.0));\n      float halfW = max(cellSize * widMul * (0.86 + 0.28 * hash21(cc + seed + 41.0)), 0.010);\n\n      // Local dab frame: along = projection onto the dab axis (centred 0), perp = cross.\n      vec2 rel = p - center;\n      float along = dot(rel, dir);\n      float perp  = dot(rel, vec2(-dir.y, dir.x));\n      // The comma TAPER: half-width peaks ~1/3 from the loaded head and drags to a fine\n      // tail (the asymmetric crescent). u in [0,1] along the dab from head to tail.\n      float halfLen = len * 0.5;\n      float u = clamp((along + halfLen) / max(len, 1e-5), 0.0, 1.0);\n      float head = smoothstep(0.0, 0.30, u);                 // rounded loaded head\n      float tail = pow(clamp((1.0 - u) / 0.70, 0.0, 1.0), 1.3); // dragged thin tail\n      float prof = clamp(min(head, tail) * 1.05, 0.0, 1.0);\n      float wNow = halfW * prof;\n      // A gentle comma CURVE \u2014 bow the spine sideways so the mark reads as a crescent.\n      float bowAmt = (hash21(cc + seed + 53.0) - 0.5) * halfW * 1.4;\n      float spine = bowAmt * sin(u * PI);                    // 0 at ends, max mid\n      float d = abs(perp - spine);\n      // Derivative-free AA: a fixed fraction of the dab width (no fwidth skirt). Coverage\n      // is 1 in the dab body, smoothly 0 at the edge; outside the [head,tail] span wNow\u21920\n      // so the dab self-terminates with no end-cap blob.\n      float aa = max(halfW * 0.45, 0.002);\n      float cov = (wNow > 1e-5) ? (1.0 - smoothstep(wNow - aa, wNow + aa, d)) : 0.0;\n      if (cov < 0.004) continue;\n\n      // One sampleBase per cell + OKLCh broken-color jitter (pigment patch shimmer). The\n      // dab pigment is chroma-boosted (saturate3 1.22) AND value-lifted (\u00D71.14) at the\n      // SOURCE \u2014 the loaded brush mark deposits BRIGHTER + more saturated pigment than the\n      // base field, so the loaded-mark pixels lift BOTH the \u00A74.1 colourfulness AND the field\n      // mean-luma. The higher mean raises the gap-fraction threshold (meanLum\u00B70.6) so the\n      // moderate-depth inter-dab ground falls below it (the gap-fraction atomicity read is\n      // DECOUPLED from the ground floor depth \u2014 the ground can stay only moderately dark, so\n      // the \u00A74.3 slope is NOT over-steepened, while the bright dabs manufacture the gap). The\n      // dark ground is untouched, so this lifts C + gap WITHOUT a band-conflicting deep ground.\n      vec3 colMid = brokenColorJitter(\n        saturate3(sampleBase(center, t), 1.22),\n        hash21(cc + seed + 89.0),\n        hash21(cc * 2.3 + seed + 97.0),\n        1.0\n      );\n\n      // edgeN: 1 at the spine, 0 at the edge (the impasto crown reads it).\n      float edgeN = (wNow > 1e-5) ? clamp(1.0 - d / wNow, 0.0, 1.0) : 0.0;\n      if (cov > best.coverage) {\n        best = StrokeHit(cov, colMid, u, (wNow > 1e-5 ? (perp - spine) / wNow : 0.0), edgeN);\n      }\n    }\n  }\n  return best;\n}\n\nvec3 mediumVangogh(vec3 col, vec2 p, float t) {\n  vec3 result = col;\n  float height = 0.0;\n\n  // The swirl flow basis (van-Gogh sky = swirl rows). Computed ONCE per pixel.\n  vec2 flow = flowField(p, t);\n\n  // Dab cell pitch in UV [0,1]. CHUNKY, SEPARABLE marks \u2014 the big layer is ~1/14 of\n  // the frame so it reads as a distinct loaded brush dab (not a fine speckle, not a\n  // screen-spanning filament). uStrokeScale (authored ~110) modulates the pitch\n  // INVERSELY (higher = finer dabs) around the ~0.07 chunky default; clamped so the\n  // dab never collapses to noise or balloons past one screen. uStrokeAnisotropy\n  // stretches the comma aspect (longer, more directional marks).\n  float pitch = clamp(7.0 / max(uStrokeScale, 20.0), 0.044, 0.12);\n  // The dab LENGTH \u2248 the cell pitch (lenAniso ~1.2-1.7) so a dab sits WITHIN its cell\n  // and leaves visible ground around it \u2014 a longer dab (lenMul > 2) spans neighbour\n  // cells and tiles the field into continuous coverage (no gaps, the gap-fraction floor\n  // miss + the marble). Narrow width keeps it a directional crescent, not a wide shard.\n  // lenAniso/widAniso \u2014 the comma aspect. The current profile lengthens\n  // the comma (1.25-1.75 \u2192 1.5-2.0) and THINNED it (0.40-0.30 \u2192 0.32-0.24): the rebuilt\n  // dabs measured \u00A74.2 structure-tensor anisotropy A=0.699, BELOW the reference band\n  // floor 0.732 (the dabs read slightly too short-fat \u2192 locally isotropic, dragging mean\n  // A down). A LONGER, THINNER comma hugs the swirl-flow tangent more strongly so the\n  // rendered field reads coherent the way the tensor metric measures it (A lift), while\n  // the thinner width LEAVES MORE inter-dab ground (the gap-fraction atomicity read is\n  // preserved, not closed). The length stays \u2248 the cell pitch so each dab remains a\n  // CONTAINED separable mark, not a tiling filament.\n  float lenAniso = mix(2.1, 2.7, uStrokeAnisotropy);   // comma length / cell pitch (a contained dab)\n  float widAniso = mix(0.23, 0.16, uStrokeAnisotropy); // comma width / cell pitch (a thin loaded crescent)\n\n  // Layer 1 \u2014 the big swirl-row dabs: the loaded gestural marks, SPARSE so the dark\n  // underpainting shows BETWEEN them (the atomicity read \u2014 visible inter-dab ground).\n  // hardness 0.74 \u2014 the loaded brush deposits with a SOFT shoulder, so adjacent dabs\n  // feather instead of razor-clipping into hard polygon shards. jitterAmt 0.85 fully\n  // scatters the cell centres so the placement GRID never reads as a periodic seam.\n  // angJitter EASED 0.55 \u2192 0.38 (the reconcile A lift): a tighter angular spread keeps\n  // adjacent dabs more flow-aligned (coherent) while the per-cell curl wobble still\n  // breaks the perfectly-concentric-rows read (the dabs FAN gently, not lock to a grid).\n  // angJitter eased 0.38 \u2192 0.26 + hardness 0.74 \u2192 0.84 (the \u00A74.2 A lift): a tighter angular\n  // spread keeps adjacent dabs strongly flow-aligned (the structure-tensor coherence) and a\n  // sharper edge gives each dab a STRONGER directional gradient (a soft dab's faint edge\n  // reads weakly anisotropic). The per-cell curl wobble still breaks the perfectly-\n  // concentric-rows read, so the dabs FAN gently rather than locking to a grid.\n  StrokeHit dBig = vangoghDab(p, pitch, lenAniso, widAniso,\n                              0.30, 0.50, 0.08, flow, t, 1.3);\n  // streakFreq raised 14 \u2192 34 (the \u00A74.3 slope fix): a high-frequency streak runs ALONG the\n  // dab spine, injecting fine-scale luma energy that flattens the too-steep \u03B2 WITHOUT\n  // adding new isotropic marks (the along-spine streak stays directional, so the \u00A74.2\n  // anisotropy the long-thin dab carries is preserved \u2014 the band-conflict resolution).\n  paintOver(result, height, dBig, 48.0, 0.34,\n            uImpasto * 0.75 * uStrokeAmount, 0.84, 1.3, 1.0 /* full crown */);\n\n  // Layer 2 \u2014 two-thirds-pitch accent dabs (the divisionist sparkle between the big\n  // marks \u2014 denser placement but still contained dabs, so dark canvas survives between).\n  // angJitter eased 0.5 \u2192 0.34 (same A-lift reasoning \u2014 the accent dabs queue along the\n  // flow rather than scattering isotropically); hardness 0.78 \u2192 0.86 sharpens the gradient.\n  StrokeHit dSml = vangoghDab(p + vec2(-5.1, 8.4), pitch * 0.62, lenAniso * 0.95,\n                              widAniso * 0.95, 0.36, 0.60, 0.20, flow, t, 4.1);\n  paintOver(result, height, dSml, 42.0, 0.22,\n            uImpasto * 0.55 * uStrokeAmount, 0.86, 4.1, 1.0);\n\n  // Layer 3 \u2014 fine divisionist flecks. The two-layer\n  // field read as a few BIG cobalt dabs over a smooth empty teal ground (the side-by-side\n  // against starry-night-crop.png: the painting is DENSE small varied flecks, not sparse\n  // large marks). The flecks are LONG\u00B7THIN directional commas hugging the swirl tangent\n  // (the A-preserving fleck \u2014 short fat flecks read isotropic and drag \u00A74.2 down). Sparse\n  // density 0.30 keeps the inter-fleck ground open (the gap-fraction atomicity read).\n  // The flecks are FINE (\u22480.42\u00D7 pitch) directional commas, tightly flow-aligned (angJitter\n  // 0.22) and SPARSE (0.30) \u2014 the divisionist sparkle between the loaded marks that keeps\n  // the inter-dab ground open (atomicity) while adding the small-mark mid-band energy. Thin\n  // + flow-aligned so the \u00A74.2 anisotropy the long dabs carry survives the added small marks.\n  StrokeHit dFleck = vangoghDab(p + vec2(8.7, -3.2), pitch * 0.42, lenAniso * 1.0,\n                                widAniso * 0.68, 0.30, 0.85, 0.22, flow, t, 7.7);\n  paintOver(result, height, dFleck, 30.0, 0.16,\n            uImpasto * 0.40 * uStrokeAmount, 0.80, 7.7, 1.0);\n\n  // \u2500\u2500 Flow-aligned ground swirl grooving \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  // The bare ground between the dabs was a SMOOTH low-frequency teal gradient \u2014 the \u00A74.3\n  // power-spectrum slope ran too STEEP (\u03B2\u2248\u22122.0: too much low-frequency nuclei-field energy\n  // vs the high band). Van Gogh's actual sky has the swirl BRUSHWORK everywhere, so groove\n  // the OPEN GROUND with a flow-aligned ripple. It is SUBTRACTIVE-biased (it only darkens,\n  // never brightens the ground), so it DEEPENS the inter-dab valleys (MORE gap-fraction \u2014\n  // atomicity preserved/strengthened) while injecting the across-flow mid-band luma energy\n  // that flattens \u03B2. Gated to the open ground (low height) via the (1-height) gate so it\n  // never lifts/erodes the loaded dab bodies (the dab read is untouched). Across the swirl\n  // FLOW axis so the grooves run WITH the sky's brushwork direction.\n  // The ground swirl-combing \u2014 a FIXED-global-angle directional grain on the open ground.\n  // A flow-FOLLOWING comb varies its direction with the swirl across the readback window,\n  // so its blurred structure tensor averages toward isotropic (no \u00A74.2 lift). A comb at one\n  // GLOBAL angle (van-Gogh's dominant diagonal stroke grain) is COHERENT over the whole\n  // window \u21D2 every open-ground pixel reads the SAME direction (the \u00A74.2 mean-anisotropy lift\n  // the swirl comb could not reach). Two resolved bands (\u224822 + \u224844 across the global axis \u21D2\n  // ~21px + ~11px at 464px, both in the \u00A74.3 fit window) also feed the \u03B2 flatten. Gated to\n  // the open ground (low height) so the loaded dabs are untouched; SUBTRACTIVE-biased so the\n  // inter-dab valleys deepen (gap-fraction preserved, not filled).\n  vec2 gdir = normalize(vec2(0.82, 0.57));   // the dominant global stroke grain axis\n  float gacross = dot(p, vec2(-gdir.y, gdir.x));\n  float groundGate = 1.0 - smoothstep(0.05, 0.28, height);\n  float groove = sin(gacross * 22.0) + 0.5 * sin(gacross * 44.0 + 1.3);\n  result *= 1.0 - 0.16 * groundGate * (0.5 - 0.5 * groove);\n\n  // Canvas tooth (fine linen weave \u2014 base relief the raking light catches).\n  float tooth1 = vnoise(p * 220.0);\n  float tooth2 = vnoise(p * 220.0 * vec2(0.6, 2.4) + 37.0);\n  float tooth  = (0.6 * tooth1 + 0.4 * tooth2) - 0.5;\n  result *= 1.0 + tooth * 0.06 * uCanvasGrain;\n\n  // Relight the accumulated impasto height (raking light catches each dab's crown \u2014\n  // the visible impasto ridge that makes a dab read as a RAISED loaded mark).\n  float canvasBase = tooth * 0.06 * 0.5;\n  result = relightImpasto(result, height, canvasBase);\n\n  // The visible Starry-Night GROUND \u2014 the open canvas between dabs (low accumulated\n  // height) darkens toward the deep underpainting, so the bright impasto dabs read as\n  // SEPARABLE atomic marks over a darker field (the dab\u2194ground contrast the user's\n  // \"reads as strokes\" bar needs, AND the painterly-statistics gap-fraction floor \u2014 the\n  // dark inter-dab ground must register as a measurable fraction of the field). 0.30\n  // floor over a WIDER smoothstep (0..0.40): deep enough that the open gaps read as the\n  // dark Starry-Night sky between marks (clearing the 4% gap floor) while the gradual\n  // ramp keeps the gaps reading as flowing underpainting, not the hard black ink LINES a\n  // narrow near-black step (0.26 / 0.0..0.32) produced.\n  // The smoothstep FLOOR starts at 0.10 (not 0): a dab's faint AA coverage TAIL deposits\n  // a sliver of height, and where many tails align along the swirl flow those slivers\n  // accumulate into a faint continuous height ridge that read as thin curved LINES in the\n  // ground. Holding the ground full-dark until a real dab CORE (height > 0.10) lifts out\n  // keeps the open field clean \u2014 only the loaded dab bodies emerge, the tails stay ground.\n  result *= mix(0.115, 1.0, smoothstep(0.085, 0.31, height));\n\n  // The van-Gogh chroma \u2014 a light OKLCh punch at 0.92 in the\n  // The discrete-dab profile's per-dab OKLCh\n  // broken-color jitter (the \u00B116\u00B0 hue + \u00B1chroma swing per cell) lifts the field's\n  // colourfulness on its own, so a 1.04 punch on TOP overshoots the\n  // reference band (rendered C=100.5 vs the painting's measured 70.67 \u00B1 15/+25 \u2192\n  // ceiling 95.67 \u2014 neon, not Starry Night's rich-but-not-garish blue/gold). The 0.92\n  // demote pulls the rendered colourfulness back IN-band while the broken-color jitter\n  // keeps the per-dab pigment variation (the discrete-stroke read is untouched \u2014 this\n  // is a chroma scale, not a dab-geometry change). Band-anchored on the real painting\n  // not a widened band.\n  result = saturate3(result, 1.0);\n  return result;\n}\n\n";

package/dist/components/aurora/index.d.ts

@@ -6,7 +6,8 @@ export { useCursorInteraction } from "./composables/useCursorInteraction";
 export { createAurora } from "./composables/runtime";
 export type { AuroraRuntimeMode, AuroraRuntimeOptions } from "./composables/runtime";
 export { DEFAULT_AURORA_CONFIG, PAPER_WASH_GROUND, DEFAULT_VIVIDNESS, VIVID_TARGET, IMAGE_BLUR_MIN_DEFAULT, IMAGE_BLUR_MAX_DEFAULT, MAX_NUCLEI, MAX_STOPS, type AuroraConfig, type AuroraCursorApi, type AuroraFlow, type AuroraInstance, type AuroraInteractivity, type AuroraMedium, type AuroraNucleus, type AuroraSource, type AuroraImageSource, type AuroraImageBlur, type FlowPattern, type OklchStop, type StrokeMode, type StrokeOrient, type WarpMode, } from "./constants/presets";
-export { resolveAtoms, configToAtoms, nucleiPrior, DEFAULT_ATOMS, type AuroraAtoms, type AuroraMotionAtom, type AuroraZones, type AuroraZoneArrangement, type AuroraMediumAtom, type AuroraInteractivityAtom, } from "./composables/atoms";
+export { resolveAtoms, configToAtoms, DEFAULT_ATOMS, type AuroraAtoms, type AuroraZones, type AuroraMediumAtom, type AuroraInteractivityAtom, type AuroraFieldInteractivityAtom, type AuroraSmoothInteractivityAtom, type AuroraPainterlyInteractivityAtom, } from "./composables/atoms";
+export { nucleiPrior, type AuroraMotionAtom, type AuroraZoneArrangement, } from "./composables/atoms-fields";
 export { cssToOklch, deriveAurora, flattenPalette, hexToOklchStop, oklchStopToHex, oklchToLinear, paletteToCssGradient, } from "./composables/color";
 export { auroraFallbackGround, sampleAuroraField, nucleiFieldStatic, relativeLuminance, type AuroraFallbackGround, type AuroraFallbackGroundOptions, type AuroraGroundMetrics, } from "./composables/auroraFallbackGround";
 export type { AuroraHarmony, DeriveAuroraOptions, DeriveEasing, } from "./composables/color";