@mkbabb/glass-ui 4.0.1 → 4.2.0

package/dist/concentric.js

@@ -1,45 +1,53 @@
-import { t as e } from "./_plugin-vue_export-helper-C1je1s0u.js";
-import { n as t, r as n } from "./procedural-color.glsl-CIFsJhwI.js";
-import { a as r, n as i, r as a, u as o } from "./procedural-color.wgsl-CToRHugY.js";
-import { c as s } from "./color-DweYl7pE.js";
-import { computed as c, createElementBlock as l, createElementVNode as u, defineComponent as d, normalizeStyle as f, onScopeDispose as p, openBlock as m, useTemplateRef as h, watch as g } from "vue";
+import { t as e } from "./_plugin-vue_export-helper-gLzyemvl.js";
+import { t } from "./usePointerVelocityField-BrkqZFhj.js";
+import { n, o as r, r as i, s as a } from "./procedural-color.wgsl-C1Y5PkM6.js";
+import { t as o } from "./flow.glsl-DqEGRpl4.js";
+import { a as s, t as c } from "./useGpuSubstrate-Ceet70xq.js";
+import { c as l } from "./color-B9jZdhJX.js";
+import { t as u } from "./useGlobalDark-B4HO9LXG.js";
+import { c as d, d as f, f as p, l as m, n as h, p as g, s as _, u as v } from "./paperGrid-CXCSMbZ1.js";
+import { computed as y, createElementBlock as b, createElementVNode as x, defineComponent as S, normalizeStyle as C, onScopeDispose as w, openBlock as T, useTemplateRef as E, watch as D } from "vue";
 //#region src/components/custom/concentric/shaders/concentric.wgsl.ts
-var _ = `
+var O = `
 const PI: f32 = 3.141592653589793;
 const TAU: f32 = 6.283185307179586;
-const RING_GRAVITY: f32 = 9.81;
-const MAX_RINGS: i32 = 8;
-const MAX_CENTERS: i32 = 4;
 const MAX_RING_STOPS: i32 = 4;
 
 // ── Concentric uniforms (the typed-struct source-of-truth — see uniformBridgeWGPU.ts) ──
 struct ConcentricUniforms {
-  // u0: (uTime, uSpeed, uAxisA, uAxisB)
+  // u0: (uTime, uSpeed, uCellSize, _pad)
   u0: vec4<f32>,
-  // ints: (uCenterCount, uRingCount, uStopCount, _pad)
+  // ints: (_pad, _pad, uStopCount, _pad)
   ints: vec4<i32>,
   // bg: (background.rgb (linear), hasBackground)
   bg: vec4<f32>,
-  // norm: (uFieldNorm, uAspect, _pad, _pad) — field → [0,1] scale
+  // norm: (uFieldNorm, uAspect, lightDirX, lightDirY)
   norm: vec4<f32>,
-  // each ring row: (amplitude, wavelength, phase, _pad)
-  rings: array<vec4<f32>, 8>,
-  // each center row: (x, y, weight, _pad)
-  centers: array<vec4<f32>, 4>,
+  // line: (lineHalfWidth, aaSoftness, contourLevels, indexEvery)
+  line: vec4<f32>,
+  // wave: (waveDirX, waveDirY, waveK, waveOmega)
+  wave: vec4<f32>,
+  // wave2: (waveSigma, twistMax, shearMax, amp)
+  wave2: vec4<f32>,
+  // topo: (heightOctaves, heightSeed, swellAmp, perturbAmp)
+  topo: vec4<f32>,
+  // cursor: (cursorX, cursorY, cursorWell, interactive)
+  cursor: vec4<f32>,
+  // tune: (toneGain, shadeAmp, indexMul, inkDarken)
+  tune: vec4<f32>,
   // each palette stop: linear-sRGB rgb + _pad
   palette: array<vec4<f32>, 4>,
 };
 
 @group(0) @binding(0) var<uniform> u: ConcentricUniforms;
 
+${n}
 ${i}
-${a}
 
-// Full-screen-triangle (the pilot idiom): NDC corners (-1,-1),(3,-1),(-1,3) cover the
-// viewport from a single 3-vertex draw — no vertex buffer.
+// Full-screen-triangle (the pilot idiom).
 struct VSOut {
   @builtin(position) pos: vec4<f32>,
-  @location(0) uv: vec2<f32>,  // domain [-1,1]², aspect-corrected x
+  @location(0) uv: vec2<f32>,
 };
 
 @vertex
@@ -50,46 +58,88 @@ fn vs_main(@builtin(vertex_index) vi: u32) -> VSOut {
   let c = corners[vi];
   var out: VSOut;
   out.pos = vec4<f32>(c, 0.0, 1.0);
-  // aspect-correct so the rings stay circular under the ellipsoidal norm (NOT squashed
-  // by the canvas aspect): widen the domain x by the aspect ratio.
   out.uv = vec2<f32>(c.x, c.y);
   return out;
 }
 
-// The ellipsoidal radial distance ‖p − c‖_e = sqrt((dx/a)² + (dy/b)²). The single radial
-// metric (transcribes ringField.ts ellipsoidalRadius).
-fn ellipsoidalRadius(p: vec2<f32>, center: vec2<f32>, axisA: f32, axisB: f32) -> f32 {
-  let dx = (p.x - center.x) / max(axisA, 1e-4);
-  let dy = (p.y - center.y) / max(axisB, 1e-4);
-  return sqrt(dx * dx + dy * dy);
+// ── The host noise basis (the SAME quintic-faded value-noise the suite speaks) ──
+fn hash21(x: f32, y: f32) -> f32 {
+  var px = fract(x * 0.1031);
+  var py = fract(y * 0.1031);
+  var pz = fract(x * 0.1031);
+  let d = px * (py + 33.33) + py * (pz + 33.33) + pz * (px + 33.33);
+  px = px + d; py = py + d; pz = pz + d;
+  return fract((px + py) * pz);
+}
+fn valueNoise(x: f32, y: f32) -> f32 {
+  let ix = floor(x); let iy = floor(y);
+  let fx = x - ix; let fy = y - iy;
+  let ux = fx * fx * fx * (fx * (fx * 6.0 - 15.0) + 10.0);
+  let uy = fy * fy * fy * (fy * (fy * 6.0 - 15.0) + 10.0);
+  let a = hash21(ix, iy);
+  let b = hash21(ix + 1.0, iy);
+  let c = hash21(ix, iy + 1.0);
+  let d2 = hash21(ix + 1.0, iy + 1.0);
+  return mix(mix(a, b, ux), mix(c, d2, ux), uy);
+}
+// The single-octave potential the curl operator wraps + the height field samples.
+fn potentialFBM(p: vec2f) -> f32 {
+  var v = 0.0; var amp = 0.5; var freq = 1.0;
+  var px = p.x; var py = p.y;
+  for (var i = 0; i < 3; i = i + 1) {
+    v = v + amp * valueNoise(px * freq, py * freq);
+    let rx = 0.8 * px - 0.6 * py;
+    let ry = 0.6 * px + 0.8 * py;
+    px = rx; py = ry; freq = freq * 2.0; amp = amp * 0.5;
+  }
+  return v;
+}
+
+// The shared curl + wave chunks (splice AFTER valueNoise + potentialFBM are declared).
+${g}
+${p}
+
+fn smoothstepEdge(e0: f32, e1: f32, x: f32) -> f32 {
+  let t = clamp((x - e0) / max(e1 - e0, 1e-6), 0.0, 1.0);
+  return t * t * (3.0 - 2.0 * t);
 }
 
-// The radial-Fourier ring-interference value f(p,t) — the multi-center weighted sum of
-// radial sinusoids (transcribes ringField.ts sampleRingField line-for-line).
-fn sampleRingField(p: vec2<f32>, t: f32) -> f32 {
-  var acc = 0.0;
-  let speed = u.u0.y;
-  let axisA = u.u0.z;
-  let axisB = u.u0.w;
-  let centerCount = u.ints.x;
-  let ringCount = u.ints.y;
-  for (var j = 0; j < MAX_CENTERS; j = j + 1) {
-    if (j >= centerCount) { break; }
-    let cj = u.centers[j];
-    let radius = ellipsoidalRadius(p, cj.xy, axisA, axisB);
-    var centerSum = 0.0;
-    for (var i = 0; i < MAX_RINGS; i = i + 1) {
-      if (i >= ringCount) { break; }
-      let r = u.rings[i];
-      let k = TAU / max(r.y, 1e-4);
-      // ω = √(g·k); speed scales the travel (the shared dispersion law).
-      let omega = sqrt(RING_GRAVITY * k) * speed;
-      let theta = k * radius - omega * t + r.z;
-      centerSum = centerSum + r.x * sin(theta);
-    }
-    acc = acc + centerSum * cj.z;
+// The level-set height at domain p (transcribes levelField.ts sampleHeight). The sampling
+// coordinate is cell-twisted (the SAME wave that twists paper-grid cells — kinship); the
+// height is a low-octave topography + the swell + the cursor peak.
+fn sampleHeight(p: vec2f, t: f32) -> f32 {
+  // The CONTINUOUS traveling-wave flow warp (no per-cell seam — the contours flow + twist as
+  // the wave passes OVER and THROUGH them, the SAME wave that twists the paper-grid cells).
+  var g = waveFlow(p, t, u.wave.xy, u.wave.z, u.wave.w, u.wave2.x, u.wave2.y, u.wave2.w);
+  if (u.cursor.w > 0.5) {
+    g = cursorSwirl(g, u.cursor.xy, u.cursor.z * 0.6, u.u0.z * 2.5);
   }
-  return acc;
+  // Sample the topography at a LOW base frequency so the basins are BROAD nested loops (a
+  // readable contour map — not a fine speckle). heightOctaves carries the fractal detail.
+  var H = heightField(g * 0.9, u.topo.x, u.topo.y);
+  H = H + u.topo.z * waveSwell(t, u.topo.y);
+  if (u.cursor.w > 0.5) {
+    let d = p - u.cursor.xy;
+    let d2 = dot(d, d);
+    // The cursor HEAVE — a SOFT bulge (a Gaussian peak feathered by a smoothstep falloff so
+    // the heave is C1-smooth, NOT the hard-edged quad the old dark render showed). The well
+    // depth/radius already carry the velocity-HEAVE scale (packed JS-side into u.cursor.z).
+    let g0 = exp(-d2 / 0.22);
+    let fall = smoothstepEdge(0.0, 0.55, exp(-d2 / 0.6));
+    H = H + u.cursor.z * g0 * fall;
+  }
+  return H;
+}
+
+// The IQ gradient-free level-set contour ink — KEPT BYTE-FROZEN (the perfect GPU AA). It is
+// FED the per-level half-width 'hw' (a parameter, NOT a re-derivation): de_contour =
+// |fract(fN + 0.5) − 0.5| / fwidth(fN). The contour density tracks 1/|∇H| automatically.
+// 'aaW' floors against a DPR-aware minimum so the index line stays CONTINUOUS where the heave
+// packs contours (steep |∇H| saturates fwidth — challenge R4).
+fn contourInk(fN: f32, hw: f32) -> f32 {
+  let band = abs(fract(fN + 0.5) - 0.5);
+  let aaW = max(fwidth(fN), 6e-4);
+  return 1.0 - smoothstepEdge(hw, hw + u.line.y, band / aaW);
 }
 
 // Sample the multi-stop palette (linear-sRGB stops, OKLab mix). t in [0,1].
@@ -106,172 +156,199 @@ fn samplePaletteLin(t: f32) -> vec3<f32> {
   return oklabToLinearSrgb(mix(labA, labB, f));
 }
 
+// The SHARED hillshade finite-diff epsilon — pinned ONCE (mirrors levelField.HILLSHADE_EPSILON
+// + the GLSL twin; a per-backend drift would red the L6 numeric parity).
+const HILLSHADE_E: f32 = 0.012;
+
 @fragment
 fn fs_main(in: VSOut) -> @location(0) vec4<f32> {
-  // aspect-correct the domain x so the rings read circular under the ellipsoidal norm.
   let aspect = max(u.norm.y, 1e-4);
   let p = vec2<f32>(in.uv.x * aspect, in.uv.y);
-  let t = u.u0.x;
+  let t = u.u0.x * u.u0.y;
+  let levels = max(u.line.z, 1.0);
 
-  let raw = sampleRingField(p, t);
-  // Normalize the field → [0,1] for the palette ramp (uFieldNorm is the amplitude scale).
-  let v = clamp(0.5 + raw * u.norm.x, 0.0, 1.0);
+  // The level-set topography (the KEPT field — the PRIMARY path).
+  let H = sampleHeight(p, t);
 
-  let lin = samplePaletteLin(v);
-  let rgb = clamp(linearToSrgb(lin), vec3<f32>(0.0), vec3<f32>(1.0));
+  // ── 1. HYPSOMETRIC TONE — tanh expands the compressed band so basins+ridges hit the ramp
+  //    ENDS (the live lumVar-flat cause). samplePaletteLin is the KEPT OKLab operator.
+  let tone = 0.5 + 0.5 * tanh(H * u.tune.x);
+  var fill = samplePaletteLin(tone);
 
-  // Premultiplied-alpha output over the (transparent / themed) ground.
-  let hasBg = u.bg.w;
-  if (hasBg > 0.5) {
-    // opaque themed ground: the field paints fully opaque.
-    return vec4<f32>(rgb, 1.0);
-  }
-  // transparent ground: the field's alpha rides its own brightness so the page reads
-  // through the troughs (the ring crests carry the ink; the calm field is faint).
-  let alpha = clamp(v * 0.92 + 0.08, 0.0, 1.0);
-  return vec4<f32>(rgb * alpha, alpha);
-}
-`, v = 9.81, y = Math.PI * 2;
-function b(e, t, n, r) {
-	let i = (e.x - t.x) / Math.max(n, 1e-4), a = (e.y - t.y) / Math.max(r, 1e-4);
-	return Math.sqrt(i * i + a * a);
-}
-function x(e, t, n, r, i, a, o) {
-	let s = 0;
-	for (let c of n) {
-		let n = b(e, c, i, a), l = 0;
-		for (let e of r) {
-			let r = y / Math.max(e.wavelength, 1e-4), i = Math.sqrt(v * r) * o, a = r * n - i * t + e.phase;
-			l += e.amplitude * Math.sin(a);
-		}
-		s += l * c.weight;
-	}
-	return s;
+  // ── 2. ANALYTIC HILLSHADE — one ∇H finite-diff at the SHARED e, dotted with the fixed cel
+  //    light → 2.5-D relief. A read-only re-sample of sampleHeight (no second field).
+  let e = HILLSHADE_E;
+  let hx = sampleHeight(p + vec2<f32>(e, 0.0), t) - sampleHeight(p - vec2<f32>(e, 0.0), t);
+  let hy = sampleHeight(p + vec2<f32>(0.0, e), t) - sampleHeight(p - vec2<f32>(0.0, e), t);
+  let grad = vec2<f32>(hx, hy) / (2.0 * e);
+  let L = normalize(u.norm.zw + vec2<f32>(1e-5, 1e-5));
+  let shade = 0.5 + 0.5 * clamp(dot(normalize(grad + vec2<f32>(1e-5)), L), -1.0, 1.0);
+  fill = fill * mix(1.0 - u.tune.y, 1.0 + u.tune.y, shade);
+
+  // ── 3. TWO-TIER INDEX/MINOR CONTOUR — isIndex a pure f(level) (floor + mod + select, NOT a
+  //    state buffer); the per-level half-width hw is FED to the byte-frozen contourInk.
+  let fN = H * levels + u.topo.w * sin(floor(H * levels) * 2.4 + t * 0.7);
+  let indexEvery = max(u.line.w, 1.0);
+  let lvl = floor(fN);
+  let isIndex = select(0.0, 1.0, fract(lvl / indexEvery) < (0.5 / indexEvery));
+  let hw = mix(u.line.x, u.line.x * u.tune.z, isIndex);
+  let ink = clamp(contourInk(fN, hw), 0.0, 1.0);
+
+  // ── 4. INK = a darker ember of the LOCAL fill (the edge-of-its-own-band signature).
+  let inkCol = mix(fill, fill * u.tune.w, 0.85);
+
+  // ── 5. ONE color path + OPAQUE OUT — the viz IS the colorful field, never lines-over-nothing.
+  //    Per-mode is resolved in the CONSUMED stops + the bg token (no in-shader uMode branch).
+  let col = mix(fill, inkCol, ink);
+  return vec4<f32>(clamp(linearToSrgb(col), vec3<f32>(0.0), vec3<f32>(1.0)), 1.0);
 }
-function S(e = 5) {
-	let t = [], n = .7;
-	for (let r = 0; r < e; r++) {
-		let e = y / n, i = Math.exp(-1 / (e * 1.4) ** 2) / (e * e);
-		t.push({
-			amplitude: i * .9,
-			wavelength: n,
-			phase: r * 1.618033 % y
-		}), n *= .62;
+`, k = 4, A = [
+	{
+		L: .5,
+		C: .115,
+		h: 350
+	},
+	{
+		L: .66,
+		C: .14,
+		h: 38
+	},
+	{
+		L: .8,
+		C: .115,
+		h: 70
+	},
+	{
+		L: .92,
+		C: .06,
+		h: 86
 	}
-	return t;
-}
-//#endregion
-//#region src/components/custom/concentric/constants.ts
-var C = 8, w = 4, T = 4, E = [
+], j = [
 	{
-		L: .94,
-		C: .025,
-		h: 80
+		L: .26,
+		C: .09,
+		h: 30
 	},
 	{
-		L: .82,
-		C: .075,
-		h: 62
+		L: .45,
+		C: .15,
+		h: 42
 	},
 	{
 		L: .66,
-		C: .105,
-		h: 44
+		C: .155,
+		h: 66
+	},
+	{
+		L: .84,
+		C: .13,
+		h: 84
 	}
-], D = S(5), O = [{
-	x: -.22,
-	y: -.14,
-	weight: 1
-}, {
-	x: .28,
-	y: .2,
-	weight: .7
-}], k = {
-	centers: O,
-	ringComponents: D,
-	axisRatio: [1, .62],
-	speed: .5,
-	palette: E,
-	background: "transparent",
-	interactive: !1,
+], M = {
+	L: .96,
+	C: .018,
+	h: 78
+}, N = {
+	L: .16,
+	C: .035,
+	h: 32
+}, P = {
+	speed: .6,
+	lineWidth: 1.8,
+	lineSoftness: 1,
+	contourLevels: 13,
+	cellSize: 1.2,
+	heightOctaves: 3,
+	heightSeed: 7,
+	swellAmp: .22,
+	perturbAmp: .06,
+	twistMax: .6,
+	shearMax: .24,
+	waveDir: [.92, .39],
+	waveK: .42,
+	waveOmega: .7,
+	waveSigma: .85,
+	cursorWell: .5,
+	toneGain: 1.6,
+	shadeAmp: .18,
+	lightDir: [-.6, .8],
+	indexEvery: 5,
+	indexMul: 1.9,
+	inkDarken: .45,
+	velocityHeave: .4,
+	palette: A,
+	background: M,
+	interactive: !0,
 	respectReducedMotion: !0
-}, A = 320, j = {
+}, F = 224, I = {
 	u0: 0,
 	ints: 4,
 	bg: 8,
 	norm: 12,
-	rings: 16,
-	centers: 48,
-	palette: 64
-}, M = .55;
-function N() {
-	let e = new ArrayBuffer(A);
+	line: 16,
+	wave: 20,
+	wave2: 24,
+	topo: 28,
+	cursor: 32,
+	tune: 36,
+	palette: 40
+}, L = .55;
+function R() {
+	let e = new ArrayBuffer(F);
 	return {
 		buffer: e,
 		f32: new Float32Array(e),
 		i32: new Int32Array(e)
 	};
 }
-function P(e, t, n, r, i) {
-	let { f32: a, i32: o } = e, [c, l] = t.axisRatio;
-	a[j.u0 + 0] = n, a[j.u0 + 1] = t.speed, a[j.u0 + 2] = c, a[j.u0 + 3] = l;
-	let u = Math.min(t.centers.length, 4), d = Math.min(t.ringComponents.length, 8), f = Math.min(i.length, 4);
-	if (o[j.ints + 0] = u, o[j.ints + 1] = d, o[j.ints + 2] = f, o[j.ints + 3] = 0, t.background === "transparent") a[j.bg + 0] = 0, a[j.bg + 1] = 0, a[j.bg + 2] = 0, a[j.bg + 3] = 0;
+function z(e, t, n, r, i, a, o, s) {
+	let { f32: c, i32: u } = e;
+	c[I.u0 + 0] = n, c[I.u0 + 1] = t.speed, c[I.u0 + 2] = t.cellSize, c[I.u0 + 3] = 0;
+	let d = Math.min(i.length, 4);
+	if (u[I.ints + 0] = 0, u[I.ints + 1] = 0, u[I.ints + 2] = d, u[I.ints + 3] = 0, t.background === "transparent") c[I.bg + 0] = 0, c[I.bg + 1] = 0, c[I.bg + 2] = 0, c[I.bg + 3] = 0;
 	else {
-		let e = s(t.background);
-		a[j.bg + 0] = e[0], a[j.bg + 1] = e[1], a[j.bg + 2] = e[2], a[j.bg + 3] = 1;
+		let e = l(t.background);
+		c[I.bg + 0] = e[0], c[I.bg + 1] = e[1], c[I.bg + 2] = e[2], c[I.bg + 3] = 1;
 	}
-	a[j.norm + 0] = M, a[j.norm + 1] = r, a[j.norm + 2] = 0, a[j.norm + 3] = 0, F(a, j.rings, t.ringComponents), I(a, j.centers, t.centers);
+	c[I.norm + 0] = L, c[I.norm + 1] = r, c[I.norm + 2] = t.lightDir[0], c[I.norm + 3] = t.lightDir[1], c[I.line + 0] = t.lineWidth, c[I.line + 1] = t.lineSoftness, c[I.line + 2] = t.contourLevels, c[I.line + 3] = t.indexEvery, c[I.wave + 0] = t.waveDir[0], c[I.wave + 1] = t.waveDir[1], c[I.wave + 2] = t.waveK, c[I.wave + 3] = t.waveOmega, c[I.wave2 + 0] = t.waveSigma, c[I.wave2 + 1] = t.twistMax, c[I.wave2 + 2] = t.shearMax, c[I.wave2 + 3] = o, c[I.topo + 0] = t.heightOctaves, c[I.topo + 1] = t.heightSeed, c[I.topo + 2] = t.swellAmp, c[I.topo + 3] = t.perturbAmp, c[I.cursor + 0] = a.x, c[I.cursor + 1] = a.y, c[I.cursor + 2] = t.cursorWell * s, c[I.cursor + 3] = +!!t.interactive, c[I.tune + 0] = t.toneGain, c[I.tune + 1] = t.shadeAmp, c[I.tune + 2] = t.indexMul, c[I.tune + 3] = t.inkDarken;
 	for (let e = 0; e < 4; e++) {
-		let t = j.palette + e * 4, n = s(i[Math.min(e, f - 1)] ?? i[0]);
-		a[t + 0] = n[0], a[t + 1] = n[1], a[t + 2] = n[2], a[t + 3] = 0;
+		let t = I.palette + e * 4, n = l(i[Math.min(e, d - 1)] ?? i[0]);
+		c[t + 0] = n[0], c[t + 1] = n[1], c[t + 2] = n[2], c[t + 3] = 0;
 	}
 	return e;
 }
-function F(e, t, n) {
-	for (let r = 0; r < 8; r++) {
-		let i = t + r * 4, a = n[r];
-		a ? (e[i + 0] = a.amplitude, e[i + 1] = a.wavelength, e[i + 2] = a.phase, e[i + 3] = 0) : (e[i + 0] = 0, e[i + 1] = 1, e[i + 2] = 0, e[i + 3] = 0);
-	}
-}
-function I(e, t, n) {
-	for (let r = 0; r < 4; r++) {
-		let i = t + r * 4, a = n[r];
-		a ? (e[i + 0] = a.x, e[i + 1] = a.y, e[i + 2] = a.weight, e[i + 3] = 0) : (e[i + 0] = 0, e[i + 1] = 0, e[i + 2] = 0, e[i + 3] = 0);
-	}
-}
 //#endregion
 //#region src/components/custom/concentric/composables/concentricWGPUSetup.ts
-var L = 64, R = 8, z = 2;
-function B(e) {
-	let { canvas: t, config: n, getPalette: r, shouldContinue: i } = e;
-	return function(e, a, s) {
-		let c = e.createShaderModule({
+var B = 64, V = 8, H = 2;
+function U(e) {
+	let { canvas: t, config: n, getPalette: r, getCursor: i, getAmp: a, getWellScale: o, shouldContinue: c, onFrame: l } = e;
+	return function(e, u, d) {
+		let f = e.createShaderModule({
 			label: "[Concentric] concentric.wgsl",
-			code: _
-		}), l = N(), u = e.createBuffer({
+			code: O
+		}), p = R(), m = e.createBuffer({
 			label: "[Concentric] uniforms",
-			size: l.buffer.byteLength,
-			usage: L | R
-		}), d = e.createBindGroupLayout({
+			size: p.buffer.byteLength,
+			usage: B | V
+		}), h = e.createBindGroupLayout({
 			label: "[Concentric] bgl",
 			entries: [{
 				binding: 0,
-				visibility: z,
+				visibility: H,
 				buffer: { type: "uniform" }
 			}]
-		}), f = e.createRenderPipeline({
+		}), g = e.createRenderPipeline({
 			label: "[Concentric] pipeline",
-			layout: e.createPipelineLayout({ bindGroupLayouts: [d] }),
+			layout: e.createPipelineLayout({ bindGroupLayouts: [h] }),
 			vertex: {
-				module: c,
+				module: f,
 				entryPoint: "vs_main"
 			},
 			fragment: {
-				module: c,
+				module: f,
 				entryPoint: "fs_main",
 				targets: [{
-					format: s,
+					format: d,
 					blend: {
 						color: {
 							srcFactor: "one",
@@ -287,22 +364,22 @@ function B(e) {
 				}]
 			},
 			primitive: { topology: "triangle-list" }
-		}), p = e.createBindGroup({
+		}), _ = e.createBindGroup({
 			label: "[Concentric] bg",
-			layout: d,
+			layout: h,
 			entries: [{
 				binding: 0,
-				resource: { buffer: u }
+				resource: { buffer: m }
 			}]
 		});
-		function m() {
-			let e = o(), n = t.clientWidth || 320, r = t.clientHeight || 320, i = Math.max(1, Math.round(n * e)), a = Math.max(1, Math.round(r * e));
+		function v() {
+			let e = s(), n = t.clientWidth || 320, r = t.clientHeight || 320, i = Math.max(1, Math.round(n * e)), a = Math.max(1, Math.round(r * e));
 			(t.width !== i || t.height !== a) && (t.width = i, t.height = a);
 		}
-		function h(i) {
-			P(l, n, i, (t.clientWidth || 320) / Math.max(t.clientHeight || 320, 1), r()), e.queue.writeBuffer(u, 0, l.buffer);
-			let o = e.createCommandEncoder({ label: "[Concentric] frame" }), s = a.getCurrentTexture().createView(), c = o.beginRenderPass({ colorAttachments: [{
-				view: s,
+		function y(s) {
+			l?.(s), z(p, n, s, (t.clientWidth || 320) / Math.max(t.clientHeight || 320, 1), r(), i(), a(), o()), e.queue.writeBuffer(m, 0, p.buffer);
+			let c = e.createCommandEncoder({ label: "[Concentric] frame" }), d = u.getCurrentTexture().createView(), f = c.beginRenderPass({ colorAttachments: [{
+				view: d,
 				clearValue: {
 					r: 0,
 					g: 0,
@@ -312,28 +389,25 @@ function B(e) {
 				loadOp: "clear",
 				storeOp: "store"
 			}] });
-			c.setPipeline(f), c.setBindGroup(0, p), c.draw(3, 1, 0, 0), c.end(), e.queue.submit([o.finish()]);
+			f.setPipeline(g), f.setBindGroup(0, _), f.draw(3, 1, 0, 0), f.end(), e.queue.submit([c.finish()]);
 		}
 		return {
-			frame: h,
-			shouldContinue: i,
-			resize: m,
+			frame: y,
+			shouldContinue: c,
+			resize: v,
 			teardown: () => {
-				u.destroy();
+				m.destroy();
 			}
 		};
 	};
 }
 //#endregion
 //#region src/components/custom/concentric/shaders/concentric.glsl.ts
-var V = "#version 300 es\nprecision highp float;\nin vec2 aPosition;\nout vec2 vUv;\nvoid main() {\n  vUv = aPosition;            // [-1,1]² domain\n  gl_Position = vec4(aPosition, 0.0, 1.0);\n}", H = `#version 300 es
+var W = "#version 300 es\nprecision highp float;\nin vec2 aPosition;\nout vec2 vUv;\nvoid main() {\n  vUv = aPosition;            // [-1,1]² domain\n  gl_Position = vec4(aPosition, 0.0, 1.0);\n}", G = `#version 300 es
 precision highp float;
 
 #define PI 3.141592653589793
 #define TAU 6.283185307179586
-#define RING_GRAVITY 9.81
-#define MAX_RINGS 8
-#define MAX_CENTERS 4
 #define MAX_RING_STOPS 4
 
 in vec2 vUv;
@@ -341,49 +415,101 @@ out vec4 fragColor;
 
 uniform float uTime;
 uniform float uSpeed;
-uniform vec2  uAxis;          // (a, b) ellipsoidal-norm axis ratio
-uniform float uFieldNorm;     // field → [0,1] amplitude scale
+uniform float uCellSize;      // the topography cell pitch (the contour-warp granularity)
+uniform float uFieldNorm;     // height → [0,1] tone scale
 uniform float uAspect;
-uniform int   uCenterCount;
-uniform int   uRingCount;
 uniform int   uStopCount;
 uniform float uHasBackground;
-uniform vec3  uRings[MAX_RINGS];     // (amplitude, wavelength, phase)
-uniform vec3  uCenters[MAX_CENTERS]; // (x, y, weight)
+uniform vec4  uLine;          // (lineHalfWidth, aaSoftness, contourLevels, indexEvery)
+uniform vec2  uLightDir;      // the fixed cel-light direction (folded norm.zw)
+uniform vec3  uBg;            // themed background (linear-sRGB)
+uniform vec4  uWave;          // (waveDirX, waveDirY, waveK, waveOmega)
+uniform vec4  uWave2;         // (waveSigma, twistMax, shearMax, amp)
+uniform vec4  uTopo;          // (heightOctaves, heightSeed, swellAmp, perturbAmp)
+uniform vec4  uCursor;        // (cursorX, cursorY, cursorWell, interactive)
+uniform vec4  uTune;          // (toneGain, shadeAmp, indexMul, inkDarken)
 uniform vec3  uPalette[MAX_RING_STOPS]; // linear-sRGB stops
 
-${t}
-${n}
+${r}
+${a}
+
+// The shared curl operator (flow.glsl.ts — forward-declares potentialFBM).
+${o}
 
-// ‖p − c‖_e = sqrt((dx/a)² + (dy/b)²) — transcribes ringField.ts ellipsoidalRadius.
-float ellipsoidalRadius(vec2 p, vec2 center, float axisA, float axisB) {
-  float dx = (p.x - center.x) / max(axisA, 1e-4);
-  float dy = (p.y - center.y) / max(axisB, 1e-4);
-  return sqrt(dx * dx + dy * dy);
+// ── The host noise basis (the SAME quintic-faded value-noise the suite speaks) ──
+float hash21(float x, float y) {
+  float px = fract(x * 0.1031);
+  float py = fract(y * 0.1031);
+  float pz = fract(x * 0.1031);
+  float d = px * (py + 33.33) + py * (pz + 33.33) + pz * (px + 33.33);
+  px += d; py += d; pz += d;
+  return fract((px + py) * pz);
+}
+float valueNoise(float x, float y) {
+  float ix = floor(x); float iy = floor(y);
+  float fx = x - ix; float fy = y - iy;
+  float ux = fx * fx * fx * (fx * (fx * 6.0 - 15.0) + 10.0);
+  float uy = fy * fy * fy * (fy * (fy * 6.0 - 15.0) + 10.0);
+  float a = hash21(ix, iy);
+  float b = hash21(ix + 1.0, iy);
+  float c = hash21(ix, iy + 1.0);
+  float d2 = hash21(ix + 1.0, iy + 1.0);
+  return mix(mix(a, b, ux), mix(c, d2, ux), uy);
+}
+// The curl chunk's forward-declared potentialFBM body.
+float potentialFBM(vec2 p) {
+  float v = 0.0; float amp = 0.5; float freq = 1.0;
+  float px = p.x; float py = p.y;
+  for (int i = 0; i < 3; i++) {
+    v += amp * valueNoise(px * freq, py * freq);
+    float rx = 0.8 * px - 0.6 * py;
+    float ry = 0.6 * px + 0.8 * py;
+    px = rx; py = ry; freq *= 2.0; amp *= 0.5;
+  }
+  return v;
 }
 
-// f(p,t) — the multi-center weighted radial sum (transcribes ringField.ts sampleRingField).
-float sampleRingField(vec2 p, float t) {
-  float acc = 0.0;
-  for (int j = 0; j < MAX_CENTERS; j++) {
-    if (j >= uCenterCount) break;
-    vec3 cj = uCenters[j];
-    float radius = ellipsoidalRadius(p, cj.xy, uAxis.x, uAxis.y);
-    float centerSum = 0.0;
-    for (int i = 0; i < MAX_RINGS; i++) {
-      if (i >= uRingCount) break;
-      vec3 r = uRings[i];
-      float k = TAU / max(r.y, 1e-4);
-      float omega = sqrt(RING_GRAVITY * k) * uSpeed;
-      float theta = k * radius - omega * t + r.z;
-      centerSum += r.x * sin(theta);
-    }
-    acc += centerSum * cj.z;
+// The shared traveling-wave CELL-WARP chunk (spliced AFTER valueNoise + potentialFBM + curl).
+${f}
+
+float smoothstepEdge(float e0, float e1, float x) {
+  float t = clamp((x - e0) / max(e1 - e0, 1e-6), 0.0, 1.0);
+  return t * t * (3.0 - 2.0 * t);
+}
+
+// The level-set height at domain p (transcribes levelField.ts sampleHeight).
+float sampleHeight(vec2 p, float t) {
+  // The CONTINUOUS traveling-wave flow warp (no per-cell seam — the contours flow + twist as
+  // the wave passes OVER and THROUGH them, the SAME wave that twists the paper-grid cells).
+  vec2 g = waveFlow(p, t, uWave.xy, uWave.z, uWave.w, uWave2.x, uWave2.y, uWave2.w);
+  if (uCursor.w > 0.5) {
+    g = cursorSwirl(g, uCursor.xy, uCursor.z * 0.6, uCellSize * 2.5);
+  }
+  // LOW base frequency → BROAD nested loops (a readable contour map). Octaves carry detail.
+  float H = heightField(g * 0.9, uTopo.x, uTopo.y);
+  H += uTopo.z * waveSwell(t, uTopo.y);
+  if (uCursor.w > 0.5) {
+    vec2 d = p - uCursor.xy;
+    float d2 = dot(d, d);
+    // The cursor HEAVE — a SOFT bulge (a Gaussian peak feathered by a smoothstep falloff so
+    // the heave is C1-smooth, NOT a hard-edged quad). The well depth/radius carry the
+    // velocity-HEAVE scale (packed JS-side into uCursor.z).
+    float g0 = exp(-d2 / 0.22);
+    float fall = smoothstepEdge(0.0, 0.55, exp(-d2 / 0.6));
+    H += uCursor.z * g0 * fall;
   }
-  return acc;
+  return H;
+}
+
+// The IQ gradient-free level-set contour ink — KEPT BYTE-FROZEN (the perfect GPU AA). It is
+// FED the per-level half-width 'hw' (a parameter, NOT a re-derivation). 'aaW' floors against a
+// DPR-aware minimum so the index line stays CONTINUOUS where the heave packs contours.
+float contourInk(float fN, float hw) {
+  float band = abs(fract(fN + 0.5) - 0.5);
+  float aaW = max(fwidth(fN), 6e-4);
+  return 1.0 - smoothstepEdge(hw, hw + uLine.y, band / aaW);
 }
 
-// Sample the multi-stop palette (linear-sRGB stops, OKLab mix). t in [0,1].
 vec3 samplePaletteLin(float t) {
   if (uStopCount <= 1) return uPalette[0];
   float n = float(uStopCount);
@@ -391,7 +517,6 @@ vec3 samplePaletteLin(float t) {
   int i0 = int(floor(ft));
   int i1 = min(i0 + 1, uStopCount - 1);
   float f = ft - float(i0);
-  // cube-root LMS (the GLSL chunk inlines cbrt as sign(x)·pow(|x|,1/3) — no cbrt3 fn).
   vec3 lmsA = LINEAR_SRGB_TO_LMS * uPalette[i0];
   vec3 lmsB = LINEAR_SRGB_TO_LMS * uPalette[i1];
   vec3 labA = LMS_TO_OKLAB * (sign(lmsA) * pow(abs(lmsA), vec3(1.0 / 3.0)));
@@ -399,23 +524,50 @@ vec3 samplePaletteLin(float t) {
   return oklabToLinearSrgb(mix(labA, labB, f));
 }
 
+// The SHARED hillshade finite-diff epsilon — pinned ONCE (mirrors levelField.HILLSHADE_EPSILON
+// + the WGSL twin; a per-backend drift would red the L6 numeric parity).
+const float HILLSHADE_E = 0.012;
+
 void main() {
   float aspect = max(uAspect, 1e-4);
   vec2 p = vec2(vUv.x * aspect, vUv.y);
-  float raw = sampleRingField(p, uTime);
-  float v = clamp(0.5 + raw * uFieldNorm, 0.0, 1.0);
-  vec3 lin = samplePaletteLin(v);
-  vec3 rgb = clamp(linearToSrgb(lin), vec3(0.0), vec3(1.0));
-  if (uHasBackground > 0.5) {
-    fragColor = vec4(rgb, 1.0);
-    return;
-  }
-  float alpha = clamp(v * 0.92 + 0.08, 0.0, 1.0);
-  fragColor = vec4(rgb * alpha, alpha);
+  float t = uTime * uSpeed;
+  float levels = max(uLine.z, 1.0);
+
+  // The level-set topography (the KEPT field — the PRIMARY path).
+  float H = sampleHeight(p, t);
+
+  // ── 1. HYPSOMETRIC TONE — tanh expands the compressed band (basins+ridges hit the ramp ENDS).
+  float tone = 0.5 + 0.5 * tanh(H * uTune.x);
+  vec3 fill = samplePaletteLin(tone);
+
+  // ── 2. ANALYTIC HILLSHADE — one ∇H finite-diff at the SHARED e, dotted with the cel light.
+  float e = HILLSHADE_E;
+  float hx = sampleHeight(p + vec2(e, 0.0), t) - sampleHeight(p - vec2(e, 0.0), t);
+  float hy = sampleHeight(p + vec2(0.0, e), t) - sampleHeight(p - vec2(0.0, e), t);
+  vec2 grad = vec2(hx, hy) / (2.0 * e);
+  vec2 L = normalize(uLightDir + vec2(1e-5));
+  float shade = 0.5 + 0.5 * clamp(dot(normalize(grad + vec2(1e-5)), L), -1.0, 1.0);
+  fill *= mix(1.0 - uTune.y, 1.0 + uTune.y, shade);
+
+  // ── 3. TWO-TIER INDEX/MINOR CONTOUR — isIndex a pure f(level); hw FED to the frozen contourInk.
+  float fN = H * levels + uTopo.w * sin(floor(H * levels) * 2.4 + t * 0.7);
+  float indexEvery = max(uLine.w, 1.0);
+  float lvl = floor(fN);
+  float isIndex = fract(lvl / indexEvery) < (0.5 / indexEvery) ? 1.0 : 0.0;
+  float hw = mix(uLine.x, uLine.x * uTune.z, isIndex);
+  float ink = clamp(contourInk(fN, hw), 0.0, 1.0);
+
+  // ── 4. INK = a darker ember of the LOCAL fill (the edge-of-its-own-band signature).
+  vec3 inkCol = mix(fill, fill * uTune.w, 0.85);
+
+  // ── 5. ONE color path + OPAQUE OUT — the viz IS the colorful field.
+  vec3 col = mix(fill, inkCol, ink);
+  fragColor = vec4(clamp(linearToSrgb(col), vec3(0.0), vec3(1.0)), 1.0);
 }`;
 //#endregion
 //#region src/components/custom/concentric/composables/concentricGLSetup.ts
-function U(e, t, n) {
+function K(e, t, n) {
 	let r = e.createShader(t);
 	if (e.shaderSource(r, n), e.compileShader(r), !e.getShaderParameter(r, e.COMPILE_STATUS)) {
 		let t = e.getShaderInfoLog(r);
@@ -423,16 +575,16 @@ function U(e, t, n) {
 	}
 	return r;
 }
-function W(e) {
-	let { canvas: t, config: n, getPalette: r, shouldContinue: i } = e;
+function q(e) {
+	let { canvas: t, config: n, getPalette: r, getCursor: i, getAmp: a, getWellScale: o, shouldContinue: c, onFrame: u } = e;
 	return function(e) {
-		let a = U(e, e.VERTEX_SHADER, V), c = U(e, e.FRAGMENT_SHADER, H), l = e.createProgram();
-		if (e.attachShader(l, a), e.attachShader(l, c), e.linkProgram(l), !e.getProgramParameter(l, e.LINK_STATUS)) throw Error(`[Concentric] link failed: ${e.getProgramInfoLog(l)}`);
-		e.deleteShader(a), e.deleteShader(c);
-		let u = e.createVertexArray();
-		e.bindVertexArray(u);
-		let d = e.createBuffer();
-		e.bindBuffer(e.ARRAY_BUFFER, d), e.bufferData(e.ARRAY_BUFFER, new Float32Array([
+		let d = K(e, e.VERTEX_SHADER, W), f = K(e, e.FRAGMENT_SHADER, G), p = e.createProgram();
+		if (e.attachShader(p, d), e.attachShader(p, f), e.linkProgram(p), !e.getProgramParameter(p, e.LINK_STATUS)) throw Error(`[Concentric] link failed: ${e.getProgramInfoLog(p)}`);
+		e.deleteShader(d), e.deleteShader(f);
+		let m = e.createVertexArray();
+		e.bindVertexArray(m);
+		let h = e.createBuffer();
+		e.bindBuffer(e.ARRAY_BUFFER, h), e.bufferData(e.ARRAY_BUFFER, new Float32Array([
 			-1,
 			-1,
 			3,
@@ -440,91 +592,131 @@ function W(e) {
 			-1,
 			3
 		]), e.STATIC_DRAW);
-		let f = e.getAttribLocation(l, "aPosition");
-		e.enableVertexAttribArray(f), e.vertexAttribPointer(f, 2, e.FLOAT, !1, 0, 0), e.bindVertexArray(null);
-		let p = (t) => e.getUniformLocation(l, t), m = p("uTime"), h = p("uSpeed"), g = p("uAxis"), _ = p("uFieldNorm"), v = p("uAspect"), y = p("uCenterCount"), b = p("uRingCount"), x = p("uStopCount"), S = p("uHasBackground"), C = p("uRings[0]"), w = p("uCenters[0]"), T = p("uPalette[0]");
-		function E() {
-			let n = o(), r = t.clientWidth || 320, i = t.clientHeight || 320, a = Math.max(1, Math.round(r * n)), s = Math.max(1, Math.round(i * n));
-			(t.width !== a || t.height !== s) && (t.width = a, t.height = s), e.viewport(0, 0, t.width, t.height);
+		let g = e.getAttribLocation(p, "aPosition");
+		e.enableVertexAttribArray(g), e.vertexAttribPointer(g, 2, e.FLOAT, !1, 0, 0), e.bindVertexArray(null);
+		let _ = (t) => e.getUniformLocation(p, t), v = _("uTime"), y = _("uSpeed"), b = _("uCellSize"), x = _("uFieldNorm"), S = _("uAspect"), C = _("uStopCount"), w = _("uHasBackground"), T = _("uLine"), E = _("uLightDir"), D = _("uBg"), O = _("uWave"), k = _("uWave2"), A = _("uTopo"), j = _("uCursor"), M = _("uTune"), N = _("uPalette[0]");
+		function P() {
+			let n = s(), r = t.clientWidth || 320, i = t.clientHeight || 320, a = Math.max(1, Math.round(r * n)), o = Math.max(1, Math.round(i * n));
+			(t.width !== a || t.height !== o) && (t.width = a, t.height = o), e.viewport(0, 0, t.width, t.height);
 		}
-		function D(i) {
-			let a = t.clientWidth || 320, o = t.clientHeight || 320, c = a / Math.max(o, 1);
-			e.useProgram(l), e.bindVertexArray(u), e.enable(e.BLEND), e.blendFunc(e.ONE, e.ONE_MINUS_SRC_ALPHA), e.clearColor(0, 0, 0, 0), e.clear(e.COLOR_BUFFER_BIT), e.uniform1f(m, i), e.uniform1f(h, n.speed), e.uniform2f(g, n.axisRatio[0], n.axisRatio[1]), e.uniform1f(_, M), e.uniform1f(v, c);
-			let d = Math.min(n.centers.length, 4), f = Math.min(n.ringComponents.length, 8), p = r(), E = Math.min(p.length, 4);
-			e.uniform1i(y, d), e.uniform1i(b, f), e.uniform1i(x, E), n.background === "transparent" ? e.uniform1f(S, 0) : e.uniform1f(S, 1);
-			let D = new Float32Array(24);
-			for (let e = 0; e < 8; e++) {
-				let t = n.ringComponents[e];
-				D[e * 3 + 0] = t?.amplitude ?? 0, D[e * 3 + 1] = t?.wavelength ?? 1, D[e * 3 + 2] = t?.phase ?? 0;
+		function F(s) {
+			u?.(s);
+			let c = t.clientWidth || 320, d = t.clientHeight || 320, f = c / Math.max(d, 1);
+			e.useProgram(p), e.bindVertexArray(m), e.enable(e.BLEND), e.blendFunc(e.ONE, e.ONE_MINUS_SRC_ALPHA), e.clearColor(0, 0, 0, 0), e.clear(e.COLOR_BUFFER_BIT), e.uniform1f(v, s), e.uniform1f(y, n.speed), e.uniform1f(b, n.cellSize), e.uniform1f(x, L), e.uniform1f(S, f);
+			let h = r(), g = Math.min(h.length, 4);
+			e.uniform1i(C, g), e.uniform4f(T, n.lineWidth, n.lineSoftness, n.contourLevels, n.indexEvery), e.uniform2f(E, n.lightDir[0], n.lightDir[1]), e.uniform4f(O, n.waveDir[0], n.waveDir[1], n.waveK, n.waveOmega), e.uniform4f(k, n.waveSigma, n.twistMax, n.shearMax, a()), e.uniform4f(A, n.heightOctaves, n.heightSeed, n.swellAmp, n.perturbAmp);
+			let _ = i();
+			if (e.uniform4f(j, _.x, _.y, n.cursorWell * o(), +!!n.interactive), e.uniform4f(M, n.toneGain, n.shadeAmp, n.indexMul, n.inkDarken), n.background === "transparent") e.uniform1f(w, 0), e.uniform3f(D, 0, 0, 0);
+			else {
+				e.uniform1f(w, 1);
+				let t = l(n.background);
+				e.uniform3f(D, t[0], t[1], t[2]);
 			}
-			e.uniform3fv(C, D);
-			let O = new Float32Array(12);
+			let P = new Float32Array(12);
 			for (let e = 0; e < 4; e++) {
-				let t = n.centers[e];
-				O[e * 3 + 0] = t?.x ?? 0, O[e * 3 + 1] = t?.y ?? 0, O[e * 3 + 2] = t?.weight ?? 0;
+				let t = l(h[Math.min(e, g - 1)] ?? h[0]);
+				P[e * 3 + 0] = t[0], P[e * 3 + 1] = t[1], P[e * 3 + 2] = t[2];
 			}
-			e.uniform3fv(w, O);
-			let k = new Float32Array(12);
-			for (let e = 0; e < 4; e++) {
-				let t = s(p[Math.min(e, E - 1)] ?? p[0]);
-				k[e * 3 + 0] = t[0], k[e * 3 + 1] = t[1], k[e * 3 + 2] = t[2];
-			}
-			e.uniform3fv(T, k), e.drawArrays(e.TRIANGLES, 0, 3), e.bindVertexArray(null);
+			e.uniform3fv(N, P), e.drawArrays(e.TRIANGLES, 0, 3), e.bindVertexArray(null);
 		}
 		return {
-			frame: D,
-			shouldContinue: i,
-			resize: E,
+			frame: F,
+			shouldContinue: c,
+			resize: P,
 			teardown: () => {
-				e.deleteProgram(l), e.deleteVertexArray(u), e.deleteBuffer(d);
+				e.deleteProgram(p), e.deleteVertexArray(m), e.deleteBuffer(h);
 			}
 		};
 	};
 }
 //#endregion
 //#region src/components/custom/concentric/composables/useConcentric.ts
-function G(e, t) {
-	let { config: n, getPalette: i } = t, a = t.mode ?? "live", o = null, s = () => {
+function J(e, n) {
+	let { config: r, getPalette: i } = n, a = n.mode ?? "live", o = t({ respectReducedMotion: r.respectReducedMotion }), s = {
+		x: 1e6,
+		y: 1e6
+	}, l = () => s, u = 0, d = () => u, f = 1, p = () => f, m = 0, h = () => {
+		o.onPointerEnter(), r.interactive && x?.wake();
+	}, g = (e) => {
+		o.onPointerMove(e), r.interactive && x?.wake();
+	}, _ = (e) => e.parentElement ?? e;
+	function v(e) {
+		let t = _(e);
+		t.addEventListener("pointermove", g), t.addEventListener("pointerenter", h), t.addEventListener("pointerleave", o.onPointerLeave);
+	}
+	function y(e) {
+		let t = _(e);
+		t.removeEventListener("pointermove", g), t.removeEventListener("pointerenter", h), t.removeEventListener("pointerleave", o.onPointerLeave);
+	}
+	function b(t) {
+		let n = m > 0 ? (t - m) * 1e3 : 16.7;
+		if (m = t, o.tick(n), x?.reducedMotion ? (u = 0, f = 1) : (u += (1.06 - u) * .04, u > 1 && (u = 1 + (u - 1) * .85)), !r.interactive || !o.active.value) {
+			s = {
+				x: 1e6,
+				y: 1e6
+			}, f = 1;
+			return;
+		}
+		let i = o.smoothedPosition.value, a = o.velocity.value, c = o.acceleration.value, l = .1, d = .04, p = e.value, h = (p?.clientWidth || 320) / Math.max(p?.clientHeight || 320, 1);
+		s = {
+			x: (i.x * 2 - 1 + a.x * l + c.x * d) * h,
+			y: -(i.y * 2 - 1) - a.y * l - c.y * d
+		};
+		let g = Math.hypot(a.x, a.y), _ = Math.min(g / 1.2, 1), v = _ * _ * (3 - 2 * _), y = o.burst.value;
+		f = 1 + r.velocityHeave * v + r.velocityHeave * .6 * y;
+	}
+	let x = null, S = () => {
 		let t = e.value;
-		return t ? (o || (o = r(t, {
+		return t ? (x || (v(t), x = c(t, {
 			mode: a,
-			respectReducedMotion: n.respectReducedMotion,
-			setupWGPU: B({
+			respectReducedMotion: r.respectReducedMotion,
+			setupWGPU: U({
 				canvas: t,
-				config: n,
+				config: r,
 				getPalette: i,
-				shouldContinue: () => !0
+				getCursor: l,
+				getAmp: d,
+				getWellScale: p,
+				shouldContinue: () => !0,
+				onFrame: b
 			}),
-			setupGL: W({
+			setupGL: q({
 				canvas: t,
-				config: n,
+				config: r,
 				getPalette: i,
-				shouldContinue: () => !0
+				getCursor: l,
+				getAmp: d,
+				getWellScale: p,
+				shouldContinue: () => !0,
+				onFrame: b
 			})
-		}), o.armAsync()), o) : null;
+		}), x.armAsync()), x) : null;
 	};
-	queueMicrotask(() => s());
-	let c = {
+	queueMicrotask(() => S());
+	let C = {
 		get backend() {
-			return s()?.backend ?? "webgpu";
+			return S()?.backend ?? "webgpu";
 		},
-		pause: () => s()?.suspend("manual"),
-		resume: () => s()?.resume("manual"),
-		wake: () => s()?.wake(),
-		renderAt: (e) => s()?.renderAt(e),
+		pause: () => S()?.suspend("manual"),
+		resume: () => S()?.resume("manual"),
+		wake: () => S()?.wake(),
+		renderAt: (e) => S()?.renderAt(e),
 		get reducedMotion() {
-			return o?.reducedMotion ?? !1;
+			return x?.reducedMotion ?? !1;
 		},
-		dispose: () => o?.dispose()
+		dispose: () => {
+			let t = e.value;
+			t && y(t), o.dispose(), x?.dispose();
+		}
 	};
-	return p(() => c.dispose()), c;
+	return w(() => C.dispose()), C;
 }
 //#endregion
 //#region src/components/custom/concentric/Concentric.vue
-var K = /* @__PURE__ */ e(/* @__PURE__ */ d({
+var Y = /* @__PURE__ */ e(/* @__PURE__ */ S({
 	__name: "Concentric",
 	props: {
-		config: { default: () => k },
+		config: { default: () => P },
 		paused: {
 			type: Boolean,
 			default: !1
@@ -532,24 +724,24 @@ var K = /* @__PURE__ */ e(/* @__PURE__ */ d({
 	},
 	emits: ["update:paused"],
 	setup(e, { expose: t }) {
-		let n = h("canvasRef"), r = G(n, {
+		let n = E("canvasRef"), { isDark: r } = u(), i = y(() => e.config.palette === A), a = () => i.value && r.value ? j : e.config.palette, o = y(() => i.value ? r.value ? N : M : e.config.background), s = J(n, {
 			config: e.config,
-			getPalette: () => e.config.palette
+			getPalette: a
 		});
-		g(() => e.paused, (e) => e ? r.pause() : r.resume(), { immediate: !0 });
-		let i = c(() => {
-			let t = e.config.background;
-			if (t !== "transparent") return `oklch(${t.L} ${t.C} ${t.h})`;
+		D(() => e.paused, (e) => e ? s.pause() : s.resume(), { immediate: !0 });
+		let c = y(() => {
+			let e = o.value;
+			if (e !== "transparent") return `oklch(${e.L} ${e.C} ${e.h})`;
 		});
 		return t({
-			pause: r.pause,
-			resume: r.resume,
-			wake: r.wake,
-			renderAt: r.renderAt
-		}), (e, t) => (m(), l("div", {
+			pause: s.pause,
+			resume: s.resume,
+			wake: s.wake,
+			renderAt: s.renderAt
+		}), (e, t) => (T(), b("div", {
 			class: "concentric-wrapper",
-			style: f(i.value ? { background: i.value } : void 0)
-		}, [u("canvas", {
+			style: C(c.value ? { background: c.value } : void 0)
+		}, [x("canvas", {
 			ref_key: "canvasRef",
 			ref: n,
 			class: "concentric-canvas",
@@ -557,6 +749,57 @@ var K = /* @__PURE__ */ e(/* @__PURE__ */ d({
 			"data-testid": "concentric-canvas"
 		}, null, 512)], 4));
 	}
-}), [["__scopeId", "data-v-f8bbc88a"]]);
+}), [["__scopeId", "data-v-18ed696c"]]);
+//#endregion
+//#region src/components/custom/concentric/composables/levelField.ts
+function X(e, t) {
+	let n = e * .1031 % 1, r = t * .1031 % 1, i = e * .1031 % 1;
+	n < 0 && (n += 1), r < 0 && (r += 1), i < 0 && (i += 1);
+	let a = n * (r + 33.33) + r * (i + 33.33) + i * (n + 33.33);
+	n += a, r += a, i += a;
+	let o = (n + r) * i % 1;
+	return o < 0 && (o += 1), o;
+}
+function Z(e, t) {
+	let n = Math.floor(e), r = Math.floor(t), i = e - n, a = t - r, o = i * i * i * (i * (i * 6 - 15) + 10), s = a * a * a * (a * (a * 6 - 15) + 10), c = X(n, r), l = X(n + 1, r), u = X(n, r + 1), d = X(n + 1, r + 1), f = (e, t, n) => e + (t - e) * n;
+	return f(f(c, l, o), f(u, d, o), s);
+}
+function Q(e, t, n) {
+	let r = m(h, e, t, n.waveDir, n.waveK, n.waveOmega, n.waveSigma, n.twistMax, n.amp);
+	n.interactive > .5 && (r = _(r, n.cursor, n.cursorWell * .6, n.cellSize * 2.5));
+	let i = d(Z, {
+		x: r.x * .9,
+		y: r.y * .9
+	}, n.heightOctaves, n.heightSeed);
+	if (i += n.swellAmp * v(t, n.heightSeed), n.interactive > .5) {
+		let t = e.x - n.cursor.x, r = e.y - n.cursor.y, a = t * t + r * r;
+		i += n.cursorWell * Math.exp(-a / .22);
+	}
+	return i;
+}
+var $ = .012;
+function ee(e, t) {
+	return .5 + .5 * Math.tanh(e * t);
+}
+function te(e, t, n, r) {
+	let i = $, a = Q({
+		x: e.x + i,
+		y: e.y
+	}, t, n) - Q({
+		x: e.x - i,
+		y: e.y
+	}, t, n), o = Q({
+		x: e.x,
+		y: e.y + i
+	}, t, n) - Q({
+		x: e.x,
+		y: e.y - i
+	}, t, n), s = a / (2 * i), c = o / (2 * i), l = Math.hypot(s, c) + 1e-5, u = Math.hypot(r.x, r.y) + 1e-5, d = s / l * (r.x / u) + c / l * (r.y / u);
+	return .5 + .5 * Math.max(-1, Math.min(1, d));
+}
+function ne(e, t) {
+	let n = Math.floor(e);
+	return +(n / t - Math.floor(n / t) < .5 / t);
+}
 //#endregion
-export { K as Concentric, O as DEFAULT_CENTERS, k as DEFAULT_CONCENTRIC_CONFIG, D as DEFAULT_RING_COMPONENTS, w as MAX_CENTERS, C as MAX_RINGS, T as MAX_RING_STOPS, v as RING_GRAVITY, E as WARM_IDENTITY_PALETTE, S as buildRingLadder, b as ellipsoidalRadius, x as sampleRingField, G as useConcentric };
+export { Y as Concentric, P as DEFAULT_CONCENTRIC_CONFIG, $ as HILLSHADE_EPSILON, k as MAX_RING_STOPS, N as WARM_GROUND_DARK, M as WARM_GROUND_LIGHT, A as WARM_IDENTITY_PALETTE, j as WARM_IDENTITY_PALETTE_DARK, te as hillshade, ne as isIndexLevel, Q as sampleHeight, ee as toneFromHeight, J as useConcentric };