@mkbabb/glass-ui 4.0.1 → 4.2.0

package/dist/components/custom/fourier-field/composables/uniformBridgeWGPU.d.ts

@@ -0,0 +1,56 @@
+import type { OklchStop } from "../../../../composables/color";
+import { type BasisComponent } from "../math";
+/** One phasor lane in the storage buffer: (re, im, index, _pad). */
+export declare const FOURIER_PHASOR_BYTES = 16;
+export declare const FOURIER_COMPUTE_UNIFORM_BYTES = 32;
+export interface FourierUniformScratch {
+    buffer: ArrayBuffer;
+    f32: Float32Array;
+    i32: Int32Array;
+}
+export declare function createFourierComputeScratch(): FourierUniformScratch;
+/** Pack the compute uniforms in place. */
+export declare function packFourierComputeUniforms(scratch: FourierUniformScratch, headT: number, trailArc: number, harmonicN: number, epicycleArmN: number, sampleCount: number, phasorCount: number): FourierUniformScratch;
+export declare const FOURIER_RENDER_UNIFORM_BYTES: number;
+export declare function createFourierRenderScratch(): FourierUniformScratch;
+/** The model→clip fit transform (center + uniform scale) — computed once per spectrum. */
+export interface FourierFit {
+    centerX: number;
+    centerY: number;
+    /** The uniform scale s such that (model − center)·s maps the curve into clip [-1,1] with margin. */
+    scale: number;
+}
+/**
+ * Stable view-fit: sample the FULL reconstruction once over the period, bound its bbox,
+ * and derive the center + a margin-padded uniform scale. The render's fullscreen pass
+ * inverts this transform per fragment so the curve never clips and the scale is fixed.
+ */
+export declare function computeFourierFit(spectrum: readonly BasisComponent[]): FourierFit;
+/**
+ * Map a MODEL-space head point to the stage's `[0,1]²` UV via the SAME fit + aspect the
+ * render's clip→model inverse uses (BD.W-FOURIER-LOOM §2a — the bloom-desync fence). The
+ * render maps clip = (model − center)·scale with the x clip un-aspect-corrected (clip.x is
+ * scaled by aspect in the inverse), so the forward is:
+ *   clipX = (mx − cx)·scale / aspect,  clipY = (my − cy)·scale,  clip ∈ [-1,1].
+ * Then UV = (clipX·0.5 + 0.5, 1 − (clipY·0.5 + 0.5))  (CSS y grows DOWN; the lean is folded
+ * into `center` upstream so the bloom tracks the LEANED head). The result is NOT clamped —
+ * a head that leaves the stage carries the bloom off-edge honestly; the consumer clamps if
+ * it must paint a sprite. Pure arithmetic off the cached `fit` — no second CPU fit to drift.
+ */
+export declare function headToUnit(headX: number, headY: number, fit: FourierFit, aspect: number): {
+    x: number;
+    y: number;
+};
+/**
+ * Convert a CSS-px stroke width to MODEL units (the shader's space). The fit `scale` maps
+ * model → clip; clip spans [-1,1] over the min CSS dimension → cssPx-per-clip = canvasCssMin/2.
+ * model-per-cssPx = (1/scale)·(2/canvasCssMin).
+ */
+export declare function trailWidthToModel(trailWidthPx: number, scale: number, canvasCssMin: number): number;
+/** Pack the render uniforms in place. */
+export declare function packFourierRenderUniforms(scratch: FourierUniformScratch, fit: FourierFit, aspect: number, trailWidthModel: number, peakAlpha: number, headGlowAlpha: number, trailFadeExp: number, trailFloor: number, intensity: number, showEpicycles: boolean, rainbowChain: boolean, squashGain: number, celGain: number, sampleCount: number, armCount: number, palette: OklchStop[]): FourierUniformScratch;
+/**
+ * Pack the phasor storage table (re, im, index, _pad) from the CPU-minted spectrum. The
+ * WGSL SUMS this per frame — it is the ONLY spectrum upload (no WGSL-side mint).
+ */
+export declare function packPhasorTable(spectrum: readonly BasisComponent[]): Float32Array;

package/dist/components/custom/fourier-field/composables/useFourierField.d.ts

@@ -1,39 +1,63 @@
-import { type ShallowRef } from "vue";
-import { type ColorResolver } from "../../../../composables/color";
-/**
- * The renderer of `<FourierField>` — the Fourier-epicycle field on a Canvas2D
- * surface. Lifted out of the SFC into this composable (BB.W-CARVE3) so the
- * component file matches the colocation symmetry its GL/canvas siblings already
- * carry: Aurora→`useAurora.ts`, GooBlob→`useMetaballRenderer.ts`,
- * Constellation→`useConstellation.ts`. The SFC stays thin (props + the two
- * template refs + the single `useFourierField(props, …)` call).
- *
- * It composes the `useCanvas2D` substrate, inheriting the offscreen /
- * tab-hidden / reduced-motion freeze for free (no hand-rolled RAF-park). Color
- * resolves through the INJECTED `colorResolver` seam (the GooBlob model): a
- * `var()`/`light-dark()` token is first resolved to a concrete `rgb()` against
- * the host's inherited color-scheme, then re-resolved on a color change AND on a
- * dark-mode toggle so the field retints with the theme.
- */
-export interface FourierFieldRenderProps {
-    /** Configuration bundle. `hero` = epicycles on, fewer harmonics; `final` = epicycles off, denser. */
-    variant: "hero" | "final";
-    /** Base CSS color (any form the resolver understands; a `var()`/`light-dark()` token resolves against the host). */
-    color: string;
-    /** REQUIRED color seam — resolves a concrete color to a gamma-sRGB [r,g,b] triple in [0,1]. */
-    colorResolver: ColorResolver;
-    /** Extra seed mixed into the spectrum PRNG for a unique-but-reproducible curve. */
-    seed: string;
-    /** When true, paint ONE static deterministic best-frame and never animate (the capture/export lever). */
-    freeze: boolean;
-    /** Outer loudness envelope (the Aurora `opacityCeiling` shape). Scales the resolved alphas at the PAINT layer; clamped [0, 2]. */
-    intensity: number;
-    /** OPTIONAL injected clock — a getter returning the loop parameter `t ∈ [0,1)` (the studio's controllable clock). */
-    clock?: () => number;
+import { type Ref } from "vue";
+import { type GpuBackend } from "../../../../composables/glass/webgpu/useGpuSubstrate";
+import type { OklchStop } from "../../../../composables/color";
+import type { FourierFieldConfig } from "../constants";
+import { type BasisComponent } from "../math";
+export interface UseFourierFieldOptions {
+    config: FourierFieldConfig;
+    /** The active phasor spectrum (CPU-minted; re-read each frame so a source-swap reaches the buffer). */
+    getSpectrum: () => readonly BasisComponent[];
+    /** Resolve the curve-color palette as OKLCh (the demo themes it; default warm-identity). */
+    getPalette: () => OklchStop[];
+    /** When true, hold the deterministic best-frame and never advance (the capture / freeze lever). */
+    freeze?: () => boolean;
+    /** The static deterministic best-frame parameter under `freeze`/PRM. Default 0.34. */
+    frozenT?: number;
+    /** Base forward period for one full traversal at 1× speed, in seconds. Default 16. */
+    periodS?: number;
+    /** `"capture"` → renderAt-only (the deterministic π capture path). Default `"live"`. */
+    mode?: "live" | "capture";
+    /**
+     * BD.W-FOURIER-LOOM §2a — the lit-field seam hook. Fired ONCE per frame from INSIDE the
+     * ONE clock's `onFrame` (NO second rAF), AFTER `headT` advances, with the head's `[0,1]²`
+     * UV (or `null` before the canvas is sized). The SFC writes `--ff-head-xy` on its host so
+     * the warm field's phosphor bloom tracks the comet. PRM → fired with the STABLE frozen-T
+     * UV (the bloom seats, no sweep).
+     */
+    onHeadFrame?: (unit: {
+        x: number;
+        y: number;
+    } | null) => void;
 }
-/** The template refs the SFC owns; the composable reads them once the host is in the tree. */
-export interface FourierFieldRefs {
-    hostRef: Readonly<ShallowRef<HTMLElement | null>>;
-    canvasRef: Readonly<ShallowRef<HTMLCanvasElement | null>>;
+/** The uniform handle a consumer wires its lifecycle against (backend-agnostic). */
+export interface FourierFieldHandle {
+    /** The resolved backend (`"webgpu"` where supported, else the WebGL2 GLSL fallback). */
+    readonly backend: GpuBackend;
+    /** Park the loop (the WCAG-2.2.2 pause seam — `DockBackgroundToggle` wires this). */
+    pause: () => void;
+    /** Re-arm the loop. */
+    resume: () => void;
+    /** Re-arm a parked loop on demand. */
+    wake: () => void;
+    /** Draw one frame out-of-loop (capture / thumbnail). */
+    renderAt: (timeSec: number) => void;
+    /** The live `prefers-reduced-motion: reduce` state. */
+    readonly reducedMotion: boolean;
+    /** The current loop parameter `head_t ∈ [0,1)` (the scrubber reads/writes it). */
+    readonly headT: number;
+    /** Scrub the clock directly (the transport scrubber / a pointer drag). */
+    setHeadT: (t: number) => void;
+    /**
+     * BD.W-FOURIER-LOOM §2a — the comet head mapped to the stage's `[0,1]²` UV, off the SAME
+     * cached fit the GPU comet paints from. The SFC writes this to `--ff-head-xy` per frame so
+     * the warm field's phosphor bloom tracks the head (the lit-field seam). `null` before the
+     * canvas is sized. PRM → a STABLE frozen-T value (the bloom seats, no sweep).
+     */
+    headUnit: () => {
+        x: number;
+        y: number;
+    } | null;
+    /** Tear down the renderer + release GPU/GL resources. */
+    dispose: () => void;
 }
-export declare function useFourierField(props: FourierFieldRenderProps, { hostRef, canvasRef }: FourierFieldRefs): void;
+export declare function useFourierField(canvasRef: Ref<HTMLCanvasElement | null>, options: UseFourierFieldOptions): FourierFieldHandle;

package/dist/components/custom/fourier-field/constants.d.ts

@@ -1,7 +1,117 @@
+import type { OklchStop } from "../../../composables/color";
 /**
- * Curve-sampling resolution for the stable view-fit bbox pass — the renderer
- * samples the epicycle curve this many times once at mount to size it to the
- * canvas with a fixed margin (so the curve never clips and the scale is constant
- * across the run). 720 = one sample per half-degree of the unit period.
+ * Curve-sampling resolution for the stable view-fit bbox pass — the renderer samples the
+ * epicycle curve this many times once at mount to size it to the canvas with a fixed
+ * margin (so the curve never clips and the scale is constant across the run). 720 = one
+ * sample per half-degree of the unit period.
  */
 export declare const FOURIER_FIT_SAMPLES = 720;
+/**
+ * The phasor-table uniform ceiling — the WGSL `MAX_PHASORS` #define. The configurator's
+ * harmonic count maxes here; a >64-term custom trace books a storage-buffer widen (cheap —
+ * the flow-field already uses a storage buffer). The curated ℱ/heart/star set + the
+ * generated elliptic spectrum all sit under it.
+ */
+export declare const MAX_PHASORS = 64;
+/**
+ * The comet-curve sample ceiling — the storage-buffer array bound. The compute pass
+ * writes the partial-sum curve point at `M` samples back along the period from the head;
+ * the render pass reads them as the comet polyline. 384 gives a smooth bold stroke.
+ */
+export declare const MAX_CURVE_SAMPLES = 384;
+/** The palette-stop ceiling — the WGSL `MAX_FOURIER_STOPS` #define. */
+export declare const MAX_FOURIER_STOPS = 4;
+/**
+ * The cursor-velocity → head_t clock-coupling gain (BD.W-VIZ-BROKEN-FIX D6 — the weighted
+ * scrub). The cursor MOTION (not its absolute X) nudges the loop clock: a flick fast-
+ * forwards, a still cursor lets the field drift at its config speed. Velocity-continuous —
+ * the head never teleports (the prior `headT = pointerX` absolute-X scrub read as "not
+ * following" a 2-D cursor).
+ */
+export declare const SCRUB_GAIN = 0.15;
+/**
+ * The 2-D cursor-FOLLOW lean depth (BD.W-VIZ-BROKEN-FIX D6b — the spatial follow beside the
+ * velocity scrub). A bounded fraction of the model half-span the view-fit center leans
+ * toward the cursor, so the whole reconstruction pans TOWARD the cursor on screen (a gentle
+ * pull, never a yank — the [[feedback-liquid-weight-universal]] weighted register). At 0
+ * the field is byte-identical (the ambient/non-interactive register).
+ */
+export declare const FOLLOW_LEAN = 0.12;
+/**
+ * The degenerate-tangent guard (BD.W-FOURIER-LOOM §2b). At a cusp the head's instantaneous
+ * speed `s = length(head − headBack)` collapses to ~0 and the unit tangent `T = d/s` blows
+ * up; below `FOURIER_TANGENT_EPS` the shaders + the GL CPU bead path all fall back to the
+ * LAST stable tangent, so `s→0` resolves IDENTICALLY across both engines (the cross-engine
+ * cusp-parity fence — one shared constant, no per-engine drift).
+ */
+export declare const FOURIER_TANGENT_EPS = 0.0001;
+/**
+ * The head squash-and-stretch gain (BD.W-FOURIER-LOOM §2b). The round head bead becomes a
+ * volume-preserving anisotropic ellipse: the tangent extent scales `1 + k·ŝ`, the normal
+ * extent `1/(1 + k·ŝ)`, where `ŝ` is the normalized head speed. The library identity carries
+ * a SMALL non-zero gain (cartoon-weight at rest — the head is never a dead disc); a consumer
+ * vivid preset turns it to 11. `0` = the byte-frozen round disc.
+ */
+export declare const FOURIER_SQUASH_GAIN = 0.55;
+/**
+ * The cartoon cel-shadow gain (BD.W-FOURIER-LOOM §3b). Each chain ring/arm/dot + the comet
+ * rope paints a second darker copy OFFSET opposite its travel — the 1940s technicolor ink.
+ * The library identity carries a SMALL non-zero gain (a quiet weight under the chain); a
+ * consumer vivid preset floors it UP. `0` = no cel pass (byte-frozen). The offset rides the
+ * head tangent, mirrored on both engines off the SAME `curveSamples` tangent.
+ */
+export declare const FOURIER_CEL_GAIN = 0.35;
+/**
+ * The full author schema — the studio's `useConfiguratorState` model. Every field is a
+ * tunable the demo configurator drives; the composable resolves it into the uniform table.
+ */
+export interface FourierFieldConfig {
+    /** The active phasor spectrum source key — `"elliptic"` (generated) or a curated shape key. */
+    source: string;
+    /** TRUNCATE the partial sum — the harmonic count N (1..min(spectrum.length, MAX_PHASORS)). */
+    harmonics: number;
+    /** Draw the rotating epicycle chain (orthogonal to N). */
+    showEpicycles: boolean;
+    /** How many chain arms to draw (1..N; ≤ the harmonic count). */
+    epicycleArms: number;
+    /** Paint the chain as a warm-anchored hue sweep vs one analogous hue. */
+    rainbowChain: boolean;
+    /** Comet-body length as a fraction of the period (0.15..1.0). */
+    trailArc: number;
+    /** Comet stroke weight in CSS px (1..6). */
+    trailWidth: number;
+    /** Outer loudness envelope (per-layer alpha multiply, 0..2). */
+    intensity: number;
+    /** Character of the generated elliptic spectrum (0.05..0.4 — smooth ellipse → crinkled). */
+    harmonicScale: number;
+    /** Clock speed multiplier (0.25/0.5/1/2). */
+    speed: number;
+    /** The curve-color ramp (the library viz palette; warm default). Resolved via the ColorResolver. */
+    palette: OklchStop[];
+    /** ONE static frame then park under `prefers-reduced-motion: reduce`. */
+    respectReducedMotion: boolean;
+    /** Pointer scrubs `head_t` + a flick injects clock momentum (the W-VIZ-INTERACTION consume). */
+    interactive: boolean;
+    /**
+     * Head squash-and-stretch gain (BD.W-FOURIER-LOOM §2b). The head bead stretches along the
+     * curve tangent on straights, squashes across it on corners (volume-preserving). The
+     * library identity carries a small non-zero default (cartoon-weight at rest); a vivid
+     * consumer preset turns it to 11. 0 = the byte-frozen round disc.
+     */
+    squashGain: number;
+    /**
+     * Cartoon cel-shadow gain (BD.W-FOURIER-LOOM §3b). A second darker copy of the chain + rope,
+     * offset opposite the head travel (the technicolor ink). The library identity carries a
+     * small non-zero default; a vivid consumer preset floors it UP. 0 = no cel pass.
+     */
+    celGain: number;
+}
+/**
+ * The warm-cream identity palette (the library default — NOT teal). A two-stop warm-amber
+ * ramp over the warm-cream foreground family, resolved via the ColorResolver. The chain's
+ * rainbow sweep is warm-anchored over THIS base; a consumer (the demo) themes it through a
+ * preset, never a token edit.
+ */
+export declare const WARM_IDENTITY_PALETTE: OklchStop[];
+/** The shipped warm-identity default config. */
+export declare const DEFAULT_FOURIER_CONFIG: FourierFieldConfig;

package/dist/components/custom/fourier-field/index.d.ts

@@ -1,26 +1,31 @@
-import type { ColorResolver } from "../../../composables/color";
+import type { ColorResolver, OklchStop } from "../../../composables/color";
+import type { FourierFieldConfig } from "./constants";
+import type { BasisComponent } from "./math";
 export { default as FourierField } from "./FourierField.vue";
 export { comp, positionsAt, partialSumAt, dftFromPoints, makeEllipticSpectrum, type BasisComponent, type EllipticSpectrumOptions, } from "./math";
-/** The configuration-BUNDLE axis — `hero` (epicycles on, fewer harmonics) vs
- *  `final` (epicycles off, denser). Not a recolour of one curve; one engine,
- *  two presets. */
-export type FourierFieldVariant = "hero" | "final";
-/** The props a consumer forwards when wrapping `<FourierField>` (the seeded
- *  inverse-DFT epicycle background; ships via `/fourier-field`). Mirrors the
- *  component's inline `defineProps` shape (an SFC cannot export its inline
- *  props type). */
+export { DEFAULT_FOURIER_CONFIG, WARM_IDENTITY_PALETTE, MAX_PHASORS, MAX_CURVE_SAMPLES, type FourierFieldConfig, } from "./constants";
+export { useFourierField, type FourierFieldHandle, type UseFourierFieldOptions, } from "./composables/useFourierField";
+/**
+ * The props a consumer forwards when wrapping `<FourierField>` (the GPU-substrate epicycle
+ * field; ships via `/fourier-field`). Mirrors the component's inline `defineProps` shape (an
+ * SFC cannot export its inline props type). BC.W-VIZ-FOURIER — the `variant: "hero"|"final"`
+ * enum is RETIRED (folds into config presets); the renderer is the WGSL-primary GPU substrate.
+ */
 export interface FourierFieldProps {
-    /** Configuration bundle. Default `hero`. */
-    variant?: FourierFieldVariant;
-    /** Base CSS color (a `var()`/`light-dark()` token resolves against the host). */
-    color: string;
-    /** REQUIRED color seam — resolves a concrete color to a gamma-sRGB [r,g,b] triple in [0,1]. */
-    colorResolver: ColorResolver;
-    /** Extra seed mixed into the spectrum PRNG for a unique-but-reproducible curve. Default "". */
+    /** The full author config (the studio's `useConfiguratorState` model). Defaults to the warm identity. */
+    config?: FourierFieldConfig;
+    /** An explicit CPU-minted spectrum (a curated shape's DFT). When absent, a seeded elliptic spectrum is generated. */
+    spectrum?: readonly BasisComponent[];
+    /** Resolve the curve palette as OKLCh (the studio themes it). */
+    getPalette?: () => OklchStop[];
+    /** Ambient-consumer color seam — a `var()`/`light-dark()` token or a literal; derives a warm palette. */
+    color?: string;
+    /** The color resolver (the GooBlob/Aurora seam) — required when `color` is a `var()` token. */
+    colorResolver?: ColorResolver;
+    /** Extra seed mixed into the generated elliptic spectrum PRNG. Default "". */
     seed?: string;
     /** Paint ONE static deterministic best-frame and never animate (the capture lever). Default false. */
     freeze?: boolean;
-    /** Outer loudness envelope (the Aurora `opacityCeiling` shape). Scales the
-     *  resolved `peakAlpha`/`headGlowAlpha` at the paint layer. Default 1; clamped [0, 2]. */
+    /** Outer loudness envelope (scales the per-layer alpha). Overrides `config.intensity` when set; clamped [0, 2]. */
     intensity?: number;
 }

package/dist/components/custom/fourier-field/shaders/fourier-field.compute.wgsl.d.ts

@@ -0,0 +1 @@
+export declare const FOURIER_FIELD_COMPUTE_WGSL = "\nconst MAX_PHASORS: i32 = 64;\nconst TAU: f32 = 6.283185307179586;\n\nstruct Phasor {\n  // (re, im, index, _pad)\n  data: vec4<f32>,\n};\n\n// \u2500\u2500 Compute uniforms (the typed-struct source-of-truth \u2014 see uniformBridgeWGPU.ts) \u2500\u2500\nstruct ComputeUniforms {\n  // c0: (headT, trailArc, _pad, _pad)\n  c0: vec4<f32>,\n  // ints: (harmonicN, epicycleArmN, sampleCount, phasorCount)\n  ints: vec4<i32>,\n};\n\n@group(0) @binding(0) var<uniform> u: ComputeUniforms;\n@group(0) @binding(1) var<storage, read> phasors: array<Phasor>;\n// curveSamples[i] = (x, y, age, _pad)\n@group(0) @binding(2) var<storage, read_write> curveSamples: array<vec4<f32>>;\n// chainTips[k] = (x, y, _pad, _pad) \u2014 the running tip after stacking phasor k\n@group(0) @binding(3) var<storage, read_write> chainTips: array<vec4<f32>>;\n\n// The PARTIAL-SUM curve point at parameter t over the first n phasors \u2014 the WGSL\n// transcription of math.ts:78-95 (partialSumAt). EXACTLY:\n//   c += vec2(re\u00B7cos \u2212 im\u00B7sin, re\u00B7sin + im\u00B7cos)  with angle = TAU\u00B7index\u00B7t.\nfn partialSumAt(t: f32, n: i32) -> vec2<f32> {\n  var c = vec2<f32>(0.0, 0.0);\n  let phasorCount = u.ints.w;\n  let lim = min(n, phasorCount);\n  for (var i = 0; i < MAX_PHASORS; i = i + 1) {\n    if (i >= lim) { break; }\n    let p = phasors[i].data;\n    let re = p.x;\n    let im = p.y;\n    let index = p.z;\n    let angle = TAU * index * t;\n    let cs = cos(angle);\n    let sn = sin(angle);\n    c = c + vec2<f32>(re * cs - im * sn, re * sn + im * cs);\n  }\n  return c;\n}\n\n// The epicycle chain tip after stacking the first k phasors at head_t \u2014 the WGSL\n// transcription of math.ts:41-60 (positionsAt, read at the running tip). The running tip\n// after phasor (k\u22121) is exactly the partial sum over the first k terms.\nfn epicycleChainTip(t: f32, k: i32) -> vec2<f32> {\n  return partialSumAt(t, k);\n}\n\n@compute @workgroup_size(64)\nfn cs_main(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let i = i32(gid.x);\n  let headT = u.c0.x;\n  let trailArc = u.c0.y;\n  let harmonicN = u.ints.x;\n  let armN = u.ints.y;\n  let sampleCount = u.ints.z;\n\n  // \u2500\u2500 The comet body samples \u2500\u2500\n  if (i < sampleCount) {\n    // age: 0 at the oldest tail (i = sampleCount\u22121), 1 at the head (i = 0).\n    let denom = max(f32(sampleCount - 1), 1.0);\n    let frac = f32(i) / denom;                 // 0 = head, 1 = tail\n    let age = 1.0 - frac;                       // 1 = head, 0 = tail\n    // sample back along the period from the head by trailArc.\n    var t = headT - trailArc * frac;\n    t = t - floor(t);                           // fract \u2192 [0,1)\n    let pt = partialSumAt(t, harmonicN);\n    curveSamples[i] = vec4<f32>(pt.x, pt.y, age, 0.0);\n  }\n\n  // \u2500\u2500 The epicycle chain tips (k = 0..armN, capped to harmonicN) \u2500\u2500\n  // chainTips[0] is the origin; chainTips[k] is the tip after phasor (k\u22121).\n  let armLim = min(armN, harmonicN);\n  if (i <= armLim && i <= MAX_PHASORS) {\n    let tip = epicycleChainTip(headT, i);\n    chainTips[i] = vec4<f32>(tip.x, tip.y, 0.0, 0.0);\n  }\n}\n";

package/dist/components/custom/fourier-field/shaders/fourier-field.glsl.d.ts

@@ -0,0 +1,4 @@
+/** The full-screen-triangle vertex shader (the aurora/concentric pattern). */
+export declare const FOURIER_FIELD_VERT_GLSL = "#version 300 es\nin vec2 aPosition;\nout vec2 vClip;\nvoid main() {\n  vClip = aPosition;\n  gl_Position = vec4(aPosition, 0.0, 1.0);\n}\n";
+/** The fragment SDF — the GLSL twin of fourier-field.render.wgsl.ts's fs_main. */
+export declare const FOURIER_FIELD_FRAG_GLSL = "#version 300 es\nprecision highp float;\n\n#define MAX_CURVE_SAMPLES 256\n#define MAX_PHASORS 64\n// BD.W-FOURIER-LOOM \u00A72b \u2014 MUST equal the WGSL twin + FOURIER_TANGENT_EPS (constants.ts).\n#define TANGENT_EPS 1e-4\n#define SPEED_REF_HALFWIDTHS 6.0\n\nin vec2 vClip;\nout vec4 fragColor;\n\nuniform vec4 uFit;          // (centerX, centerY, scale, aspect)\nuniform vec4 uTrail;        // (trailWidth, peakAlpha, headGlowAlpha, trailFadeExp)\nuniform vec4 uEnv;          // (trailFloor, intensity, showEpicycles, rainbowChain)\nuniform vec4 uLoom;         // (squashGain, celGain, _pad, _pad) \u2014 FOURIER-LOOM \u00A72b/\u00A73b\nuniform int  uSampleCount;\nuniform int  uArmCount;\nuniform int  uStopCount;\nuniform vec3 uPalette[4];   // linear-sRGB stops\n// curveSamples[i] = (x, y, age) in MODEL space; chainTips[k] = (x, y) in MODEL space.\nuniform vec3 uCurve[MAX_CURVE_SAMPLES];\nuniform vec2 uChain[MAX_PHASORS];\n\nconst float PI = 3.141592653589793;\n\n\nfloat srgbToLinearCh(float c) {\n    return c <= 0.04045 ? c / 12.92 : pow((c + 0.055) / 1.055, 2.4);\n}\nvec3 srgbToLinear(vec3 c) {\n    return vec3(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\n\nfloat linearToSrgbCh(float c) {\n    return c <= 0.0031308 ? c * 12.92 : 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\nvec3 linearToSrgb(vec3 c) {\n    return vec3(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}\n\n// value.js LINEAR_SRGB_TO_LMS (constants.ts), row-major; written here as GLSL\n// columns (= the transpose) so mat3 * vec3 evaluates the row-major M\u00B7v.\nconst mat3 LINEAR_SRGB_TO_LMS = mat3(\n    0.4122214708, 0.2119034982, 0.0883024619,\n    0.5363325363, 0.6806995451, 0.2817188376,\n    0.0514459929, 0.1073969566, 0.6299787005\n);\n\n// value.js srgbToOKLab's INLINE LMS\u2192OKLab coefficients (gamut.ts lines 295-297 \u2014\n// these differ at the ~1e-9 digit from LMS_TO_OKLAB_MATRIX; use the inline ones to\n// mirror the exact value.js path), row-major \u2192 GLSL columns.\nconst mat3 LMS_TO_OKLAB = mat3(\n    0.2104542553, 1.9779984951, 0.0259040371,\n    0.7936177850, -2.4285922050, 0.7827717662,\n    -0.0040720468, 0.4505937099, -0.8086757660\n);\n\n// value.js OKLAB_TO_LMS_COEFF (constants.ts), row-major \u2192 GLSL columns. Rows:\n// l = [1, 0.3963377774, 0.2158037573], m = [1, -0.1055613458, -0.0638541728],\n// s = [1, -0.0894841775, -1.2914855480].\nconst mat3 OKLAB_TO_LMS = mat3(\n    1.0, 1.0, 1.0,\n    0.3963377774, -0.1055613458, -0.0894841775,\n    0.2158037573, -0.0638541728, -1.2914855480\n);\n\n// value.js LMS_TO_LINEAR_SRGB (constants.ts), row-major \u2192 GLSL columns.\nconst mat3 LMS_TO_LINEAR_SRGB = mat3(\n    4.0767416621, -1.2684380046, -0.0041960863,\n    -3.3077115913, 2.6097574011, -0.7034186147,\n    0.2309699292, -0.3413193965, 1.7076147010\n);\n\n// Gamma sRGB \u2192 raw OKLab (L, a, b). Mirrors value.js srgbToOKLab.\nvec3 srgbToOklab(vec3 c) {\n    vec3 lin = srgbToLinear(c);\n    vec3 lms = LINEAR_SRGB_TO_LMS * lin;\n    vec3 lmsCbrt = sign(lms) * pow(abs(lms), vec3(1.0 / 3.0));\n    return LMS_TO_OKLAB * lmsCbrt;\n}\n\n// Raw OKLab (L, a, b) \u2192 linear sRGB. Mirrors value.js oklabToLinearSRGB.\nvec3 oklabToLinearSrgb(vec3 lab) {\n    vec3 lms_ = OKLAB_TO_LMS * lab;\n    vec3 lms = lms_ * lms_ * lms_;\n    return LMS_TO_LINEAR_SRGB * lms;\n}\n\n// OKLab \u2192 OKLCh: H in RADIANS. Mirrors value.js rawOklabToOklch (which returns\n// degrees; we stay in radians and only fold to [0, 2pi)).\nvec3 oklabToOklch(vec3 lab) {\n    float C = length(lab.yz);\n    float H = atan(lab.z, lab.y);\n    if (H < 0.0) H += 2.0 * PI;\n    return vec3(lab.x, C, H);\n}\n\n// OKLCh (H radians) \u2192 OKLab. Mirrors value.js rawOklchToOklab.\nvec3 oklchToOklab(vec3 lch) {\n    return vec3(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}\n\n// Negative-safe cube root (the WGSL chunk's cbrt3 twin; the GLSL chunk inlines it).\nvec3 cbrt3(vec3 v) { return sign(v) * pow(abs(v), vec3(1.0 / 3.0)); }\n\nvec3 samplePaletteLin(float t) {\n  if (uStopCount <= 1) return uPalette[0];\n  float n = float(uStopCount);\n  float ft = clamp(t, 0.0, 1.0) * (n - 1.0);\n  int i0 = int(floor(ft));\n  int i1 = min(i0 + 1, uStopCount - 1);\n  float f = ft - float(i0);\n  vec3 labA = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * uPalette[i0]);\n  vec3 labB = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * uPalette[i1]);\n  return oklabToLinearSrgb(mix(labA, labB, f));\n}\n\nvec3 chainColorLin(float seg, bool rainbow) {\n  vec3 baseLin = uPalette[0];\n  if (!rainbow) return baseLin;\n  vec3 lab = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * baseLin);\n  vec3 lch = oklabToOklch(lab);\n  float hueShift = mix(-0.45, 1.15, clamp(seg, 0.0, 1.0));\n  vec3 lifted = vec3(0.66, max(lch.y, 0.14), lch.z + hueShift);\n  return oklabToLinearSrgb(oklchToOklab(lifted));\n}\n\nfloat segDist(vec2 p, vec2 a, vec2 b) {\n  vec2 pa = p - a;\n  vec2 ba = b - a;\n  float h = clamp(dot(pa, ba) / max(dot(ba, ba), 1e-8), 0.0, 1.0);\n  return length(pa - ba * h);\n}\n\n// BD.W-FOURIER-LOOM \u00A72b \u2014 the head travel frame (T, \u015D), the GLSL twin of the WGSL headFrame.\n// The cusp guard returns +x as the stable fallback when s \u2264 TANGENT_EPS \u2014 identical to the\n// WGSL twin + the CPU bead path.\nstruct HeadFrame { vec2 T; float sHat; };\nHeadFrame headFrame(vec2 head, vec2 headBack, float halfW) {\n  vec2 d = head - headBack;\n  float s = length(d);\n  HeadFrame fr;\n  if (s <= TANGENT_EPS) { fr.T = vec2(1.0, 0.0); fr.sHat = 0.0; return fr; }\n  fr.T = d / s;\n  float refScale = max(halfW * SPEED_REF_HALFWIDTHS, 1e-6);\n  fr.sHat = clamp(s / refScale, 0.0, 1.0);\n  return fr;\n}\n\n// The volume-preserving anisotropic head distance (the WGSL headAniso twin).\nfloat headAniso(vec2 p, vec2 head, HeadFrame fr, float k) {\n  float g = 1.0 + k * fr.sHat;\n  vec2 n = vec2(-fr.T.y, fr.T.x);\n  vec2 rel = p - head;\n  float along = dot(rel, fr.T) / g;\n  float across = dot(rel, n) * g;\n  return length(vec2(along, across));\n}\n\nvoid main() {\n  vec2 center = uFit.xy;\n  float scale = max(uFit.z, 1e-6);\n  float aspect = max(uFit.w, 1e-4);\n  // clip \u2192 model (the inverse of model\u2192clip fit).\n  vec2 p = center + vec2(vClip.x * aspect, vClip.y) / scale;\n\n  float aa = max(fwidth(p.x) + fwidth(p.y), 1e-5) * 0.75;\n  float trailWidth = uTrail.x;            // already in model units (packed CPU-side)\n  float peak = uTrail.y * uEnv.y;\n  float headGlow = uTrail.z * uEnv.y;\n  float fadeExp = uTrail.w;\n  float trailFloor = uEnv.x;\n  bool showEpicycles = uEnv.z > 0.5;\n  bool rainbow = uEnv.w > 0.5;\n  float squashGain = uLoom.x;            // FOURIER-LOOM \u00A72b\n  float celGain = uLoom.y;               // FOURIER-LOOM \u00A73b\n  float halfW = trailWidth * 0.5;\n\n  // \u00A72b \u2014 the head travel frame (SAME uCurve[0]/[1] the WGSL twin reads \u2192 parity).\n  HeadFrame headFr;\n  headFr.T = vec2(1.0, 0.0);\n  headFr.sHat = 0.0;\n  if (uSampleCount >= 2) {\n    headFr = headFrame(uCurve[0].xy, uCurve[1].xy, halfW);\n  }\n  vec2 celOff = -headFr.T * halfW * 1.4;\n\n  vec4 accum = vec4(0.0);\n\n  // \u00A73b \u2014 the cartoon CEL-SHADOW: a darker offset copy of the rope + chain, opposite travel,\n  // painted FIRST (under the lit chain). PRM-static; celGain = 0 \u2192 no pass (byte-frozen).\n  if (celGain > 0.001) {\n    vec3 ink = vec3(0.0);\n    float celA = clamp(celGain, 0.0, 1.0);\n    for (int i = 0; i < MAX_CURVE_SAMPLES; i++) {\n      if (i >= uSampleCount - 1) break;\n      vec2 sa = uCurve[i].xy + celOff;\n      vec2 sb = uCurve[i + 1].xy + celOff;\n      float d = segDist(p, sa, sb);\n      float cover = 1.0 - smoothstep(halfW, halfW + aa, d);\n      if (cover < 0.002) continue;\n      float m = cover * celA * peak;\n      accum = vec4(ink * m, m) + accum * (1.0 - m);\n    }\n    if (showEpicycles && uArmCount >= 1) {\n      for (int k = 0; k < MAX_PHASORS; k++) {\n        if (k >= uArmCount) break;\n        vec2 a = uChain[k] + celOff;\n        vec2 b = uChain[k + 1] + celOff;\n        float dArm = segDist(p, a, b);\n        float armMask = 1.0 - smoothstep(halfW * 0.55, halfW * 0.55 + aa, dArm);\n        float m = armMask * celA * peak * 0.7;\n        accum = vec4(ink * m, m) + accum * (1.0 - m);\n      }\n    }\n  }\n\n  if (showEpicycles && uArmCount >= 1) {\n    for (int k = 0; k < MAX_PHASORS; k++) {\n      if (k >= uArmCount) break;\n      vec2 a = uChain[k];\n      vec2 b = uChain[k + 1];\n      float seg = float(k) / max(float(uArmCount - 1), 1.0);\n      vec3 lin = chainColorLin(seg, rainbow);\n      float radius = length(b - a);\n      float dRing = abs(length(p - a) - radius);\n      float ringW = max(halfW * 0.45, aa);\n      float ringMask = (1.0 - smoothstep(ringW, ringW + aa, dRing)) * 0.5;\n      float dArm = segDist(p, a, b);\n      float armMask = 1.0 - smoothstep(halfW * 0.55, halfW * 0.55 + aa, dArm);\n      float dotR = max(halfW * 0.7, aa * 2.0);\n      float dDot = length(p - a);\n      float dotMask = 1.0 - smoothstep(dotR, dotR + aa, dDot);\n      float m = clamp(max(max(ringMask, armMask), dotMask), 0.0, 1.0) * peak * 0.7;\n      vec3 rgb = clamp(linearToSrgb(lin), vec3(0.0), vec3(1.0));\n      accum = vec4(rgb * m, m) + accum * (1.0 - m);\n    }\n  }\n\n  for (int i = 0; i < MAX_CURVE_SAMPLES; i++) {\n    if (i >= uSampleCount - 1) break;\n    vec3 sa = uCurve[i];\n    vec3 sb = uCurve[i + 1];\n    float d = segDist(p, sa.xy, sb.xy);\n    float cover = 1.0 - smoothstep(halfW, halfW + aa, d);\n    if (cover < 0.002) continue;\n    float age = max(sa.z, sb.z);\n    float a = peak * pow(age, fadeExp);\n    a = max(a, peak * trailFloor) * cover;\n    vec3 lin = samplePaletteLin(1.0 - age * 0.4);\n    vec3 rgb = clamp(linearToSrgb(lin), vec3(0.0), vec3(1.0));\n    accum = vec4(rgb * a, a) + accum * (1.0 - a);\n  }\n\n  if (uSampleCount >= 1) {\n    vec2 head = uCurve[0].xy;\n    // \u00A72b \u2014 the squash-and-stretch anisotropic head (collapses to the round disc at rest).\n    float dHead = headAniso(p, head, headFr, squashGain);\n    float coreR = halfW * 1.5;\n    float haloR = coreR * 3.0;\n    vec3 headRgb = clamp(linearToSrgb(samplePaletteLin(0.0)), vec3(0.0), vec3(1.0));\n    float halo = (1.0 - smoothstep(0.0, haloR, dHead)) * headGlow * 0.35;\n    accum = vec4(headRgb * halo, halo) + accum * (1.0 - halo);\n    float core = (1.0 - smoothstep(coreR, coreR + aa, dHead)) * headGlow;\n    accum = vec4(headRgb * core, core) + accum * (1.0 - core);\n    float spec = (1.0 - smoothstep(coreR * 0.4, coreR * 0.4 + aa, dHead)) * headGlow * 0.9;\n    accum = vec4(vec3(1.0) * spec, spec) + accum * (1.0 - spec);\n  }\n\n  fragColor = accum;\n}\n";

package/dist/components/custom/fourier-field/shaders/fourier-field.render.wgsl.d.ts

@@ -0,0 +1 @@
+export declare const FOURIER_FIELD_RENDER_WGSL = "\nconst PI: f32 = 3.141592653589793;\nconst TAU: f32 = 6.283185307179586;\nconst MAX_CURVE_SAMPLES: i32 = 384;\nconst MAX_PHASORS: i32 = 64;\nconst MAX_FOURIER_STOPS: i32 = 4;\n// BD.W-FOURIER-LOOM \u00A72b \u2014 the degenerate-tangent guard (must equal FOURIER_TANGENT_EPS in\n// constants.ts + the GL CPU bead path so a cusp resolves IDENTICALLY across both engines).\nconst TANGENT_EPS: f32 = 1e-4;\n// The speed yardstick: the head speed (model units between curveSamples[0] and [1]) is\n// normalized against this many trail half-widths so \u015D \u2208 [0,1] is scale-free + parity-safe.\nconst SPEED_REF_HALFWIDTHS: f32 = 6.0;\n\n// \u2500\u2500 Render uniforms (the typed-struct source-of-truth \u2014 see uniformBridgeWGPU.ts) \u2500\u2500\nstruct RenderUniforms {\n  // r0: (centerX, centerY, scale, aspect)  \u2014 model\u2192clip fit transform\n  r0: vec4<f32>,\n  // r1: (trailWidth, peakAlpha, headGlowAlpha, trailFadeExp)\n  r1: vec4<f32>,\n  // r2: (trailFloor, intensity, showEpicycles, rainbowChain)\n  r2: vec4<f32>,\n  // r3: (squashGain, celGain, _pad, _pad) \u2014 FOURIER-LOOM \u00A72b/\u00A73b\n  r3: vec4<f32>,\n  // ints: (sampleCount, armCount, stopCount, _pad)\n  ints: vec4<i32>,\n  // palette stops: linear-sRGB rgb + _pad\n  palette: array<vec4<f32>, 4>,\n};\n\n@group(0) @binding(0) var<uniform> u: RenderUniforms;\n// curveSamples[i] = (x, y, age, _pad) in MODEL space\n@group(0) @binding(1) var<storage, read> curveSamples: array<vec4<f32>>;\n// chainTips[k] = (x, y, _pad, _pad) in MODEL space\n@group(0) @binding(2) var<storage, read> chainTips: array<vec4<f32>>;\n\n\nfn srgbToLinearCh(c: f32) -> f32 {\n  if (c <= 0.04045) { return c / 12.92; }\n  return pow((c + 0.055) / 1.055, 2.4);\n}\nfn srgbToLinear(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\n\nfn linearToSrgbCh(c: f32) -> f32 {\n  if (c <= 0.0031308) { return c * 12.92; }\n  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\nfn linearToSrgb(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}\n\n// value.js LINEAR_SRGB_TO_LMS, row-major \u2192 WGSL columns (= the transpose).\nconst LINEAR_SRGB_TO_LMS: mat3x3<f32> = mat3x3<f32>(\n  0.4122214708, 0.2119034982, 0.0883024619,\n  0.5363325363, 0.6806995451, 0.2817188376,\n  0.0514459929, 0.1073969566, 0.6299787005\n);\n\n// value.js srgbToOKLab's INLINE LMS\u2192OKLab coefficients, row-major \u2192 WGSL columns.\nconst LMS_TO_OKLAB: mat3x3<f32> = mat3x3<f32>(\n  0.2104542553, 1.9779984951, 0.0259040371,\n  0.7936177850, -2.4285922050, 0.7827717662,\n  -0.0040720468, 0.4505937099, -0.8086757660\n);\n\n// value.js OKLAB_TO_LMS_COEFF, row-major \u2192 WGSL columns.\nconst OKLAB_TO_LMS: mat3x3<f32> = mat3x3<f32>(\n  1.0, 1.0, 1.0,\n  0.3963377774, -0.1055613458, -0.0894841775,\n  0.2158037573, -0.0638541728, -1.2914855480\n);\n\n// value.js LMS_TO_LINEAR_SRGB, row-major \u2192 WGSL columns.\nconst LMS_TO_LINEAR_SRGB: mat3x3<f32> = mat3x3<f32>(\n  4.0767416621, -1.2684380046, -0.0041960863,\n  -3.3077115913, 2.6097574011, -0.7034186147,\n  0.2309699292, -0.3413193965, 1.7076147010\n);\n\nfn cbrt3(v: vec3<f32>) -> vec3<f32> {\n  return sign(v) * pow(abs(v), vec3<f32>(1.0 / 3.0));\n}\n\n// Gamma sRGB \u2192 raw OKLab (L, a, b). Mirrors value.js srgbToOKLab.\nfn srgbToOklab(c: vec3<f32>) -> vec3<f32> {\n  let lin = srgbToLinear(c);\n  let lms = LINEAR_SRGB_TO_LMS * lin;\n  return LMS_TO_OKLAB * cbrt3(lms);\n}\n\n// Raw OKLab (L, a, b) \u2192 linear sRGB. Mirrors value.js oklabToLinearSRGB.\nfn oklabToLinearSrgb(lab: vec3<f32>) -> vec3<f32> {\n  let lms_ = OKLAB_TO_LMS * lab;\n  let lms = lms_ * lms_ * lms_;\n  return LMS_TO_LINEAR_SRGB * lms;\n}\n\n// OKLab \u2192 OKLCh: H in RADIANS, folded to [0, 2pi). Mirrors value.js rawOklabToOklch.\nfn oklabToOklch(lab: vec3<f32>) -> vec3<f32> {\n  let C = length(lab.yz);\n  var H = atan2(lab.z, lab.y);\n  if (H < 0.0) { H = H + 2.0 * PI; }\n  return vec3<f32>(lab.x, C, H);\n}\n\n// OKLCh (H radians) \u2192 OKLab. Mirrors value.js rawOklchToOklab.\nfn oklchToOklab(lch: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}\n\n// Sample the multi-stop palette (linear-sRGB stops, OKLab mix). t in [0,1].\nfn samplePaletteLin(t: f32) -> vec3<f32> {\n  let stopCount = u.ints.z;\n  if (stopCount <= 1) { return u.palette[0].rgb; }\n  let n = f32(stopCount);\n  let ft = clamp(t, 0.0, 1.0) * (n - 1.0);\n  let i0 = i32(floor(ft));\n  let i1 = min(i0 + 1, stopCount - 1);\n  let f = ft - f32(i0);\n  let labA = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i0].rgb);\n  let labB = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i1].rgb);\n  return oklabToLinearSrgb(mix(labA, labB, f));\n}\n\n// A warm-anchored chain hue sweep over the palette base \u2014 the rainbow chain register.\n// Tilts the base hue by a tight warm-ward band so the chain stays colourful but warm.\nfn chainColorLin(seg: f32, rainbow: bool) -> vec3<f32> {\n  let baseLin = u.palette[0].rgb;\n  if (!rainbow) { return baseLin; }\n  let lab = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * baseLin);\n  let lch = oklabToOklch(lab);\n  // warm-anchored: a touch cool at the root climbing warm toward the tips.\n  let hueShift = mix(-0.45, 1.15, clamp(seg, 0.0, 1.0)); // radians (~ -26\u00B0..+66\u00B0)\n  let h = lch.z + hueShift;\n  let lifted = vec3<f32>(0.66, max(lch.y, 0.14), h);\n  return oklabToLinearSrgb(oklchToOklab(lifted));\n}\n\n// Distance from point p to segment ab (model space).\nfn segDist(p: vec2<f32>, a: vec2<f32>, b: vec2<f32>) -> f32 {\n  let pa = p - a;\n  let ba = b - a;\n  let h = clamp(dot(pa, ba) / max(dot(ba, ba), 1e-8), 0.0, 1.0);\n  return length(pa - ba * h);\n}\n\n// BD.W-FOURIER-LOOM \u00A72b \u2014 the head travel frame: the unit tangent T from curveSamples[0]\n// (head) vs [1] (one step back) + the normalized speed \u015D \u2208 [0,1]. The cusp guard returns\n// the +x axis as the stable fallback when s \u2264 TANGENT_EPS, identical to the GL CPU path.\nstruct HeadFrame { T: vec2<f32>, sHat: f32, };\nfn headFrame(head: vec2<f32>, headBack: vec2<f32>, halfW: f32) -> HeadFrame {\n  let d = head - headBack;\n  let s = length(d);\n  var out: HeadFrame;\n  if (s <= TANGENT_EPS) {\n    out.T = vec2<f32>(1.0, 0.0);\n    out.sHat = 0.0;\n    return out;\n  }\n  out.T = d / s;\n  let refScale = max(halfW * SPEED_REF_HALFWIDTHS, 1e-6);\n  out.sHat = clamp(s / refScale, 0.0, 1.0);\n  return out;\n}\n\n// The volume-preserving anisotropic head distance: project (p \u2212 head) onto T and T\u22A5, stretch\n// the tangent extent by (1 + k\u00B7\u015D) and squeeze the normal extent by 1/(1 + k\u00B7\u015D), then length.\n// k = 0 (or \u015D = 0) collapses to the round disc length(p \u2212 head) \u2014 byte-frozen at rest.\nfn headAniso(p: vec2<f32>, head: vec2<f32>, fr: HeadFrame, k: f32) -> f32 {\n  let g = 1.0 + k * fr.sHat;\n  let n = vec2<f32>(-fr.T.y, fr.T.x);\n  let rel = p - head;\n  let along = dot(rel, fr.T) / g;\n  let across = dot(rel, n) * g;\n  return length(vec2<f32>(along, across));\n}\n\nstruct VSOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) model: vec2<f32>,   // model-space coordinate of this fragment\n};\n\n@vertex\nfn vs_main(@builtin(vertex_index) vi: u32) -> VSOut {\n  // Full-screen triangle (covers the viewport with 3 verts).\n  var p = array<vec2<f32>, 3>(\n    vec2<f32>(-1.0, -3.0), vec2<f32>(-1.0, 1.0), vec2<f32>(3.0, 1.0),\n  );\n  let clip = p[vi];\n  // Inverse of the model\u2192clip fit: clip = (model \u2212 center)\u00B7scale, aspect-corrected x.\n  // \u2192 model = center + clip\u00B7(1/scale), x un-aspect-corrected.\n  let center = u.r0.xy;\n  let scale = max(u.r0.z, 1e-6);\n  let aspect = max(u.r0.w, 1e-4);\n  let model = center + vec2<f32>(clip.x * aspect, clip.y) / scale;\n\n  var out: VSOut;\n  out.pos = vec4<f32>(clip, 0.0, 1.0);\n  out.model = model;\n  return out;\n}\n\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4<f32> {\n  let p = in.model;\n  // AA feather: one device pixel in model units (fwidth of the model coord).\n  let aa = max(fwidth(p.x) + fwidth(p.y), 1e-5) * 0.75;\n\n  let trailWidth = u.r1.x;                // already in model units (packed CPU-side)\n  let peak = u.r1.y * u.r2.y;             // peakAlpha \u00B7 intensity\n  let headGlow = u.r1.z * u.r2.y;\n  let fadeExp = u.r1.w;\n  let trailFloor = u.r2.x;\n  let sampleCount = u.ints.x;\n  let armCount = u.ints.y;\n  let showEpicycles = u.r2.z > 0.5;\n  let rainbow = u.r2.w > 0.5;\n  let squashGain = u.r3.x;                 // FOURIER-LOOM \u00A72b\n  let celGain = u.r3.y;                    // FOURIER-LOOM \u00A73b\n  let halfW = trailWidth * 0.5;\n\n  // BD.W-FOURIER-LOOM \u00A72b \u2014 the head travel frame (the SAME curveSamples[0]/[1] both engines\n  // read \u2192 parity by construction). The cel offset (\u00A73b) rides \u2212T (opposite travel).\n  var headFr: HeadFrame;\n  headFr.T = vec2<f32>(1.0, 0.0);\n  headFr.sHat = 0.0;\n  if (sampleCount >= 2) {\n    headFr = headFrame(curveSamples[0].xy, curveSamples[1].xy, halfW);\n  }\n  let celOff = -headFr.T * halfW * 1.4;    // the ink lags behind the travel\n\n  var accum = vec4<f32>(0.0);              // premultiplied accumulation\n\n  // \u2500\u2500 \u00A73b \u2014 the cartoon CEL-SHADOW: a darker offset copy of the chain + rope, opposite\n  //    travel, painted FIRST (it sits UNDER the lit chain). PRM-static (the frozen-T travel\n  //    frame is a fixed offset, no live sweep). celGain = 0 \u2192 no pass (byte-frozen). \u2500\u2500\n  if (celGain > 0.001) {\n    let ink = vec3<f32>(0.0);              // pure ink \u2014 the technicolor 2-tone shadow\n    let celA = clamp(celGain, 0.0, 1.0);\n    // the rope cel (one offset distance-to-curve band).\n    for (var i = 0; i < MAX_CURVE_SAMPLES; i = i + 1) {\n      if (i >= sampleCount - 1) { break; }\n      let sa = curveSamples[i].xy + celOff;\n      let sb = curveSamples[i + 1].xy + celOff;\n      let d = segDist(p, sa, sb);\n      let cover = 1.0 - smoothstep(halfW, halfW + aa, d);\n      if (cover < 0.002) { continue; }\n      let m = cover * celA * peak;\n      accum = vec4<f32>(ink * m, m) + accum * (1.0 - m);\n    }\n    // the chain cel (arms only \u2014 the bold scaffold ink).\n    if (showEpicycles && armCount >= 1) {\n      for (var k = 0; k < MAX_PHASORS; k = k + 1) {\n        if (k >= armCount) { break; }\n        let a = chainTips[k].xy + celOff;\n        let b = chainTips[k + 1].xy + celOff;\n        let dArm = segDist(p, a, b);\n        let armMask = 1.0 - smoothstep(halfW * 0.55, halfW * 0.55 + aa, dArm);\n        let m = armMask * celA * peak * 0.7;\n        accum = vec4<f32>(ink * m, m) + accum * (1.0 - m);\n      }\n    }\n  }\n\n  // \u2500\u2500 Epicycle scaffolding (orbit rings + arms + joint dots) UNDER the curve \u2500\u2500\n  if (showEpicycles && armCount >= 1) {\n    for (var k = 0; k < MAX_PHASORS; k = k + 1) {\n      if (k >= armCount) { break; }\n      let a = chainTips[k].xy;\n      let b = chainTips[k + 1].xy;\n      let seg = f32(k) / max(f32(armCount - 1), 1.0);\n      let lin = chainColorLin(seg, rainbow);\n      // orbit RING around a (radius = arm length).\n      let radius = length(b - a);\n      let dRing = abs(length(p - a) - radius);\n      let ringW = max(halfW * 0.45, aa);\n      let ringMask = (1.0 - smoothstep(ringW, ringW + aa, dRing)) * 0.5;\n      // ARM segment a\u2192b.\n      let dArm = segDist(p, a, b);\n      let armMask = 1.0 - smoothstep(halfW * 0.55, halfW * 0.55 + aa, dArm);\n      // joint DOT at a.\n      let dotR = max(halfW * 0.7, aa * 2.0);\n      let dDot = length(p - a);\n      let dotMask = 1.0 - smoothstep(dotR, dotR + aa, dDot);\n      let m = clamp(max(max(ringMask, armMask), dotMask), 0.0, 1.0) * peak * 0.7;\n      let rgb = clamp(linearToSrgb(lin), vec3<f32>(0.0), vec3<f32>(1.0));\n      // over-composite (premultiplied).\n      accum = vec4<f32>(rgb * m, m) + accum * (1.0 - m);\n    }\n  }\n\n  // \u2500\u2500 The comet TRAIL \u2014 min-distance to the curve polyline, per-segment age fade \u2500\u2500\n  for (var i = 0; i < MAX_CURVE_SAMPLES; i = i + 1) {\n    if (i >= sampleCount - 1) { break; }\n    let sa = curveSamples[i];\n    let sb = curveSamples[i + 1];\n    let d = segDist(p, sa.xy, sb.xy);\n    let cover = 1.0 - smoothstep(halfW, halfW + aa, d);\n    if (cover < 0.002) { continue; }\n    let age = max(sa.z, sb.z);            // 1 at head, 0 at tail\n    var a = peak * pow(age, fadeExp);\n    a = max(a, peak * trailFloor);\n    a = a * cover;\n    let lin = samplePaletteLin(1.0 - age * 0.4); // warm core, lighter tail\n    let rgb = clamp(linearToSrgb(lin), vec3<f32>(0.0), vec3<f32>(1.0));\n    accum = vec4<f32>(rgb * a, a) + accum * (1.0 - a);\n  }\n\n  // \u2500\u2500 The comet HEAD \u2014 squash-and-stretch (\u00A72b) halo + saturated core + white specular.\n  //    dHead is the volume-preserving anisotropic distance off the travel frame; at rest\n  //    (sHat=0) or squashGain=0 it collapses to the round disc length(p \u2212 head). \u2500\u2500\n  if (sampleCount >= 1) {\n    let head = curveSamples[0].xy;\n    let dHead = headAniso(p, head, headFr, squashGain);\n    let coreR = halfW * 1.5;\n    let haloR = coreR * 3.0;\n    let headLin = samplePaletteLin(0.0);\n    let headRgb = clamp(linearToSrgb(headLin), vec3<f32>(0.0), vec3<f32>(1.0));\n    // soft halo\n    let halo = (1.0 - smoothstep(0.0, haloR, dHead)) * headGlow * 0.35;\n    accum = vec4<f32>(headRgb * halo, halo) + accum * (1.0 - halo);\n    // saturated core\n    let core = (1.0 - smoothstep(coreR, coreR + aa, dHead)) * headGlow;\n    accum = vec4<f32>(headRgb * core, core) + accum * (1.0 - core);\n    // white specular\n    let spec = (1.0 - smoothstep(coreR * 0.4, coreR * 0.4 + aa, dHead)) * headGlow * 0.9;\n    accum = vec4<f32>(vec3<f32>(1.0) * spec, spec) + accum * (1.0 - spec);\n  }\n\n  return accum;\n}\n";

package/dist/components/custom/goo-blob/GooBlob.vue.d.ts

@@ -1,4 +1,4 @@
-import type { BlobMood, BlobConfig } from "./types";
+import type { BlobMood, BlobConfig, BlobVariant } from "./types";
 /**
  * GooBlob — a gooey metaball creature on a WebGL2 canvas.
  *
@@ -30,6 +30,14 @@ type __VLS_Props = {
      * The metaball tuning. Pass `BLOB_CONFIG_DEFAULTS` for the stock look.
      */
     config?: BlobConfig;
+    /**
+     * BC.W-GOOBLOB-PLAIN — the render-variant axis. `"blob"` is the STAGE-1
+     * shadowless lightless fill-only floor; `"meatball"` (default) is the full lit
+     * register. When set it WINS the resolved config's `variant` (the per-instance
+     * override); unset, the config's own `variant` rules. STAGE 1's `uStage` gate
+     * strips the lit/shadow blocks for the `"blob"` register.
+     */
+    variant?: BlobVariant;
     /** Extra seed string mixed into the satellite PRNG for a unique-but-reproducible system. */
     seed?: string;
     /**

package/dist/components/custom/goo-blob/composables/easing.d.ts

@@ -4,3 +4,4 @@ export declare function easeInOut(t: number): number;
 export declare function easeIn(t: number): number;
 /** Quadratic ease-out (the satellite retract ramp). */
 export declare function easeOut(t: number): number;
+export declare function fissionSnap(t: number): number;

package/dist/components/custom/goo-blob/composables/useBlobSatellites.d.ts

@@ -9,6 +9,7 @@ export declare function useBlobSatellites(config: BlobConfig, initialColor: stri
     tick: (now: number, mood: MoodParams) => void;
     nudge: () => void;
     reseed: (color: string) => void;
+    onPinch: (cb: (impulse: number) => void) => void;
     isQuiescent: () => boolean;
     nextEventMs: (now: number) => number;
 };

package/dist/components/custom/goo-blob/constants.d.ts

@@ -53,5 +53,30 @@ export declare const BASE_OPACITY = 0.75;
 export declare const ORBIT_BLEND_MS = 2000;
 /** Minimum spacing (ms) between satellite merge events. */
 export declare const MERGE_STAGGER_MS = 3000;
-export declare const UNIFORM_NAMES: readonly ["uResolution", "uTime", "uBaseColor", "uPointer", "uPointerActive", "uPointerAttraction", "uPointerStrength", "uBodyRadius", "uPulsePhase", "uPulseAmp", "uNoiseAmp", "uNoiseFreq", "uNoiseSpeed", "uWarpAmp", "uSmoothK", "uMerge", "uMaxReach", "uLit", "uRimColor", "uLightDir", "uSpecStrength", "uSpecShininess", "uRimPower", "uRimStrength", "uIridescence", "uIridHue", "uIridSpeed", "uSssScale", "uSssPower", "uCoreGlow", "uHueRange", "uSatShift", "uBrightnessShift", "uColorNoiseFreq", "uColorNoiseSpeed", "uStopCount", "uSatCount", "uTrailCount", "uVelocity", "uStretch"];
+/**
+ * The bounded fission APEX (config-UV) — the orbit radius the fissioning satellite
+ * breathes OUT to at its excursion peak. Beyond the body skin (0.22) by a clean gap that
+ * exceeds the smin reach so the neck SNAPS; bounded so the single fissioner + apex rule
+ * re-prevents the "two unrelated discs" failure WITHOUT the blanket never-leaves-reach
+ * clamp. Paints at `FISSION_REACH_MAX · POS_SCALE` uv.
+ */
+export declare const FISSION_REACH_MAX = 0.4;
+/** The fission PERIAPSIS (config-UV) — the merged-in radius the satellite gathers to before the snap (well inside the body skin, fully bonded). */
+export declare const FISSION_REACH_MIN = 0.18;
+/**
+ * The full fission BEAT duration (ms) — the SLOW gather + FAST snap + re-merge window the
+ * `fissioning` phase runs for. Long enough that the colony reads as a steady-state
+ * merge↔split breath (perpetually mid-merge on one satellite while mid-split on another),
+ * NOT a rare twitch. The `fissionSnap` curve maps the beat's `t in [0,1]` to the reach.
+ */
+export declare const FISSION_BEAT_MS = 5200;
+/**
+ * The fission INTENSITY → cadence map. `fissionAmp` (0..1, config × mood) scales how
+ * OFTEN a satellite enters the fissioning beat vs the calm bonded breath: at amp 0 the
+ * fission probability is 0 (the calm default never splits); at amp 1 a satellite reaching
+ * its orbit-phase boundary enters `fissioning` with this probability instead of a plain
+ * merge. Mood-coupled (excited raises the effective amp, sleepy lowers it).
+ */
+export declare const FISSION_PROB_AT_FULL = 0.75;
+export declare const UNIFORM_NAMES: readonly ["uResolution", "uTime", "uBaseColor", "uPointer", "uPointerActive", "uPointerAttraction", "uPointerStrength", "uBodyRadius", "uPulsePhase", "uPulseAmp", "uNoiseAmp", "uNoiseFreq", "uNoiseSpeed", "uWarpAmp", "uSmoothK", "uMerge", "uStage", "uMorphT", "uMaxReach", "uLit", "uRimColor", "uLightDir", "uSpecStrength", "uSpecShininess", "uRimPower", "uRimStrength", "uShadow", "uShadowSoftness", "uIridescence", "uIridHue", "uIridSpeed", "uSssScale", "uSssPower", "uCoreGlow", "uHueRange", "uSatShift", "uBrightnessShift", "uColorNoiseFreq", "uColorNoiseSpeed", "uStopCount", "uSatCount", "uTrailCount", "uVelocity", "uStretch"];
 export type UniformName = (typeof UNIFORM_NAMES)[number];

package/dist/components/custom/goo-blob/index.d.ts

@@ -1,5 +1,5 @@
 export { default as GooBlob } from "./GooBlob.vue";
-export type { BlobMood, BlobMerge, BlobQuality, MoodParams, MetaballSource, BlobConfig, BlobGeometry, BlobSatelliteTiming, BlobMembrane, BlobColor, BlobSurface, BlobInteraction, SatellitePhase, SatelliteInternal, } from "./types";
+export type { BlobMood, BlobMerge, BlobVariant, BlobQuality, MoodParams, MetaballSource, BlobConfig, BlobGeometry, BlobSatelliteTiming, BlobMembrane, BlobColor, BlobSurface, BlobInteraction, SatellitePhase, SatelliteInternal, } from "./types";
 export { BLOB_CONFIG_DEFAULTS, BLOB_CONFIG_KEY } from "./types";
 export { useBlobMood, type BlobMoodSystem } from "./composables/useBlobMood";
 export { useBlobPointer, type BlobPointer } from "./composables/useBlobPointer";

package/dist/components/custom/goo-blob/shaders/metaball-noise.wgsl.d.ts

@@ -0,0 +1 @@
+export declare const METABALL_NOISE_WGSL = "\nconst FBM_LACUNARITY: f32 = 1.8;\nconst FBM_GAIN: f32 = 0.42;\n\n// \u2500\u2500 Noise (blob-LOCAL 3D-p3 hash + IQ analytic-derivative gradient noise) \u2500\u2500\nfn hash21(p: vec2<f32>) -> f32 {\n  var p3 = fract(vec3<f32>(p.x, p.y, p.x) * 0.1031);\n  p3 = p3 + dot(p3, p3.yzx + 33.33);\n  return fract((p3.x + p3.y) * p3.z);\n}\n\n// IQ analytic-derivative gradient noise \u2014 value in .x, ANALYTIC gradient (d/dx, d/dy) in\n// .yz, from one eval. The quintic fade has a continuous 2nd derivative.\nfn noised(p: vec2<f32>) -> vec3<f32> {\n  let i = floor(p);\n  let f = fract(p);\n  let uu = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);\n  let du = 30.0 * f * f * (f * (f - 2.0) + 1.0);\n\n  let ga = -1.0 + 2.0 * vec2<f32>(hash21(i + vec2<f32>(0.0, 0.0)), hash21(i + vec2<f32>(7.3, 0.0)));\n  let gb = -1.0 + 2.0 * vec2<f32>(hash21(i + vec2<f32>(1.0, 0.0)), hash21(i + vec2<f32>(8.3, 0.0)));\n  let gc = -1.0 + 2.0 * vec2<f32>(hash21(i + vec2<f32>(0.0, 1.0)), hash21(i + vec2<f32>(7.3, 1.0)));\n  let gd = -1.0 + 2.0 * vec2<f32>(hash21(i + vec2<f32>(1.0, 1.0)), hash21(i + vec2<f32>(8.3, 1.0)));\n\n  let va = dot(ga, f - vec2<f32>(0.0, 0.0));\n  let vb = dot(gb, f - vec2<f32>(1.0, 0.0));\n  let vc = dot(gc, f - vec2<f32>(0.0, 1.0));\n  let vd = dot(gd, f - vec2<f32>(1.0, 1.0));\n\n  let n = va + uu.x * (vb - va) + uu.y * (vc - va) + uu.x * uu.y * (va - vb - vc + vd);\n  let value = 0.5 + 0.5 * n;\n\n  let grad =\n    ga + uu.x * (gb - ga) + uu.y * (gc - ga) + uu.x * uu.y * (ga - gb - gc + gd) +\n    du * (vec2<f32>(uu.y, uu.x) * (va - vb - vc + vd) + vec2<f32>(vb, vc) - va);\n  return vec3<f32>(value, 0.5 * grad);\n}\n\nfn fbm(p0: vec2<f32>, octaves: i32) -> f32 {\n  var value = 0.0;\n  var amp = 0.5;\n  var freq = 1.0;\n  var p = p0;\n  for (var i = 0; i < 4; i = i + 1) {\n    if (i >= octaves) { break; }\n    value = value + amp * noised(p * freq).x;\n    p = FBM_ROT * p;\n    freq = freq * FBM_LACUNARITY;\n    amp = amp * FBM_GAIN;\n  }\n  return value;\n}\n\n// FBM with ANALYTIC GRADIENT \u2014 value in .x, \u2202/\u2202x, \u2202/\u2202y in .yz. The gradient accumulates\n// noised()'s analytic gradient per octave, chain-ruled through the per-octave frequency\n// scale AND the FBM_ROT rotation (the keystone feed for the analytic surface normal).\nfn fbmG(p: vec2<f32>, octaves: i32) -> vec3<f32> {\n  var value = 0.0;\n  var grad = vec2<f32>(0.0, 0.0);\n  var amp = 0.5;\n  var freq = 1.0;\n  var rotAccum = mat2x2<f32>(1.0, 0.0, 0.0, 1.0);\n  var pp = p;\n  for (var i = 0; i < 4; i = i + 1) {\n    if (i >= octaves) { break; }\n    let n = noised(pp * freq);\n    value = value + amp * n.x;\n    grad = grad + amp * freq * (transpose(rotAccum) * n.yz);\n    pp = FBM_ROT * pp;\n    freq = freq * FBM_LACUNARITY;\n    amp = amp * FBM_GAIN;\n    rotAccum = FBM_ROT * rotAccum;\n  }\n  return vec3<f32>(value, grad);\n}\n\n// One domain-warp pass with the ANALYTIC GRADIENT carried (warp-Jacobian approximation).\nfn fbmWarpedG(p: vec2<f32>, octaves: i32, warpAmp: f32) -> vec3<f32> {\n  if (warpAmp <= 0.0) { return fbmG(p, octaves); }\n  let q = vec2<f32>(fbm(p + vec2<f32>(0.0, 0.0), octaves),\n                    fbm(p + vec2<f32>(5.2, 1.3), octaves));\n  return fbmG(p + warpAmp * (q - 0.5), octaves);\n}\n";

package/dist/components/custom/goo-blob/shaders/metaball-palette.wgsl.d.ts

@@ -0,0 +1 @@
+export declare const METABALL_PALETTE_WGSL = "\n// \u2500\u2500 OKLCh gamut clamp (hue-preserving inward chroma clamp \u2014 blob-local) \u2500\u2500\nfn inGamut(lin: vec3<f32>) -> bool {\n  return all(lin >= vec3<f32>(0.0)) && all(lin <= vec3<f32>(1.0));\n}\nfn gamutClampOklch(lch: vec3<f32>) -> vec3<f32> {\n  let lin = oklabToLinearSrgb(oklchToOklab(lch));\n  if (inGamut(lin)) { return lch; }\n  var lo = 0.0;\n  var hi = lch.y;\n  for (var i = 0; i < 16; i = i + 1) {\n    let mid = 0.5 * (lo + hi);\n    let test = vec3<f32>(lch.x, mid, lch.z);\n    if (inGamut(oklabToLinearSrgb(oklchToOklab(test)))) { lo = mid; } else { hi = mid; }\n  }\n  return vec3<f32>(lch.x, lo, lch.z);\n}\n\n// W11.b \u2014 sample the multi-stop palette at t, OKLab mix + midpoint chroma-bump. Returns\n// an OKLCh stop [L, C, h(rad)]. Falls back to uBaseColor when uStopCount <= 1.\nfn samplePaletteOklch(t: f32) -> vec3<f32> {\n  let uStopCount = u.ints.x;\n  if (uStopCount <= 1) { return oklabToOklch(srgbToOklab(u.base.rgb)); }\n  let n = f32(uStopCount);\n  let ft = clamp(t, 0.0, 1.0) * (n - 1.0);\n  let i0 = i32(floor(ft));\n  let i1 = min(i0 + 1, uStopCount - 1);\n  let f = ft - f32(i0);\n  let labA = srgbToOklab(u.palette[i0].rgb);\n  let labB = srgbToOklab(u.palette[i1].rgb);\n  let lab = mix(labA, labB, f);\n  var lch = oklabToOklch(lab);\n  lch.y = lch.y + 0.03 * sin(PI * f);\n  return lch;\n}\n\n// AX.W15 \u2014 de-synced breath (three DETUNED sines at irrational ratios).\nfn breath(phase: f32) -> f32 {\n  return (sin(phase) + 0.5 * sin(phase * 1.4444 + 1.7) + 0.28 * sin(phase * 0.31 + 4.1)) / 1.78;\n}\n";

package/dist/components/custom/goo-blob/shaders/metaball-uniforms.glsl.d.ts

@@ -1 +1 @@
-export declare const METABALL_UNIFORMS_GLSL = "#version 300 es\nprecision highp float;\n\nin vec2 vUv;\nout vec4 fragColor;\n\nuniform vec2 uResolution;\nuniform float uTime;\nuniform vec3 uBaseColor;\n\n// Multi-stop palette (W11.b) \u2014 2-4 in-family OKLCh stops (uploaded GAMMA sRGB, like\n// uBaseColor). uStopCount <= 1 falls back to uBaseColor (the single-color default,\n// zero regression). MAX_BLOB_STOPS is a compile-time #define.\n#define MAX_BLOB_STOPS 4\nuniform int uStopCount;\nuniform vec3 uPalette[MAX_BLOB_STOPS];\n\n// Pointer\nuniform vec2 uPointer;\nuniform float uPointerActive;\nuniform float uPointerAttraction;\nuniform float uPointerStrength;\n\n// Main body\nuniform float uBodyRadius;\n\n// Pulsation\nuniform float uPulsePhase;\nuniform float uPulseAmp;\n\n// Surface noise\nuniform float uNoiseAmp;\nuniform float uNoiseFreq;\nuniform float uNoiseSpeed;\n\n// Gooey\nuniform float uSmoothK;\nuniform float uMerge;   // 0 = quadratic smin, 1 = circular smin (rounder menisci)\n\n// AX.W16 (arm 5) \u2014 the PRE-FBM bounding-discard radius (UV space). main() early-outs\n// to a transparent write for any fragment OUTSIDE this radius BEFORE the two 3-octave\n// FBM calls + the OKLCh round-trip. The renderer uploads it PADDED by every\n// outward-expanding term (body + eccentric orbit + sat radius + smin band + FBM edge\n// amplitude + click-pulse + a lean/squash safety pad) so it NEVER clips the wet\n// meniscus (IQ: inflate the bound to match any outward op).\nuniform float uMaxReach;\n\n// Membrane \u2014 domain-warp strength on the FBM edge displacement (0 = plain fbm).\nuniform float uWarpAmp;\n\n// Lit glass surface (W9.b) \u2014 gated behind uLit so the flat fill stays default.\nuniform float uLit;             // 0 = flat fill (default), 1 = lit droplet\nuniform vec3 uRimColor;         // Fresnel rim tint (GAMMA sRGB, via the /color leaf)\nuniform vec3 uLightDir;         // normalized light direction (x, y, z)\nuniform float uSpecStrength;    // Blinn-Phong specular weight\nuniform float uSpecShininess;   // specular exponent (16-64, tight glint)\nuniform float uRimPower;        // Fresnel/Schlick exponent (~2-3)\nuniform float uRimStrength;     // Fresnel rim weight\n\n// Iridescence + fake subsurface (W11.a) \u2014 translucent-gel read.\nuniform float uIridescence;     // warm-pearl rim sheen weight (0 = off)\nuniform float uIridHue;         // base hue (radians) the cosine palette biases toward (warm)\nuniform float uIridSpeed;       // animated-thickness scroll for the iridescent t\nuniform float uSssScale;        // fast-SSS back-light weight\nuniform float uSssPower;        // fast-SSS exponent\nuniform float uCoreGlow;        // thickness-driven inner-luminosity lift\n\n// Color perturbation (perceptually uniform \u2014 OKLCh L/C/h)\nuniform float uHueRange;        // degrees of hue swing (converted to radians)\nuniform float uSatShift;        // OKLCh chroma swing\nuniform float uBrightnessShift; // OKLCh lightness bias\nuniform float uColorNoiseFreq;\nuniform float uColorNoiseSpeed;\n\n// Satellites (max 4)\n#define MAX_SATS 4\nuniform int uSatCount;\nuniform vec2 uSatPos[MAX_SATS];\nuniform float uSatRadius[MAX_SATS];\nuniform float uSatOpacity[MAX_SATS];\n\n// Pointer trail (W10) \u2014 a decaying-radius pseudopod toward the cursor. uTrail is a\n// COMPILE-TIME-SIZED array (GLSL ES 3.00 forbids a uniform-sized array) with a\n// DYNAMIC break on uTrailCount, mirroring the satellite loop. Later samples paint\n// smaller metaballs (r *= 1 - i/N) so the trail tapers into a tail.\n#define TRAIL_N 15\nuniform int uTrailCount;\nuniform vec2 uTrailPos[TRAIL_N];\nuniform float uTrailRadius[TRAIL_N];\n\n// Velocity-driven volume-preserving squash-and-stretch (W10).\nuniform vec2 uVelocity;   // smoothed pointer velocity (motion direction + speed)\nuniform float uStretch;   // squash-stretch magnitude (0 = off)\n\nconst float PI = 3.141592653589793;\n";
+export declare const METABALL_UNIFORMS_GLSL = "#version 300 es\nprecision highp float;\n\nin vec2 vUv;\nout vec4 fragColor;\n\nuniform vec2 uResolution;\nuniform float uTime;\nuniform vec3 uBaseColor;\n\n// Multi-stop palette (W11.b) \u2014 2-4 in-family OKLCh stops (uploaded GAMMA sRGB, like\n// uBaseColor). uStopCount <= 1 falls back to uBaseColor (the single-color default,\n// zero regression). MAX_BLOB_STOPS is a compile-time #define.\n#define MAX_BLOB_STOPS 4\nuniform int uStopCount;\nuniform vec3 uPalette[MAX_BLOB_STOPS];\n\n// Pointer\nuniform vec2 uPointer;\nuniform float uPointerActive;\nuniform float uPointerAttraction;\nuniform float uPointerStrength;\n\n// Main body\nuniform float uBodyRadius;\n\n// Pulsation\nuniform float uPulsePhase;\nuniform float uPulseAmp;\n\n// Surface noise\nuniform float uNoiseAmp;\nuniform float uNoiseFreq;\nuniform float uNoiseSpeed;\n\n// Gooey\nuniform float uSmoothK;\nuniform float uMerge;   // 0 = quadratic smin, 1 = circular smin (rounder menisci)\n\n// BC.W-GOOBLOB-PLAIN \u2014 the STAGE-1 gate. 1.0 = the plain shadowless lightless\n// fill-only floor (variant=\"blob\"); 0.0 = the full lit pipeline (variant=\"meatball\" /\n// STAGE 2). The WebGL2 fallback transcribes the SAME stripped branch the WGSL primary\n// gates (research/viz/goo-blob.md \u00A75 \u2014 the GLSL twin).\n// BD.W-GOO-CAROUSEL-DECK \u2014 uStage is now DERIVED from uMorphT (uStage = uMorphT<=0 ?\n// 1 : 0) at upload; the SHADING morph (below) reads uMorphT directly.\nuniform float uStage;\n\n// BD.W-GOO-CAROUSEL-DECK \u2014 the blob to meatball SHADING-MORPH scalar. 0.0 = the flat blob\n// fill (byte-identical to the STAGE-1 floor), 1.0 = the fully-dressed lit meatball; the\n// in-between LERPS the surface shading (NOT the geometry \u2014 the smin field is shared). The\n// renderer resolves it from config.morphT (variant to endpoint back-compat: blob to 0,\n// meatball to 1). A consumer ANIMATING morphT 0 to 1 gets the live morph.\nuniform float uMorphT;\n\n// AX.W16 (arm 5) \u2014 the PRE-FBM bounding-discard radius (UV space). main() early-outs\n// to a transparent write for any fragment OUTSIDE this radius BEFORE the two 3-octave\n// FBM calls + the OKLCh round-trip. The renderer uploads it PADDED by every\n// outward-expanding term (body + eccentric orbit + sat radius + smin band + FBM edge\n// amplitude + click-pulse + a lean/squash safety pad) so it NEVER clips the wet\n// meniscus (IQ: inflate the bound to match any outward op).\nuniform float uMaxReach;\n\n// Membrane \u2014 domain-warp strength on the FBM edge displacement (0 = plain fbm).\nuniform float uWarpAmp;\n\n// Lit glass surface (W9.b) \u2014 gated behind uLit so the flat fill stays default.\nuniform float uLit;             // 0 = flat fill (default), 1 = lit droplet\nuniform vec3 uRimColor;         // Fresnel rim tint (GAMMA sRGB, via the /color leaf)\nuniform vec3 uLightDir;         // normalized light direction (x, y, z)\nuniform float uSpecStrength;    // Blinn-Phong specular weight\nuniform float uSpecShininess;   // specular exponent (16-64, tight glint)\nuniform float uRimPower;        // Fresnel/Schlick exponent (~2-3)\nuniform float uRimStrength;     // Fresnel rim weight\n\n// BC.W-GOOBLOB-MEATBALL \u2014 the procedural 2D SDF soft-shadow march (T2, the GLSL twin of\n// the WGSL res.z/res.w lanes). uShadow gates the IQ rmshadows soft contact shadow that\n// FOLLOWS the irregular silhouette; uShadowSoftness is the penumbra hardness (4-48).\nuniform float uShadow;          // 0 = no shadow, 1 = the soft contact shadow ON\nuniform float uShadowSoftness;  // penumbra hardness (inverse light-source size, 4-48)\n\n// Iridescence + fake subsurface (W11.a) \u2014 translucent-gel read.\nuniform float uIridescence;     // warm-pearl rim sheen weight (0 = off)\nuniform float uIridHue;         // base hue (radians) the cosine palette biases toward (warm)\nuniform float uIridSpeed;       // animated-thickness scroll for the iridescent t\nuniform float uSssScale;        // fast-SSS back-light weight\nuniform float uSssPower;        // fast-SSS exponent\nuniform float uCoreGlow;        // thickness-driven inner-luminosity lift\n\n// Color perturbation (perceptually uniform \u2014 OKLCh L/C/h)\nuniform float uHueRange;        // degrees of hue swing (converted to radians)\nuniform float uSatShift;        // OKLCh chroma swing\nuniform float uBrightnessShift; // OKLCh lightness bias\nuniform float uColorNoiseFreq;\nuniform float uColorNoiseSpeed;\n\n// Satellites (max 4)\n#define MAX_SATS 4\nuniform int uSatCount;\nuniform vec2 uSatPos[MAX_SATS];\nuniform float uSatRadius[MAX_SATS];\nuniform float uSatOpacity[MAX_SATS];\n\n// Pointer trail (W10) \u2014 a decaying-radius pseudopod toward the cursor. uTrail is a\n// COMPILE-TIME-SIZED array (GLSL ES 3.00 forbids a uniform-sized array) with a\n// DYNAMIC break on uTrailCount, mirroring the satellite loop. Later samples paint\n// smaller metaballs (r *= 1 - i/N) so the trail tapers into a tail.\n#define TRAIL_N 15\nuniform int uTrailCount;\nuniform vec2 uTrailPos[TRAIL_N];\nuniform float uTrailRadius[TRAIL_N];\n\n// Velocity-driven volume-preserving squash-and-stretch (W10).\nuniform vec2 uVelocity;   // smoothed pointer velocity (motion direction + speed)\nuniform float uStretch;   // squash-stretch magnitude (0 = off)\n\nconst float PI = 3.141592653589793;\n";