@mkbabb/glass-ui 4.0.0 → 4.1.0

package/dist/paper-grid.js

@@ -0,0 +1,788 @@
+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
+//#region src/components/custom/paper-grid/shaders/paper-grid.wgsl.ts
+var N = `
+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)
+  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: vec4<f32>,
+  // cursor2: (uBulgeMode, uInteractive, _pad, _pad)
+  cursor2: vec4<f32>,
+  // line: (uLineColor.rgb (linear), _pad)
+  line: vec4<f32>,
+  // bg: (uBg.rgb (linear), _pad)
+  bg: vec4<f32>,
+};
+
+@group(0) @binding(0) var<uniform> u: PaperGridUniforms;
+
+${n}
+
+// ── The host noise basis (transcribes paperGrid.ts hash21/valueNoise/potentialFBM) ──
+// A quintic-faded 2D value-noise fbm potential — the SAME basis the dot-flow-field carries
+// (so the suite speaks ONE noise basis). DECLARED ABOVE the curl splice (WGSL has no forward
+// declaration — a function may only call one declared earlier).
+fn hash21(x: f32, y: f32) -> f32 {
+  var px = fract(x * 0.1031);
+  var py = fract(y * 0.1031);
+  var pz = fract(x * 0.1031);
+  let d = px * (py + 33.33) + py * (pz + 33.33) + pz * (px + 33.33);
+  px = px + d;
+  py = py + d;
+  pz = pz + d;
+  return fract((px + py) * pz);
+}
+
+fn valueNoise(x: f32, y: f32) -> f32 {
+  let ix = floor(x);
+  let iy = floor(y);
+  let fx = x - ix;
+  let fy = y - iy;
+  let ux = fx * fx * fx * (fx * (fx * 6.0 - 15.0) + 10.0);
+  let uy = fy * fy * fy * (fy * (fy * 6.0 - 15.0) + 10.0);
+  let a = hash21(ix, iy);
+  let b = hash21(ix + 1.0, iy);
+  let c = hash21(ix, iy + 1.0);
+  let d2 = hash21(ix + 1.0, iy + 1.0);
+  return mix(mix(a, b, ux), mix(c, d2, ux), uy);
+}
+
+// The 3-octave scalar fbm potential — the host noise basis the curl operator wraps.
+fn potentialFBM(p: vec2f) -> f32 {
+  var v = 0.0;
+  var amp = 0.5;
+  var freq = 1.0;
+  var px = p.x;
+  var py = p.y;
+  for (var i = 0; i < 3; i = i + 1) {
+    v = v + amp * valueNoise(px * freq, py * freq);
+    // FBM_ROT mat2(0.8, 0.6, -0.6, 0.8) — same rotation as the shared chunk.
+    let rx = 0.8 * px - 0.6 * py;
+    let ry = 0.6 * px + 0.8 * py;
+    px = rx;
+    py = ry;
+    freq = freq * 2.0;
+    amp = amp * 0.5;
+  }
+  return v;
+}
+
+// The shared divergence-free 2D-curl operator (flow.wgsl.ts — the FIRST WGSL curl consumer).
+
+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;
+}
+
+// ── §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
+// the per-axis screen-space derivative of g (length(vec2(dpdx, dpdy)) per axis). Returns
+// line coverage [0..1] — exactly N device-pixels wide at ANY DPR/zoom (the blur-kill).
+fn gridCoverage(g: vec2f, targetWidth: f32, uvDeriv: vec2f) -> f32 {
+  // triangle wave per axis: 0 at a line, 1 at the cell center.
+  let gridUV = 1.0 - abs(fract(g) * 2.0 - 1.0);
+  let drawWidth = clamp(vec2f(targetWidth), uvDeriv, vec2f(0.5));
+  let lineAA = uvDeriv * 1.5;
+  // smoothstep with edge0 > edge1 (Golus) → a falling edge.
+  var grid2 = smoothstep(drawWidth + lineAA, drawWidth - lineAA, gridUV);
+  // preserve thin-line intensity where the line is sub-drawWidth.
+  grid2 = grid2 * clamp(vec2f(targetWidth) / max(drawWidth, vec2f(1e-6)), vec2f(0.0), vec2f(1.0));
+  // Moiré suppression: fade toward the average where the cell packs tighter than a pixel.
+  grid2 = mix(grid2, vec2f(targetWidth), clamp(uvDeriv * 2.0 - 1.0, vec2f(0.0), vec2f(1.0)));
+  return max(grid2.x, grid2.y);
+}
+
+// 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 {
+  @builtin(position) pos: vec4f,
+  @location(0) uv: vec2f,  // domain [-1,1]², aspect-corrected x
+};
+
+@vertex
+fn vs_main(@builtin(vertex_index) vi: u32) -> VSOut {
+  var corners = array<vec2f, 3>(
+    vec2f(-1.0, -1.0), vec2f(3.0, -1.0), vec2f(-1.0, 3.0),
+  );
+  let c = corners[vi];
+  var out: VSOut;
+  out.pos = vec4f(c, 0.0, 1.0);
+  out.uv = vec2f(c.x, c.y);
+  return out;
+}
+
+@fragment
+fn fs_main(in: VSOut) -> @location(0) vec4f {
+  let aspect = max(u.warp2.y, 1e-4);
+  // aspect-correct the domain x so the cells read square.
+  let uv = vec2f(in.uv.x * aspect, in.uv.y);
+  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);
+
+  // 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).
+  let dv = vec2f(
+    length(vec2f(dpdx(g.x), dpdy(g.x))),
+    length(vec2f(dpdx(g.y), dpdy(g.y))),
+  );
+
+  let minor = gridCoverage(g, u.grid.x, dv);
+  // The major tier evals at g / majorEvery with its own derivative scaling.
+  let me = max(u.u0.w, 1.0);
+  let major = gridCoverage(g / me, u.grid.y, dv / me);
+  let line = max(minor * u.grid.z, major * u.grid.w);
+
+  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.
+    let bg = clamp(linearToSrgb(u.bg.rgb), vec3f(0.0), vec3f(1.0));
+    let a = line * u.field.x;
+    let outRgb = mix(bg, 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 = {
+	u0: 0,
+	warp: 4,
+	warp2: 8,
+	grid: 12,
+	field: 16,
+	cursor: 20,
+	cursor2: 24,
+	line: 28,
+	bg: 32
+};
+function F() {
+	let e = /* @__PURE__ */ new ArrayBuffer(144);
+	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;
+	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;
+	}
+	return 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({
+			label: "[PaperGrid] paper-grid.wgsl",
+			code: N
+		}), u = F(), d = e.createBuffer({
+			label: "[PaperGrid] uniforms",
+			size: u.buffer.byteLength,
+			usage: L | R
+		}), f = e.createBindGroupLayout({
+			label: "[PaperGrid] bgl",
+			entries: [{
+				binding: 0,
+				visibility: z,
+				buffer: { type: "uniform" }
+			}]
+		}), p = e.createRenderPipeline({
+			label: "[PaperGrid] pipeline",
+			layout: e.createPipelineLayout({ bindGroupLayouts: [f] }),
+			vertex: {
+				module: l,
+				entryPoint: "vs_main"
+			},
+			fragment: {
+				module: l,
+				entryPoint: "fs_main",
+				targets: [{
+					format: c,
+					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" }
+		}), m = e.createBindGroup({
+			label: "[PaperGrid] bg",
+			layout: f,
+			entries: [{
+				binding: 0,
+				resource: { buffer: d }
+			}]
+		});
+		function h() {
+			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,
+				clearValue: {
+					r: 0,
+					g: 0,
+					b: 0,
+					a: 0
+				},
+				loadOp: "clear",
+				storeOp: "store"
+			}] });
+			g.setPipeline(p), g.setBindGroup(0, m), g.draw(3, 1, 0, 0), g.end(), e.queue.submit([f.finish()]);
+		}
+		return {
+			frame: g,
+			shouldContinue: i,
+			resize: h,
+			teardown: () => {
+				d.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
+precision highp float;
+
+#define TAU 6.283185307179586
+
+in vec2 vUv;
+out vec4 fragColor;
+
+uniform float uTime;
+uniform float uGridScale;
+uniform float uMajorEvery;
+uniform float uAspect;
+uniform vec4  uWarp;          // (warpScale, warpSpeed, warpScale2, warpSpeed2)
+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 vec3  uLineColor;     // linear-sRGB ink
+uniform vec3  uBg;            // linear-sRGB themed bg
+
+${r}
+
+// 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}
+
+// ── The host noise basis (transcribes paperGrid.ts hash21/valueNoise/potentialFBM) ──
+float hash21(float x, float y) {
+  float px = fract(x * 0.1031);
+  float py = fract(y * 0.1031);
+  float pz = fract(x * 0.1031);
+  float d = px * (py + 33.33) + py * (pz + 33.33) + pz * (px + 33.33);
+  px += d;
+  py += d;
+  pz += d;
+  return fract((px + py) * pz);
+}
+
+float valueNoise(float x, float y) {
+  float ix = floor(x);
+  float iy = floor(y);
+  float fx = x - ix;
+  float fy = y - iy;
+  float ux = fx * fx * fx * (fx * (fx * 6.0 - 15.0) + 10.0);
+  float uy = fy * fy * fy * (fy * (fy * 6.0 - 15.0) + 10.0);
+  float a = hash21(ix, iy);
+  float b = hash21(ix + 1.0, iy);
+  float c = hash21(ix, iy + 1.0);
+  float d2 = hash21(ix + 1.0, iy + 1.0);
+  return mix(mix(a, b, ux), mix(c, d2, ux), uy);
+}
+
+// The 3-octave scalar fbm potential — the curl chunk's forward-declared potentialFBM body.
+float potentialFBM(vec2 p) {
+  float v = 0.0;
+  float amp = 0.5;
+  float freq = 1.0;
+  float px = p.x;
+  float py = p.y;
+  for (int i = 0; i < 3; i++) {
+    v += amp * valueNoise(px * freq, py * freq);
+    // FBM_ROT mat2(0.8, 0.6, -0.6, 0.8) — same rotation as the shared chunk.
+    float rx = 0.8 * px - 0.6 * py;
+    float ry = 0.6 * px + 0.8 * py;
+    px = rx;
+    py = ry;
+    freq *= 2.0;
+    amp *= 0.5;
+  }
+  return v;
+}
+
+// ── §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;
+}
+
+// ── §1 The Ben Golus derivative-AA grid coverage (transcribes paperGrid.ts gridCoverage) ──
+float gridCoverage(vec2 g, float targetWidth, vec2 uvDeriv) {
+  vec2 gridUV = 1.0 - abs(fract(g) * 2.0 - 1.0);
+  vec2 drawWidth = clamp(vec2(targetWidth), uvDeriv, vec2(0.5));
+  vec2 lineAA = uvDeriv * 1.5;
+  vec2 grid2 = smoothstep(drawWidth + lineAA, drawWidth - lineAA, gridUV);
+  grid2 *= clamp(vec2(targetWidth) / max(drawWidth, vec2(1e-6)), vec2(0.0), vec2(1.0));
+  grid2 = mix(grid2, vec2(targetWidth), clamp(uvDeriv * 2.0 - 1.0, vec2(0.0), vec2(1.0)));
+  return max(grid2.x, grid2.y);
+}
+
+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);
+
+  // 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).
+  vec2 dv = vec2(
+    length(vec2(dFdx(g.x), dFdy(g.x))),
+    length(vec2(dFdx(g.y), dFdy(g.y)))
+  );
+
+  float minor = gridCoverage(g, uGrid.x, dv);
+  float me = max(uMajorEvery, 1.0);
+  float major = gridCoverage(g / me, uGrid.y, dv / me);
+  float line = max(minor * uGrid.z, major * uGrid.w);
+
+  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));
+    float a = line * uFieldAlpha;
+    fragColor = vec4(mix(bg, col, a), 1.0);
+    return;
+  }
+  float a = line * uFieldAlpha;
+  fragColor = vec4(col * a, a);  // premultiplied over transparent
+}`;
+//#endregion
+//#region src/components/custom/paper-grid/composables/paperGridGLSetup.ts
+function U(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(`[PaperGrid] shader compile failed: ${t}`);
+	}
+	return r;
+}
+function W(e) {
+	let { canvas: t, config: n, getCursor: r, shouldContinue: i, onFrame: o } = 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([
+			-1,
+			-1,
+			3,
+			-1,
+			-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 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);
+			else {
+				e.uniform1f(C, 1);
+				let t = s(n.background);
+				e.uniform3f(D, t[0], t[1], t[2]);
+			}
+			e.drawArrays(e.TRIANGLES, 0, 3), e.bindVertexArray(null);
+		}
+		return {
+			frame: k,
+			shouldContinue: i,
+			resize: O,
+			teardown: () => {
+				e.deleteProgram(u), e.deleteVertexArray(d), e.deleteBuffer(f);
+			}
+		};
+	};
+}
+//#endregion
+//#region src/components/custom/paper-grid/composables/usePaperGrid.ts
+function G(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) {
+			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);
+		c = {
+			x: (h + p.x * _) * d,
+			y: (g - p.y * _) * 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);
+	}
+	function v(e) {
+		let t = g(e);
+		t.removeEventListener("pointermove", m), t.removeEventListener("pointerenter", p), t.removeEventListener("pointerleave", s.onPointerLeave);
+	}
+	let y = () => {
+		let t = e.value;
+		return t ? (d || (_(t), d = o(t, {
+			mode: i,
+			respectReducedMotion: r.respectReducedMotion,
+			setupWGPU: B({
+				canvas: t,
+				config: r,
+				getCursor: l,
+				shouldContinue: () => !0,
+				onFrame: f
+			}),
+			setupGL: W({
+				canvas: t,
+				config: r,
+				getCursor: l,
+				shouldContinue: () => !0,
+				onFrame: f
+			})
+		}), d.armAsync()), d) : null;
+	};
+	queueMicrotask(() => y());
+	let b = {
+		get backend() {
+			return y()?.backend ?? "webgpu";
+		},
+		pause: () => y()?.suspend("manual"),
+		resume: () => y()?.resume("manual"),
+		wake: () => y()?.wake(),
+		renderAt: (e) => y()?.renderAt(e),
+		get reducedMotion() {
+			return d?.reducedMotion ?? !1;
+		},
+		dispose: () => {
+			let t = e.value;
+			t && v(t), s.dispose(), d?.dispose();
+		}
+	};
+	return h(() => b.dispose()), b;
+}
+//#endregion
+//#region src/components/custom/paper-grid/constants.ts
+var K = 16, q = {
+	L: .62,
+	C: .05,
+	h: 62
+}, J = {
+	cellSize: 64,
+	majorEvery: 5,
+	minorAlpha: .04,
+	majorAlpha: .11,
+	lineWidth: 1,
+	waveAmplitude: .1,
+	waveScale: .5,
+	waveSpeed: .15,
+	fieldAlpha: 1,
+	bulgeStrength: .12,
+	bulgeRadius: 3,
+	bulgeMode: "repel",
+	lineColor: q,
+	background: "transparent",
+	interactive: !0,
+	respectReducedMotion: !0
+}, Y = /* @__PURE__ */ e(/* @__PURE__ */ f({
+	__name: "PaperGrid",
+	props: {
+		config: { default: () => J },
+		paused: {
+			type: Boolean,
+			default: !1
+		}
+	},
+	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 e = n.value;
+				if (e) {
+					let t = getComputedStyle(e).getPropertyValue("--foreground").trim();
+					if (t) try {
+						i.lineColor = c(t);
+					} catch {}
+				}
+			}
+		});
+		let a = G(r, { config: i });
+		y(() => e.paused, (e) => e ? a.pause() : a.resume(), { immediate: !0 });
+		let o = l(() => {
+			let t = e.config.background;
+			if (t !== "transparent") return `oklch(${t.L} ${t.C} ${t.h})`;
+		});
+		return t({
+			pause: a.pause,
+			resume: a.resume,
+			wake: a.wake,
+			renderAt: a.renderAt
+		}), (e, t) => (g(), u("div", {
+			ref_key: "wrapperRef",
+			ref: n,
+			class: "paper-grid-wrapper",
+			style: p(o.value ? { background: o.value } : void 0)
+		}, [d("canvas", {
+			ref_key: "canvasRef",
+			ref: r,
+			class: "paper-grid-canvas",
+			"aria-hidden": "true",
+			"data-testid": "paper-grid-canvas"
+		}, null, 512)], 4));
+	}
+}), [["__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 };