@mkbabb/glass-ui 8.0.0 → 9.0.0

package/dist/color.wgsl-BTszLY39.js

@@ -0,0 +1,398 @@
+import { n as e, t } from "./createCanvasLifecycle-hJHobVTn.js";
+import { a as n, i as r, o as i, r as a } from "./rendererStatus-BxUlBLVy.js";
+//#region src/composables/glass/webgl/useWebGLCanvas.ts
+function o() {
+	if (typeof document > "u") return null;
+	let e = null;
+	try {
+		if (e = document.createElement("canvas").getContext("webgl2"), !e) return null;
+		let t = e.getExtension("WEBGL_debug_renderer_info");
+		return t ? String(e.getParameter(t.UNMASKED_RENDERER_WEBGL) ?? "").toLowerCase() : null;
+	} catch {
+		return null;
+	} finally {
+		e?.getExtension("WEBGL_lose_context")?.loseContext();
+	}
+}
+function s(e, n) {
+	let { setup: r, contextAttrs: i } = n, a = null, o = null;
+	function s() {
+		let t = e.getContext("webgl2", i ?? void 0);
+		if (!t) throw Error("[useWebGLCanvas] WebGL2 unavailable");
+		return a = t, o = r(a), {
+			frame: o.frame,
+			shouldContinue: o.shouldContinue,
+			time: o.time,
+			teardown: () => {
+				o?.teardown?.(), a?.getExtension("WEBGL_lose_context")?.loseContext(), a = null, o = null;
+			}
+		};
+	}
+	let c = null, l = null;
+	function u(e) {
+		e.preventDefault(), a = null, o = null, l?.();
+	}
+	let d = t({
+		canvas: e,
+		mode: n.mode,
+		respectReducedMotion: n.respectReducedMotion,
+		dprPolicy: n.dprPolicy,
+		composeIntersectionPark: n.composeIntersectionPark,
+		intersectionRootMargin: n.intersectionRootMargin,
+		revealBloom: n.revealBloom,
+		onContextStateChange: n.onContextStateChange,
+		onContextError: n.onContextError,
+		buildContext: s,
+		resize: (e) => o?.resize(e),
+		bindContextEvents: (t, n) => {
+			c = t, l = n, e.addEventListener("webglcontextlost", u, !1), e.addEventListener("webglcontextrestored", c, !1);
+		},
+		unbindContextEvents: () => {
+			e.removeEventListener("webglcontextlost", u, !1), c && e.removeEventListener("webglcontextrestored", c, !1);
+		}
+	});
+	return {
+		arm: d.arm,
+		presize: d.presize,
+		suspend: d.suspend,
+		resume: d.resume,
+		wake: d.wake,
+		renderAt: d.renderAt,
+		dispose: d.dispose,
+		get gl() {
+			return a;
+		},
+		get reducedMotion() {
+			return d.reducedMotion;
+		}
+	};
+}
+//#endregion
+//#region src/composables/glass/webgpu/webgpuDevice.ts
+var c = class extends Error {
+	kind;
+	constructor(e, t, n) {
+		super(t), this.name = "WebGPUInitError", this.kind = e, n !== void 0 && (this.cause = n);
+	}
+};
+function l(e) {
+	try {
+		let t = e.info;
+		if (t?.isFallbackAdapter || e.isFallbackAdapter) return !0;
+		if (!t) return !1;
+		let n = [
+			t.vendor,
+			t.architecture,
+			t.description
+		].filter((e) => typeof e == "string").join(" ").toLowerCase();
+		return n.includes("swiftshader") || n.includes("llvmpipe") || n.includes("software") || n.includes("basic render") || n.includes("microsoft basic");
+	} catch {
+		return !1;
+	}
+}
+var u = 6e3;
+function d(e, t) {
+	if (typeof setTimeout > "u") return e;
+	let n, r = new Promise((e, r) => {
+		n = setTimeout(() => {
+			r(new c("acquire-timeout", `[useWebGPUCanvas] ${t}() did not settle within ${u}ms — falling to the WebGL2 net`));
+		}, u);
+	});
+	return Promise.race([e, r]).finally(() => clearTimeout(n));
+}
+//#endregion
+//#region src/composables/glass/webgpu/useWebGPUCanvas.ts
+function f() {
+	return typeof navigator < "u" && "gpu" in navigator && navigator.gpu != null;
+}
+var p = null;
+function m(e, t) {
+	if (p) return p;
+	if (!f()) return Promise.reject(new c("no-navigator-gpu", "[useWebGPUCanvas] navigator.gpu unavailable"));
+	let n = (async () => {
+		let i = await d(navigator.gpu.requestAdapter(e), "requestAdapter");
+		if (!i) throw new c("no-adapter", "[useWebGPUCanvas] no GPU adapter");
+		if (l(i)) throw new c("software-adapter", "[useWebGPUCanvas] software WebGPU adapter (SwiftShader/llvmpipe/fallback) — falling to the WebGL2 net");
+		let a;
+		try {
+			a = await d(i.requestDevice(t), "requestDevice");
+		} catch (e) {
+			throw e instanceof c ? e : new c("device-request", "[useWebGPUCanvas] requestDevice rejected", e);
+		}
+		return a.lost.then(() => {
+			p === n && (p = null);
+		}), {
+			device: a,
+			adapterClass: r(i.info)
+		};
+	})();
+	return n.catch(() => {
+		p === n && (p = null);
+	}), p = n, n;
+}
+function h(n, r) {
+	let { setup: i } = r, a = r.alphaMode ?? "premultiplied", o = null, s = null, l = "bgra8unorm", u = null, d = !1, p = null, h = null, g = "Acquiring adapter", _ = null, v = null, y = null;
+	function b() {
+		if (!o) throw Error("[useWebGPUCanvas] device not acquired");
+		let e = n.getContext("webgpu");
+		if (!e) throw Error("[useWebGPUCanvas] WebGPU context unavailable");
+		return s = e, l = navigator.gpu.getPreferredCanvasFormat(), e.configure({
+			device: o,
+			format: l,
+			alphaMode: a
+		}), o.pushErrorScope("validation"), o.addEventListener("uncapturederror", x), u = i(o, s, l), C(), y = o.popErrorScope(), y.then((e) => {
+			e && r.onInitError?.(e);
+		}), {
+			frame: (e) => u?.frame(e),
+			shouldContinue: () => u?.shouldContinue() ?? !1,
+			time: (e) => u?.time?.(e) ?? e,
+			teardown: S
+		};
+	}
+	function x(e) {
+		let t = e.error;
+		r.onInitError?.(t);
+	}
+	function S() {
+		u?.teardown?.(), o?.removeEventListener("uncapturederror", x), s?.unconfigure(), s = null, u = null, y = null;
+	}
+	function C() {
+		try {
+			u?.resize(e(n, r.dprPolicy)), u?.frame(0);
+		} catch {}
+	}
+	let w = t({
+		canvas: n,
+		mode: r.mode,
+		respectReducedMotion: r.respectReducedMotion,
+		dprPolicy: r.dprPolicy,
+		composeIntersectionPark: r.composeIntersectionPark,
+		intersectionRootMargin: r.intersectionRootMargin,
+		revealBloom: r.revealBloom,
+		onContextStateChange: (e) => {
+			if (e === "lost") {
+				r.onContextStateChange?.(e);
+				return;
+			}
+			let t = y;
+			if (!t) {
+				r.onContextStateChange?.(e);
+				return;
+			}
+			t.then((n) => {
+				!d && !n && y === t && r.onContextStateChange?.(e);
+			});
+		},
+		onContextError: (e) => r.onInitError?.(e),
+		buildContext: b,
+		resize: (e) => u?.resize(e),
+		bindContextEvents: (e, t) => {
+			_ = e, v = t;
+		},
+		unbindContextEvents: () => {
+			_ = null, v = null;
+		}
+	});
+	async function T() {
+		if (!f()) throw new c("no-navigator-gpu", "[useWebGPUCanvas] navigator.gpu unavailable");
+		let e = await m(r.adapterOptions, r.deviceDescriptor);
+		o = e.device, g = e.adapterClass, E(e.device);
+	}
+	function E(e) {
+		e.lost.then((e) => {
+			if (!d) {
+				if (v?.(), S(), o = null, e.reason === "destroyed") {
+					let t = /* @__PURE__ */ Error(`[useWebGPUCanvas] device destroyed${e.message ? ` (${e.message})` : ""}`);
+					h = t, r.onInitError?.(t);
+					return;
+				}
+				T().then(() => {
+					d || _?.();
+				}).catch((e) => {
+					h = e, r.onInitError?.(e);
+				});
+			}
+		});
+	}
+	async function D() {
+		if (!d) {
+			if (h) throw h;
+			if (p) return p;
+			if (o) {
+				w.arm();
+				return;
+			}
+			return w.presize(), p = (async () => {
+				try {
+					if (await T(), d) return;
+					if (w.arm(), y) {
+						let e = r.mode !== "capture";
+						e && w.suspend("manual");
+						let t = await y;
+						if (d) return;
+						if (t) throw new c("pipeline-validation", `[useWebGPUCanvas] pipeline failed validation (${t.message})`);
+						e && w.resume("manual");
+					}
+				} catch (e) {
+					throw h = e, S(), e instanceof c || r.onInitError?.(e), e;
+				} finally {
+					p = null;
+				}
+			})(), p;
+		}
+	}
+	return {
+		armAsync: D,
+		arm: () => {
+			o && w.arm();
+		},
+		presize: w.presize,
+		suspend: w.suspend,
+		resume: w.resume,
+		wake: w.wake,
+		renderAt: w.renderAt,
+		dispose: () => {
+			d = !0, w.dispose(), o = null;
+		},
+		get device() {
+			return o;
+		},
+		get adapterClass() {
+			return g;
+		},
+		get reducedMotion() {
+			return w.reducedMotion;
+		}
+	};
+}
+//#endregion
+//#region src/composables/glass/webgpu/useGpuSubstrate.ts
+function g(e, t) {
+	let r;
+	return r = s(e, {
+		mode: t.mode,
+		respectReducedMotion: t.respectReducedMotion,
+		contextAttrs: t.contextAttrs,
+		dprPolicy: t.dprPolicy,
+		composeIntersectionPark: t.composeIntersectionPark,
+		intersectionRootMargin: t.intersectionRootMargin,
+		revealBloom: t.revealBloom,
+		onContextStateChange: (e) => {
+			t.onStatus?.(e === "lost" ? n("webgl2") : {
+				phase: "ready",
+				engine: "webgl2",
+				adapter: a(r.gl)
+			});
+		},
+		setup: t.setupGL,
+		onContextError: (e) => {
+			t.onStatus?.(i("webgl2", "WebGL 2 context", e)), t.onInitError?.(e);
+		}
+	}), r;
+}
+function _(e, t) {
+	let r = f() && t.setupWGPU != null, o = null, s = null, l = r ? "webgpu" : "webgl2", u = !1, d = (e) => t.onStatus?.(e), p = (e, t, r) => d(e === "lost" ? n(t) : {
+		phase: "ready",
+		engine: t,
+		adapter: r()
+	});
+	d(n(l)), r ? o = h(e, {
+		mode: t.mode,
+		respectReducedMotion: t.respectReducedMotion,
+		dprPolicy: t.dprPolicy,
+		composeIntersectionPark: t.composeIntersectionPark,
+		intersectionRootMargin: t.intersectionRootMargin,
+		revealBloom: t.revealBloom,
+		setup: t.setupWGPU,
+		alphaMode: t.alphaMode,
+		adapterOptions: t.adapterOptions,
+		deviceDescriptor: t.deviceDescriptor,
+		onContextStateChange: (e) => {
+			p(e, "webgpu", () => o?.adapterClass ?? "Hardware adapter");
+		},
+		onInitError: (e) => {
+			d(i("webgpu", o?.adapterClass ?? "Hardware adapter", e)), t.onInitError?.(e);
+		}
+	}) : s = g(e, t);
+	function m(r) {
+		o?.dispose(), o = null, l = "webgl2", d(n("webgl2")), t.onBackendFallback?.({
+			from: "webgpu",
+			to: "webgl2",
+			error: r
+		});
+		try {
+			s = g(e, t), s.arm(), d({
+				phase: "ready",
+				engine: "webgl2",
+				adapter: a(s.gl)
+			});
+		} catch (e) {
+			throw s = null, d(i("webgl2", "WebGL 2 context", e)), t.onInitError?.(e), e;
+		}
+	}
+	async function _() {
+		if (!u) {
+			if (v(), o) try {
+				await o.armAsync(), d({
+					phase: "ready",
+					engine: "webgpu",
+					adapter: o.adapterClass
+				});
+				return;
+			} catch (e) {
+				if (u) return;
+				if (e instanceof c && e.kind !== "pipeline-validation") {
+					m(e);
+					return;
+				}
+				throw d(i("webgpu", o.adapterClass, e)), e;
+			}
+			try {
+				s?.arm(), d({
+					phase: "ready",
+					engine: "webgl2",
+					adapter: a(s?.gl ?? null)
+				});
+			} catch (e) {
+				throw d(i("webgl2", "WebGL 2 context", e)), t.onInitError?.(e), e;
+			}
+		}
+	}
+	function v() {
+		u || (o?.presize(), s?.presize());
+	}
+	function y() {
+		u || (v(), o?.arm(), s?.arm());
+	}
+	return {
+		get backend() {
+			return l;
+		},
+		armAsync: _,
+		arm: y,
+		presize: v,
+		suspend: (e) => {
+			o?.suspend(e), s?.suspend(e);
+		},
+		resume: (e) => {
+			o?.resume(e), s?.resume(e);
+		},
+		wake: () => {
+			o?.wake(), s?.wake();
+		},
+		renderAt: (e) => {
+			o?.renderAt(e), s?.renderAt(e);
+		},
+		dispose: () => {
+			u = !0, o?.dispose(), s?.dispose(), o = null, s = null;
+		},
+		get reducedMotion() {
+			return (o ?? s)?.reducedMotion ?? !1;
+		}
+	};
+}
+//#endregion
+//#region src/composables/glass/procedural/color.wgsl.ts
+var v = "\nfn srgbToLinearCh(c: f32) -> f32 {\n  if (c <= 0.04045) { return c / 12.92; }\n  return pow((c + 0.055) / 1.055, 2.4);\n}\nfn srgbToLinear(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\n\nfn linearToSrgbCh(c: f32) -> f32 {\n  if (c <= 0.0031308) { return c * 12.92; }\n  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\nfn linearToSrgb(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}", y = "const FBM_ROT: mat2x2<f32> = mat2x2<f32>(0.8, 0.6, -0.6, 0.8);", b = "\n// value.js LINEAR_SRGB_TO_LMS, row-major → WGSL columns (= the transpose).\nconst LINEAR_SRGB_TO_LMS: mat3x3<f32> = mat3x3<f32>(\n  0.4122214708, 0.2119034982, 0.0883024619,\n  0.5363325363, 0.6806995451, 0.2817188376,\n  0.0514459929, 0.1073969566, 0.6299787005\n);\n\n// value.js srgbToOKLab's INLINE LMS→OKLab coefficients, row-major → WGSL columns.\nconst LMS_TO_OKLAB: mat3x3<f32> = mat3x3<f32>(\n  0.2104542553, 1.9779984951, 0.0259040371,\n  0.7936177850, -2.4285922050, 0.7827717662,\n  -0.0040720468, 0.4505937099, -0.8086757660\n);\n\n// value.js OKLAB_TO_LMS_COEFF, row-major → WGSL columns.\nconst OKLAB_TO_LMS: mat3x3<f32> = mat3x3<f32>(\n  1.0, 1.0, 1.0,\n  0.3963377774, -0.1055613458, -0.0894841775,\n  0.2158037573, -0.0638541728, -1.2914855480\n);\n\n// value.js LMS_TO_LINEAR_SRGB, row-major → WGSL columns.\nconst LMS_TO_LINEAR_SRGB: mat3x3<f32> = mat3x3<f32>(\n  4.0767416621, -1.2684380046, -0.0041960863,\n  -3.3077115913, 2.6097574011, -0.7034186147,\n  0.2309699292, -0.3413193965, 1.7076147010\n);\n\nfn cbrt3(v: vec3<f32>) -> vec3<f32> {\n  return sign(v) * pow(abs(v), vec3<f32>(1.0 / 3.0));\n}\n\n// Gamma sRGB → raw OKLab (L, a, b). Mirrors value.js srgbToOKLab.\nfn srgbToOklab(c: vec3<f32>) -> vec3<f32> {\n  let lin = srgbToLinear(c);\n  let lms = LINEAR_SRGB_TO_LMS * lin;\n  return LMS_TO_OKLAB * cbrt3(lms);\n}\n\n// Raw OKLab (L, a, b) → linear sRGB. Mirrors value.js oklabToLinearSRGB.\nfn oklabToLinearSrgb(lab: vec3<f32>) -> vec3<f32> {\n  let lms_ = OKLAB_TO_LMS * lab;\n  let lms = lms_ * lms_ * lms_;\n  return LMS_TO_LINEAR_SRGB * lms;\n}\n\n// OKLab → OKLCh: H in RADIANS, folded to [0, 2pi). Mirrors value.js rawOklabToOklch.\nfn oklabToOklch(lab: vec3<f32>) -> vec3<f32> {\n  let C = length(lab.yz);\n  var H = atan2(lab.z, lab.y);\n  if (H < 0.0) { H = H + 2.0 * PI; }\n  return vec3<f32>(lab.x, C, H);\n}\n\n// OKLCh (H radians) → OKLab. Mirrors value.js rawOklchToOklab.\nfn oklchToOklab(lch: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}", x = "\n// value.js interpolateHue in the NORMALIZED-TURNS domain. methods: 0 shorter,\n// 1 longer, 2 increasing, 3 decreasing.\nfn interpolateHueTurns(h0: f32, h1: f32, t: f32, method: i32) -> f32 {\n  let TAU = 2.0 * PI;\n  var a = h0 / TAU;\n  var b = h1 / TAU;\n  let i = b - a;\n  if (method == 0) {              // shorter\n    if (i > 0.5) { a = a + 1.0; } else if (i < -0.5) { b = b + 1.0; }\n  } else if (method == 1) {       // longer\n    if (i > 0.0 && i < 0.5) { a = a + 1.0; } else if (i > -0.5 && i <= 0.0) { b = b + 1.0; }\n  } else if (method == 2) {       // increasing\n    if (i < 0.0) { b = b + 1.0; }\n  } else {                        // decreasing\n    if (i > 0.0) { a = a + 1.0; }\n  }\n  var r = a + t * (b - a);\n  r = fract(r);                   // fract is non-negative in WGSL\n  return r * TAU;                 // back to radians\n}\n\n// Linear-sRGB endpoint pair → OKLab-rectangular interpolation → linear sRGB.\nfn mixPaletteOklab(linA: vec3<f32>, linB: vec3<f32>, t: f32) -> vec3<f32> {\n  let labA = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * linA);\n  let labB = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * linB);\n  let lab = mix(labA, labB, t);\n  return oklabToLinearSrgb(lab);\n}\n\n// Linear-sRGB endpoint pair → OKLCh hue-arc interpolation → linear sRGB.\nfn mixPaletteOklchArc(linA: vec3<f32>, linB: vec3<f32>, t: f32, method: i32) -> vec3<f32> {\n  let labA = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * linA);\n  let labB = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * linB);\n  let lchA = oklabToOklch(labA);\n  let lchB = oklabToOklch(labB);\n  let L = mix(lchA.x, lchB.x, t);\n  let C = mix(lchA.y, lchB.y, t);\n  let H = interpolateHueTurns(lchA.z, lchB.z, t, method);\n  return oklabToLinearSrgb(oklchToOklab(vec3<f32>(L, C, H)));\n}\n\n// The ramp dispatcher (the samplePalette splices it). tRaw is the raw inter-stop\n// parameter [0,1]; the smoothstep ease + the huePath branch live here so the ramp is\n// one source. increasing(2)/decreasing(3) take the OKLCh hue-arc; every other method\n// takes the OKLab-rectangular straight line.\nfn samplePaletteRamp(a: vec3<f32>, b: vec3<f32>, tRaw: f32, huePath: i32) -> vec3<f32> {\n  let t = smoothstep(0.0, 1.0, tRaw);\n  if (huePath == 2 || huePath == 3) {\n    return mixPaletteOklchArc(a, b, t, huePath);\n  }\n  return mixPaletteOklab(a, b, t);\n}";
+//#endregion
+export { _ as a, x as i, v as n, o, b as r, y as t };

package/dist/{command-BuBnYpxF.js → command-tEzAaVY_.js}

@@ -3,7 +3,7 @@ import { t } from "./primitive-B2t2jdqM.js";
 import { t as n } from "./selection-DqIULxRG.js";
 import { n as r, t as i } from "./DialogContent-4hzLiaCQ.js";
 import { t as a } from "./rowClass-DYOXwxhO.js";
-import { t as o } from "./participation-B0hdsIRo.js";
+import { t as o } from "./participation-Di4UHbzk.js";
 import { computed as s, createBlock as c, createCommentVNode as l, createElementBlock as u, createTextVNode as d, createVNode as f, defineComponent as p, mergeProps as m, normalizeClass as h, openBlock as g, renderSlot as _, toDisplayString as v, unref as y, useAttrs as b, withCtx as x } from "vue";
 import { ComboboxContent as S, ComboboxEmpty as C, ComboboxGroup as w, ComboboxInput as T, ComboboxItem as E, ComboboxLabel as D, ComboboxRoot as O, ComboboxSeparator as k } from "reka-ui";
 import { Search as A } from "@lucide/vue";

package/dist/command.js

@@ -1,2 +1,2 @@
-import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c } from "./command-BuBnYpxF.js";
+import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c } from "./command-tEzAaVY_.js";
 export { r as Command, t as CommandDialog, s as CommandEmpty, a as CommandGroup, e as CommandInput, n as CommandItem, o as CommandList, i as CommandSeparator, c as CommandShortcut };

package/dist/components/_shared/control.d.ts

@@ -1,5 +1,4 @@
 export type ControlSize = "sm" | "md" | "lg";
-export declare const controlSizeClass: (size?: ControlSize) => string;
 /** The state axis every binary control exposes. */
 export interface ControlProps {
     invalid?: boolean;

package/dist/components/_shared/index.d.ts

@@ -1,2 +1 @@
-export { controlSizeClass } from "./control.js";
 export type { ControlSize } from "./control.js";

package/dist/components/aurora/Aurora.vue.d.ts

@@ -91,6 +91,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
     pause: () => void;
     resume: () => void;
     isArmed: Readonly<import("vue").Ref<boolean, boolean>>;
+    isSettled: Readonly<import("vue").Ref<boolean, boolean>>;
     rendererStatus: Readonly<import("vue").Ref<RendererStatus, RendererStatus>>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     rendererStatus: (status: RendererStatus) => any;

package/dist/components/aurora/composables/frameLoop.d.ts

@@ -11,14 +11,15 @@
  *
  * `drawFrame` re-sends the per-frame cursor + time uniforms and issues the single
  * full-screen-triangle draw. `needsAnimation` is the demand gate: `false` under
- * reduced-motion (the static frame draws once, then parks), `false` at steady-state (all
- * four drift uniforms 0 AND the field settled — the next frame is pixel-identical), and
- * `true` while drift is live or the field is still easing (engagement, speed, burst,
- * attractor motion above ε).
+ * reduced-motion (the static frame draws once, then parks), `false` at steady-state (no
+ * drift axis above its own amplitude floor AND the field settled — the next frame is
+ * pixel-identical), and `true` while drift is live or the field is still easing
+ * (engagement, speed, burst, attractor motion above ε). The drift half is
+ * `isAuroraDriftLive` — the ONE predicate this loop and both WGSL loops share.
  */
 import type { UniformLocations } from "./glSetup.js";
 import type { AuroraCursorUniforms } from "./uniformBridge.js";
-import type { AuroraConfig } from "../constants/presets.js";
+import { type AuroraConfig } from "../constants/presets.js";
 import type { UsePointerVelocityField } from "../../../composables/motion/pointer/usePointerVelocityField.js";
 /** The at-rest scalars a config-less cursor read seeds (strength ceiling + influence radius). */
 export interface AuroraCursorScalars {

package/dist/components/aurora/composables/runtime.d.ts

@@ -75,6 +75,20 @@ export interface AuroraRuntimeOptions {
      * threaded through both seams.
      */
     forceWebGLUnderSoftwareRaster?: boolean;
+    /**
+     * Pin the render backend instead of letting the substrate picker choose.
+     *
+     * `"webgl2"` withholds the WGSL setup from `createGpuSubstrate`, which is the ONLY
+     * honest way to reach the WebGL2 arm in-app: the picker's `attemptWebGPU` reads
+     * `supportsWebGPU() && setupWGPU != null`, so a browser flag cannot express this and
+     * `renderMode: "webgl"` is a MODE (animate at all / never), not a backend.
+     *
+     * The capture harness drives it as `?engine=webgl2` so the GL arm can be archived
+     * before it is deleted. There is no `"webgpu"` member: forcing WebGPU on a host
+     * without an adapter would be a masking fallback — the picker already prefers it and
+     * falls loud when it cannot arm.
+     */
+    forceBackend?: "webgl2";
     /**
      * Reveal-bloom consumer door.
      *
@@ -131,7 +145,18 @@ export interface AuroraRuntime extends Omit<AuroraInstance, "pause" | "resume">
     /** Live reduced-motion state; the cursor listener early-outs on it. */
     readonly reducedMotion: boolean;
 }
-/** One medium-aware predicate shared by pointer writes and uniform projection. */
+/**
+ * One medium-aware predicate shared by pointer writes and uniform projection.
+ *
+ * `swirl` is the DEFAULT-ON axis: every aurora shapes under the pointer unless its
+ * config says `swirl: false`. Suppression is not this predicate's job — the master
+ * tempo scalar zeroes the field tick under reduced motion and under the background
+ * pause, so a PRM reader never sees the cursor regardless of what this returns.
+ *
+ * `light` stays an explicit opt-in AND stays medium-aware: it steers the impasto light
+ * direction, and the smooth body has no impasto, so `light` alone over `smooth` shapes
+ * nothing and must not arm a pointer path.
+ */
 export declare function isAuroraPointerEnabled(config: AuroraConfig): boolean;
 /** One shader-time projection shared by the WebGPU and WebGL2 bridges. */
 export declare function resolveAuroraRenderTime(config: AuroraConfig, elapsedSec: number, progress: number, reducedMotion: boolean): number;

package/dist/components/aurora/composables/useAurora.d.ts

@@ -42,8 +42,36 @@ export interface UseAuroraReturn {
      * acquisition and flips only when the backend readiness promise resolves.
      */
     isArmed: Readonly<Ref<boolean>>;
+    /**
+     * The SETTLE BEACON. `true` once the runtime has armed, the current config has been
+     * applied, and the ground→field entrance has finished painting over it.
+     *
+     * `Aurora.vue` publishes it as `data-aurora-settled`; every capture — π, gate, or a
+     * consumer's own — waits on that attribute. A wall-clock sleep is not a substitute:
+     * inside the entrance the field paints medium-INDEPENDENTLY, so an early capture
+     * reads a picture that is identical across every medium and across page loads, with
+     * perfect confidence and no way to tell. Three seats measured that picture.
+     *
+     * Any config change re-opens it — a preset switch has its own entrance. So does a
+     * context LOSS: the field it witnesses is gone, and the restore replays the entrance,
+     * so the beacon never carries its pre-loss stamp across that replay.
+     */
+    isSettled: Readonly<Ref<boolean>>;
     rendererStatus: Readonly<Ref<RendererStatus>>;
 }
+/**
+ * How long past the last applied config the field needs before a capture is admissible.
+ *
+ * The entrance is the ground→field CROSSFADE: `.aurora-canvas-layer` transitions opacity
+ * 0→1 over `--duration-slow` (0.45 s) once `isArmed` flips, dissolving the palette-derived
+ * frame-0 ground into the live field. Until that completes a capture reads a blend of the
+ * two, which is what makes it medium-independent. 500 ms clears the 450 ms token with the
+ * margin for the frame the config write lands on.
+ *
+ * The clock is advanced by `requestAnimationFrame`, not `setTimeout`, so a backgrounded
+ * or parked surface never stamps a beacon it has not painted.
+ */
+export declare const AURORA_SETTLE_MS = 500;
 /**
  * Vue-side wrapper for the imperative `createAurora` runtime.
  *

package/dist/components/aurora/composables/wgpuSetup.d.ts

@@ -15,7 +15,7 @@
 import type { WebGPUCanvasFrame } from "../../../composables/glass/webgpu/useWebGPUCanvas.js";
 import { type AuroraCursorScalars } from "./frameLoop.js";
 import { type UploadableImageSource } from "./textureUpload.js";
-import type { AuroraConfig } from "../constants/presets.js";
+import { type AuroraConfig } from "../constants/presets.js";
 import type { UsePointerVelocityField } from "../../../composables/motion/pointer/usePointerVelocityField.js";
 export interface AuroraWGPUSetupDeps {
     canvas: HTMLCanvasElement;

package/dist/components/aurora/constants/presets.d.ts

@@ -68,8 +68,13 @@ export type WarpMode = "fbm" | "cellular" | "hybrid" | "curl";
  * - `swirl`  — cursor-local warp and luminance lean on both engines.
  * - `amplitude` — sizes the transient burst folded into cursor strength on the CPU.
  * Every axis is suppressed under `prefers-reduced-motion` + the DockBackgroundToggle
- * pause (the master tempo scalar is the single suppression seam). The wispy-sky
- * default carries no `interactivity` (every axis OFF — the default stays static).
+ * pause (the master tempo scalar is the single suppression seam).
+ *
+ * `swirl` is ON by default — a config opts OUT with `swirl: false`. Every aurora is
+ * pointer-shapeable, and a capability parked behind an opt-in flag is a capability the
+ * surface does not have. `light` and `scroll` remain explicit opt-ins: `light` is only
+ * meaningful over a painterly body (smooth has no impasto to relight), and `scroll`
+ * re-times the shader clock against page position, which no surface should inherit.
  */
 export interface AuroraInteractivity {
     light?: boolean;
@@ -204,12 +209,46 @@ export interface AuroraConfig {
      */
     vividness?: number;
     /**
-     * Pointer/scroll interactivity opt-in (default OFF — the wispy-sky
-     * default stays static). Omitted = every
-     * axis off. Aliased on `/api` as part of the `AuroraConfig` surface.
+     * Pointer/scroll interactivity. `swirl` is ON unless a config says
+     * `swirl: false` — the pointer shapes every aurora by default, PRM-guarded by the
+     * master tempo scalar. `light` and `scroll` stay explicit opt-ins.
+     * Aliased on `/api` as part of the `AuroraConfig` surface.
      */
     interactivity?: AuroraInteractivity;
 }
+/**
+ * The per-axis liveness floor of the drift demand gate.
+ *
+ * The four drift axes do NOT share a domain — nuclei 0..0.05, palette 0..0.04, breath
+ * 0..0.15, warp 0..0.015 — so ONE flat epsilon over raw values would retire whole axes
+ * (any epsilon that reaches `paletteDrift` is above `warpDrift`'s entire range). Each
+ * axis therefore carries its own floor, seeded at 1% of that axis's authored domain.
+ *
+ * The floors are the SHAPE, not the cut. Cutting them where they would actually park a
+ * loop is a PAINT decision and it is `W-AURORA-FIELD`'s (π-FIELD), because the shipped
+ * configs do not separate in config space: the recessive shell field
+ * (`aurora-hero.ts` `nucleiDrift`/`paletteDrift` 0.012) and the focal studio default
+ * (0.015) sit 25% apart on both axes and are identical on the other two. What separates
+ * them is not the drift amplitude but the composited range their palettes can express —
+ * shell chroma ≤ 0.07 over an L span of 0.03 against the studio's C 0.16/0.13/0.095 —
+ * and that term is the field re-founding's to derive, not this gate's to guess.
+ */
+export declare const AURORA_DRIFT_FLOOR: {
+    readonly nucleiDrift: 0.0005;
+    readonly paletteDrift: 0.0004;
+    readonly breathDepth: 0.0015;
+    readonly warpDrift: 0.00015;
+};
+/**
+ * The demand gate over the four drift axes — the ONE predicate the WebGL2 frame loop
+ * and BOTH WGSL loops consume.
+ *
+ * It was three copies of a `!== 0` ladder, and they had already diverged: the image
+ * pipeline's copy omitted `breathDepth`, so an image-source aurora carrying breath and
+ * no drift parked its loop and never rendered the breath. Liveness is an AMPLITUDE
+ * question against each axis's own domain, never a literal comparison against zero.
+ */
+export declare function isAuroraDriftLive(config: AuroraConfig): boolean;
 /**
  * Pointer-cursor API exposed by `createAurora`. Values in 0..1 (CSS-top-origin).
  * Runtime flips Y and eases internally.

package/dist/components/aurora/index.d.ts

@@ -1,6 +1,6 @@
 export { default as Aurora } from "./Aurora.vue.js";
 export { resolveRenderMode, isSoftwareWebGLRenderer, type AuroraRenderMode, type ResolveRenderModeOptions, } from "./constants/renderMode.js";
-export { useAurora } from "./composables/useAurora.js";
+export { useAurora, AURORA_SETTLE_MS } from "./composables/useAurora.js";
 export type { UseAuroraReturn } from "./composables/useAurora.js";
 export { useCursorInteraction } from "./composables/useCursorInteraction.js";
 export { createAurora } from "./composables/runtime.js";