@mkbabb/glass-ui 4.0.1 → 4.1.0

package/dist/concentric.js

@@ -1,10 +1,116 @@
 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";
-//#region src/components/custom/concentric/shaders/concentric.wgsl.ts
-var _ = `
+import { t } from "./usePointerVelocityField-QLsy3_kv.js";
+import { n, o as r, r as i, s as a } from "./procedural-color.wgsl-m7Zgv35j.js";
+import { a as o, t as s } from "./useGpuSubstrate-4pTcp6mX.js";
+import { c } from "./color-Cs0-oxYL.js";
+import { computed as l, createElementBlock as u, createElementVNode as d, defineComponent as f, normalizeStyle as p, onScopeDispose as m, openBlock as h, useTemplateRef as g, watch as _ } from "vue";
+//#region src/components/custom/concentric/composables/ringField.ts
+var v = 9.81, y = Math.PI * 2;
+function b(e, t, n, r) {
+	let i = Math.cos(t.rotAlpha), a = Math.sin(t.rotAlpha), o = e.x - t.x, s = e.y - t.y, c = i * o + a * s, l = -a * o + i * s, u = c / Math.max(n, 1e-4), d = l / Math.max(r, 1e-4);
+	return Math.sqrt(u * u + d * d);
+}
+function x(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 S(e, t, n, r) {
+	let i = Math.cos(t.rotAlpha), a = Math.sin(t.rotAlpha), o = e.x - t.x, s = e.y - t.y, c = i * o + a * s, l = -a * o + i * s, u = Math.max(n, 1e-4), d = Math.max(r, 1e-4), f = c / u, p = l / d, m = Math.sqrt(f * f + p * p), h = f / u, g = p / d;
+	return Math.sqrt(h * h + g * g) / Math.max(m, 1e-4);
+}
+function C(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;
+}
+function w(e, t, n, r, i, a, o, s, c, l = .08) {
+	let u = 0, d = 0;
+	for (let f of n) {
+		let n = b(e, f, i, a), p = S(e, f, i, a);
+		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, m = Math.sin(a), h = Math.abs(Math.cos(a)), g = Math.max(r * p, 1e-4), _ = Math.abs(m) / Math.max(h * g, 1e-4) * g / Math.max(l, 1e-4), b = 1 - T(s, s + c, _), x = e.amplitude * f.weight;
+			u = Math.max(u, b * x), d += m * x;
+		}
+	}
+	return {
+		ink: E(u),
+		env: d
+	};
+}
+function T(e, t, n) {
+	let r = E((n - e) / Math.max(t - e, 1e-6));
+	return r * r * (3 - 2 * r);
+}
+function E(e) {
+	return e < 0 ? 0 : e > 1 ? 1 : e;
+}
+function D(e, t = 1, n = 0) {
+	let r = [], i = Math.max(1, Math.min(2, t));
+	for (let t = 0; t < i; t++) r.push({
+		amplitude: t === 0 ? 1 : .45,
+		wavelength: e / (t + 1),
+		phase: (n + t * 1.618033) % y
+	});
+	return r;
+}
+//#endregion
+//#region src/components/custom/concentric/constants.ts
+var O = 8, k = 4, A = 4;
+function j(e) {
+	return e === "static-contour" ? 1 : e === "both" ? 2 : 0;
+}
+var M = [
+	{
+		L: .94,
+		C: .025,
+		h: 80
+	},
+	{
+		L: .82,
+		C: .075,
+		h: 62
+	},
+	{
+		L: .66,
+		C: .105,
+		h: 44
+	}
+];
+function N(e = .24, t = .04) {
+	return [D(e, 1, 0)[0], D(e * (1 + t), 1, 1.7)[0]];
+}
+var P = N(), F = [{
+	x: -.28,
+	y: -.18,
+	weight: 1,
+	rotAlpha: .35
+}, {
+	x: .3,
+	y: .22,
+	weight: .85,
+	rotAlpha: -.55
+}], I = {
+	centers: F,
+	ringComponents: P,
+	axisRatio: [1, .62],
+	speed: .5,
+	lineWidth: 1.4,
+	lineSoftness: 1,
+	renderMode: "traveling-rings",
+	contourLevels: 12,
+	beatDetune: .04,
+	palette: M,
+	background: "transparent",
+	interactive: !1,
+	respectReducedMotion: !0
+}, L = `
 const PI: f32 = 3.141592653589793;
 const TAU: f32 = 6.283185307179586;
 const RING_GRAVITY: f32 = 9.81;
@@ -16,15 +122,17 @@ const MAX_RING_STOPS: i32 = 4;
 struct ConcentricUniforms {
   // u0: (uTime, uSpeed, uAxisA, uAxisB)
   u0: vec4<f32>,
-  // ints: (uCenterCount, uRingCount, uStopCount, _pad)
+  // ints: (uCenterCount, uRingCount, uStopCount, uRenderMode)  // 0 rings · 1 contour · 2 both
   ints: vec4<i32>,
   // bg: (background.rgb (linear), hasBackground)
   bg: vec4<f32>,
   // norm: (uFieldNorm, uAspect, _pad, _pad) — field → [0,1] scale
   norm: vec4<f32>,
+  // line: (lineHalfWidth, aaSoftness, contourLevels, _pad) — stroke geometry (field units)
+  line: vec4<f32>,
   // each ring row: (amplitude, wavelength, phase, _pad)
   rings: array<vec4<f32>, 8>,
-  // each center row: (x, y, weight, _pad)
+  // each center row: (x, y, weight, rotAlpha)
   centers: array<vec4<f32>, 4>,
   // each palette stop: linear-sRGB rgb + _pad
   palette: array<vec4<f32>, 4>,
@@ -32,8 +140,8 @@ struct ConcentricUniforms {
 
 @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.
@@ -50,22 +158,45 @@ 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);
+// The ellipsoidal radial distance in the family's ROTATED frame R(−α): rotate (p − c) by
+// −α, then scale by (a,b). Transcribes ringField.ts ellipsoidalRadiusRot.
+fn ellipsoidalRadiusRot(p: vec2<f32>, center: vec2<f32>, rotAlpha: f32, axisA: f32, axisB: f32) -> f32 {
+  let ca = cos(rotAlpha);
+  let sa = sin(rotAlpha);
+  let px = p.x - center.x;
+  let py = p.y - center.y;
+  let rx = ca * px + sa * py;
+  let ry = -sa * px + ca * py;
+  let dx = rx / max(axisA, 1e-4);
+  let dy = ry / max(axisB, 1e-4);
   return sqrt(dx * dx + dy * dy);
 }
 
+// |∇r| of the rotated ellipsoidal radius — closed-form (the IQ distance-estimation
+// denominator). Transcribes ringField.ts ellipsoidalGradMag.
+fn ellipsoidalGradMag(p: vec2<f32>, center: vec2<f32>, rotAlpha: f32, axisA: f32, axisB: f32) -> f32 {
+  let ca = cos(rotAlpha);
+  let sa = sin(rotAlpha);
+  let px = p.x - center.x;
+  let py = p.y - center.y;
+  let rx = ca * px + sa * py;
+  let ry = -sa * px + ca * py;
+  let a = max(axisA, 1e-4);
+  let b = max(axisB, 1e-4);
+  let sx = rx / a;
+  let sy = ry / b;
+  let r = sqrt(sx * sx + sy * sy);
+  let gx = sx / a;
+  let gy = sy / b;
+  return sqrt(gx * gx + gy * gy) / max(r, 1e-4);
+}
+
 // The radial-Fourier ring-interference value f(p,t) — the multi-center weighted sum of
-// radial sinusoids (transcribes ringField.ts sampleRingField line-for-line).
+// CLEAN radial sinusoids (the BEAT ENVELOPE; transcribes ringField.ts sampleRingField).
 fn sampleRingField(p: vec2<f32>, t: f32) -> f32 {
   var acc = 0.0;
   let speed = u.u0.y;
@@ -76,13 +207,12 @@ fn sampleRingField(p: vec2<f32>, t: f32) -> f32 {
   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);
+    let radius = ellipsoidalRadiusRot(p, cj.xy, cj.w, 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);
@@ -92,6 +222,72 @@ fn sampleRingField(p: vec2<f32>, t: f32) -> f32 {
   return acc;
 }
 
+// The IQ gradient-normalized isoline INK + the beat ENVELOPE — the per-pixel line strength
+// (brightest-wins union over every family × ring crest) and the raw envelope (the hue
+// driver). Transcribes ringField.ts ringIsolineInk.
+struct InkEnv { ink: f32, env: f32, };
+fn ringIsolineInk(p: vec2<f32>, t: f32) -> InkEnv {
+  var ink = 0.0;
+  var env = 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;
+  let lineHalfW = u.line.x;
+  let aa = u.line.y;
+  for (var j = 0; j < MAX_CENTERS; j = j + 1) {
+    if (j >= centerCount) { break; }
+    let cj = u.centers[j];
+    let radius = ellipsoidalRadiusRot(p, cj.xy, cj.w, axisA, axisB);
+    let gradR = ellipsoidalGradMag(p, cj.xy, cj.w, axisA, axisB);
+    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);
+      let omega = sqrt(RING_GRAVITY * k) * speed;
+      let phase = k * radius - omega * t + r.z;
+      let s = sin(phase);
+      let cphase = abs(cos(phase));
+      let gradPhase = max(k * gradR, 1e-4);
+      // The IQ gradient-normalized distance-to-isoline (domain units; round-trips JS).
+      let de = abs(s) / max(cphase * gradPhase, 1e-4);
+      // Convert the domain-units distance to PIXELS via fwidth(phase) (the device
+      // per-pixel phase change) so the stroke is a constant pixel width everywhere —
+      // lineHalfW/aa are in pixels (NOT fwidthFine, Compatibility-Mode safe).
+      let dPx = max(fwidth(phase), 1e-4);
+      let dePx = de * gradPhase / dPx;
+      var lineV = 1.0 - smoothstep(lineHalfW, lineHalfW + aa, dePx);
+      // Analytic anti-aliasing: where the rings pack tighter than the pixel can resolve
+      // (fwidth(phase) ≳ π, near a center / under DPR), FADE the line out instead of
+      // flooding to a solid mass (IQ filterwidth — the aliasing-fade that keeps the field
+      // thin LINES, not a bright slab where the rings converge).
+      let aliasFade = 1.0 - smoothstep(PI * 0.6, PI * 1.2, dPx);
+      lineV = lineV * aliasFade;
+      let w = r.x * cj.z;
+      ink = max(ink, lineV * w);
+      env = env + s * w;
+    }
+  }
+  var oe: InkEnv;
+  oe.ink = clamp(ink, 0.0, 1.0);
+  oe.env = env;
+  return oe;
+}
+
+// The topographic-contour operator: the isolines of the STATIC interference envelope at N
+// evenly-spaced heights. de_contour = |fract(f·N + 0.5) − 0.5| / |fwidth(f·N)| — the IQ
+// contour-line form. fwidth is the device pixel-derivative safety clamp on the composite
+// ONLY (NOT fwidthFine — Compatibility-Mode safe on Metal/WebKit).
+fn contourInk(envValue: f32, levels: f32) -> f32 {
+  let fN = envValue * levels;
+  let band = abs(fract(fN + 0.5) - 0.5);
+  // fwidth is the device pixel-derivative safety clamp (NOT fwidthFine — Compatibility-Mode
+  // safe on Metal/WebKit).
+  let aaW = max(fwidth(fN), 1e-4);
+  return 1.0 - smoothstep(u.line.x, u.line.x + u.line.y, band / aaW);
+}
+
 // Sample the multi-stop palette (linear-sRGB stops, OKLab mix). t in [0,1].
 fn samplePaletteLin(t: f32) -> vec3<f32> {
   let stopCount = u.ints.z;
@@ -112,166 +308,119 @@ fn fs_main(in: VSOut) -> @location(0) vec4<f32> {
   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 mode = u.ints.w;  // 0 traveling-rings · 1 static-contour · 2 both
+  let levels = u.line.z;
+
+  // The isoline strokes (the LINES) + the beat envelope (the HUE).
+  let oe = ringIsolineInk(p, t);
+  var ink = oe.ink;
+  let env = oe.env;
 
-  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 static-contour mode draws elevation lines of the (static) envelope.
+  if (mode == 1) {
+    ink = contourInk(env * u.norm.x, max(levels, 1.0));
+  } else if (mode == 2) {
+    ink = max(ink, contourInk(env * u.norm.x, max(levels, 1.0)));
+  }
+  // fwidth safety clamp on the final line composite (Compatibility-Mode safe).
+  ink = clamp(ink, 0.0, 1.0);
 
+  // The beat-envelope drives the warm-family tone across the ramp (cream↔amber↔ember) so the
+  // crossing ring families read as warm-light interference; the saturated mid-amber reads on
+  // BOTH the cream page and the dark page (the warm-cream identity, NOT a themed hue).
+  let v = clamp(0.5 + env * u.norm.x, 0.0, 1.0);
   let lin = samplePaletteLin(v);
   let rgb = clamp(linearToSrgb(lin), vec3<f32>(0.0), vec3<f32>(1.0));
 
-  // 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);
+    // opaque themed ground: composite the lit line over the themed bg.
+    let bg = clamp(linearToSrgb(u.bg.rgb), vec3<f32>(0.0), vec3<f32>(1.0));
+    let outRgb = mix(bg, rgb, ink);
+    return vec4<f32>(outRgb, 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);
+  // transparent ground: the LINE carries the alpha — the page reads through the troughs.
+  let alpha = ink;
   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;
-}
-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;
-	}
-	return t;
-}
-//#endregion
-//#region src/components/custom/concentric/constants.ts
-var C = 8, w = 4, T = 4, E = [
-	{
-		L: .94,
-		C: .025,
-		h: 80
-	},
-	{
-		L: .82,
-		C: .075,
-		h: 62
-	},
-	{
-		L: .66,
-		C: .105,
-		h: 44
-	}
-], 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,
-	respectReducedMotion: !0
-}, A = 320, j = {
+`, R = 336, z = {
 	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,
+	rings: 20,
+	centers: 52,
+	palette: 68
+}, B = .55;
+function V() {
+	let e = new ArrayBuffer(R);
 	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 H(e, t, n, r, i, a) {
+	let { f32: o, i32: s } = e, [l, u] = t.axisRatio, d = a ?? t.centers;
+	o[z.u0 + 0] = n, o[z.u0 + 1] = t.speed, o[z.u0 + 2] = l, o[z.u0 + 3] = u;
+	let f = Math.min(d.length, 4), p = Math.min(t.ringComponents.length, 8), m = Math.min(i.length, 4);
+	if (s[z.ints + 0] = f, s[z.ints + 1] = p, s[z.ints + 2] = m, s[z.ints + 3] = j(t.renderMode), t.background === "transparent") o[z.bg + 0] = 0, o[z.bg + 1] = 0, o[z.bg + 2] = 0, o[z.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 = c(t.background);
+		o[z.bg + 0] = e[0], o[z.bg + 1] = e[1], o[z.bg + 2] = e[2], o[z.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);
+	o[z.norm + 0] = B, o[z.norm + 1] = r, o[z.norm + 2] = 0, o[z.norm + 3] = 0, o[z.line + 0] = t.lineWidth, o[z.line + 1] = t.lineSoftness, o[z.line + 2] = t.contourLevels, o[z.line + 3] = 0, U(o, z.rings, t.ringComponents), W(o, z.centers, d);
 	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 = z.palette + e * 4, n = c(i[Math.min(e, m - 1)] ?? i[0]);
+		o[t + 0] = n[0], o[t + 1] = n[1], o[t + 2] = n[2], o[t + 3] = 0;
 	}
 	return e;
 }
-function F(e, t, n) {
+function U(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) {
+function W(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);
+		a ? (e[i + 0] = a.x, e[i + 1] = a.y, e[i + 2] = a.weight, e[i + 3] = a.rotAlpha) : (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 G = 64, K = 8, q = 2;
+function J(e) {
+	let { canvas: t, config: n, getPalette: r, getCenters: i, shouldContinue: a, onFrame: s } = e;
+	return function(e, c, l) {
+		let u = e.createShaderModule({
 			label: "[Concentric] concentric.wgsl",
-			code: _
-		}), l = N(), u = e.createBuffer({
+			code: L
+		}), d = V(), f = e.createBuffer({
 			label: "[Concentric] uniforms",
-			size: l.buffer.byteLength,
-			usage: L | R
-		}), d = e.createBindGroupLayout({
+			size: d.buffer.byteLength,
+			usage: G | K
+		}), p = e.createBindGroupLayout({
 			label: "[Concentric] bgl",
 			entries: [{
 				binding: 0,
-				visibility: z,
+				visibility: q,
 				buffer: { type: "uniform" }
 			}]
-		}), f = e.createRenderPipeline({
+		}), m = e.createRenderPipeline({
 			label: "[Concentric] pipeline",
-			layout: e.createPipelineLayout({ bindGroupLayouts: [d] }),
+			layout: e.createPipelineLayout({ bindGroupLayouts: [p] }),
 			vertex: {
-				module: c,
+				module: u,
 				entryPoint: "vs_main"
 			},
 			fragment: {
-				module: c,
+				module: u,
 				entryPoint: "fs_main",
 				targets: [{
-					format: s,
+					format: l,
 					blend: {
 						color: {
 							srcFactor: "one",
@@ -287,22 +436,22 @@ function B(e) {
 				}]
 			},
 			primitive: { topology: "triangle-list" }
-		}), p = e.createBindGroup({
+		}), h = e.createBindGroup({
 			label: "[Concentric] bg",
-			layout: d,
+			layout: p,
 			entries: [{
 				binding: 0,
-				resource: { buffer: u }
+				resource: { buffer: f }
 			}]
 		});
-		function m() {
+		function g() {
 			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));
 			(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 _(a) {
+			s?.(a), H(d, n, a, (t.clientWidth || 320) / Math.max(t.clientHeight || 320, 1), r(), i()), e.queue.writeBuffer(f, 0, d.buffer);
+			let o = e.createCommandEncoder({ label: "[Concentric] frame" }), l = c.getCurrentTexture().createView(), u = o.beginRenderPass({ colorAttachments: [{
+				view: l,
 				clearValue: {
 					r: 0,
 					g: 0,
@@ -312,21 +461,21 @@ 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()]);
+			u.setPipeline(m), u.setBindGroup(0, h), u.draw(3, 1, 0, 0), u.end(), e.queue.submit([o.finish()]);
 		}
 		return {
-			frame: h,
-			shouldContinue: i,
-			resize: m,
+			frame: _,
+			shouldContinue: a,
+			resize: g,
 			teardown: () => {
-				u.destroy();
+				f.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 Y = "#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}", X = `#version 300 es
 precision highp float;
 
 #define PI 3.141592653589793
@@ -347,28 +496,55 @@ uniform float uAspect;
 uniform int   uCenterCount;
 uniform int   uRingCount;
 uniform int   uStopCount;
+uniform int   uRenderMode;    // 0 traveling-rings · 1 static-contour · 2 both
 uniform float uHasBackground;
+uniform vec3  uLine;          // (lineHalfWidth, aaSoftness, contourLevels) — stroke geometry
+uniform vec3  uBg;            // themed background (linear-sRGB)
 uniform vec3  uRings[MAX_RINGS];     // (amplitude, wavelength, phase)
-uniform vec3  uCenters[MAX_CENTERS]; // (x, y, weight)
+uniform vec4  uCenters[MAX_CENTERS]; // (x, y, weight, rotAlpha)
 uniform vec3  uPalette[MAX_RING_STOPS]; // linear-sRGB stops
 
-${t}
-${n}
+${r}
+${a}
 
-// ‖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);
+// rotated ellipsoidal radius — transcribes ringField.ts ellipsoidalRadiusRot.
+float ellipsoidalRadiusRot(vec2 p, vec2 center, float rotAlpha, float axisA, float axisB) {
+  float ca = cos(rotAlpha);
+  float sa = sin(rotAlpha);
+  float px = p.x - center.x;
+  float py = p.y - center.y;
+  float rx = ca * px + sa * py;
+  float ry = -sa * px + ca * py;
+  float dx = rx / max(axisA, 1e-4);
+  float dy = ry / max(axisB, 1e-4);
   return sqrt(dx * dx + dy * dy);
 }
 
+// |∇r| of the rotated ellipsoidal radius — transcribes ringField.ts ellipsoidalGradMag.
+float ellipsoidalGradMag(vec2 p, vec2 center, float rotAlpha, float axisA, float axisB) {
+  float ca = cos(rotAlpha);
+  float sa = sin(rotAlpha);
+  float px = p.x - center.x;
+  float py = p.y - center.y;
+  float rx = ca * px + sa * py;
+  float ry = -sa * px + ca * py;
+  float a = max(axisA, 1e-4);
+  float b = max(axisB, 1e-4);
+  float sx = rx / a;
+  float sy = ry / b;
+  float r = sqrt(sx * sx + sy * sy);
+  float gx = sx / a;
+  float gy = sy / b;
+  return sqrt(gx * gx + gy * gy) / max(r, 1e-4);
+}
+
 // 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);
+    vec4 cj = uCenters[j];
+    float radius = ellipsoidalRadiusRot(p, cj.xy, cj.w, uAxis.x, uAxis.y);
     float centerSum = 0.0;
     for (int i = 0; i < MAX_RINGS; i++) {
       if (i >= uRingCount) break;
@@ -383,7 +559,54 @@ float sampleRingField(vec2 p, float t) {
   return acc;
 }
 
-// Sample the multi-stop palette (linear-sRGB stops, OKLab mix). t in [0,1].
+// The IQ gradient-normalized isoline ink + the beat envelope (transcribes ringIsolineInk).
+// Returns vec2(ink, env).
+vec2 ringIsolineInk(vec2 p, float t) {
+  float ink = 0.0;
+  float env = 0.0;
+  float lineHalfW = uLine.x;
+  float aa = uLine.y;
+  for (int j = 0; j < MAX_CENTERS; j++) {
+    if (j >= uCenterCount) break;
+    vec4 cj = uCenters[j];
+    float radius = ellipsoidalRadiusRot(p, cj.xy, cj.w, uAxis.x, uAxis.y);
+    float gradR = ellipsoidalGradMag(p, cj.xy, cj.w, uAxis.x, uAxis.y);
+    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 phase = k * radius - omega * t + r.z;
+      float s = sin(phase);
+      float cphase = abs(cos(phase));
+      float gradPhase = max(k * gradR, 1e-4);
+      // The IQ gradient-normalized distance-to-isoline (domain units; round-trips JS).
+      float de = abs(s) / max(cphase * gradPhase, 1e-4);
+      // Convert to PIXELS via fwidth(phase) so the stroke is a constant pixel width.
+      float dPx = max(fwidth(phase), 1e-4);
+      float dePx = de * gradPhase / dPx;
+      float lineV = 1.0 - smoothstep(lineHalfW, lineHalfW + aa, dePx);
+      // Analytic anti-aliasing: fade lines where the rings pack tighter than a pixel can
+      // resolve (fwidth(phase) ≳ π, near a center / under DPR) so the field stays thin LINES
+      // instead of flooding to a bright slab (IQ filterwidth).
+      float aliasFade = 1.0 - smoothstep(PI * 0.6, PI * 1.2, dPx);
+      lineV *= aliasFade;
+      float w = r.x * cj.z;
+      ink = max(ink, lineV * w);
+      env += s * w;
+    }
+  }
+  return vec2(clamp(ink, 0.0, 1.0), env);
+}
+
+// The topographic-contour operator (transcribes contourInk).
+float contourInk(float envValue, float levels) {
+  float fN = envValue * levels;
+  float band = abs(fract(fN + 0.5) - 0.5);
+  float aaW = max(fwidth(fN), 1e-4);
+  return 1.0 - smoothstep(uLine.x, uLine.x + uLine.y, band / aaW);
+}
+
 vec3 samplePaletteLin(float t) {
   if (uStopCount <= 1) return uPalette[0];
   float n = float(uStopCount);
@@ -391,7 +614,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)));
@@ -402,20 +624,35 @@ vec3 samplePaletteLin(float t) {
 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);
+
+  vec2 ie = ringIsolineInk(p, uTime);
+  float ink = ie.x;
+  float env = ie.y;
+
+  if (uRenderMode == 1) {
+    ink = contourInk(env * uFieldNorm, max(uLine.z, 1.0));
+  } else if (uRenderMode == 2) {
+    ink = max(ink, contourInk(env * uFieldNorm, max(uLine.z, 1.0)));
+  }
+  ink = clamp(ink, 0.0, 1.0);
+
+  // The beat-envelope drives the warm-family tone across the ramp (cream↔amber↔ember) so the
+  // crossing families read as warm-light interference (the warm-cream identity).
+  float v = clamp(0.5 + env * 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);
+    vec3 bg = clamp(linearToSrgb(uBg), vec3(0.0), vec3(1.0));
+    fragColor = vec4(mix(bg, rgb, ink), 1.0);
     return;
   }
-  float alpha = clamp(v * 0.92 + 0.08, 0.0, 1.0);
+  float alpha = ink;
   fragColor = vec4(rgb * alpha, alpha);
 }`;
 //#endregion
 //#region src/components/custom/concentric/composables/concentricGLSetup.ts
-function U(e, t, n) {
+function Z(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 +660,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, getCenters: i, shouldContinue: a, onFrame: s } = 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 l = Z(e, e.VERTEX_SHADER, Y), u = Z(e, e.FRAGMENT_SHADER, X), d = e.createProgram();
+		if (e.attachShader(d, l), e.attachShader(d, u), e.linkProgram(d), !e.getProgramParameter(d, e.LINK_STATUS)) throw Error(`[Concentric] link failed: ${e.getProgramInfoLog(d)}`);
+		e.deleteShader(l), e.deleteShader(u);
+		let f = e.createVertexArray();
+		e.bindVertexArray(f);
+		let p = e.createBuffer();
+		e.bindBuffer(e.ARRAY_BUFFER, p), e.bufferData(e.ARRAY_BUFFER, new Float32Array([
 			-1,
 			-1,
 			3,
@@ -440,91 +677,128 @@ 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 m = e.getAttribLocation(d, "aPosition");
+		e.enableVertexAttribArray(m), e.vertexAttribPointer(m, 2, e.FLOAT, !1, 0, 0), e.bindVertexArray(null);
+		let h = (t) => e.getUniformLocation(d, t), g = h("uTime"), _ = h("uSpeed"), v = h("uAxis"), y = h("uFieldNorm"), b = h("uAspect"), x = h("uCenterCount"), S = h("uRingCount"), C = h("uStopCount"), w = h("uRenderMode"), T = h("uHasBackground"), E = h("uLine"), D = h("uBg"), O = h("uRings[0]"), k = h("uCenters[0]"), A = h("uPalette[0]");
+		function M() {
 			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);
 		}
-		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);
+		function N(a) {
+			s?.(a);
+			let o = t.clientWidth || 320, l = t.clientHeight || 320, u = o / Math.max(l, 1);
+			e.useProgram(d), e.bindVertexArray(f), 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(g, a), e.uniform1f(_, n.speed), e.uniform2f(v, n.axisRatio[0], n.axisRatio[1]), e.uniform1f(y, B), e.uniform1f(b, u);
+			let p = i(), m = Math.min(p.length, 4), h = Math.min(n.ringComponents.length, 8), M = r(), N = Math.min(M.length, 4);
+			if (e.uniform1i(x, m), e.uniform1i(S, h), e.uniform1i(C, N), e.uniform1i(w, j(n.renderMode)), e.uniform3f(E, n.lineWidth, n.lineSoftness, n.contourLevels), n.background === "transparent") e.uniform1f(T, 0), e.uniform3f(D, 0, 0, 0);
+			else {
+				e.uniform1f(T, 1);
+				let t = c(n.background);
+				e.uniform3f(D, t[0], t[1], t[2]);
+			}
+			let P = 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;
+				P[e * 3 + 0] = t?.amplitude ?? 0, P[e * 3 + 1] = t?.wavelength ?? 1, P[e * 3 + 2] = t?.phase ?? 0;
 			}
-			e.uniform3fv(C, D);
-			let O = new Float32Array(12);
+			e.uniform3fv(O, P);
+			let F = new Float32Array(16);
 			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 = p[e];
+				F[e * 4 + 0] = t?.x ?? 0, F[e * 4 + 1] = t?.y ?? 0, F[e * 4 + 2] = t?.weight ?? 0, F[e * 4 + 3] = t?.rotAlpha ?? 0;
 			}
-			e.uniform3fv(w, O);
-			let k = new Float32Array(12);
+			e.uniform4fv(k, F);
+			let I = 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];
+				let t = c(M[Math.min(e, N - 1)] ?? M[0]);
+				I[e * 3 + 0] = t[0], I[e * 3 + 1] = t[1], I[e * 3 + 2] = t[2];
 			}
-			e.uniform3fv(T, k), e.drawArrays(e.TRIANGLES, 0, 3), e.bindVertexArray(null);
+			e.uniform3fv(A, I), e.drawArrays(e.TRIANGLES, 0, 3), e.bindVertexArray(null);
 		}
 		return {
-			frame: D,
-			shouldContinue: i,
-			resize: E,
+			frame: N,
+			shouldContinue: a,
+			resize: M,
 			teardown: () => {
-				e.deleteProgram(l), e.deleteVertexArray(u), e.deleteBuffer(d);
+				e.deleteProgram(d), e.deleteVertexArray(f), e.deleteBuffer(p);
 			}
 		};
 	};
 }
 //#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 $(e, n) {
+	let { config: r, getPalette: i } = n, a = n.mode ?? "live", o = t({ respectReducedMotion: r.respectReducedMotion }), c = r.centers.slice(), l = 0, u = () => {
+		o.onPointerEnter(), r.interactive && v?.wake();
+	}, d = (e) => {
+		o.onPointerMove(e), r.interactive && v?.wake();
+	}, f = (e) => e.parentElement ?? e;
+	function p(e) {
+		let t = f(e);
+		t.addEventListener("pointermove", d), t.addEventListener("pointerenter", u), t.addEventListener("pointerleave", o.onPointerLeave);
+	}
+	function h(e) {
+		let t = f(e);
+		t.removeEventListener("pointermove", d), t.removeEventListener("pointerenter", u), t.removeEventListener("pointerleave", o.onPointerLeave);
+	}
+	function g(e) {
+		let t = l > 0 ? (e - l) * 1e3 : 16.7;
+		if (l = e, o.tick(t), c = r.centers.slice(0, 4), !r.interactive || !o.active.value || c.length >= 4) return;
+		let n = o.smoothedPosition.value, i = o.velocity.value, a = n.x * 2 - 1, s = -(n.y * 2 - 1), u = Math.atan2(i.y, i.x), d = .35 + Math.min(.65, o.burst.value);
+		c.push({
+			x: a,
+			y: s,
+			weight: d,
+			rotAlpha: u
+		});
+	}
+	let _ = () => c, v = null, y = () => {
 		let t = e.value;
-		return t ? (o || (o = r(t, {
+		return t ? (v || (p(t), v = s(t, {
 			mode: a,
-			respectReducedMotion: n.respectReducedMotion,
-			setupWGPU: B({
+			respectReducedMotion: r.respectReducedMotion,
+			setupWGPU: J({
 				canvas: t,
-				config: n,
+				config: r,
 				getPalette: i,
-				shouldContinue: () => !0
+				getCenters: _,
+				shouldContinue: () => !0,
+				onFrame: g
 			}),
-			setupGL: W({
+			setupGL: Q({
 				canvas: t,
-				config: n,
+				config: r,
 				getPalette: i,
-				shouldContinue: () => !0
+				getCenters: _,
+				shouldContinue: () => !0,
+				onFrame: g
 			})
-		}), o.armAsync()), o) : null;
+		}), v.armAsync()), v) : null;
 	};
-	queueMicrotask(() => s());
-	let c = {
+	queueMicrotask(() => y());
+	let b = {
 		get backend() {
-			return s()?.backend ?? "webgpu";
+			return y()?.backend ?? "webgpu";
 		},
-		pause: () => s()?.suspend("manual"),
-		resume: () => s()?.resume("manual"),
-		wake: () => s()?.wake(),
-		renderAt: (e) => s()?.renderAt(e),
+		pause: () => y()?.suspend("manual"),
+		resume: () => y()?.resume("manual"),
+		wake: () => y()?.wake(),
+		renderAt: (e) => y()?.renderAt(e),
 		get reducedMotion() {
-			return o?.reducedMotion ?? !1;
+			return v?.reducedMotion ?? !1;
 		},
-		dispose: () => o?.dispose()
+		dispose: () => {
+			let t = e.value;
+			t && h(t), o.dispose(), v?.dispose();
+		}
 	};
-	return p(() => c.dispose()), c;
+	return m(() => b.dispose()), b;
 }
 //#endregion
 //#region src/components/custom/concentric/Concentric.vue
-var K = /* @__PURE__ */ e(/* @__PURE__ */ d({
+var ee = /* @__PURE__ */ e(/* @__PURE__ */ f({
 	__name: "Concentric",
 	props: {
-		config: { default: () => k },
+		config: { default: () => I },
 		paused: {
 			type: Boolean,
 			default: !1
@@ -532,12 +806,12 @@ var K = /* @__PURE__ */ e(/* @__PURE__ */ d({
 	},
 	emits: ["update:paused"],
 	setup(e, { expose: t }) {
-		let n = h("canvasRef"), r = G(n, {
+		let n = g("canvasRef"), r = $(n, {
 			config: e.config,
 			getPalette: () => e.config.palette
 		});
-		g(() => e.paused, (e) => e ? r.pause() : r.resume(), { immediate: !0 });
-		let i = c(() => {
+		_(() => e.paused, (e) => e ? r.pause() : r.resume(), { immediate: !0 });
+		let i = l(() => {
 			let t = e.config.background;
 			if (t !== "transparent") return `oklch(${t.L} ${t.C} ${t.h})`;
 		});
@@ -546,10 +820,10 @@ var K = /* @__PURE__ */ e(/* @__PURE__ */ d({
 			resume: r.resume,
 			wake: r.wake,
 			renderAt: r.renderAt
-		}), (e, t) => (m(), l("div", {
+		}), (e, t) => (h(), u("div", {
 			class: "concentric-wrapper",
-			style: f(i.value ? { background: i.value } : void 0)
-		}, [u("canvas", {
+			style: p(i.value ? { background: i.value } : void 0)
+		}, [d("canvas", {
 			ref_key: "canvasRef",
 			ref: n,
 			class: "concentric-canvas",
@@ -559,4 +833,4 @@ var K = /* @__PURE__ */ e(/* @__PURE__ */ d({
 	}
 }), [["__scopeId", "data-v-f8bbc88a"]]);
 //#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 { ee as Concentric, F as DEFAULT_CENTERS, I as DEFAULT_CONCENTRIC_CONFIG, P as DEFAULT_RING_COMPONENTS, k as MAX_CENTERS, O as MAX_RINGS, A as MAX_RING_STOPS, v as RING_GRAVITY, M as WARM_IDENTITY_PALETTE, N as buildDefaultRingComponents, D as buildRingFamily, S as ellipsoidalGradMag, x as ellipsoidalRadius, b as ellipsoidalRadiusRot, j as renderModeToInt, w as ringIsolineInk, C as sampleRingField, $ as useConcentric };