@mkbabb/glass-ui 3.6.0 → 3.8.0

package/dist/color-DMLTunJK.js

@@ -0,0 +1,84 @@
+import { colorUnit2 as e, gamutMapOKLab as t, interpolateHue as n, isInSRGBGamut as r, oklabToLinearSRGB as i, oklabToRgb255 as a, parseCSSColor as o, rawOklabToOklch as s, rawOklchToOklab as c, srgbToOKLab as l } from "@mkbabb/value.js";
+//#region src/composables/color/index.ts
+function u(e) {
+	let [t, n, r] = c(e.L, e.C, e.h), [a, o, s] = i(t, n, r);
+	return [
+		Math.max(0, a),
+		Math.max(0, o),
+		Math.max(0, s)
+	];
+}
+function d(e, t, n) {
+	if (!Number.isFinite(e) || !Number.isFinite(t) || !Number.isFinite(n)) throw Error(`warmCatchLight: non-finite OKLCh anchor (L=${e}, C=${t}, h=${n})`);
+	return u({
+		L: e,
+		C: t,
+		h: n
+	});
+}
+function f(e) {
+	let [t, n, r] = c(e.L, e.C, e.h), [i, o, s] = a(t, n, r), l = (e) => Math.min(1, Math.max(0, e / 255));
+	return [
+		l(i),
+		l(o),
+		l(s)
+	];
+}
+function p(t) {
+	let n = e(o(t), "rgb").value, [r, i, a] = l(Number(n.r), Number(n.g), Number(n.b)), [c, u, d] = s(r, i, a);
+	return {
+		L: c,
+		C: u,
+		h: d
+	};
+}
+function m(e) {
+	let [t, n, r] = c(e.L, e.C, e.h), [i, o, s] = a(t, n, r), l = (e) => Math.round(e).toString(16).padStart(2, "0");
+	return `#${l(i)}${l(o)}${l(s)}`;
+}
+var h = (e) => f(p(e)), g = {
+	complementary: "longer",
+	"split-complementary": "longer",
+	analogous: "shorter",
+	monochrome: "shorter",
+	triad: "increasing",
+	tetradic: "increasing"
+}, _ = (e) => (e % 360 + 360) % 360;
+function v(e, t, r, i) {
+	let a = g[t], o = (e, t) => _(n(_(e) / 360, _(t) / 360, i, a) * 360);
+	switch (t) {
+		case "monochrome": return _(e);
+		case "complementary": return o(e, e + 180);
+		case "split-complementary": return o(e + 150, e + 210);
+		case "triad": return o(e, e + 240);
+		case "tetradic": return o(e, e + 270);
+		default: return o(e - r, e + r);
+	}
+}
+function y(e) {
+	let [n, a, o] = c(e.L, e.C, e.h), [l, u, d] = t(n, a, o), [f, p, m] = s(l, u, d), h = p;
+	for (let e = 0; e < 6; e++) {
+		let [e, t, n] = c(f, h, m), [a, o, s] = i(e, t, n);
+		if (r(a, o, s)) break;
+		h *= .999;
+	}
+	return {
+		L: f,
+		C: h,
+		h: m
+	};
+}
+function b(e, t = {}) {
+	let n = typeof e == "string" ? p(e) : e, { stopCount: r = 3, harmony: i = "analogous", lightnessSpread: a = .18, hueSpread: o = 24, chromaBump: s = .03 } = t, c = Math.max(2, Math.min(4, Math.round(r))), l = [];
+	for (let e = 0; e < c; e++) {
+		let t = c === 1 ? 0 : e / (c - 1), r = n.L - a / 2 + a * t, u = Math.max(0, n.C + s * Math.sin(Math.PI * t)), d = v(n.h, i, o, t);
+		l.push(y({
+			L: Math.min(.98, Math.max(.05, r)),
+			C: u,
+			h: d
+		}));
+	}
+	return l;
+}
+//#endregion
+export { y as a, u as c, v as i, d as l, h as n, m as o, b as r, f as s, p as t };

package/dist/color.js

@@ -1,2 +1,2 @@
-import { a as e, i as t, n, r, t as i } from "./color-DS-iLRVM.js";
-export { i as cssToOklch, n as defaultBlobColorResolver, r as oklchStopToHex, t as oklchToGammaRgb, e as oklchToLinear };
+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 "./color-DMLTunJK.js";
+export { c as cssToOklch, i as defaultBlobColorResolver, o as deriveBlobPalette, n as deriveHue, e as gamutMapStop, a as oklchStopToHex, s as oklchToGammaRgb, t as oklchToLinear, r as warmCatchLight };

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 "./CommandShortcut-BiVyqipe.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 "./CommandShortcut-SzWRhROC.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/compile-BBTRjvQS.js

@@ -0,0 +1,158 @@
+//#region src/composables/glass/webgl/shaders/procedural-color.glsl.ts
+var e = "\nfloat srgbToLinearCh(float c) {\n    return c <= 0.04045 ? c / 12.92 : pow((c + 0.055) / 1.055, 2.4);\n}\nvec3 srgbToLinear(vec3 c) {\n    return vec3(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\n\nfloat linearToSrgbCh(float c) {\n    return c <= 0.0031308 ? c * 12.92 : 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\nvec3 linearToSrgb(vec3 c) {\n    return vec3(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}", t = "const mat2 FBM_ROT = mat2(0.8, 0.6, -0.6, 0.8);", n = "\n// value.js LINEAR_SRGB_TO_LMS (constants.ts), row-major; written here as GLSL\n// columns (= the transpose) so mat3 * vec3 evaluates the row-major M·v.\nconst mat3 LINEAR_SRGB_TO_LMS = mat3(\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 (gamut.ts lines 295-297 —\n// these differ at the ~1e-9 digit from LMS_TO_OKLAB_MATRIX; use the inline ones to\n// mirror the exact value.js path), row-major → GLSL columns.\nconst mat3 LMS_TO_OKLAB = mat3(\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 (constants.ts), row-major → GLSL columns. Rows:\n// l = [1, 0.3963377774, 0.2158037573], m = [1, -0.1055613458, -0.0638541728],\n// s = [1, -0.0894841775, -1.2914855480].\nconst mat3 OKLAB_TO_LMS = mat3(\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 (constants.ts), row-major → GLSL columns.\nconst mat3 LMS_TO_LINEAR_SRGB = mat3(\n    4.0767416621, -1.2684380046, -0.0041960863,\n    -3.3077115913, 2.6097574011, -0.7034186147,\n    0.2309699292, -0.3413193965, 1.7076147010\n);\n\n// Gamma sRGB → raw OKLab (L, a, b). Mirrors value.js srgbToOKLab.\nvec3 srgbToOklab(vec3 c) {\n    vec3 lin = srgbToLinear(c);\n    vec3 lms = LINEAR_SRGB_TO_LMS * lin;\n    vec3 lmsCbrt = sign(lms) * pow(abs(lms), vec3(1.0 / 3.0));\n    return LMS_TO_OKLAB * lmsCbrt;\n}\n\n// Raw OKLab (L, a, b) → linear sRGB. Mirrors value.js oklabToLinearSRGB.\nvec3 oklabToLinearSrgb(vec3 lab) {\n    vec3 lms_ = OKLAB_TO_LMS * lab;\n    vec3 lms = lms_ * lms_ * lms_;\n    return LMS_TO_LINEAR_SRGB * lms;\n}\n\n// OKLab → OKLCh: H in RADIANS. Mirrors value.js rawOklabToOklch (which returns\n// degrees; we stay in radians and only fold to [0, 2pi)).\nvec3 oklabToOklch(vec3 lab) {\n    float C = length(lab.yz);\n    float H = atan(lab.z, lab.y);\n    if (H < 0.0) H += 2.0 * PI;\n    return vec3(lab.x, C, H);\n}\n\n// OKLCh (H radians) → OKLab. Mirrors value.js rawOklchToOklab.\nvec3 oklchToOklab(vec3 lch) {\n    return vec3(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}", r = "\n// value.js interpolateHue in the NORMALIZED-TURNS domain (h_rad/TAU → turns, the\n// exact .5/+1.0 branch per method, fract() wrap, *TAU back). A radians-native port\n// (PI thresholds / +TAU wrap) diverges 180° at the antipode. methods: 0 shorter,\n// 1 longer, 2 increasing, 3 decreasing.\nfloat interpolateHueTurns(float h0, float h1, float t, int method) {\n  float TAU = 2.0 * PI;\n  float a = h0 / TAU;\n  float b = h1 / TAU;\n  float i = b - a;\n  if (method == 0) {              // shorter\n    if (i > 0.5) a += 1.0; else if (i < -0.5) b += 1.0;\n  } else if (method == 1) {       // longer\n    if (i > 0.0 && i < 0.5) a += 1.0; else if (i > -0.5 && i <= 0.0) b += 1.0;\n  } else if (method == 2) {       // increasing\n    if (i < 0.0) b += 1.0;\n  } else {                        // decreasing\n    if (i > 0.0) a += 1.0;\n  }\n  float r = a + t * (b - a);\n  r = fract(r);                   // (r % 1 + 1) % 1 — fract is non-negative in GLSL\n  return r * TAU;                 // back to radians\n}\n\n// Linear-sRGB endpoint pair → OKLab-rectangular interpolation → linear sRGB. Holds\n// chroma across the ramp (no grey midpoint). The default/shorter ramp path.\nvec3 mixPaletteOklab(vec3 linA, vec3 linB, float t) {\n  vec3 labA = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linA) * pow(abs(LINEAR_SRGB_TO_LMS * linA), vec3(1.0 / 3.0)));\n  vec3 labB = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linB) * pow(abs(LINEAR_SRGB_TO_LMS * linB), vec3(1.0 / 3.0)));\n  vec3 lab = mix(labA, labB, t);\n  return oklabToLinearSrgb(lab);\n}\n\n// Linear-sRGB endpoint pair → OKLCh interpolation along the huePath arc → linear\n// sRGB. L and C lerp; H walks the chosen arc. The deliberate-rainbow path.\nvec3 mixPaletteOklchArc(vec3 linA, vec3 linB, float t, int method) {\n  vec3 labA = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linA) * pow(abs(LINEAR_SRGB_TO_LMS * linA), vec3(1.0 / 3.0)));\n  vec3 labB = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linB) * pow(abs(LINEAR_SRGB_TO_LMS * linB), vec3(1.0 / 3.0)));\n  vec3 lchA = oklabToOklch(labA);\n  vec3 lchB = oklabToOklch(labB);\n  float L = mix(lchA.x, lchB.x, t);\n  float C = mix(lchA.y, lchB.y, t);\n  float H = interpolateHueTurns(lchA.z, lchB.z, t, method);\n  return oklabToLinearSrgb(oklchToOklab(vec3(L, C, H)));\n}\n\n// The ramp dispatcher both samplePalette ports splice. tRaw is the raw inter-stop\n// parameter [0,1]; the smoothstep ease + the huePath branch live HERE so the GLSL\n// and WGSL ramps are character-for-character one source. increasing(2)/decreasing(3)\n// take the OKLCh hue-arc (rainbow sweep); every other method takes the OKLab-\n// rectangular straight line (no hue detour).\nvec3 samplePaletteRamp(vec3 a, vec3 b, float tRaw, int huePath) {\n  float 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}", i = "\n// Jarzynski PCG2D — uvec2 → uvec2 permuted-congruential hash (JCGT 2020).\nuvec2 pcg2d(uvec2 v) {\n  v = v * 1664525u + 1013904223u;\n  v.x += v.y * 1664525u;\n  v.y += v.x * 1664525u;\n  v = v ^ (v >> 16u);\n  v.x += v.y * 1664525u;\n  v.y += v.x * 1664525u;\n  v = v ^ (v >> 16u);\n  return v;\n}\n\n// Float→[0,1) scalar hash: bit-reinterpret the lattice coordinate, pcg2d it, take the\n// high word back to [0,1). Integer-bit — no sin() periodicity, no float-fract lattice.\nfloat pcgHash2(vec2 p) {\n  uvec2 u = floatBitsToUint(p);\n  return float(pcg2d(u).x) * (1.0 / 4294967296.0);\n}\n\n// Integer-lattice gradient: pcg2d the integer cell, fold the hash to an angle, return\n// the unit gradient vector. The gradient basis (not a scalar value) is what makes the\n// noise zero at the nodes (no value-noise plateaus).\nvec2 pcgGrad2(ivec2 cell) {\n  uvec2 h = pcg2d(uvec2(cell));\n  float ang = float(h.x) * (1.0 / 4294967296.0) * 6.28318530717958647692;\n  return vec2(cos(ang), sin(ang));\n}\n\n// 2D SIMPLEX gradient noise (Gustavson skew). The skew transform F2/G2 maps the square\n// lattice onto a simplex (triangular) grid — no axis-aligned directional bias. Each of\n// the three simplex corners contributes grad·offset shaped by a radial (0.5 - r²)⁴\n// falloff. Output is ~[-1, 1]; callers remap to [0,1] via 0.5 + 0.5*gnoise.\nfloat gnoise(vec2 p) {\n  const float F2 = 0.36602540378443864676; // (sqrt(3) - 1) / 2\n  const float G2 = 0.21132486540518711775; // (3 - sqrt(3)) / 6\n  float s = (p.x + p.y) * F2;\n  vec2 i = floor(p + s);\n  float tt = (i.x + i.y) * G2;\n  vec2 x0 = p - (i - tt);                    // offset from the simplex origin corner\n  ivec2 i1 = (x0.x > x0.y) ? ivec2(1, 0) : ivec2(0, 1);\n  vec2 x1 = x0 - vec2(i1) + G2;\n  vec2 x2 = x0 - 1.0 + 2.0 * G2;\n  ivec2 ii = ivec2(i);\n  float n = 0.0;\n  float t0 = 0.5 - dot(x0, x0);\n  if (t0 > 0.0) { t0 *= t0; n += t0 * t0 * dot(pcgGrad2(ii), x0); }\n  float t1 = 0.5 - dot(x1, x1);\n  if (t1 > 0.0) { t1 *= t1; n += t1 * t1 * dot(pcgGrad2(ii + i1), x1); }\n  float t2 = 0.5 - dot(x2, x2);\n  if (t2 > 0.0) { t2 *= t2; n += t2 * t2 * dot(pcgGrad2(ii + ivec2(1, 1)), x2); }\n  return 70.0 * n;                           // normalize to ~[-1, 1]\n}", a = "\nfn srgbToLinearCh(c: f32) -> f32 {\n    return select(pow((c + 0.055) / 1.055, 2.4), c / 12.92, c <= 0.04045);\n}\nfn srgbToLinear(c: vec3f) -> vec3f {\n    return vec3f(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\nfn linearToSrgbCh(c: f32) -> f32 {\n    return select(1.055 * pow(c, 1.0 / 2.4) - 0.055, c * 12.92, c <= 0.0031308);\n}\nfn linearToSrgb(c: vec3f) -> vec3f {\n    return vec3f(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}", o = "const FBM_ROT: mat2x2f = mat2x2f(0.8, 0.6, -0.6, 0.8);", s = "\nconst LINEAR_SRGB_TO_LMS: mat3x3f = mat3x3f(\n    0.4122214708, 0.2119034982, 0.0883024619,\n    0.5363325363, 0.6806995451, 0.2817188376,\n    0.0514459929, 0.1073969566, 0.6299787005\n);\nconst LMS_TO_OKLAB: mat3x3f = mat3x3f(\n    0.2104542553, 1.9779984951, 0.0259040371,\n    0.7936177850, -2.4285922050, 0.7827717662,\n    -0.0040720468, 0.4505937099, -0.8086757660\n);\nconst OKLAB_TO_LMS: mat3x3f = mat3x3f(\n    1.0, 1.0, 1.0,\n    0.3963377774, -0.1055613458, -0.0894841775,\n    0.2158037573, -0.0638541728, -1.2914855480\n);\nconst LMS_TO_LINEAR_SRGB: mat3x3f = mat3x3f(\n    4.0767416621, -1.2684380046, -0.0041960863,\n    -3.3077115913, 2.6097574011, -0.7034186147,\n    0.2309699292, -0.3413193965, 1.7076147010\n);\n\nfn srgbToOklab(c: vec3f) -> vec3f {\n    let lin = srgbToLinear(c);\n    let lms = LINEAR_SRGB_TO_LMS * lin;\n    let lmsCbrt = sign(lms) * pow(abs(lms), vec3f(1.0 / 3.0));\n    return LMS_TO_OKLAB * lmsCbrt;\n}\nfn oklabToLinearSrgb(lab: vec3f) -> vec3f {\n    let lms_ = OKLAB_TO_LMS * lab;\n    let lms = lms_ * lms_ * lms_;\n    return LMS_TO_LINEAR_SRGB * lms;\n}\nfn oklabToOklch(lab: vec3f) -> vec3f {\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 vec3f(lab.x, C, H);\n}\nfn oklchToOklab(lch: vec3f) -> vec3f {\n    return vec3f(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}", c = "\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  let r = fract(a + t * (b - a));\n  return r * TAU;\n}\n\nfn mixPaletteOklab(linA: vec3f, linB: vec3f, t: f32) -> vec3f {\n  let labA = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linA) * pow(abs(LINEAR_SRGB_TO_LMS * linA), vec3f(1.0 / 3.0)));\n  let labB = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linB) * pow(abs(LINEAR_SRGB_TO_LMS * linB), vec3f(1.0 / 3.0)));\n  let lab = mix(labA, labB, vec3f(t));\n  return oklabToLinearSrgb(lab);\n}\n\nfn mixPaletteOklchArc(linA: vec3f, linB: vec3f, t: f32, method: i32) -> vec3f {\n  let labA = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linA) * pow(abs(LINEAR_SRGB_TO_LMS * linA), vec3f(1.0 / 3.0)));\n  let labB = LMS_TO_OKLAB * (sign(LINEAR_SRGB_TO_LMS * linB) * pow(abs(LINEAR_SRGB_TO_LMS * linB), vec3f(1.0 / 3.0)));\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(vec3f(L, C, H)));\n}\n\nfn samplePaletteRamp(a: vec3f, b: vec3f, tRaw: f32, huePath: i32) -> vec3f {\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}", l = "\nfn pcg2d(v0: vec2u) -> vec2u {\n  var v = v0 * 1664525u + vec2u(1013904223u);\n  v.x = v.x + v.y * 1664525u;\n  v.y = v.y + v.x * 1664525u;\n  v = v ^ (v >> vec2u(16u));\n  v.x = v.x + v.y * 1664525u;\n  v.y = v.y + v.x * 1664525u;\n  v = v ^ (v >> vec2u(16u));\n  return v;\n}\n\nfn pcgHash2(p: vec2f) -> f32 {\n  let u = bitcast<vec2u>(p);\n  return f32(pcg2d(u).x) * (1.0 / 4294967296.0);\n}\n\nfn pcgGrad2(cell: vec2i) -> vec2f {\n  let h = pcg2d(bitcast<vec2u>(cell));\n  let ang = f32(h.x) * (1.0 / 4294967296.0) * 6.28318530717958647692;\n  return vec2f(cos(ang), sin(ang));\n}\n\nfn gnoise(p: vec2f) -> f32 {\n  let F2 = 0.36602540378443864676;\n  let G2 = 0.21132486540518711775;\n  let s = (p.x + p.y) * F2;\n  let i = floor(p + vec2f(s));\n  let tt = (i.x + i.y) * G2;\n  let x0 = p - (i - vec2f(tt));\n  var i1 = vec2i(0, 1);\n  if (x0.x > x0.y) { i1 = vec2i(1, 0); }\n  let x1 = x0 - vec2f(i1) + vec2f(G2);\n  let x2 = x0 - vec2f(1.0) + vec2f(2.0 * G2);\n  let ii = vec2i(i);\n  var n = 0.0;\n  var t0 = 0.5 - dot(x0, x0);\n  if (t0 > 0.0) { t0 = t0 * t0; n = n + t0 * t0 * dot(pcgGrad2(ii), x0); }\n  var t1 = 0.5 - dot(x1, x1);\n  if (t1 > 0.0) { t1 = t1 * t1; n = n + t1 * t1 * dot(pcgGrad2(ii + i1), x1); }\n  var t2 = 0.5 - dot(x2, x2);\n  if (t2 > 0.0) { t2 = t2 * t2; n = n + t2 * t2 * dot(pcgGrad2(ii + vec2i(1, 1)), x2); }\n  return 70.0 * n;\n}";
+function u(e, t, n) {
+	return Math.max(t, Math.min(n, e));
+}
+function d() {
+	let e = typeof window < "u" && window.devicePixelRatio || 1;
+	return Math.min(e, 2);
+}
+//#endregion
+//#region src/composables/glass/webgl/createCanvasLifecycle.ts
+function f(e) {
+	let { canvas: t, buildContext: n, resize: r } = e, i = e.respectReducedMotion ?? e.mode !== "capture", a = /* @__PURE__ */ new Set();
+	e.mode === "capture" && a.add("manual");
+	let o = () => a.size === 0, s = 0, c = typeof performance < "u" ? performance.now() : 0, l = null, u = !1, d = !1, f = i && typeof window < "u" && window.matchMedia ? window.matchMedia("(prefers-reduced-motion: reduce)") : null, p = f?.matches ?? !1;
+	function m() {
+		if (!o() || !l) return;
+		let e = (performance.now() - c) / 1e3, t = l.time ? l.time(e) : e;
+		l.frame(t), s = !p && l.shouldContinue() ? requestAnimationFrame(m) : 0;
+	}
+	function h() {
+		u && o() && !s && l && (s = requestAnimationFrame(m));
+	}
+	function g() {
+		let e = f?.matches ?? !1;
+		e !== p && (p = e, e || (c = performance.now()), h());
+	}
+	f?.addEventListener("change", g);
+	function _(e = "manual") {
+		let t = o();
+		a.add(e), t && !o() && (cancelAnimationFrame(s), s = 0);
+	}
+	function v(e = "manual") {
+		let t = !o();
+		a.delete(e), t && o() && u && l && (c = performance.now() - 1e3, m());
+	}
+	let y = typeof document < "u";
+	function b() {
+		document.hidden ? _("tab-hidden") : v("tab-hidden");
+	}
+	y && document.addEventListener("visibilitychange", b), y && document.hidden && a.add("tab-hidden");
+	let x = null;
+	function S(e) {
+		e.skipped ? _("off-screen") : v("off-screen");
+	}
+	function C() {
+		if (x) return;
+		let e = t.parentElement;
+		e && (x = e, e.addEventListener("contentvisibilityautostatechange", S));
+	}
+	function w() {
+		x?.removeEventListener("contentvisibilityautostatechange", S), x = null;
+	}
+	function T() {
+		l = n(), r();
+	}
+	function E() {
+		u || d || (e.bindContextEvents?.(() => {
+			d || (T(), o() && h());
+		}, () => {
+			l = null, cancelAnimationFrame(s), s = 0;
+		}), T(), C(), u = !0, c = performance.now(), o() && (s = requestAnimationFrame(m)));
+	}
+	function D(e) {
+		u || E(), l?.frame(e);
+	}
+	function O() {
+		d = !0, cancelAnimationFrame(s), s = 0, y && document.removeEventListener("visibilitychange", b), f?.removeEventListener("change", g), w(), e.unbindContextEvents?.(), l?.teardown?.(), l = null, a.clear();
+	}
+	return e.mode === "capture" && E(), {
+		arm: E,
+		suspend: _,
+		resume: v,
+		wake: h,
+		renderAt: D,
+		dispose: O,
+		get armed() {
+			return u;
+		},
+		get disposed() {
+			return d;
+		},
+		get running() {
+			return o();
+		},
+		get reducedMotion() {
+			return p;
+		}
+	};
+}
+//#endregion
+//#region src/composables/glass/webgl/useWebGLCanvas.ts
+function p(e, t) {
+	let { setup: n, contextAttrs: r } = t, i = null, a = null, o = null;
+	function s() {
+		let t = e.getContext("webgl2", r ?? void 0);
+		if (!t) throw Error("[useWebGLCanvas] WebGL2 unavailable");
+		return i = t, o = n(i), a || (a = new ResizeObserver(() => o?.resize()), a.observe(e)), {
+			frame: o.frame,
+			shouldContinue: o.shouldContinue,
+			time: o.time,
+			teardown: () => {
+				o?.teardown?.(), i?.getExtension("WEBGL_lose_context")?.loseContext(), a?.disconnect(), a = null, i = null, o = null;
+			}
+		};
+	}
+	let c = null, l = null;
+	function u(e) {
+		e.preventDefault(), i = null, o = null, l?.();
+	}
+	let d = f({
+		canvas: e,
+		mode: t.mode,
+		respectReducedMotion: t.respectReducedMotion,
+		buildContext: s,
+		resize: () => o?.resize(),
+		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,
+		suspend: d.suspend,
+		resume: d.resume,
+		wake: d.wake,
+		renderAt: d.renderAt,
+		dispose: d.dispose,
+		get gl() {
+			return i;
+		},
+		get reducedMotion() {
+			return d.reducedMotion;
+		}
+	};
+}
+//#endregion
+//#region src/composables/glass/webgl/compile.ts
+function m(e, t, n, r = "[glass-ui:webgl]") {
+	let i = e.createShader(t);
+	if (e.shaderSource(i, n), e.compileShader(i), !e.getShaderParameter(i, e.COMPILE_STATUS)) {
+		let t = e.getShaderInfoLog(i) ?? "unknown";
+		throw e.deleteShader(i), Error(`${r} shader compile failed:\n${t}`);
+	}
+	return i;
+}
+function h(e, t, n, r = "[glass-ui:webgl]") {
+	let i = e.createProgram();
+	if (e.attachShader(i, t), e.attachShader(i, n), e.linkProgram(i), !e.getProgramParameter(i, e.LINK_STATUS)) {
+		let t = e.getProgramInfoLog(i) ?? "unknown";
+		throw e.deleteProgram(i), Error(`${r} program link failed:\n${t}`);
+	}
+	return i;
+}
+//#endregion
+export { u as a, o as c, n as d, s as f, l as g, i as h, f as i, e as l, c as m, h as n, d as o, r as p, p as r, t as s, m as t, a as u };

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

@@ -82,6 +82,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
     setCursor: (x: number, y: number, strength?: number) => void;
     clearCursor: () => void;
     setCursorRadius: (r: number) => void;
+    injectCursorVelocity: (dx: number, dy: number) => void;
     renderAt: (t: number) => void;
     pause: () => void;
     resume: () => void;

package/dist/components/custom/aurora/composables/atoms.d.ts

@@ -0,0 +1,125 @@
+/**
+ * AX.W10 — the aurora "atoms of control" door: the ONE consumer-facing surface
+ * over the ~28-field author schema. `AuroraConfig` is the INTERNAL author schema
+ * (the full escape hatch a preset author types against); `resolveAtoms` is the
+ * SIMPLIFIED door the live config UI + every consumer drives.
+ *
+ * The atoms are the user's named control elements (§2.7) — COLOR, ZONES, NOISE,
+ * MEDIUM(+texture), MOTION — ≤7 intuitive knobs, each normalized and total
+ * (Burley's "Principled" 5-rule discipline: intuitive, few, normalized, robust for
+ * EVERY combination). Each atom maps to a co-varying cluster of config fields so one
+ * knob moves the entangled axes together (a single COLOR-energy knob co-varies
+ * saturation + valueVariance + breath + the warm/cool temperature, because moving any
+ * one alone reads as a defect).
+ *
+ * Contract (machine-asserted by proof:aurora-atoms-roundtrip):
+ *   - TOTAL — every atom combination (incl. out-of-range/adversarial inputs) produces
+ *     a VALID in-range `AuroraConfig` respecting every `budget.ts` cap (no NaN, no
+ *     out-of-range field). Clamp/saturate, never garbage.
+ *   - DEFAULT-PRESERVING — `resolveAtoms(DEFAULT_ATOMS)` deep-equals
+ *     `DEFAULT_AURORA_CONFIG` (the wispy-sky default survives the door).
+ *
+ * Mechanism: clone `DEFAULT_AURORA_CONFIG` and apply ONLY the atoms that are PRESENT
+ * as clamped overrides. An absent atom keeps the default's value, so the empty atom
+ * set (`DEFAULT_ATOMS`) resolves to exactly the wispy-sky default by construction.
+ */
+import { type AuroraConfig, type AuroraMedium, type OklchStop } from "../constants/presets";
+import { type AuroraHarmony } from "./color";
+/** The motion atom — the three motion registers. */
+export type AuroraMotionAtom = "still" | "breathing" | "drifting";
+/**
+ * The ZONES arrangement character — selects the nuclei placement prior. NOT a bare
+ * integer count: the same count reads as a different field per arrangement.
+ * - `scattered` — radial-ish spread off the centre (loose, atmospheric).
+ * - `composed`  — the rule-of-thirds prior (the deliberate, balanced field).
+ * - `centred`   — a tight central cluster (one dominant glow, calm).
+ */
+export type AuroraZoneArrangement = "scattered" | "composed" | "centred";
+/** The ZONES atom — a count + an arrangement character (default `composed`). */
+export interface AuroraZones {
+    /** 1..MAX_NUCLEI — the number of color zones (nuclei). Clamped. */
+    count: number;
+    /** The placement prior. Default `composed` (rule-of-thirds). */
+    arrangement?: AuroraZoneArrangement;
+}
+/**
+ * The MEDIUM atom — the painterly medium + (only for a TEXTURED medium) its dominant
+ * texture amount. `amount` is STRUCTURALLY ABSENT for `smooth`: a smooth medium has
+ * no dominant texture knob, so the door does not offer/accept one (no silent-inert
+ * arm). For a textured medium `amount` (0..1) drives the medium's signature knob.
+ */
+export type AuroraMediumAtom = {
+    kind: "smooth";
+} | {
+    kind: Exclude<AuroraMedium, "smooth">;
+    amount?: number;
+};
+/**
+ * The interactivity atom — ONLY the wired axes ship. `light` (cursor-as-light) and
+ * `scroll` (scroll-coupled palette/breath) are wired downstream
+ * (`frameLoop.ts`/`useAurora.ts`); the declared-but-unwired `flow`/`wake` axes are
+ * EXCISED from the shipped atom shape (no declared-but-dead axis — excise-or-wire).
+ */
+export interface AuroraInteractivityAtom {
+    /** cursor drives the impasto light direction (cursor-as-light + idle orbit). */
+    light?: boolean;
+    /** palette/breath progress couples to scroll (via useScrollProgress). */
+    scroll?: boolean;
+}
+/**
+ * The Tier-1 atoms of control (≤7) — the user's named control elements. EVERY atom is
+ * OPTIONAL; an absent atom keeps the wispy-sky default for the fields it would drive,
+ * so `DEFAULT_ATOMS` (the empty set) resolves to `DEFAULT_AURORA_CONFIG`.
+ */
+export interface AuroraAtoms {
+    /** A seed color (CSS string or an OklchStop anchor) → drives the derived palette. */
+    seed?: string | OklchStop;
+    /** The hue scheme across the derived ramp. Default `analogous` (when a seed is set). */
+    harmony?: AuroraHarmony;
+    /**
+     * 0..1 — the color ENERGY knob. One scalar co-varies the entangled chroma/value
+     * cluster: saturation, valueVariance, breath, AND the warm-light/cool-shadow
+     * temperature on the derived palette. 0 = calm/muted, 1 = vivid/charged. A
+     * continuous curve, not a 3-point named LUT.
+     */
+    colorEnergy?: number;
+    /** The color zones (nuclei) — a count + an arrangement character. */
+    zones?: AuroraZones;
+    /**
+     * 0..1 — the NOISE knob. One scalar fans to the organic-boundary cluster:
+     * warpAmount (how much the zones distort), warpScale (the distortion frequency),
+     * warpMode (smooth fBm → cellular as it climbs), and noiseOctaves (detail). 0 =
+     * clean isotropic zones, 1 = turbulent organic edges.
+     */
+    noise?: number;
+    /** The painterly medium + (textured mediums only) its dominant texture amount. */
+    medium?: AuroraMediumAtom;
+    /** still | breathing | drifting — the three motion registers. */
+    motion?: AuroraMotionAtom;
+    /** The pointer/scroll interactivity axes (default OFF). Only `light`/`scroll` ship. */
+    interactivity?: AuroraInteractivityAtom;
+}
+/**
+ * The default atoms — the EMPTY set. `resolveAtoms(DEFAULT_ATOMS)` deep-equals the
+ * wispy-sky `DEFAULT_AURORA_CONFIG` (machine-asserted). The user explicitly asked the
+ * default to be preserved; the empty-atom pass-through is how the door honors it.
+ */
+export declare const DEFAULT_ATOMS: AuroraAtoms;
+/**
+ * The deterministic nuclei prior for `count` zones under an `arrangement` character.
+ * ONE home for the rule-of-thirds prior (the AW duplicated prior pair is gone). Total:
+ * clamps `count` to `[1, MAX_NUCLEI]`; every arrangement yields a valid in-range nuclei
+ * array.
+ *
+ * - `composed`  — the rule-of-thirds anchor table (the deliberate balanced field).
+ * - `scattered` — a golden-angle (φ⁻¹) low-discrepancy spread off-centre (loose).
+ * - `centred`   — a tight cluster around the centre (one dominant glow).
+ */
+export declare function nucleiPrior(count: number, arrangement?: AuroraZoneArrangement): AuroraConfig["nuclei"];
+/**
+ * Expand the ≤7 Tier-1 atoms into a full, valid, in-range `AuroraConfig`. A PURE,
+ * TOTAL function: clones the wispy-sky default and applies ONLY the present atoms as
+ * clamped overrides, so the empty atom set resolves to exactly `DEFAULT_AURORA_CONFIG`
+ * and every atom combination yields a config respecting every `budget.ts` cap.
+ */
+export declare function resolveAtoms(atoms?: AuroraAtoms): AuroraConfig;

package/dist/components/custom/aurora/composables/color.d.ts

@@ -1,7 +1,7 @@
-import { type AuroraConfig } from "../constants/presets";
-import { type OklchStop } from "../../../../composables/color";
+import { type ColorHarmony, type OklchStop } from "../../../../composables/color";
 export { cssToOklch, oklchStopToHex, oklchToLinear, } from "../../../../composables/color";
 export type { OklchStop } from "../../../../composables/color";
+export type { ColorHarmony } from "../../../../composables/color";
 /**
  * Pack up to `maxStops` OklchStops into linear-sRGB triples. When `out` is
  * provided the buffer is filled in place (no allocation) — the runtime owns a
@@ -26,19 +26,12 @@ export declare function flattenPalette(stops: OklchStop[], maxStops?: number, ou
 export declare function paletteToCssGradient(stops: OklchStop[]): string;
 export declare function hexToOklchStop(hex: string): OklchStop;
 /**
- * Harmony schemes for {@link deriveAurora}. Each maps the seed hue onto the
- * derived stops differently:
- * - `analogous` — the ramp walks the seed hue ± a small spread (neighbouring
- *   hues; the painterly default).
- * - `complementary` — stops travel from the seed hue toward its opposite (+180°)
- *   along the LONG arc (keeps the ramp saturated; the short arc cuts through grey
- *   on a warm→cool pair — the muddy-midtone defect).
- * - `split-complementary` — anchor + the two hues flanking the complement (±150/210).
- * - `triad` — stops distributed across the seed hue and its two 120° partners.
- * - `tetradic` — anchor + the three 90° partners (90/180/270).
- * - `monochrome` — every stop holds the seed hue; only L and C travel.
+ * Harmony schemes for {@link deriveAurora} — the PUBLIC alias of the shared
+ * `ColorHarmony` vocabulary hoisted to the `/color` leaf (AW.W11.b). The blob and
+ * aurora derive from this ONE union; aurora keeps the `AuroraHarmony` name for
+ * surface preservation. See `ColorHarmony` for the per-scheme semantics.
  */
-export type AuroraHarmony = "analogous" | "complementary" | "split-complementary" | "triad" | "tetradic" | "monochrome";
+export type AuroraHarmony = ColorHarmony;
 /**
  * Eased L/C journey shapes for the derived ramp. `bell` (the W5 default for chroma)
  * peaks the chroma in the mids and desaturates the extremes — the painterly
@@ -85,14 +78,3 @@ export interface DeriveAuroraOptions {
  * @param options ramp shape — stop count, harmony, L/C/h spreads.
  */
 export declare function deriveAurora(seed: string | OklchStop, options?: DeriveAuroraOptions): OklchStop[];
-/** Atmospheric mood words for {@link deriveScene}. */
-export type AuroraMood = "atmospheric" | "painterly" | "vivid" | "muted";
-/**
- * Seed ONE color + a mood word into a WHOLE `AuroraConfig` — palette (via
- * `deriveAurora`), nuclei layout (a rule-of-thirds/golden prior), medium, and the
- * motion/output knobs the mood implies. A SUPERSET front door over `deriveAurora`:
- * a consumer hands a seed + `"painterly"` and gets a coherent backdrop, not just a
- * palette. The base is the wispy-sky `DEFAULT_AURORA_CONFIG` (every field the mood
- * does not touch stays the library default).
- */
-export declare function deriveScene(seed: string | OklchStop, mood?: AuroraMood): AuroraConfig;

package/dist/components/custom/aurora/composables/cursorModel.d.ts

@@ -20,6 +20,14 @@ export declare const CURSOR_DECAY_PER_FRAME = 0.992;
  * below this the next frame is visually identical, so the loop may park.
  */
 export declare const CURSOR_REST_EPSILON = 0.001;
+/**
+ * AW.W8.1 — the velocity-burst decay per frame. A fast pointer flick injects a
+ * transient `burst` that eases out over ~1s (≈0.96^60 ≈ 0.09 after 1s at 60fps),
+ * distinct from the steady attraction. The velocity itself eases faster (it tracks
+ * the live pointer delta, not a lingering field).
+ */
+export declare const CURSOR_BURST_DECAY_PER_FRAME = 0.96;
+export declare const CURSOR_VELOCITY_LERP = 0.3;
 /** The mutable eased-cursor state. `strength` ramps in; `targetStrength` decays. */
 export interface CursorState {
     x: number;
@@ -29,14 +37,39 @@ export interface CursorState {
     strength: number;
     targetStrength: number;
     radius: number;
+    /**
+     * AW.W8.1 — the smoothed pointer velocity (delta per move, eased). The
+     * velocity-reactive flow consumes its magnitude; a fast flick spikes it. Units
+     * are normalized-screen per move (clamped to avoid a teleport spike).
+     */
+    velX: number;
+    velY: number;
+    /**
+     * AW.W8.1 — the transient swirl-BURST a fast flick injects (decays over ~1s).
+     * The flow shader reads this as a decaying velocity-driven term, distinct from
+     * the steady `strength` attraction.
+     */
+    burst: number;
 }
 /** A fresh at-rest cursor (centred, no attraction, default radius). */
 export declare function createCursorState(): CursorState;
 /**
  * Advance the cursor easing one frame — snappy approach toward the target
- * position, gentle decay of the attraction strength when idle.
+ * position, gentle decay of the attraction strength when idle. AW.W8.1: also eases
+ * the velocity toward zero and decays the swirl-burst. `tempo` (the master tempo
+ * scalar, default 1; 0 under PRM/pause) scales the velocity + burst toward stillness
+ * so the whole interactive stack freezes when tempo is 0 — `tempo` multiplies the
+ * retained fraction, NOT `uTime` (scaling the clock makes the flow jump; the
+ * integration step scales, the absolute clock keeps marching — the W11 discipline).
+ */
+export declare function advanceCursor(cursor: CursorState, tempo?: number): void;
+/**
+ * AW.W8.1 — feed a pointer delta into the velocity + burst. Called from the
+ * `pointermove` listener, which MUST early-out on reduced-motion BEFORE calling this
+ * (the cursor write-path PRM check — the listener fires independent of the rAF loop).
+ * The delta is clamped so a teleport (tab-in, scroll jump) does not spike a giant burst.
  */
-export declare function advanceCursor(cursor: CursorState): void;
+export declare function injectCursorVelocity(cursor: CursorState, dx: number, dy: number): void;
 /**
  * True while the cursor is still easing (position not yet at target, or strength
  * not yet decayed below ε). The render-demand gate ORs this with the config drift

package/dist/components/custom/aurora/composables/glSetup.d.ts

@@ -9,7 +9,7 @@
  * shader-uniform boundary: a NEW uniform name must be added here, and the cache is
  * keyed off it, so a fresh uniform always gets a location slot.
  */
-export declare const UNIFORM_NAMES: readonly ["uTime", "uPalette", "uStopCount", "uNucleiCount", "uNucleiPos", "uNucleiRadius", "uNucleiPaletteBias", "uNucleiValueBias", "uNucleiDriftRadius", "uNucleiDriftPhase", "uNucleiElong", "uNucleiAngle", "uSoftmaxBeta", "uValueVariance", "uWarpAmount", "uWarpScale", "uWarpDrift", "uWarpMode", "uNoiseOctaves", "uMedium", "uHuePath", "uFlowPattern", "uFlowFocal", "uFlowAngle", "uFlowCurl", "uCursor", "uCursorStrength", "uCursorRadius", "uStrokeAmount", "uStrokeScale", "uStrokeAnisotropy", "uStrokeLayers", "uStrokeMode", "uWetEdge", "uGranulation", "uImpasto", "uBrokenColor", "uCanvasGrain", "uNucleiDrift", "uPaletteDrift", "uBreathDepth", "uBreathPeriod", "uSaturation", "uPaperGrain", "uAlpha"];
+export declare const UNIFORM_NAMES: readonly ["uTime", "uPalette", "uStopCount", "uNucleiCount", "uNucleiPos", "uNucleiRadius", "uNucleiPaletteBias", "uNucleiValueBias", "uNucleiDriftRadius", "uNucleiDriftPhase", "uNucleiElong", "uNucleiAngle", "uSoftmaxBeta", "uValueVariance", "uWarpAmount", "uWarpScale", "uWarpDrift", "uWarpMode", "uNoiseOctaves", "uMedium", "uHuePath", "uFlowPattern", "uFlowFocal", "uFlowAngle", "uFlowCurl", "uCursor", "uCursorStrength", "uCursorRadius", "uCursorVelocity", "uCursorBurst", "uStrokeAmount", "uStrokeScale", "uStrokeAnisotropy", "uStrokeLayers", "uStrokeMode", "uStrokeOrient", "uLightDir", "uLightColor", "uWetEdge", "uGranulation", "uImpasto", "uBrokenColor", "uCanvasGrain", "uNucleiDrift", "uPaletteDrift", "uBreathDepth", "uBreathPeriod", "uSaturation", "uPaperGrain", "uAlpha"];
 export type UniformName = (typeof UNIFORM_NAMES)[number];
 export type UniformLocations = Record<UniformName, WebGLUniformLocation | null>;
 export interface GlProgram {

package/dist/components/custom/aurora/composables/gpuRuntime.d.ts

@@ -0,0 +1,16 @@
+import type { GPUCanvasFrame, GPUCanvasSetupArgs } from "../../../../composables/glass/createGPUCanvas";
+import type { CursorState } from "./cursorModel";
+import type { AuroraConfig } from "../constants/presets";
+export interface GPUAuroraDeps {
+    canvas: HTMLCanvasElement;
+    getConfig: () => AuroraConfig;
+    cursor: CursorState;
+    getReducedMotion: () => boolean;
+    /** The frozen frame-time offset under reduced motion (matches the WebGL2 path). */
+    frozenOffset: number;
+}
+/**
+ * The `setup` callback for `createGPUCanvas`. Builds the pipeline once on the device,
+ * returns the frame hooks. The single render pass draws the WGSL aurora base field.
+ */
+export declare function createGPUAuroraSetup(deps: GPUAuroraDeps): ({ device, context, format }: GPUCanvasSetupArgs) => GPUCanvasFrame;

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

@@ -72,6 +72,15 @@ export interface AuroraRuntimeOptions {
      * `instance.arm()` on the deferred path — rethrows from `arm()`.
      */
     onInitError?: (err: Error) => void;
+    /**
+     * AW.W7b — the WebGPU backend route. When a `GPUDevice` is supplied (the
+     * `resolveRenderModeAsync` probe resolved a non-fallback adapter), the runtime
+     * routes to `createGPUCanvas` drawing the SAME single-pass aurora over WebGPU;
+     * otherwise the WebGL2 fragment path is the universal fallback. `useAurora` runs
+     * the probe past first paint (the CSS placeholder paints first) and threads the
+     * device here. `null`/absent → the WebGL2 path (the zero-regression default).
+     */
+    gpuDevice?: GPUDevice | null;
 }
 /**
  * The concrete `createAurora` return shape. It IS an {@link AuroraInstance}
@@ -83,5 +92,14 @@ export interface AuroraRuntimeOptions {
 export interface AuroraRuntime extends Omit<AuroraInstance, "pause" | "resume"> {
     pause(reason?: SuspendReason): void;
     resume(reason?: SuspendReason): void;
+    /**
+     * AW.W8.1 — feed a pointer delta into the velocity-reactive flow (a fast flick →
+     * a transient swirl-burst). The PRM early-out lives here: the injection is
+     * suppressed when the substrate reports reduced-motion (the cursor write-path
+     * fires from the pointermove listener, INDEPENDENT of the parked rAF loop).
+     */
+    injectCursorVelocity(dx: number, dy: number): void;
+    /** AW.W8.1 — the live reduced-motion state (the cursor listener early-outs on it). */
+    readonly reducedMotion: boolean;
 }
 export declare function createAurora(canvas: HTMLCanvasElement, initial: AuroraConfig, options?: AuroraRuntimeOptions): AuroraRuntime;