@mkbabb/glass-ui 4.1.0 → 4.2.0

package/dist/paper-grid.js

@@ -1,139 +1,28 @@
-import { t as e } from "./_plugin-vue_export-helper-C1je1s0u.js";
-import { t } from "./usePointerVelocityField-QLsy3_kv.js";
-import { n, o as r } from "./procedural-color.wgsl-m7Zgv35j.js";
-import { t as i } from "./flow.glsl-B2P7e0MT.js";
-import { a, t as o } from "./useGpuSubstrate-4pTcp6mX.js";
-import { c as s, t as c } from "./color-Cs0-oxYL.js";
-import { computed as l, createElementBlock as u, createElementVNode as d, defineComponent as f, normalizeStyle as p, onMounted as m, onScopeDispose as h, openBlock as g, reactive as _, useTemplateRef as v, watch as y } from "vue";
-//#region src/components/custom/paper-grid/composables/paperGrid.ts
-Math.PI * 2;
-var b = .012;
-function x(e, t) {
-	let n = e * .1031 % 1, r = t * .1031 % 1, i = e * .1031 % 1;
-	n < 0 && (n += 1), r < 0 && (r += 1), i < 0 && (i += 1);
-	let a = n * (r + 33.33) + r * (i + 33.33) + i * (n + 33.33);
-	n += a, r += a, i += a;
-	let o = (n + r) * i % 1;
-	return o < 0 && (o += 1), o;
-}
-function S(e, t, n) {
-	return e + (t - e) * n;
-}
-function C(e, t) {
-	let n = Math.floor(e), r = Math.floor(t), i = e - n, a = t - r, o = i * i * i * (i * (i * 6 - 15) + 10), s = a * a * a * (a * (a * 6 - 15) + 10), c = x(n, r), l = x(n + 1, r), u = x(n, r + 1), d = x(n + 1, r + 1);
-	return S(S(c, l, o), S(u, d, o), s);
-}
-function w(e) {
-	let t = 0, n = .5, r = 1, i = e.x, a = e.y;
-	for (let e = 0; e < 3; e++) {
-		t += n * C(i * r, a * r);
-		let e = .8 * i - .6 * a, o = .6 * i + .8 * a;
-		i = e, a = o, r *= 2, n *= .5;
-	}
-	return t;
-}
-function T(e) {
-	let t = w({
-		x: e.x + b,
-		y: e.y
-	}) - w({
-		x: e.x - b,
-		y: e.y
-	}), n = w({
-		x: e.x,
-		y: e.y + b
-	}) - w({
-		x: e.x,
-		y: e.y - b
-	}), r = t / (2 * b);
-	return {
-		x: n / (2 * b),
-		y: -r
-	};
-}
-function E(e, t, n, r, i, a, o) {
-	let s = T({
-		x: e.x * n + t * r,
-		y: e.y * n + t * r
-	}), c = T({
-		x: e.x * i - t * a,
-		y: e.y * i - t * a
-	});
-	return {
-		x: s.x * o + c.x * o * .5,
-		y: s.y * o + c.y * o * .5
-	};
-}
-function D(e, t, n, r) {
-	let i = e.x - t.x, a = e.y - t.y, o = Math.hypot(i, a), s = Math.max(r, 1e-4), c = n * Math.exp(-(o * o) / (2 * s * s));
-	if (o < 1e-5) return {
-		x: 0,
-		y: 0
-	};
-	let l = 1 / o;
-	return {
-		x: i * l * c,
-		y: a * l * c
-	};
-}
-function O(e, t, n) {
-	let r = t - e, i = Math.abs(r) < 1e-9 ? r < 0 ? -1e-9 : 1e-9 : r, a = Math.min(Math.max((n - e) / i, 0), 1);
-	return a * a * (3 - 2 * a);
-}
-function k(e, t, n) {
-	return Math.min(Math.max(e, t), n);
-}
-function A(e, t, n) {
-	let r = 1 - Math.abs((e.x - Math.floor(e.x)) * 2 - 1), i = 1 - Math.abs((e.y - Math.floor(e.y)) * 2 - 1), a = k(t, n.x, .5), o = k(t, n.y, .5), s = n.x * 1.5, c = n.y * 1.5, l = O(a + s, a - s, r), u = O(o + c, o - c, i);
-	return l *= k(t / Math.max(a, 1e-6), 0, 1), u *= k(t / Math.max(o, 1e-6), 0, 1), l = S(l, t, k(n.x * 2 - 1, 0, 1)), u = S(u, t, k(n.y * 2 - 1, 0, 1)), Math.max(l, u);
-}
-function j(e, t, n) {
-	let r = {
-		x: e.x * n.gridScale,
-		y: e.y * n.gridScale
-	}, i = E(r, t, n.warpScale, n.warpSpeed, n.warpScale2, n.warpSpeed2, n.amplitude);
-	r = {
-		x: r.x + i.x,
-		y: r.y + i.y
-	};
-	let a = D(r, n.cursor, n.bulgeStrength * n.bulgeMode, n.bulgeRadius);
-	r = {
-		x: r.x + a.x,
-		y: r.y + a.y
-	};
-	let o = A(r, n.targetWidth, n.uvDeriv), s = Math.max(n.majorEvery, 1), c = {
-		x: r.x / s,
-		y: r.y / s
-	}, l = {
-		x: n.uvDeriv.x / s,
-		y: n.uvDeriv.y / s
-	}, u = A(c, n.targetWidthMajor, l), d = Math.max(o * n.minorAlpha, u * n.majorAlpha);
-	return {
-		line: d,
-		alpha: d * n.fieldAlpha
-	};
-}
-function M(e, t) {
-	return e / Math.max(t, 1);
-}
-//#endregion
+import { t as e } from "./_plugin-vue_export-helper-gLzyemvl.js";
+import { t } from "./usePointerVelocityField-BrkqZFhj.js";
+import { n, o as r } from "./procedural-color.wgsl-C1Y5PkM6.js";
+import { t as i } from "./flow.glsl-DqEGRpl4.js";
+import { a, t as o } from "./useGpuSubstrate-Ceet70xq.js";
+import { c as s, t as c } from "./color-B9jZdhJX.js";
+import { a as l, d as u, f as d, i as f, n as p, o as m, p as h, r as g, t as _ } from "./paperGrid-CXCSMbZ1.js";
+import { computed as v, createElementBlock as y, createElementVNode as b, defineComponent as x, normalizeStyle as S, onMounted as C, onScopeDispose as w, openBlock as T, reactive as E, useTemplateRef as D, watch as O } from "vue";
 //#region src/components/custom/paper-grid/shaders/paper-grid.wgsl.ts
-var N = `
+var k = `
 const TAU: f32 = 6.283185307179586;
 
 // ── Paper-grid uniforms (the typed-struct source-of-truth — see uniformBridgeWGPU.ts) ──
 struct PaperGridUniforms {
   // u0: (uTime, uGridScale, uMinorPitch, uMajorEvery)
   u0: vec4<f32>,
-  // warp: (uWarpScale, uWarpSpeed, uWarpScale2, uWarpSpeed2)
-  warp: vec4<f32>,
-  // warp2: (uAmplitude, uAspect, _pad, _pad)
+  // face: (uFaceAlpha, uFaceRelief, uSquashK, uBaseInset) — the height-lit FACE (re-points the retired warp lane)
+  face: vec4<f32>,
+  // warp2: (uAmplitude, uAspect, uLightDirX, uLightDirY) — aspect + the cel key-light
   warp2: vec4<f32>,
   // grid: (uTargetWidth, uTargetWidthMajor, uMinorAlpha, uMajorAlpha)
   grid: vec4<f32>,
   // field: (uFieldAlpha, uHasBackground, _pad, _pad)
   field: vec4<f32>,
-  // cursor: (uCursorX, uCursorY, uBulgeStrength, uBulgeRadius)
+  // cursor: (uCursorX, uCursorY, uSwirlStrength, uSwirlRadius)
   cursor: vec4<f32>,
   // cursor2: (uBulgeMode, uInteractive, _pad, _pad)
   cursor2: vec4<f32>,
@@ -141,6 +30,16 @@ struct PaperGridUniforms {
   line: vec4<f32>,
   // bg: (uBg.rgb (linear), _pad)
   bg: vec4<f32>,
+  // wave: (waveDirX, waveDirY, waveK, waveOmega) — the traveling-wave crest
+  wave: vec4<f32>,
+  // wave2: (waveSigma, twistMax, shearMax, amp) — the cell-twist envelope (amp: spring-eased)
+  wave2: vec4<f32>,
+  // faceLo: (rose-umber trough .rgb (linear), _pad) — the warm-divergent ramp (FOLD B, 3-stop)
+  faceLo: vec4<f32>,
+  // faceMid: (ember-amber mid .rgb (linear), _pad)
+  faceMid: vec4<f32>,
+  // faceHi: (warm-wheat crest .rgb (linear), _pad)
+  faceHi: vec4<f32>,
 };
 
 @group(0) @binding(0) var<uniform> u: PaperGridUniforms;
@@ -197,45 +96,13 @@ fn potentialFBM(p: vec2f) -> f32 {
 }
 
 // The shared divergence-free 2D-curl operator (flow.wgsl.ts — the FIRST WGSL curl consumer).
+${h}
 
-const CURL_EPS: f32 = 0.012;
-
-// ∇×ψ in 2D — the divergence-free flow direction. Central finite differences of the
-// scalar potential give the partials; the cross-pairing (∂y, −∂x) is the 2D curl.
-fn curlFBM(p: vec2f) -> vec2f {
-  let dx = potentialFBM(p + vec2f(CURL_EPS, 0.0)) - potentialFBM(p - vec2f(CURL_EPS, 0.0));
-  let dy = potentialFBM(p + vec2f(0.0, CURL_EPS)) - potentialFBM(p - vec2f(0.0, CURL_EPS));
-  // ψ-gradient is (dx, dy)/(2·eps); the curl rotates it 90°: (∂ψ/∂y, −∂ψ/∂x).
-  let g = vec2f(dx, dy) / (2.0 * CURL_EPS);
-  return vec2f(g.y, -g.x);
-}
-
-
-// ── §3 The "liquid": the global curl-flow domain warp (transcribes paperGrid.ts curlWarp) ──
-// TWO counter-flowing curl terms at different scales/speeds (Alex Harri counter-flow — never
-// visibly loops). A SHALLOW, LOW-frequency warp keeps the lines a clearly-readable grid.
-fn curlWarp(g: vec2f, t: f32) -> vec2f {
-  let warpScale = u.warp.x;
-  let warpSpeed = u.warp.y;
-  let warpScale2 = u.warp.z;
-  let warpSpeed2 = u.warp.w;
-  let amp = u.warp2.x;
-  let a = curlFBM(vec2f(g.x * warpScale + t * warpSpeed, g.y * warpScale + t * warpSpeed));
-  let b = curlFBM(vec2f(g.x * warpScale2 - t * warpSpeed2, g.y * warpScale2 - t * warpSpeed2));
-  return vec2f(a.x * amp + b.x * amp * 0.5, a.y * amp + b.y * amp * 0.5);
-}
-
-// ── §4 The pointer bulge: a LOCAL Gaussian warp (transcribes paperGrid.ts cursorBulge) ──
-fn cursorBulge(g: vec2f) -> vec2f {
-  let cursor = u.cursor.xy;
-  let strength = u.cursor.z * u.cursor2.x;  // bulgeStrength × bulgeMode (+repel / −attract)
-  let radius = max(u.cursor.w, 1e-4);
-  let toC = g - cursor;
-  let d = length(toC);
-  let bulge = strength * exp(-(d * d) / (2.0 * radius * radius));
-  if (d < 1e-5) { return vec2f(0.0); }
-  return (toC / d) * bulge;
-}
+// The shared traveling-wave CELL-WARP chunk (waveField.wgsl.ts — cellTwist/cursorSwirl/
+// travelingEnvelope; splices AFTER valueNoise + curlFBM are declared). paper-grid + concentric
+// share this EXACTLY — the cell-local twist replaces the retired LINE-warp (the C3 cure: the
+// boxes twist about their own center, the lines stay locally straight).
+${d}
 
 // ── §1 The crisp line: Ben Golus derivative-AA grid coverage (transcribes gridCoverage) ──
 // targetWidth is the line half-width in GRID UNITS (lineWidthPx / minorPitchPx); uvDeriv is
@@ -255,6 +122,18 @@ fn gridCoverage(g: vec2f, targetWidth: f32, uvDeriv: vec2f) -> f32 {
   return max(grid2.x, grid2.y);
 }
 
+// ── The 3-stop warm-divergent FACE ramp (FOLD B — height-keyed, NOT a 2-point mid-park) ──
+// trough (faceLo) → mid (faceMid) → crest (faceHi), keyed on rampT = mix(shade, h). All stops
+// are warm hue ∈ [20,90] (the teal-navy purge clear by construction). Linear-space stops; the
+// fs_main routes the result through the production OETF (FOLD E).
+fn faceRamp(rampT: f32) -> vec3f {
+  let s = clamp(rampT, 0.0, 1.0);
+  if (s < 0.5) {
+    return mix(u.faceLo.rgb, u.faceMid.rgb, s * 2.0);
+  }
+  return mix(u.faceMid.rgb, u.faceHi.rgb, (s - 0.5) * 2.0);
+}
+
 // 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.
 struct VSOut {
@@ -282,10 +161,20 @@ fn fs_main(in: VSOut) -> @location(0) vec4f {
   let t = u.u0.x;
   let gridScale = u.u0.y;
 
-  // §5 the per-pixel kernel: warp + bulge the grid coordinate, then two-tier Golus.
-  var g = uv * gridScale;
-  g = g + curlWarp(g, t);
-  g = g + cursorBulge(g);
+  // §5 the per-pixel kernel: CELL-TWIST + cursor-swirl the grid coordinate, then two-tier Golus.
+  // cellTwist rotates each cell about its OWN center (the boxes twist, the lines stay locally
+  // straight — the C3 cure) gated by a traveling Gaussian crest; cursorSwirl twists the cells
+  // about the finger. The Golus dv reads the FINAL twisted coord (the crisp-line fence survives).
+  let g0 = uv * gridScale;
+  // FOLD A — the PRE-twist driver: the face samples height/relief at THIS cc (floor(twisted_g)
+  // at the crest lights a NEIGHBOUR cell). cellTwist rides the SAME driver, so twist + face fuse.
+  let drv = cellDriver(g0, 1.0, t, u.wave.xy, u.wave.z, u.wave.w, u.wave2.x, u.wave2.w);
+  let cc = drv.xy;
+  var g = cellTwist(g0, 1.0, t, u.wave.xy, u.wave.z, u.wave.w, u.wave2.x, u.wave2.y, u.wave2.z, u.wave2.w);
+  if (u.cursor2.y > 0.5) {
+    // bulgeMode (cursor2.x: +repel / −attract) signs the swirl direction.
+    g = cursorSwirl(g, u.cursor.xy, u.cursor.z * u.cursor2.x, u.cursor.w);
+  }
 
   // The screen-space derivative of g (Golus): length(vec2(dpdx, dpdy)) per axis. fwidth-class
   // derivative reads the ACTUAL backing-store pixel (NOT fwidthFine — Compatibility-Mode safe).
@@ -300,86 +189,112 @@ fn fs_main(in: VSOut) -> @location(0) vec4f {
   let major = gridCoverage(g / me, u.grid.y, dv / me);
   let line = max(minor * u.grid.z, major * u.grid.w);
 
+  // ── The FACE (BD.W-PAPERGRID-FACE) — height-lit filled cell interior ──────────────────
+  // Sample height/relief at the pre-twist driver cc (FOLD A); Lambert the ∇H slope against the
+  // fixed cel key-light; squash the inset so the crest face inflates; multi-stop warm-divergent
+  // ramp keyed on mix(shade, h) (FOLD B); the ink through the production OETF (FOLD E).
+  let h     = cellHeight(cc, t, u.wave.xy, u.wave.z, u.wave.w, u.wave2.x, u.wave2.w);
+  let grad  = faceRelief(cc, 1.0, t, u.wave.xy, u.wave.z, u.wave.w, u.wave2.x, u.wave2.w);
+  let n     = normalize(vec3f(-grad * u.face.y, 1.0));
+  let shade = clamp(0.5 + dot(n, normalize(vec3f(u.warp2.zw, 1.0))) * 0.5, 0.0, 1.0);
+  let inset = u.face.w * (1.0 - u.face.z * h);            // squash & stretch
+  let face  = facePlateau(g, inset, dv);
+  let rampT = clamp(shade * 0.5 + h * 0.5, 0.0, 1.0);     // FOLD B — height-keyed crest
+  let faceInk = clamp(linearToSrgb(faceRamp(rampT)), vec3f(0.0), vec3f(1.0));
+  let faceA = face * u.face.x * u.field.x;                // FOLD D — one field-blend scalar
+
   let col = clamp(linearToSrgb(u.line.rgb), vec3f(0.0), vec3f(1.0));
   let hasBg = u.field.y;
   if (hasBg > 0.5) {
-    // opaque ground: composite the ink over the themed bg.
+    // opaque ground: the face fills the cell, the ink over the themed bg, the line on top.
     let bg = clamp(linearToSrgb(u.bg.rgb), vec3f(0.0), vec3f(1.0));
+    let base = mix(bg, faceInk, faceA);
     let a = line * u.field.x;
-    let outRgb = mix(bg, col, a);
+    let outRgb = mix(base, col, a);
     return vec4f(outRgb, 1.0);
   }
-  // transparent ground: the LINE carries the alpha — the page reads through the cells.
-  let a = line * u.field.x;
-  return vec4f(col * a, a);  // premultiplied over transparent
-}
-`, P = {
+  // transparent ground: the FACE composites UNDER the line, the SOURCE-OVER operator in
+  // PREMULTIPLIED space (the page reads through the gutters). faceAlpha:0 → faceA=0 → the face
+  // term vanishes → vec4f(col·line, line) = byte-identical to the HEAD line-only render.
+  let linePremult = (col * line) * u.field.x;            // line layer (the FieldAlpha global subtlety)
+  let lineA = line * u.field.x;
+  let facePremult = faceInk * faceA;                     // face layer premultiplied (faceA folds field.x)
+  let outPremult = linePremult + facePremult * (1.0 - lineA);
+  let a = lineA + faceA * (1.0 - lineA);
+  return vec4f(outPremult, a);                           // premultiplied over transparent
+}
+`, A = {
 	u0: 0,
-	warp: 4,
+	face: 4,
 	warp2: 8,
 	grid: 12,
 	field: 16,
 	cursor: 20,
 	cursor2: 24,
 	line: 28,
-	bg: 32
+	bg: 32,
+	wave: 36,
+	wave2: 40,
+	faceLo: 44,
+	faceMid: 48,
+	faceHi: 52
 };
-function F() {
-	let e = /* @__PURE__ */ new ArrayBuffer(144);
+function j() {
+	let e = /* @__PURE__ */ new ArrayBuffer(224);
 	return {
 		buffer: e,
 		f32: new Float32Array(e)
 	};
 }
-function I(e, t, n, r, i, a) {
-	let { f32: o } = e, c = M(i, t.cellSize);
-	o[P.u0 + 0] = n, o[P.u0 + 1] = c, o[P.u0 + 2] = t.cellSize, o[P.u0 + 3] = t.majorEvery;
-	let l = t.waveScale, u = t.waveScale * 1.7, d = t.waveSpeed, f = t.waveSpeed * .6;
-	o[P.warp + 0] = l, o[P.warp + 1] = d, o[P.warp + 2] = u, o[P.warp + 3] = f, o[P.warp2 + 0] = t.waveAmplitude, o[P.warp2 + 1] = r, o[P.warp2 + 2] = 0, o[P.warp2 + 3] = 0;
-	let p = Math.max(t.cellSize, 1), m = t.lineWidth / p, h = t.lineWidth * 1.6 / p;
-	o[P.grid + 0] = m, o[P.grid + 1] = h, o[P.grid + 2] = t.minorAlpha, o[P.grid + 3] = t.majorAlpha;
-	let g = t.background === "transparent" ? 0 : 1;
-	o[P.field + 0] = t.fieldAlpha, o[P.field + 1] = g, o[P.field + 2] = 0, o[P.field + 3] = 0, o[P.cursor + 0] = a.x, o[P.cursor + 1] = a.y, o[P.cursor + 2] = t.bulgeStrength, o[P.cursor + 3] = t.bulgeRadius, o[P.cursor2 + 0] = t.bulgeMode === "attract" ? -1 : 1, o[P.cursor2 + 1] = +!!t.interactive, o[P.cursor2 + 2] = 0, o[P.cursor2 + 3] = 0;
-	let _ = s(t.lineColor);
-	if (o[P.line + 0] = _[0], o[P.line + 1] = _[1], o[P.line + 2] = _[2], o[P.line + 3] = 0, t.background === "transparent") o[P.bg + 0] = 0, o[P.bg + 1] = 0, o[P.bg + 2] = 0, o[P.bg + 3] = 0;
+function M(e, t, n, r, i, a, o) {
+	let { f32: c } = e, l = f(i, t.cellSize);
+	c[A.u0 + 0] = n, c[A.u0 + 1] = l, c[A.u0 + 2] = t.cellSize, c[A.u0 + 3] = t.majorEvery, c[A.face + 0] = t.faceAlpha, c[A.face + 1] = t.faceRelief, c[A.face + 2] = t.squashK, c[A.face + 3] = t.baseInset, c[A.warp2 + 0] = 0, c[A.warp2 + 1] = r, c[A.warp2 + 2] = t.lightDir[0], c[A.warp2 + 3] = t.lightDir[1];
+	let u = Math.max(t.cellSize, 1), d = t.lineWidth / u, p = t.lineWidth * 1.6 / u;
+	c[A.grid + 0] = d, c[A.grid + 1] = p, c[A.grid + 2] = t.minorAlpha, c[A.grid + 3] = t.majorAlpha;
+	let m = t.background === "transparent" ? 0 : 1;
+	c[A.field + 0] = t.fieldAlpha, c[A.field + 1] = m, c[A.field + 2] = 0, c[A.field + 3] = 0, c[A.cursor + 0] = a.x, c[A.cursor + 1] = a.y, c[A.cursor + 2] = t.bulgeStrength, c[A.cursor + 3] = t.bulgeRadius, c[A.cursor2 + 0] = t.bulgeMode === "attract" ? -1 : 1, c[A.cursor2 + 1] = +!!t.interactive, c[A.cursor2 + 2] = 0, c[A.cursor2 + 3] = 0;
+	let h = s(t.lineColor);
+	if (c[A.line + 0] = h[0], c[A.line + 1] = h[1], c[A.line + 2] = h[2], c[A.line + 3] = 0, t.background === "transparent") c[A.bg + 0] = 0, c[A.bg + 1] = 0, c[A.bg + 2] = 0, c[A.bg + 3] = 0;
 	else {
 		let e = s(t.background);
-		o[P.bg + 0] = e[0], o[P.bg + 1] = e[1], o[P.bg + 2] = e[2], o[P.bg + 3] = 0;
+		c[A.bg + 0] = e[0], c[A.bg + 1] = e[1], c[A.bg + 2] = e[2], c[A.bg + 3] = 0;
 	}
-	return e;
+	c[A.wave + 0] = t.waveDir[0], c[A.wave + 1] = t.waveDir[1], c[A.wave + 2] = t.waveK, c[A.wave + 3] = t.waveOmega, c[A.wave2 + 0] = t.waveSigma, c[A.wave2 + 1] = t.twistMax, c[A.wave2 + 2] = t.shearMax, c[A.wave2 + 3] = o;
+	let g = s(t.faceWarmLo), _ = s(t.faceWarmMid), v = s(t.faceWarmHi);
+	return c[A.faceLo + 0] = g[0], c[A.faceLo + 1] = g[1], c[A.faceLo + 2] = g[2], c[A.faceLo + 3] = 0, c[A.faceMid + 0] = _[0], c[A.faceMid + 1] = _[1], c[A.faceMid + 2] = _[2], c[A.faceMid + 3] = 0, c[A.faceHi + 0] = v[0], c[A.faceHi + 1] = v[1], c[A.faceHi + 2] = v[2], c[A.faceHi + 3] = 0, e;
 }
 //#endregion
 //#region src/components/custom/paper-grid/composables/paperGridWGPUSetup.ts
-var L = 64, R = 8, z = 2;
-function B(e) {
-	let { canvas: t, config: n, getCursor: r, shouldContinue: i, onFrame: o } = e;
-	return function(e, s, c) {
-		let l = e.createShaderModule({
+var N = 64, P = 8, F = 2;
+function I(e) {
+	let { canvas: t, config: n, getCursor: r, getAmp: i, shouldContinue: o, onFrame: s } = e;
+	return function(e, c, l) {
+		let u = e.createShaderModule({
 			label: "[PaperGrid] paper-grid.wgsl",
-			code: N
-		}), u = F(), d = e.createBuffer({
+			code: k
+		}), d = j(), f = e.createBuffer({
 			label: "[PaperGrid] uniforms",
-			size: u.buffer.byteLength,
-			usage: L | R
-		}), f = e.createBindGroupLayout({
+			size: d.buffer.byteLength,
+			usage: N | P
+		}), p = e.createBindGroupLayout({
 			label: "[PaperGrid] bgl",
 			entries: [{
 				binding: 0,
-				visibility: z,
+				visibility: F,
 				buffer: { type: "uniform" }
 			}]
-		}), p = e.createRenderPipeline({
+		}), m = e.createRenderPipeline({
 			label: "[PaperGrid] pipeline",
-			layout: e.createPipelineLayout({ bindGroupLayouts: [f] }),
+			layout: e.createPipelineLayout({ bindGroupLayouts: [p] }),
 			vertex: {
-				module: l,
+				module: u,
 				entryPoint: "vs_main"
 			},
 			fragment: {
-				module: l,
+				module: u,
 				entryPoint: "fs_main",
 				targets: [{
-					format: c,
+					format: l,
 					blend: {
 						color: {
 							srcFactor: "one",
@@ -395,24 +310,24 @@ function B(e) {
 				}]
 			},
 			primitive: { topology: "triangle-list" }
-		}), m = e.createBindGroup({
+		}), h = e.createBindGroup({
 			label: "[PaperGrid] bg",
-			layout: f,
+			layout: p,
 			entries: [{
 				binding: 0,
-				resource: { buffer: d }
+				resource: { buffer: f }
 			}]
 		});
-		function h() {
+		function g() {
 			let e = a(), n = t.clientWidth || 320, r = t.clientHeight || 320, i = Math.max(1, Math.round(n * e)), o = Math.max(1, Math.round(r * e));
 			(t.width !== i || t.height !== o) && (t.width = i, t.height = o);
 		}
-		function g(i) {
-			o?.(i);
-			let c = t.clientWidth || 320, l = t.clientHeight || 320;
-			I(u, n, i, c / Math.max(l, 1), t.height || Math.round(l * a()), r()), e.queue.writeBuffer(d, 0, u.buffer);
-			let f = e.createCommandEncoder({ label: "[PaperGrid] frame" }), h = s.getCurrentTexture().createView(), g = f.beginRenderPass({ colorAttachments: [{
-				view: h,
+		function _(o) {
+			s?.(o);
+			let l = t.clientWidth || 320, u = t.clientHeight || 320;
+			M(d, n, o, l / Math.max(u, 1), t.height || Math.round(u * a()), r(), i()), e.queue.writeBuffer(f, 0, d.buffer);
+			let p = e.createCommandEncoder({ label: "[PaperGrid] frame" }), g = c.getCurrentTexture().createView(), _ = p.beginRenderPass({ colorAttachments: [{
+				view: g,
 				clearValue: {
 					r: 0,
 					g: 0,
@@ -422,21 +337,21 @@ function B(e) {
 				loadOp: "clear",
 				storeOp: "store"
 			}] });
-			g.setPipeline(p), g.setBindGroup(0, m), g.draw(3, 1, 0, 0), g.end(), e.queue.submit([f.finish()]);
+			_.setPipeline(m), _.setBindGroup(0, h), _.draw(3, 1, 0, 0), _.end(), e.queue.submit([p.finish()]);
 		}
 		return {
-			frame: g,
-			shouldContinue: i,
-			resize: h,
+			frame: _,
+			shouldContinue: o,
+			resize: g,
 			teardown: () => {
-				d.destroy();
+				f.destroy();
 			}
 		};
 	};
 }
 //#endregion
 //#region src/components/custom/paper-grid/shaders/paper-grid.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 L = "#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}", R = `#version 300 es
 precision highp float;
 
 #define TAU 6.283185307179586
@@ -453,13 +368,32 @@ uniform float uAmplitude;
 uniform vec4  uGrid;          // (targetWidth, targetWidthMajor, minorAlpha, majorAlpha)
 uniform float uFieldAlpha;
 uniform float uHasBackground;
-uniform vec4  uCursor;        // (cursorX, cursorY, bulgeStrength, bulgeRadius)
-uniform float uBulgeMode;     // +1 repel / −1 attract
+uniform vec4  uCursor;        // (cursorX, cursorY, swirlStrength, swirlRadius)
+uniform float uBulgeMode;     // +1 repel / −1 attract (signs the swirl)
+uniform float uInteractive;   // 1 = cursor swirl on
+uniform vec4  uWave;          // (waveDirX, waveDirY, waveK, waveOmega)
+uniform vec4  uWave2;         // (waveSigma, twistMax, shearMax, amp)
 uniform vec3  uLineColor;     // linear-sRGB ink
 uniform vec3  uBg;            // linear-sRGB themed bg
+// ── The FACE (BD.W-PAPERGRID-FACE) — the height-lit filled cell interior ──
+uniform vec4  uFace;          // (faceAlpha, faceRelief, squashK, baseInset)
+uniform vec2  uLightDir;      // the cel key-light direction
+uniform vec3  uFaceLo;        // linear-sRGB rose-umber trough (FOLD B, 3-stop)
+uniform vec3  uFaceMid;       // linear-sRGB ember-amber mid
+uniform vec3  uFaceHi;        // linear-sRGB warm-wheat crest
 
 ${r}
 
+// The 3-stop warm-divergent FACE ramp (FOLD B — height-keyed, NOT a 2-point mid-park). All stops
+// warm hue ∈ [20,90]; linear-space (the OETF runs in main, FOLD E).
+vec3 faceRamp(float rampT) {
+  float s = clamp(rampT, 0.0, 1.0);
+  if (s < 0.5) {
+    return mix(uFaceLo, uFaceMid, s * 2.0);
+  }
+  return mix(uFaceMid, uFaceHi, (s - 0.5) * 2.0);
+}
+
 // The shared divergence-free 2D-curl operator (flow.glsl.ts) — the prototype declares
 // potentialFBM; the host defines its BODY below the splice (GLSL forward-declaration).
 ${i}
@@ -510,28 +444,11 @@ float potentialFBM(vec2 p) {
   return v;
 }
 
-// ── §3 The global curl-flow domain warp (transcribes paperGrid.ts curlWarp) ──
-vec2 curlWarp(vec2 g, float t) {
-  float warpScale = uWarp.x;
-  float warpSpeed = uWarp.y;
-  float warpScale2 = uWarp.z;
-  float warpSpeed2 = uWarp.w;
-  vec2 a = curlFBM(vec2(g.x * warpScale + t * warpSpeed, g.y * warpScale + t * warpSpeed));
-  vec2 b = curlFBM(vec2(g.x * warpScale2 - t * warpSpeed2, g.y * warpScale2 - t * warpSpeed2));
-  return vec2(a.x * uAmplitude + b.x * uAmplitude * 0.5, a.y * uAmplitude + b.y * uAmplitude * 0.5);
-}
-
-// ── §4 The local pointer bulge (transcribes paperGrid.ts cursorBulge) ──
-vec2 cursorBulge(vec2 g) {
-  vec2 cursor = uCursor.xy;
-  float strength = uCursor.z * uBulgeMode;  // bulgeStrength × bulgeMode (+repel / −attract)
-  float radius = max(uCursor.w, 1e-4);
-  vec2 toC = g - cursor;
-  float d = length(toC);
-  float bulge = strength * exp(-(d * d) / (2.0 * radius * radius));
-  if (d < 1e-5) return vec2(0.0);
-  return (toC / d) * bulge;
-}
+// The shared traveling-wave CELL-WARP chunk (waveField.glsl.ts — cellTwist/cursorSwirl/
+// travelingEnvelope; spliced AFTER valueNoise + potentialFBM bodies + the curlFBM chunk).
+// paper-grid + concentric share this EXACTLY (the C3 cure: the boxes twist about their own
+// center, the lines stay locally straight — never the retired LINE-warp).
+${u}
 
 // ── §1 The Ben Golus derivative-AA grid coverage (transcribes paperGrid.ts gridCoverage) ──
 float gridCoverage(vec2 g, float targetWidth, vec2 uvDeriv) {
@@ -548,10 +465,19 @@ void main() {
   float aspect = max(uAspect, 1e-4);
   vec2 uv = vec2(vUv.x * aspect, vUv.y);
 
-  // §5 the per-pixel kernel: warp + bulge the grid coordinate, then two-tier Golus.
-  vec2 g = uv * uGridScale;
-  g += curlWarp(g, uTime);
-  g += cursorBulge(g);
+  // §5 the per-pixel kernel: CELL-TWIST + cursor-swirl the grid coordinate, then two-tier Golus.
+  // cellTwist rotates each cell about its OWN center (the boxes twist, the lines stay locally
+  // straight — the C3 cure) gated by a traveling Gaussian crest; cursorSwirl twists the cells
+  // about the finger. The Golus dv reads the FINAL twisted coord (the crisp-line fence survives).
+  vec2 g0 = uv * uGridScale;
+  // FOLD A — the PRE-twist driver: the face samples height/relief at THIS cc (floor(twisted_g)
+  // at the crest lights a NEIGHBOUR cell). cellTwist rides the SAME driver, so twist + face fuse.
+  vec3 drv = cellDriver(g0, 1.0, uTime, uWave.xy, uWave.z, uWave.w, uWave2.x, uWave2.w);
+  vec2 cc = drv.xy;
+  vec2 g = cellTwist(g0, 1.0, uTime, uWave.xy, uWave.z, uWave.w, uWave2.x, uWave2.y, uWave2.z, uWave2.w);
+  if (uInteractive > 0.5) {
+    g = cursorSwirl(g, uCursor.xy, uCursor.z * uBulgeMode, uCursor.w);
+  }
 
   // The screen-space derivative of g (Golus): length(vec2(dFdx, dFdy)) per axis (the actual
   // backing-store pixel — NOT a CSS sub-pixel, the blur-kill).
@@ -565,19 +491,41 @@ void main() {
   float major = gridCoverage(g / me, uGrid.y, dv / me);
   float line = max(minor * uGrid.z, major * uGrid.w);
 
+  // ── The FACE (BD.W-PAPERGRID-FACE) — height-lit filled cell interior ──────────────────
+  // Sample height/relief at the pre-twist driver cc (FOLD A); Lambert the ∇H slope against the
+  // fixed cel key-light; squash the inset so the crest face inflates; multi-stop warm-divergent
+  // ramp keyed on mix(shade, h) (FOLD B); the ink through the production OETF (FOLD E).
+  float h      = cellHeight(cc, uTime, uWave.xy, uWave.z, uWave.w, uWave2.x, uWave2.w);
+  vec2  grad   = faceRelief(cc, 1.0, uTime, uWave.xy, uWave.z, uWave.w, uWave2.x, uWave2.w);
+  vec3  n      = normalize(vec3(-grad * uFace.y, 1.0));
+  float shade  = clamp(0.5 + dot(n, normalize(vec3(uLightDir, 1.0))) * 0.5, 0.0, 1.0);
+  float inset  = uFace.w * (1.0 - uFace.z * h);            // squash & stretch
+  float face   = facePlateau(g, inset, dv);
+  float rampT  = clamp(shade * 0.5 + h * 0.5, 0.0, 1.0);   // FOLD B — height-keyed crest
+  vec3  faceInk = clamp(linearToSrgb(faceRamp(rampT)), vec3(0.0), vec3(1.0));
+  float faceA  = face * uFace.x * uFieldAlpha;             // FOLD D — one field-blend scalar
+
   vec3 col = clamp(linearToSrgb(uLineColor), vec3(0.0), vec3(1.0));
   if (uHasBackground > 0.5) {
     vec3 bg = clamp(linearToSrgb(uBg), vec3(0.0), vec3(1.0));
+    vec3 base = mix(bg, faceInk, faceA);
     float a = line * uFieldAlpha;
-    fragColor = vec4(mix(bg, col, a), 1.0);
+    fragColor = vec4(mix(base, col, a), 1.0);
     return;
   }
-  float a = line * uFieldAlpha;
-  fragColor = vec4(col * a, a);  // premultiplied over transparent
+  // transparent ground: the FACE composites UNDER the line, the SOURCE-OVER operator in
+  // PREMULTIPLIED space. faceAlpha:0 → faceA=0 → the face term vanishes → vec4(col·line, line) =
+  // byte-identical to the HEAD line-only render.
+  vec3 linePremult = (col * line) * uFieldAlpha;          // line layer (the FieldAlpha subtlety)
+  float lineA = line * uFieldAlpha;
+  vec3 facePremult = faceInk * faceA;                     // face layer premultiplied (faceA folds field)
+  vec3 outPremult = linePremult + facePremult * (1.0 - lineA);
+  float a = lineA + faceA * (1.0 - lineA);
+  fragColor = vec4(outPremult, a);  // premultiplied over transparent
 }`;
 //#endregion
 //#region src/components/custom/paper-grid/composables/paperGridGLSetup.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);
@@ -585,16 +533,16 @@ function U(e, t, n) {
 	}
 	return r;
 }
-function W(e) {
-	let { canvas: t, config: n, getCursor: r, shouldContinue: i, onFrame: o } = e;
+function B(e) {
+	let { canvas: t, config: n, getCursor: r, getAmp: i, shouldContinue: o, onFrame: c } = e;
 	return function(e) {
-		let c = U(e, e.VERTEX_SHADER, V), l = U(e, e.FRAGMENT_SHADER, H), u = e.createProgram();
-		if (e.attachShader(u, c), e.attachShader(u, l), e.linkProgram(u), !e.getProgramParameter(u, e.LINK_STATUS)) throw Error(`[PaperGrid] link failed: ${e.getProgramInfoLog(u)}`);
-		e.deleteShader(c), e.deleteShader(l);
-		let d = e.createVertexArray();
-		e.bindVertexArray(d);
-		let f = e.createBuffer();
-		e.bindBuffer(e.ARRAY_BUFFER, f), e.bufferData(e.ARRAY_BUFFER, new Float32Array([
+		let l = z(e, e.VERTEX_SHADER, L), u = z(e, e.FRAGMENT_SHADER, R), d = e.createProgram();
+		if (e.attachShader(d, l), e.attachShader(d, u), e.linkProgram(d), !e.getProgramParameter(d, e.LINK_STATUS)) throw Error(`[PaperGrid] link failed: ${e.getProgramInfoLog(d)}`);
+		e.deleteShader(l), e.deleteShader(u);
+		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,
@@ -602,144 +550,169 @@ function W(e) {
 			-1,
 			3
 		]), e.STATIC_DRAW);
-		let p = e.getAttribLocation(u, "aPosition");
-		e.enableVertexAttribArray(p), e.vertexAttribPointer(p, 2, e.FLOAT, !1, 0, 0), e.bindVertexArray(null);
-		let m = (t) => e.getUniformLocation(u, t), h = m("uTime"), g = m("uGridScale"), _ = m("uMajorEvery"), v = m("uAspect"), y = m("uWarp"), b = m("uAmplitude"), x = m("uGrid"), S = m("uFieldAlpha"), C = m("uHasBackground"), w = m("uCursor"), T = m("uBulgeMode"), E = m("uLineColor"), D = m("uBg");
-		function O() {
+		let h = e.getAttribLocation(d, "aPosition");
+		e.enableVertexAttribArray(h), e.vertexAttribPointer(h, 2, e.FLOAT, !1, 0, 0), e.bindVertexArray(null);
+		let g = (t) => e.getUniformLocation(d, t), _ = g("uTime"), v = g("uGridScale"), y = g("uMajorEvery"), b = g("uAspect"), x = g("uGrid"), S = g("uFieldAlpha"), C = g("uHasBackground"), w = g("uCursor"), T = g("uBulgeMode"), E = g("uInteractive"), D = g("uWave"), O = g("uWave2"), k = g("uLineColor"), A = g("uBg"), j = g("uFace"), M = g("uLightDir"), N = g("uFaceLo"), P = g("uFaceMid"), F = g("uFaceHi");
+		function I() {
 			let n = a(), r = t.clientWidth || 320, i = t.clientHeight || 320, o = Math.max(1, Math.round(r * n)), s = Math.max(1, Math.round(i * n));
 			(t.width !== o || t.height !== s) && (t.width = o, t.height = s), e.viewport(0, 0, t.width, t.height);
 		}
-		function k(i) {
-			o?.(i);
-			let c = t.clientWidth || 320, l = t.clientHeight || 320, f = c / Math.max(l, 1), p = M(t.height || Math.round(l * a()), n.cellSize);
-			e.useProgram(u), e.bindVertexArray(d), 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(h, i), e.uniform1f(g, p), e.uniform1f(_, n.majorEvery), e.uniform1f(v, f);
-			let m = n.waveScale, O = n.waveScale * 1.7, k = n.waveSpeed, A = n.waveSpeed * .6;
-			e.uniform4f(y, m, k, O, A), e.uniform1f(b, n.waveAmplitude);
-			let j = Math.max(n.cellSize, 1), N = n.lineWidth / j, P = n.lineWidth * 1.6 / j;
-			e.uniform4f(x, N, P, n.minorAlpha, n.majorAlpha), e.uniform1f(S, n.fieldAlpha);
-			let F = r();
-			e.uniform4f(w, F.x, F.y, n.bulgeStrength, n.bulgeRadius), e.uniform1f(T, n.bulgeMode === "attract" ? -1 : 1);
-			let I = s(n.lineColor);
-			if (e.uniform3f(E, I[0], I[1], I[2]), n.background === "transparent") e.uniform1f(C, 0), e.uniform3f(D, 0, 0, 0);
+		function B(o) {
+			c?.(o);
+			let l = t.clientWidth || 320, u = t.clientHeight || 320, m = l / Math.max(u, 1), h = f(t.height || Math.round(u * a()), n.cellSize);
+			e.useProgram(d), 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.uniform1f(_, o), e.uniform1f(v, h), e.uniform1f(y, n.majorEvery), e.uniform1f(b, m), e.uniform4f(D, n.waveDir[0], n.waveDir[1], n.waveK, n.waveOmega), e.uniform4f(O, n.waveSigma, n.twistMax, n.shearMax, i()), e.uniform1f(E, +!!n.interactive);
+			let g = Math.max(n.cellSize, 1), I = n.lineWidth / g, L = n.lineWidth * 1.6 / g;
+			e.uniform4f(x, I, L, n.minorAlpha, n.majorAlpha), e.uniform1f(S, n.fieldAlpha);
+			let R = r();
+			e.uniform4f(w, R.x, R.y, n.bulgeStrength, n.bulgeRadius), e.uniform1f(T, n.bulgeMode === "attract" ? -1 : 1);
+			let z = s(n.lineColor);
+			e.uniform3f(k, z[0], z[1], z[2]), e.uniform4f(j, n.faceAlpha, n.faceRelief, n.squashK, n.baseInset), e.uniform2f(M, n.lightDir[0], n.lightDir[1]);
+			let B = s(n.faceWarmLo), V = s(n.faceWarmMid), H = s(n.faceWarmHi);
+			if (e.uniform3f(N, B[0], B[1], B[2]), e.uniform3f(P, V[0], V[1], V[2]), e.uniform3f(F, H[0], H[1], H[2]), n.background === "transparent") e.uniform1f(C, 0), e.uniform3f(A, 0, 0, 0);
 			else {
 				e.uniform1f(C, 1);
 				let t = s(n.background);
-				e.uniform3f(D, t[0], t[1], t[2]);
+				e.uniform3f(A, t[0], t[1], t[2]);
 			}
 			e.drawArrays(e.TRIANGLES, 0, 3), e.bindVertexArray(null);
 		}
 		return {
-			frame: k,
-			shouldContinue: i,
-			resize: O,
+			frame: B,
+			shouldContinue: o,
+			resize: I,
 			teardown: () => {
-				e.deleteProgram(u), e.deleteVertexArray(d), e.deleteBuffer(f);
+				e.deleteProgram(d), e.deleteVertexArray(p), e.deleteBuffer(m);
 			}
 		};
 	};
 }
 //#endregion
 //#region src/components/custom/paper-grid/composables/usePaperGrid.ts
-function G(e, n) {
+function V(e, n) {
 	let { config: r } = n, i = n.mode ?? "live", s = t({ respectReducedMotion: r.respectReducedMotion }), c = {
 		x: 1e6,
 		y: 1e6
-	}, l = () => c, u = 0, d = null;
-	function f(t) {
-		let n = u > 0 ? (t - u) * 1e3 : 16.7;
-		if (u = t, s.tick(n), !r.interactive || !s.active.value) {
+	}, l = () => c, u = 0, d = () => u, p = 0, m = null;
+	function h(t) {
+		let n = p > 0 ? (t - p) * 1e3 : 16.7;
+		if (p = t, s.tick(n), m?.reducedMotion ? u = 0 : (u += (1.06 - u) * .04, u > 1 && (u = 1 + (u - 1) * .85)), !r.interactive || !s.active.value) {
 			c = {
 				x: 1e6,
 				y: 1e6
 			};
 			return;
 		}
-		let i = e.value, o = i?.clientHeight || 320, l = (i?.clientWidth || 320) / Math.max(o, 1), d = M(i?.height || Math.round(o * a()) || 320, r.cellSize), f = s.smoothedPosition.value, p = s.velocity.value, m = s.burst.value, h = (f.x * 2 - 1) * l, g = -(f.y * 2 - 1), _ = .12 + Math.min(.4, m);
+		let i = e.value, o = i?.clientHeight || 320, l = (i?.clientWidth || 320) / Math.max(o, 1), d = f(i?.height || Math.round(o * a()) || 320, r.cellSize), h = s.smoothedPosition.value, g = s.velocity.value, _ = s.burst.value, v = (h.x * 2 - 1) * l, y = -(h.y * 2 - 1), b = .12 + Math.min(.4, _);
 		c = {
-			x: (h + p.x * _) * d,
-			y: (g - p.y * _) * d
+			x: (v + g.x * b) * d,
+			y: (y - g.y * b) * d
 		};
 	}
-	let p = () => {
-		s.onPointerEnter(), r.interactive && d?.wake();
-	}, m = (e) => {
-		s.onPointerMove(e), r.interactive && d?.wake();
-	}, g = (e) => e.parentElement ?? e;
-	function _(e) {
-		let t = g(e);
-		t.addEventListener("pointermove", m), t.addEventListener("pointerenter", p), t.addEventListener("pointerleave", s.onPointerLeave);
+	let g = () => {
+		s.onPointerEnter(), r.interactive && m?.wake();
+	}, _ = (e) => {
+		s.onPointerMove(e), r.interactive && m?.wake();
+	}, v = (e) => e.parentElement ?? e;
+	function y(e) {
+		let t = v(e);
+		t.addEventListener("pointermove", _), t.addEventListener("pointerenter", g), t.addEventListener("pointerleave", s.onPointerLeave);
 	}
-	function v(e) {
-		let t = g(e);
-		t.removeEventListener("pointermove", m), t.removeEventListener("pointerenter", p), t.removeEventListener("pointerleave", s.onPointerLeave);
+	function b(e) {
+		let t = v(e);
+		t.removeEventListener("pointermove", _), t.removeEventListener("pointerenter", g), t.removeEventListener("pointerleave", s.onPointerLeave);
 	}
-	let y = () => {
+	let x = () => {
 		let t = e.value;
-		return t ? (d || (_(t), d = o(t, {
+		return t ? (m || (y(t), m = o(t, {
 			mode: i,
 			respectReducedMotion: r.respectReducedMotion,
-			setupWGPU: B({
+			setupWGPU: I({
 				canvas: t,
 				config: r,
 				getCursor: l,
+				getAmp: d,
 				shouldContinue: () => !0,
-				onFrame: f
+				onFrame: h
 			}),
-			setupGL: W({
+			setupGL: B({
 				canvas: t,
 				config: r,
 				getCursor: l,
+				getAmp: d,
 				shouldContinue: () => !0,
-				onFrame: f
+				onFrame: h
 			})
-		}), d.armAsync()), d) : null;
+		}), m.armAsync()), m) : null;
 	};
-	queueMicrotask(() => y());
-	let b = {
+	queueMicrotask(() => x());
+	let S = {
 		get backend() {
-			return y()?.backend ?? "webgpu";
+			return x()?.backend ?? "webgpu";
 		},
-		pause: () => y()?.suspend("manual"),
-		resume: () => y()?.resume("manual"),
-		wake: () => y()?.wake(),
-		renderAt: (e) => y()?.renderAt(e),
+		pause: () => x()?.suspend("manual"),
+		resume: () => x()?.resume("manual"),
+		wake: () => x()?.wake(),
+		renderAt: (e) => x()?.renderAt(e),
 		get reducedMotion() {
-			return d?.reducedMotion ?? !1;
+			return m?.reducedMotion ?? !1;
 		},
 		dispose: () => {
 			let t = e.value;
-			t && v(t), s.dispose(), d?.dispose();
+			t && b(t), s.dispose(), m?.dispose();
 		}
 	};
-	return h(() => b.dispose()), b;
+	return w(() => S.dispose()), S;
 }
 //#endregion
 //#region src/components/custom/paper-grid/constants.ts
-var K = 16, q = {
+var H = 16, U = {
 	L: .62,
 	C: .05,
 	h: 62
-}, J = {
+}, W = {
+	L: .44,
+	C: .07,
+	h: 32
+}, G = {
+	L: .66,
+	C: .12,
+	h: 58
+}, K = {
+	L: .9,
+	C: .1,
+	h: 84
+}, q = {
 	cellSize: 64,
 	majorEvery: 5,
-	minorAlpha: .04,
-	majorAlpha: .11,
+	minorAlpha: .12,
+	majorAlpha: .22,
 	lineWidth: 1,
-	waveAmplitude: .1,
-	waveScale: .5,
-	waveSpeed: .15,
+	twistMax: .62,
+	shearMax: .26,
+	waveDir: [.92, .39],
+	waveK: .62,
+	waveOmega: 1.05,
+	waveSigma: .42,
 	fieldAlpha: 1,
-	bulgeStrength: .12,
-	bulgeRadius: 3,
+	bulgeStrength: .9,
+	bulgeRadius: 2.5,
 	bulgeMode: "repel",
-	lineColor: q,
+	lineColor: U,
+	faceAlpha: 0,
+	faceRelief: 2.6,
+	squashK: .42,
+	baseInset: .14,
+	faceWarmLo: W,
+	faceWarmMid: G,
+	faceWarmHi: K,
+	lightDir: [.6, .8],
 	background: "transparent",
 	interactive: !0,
 	respectReducedMotion: !0
-}, Y = /* @__PURE__ */ e(/* @__PURE__ */ f({
+}, J = /* @__PURE__ */ e(/* @__PURE__ */ x({
 	__name: "PaperGrid",
 	props: {
-		config: { default: () => J },
+		config: { default: () => q },
 		paused: {
 			type: Boolean,
 			default: !1
@@ -747,9 +720,9 @@ var K = 16, q = {
 	},
 	emits: ["update:paused"],
 	setup(e, { expose: t }) {
-		let n = v("wrapperRef"), r = v("canvasRef"), i = _({ ...e.config });
-		y(() => e.config, (e) => Object.assign(i, e), { deep: !0 }), m(() => {
-			if (e.config.lineColor === J.lineColor) {
+		let n = D("wrapperRef"), r = D("canvasRef"), i = E({ ...e.config });
+		O(() => e.config, (e) => Object.assign(i, e), { deep: !0 }), C(() => {
+			if (e.config.lineColor === q.lineColor) {
 				let e = n.value;
 				if (e) {
 					let t = getComputedStyle(e).getPropertyValue("--foreground").trim();
@@ -759,9 +732,9 @@ var K = 16, q = {
 				}
 			}
 		});
-		let a = G(r, { config: i });
-		y(() => e.paused, (e) => e ? a.pause() : a.resume(), { immediate: !0 });
-		let o = l(() => {
+		let a = V(r, { config: i });
+		O(() => e.paused, (e) => e ? a.pause() : a.resume(), { immediate: !0 });
+		let o = v(() => {
 			let t = e.config.background;
 			if (t !== "transparent") return `oklch(${t.L} ${t.C} ${t.h})`;
 		});
@@ -770,12 +743,12 @@ var K = 16, q = {
 			resume: a.resume,
 			wake: a.wake,
 			renderAt: a.renderAt
-		}), (e, t) => (g(), u("div", {
+		}), (e, t) => (T(), y("div", {
 			ref_key: "wrapperRef",
 			ref: n,
 			class: "paper-grid-wrapper",
-			style: p(o.value ? { background: o.value } : void 0)
-		}, [d("canvas", {
+			style: S(o.value ? { background: o.value } : void 0)
+		}, [b("canvas", {
 			ref_key: "canvasRef",
 			ref: r,
 			class: "paper-grid-canvas",
@@ -785,4 +758,4 @@ var K = 16, q = {
 	}
 }), [["__scopeId", "data-v-fc108d7d"]]);
 //#endregion
-export { b as CURL_EPS, J as DEFAULT_PAPER_GRID_CONFIG, K as PAPER_GRID_MAX_MAJOR_EVERY, Y as PaperGrid, q as WARM_IDENTITY_INK, T as curlFBM, E as curlWarp, D as cursorBulge, A as gridCoverage, M as gridScaleFor, w as potentialFBM, j as samplePaperGrid, G as usePaperGrid };
+export { _ as CURL_EPS, q as DEFAULT_PAPER_GRID_CONFIG, K as FACE_WARM_HI, W as FACE_WARM_LO, G as FACE_WARM_MID, H as PAPER_GRID_MAX_MAJOR_EVERY, J as PaperGrid, U as WARM_IDENTITY_INK, p as curlFBM, g as gridCoverage, f as gridScaleFor, l as potentialFBM, m as samplePaperGrid, V as usePaperGrid };