@mkbabb/glass-ui 4.0.0 → 4.1.0

package/dist/color-Cs0-oxYL.js

@@ -0,0 +1,116 @@
+import { computed as e, toValue as t } from "vue";
+import { OKLCHColor as n, colorUnit2 as r, gamutMapOKLab as i, interpolateHue as a, isInSRGBGamut as o, oklabToLinearSRGB as s, oklabToRgb255 as c, parseCSSColor as l, rawOklabToOklch as u, rawOklchToOklab as d, safeAccentColor as f, srgbToOKLab as p } from "@mkbabb/value.js";
+//#region src/composables/color/useAccentTone.ts
+var m = "hsl(36 48% 97%)", h = 4.5, g = .18;
+function _(e, t, n) {
+	let [r] = d(e.L, e.C, e.h), [i] = d(t.L, t.C, t.h);
+	return r * (1 - n) + i * n;
+}
+function v(r, i = {}) {
+	let a = e(() => {
+		let e = t(r) || "var(--primary)";
+		if (/var\(/.test(e)) return "";
+		i.fillStrength;
+		let a = i.bandStrength ?? g, o = i.inkContrast ?? h, s = i.surface || m, c, l;
+		try {
+			c = S(e), l = S(s);
+		} catch {
+			return "";
+		}
+		let u = _(l, c, a);
+		return f(new n(c.L, c.C, c.h), u, o * .1).toString();
+	});
+	return {
+		toneStyle: e(() => {
+			let e = { "--tone": t(r) || "var(--primary)" }, n = a.value;
+			return n && (e["--accent-ink-resolved"] = n), e;
+		}),
+		ink: a
+	};
+}
+//#endregion
+//#region src/composables/color/index.ts
+function y(e) {
+	let [t, n, r] = d(e.L, e.C, e.h), [i, a, o] = s(t, n, r);
+	return [
+		Math.max(0, i),
+		Math.max(0, a),
+		Math.max(0, o)
+	];
+}
+function b(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 y({
+		L: e,
+		C: t,
+		h: n
+	});
+}
+function x(e) {
+	let [t, n, r] = d(e.L, e.C, e.h), [i, a, o] = c(t, n, r), s = (e) => Math.min(1, Math.max(0, e / 255));
+	return [
+		s(i),
+		s(a),
+		s(o)
+	];
+}
+function S(e) {
+	let t = r(l(e), "rgb").value, [n, i, a] = p(Number(t.r), Number(t.g), Number(t.b)), [o, s, c] = u(n, i, a);
+	return {
+		L: o,
+		C: s,
+		h: c
+	};
+}
+function C(e) {
+	let [t, n, r] = d(e.L, e.C, e.h), [i, a, o] = c(t, n, r), s = (e) => Math.round(e).toString(16).padStart(2, "0");
+	return `#${s(i)}${s(a)}${s(o)}`;
+}
+var w = (e) => x(S(e)), T = {
+	complementary: "longer",
+	"split-complementary": "longer",
+	analogous: "shorter",
+	monochrome: "shorter",
+	triad: "increasing",
+	tetradic: "increasing"
+}, E = (e) => (e % 360 + 360) % 360;
+function D(e, t, n, r) {
+	let i = T[t], o = (e, t) => E(a(E(e) / 360, E(t) / 360, r, i) * 360);
+	switch (t) {
+		case "monochrome": return E(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 - n, e + n);
+	}
+}
+function O(e) {
+	let [t, n, r] = d(e.L, e.C, e.h), [a, c, l] = i(t, n, r), [f, p, m] = u(a, c, l), h = p;
+	for (let e = 0; e < 6; e++) {
+		let [e, t, n] = d(f, h, m), [r, i, a] = s(e, t, n);
+		if (o(r, i, a)) break;
+		h *= .999;
+	}
+	return {
+		L: f,
+		C: h,
+		h: m
+	};
+}
+function k(e, t = {}) {
+	let n = typeof e == "string" ? S(e) : e, { stopCount: r = 3, harmony: i = "analogous", lightnessSpread: a = .18, hueSpread: o = 24, chromaBump: s = .03, chromaCeiling: c } = t, l = Math.max(2, Math.min(4, Math.round(r))), u = [];
+	for (let e = 0; e < l; e++) {
+		let t = l === 1 ? 0 : e / (l - 1), r = n.L - a / 2 + a * t, d = Math.max(0, n.C + s * Math.sin(Math.PI * t));
+		c !== void 0 && (d = Math.min(d, c));
+		let f = D(n.h, i, o, t);
+		u.push(O({
+			L: Math.min(.98, Math.max(.05, r)),
+			C: d,
+			h: f
+		}));
+	}
+	return u;
+}
+//#endregion
+export { O as a, y as c, D as i, b as l, w as n, C as o, k as r, x as s, S as t, v as u };

package/dist/color.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 "./color-DweYl7pE.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 };
+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, u as l } from "./color-Cs0-oxYL.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, l as useAccentTone, 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-DdtWXxOK.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-D3yxgHNn.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-nZ1xVYTp.js

@@ -0,0 +1,19 @@
+//#region src/composables/glass/webgl/compile.ts
+function e(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 t(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 { t as n, e as t };

package/dist/completion-seal.d.ts

@@ -0,0 +1 @@
+export * from "./components/custom/completion-seal";

package/dist/completion-seal.js

@@ -0,0 +1,89 @@
+import { t as e } from "./cn-DJXf4yaB.js";
+import { computed as t, createCommentVNode as n, createElementBlock as r, defineComponent as i, normalizeClass as a, onMounted as o, openBlock as s, readonly as c, ref as l, toDisplayString as u, toRef as d, unref as f, watch as p } from "vue";
+//#region src/components/custom/completion-seal/composables/useCompletionSeal.ts
+function m() {
+	return typeof window < "u" && typeof window.matchMedia == "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
+function h(e) {
+	if (e != null) return typeof e == "function" ? e() : e.value;
+}
+function g(e = {}) {
+	let { play: n, respectReducedMotion: r = !0 } = e, i = l(!1), a = l(!1), s = t(() => r && m());
+	function u() {
+		if (s.value) {
+			i.value = !1, a.value = !0;
+			return;
+		}
+		i.value = !1, typeof requestAnimationFrame == "function" ? requestAnimationFrame(() => {
+			i.value = !0, a.value = !0;
+		}) : (i.value = !0, a.value = !0);
+	}
+	return n == null ? o(u) : (o(() => {
+		h(n) && u();
+	}), p(() => h(n), (e, t) => {
+		e && !t && u();
+	})), {
+		playing: c(i),
+		drawn: c(a),
+		reduced: c(s),
+		draw: u
+	};
+}
+var _ = "0 0 64 64", v = {
+	check: "M16 33 L28 45 L48 19",
+	wordmark: "M14 30 L26 42 L50 16 M14 50 L50 50"
+}, y = {
+	cx: 32,
+	cy: 32,
+	r: 24
+}, b = [
+	"data-shape",
+	"data-play",
+	"data-drawn"
+], x = ["viewBox"], S = [
+	"cx",
+	"cy",
+	"r"
+], C = ["d"], w = {
+	key: 0,
+	class: "sr-only"
+}, T = /* @__PURE__ */ i({
+	name: "CompletionSeal",
+	__name: "CompletionSeal",
+	props: {
+		shape: {},
+		label: {},
+		play: { type: Boolean },
+		class: {}
+	},
+	setup(i) {
+		let o = i, c = t(() => o.shape ?? "check"), l = t(() => c.value === "wordmark" ? v.wordmark : v.check), { playing: p, drawn: m } = g({ play: o.play === void 0 ? void 0 : d(o, "play") });
+		return (t, i) => (s(), r("div", {
+			class: a(["completion-seal", f(e)(o.class)]),
+			"data-shape": c.value,
+			"data-play": f(p) ? "" : void 0,
+			"data-drawn": f(m) ? "" : void 0,
+			role: "status",
+			"aria-live": "polite"
+		}, [(s(), r("svg", {
+			class: "completion-seal__svg",
+			viewBox: f(_),
+			"aria-hidden": "true",
+			focusable: "false"
+		}, [c.value === "ring" ? (s(), r("circle", {
+			key: 0,
+			class: "completion-seal__mark",
+			cx: f(y).cx,
+			cy: f(y).cy,
+			r: f(y).r,
+			pathLength: "100"
+		}, null, 8, S)) : (s(), r("path", {
+			key: 1,
+			class: "completion-seal__mark",
+			d: l.value,
+			pathLength: "100"
+		}, null, 8, C))], 8, x)), o.label ? (s(), r("span", w, u(o.label), 1)) : n("", !0)], 10, b));
+	}
+});
+//#endregion
+export { T as CompletionSeal, g as useCompletionSeal };

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

@@ -52,11 +52,16 @@ type __VLS_Props = {
      *   - `"css"`   — never arm WebGL; the `paletteToCssGradient` placeholder
      *     stays the permanent surface (the warm wash composites, it just
      *     does not animate).
-     *   - `"auto"` (default) — resolve to `"css"` on low-power /
-     *     reduced-motion / save-data devices (`hardwareConcurrency <= 4` OR
-     *     `prefers-reduced-motion: reduce` OR `connection.saveData`), else
-     *     `"webgl"`. Resolved once at setup; SSR / missing-API safe (assumes
-     *     capable → `"webgl"` when the probes are unavailable).
+     *   - `"auto"` (default) — resolves to `"webgl"` on every device EXCEPT a
+     *     detected SOFTWARE renderer (SwiftShader / llvmpipe / MS Basic Render),
+     *     which falls to `"css"` (the page-wedging-software-raster guard, the only
+     *     surviving `"css"` signal). BC.W-VIZ-AURORA (T1) RETIRED the dead-static
+     *     `hardwareConcurrency <= 4` / `saveData` / `reduced-motion` falls: a
+     *     2026-capable low-core / throttled tab no longer gets a frozen gradient
+     *     (the "renders SLOW" defect root), and reduced-motion is handled SOLELY by
+     *     the substrate's live `matchMedia` freeze (one static frame then park,
+     *     re-arms on un-reduce). Resolved once at setup; SSR / missing-API safe
+     *     (assumes capable → `"webgl"` when the probes are unavailable).
      */
     renderMode?: AuroraRenderMode;
     /**

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

@@ -0,0 +1,39 @@
+import { type AuroraConfig, type AuroraMedium } from "../constants/presets";
+import type { AuroraMotionAtom } from "./atoms";
+/** Linear interpolation over a co-varying axis (the continuous curve, not a LUT). */
+export declare function lerp(a: number, b: number, t: number): number;
+/** The motion atom → the three motion fields. */
+export interface MotionFields {
+    nucleiDrift: number;
+    paletteDrift: number;
+    warpDrift: number;
+    breathDepth: number;
+}
+/** The calm↔vivid poles for each co-varying COLOR-energy axis. */
+export declare const COLOR_ENERGY: {
+    readonly saturation: {
+        readonly calm: 0.85;
+        readonly vivid: 1.2;
+    };
+    readonly valueVariance: {
+        readonly calm: 0.04;
+        readonly vivid: 0.14;
+    };
+    readonly breathDepth: {
+        readonly calm: 0.03;
+        readonly vivid: 0.08;
+    };
+    readonly temperatureShift: {
+        readonly calm: 0.15;
+        readonly vivid: 0.5;
+    };
+};
+export declare const MOTION_FIELDS: Record<AuroraMotionAtom, MotionFields>;
+/** The textured medium → its dominant texture knob. Only reached for a textured medium. */
+export declare function applyTexture(cfg: AuroraConfig, medium: Exclude<AuroraMedium, "smooth">, amount: number): void;
+/** Read back the textured medium's dominant texture amount (the applyTexture inverse). */
+export declare function textureAmountFor(cfg: AuroraConfig, kind: Exclude<AuroraMedium, "smooth">): number;
+/** Classify the motion atom from the config's drift fields (the resolveAtoms forward map). */
+export declare function motionFor(cfg: AuroraConfig): AuroraMotionAtom;
+/** Invert a clamped lerp(calm, vivid, t) back to t∈[0,1] (the energy/noise inverses). */
+export declare function unlerp(value: number, lo: number, hi: number): number;

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

@@ -0,0 +1,108 @@
+/**
+ * Aurora luminance-faithful fallback ground (BB.W-AURORA-SWRASTER).
+ *
+ * The headless / software-raster substrate cannot run the live WebGL field, but
+ * speedtest's CI/witness harness must still certify text-on-aurora AA contrast
+ * floors HEADLESS (no `--use-gl=angle`). The flat `paletteToCssGradient`
+ * placeholder (`color.ts`) is a deliberate "visually-adjacent approximation" — a
+ * gamma-sRGB-stop `linear-gradient(135deg, …)` band whose MEAN luminance and
+ * SPATIAL distribution both diverge from the shader's nuclei-field composite, so a
+ * contrast capture against it certifies the WRONG floor. This module REPLACES it,
+ * in the software-raster / capture substrate, with a FIELD-SAMPLED ground derived
+ * from the SAME inputs the shader uploads (the palette stops + the nuclei field),
+ * matching the composite's mean + per-quadrant luminance within the certify band.
+ *
+ * THE FIELD MATH IS MIRRORED CPU-SIDE, NOT RE-INVENTED. `sampleAuroraField`
+ * reproduces the shader's STATIC (t=0) composite — `composition.glsl.ts`'s
+ * `nucleiField` (the softmax-Gaussian over the nuclei → paletteId + valueMod) +
+ * `samplePalette` (the linear-sRGB LUT lerp of the CPU-baked endpoints) + the
+ * `valueVariance` modulation + the Khronos PBR-Neutral tonemap (`tonemap.glsl.ts`'s
+ * `aces()`) + the mandatory `linearToSrgb` OETF (`proof:aurora-space-gamma`). The
+ * palette LUT is `oklchToLinear` (the SAME value.js Ottosson bake `flattenPalette`
+ * feeds the GPU) — ONE color source, no re-implemented OKLCh math. The
+ * between-endpoint interpolation runs in LINEAR (the linear-baked endpoints the
+ * shader's LUT also reads); the shader's OKLCh between-stop refinement is a
+ * sub-perceptual luminance delta on adjacent stops, well inside the certify band.
+ *
+ * THE GROUND IS A ONE-SHOT 2D-CANVAS RASTER (the "CSS/2D fallback" the brief names
+ * verbatim — option b, the higher-faithfulness path). A low-res `<canvas>` 2D
+ * context paints the downsampled nuclei-field raster (each texel its `sampleAuroraField`
+ * color), exported ONCE as a `data:` URI and CSS-upscaled (`image-rendering` smooth →
+ * bilinear, which preserves the per-quadrant MEAN luminance) — so the painted ground
+ * reproduces the composite's SPATIAL luminance, not a partial-alpha approximation. It
+ * paints once at mount and parks (no rAF, zero ongoing GPU). When no `document` is
+ * available (SSR / happy-dom) it degrades to a deterministic pure-CSS layered
+ * `radial-gradient` stack (zero canvas) — the same field samples, the SSR-safe form.
+ * The luminance metrics (mean + the 4-quadrant relative luminance) are returned
+ * alongside so the gate / π can MEASURE the faithfulness claim rather than assert it.
+ */
+import type { AuroraConfig, AuroraNucleus } from "../constants/presets";
+/** A linear-sRGB triple in [0,1]. */
+type Lin = [number, number, number];
+/** Linear-sRGB relative luminance (Rec.709 / WCAG), the contrast-floor metric. */
+export declare function relativeLuminance([r, g, b]: Lin): number;
+/**
+ * The static (t=0) nuclei field at normalized `(x, y)` — mirrors
+ * `composition.glsl.ts`'s `nucleiField`. At t=0 the drift orbit term vanishes
+ * (cos 0 / sin 0 → the nucleus sits at its authored position), so the field is a
+ * pure softmax-Gaussian over the static nuclei: `w_i = exp(-β·d2_i/r_i²)`,
+ * `paletteId = Σ(w_i·bias_i)/Σw_i`, `valueMod = Σ(w_i·vbias_i)/Σw_i`. The
+ * anisotropic-ellipse local-frame rotation (elongation + angle) is reproduced.
+ *
+ * NOTE the Y convention: the shader flips Y at the uniform boundary
+ * (`uniformBridge.flipY`) so a CSS-top-origin `nucleus.y` becomes a shader
+ * bottom-origin position, AND the fragment samples `vUv` (bottom-origin). Sampling
+ * here in CSS-top-origin against the AUTHORED (un-flipped) positions reproduces the
+ * same field in the SAME visual frame — the two Y flips cancel, so the emitted CSS
+ * ground (top-origin) matches the rendered surface visually.
+ */
+export declare function nucleiFieldStatic(nuclei: readonly AuroraNucleus[], softmaxBeta: number, x: number, y: number): {
+    paletteId: number;
+    valueMod: number;
+};
+/**
+ * Sample the aurora's STATIC composite at normalized `(x, y)` → a gamma-sRGB
+ * `[r,g,b]` in [0,1]. The full CPU mirror of the shader main() output transfer:
+ * field → linear palette LUT → valueVariance modulation → PBR-Neutral tonemap →
+ * the `clamp(col*0.985 + 0.008)` toe → the `linearToSrgb` OETF. The drift / breath
+ * / cursor / medium-texture terms are STATIC (t=0, no cursor, the atmospheric
+ * smooth pole) — the luminance ground the certify reads, not the live animation.
+ */
+export declare function sampleAuroraField(config: AuroraConfig, x: number, y: number): Lin;
+/** The luminance metrics the gate / π MEASURES the faithfulness against. */
+export interface AuroraGroundMetrics {
+    /** Mean relative luminance over the sample grid (gamma → relative-luminance). */
+    mean: number;
+    /** The 4-quadrant mean relative luminance, [topLeft, topRight, bottomLeft, bottomRight]. */
+    quadrants: [number, number, number, number];
+}
+export interface AuroraFallbackGroundOptions {
+    /** Field-sample grid resolution per axis (default 8 → an 8×8 = 64-sample ground). */
+    grid?: number;
+}
+export interface AuroraFallbackGround {
+    /** The CSS `background-image` value — a layered radial-gradient nuclei-glow field. */
+    backgroundImage: string;
+    /** The CSS `background-color` base fill (the field-mean color — the luminance anchor). */
+    backgroundColor: string;
+    /** The measured luminance metrics (mean + per-quadrant) for the certify band. */
+    metrics: AuroraGroundMetrics;
+}
+/**
+ * Build the luminance-faithful CSS fallback ground for an aurora config.
+ *
+ * Samples the static field at a `grid × grid` lattice (the SAME `sampleAuroraField`
+ * the gate / π measures), emits a stack of soft `radial-gradient` layers — one per
+ * sample cell, centred on the cell, fading to transparent at ~the cell radius — over
+ * a base fill at the FIELD-MEAN color. The base fill anchors the global luminance;
+ * the radial layers paint the spatial nuclei-glow distribution, so the ground reads
+ * as the same atmosphere the composite paints, not a flat diagonal band. Pure CSS,
+ * zero canvas, deterministic from the config (palette + nuclei) — a re-run with the
+ * same config reproduces it byte-for-byte.
+ *
+ * The returned `metrics` are computed over the SAME sample lattice the layers paint,
+ * so the gate's certify-band assertion measures the ground the consumer actually
+ * sees (not a separate idealization).
+ */
+export declare function auroraFallbackGround(config: AuroraConfig, options?: AuroraFallbackGroundOptions): AuroraFallbackGround;
+export {};

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

@@ -60,6 +60,19 @@ export interface DeriveAuroraOptions {
      * fold that makes the oil/oil-pastel mediums read as mixed paint. Default 0.
      */
     temperatureShift?: number;
+    /**
+     * BC.W-VIZ-AURORA (A7) — the additive DERIVE-path hue-EXCLUSION axis (the
+     * speedtest-AX cross-repo fold). Named OKLCh hue bands (each `[startDeg, endDeg]`,
+     * wrap-around supported via `start > end`) that EVERY derived stop's hue must fall
+     * OUTSIDE. The mechanism that makes "teal-on-navy is GONE" enforceable in the DERIVE
+     * path, not just the static default — a consumer deriving a palette FROM any seed
+     * can never re-introduce a purged band (e.g. `avoidHues: [[170, 200]]` excludes the
+     * teal arc by construction). The exclusion RE-ROUTES the walked hue to the nearest
+     * band EDGE (preserving L/C — no chroma flatten); it is NOT a post-hoc desaturate.
+     * Additive + default-unset → byte-identical derive (the `WarpMode`-additive-widen
+     * precedent: `proof:aurora-atoms-roundtrip` stays GREEN by construction).
+     */
+    avoidHues?: readonly (readonly [number, number])[];
 }
 /**
  * Seed ONE color into a harmonious, gamut-safe N-stop aurora palette.

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

@@ -11,6 +11,7 @@
 import type { UniformLocations } from "./glSetup";
 import { type CursorState } from "./cursorModel";
 import type { AuroraConfig } from "../constants/presets";
+import type { UsePointerVelocityField } from "../../../../composables/motion/usePointerVelocityField";
 export interface FrameLoopDeps {
     gl: WebGL2RenderingContext;
     prog: WebGLProgram;
@@ -20,6 +21,14 @@ export interface FrameLoopDeps {
     getConfig: () => AuroraConfig;
     /** Reduced-motion intent — parks the loop after one static frame. */
     getReducedMotion: () => boolean;
+    /**
+     * BC.W-VIZ-AURORA (T5) — the shared viz-pointer-physics field (BB.B4). FED
+     * `tick(deltaMs)` from THIS frame callback (the one-loop discipline — the field owns
+     * NO own rAF); the renderer reads `acceleration` for the iOS-27 gel snap-back. The
+     * existing cursorModel velocity/burst stays the byte-faithful baseline; the accel
+     * term is the additive fold.
+     */
+    pointerField: UsePointerVelocityField;
 }
 export interface FrameLoop {
     /** Advance the cursor easing THEN draw — the per-frame step. */

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

@@ -70,8 +70,27 @@ export interface AuroraRuntimeOptions {
      * NOTE: this is the `useAurora` Vue-wrapper contract surface. The imperative
      * `createAurora(...)` runtime throws on eager init failure and — for
      * `instance.arm()` on the deferred path — rethrows from `arm()`.
+     *
+     * BB.W-AURORA-SWRASTER — a SOFTWARE-RASTER fall is NOT a contract violation:
+     * it never reaches `onInitError`. The wedge catch (see {@link createAurora})
+     * recognizes the software-raster signal at arm time, leaves the canvas
+     * un-armed (the placeholder stays the surface), and returns CLEANLY — so a
+     * consumer who pins `mode:"capture"`/`mode:"webgl"` under SwiftShader never
+     * has to wire `onInitError` to avoid the hang. The handler is preserved for
+     * GENUINE violations (a malformed shader, an OOM, a real link failure).
      */
     onInitError?: (err: Error) => void;
+    /**
+     * BB.W-AURORA-SWRASTER — opt OUT of the runtime software-raster wedge catch.
+     * Default `false`: the wedge catch is the safe default — `createAurora`
+     * recognizes a software renderer at arm time and falls cleanly to the
+     * placeholder rather than arming the page-wedging live GL layer. `true` (the
+     * named, recorded escape for a deterministic test that ACCEPTS the cost)
+     * arms WebGL even under a detected software renderer. Mirrors the
+     * `resolveRenderMode` escape of the same name — ONE consumer-facing flag,
+     * threaded through both seams.
+     */
+    forceWebGLUnderSoftwareRaster?: boolean;
 }
 /**
  * The concrete `createAurora` return shape. It IS an {@link AuroraInstance}
@@ -83,6 +102,18 @@ export interface AuroraRuntimeOptions {
 export interface AuroraRuntime extends Omit<AuroraInstance, "pause" | "resume"> {
     pause(reason?: SuspendReason): void;
     resume(reason?: SuspendReason): void;
+    /**
+     * BC.W-VIZ-AURORA (T2) — the device-resolved arm PROMISE. On the WebGPU
+     * backend `renderAt`/`arm` are NO-OPS until `armAsync()` resolves the async
+     * adapter→device→configure→setup prelude (`useGpuSubstrate.armAsync` tries
+     * WebGPU then falls to the WebGL2 net). A CAPTURE consumer (`renderAt(t)` +
+     * `toDataURL`) MUST `await armAsync()` before the first `renderAt` — the
+     * synchronous `arm()` cannot guarantee the WebGPU device is present, so a
+     * synchronous `renderAt` right after `createAurora(…,{mode:"capture"})` paints
+     * a BLANK frame (the dead-preview defect). Resolves once the backend is armed;
+     * the WebGL2 fallback resolves immediately. Idempotent + safe post-dispose.
+     */
+    armAsync(): Promise<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

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

@@ -27,6 +27,7 @@ export declare const MEDIUM_ID: {
     readonly crayon: 4;
     readonly vangogh: 5;
     readonly "oil-pastel": 6;
+    readonly kuwahara: 7;
 };
 export declare const HUE_PATH_ID: {
     readonly shorter: 0;
@@ -50,6 +51,7 @@ export declare const WARP_ID: {
     readonly fbm: 0;
     readonly cellular: 1;
     readonly hybrid: 2;
+    readonly curl: 3;
 };
 export declare const STROKE_MODE_ID: {
     readonly oil: 0;
@@ -81,7 +83,9 @@ export declare function resolveStrokeModeId(cfg: AuroraConfig): number;
  * `oil-pastel`, `crayon`) FORCE the structure-tensor orientation regardless of the
  * config's `strokeOrient` field — their marks must hug the color zones (the
  * congruent-to-real-works contract). Every other medium honors the config's
- * `strokeOrient` (default `"flow"`).
+ * `strokeOrient` (default `"flow"`). BB.W-AUR-KUWAHARA — `kuwahara` ALSO forces
+ * tensor: the anisotropic Kuwahara kernel is squeezed along the structure-tensor
+ * minor eigenvector, so the orientation source must be the tensor field.
  */
 export declare function resolveStrokeOrientId(cfg: AuroraConfig): number;
 /**

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

@@ -0,0 +1,60 @@
+/**
+ * Aurora WGSL uniform bridge — the typed-struct SOURCE OF TRUTH for the WebGPU primary.
+ *
+ * The WGSL `Uniforms` struct (`aurora.wgsl.ts`) and the JS `ArrayBuffer` write offsets
+ * are generated from the SAME layout table here, so a std140-vs-WGSL alignment mismatch
+ * (the parity-ΔE-blowout trap the wave's §Triumvirate names) is structurally impossible:
+ * the field order + the byte offsets are ONE declaration.
+ *
+ * The struct packs every scalar into a vec4 lane + every per-nucleus row / palette stop
+ * into a vec4 so the array stride is the natural 16 bytes (no std140 16-byte-array-stride
+ * surprise). The byte layout (all offsets in bytes, std140-compatible — vec4 align 16):
+ *
+ *   scalars0 : vec4<f32>   off   0   (uTime, uSoftmaxBeta, uValueVariance, uWarpAmount)
+ *   scalars1 : vec4<f32>   off  16   (uWarpScale, uWarpDrift, uSaturation, uPaperGrain)
+ *   scalars2 : vec4<f32>   off  32   (uAlpha, uNucleiDrift, uPaletteDrift, uBreathDepth)
+ *   scalars3 : vec4<f32>   off  48   (uBreathPeriod, uCursorStrength, uCursorRadius, _)
+ *   cursor   : vec4<f32>   off  64   (uCursor.x, uCursor.y, _, _)
+ *   ints0    : vec4<i32>   off  80   (uStopCount, uNucleiCount, uWarpMode, uNoiseOctaves)
+ *   ints1    : vec4<i32>   off  96   (uMedium, uHuePath, _, _)
+ *   palette  : array<vec4<f32>, 8>  off 112  (rgb linear-sRGB stop + pad)
+ *   nuc0     : array<vec4<f32>, 6>  off 240  (pos.x, pos.y, radius, paletteBias)
+ *   nuc1     : array<vec4<f32>, 6>  off 336  (valueBias, driftRadius, driftPhase, elong)
+ *   nuc2     : array<vec4<f32>, 6>  off 432  (angle, _, _, _)
+ *   scalars4 : vec4<f32>   off 528  (uStrokeAmount, uStrokeScale, uStrokeAnisotropy, uCanvasGrain)
+ *   scalars5 : vec4<f32>   off 544  (uWetEdge, uGranulation, uBrokenColor, uKuwaharaQ)
+ *   kuwahara : vec4<f32>   off 560  (uKuwaharaRadius, uKuwaharaSectors, _, _)
+ *   total    : 576 bytes (16-aligned)
+ *
+ * BC.W-VIZ-AURORA (T4) — the painterly-medium scalar lanes (scalars4/scalars5/kuwahara)
+ * are APPENDED after the arrays, so EVERY pre-existing offset is byte-identical and the
+ * smooth-default parity capture is byte-equivalent (these lanes pack 0 on a smooth config).
+ * The WGSL `Uniforms` struct (`aurora.wgsl.ts`) carries the SAME three trailing lanes —
+ * the typed-struct lockstep: a one-sided add reds the parity-ΔE.
+ *
+ * Y-origin: config authoring is CSS-top-origin (0 = top); the bridge flips Y at the
+ * uniform boundary (`flipY`), exactly as the GLSL `uniformBridge` does.
+ */
+import { type AuroraConfig } from "../constants/presets";
+import type { CursorState } from "./cursorModel";
+/** The total uniform-buffer byte size (16-aligned). */
+export declare const AURORA_WGPU_UNIFORM_BYTES = 576;
+/**
+ * The packed scratch buffer + the dual ArrayBuffer views. A slider drag refills this
+ * in place (no per-frame allocation) — mirroring the GLSL bridge's pre-allocated
+ * upload buffers. The Float32 view writes the float lanes; the Int32 view writes the
+ * two int lanes (a WGSL `i32` shares the buffer at the 16-byte-aligned offsets).
+ */
+export interface AuroraWGPUUniformScratch {
+    buffer: ArrayBuffer;
+    f32: Float32Array;
+    i32: Int32Array;
+    paletteScratch: Float32Array;
+}
+export declare function createAuroraWGPUUniformScratch(): AuroraWGPUUniformScratch;
+/**
+ * Pack an {@link AuroraConfig} + the live cursor + the frame time into the uniform
+ * scratch buffer. The byte layout mirrors the WGSL `Uniforms` struct EXACTLY. Returns
+ * the same scratch (the caller `queue.writeBuffer`s `scratch.buffer`).
+ */
+export declare function packAuroraWGPUUniforms(scratch: AuroraWGPUUniformScratch, cfg: AuroraConfig, cursor: CursorState, timeSec: number): AuroraWGPUUniformScratch;

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

@@ -0,0 +1,37 @@
+/**
+ * Aurora WGSL setup seam — the WebGPU twin of `glSetup` + `frameLoop`.
+ *
+ * `createAuroraWGPUSetup` returns a `setupWGPU(device, context, format)` callback the
+ * `useGpuSubstrate` picker invokes on the async arm (AND on every device-restore). It
+ * builds the render pipeline (the `aurora.wgsl` full-screen-triangle pass), the uniform
+ * buffer (the `uniformBridgeWGPU` typed-struct source-of-truth), and the bind group, then
+ * returns the substrate's per-frame hooks (`frame`/`shouldContinue`/`resize`/`time`/
+ * `teardown`).
+ *
+ * The render-demand gate + the cursor-advance + the DPR resize mirror the WebGL2
+ * `frameLoop`/`runtime.resize` exactly — the loop is substrate-AGNOSTIC, so the same
+ * `getConfig`/`getReducedMotion`/`cursor` closures drive both backends.
+ */
+import type { WebGPUCanvasFrame } from "../../../../composables/glass/webgpu/useWebGPUCanvas";
+import { type CursorState } from "./cursorModel";
+import type { AuroraConfig } from "../constants/presets";
+import type { UsePointerVelocityField } from "../../../../composables/motion/usePointerVelocityField";
+export interface AuroraWGPUSetupDeps {
+    canvas: HTMLCanvasElement;
+    cursor: CursorState;
+    getConfig: () => AuroraConfig;
+    getReducedMotion: () => boolean;
+    /**
+     * BC.W-VIZ-AURORA (T5) — the shared viz-pointer-physics field (BB.B4). FED
+     * `tick(deltaMs)` from the WGPU frame callback (the SAME field instance the WebGL2
+     * loop feeds — one source, no own rAF); the renderer reads `acceleration` for the
+     * iOS-27 gel snap-back.
+     */
+    pointerField: UsePointerVelocityField;
+}
+/**
+ * Build the aurora `setupWGPU(device, context, format)` callback. Closes over the
+ * aurora-specific state (cursor/config/reduced-motion) the runtime owns — identical to
+ * the closures the WebGL2 `setup` threads.
+ */
+export declare function createAuroraWGPUSetup(deps: AuroraWGPUSetupDeps): (device: GPUDevice, context: GPUCanvasContext, format: GPUTextureFormat) => WebGPUCanvasFrame;