@mkbabb/glass-ui 0.3.0 → 2.0.0

package/dist/components/custom/animated-digit/index.d.ts

@@ -0,0 +1,2 @@
+export { default as AnimatedDigit } from "./AnimatedDigit.vue";
+export type { AnimatedDigitMode, AnimatedDigitProps } from "./AnimatedDigit.vue";

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

@@ -0,0 +1,95 @@
+import type { AuroraRuntimeOptions } from "./composables/runtime";
+import { type AuroraConfig } from "./presets";
+import { type AuroraRenderMode } from "./renderMode";
+/**
+ * Aurora — a painterly WebGL2 background.
+ *
+ * Renders into a single canvas sized to its container via ResizeObserver.
+ * Config is reactive; the composable watches it deeply and re-uploads
+ * uniforms on change. Cursor interaction is deliberately not wired here —
+ * use `useCursorInteraction` (or call the exposed `setCursor` API) against
+ * the container element so the consumer controls pointer policy.
+ *
+ * Lazy-arm (HA4 §1): by default the expensive WebGL init (shader compile +
+ * GPU link) is deferred past the consumer's first paint. Until the runtime
+ * arms, a cheap CSS-gradient placeholder derived from `config.palette` paints
+ * the first frame with zero JS / zero GPU; the canvas cross-fades in over it
+ * once armed. The placeholder stays mounted underneath as the natural
+ * WebGL2-unavailable visual fallback (HA4 §1.5). Capture / thumbnail-baking
+ * consumers pass `runtimeOptions.initStrategy: "eager"` (or `mode: "capture"`)
+ * to arm synchronously.
+ *
+ * Init failures (WebGL2 unavailable, shader compile/link failure) are
+ * library-internal contract violations and surface by default (O invariant
+ * 24): synchronously on the eager path, on the microtask queue on the
+ * deferred path. Pass `onInitError` to handle the error and leave the canvas
+ * unmounted instead — the canonical opt-in path back to silent fallback.
+ *
+ * `opacityCeiling` (A3 §6.R-9, G-AK-D11) is the outer compositing envelope:
+ * `1.0` (default) for hero surfaces, `~0.5` for quiet content-over-aurora
+ * routes where form/text density would otherwise compete with the drift.
+ * It applies uniformly to the placeholder and the canvas so the cross-fade
+ * rides under the clamped ceiling and the shader's per-pixel `alpha`
+ * remains an orthogonal authoring concern.
+ */
+type __VLS_Props = {
+    /**
+     * Aurora field configuration (palette, nuclei, warp, media). Optional —
+     * omit it and the canonical `DEFAULT_AURORA_CONFIG` painterly look
+     * renders (gap 11, AM.W1). Pass a full config to author a custom field,
+     * or a preset object from `./presets`. The default is supplied via a
+     * `withDefaults` factory so each mount gets its own (un-shared) object.
+     */
+    config?: AuroraConfig;
+    runtimeOptions?: AuroraRuntimeOptions;
+    onInitError?: (err: Error) => void;
+    /**
+     * Adaptive render substrate (AM.W1; `aurora-lazy-init §3.1`). Aurora is
+     * NEVER retired — the warm wash always composites; only the substrate
+     * adapts:
+     *   - `"webgl"` — arm the WebGL path (still deferred to idle past first
+     *     paint via the `initStrategy:"deferred"` default).
+     *   - `"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).
+     */
+    renderMode?: AuroraRenderMode;
+    /**
+     * Per-route aurora saturation clamp (A3 §6.R-9 / G-AK-D11).
+     *
+     * The shader's `alpha` config field is per-pixel pigment opacity inside
+     * the painted image. `opacityCeiling` is the *outer envelope* — the
+     * maximum compositing opacity the aurora surface (placeholder +
+     * canvas) is allowed to reach against page content. It applies
+     * uniformly to both layers via the `--aurora-opacity-ceiling` custom
+     * property so the cross-fade preserves the clamped ceiling.
+     *
+     * Defaults to `1.0` (the dial route — full brand register). Quiet
+     * content-over-aurora routes (survey, thankyou, admin-login) opt in
+     * to `0.5` so the drift recedes behind form/text density. Clamped to
+     * `[0, 1]` defensively.
+     */
+    opacityCeiling?: number;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
+    config: AuroraConfig;
+    canvasRef: import("vue").Ref<HTMLCanvasElement | null, HTMLCanvasElement | null>;
+    setCursor: (x: number, y: number, strength?: number) => void;
+    clearCursor: () => void;
+    setCursorRadius: (r: number) => void;
+    renderAt: (t: number) => void;
+    pause: () => void;
+    resume: () => void;
+    isArmed: Readonly<import("vue").Ref<boolean, boolean>>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    config: AuroraConfig;
+    renderMode: AuroraRenderMode;
+    opacityCeiling: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,39 @@
+import type { OklchStop } from "../presets";
+export declare function clamp(v: number, min: number, max: number): number;
+export declare function srgbToOKLab(r: number, g: number, b: number): [number, number, number];
+export declare function oklabToOklch(L: number, a: number, b: number): [number, number, number];
+export declare function oklchToOklab(L: number, C: number, H: number): [number, number, number];
+export declare function oklabToRgb255(L: number, a: number, b: number): [number, number, number];
+export declare function rgbToOklch(r: number, g: number, b: number): [number, number, number];
+export declare function oklchToRgb(L: number, C: number, H: number): [number, number, number];
+/**
+ * OKLCh stop to linear-sRGB in [0, 1] — bundle-canonical bake target.
+ * The shader ACES-tonemaps in linear, so the LUT must stay linear.
+ */
+export declare function oklchToLinear(stop: OklchStop): [number, number, number];
+/**
+ * Pack up to `maxStops` OklchStops into linear-sRGB triples. When `out` is
+ * provided the buffer is filled in place (no allocation) — the runtime owns a
+ * single buffer reused on every config update so a slider drag does not churn
+ * the GC. Unused slots are zero-filled; the shader clamps via `uStopCount`.
+ */
+export declare function flattenPalette(stops: OklchStop[], maxStops?: number, out?: Float32Array): Float32Array;
+/**
+ * Derive a cheap CSS `linear-gradient` from an Aurora palette — the static
+ * first-frame placeholder painted under the WebGL canvas while the runtime
+ * arms (see `useAurora`'s deferred init / Aurora.vue's placeholder element).
+ *
+ * The shader interpolates the same OKLCh stops in linear sRGB; here we render
+ * each stop as a gamma-sRGB hex so the browser's gradient compositor produces
+ * a visually-adjacent approximation with zero JS and zero GPU on first paint.
+ * A diagonal axis (135deg) reads as atmospheric depth rather than a flat band.
+ *
+ * Single-stop palettes degrade to a flat fill; an empty palette yields
+ * `transparent` so the placeholder is simply invisible (the canvas still
+ * fades in over it once armed).
+ */
+export declare function paletteToCssGradient(stops: OklchStop[]): string;
+export declare function oklchStopToHex(s: OklchStop): string;
+export declare function hexToOklchStop(hex: string): OklchStop;
+export declare function cssToRgb(css: string): [number, number, number];
+export declare function cssToOklch(css: string): OklchStop;

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

@@ -0,0 +1,10 @@
+import type { Ref } from "vue";
+/**
+ * A reactive config can be authored as a plain object, a `Ref`, or a getter.
+ * `useAurora` and `useCursorInteraction` both accept this shape so consumers
+ * can pass either a static config (single-config use) or a getter that
+ * dereferences a parent ref every call (preset-switch scenarios where the
+ * config object identity changes underneath the composable).
+ */
+export type ConfigSource<T> = T | Ref<T> | (() => T);
+export declare function asGetter<T>(src: ConfigSource<T>): () => T;

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

@@ -0,0 +1,54 @@
+/**
+ * Aurora v4.1 runtime — port of bundle `runtime.js` to TypeScript.
+ *
+ * Compiles the shader, owns the WebGL2 context and RAF loop, translates a
+ * reactive `AuroraConfig` into uniforms, and exposes an imperative cursor API
+ * plus a side-effect-safe `renderAt(t)` method for capture baking.
+ *
+ * Y-origin convention: config authoring is CSS-top-origin (0 = top). The
+ * runtime flips Y at the uniform boundary (see AUTHOR_Y_ORIGIN_IS_TOP marks).
+ */
+import { type AuroraConfig, type AuroraInstance } from "../presets";
+export type AuroraRuntimeMode = "live" | "capture";
+/**
+ * When the expensive WebGL path (context creation, shader compile + GPU link,
+ * first uniform upload, rAF arm) actually runs.
+ *
+ * - `"deferred"` (default) — `createAurora` constructs a cheap, un-armed
+ *   instance and returns immediately; the GL work is invoked later via
+ *   `instance.arm()`. The Vue wrapper `useAurora` schedules `arm()` past first
+ *   paint on an idle tick, gated on canvas visibility — so the shader
+ *   compile-link never lands on the consumer's first-paint critical path.
+ * - `"eager"` — `createAurora` arms synchronously before returning, exactly
+ *   as a pre-lazy-arm runtime did. Capture / thumbnail-baking consumers need
+ *   this: `renderAt` must draw a real frame the instant `createAurora`
+ *   returns. `mode: "capture"` forces eager regardless of this field.
+ */
+export type AuroraInitStrategy = "eager" | "deferred";
+export interface AuroraRuntimeOptions {
+    mode?: AuroraRuntimeMode;
+    preserveDrawingBuffer?: boolean;
+    /**
+     * When to run the expensive WebGL init. Defaults to `"deferred"`.
+     * `mode: "capture"` forces `"eager"` (a capture runtime must be able to
+     * `renderAt` synchronously). See {@link AuroraInitStrategy}.
+     */
+    initStrategy?: AuroraInitStrategy;
+    /**
+     * Init-failure handler. A WebGL2/shader-compile/link failure is a
+     * library-internal contract violation (O invariant 24). On the EAGER path
+     * `createAurora` throws synchronously and `useAurora` rethrows by default
+     * so the signal reaches the consumer's error boundary / dev console. On
+     * the DEFERRED path the failure happens on an idle tick — outside any
+     * mount-time boundary — so the runtime routes it here, and `useAurora`
+     * re-surfaces it on the microtask queue (so it still reaches the dev
+     * console / `app.config.errorHandler`) when no handler is supplied.
+     * Provide this callback to opt into silent handling on either path.
+     *
+     * 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()`.
+     */
+    onInitError?: (err: Error) => void;
+}
+export declare function createAurora(canvas: HTMLCanvasElement, initial: AuroraConfig, options?: AuroraRuntimeOptions): AuroraInstance;

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

@@ -0,0 +1,67 @@
+import { type Ref } from "vue";
+import { type AuroraRuntimeOptions } from "./runtime";
+import { type ConfigSource } from "./configSource";
+import type { AuroraConfig } from "../presets";
+/**
+ * Adaptive-substrate options threaded down from `Aurora.vue` (AM.W1). The
+ * render mode is the RESOLVED concrete substrate (`"auto"` already collapsed
+ * to `"webgl"`/`"css"` at the component boundary via `resolveRenderMode`).
+ */
+export interface UseAuroraAdaptiveOptions {
+    /**
+     * Resolved render substrate. `"css"` short-circuits the WebGL arm schedule
+     * entirely — no webgl2 context is ever created; the `Aurora.vue`
+     * placeholder stays the permanent surface. `"webgl"` (default) arms the
+     * deferred WebGL path as before.
+     */
+    renderMode?: "webgl" | "css";
+}
+/**
+ * Public return shape of {@link useAurora}.
+ *
+ * O.W4 Lane B — Fix 2 (Rγ L2): authored to replace the previous anonymous
+ * inline-typed literal. Parallels sibling composable return interfaces
+ * (`ConfiguratorState<T>`, `SidebarState`, `UseSortableReturn`); consumers
+ * can now annotate variables holding `useAurora` results without reaching
+ * for `ReturnType<typeof useAurora>`.
+ *
+ * NOT a /api discovery-surface candidate (per /api preamble: composable
+ * option/return types change with implementation). Exposed only via the
+ * `@mkbabb/glass-ui/aurora` package barrel.
+ */
+export interface UseAuroraReturn {
+    setCursor: (x: number, y: number, strength?: number) => void;
+    clearCursor: () => void;
+    setCursorRadius: (r: number) => void;
+    renderAt: (t: number) => void;
+    pause: () => void;
+    resume: () => void;
+    /**
+     * `true` once the WebGL runtime has armed (shader compiled + linked, first
+     * frame drawable). `Aurora.vue` watches this to cross-fade the canvas in
+     * over the static CSS-gradient placeholder. Eager / capture consumers see
+     * it flip `true` synchronously within `onMounted`; deferred consumers see
+     * it flip on the post-first-paint idle tick.
+     */
+    isArmed: Readonly<Ref<boolean>>;
+}
+/**
+ * Vue-side wrapper for the imperative `createAurora` runtime.
+ *
+ * Accepts the config as a plain object, a ref, or a getter. Internally we
+ * watch it deeply with `{ deep: true }` so both:
+ *   (a) parent swaps the reference (e.g. preset switch), and
+ *   (b) parent mutates the reactive object (slider drag),
+ * trigger a uniform re-upload. Passing a raw object works for single-config
+ * use; passing a getter or ref works for preset-switch scenarios.
+ *
+ * Lazy-arm: by default (`initStrategy: "deferred"`) `createAurora` constructs
+ * a cheap, un-armed instance and the expensive WebGL init (shader compile +
+ * GPU link — the dominant synchronous cost) is deferred past first paint via
+ * `requestIdleCallback`, gated on the canvas's first viewport intersection
+ * (composing `useIntersectionPause`). `Aurora.vue` paints a CSS-gradient
+ * placeholder under the canvas so the consumer's first paint is never blocked
+ * on the shader. Capture / `initStrategy: "eager"` consumers arm synchronously
+ * inside `createAurora` and skip the defer entirely.
+ */
+export declare function useAurora(canvasRef: Ref<HTMLCanvasElement | null>, configSource: ConfigSource<AuroraConfig>, runtimeOptions?: AuroraRuntimeOptions, adaptiveOptions?: UseAuroraAdaptiveOptions): UseAuroraReturn;

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

@@ -0,0 +1,25 @@
+import { type Ref } from "vue";
+import { type ConfigSource } from "./configSource";
+import type { AuroraConfig } from "../presets";
+export interface CursorInteractionOptions {
+    /** Fires `setCursor(x,y,strength)` for continuous swirl. */
+    setCursor: (x: number, y: number, strength?: number) => void;
+    clearCursor: () => void;
+    /**
+     * Nucleus-ring hit fraction: a nucleus is "hit" when distance ≤ radius × this.
+     * 0.35 matches the overlay's default ring thickness.
+     */
+    hitFraction?: number;
+}
+/**
+ * Wires pointer events on the stage element to (a) continuous cursor swirl,
+ * and (b) CRUD on `getCfg().nuclei` — spawn (alt-click), remove (shift-click /
+ * right-click), drag, delete key.
+ *
+ * Accepts the config as a plain object, ref, or getter; every pointer event
+ * re-resolves the current config, so CRUD always targets the active preset
+ * even after a preset switch swaps the underlying config reference.
+ */
+export declare function useCursorInteraction(stageRef: Ref<HTMLElement | null>, configSource: ConfigSource<AuroraConfig>, options: CursorInteractionOptions): {
+    isDragging: () => number | null;
+};

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

@@ -0,0 +1,9 @@
+export { default as Aurora } from "./Aurora.vue";
+export { resolveRenderMode, type AuroraRenderMode } from "./renderMode";
+export { useAurora } from "./composables/useAurora";
+export type { UseAuroraReturn } from "./composables/useAurora";
+export { useCursorInteraction } from "./composables/useCursorInteraction";
+export { createAurora } from "./composables/runtime";
+export type { AuroraRuntimeMode, AuroraRuntimeOptions } from "./composables/runtime";
+export { DEFAULT_AURORA_CONFIG, MAX_NUCLEI, MAX_STOPS, type AuroraConfig, type AuroraCursorApi, type AuroraFlow, type AuroraInstance, type AuroraMedium, type AuroraNucleus, type FlowPattern, type OklchStop, type StrokeMode, type WarpMode, } from "./presets";
+export { cssToOklch, flattenPalette, hexToOklchStop, oklchStopToHex, oklchToLinear, paletteToCssGradient, } from "./composables/color";

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

@@ -0,0 +1,121 @@
+/**
+ * Aurora v4.1 — library config shape.
+ *
+ * Authored presets (Sky, Dawn, Meadow, Deliberative, Day9, Oil Impasto,
+ * Oil Gestural, Oil Van Gogh, Crayon Sunset, Crayon Rainbow, Crayon Ocean)
+ * live in the consumer — see demo/stories/aurora/presets.ts.
+ *
+ * Per memory rule "Presets in consumers": named themed presets belong in
+ * each consumer project, not in the library. The library exports only the
+ * shape + a minimum-viable DEFAULT_AURORA_CONFIG for the component's own
+ * type-check ergonomics.
+ */
+export interface OklchStop {
+    L: number;
+    C: number;
+    h: number;
+}
+export interface AuroraNucleus {
+    /** 0..1 in CSS-top-origin space (0 = top, 1 = bottom). Runtime flips Y. */
+    x: number;
+    y: number;
+    /** Radius of Gaussian falloff, in normalized canvas units. 0.15..0.8. */
+    radius: number;
+    /** 0..1 — which palette stop this nucleus pulls toward. */
+    paletteBias: number;
+    /** -0.3..0.3 — lightness pull within the nucleus's zone of influence. */
+    valueBias: number;
+    /** 0..0.03 — orbit amplitude for slow drift. */
+    driftRadius: number;
+    /** 0..2π — phase seed. */
+    driftPhase: number;
+    /**
+     * Major:minor axis ratio. 1.0 = isotropic (default). Range [1, 3]. The
+     * nucleus's Gaussian becomes an ellipse stretched along `angle`.
+     */
+    elongation?: number;
+    /**
+     * Major-axis orientation in degrees, CSS-top-origin (matches y-flip).
+     * Default 0 (horizontal). Range [-180, 180]. Runtime converts to radians.
+     */
+    angle?: number;
+}
+export type AuroraMedium = "smooth" | "pastel" | "watercolor" | "oil";
+/** Applied only when `medium === "oil"`. Routes inside the shader. */
+export type StrokeMode = "oil" | "knife" | "crayon" | "chunky";
+export type FlowPattern = "none" | "radial" | "swirl" | "diagonal" | "multi";
+export type WarpMode = "fbm" | "cellular" | "hybrid";
+export interface AuroraFlow {
+    pattern: FlowPattern;
+    /** 0..1 CSS-top-origin. Runtime flips Y. */
+    focalX: number;
+    focalY: number;
+    /** Degrees. Only used for "diagonal". */
+    angle: number;
+    /** 0..1 curl intensity (attenuated per-pattern inside the shader). */
+    curl: number;
+}
+export interface AuroraConfig {
+    palette: OklchStop[];
+    nuclei: AuroraNucleus[];
+    softmaxBeta: number;
+    valueVariance: number;
+    warpAmount: number;
+    warpScale: number;
+    warpDrift: number;
+    warpMode: WarpMode;
+    noiseOctaves: 3 | 4 | 5;
+    medium: AuroraMedium;
+    flow: AuroraFlow;
+    strokeAmount: number;
+    strokeScale: number;
+    strokeAnisotropy: number;
+    strokeLayers: 1 | 2;
+    strokeMode: StrokeMode;
+    wetEdge: number;
+    granulation: number;
+    impasto: number;
+    brokenColor: number;
+    canvasGrain: number;
+    nucleiDrift: number;
+    paletteDrift: number;
+    breathDepth: number;
+    breathPeriod: number;
+    saturation: number;
+    paperGrain: number;
+    alpha: number;
+}
+/**
+ * Pointer-cursor API exposed by `createAurora`. Values in 0..1 (CSS-top-origin).
+ * Runtime flips Y and eases internally.
+ */
+export interface AuroraCursorApi {
+    setCursor(x: number, y: number, strength?: number): void;
+    clearCursor(): void;
+    setCursorRadius(r: number): void;
+}
+export interface AuroraInstance extends AuroraCursorApi {
+    /**
+     * Run the expensive WebGL init — context creation, shader compile + GPU
+     * link, first uniform upload, rAF arm. Idempotent. On the `"eager"` /
+     * capture `initStrategy` `createAurora` already calls this before
+     * returning; on `"deferred"` the consumer (e.g. `useAurora`) invokes it
+     * past first paint. Throws on WebGL2/compile/link failure (O invariant
+     * 24). A no-op once armed or once `dispose()` has run.
+     */
+    arm(): void;
+    update(cfg: AuroraConfig): void;
+    /** Render a single deterministic frame at time `t` (seconds). Used for thumbnail bakes. */
+    renderAt(timeSec: number): void;
+    pause(): void;
+    resume(): void;
+    setReducedMotion(flag: boolean): void;
+    dispose(): void;
+}
+export declare const MAX_NUCLEI = 6;
+export declare const MAX_STOPS = 8;
+/**
+ * A neutral starting point for consumers that build their own config from scratch.
+ * Not a themed preset — the demo's 11 authored presets override every field.
+ */
+export declare const DEFAULT_AURORA_CONFIG: AuroraConfig;

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

@@ -0,0 +1,30 @@
+/**
+ * Aurora adaptive render substrate (AM.W1; `aurora-lazy-init §3.1`).
+ *
+ * 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.
+ */
+export type AuroraRenderMode = "webgl" | "css" | "auto";
+/**
+ * Resolve `"auto"` to a concrete substrate per device tier. `"webgl"` and
+ * `"css"` pass through unchanged.
+ *
+ * `"auto"` resolves to `"css"` when ANY low-power signal is present:
+ *   - `navigator.hardwareConcurrency <= 4` (few logical cores),
+ *   - `prefers-reduced-motion: reduce`,
+ *   - `navigator.connection.saveData === true` (Data Saver on).
+ * Otherwise `"webgl"`.
+ *
+ * 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";

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

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

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

@@ -0,0 +1 @@
+export declare const VERTEX_SRC = "#version 300 es\nin vec2 aPos;\nout vec2 vUv;\nvoid main() {\n  vUv = aPos * 0.5 + 0.5;\n  gl_Position = vec4(aPos, 0.0, 1.0);\n}";

package/dist/components/custom/configurator/Configurator.vue.d.ts

@@ -0,0 +1,102 @@
+import { type HTMLAttributes } from "vue";
+import { type ConfiguratorDensity } from "./density";
+/**
+ * Scroll behavior for the controls column.
+ *
+ * - `auto`   — overflow-y-auto with `.scroll-fade-y` mask; controls scroll
+ *              when their intrinsic height exceeds the host. Default.
+ * - `always` — controls always render scroll affordance (mask + thin
+ *              scrollbar). Use when authors want a fixed-height studio
+ *              regardless of content.
+ * - `never`  — controls do not scroll; host grows to content height. Use
+ *              for popover/sheet hosts that already manage their own
+ *              overflow.
+ */
+export type ConfiguratorScrollMode = "auto" | "always" | "never";
+/**
+ * Generic preset descriptor. Consumers pass `T` as the live config shape.
+ * The primitive carries no preset semantics beyond `key + label` for
+ * the picker row and `config: T` for the active payload — preset
+ * selection / diff-from-preset / reset semantics live in the optional
+ * `useConfiguratorState<T>` composable.
+ */
+export interface ConfiguratorPreset<T> {
+    readonly key: string;
+    readonly label: string;
+    readonly sub?: string;
+    /** Optional baked thumbnail (data URL or static path). */
+    readonly thumb?: string;
+    readonly config: T;
+}
+declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
+        /** Optional preset table; presented to the `presets` slot fallback. */
+        presets?: readonly ConfiguratorPreset<T>[];
+        /** Currently active preset key — display only; selection is the consumer's. */
+        activePreset?: string;
+        /** Optional layer descriptors; presented to `controls` slot fallback. */
+        layers?: readonly {
+            id: string;
+            label: string;
+        }[];
+        /** Active layer id — display only; switching is the consumer's. */
+        activeLayer?: string;
+        /** Scroll behavior for the controls column. Default: `auto`. */
+        scrollMode?: ConfiguratorScrollMode;
+        /**
+         * Row-level density axis (N.W2 Lane A). Cascades to descendant
+         * `<ConfiguratorRow>` children via provide/inject. A row may
+         * override locally by setting its own `density` prop (prop wins
+         * over inject). Default `"comfortable"` preserves the prior
+         * `gap-1.5 py-2` recipe exactly.
+         */
+        density?: ConfiguratorDensity;
+        /** Optional outer container override. */
+        class?: HTMLAttributes["class"];
+    } & {
+        onReset?: (() => any) | undefined;
+        "onSelect-preset"?: ((key: string) => any) | undefined;
+        "onSelect-layer"?: ((id: string) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        stage?: (props: {}) => any;
+    } & {
+        presets?: (props: {
+            presets: readonly ConfiguratorPreset<T>[] | undefined;
+            activePreset: string | undefined;
+        }) => any;
+    } & {
+        controls?: (props: {
+            layers: readonly {
+                id: string;
+                label: string;
+            }[] | undefined;
+            activeLayer: string | undefined;
+            selectLayer: (id: string) => void;
+        }) => any;
+    } & {
+        default?: (props: {}) => any;
+    } & {
+        footer?: (props: {
+            reset: () => void;
+        }) => any;
+    };
+    emit: {
+        (e: "select-preset", key: string): void;
+        (e: "select-layer", id: string): void;
+        (e: "reset"): void;
+    };
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};