@mkbabb/glass-ui 10.1.4 → 11.0.0

package/dist/wgpuSetup-CFuqd_RP.js

@@ -0,0 +1,1278 @@
+import { h as e, m as t, n, v as r } from "./color-HkUaTAJj.js";
+import { i, n as a, r as o, t as s } from "./color.wgsl-B-qDJ_OM.js";
+import { a as c, n as l, r as u, s as d, t as f } from "./uniformBridge-CJyy7NOn.js";
+//#endregion
+//#region src/components/aurora/constants/shaders/aurora.wgsl.ts
+var p = `
+const MAX_NUCLEI: i32 = 8;
+const MAX_STOPS: i32 = 8;
+const PI: f32 = 3.141592653589793;
+
+// ── Uniforms (the typed-struct source-of-truth — see aurora.wgsl.uniforms.ts) ──
+// Scalars are packed into vec4 lanes to keep the std140/WGSL 16-byte struct alignment
+// trivial. nuc0[i] = (pos.x, pos.y, radius, paletteBias); nuc1[i] = (valueBias,
+// driftRadius, driftPhase, elong); nuc2[i] = (angle, _, _, _). palette[i].rgb is the
+// CPU-baked linear-sRGB stop.
+struct Uniforms {
+  // scalars0: (uTime, uSoftmaxBeta, uValueVariance, uWarpAmount)
+  scalars0: vec4<f32>,
+  // scalars1: (uWarpScale, uWarpDrift, uSaturation, uPaperGrain)
+  scalars1: vec4<f32>,
+  // scalars2: (uAlpha, uNucleiDrift, uPaletteDrift, uBreathDepth)
+  scalars2: vec4<f32>,
+  // scalars3: (uBreathPeriod, uCursorStrength, uCursorRadius, uVividness)
+  // The .w pad lane now carries the chroma-floor strength.
+  scalars3: vec4<f32>,
+  // cursor: (uCursor.x, uCursor.y, uMetalPolish, uMetalHeightScale)
+  // The two free pad lanes carry the metal-medium knobs (the
+  // metal light is cursor-synthesized so it reads in-struct on the WGSL primary too).
+  cursor: vec4<f32>,
+  // ints: (uStopCount, uNucleiCount, uWarpMode, uNoiseOctaves)
+  ints0: vec4<i32>,
+  // ints1: (uMedium, uHuePath, _, _)
+  ints1: vec4<i32>,
+  palette: array<vec4<f32>, 8>,
+  nuc0: array<vec4<f32>, 8>,
+  nuc1: array<vec4<f32>, 8>,
+  nuc2: array<vec4<f32>, 8>,
+  // The painterly-medium scalar lanes are appended after the
+  // arrays so EVERY existing offset (and the smooth-default parity capture) is
+  // byte-identical (these lanes are written 0 on a smooth config). scalars4:
+  // (uStrokeAmount, uStrokeScale, uStrokeAnisotropy, uCanvasGrain). scalars5:
+  // (uWetEdge, uGranulation, uBrokenColor, uKuwaharaQ). kuwahara: (uKuwaharaRadius,
+  // uKuwaharaSectors, _, _) — the Kuwahara radius/sectors/q in lockstep with
+  // packAuroraWGPUUniforms (the typed-struct discipline).
+  scalars4: vec4<f32>,
+  scalars5: vec4<f32>,
+  kuwahara: vec4<f32>,
+};
+
+@group(0) @binding(0) var<uniform> u: Uniforms;
+
+// ── Authoring-scale → rad/sec lifts (byte-identical to aurora.frag.ts) ──
+const K_NUCLEI: f32 = 14.0;
+const K_PAL: f32 = 24.0;
+const K_WARP: f32 = 5.0;
+
+// ── Noise (Aurora-local hash21/vnoise/fbm, deliberately distinct) ──────────
+fn hash21(p0: vec2<f32>) -> f32 {
+  var p = fract(p0 * vec2<f32>(123.34, 456.21));
+  p = p + dot(p, p + 45.32);
+  return fract(p.x * p.y);
+}
+
+fn hash22(p0: vec2<f32>) -> vec2<f32> {
+  let p = vec2<f32>(dot(p0, vec2<f32>(127.1, 311.7)),
+                    dot(p0, vec2<f32>(269.5, 183.3)));
+  return fract(sin(p) * 43758.5453);
+}
+
+fn vnoise(p: vec2<f32>) -> f32 {
+  let i = floor(p);
+  let f = fract(p);
+  let uu = f * f * (3.0 - 2.0 * f);
+  let a = hash21(i);
+  let b = hash21(i + vec2<f32>(1.0, 0.0));
+  let c = hash21(i + vec2<f32>(0.0, 1.0));
+  let d = hash21(i + vec2<f32>(1.0, 1.0));
+  return mix(mix(a, b, uu.x), mix(c, d, uu.x), uu.y);
+}
+
+${s}
+
+fn fbm(p0: vec2<f32>) -> f32 {
+  var v = 0.0;
+  var a = 0.5;
+  var p = p0;
+  let octaves = u.ints0.w;
+  for (var i = 0; i < 5; i = i + 1) {
+    if (i >= octaves) { break; }
+    v = v + a * vnoise(p);
+    p = FBM_ROT * p * 2.02;
+    a = a * 0.5;
+  }
+  return v;
+}
+
+fn potentialFBM(p: vec2f) -> f32 { return fbm(p); }
+
+const CURL_EPS: f32 = 0.012;
+
+// ∇×ψ in 2D — the divergence-free flow direction. Central finite differences of the
+// scalar potential give the partials; the cross-pairing (∂y, −∂x) is the 2D curl.
+fn curlFBM(p: vec2f) -> vec2f {
+  let dx = potentialFBM(p + vec2f(CURL_EPS, 0.0)) - potentialFBM(p - vec2f(CURL_EPS, 0.0));
+  let dy = potentialFBM(p + vec2f(0.0, CURL_EPS)) - potentialFBM(p - vec2f(0.0, CURL_EPS));
+  // ψ-gradient is (dx, dy)/(2·eps); the curl rotates it 90°: (∂ψ/∂y, −∂ψ/∂x).
+  let g = vec2f(dx, dy) / (2.0 * CURL_EPS);
+  return vec2f(g.y, -g.x);
+}
+
+
+${a}
+${o}
+${i}
+
+// Interleaved Gradient Noise (Jimenez) — display-space 1-LSB dither.
+fn ign(p: vec2<f32>) -> f32 {
+  return fract(52.9829189 * fract(dot(p, vec2<f32>(0.06711056, 0.00583715))));
+}
+
+// Cellular, Worley f1.
+fn cellular(p: vec2<f32>) -> f32 {
+  let i = floor(p);
+  let f = fract(p);
+  var m = 1e9;
+  for (var y = -1; y <= 1; y = y + 1) {
+    for (var x = -1; x <= 1; x = x + 1) {
+      let g = vec2<f32>(f32(x), f32(y));
+      let o = hash22(i + g);
+      let r = g + o - f;
+      m = min(m, dot(r, r));
+    }
+  }
+  return sqrt(m);
+}
+
+// ── Warp (Quilez double warp + the four warp modes + the cursor swirl) ──
+fn domainWarp(p: vec2<f32>, t: f32) -> vec2<f32> {
+  let warpScale = u.scalars1.x;
+  let warpDrift = u.scalars1.y;
+  let warpAmount = u.scalars0.w;
+  let warpMode = u.ints0.z;
+  let cursorStrength = u.scalars3.y;
+  let cursorRadius = u.scalars3.z;
+  let cursor = u.cursor.xy;
+
+  let q = vec2<f32>(fbm(p * warpScale + vec2<f32>(0.0, 0.0) + t * warpDrift * K_WARP),
+                    fbm(p * warpScale + vec2<f32>(5.2, 1.3) + t * warpDrift * K_WARP));
+  let r = vec2<f32>(fbm(p * warpScale + 4.0 * q + vec2<f32>(1.7, 9.2)),
+                    fbm(p * warpScale + 4.0 * q + vec2<f32>(8.3, 2.8)));
+
+  var warp = r;
+  if (warpMode == 1) {
+    // cellular — chunky territories
+    let c1 = cellular(p * warpScale * 1.5 + vec2<f32>(t * warpDrift * K_WARP * 2.0, 0.0));
+    let c2 = cellular(p * warpScale * 1.5 + vec2<f32>(11.0, 7.0 + t * warpDrift * K_WARP * 2.0));
+    warp = vec2<f32>(c1, c2);
+  } else if (warpMode == 2) {
+    // hybrid — fbm + cellular averaged
+    let c1 = cellular(p * warpScale * 1.2);
+    let c2 = cellular(p * warpScale * 1.2 + vec2<f32>(11.0, 7.0));
+    warp = mix(r, vec2<f32>(c1, c2), 0.5);
+  } else if (warpMode == 3) {
+    let fp = p * warpScale + vec2<f32>(t * warpDrift * K_WARP);
+    warp = curlFBM(fp);
+  }
+  var warped = p + warpAmount * warp;
+
+  // Cursor swirl — rotate p around the cursor with radial falloff.
+  if (cursorStrength > 0.001) {
+    let toP = p - cursor;
+    let d = length(toP);
+    let rr = max(cursorRadius, 0.01);
+    let w = exp(-(d * d) / (rr * rr * 0.45));
+    let ang = w * cursorStrength * 2.1;
+    let ca = cos(ang);
+    let sa = sin(ang);
+    var rotated = vec2<f32>(ca * toP.x - sa * toP.y, sa * toP.x + ca * toP.y) + cursor;
+    let pinch = w * cursorStrength * 0.08;
+    rotated = mix(rotated, cursor, pinch);
+    warped = mix(warped, rotated + warpAmount * warp * 0.7, w * cursorStrength);
+  }
+  return warped;
+}
+
+// ── Palette LUT ──
+fn samplePalette(id0: f32) -> vec3<f32> {
+  let id = clamp(id0, 0.0, 1.0);
+  let stopCount = u.ints0.x;
+  let scaled = id * f32(stopCount - 1);
+  let i0 = i32(floor(scaled));
+  let i1 = min(i0 + 1, stopCount - 1);
+  let t = fract(scaled);
+  return samplePaletteRamp(u.palette[i0].rgb, u.palette[i1].rgb, t, u.ints1.y);
+}
+
+// ── Nuclei field (anisotropic Gaussian softmax + drift + palette drift) ──
+struct NucleiResult { paletteId: f32, valueMod: f32 };
+
+fn nucleiField(p: vec2<f32>, t: f32) -> NucleiResult {
+  let nucleiCount = u.ints0.y;
+  let nucleiDrift = u.scalars2.y;
+  let paletteDrift = u.scalars2.z;
+  let softmaxBeta = u.scalars0.y;
+
+  var accumBias = 0.0;
+  var accumValue = 0.0;
+  var accumW = 0.0;
+  for (var i = 0; i < MAX_NUCLEI; i = i + 1) {
+    if (i >= nucleiCount) { break; }
+    let n0 = u.nuc0[i];   // pos.x, pos.y, radius, paletteBias
+    let n1 = u.nuc1[i];   // valueBias, driftRadius, driftPhase, elong
+    let angle = u.nuc2[i].x;
+    let driftRadius = n1.y;
+    let driftPhase = n1.z;
+    let posI = n0.xy + driftRadius * vec2<f32>(
+      cos(t * nucleiDrift * K_NUCLEI + driftPhase),
+      sin(t * nucleiDrift * K_NUCLEI + driftPhase * 1.13)
+    );
+    let diff = p - posI;
+    let ca = cos(angle);
+    let sa = sin(angle);
+    let local = vec2<f32>(ca * diff.x + sa * diff.y, -sa * diff.x + ca * diff.y);
+    let along = local.x / max(n1.w, 0.01);
+    let across = local.y;
+    let d2 = along * along + across * across;
+    let r = max(n0.z, 0.01);
+    let w = exp(-softmaxBeta * d2 / (r * r));
+    accumBias = accumBias + w * n0.w;
+    accumValue = accumValue + w * n1.x;
+    accumW = accumW + w;
+  }
+  var paletteId = accumBias / max(accumW, 1e-4);
+  let valueMod = accumValue / max(accumW, 1e-4);
+
+  let palAmp = clamp(paletteDrift * 6.0, 0.0, 0.06);
+  paletteId = paletteId + palAmp * sin(t * paletteDrift * K_PAL);
+  paletteId = clamp(paletteId, 0.0, 1.0);
+  return NucleiResult(paletteId, valueMod);
+}
+
+// ── Color utils (OKLCh saturation) ──
+fn linOklab(lin: vec3<f32>) -> vec3<f32> {
+  let lms = LINEAR_SRGB_TO_LMS * lin;
+  return LMS_TO_OKLAB * cbrt3(lms);
+}
+
+fn saturate3(c: vec3<f32>, amt: f32) -> vec3<f32> {
+  var lch = oklabToOklch(linOklab(c));
+  lch.y = max(lch.y * amt, 0.0);
+  return max(oklabToLinearSrgb(oklchToOklab(lch)), vec3<f32>(0.0));
+}
+
+// The chroma floor, the WGSL twin of the GLSL vividnessFloor.
+// OKLab chroma lifted toward the floor, hue + L preserved; below VIVID_EPS the (a,b)
+// direction is precision noise so the lift synthesizes along the WARM anchor (amber,
+// both components positive) — never teal/navy. vividness (scalars3.w) == 0 is a no-op
+// (the byte-identity opt-out). Mode factor lifts a dim field a touch (read through glass).
+const VIVID_TARGET: f32 = 0.115;
+const VIVID_EPS: f32 = 0.012;
+const VIVID_WARM_ANCHOR: vec2<f32> = vec2<f32>(0.34202, 0.93969);
+fn vividnessFloor(c: vec3<f32>, vividness: f32) -> vec3<f32> {
+  if (vividness <= 0.0001) { return c; }
+  var lab = linOklab(c);
+  let C = length(lab.yz);
+  let modeLift = mix(1.18, 1.0, clamp(lab.x * 1.4, 0.0, 1.0));
+  let Cmin = vividness * VIVID_TARGET * modeLift;
+  var hueDir = VIVID_WARM_ANCHOR;
+  if (C > VIVID_EPS) { hueDir = lab.yz / C; }
+  let yz = hueDir * max(C, Cmin);
+  lab = vec3<f32>(lab.x, yz.x, yz.y);
+  return max(oklabToLinearSrgb(lab), vec3<f32>(0.0));
+}
+
+// ── PBR-Neutral tonemap (named aces() in the GLSL — the tonemap slot) ──
+fn aces(color0: vec3<f32>) -> vec3<f32> {
+  let startCompression = 0.8 - 0.04;
+  let desaturation = 0.15;
+  var color = color0;
+  let x = min(color.r, min(color.g, color.b));
+  var offset = 0.04;
+  if (x < 0.08) { offset = x - 6.25 * x * x; }
+  color = color - offset;
+  let peak = max(color.r, max(color.g, color.b));
+  if (peak < startCompression) { return clamp(color, vec3<f32>(0.0), vec3<f32>(1.0)); }
+  let d = 1.0 - startCompression;
+  let newPeak = 1.0 - d * d / (peak + d - startCompression);
+  color = color * (newPeak / peak);
+  let g = 1.0 - 1.0 / (desaturation * (peak - newPeak) + 1.0);
+  return clamp(mix(color, newPeak * vec3<f32>(1.0), g), vec3<f32>(0.0), vec3<f32>(1.0));
+}
+
+// ── Painterly-medium bodies (the keystone WGSL port) ───────────────────────
+// Spliced HERE, after every helper the mediums consume is defined (domainWarp,
+// nucleiField, samplePalette, linOklab, saturate3, oklabToOklch/oklchToOklab,
+// hash21/vnoise/fbm) and before the vertex/fragment stages. applyMedium(col,p,t)
+// is the dispatch the fragment stage calls.
+
+// ── Painterly luma + medium scalar accessors ───────────────────────────────
+const W_LUMA: vec3<f32> = vec3<f32>(0.2126, 0.7152, 0.0722);
+
+fn mStrokeAmount() -> f32 { return u.scalars4.x; }
+fn mStrokeScale() -> f32 { return u.scalars4.y; }
+fn mStrokeAnisotropy() -> f32 { return u.scalars4.z; }
+fn mCanvasGrain() -> f32 { return u.scalars4.w; }
+fn mWetEdge() -> f32 { return u.scalars5.x; }
+fn mGranulation() -> f32 { return u.scalars5.y; }
+fn mBrokenColor() -> f32 { return u.scalars5.z; }
+fn mKuwaharaQ() -> f32 { return u.scalars5.w; }
+fn mKuwaharaRadius() -> f32 { return u.kuwahara.x; }
+// The metal-medium knobs ride the free cursor.z/.w pad lanes
+// (uniformBridgeWGPU packs them; written 0 on a non-metal config → no-op). These read
+// the IN-STRUCT cursor — the metal light is cursor-synthesized so it crosses to WGSL
+// (a phantom uLightDir read would be flat on the primary; uLightDir is fragment-only).
+fn mMetalPolish() -> f32 { return u.cursor.z; }
+fn mMetalHeightScale() -> f32 { return u.cursor.w; }
+
+// ── Gradient pack (the WGSL twin) ──────────────────────────────────────────
+// structureTensorField re-plumbs its already-computed luma gradient (Gx,Gy) out
+// through the return value's .w lane so the metal medium pays ZERO extra taps. 12 bits per
+// bounded component ([-4,4]) fit into one f32; the crayon/kuwahara callers read only .xy/.z.
+fn packGrad(gx: f32, gy: f32) -> f32 {
+  let qx = floor(clamp(gx * 0.125 + 0.5, 0.0, 1.0) * 4095.0);
+  let qy = floor(clamp(gy * 0.125 + 0.5, 0.0, 1.0) * 4095.0);
+  return qx + qy * 4096.0;
+}
+fn unpackGrad(packed: f32) -> vec2<f32> {
+  let qy = floor(packed * (1.0 / 4096.0));
+  let qx = packed - qy * 4096.0;
+  return (vec2<f32>(qx, qy) * (1.0 / 4095.0) - 0.5) * 8.0;
+}
+
+// ── Base color re-sample (the edge-mask operator the mediums Sobel/sector-sample) ──
+// The WGSL twin of mediums.glsl.ts sampleBase: warp -> nuclei field -> palette -> value.
+fn sampleBase(p: vec2<f32>, t: f32) -> vec3<f32> {
+  let pw = domainWarp(p, t);
+  let nf = nucleiField(pw, t);
+  var c = samplePalette(nf.paletteId);
+  c = c * (1.0 + u.scalars0.z * nf.valueMod);
+  return c;
+}
+
+// ── Broken color (hue + chroma jitter at constant OKLCh L) ──────────────────
+fn brokenColorJitter(c: vec3<f32>, hueSeed: f32, valueSeed: f32, strength: f32) -> vec3<f32> {
+  let amt = clamp(mBrokenColor() * strength, 0.0, 1.0);
+  if (amt <= 0.001) { return c; }
+  var lch = oklabToOklch(linOklab(c));
+  lch.z = lch.z + (hueSeed - 0.5) * (32.0 * PI / 180.0) * amt;
+  lch.y = max(lch.y * (1.0 + (valueSeed - 0.5) * 0.28 * amt), 0.0);
+  return max(oklabToLinearSrgb(oklchToOklab(lch)), vec3<f32>(0.0));
+}
+
+// ── Structure tensor / edge-tangent flow (the WGSL twin) ───────────────────
+// Returns vec4(tangent.x, tangent.y, A, packGrad(Gx,Gy)) — the minor-eigenvector
+// edge-tangent + coherence + the metal medium's packed gradient. The .xy/.z
+// crayon/kuwahara callers are byte-unchanged.
+fn structureTensorField(p: vec2<f32>, t: f32, fallbackDir: vec2<f32>) -> vec4<f32> {
+  let e = 0.0035;
+  let l00 = dot(sampleBase(p + vec2<f32>(-e, -e), t), W_LUMA);
+  let l10 = dot(sampleBase(p + vec2<f32>(0.0, -e), t), W_LUMA);
+  let l20 = dot(sampleBase(p + vec2<f32>( e, -e), t), W_LUMA);
+  let l01 = dot(sampleBase(p + vec2<f32>(-e, 0.0), t), W_LUMA);
+  let l21 = dot(sampleBase(p + vec2<f32>( e, 0.0), t), W_LUMA);
+  let l02 = dot(sampleBase(p + vec2<f32>(-e, e), t), W_LUMA);
+  let l12 = dot(sampleBase(p + vec2<f32>(0.0, e), t), W_LUMA);
+  let l22 = dot(sampleBase(p + vec2<f32>( e, e), t), W_LUMA);
+  let Gx = (l20 + 2.0 * l21 + l22) - (l00 + 2.0 * l01 + l02);
+  let Gy = (l02 + 2.0 * l12 + l22) - (l00 + 2.0 * l10 + l20);
+  let Jxx = Gx * Gx;
+  let Jyy = Gy * Gy;
+  let Jxy = Gx * Gy;
+  let tr = Jxx + Jyy;
+  let disc = sqrt(max((Jxx - Jyy) * (Jxx - Jyy) + 4.0 * Jxy * Jxy, 0.0));
+  let lambdaMaj = 0.5 * (tr + disc);
+  let lambdaMin = 0.5 * (tr - disc);
+  var tangent: vec2<f32>;
+  if (disc < 1e-7) {
+    tangent = fallbackDir;
+  } else {
+    let theta = 0.5 * atan2(2.0 * Jxy, Jxx - Jyy);
+    tangent = vec2<f32>(-sin(theta), cos(theta));
+  }
+  var A = (lambdaMaj - lambdaMin) / (lambdaMaj + lambdaMin + 1e-6);
+  A = clamp(A, 0.0, 1.0);
+  if (dot(tangent, fallbackDir) < 0.0) { tangent = -tangent; }
+  let blendW = pow(A, 0.28);
+  let dir = normalize(mix(fallbackDir, tangent, blendW) + vec2<f32>(1e-6, 1e-6));
+  return vec4<f32>(dir, A, packGrad(Gx, Gy));
+}
+
+// ── Flow field (the WGSL twin — the simple flow seed the medium fallback dirs use) ──
+fn flowField(p: vec2<f32>, t: f32) -> vec2<f32> {
+  // Curl-noise-driven swirl (the medium-default dir; the full radial/swirl/diagonal
+  // dispatch rides uniforms the WGSL struct does not carry — the procedural mediums
+  // use this multi/curl seed as the fallback the structure tensor relaxes toward).
+  let n = fbm(p * 2.0 + vec2<f32>(t * 0.02, t * 0.02));
+  let a = n * 6.2831853;
+  var dir = vec2<f32>(cos(a), sin(a));
+  // Cursor swirl bias (matches the GLSL flow cursor term — the steady attraction).
+  let cursorStrength = u.scalars3.y;
+  let cursorRadius = u.scalars3.z;
+  let cursor = u.cursor.xy;
+  if (cursorStrength > 0.001) {
+    let toCur = cursor - p;
+    let d = length(toCur);
+    let r = max(cursorRadius, 0.01);
+    let w = exp(-(d * d) / (r * r * 0.5));
+    let tangent = vec2<f32>(-toCur.y, toCur.x) / max(d, 1e-4);
+    let a0 = atan2(dir.y, dir.x);
+    let a1 = atan2(tangent.y, tangent.x);
+    var da = a1 - a0;
+    da = atan2(sin(da), cos(da));
+    let aa = a0 + da * w * cursorStrength;
+    dir = vec2<f32>(cos(aa), sin(aa));
+  }
+  return dir;
+}
+
+// ── Watercolor — wet-edge cauliflowers + granulation + wash banding ─────────
+fn mediumWatercolor(col0: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {
+  var col = col0;
+  let eps = 0.004;
+  let cx1 = sampleBase(p + vec2<f32>(eps, 0.0), t);
+  let cx2 = sampleBase(p - vec2<f32>(eps, 0.0), t);
+  let cy1 = sampleBase(p + vec2<f32>(0.0, eps), t);
+  let cy2 = sampleBase(p - vec2<f32>(0.0, eps), t);
+  let gx = dot(cx1 - cx2, W_LUMA);
+  let gy = dot(cy1 - cy2, W_LUMA);
+  let edge = sqrt(gx * gx + gy * gy) / (2.0 * eps);
+  let mask = smoothstep(0.0, 2.5, edge);
+  col = col * mix(1.0, 0.78, mask * mWetEdge());
+
+  let paper = 0.5 * vnoise(p * 160.0) + 0.5 * vnoise(p * 360.0);
+  let pigLoad = 1.0 - dot(col, W_LUMA);
+  col = col * (1.0 - mGranulation() * pigLoad * (paper - 0.5));
+
+  let band = fbm(vec2<f32>(p.x * 1.5, p.y * 0.4));
+  col = col * (1.0 + 0.04 * (band - 0.5));
+  return col;
+}
+
+// ── Pastel — anisotropic stroke noise along the flow + tooth grain ──────────
+fn mediumPastel(col0: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {
+  var col = col0;
+  let flow = flowField(p, t);
+  let perp = vec2<f32>(-flow.y, flow.x);
+  let strokeScale = mStrokeScale();
+  let along = dot(p, flow) * strokeScale;
+  var across = dot(p, perp) * strokeScale;
+  across = across + 0.03 * (vnoise(p * 260.0) - 0.5);
+
+  let aniso = mix(1.0, 0.18, mStrokeAnisotropy());
+  let stroke = fbm(vec2<f32>(along * aniso, across));
+  col = col * mix(1.0, 0.82 + 0.32 * stroke, mStrokeAmount());
+
+  let tooth = vnoise(p * 800.0);
+  col = col * (1.0 - 0.08 * mStrokeAmount() * (tooth - 0.5));
+  return col;
+}
+
+// ── Crayon — DRY wax pigment on paper tooth (the tooth-multiply + scumble) ──
+fn mediumCrayon(col0: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {
+  let flow = structureTensorField(p, t, flowField(p, t)).xy;
+  let ang = atan2(flow.y, flow.x);
+  let ca = cos(-ang);
+  let sa = sin(-ang);
+  let pr = vec2<f32>(p.x * ca - p.y * sa, p.x * sa + p.y * ca);
+
+  let aniso = mix(0.45, 0.95, mStrokeAnisotropy());
+  let scale = max(mStrokeScale() * 1.6, 180.0);
+
+  let t1 = vnoise(vec2<f32>(pr.x * scale * aniso, pr.y * scale));
+  let t2 = vnoise(vec2<f32>(pr.x * scale * aniso * 0.4, pr.y * scale * 0.4) + vec2<f32>(11.0, 11.0));
+  let t3 = vnoise(vec2<f32>(pr.x * scale * aniso * 2.1, pr.y * scale * 2.1) + vec2<f32>(23.0, 23.0));
+  let tooth = 0.55 * t1 + 0.30 * t2 + 0.15 * t3;
+
+  let pressure = clamp(mStrokeAmount(), 0.0, 1.0);
+  let bite = mix(0.18, 0.46, pressure);
+  var result = col0 * (1.0 - bite * (0.5 - tooth));
+
+  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)));
+  let scumbleCoverage = scumbleMask * pressure * 0.7;
+  let paper = col0 * mix(0.80, 0.94, pressure);
+  result = mix(paper, result, scumbleCoverage);
+
+  let pigmentCell = floor(pr * max(scale * 0.18, 32.0));
+  let pigmentMask = smoothstep(0.28, 0.82, vnoise(pr * scale * 0.21 + vec2<f32>(19.0, 19.0)));
+  result = brokenColorJitter(
+    result,
+    hash21(pigmentCell + vec2<f32>(17.0, 17.0)),
+    hash21(pigmentCell * 2.1 + vec2<f32>(31.0, 31.0)),
+    0.45 + 0.55 * pigmentMask
+  );
+
+  result = saturate3(result, 1.08);
+  return result;
+}
+
+// ── Kuwahara — the SOFT anisotropic generalized Kuwahara painterly finish ────
+// THE KEYSTONE (Kyprianidis 2010). Aurora is a PROCEDURAL field (no input texture) so the
+// operator runs over sampleBase directly: an elliptical kernel oriented along the structure
+// tensor (elongated along the edge-tangent, narrowed across by the anisotropy), 8 OVERLAPPING
+// sectors via SMOOTH gaussian-angular weights, blended by 1/(1+var^q) (the SOFT criterion →
+// no 8-spoke pinwheel by construction). 4 rings × 8 angular taps = 32 procedural samples.
+fn mediumKuwahara(col0: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {
+  let stf = structureTensorField(p, t, flowField(p, t));
+  let tangent = stf.xy;
+  let A = stf.z;
+  // The studio knob drives the patch radius; clamp into the procedural patch band.
+  let radius = clamp(mKuwaharaRadius() + mStrokeScale() * 0.00018, 0.006, 0.024);
+  let aniso = mix(1.0, 0.34, clamp(A, 0.0, 1.0));
+  let ax = tangent;
+  let ay = vec2<f32>(-tangent.y, tangent.x);
+
+  // Per-sector weighted sums (8 sectors). WGSL has no runtime-indexed local arrays of
+  // vectors as cleanly as GLSL, so unroll the sector accumulators explicitly.
+  var mSum: array<vec3<f32>, 8>;
+  var sSum: array<vec3<f32>, 8>;
+  var wSum: array<f32, 8>;
+  for (var i = 0; i < 8; i = i + 1) {
+    mSum[i] = vec3<f32>(0.0);
+    sSum[i] = vec3<f32>(0.0);
+    wSum[i] = 0.0;
+  }
+
+  let RINGS = 4;
+  let TAPS = 8;
+  for (var r = 1; r <= RINGS; r = r + 1) {
+    let rr = f32(r) / f32(RINGS);
+    let radial = 1.0 - 0.6 * rr;
+    for (var a = 0; a < TAPS; a = a + 1) {
+      let ang = 6.2831853 * f32(a) / f32(TAPS);
+      let dirE = ax * cos(ang) + ay * (sin(ang) * aniso);
+      let off = dirE * (radius * rr);
+      let c = sampleBase(p + off, t);
+      for (var k = 0; k < 8; k = k + 1) {
+        let sectorAng = 6.2831853 * f32(k) / 8.0;
+        var d = ang - sectorAng;
+        d = atan2(sin(d), cos(d));
+        let sw = exp(-d * d * 2.2) * radial;
+        mSum[k] = mSum[k] + c * sw;
+        sSum[k] = sSum[k] + c * c * sw;
+        wSum[k] = wSum[k] + sw;
+      }
+    }
+  }
+
+  let q = max(mKuwaharaQ(), 1.0);
+  var accum = vec3<f32>(0.0);
+  var accumW = 0.0;
+  for (var k = 0; k < 8; k = k + 1) {
+    let wk = max(wSum[k], 1e-4);
+    let mean = mSum[k] / wk;
+    let var3 = max(sSum[k] / wk - mean * mean, vec3<f32>(0.0));
+    let variance = dot(var3, W_LUMA);
+    let sectorW = 1.0 / (1.0 + pow(variance * 320.0, q));
+    accum = accum + mean * sectorW;
+    accumW = accumW + sectorW;
+  }
+  var result = accum / max(accumW, 1e-4);
+
+  // Anchor in near-flat zones so the smoothing only bites at edges.
+  let center = sampleBase(p, t);
+  result = mix(center, result, clamp(0.35 + 0.65 * A, 0.0, 1.0));
+
+  // Faint canvas tooth + pigment-saturation so the flattened patches read as oil paint.
+  let tooth = vnoise(p * 300.0) - 0.5;
+  result = result * (1.0 + tooth * 0.06 * mCanvasGrain());
+  result = saturate3(result, 1.04);
+
+  return mix(col0, result, clamp(mStrokeAmount(), 0.0, 1.0));
+}
+
+// ── Metal — the two-term anisotropic BRDF (uMedium==8/9; the WGSL twin) ──────
+// The field re-lights as warm folded metal: the luma HEIGHT field (the packed
+// structure-tensor gradient → the surface normal) catches an anisotropic Blinn streak
+// (brushed metal, running ALONG the coherent edge-tangent) plus a sharp crest, both
+// raked by the IN-STRUCT cursor-synth light (crosses to WGSL — never uLightDir). The
+// catch is the achromatic-warm anchor (never a cold chrome-blue). ZERO extra taps —
+// the gradient is unpacked from the tensor's .w lane the caller already computed.
+const METAL_CATCH_WARM: vec3<f32> = vec3<f32>(1.0, 0.97, 0.90);
+const METAL_HEIGHT_SCALE: f32 = 2.2;
+const METAL_LIGHT_Z: f32 = 0.55;
+const METAL_IDLE_RAKE: vec2<f32> = vec2<f32>(0.32, 0.34);
+const METAL_SHININESS_ANISO: f32 = 6.0;
+const METAL_SHININESS_CREST: f32 = 40.0;
+const METAL_COHERENCE_FLOOR: f32 = 0.22;
+const METAL_BODY_FLOOR: f32 = 0.42;
+const METAL_GRADIENT_FLATTEN: f32 = 0.55;
+const METAL_SPARKLE_DENSITY: f32 = 240.0;
+const METAL_SPARKLE_THRESH: f32 = 0.72;
+const METAL_SPARKLE_AMP: f32 = 0.6;
+
+fn metalShade(baseCol: vec3<f32>, p: vec2<f32>, stf: vec4<f32>) -> vec3<f32> {
+  let tangent = stf.xy;
+  let A = stf.z;
+  let grad = unpackGrad(stf.w);
+  let N = normalize(vec3<f32>(grad * (METAL_HEIGHT_SCALE * mMetalHeightScale()), 1.0));
+  let V = vec3<f32>(0.0, 0.0, 1.0);
+  // Cursor-synth rake light (u.cursor is in-struct — crosses to WGSL).
+  let L = normalize(vec3<f32>((u.cursor.xy - p) + METAL_IDLE_RAKE, METAL_LIGHT_Z));
+  let H = normalize(L + V);
+  // Anisotropic streak — brushed metal along the edge-tangent.
+  let tH = dot(normalize(tangent), H.xy);
+  let sinTH = sqrt(clamp(1.0 - tH * tH, 0.0, 1.0));
+  let streak = pow(clamp(sinTH, 0.0, 1.0), METAL_SHININESS_ANISO);
+  let crest = pow(clamp(dot(N, H), 0.0, 1.0), METAL_SHININESS_CREST);
+  var spec = streak * crest;
+  spec = spec * smoothstep(0.0, METAL_COHERENCE_FLOOR, A);
+  // Technicolor valley base — the body keeps the FIELD hue; luma rides the relief.
+  let diff = clamp(dot(N, L), 0.0, 1.0);
+  let body = baseCol * (METAL_BODY_FLOOR + (1.0 - METAL_BODY_FLOOR) * diff);
+  return body + METAL_CATCH_WARM * (spec * clamp(mMetalPolish(), 0.0, 4.0));
+}
+
+fn mediumMetal(col: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {
+  let stf = structureTensorField(p, t, flowField(p, t));
+  return metalShade(col, p, stf);
+}
+
+// metal-gradient (uMedium==9) — the SAME BRDF over a pre-flattened base + the
+// twinkle-in-place flake sparkle (position FIXED per cell, phase-animated, facing-gated).
+fn mediumMetalGradient(col: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {
+  let stf = structureTensorField(p, t, flowField(p, t));
+  let flat = mix(col, vec3<f32>(dot(col, W_LUMA)), METAL_GRADIENT_FLATTEN);
+  var metal = metalShade(flat, p, stf);
+  let grad = unpackGrad(stf.w);
+  let facing = normalize(vec3<f32>(grad * (METAL_HEIGHT_SCALE * mMetalHeightScale()), 1.0)).z;
+  let cell = floor(p * METAL_SPARKLE_DENSITY);
+  let seed = hash21(cell);
+  let tw = pow(clamp(sin(t + seed * 6.2831853), 0.0, 1.0), 40.0);
+  let flakeGate = step(METAL_SPARKLE_THRESH, seed);
+  metal = metal + METAL_CATCH_WARM * (tw * flakeGate * clamp(facing, 0.0, 1.0) * METAL_SPARKLE_AMP);
+  return metal;
+}
+
+// ── Medium dispatch (the WGSL twin of the GLSL main() if-ladder) ────────────
+// uMedium: 0 smooth · 1 pastel · 2 watercolor · 3 oil · 4 crayon · 5 vangogh ·
+// 6 oil-pastel · 7 kuwahara · 8 metal · 9 metal-gradient. The cheap peer mediums
+// (pastel/watercolor/crayon) + kuwahara + metal port their own bodies; the
+// oil/vangogh/oil-pastel STROKE cascade renders the anisotropic-Kuwahara PAINTERLY
+// finish here (a real oil-paint read, never the smooth core — the "NO FALLBACKS on
+// Safari" mandate; the full per-dab Starry-Night stroke WGSL remains a separate
+// full-fidelity port).
+fn applyMedium(col: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {
+  let medium = u.ints1.x;
+  if (medium == 1) { return mediumPastel(col, p, t); }
+  if (medium == 2) { return mediumWatercolor(col, p, t); }
+  if (medium == 4) { return mediumCrayon(col, p, t); }
+  // Metal uses both renderer paths; a fragment-only implementation is invisible on the
+  // WGSL primary. IDs 8 and 9 select metal and metal-gradient respectively.
+  if (medium == 8) { return mediumMetal(col, p, t); }
+  if (medium == 9) { return mediumMetalGradient(col, p, t); }
+  // oil(3), vangogh(5), oil-pastel(6), kuwahara(7) all render the painterly
+  // anisotropic-Kuwahara finish on the WGSL primary (the WebGL2 fallback carries the
+  // full per-dab stroke cascade for oil/vangogh/oil-pastel).
+  if (medium == 3 || medium == 5 || medium == 6 || medium == 7) {
+    return mediumKuwahara(col, p, t);
+  }
+  return col;
+}
+
+
+// ── Full-screen triangle vertex stage (the pilot idiom — no vertex buffer) ──
+struct VSOut {
+  @builtin(position) pos: vec4<f32>,
+  @location(0) uv: vec2<f32>,
+};
+
+@vertex
+fn vs_main(@builtin(vertex_index) vi: u32) -> VSOut {
+  // NDC corners of the covering triangle (-1,-1), (3,-1), (-1,3).
+  var p = vec2<f32>(-1.0, -1.0);
+  if (vi == 1u) { p = vec2<f32>(3.0, -1.0); }
+  else if (vi == 2u) { p = vec2<f32>(-1.0, 3.0); }
+  var out: VSOut;
+  out.pos = vec4<f32>(p, 0.0, 1.0);
+  // vUv = aPos * 0.5 + 0.5 (the aurora.vert convention).
+  out.uv = p * 0.5 + 0.5;
+  return out;
+}
+
+// ── Fragment stage (the main() transcription) ──
+@fragment
+fn fs_main(in: VSOut) -> @location(0) vec4<f32> {
+  let t = u.scalars0.x;
+  let valueVariance = u.scalars0.z;
+  let breathDepth = u.scalars2.w;
+  let breathPeriod = u.scalars3.x;
+  let saturation = u.scalars1.z;
+  let paperGrain = u.scalars1.w;
+  let alpha = u.scalars2.x;
+  let vividness = u.scalars3.w;
+
+  let uv = in.uv;
+  let pN = uv;
+
+  let p_warp = domainWarp(pN, t);
+
+  let nf = nucleiField(p_warp, t);
+  var col = samplePalette(nf.paletteId);
+  col = col * (1.0 + valueVariance * nf.valueMod);
+
+  // Breath — slow global luminance wobble.
+  let breath = sin(t * 6.2831 / max(breathPeriod, 1.0));
+  col = col * (1.0 + breathDepth * breath * 0.5);
+
+  // Painterly-medium dispatch. uMedium 0 (smooth) is a
+  // no-op pass-through so the DEFAULT smooth config renders unchanged
+  // (the parity capture); uMedium 1-7 render the painterly
+  // bodies (pastel/watercolor/crayon/kuwahara) or the anisotropic-Kuwahara finish
+  // (oil/vangogh/oil-pastel) — never a silent smooth degrade on Safari 26.
+  col = applyMedium(col, pN, t);
+
+  // Cursor-local luminance lean, byte-parallel with the GLSL path.
+  let cursorDelta = pN - u.cursor.xy;
+  let cursorRadius = max(u.scalars3.z, 0.01);
+  let cursorLean = exp(-dot(cursorDelta, cursorDelta) / (cursorRadius * cursorRadius * 0.5));
+  col = col * (1.0 + 0.12 * cursorLean * u.scalars3.y);
+
+  // Saturation trim.
+  col = saturate3(col, saturation);
+
+  // The chroma floor is warm-anchored and hue-preserving. The WGSL
+  // twin of the GLSL call; vividness:0 is a no-op so the smooth/pale default stays gated.
+  col = vividnessFloor(col, vividness);
+
+  // Tonemap + film grain.
+  col = aces(col);
+  // gl_FragCoord.xy → the device-pixel position (the WGSL @builtin(position)).
+  let fragCoord = in.pos.xy;
+  let grain = hash21(fragCoord + t * 17.0);
+  col = col + (grain - 0.5) * paperGrain;
+
+  col = clamp(col * 0.985 + 0.008, vec3<f32>(0.0), vec3<f32>(1.0));
+
+  // MANDATORY OETF — closes the seam (the whole pipeline above runs in LINEAR).
+  col = linearToSrgb(col);
+
+  // 1-LSB triangular IGN dither in DISPLAY space, AFTER the OETF.
+  col = col + (1.0 / 255.0) * (ign(fragCoord) - 0.5);
+
+  // Premultiply on DISPLAY-space color (matches the WebGL2 path: OETF, then premul).
+  return vec4<f32>(col * alpha, alpha);
+}
+`, m = `
+const MAX_NUCLEI: i32 = 8;
+const PI: f32 = 3.141592653589793;
+const BLUR_RINGS: i32 = 3;
+const BLUR_SECTORS: i32 = 8;
+
+// The image program's OWN uniform struct (packed vec4 lanes — trivial std140/WGSL
+// alignment). DISTINCT from the palette program's 672-byte struct (a separate program).
+struct ImageUniforms {
+  // scalars0: (uTime, uWarpAmount, uWarpScale, uWarpDrift)
+  scalars0: vec4<f32>,
+  // scalars1: (uSoftmaxBeta, uNucleiDrift, uCursorStrength, uCursorRadius)
+  scalars1: vec4<f32>,
+  // scalars2: (uSaturation, uPaperGrain, uAlpha, uVividness)
+  scalars2: vec4<f32>,
+  // image: (uBlurMin, uBlurMax, uImageAspect, _)
+  image: vec4<f32>,
+  // cursor: (uCursor.x, uCursor.y, _, _)
+  cursor: vec4<f32>,
+  // ints: (uNucleiCount, uNoiseOctaves, _, _)
+  ints: vec4<i32>,
+  // nuc0[i] = (pos.x, pos.y, radius, valueBias); nuc1[i] = (driftRadius, driftPhase, elong, angle)
+  nuc0: array<vec4<f32>, 8>,
+  nuc1: array<vec4<f32>, 8>,
+};
+
+@group(0) @binding(0) var<uniform> u: ImageUniforms;
+@group(0) @binding(1) var imgTex: texture_2d<f32>;
+@group(0) @binding(2) var imgSampler: sampler;
+
+const K_NUCLEI: f32 = 14.0;
+const K_WARP: f32 = 5.0;
+
+// ── Noise (aurora-local hash21/vnoise/fbm — the same compact foundation) ──
+fn hash21(p0: vec2<f32>) -> f32 {
+  var p = fract(p0 * vec2<f32>(123.34, 456.21));
+  p = p + dot(p, p + 45.32);
+  return fract(p.x * p.y);
+}
+fn vnoise(p: vec2<f32>) -> f32 {
+  let i = floor(p);
+  let f = fract(p);
+  let uu = f * f * (3.0 - 2.0 * f);
+  let a = hash21(i);
+  let b = hash21(i + vec2<f32>(1.0, 0.0));
+  let c = hash21(i + vec2<f32>(0.0, 1.0));
+  let d = hash21(i + vec2<f32>(1.0, 1.0));
+  return mix(mix(a, b, uu.x), mix(c, d, uu.x), uu.y);
+}
+${s}
+fn fbm(p0: vec2<f32>) -> f32 {
+  var v = 0.0;
+  var a = 0.5;
+  var p = p0;
+  let octaves = u.ints.y;
+  for (var i = 0; i < 5; i = i + 1) {
+    if (i >= octaves) { break; }
+    v = v + a * vnoise(p);
+    p = FBM_ROT * p * 2.02;
+    a = a * 0.5;
+  }
+  return v;
+}
+fn ign(p: vec2<f32>) -> f32 {
+  return fract(52.9829189 * fract(dot(p, vec2<f32>(0.06711056, 0.00583715))));
+}
+
+${a}
+${o}
+
+fn linOklab(lin: vec3<f32>) -> vec3<f32> {
+  let lms = LINEAR_SRGB_TO_LMS * lin;
+  return LMS_TO_OKLAB * cbrt3(lms);
+}
+
+// The Quilez double-warp (fbm) + the cursor swirl — the drift that moves the blur zone.
+fn domainWarp(p: vec2<f32>, t: f32) -> vec2<f32> {
+  let warpAmount = u.scalars0.y;
+  let warpScale = u.scalars0.z;
+  let warpDrift = u.scalars0.w;
+  let cursorStrength = u.scalars1.z;
+  let cursorRadius = u.scalars1.w;
+  let cursor = u.cursor.xy;
+  let q = vec2<f32>(fbm(p * warpScale + vec2<f32>(0.0, 0.0) + t * warpDrift * K_WARP),
+                    fbm(p * warpScale + vec2<f32>(5.2, 1.3) + t * warpDrift * K_WARP));
+  let r = vec2<f32>(fbm(p * warpScale + 4.0 * q + vec2<f32>(1.7, 9.2)),
+                    fbm(p * warpScale + 4.0 * q + vec2<f32>(8.3, 2.8)));
+  var warped = p + warpAmount * r;
+  if (cursorStrength > 0.001) {
+    let toP = p - cursor;
+    let d = length(toP);
+    let rr = max(cursorRadius, 0.01);
+    let w = exp(-(d * d) / (rr * rr * 0.45));
+    let ang = w * cursorStrength * 2.1;
+    let ca = cos(ang);
+    let sa = sin(ang);
+    let rotated = vec2<f32>(ca * toP.x - sa * toP.y, sa * toP.x + ca * toP.y) + cursor;
+    warped = mix(warped, rotated + warpAmount * r * 0.7, w * cursorStrength);
+  }
+  return warped;
+}
+
+// The drifting BLUR ZONE — the anisotropic-Gaussian nuclei softmax (the SAME field the
+// palette program reads), drift-coupled.
+fn zoneField(p: vec2<f32>, t: f32) -> f32 {
+  let nucleiCount = u.ints.x;
+  let nucleiDrift = u.scalars1.y;
+  let softmaxBeta = u.scalars1.x;
+  var accum = 0.0;
+  var accumW = 0.0;
+  for (var i = 0; i < MAX_NUCLEI; i = i + 1) {
+    if (i >= nucleiCount) { break; }
+    let n0 = u.nuc0[i];  // pos.x, pos.y, radius, valueBias
+    let n1 = u.nuc1[i];  // driftRadius, driftPhase, elong, angle
+    let posI = n0.xy + n1.x * vec2<f32>(
+      cos(t * nucleiDrift * K_NUCLEI + n1.y),
+      sin(t * nucleiDrift * K_NUCLEI + n1.y * 1.13));
+    let diff = p - posI;
+    let ca = cos(n1.w);
+    let sa = sin(n1.w);
+    let local = vec2<f32>(ca * diff.x + sa * diff.y, -sa * diff.x + ca * diff.y);
+    let along = local.x / max(n1.z, 0.01);
+    let d2 = along * along + local.y * local.y;
+    let rad = max(n0.z, 0.01);
+    let w = exp(-softmaxBeta * d2 / (rad * rad));
+    accum = accum + w * (0.5 + 0.5 * n0.w);
+    accumW = accumW + w;
+  }
+  return clamp(accum / max(accumW, 1e-4), 0.0, 1.0);
+}
+
+fn coverUv(uv: vec2<f32>) -> vec2<f32> {
+  let aspect = max(u.image.z, 0.0001);
+  var c = uv - vec2<f32>(0.5);
+  c.x = c.x * aspect;
+  let s = 1.0 / max(aspect, 1.0);
+  return c * s + vec2<f32>(0.5);
+}
+
+// The bounded 24-tap zone blur — a FIXED 3-ring × 8-sector stratified kernel, radius
+// per-fragment, sampled in LINEAR light. textureSampleLevel (explicit LOD 0) — WGSL has
+// no implicit derivative in a varying-radius loop.
+fn zoneBlur(uv: vec2<f32>, radius: f32) -> vec3<f32> {
+  let aspect = max(u.image.z, 0.0001);
+  var sum = srgbToLinear(textureSampleLevel(imgTex, imgSampler, coverUv(uv), 0.0).rgb);
+  var wsum = 1.0;
+  for (var ring = 1; ring <= BLUR_RINGS; ring = ring + 1) {
+    let rr = radius * (f32(ring) / f32(BLUR_RINGS));
+    for (var s = 0; s < BLUR_SECTORS; s = s + 1) {
+      let a = (f32(s) + 0.5 * f32(ring)) / f32(BLUR_SECTORS) * 2.0 * PI;
+      let off = vec2<f32>(cos(a) / aspect, sin(a)) * rr;
+      sum = sum + srgbToLinear(textureSampleLevel(imgTex, imgSampler, coverUv(uv + off), 0.0).rgb);
+      wsum = wsum + 1.0;
+    }
+  }
+  return sum / wsum;
+}
+
+const VIVID_TARGET: f32 = 0.115;
+const VIVID_EPS: f32 = 0.012;
+const VIVID_WARM_ANCHOR: vec2<f32> = vec2<f32>(0.34202, 0.93969);
+fn vividnessFloor(c: vec3<f32>, vividness: f32) -> vec3<f32> {
+  if (vividness <= 0.0001) { return c; }
+  var lab = linOklab(c);
+  let C = length(lab.yz);
+  let modeLift = mix(1.18, 1.0, clamp(lab.x * 1.4, 0.0, 1.0));
+  let Cmin = vividness * VIVID_TARGET * modeLift;
+  var hueDir = VIVID_WARM_ANCHOR;
+  if (C > VIVID_EPS) { hueDir = lab.yz / C; }
+  let yz = hueDir * max(C, Cmin);
+  lab = vec3<f32>(lab.x, yz.x, yz.y);
+  return max(oklabToLinearSrgb(lab), vec3<f32>(0.0));
+}
+
+fn saturate3(c: vec3<f32>, amt: f32) -> vec3<f32> {
+  var lch = oklabToOklch(linOklab(c));
+  lch.y = max(lch.y * amt, 0.0);
+  return max(oklabToLinearSrgb(oklchToOklab(lch)), vec3<f32>(0.0));
+}
+
+fn aces(color0: vec3<f32>) -> vec3<f32> {
+  let startCompression = 0.8 - 0.04;
+  let desaturation = 0.15;
+  var color = color0;
+  let x = min(color.r, min(color.g, color.b));
+  var offset = 0.04;
+  if (x < 0.08) { offset = x - 6.25 * x * x; }
+  color = color - offset;
+  let peak = max(color.r, max(color.g, color.b));
+  if (peak < startCompression) { return clamp(color, vec3<f32>(0.0), vec3<f32>(1.0)); }
+  let d = 1.0 - startCompression;
+  let newPeak = 1.0 - d * d / (peak + d - startCompression);
+  color = color * (newPeak / peak);
+  let g = 1.0 - 1.0 / (desaturation * (peak - newPeak) + 1.0);
+  return clamp(mix(color, newPeak * vec3<f32>(1.0), g), vec3<f32>(0.0), vec3<f32>(1.0));
+}
+
+struct VSOut {
+  @builtin(position) pos: vec4<f32>,
+  @location(0) uv: vec2<f32>,
+};
+
+@vertex
+fn vs_main(@builtin(vertex_index) vi: u32) -> VSOut {
+  var p = vec2<f32>(-1.0, -1.0);
+  if (vi == 1u) { p = vec2<f32>(3.0, -1.0); }
+  else if (vi == 2u) { p = vec2<f32>(-1.0, 3.0); }
+  var out: VSOut;
+  out.pos = vec4<f32>(p, 0.0, 1.0);
+  out.uv = p * 0.5 + 0.5;
+  return out;
+}
+
+@fragment
+fn fs_main(in: VSOut) -> @location(0) vec4<f32> {
+  let t = u.scalars0.x;
+  let saturation = u.scalars2.x;
+  let paperGrain = u.scalars2.y;
+  let alpha = u.scalars2.z;
+  let vividness = u.scalars2.w;
+  let blurMin = u.image.x;
+  let blurMax = u.image.y;
+
+  let uv = in.uv;
+  let p_warp = domainWarp(uv, t);
+  let zone = zoneField(p_warp, t);
+
+  let radius = mix(blurMin, blurMax, zone);
+  var col = zoneBlur(uv, radius);
+
+  let cursorDelta = uv - u.cursor.xy;
+  let cursorRadius = max(u.scalars1.w, 0.01);
+  let cursorLean = exp(-dot(cursorDelta, cursorDelta) / (cursorRadius * cursorRadius * 0.5));
+  col = col * (1.0 + 0.12 * cursorLean * u.scalars1.z);
+
+  col = saturate3(col, saturation);
+  col = vividnessFloor(col, vividness);
+
+  col = aces(col);
+  let fragCoord = in.pos.xy;
+  let grain = hash21(fragCoord + t * 17.0);
+  col = col + (grain - 0.5) * paperGrain;
+  col = clamp(col * 0.985 + 0.008, vec3<f32>(0.0), vec3<f32>(1.0));
+
+  col = linearToSrgb(col);
+  col = col + (1.0 / 255.0) * (ign(fragCoord) - 0.5);
+
+  return vec4<f32>(col * alpha, alpha);
+}
+`, h = {
+	scalars0: 0,
+	scalars1: 4,
+	scalars2: 8,
+	scalars3: 12,
+	cursor: 16,
+	ints0: 20,
+	ints1: 24,
+	palette: 28,
+	nuc0: 60,
+	nuc1: 92,
+	nuc2: 124,
+	scalars4: 156,
+	scalars5: 160,
+	kuwahara: 164
+}, g = .01, _ = 8, v = 4, y = (e) => 1 - e;
+function b() {
+	let e = /* @__PURE__ */ new ArrayBuffer(672);
+	return {
+		buffer: e,
+		f32: new Float32Array(e),
+		i32: new Int32Array(e),
+		paletteScratch: /* @__PURE__ */ new Float32Array(24)
+	};
+}
+function x(e, t, r, i, a = t.alpha) {
+	let { f32: o, i32: s, paletteScratch: c } = e;
+	o[h.scalars0 + 0] = i, o[h.scalars0 + 1] = t.softmaxBeta, o[h.scalars0 + 2] = t.valueVariance, o[h.scalars0 + 3] = t.warpAmount, o[h.scalars1 + 0] = t.warpScale, o[h.scalars1 + 1] = t.warpDrift, o[h.scalars1 + 2] = t.saturation, o[h.scalars1 + 3] = t.paperGrain, o[h.scalars2 + 0] = a, o[h.scalars2 + 1] = t.nucleiDrift, o[h.scalars2 + 2] = t.paletteDrift, o[h.scalars2 + 3] = t.breathDepth, o[h.scalars3 + 0] = t.breathPeriod, o[h.scalars3 + 1] = r.strength, o[h.scalars3 + 2] = r.radius, o[h.scalars3 + 3] = t.vividness ?? 1, o[h.cursor + 0] = r.x, o[h.cursor + 1] = y(r.y), o[h.cursor + 2] = t.metalPolish ?? 1, o[h.cursor + 3] = t.metalHeightScale ?? 1, s[h.ints0 + 0] = Math.min(t.palette.length, 8);
+	let d = Math.min(t.nuclei.length, 8);
+	s[h.ints0 + 1] = d, s[h.ints0 + 2] = u[t.warpMode], s[h.ints0 + 3] = t.noiseOctaves, s[h.ints1 + 0] = l[t.medium], s[h.ints1 + 1] = f[t.huePath ?? "shorter"], s[h.ints1 + 2] = 0, s[h.ints1 + 3] = 0, n(t.palette, 8, c);
+	for (let e = 0; e < 8; e++) {
+		let t = h.palette + e * 4;
+		o[t + 0] = c[e * 3 + 0], o[t + 1] = c[e * 3 + 1], o[t + 2] = c[e * 3 + 2], o[t + 3] = 0;
+	}
+	for (let e = 0; e < 8; e++) {
+		let n = h.nuc0 + e * 4, r = h.nuc1 + e * 4, i = h.nuc2 + e * 4;
+		if (e < d) {
+			let a = t.nuclei[e];
+			o[n + 0] = a.x, o[n + 1] = y(a.y), o[n + 2] = a.radius, o[n + 3] = a.paletteBias, o[r + 0] = a.valueBias, o[r + 1] = a.driftRadius, o[r + 2] = a.driftPhase, o[r + 3] = a.elongation ?? 1, o[i + 0] = -(a.angle ?? 0) * Math.PI / 180, o[i + 1] = 0, o[i + 2] = 0, o[i + 3] = 0;
+		} else o[n + 0] = 0, o[n + 1] = 0, o[n + 2] = 0, o[n + 3] = 0, o[r + 0] = 0, o[r + 1] = 0, o[r + 2] = 0, o[r + 3] = 1, o[i + 0] = 0, o[i + 1] = 0, o[i + 2] = 0, o[i + 3] = 0;
+	}
+	return o[h.scalars4 + 0] = t.strokeAmount, o[h.scalars4 + 1] = t.strokeScale, o[h.scalars4 + 2] = t.strokeAnisotropy, o[h.scalars4 + 3] = t.canvasGrain, o[h.scalars5 + 0] = t.wetEdge, o[h.scalars5 + 1] = t.granulation, o[h.scalars5 + 2] = t.brokenColor, o[h.scalars5 + 3] = t.kuwaharaQ ?? v, o[h.kuwahara + 0] = t.kuwaharaRadius ?? g, o[h.kuwahara + 1] = _, o[h.kuwahara + 2] = 0, o[h.kuwahara + 3] = 0, e;
+}
+var S = {
+	scalars0: 0,
+	scalars1: 4,
+	scalars2: 8,
+	image: 12,
+	cursor: 16,
+	ints: 20,
+	nuc0: 24,
+	nuc1: 56
+}, C = (e) => 1 - e;
+function w() {
+	let e = /* @__PURE__ */ new ArrayBuffer(352);
+	return {
+		buffer: e,
+		f32: new Float32Array(e),
+		i32: new Int32Array(e)
+	};
+}
+function T(e, t, n, r, i, a = t.alpha) {
+	let { f32: o, i32: s } = e;
+	o[S.scalars0 + 0] = r, o[S.scalars0 + 1] = t.warpAmount, o[S.scalars0 + 2] = t.warpScale, o[S.scalars0 + 3] = t.warpDrift, o[S.scalars1 + 0] = t.softmaxBeta, o[S.scalars1 + 1] = t.nucleiDrift, o[S.scalars1 + 2] = n.strength, o[S.scalars1 + 3] = n.radius, o[S.scalars2 + 0] = t.saturation, o[S.scalars2 + 1] = t.paperGrain, o[S.scalars2 + 2] = a, o[S.scalars2 + 3] = t.vividness ?? 1, o[S.image + 0] = t.imageBlur?.min ?? .004, o[S.image + 1] = t.imageBlur?.max ?? .06, o[S.image + 2] = i, o[S.image + 3] = 0, o[S.cursor + 0] = n.x, o[S.cursor + 1] = C(n.y), o[S.cursor + 2] = 0, o[S.cursor + 3] = 0;
+	let c = Math.min(t.nuclei.length, 8);
+	s[S.ints + 0] = c, s[S.ints + 1] = t.noiseOctaves, s[S.ints + 2] = 0, s[S.ints + 3] = 0;
+	for (let e = 0; e < 8; e++) {
+		let n = S.nuc0 + e * 4, r = S.nuc1 + e * 4;
+		if (e < c) {
+			let i = t.nuclei[e];
+			o[n + 0] = i.x, o[n + 1] = C(i.y), o[n + 2] = i.radius, o[n + 3] = i.valueBias, o[r + 0] = i.driftRadius, o[r + 1] = i.driftPhase, o[r + 2] = i.elongation ?? 1, o[r + 3] = -(i.angle ?? 0) * Math.PI / 180;
+		} else o[n + 0] = 0, o[n + 1] = 0, o[n + 2] = 0, o[n + 3] = 0, o[r + 0] = 0, o[r + 1] = 0, o[r + 2] = 1, o[r + 3] = 0;
+	}
+	return e;
+}
+//#endregion
+//#region src/components/aurora/composables/wgpuSetup.ts
+var E = 2, D = {
+	color: {
+		srcFactor: "one",
+		dstFactor: "one-minus-src-alpha",
+		operation: "add"
+	},
+	alpha: {
+		srcFactor: "one",
+		dstFactor: "one-minus-src-alpha",
+		operation: "add"
+	}
+};
+function O(e) {
+	let { canvas: n, opaquePresentation: r, getCursorScalars: i, getConfig: a, getReducedMotion: o, getRenderTime: s, pointerField: l, getDecodedImage: u, registerImageUploader: f } = e, m = null;
+	return function(e, h, g) {
+		if (a().source === "image") return k(e, h, g, {
+			canvas: n,
+			opaquePresentation: r,
+			getCursorScalars: i,
+			getConfig: a,
+			getReducedMotion: o,
+			getRenderTime: s,
+			pointerField: l,
+			getDecodedImage: u,
+			registerImageUploader: f
+		});
+		let _ = e.createShaderModule({
+			label: "[Aurora] aurora.wgsl",
+			code: p
+		}), v = e.createBuffer({
+			label: "[Aurora] uniforms",
+			size: 672,
+			usage: 72
+		}), y = e.createBindGroupLayout({
+			label: "[Aurora] bind-group-0",
+			entries: [{
+				binding: 0,
+				visibility: E,
+				buffer: { type: "uniform" }
+			}]
+		}), S = e.createRenderPipeline({
+			label: "[Aurora] pipeline",
+			layout: e.createPipelineLayout({ bindGroupLayouts: [y] }),
+			vertex: {
+				module: _,
+				entryPoint: "vs_main"
+			},
+			fragment: {
+				module: _,
+				entryPoint: "fs_main",
+				targets: [{
+					format: g,
+					blend: r ? void 0 : D
+				}]
+			},
+			primitive: { topology: "triangle-list" }
+		}), C = e.createBindGroup({
+			label: "[Aurora] bind-group",
+			layout: y,
+			entries: [{
+				binding: 0,
+				resource: { buffer: v }
+			}]
+		}), w = b();
+		function T(e) {}
+		function O(t) {
+			let n = +!o(), c = m === null ? 0 : Math.max(0, (t - m) * 1e3);
+			m = t, l.tick(n === 0 ? 0 : c);
+			let u = d(l, i(), n), f = a();
+			x(w, f, u, s(t), r ? 1 : f.alpha), e.queue.writeBuffer(v, 0, w.buffer);
+			let p = h.getCurrentTexture().createView(), g = e.createCommandEncoder({ label: "[Aurora] frame" }), _ = g.beginRenderPass({ colorAttachments: [{
+				view: p,
+				clearValue: {
+					r: 0,
+					g: 0,
+					b: 0,
+					a: +!!r
+				},
+				loadOp: "clear",
+				storeOp: "store"
+			}] });
+			_.setPipeline(S), _.setBindGroup(0, C), _.draw(3, 1, 0, 0), _.end(), e.queue.submit([g.finish()]);
+		}
+		function A() {
+			return o() ? !1 : t(a()) ? !0 : c(l);
+		}
+		return {
+			frame: O,
+			shouldContinue: A,
+			resize: T,
+			teardown: () => {
+				v.destroy();
+			}
+		};
+	};
+}
+function k(n, i, a, o) {
+	let { canvas: s, opaquePresentation: l, getCursorScalars: u, getConfig: f, getReducedMotion: p, getRenderTime: h, pointerField: g, getDecodedImage: _, registerImageUploader: v } = o, y = null, b = n.createShaderModule({
+		label: "[Aurora] aurora-image.wgsl",
+		code: m
+	}), x = n.createBuffer({
+		label: "[Aurora] image uniforms",
+		size: 352,
+		usage: 72
+	}), S = n.createSampler({
+		label: "[Aurora] image sampler",
+		magFilter: "linear",
+		minFilter: "linear",
+		addressModeU: "clamp-to-edge",
+		addressModeV: "clamp-to-edge"
+	}), C = n.createBindGroupLayout({
+		label: "[Aurora] image bind-group-0",
+		entries: [
+			{
+				binding: 0,
+				visibility: E,
+				buffer: { type: "uniform" }
+			},
+			{
+				binding: 1,
+				visibility: E,
+				texture: {
+					sampleType: "float",
+					viewDimension: "2d"
+				}
+			},
+			{
+				binding: 2,
+				visibility: E,
+				sampler: { type: "filtering" }
+			}
+		]
+	}), O = n.createRenderPipeline({
+		label: "[Aurora] image pipeline",
+		layout: n.createPipelineLayout({ bindGroupLayouts: [C] }),
+		vertex: {
+			module: b,
+			entryPoint: "vs_main"
+		},
+		fragment: {
+			module: b,
+			entryPoint: "fs_main",
+			targets: [{
+				format: a,
+				blend: l ? void 0 : D
+			}]
+		},
+		primitive: { topology: "triangle-list" }
+	}), k = r(n, _() ?? e()).texture;
+	function A() {
+		return n.createBindGroup({
+			label: "[Aurora] image bind-group",
+			layout: C,
+			entries: [
+				{
+					binding: 0,
+					resource: { buffer: x }
+				},
+				{
+					binding: 1,
+					resource: k.createView()
+				},
+				{
+					binding: 2,
+					resource: S
+				}
+			]
+		});
+	}
+	let j = A();
+	v((e) => {
+		k.destroy(), k = r(n, e).texture, j = A();
+	});
+	let M = w();
+	function N(e) {}
+	function P(e) {
+		let t = +!p(), r = y === null ? 0 : Math.max(0, (e - y) * 1e3);
+		y = e, g.tick(t === 0 ? 0 : r);
+		let a = d(g, u(), t), o = s.height > 0 ? s.width / s.height : 1, c = f();
+		T(M, c, a, h(e), o, l ? 1 : c.alpha), n.queue.writeBuffer(x, 0, M.buffer);
+		let m = i.getCurrentTexture().createView(), _ = n.createCommandEncoder({ label: "[Aurora] image frame" }), v = _.beginRenderPass({ colorAttachments: [{
+			view: m,
+			clearValue: {
+				r: 0,
+				g: 0,
+				b: 0,
+				a: +!!l
+			},
+			loadOp: "clear",
+			storeOp: "store"
+		}] });
+		v.setPipeline(O), v.setBindGroup(0, j), v.draw(3, 1, 0, 0), v.end(), n.queue.submit([_.finish()]);
+	}
+	function F() {
+		return p() ? !1 : t(f()) ? !0 : c(g);
+	}
+	return {
+		frame: P,
+		shouldContinue: F,
+		resize: N,
+		teardown: () => {
+			v(null), k.destroy(), x.destroy();
+		}
+	};
+}
+//#endregion
+export { O as createAuroraWGPUSetup };