@mkbabb/glass-ui 4.2.0 → 6.0.0

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

@@ -1,100 +0,0 @@
-/**
- * Aurora uniform bridge — the reactive-config → GL-uniform translation seam.
- *
- * Owns the sealed enum↔shader-int dispatch maps and the per-config uniform upload.
- * Each map is `as const` constrained by a `satisfies Record<Union, number>` so a
- * NEW union member is a COMPILE error until it gets a slot — no silent stale-Record
- * gap where a fresh enum value uploads `undefined`.
- *
- * Crayon is a FIRST-CLASS medium (`uMedium == 4`, AX.W13), NOT a stroke mode: the
- * shader has a dedicated `mediumCrayon()` body (DRY wax-on-tooth). `MEDIUM_ID` carries
- * the `crayon: 4` slot and `StrokeMode` no longer has a `crayon` member — the legacy
- * `oil` + `strokeMode:"crayon"` peer-route is REMOVED (clean break); a crayon surface
- * selects `medium:"crayon"`.
- *
- * The pre-allocated upload buffers live in the bridge: a slider drag refills them
- * in place rather than allocating ~8 Float32Arrays per frame.
- */
-import type { OklchStop } from "../../../../composables/color";
-import type { UniformLocations } from "./glSetup";
-import type { CursorState } from "./cursorModel";
-import { type AuroraConfig } from "../constants/presets";
-export declare const MEDIUM_ID: {
-    readonly smooth: 0;
-    readonly pastel: 1;
-    readonly watercolor: 2;
-    readonly oil: 3;
-    readonly crayon: 4;
-    readonly vangogh: 5;
-    readonly "oil-pastel": 6;
-    readonly kuwahara: 7;
-};
-export declare const HUE_PATH_ID: {
-    readonly shorter: 0;
-    readonly longer: 1;
-    readonly increasing: 2;
-    readonly decreasing: 3;
-};
-export declare const FLOW_ID: {
-    readonly none: 0;
-    readonly radial: 1;
-    readonly swirl: 2;
-    readonly diagonal: 3;
-    readonly multi: 4;
-    readonly tensor: 5;
-};
-export declare const STROKE_ORIENT_ID: {
-    readonly flow: 0;
-    readonly tensor: 1;
-};
-export declare const WARP_ID: {
-    readonly fbm: 0;
-    readonly cellular: 1;
-    readonly hybrid: 2;
-    readonly curl: 3;
-};
-export declare const STROKE_MODE_ID: {
-    readonly oil: 0;
-    readonly knife: 1;
-    readonly chunky: 3;
-};
-export declare const AURORA_CATCH_LIGHT_ANCHOR: OklchStop;
-/**
- * Resolve a config's `lightColor` to a LINEAR-light `[r,g,b]` triple. Accepts either
- * a raw linear triple (the array form, passed through) OR an `{L,C,h}` OKLCh anchor
- * (derived through the shared `warmCatchLight` helper). Omitted = the canonical aurora
- * warm-white from `AURORA_CATCH_LIGHT_ANCHOR`.
- */
-export declare function resolveLightColor(lightColor: [number, number, number] | OklchStop | undefined): [number, number, number];
-/**
- * The effective `uMedium` int for a config. AX.W13 — a pure identity map over the
- * medium union (the `oil` + `strokeMode:"crayon"` peer-route is REMOVED; crayon is its
- * own first-class `medium:"crayon"`). `medium` is total over `MEDIUM_ID` (the
- * `satisfies` guarantees it), so this never resolves `undefined`.
- */
-export declare function resolveMediumId(cfg: AuroraConfig): number;
-/**
- * The `uStrokeMode` int for a config. AX.W13 — `strokeMode` is total over
- * `STROKE_MODE_ID` (no `crayon` special-case), so this is a direct map.
- */
-export declare function resolveStrokeModeId(cfg: AuroraConfig): number;
-/**
- * AX.W13 — the `uStrokeOrient` int for a config. The painterly mediums (`vangogh`,
- * `oil-pastel`, `crayon`) FORCE the structure-tensor orientation regardless of the
- * config's `strokeOrient` field — their marks must hug the color zones (the
- * congruent-to-real-works contract). Every other medium honors the config's
- * `strokeOrient` (default `"flow"`). BB.W-AUR-KUWAHARA — `kuwahara` ALSO forces
- * tensor: the anisotropic Kuwahara kernel is squeezed along the structure-tensor
- * minor eigenvector, so the orientation source must be the tensor field.
- */
-export declare function resolveStrokeOrientId(cfg: AuroraConfig): number;
-/**
- * Build the per-config uniform uploader bound to a program's uniform location
- * cache + cursor state. Returns `uploadConfig` — call it to push a fresh
- * `AuroraConfig` into the live program. The cursor uniforms are initialised here
- * and re-sent per frame by the frame loop.
- *
- * Y-origin: config authoring is CSS-top-origin (0 = top); the bridge flips Y at
- * the uniform boundary (`flipY`).
- */
-export declare function createUniformBridge(gl: WebGL2RenderingContext, prog: WebGLProgram, U: UniformLocations, cursor: CursorState): (cfg: AuroraConfig) => void;

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

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

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

@@ -1,86 +0,0 @@
-import { type Ref } from "vue";
-import { type AuroraRuntimeOptions } from "./runtime";
-import { type ConfigSource } from "./configSource";
-import type { AuroraConfig } from "../constants/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;
-    /**
-     * AW.W8.1 — feed a pointer delta into the velocity-reactive flow (a fast flick →
-     * a transient swirl-burst). PRM-gated at the runtime (the cursor write-path
-     * early-out). The aurora demo wires this from its stage pointermove listener.
-     */
-    injectCursorVelocity: (dx: number, dy: 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.
- *
- * Init-failure contract (O invariant 24 — "fails explicitly by default"). A
- * WebGL2/shader-compile/link failure is a library-internal contract violation.
- * On the DEFERRED path the failure lands on an idle tick, OUTSIDE any
- * mount-time error boundary, so the consumer MUST handle it through exactly one
- * of three paths:
- *   1. pass an `onInitError(err)` handler in `runtimeOptions` (the explicit
- *      opt-in — receives the error directly), OR
- *   2. install a Vue global `app.config.errorHandler` (the re-surfaced
- *      microtask rejection reaches it), OR
- *   3. knowingly accept the unhandled rejection (the dev console still gets it).
- * Armed deferred with NO `onInitError`, `useAurora` dev-warns ONCE so the
- * silent-by-omission case is visible. WebGL2-unavailable still throws HARD.
- */
-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

@@ -1,33 +0,0 @@
-import { type Ref } from "vue";
-import { type ConfigSource } from "./configSource";
-import type { AuroraConfig } from "../constants/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;
-    /**
-     * AW.W8.1 — feed the per-move pointer delta into the velocity-reactive flow (a
-     * fast flick → a transient swirl-burst). The runtime's `injectCursorVelocity`
-     * EARLY-OUTS on reduced-motion (the cursor write-path PRM check), so a parked
-     * loop with a live pointermove does NOT move the field under reduce. Optional —
-     * absent keeps the position-only steady swirl.
-     */
-    injectVelocity?: (dx: number, dy: number) => void;
-}
-/**
- * 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/composables/wgpuSetup.d.ts

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

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

@@ -1,258 +0,0 @@
-/**
- * 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.
- */
-import type { OklchStop } from "../../../../composables/color";
-export type { OklchStop };
-import type { HueInterpolationMethod } from "@mkbabb/value.js";
-export type AuroraHuePath = HueInterpolationMethod;
-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.08 — orbit amplitude for slow drift (the visible-travel gate). */
-    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" | "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";
-/**
- * AW.W4.1 — how a stroke's orientation is sourced. `flow` keeps the hand-authored
- * `flowField` pattern + per-cell jitter (the named legacy choice); `tensor`
- * substitutes the structure-tensor minor-eigenvector (the color field's own
- * 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" | "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:
- * - `light`  — the cursor drives the impasto `uLightDir` (cursor-as-light + idle orbit).
- * - `flow`   — pointer/scroll VELOCITY injects a transient swirl-burst (velocity-reactive).
- * - `scroll` — palette/breath progress couples to scroll (via `useScrollProgress`).
- * - `wake`   — the WebGPU stateful pointer wake (a ping-pong velocity texture; AW.W8.2).
- * Every axis is suppressed under `prefers-reduced-motion` + the DockBackgroundToggle
- * pause (the master tempo scalar is the single suppression seam). The wispy-sky
- * default carries no `interactivity` (every axis OFF — the default stays static).
- */
-export interface AuroraInteractivity {
-    light?: boolean;
-    flow?: boolean;
-    scroll?: boolean;
-    wake?: boolean;
-}
-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;
-    /**
-     * W5 — the hue-arc method for the OKLCh palette interpolation. Optional;
-     * omitted = `"shorter"` (the OKLab-rectangular ramp — the muddy-midtone-free
-     * default). `"increasing"`/`"decreasing"` request the OKLCh hue-arc for a
-     * deliberate rainbow sweep across the stops. Aliased on `/api` as `AuroraHuePath`.
-     */
-    huePath?: AuroraHuePath;
-    flow: AuroraFlow;
-    /**
-     * AW.W4.1 — how the painterly stroke direction is sourced. Optional; omitted =
-     * `"flow"` (the hand-authored `flowField` pattern — the pre-W4 path, so an
-     * unset config renders identically). `"tensor"` substitutes the structure-tensor
-     * minor eigenvector (the color field's own edge-tangent flow); the `vangogh` /
-     * `oil-pastel` mediums force it.
-     */
-    strokeOrient?: StrokeOrient;
-    strokeAmount: number;
-    strokeScale: number;
-    strokeAnisotropy: number;
-    strokeLayers: 1 | 2;
-    strokeMode: StrokeMode;
-    wetEdge: number;
-    granulation: number;
-    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
-     * (matching the prior fixed-rim default, so the still default reads identically).
-     * Unit-ish [x, y, z] in screen space (z toward the viewer). AW.W8 drives this
-     * from the cursor (cursor-as-light); the shader re-normalizes it.
-     */
-    lightDir?: [number, number, number];
-    /**
-     * AW.W4.2 / AX.W11 — the relight tint (the impasto catch-light). Optional;
-     * omitted = the canonical warm-white the shared `warmCatchLight` OKLCh helper
-     * derives (the `(0.985, 0.0125, 77.5°)` anchor — perceptually the prior eyeballed
-     * warm-white, now on the OKLCh core). Author it either as a raw LINEAR-light
-     * `[r,g,b]` triple OR as an `{L,C,h}` OKLCh anchor (the bridge derives the linear
-     * triple via `warmCatchLight`). The diffuse + Blinn-specular terms modulate by it.
-     */
-    lightColor?: [number, number, number] | OklchStop;
-    nucleiDrift: number;
-    paletteDrift: number;
-    breathDepth: number;
-    breathPeriod: number;
-    saturation: number;
-    paperGrain: number;
-    alpha: number;
-    /**
-     * BD.W-AUR-VIVIDNESS — the §3 chroma FLOOR (the warm-field vividness contract).
-     * Optional; omitted = `DEFAULT_VIVIDNESS` (1 — high, the library's vivid identity).
-     * A shader-resident OKLab chroma-floor lifts any pale zone toward `VIVID_TARGET`
-     * (mode-scaled in the shader) so the field never resolves toward gray BEHIND glass
-     * — the literal fix for the "missing colorful field → gray glass" defect. The lift
-     * is HUE-PRESERVING (scales chroma along the zone's existing OKLab direction); below
-     * `VIVID_EPS` the hue is precision noise, so the floor synthesizes along the WARM
-     * anchor (`VIVID_WARM_ANCHOR`) — NEVER teal/navy, the warm-floor guarantee. A
-     * deliberately-pale hero surface opts OUT with `vividness: 0` (the new lanes write 0,
-     * so a `vividness:0` config is byte-identical to the pre-floor render — the gated
-     * identity move). Range 0..1.
-     */
-    vividness?: number;
-    /**
-     * AW.W6/W8 — the pointer/scroll interactivity opt-in (default OFF — the wispy-sky
-     * default stays static). W6 declares the SHAPE; W8 wires the cursor-as-light /
-     * velocity-reactive flow / scroll-coupling / WebGPU-wake behavior. Omitted = every
-     * axis off. Aliased on `/api` as part of the `AuroraConfig` surface.
-     */
-    interactivity?: AuroraInteractivity;
-}
-/**
- * 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;
-    /**
-     * 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;
-    pause(): void;
-    resume(): void;
-    setReducedMotion(flag: boolean): void;
-    dispose(): void;
-}
-export declare const MAX_NUCLEI = 6;
-export declare const MAX_STOPS = 8;
-/**
- * The default `vividness` for a bare `<Aurora>` — HIGH (the library's vivid identity).
- * This INVERTS the pre-floor status quo: vivid is the default, pale is the explicit
- * `vividness: 0` opt-out. The literal §3 fix — a warm glass plate over the default field
- * now reads transmissive-not-gray because the field carries chroma.
- */
-export declare const DEFAULT_VIVIDNESS = 1;
-/**
- * The per-fragment OKLab chroma the floor lifts a pale zone TOWARD at `vividness:1`
- * (the shader scales this by a mode factor — a dim/dark field needs more chroma to read
- * vivid through glass). Tuned so the lifted DEFAULT field clears the §3 transmissive
- * floor (mean OKLab chroma ≥ 0.045) with headroom; a vivid zone above this is untouched.
- * Mirrored as `VIVID_TARGET` in the GLSL + WGSL twins.
- */
-export declare const VIVID_TARGET = 0.115;
-/**
- * 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;
-/**
- * `PAPER_WASH_GROUND` — the library-canon recessive-ground crayon calibration
- * (BA.W-ATLAS-RECONCILE A-4a; d6 9467bd16 adopt). A pure PRESET PARTIAL (no
- * palette/nuclei/motion) pinning the recessive crayon-ground deposition dials so a
- * data-ground aurora reads as paper-on-tooth without each consumer dial-tuning the
- * same recessive calibration by hand. It carries NO palette/nuclei — the consumer
- * spreads it over its own pole-derived pigment (page-glow IS data-glow):
- * `const cfg = { ...consumerBase, ...PAPER_WASH_GROUND }`.
- *
- * House-rule clean (presets-in-consumers): this is the LIBRARY's own recessive-ground
- * IDENTITY, not a consumer theme — admissible at the root. `satisfies
- * Partial<AuroraConfig>` holds (every key is a first-class `AuroraConfig` field at
- * HEAD; the `crayon` medium is `uMedium==4`).
- */
-export declare const PAPER_WASH_GROUND: {
-    readonly medium: "crayon";
-    readonly strokeOrient: "tensor";
-    readonly granulation: 0.3;
-    readonly canvasGrain: 0.5;
-    readonly strokeAmount: 0.35;
-    readonly strokeAnisotropy: 0.5;
-    readonly strokeLayers: 1;
-    readonly impasto: 0;
-    readonly brokenColor: 0;
-    readonly wetEdge: 0;
-    readonly saturation: 0.92;
-    readonly paperGrain: 0.008;
-};

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

@@ -1 +0,0 @@
-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";