@mkbabb/glass-ui 3.2.0 → 3.4.0

package/dist/DialogContent-B61rP8lj.js

@@ -1,93 +0,0 @@
-import { t as e } from "./cn-DJXf4yaB.js";
-import { t } from "./x-C4pz9nbD.js";
-import { t as n } from "./useSpringMount-CnizvZGm.js";
-import { t as r } from "./ModalOverlay-B_CBtqcE.js";
-import { computed as i, createBlock as a, createElementVNode as o, createVNode as s, defineComponent as c, guardReactiveProps as l, mergeProps as u, normalizeProps as d, openBlock as f, renderSlot as p, unref as m, withCtx as h } from "vue";
-import { DialogClose as g, DialogContent as _, DialogPortal as v, DialogRoot as y, injectDialogRootContext as b, useForwardPropsEmits as x } from "reka-ui";
-//#endregion
-//#region src/components/ui/dialog/Dialog.vue
-var S = /* @__PURE__ */ c({
-	__name: "Dialog",
-	props: {
-		open: { type: Boolean },
-		defaultOpen: { type: Boolean },
-		modal: { type: Boolean }
-	},
-	emits: ["update:open"],
-	setup(e, { emit: t }) {
-		let n = x(e, t);
-		return (e, t) => (f(), a(m(y), d(l(m(n))), {
-			default: h(() => [p(e.$slots, "default")]),
-			_: 3
-		}, 16));
-	}
-}), C = "fixed left-1/2 top-1/2 z-modal grid w-full max-w-lg gap-4 p-6", w = "-translate-x-1/2 -translate-y-1/2 duration-[var(--duration-normal)] popover-animate", T = /* @__PURE__ */ c({
-	__name: "DialogContent",
-	props: {
-		forceMount: { type: Boolean },
-		disableOutsidePointerEvents: { type: Boolean },
-		asChild: { type: Boolean },
-		as: {},
-		class: { type: [
-			Boolean,
-			null,
-			String,
-			Object,
-			Array
-		] },
-		variant: { default: "glass" },
-		scrimAnimation: {},
-		spring: { type: [Boolean, String] }
-	},
-	emits: [
-		"escapeKeyDown",
-		"pointerDownOutside",
-		"focusOutside",
-		"interactOutside",
-		"openAutoFocus",
-		"closeAutoFocus"
-	],
-	setup(c, { emit: l }) {
-		let d = c, y = l, S = x(i(() => {
-			let { class: e, variant: t, scrimAnimation: n, spring: r, ...i } = d;
-			return i;
-		}), y), T = i(() => d.variant === "opaque" ? "bg-background border sm:rounded-dialog" : "glass-floating rounded-dialog"), E = d.spring ? b() : null, D = d.spring && E ? n({
-			open: E.open,
-			preset: typeof d.spring == "string" ? d.spring : "smooth"
-		}) : null, O = i(() => {
-			if (!D) return;
-			let e = D.position.value;
-			return {
-				transform: `translate(-50%, -50%) scale(${1 - .05 * e})`,
-				opacity: String(1 - e),
-				animation: "none",
-				transition: "none"
-			};
-		});
-		return (n, i) => (f(), a(m(v), null, {
-			default: h(() => [s(r, {
-				scrim: "glass",
-				animate: "fade",
-				layout: "centered",
-				"scrim-animation": d.scrimAnimation
-			}, null, 8, ["scrim-animation"]), s(m(_), u(m(S), {
-				class: m(e)(C, d.spring ? "" : w, T.value, d.class),
-				style: O.value,
-				"data-spring": d.spring ? typeof d.spring == "string" ? d.spring : "smooth" : void 0
-			}), {
-				default: h(() => [p(n.$slots, "default"), s(m(g), { class: "focus-ring absolute right-4 top-4 rounded-sm opacity-70 transition-opacity hover:opacity-100 disabled:pointer-events-none data-[state=open]:bg-accent data-[state=open]:text-muted-foreground" }, {
-					default: h(() => [s(m(t), { class: "w-4 h-4" }), i[0] ||= o("span", { class: "sr-only" }, "Close", -1)]),
-					_: 1
-				})]),
-				_: 3
-			}, 16, [
-				"class",
-				"style",
-				"data-spring"
-			])]),
-			_: 3
-		}));
-	}
-});
-//#endregion
-export { S as n, T as t };

package/dist/HoverPopover-BlEwqG7S.js

@@ -1,96 +0,0 @@
-import { t as e } from "./cn-DJXf4yaB.js";
-import { i as t } from "./dockContext-DM58L1Jt.js";
-import { Fragment as n, computed as r, createBlock as i, createElementBlock as a, createElementVNode as o, createVNode as s, defineComponent as c, mergeProps as l, openBlock as u, ref as d, renderSlot as f, toDisplayString as p, unref as m, useId as h, watch as g, withCtx as _ } from "vue";
-import { HoverCardContent as v, HoverCardPortal as y, HoverCardRoot as b, HoverCardTrigger as x } from "reka-ui";
-//#region src/components/custom/hover-popover/HoverPopover.vue?vue&type=script&setup=true&lang.ts
-var S = { class: "hover-popover-label" }, C = { class: "hover-popover-label" }, w = /* @__PURE__ */ c({
-	__name: "HoverPopover",
-	props: {
-		content: {},
-		open: { type: Boolean },
-		side: { default: "top" },
-		align: { default: "center" },
-		hoverOpenDelay: { default: 250 },
-		closeDelay: { default: 150 },
-		sideOffset: { default: 6 },
-		class: { type: [
-			Boolean,
-			null,
-			String,
-			Object,
-			Array
-		] },
-		keepDockOpen: {
-			type: Boolean,
-			default: !1
-		},
-		native: {
-			type: Boolean,
-			default: !1
-		}
-	},
-	emits: ["update:open"],
-	setup(c, { emit: w }) {
-		let T = w, E = c, D = r(() => e("z-popover hover-popover-panel popover-animate", E.class)), O = typeof HTMLButtonElement < "u" && "interestForElement" in HTMLButtonElement.prototype, k = r(() => E.native && O), A = `gl-hover-popover-${h() ?? "0"}`, j = d(E.open ?? !1);
-		g(() => E.open, (e) => {
-			typeof e == "boolean" && e !== j.value && (j.value = e);
-		}), g(j, (e) => {
-			T("update:open", e);
-		});
-		function M(e) {
-			let t = e.newState === "open";
-			t !== j.value && (j.value = t);
-		}
-		let N = t(), P = !1;
-		g(j, (e) => {
-			E.keepDockOpen && (e && !P ? (N?.keepOpen(), P = !0) : !e && P && (N?.release(), P = !1));
-		});
-		let F = r(() => E.keepDockOpen && N?.id ? {
-			"data-glass-dock-portal": "",
-			"data-glass-dock-owner": N.id
-		} : {});
-		return (t, r) => k.value ? (u(), a(n, { key: 0 }, [o("span", {
-			class: "hover-popover-native-trigger",
-			interestfor: A
-		}, [f(t.$slots, "trigger", {}, () => [f(t.$slots, "default")])]), o("div", l({
-			id: A,
-			popover: "hint",
-			class: m(e)("glass-top-layer hover-popover-panel", E.class)
-		}, F.value, { onToggle: M }), [f(t.$slots, "content", {}, () => [o("span", S, p(c.content), 1)])], 16)], 64)) : (u(), i(m(b), {
-			key: 1,
-			open: j.value,
-			"onUpdate:open": r[0] ||= (e) => j.value = e,
-			"open-delay": c.hoverOpenDelay,
-			"close-delay": c.closeDelay
-		}, {
-			default: _(() => [s(m(x), { "as-child": "" }, {
-				default: _(() => [f(t.$slots, "trigger", {}, () => [f(t.$slots, "default")])]),
-				_: 3
-			}), s(m(y), null, {
-				default: _(() => [s(m(v), l({
-					side: c.side,
-					align: c.align,
-					"side-offset": c.sideOffset,
-					"avoid-collisions": !0,
-					class: D.value
-				}, F.value), {
-					default: _(() => [f(t.$slots, "content", {}, () => [o("span", C, p(c.content), 1)])]),
-					_: 3
-				}, 16, [
-					"side",
-					"align",
-					"side-offset",
-					"class"
-				])]),
-				_: 3
-			})]),
-			_: 3
-		}, 8, [
-			"open",
-			"open-delay",
-			"close-delay"
-		]));
-	}
-});
-//#endregion
-export { w as t };

package/dist/Input-IFsIzId2.js

@@ -1,30 +0,0 @@
-import { t as e } from "./cn-DJXf4yaB.js";
-import { createElementBlock as t, defineComponent as n, isRef as r, mergeProps as i, openBlock as a, unref as o, vModelDynamic as s, withDirectives as c } from "vue";
-import { useVModel as l } from "@vueuse/core";
-//#endregion
-//#region src/components/ui/input/Input.vue
-var u = /* @__PURE__ */ n({
-	inheritAttrs: !1,
-	__name: "Input",
-	props: {
-		defaultValue: {},
-		modelValue: {},
-		class: { type: [
-			Boolean,
-			null,
-			String,
-			Object,
-			Array
-		] }
-	},
-	emits: ["update:modelValue"],
-	setup(n, { emit: u }) {
-		let d = n, f = l(d, "modelValue", u, {
-			passive: !0,
-			defaultValue: d.defaultValue
-		});
-		return (n, l) => c((a(), t("input", i({ "onUpdate:modelValue": l[0] ||= (e) => r(f) ? f.value = e : null }, n.$attrs, { class: o(e)("input-pill text-sm file:border-0 file:bg-transparent file:text-sm file:font-medium", d.class) }), null, 16)), [[s, o(f)]]);
-	}
-});
-//#endregion
-export { u as t };

package/dist/Progress-Bs44qWEM.js

@@ -1,126 +0,0 @@
-import { t as e } from "./cn-DJXf4yaB.js";
-import { t } from "./_plugin-vue_export-helper-C1je1s0u.js";
-import { Fragment as n, computed as r, createBlock as i, createCommentVNode as a, createElementBlock as o, createElementVNode as s, createVNode as c, defineComponent as l, mergeProps as u, normalizeClass as d, normalizeStyle as f, openBlock as p, renderList as m, unref as h, withCtx as g } from "vue";
-import { ProgressIndicator as _, ProgressRoot as v } from "reka-ui";
-//#region src/components/ui/progress/Progress.vue?vue&type=script&setup=true&lang.ts
-var y = ["data-state", "data-index"], b = {
-	key: 0,
-	class: "progress-sectioned-sweep",
-	"aria-hidden": "true"
-}, x = /* @__PURE__ */ t(/* @__PURE__ */ l({
-	__name: "Progress",
-	props: {
-		modelValue: { default: 0 },
-		max: {},
-		getValueLabel: {},
-		getValueText: {},
-		asChild: { type: Boolean },
-		as: {},
-		class: { type: [
-			Boolean,
-			null,
-			String,
-			Object,
-			Array
-		] },
-		variant: { default: "default" },
-		segments: { default: () => [] },
-		currentSegmentKey: { default: null },
-		activeProgress: { default: 0 },
-		indeterminate: {
-			type: Boolean,
-			default: !1
-		},
-		disableCrescendo: {
-			type: Boolean,
-			default: !1
-		}
-	},
-	setup(t) {
-		let l = t, x = r(() => {
-			let { class: e, variant: t, segments: n, currentSegmentKey: r, activeProgress: i, indeterminate: a, disableCrescendo: o, ...s } = l;
-			return s;
-		}), S = r(() => {
-			if (l.variant === "sectioned" || l.indeterminate) return "idle";
-			let e = l.modelValue ?? 0;
-			return e <= 0 ? "idle" : e >= 100 ? "complete" : e < 5 ? "loading" : "progressing";
-		}), C = r(() => {
-			if (l.variant !== "gradient" || l.indeterminate) return;
-			if (l.disableCrescendo) return { "--progress-crescendo": "0%" };
-			let e = l.modelValue ?? 0;
-			if (e < 85) return { "--progress-crescendo": "0%" };
-			let t = (e - 85) / 15 * 100;
-			return { "--progress-crescendo": `${Math.min(100, Math.max(0, t))}%` };
-		}), w = r(() => l.variant === "sectioned" ? "relative h-[var(--progress-sectioned-height,0.875rem)] w-full overflow-hidden rounded-pill progress-sectioned-rail" : l.variant === "gradient" ? "relative h-4 w-full overflow-hidden rounded-pill bg-[var(--progress-track,theme(colors.secondary.DEFAULT))] progress-gradient-rail" : "relative h-4 w-full overflow-hidden rounded-pill bg-secondary"), T = r(() => l.variant === "sectioned" ? "absolute inset-0 pointer-events-none opacity-0" : l.variant === "gradient" ? "h-full w-full flex-1 rounded-pill [background:var(--progress-fill,theme(colors.primary.DEFAULT))] transition-transform" : "h-full w-full flex-1 rounded-pill bg-primary transition-transform"), E = r(() => {
-			if (l.variant !== "sectioned" || l.segments.length === 0) return [];
-			let e = l.segments.map((e) => e.weight ?? 1), t = e.reduce((e, t) => e + t, 0) || 1, n = l.segments.findIndex((e) => e.key === l.currentSegmentKey), r = 0;
-			return l.segments.map((i, a) => {
-				let o = e[a] / t * 100, s = r, c = r + o;
-				r = c;
-				let u;
-				u = i.state ? i.state : n < 0 ? "pending" : a < n ? "completed" : a === n ? "active" : "pending";
-				let d = u === "completed" ? 1 : u === "active" ? Math.max(0, Math.min(1, l.activeProgress)) : 0;
-				return {
-					...i,
-					startPct: s,
-					endPct: c,
-					widthPct: o,
-					resolvedState: u,
-					fill: d
-				};
-			});
-		}), D = r(() => {
-			if (l.variant !== "sectioned" || E.value.length === 0) return l.modelValue ?? 0;
-			let e = 0;
-			for (let t of E.value) e += t.fill * t.widthPct;
-			return Math.max(0, Math.min(100, e));
-		}), O = r(() => l.variant === "sectioned" ? D.value : l.modelValue ?? 0);
-		return (r, D) => (p(), i(h(v), u(x.value, {
-			"model-value": O.value,
-			class: h(e)(w.value, l.class),
-			"data-lifecycle": S.value,
-			"data-indeterminate": t.indeterminate || void 0,
-			"data-crescendo": t.disableCrescendo ? "disabled" : void 0
-		}), {
-			default: g(() => [c(h(_), {
-				class: d(T.value),
-				style: f(t.variant === "sectioned" ? void 0 : {
-					transform: `translateX(-${100 - (l.modelValue ?? 0)}%)`,
-					...C.value ?? {}
-				})
-			}, null, 8, ["class", "style"]), t.variant === "sectioned" ? (p(), o(n, { key: 0 }, [(p(!0), o(n, null, m(E.value, (e, t) => (p(), o("div", {
-				key: e.key,
-				class: "progress-sectioned-cell",
-				"data-state": e.resolvedState,
-				"data-index": t,
-				style: f({
-					left: e.startPct + "%",
-					width: e.widthPct + "%",
-					"--cell-color": e.color,
-					"--cell-fill": e.fill
-				})
-			}, [s("span", {
-				class: "progress-sectioned-fill",
-				style: f({ width: e.fill * 100 + "%" })
-			}, null, 4), e.resolvedState === "active" ? (p(), o("span", b)) : a("", !0)], 12, y))), 128)), (p(!0), o(n, null, m(E.value, (e, t) => (p(), o(n, { key: `seam-${e.key}` }, [t < E.value.length - 1 ? (p(), o("span", {
-				key: 0,
-				class: "progress-sectioned-seam",
-				style: f({
-					left: e.endPct + "%",
-					"--seam-from": e.color,
-					"--seam-to": E.value[t + 1].color
-				}),
-				"aria-hidden": "true"
-			}, null, 4)) : a("", !0)], 64))), 128))], 64)) : a("", !0)]),
-			_: 1
-		}, 16, [
-			"model-value",
-			"class",
-			"data-lifecycle",
-			"data-indeterminate",
-			"data-crescendo"
-		]));
-	}
-}), [["__scopeId", "data-v-ca211071"]]);
-//#endregion
-export { x as t };

package/dist/UnderlineTabs-B4FV2zi_.js

@@ -1,37 +0,0 @@
-import { t as e } from "./cn-DJXf4yaB.js";
-import { t } from "./_plugin-vue_export-helper-C1je1s0u.js";
-import { Fragment as n, createElementBlock as r, defineComponent as i, normalizeClass as a, openBlock as o, renderList as s, toDisplayString as c, unref as l } from "vue";
-//#region src/components/custom/tabs/UnderlineTabs.vue?vue&type=script&setup=true&lang.ts
-var u = ["aria-selected", "onClick"], d = /* @__PURE__ */ t(/* @__PURE__ */ i({
-	__name: "UnderlineTabs",
-	props: {
-		options: {},
-		modelValue: {},
-		class: { type: [
-			Boolean,
-			null,
-			String,
-			Object,
-			Array
-		] }
-	},
-	emits: ["update:modelValue"],
-	setup(t, { emit: i }) {
-		let d = t, f = i;
-		function p(e) {
-			f("update:modelValue", e);
-		}
-		return (i, f) => (o(), r("div", {
-			role: "tablist",
-			class: a(l(e)("underline-tabs", d.class))
-		}, [(o(!0), r(n, null, s(t.options, (e) => (o(), r("button", {
-			key: e.value,
-			class: "underline-tab",
-			role: "tab",
-			"aria-selected": t.modelValue === e.value ? "true" : "false",
-			onClick: (t) => p(e.value)
-		}, c(e.label), 9, u))), 128))], 2));
-	}
-}), [["__scopeId", "data-v-93401bfa"]]);
-//#endregion
-export { d as t };

package/dist/components/custom/aurora/shaders/aurora.frag.d.ts

@@ -1 +0,0 @@
-export declare const FRAGMENT_SRC = "#version 300 es\nprecision highp float;\n\nin vec2 vUv;\nout vec4 fragColor;\n\n#define MAX_NUCLEI 6\n#define MAX_STOPS  8\n\n// \u2500\u2500 Uniforms \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nuniform float uTime;\n\n// Palette baked CPU-side to linear-sRGB\nuniform vec3  uPalette[MAX_STOPS];\nuniform int   uStopCount;\n\n// Nuclei (parallel arrays)\nuniform int   uNucleiCount;\nuniform vec2  uNucleiPos[MAX_NUCLEI];\nuniform float uNucleiRadius[MAX_NUCLEI];\nuniform float uNucleiPaletteBias[MAX_NUCLEI];\nuniform float uNucleiValueBias[MAX_NUCLEI];\nuniform float uNucleiDriftRadius[MAX_NUCLEI];\nuniform float uNucleiDriftPhase[MAX_NUCLEI];\n// Anisotropy: per-nucleus elongation (1.0 = isotropic) and major-axis angle (radians).\n// Defaults (1.0 / 0.0) reduce to the original circular Gaussian.\nuniform float uNucleiElong[MAX_NUCLEI];\nuniform float uNucleiAngle[MAX_NUCLEI];\nuniform float uSoftmaxBeta;\nuniform float uValueVariance;\n\n// Warp\nuniform float uWarpAmount;\nuniform float uWarpScale;\nuniform float uWarpDrift;\nuniform int   uWarpMode;      // 0=fbm 1=cellular 2=hybrid\nuniform int   uNoiseOctaves;\n\n// Medium\n// 0 smooth, 1 pastel, 2 watercolor, 3 oil\nuniform int   uMedium;\nuniform int   uFlowPattern;   // 0 none, 1 radial, 2 swirl, 3 diagonal, 4 multi\nuniform vec2  uFlowFocal;\nuniform float uFlowAngle;\nuniform float uFlowCurl;\nuniform vec2  uCursor;          // in 0..1 screen space (matches pN)\nuniform float uCursorStrength;  // 0..1 attraction amount\nuniform float uCursorRadius;    // radius of influence (0.05..0.5)\nuniform float uStrokeAmount;\nuniform float uStrokeScale;\nuniform float uStrokeAnisotropy;\nuniform int   uStrokeLayers;  // 1 or 2 (crosshatch)\nuniform int   uStrokeMode;    // 0 oil (modern gestural), 1 palette-knife, 2 crayon/oil-pastel, 3 modern-chunky\nuniform float uWetEdge;\nuniform float uGranulation;\nuniform float uImpasto;\nuniform float uBrokenColor;\nuniform float uCanvasGrain;\n\n// Motion\nuniform float uNucleiDrift;\nuniform float uPaletteDrift;\nuniform float uBreathDepth;\nuniform float uBreathPeriod;\n\n// Output\nuniform float uSaturation;\nuniform float uPaperGrain;\nuniform float uAlpha;\n\n// \u2500\u2500 Time rate \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// The authoring coefficients (uNucleiDrift, uPaletteDrift, uWarpDrift) live in a\n// human-friendly 0..~0.05 band \u2014 that scale is what the config schema and every\n// demo preset are tuned against. But that band, multiplied straight into uTime\n// (seconds), yields rad/sec rates so small the field reads visually static (one\n// nuclei orbit took ~10 min at the old default). These K_* constants decouple\n// the AUTHORING scale from the RAD/SEC scale: each time term wraps its coefficient\n// in the matching K_, lifting the same authored value to a perceptible period\n// without touching any preset. Tuned so the field reads SLOWLY ALIVE \u2014 drift over\n// a ~5\u201315s window, never a frantic pan. These are downstream of uTime, which the\n// runtime FREEZES under reduced-motion (t = frozenOffset) before the shader sees\n// it, so the lift cannot leak motion into the reduced-motion path.\nconst float K_NUCLEI = 14.0; // nuclei orbit: ~one cycle per ~45s at default 0.01\nconst float K_PAL    = 24.0; // palette hue breathe: ~one cycle per ~33s at default\nconst float K_WARP   = 5.0;  // domain warp scroll: a perceptible fbm-cell traverse\n\n// \u2500\u2500 Noise \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nfloat hash21(vec2 p) {\n  p = fract(p * vec2(123.34, 456.21));\n  p += dot(p, p + 45.32);\n  return fract(p.x * p.y);\n}\n\nvec2 hash22(vec2 p) {\n  p = vec2(dot(p, vec2(127.1, 311.7)),\n           dot(p, vec2(269.5, 183.3)));\n  return fract(sin(p) * 43758.5453);\n}\n\nfloat vnoise(vec2 p) {\n  vec2 i = floor(p);\n  vec2 f = fract(p);\n  vec2 u = f * f * (3.0 - 2.0 * f);\n  float a = hash21(i);\n  float b = hash21(i + vec2(1.0, 0.0));\n  float c = hash21(i + vec2(0.0, 1.0));\n  float d = hash21(i + vec2(1.0, 1.0));\n  return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);\n}\n\nfloat fbm(vec2 p) {\n  float v = 0.0;\n  float a = 0.5;\n  mat2 r = mat2(0.8, 0.6, -0.6, 0.8);\n  for (int i = 0; i < 5; i++) {\n    if (i >= uNoiseOctaves) break;\n    v += a * vnoise(p);\n    p = r * p * 2.02;\n    a *= 0.5;\n  }\n  return v;\n}\n\n// Cellular / Worley f1\nfloat cellular(vec2 p) {\n  vec2 i = floor(p);\n  vec2 f = fract(p);\n  float m = 1e9;\n  for (int y = -1; y <= 1; y++) {\n    for (int x = -1; x <= 1; x++) {\n      vec2 g = vec2(float(x), float(y));\n      vec2 o = hash22(i + g);\n      vec2 r = g + o - f;\n      m = min(m, dot(r, r));\n    }\n  }\n  return sqrt(m);\n}\n\n// \u2500\u2500 Warp \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nvec2 domainWarp(vec2 p, float t) {\n  // Quilez canonical double warp\n  vec2 q = vec2(fbm(p * uWarpScale + vec2(0.0, 0.0) + t * uWarpDrift * K_WARP),\n                fbm(p * uWarpScale + vec2(5.2, 1.3) + t * uWarpDrift * K_WARP));\n  vec2 r = vec2(fbm(p * uWarpScale + 4.0 * q + vec2(1.7, 9.2)),\n                fbm(p * uWarpScale + 4.0 * q + vec2(8.3, 2.8)));\n\n  vec2 warp = r;\n  if (uWarpMode == 1) {\n    // cellular \u2014 chunky territories (MEADOW block-like)\n    float c1 = cellular(p * uWarpScale * 1.5 + vec2(t * uWarpDrift * K_WARP * 2.0, 0.0));\n    float c2 = cellular(p * uWarpScale * 1.5 + vec2(11.0, 7.0 + t * uWarpDrift * K_WARP * 2.0));\n    warp = vec2(c1, c2);\n  } else if (uWarpMode == 2) {\n    // hybrid \u2014 fbm + cellular averaged\n    float c1 = cellular(p * uWarpScale * 1.2);\n    float c2 = cellular(p * uWarpScale * 1.2 + vec2(11.0, 7.0));\n    warp = mix(r, vec2(c1, c2), 0.5);\n  }\n  vec2 warped = p + uWarpAmount * warp;\n\n  // Cursor swirl \u2014 rotate p around uCursor with radial falloff.\n  // This warps the underlying color field so the bands sweep around the pointer.\n  if (uCursorStrength > 0.001) {\n    vec2 toP = p - uCursor;\n    float d = length(toP);\n    float r = max(uCursorRadius, 0.01);\n    // Smooth falloff; strong near cursor, zero beyond ~1.5\u00D7 radius.\n    float w = exp(-(d * d) / (r * r * 0.45));\n    // Max rotation ~120\u00B0 at cursor center, scaled by strength\n    float ang = w * uCursorStrength * 2.1;\n    float ca = cos(ang), sa = sin(ang);\n    vec2 rotated = vec2(ca * toP.x - sa * toP.y, sa * toP.x + ca * toP.y) + uCursor;\n    // Also pinch slightly toward the cursor (gravity) \u2014 adds depth to swirl\n    float pinch = w * uCursorStrength * 0.08;\n    rotated = mix(rotated, uCursor, pinch);\n    // Blend original warped position with cursor-rotated version\n    warped = mix(warped, rotated + uWarpAmount * warp * 0.7, w * uCursorStrength);\n  }\n\n  return warped;\n}\n\n// \u2500\u2500 Palette LUT \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nvec3 samplePalette(float id) {\n  id = clamp(id, 0.0, 1.0);\n  float scaled = id * float(uStopCount - 1);\n  int i0 = int(floor(scaled));\n  int i1 = min(i0 + 1, uStopCount - 1);\n  float t = fract(scaled);\n  t = smoothstep(0.0, 1.0, t);\n  return mix(uPalette[i0], uPalette[i1], t);\n}\n\n// \u2500\u2500 Nuclei field \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nvoid nucleiField(vec2 p, float t, out float paletteId, out float valueMod) {\n  float accumBias  = 0.0;\n  float accumValue = 0.0;\n  float accumW     = 0.0;\n  for (int i = 0; i < MAX_NUCLEI; i++) {\n    if (i >= uNucleiCount) break;\n    vec2 posI = uNucleiPos[i]\n              + uNucleiDriftRadius[i] * vec2(\n                  cos(t * uNucleiDrift * K_NUCLEI + uNucleiDriftPhase[i]),\n                  sin(t * uNucleiDrift * K_NUCLEI + uNucleiDriftPhase[i] * 1.13)\n                );\n    vec2 diff = p - posI;\n    // Anisotropic Gaussian: rotate diff into the nucleus's local frame\n    // (major axis along uNucleiAngle), then scale the major-axis component by\n    // 1/elongation so the squared distance describes an ellipse. Defaults\n    // 1.0/0.0 reduce to the isotropic dot(diff, diff).\n    float ca = cos(uNucleiAngle[i]);\n    float sa = sin(uNucleiAngle[i]);\n    vec2  local = vec2( ca * diff.x + sa * diff.y,\n                       -sa * diff.x + ca * diff.y);\n    float along  = local.x / max(uNucleiElong[i], 0.01);\n    float across = local.y;\n    float d2 = along * along + across * across;\n    float r = max(uNucleiRadius[i], 0.01);\n    float w = exp(-uSoftmaxBeta * d2 / (r * r));\n    accumBias  += w * uNucleiPaletteBias[i];\n    accumValue += w * uNucleiValueBias[i];\n    accumW     += w;\n  }\n  paletteId = accumBias  / max(accumW, 1e-4);\n  valueMod  = accumValue / max(accumW, 1e-4);\n\n  // Palette drift \u2014 slow global paletteId breathe between adjacent stops. The\n  // rate rides K_PAL (perceptible ~30\u201360s hue cycle at the default coefficient);\n  // the amplitude lifts the authored coefficient into a 0.03..0.06 paletteId band\n  // so the palette visibly travels rather than dithering within one stop.\n  float palAmp = clamp(uPaletteDrift * 6.0, 0.0, 0.06);\n  paletteId += palAmp * sin(t * uPaletteDrift * K_PAL);\n  paletteId = clamp(paletteId, 0.0, 1.0);\n}\n\n// \u2500\u2500 Flow field \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nvec2 flowField(vec2 p, float t) {\n  vec2 dir = vec2(1.0, 0.0);\n  if (uFlowPattern == 1) {\n    // radial\n    dir = normalize(p - uFlowFocal + 1e-4);\n  } else if (uFlowPattern == 2) {\n    // swirl \u2014 tangent to radial\n    vec2 rad = normalize(p - uFlowFocal + 1e-4);\n    dir = vec2(-rad.y, rad.x);\n  } else if (uFlowPattern == 3) {\n    // diagonal\n    float a = radians(uFlowAngle);\n    dir = vec2(cos(a), sin(a));\n  } else if (uFlowPattern == 4) {\n    // multi \u2014 curl-noise driven\n    float n = fbm(p * 2.0 + t * 0.02);\n    float a = n * 6.2831;\n    dir = vec2(cos(a), sin(a));\n  }\n  // curl \u2014 perturb by noise. Radial gets much less curl so rays stay clean.\n  if (uFlowCurl > 0.0) {\n    float n = fbm(p * 3.0) - 0.5;\n    float curlAmt = uFlowCurl;\n    if (uFlowPattern == 1) curlAmt *= 0.25;  // radial: preserve ray clarity\n    if (uFlowPattern == 2) curlAmt *= 0.55;  // swirl: allow moderate curl\n    float a = atan(dir.y, dir.x) + n * 3.14159 * curlAmt;\n    dir = vec2(cos(a), sin(a));\n  }\n  // cursor influence \u2014 swirl around the cursor position\n  if (uCursorStrength > 0.001) {\n    vec2 toCur = uCursor - p;\n    float d = length(toCur);\n    float r = max(uCursorRadius, 0.01);\n    float w = exp(-(d * d) / (r * r * 0.5));\n    // swirl tangent\n    vec2 tangent = vec2(-toCur.y, toCur.x) / max(d, 1e-4);\n    float a0 = atan(dir.y, dir.x);\n    float a1 = atan(tangent.y, tangent.x);\n    // blend angle\n    float da = a1 - a0;\n    da = atan(sin(da), cos(da)); // wrap to [-pi, pi]\n    float a = a0 + da * w * uCursorStrength;\n    dir = vec2(cos(a), sin(a));\n  }\n  return dir;\n}\n\n// \u2500\u2500 Color utils \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nconst vec3 W_LUMA = vec3(0.2126, 0.7152, 0.0722);\n\nvec3 hueShift(vec3 c, float degrees) {\n  float a = radians(degrees);\n  float co = cos(a), si = sin(a);\n  mat3 m = mat3(\n    0.299 + 0.701 * co + 0.168 * si,\n    0.587 - 0.587 * co + 0.330 * si,\n    0.114 - 0.114 * co - 0.497 * si,\n\n    0.299 - 0.299 * co - 0.328 * si,\n    0.587 + 0.413 * co + 0.035 * si,\n    0.114 - 0.114 * co + 0.292 * si,\n\n    0.299 - 0.300 * co + 1.250 * si,\n    0.587 - 0.588 * co - 1.050 * si,\n    0.114 + 0.886 * co - 0.203 * si\n  );\n  return m * c;\n}\n\nvec3 brokenColorJitter(vec3 c, float hueSeed, float valueSeed, float strength) {\n  float amt = clamp(uBrokenColor * strength, 0.0, 1.0);\n  if (amt <= 0.001) return c;\n  float hueDeg = (hueSeed - 0.5) * 32.0 * amt;\n  float valueMul = 1.0 + (valueSeed - 0.5) * 0.28 * amt;\n  return max(hueShift(c, hueDeg) * valueMul, vec3(0.0));\n}\n\nvec3 saturate3(vec3 c, float amt) {\n  float l = dot(c, W_LUMA);\n  return mix(vec3(l), c, amt);\n}\n\n// ACES approximation\nvec3 aces(vec3 x) {\n  float a = 2.51;\n  float b = 0.03;\n  float c = 2.43;\n  float d = 0.59;\n  float e = 0.14;\n  return clamp((x * (a * x + b)) / (x * (c * x + d) + e), 0.0, 1.0);\n}\n\n// \u2500\u2500 Medium overlays \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n// A quick re-computation of base color for edge-mask sampling\nvec3 sampleBase(vec2 p, float t) {\n  vec2 pw = domainWarp(p, t);\n  float id; float vm;\n  nucleiField(pw, t, id, vm);\n  vec3 c = samplePalette(id);\n  c *= 1.0 + uValueVariance * vm;\n  return c;\n}\n\nvec3 mediumWatercolor(vec3 col, vec2 p, float t) {\n  // Wet-edge cauliflowers via luma-gradient magnitude\n  float eps = 0.004;\n  vec3 cx1 = sampleBase(p + vec2(eps, 0.0), t);\n  vec3 cx2 = sampleBase(p - vec2(eps, 0.0), t);\n  vec3 cy1 = sampleBase(p + vec2(0.0, eps), t);\n  vec3 cy2 = sampleBase(p - vec2(0.0, eps), t);\n  float gx = dot(cx1 - cx2, W_LUMA);\n  float gy = dot(cy1 - cy2, W_LUMA);\n  float edge = sqrt(gx * gx + gy * gy) / (2.0 * eps);\n  float mask = smoothstep(0.0, 2.5, edge);\n  col *= mix(1.0, 0.78, mask * uWetEdge);\n\n  // Granulation \u2014 pigment settles in paper tooth\n  float paper = 0.5 * vnoise(p * 160.0) + 0.5 * vnoise(p * 360.0);\n  float pigLoad = 1.0 - dot(col, W_LUMA);\n  col *= 1.0 - uGranulation * pigLoad * (paper - 0.5);\n\n  // Wash banding \u2014 faint horizontal wet gradient\n  float band = fbm(vec2(p.x * 1.5, p.y * 0.4));\n  col *= 1.0 + 0.04 * (band - 0.5);\n  return col;\n}\n\nvec3 mediumPastel(vec3 col, vec2 p, float t) {\n  vec2 flow = flowField(p, t);\n  vec2 perp = vec2(-flow.y, flow.x);\n  float along  = dot(p, flow) * uStrokeScale;\n  float across = dot(p, perp) * uStrokeScale;\n  across += 0.03 * (vnoise(p * 260.0) - 0.5);\n\n  float aniso = mix(1.0, 0.18, uStrokeAnisotropy);\n  float stroke = fbm(vec2(along * aniso, across));\n  col *= mix(1.0, 0.82 + 0.32 * stroke, uStrokeAmount);\n\n  // Pastel tooth \u2014 tiny high-frequency grain\n  float tooth = vnoise(p * 800.0);\n  col *= 1.0 - 0.08 * uStrokeAmount * (tooth - 0.5);\n  return col;\n}\n\n// \u2500\u2500 Curved swept brushstroke primitive \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// A stroke is a curved spine from A to B with quadratic bulge K (sideways offset\n// at midpoint). Width varies along length via a shape profile. Edge is ragged\n// (bristle-modulated), ends are rounded blobs, inside has streak modulation.\n//\n// For pixel p, we invert an approximate projection onto the curved spine:\n//   1) project p onto straight AB axis -> along0, cross0\n//   2) at parameter along0, spine offset = 4\u00B7K\u00B7along0\u00B7(1-along0) perpendicular\n//   3) cross = cross0 - spineOffset, refine along one iteration\n// Coverage blends paint atop col based on per-stroke color sampled from the\n// underlying base at spine midpoint \u2014 so overlapping strokes from different\n// palette regions meet at hard, ragged demarcations.\n\nstruct StrokeHit {\n  float coverage;  // 0..1\n  vec3  color;\n  float alongT;    // 0..1 along spine, for internal modulation\n  float crossN;    // cross distance / current half-width, signed\n  float edgeN;     // distance to edge in half-widths (0 = at edge, 1 = at spine)\n};\n\nStrokeHit noHit() { return StrokeHit(0.0, vec3(0.0), 0.0, 0.0, 0.0); }\n\nvec2 rotateDir(vec2 dir, float angle) {\n  float ca = cos(angle), sa = sin(angle);\n  return vec2(dir.x * ca - dir.y * sa, dir.x * sa + dir.y * ca);\n}\n\nvec2 safeDir(vec2 dir) {\n  float len = length(dir);\n  return len > 1e-4 ? dir / len : vec2(1.0, 0.0);\n}\n\n// Shape profile along the stroke. type:\n//   0 tapered    \u2014 thin-fat-thin (classic brush)\n//   1 load-drag  \u2014 fat start, tapers to a point\n//   2 dab        \u2014 ellipse-like, round center\n//   3 even       \u2014 near-constant, slight end taper\nfloat strokeShape(float t, int type) {\n  t = clamp(t, 0.0, 1.0);\n  if (type == 1) {\n    // loaded at t=0, tapering\n    return pow(1.0 - t, 0.55) * smoothstep(0.0, 0.08, t);\n  } else if (type == 2) {\n    // dab / blob\n    float d = t - 0.5;\n    return exp(-d * d * 12.0);\n  } else if (type == 3) {\n    // mostly even, slight end softening\n    return smoothstep(0.0, 0.08, t) * smoothstep(1.0, 0.92, t) * 0.95 + 0.05;\n  }\n  // 0 tapered\n  return smoothstep(0.0, 0.22, t) * smoothstep(1.0, 0.78, t);\n}\n\n// A single curved stroke.\n//   a, b           \u2014 endpoints\n//   halfW          \u2014 base half-width (world units)\n//   bulge          \u2014 signed perpendicular midpoint offset, in world units\n//   shapeType      \u2014 0..3\n//   bristleFreq    \u2014 spatial frequency of edge raggedness\n//   bristleAmp     \u2014 0..0.5 fraction of halfW chewed away at edge extrema\n//   streakSeed     \u2014 uniqueness seed for internal streaks\n//   colAtMid       \u2014 pre-sampled color at midpoint\nStrokeHit curvedStroke(vec2 p, vec2 a, vec2 b, float halfW,\n                       float bulge, int shapeType,\n                       float bristleFreq, float bristleAmp,\n                       float streakSeed, vec3 colAtMid) {\n  vec2 ab = b - a;\n  float L = length(ab);\n  if (L < 1e-5) return noHit();\n  vec2 tang = ab / L;\n  vec2 norm = vec2(-tang.y, tang.x);\n\n  vec2 rel = p - a;\n  float along0 = dot(rel, tang) / L;      // straight projection 0..1 along AB\n  float cross0 = dot(rel, norm);          // signed cross\n\n  // Spine sideways offset due to bulge (parabolic)\n  float bend = 4.0 * bulge * along0 * (1.0 - along0);\n  float cross1 = cross0 - bend;\n\n  // One refinement step: as the spine bends, the closest-point along shifts.\n  // Spine tangent differs from straight tangent; first-order correction:\n  float dBend = 4.0 * bulge * (1.0 - 2.0 * along0);  // d(bend)/d(along)\n  float along1 = along0 + (cross1 * dBend) / (L * (1.0 + dBend * dBend / (L * L)));\n\n  // Bristle-ragged edge: half-width gets chewed by 1D noise along the spine\n  float edgeNoise = fbm(vec2(along1 * bristleFreq, streakSeed * 7.3)) - 0.5;\n  float edgeNoise2 = fbm(vec2(along1 * bristleFreq * 2.3, streakSeed * 3.1 + 17.0)) - 0.5;\n  float edgeMod = 1.0 - bristleAmp * (0.6 + 0.4 * edgeNoise) * (0.5 + edgeNoise2);\n\n  // Width profile along the stroke\n  float shape = strokeShape(along1, shapeType);\n  float halfWNow = halfW * shape * edgeMod;\n\n  // Inside-segment coverage\n  float cov = 0.0;\n  if (along1 >= 0.0 && along1 <= 1.0 && halfWNow > 1e-6) {\n    float cn = abs(cross1) / halfWNow;\n    // razor-hard edge with tiny aa\n    cov = 1.0 - smoothstep(0.88, 1.02, cn);\n  }\n\n  // End-cap blobs (rounded tips, not perpendicular cuts)\n  float capA = 0.0, capB = 0.0;\n  {\n    vec2 capCenterA = a + norm * (bulge * 0.0); // at a\n    vec2 capCenterB = a + tang * L + norm * bend * 0.0 + norm * 0.0; // at b; bend is 0 at endpoints\n    capCenterB = b;\n    float endShapeA = strokeShape(0.02, shapeType);\n    float endShapeB = strokeShape(0.98, shapeType);\n    float rA = halfW * endShapeA * (0.9 + 0.2 * fbm(vec2(streakSeed * 13.0)));\n    float rB = halfW * endShapeB * (0.9 + 0.2 * fbm(vec2(streakSeed * 19.0 + 5.0)));\n    float dA = length(p - capCenterA);\n    float dB = length(p - capCenterB);\n    capA = 1.0 - smoothstep(rA * 0.85, rA * 1.05, dA);\n    capB = 1.0 - smoothstep(rB * 0.85, rB * 1.05, dB);\n    // Only apply caps if we're BEYOND the segment; otherwise the segment wins.\n    capA *= (along1 < 0.05) ? 1.0 : 0.0;\n    capB *= (along1 > 0.95) ? 1.0 : 0.0;\n  }\n\n  float coverage = max(cov, max(capA, capB));\n  if (coverage < 0.002) return noHit();\n\n  // Edge distance (for impasto later): 0 at edge, 1 at spine\n  float edgeDist = halfWNow > 1e-6 ? clamp(1.0 - abs(cross1) / halfWNow, 0.0, 1.0) : 0.0;\n\n  return StrokeHit(\n    coverage,\n    colAtMid,\n    clamp(along1, 0.0, 1.0),\n    halfWNow > 1e-6 ? cross1 / halfWNow : 0.0,\n    edgeDist\n  );\n}\n\n// Composite stroke over col with internal streaking + impasto edge highlight.\n//   streakAmp    \u2014 0..0.2 how much internal streaks darken/lighten\n//   impastoAmp   \u2014 0..1 edge catch-light strength\n//   hardness     \u2014 0..1 how crisp the compositing transition is (1 = razor, 0 = creamy)\nvoid paintOver(inout vec3 col, StrokeHit s, float streakFreq, float streakAmp,\n               float impastoAmp, float hardness, float streakSeed) {\n  if (s.coverage < 0.002) return;\n  float strokeOpacity = clamp(uStrokeAmount, 0.0, 1.0);\n  if (strokeOpacity <= 0.001) return;\n  vec3 c = s.color;\n\n  // Internal streaks \u2014 fbm along spine, modulated by cross position. Gives\n  // the loaded-brush look: some bristles carry more pigment than others.\n  float streakA = fbm(vec2(s.alongT * streakFreq, s.crossN * 2.7 + streakSeed));\n  float streakB = fbm(vec2(s.alongT * streakFreq * 0.6 + streakSeed * 3.7, s.crossN * 4.1));\n  float streak = 0.6 * (streakA - 0.5) + 0.4 * (streakB - 0.5);\n  c *= 1.0 + streak * streakAmp * 2.0;\n\n  // Subtle value variance across width (hollow-center catch-light)\n  float crossShade = smoothstep(0.0, 0.4, s.edgeN) * (1.0 - smoothstep(0.65, 1.0, s.edgeN));\n  c *= 1.0 + crossShade * 0.05;\n\n  // Impasto edge highlight \u2014 bright rim on one side of the stroke\n  float rim = smoothstep(0.85, 1.0, 1.0 - s.edgeN) * step(0.0, s.crossN);\n  c += impastoAmp * rim * vec3(0.18, 0.15, 0.11);\n  // Shadow on the other side (darker, cooler)\n  float shadow = smoothstep(0.85, 1.0, 1.0 - s.edgeN) * step(0.0, -s.crossN);\n  c -= impastoAmp * shadow * 0.25 * vec3(0.10, 0.09, 0.07);\n\n  float softLimit = mix(0.35, 0.98, hardness);\n  float alpha = smoothstep(0.0, 1.0 - softLimit, s.coverage) * strokeOpacity;\n  col = mix(col, c, alpha);\n}\n\n// Best-of-9-neighbor placement: sample 3x3 surrounding cells and take the\n// stroke that covers this pixel most. Breaks the grid by per-cell jitter and\n// sparse density via noise thresholding.\nStrokeHit bestOil(vec2 p, float cellSize, float lenMul, float halfWMul,\n                  float jitterAmt, float density, int shapeType,\n                  float bristleAmp, vec2 flow, float t, float seed) {\n  vec2 cell = floor(p / cellSize);\n\n  StrokeHit best = noHit();\n  // 3x3 neighborhood\n  for (int dy = -1; dy <= 1; dy++) {\n    for (int dx = -1; dx <= 1; dx++) {\n      vec2 cc = cell + vec2(float(dx), float(dy));\n      vec2 hh = hash22(cc + seed) - 0.5;\n      // Density gate \u2014 noise threshold; sparse placement.\n      float gate = hash21(cc * 1.7 + seed * 0.3);\n      if (gate > density) continue;\n\n      vec2 center = (cc + 0.5 + hh * jitterAmt) * cellSize;\n\n      // Per-stroke direction: consume the layer-provided flow, then add only\n      // deterministic local perturbation so alternate stroke layers stay live.\n      vec2 f = safeDir(flow);\n      float angJ = (hash21(cc + seed + 11.0) - 0.5) * 0.9;  // +/- 0.45 rad\n      float localCurl = (fbm(center * (2.6 + seed * 0.11) + seed * 1.9) - 0.5) * 0.55 * uFlowCurl;\n      vec2 dir = rotateDir(f, angJ + localCurl);\n\n      float lenV = cellSize * lenMul * (0.65 + 0.55 * hash21(cc + seed + 23.0));\n      float halfW = cellSize * halfWMul * (0.70 + 0.55 * hash21(cc + seed + 41.0));\n      float bulge = (hash21(cc + seed + 53.0) - 0.5) * lenV * 0.35;\n\n      vec2 a = center - dir * (lenV * 0.5);\n      vec2 b = center + dir * (lenV * 0.5);\n\n      vec3 colMid = brokenColorJitter(\n        sampleBase(center, t),\n        hash21(cc + seed + 89.0),\n        hash21(cc * 2.3 + seed + 97.0),\n        1.0\n      );\n\n      StrokeHit h = curvedStroke(p, a, b, halfW, bulge, shapeType,\n                                 7.0, bristleAmp,\n                                 hash21(cc + seed + 67.0), colMid);\n      if (h.coverage > best.coverage) best = h;\n    }\n  }\n  return best;\n}\n\n// \u2500\u2500 Crayon / oil-pastel \u2014 paper tooth \u00D7 wax pigment \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// Crayon is not strokes. It's pigment crumbs dragged across paper tooth.\n// Model: heavy 2D tooth noise at multiple scales, anisotropically stretched\n// along flow direction, multiplied into the base color. Add a slow \"waxy\n// film\" that slightly unifies hues, and occasional darker \"pressed\" spots\n// where the crayon dug in. NO straight segments.\nvec3 mediumOil_crayon(vec3 col, vec2 p, float t) {\n  vec2 flow = flowField(p, t);\n  float ang = atan(flow.y, flow.x);\n  float ca = cos(-ang), sa = sin(-ang);\n  vec2 pr = vec2(p.x * ca - p.y * sa, p.x * sa + p.y * ca);\n\n  // Anisotropic tooth \u2014 squished along flow, coarse cross flow.\n  float aniso = mix(0.45, 0.95, uStrokeAnisotropy);\n  float scale = max(uStrokeScale * 1.6, 180.0);\n\n  float t1 = vnoise(vec2(pr.x * scale * aniso, pr.y * scale));\n  float t2 = vnoise(vec2(pr.x * scale * aniso * 0.4, pr.y * scale * 0.4) + 11.0);\n  float t3 = vnoise(vec2(pr.x * scale * aniso * 2.1, pr.y * scale * 2.1) + 23.0);\n  float tooth = 0.55 * t1 + 0.30 * t2 + 0.15 * t3;\n  // Center at 0, amplify\n  tooth = (tooth - 0.5) * 1.4;\n\n  // Multiplicative darkening where tooth is low (pigment skipped paper valleys)\n  float lay = 1.0 + tooth * 0.32 * uStrokeAmount;\n  vec3 result = col * lay;\n\n  // Occasional pressed-in crumbs \u2014 rare darker crumbs\n  float crumbs = smoothstep(0.78, 0.95, vnoise(pr * scale * 3.0));\n  result *= 1.0 - crumbs * 0.18 * uStrokeAmount;\n\n  // Waxy highlight film \u2014 slight lightening on tooth peaks\n  float waxy = smoothstep(0.55, 0.85, t1);\n  result += waxy * 0.04 * vec3(1.0);\n\n  // Paper tooth overlay (subtler than oil's canvas)\n  float paperTooth = vnoise(p * 340.0) - 0.5;\n  result *= 1.0 + paperTooth * 0.14 * uCanvasGrain;\n\n  // Broken-color pigment: stable wax/pigment patches, not temporal flicker.\n  vec2 pigmentCell = floor(pr * max(scale * 0.18, 32.0));\n  float pigmentMask = smoothstep(0.28, 0.82, vnoise(pr * scale * 0.21 + 19.0));\n  result = brokenColorJitter(\n    result,\n    hash21(pigmentCell + 17.0),\n    hash21(pigmentCell * 2.1 + 31.0),\n    0.45 + 0.55 * pigmentMask\n  );\n\n  // Crayon is saturation-amplified\n  result = saturate3(result, 1.12);\n\n  return result;\n}\n\nvec3 mediumOil(vec3 col, vec2 p, float t) {\n  // Mode knobs (uStrokeMode):\n  //   0 oil         \u2014 balanced modern-abstract/palette-knife hybrid\n  //   1 knife       \u2014 palette-knife impasto: razor edges, heavy bristle/shadow\n  //   2 crayon      \u2014 soft-edged wax smudges on tooth (no straight segments)\n  //   3 brushwork   \u2014 thick bristle brush\n  int mode = uStrokeMode;\n\n  // Per-mode parameters\n  int  shapeType   = 0;     // tapered\n  float bristleAmp = 0.25;  // 0..0.5\n  float streakFreq = 9.0;\n  float streakAmp  = 0.09;\n  float impastoAmp = 0.9;\n  float hardness   = 0.80;  // edge compositing\n  float toothScale = 240.0;\n  float toothAmp   = 0.09;\n  float pigmentSat = 1.03;\n  float densityBig = 0.65;\n  float densityMed = 0.78;\n  float densitySml = 0.90;\n\n  if (mode == 1) {        // palette knife\n    shapeType = 3;        // flat, even\n    bristleAmp = 0.12;\n    streakFreq = 4.0;  streakAmp = 0.05;\n    impastoAmp = 1.6;\n    hardness   = 0.95;\n    toothAmp   = 0.04;\n    densityBig = 0.80; densityMed = 0.88; densitySml = 0.70;\n  } else if (mode == 2) { // crayon \u2014 handled specially below\n    return mediumOil_crayon(col, p, t);\n  } else if (mode == 3) { // thick brushwork\n    shapeType = 0;        // tapered\n    bristleAmp = 0.32;\n    streakFreq = 14.0; streakAmp = 0.14;\n    impastoAmp = 1.2;\n    hardness   = 0.85;\n    toothAmp   = 0.07;\n  }\n\n  // Scales & multipliers from uniforms\n  float baseScale = max(uStrokeScale * 0.006, 0.008);\n  // Three layers: big gestural, medium body, small dabs\n  float sBig = baseScale * 2.4;\n  float sMed = baseScale * 1.1;\n  float sSml = baseScale * 0.45;\n\n  float lenMulBig = mix(2.2, 3.8, uStrokeAnisotropy);\n  float widMulBig = mix(0.55, 0.32, uStrokeAnisotropy);\n  float lenMulMed = mix(2.0, 3.4, uStrokeAnisotropy);\n  float widMulMed = mix(0.50, 0.30, uStrokeAnisotropy);\n  float lenMulSml = mix(1.6, 2.6, uStrokeAnisotropy);\n  float widMulSml = mix(0.45, 0.32, uStrokeAnisotropy);\n\n  float jitterAmt = 0.75;   // large jitter \u2014 no grid\n  vec2 flow = flowField(p, t);\n\n  vec3 result = col;\n\n  // Layer 1 \u2014 big gestural strokes (sparse, shaping)\n  StrokeHit hBig = bestOil(p, sBig, lenMulBig, widMulBig, jitterAmt * 0.55,\n                           densityBig, shapeType, bristleAmp, flow, t, 1.3);\n  paintOver(result, hBig, streakFreq * 0.7, streakAmp,\n            uImpasto * impastoAmp * uStrokeAmount, hardness, 1.3);\n\n  // Layer 2 \u2014 medium body strokes\n  StrokeHit hMed = bestOil(p + vec2(11.3, 3.7), sMed, lenMulMed, widMulMed,\n                           jitterAmt, densityMed, shapeType, bristleAmp, flow, t, 2.7);\n  paintOver(result, hMed, streakFreq, streakAmp,\n            uImpasto * impastoAmp * uStrokeAmount, hardness, 2.7);\n\n  // Layer 3 \u2014 small dabs (more frequent, smaller)\n  int smlShape = (mode == 1) ? 2 : shapeType; // knife uses dabs for sparkle\n  StrokeHit hSml = bestOil(p + vec2(-5.1, 8.4), sSml, lenMulSml, widMulSml,\n                           jitterAmt * 1.3, densitySml, smlShape,\n                           bristleAmp * 0.85, flow, t, 4.1);\n  paintOver(result, hSml, streakFreq * 1.4, streakAmp * 0.8,\n            uImpasto * impastoAmp * 0.65 * uStrokeAmount, hardness, 4.1);\n\n  // Layer 4 \u2014 fill dabs (very dense, very small) \u2014 covers bald spots\n  float sFill = baseScale * 0.22;\n  float lenMulFill = mix(1.4, 2.0, uStrokeAnisotropy);\n  float widMulFill = mix(0.50, 0.38, uStrokeAnisotropy);\n  int fillShape = (mode == 1) ? 3 : 2; // knife=even, others=dab (round fills)\n  StrokeHit hFill = bestOil(p + vec2(3.9, -6.2), sFill, lenMulFill, widMulFill,\n                            jitterAmt * 1.5, 0.95, fillShape,\n                            bristleAmp * 0.6, flow, t, 8.9);\n  paintOver(result, hFill, streakFreq * 1.8, streakAmp * 0.6,\n            uImpasto * impastoAmp * 0.4 * uStrokeAmount, hardness * 0.9, 8.9);\n\n  // Optional crosshatch layer\n  if (uStrokeLayers == 2) {\n    vec2 flow2 = vec2(-flow.y, flow.x);\n    StrokeHit hX = bestOil(p + vec2(7.3, -2.1), sMed, lenMulMed * 0.9, widMulMed,\n                           jitterAmt, densityMed * 0.7, shapeType, bristleAmp, flow2, t, 6.5);\n    paintOver(result, hX, streakFreq, streakAmp * 0.85,\n              uImpasto * impastoAmp * 0.55 * uStrokeAmount, hardness, 6.5);\n  }\n\n  // Canvas tooth \u2014 linen weave\n  float tooth1 = vnoise(p * toothScale);\n  float tooth2 = vnoise(p * toothScale * vec2(0.6, 2.4) + 37.0);\n  float tooth  = (0.6 * tooth1 + 0.4 * tooth2) - 0.5;\n  result *= 1.0 + tooth * toothAmp * uCanvasGrain;\n\n  // Pigment saturation boost\n  result = saturate3(result, pigmentSat);\n\n  return result;\n}\n\n// \u2500\u2500 Main \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nvoid main() {\n  // Normalized 0..1 coordinates for nuclei, domain warp, and medium sampling.\n  vec2 uv = vUv;\n  vec2 pN = uv;\n\n  float t = uTime;\n\n  // Warp in pN space\n  vec2 p_warp = domainWarp(pN, t);\n\n  // Composition\n  float paletteId; float valueMod;\n  nucleiField(p_warp, t, paletteId, valueMod);\n  vec3 col = samplePalette(paletteId);\n  col *= 1.0 + uValueVariance * valueMod;\n\n  // Breath \u2014 slow global luminance wobble\n  float breath = sin(t * 6.2831 / max(uBreathPeriod, 1.0));\n  col *= 1.0 + uBreathDepth * breath * 0.5;\n\n  // Medium\n  if (uMedium == 1) col = mediumPastel(col, pN, t);\n  else if (uMedium == 2) col = mediumWatercolor(col, pN, t);\n  else if (uMedium == 3) col = mediumOil(col, pN, t);\n\n  // Saturation trim\n  col = saturate3(col, uSaturation);\n\n  // Tonemap + film grain\n  col = aces(col);\n  float grain = hash21(gl_FragCoord.xy + t * 17.0);\n  col += (grain - 0.5) * uPaperGrain;\n\n  col = clamp(col * 0.985 + 0.008, 0.0, 1.0);\n  fragColor = vec4(col * uAlpha, uAlpha);\n}\n";

package/dist/composables/dom/useBreakpoint.d.ts

@@ -1,38 +0,0 @@
-import { type Ref } from "vue";
-export interface UseBreakpointControls {
-    /** Live `matches` state for the given media query. */
-    readonly matches: Readonly<Ref<boolean>>;
-    /** Tear down the `matchMedia` listener. Auto-called on scope dispose. */
-    stop: () => void;
-}
-/**
- * `useBreakpoint(query)` — a reactive read of a CSS media query's `matches`
- * state, kept live across resize / orientation / display-mode changes.
- *
- * Wraps `window.matchMedia(query)`, subscribes a single `change` handler,
- * and mirrors `mql.matches` into a `Ref<boolean>`. Auto-cleans on Vue scope
- * disposal (mirrors `useResizeObserver` / `useInterval` upstream); outside
- * a scope callers use the returned `stop()` control.
- *
- * SSR-safe: when `window` is undefined the composable returns a
- * permanently-`false` ref. Consumers should treat the initial frame as
- * "mobile-first / narrow-default" because the matchMedia subscription only
- * mounts client-side. This is the same shape consumers wrote by hand at the
- * speedtest origin sites.
- *
- * Why this exists (speedtest origin, glass-ui promotion W6-β): the survey
- * cockpit (`SurveyWizard.vue`) and the admin data-source toggle
- * (`AdminDataSourceToggle.vue`) both hand-rolled the same `matchMedia`
- * subscribe-on-mount + tear-down-on-unmount pattern. Two hand-rolls of one
- * pattern is the `feedback_generic_components` 2-consumer trigger;
- * absorbed publisher-side per `feedback_library_gaps`.
- *
- * Usage:
- *   const { matches: isDesktop } = useBreakpoint("(min-width: 720px)");
- *   const wide = isDesktop.value;  // live across resize.
- *
- * @param query A CSS `@media` query string, e.g. `"(min-width: 720px)"`.
- * @returns Object with `matches: Ref<boolean>` and `stop()` for manual
- *          disposal outside a Vue scope.
- */
-export declare function useBreakpoint(query: string): UseBreakpointControls;

package/dist/composables/dom/useIdleReady.d.ts

@@ -1,63 +0,0 @@
-import { type Ref } from "vue";
-export interface UseIdleReadyOptions {
-    /**
-     * `requestIdleCallback` timeout, in ms. Default 2_000 — the canonical
-     * value at every speedtest hand-rolled site (App.vue + useIPInfo both
-     * pass `{ timeout: 2000 }`). Unlike useViewportReady's 10s (which fronts
-     * the budget with an IO gate), useIdleReady has no visibility stage, so
-     * the timeout is the only ceiling — 2s matches the consumer sites and
-     * keeps the deferred work inside a reasonable post-paint window.
-     */
-    timeout?: number;
-    /**
-     * Optional task run the moment the gate flips (the scope-aware variant —
-     * useIPInfo's `() => void refresh()`). Runs exactly once; auto-cancelled
-     * on scope dispose with the rIC handle so a short-lived consumer cannot
-     * leak a deferred write to disposed refs. Consumers that only need the
-     * `ready` ref omit it.
-     */
-    onReady?: () => void;
-}
-export interface UseIdleReadyControls {
-    /** Flips `false → true` exactly once on the first idle tick (post-mount). */
-    readonly ready: Ref<boolean>;
-    /** Tear down the pending idle/timer handle. Auto-called on scope dispose. */
-    stop: () => void;
-}
-/**
- * `useIdleReady(options?)` — `requestIdleCallback` (+ `setTimeout(0)` Safari
- * fallback) post-mount idle gate that flips a `Ref<boolean>` exactly once on
- * the first idle tick, and optionally runs an `onReady` task at that moment.
- *
- * The rIC-only sibling of `useViewportReady` — same one-shot `ready` ref +
- * `stop()` shape, same auto-dispose discipline — minus the
- * `IntersectionObserver` visibility stage. The gate is "idle, full stop", not
- * "visible AND idle"; reach for it when there is no element to gate on (a
- * top-level lazy mount, a composable's first-idle data fetch).
- *
- * Two unified use shapes:
- *
- *   1. `ready`-flag — `v-if`-gate a heavy mount on the returned ref:
- *        const { ready } = useIdleReady();
- *        // <Aurora v-if="ready" />
- *   2. scope-aware task — run a callback on first idle, cancelled on dispose:
- *        useIdleReady({ onReady: () => void refresh() });
- *      The handle is auto-cancelled on Vue scope disposal so a short-lived
- *      consumer cannot leak a deferred write to disposed refs.
- *
- * The composable schedules synchronously at call time (NOT inside an
- * `onMounted`) so it works outside a component too (e.g. inside `useIPInfo`,
- * a composable not a component). SSR / non-browser flips synchronously so
- * consumers don't stall.
- *
- * Why this exists (speedtest origin, glass-ui promotion AO.W3): the gate is
- * hand-rolled at 5 speedtest sites (App.vue, MapView.vue, DashboardMap.vue,
- * useAutoStart.ts, useIPInfo.ts) — the ≥2-consumer substrate-promotion gate
- * (J inv 10 / L inv 8) fires for a publisher-side absorption.
- *
- * @param options.timeout Default `2000` ms — forwarded to `requestIdleCallback`.
- * @param options.onReady Optional one-shot task run on the idle flip.
- * @returns Object with `ready: Ref<boolean>` (flips false → true once) and
- *          `stop()` for manual disposal outside a Vue scope.
- */
-export declare function useIdleReady(options?: UseIdleReadyOptions): UseIdleReadyControls;

package/dist/composables/dom/useViewportReady.d.ts

@@ -1,87 +0,0 @@
-import { type Ref } from "vue";
-/**
- * Structural Ref shape — accepts the consumer's `Ref<T>` regardless of which
- * `@vue/reactivity` package the brand symbol comes from. Glass-ui may sit at
- * a different vue minor than the consumer, and Vue 3.5's `[RefSymbol]`
- * phantom is nominal-by-package; structural-by-`.value` is the correct
- * contract for a consumer-facing API. Same shape `useResizeObserver` uses.
- */
-type RefLike<T> = {
-    value: T;
-};
-export interface UseViewportReadyOptions {
-    /**
-     * IntersectionObserver `rootMargin`. Default `"200px"` so the gate flips
-     * before the host actually crosses the viewport edge — gives the
-     * consumer a quiet window for lazy-mount (`echarts`, `<canvas>` re-init,
-     * heavy widget hydration) to land off the LCP frame.
-     */
-    rootMargin?: string;
-    /**
-     * `requestIdleCallback` timeout, in ms. Default 10_000.
-     *
-     * Why 10s and not the conventional 1–2s: a cold-loading consumer (slow
-     * throughput, weak device) may not sustainably idle inside a 1–2s
-     * window — the timeout fires inside the LCP measurement window and
-     * defeats the IO gate's "wait for viewport AND idle main thread"
-     * semantic. The IO gate fronts the budget, so the timeout only fires
-     * after intersection has already resolved; ten seconds gives the main
-     * thread room to idle naturally.
-     */
-    idleTimeout?: number;
-    /**
-     * IntersectionObserver `threshold`. Default 0.01 (1 % visible). Mirrors
-     * the speedtest origin-site semantic — "any pixel visible counts".
-     */
-    threshold?: number;
-}
-export interface UseViewportReadyControls {
-    /** Flips `false → true` exactly once when the host is visible + idle. */
-    readonly ready: Ref<boolean>;
-    /** Tear down observer + idle handle. Auto-called on scope dispose. */
-    stop: () => void;
-}
-/**
- * `useViewportReady(host)` — two-stage `IntersectionObserver` +
- * `requestIdleCallback` gate that flips a `Ref<boolean>` exactly once when
- * the host element has entered the viewport AND the main thread has idled.
- *
- * The intended use is lazy-mount of a heavy widget (echarts, leaflet,
- * three.js, codemirror, custom canvas) that would otherwise pull its chunk
- * into the first-paint critical path. The two-stage gate ensures:
- *
- *   1. Visibility-first — `IntersectionObserver` watches `host`. Until the
- *      host crosses into the viewport (+ `rootMargin`), no fetch fires.
- *   2. Idle-second — once visible, `requestIdleCallback` schedules the flip
- *      so the chunk fetch waits for an idle main thread. Safari (no rIC)
- *      falls back to `setTimeout(fire, 16)` — one frame later — so the
- *      composition still defers past the IO callback's paint frame.
- *
- * The composable is one-shot: once the gate flips to `true` it disconnects
- * its observer and clears any pending idle handle. Auto-cleans on Vue scope
- * disposal (mirrors `useResizeObserver` / `useInterval` upstream); outside
- * a scope callers receive the manual `stop()` control.
- *
- * Why this exists (speedtest origin, glass-ui promotion AJ.W6-α): both
- * `AdminOverviewView` and `ChartsView` shipped a near-identical `chartReady`
- * flag flipped by `requestIdleCallback` alone. The W3-R1 idiom in those
- * sites — gate visibility first, then schedule rIC inside the IO callback —
- * is generic across heavy-widget hydration; the speedtest 2-consumer trigger
- * fired for a publisher-side absorption per `feedback_generic_components`.
- *
- * Usage:
- *   const host = ref<HTMLElement | null>(null);
- *   const { ready } = useViewportReady(host);
- *   // <Chart v-if="ready" /> — fetched lazily once host is visible + idle.
- *
- * @param host A `Ref<Element | null>` for the element to gate visibility on.
- *             The observer watches THIS element, not the lazy-mounted
- *             widget (which doesn't exist pre-flip).
- * @param options.rootMargin Default `"200px"`.
- * @param options.idleTimeout Default `10000` ms.
- * @param options.threshold   Default `0.01`.
- * @returns Object with `ready: Ref<boolean>` (flips false → true once) and
- *          `stop()` for manual disposal outside a Vue scope.
- */
-export declare function useViewportReady(host: RefLike<Element | null>, options?: UseViewportReadyOptions): UseViewportReadyControls;
-export {};