@mkbabb/glass-ui 4.0.1 → 4.1.0

package/dist/fourier-field.js

@@ -1,180 +1,771 @@
-import { t as e } from "./useCanvas2D-B8w_E3Rr.js";
-import { t } from "./_plugin-vue_export-helper-C1je1s0u.js";
-import { i as n, s as r, t as i } from "./color-DweYl7pE.js";
-import { t as a } from "./useGlobalDark-C28t0VWJ.js";
-import { n as o, t as s } from "./prng-Za0Rmgag.js";
-import { a as c, i as l, n as u, r as d, t as f } from "./math-BINYmg5z.js";
-import { createElementBlock as p, createElementVNode as m, defineComponent as h, onMounted as g, openBlock as _, ref as v, useTemplateRef as y, watch as b } from "vue";
-//#region src/components/custom/fourier-field/presets.ts
-var x = {
-	hero: {
-		harmonics: 5,
-		harmonicScale: .24,
-		epicycles: !0,
-		trailLength: 260,
-		epicycleHueShift: 42,
-		durationMs: 16e3,
-		frozenSeed: "fourier-field/hero",
-		frozenT: .34,
-		peakAlpha: .92,
-		trailWidth: 3,
-		headGlowAlpha: .95,
-		headGlowBlur: 18,
-		headDotRadius: 5,
-		epicycleRatios: {
-			circle: .5,
-			arm: .72
-		},
-		epicycleWidths: {
-			circle: 2.4,
-			arm: 2
-		},
-		epicycleRainbow: !0,
-		trailFadeExp: 1.35,
-		trailFloor: .34
-	},
-	final: {
-		harmonics: 11,
-		harmonicScale: .17,
-		epicycles: !1,
-		trailLength: 360,
-		epicycleHueShift: 36,
-		durationMs: 21e3,
-		frozenSeed: "fourier-field/final",
-		frozenT: .42,
-		peakAlpha: .88,
-		trailWidth: 3.2,
-		headGlowAlpha: .92,
-		headGlowBlur: 16,
-		headDotRadius: 4.5,
-		epicycleRatios: {
-			circle: 0,
-			arm: 0
-		},
-		epicycleWidths: {
-			circle: 0,
-			arm: 0
-		},
-		epicycleRainbow: !1,
-		trailFadeExp: 1.45,
-		trailFloor: .36
-	}
+import { t as e } from "./_plugin-vue_export-helper-C1je1s0u.js";
+import { n as t } from "./useResolveTokenColor-vAylyR0x.js";
+import { t as n } from "./usePointerVelocityField-QLsy3_kv.js";
+import { n as r, o as i, r as a, s as o } from "./procedural-color.wgsl-m7Zgv35j.js";
+import { a as s, t as c } from "./useGpuSubstrate-4pTcp6mX.js";
+import { c as l, t as u } from "./color-Cs0-oxYL.js";
+import { t as d } from "./useGlobalDark-CmjB9E32.js";
+import { n as f, t as p } from "./prng-B-d9eYX8.js";
+import { a as m, i as h, n as g, r as _, t as v } from "./math-Eb0w3LqU.js";
+import { computed as y, createElementBlock as b, createElementVNode as x, defineComponent as S, normalizeClass as C, onMounted as w, onScopeDispose as T, openBlock as E, shallowRef as D, useTemplateRef as O, watch as k } from "vue";
+//#region src/components/custom/fourier-field/constants.ts
+var A = 64, j = 384, M = [{
+	L: .62,
+	C: .19,
+	h: 34
+}, {
+	L: .86,
+	C: .06,
+	h: 70
+}], N = {
+	source: "elliptic",
+	harmonics: 6,
+	showEpicycles: !0,
+	epicycleArms: 6,
+	rainbowChain: !0,
+	trailArc: .43,
+	trailWidth: 3,
+	intensity: 1,
+	harmonicScale: .24,
+	speed: 1,
+	palette: M,
+	respectReducedMotion: !0,
+	interactive: !0
+}, P = "\nconst MAX_PHASORS: i32 = 64;\nconst TAU: f32 = 6.283185307179586;\n\nstruct Phasor {\n  // (re, im, index, _pad)\n  data: vec4<f32>,\n};\n\n// ── Compute uniforms (the typed-struct source-of-truth — see uniformBridgeWGPU.ts) ──\nstruct ComputeUniforms {\n  // c0: (headT, trailArc, _pad, _pad)\n  c0: vec4<f32>,\n  // ints: (harmonicN, epicycleArmN, sampleCount, phasorCount)\n  ints: vec4<i32>,\n};\n\n@group(0) @binding(0) var<uniform> u: ComputeUniforms;\n@group(0) @binding(1) var<storage, read> phasors: array<Phasor>;\n// curveSamples[i] = (x, y, age, _pad)\n@group(0) @binding(2) var<storage, read_write> curveSamples: array<vec4<f32>>;\n// chainTips[k] = (x, y, _pad, _pad) — the running tip after stacking phasor k\n@group(0) @binding(3) var<storage, read_write> chainTips: array<vec4<f32>>;\n\n// The PARTIAL-SUM curve point at parameter t over the first n phasors — the WGSL\n// transcription of math.ts:78-95 (partialSumAt). EXACTLY:\n//   c += vec2(re·cos − im·sin, re·sin + im·cos)  with angle = TAU·index·t.\nfn partialSumAt(t: f32, n: i32) -> vec2<f32> {\n  var c = vec2<f32>(0.0, 0.0);\n  let phasorCount = u.ints.w;\n  let lim = min(n, phasorCount);\n  for (var i = 0; i < MAX_PHASORS; i = i + 1) {\n    if (i >= lim) { break; }\n    let p = phasors[i].data;\n    let re = p.x;\n    let im = p.y;\n    let index = p.z;\n    let angle = TAU * index * t;\n    let cs = cos(angle);\n    let sn = sin(angle);\n    c = c + vec2<f32>(re * cs - im * sn, re * sn + im * cs);\n  }\n  return c;\n}\n\n// The epicycle chain tip after stacking the first k phasors at head_t — the WGSL\n// transcription of math.ts:41-60 (positionsAt, read at the running tip). The running tip\n// after phasor (k−1) is exactly the partial sum over the first k terms.\nfn epicycleChainTip(t: f32, k: i32) -> vec2<f32> {\n  return partialSumAt(t, k);\n}\n\n@compute @workgroup_size(64)\nfn cs_main(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let i = i32(gid.x);\n  let headT = u.c0.x;\n  let trailArc = u.c0.y;\n  let harmonicN = u.ints.x;\n  let armN = u.ints.y;\n  let sampleCount = u.ints.z;\n\n  // ── The comet body samples ──\n  if (i < sampleCount) {\n    // age: 0 at the oldest tail (i = sampleCount−1), 1 at the head (i = 0).\n    let denom = max(f32(sampleCount - 1), 1.0);\n    let frac = f32(i) / denom;                 // 0 = head, 1 = tail\n    let age = 1.0 - frac;                       // 1 = head, 0 = tail\n    // sample back along the period from the head by trailArc.\n    var t = headT - trailArc * frac;\n    t = t - floor(t);                           // fract → [0,1)\n    let pt = partialSumAt(t, harmonicN);\n    curveSamples[i] = vec4<f32>(pt.x, pt.y, age, 0.0);\n  }\n\n  // ── The epicycle chain tips (k = 0..armN, capped to harmonicN) ──\n  // chainTips[0] is the origin; chainTips[k] is the tip after phasor (k−1).\n  let armLim = min(armN, harmonicN);\n  if (i <= armLim && i <= MAX_PHASORS) {\n    let tip = epicycleChainTip(headT, i);\n    chainTips[i] = vec4<f32>(tip.x, tip.y, 0.0, 0.0);\n  }\n}\n", F = `
+const PI: f32 = 3.141592653589793;
+const TAU: f32 = 6.283185307179586;
+const MAX_CURVE_SAMPLES: i32 = 384;
+const MAX_PHASORS: i32 = 64;
+const MAX_FOURIER_STOPS: i32 = 4;
+
+// ── Render uniforms (the typed-struct source-of-truth — see uniformBridgeWGPU.ts) ──
+struct RenderUniforms {
+  // r0: (centerX, centerY, scale, aspect)  — model→clip fit transform
+  r0: vec4<f32>,
+  // r1: (trailWidth, peakAlpha, headGlowAlpha, trailFadeExp)
+  r1: vec4<f32>,
+  // r2: (trailFloor, intensity, showEpicycles, rainbowChain)
+  r2: vec4<f32>,
+  // ints: (sampleCount, armCount, stopCount, _pad)
+  ints: vec4<i32>,
+  // palette stops: linear-sRGB rgb + _pad
+  palette: array<vec4<f32>, 4>,
 };
-//#endregion
-//#region src/components/custom/fourier-field/composables/useFourierField.ts
-function S(t, { hostRef: l, canvasRef: u }) {
-	let { variant: f, colorResolver: p, seed: m, freeze: h, intensity: _, clock: y } = t, S = Math.max(0, Math.min(2, _)), C = v(t.color), w = v("rgb(0, 0, 0)"), T = v("rgb(0, 0, 0)"), E = v([]);
-	function D(e) {
-		if (!e.includes("var(") && !e.includes("light-dark(")) return e;
-		let t = l.value;
-		if (typeof window > "u" || !t) return e;
-		let n = t.style.color;
-		t.style.color = e;
-		let r = getComputedStyle(t).color;
-		return t.style.color = n, r || e;
+
+@group(0) @binding(0) var<uniform> u: RenderUniforms;
+// curveSamples[i] = (x, y, age, _pad) in MODEL space
+@group(0) @binding(1) var<storage, read> curveSamples: array<vec4<f32>>;
+// chainTips[k] = (x, y, _pad, _pad) in MODEL space
+@group(0) @binding(2) var<storage, read> chainTips: array<vec4<f32>>;
+
+${r}
+${a}
+
+// 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;
+  if (stopCount <= 1) { return u.palette[0].rgb; }
+  let n = f32(stopCount);
+  let ft = clamp(t, 0.0, 1.0) * (n - 1.0);
+  let i0 = i32(floor(ft));
+  let i1 = min(i0 + 1, stopCount - 1);
+  let f = ft - f32(i0);
+  let labA = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i0].rgb);
+  let labB = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i1].rgb);
+  return oklabToLinearSrgb(mix(labA, labB, f));
+}
+
+// A warm-anchored chain hue sweep over the palette base — the rainbow chain register.
+// Tilts the base hue by a tight warm-ward band so the chain stays colourful but warm.
+fn chainColorLin(seg: f32, rainbow: bool) -> vec3<f32> {
+  let baseLin = u.palette[0].rgb;
+  if (!rainbow) { return baseLin; }
+  let lab = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * baseLin);
+  let lch = oklabToOklch(lab);
+  // warm-anchored: a touch cool at the root climbing warm toward the tips.
+  let hueShift = mix(-0.45, 1.15, clamp(seg, 0.0, 1.0)); // radians (~ -26°..+66°)
+  let h = lch.z + hueShift;
+  let lifted = vec3<f32>(0.66, max(lch.y, 0.14), h);
+  return oklabToLinearSrgb(oklchToOklab(lifted));
+}
+
+// Distance from point p to segment ab (model space).
+fn segDist(p: vec2<f32>, a: vec2<f32>, b: vec2<f32>) -> f32 {
+  let pa = p - a;
+  let ba = b - a;
+  let h = clamp(dot(pa, ba) / max(dot(ba, ba), 1e-8), 0.0, 1.0);
+  return length(pa - ba * h);
+}
+
+struct VSOut {
+  @builtin(position) pos: vec4<f32>,
+  @location(0) model: vec2<f32>,   // model-space coordinate of this fragment
+};
+
+@vertex
+fn vs_main(@builtin(vertex_index) vi: u32) -> VSOut {
+  // Full-screen triangle (covers the viewport with 3 verts).
+  var p = array<vec2<f32>, 3>(
+    vec2<f32>(-1.0, -3.0), vec2<f32>(-1.0, 1.0), vec2<f32>(3.0, 1.0),
+  );
+  let clip = p[vi];
+  // Inverse of the model→clip fit: clip = (model − center)·scale, aspect-corrected x.
+  // → model = center + clip·(1/scale), x un-aspect-corrected.
+  let center = u.r0.xy;
+  let scale = max(u.r0.z, 1e-6);
+  let aspect = max(u.r0.w, 1e-4);
+  let model = center + vec2<f32>(clip.x * aspect, clip.y) / scale;
+
+  var out: VSOut;
+  out.pos = vec4<f32>(clip, 0.0, 1.0);
+  out.model = model;
+  return out;
+}
+
+@fragment
+fn fs_main(in: VSOut) -> @location(0) vec4<f32> {
+  let p = in.model;
+  // AA feather: one device pixel in model units (fwidth of the model coord).
+  let aa = max(fwidth(p.x) + fwidth(p.y), 1e-5) * 0.75;
+
+  let trailWidth = u.r1.x;                // already in model units (packed CPU-side)
+  let peak = u.r1.y * u.r2.y;             // peakAlpha · intensity
+  let headGlow = u.r1.z * u.r2.y;
+  let fadeExp = u.r1.w;
+  let trailFloor = u.r2.x;
+  let sampleCount = u.ints.x;
+  let armCount = u.ints.y;
+  let showEpicycles = u.r2.z > 0.5;
+  let rainbow = u.r2.w > 0.5;
+  let halfW = trailWidth * 0.5;
+
+  var accum = vec4<f32>(0.0);              // premultiplied accumulation
+
+  // ── Epicycle scaffolding (orbit rings + arms + joint dots) UNDER the curve ──
+  if (showEpicycles && armCount >= 1) {
+    for (var k = 0; k < MAX_PHASORS; k = k + 1) {
+      if (k >= armCount) { break; }
+      let a = chainTips[k].xy;
+      let b = chainTips[k + 1].xy;
+      let seg = f32(k) / max(f32(armCount - 1), 1.0);
+      let lin = chainColorLin(seg, rainbow);
+      // orbit RING around a (radius = arm length).
+      let radius = length(b - a);
+      let dRing = abs(length(p - a) - radius);
+      let ringW = max(halfW * 0.45, aa);
+      let ringMask = (1.0 - smoothstep(ringW, ringW + aa, dRing)) * 0.5;
+      // ARM segment a→b.
+      let dArm = segDist(p, a, b);
+      let armMask = 1.0 - smoothstep(halfW * 0.55, halfW * 0.55 + aa, dArm);
+      // joint DOT at a.
+      let dotR = max(halfW * 0.7, aa * 2.0);
+      let dDot = length(p - a);
+      let dotMask = 1.0 - smoothstep(dotR, dotR + aa, dDot);
+      let m = clamp(max(max(ringMask, armMask), dotMask), 0.0, 1.0) * peak * 0.7;
+      let rgb = clamp(linearToSrgb(lin), vec3<f32>(0.0), vec3<f32>(1.0));
+      // over-composite (premultiplied).
+      accum = vec4<f32>(rgb * m, m) + accum * (1.0 - m);
+    }
+  }
+
+  // ── The comet TRAIL — min-distance to the curve polyline, per-segment age fade ──
+  for (var i = 0; i < MAX_CURVE_SAMPLES; i = i + 1) {
+    if (i >= sampleCount - 1) { break; }
+    let sa = curveSamples[i];
+    let sb = curveSamples[i + 1];
+    let d = segDist(p, sa.xy, sb.xy);
+    let cover = 1.0 - smoothstep(halfW, halfW + aa, d);
+    if (cover < 0.002) { continue; }
+    let age = max(sa.z, sb.z);            // 1 at head, 0 at tail
+    var a = peak * pow(age, fadeExp);
+    a = max(a, peak * trailFloor);
+    a = a * cover;
+    let lin = samplePaletteLin(1.0 - age * 0.4); // warm core, lighter tail
+    let rgb = clamp(linearToSrgb(lin), vec3<f32>(0.0), vec3<f32>(1.0));
+    accum = vec4<f32>(rgb * a, a) + accum * (1.0 - a);
+  }
+
+  // ── The comet HEAD — halo + saturated core + white specular at curveSamples[0] ──
+  if (sampleCount >= 1) {
+    let head = curveSamples[0].xy;
+    let dHead = length(p - head);
+    let coreR = halfW * 1.5;
+    let haloR = coreR * 3.0;
+    let headLin = samplePaletteLin(0.0);
+    let headRgb = clamp(linearToSrgb(headLin), vec3<f32>(0.0), vec3<f32>(1.0));
+    // soft halo
+    let halo = (1.0 - smoothstep(0.0, haloR, dHead)) * headGlow * 0.35;
+    accum = vec4<f32>(headRgb * halo, halo) + accum * (1.0 - halo);
+    // saturated core
+    let core = (1.0 - smoothstep(coreR, coreR + aa, dHead)) * headGlow;
+    accum = vec4<f32>(headRgb * core, core) + accum * (1.0 - core);
+    // white specular
+    let spec = (1.0 - smoothstep(coreR * 0.4, coreR * 0.4 + aa, dHead)) * headGlow * 0.9;
+    accum = vec4<f32>(vec3<f32>(1.0) * spec, spec) + accum * (1.0 - spec);
+  }
+
+  return accum;
+}
+`, I = {
+	c0: 0,
+	ints: 4
+};
+function L() {
+	let e = /* @__PURE__ */ new ArrayBuffer(32);
+	return {
+		buffer: e,
+		f32: new Float32Array(e),
+		i32: new Int32Array(e)
+	};
+}
+function R(e, t, n, r, i, a, o) {
+	let { f32: s, i32: c } = e;
+	return s[I.c0 + 0] = t, s[I.c0 + 1] = n, s[I.c0 + 2] = 0, s[I.c0 + 3] = 0, c[I.ints + 0] = r, c[I.ints + 1] = i, c[I.ints + 2] = a, c[I.ints + 3] = o, e;
+}
+var z = 128, B = {
+	r0: 0,
+	r1: 4,
+	r2: 8,
+	ints: 12,
+	palette: 16
+};
+function V() {
+	let e = new ArrayBuffer(z);
+	return {
+		buffer: e,
+		f32: new Float32Array(e),
+		i32: new Int32Array(e)
+	};
+}
+function H(e) {
+	let t = Infinity, n = Infinity, r = -Infinity, i = -Infinity, a = e;
+	for (let e = 0; e < 720; e++) {
+		let o = m(a, e / 720), [s, c] = o[o.length - 1];
+		s < t && (t = s), c < n && (n = c), s > r && (r = s), c > i && (i = c);
 	}
-	let O = x[f], k = 0;
-	function A() {
-		C.value = D(t.color);
-		let [e, a, o] = p(C.value).map((e) => Math.round(e * 255));
-		w.value = `rgb(${e}, ${a}, ${o})`;
-		let s = i(C.value), [c, l, u] = r({
-			L: s.L,
-			C: s.C,
-			h: n(s.h, "analogous", O.epicycleHueShift, 1)
-		}).map((e) => Math.round(e * 255));
-		if (T.value = `rgb(${c}, ${l}, ${u})`, O.epicycleRainbow && k > 0) {
-			let e = [];
-			for (let t = 0; t < k; t++) {
-				let n = k > 1 ? t / (k - 1) : 0, [i, a, o] = r({
-					L: .62,
-					C: .17,
-					h: s.h + -30 + n * 100
-				}).map((e) => Math.round(e * 255));
-				e.push(`rgb(${i}, ${a}, ${o})`);
-			}
-			E.value = e;
-		} else E.value = [];
+	if (!isFinite(t)) return {
+		centerX: 0,
+		centerY: 0,
+		scale: 1
+	};
+	let o = Math.max(.001, r - t), s = Math.max(.001, i - n), c = 2 * .82 / Math.max(o, s);
+	return {
+		centerX: (t + r) / 2,
+		centerY: (n + i) / 2,
+		scale: c
+	};
+}
+function U(e, t, n) {
+	let r = Math.max(n, 1) / 2;
+	return e / Math.max(t, 1e-6) / r;
+}
+function W(e, t, n, r, i, a, o, s, c, u, d, f, p, m) {
+	let { f32: h, i32: g } = e;
+	h[B.r0 + 0] = t.centerX, h[B.r0 + 1] = t.centerY, h[B.r0 + 2] = t.scale, h[B.r0 + 3] = n, h[B.r1 + 0] = r, h[B.r1 + 1] = i, h[B.r1 + 2] = a, h[B.r1 + 3] = o, h[B.r2 + 0] = s, h[B.r2 + 1] = c, h[B.r2 + 2] = +!!u, h[B.r2 + 3] = +!!d;
+	let _ = Math.min(m.length, 4);
+	g[B.ints + 0] = f, g[B.ints + 1] = p, g[B.ints + 2] = _, g[B.ints + 3] = 0;
+	for (let e = 0; e < 4; e++) {
+		let t = B.palette + e * 4, n = l(m[Math.min(e, _ - 1)] ?? m[0]);
+		h[t + 0] = n[0], h[t + 1] = n[1], h[t + 2] = n[2], h[t + 3] = 0;
 	}
-	function j(e) {
-		return d(o(s((h ? e.frozenSeed : `${Math.random()}`) + m)), {
-			harmonics: e.harmonics,
-			harmonicScale: e.harmonicScale
-		});
+	return e;
+}
+function ee(e) {
+	let t = Math.min(e.length, 64), n = new Float32Array(256);
+	for (let r = 0; r < t; r++) {
+		let t = e[r], i = r * 4;
+		n[i + 0] = t.coefficient[0], n[i + 1] = t.coefficient[1], n[i + 2] = t.index, n[i + 3] = 0;
 	}
-	let { isDark: M } = a();
-	g(() => {
-		let n = u.value;
-		if (!n) return;
-		let r = x[f], i = j(r), a = [...i].sort((e, t) => t.amplitude - e.amplitude);
-		k = a.length, A();
-		let o = Infinity, s = Infinity, d = -Infinity, p = -Infinity;
-		for (let e = 0; e < 720; e++) {
-			let t = c(i, e / 720), [n, r] = t[t.length - 1];
-			n < o && (o = n), r < s && (s = r), n > d && (d = n), r > p && (p = r);
-		}
-		let m = Math.max(.001, d - o), g = Math.max(.001, p - s), _ = (o + d) / 2, v = (s + p) / 2, C = [], D = e({
-			canvas: u,
-			setup: () => ({ render(e, t) {
-				let o = n.clientWidth || n.offsetWidth || 0, s = n.clientHeight || n.offsetHeight || 0;
-				if (!o || !s) return;
-				let l = .82, u = Math.min(o / m * l, s / g * l), d = o / 2, f = s / 2, p = (e, t) => [d + (e - _) * u, f + (t - v) * u], b = h || D.reducedMotion ? r.frozenT : y ? y() : t / r.durationMs % 1, x = w.value, O = T.value, k = E.value, A = M.value, j = r.peakAlpha * S, N = r.headGlowAlpha * S;
-				if (e.clearRect(0, 0, o, s), r.epicycleRatios.arm > 0) {
-					let t = c(a, b);
-					e.lineCap = "round", e.lineJoin = "round";
-					let n = Math.min(1, j * r.epicycleRatios.circle), i = Math.min(1, j * r.epicycleRatios.arm);
-					for (let a = 1; a < t.length; a++) {
-						let [o, s] = p(t[a - 1][0], t[a - 1][1]), [c, l] = p(t[a][0], t[a][1]), u = Math.hypot(c - o, l - s), d = k.length > 0 ? k[Math.min(a - 1, k.length - 1)] : O;
-						e.strokeStyle = d, e.lineWidth = r.epicycleWidths.circle, e.globalAlpha = n, e.beginPath(), e.arc(o, s, u, 0, Math.PI * 2), e.stroke(), e.lineWidth = r.epicycleWidths.arm, e.globalAlpha = i, e.beginPath(), e.moveTo(o, s), e.lineTo(c, l), e.stroke(), e.fillStyle = d, e.globalAlpha = Math.min(1, i * .9), e.beginPath(), e.arc(o, s, Math.max(2, r.epicycleWidths.arm * .9), 0, Math.PI * 2), e.fill();
-					}
-					e.globalAlpha = 1;
+	return n;
+}
+//#endregion
+//#region src/components/custom/fourier-field/composables/fourierFieldWGPUSetup.ts
+var G = 64, K = 128, q = 8, te = 1, J = 2, Y = 4, ne = 64, re = .92, ie = .95, ae = 1.35, oe = .34;
+function se(e) {
+	let { canvas: t, config: n, getSpectrum: r, getPalette: i, getHeadT: a, shouldContinue: o, onFrame: c } = e;
+	return function(e, l, u) {
+		let d = e.createShaderModule({
+			label: "[FourierField] fourier-field.compute.wgsl",
+			code: P
+		}), f = e.createShaderModule({
+			label: "[FourierField] fourier-field.render.wgsl",
+			code: F
+		}), p = e.createBuffer({
+			label: "[FourierField] phasors",
+			size: 1024,
+			usage: K | q
+		}), m = e.createBuffer({
+			label: "[FourierField] curve-samples",
+			size: 384 * 16,
+			usage: K
+		}), h = e.createBuffer({
+			label: "[FourierField] chain-tips",
+			size: 1040,
+			usage: K
+		}), g = e.createBuffer({
+			label: "[FourierField] compute-uniforms",
+			size: L().buffer.byteLength,
+			usage: G | q
+		}), _ = e.createBuffer({
+			label: "[FourierField] render-uniforms",
+			size: V().buffer.byteLength,
+			usage: G | q
+		}), v = e.createBindGroupLayout({
+			label: "[FourierField] compute-bgl",
+			entries: [
+				{
+					binding: 0,
+					visibility: Y,
+					buffer: { type: "uniform" }
+				},
+				{
+					binding: 1,
+					visibility: Y,
+					buffer: { type: "read-only-storage" }
+				},
+				{
+					binding: 2,
+					visibility: Y,
+					buffer: { type: "storage" }
+				},
+				{
+					binding: 3,
+					visibility: Y,
+					buffer: { type: "storage" }
 				}
-				let P = r.trailLength / 600, F = r.trailLength;
-				C.length = 0;
-				for (let e = F; e >= 0; e--) {
-					let t = c(i, (b - e / F * P + 1) % 1);
-					C.push(p(t[t.length - 1][0], t[t.length - 1][1]));
+			]
+		}), y = e.createComputePipeline({
+			label: "[FourierField] compute-pipeline",
+			layout: e.createPipelineLayout({ bindGroupLayouts: [v] }),
+			compute: {
+				module: d,
+				entryPoint: "cs_main"
+			}
+		}), b = e.createBindGroup({
+			label: "[FourierField] compute-bg",
+			layout: v,
+			entries: [
+				{
+					binding: 0,
+					resource: { buffer: g }
+				},
+				{
+					binding: 1,
+					resource: { buffer: p }
+				},
+				{
+					binding: 2,
+					resource: { buffer: m }
+				},
+				{
+					binding: 3,
+					resource: { buffer: h }
 				}
-				e.globalCompositeOperation = "source-over", e.strokeStyle = x, e.lineCap = "round", e.lineJoin = "round", e.lineWidth = r.trailWidth;
-				for (let t = 1; t < C.length; t++) {
-					let n = j * (t / (C.length - 1)) ** r.trailFadeExp;
-					n = Math.max(n, j * r.trailFloor), e.globalAlpha = Math.min(1, n), e.beginPath(), e.moveTo(C[t - 1][0], C[t - 1][1]), e.lineTo(C[t][0], C[t][1]), e.stroke();
+			]
+		}), x = e.createBindGroupLayout({
+			label: "[FourierField] render-bgl",
+			entries: [
+				{
+					binding: 0,
+					visibility: te | J,
+					buffer: { type: "uniform" }
+				},
+				{
+					binding: 1,
+					visibility: J,
+					buffer: { type: "read-only-storage" }
+				},
+				{
+					binding: 2,
+					visibility: J,
+					buffer: { type: "read-only-storage" }
 				}
-				if (e.globalCompositeOperation = M.value ? "lighter" : "source-over", A && C.length >= 4) {
-					e.strokeStyle = x, e.lineWidth = r.trailWidth;
-					let t = Math.max(1, Math.floor(C.length * .66));
-					for (let n = t; n < C.length; n++) {
-						let r = (n - t) / Math.max(1, C.length - 1 - t);
-						e.globalAlpha = Math.min(1, .18 * r * S), e.beginPath(), e.moveTo(C[n - 1][0], C[n - 1][1]), e.lineTo(C[n][0], C[n][1]), e.stroke();
+			]
+		}), S = e.createRenderPipeline({
+			label: "[FourierField] render-pipeline",
+			layout: e.createPipelineLayout({ bindGroupLayouts: [x] }),
+			vertex: {
+				module: f,
+				entryPoint: "vs_main"
+			},
+			fragment: {
+				module: f,
+				entryPoint: "fs_main",
+				targets: [{
+					format: u,
+					blend: {
+						color: {
+							srcFactor: "one",
+							dstFactor: "one-minus-src-alpha",
+							operation: "add"
+						},
+						alpha: {
+							srcFactor: "one",
+							dstFactor: "one-minus-src-alpha",
+							operation: "add"
+						}
 					}
+				}]
+			},
+			primitive: { topology: "triangle-list" }
+		}), C = e.createBindGroup({
+			label: "[FourierField] render-bg",
+			layout: x,
+			entries: [
+				{
+					binding: 0,
+					resource: { buffer: _ }
+				},
+				{
+					binding: 1,
+					resource: { buffer: m }
+				},
+				{
+					binding: 2,
+					resource: { buffer: h }
 				}
-				if (C.length >= 2) {
-					e.save(), e.globalCompositeOperation = "source-over", e.shadowColor = x, e.shadowBlur = r.headGlowBlur, e.globalAlpha = Math.min(1, N), e.strokeStyle = x, e.lineWidth = r.trailWidth + .6;
-					let t = C.slice(-6);
-					e.beginPath(), e.moveTo(t[0][0], t[0][1]);
-					for (let n = 1; n < t.length; n++) e.lineTo(t[n][0], t[n][1]);
-					e.stroke(), e.restore();
-				}
-				if (r.headDotRadius > 0 && C.length >= 1) {
-					let [t, n] = C[C.length - 1];
-					e.globalCompositeOperation = "source-over", e.globalAlpha = Math.min(1, N * .4), e.fillStyle = x, e.beginPath(), e.arc(t, n, r.headDotRadius * 2.6, 0, Math.PI * 2), e.fill(), e.globalAlpha = Math.min(1, N), e.beginPath(), e.arc(t, n, r.headDotRadius, 0, Math.PI * 2), e.fill(), e.globalAlpha = Math.min(1, N * .95), e.fillStyle = "rgb(255, 255, 255)", e.beginPath(), e.arc(t, n, Math.max(1.2, r.headDotRadius * .38), 0, Math.PI * 2), e.fill();
-				}
-				e.shadowBlur = 0, e.globalCompositeOperation = "source-over", e.globalAlpha = 1;
-			} })
-		});
-		b(l, A, { immediate: !0 }), b(() => t.color, () => {
-			A(), D.wake();
-		}), b(M, () => {
-			A(), D.wake();
-		});
-	});
+			]
+		}), w = L(), T = V(), E = null, D = {
+			centerX: 0,
+			centerY: 0,
+			scale: 1
+		}, O = 0;
+		function k() {
+			let t = r();
+			t !== E && (E = t, O = Math.min(t.length, 64), D = H(t), e.queue.writeBuffer(p, 0, ee(t)));
+		}
+		function A() {
+			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 j(r) {
+			c?.(r), k();
+			let o = a(), s = Math.max(1, Math.min(Math.round(n.harmonics), O)), u = n.showEpicycles ? Math.max(1, Math.min(Math.round(n.epicycleArms), s)) : 0;
+			R(w, o, n.trailArc, s, u, 384, O), e.queue.writeBuffer(g, 0, w.buffer);
+			let d = Math.min(t.clientWidth || 320, t.clientHeight || 320), f = (t.clientWidth || 320) / Math.max(t.clientHeight || 320, 1), p = U(n.trailWidth, D.scale, d);
+			W(T, D, f, p, re, ie, ae, oe, n.intensity, n.showEpicycles, n.rainbowChain, 384, u, i()), e.queue.writeBuffer(_, 0, T.buffer);
+			let m = e.createCommandEncoder({ label: "[FourierField] frame" }), h = m.beginComputePass();
+			h.setPipeline(y), h.setBindGroup(0, b), h.dispatchWorkgroups(Math.ceil(384 / ne)), h.end();
+			let v = l.getCurrentTexture().createView(), x = m.beginRenderPass({ colorAttachments: [{
+				view: v,
+				clearValue: {
+					r: 0,
+					g: 0,
+					b: 0,
+					a: 0
+				},
+				loadOp: "clear",
+				storeOp: "store"
+			}] });
+			x.setPipeline(S), x.setBindGroup(0, C), x.draw(3, 1, 0, 0), x.end(), e.queue.submit([m.finish()]);
+		}
+		return {
+			frame: j,
+			shouldContinue: o,
+			resize: A,
+			teardown: () => {
+				p.destroy(), m.destroy(), h.destroy(), g.destroy(), _.destroy();
+			}
+		};
+	};
+}
+//#endregion
+//#region src/components/custom/fourier-field/shaders/fourier-field.glsl.ts
+var ce = "#version 300 es\nin vec2 aPosition;\nout vec2 vClip;\nvoid main() {\n  vClip = aPosition;\n  gl_Position = vec4(aPosition, 0.0, 1.0);\n}\n", le = `#version 300 es
+precision highp float;
+
+#define MAX_CURVE_SAMPLES 256
+#define MAX_PHASORS 64
+
+in vec2 vClip;
+out vec4 fragColor;
+
+uniform vec4 uFit;          // (centerX, centerY, scale, aspect)
+uniform vec4 uTrail;        // (trailWidth, peakAlpha, headGlowAlpha, trailFadeExp)
+uniform vec4 uEnv;          // (trailFloor, intensity, showEpicycles, rainbowChain)
+uniform int  uSampleCount;
+uniform int  uArmCount;
+uniform int  uStopCount;
+uniform vec3 uPalette[4];   // linear-sRGB stops
+// curveSamples[i] = (x, y, age) in MODEL space; chainTips[k] = (x, y) in MODEL space.
+uniform vec3 uCurve[MAX_CURVE_SAMPLES];
+uniform vec2 uChain[MAX_PHASORS];
+
+const float PI = 3.141592653589793;
+
+${i}
+${o}
+
+// Negative-safe cube root (the WGSL chunk's cbrt3 twin; the GLSL chunk inlines it).
+vec3 cbrt3(vec3 v) { return sign(v) * pow(abs(v), vec3(1.0 / 3.0)); }
+
+vec3 samplePaletteLin(float t) {
+  if (uStopCount <= 1) return uPalette[0];
+  float n = float(uStopCount);
+  float ft = clamp(t, 0.0, 1.0) * (n - 1.0);
+  int i0 = int(floor(ft));
+  int i1 = min(i0 + 1, uStopCount - 1);
+  float f = ft - float(i0);
+  vec3 labA = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * uPalette[i0]);
+  vec3 labB = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * uPalette[i1]);
+  return oklabToLinearSrgb(mix(labA, labB, f));
+}
+
+vec3 chainColorLin(float seg, bool rainbow) {
+  vec3 baseLin = uPalette[0];
+  if (!rainbow) return baseLin;
+  vec3 lab = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * baseLin);
+  vec3 lch = oklabToOklch(lab);
+  float hueShift = mix(-0.45, 1.15, clamp(seg, 0.0, 1.0));
+  vec3 lifted = vec3(0.66, max(lch.y, 0.14), lch.z + hueShift);
+  return oklabToLinearSrgb(oklchToOklab(lifted));
+}
+
+float segDist(vec2 p, vec2 a, vec2 b) {
+  vec2 pa = p - a;
+  vec2 ba = b - a;
+  float h = clamp(dot(pa, ba) / max(dot(ba, ba), 1e-8), 0.0, 1.0);
+  return length(pa - ba * h);
+}
+
+void main() {
+  vec2 center = uFit.xy;
+  float scale = max(uFit.z, 1e-6);
+  float aspect = max(uFit.w, 1e-4);
+  // clip → model (the inverse of model→clip fit).
+  vec2 p = center + vec2(vClip.x * aspect, vClip.y) / scale;
+
+  float aa = max(fwidth(p.x) + fwidth(p.y), 1e-5) * 0.75;
+  float trailWidth = uTrail.x;            // already in model units (packed CPU-side)
+  float peak = uTrail.y * uEnv.y;
+  float headGlow = uTrail.z * uEnv.y;
+  float fadeExp = uTrail.w;
+  float trailFloor = uEnv.x;
+  bool showEpicycles = uEnv.z > 0.5;
+  bool rainbow = uEnv.w > 0.5;
+  float halfW = trailWidth * 0.5;
+
+  vec4 accum = vec4(0.0);
+
+  if (showEpicycles && uArmCount >= 1) {
+    for (int k = 0; k < MAX_PHASORS; k++) {
+      if (k >= uArmCount) break;
+      vec2 a = uChain[k];
+      vec2 b = uChain[k + 1];
+      float seg = float(k) / max(float(uArmCount - 1), 1.0);
+      vec3 lin = chainColorLin(seg, rainbow);
+      float radius = length(b - a);
+      float dRing = abs(length(p - a) - radius);
+      float ringW = max(halfW * 0.45, aa);
+      float ringMask = (1.0 - smoothstep(ringW, ringW + aa, dRing)) * 0.5;
+      float dArm = segDist(p, a, b);
+      float armMask = 1.0 - smoothstep(halfW * 0.55, halfW * 0.55 + aa, dArm);
+      float dotR = max(halfW * 0.7, aa * 2.0);
+      float dDot = length(p - a);
+      float dotMask = 1.0 - smoothstep(dotR, dotR + aa, dDot);
+      float m = clamp(max(max(ringMask, armMask), dotMask), 0.0, 1.0) * peak * 0.7;
+      vec3 rgb = clamp(linearToSrgb(lin), vec3(0.0), vec3(1.0));
+      accum = vec4(rgb * m, m) + accum * (1.0 - m);
+    }
+  }
+
+  for (int i = 0; i < MAX_CURVE_SAMPLES; i++) {
+    if (i >= uSampleCount - 1) break;
+    vec3 sa = uCurve[i];
+    vec3 sb = uCurve[i + 1];
+    float d = segDist(p, sa.xy, sb.xy);
+    float cover = 1.0 - smoothstep(halfW, halfW + aa, d);
+    if (cover < 0.002) continue;
+    float age = max(sa.z, sb.z);
+    float a = peak * pow(age, fadeExp);
+    a = max(a, peak * trailFloor) * cover;
+    vec3 lin = samplePaletteLin(1.0 - age * 0.4);
+    vec3 rgb = clamp(linearToSrgb(lin), vec3(0.0), vec3(1.0));
+    accum = vec4(rgb * a, a) + accum * (1.0 - a);
+  }
+
+  if (uSampleCount >= 1) {
+    vec2 head = uCurve[0].xy;
+    float dHead = length(p - head);
+    float coreR = halfW * 1.5;
+    float haloR = coreR * 3.0;
+    vec3 headRgb = clamp(linearToSrgb(samplePaletteLin(0.0)), vec3(0.0), vec3(1.0));
+    float halo = (1.0 - smoothstep(0.0, haloR, dHead)) * headGlow * 0.35;
+    accum = vec4(headRgb * halo, halo) + accum * (1.0 - halo);
+    float core = (1.0 - smoothstep(coreR, coreR + aa, dHead)) * headGlow;
+    accum = vec4(headRgb * core, core) + accum * (1.0 - core);
+    float spec = (1.0 - smoothstep(coreR * 0.4, coreR * 0.4 + aa, dHead)) * headGlow * 0.9;
+    accum = vec4(vec3(1.0) * spec, spec) + accum * (1.0 - spec);
+  }
+
+  fragColor = accum;
+}
+`, X = 256, Z = 64, ue = .92, de = .95, fe = 1.35, pe = .34;
+function Q(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);
+		throw e.deleteShader(r), Error(`[FourierField] shader compile failed: ${t}`);
+	}
+	return r;
+}
+function me(e) {
+	let { canvas: t, config: n, getSpectrum: r, getPalette: i, getHeadT: a, shouldContinue: o, onFrame: c } = e;
+	return function(e) {
+		let u = Q(e, e.VERTEX_SHADER, ce), d = Q(e, e.FRAGMENT_SHADER, le), f = e.createProgram();
+		if (e.attachShader(f, u), e.attachShader(f, d), e.linkProgram(f), !e.getProgramParameter(f, e.LINK_STATUS)) throw Error(`[FourierField] link failed: ${e.getProgramInfoLog(f)}`);
+		e.deleteShader(u), e.deleteShader(d);
+		let p = e.createVertexArray();
+		e.bindVertexArray(p);
+		let m = e.createBuffer();
+		e.bindBuffer(e.ARRAY_BUFFER, m), e.bufferData(e.ARRAY_BUFFER, new Float32Array([
+			-1,
+			-1,
+			3,
+			-1,
+			-1,
+			3
+		]), e.STATIC_DRAW);
+		let g = e.getAttribLocation(f, "aPosition");
+		e.enableVertexAttribArray(g), e.vertexAttribPointer(g, 2, e.FLOAT, !1, 0, 0), e.bindVertexArray(null);
+		let _ = (t) => e.getUniformLocation(f, t), v = _("uFit"), y = _("uTrail"), b = _("uEnv"), x = _("uSampleCount"), S = _("uArmCount"), C = _("uStopCount"), w = _("uPalette[0]"), T = _("uCurve[0]"), E = _("uChain[0]"), D = new Float32Array(X * 3), O = new Float32Array((Z + 1) * 2), k = new Float32Array(12), A = null, j = {
+			centerX: 0,
+			centerY: 0,
+			scale: 1
+		}, M = 0;
+		function N() {
+			let e = r();
+			e !== A && (A = e, M = Math.min(e.length, Z), j = H(e));
+		}
+		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 F(r) {
+			c?.(r), N();
+			let o = A;
+			if (!o) return;
+			let s = a(), u = Math.max(1, Math.min(Math.round(n.harmonics), M)), d = n.showEpicycles ? Math.max(1, Math.min(Math.round(n.epicycleArms), u)) : 0, m = X, g = Math.max(m - 1, 1);
+			for (let e = 0; e < m; e++) {
+				let t = e / g, r = 1 - t, i = s - n.trailArc * t;
+				i -= Math.floor(i);
+				let [a, c] = h(o, i, u), l = e * 3;
+				D[l + 0] = a, D[l + 1] = c, D[l + 2] = r;
+			}
+			let _ = Math.min(d, u);
+			for (let e = 0; e <= Z; e++) {
+				let t = e * 2;
+				if (e <= _) {
+					let [n, r] = h(o, s, e);
+					O[t + 0] = n, O[t + 1] = r;
+				} else O[t + 0] = 0, O[t + 1] = 0;
+			}
+			let P = t.clientWidth || 320, F = t.clientHeight || 320, I = Math.min(P, F), L = P / Math.max(F, 1), R = U(n.trailWidth, j.scale, I), z = i(), B = Math.min(z.length, 4);
+			for (let e = 0; e < 4; e++) {
+				let t = l(z[Math.min(e, B - 1)] ?? z[0]);
+				k[e * 3 + 0] = t[0], k[e * 3 + 1] = t[1], k[e * 3 + 2] = t[2];
+			}
+			e.useProgram(f), e.bindVertexArray(p), 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.uniform4f(v, j.centerX, j.centerY, j.scale, L), e.uniform4f(y, R, ue, de, fe), e.uniform4f(b, pe, n.intensity, +!!n.showEpicycles, +!!n.rainbowChain), e.uniform1i(x, m), e.uniform1i(S, d), e.uniform1i(C, B), e.uniform3fv(w, k), e.uniform3fv(T, D), e.uniform2fv(E, O), e.drawArrays(e.TRIANGLES, 0, 3);
+		}
+		return {
+			frame: F,
+			shouldContinue: o,
+			resize: P,
+			teardown: () => {
+				e.deleteProgram(f), e.deleteBuffer(m), e.deleteVertexArray(p);
+			}
+		};
+	};
+}
+//#endregion
+//#region src/components/custom/fourier-field/composables/useFourierField.ts
+function $(e, t) {
+	let { config: r, getSpectrum: i, getPalette: a } = t, o = t.mode ?? "live", s = t.frozenT ?? .34, l = t.periodS ?? 16, u = 0, d = -1, f = 0, p = n({ respectReducedMotion: r.respectReducedMotion }), m = () => (t.freeze?.() ?? !1) || (S?.reducedMotion ?? !1);
+	function h(e) {
+		let t = d >= 0 ? (e - d) * 1e3 : 16.7;
+		if (d = e, p.tick(t), m()) {
+			u = s, f = 0;
+			return;
+		}
+		let n = Math.min(Math.max(t / 1e3, 0), .05);
+		if (r.interactive && p.active.value) {
+			u = p.smoothedPosition.value.x % 1, u < 0 && (u += 1), f = p.burst.value * 4;
+			return;
+		}
+		let i = r.speed / l + f;
+		u = (u + i * n) % 1, u < 0 && (u += 1), f *= .92 ** (n * 60), Math.abs(f) < 1e-4 && (f = 0);
+	}
+	let g = () => u, _ = (e) => {
+		p.onPointerMove(e), r.interactive && S?.wake();
+	}, v = () => {
+		p.onPointerEnter(), r.interactive && S?.wake();
+	}, y = (e) => e.parentElement ?? e;
+	function b(e) {
+		let t = y(e);
+		t.addEventListener("pointermove", _), t.addEventListener("pointerenter", v), t.addEventListener("pointerleave", p.onPointerLeave);
+	}
+	function x(e) {
+		let t = y(e);
+		t.removeEventListener("pointermove", _), t.removeEventListener("pointerenter", v), t.removeEventListener("pointerleave", p.onPointerLeave);
+	}
+	let S = null, C = () => {
+		let t = e.value;
+		return t ? (S || (b(t), S = c(t, {
+			mode: o,
+			respectReducedMotion: r.respectReducedMotion,
+			setupWGPU: se({
+				canvas: t,
+				config: r,
+				getSpectrum: i,
+				getPalette: a,
+				getHeadT: g,
+				shouldContinue: () => !0,
+				onFrame: h
+			}),
+			setupGL: me({
+				canvas: t,
+				config: r,
+				getSpectrum: i,
+				getPalette: a,
+				getHeadT: g,
+				shouldContinue: () => !0,
+				onFrame: h
+			})
+		}), S.armAsync()), S) : null;
+	};
+	queueMicrotask(() => C());
+	let w = {
+		get backend() {
+			return C()?.backend ?? "webgpu";
+		},
+		pause: () => C()?.suspend("manual"),
+		resume: () => C()?.resume("manual"),
+		wake: () => C()?.wake(),
+		renderAt: (e) => C()?.renderAt(e),
+		get reducedMotion() {
+			return S?.reducedMotion ?? !1;
+		},
+		get headT() {
+			return u;
+		},
+		setHeadT: (e) => {
+			u = (e % 1 + 1) % 1, C()?.wake();
+		},
+		dispose: () => {
+			let t = e.value;
+			t && x(t), p.dispose(), S?.dispose();
+		}
+	};
+	return T(() => w.dispose()), w;
 }
 //#endregion
 //#region src/components/custom/fourier-field/FourierField.vue
-var C = /* @__PURE__ */ t(/* @__PURE__ */ h({
+var he = /* @__PURE__ */ e(/* @__PURE__ */ S({
 	__name: "FourierField",
 	props: {
-		variant: { default: "hero" },
+		config: {},
+		spectrum: {},
+		getPalette: {},
 		color: {},
 		colorResolver: {},
 		seed: { default: "" },
@@ -182,25 +773,81 @@ var C = /* @__PURE__ */ t(/* @__PURE__ */ h({
 			type: Boolean,
 			default: !1
 		},
-		intensity: { default: 1 },
-		clock: {}
+		intensity: {}
 	},
-	setup(e) {
-		let t = e, n = y("hostRef"), r = y("canvasRef");
-		return S(t, {
-			hostRef: n,
-			canvasRef: r
-		}), (e, t) => (_(), p("div", {
+	setup(e, { expose: n }) {
+		let r = e, i = O("hostRef"), a = O("canvasRef"), { isDark: o } = d(), s = y(() => {
+			let e = r.config ?? N, t = r.intensity == null ? e.intensity : Math.max(0, Math.min(2, r.intensity)), n = r.config ? e.interactive : !1;
+			return {
+				...e,
+				intensity: t,
+				interactive: n
+			};
+		}), c = y(() => r.spectrum && r.spectrum.length > 0 ? r.spectrum : _(f(p((r.freeze ? "fourier-field/frozen" : r.seed || "fourier-field") + r.seed)), {
+			harmonics: Math.min(s.value.harmonics + 4, 62),
+			harmonicScale: s.value.harmonicScale
+		})), l = () => c.value;
+		function m(e) {
+			if (!e.includes("var(") && !e.includes("light-dark(")) return e;
+			let n = i.value;
+			if (typeof window > "u" || !n) return e;
+			if (e.includes("var(")) return t(e, n);
+			let r = n.style.color;
+			n.style.color = e;
+			let a = getComputedStyle(n).color;
+			return n.style.color = r, a || e;
+		}
+		let h = D(s.value.palette);
+		function g() {
+			if (r.getPalette) {
+				h.value = r.getPalette();
+				return;
+			}
+			if (o.value, r.color) {
+				let e = m(r.color);
+				if (e.includes("var(") || e.includes("light-dark(")) return;
+				let t = u(e);
+				h.value = [{
+					L: Math.max(.5, t.L),
+					C: Math.max(.12, t.C),
+					h: t.h
+				}, {
+					L: Math.min(.9, t.L + .22),
+					C: t.C * .4,
+					h: t.h + 18
+				}];
+				return;
+			}
+			h.value = s.value.palette;
+		}
+		let v = $(a, {
+			config: s.value,
+			getSpectrum: l,
+			getPalette: () => h.value,
+			freeze: () => r.freeze
+		});
+		return k([
+			() => r.color,
+			() => r.getPalette,
+			o
+		], g, { immediate: !0 }), w(g), k(o, () => v.wake()), k(() => r.freeze, () => v.wake()), n({
+			backend: () => v.backend,
+			pause: v.pause,
+			resume: v.resume,
+			wake: v.wake,
+			renderAt: v.renderAt,
+			setHeadT: v.setHeadT
+		}), (e, t) => (E(), b("div", {
 			ref_key: "hostRef",
-			ref: n,
-			class: "fourier-field"
-		}, [m("canvas", {
+			ref: i,
+			class: C(["fourier-field", { "fourier-field--interactive": s.value.interactive }])
+		}, [x("canvas", {
 			ref_key: "canvasRef",
-			ref: r,
+			ref: a,
 			class: "fourier-field-canvas",
 			"aria-hidden": "true"
-		}, null, 512)], 512));
+		}, null, 512)], 2));
 	}
-}), [["__scopeId", "data-v-5638d46b"]]);
+}), [["__scopeId", "data-v-b0591225"]]);
 //#endregion
-export { C as FourierField, f as comp, u as dftFromPoints, d as makeEllipticSpectrum, l as partialSumAt, c as positionsAt };
+export { N as DEFAULT_FOURIER_CONFIG, he as FourierField, j as MAX_CURVE_SAMPLES, A as MAX_PHASORS, M as WARM_IDENTITY_PALETTE, v as comp, g as dftFromPoints, _ as makeEllipticSpectrum, h as partialSumAt, m as positionsAt, $ as useFourierField };