@mkbabb/glass-ui 4.0.1 → 4.2.0

package/dist/fourier-field.js

@@ -1,180 +1,995 @@
-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-gLzyemvl.js";
+import { n as t } from "./useResolveTokenColor-ChOnCckA.js";
+import { t as n } from "./usePointerVelocityField-BrkqZFhj.js";
+import { n as r, o as i, r as a, s as o } from "./procedural-color.wgsl-C1Y5PkM6.js";
+import { a as s, t as c } from "./useGpuSubstrate-Ceet70xq.js";
+import { c as l, t as u } from "./color-B9jZdhJX.js";
+import { t as d } from "./useGlobalDark-B4HO9LXG.js";
+import { n as f, t as p } from "./prng-B5tIXTtj.js";
+import { a as m, i as h, n as g, r as _, t as v } from "./math-5RcIgCB4.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 = .15, N = .12, P = .55, F = .35, I = [{
+	L: .62,
+	C: .19,
+	h: 34
+}, {
+	L: .86,
+	C: .06,
+	h: 70
+}], L = {
+	source: "elliptic",
+	harmonics: 6,
+	showEpicycles: !0,
+	epicycleArms: 6,
+	rainbowChain: !0,
+	trailArc: .43,
+	trailWidth: 3,
+	intensity: 1,
+	harmonicScale: .24,
+	speed: 1,
+	palette: I,
+	respectReducedMotion: !0,
+	interactive: !0,
+	squashGain: P,
+	celGain: F
+}, R = "\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", z = `
+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;
+// BD.W-FOURIER-LOOM §2b — the degenerate-tangent guard (must equal FOURIER_TANGENT_EPS in
+// constants.ts + the GL CPU bead path so a cusp resolves IDENTICALLY across both engines).
+const TANGENT_EPS: f32 = 1e-4;
+// The speed yardstick: the head speed (model units between curveSamples[0] and [1]) is
+// normalized against this many trail half-widths so ŝ ∈ [0,1] is scale-free + parity-safe.
+const SPEED_REF_HALFWIDTHS: f32 = 6.0;
+
+// ── 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>,
+  // r3: (squashGain, celGain, _pad, _pad) — FOURIER-LOOM §2b/§3b
+  r3: 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);
+}
+
+// BD.W-FOURIER-LOOM §2b — the head travel frame: the unit tangent T from curveSamples[0]
+// (head) vs [1] (one step back) + the normalized speed ŝ ∈ [0,1]. The cusp guard returns
+// the +x axis as the stable fallback when s ≤ TANGENT_EPS, identical to the GL CPU path.
+struct HeadFrame { T: vec2<f32>, sHat: f32, };
+fn headFrame(head: vec2<f32>, headBack: vec2<f32>, halfW: f32) -> HeadFrame {
+  let d = head - headBack;
+  let s = length(d);
+  var out: HeadFrame;
+  if (s <= TANGENT_EPS) {
+    out.T = vec2<f32>(1.0, 0.0);
+    out.sHat = 0.0;
+    return out;
+  }
+  out.T = d / s;
+  let refScale = max(halfW * SPEED_REF_HALFWIDTHS, 1e-6);
+  out.sHat = clamp(s / refScale, 0.0, 1.0);
+  return out;
+}
+
+// The volume-preserving anisotropic head distance: project (p − head) onto T and T⊥, stretch
+// the tangent extent by (1 + k·ŝ) and squeeze the normal extent by 1/(1 + k·ŝ), then length.
+// k = 0 (or ŝ = 0) collapses to the round disc length(p − head) — byte-frozen at rest.
+fn headAniso(p: vec2<f32>, head: vec2<f32>, fr: HeadFrame, k: f32) -> f32 {
+  let g = 1.0 + k * fr.sHat;
+  let n = vec2<f32>(-fr.T.y, fr.T.x);
+  let rel = p - head;
+  let along = dot(rel, fr.T) / g;
+  let across = dot(rel, n) * g;
+  return length(vec2<f32>(along, across));
+}
+
+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 squashGain = u.r3.x;                 // FOURIER-LOOM §2b
+  let celGain = u.r3.y;                    // FOURIER-LOOM §3b
+  let halfW = trailWidth * 0.5;
+
+  // BD.W-FOURIER-LOOM §2b — the head travel frame (the SAME curveSamples[0]/[1] both engines
+  // read → parity by construction). The cel offset (§3b) rides −T (opposite travel).
+  var headFr: HeadFrame;
+  headFr.T = vec2<f32>(1.0, 0.0);
+  headFr.sHat = 0.0;
+  if (sampleCount >= 2) {
+    headFr = headFrame(curveSamples[0].xy, curveSamples[1].xy, halfW);
+  }
+  let celOff = -headFr.T * halfW * 1.4;    // the ink lags behind the travel
+
+  var accum = vec4<f32>(0.0);              // premultiplied accumulation
+
+  // ── §3b — the cartoon CEL-SHADOW: a darker offset copy of the chain + rope, opposite
+  //    travel, painted FIRST (it sits UNDER the lit chain). PRM-static (the frozen-T travel
+  //    frame is a fixed offset, no live sweep). celGain = 0 → no pass (byte-frozen). ──
+  if (celGain > 0.001) {
+    let ink = vec3<f32>(0.0);              // pure ink — the technicolor 2-tone shadow
+    let celA = clamp(celGain, 0.0, 1.0);
+    // the rope cel (one offset distance-to-curve band).
+    for (var i = 0; i < MAX_CURVE_SAMPLES; i = i + 1) {
+      if (i >= sampleCount - 1) { break; }
+      let sa = curveSamples[i].xy + celOff;
+      let sb = curveSamples[i + 1].xy + celOff;
+      let d = segDist(p, sa, sb);
+      let cover = 1.0 - smoothstep(halfW, halfW + aa, d);
+      if (cover < 0.002) { continue; }
+      let m = cover * celA * peak;
+      accum = vec4<f32>(ink * m, m) + accum * (1.0 - m);
+    }
+    // the chain cel (arms only — the bold scaffold ink).
+    if (showEpicycles && armCount >= 1) {
+      for (var k = 0; k < MAX_PHASORS; k = k + 1) {
+        if (k >= armCount) { break; }
+        let a = chainTips[k].xy + celOff;
+        let b = chainTips[k + 1].xy + celOff;
+        let dArm = segDist(p, a, b);
+        let armMask = 1.0 - smoothstep(halfW * 0.55, halfW * 0.55 + aa, dArm);
+        let m = armMask * celA * peak * 0.7;
+        accum = vec4<f32>(ink * m, m) + accum * (1.0 - m);
+      }
+    }
+  }
+
+  // ── 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 — squash-and-stretch (§2b) halo + saturated core + white specular.
+  //    dHead is the volume-preserving anisotropic distance off the travel frame; at rest
+  //    (sHat=0) or squashGain=0 it collapses to the round disc length(p − head). ──
+  if (sampleCount >= 1) {
+    let head = curveSamples[0].xy;
+    let dHead = headAniso(p, head, headFr, squashGain);
+    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;
+}
+`, B = {
+	c0: 0,
+	ints: 4
+};
+function V() {
+	let e = /* @__PURE__ */ new ArrayBuffer(32);
+	return {
+		buffer: e,
+		f32: new Float32Array(e),
+		i32: new Int32Array(e)
+	};
+}
+function H(e, t, n, r, i, a, o) {
+	let { f32: s, i32: c } = e;
+	return s[B.c0 + 0] = t, s[B.c0 + 1] = n, s[B.c0 + 2] = 0, s[B.c0 + 3] = 0, c[B.ints + 0] = r, c[B.ints + 1] = i, c[B.ints + 2] = a, c[B.ints + 3] = o, e;
+}
+var U = 144, W = {
+	r0: 0,
+	r1: 4,
+	r2: 8,
+	r3: 12,
+	ints: 16,
+	palette: 20
+};
+function G() {
+	let e = new ArrayBuffer(U);
+	return {
+		buffer: e,
+		f32: new Float32Array(e),
+		i32: new Int32Array(e)
+	};
+}
+function K(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 ee(e, t, n, r) {
+	let i = Math.max(r, 1e-4), a = (e - n.centerX) * n.scale / i, o = (t - n.centerY) * n.scale;
+	return {
+		x: a * .5 + .5,
+		y: 1 - (o * .5 + .5)
+	};
+}
+function q(e, t, n) {
+	let r = Math.max(n, 1) / 2;
+	return e / Math.max(t, 1e-6) / r;
+}
+function te(e, t, n, r, i, a, o, s, c, u, d, f, p, m, h, g) {
+	let { f32: _, i32: v } = e;
+	_[W.r0 + 0] = t.centerX, _[W.r0 + 1] = t.centerY, _[W.r0 + 2] = t.scale, _[W.r0 + 3] = n, _[W.r1 + 0] = r, _[W.r1 + 1] = i, _[W.r1 + 2] = a, _[W.r1 + 3] = o, _[W.r2 + 0] = s, _[W.r2 + 1] = c, _[W.r2 + 2] = +!!u, _[W.r2 + 3] = +!!d, _[W.r3 + 0] = f, _[W.r3 + 1] = p, _[W.r3 + 2] = 0, _[W.r3 + 3] = 0;
+	let y = Math.min(g.length, 4);
+	v[W.ints + 0] = m, v[W.ints + 1] = h, v[W.ints + 2] = y, v[W.ints + 3] = 0;
+	for (let e = 0; e < 4; e++) {
+		let t = W.palette + e * 4, n = l(g[Math.min(e, y - 1)] ?? g[0]);
+		_[t + 0] = n[0], _[t + 1] = n[1], _[t + 2] = n[2], _[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 ne(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 J = 64, Y = 128, X = 8, re = 1, Z = 2, Q = 4, ie = 64, ae = .92, oe = .95, se = 1.35, ce = .34;
+function le(e) {
+	let { canvas: t, config: n, getSpectrum: r, getPalette: i, getHeadT: a, shouldContinue: o, onFrame: c } = e, l = e.getPointerLean;
+	return function(e, u, d) {
+		let f = e.createShaderModule({
+			label: "[FourierField] fourier-field.compute.wgsl",
+			code: R
+		}), p = e.createShaderModule({
+			label: "[FourierField] fourier-field.render.wgsl",
+			code: z
+		}), m = e.createBuffer({
+			label: "[FourierField] phasors",
+			size: 1024,
+			usage: Y | X
+		}), h = e.createBuffer({
+			label: "[FourierField] curve-samples",
+			size: 384 * 16,
+			usage: Y
+		}), g = e.createBuffer({
+			label: "[FourierField] chain-tips",
+			size: 1040,
+			usage: Y
+		}), _ = e.createBuffer({
+			label: "[FourierField] compute-uniforms",
+			size: V().buffer.byteLength,
+			usage: J | X
+		}), v = e.createBuffer({
+			label: "[FourierField] render-uniforms",
+			size: G().buffer.byteLength,
+			usage: J | X
+		}), y = e.createBindGroupLayout({
+			label: "[FourierField] compute-bgl",
+			entries: [
+				{
+					binding: 0,
+					visibility: Q,
+					buffer: { type: "uniform" }
+				},
+				{
+					binding: 1,
+					visibility: Q,
+					buffer: { type: "read-only-storage" }
+				},
+				{
+					binding: 2,
+					visibility: Q,
+					buffer: { type: "storage" }
+				},
+				{
+					binding: 3,
+					visibility: Q,
+					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]));
+			]
+		}), b = e.createComputePipeline({
+			label: "[FourierField] compute-pipeline",
+			layout: e.createPipelineLayout({ bindGroupLayouts: [y] }),
+			compute: {
+				module: f,
+				entryPoint: "cs_main"
+			}
+		}), x = e.createBindGroup({
+			label: "[FourierField] compute-bg",
+			layout: y,
+			entries: [
+				{
+					binding: 0,
+					resource: { buffer: _ }
+				},
+				{
+					binding: 1,
+					resource: { buffer: m }
+				},
+				{
+					binding: 2,
+					resource: { buffer: h }
+				},
+				{
+					binding: 3,
+					resource: { buffer: g }
 				}
-				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();
+			]
+		}), S = e.createBindGroupLayout({
+			label: "[FourierField] render-bgl",
+			entries: [
+				{
+					binding: 0,
+					visibility: re | Z,
+					buffer: { type: "uniform" }
+				},
+				{
+					binding: 1,
+					visibility: Z,
+					buffer: { type: "read-only-storage" }
+				},
+				{
+					binding: 2,
+					visibility: Z,
+					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();
+			]
+		}), C = e.createRenderPipeline({
+			label: "[FourierField] render-pipeline",
+			layout: e.createPipelineLayout({ bindGroupLayouts: [S] }),
+			vertex: {
+				module: p,
+				entryPoint: "vs_main"
+			},
+			fragment: {
+				module: p,
+				entryPoint: "fs_main",
+				targets: [{
+					format: d,
+					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" }
+		}), w = e.createBindGroup({
+			label: "[FourierField] render-bg",
+			layout: S,
+			entries: [
+				{
+					binding: 0,
+					resource: { buffer: v }
+				},
+				{
+					binding: 1,
+					resource: { buffer: h }
+				},
+				{
+					binding: 2,
+					resource: { buffer: g }
 				}
-				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();
-		});
-	});
+			]
+		}), T = V(), E = G(), D = null, O = {
+			centerX: 0,
+			centerY: 0,
+			scale: 1
+		}, k = 0;
+		function A() {
+			let t = r();
+			t !== D && (D = t, k = Math.min(t.length, 64), O = K(t), e.queue.writeBuffer(m, 0, ne(t)));
+		}
+		function j() {
+			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 M(r) {
+			c?.(r), A();
+			let o = a(), s = Math.max(1, Math.min(Math.round(n.harmonics), k)), d = n.showEpicycles ? Math.max(1, Math.min(Math.round(n.epicycleArms), s)) : 0;
+			H(T, o, n.trailArc, s, d, 384, k), e.queue.writeBuffer(_, 0, T.buffer);
+			let f = Math.min(t.clientWidth || 320, t.clientHeight || 320), p = (t.clientWidth || 320) / Math.max(t.clientHeight || 320, 1), m = q(n.trailWidth, O.scale, f), h = l?.() ?? {
+				x: 0,
+				y: 0
+			};
+			te(E, h.x !== 0 || h.y !== 0 ? {
+				...O,
+				centerX: O.centerX - h.x,
+				centerY: O.centerY - h.y
+			} : O, p, m, ae, oe, se, ce, n.intensity, n.showEpicycles, n.rainbowChain, n.squashGain, n.celGain, 384, d, i()), e.queue.writeBuffer(v, 0, E.buffer);
+			let g = e.createCommandEncoder({ label: "[FourierField] frame" }), y = g.beginComputePass();
+			y.setPipeline(b), y.setBindGroup(0, x), y.dispatchWorkgroups(Math.ceil(384 / ie)), y.end();
+			let S = u.getCurrentTexture().createView(), D = g.beginRenderPass({ colorAttachments: [{
+				view: S,
+				clearValue: {
+					r: 0,
+					g: 0,
+					b: 0,
+					a: 0
+				},
+				loadOp: "clear",
+				storeOp: "store"
+			}] });
+			D.setPipeline(C), D.setBindGroup(0, w), D.draw(3, 1, 0, 0), D.end(), e.queue.submit([g.finish()]);
+		}
+		return {
+			frame: M,
+			shouldContinue: o,
+			resize: j,
+			teardown: () => {
+				m.destroy(), h.destroy(), g.destroy(), _.destroy(), v.destroy();
+			}
+		};
+	};
+}
+//#endregion
+//#region src/components/custom/fourier-field/shaders/fourier-field.glsl.ts
+var ue = "#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", de = `#version 300 es
+precision highp float;
+
+#define MAX_CURVE_SAMPLES 256
+#define MAX_PHASORS 64
+// BD.W-FOURIER-LOOM §2b — MUST equal the WGSL twin + FOURIER_TANGENT_EPS (constants.ts).
+#define TANGENT_EPS 1e-4
+#define SPEED_REF_HALFWIDTHS 6.0
+
+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 vec4 uLoom;         // (squashGain, celGain, _pad, _pad) — FOURIER-LOOM §2b/§3b
+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);
+}
+
+// BD.W-FOURIER-LOOM §2b — the head travel frame (T, ŝ), the GLSL twin of the WGSL headFrame.
+// The cusp guard returns +x as the stable fallback when s ≤ TANGENT_EPS — identical to the
+// WGSL twin + the CPU bead path.
+struct HeadFrame { vec2 T; float sHat; };
+HeadFrame headFrame(vec2 head, vec2 headBack, float halfW) {
+  vec2 d = head - headBack;
+  float s = length(d);
+  HeadFrame fr;
+  if (s <= TANGENT_EPS) { fr.T = vec2(1.0, 0.0); fr.sHat = 0.0; return fr; }
+  fr.T = d / s;
+  float refScale = max(halfW * SPEED_REF_HALFWIDTHS, 1e-6);
+  fr.sHat = clamp(s / refScale, 0.0, 1.0);
+  return fr;
+}
+
+// The volume-preserving anisotropic head distance (the WGSL headAniso twin).
+float headAniso(vec2 p, vec2 head, HeadFrame fr, float k) {
+  float g = 1.0 + k * fr.sHat;
+  vec2 n = vec2(-fr.T.y, fr.T.x);
+  vec2 rel = p - head;
+  float along = dot(rel, fr.T) / g;
+  float across = dot(rel, n) * g;
+  return length(vec2(along, across));
+}
+
+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 squashGain = uLoom.x;            // FOURIER-LOOM §2b
+  float celGain = uLoom.y;               // FOURIER-LOOM §3b
+  float halfW = trailWidth * 0.5;
+
+  // §2b — the head travel frame (SAME uCurve[0]/[1] the WGSL twin reads → parity).
+  HeadFrame headFr;
+  headFr.T = vec2(1.0, 0.0);
+  headFr.sHat = 0.0;
+  if (uSampleCount >= 2) {
+    headFr = headFrame(uCurve[0].xy, uCurve[1].xy, halfW);
+  }
+  vec2 celOff = -headFr.T * halfW * 1.4;
+
+  vec4 accum = vec4(0.0);
+
+  // §3b — the cartoon CEL-SHADOW: a darker offset copy of the rope + chain, opposite travel,
+  // painted FIRST (under the lit chain). PRM-static; celGain = 0 → no pass (byte-frozen).
+  if (celGain > 0.001) {
+    vec3 ink = vec3(0.0);
+    float celA = clamp(celGain, 0.0, 1.0);
+    for (int i = 0; i < MAX_CURVE_SAMPLES; i++) {
+      if (i >= uSampleCount - 1) break;
+      vec2 sa = uCurve[i].xy + celOff;
+      vec2 sb = uCurve[i + 1].xy + celOff;
+      float d = segDist(p, sa, sb);
+      float cover = 1.0 - smoothstep(halfW, halfW + aa, d);
+      if (cover < 0.002) continue;
+      float m = cover * celA * peak;
+      accum = vec4(ink * m, m) + accum * (1.0 - m);
+    }
+    if (showEpicycles && uArmCount >= 1) {
+      for (int k = 0; k < MAX_PHASORS; k++) {
+        if (k >= uArmCount) break;
+        vec2 a = uChain[k] + celOff;
+        vec2 b = uChain[k + 1] + celOff;
+        float dArm = segDist(p, a, b);
+        float armMask = 1.0 - smoothstep(halfW * 0.55, halfW * 0.55 + aa, dArm);
+        float m = armMask * celA * peak * 0.7;
+        accum = vec4(ink * m, m) + accum * (1.0 - m);
+      }
+    }
+  }
+
+  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;
+    // §2b — the squash-and-stretch anisotropic head (collapses to the round disc at rest).
+    float dHead = headAniso(p, head, headFr, squashGain);
+    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;
+}
+`, fe = 256, $ = 64, pe = .92, me = .95, he = 1.35, ge = .34;
+function _e(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 ve(e) {
+	let { canvas: t, config: n, getSpectrum: r, getPalette: i, getHeadT: a, shouldContinue: o, onFrame: c } = e, u = e.getPointerLean;
+	return function(e) {
+		let d = _e(e, e.VERTEX_SHADER, ue), f = _e(e, e.FRAGMENT_SHADER, de), p = e.createProgram();
+		if (e.attachShader(p, d), e.attachShader(p, f), e.linkProgram(p), !e.getProgramParameter(p, e.LINK_STATUS)) throw Error(`[FourierField] link failed: ${e.getProgramInfoLog(p)}`);
+		e.deleteShader(d), e.deleteShader(f);
+		let m = e.createVertexArray();
+		e.bindVertexArray(m);
+		let g = e.createBuffer();
+		e.bindBuffer(e.ARRAY_BUFFER, g), e.bufferData(e.ARRAY_BUFFER, new Float32Array([
+			-1,
+			-1,
+			3,
+			-1,
+			-1,
+			3
+		]), e.STATIC_DRAW);
+		let _ = e.getAttribLocation(p, "aPosition");
+		e.enableVertexAttribArray(_), e.vertexAttribPointer(_, 2, e.FLOAT, !1, 0, 0), e.bindVertexArray(null);
+		let v = (t) => e.getUniformLocation(p, t), y = v("uFit"), b = v("uTrail"), x = v("uEnv"), S = v("uLoom"), C = v("uSampleCount"), w = v("uArmCount"), T = v("uStopCount"), E = v("uPalette[0]"), D = v("uCurve[0]"), O = v("uChain[0]"), k = new Float32Array(fe * 3), A = new Float32Array(($ + 1) * 2), j = new Float32Array(12), M = null, N = {
+			centerX: 0,
+			centerY: 0,
+			scale: 1
+		}, P = 0;
+		function F() {
+			let e = r();
+			e !== M && (M = e, P = Math.min(e.length, $), N = K(e));
+		}
+		function I() {
+			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 L(r) {
+			c?.(r), F();
+			let o = M;
+			if (!o) return;
+			let s = a(), d = Math.max(1, Math.min(Math.round(n.harmonics), P)), f = n.showEpicycles ? Math.max(1, Math.min(Math.round(n.epicycleArms), d)) : 0, g = fe, _ = Math.max(g - 1, 1);
+			for (let e = 0; e < g; e++) {
+				let t = e / _, r = 1 - t, i = s - n.trailArc * t;
+				i -= Math.floor(i);
+				let [a, c] = h(o, i, d), l = e * 3;
+				k[l + 0] = a, k[l + 1] = c, k[l + 2] = r;
+			}
+			let v = Math.min(f, d);
+			for (let e = 0; e <= $; e++) {
+				let t = e * 2;
+				if (e <= v) {
+					let [n, r] = h(o, s, e);
+					A[t + 0] = n, A[t + 1] = r;
+				} else A[t + 0] = 0, A[t + 1] = 0;
+			}
+			let I = t.clientWidth || 320, L = t.clientHeight || 320, R = Math.min(I, L), z = I / Math.max(L, 1), B = q(n.trailWidth, N.scale, R), V = i(), H = Math.min(V.length, 4);
+			for (let e = 0; e < 4; e++) {
+				let t = l(V[Math.min(e, H - 1)] ?? V[0]);
+				j[e * 3 + 0] = t[0], j[e * 3 + 1] = t[1], j[e * 3 + 2] = t[2];
+			}
+			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);
+			let U = u?.() ?? {
+				x: 0,
+				y: 0
+			};
+			e.uniform4f(y, N.centerX - U.x, N.centerY - U.y, N.scale, z), e.uniform4f(b, B, pe, me, he), e.uniform4f(x, ge, n.intensity, +!!n.showEpicycles, +!!n.rainbowChain), e.uniform4f(S, n.squashGain, n.celGain, 0, 0), e.uniform1i(C, g), e.uniform1i(w, f), e.uniform1i(T, H), e.uniform3fv(E, j), e.uniform3fv(D, k), e.uniform2fv(O, A), e.drawArrays(e.TRIANGLES, 0, 3);
+		}
+		return {
+			frame: L,
+			shouldContinue: o,
+			resize: I,
+			teardown: () => {
+				e.deleteProgram(p), e.deleteBuffer(g), e.deleteVertexArray(m);
+			}
+		};
+	};
+}
+//#endregion
+//#region src/components/custom/fourier-field/composables/useFourierField.ts
+function ye(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 = 0;
+	function m(e) {
+		if (f === 0 && p === 0) return;
+		let t = -64 * f - 2 * .62 * 8 * p;
+		p += t * e, f += p * e, Math.abs(f) < 1e-4 && Math.abs(p) < 1e-4 && (f = 0, p = 0);
+	}
+	let g = n({ respectReducedMotion: r.respectReducedMotion }), _ = () => (t.freeze?.() ?? !1) || (F?.reducedMotion ?? !1);
+	function v(e) {
+		y(e), t.onHeadFrame?.(E());
+	}
+	function y(e) {
+		let t = d >= 0 ? (e - d) * 1e3 : 16.7;
+		if (d = e, g.tick(t), _()) {
+			u = s, f = 0, p = 0;
+			return;
+		}
+		let n = Math.min(Math.max(t / 1e3, 0), .05);
+		if (r.interactive && g.active.value) {
+			let e = r.speed / l + g.velocity.value.x * M + f;
+			u = (u + e * n) % 1, u < 0 && (u += 1);
+			let t = g.burst.value * 4;
+			t !== 0 && (f = t, p = 0), m(n);
+			return;
+		}
+		let i = r.speed / l + f;
+		u = (u + i * n) % 1, u < 0 && (u += 1), m(n);
+	}
+	let b = () => u, x = null, S = {
+		centerX: 0,
+		centerY: 0,
+		scale: 1
+	}, C = () => {
+		let e = i();
+		return e !== x && (x = e, S = K(e)), S;
+	}, w = () => {
+		let e = i(), t = Math.max(1, Math.min(Math.round(r.harmonics), e.length, 64)), [n, a] = h(e, u, t);
+		return {
+			x: n,
+			y: a
+		};
+	}, E = () => {
+		let t = e.value;
+		if (!t) return null;
+		let n = t.clientWidth || 0, r = t.clientHeight || 0;
+		if (n <= 0 || r <= 0) return null;
+		let i = n / r, a = w(), o = C(), s = D(), c = s.x !== 0 || s.y !== 0 ? {
+			...o,
+			centerX: o.centerX - s.x,
+			centerY: o.centerY - s.y
+		} : o;
+		return ee(a.x, a.y, c, i);
+	}, D = () => {
+		if (!r.interactive || !g.active.value) return {
+			x: 0,
+			y: 0
+		};
+		let e = g.smoothedPosition.value;
+		return {
+			x: (e.x * 2 - 1) * N,
+			y: (e.y * 2 - 1) * N
+		};
+	}, O = (e) => {
+		g.onPointerMove(e), r.interactive && F?.wake();
+	}, k = () => {
+		g.onPointerEnter(), r.interactive && F?.wake();
+	}, A = (e) => e.parentElement ?? e;
+	function j(e) {
+		let t = A(e);
+		t.addEventListener("pointermove", O), t.addEventListener("pointerenter", k), t.addEventListener("pointerleave", g.onPointerLeave);
+	}
+	function P(e) {
+		let t = A(e);
+		t.removeEventListener("pointermove", O), t.removeEventListener("pointerenter", k), t.removeEventListener("pointerleave", g.onPointerLeave);
+	}
+	let F = null, I = () => {
+		let t = e.value;
+		return t ? (F || (j(t), F = c(t, {
+			mode: o,
+			respectReducedMotion: r.respectReducedMotion,
+			setupWGPU: le({
+				canvas: t,
+				config: r,
+				getSpectrum: i,
+				getPalette: a,
+				getHeadT: b,
+				shouldContinue: () => !0,
+				onFrame: v,
+				getPointerLean: D
+			}),
+			setupGL: ve({
+				canvas: t,
+				config: r,
+				getSpectrum: i,
+				getPalette: a,
+				getHeadT: b,
+				shouldContinue: () => !0,
+				onFrame: v,
+				getPointerLean: D
+			})
+		}), F.armAsync()), F) : null;
+	};
+	queueMicrotask(() => I());
+	let L = {
+		get backend() {
+			return I()?.backend ?? "webgpu";
+		},
+		pause: () => I()?.suspend("manual"),
+		resume: () => I()?.resume("manual"),
+		wake: () => I()?.wake(),
+		renderAt: (e) => I()?.renderAt(e),
+		get reducedMotion() {
+			return F?.reducedMotion ?? !1;
+		},
+		get headT() {
+			return u;
+		},
+		setHeadT: (e) => {
+			u = (e % 1 + 1) % 1, I()?.wake();
+		},
+		headUnit: E,
+		dispose: () => {
+			let t = e.value;
+			t && P(t), g.dispose(), F?.dispose();
+		}
+	};
+	return T(() => L.dispose()), L;
 }
 //#endregion
 //#region src/components/custom/fourier-field/FourierField.vue
-var C = /* @__PURE__ */ t(/* @__PURE__ */ h({
+var be = /* @__PURE__ */ e(/* @__PURE__ */ S({
 	__name: "FourierField",
 	props: {
-		variant: { default: "hero" },
+		config: {},
+		spectrum: {},
+		getPalette: {},
 		color: {},
 		colorResolver: {},
 		seed: { default: "" },
@@ -182,25 +997,101 @@ 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 ?? L, 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 = () => h.value, S = new Proxy({}, {
+			get: (e, t) => Reflect.get(s.value, t),
+			has: (e, t) => Reflect.has(s.value, t),
+			ownKeys: () => Reflect.ownKeys(s.value),
+			getOwnPropertyDescriptor: (e, t) => Reflect.getOwnPropertyDescriptor(s.value, t)
+		});
+		function T(e) {
+			let t = i.value;
+			!t || !e || t.style.setProperty("--ff-head-xy", `${e.x.toFixed(4)} ${e.y.toFixed(4)}`);
+		}
+		let A = ye(a, {
+			config: S,
+			getSpectrum: l,
+			getPalette: v,
+			freeze: () => r.freeze,
+			onHeadFrame: T
+		});
+		function j() {
+			let e = i.value;
+			if (!e) return;
+			let t = h.value[0];
+			t && e.style.setProperty("--ff-head-hue", `${t.h.toFixed(1)}`);
+		}
+		return k(() => r.config, () => A.wake(), { deep: !0 }), k([
+			() => r.color,
+			() => r.getPalette,
+			o
+		], g, { immediate: !0 }), k(h, j), w(() => {
+			g(), j();
+		}), k(o, () => A.wake()), k(() => r.freeze, () => A.wake()), n({
+			backend: () => A.backend,
+			pause: A.pause,
+			resume: A.resume,
+			wake: A.wake,
+			renderAt: A.renderAt,
+			setHeadT: A.setHeadT,
+			headUnit: A.headUnit
+		}), (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-4914c4f3"]]);
 //#endregion
-export { C as FourierField, f as comp, u as dftFromPoints, d as makeEllipticSpectrum, l as partialSumAt, c as positionsAt };
+export { L as DEFAULT_FOURIER_CONFIG, be as FourierField, j as MAX_CURVE_SAMPLES, A as MAX_PHASORS, I as WARM_IDENTITY_PALETTE, v as comp, g as dftFromPoints, _ as makeEllipticSpectrum, h as partialSumAt, m as positionsAt, ye as useFourierField };