@mkbabb/glass-ui 4.0.0 → 4.1.0

package/dist/components/custom/aurora/constants/budget.d.ts

@@ -19,6 +19,19 @@
  * after the offscreen-park. Consumed by aurora's + goo-blob's `resize()`.
  */
 export declare const AV_DPR_MAX = 2;
+/**
+ * BB.W-PERF-PRODUCER A′-5 — the aurora decorative-WASH DPR ceiling, SUB-2× and
+ * DISTINCT from the focal goo-blob's {@link AV_DPR_MAX}. The aurora atmosphere is a
+ * heavily-blurred drift background, not a sharp-silhouette creature: backing it at
+ * full-viewport 2× (the value.js LP1 trace: ~2880×1800, ~21.8 MB native heap) is
+ * visually indistinguishable from 1.5× on a drift wash (the per-pixel FBM is
+ * already smoothed below the DPR-2 detail floor), so the 1.5× ceiling quarters the
+ * GPU memory + per-composite raster for no perceptible loss. The FOCAL goo-blob
+ * KEEPS {@link AV_DPR_MAX} = 2 — its silhouette is sharp; only the aurora wash
+ * reads this sub-cap. This is the CPU-side backing-store DIMENSION only; it never
+ * reaches the shader (`aurora.frag` is byte-fenced — the GL fence is absolute).
+ */
+export declare const AV_AURORA_DPR_MAX = 1.5;
 /**
  * The maximum animated metaball nuclei (the goo-blob body + its satellites, or
  * an aurora field's count). The goo-blob shader hard-caps satellites at 4; this
@@ -48,3 +61,11 @@ export declare function clampBudget(value: number, min: number, max: number): nu
  * `1` when `window` is absent). The single CPU-side reader of {@link AV_DPR_MAX}.
  */
 export declare function resolveBudgetDpr(): number;
+/**
+ * BB.W-PERF-PRODUCER A′-5 — resolve the budget-clamped backing-store DPR for the
+ * aurora decorative WASH, at the SUB-2× {@link AV_AURORA_DPR_MAX} ceiling (distinct
+ * from {@link resolveBudgetDpr}'s focal 2×). SSR-safe (returns `1` when `window` is
+ * absent). The single CPU-side reader is aurora's `runtime.ts` `resize()`; the
+ * focal goo-blob keeps {@link resolveBudgetDpr}.
+ */
+export declare function resolveAuroraWashDpr(): number;

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

@@ -39,7 +39,7 @@ export interface AuroraNucleus {
      */
     angle?: number;
 }
-export type AuroraMedium = "smooth" | "pastel" | "watercolor" | "oil" | "crayon" | "vangogh" | "oil-pastel";
+export type AuroraMedium = "smooth" | "pastel" | "watercolor" | "oil" | "crayon" | "vangogh" | "oil-pastel" | "kuwahara";
 /** Oil-stroke sub-mode. Applied only when `medium === "oil"`. Routes inside the shader. */
 export type StrokeMode = "oil" | "knife" | "chunky";
 export type FlowPattern = "none" | "radial" | "swirl" | "diagonal" | "multi" | "tensor";
@@ -50,7 +50,7 @@ export type FlowPattern = "none" | "radial" | "swirl" | "diagonal" | "multi" | "
  * edge-tangent flow). No default that hides one as a duplicate of the other.
  */
 export type StrokeOrient = "flow" | "tensor";
-export type WarpMode = "fbm" | "cellular" | "hybrid";
+export type WarpMode = "fbm" | "cellular" | "hybrid" | "curl";
 /**
  * AW.W6/W8 — the interactivity flag SHAPE (declared at W6, default OFF; behavior
  * wired at W8). Each axis opts the aurora into a pointer/scroll response:
@@ -115,6 +115,16 @@ export interface AuroraConfig {
     impasto: number;
     brokenColor: number;
     canvasGrain: number;
+    /**
+     * BC.W-VIZ-AURORA (T4) — the anisotropic-Kuwahara painterly-finish knobs (the
+     * `medium:"kuwahara"` register; the WGSL primary's keystone). Optional; omitted =
+     * the recipe defaults (radius 0.010 procedural-patch units, q 4.0 the SOFT
+     * variance-weight exponent). Sectors are fixed at 8 (the soft-blend overlap floor —
+     * not an authoring axis). These ride the appended WGSL `kuwahara`/`scalars5` struct
+     * lanes; a smooth/non-kuwahara config leaves them at the default (a no-op).
+     */
+    kuwaharaRadius?: number;
+    kuwaharaQ?: number;
     /**
      * AW.W4.2 — the impasto relight direction (the movable directional source the
      * accumulated paint-height field catches). Optional; omitted = upper-left
@@ -166,6 +176,14 @@ export interface AuroraInstance extends AuroraCursorApi {
      * 24). A no-op once armed or once `dispose()` has run.
      */
     arm(): void;
+    /**
+     * BC.W-VIZ-AURORA (T2) — the device-resolved arm PROMISE. On the WebGPU
+     * backend `renderAt`/`arm` are no-ops until this resolves the async
+     * adapter→device→configure→setup prelude. A CAPTURE consumer (thumbnail bake)
+     * MUST `await armAsync()` before the first `renderAt` or the frame is BLANK
+     * (the dead-preview defect). The WebGL2 fallback resolves immediately.
+     */
+    armAsync(): Promise<void>;
     update(cfg: AuroraConfig): void;
     /** Render a single deterministic frame at time `t` (seconds). Used for thumbnail bakes. */
     renderAt(timeSec: number): void;

package/dist/components/custom/aurora/constants/renderMode.d.ts

@@ -1,32 +1,91 @@
+export type AuroraRenderMode = "webgl" | "css" | "auto";
 /**
- * Aurora adaptive render substrate (AM.W1; `aurora-lazy-init §3.1`).
+ * Detect a SOFTWARE / CPU WebGL renderer (SwiftShader, llvmpipe, the Microsoft
+ * Basic Render Driver) via the shared `probeWebGL2Renderer` capability helper
+ * (BB.W-CI-GREEN — the substrate owns the SINGLE `getContext("webgl2")`
+ * bootstrap; this consumer reads the renderer STRING through it rather than
+ * creating a second probe context, per `proof:webgl-substrate-single`).
+ *
+ * WHY this is a `"css"` signal (the N.W5 Defect-A root cause, proven live under
+ * the playwright SwiftShader harness): a full-viewport WebGL2 surface is a
+ * compositor layer the rasteriser must re-raster on every composite. On a
+ * software rasteriser that per-composite cost is so high that a REAL pointer
+ * interaction — which forces a composite — starves the renderer's input ack and
+ * the page goes UNRESPONSIVE (the headless-Chromium hang; the same severe jank a
+ * GPU-blocklisted user feels). Neither a frame-cadence cap, a backing-store
+ * shrink, nor a reduced-motion park cures it (all keep the live GL layer);
+ * ONLY *not creating the WebGL surface* does. So a software renderer takes the
+ * `"css"` substrate — the static gradient placeholder is a complete render of the
+ * same palette, composites cheaply, and never stalls input. A blocklisted-GPU
+ * user gets a smooth atmosphere instead of a janky/hanging one.
  *
- * Aurora is NEVER retired — the warm wash composites under every branch. Only
- * the *substrate* adapts: the animated WebGL field on capable devices, the
- * static CSS-gradient placeholder (a complete render of the same palette) on
- * low-power / reduced-motion / save-data devices.
+ * A `null` probe (no WebGL2 / extension masked / throw) returns `false` — we
+ * never downgrade a renderer we cannot PROVE is software (the `"css"` path is the
+ * conservative-but-lossy choice, so a false miss keeps the richer default).
  */
-export type AuroraRenderMode = "webgl" | "css" | "auto";
+export declare function isSoftwareWebGLRenderer(): boolean;
+/**
+ * Resolve-mode options. The software-raster GUARD is the safe DEFAULT (see
+ * {@link resolveRenderMode}); the single ESCAPE is `forceWebGLUnderSoftwareRaster`
+ * (BB.W-AURORA-SWRASTER).
+ */
+export interface ResolveRenderModeOptions {
+    /**
+     * Opt OUT of the universal software-raster guard. When `true`, a forced
+     * `mode:"webgl"`/`mode:"capture"` arm ARMS the live WebGL2 surface even on a
+     * detected software renderer (SwiftShader / llvmpipe / MS Basic Render) — for
+     * a deterministic test that ACCEPTS the per-composite raster cost. Default
+     * `false`: the guard is the SAFE default (a software-raster signal forces
+     * `"css"` regardless of the requested mode, so a consumer who pins
+     * `mode:"webgl"` on a headless / GPU-blocklisted device gets the static
+     * ground, never the page-wedging hang). The escape is NAMED + recorded,
+     * never silent.
+     */
+    forceWebGLUnderSoftwareRaster?: boolean;
+}
 /**
- * Resolve `"auto"` to a concrete substrate per device tier. `"webgl"` and
- * `"css"` pass through unchanged.
+ * Resolve `"auto"` to a concrete substrate per device tier — AND universalize the
+ * software-raster guard out of the `"auto"`-only branch (BB.W-AURORA-SWRASTER).
+ *
+ * THE GUARD (the universal first leg). A SOFTWARE WebGL renderer (SwiftShader /
+ * llvmpipe / MS Basic Render — the GPU-blocklisted / headless path) forces `"css"`
+ * for ANY WebGL-ARMING requested mode (`"webgl"` OR `"auto"`), not only `"auto"`.
+ * A full-viewport software-rastered GL layer is so expensive to re-raster on every
+ * composite that a pointer interaction starves the renderer's input ack and the
+ * page goes UNRESPONSIVE (the headless-Chromium hang the speedtest harness
+ * documents). A consumer (or a capture harness) that pins `mode:"webgl"` /
+ * `mode:"capture"` on such a device MUST still fall to the static ground — so the
+ * probe runs BEFORE the `mode !== "auto"` short-circuit when the requested mode
+ * would arm WebGL. The single ESCAPE is `options.forceWebGLUnderSoftwareRaster`
+ * (default `false` — the guard is the safe default).
+ *
+ * BC.W-VIZ-AURORA (T1) — the DEAD-STATIC `"auto"` fall is RETIRED. The
+ * `lowConcurrency` (`hardwareConcurrency <= 4`) and `saveData` heuristics are
+ * GONE: they predate the offscreen-park + the `AV_AURORA_DPR_MAX` sub-2× cap +
+ * the demand-gate that make a full-viewport aurora cheap, and `<= 4` is
+ * false-positive-prone in 2026 (a capable base-M-series laptop / a throttled VM
+ * tab reports 4 logical cores → it got a FROZEN static gradient that reads as
+ * "the aurora is broken", USER-DEFECTS §E "renders SLOW"). So `"auto"` arms the
+ * GPU on every Chrome-113/Safari-26/Firefox-141 device.
+ *
+ * Reduced-motion is handled SOLELY by the substrate's live `matchMedia` freeze
+ * (`createCanvasLifecycle` paints ONE static frame then parks, and re-arms on
+ * un-reduce) — NOT a render-mode fall (the old `"css"` fall never armed WebGL,
+ * so an un-reduce mid-session could never wake it; the substrate freeze does).
+ * The ONLY `"css"` signal that remains is the genuine software-raster GUARD
+ * (the universal first leg above) — and even that is subsumed by
+ * `BC.W-WEBGPU-EVERYWHERE`'s try-WebGPU-then-rebuild-WebGL2 picker.
  *
- * `"auto"` resolves to `"css"` when ANY low-power signal is present:
- *   - a SOFTWARE WebGL renderer (SwiftShader / llvmpipe / MS Basic Render — the
- *     GPU-blocklisted path; see {@link isSoftwareWebGLRenderer}),
- *   - `navigator.hardwareConcurrency <= 4` (few logical cores),
- *   - `prefers-reduced-motion: reduce`,
- *   - `navigator.connection.saveData === true` (Data Saver on).
- * Otherwise `"webgl"`.
+ * THE CAPABLE PATH IS BYTE-UNTOUCHED: `isSoftwareWebGLRenderer()` returns `false`
+ * on a real GPU (or a null probe — never a false downgrade), so a forced
+ * `mode:"webgl"` on hardware passes through exactly as before.
  *
  * SSR / missing-API safe: if `navigator` / `window` / the probes are
  * unavailable we ASSUME a capable device and resolve `"webgl"` (the warm wash
  * still composites either way — the only question is whether it animates).
- * `navigator.connection` is non-standard, so it is feature-probed via an
- * optional-chained cast rather than a typed accessor.
  *
  * Called ONCE at component setup — the device tier is a mount-time decision,
  * not a reactive one (a connection-type flip mid-session does not re-resolve;
  * the consumer remounts to re-evaluate, matching the deferred-arm contract).
  */
-export declare function resolveRenderMode(mode: AuroraRenderMode): "webgl" | "css";
+export declare function resolveRenderMode(mode: AuroraRenderMode, options?: ResolveRenderModeOptions): "webgl" | "css";

package/dist/components/custom/aurora/constants/shaders/aurora-mediums.wgsl.d.ts

@@ -0,0 +1 @@
+export declare const AURORA_MEDIUMS_WGSL = "\n// \u2500\u2500 Painterly luma + medium scalar accessors \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nconst W_LUMA: vec3<f32> = vec3<f32>(0.2126, 0.7152, 0.0722);\n\nfn mStrokeAmount() -> f32 { return u.scalars4.x; }\nfn mStrokeScale() -> f32 { return u.scalars4.y; }\nfn mStrokeAnisotropy() -> f32 { return u.scalars4.z; }\nfn mCanvasGrain() -> f32 { return u.scalars4.w; }\nfn mWetEdge() -> f32 { return u.scalars5.x; }\nfn mGranulation() -> f32 { return u.scalars5.y; }\nfn mBrokenColor() -> f32 { return u.scalars5.z; }\nfn mKuwaharaQ() -> f32 { return u.scalars5.w; }\nfn mKuwaharaRadius() -> f32 { return u.kuwahara.x; }\n\n// \u2500\u2500 Base color re-sample (the edge-mask operator the mediums Sobel/sector-sample) \u2500\u2500\n// The WGSL twin of mediums.glsl.ts sampleBase: warp -> nuclei field -> palette -> value.\nfn sampleBase(p: vec2<f32>, t: f32) -> vec3<f32> {\n  let pw = domainWarp(p, t);\n  let nf = nucleiField(pw, t);\n  var c = samplePalette(nf.paletteId);\n  c = c * (1.0 + u.scalars0.z * nf.valueMod);\n  return c;\n}\n\n// \u2500\u2500 Broken color (hue + chroma jitter at constant OKLCh L) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nfn brokenColorJitter(c: vec3<f32>, hueSeed: f32, valueSeed: f32, strength: f32) -> vec3<f32> {\n  let amt = clamp(mBrokenColor() * strength, 0.0, 1.0);\n  if (amt <= 0.001) { return c; }\n  var lch = oklabToOklch(linOklab(c));\n  lch.z = lch.z + (hueSeed - 0.5) * (32.0 * PI / 180.0) * amt;\n  lch.y = max(lch.y * (1.0 + (valueSeed - 0.5) * 0.28 * amt), 0.0);\n  return max(oklabToLinearSrgb(oklchToOklab(lch)), vec3<f32>(0.0));\n}\n\n// \u2500\u2500 Structure-tensor / edge-tangent-flow (AW.W4.1; the WGSL twin) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// Returns vec3(tangent.x, tangent.y, A) \u2014 the minor-eigenvector edge-tangent + coherence.\nfn structureTensorField(p: vec2<f32>, t: f32, fallbackDir: vec2<f32>) -> vec3<f32> {\n  let e = 0.0035;\n  let l00 = dot(sampleBase(p + vec2<f32>(-e, -e), t), W_LUMA);\n  let l10 = dot(sampleBase(p + vec2<f32>(0.0, -e), t), W_LUMA);\n  let l20 = dot(sampleBase(p + vec2<f32>( e, -e), t), W_LUMA);\n  let l01 = dot(sampleBase(p + vec2<f32>(-e, 0.0), t), W_LUMA);\n  let l21 = dot(sampleBase(p + vec2<f32>( e, 0.0), t), W_LUMA);\n  let l02 = dot(sampleBase(p + vec2<f32>(-e, e), t), W_LUMA);\n  let l12 = dot(sampleBase(p + vec2<f32>(0.0, e), t), W_LUMA);\n  let l22 = dot(sampleBase(p + vec2<f32>( e, e), t), W_LUMA);\n  let Gx = (l20 + 2.0 * l21 + l22) - (l00 + 2.0 * l01 + l02);\n  let Gy = (l02 + 2.0 * l12 + l22) - (l00 + 2.0 * l10 + l20);\n  let Jxx = Gx * Gx;\n  let Jyy = Gy * Gy;\n  let Jxy = Gx * Gy;\n  let tr = Jxx + Jyy;\n  let disc = sqrt(max((Jxx - Jyy) * (Jxx - Jyy) + 4.0 * Jxy * Jxy, 0.0));\n  let lambdaMaj = 0.5 * (tr + disc);\n  let lambdaMin = 0.5 * (tr - disc);\n  var tangent: vec2<f32>;\n  if (disc < 1e-7) {\n    tangent = fallbackDir;\n  } else {\n    let theta = 0.5 * atan2(2.0 * Jxy, Jxx - Jyy);\n    tangent = vec2<f32>(-sin(theta), cos(theta));\n  }\n  var A = (lambdaMaj - lambdaMin) / (lambdaMaj + lambdaMin + 1e-6);\n  A = clamp(A, 0.0, 1.0);\n  if (dot(tangent, fallbackDir) < 0.0) { tangent = -tangent; }\n  let blendW = pow(A, 0.28);\n  let dir = normalize(mix(fallbackDir, tangent, blendW) + vec2<f32>(1e-6, 1e-6));\n  return vec3<f32>(dir, A);\n}\n\n// \u2500\u2500 Flow field (the WGSL twin \u2014 the simple flow seed the medium fallback dirs use) \u2500\u2500\nfn flowField(p: vec2<f32>, t: f32) -> vec2<f32> {\n  // Curl-noise-driven swirl (the medium-default dir; the full radial/swirl/diagonal\n  // dispatch rides uniforms the WGSL struct does not carry \u2014 the procedural mediums\n  // use this multi/curl seed as the fallback the structure tensor relaxes toward).\n  let n = fbm(p * 2.0 + vec2<f32>(t * 0.02, t * 0.02));\n  let a = n * 6.2831853;\n  var dir = vec2<f32>(cos(a), sin(a));\n  // Cursor swirl bias (matches the GLSL flow cursor term \u2014 the steady attraction).\n  let cursorStrength = u.scalars3.y;\n  let cursorRadius = u.scalars3.z;\n  let cursor = u.cursor.xy;\n  if (cursorStrength > 0.001) {\n    let toCur = cursor - p;\n    let d = length(toCur);\n    let r = max(cursorRadius, 0.01);\n    let w = exp(-(d * d) / (r * r * 0.5));\n    let tangent = vec2<f32>(-toCur.y, toCur.x) / max(d, 1e-4);\n    let a0 = atan2(dir.y, dir.x);\n    let a1 = atan2(tangent.y, tangent.x);\n    var da = a1 - a0;\n    da = atan2(sin(da), cos(da));\n    let aa = a0 + da * w * cursorStrength;\n    dir = vec2<f32>(cos(aa), sin(aa));\n  }\n  return dir;\n}\n\n// \u2500\u2500 Watercolor \u2014 wet-edge cauliflowers + granulation + wash banding \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nfn mediumWatercolor(col0: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {\n  var col = col0;\n  let eps = 0.004;\n  let cx1 = sampleBase(p + vec2<f32>(eps, 0.0), t);\n  let cx2 = sampleBase(p - vec2<f32>(eps, 0.0), t);\n  let cy1 = sampleBase(p + vec2<f32>(0.0, eps), t);\n  let cy2 = sampleBase(p - vec2<f32>(0.0, eps), t);\n  let gx = dot(cx1 - cx2, W_LUMA);\n  let gy = dot(cy1 - cy2, W_LUMA);\n  let edge = sqrt(gx * gx + gy * gy) / (2.0 * eps);\n  let mask = smoothstep(0.0, 2.5, edge);\n  col = col * mix(1.0, 0.78, mask * mWetEdge());\n\n  let paper = 0.5 * vnoise(p * 160.0) + 0.5 * vnoise(p * 360.0);\n  let pigLoad = 1.0 - dot(col, W_LUMA);\n  col = col * (1.0 - mGranulation() * pigLoad * (paper - 0.5));\n\n  let band = fbm(vec2<f32>(p.x * 1.5, p.y * 0.4));\n  col = col * (1.0 + 0.04 * (band - 0.5));\n  return col;\n}\n\n// \u2500\u2500 Pastel \u2014 anisotropic stroke noise along the flow + tooth grain \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nfn mediumPastel(col0: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {\n  var col = col0;\n  let flow = flowField(p, t);\n  let perp = vec2<f32>(-flow.y, flow.x);\n  let strokeScale = mStrokeScale();\n  let along = dot(p, flow) * strokeScale;\n  var across = dot(p, perp) * strokeScale;\n  across = across + 0.03 * (vnoise(p * 260.0) - 0.5);\n\n  let aniso = mix(1.0, 0.18, mStrokeAnisotropy());\n  let stroke = fbm(vec2<f32>(along * aniso, across));\n  col = col * mix(1.0, 0.82 + 0.32 * stroke, mStrokeAmount());\n\n  let tooth = vnoise(p * 800.0);\n  col = col * (1.0 - 0.08 * mStrokeAmount() * (tooth - 0.5));\n  return col;\n}\n\n// \u2500\u2500 Crayon \u2014 DRY wax pigment on paper tooth (the tooth-multiply + scumble) \u2500\u2500\nfn mediumCrayon(col0: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {\n  let flow = structureTensorField(p, t, flowField(p, t)).xy;\n  let ang = atan2(flow.y, flow.x);\n  let ca = cos(-ang);\n  let sa = sin(-ang);\n  let pr = vec2<f32>(p.x * ca - p.y * sa, p.x * sa + p.y * ca);\n\n  let aniso = mix(0.45, 0.95, mStrokeAnisotropy());\n  let scale = max(mStrokeScale() * 1.6, 180.0);\n\n  let t1 = vnoise(vec2<f32>(pr.x * scale * aniso, pr.y * scale));\n  let t2 = vnoise(vec2<f32>(pr.x * scale * aniso * 0.4, pr.y * scale * 0.4) + vec2<f32>(11.0, 11.0));\n  let t3 = vnoise(vec2<f32>(pr.x * scale * aniso * 2.1, pr.y * scale * 2.1) + vec2<f32>(23.0, 23.0));\n  let tooth = 0.55 * t1 + 0.30 * t2 + 0.15 * t3;\n\n  let pressure = clamp(mStrokeAmount(), 0.0, 1.0);\n  let bite = mix(0.18, 0.46, pressure);\n  var result = col0 * (1.0 - bite * (0.5 - tooth));\n\n  let scumbleMask = smoothstep(0.42, 0.78, vnoise(vec2<f32>(pr.x * scale * 0.55, pr.y * scale * 0.22) + vec2<f32>(7.0, 7.0)));\n  let scumbleCoverage = scumbleMask * pressure * 0.7;\n  let paper = col0 * mix(0.80, 0.94, pressure);\n  result = mix(paper, result, scumbleCoverage);\n\n  let pigmentCell = floor(pr * max(scale * 0.18, 32.0));\n  let pigmentMask = smoothstep(0.28, 0.82, vnoise(pr * scale * 0.21 + vec2<f32>(19.0, 19.0)));\n  result = brokenColorJitter(\n    result,\n    hash21(pigmentCell + vec2<f32>(17.0, 17.0)),\n    hash21(pigmentCell * 2.1 + vec2<f32>(31.0, 31.0)),\n    0.45 + 0.55 * pigmentMask\n  );\n\n  result = saturate3(result, 1.08);\n  return result;\n}\n\n// \u2500\u2500 Kuwahara \u2014 the SOFT anisotropic generalized Kuwahara painterly finish \u2500\u2500\u2500\u2500\n// THE KEYSTONE (Kyprianidis 2010). Aurora is a PROCEDURAL field (no input texture) so the\n// operator runs over sampleBase directly: an elliptical kernel oriented along the structure\n// tensor (elongated along the edge-tangent, narrowed across by the anisotropy), 8 OVERLAPPING\n// sectors via SMOOTH gaussian-angular weights, blended by 1/(1+var^q) (the SOFT criterion \u2192\n// no 8-spoke pinwheel by construction). 4 rings \u00D7 8 angular taps = 32 procedural samples.\nfn mediumKuwahara(col0: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {\n  let stf = structureTensorField(p, t, flowField(p, t));\n  let tangent = stf.xy;\n  let A = stf.z;\n  // The studio knob drives the patch radius; clamp into the procedural patch band.\n  let radius = clamp(mKuwaharaRadius() + mStrokeScale() * 0.00018, 0.006, 0.024);\n  let aniso = mix(1.0, 0.34, clamp(A, 0.0, 1.0));\n  let ax = tangent;\n  let ay = vec2<f32>(-tangent.y, tangent.x);\n\n  // Per-sector weighted sums (8 sectors). WGSL has no runtime-indexed local arrays of\n  // vectors as cleanly as GLSL, so unroll the sector accumulators explicitly.\n  var mSum: array<vec3<f32>, 8>;\n  var sSum: array<vec3<f32>, 8>;\n  var wSum: array<f32, 8>;\n  for (var i = 0; i < 8; i = i + 1) {\n    mSum[i] = vec3<f32>(0.0);\n    sSum[i] = vec3<f32>(0.0);\n    wSum[i] = 0.0;\n  }\n\n  let RINGS = 4;\n  let TAPS = 8;\n  for (var r = 1; r <= RINGS; r = r + 1) {\n    let rr = f32(r) / f32(RINGS);\n    let radial = 1.0 - 0.6 * rr;\n    for (var a = 0; a < TAPS; a = a + 1) {\n      let ang = 6.2831853 * f32(a) / f32(TAPS);\n      let dirE = ax * cos(ang) + ay * (sin(ang) * aniso);\n      let off = dirE * (radius * rr);\n      let c = sampleBase(p + off, t);\n      for (var k = 0; k < 8; k = k + 1) {\n        let sectorAng = 6.2831853 * f32(k) / 8.0;\n        var d = ang - sectorAng;\n        d = atan2(sin(d), cos(d));\n        let sw = exp(-d * d * 2.2) * radial;\n        mSum[k] = mSum[k] + c * sw;\n        sSum[k] = sSum[k] + c * c * sw;\n        wSum[k] = wSum[k] + sw;\n      }\n    }\n  }\n\n  let q = max(mKuwaharaQ(), 1.0);\n  var accum = vec3<f32>(0.0);\n  var accumW = 0.0;\n  for (var k = 0; k < 8; k = k + 1) {\n    let wk = max(wSum[k], 1e-4);\n    let mean = mSum[k] / wk;\n    let var3 = max(sSum[k] / wk - mean * mean, vec3<f32>(0.0));\n    let variance = dot(var3, W_LUMA);\n    let sectorW = 1.0 / (1.0 + pow(variance * 320.0, q));\n    accum = accum + mean * sectorW;\n    accumW = accumW + sectorW;\n  }\n  var result = accum / max(accumW, 1e-4);\n\n  // Anchor in near-flat zones so the smoothing only bites at edges.\n  let center = sampleBase(p, t);\n  result = mix(center, result, clamp(0.35 + 0.65 * A, 0.0, 1.0));\n\n  // Faint canvas tooth + pigment-saturation so the flattened patches read as oil paint.\n  let tooth = vnoise(p * 300.0) - 0.5;\n  result = result * (1.0 + tooth * 0.06 * mCanvasGrain());\n  result = saturate3(result, 1.04);\n\n  return mix(col0, result, clamp(mStrokeAmount(), 0.0, 1.0));\n}\n\n// \u2500\u2500 Medium dispatch (the WGSL twin of the GLSL main() if-ladder) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// uMedium: 0 smooth \u00B7 1 pastel \u00B7 2 watercolor \u00B7 3 oil \u00B7 4 crayon \u00B7 5 vangogh \u00B7\n// 6 oil-pastel \u00B7 7 kuwahara. The cheap peer mediums (pastel/watercolor/crayon) +\n// kuwahara port their own bodies; the oil/vangogh/oil-pastel STROKE cascade renders\n// the anisotropic-Kuwahara PAINTERLY finish here (a real oil-paint read, never the\n// smooth core \u2014 the \"NO FALLBACKS on Safari\" mandate; the full per-dab Starry-Night\n// stroke WGSL is the booked W-AURORA-WGPU-MEDIUMS-STROKES tail).\nfn applyMedium(col: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {\n  let medium = u.ints1.x;\n  if (medium == 1) { return mediumPastel(col, p, t); }\n  if (medium == 2) { return mediumWatercolor(col, p, t); }\n  if (medium == 4) { return mediumCrayon(col, p, t); }\n  // oil(3) / vangogh(5) / oil-pastel(6) / kuwahara(7) all render the painterly\n  // anisotropic-Kuwahara finish on the WGSL primary (the WebGL2 fallback carries the\n  // full per-dab stroke cascade for oil/vangogh/oil-pastel).\n  if (medium == 3 || medium == 5 || medium == 6 || medium == 7) {\n    return mediumKuwahara(col, p, t);\n  }\n  return col;\n}\n";

package/dist/components/custom/aurora/constants/shaders/aurora.wgsl.d.ts

@@ -0,0 +1 @@
+export declare const AURORA_WGSL = "\nconst MAX_NUCLEI: i32 = 6;\nconst MAX_STOPS: i32 = 8;\nconst PI: f32 = 3.141592653589793;\n\n// \u2500\u2500 Uniforms (the typed-struct source-of-truth \u2014 see aurora.wgsl.uniforms.ts) \u2500\u2500\n// Scalars are packed into vec4 lanes to keep the std140/WGSL 16-byte struct alignment\n// trivial. nuc0[i] = (pos.x, pos.y, radius, paletteBias); nuc1[i] = (valueBias,\n// driftRadius, driftPhase, elong); nuc2[i] = (angle, _, _, _). palette[i].rgb is the\n// CPU-baked linear-sRGB stop.\nstruct Uniforms {\n  // scalars0: (uTime, uSoftmaxBeta, uValueVariance, uWarpAmount)\n  scalars0: vec4<f32>,\n  // scalars1: (uWarpScale, uWarpDrift, uSaturation, uPaperGrain)\n  scalars1: vec4<f32>,\n  // scalars2: (uAlpha, uNucleiDrift, uPaletteDrift, uBreathDepth)\n  scalars2: vec4<f32>,\n  // scalars3: (uBreathPeriod, uCursorStrength, uCursorRadius, _pad)\n  scalars3: vec4<f32>,\n  // cursor: (uCursor.x, uCursor.y, _pad, _pad)\n  cursor: vec4<f32>,\n  // ints: (uStopCount, uNucleiCount, uWarpMode, uNoiseOctaves)\n  ints0: vec4<i32>,\n  // ints1: (uMedium, uHuePath, _, _)\n  ints1: vec4<i32>,\n  palette: array<vec4<f32>, 8>,\n  nuc0: array<vec4<f32>, 6>,\n  nuc1: array<vec4<f32>, 6>,\n  nuc2: array<vec4<f32>, 6>,\n  // BC.W-VIZ-AURORA (T4) \u2014 the painterly-medium scalar lanes. APPENDED after the\n  // arrays so EVERY existing offset (and the smooth-default parity capture) is\n  // byte-identical (these lanes are written 0 on a smooth config). scalars4:\n  // (uStrokeAmount, uStrokeScale, uStrokeAnisotropy, uCanvasGrain). scalars5:\n  // (uWetEdge, uGranulation, uBrokenColor, uKuwaharaQ). kuwahara: (uKuwaharaRadius,\n  // uKuwaharaSectors, _, _) \u2014 the Kuwahara radius/sectors/q in lockstep with\n  // packAuroraWGPUUniforms (the typed-struct discipline).\n  scalars4: vec4<f32>,\n  scalars5: vec4<f32>,\n  kuwahara: vec4<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u: Uniforms;\n\n// \u2500\u2500 Authoring-scale \u2192 rad/sec lifts (byte-identical to aurora.frag.ts) \u2500\u2500\nconst K_NUCLEI: f32 = 14.0;\nconst K_PAL: f32 = 24.0;\nconst K_WARP: f32 = 5.0;\n\n// \u2500\u2500 Noise (aurora-local hash21/vnoise/fbm \u2014 legitimately divergent per AV.W2 \u00A73a) \u2500\u2500\nfn hash21(p0: vec2<f32>) -> f32 {\n  var p = fract(p0 * vec2<f32>(123.34, 456.21));\n  p = p + dot(p, p + 45.32);\n  return fract(p.x * p.y);\n}\n\nfn hash22(p0: vec2<f32>) -> vec2<f32> {\n  let p = vec2<f32>(dot(p0, vec2<f32>(127.1, 311.7)),\n                    dot(p0, vec2<f32>(269.5, 183.3)));\n  return fract(sin(p) * 43758.5453);\n}\n\nfn vnoise(p: vec2<f32>) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let uu = f * f * (3.0 - 2.0 * f);\n  let a = hash21(i);\n  let b = hash21(i + vec2<f32>(1.0, 0.0));\n  let c = hash21(i + vec2<f32>(0.0, 1.0));\n  let d = hash21(i + vec2<f32>(1.0, 1.0));\n  return mix(mix(a, b, uu.x), mix(c, d, uu.x), uu.y);\n}\n\nconst FBM_ROT: mat2x2<f32> = mat2x2<f32>(0.8, 0.6, -0.6, 0.8);\n\nfn fbm(p0: vec2<f32>) -> f32 {\n  var v = 0.0;\n  var a = 0.5;\n  var p = p0;\n  let octaves = u.ints0.w;\n  for (var i = 0; i < 5; i = i + 1) {\n    if (i >= octaves) { break; }\n    v = v + a * vnoise(p);\n    p = FBM_ROT * p * 2.02;\n    a = a * 0.5;\n  }\n  return v;\n}\n\n\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}\n\n// value.js LINEAR_SRGB_TO_LMS, row-major \u2192 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\u2192OKLab coefficients, row-major \u2192 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 \u2192 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 \u2192 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 \u2192 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) \u2192 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 \u2192 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) \u2192 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}\n\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 \u2192 OKLab-rectangular interpolation \u2192 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 \u2192 OKLCh hue-arc interpolation \u2192 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}\n\n// Interleaved Gradient Noise (Jimenez) \u2014 display-space 1-LSB dither.\nfn ign(p: vec2<f32>) -> f32 {\n  return fract(52.9829189 * fract(dot(p, vec2<f32>(0.06711056, 0.00583715))));\n}\n\n// Cellular / Worley f1.\nfn cellular(p: vec2<f32>) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  var m = 1e9;\n  for (var y = -1; y <= 1; y = y + 1) {\n    for (var x = -1; x <= 1; x = x + 1) {\n      let g = vec2<f32>(f32(x), f32(y));\n      let o = hash22(i + g);\n      let r = g + o - f;\n      m = min(m, dot(r, r));\n    }\n  }\n  return sqrt(m);\n}\n\n// \u2500\u2500 Warp (Quilez double warp + the three warp modes + the cursor swirl) \u2500\u2500\nfn domainWarp(p: vec2<f32>, t: f32) -> vec2<f32> {\n  let warpScale = u.scalars1.x;\n  let warpDrift = u.scalars1.y;\n  let warpAmount = u.scalars0.w;\n  let warpMode = u.ints0.z;\n  let cursorStrength = u.scalars3.y;\n  let cursorRadius = u.scalars3.z;\n  let cursor = u.cursor.xy;\n\n  let q = vec2<f32>(fbm(p * warpScale + vec2<f32>(0.0, 0.0) + t * warpDrift * K_WARP),\n                    fbm(p * warpScale + vec2<f32>(5.2, 1.3) + t * warpDrift * K_WARP));\n  let r = vec2<f32>(fbm(p * warpScale + 4.0 * q + vec2<f32>(1.7, 9.2)),\n                    fbm(p * warpScale + 4.0 * q + vec2<f32>(8.3, 2.8)));\n\n  var warp = r;\n  if (warpMode == 1) {\n    // cellular \u2014 chunky territories\n    let c1 = cellular(p * warpScale * 1.5 + vec2<f32>(t * warpDrift * K_WARP * 2.0, 0.0));\n    let c2 = cellular(p * warpScale * 1.5 + vec2<f32>(11.0, 7.0 + t * warpDrift * K_WARP * 2.0));\n    warp = vec2<f32>(c1, c2);\n  } else if (warpMode == 2) {\n    // hybrid \u2014 fbm + cellular averaged\n    let c1 = cellular(p * warpScale * 1.2);\n    let c2 = cellular(p * warpScale * 1.2 + vec2<f32>(11.0, 7.0));\n    warp = mix(r, vec2<f32>(c1, c2), 0.5);\n  }\n  var warped = p + warpAmount * warp;\n\n  // Cursor swirl \u2014 rotate p around the cursor with radial falloff.\n  if (cursorStrength > 0.001) {\n    let toP = p - cursor;\n    let d = length(toP);\n    let rr = max(cursorRadius, 0.01);\n    let w = exp(-(d * d) / (rr * rr * 0.45));\n    let ang = w * cursorStrength * 2.1;\n    let ca = cos(ang);\n    let sa = sin(ang);\n    var rotated = vec2<f32>(ca * toP.x - sa * toP.y, sa * toP.x + ca * toP.y) + cursor;\n    let pinch = w * cursorStrength * 0.08;\n    rotated = mix(rotated, cursor, pinch);\n    warped = mix(warped, rotated + warpAmount * warp * 0.7, w * cursorStrength);\n  }\n  return warped;\n}\n\n// \u2500\u2500 Palette LUT \u2500\u2500\nfn samplePalette(id0: f32) -> vec3<f32> {\n  let id = clamp(id0, 0.0, 1.0);\n  let stopCount = u.ints0.x;\n  let scaled = id * f32(stopCount - 1);\n  let i0 = i32(floor(scaled));\n  let i1 = min(i0 + 1, stopCount - 1);\n  let t = fract(scaled);\n  return samplePaletteRamp(u.palette[i0].rgb, u.palette[i1].rgb, t, u.ints1.y);\n}\n\n// \u2500\u2500 Nuclei field (anisotropic Gaussian softmax + drift + palette drift) \u2500\u2500\nstruct NucleiResult { paletteId: f32, valueMod: f32 };\n\nfn nucleiField(p: vec2<f32>, t: f32) -> NucleiResult {\n  let nucleiCount = u.ints0.y;\n  let nucleiDrift = u.scalars2.y;\n  let paletteDrift = u.scalars2.z;\n  let softmaxBeta = u.scalars0.y;\n\n  var accumBias = 0.0;\n  var accumValue = 0.0;\n  var accumW = 0.0;\n  for (var i = 0; i < MAX_NUCLEI; i = i + 1) {\n    if (i >= nucleiCount) { break; }\n    let n0 = u.nuc0[i];   // pos.x, pos.y, radius, paletteBias\n    let n1 = u.nuc1[i];   // valueBias, driftRadius, driftPhase, elong\n    let angle = u.nuc2[i].x;\n    let driftRadius = n1.y;\n    let driftPhase = n1.z;\n    let posI = n0.xy + driftRadius * vec2<f32>(\n      cos(t * nucleiDrift * K_NUCLEI + driftPhase),\n      sin(t * nucleiDrift * K_NUCLEI + driftPhase * 1.13)\n    );\n    let diff = p - posI;\n    let ca = cos(angle);\n    let sa = sin(angle);\n    let local = vec2<f32>(ca * diff.x + sa * diff.y, -sa * diff.x + ca * diff.y);\n    let along = local.x / max(n1.w, 0.01);\n    let across = local.y;\n    let d2 = along * along + across * across;\n    let r = max(n0.z, 0.01);\n    let w = exp(-softmaxBeta * d2 / (r * r));\n    accumBias = accumBias + w * n0.w;\n    accumValue = accumValue + w * n1.x;\n    accumW = accumW + w;\n  }\n  var paletteId = accumBias / max(accumW, 1e-4);\n  let valueMod = accumValue / max(accumW, 1e-4);\n\n  let palAmp = clamp(paletteDrift * 6.0, 0.0, 0.06);\n  paletteId = paletteId + palAmp * sin(t * paletteDrift * K_PAL);\n  paletteId = clamp(paletteId, 0.0, 1.0);\n  return NucleiResult(paletteId, valueMod);\n}\n\n// \u2500\u2500 Color utils (OKLCh saturation) \u2500\u2500\nfn linOklab(lin: vec3<f32>) -> vec3<f32> {\n  let lms = LINEAR_SRGB_TO_LMS * lin;\n  return LMS_TO_OKLAB * cbrt3(lms);\n}\n\nfn saturate3(c: vec3<f32>, amt: f32) -> vec3<f32> {\n  var lch = oklabToOklch(linOklab(c));\n  lch.y = max(lch.y * amt, 0.0);\n  return max(oklabToLinearSrgb(oklchToOklab(lch)), vec3<f32>(0.0));\n}\n\n// \u2500\u2500 PBR-Neutral tonemap (named aces() in the GLSL \u2014 the tonemap slot) \u2500\u2500\nfn aces(color0: vec3<f32>) -> vec3<f32> {\n  let startCompression = 0.8 - 0.04;\n  let desaturation = 0.15;\n  var color = color0;\n  let x = min(color.r, min(color.g, color.b));\n  var offset = 0.04;\n  if (x < 0.08) { offset = x - 6.25 * x * x; }\n  color = color - offset;\n  let peak = max(color.r, max(color.g, color.b));\n  if (peak < startCompression) { return clamp(color, vec3<f32>(0.0), vec3<f32>(1.0)); }\n  let d = 1.0 - startCompression;\n  let newPeak = 1.0 - d * d / (peak + d - startCompression);\n  color = color * (newPeak / peak);\n  let g = 1.0 - 1.0 / (desaturation * (peak - newPeak) + 1.0);\n  return clamp(mix(color, newPeak * vec3<f32>(1.0), g), vec3<f32>(0.0), vec3<f32>(1.0));\n}\n\n// \u2500\u2500 BC.W-VIZ-AURORA (T4) \u2014 the painterly-medium bodies (the keystone WGSL port) \u2500\u2500\n// Spliced HERE, after every helper the mediums consume is defined (domainWarp,\n// nucleiField, samplePalette, linOklab, saturate3, oklabToOklch/oklchToOklab,\n// hash21/vnoise/fbm) and before the vertex/fragment stages. applyMedium(col,p,t)\n// is the dispatch the fragment stage calls.\n\n// \u2500\u2500 Painterly luma + medium scalar accessors \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nconst W_LUMA: vec3<f32> = vec3<f32>(0.2126, 0.7152, 0.0722);\n\nfn mStrokeAmount() -> f32 { return u.scalars4.x; }\nfn mStrokeScale() -> f32 { return u.scalars4.y; }\nfn mStrokeAnisotropy() -> f32 { return u.scalars4.z; }\nfn mCanvasGrain() -> f32 { return u.scalars4.w; }\nfn mWetEdge() -> f32 { return u.scalars5.x; }\nfn mGranulation() -> f32 { return u.scalars5.y; }\nfn mBrokenColor() -> f32 { return u.scalars5.z; }\nfn mKuwaharaQ() -> f32 { return u.scalars5.w; }\nfn mKuwaharaRadius() -> f32 { return u.kuwahara.x; }\n\n// \u2500\u2500 Base color re-sample (the edge-mask operator the mediums Sobel/sector-sample) \u2500\u2500\n// The WGSL twin of mediums.glsl.ts sampleBase: warp -> nuclei field -> palette -> value.\nfn sampleBase(p: vec2<f32>, t: f32) -> vec3<f32> {\n  let pw = domainWarp(p, t);\n  let nf = nucleiField(pw, t);\n  var c = samplePalette(nf.paletteId);\n  c = c * (1.0 + u.scalars0.z * nf.valueMod);\n  return c;\n}\n\n// \u2500\u2500 Broken color (hue + chroma jitter at constant OKLCh L) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nfn brokenColorJitter(c: vec3<f32>, hueSeed: f32, valueSeed: f32, strength: f32) -> vec3<f32> {\n  let amt = clamp(mBrokenColor() * strength, 0.0, 1.0);\n  if (amt <= 0.001) { return c; }\n  var lch = oklabToOklch(linOklab(c));\n  lch.z = lch.z + (hueSeed - 0.5) * (32.0 * PI / 180.0) * amt;\n  lch.y = max(lch.y * (1.0 + (valueSeed - 0.5) * 0.28 * amt), 0.0);\n  return max(oklabToLinearSrgb(oklchToOklab(lch)), vec3<f32>(0.0));\n}\n\n// \u2500\u2500 Structure-tensor / edge-tangent-flow (AW.W4.1; the WGSL twin) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// Returns vec3(tangent.x, tangent.y, A) \u2014 the minor-eigenvector edge-tangent + coherence.\nfn structureTensorField(p: vec2<f32>, t: f32, fallbackDir: vec2<f32>) -> vec3<f32> {\n  let e = 0.0035;\n  let l00 = dot(sampleBase(p + vec2<f32>(-e, -e), t), W_LUMA);\n  let l10 = dot(sampleBase(p + vec2<f32>(0.0, -e), t), W_LUMA);\n  let l20 = dot(sampleBase(p + vec2<f32>( e, -e), t), W_LUMA);\n  let l01 = dot(sampleBase(p + vec2<f32>(-e, 0.0), t), W_LUMA);\n  let l21 = dot(sampleBase(p + vec2<f32>( e, 0.0), t), W_LUMA);\n  let l02 = dot(sampleBase(p + vec2<f32>(-e, e), t), W_LUMA);\n  let l12 = dot(sampleBase(p + vec2<f32>(0.0, e), t), W_LUMA);\n  let l22 = dot(sampleBase(p + vec2<f32>( e, e), t), W_LUMA);\n  let Gx = (l20 + 2.0 * l21 + l22) - (l00 + 2.0 * l01 + l02);\n  let Gy = (l02 + 2.0 * l12 + l22) - (l00 + 2.0 * l10 + l20);\n  let Jxx = Gx * Gx;\n  let Jyy = Gy * Gy;\n  let Jxy = Gx * Gy;\n  let tr = Jxx + Jyy;\n  let disc = sqrt(max((Jxx - Jyy) * (Jxx - Jyy) + 4.0 * Jxy * Jxy, 0.0));\n  let lambdaMaj = 0.5 * (tr + disc);\n  let lambdaMin = 0.5 * (tr - disc);\n  var tangent: vec2<f32>;\n  if (disc < 1e-7) {\n    tangent = fallbackDir;\n  } else {\n    let theta = 0.5 * atan2(2.0 * Jxy, Jxx - Jyy);\n    tangent = vec2<f32>(-sin(theta), cos(theta));\n  }\n  var A = (lambdaMaj - lambdaMin) / (lambdaMaj + lambdaMin + 1e-6);\n  A = clamp(A, 0.0, 1.0);\n  if (dot(tangent, fallbackDir) < 0.0) { tangent = -tangent; }\n  let blendW = pow(A, 0.28);\n  let dir = normalize(mix(fallbackDir, tangent, blendW) + vec2<f32>(1e-6, 1e-6));\n  return vec3<f32>(dir, A);\n}\n\n// \u2500\u2500 Flow field (the WGSL twin \u2014 the simple flow seed the medium fallback dirs use) \u2500\u2500\nfn flowField(p: vec2<f32>, t: f32) -> vec2<f32> {\n  // Curl-noise-driven swirl (the medium-default dir; the full radial/swirl/diagonal\n  // dispatch rides uniforms the WGSL struct does not carry \u2014 the procedural mediums\n  // use this multi/curl seed as the fallback the structure tensor relaxes toward).\n  let n = fbm(p * 2.0 + vec2<f32>(t * 0.02, t * 0.02));\n  let a = n * 6.2831853;\n  var dir = vec2<f32>(cos(a), sin(a));\n  // Cursor swirl bias (matches the GLSL flow cursor term \u2014 the steady attraction).\n  let cursorStrength = u.scalars3.y;\n  let cursorRadius = u.scalars3.z;\n  let cursor = u.cursor.xy;\n  if (cursorStrength > 0.001) {\n    let toCur = cursor - p;\n    let d = length(toCur);\n    let r = max(cursorRadius, 0.01);\n    let w = exp(-(d * d) / (r * r * 0.5));\n    let tangent = vec2<f32>(-toCur.y, toCur.x) / max(d, 1e-4);\n    let a0 = atan2(dir.y, dir.x);\n    let a1 = atan2(tangent.y, tangent.x);\n    var da = a1 - a0;\n    da = atan2(sin(da), cos(da));\n    let aa = a0 + da * w * cursorStrength;\n    dir = vec2<f32>(cos(aa), sin(aa));\n  }\n  return dir;\n}\n\n// \u2500\u2500 Watercolor \u2014 wet-edge cauliflowers + granulation + wash banding \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nfn mediumWatercolor(col0: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {\n  var col = col0;\n  let eps = 0.004;\n  let cx1 = sampleBase(p + vec2<f32>(eps, 0.0), t);\n  let cx2 = sampleBase(p - vec2<f32>(eps, 0.0), t);\n  let cy1 = sampleBase(p + vec2<f32>(0.0, eps), t);\n  let cy2 = sampleBase(p - vec2<f32>(0.0, eps), t);\n  let gx = dot(cx1 - cx2, W_LUMA);\n  let gy = dot(cy1 - cy2, W_LUMA);\n  let edge = sqrt(gx * gx + gy * gy) / (2.0 * eps);\n  let mask = smoothstep(0.0, 2.5, edge);\n  col = col * mix(1.0, 0.78, mask * mWetEdge());\n\n  let paper = 0.5 * vnoise(p * 160.0) + 0.5 * vnoise(p * 360.0);\n  let pigLoad = 1.0 - dot(col, W_LUMA);\n  col = col * (1.0 - mGranulation() * pigLoad * (paper - 0.5));\n\n  let band = fbm(vec2<f32>(p.x * 1.5, p.y * 0.4));\n  col = col * (1.0 + 0.04 * (band - 0.5));\n  return col;\n}\n\n// \u2500\u2500 Pastel \u2014 anisotropic stroke noise along the flow + tooth grain \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nfn mediumPastel(col0: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {\n  var col = col0;\n  let flow = flowField(p, t);\n  let perp = vec2<f32>(-flow.y, flow.x);\n  let strokeScale = mStrokeScale();\n  let along = dot(p, flow) * strokeScale;\n  var across = dot(p, perp) * strokeScale;\n  across = across + 0.03 * (vnoise(p * 260.0) - 0.5);\n\n  let aniso = mix(1.0, 0.18, mStrokeAnisotropy());\n  let stroke = fbm(vec2<f32>(along * aniso, across));\n  col = col * mix(1.0, 0.82 + 0.32 * stroke, mStrokeAmount());\n\n  let tooth = vnoise(p * 800.0);\n  col = col * (1.0 - 0.08 * mStrokeAmount() * (tooth - 0.5));\n  return col;\n}\n\n// \u2500\u2500 Crayon \u2014 DRY wax pigment on paper tooth (the tooth-multiply + scumble) \u2500\u2500\nfn mediumCrayon(col0: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {\n  let flow = structureTensorField(p, t, flowField(p, t)).xy;\n  let ang = atan2(flow.y, flow.x);\n  let ca = cos(-ang);\n  let sa = sin(-ang);\n  let pr = vec2<f32>(p.x * ca - p.y * sa, p.x * sa + p.y * ca);\n\n  let aniso = mix(0.45, 0.95, mStrokeAnisotropy());\n  let scale = max(mStrokeScale() * 1.6, 180.0);\n\n  let t1 = vnoise(vec2<f32>(pr.x * scale * aniso, pr.y * scale));\n  let t2 = vnoise(vec2<f32>(pr.x * scale * aniso * 0.4, pr.y * scale * 0.4) + vec2<f32>(11.0, 11.0));\n  let t3 = vnoise(vec2<f32>(pr.x * scale * aniso * 2.1, pr.y * scale * 2.1) + vec2<f32>(23.0, 23.0));\n  let tooth = 0.55 * t1 + 0.30 * t2 + 0.15 * t3;\n\n  let pressure = clamp(mStrokeAmount(), 0.0, 1.0);\n  let bite = mix(0.18, 0.46, pressure);\n  var result = col0 * (1.0 - bite * (0.5 - tooth));\n\n  let scumbleMask = smoothstep(0.42, 0.78, vnoise(vec2<f32>(pr.x * scale * 0.55, pr.y * scale * 0.22) + vec2<f32>(7.0, 7.0)));\n  let scumbleCoverage = scumbleMask * pressure * 0.7;\n  let paper = col0 * mix(0.80, 0.94, pressure);\n  result = mix(paper, result, scumbleCoverage);\n\n  let pigmentCell = floor(pr * max(scale * 0.18, 32.0));\n  let pigmentMask = smoothstep(0.28, 0.82, vnoise(pr * scale * 0.21 + vec2<f32>(19.0, 19.0)));\n  result = brokenColorJitter(\n    result,\n    hash21(pigmentCell + vec2<f32>(17.0, 17.0)),\n    hash21(pigmentCell * 2.1 + vec2<f32>(31.0, 31.0)),\n    0.45 + 0.55 * pigmentMask\n  );\n\n  result = saturate3(result, 1.08);\n  return result;\n}\n\n// \u2500\u2500 Kuwahara \u2014 the SOFT anisotropic generalized Kuwahara painterly finish \u2500\u2500\u2500\u2500\n// THE KEYSTONE (Kyprianidis 2010). Aurora is a PROCEDURAL field (no input texture) so the\n// operator runs over sampleBase directly: an elliptical kernel oriented along the structure\n// tensor (elongated along the edge-tangent, narrowed across by the anisotropy), 8 OVERLAPPING\n// sectors via SMOOTH gaussian-angular weights, blended by 1/(1+var^q) (the SOFT criterion \u2192\n// no 8-spoke pinwheel by construction). 4 rings \u00D7 8 angular taps = 32 procedural samples.\nfn mediumKuwahara(col0: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {\n  let stf = structureTensorField(p, t, flowField(p, t));\n  let tangent = stf.xy;\n  let A = stf.z;\n  // The studio knob drives the patch radius; clamp into the procedural patch band.\n  let radius = clamp(mKuwaharaRadius() + mStrokeScale() * 0.00018, 0.006, 0.024);\n  let aniso = mix(1.0, 0.34, clamp(A, 0.0, 1.0));\n  let ax = tangent;\n  let ay = vec2<f32>(-tangent.y, tangent.x);\n\n  // Per-sector weighted sums (8 sectors). WGSL has no runtime-indexed local arrays of\n  // vectors as cleanly as GLSL, so unroll the sector accumulators explicitly.\n  var mSum: array<vec3<f32>, 8>;\n  var sSum: array<vec3<f32>, 8>;\n  var wSum: array<f32, 8>;\n  for (var i = 0; i < 8; i = i + 1) {\n    mSum[i] = vec3<f32>(0.0);\n    sSum[i] = vec3<f32>(0.0);\n    wSum[i] = 0.0;\n  }\n\n  let RINGS = 4;\n  let TAPS = 8;\n  for (var r = 1; r <= RINGS; r = r + 1) {\n    let rr = f32(r) / f32(RINGS);\n    let radial = 1.0 - 0.6 * rr;\n    for (var a = 0; a < TAPS; a = a + 1) {\n      let ang = 6.2831853 * f32(a) / f32(TAPS);\n      let dirE = ax * cos(ang) + ay * (sin(ang) * aniso);\n      let off = dirE * (radius * rr);\n      let c = sampleBase(p + off, t);\n      for (var k = 0; k < 8; k = k + 1) {\n        let sectorAng = 6.2831853 * f32(k) / 8.0;\n        var d = ang - sectorAng;\n        d = atan2(sin(d), cos(d));\n        let sw = exp(-d * d * 2.2) * radial;\n        mSum[k] = mSum[k] + c * sw;\n        sSum[k] = sSum[k] + c * c * sw;\n        wSum[k] = wSum[k] + sw;\n      }\n    }\n  }\n\n  let q = max(mKuwaharaQ(), 1.0);\n  var accum = vec3<f32>(0.0);\n  var accumW = 0.0;\n  for (var k = 0; k < 8; k = k + 1) {\n    let wk = max(wSum[k], 1e-4);\n    let mean = mSum[k] / wk;\n    let var3 = max(sSum[k] / wk - mean * mean, vec3<f32>(0.0));\n    let variance = dot(var3, W_LUMA);\n    let sectorW = 1.0 / (1.0 + pow(variance * 320.0, q));\n    accum = accum + mean * sectorW;\n    accumW = accumW + sectorW;\n  }\n  var result = accum / max(accumW, 1e-4);\n\n  // Anchor in near-flat zones so the smoothing only bites at edges.\n  let center = sampleBase(p, t);\n  result = mix(center, result, clamp(0.35 + 0.65 * A, 0.0, 1.0));\n\n  // Faint canvas tooth + pigment-saturation so the flattened patches read as oil paint.\n  let tooth = vnoise(p * 300.0) - 0.5;\n  result = result * (1.0 + tooth * 0.06 * mCanvasGrain());\n  result = saturate3(result, 1.04);\n\n  return mix(col0, result, clamp(mStrokeAmount(), 0.0, 1.0));\n}\n\n// \u2500\u2500 Medium dispatch (the WGSL twin of the GLSL main() if-ladder) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// uMedium: 0 smooth \u00B7 1 pastel \u00B7 2 watercolor \u00B7 3 oil \u00B7 4 crayon \u00B7 5 vangogh \u00B7\n// 6 oil-pastel \u00B7 7 kuwahara. The cheap peer mediums (pastel/watercolor/crayon) +\n// kuwahara port their own bodies; the oil/vangogh/oil-pastel STROKE cascade renders\n// the anisotropic-Kuwahara PAINTERLY finish here (a real oil-paint read, never the\n// smooth core \u2014 the \"NO FALLBACKS on Safari\" mandate; the full per-dab Starry-Night\n// stroke WGSL is the booked W-AURORA-WGPU-MEDIUMS-STROKES tail).\nfn applyMedium(col: vec3<f32>, p: vec2<f32>, t: f32) -> vec3<f32> {\n  let medium = u.ints1.x;\n  if (medium == 1) { return mediumPastel(col, p, t); }\n  if (medium == 2) { return mediumWatercolor(col, p, t); }\n  if (medium == 4) { return mediumCrayon(col, p, t); }\n  // oil(3) / vangogh(5) / oil-pastel(6) / kuwahara(7) all render the painterly\n  // anisotropic-Kuwahara finish on the WGSL primary (the WebGL2 fallback carries the\n  // full per-dab stroke cascade for oil/vangogh/oil-pastel).\n  if (medium == 3 || medium == 5 || medium == 6 || medium == 7) {\n    return mediumKuwahara(col, p, t);\n  }\n  return col;\n}\n\n\n// \u2500\u2500 Full-screen triangle vertex stage (the pilot idiom \u2014 no vertex buffer) \u2500\u2500\nstruct VSOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) uv: vec2<f32>,\n};\n\n@vertex\nfn vs_main(@builtin(vertex_index) vi: u32) -> VSOut {\n  // NDC corners of the covering triangle (-1,-1), (3,-1), (-1,3).\n  var p = vec2<f32>(-1.0, -1.0);\n  if (vi == 1u) { p = vec2<f32>(3.0, -1.0); }\n  else if (vi == 2u) { p = vec2<f32>(-1.0, 3.0); }\n  var out: VSOut;\n  out.pos = vec4<f32>(p, 0.0, 1.0);\n  // vUv = aPos * 0.5 + 0.5 (the aurora.vert convention).\n  out.uv = p * 0.5 + 0.5;\n  return out;\n}\n\n// \u2500\u2500 Fragment stage (the main() transcription) \u2500\u2500\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4<f32> {\n  let t = u.scalars0.x;\n  let valueVariance = u.scalars0.z;\n  let breathDepth = u.scalars2.w;\n  let breathPeriod = u.scalars3.x;\n  let saturation = u.scalars1.z;\n  let paperGrain = u.scalars1.w;\n  let alpha = u.scalars2.x;\n\n  let uv = in.uv;\n  let pN = uv;\n\n  let p_warp = domainWarp(pN, t);\n\n  let nf = nucleiField(p_warp, t);\n  var col = samplePalette(nf.paletteId);\n  col = col * (1.0 + valueVariance * nf.valueMod);\n\n  // Breath \u2014 slow global luminance wobble.\n  let breath = sin(t * 6.2831 / max(breathPeriod, 1.0));\n  col = col * (1.0 + breathDepth * breath * 0.5);\n\n  // BC.W-VIZ-AURORA (T4) \u2014 the painterly-medium dispatch. uMedium 0 (smooth) is a\n  // no-op pass-through so the DEFAULT smooth config is byte-identical to the prior\n  // WGSL primary (the parity capture); uMedium 1-7 render the ported painterly\n  // bodies (pastel/watercolor/crayon/kuwahara) or the anisotropic-Kuwahara finish\n  // (oil/vangogh/oil-pastel) \u2014 never a silent smooth degrade on Safari 26.\n  col = applyMedium(col, pN, t);\n\n  // Saturation trim.\n  col = saturate3(col, saturation);\n\n  // Tonemap + film grain.\n  col = aces(col);\n  // gl_FragCoord.xy \u2192 the device-pixel position (the WGSL @builtin(position)).\n  let fragCoord = in.pos.xy;\n  let grain = hash21(fragCoord + t * 17.0);\n  col = col + (grain - 0.5) * paperGrain;\n\n  col = clamp(col * 0.985 + 0.008, vec3<f32>(0.0), vec3<f32>(1.0));\n\n  // MANDATORY OETF \u2014 closes the seam (the whole pipeline above runs in LINEAR).\n  col = linearToSrgb(col);\n\n  // 1-LSB triangular IGN dither in DISPLAY space, AFTER the OETF.\n  col = col + (1.0 / 255.0) * (ign(fragCoord) - 0.5);\n\n  // Premultiply on DISPLAY-space color (matches the WebGL2 path: OETF, then premul).\n  return vec4<f32>(col * alpha, alpha);\n}\n";

package/dist/components/custom/aurora/constants/shaders/oil-modes.glsl.d.ts

@@ -0,0 +1 @@
+export declare const AURORA_OIL_MODES_GLSL = "StrokeProfile profileFor(int medium, int mode) {\n  // The oil baseline (mode 0) \u2014 balanced modern-abstract/palette-knife hybrid.\n  StrokeProfile prof = StrokeProfile(\n    0,      // shapeType \u2014 tapered\n    0.25,   // bristleAmp\n    9.0,    // streakFreq\n    0.09,   // streakAmp\n    0.9,    // impastoAmp\n    0.80,   // hardness\n    340.0,  // toothScale \u2014 W-AUR-VANGOGH-CONFIG reconcile: FINER 240 \u2192 340. Oil's \u00A74.3 \u03B2 sat\n            //               right AT the \u22121.45 band ceiling (\u00B10.02 frame variance straddling\n            //               it, surfaced once the vangogh bands went green and the spec reached\n            //               the oil \u03B2 assert). MEASURED on the live GPU: ADDING fine high-\n            //               frequency tooth energy steepens oil's power-spectrum slope (more\n            //               negative \u2014 coarsening it the other way pushed \u03B2 SHALLOWER to\n            //               \u22121.33). A finer, stronger tooth moves \u03B2 to a safe distance inside\n            //               the \u22125/3 band [\u22121.85, \u22121.45]. Oil-only (oil-pastel sets 280).\n    0.14,   // toothAmp \u2014 raised 0.09 \u2192 0.14 (same oil-\u03B2 steepen: more fine-grain high band).\n    1.03,   // pigmentSat\n    0.65,   // densityBig\n    0.78,   // densityMed\n    0.90,   // densitySml\n    0.0,    // energyGrade \u2014 oil is uniform-length (no Starry-Night cascade)\n    0.4,    // impastoFloor \u2014 oil's 0.4+0.6\u00B7edgeN crown falloff\n    0.92,   // densityFill \u2014 oil fills DENSELY with the directional low-relief fill so the\n            //               flat-colour regions between the macro strokes are TEXTURED with\n            //               flow-aligned fine strokes (the \u00A74.2 anisotropy needs every pixel\n            //               to carry directional gradient; a flat untextured region reads as\n            //               an isotropic/degenerate tensor and drags mean A down). The fill\n            //               is now directional + low-streak, so dense coverage textures\n            //               WITHOUT the prior round-dab speckle.\n    1.0     // groundFloor \u2014 oil keeps the full base (no ground darken; fills everywhere)\n  );\n\n  // W-AUR-VANGOGH-REBUILD \u2014 the van-Gogh medium NO LONGER routes through this oil\n  // StrokeProfile cascade. It is a DEDICATED atomic-dab body (mediumVangogh / vangoghDab\n  // below) \u2014 the prior profile-driven cascade (four dense layers of long-thin\n  // tensor-oriented strokes) merged into the \"marbled flow-bands\" read and ran at ~4fps.\n  // profileFor now serves ONLY the oil + oil-pastel stroke mediums; the MEDIUM_VANGOGH\n  // case is removed (no caller). MEDIUM_VANGOGH stays #define'd (the main() dispatch +\n  // isPainterlyStroke still key off uMedium==5).\n\n  // \u2500\u2500 Oil-pastel \u2014 broad smeared directional strokes deposited via the brush engine\n  // (slice 8 F1). Creamy soft edges (low hardness), heavy build-up, and a chroma punch.\n  // Distinct from the dry-crayon tooth-multiply (mediumCrayon): oil-pastel LAYS strokes.\n  if (medium == MEDIUM_OILPASTEL) {\n    prof.shapeType   = 0;     // tapered directional smear \u2014 a round dab reads locally\n                              // isotropic (steep \u03B2 / low A); the creamy oil-pastel mark\n                              // is a broad DIRECTIONAL smear, which carries the \u00A74.2\n                              // coherence + adds the directional mid-band the \u00A74.3 slope\n                              // needs (the round-dab profile rolled \u03B2 off to \u22122.8)\n    prof.bristleAmp  = 0.10;  // smooth creamy edges (waxy pastel, not bristle)\n    prof.streakFreq  = 18.0;  // finer internal smear \u2014 adds the mid/high-band the smooth\n                              // round-dab profile lacked (the \u03B2-too-steep fix); the\n                              // directional along-spine streak flattens the \u00A74.3 slope\n                              // without crossing the strokes\n    prof.streakAmp   = 0.20;\n    prof.impastoAmp  = 0.7;   // build-up, but flatter than oil impasto\n    prof.hardness    = 0.42;  // CREAMY \u2014 soft compositing, strokes blend on overlap\n    prof.toothScale  = 280.0;\n    prof.toothAmp    = 0.12;  // the pastel tooth reads stronger\n    prof.pigmentSat  = 0.80;  // the waxy chroma \u2014 eased off 1.16 so the rendered C clears\n                              // the \u00A74.1 band ceiling with margin while the K-M subtractive\n                              // overlap path (paintOverOklab) keeps the chroma OFF the grey floor\n    prof.hardness    = 0.58;  // creamy but the strokes still REGISTER \u2014 a too-soft blend\n                              // (0.42) smeared the marks into the smooth colour zones and\n                              // the field rolled off too steep (\u03B2\u2248\u22122.9, a near-gradient);\n                              // a crisper deposit keeps the mid/high-band the \u22125/3 slope needs\n    prof.densityBig  = 0.62;  // broad directional coverage \u2014 but NOT over-dense: too many\n                              // overlapping creamy strokes point in slightly-varied\n                              // directions and the local \u00A74.2 coherence DROPS (over-dense\n                              // measured A=0.57 < the 0.62-density A=0.63). The mid-density\n                              // flow-aligned deposit is the coherence sweet spot.\n    prof.densityMed  = 0.78;\n    prof.densitySml  = 0.90;\n    prof.energyGrade = 0.80;  // a strong Starry-Night length cascade \u2014 varies stroke length\n                              // by luma/coherence so the dab-size energy spreads across\n                              // scales (the \u22125/3 cascade the uniform-length 0.0 grade lacked,\n                              // the \u00A74.3 \u03B2-too-steep fix). Not the full van-Gogh 1.0 (oil-\n                              // pastel keeps its creamy broad character).\n    prof.impastoFloor = 0.55; // a softer crown than van-Gogh's full-height glint\n    return prof;\n  }\n\n  // \u2500\u2500 Oil sub-modes (mode dispatch on the oil medium).\n  if (mode == 1) {           // palette knife \u2014 razor edges, heavy impasto\n    prof.shapeType  = 3;     // flat, even\n    prof.bristleAmp = 0.12;\n    prof.streakFreq = 4.0;  prof.streakAmp = 0.05;\n    prof.impastoAmp = 1.6;\n    prof.hardness   = 0.95;\n    prof.toothAmp   = 0.04;\n    prof.densityBig = 0.80; prof.densityMed = 0.88; prof.densitySml = 0.70;\n  } else if (mode == 3) {    // thick brushwork \u2014 heavy bristle brush\n    prof.shapeType  = 0;     // tapered\n    prof.bristleAmp = 0.32;\n    prof.streakFreq = 14.0; prof.streakAmp = 0.14;\n    prof.impastoAmp = 1.2;\n    prof.hardness   = 0.85;\n    prof.toothAmp   = 0.07;\n  }\n  return prof;\n}\n";

package/dist/components/custom/aurora/constants/shaders/procedural-color.wgsl.d.ts

@@ -0,0 +1,4 @@
+export declare const OETF_WGSL = "\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}";
+export declare const FBM_ROT_WGSL = "const FBM_ROT: mat2x2<f32> = mat2x2<f32>(0.8, 0.6, -0.6, 0.8);";
+export declare const OKLCH_MATRICES_WGSL = "\n// value.js LINEAR_SRGB_TO_LMS, row-major \u2192 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\u2192OKLab coefficients, row-major \u2192 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 \u2192 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 \u2192 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 \u2192 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) \u2192 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 \u2192 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) \u2192 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}";
+export declare const PALETTE_RAMP_WGSL = "\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 \u2192 OKLab-rectangular interpolation \u2192 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 \u2192 OKLCh hue-arc interpolation \u2192 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}";

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

@@ -1,5 +1,5 @@
 export { default as Aurora } from "./Aurora.vue";
-export { resolveRenderMode, type AuroraRenderMode } from "./constants/renderMode";
+export { resolveRenderMode, isSoftwareWebGLRenderer, type AuroraRenderMode, type ResolveRenderModeOptions, } from "./constants/renderMode";
 export { useAurora } from "./composables/useAurora";
 export type { UseAuroraReturn } from "./composables/useAurora";
 export { useCursorInteraction } from "./composables/useCursorInteraction";
@@ -8,5 +8,6 @@ export type { AuroraRuntimeMode, AuroraRuntimeOptions } from "./composables/runt
 export { DEFAULT_AURORA_CONFIG, PAPER_WASH_GROUND, MAX_NUCLEI, MAX_STOPS, type AuroraConfig, type AuroraCursorApi, type AuroraFlow, type AuroraInstance, type AuroraInteractivity, type AuroraMedium, type AuroraNucleus, type FlowPattern, type OklchStop, type StrokeMode, type StrokeOrient, type WarpMode, } from "./constants/presets";
 export { resolveAtoms, configToAtoms, nucleiPrior, DEFAULT_ATOMS, type AuroraAtoms, type AuroraMotionAtom, type AuroraZones, type AuroraZoneArrangement, type AuroraMediumAtom, type AuroraInteractivityAtom, } from "./composables/atoms";
 export { cssToOklch, deriveAurora, flattenPalette, hexToOklchStop, oklchStopToHex, oklchToLinear, paletteToCssGradient, } from "./composables/color";
+export { auroraFallbackGround, sampleAuroraField, nucleiFieldStatic, relativeLuminance, type AuroraFallbackGround, type AuroraFallbackGroundOptions, type AuroraGroundMetrics, } from "./composables/auroraFallbackGround";
 export type { AuroraHarmony, DeriveAuroraOptions, DeriveEasing, } from "./composables/color";
 export type { AuroraHuePath } from "./constants/presets";

package/dist/components/custom/border-progress/BorderProgress.vue.d.ts

@@ -0,0 +1,46 @@
+import { type BorderProgressCoverage, type BorderProgressMilestone, type BorderProgressMilestoneEvent } from "./constants";
+export interface BorderProgressProps {
+    /** The progress scalar. 0..1 (or 0..`max`) drives the registered conic angle. */
+    value: number;
+    /** The value-axis ceiling. Default `1` (a 0..1 scalar; pass `100` for percent). */
+    max?: number;
+    /** `full-ring` (default) sweeps the perimeter; `bottom-edge` paints only the bottom band. */
+    coverage?: BorderProgressCoverage;
+    /**
+     * The conic color stops — CSS color strings. Default the LIBRARY brand ramp
+     * (the `--section-color-*`/`--viz-*` tokens, resolved in the cascade). A
+     * consumer passes its OWN phase palette (presets-in-consumers — no consumer
+     * hue enters a library token). CONCRETE anchors are walked OKLCH/shorter-hue;
+     * `var(--…)` token anchors pass through to the live cascade.
+     */
+    stops?: readonly string[];
+    /** The ring thickness in px (default within the 10-14px envelope). */
+    width?: number;
+    /** The host border-radius in px the ring follows. Default 16. */
+    radius?: number;
+    /**
+     * Phase-edge boundaries. The ring fires `milestone` + (PRM-gated) pulses when
+     * `value` crosses one. The consumer owns the phase colors (the chassis
+     * `--phase-color` cascade precedent — the milestone is the EVENT seam).
+     */
+    milestones?: readonly BorderProgressMilestone[];
+    /** Pass-through class on the root. */
+    class?: string;
+}
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<BorderProgressProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    milestone: (event: BorderProgressMilestoneEvent) => any;
+}, string, import("vue").PublicProps, Readonly<BorderProgressProps> & Readonly<{
+    onMilestone?: ((event: BorderProgressMilestoneEvent) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/custom/border-progress/composables/spectrum-walk.d.ts

@@ -0,0 +1,25 @@
+import { type OklchStop } from "../../../../composables/color";
+/**
+ * Walk the anchor ramp to the single OKLCh stop at parameter `t` (0..1) via the
+ * shorter-hue arc — the segment is located, then value.js's `mixColors` runs the
+ * OKLCh/shorter-hue perceptual mix at the in-segment fraction (the single-point
+ * twin of `sampleColorRamp`; ONE color source — value.js). L/C lerp in OKLCh and
+ * the hue walks the SHORTER arc, so the warm→cool midpoint keeps its chroma.
+ *
+ * Deterministic + DOM-free (SSR-safe; mirrors `deriveBlobPalette`).
+ */
+export declare function spectrumAt(stops: readonly OklchStop[], t: number): OklchStop;
+/**
+ * Walk a CONCRETE-anchor ramp to `count` evenly-spaced HEX stops — the perceptual
+ * (OKLCH/shorter-hue) cold path. The caller (`spectrumStops` in the sync shell) has
+ * already screened out `var(--…)` ramps, so every stop here is a CONCRETE CSS color
+ * the leaf's `cssToOklch` parses to OKLCh; the walk carries no chroma trough.
+ *
+ * Each adjacent anchor pair is one `sampleColorRamp` segment (the value.js grid
+ * sampler walked SHORTER-hue in OKLCh); the per-segment grids concatenate (shared
+ * boundary deduped) into one continuous `count`-stop ramp. The endpoints anchor the
+ * input exactly; the hue walks the shorter arc end-to-end, so no segment greys out.
+ *
+ * @returns one HEX (`#rrggbb`) per stop.
+ */
+export declare function walkConcreteSpectrum(stops: readonly string[], count: number): string[];

package/dist/components/custom/border-progress/composables/useBorderSpectrum.d.ts

@@ -0,0 +1,18 @@
+/** A consumer-supplied callback the COLD path calls once the perceptual walk resolves. */
+export type SpectrumUpgrade = (stops: string[]) => void;
+/**
+ * Produce `samples` evenly-spaced HEX/CSS stops across the anchor ramp — the conic
+ * gradient's color stops. CSS `var(--…)` tokens (the LIBRARY-default brand ramp) are
+ * passed through UNTOUCHED (they resolve in the cascade at paint — the value.js-free
+ * fast path). CONCRETE color anchors return the synchronous interim immediately AND,
+ * when `onUpgrade` is supplied, load `./spectrum-walk` and upgrade to the OKLCH/
+ * shorter-hue perceptual walk once the dynamic chunk resolves.
+ *
+ * `spectrumStops` is SYNCHRONOUS (the SFC's `computed` cannot await). The dynamic
+ * boundary lives INSIDE it (the value.js branch fires `import()` and returns the
+ * synchronous interim), never on the export signature.
+ *
+ * @returns one stop per sample — `var()` strings for a token ramp, the raw anchors
+ *   for the concrete-anchor synchronous interim (upgraded to HEX via `onUpgrade`).
+ */
+export declare function spectrumStops(stops: readonly string[], samples?: number, onUpgrade?: SpectrumUpgrade): string[];

package/dist/components/custom/border-progress/constants.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The coverage axis — `full-ring` sweeps the entire border perimeter,
+ * `bottom-edge` paints ONLY the bottom border band (the literal C2 case: "the
+ * bottom progressbar should serve as a thicker, dynamic BORDER"). The two
+ * coverages share the ONE conic-mask mechanism (a `coverage`-scoped mask
+ * region — NOT a second recipe).
+ */
+export type BorderProgressCoverage = "full-ring" | "bottom-edge";
+/**
+ * The thickness envelope (px). AMENDED 6-8px → 10-14px (speedtest AW v3 relay
+ * A1, 2026-06-17): the thin-hairline 6-8px read as a rim, not the "thicker,
+ * dynamic BORDER" the ask wants. The gate W4 + the π assert the band sits inside
+ * [10, 14].
+ */
+export declare const BORDER_PROGRESS_WIDTH_MIN = 10;
+export declare const BORDER_PROGRESS_WIDTH_MAX = 14;
+/** The default ring thickness — the centre of the 10-14px envelope. */
+export declare const BORDER_PROGRESS_WIDTH_DEFAULT = 12;
+/** The default host border-radius (px) the ring follows when unset by the consumer. */
+export declare const BORDER_PROGRESS_RADIUS_DEFAULT = 16;
+/**
+ * The number of conic stops the spectrum walk samples between the consumer's
+ * anchor stops. A denser sample yields a smoother sweep with no visible banding;
+ * the OKLCH/shorter-hue arc keeps every sample saturated (no chroma trough).
+ */
+export declare const BORDER_PROGRESS_SPECTRUM_SAMPLES = 24;
+/**
+ * The LIBRARY-identity default spectrum — the section/viz brand ramp (the
+ * `--section-color-*` 13-stop ramp + the `--viz-*` twins). These resolve through
+ * the CSS token cascade at paint, so the default carries no baked hue; a consumer
+ * that wants its OWN phase palette passes its stops as the `stops` prop
+ * (presets-in-consumers — NO speedtest/ppmycota hue enters a library token).
+ *
+ * The default is a warm→cool brand arc (rose → indigo → violet) sampled off the
+ * 13-stop ramp so the resting ring already reads as "a spectrum of our colors".
+ */
+export declare const BORDER_PROGRESS_DEFAULT_SPECTRUM: readonly string[];
+/**
+ * A phase-edge milestone descriptor — the consumer declares phase boundaries on
+ * the 0..1 (or 0..100) value axis; the ring fires a `milestone` event + (PRM-
+ * gated) pulses when the value crosses one. The chassis `--phase-color` cascade
+ * is the precedent (the bus carries phase IDENTITY; the milestone is the EVENT
+ * seam — the consumer owns the phase colors, presets-in-consumers).
+ */
+export interface BorderProgressMilestone {
+    /** The value-axis boundary (in the same units as `value`). */
+    at: number;
+    /** An opaque id echoed back on the `milestone` emit. */
+    id: string;
+    /** An optional label echoed back on the emit (analytics / a11y). */
+    label?: string;
+}
+/** The payload of the `milestone` emit — the crossed edge + the value at crossing. */
+export interface BorderProgressMilestoneEvent {
+    /** The crossed milestone descriptor. */
+    milestone: BorderProgressMilestone;
+    /** The value at the moment of crossing (post-update). */
+    value: number;
+}

package/dist/components/custom/border-progress/index.d.ts

@@ -0,0 +1,4 @@
+export { default as BorderProgress } from "./BorderProgress.vue";
+export type { BorderProgressProps } from "./BorderProgress.vue";
+export type { BorderProgressCoverage, BorderProgressMilestone, BorderProgressMilestoneEvent, } from "./constants";
+export { spectrumStops, type SpectrumUpgrade } from "./composables/useBorderSpectrum";

package/dist/components/custom/completion-seal/CompletionSeal.vue.d.ts

@@ -0,0 +1,21 @@
+import { type CompletionSealShape } from "./constants";
+export interface CompletionSealProps {
+    /** The seal glyph — `check` (default) | `ring` | `wordmark`. */
+    shape?: CompletionSealShape;
+    /**
+     * The accessible completion announcement (the `role="status"`/`aria-live` text — a
+     * screen reader hears "Speedtest complete", etc.). The gold mark is the visual.
+     */
+    label?: string;
+    /**
+     * The draw trigger — the consumer fires it on completion. When it flips truthy the
+     * seal draws ONCE. Default (unset) plays on mount (the seal draws when it appears —
+     * the canonical completion moment).
+     */
+    play?: boolean;
+    /** Pass-through class on the root. */
+    class?: string;
+}
+declare const __VLS_export: import("vue").DefineComponent<CompletionSealProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<CompletionSealProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/custom/completion-seal/composables/useCompletionSeal.d.ts

@@ -0,0 +1,37 @@
+import { type Ref } from "vue";
+export interface UseCompletionSealOptions {
+    /**
+     * The draw trigger. When it flips truthy the seal draws ONCE (the consumer fires it
+     * on completion). A `Ref` or a getter; default plays on mount (`play` unset → the
+     * seal draws when it appears, the canonical completion moment).
+     */
+    play?: Ref<boolean | undefined> | (() => boolean | undefined);
+    /**
+     * Honor `prefers-reduced-motion: reduce` — under reduce the seal appears INSTANTLY
+     * fully-drawn (no stroke animation, no glint sweep). Default true. (Never forced
+     * false — the PRM-safe-by-construction fence.)
+     */
+    respectReducedMotion?: boolean;
+}
+export interface UseCompletionSeal {
+    /** The reactive `data-play` seam — bind it to `:data-play` on `.completion-seal`. */
+    playing: Readonly<Ref<boolean>>;
+    /** True once the seal has drawn (or snapped under PRM) — the static held state. */
+    drawn: Readonly<Ref<boolean>>;
+    /**
+     * Whether the motion is suppressed (PRM) — the SFC snaps `--seal-draw: 100%` and
+     * omits the `data-play` arm so the recipe's no-preference gate never fires.
+     */
+    reduced: Readonly<Ref<boolean>>;
+    /** Imperatively (re-)fire the one-shot draw (a second completion event). */
+    draw: () => void;
+}
+/**
+ * The one-shot completion-seal draw. Arms `playing` (the `data-play` seam) for the
+ * single draw pass, then settles to the static `drawn` state. Under reduced motion it
+ * never arms — `reduced` is true and the seal is the instant fully-drawn mark.
+ *
+ * Deterministic + SSR-safe (the matchMedia guard) — the recipe owns the paint, this
+ * leaf owns the boolean lifecycle.
+ */
+export declare function useCompletionSeal(options?: UseCompletionSealOptions): UseCompletionSeal;

package/dist/components/custom/completion-seal/constants.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The seal glyph axis — the mark the gold stroke draws:
+ *  - `check` (default) — a checkmark (the canonical "done" garnish).
+ *  - `ring`  — a ring/circle around the completion (a seal around the event).
+ *  - `wordmark` — a self-contained seal mark (a stylized seal glyph).
+ *
+ * All three share the ONE gold-draw mechanism (the `--seal-draw` stroke-reveal on the
+ * `--seal-ink` gold stroke) — a `shape`-scoped path, NOT a second recipe. The seal is
+ * the GOLD-DRAW completion register, distinct from the HandMark hand-voice family.
+ */
+export type CompletionSealShape = "check" | "ring" | "wordmark";
+/** The default seal glyph — the checkmark "done" garnish. */
+export declare const COMPLETION_SEAL_DEFAULT_SHAPE: CompletionSealShape;
+/**
+ * The normalized SVG viewBox the glyphs are authored in. The mark `pathLength="100"`
+ * normalizes every glyph's draw length so the `stroke-dashoffset` wipe is path-agnostic
+ * (the recipe reads `--seal-draw` 0..100% against the normalized length).
+ */
+export declare const COMPLETION_SEAL_VIEWBOX = "0 0 64 64";
+/**
+ * The per-shape SVG path/element the gold stroke draws. `check`/`wordmark` are <path>
+ * `d`-strings; `ring` is drawn as a <circle> (the SFC branches on shape). Authored in
+ * the 64×64 viewBox, `pathLength="100"` normalized at the element.
+ */
+export declare const COMPLETION_SEAL_PATHS: Record<Exclude<CompletionSealShape, "ring">, string>;
+/**
+ * The `ring` glyph geometry (a <circle>) — the centre + radius in the 64×64 viewBox.
+ * A near-perimeter ring so the seal reads hero-scale.
+ */
+export declare const COMPLETION_SEAL_RING: {
+    readonly cx: 32;
+    readonly cy: 32;
+    readonly r: 24;
+};
+/**
+ * The SPRING register the draw rides (SPRING-EASE / W-MOTION-CANON P2 enter-bouncy):
+ *  - the SETTLE leg (the spatial overshoot) rides `--spring-bouncy` (an ENTER may
+ *    overshoot on arrival);
+ *  - the DRAW + GLINT legs ride the `--spring-snappy` CLOCK (the snappy settle duration)
+ *    so the gold inks crisply, not languidly.
+ * The seal mints NO new spring token — it READS the SPRING-EASE register (the no-new-clock
+ * fence). These names are the recorded register choice; the actual curves live in the
+ * cascade (tokens/scheme-motion.css) and the recipe (completion-seal.css) reads them.
+ */
+export declare const COMPLETION_SEAL_SETTLE_SPRING = "--spring-bouncy";
+export declare const COMPLETION_SEAL_DRAW_SPRING = "--spring-snappy";