@dopaminefx/effect-aurora 0.1.0

package/src/aurora-shader.ts

@@ -0,0 +1,287 @@
+/**
+ * GLSL ES 3.00 source for **Aurora** — a calm success / ambient effect, and a
+ * deliberate DIVERGENCE from Solarbloom's centered radial bloom and Verdict's
+ * single directional stroke.
+ *
+ * Governing metaphor: HANGING CURTAINS OF POLAR LIGHT (aurora borealis). The
+ * composition is a horizontal BAND of vertical light RIBBONS that drape across
+ * the upper field, sway, and sweep sideways, then gently brighten and fade. It
+ * is DIRECTIONAL/curtain — emphatically NOT a radial bloom: there is no bright
+ * core, no concentric falloff. The light reads as sheets hanging from an unseen
+ * line near the top of the frame, feathering downward into nothing.
+ *
+ * Layers, summed as light (canvas is black, composited `mix-blend-mode: screen`,
+ * so black == no change, bright == cast light onto the page beneath):
+ *   1. SKY WASH — a very faint cool gradient hugging the top of the band, so the
+ *      curtains hang from a soft glow rather than empty black.
+ *   2. THE CURTAINS — several vertical ribbons. Each ribbon's horizontal centre
+ *      is displaced by layered fbm (slow, nature-informed drift) plus a global
+ *      sideways SWEEP; coverage is a soft horizontal lobe. Vertical STRIATIONS
+ *      (fine fluting) ride each ribbon. Brightness peaks high in the band and
+ *      feathers toward the bottom edge (the draped hem).
+ *   3. RAYS — faint brighter vertical streaks inside the curtains (the classic
+ *      "searchlight" pillars), modulated by a second noise so they twinkle.
+ *   4. CROWN SHIMMER — a slow hue/intensity breathing across the whole band as
+ *      it settles, so the colour wanders the way a real aurora pulses.
+ *
+ * Reward timing lives in uniforms (uAmp = envelope amplitude, brighten→fade;
+ * uLife = whole-effect progress; uSweep = accumulated sideways drift). Pure
+ * function of uTimeS — frame-perfect & cheap under SwiftShader (analytic noise,
+ * single pass, no loops over large counts).
+ *
+ * whimsy == uStyle: 0 = photoreal soft VOLUMETRIC curtains (smooth gradients,
+ *   feathered hems, dithered); 1 = stylized HARD CEL bands — posterized ribbons
+ *   with crisp edges + a bright rim, the drift snapped (the pass runner already
+ *   animates the clock "on twos" as style rises).
+ */
+
+import {
+  GLSL_CONSTANTS,
+  GLSL_DITHER,
+  GLSL_FBM,
+  GLSL_HASH,
+  GLSL_PALETTE_MIX,
+  GLSL_TONEMAP_ACES,
+} from "@dopaminefx/core";
+
+/**
+ * Number of curtain ribbons. Single source of truth: BOTH the GLSL
+ * `#define CURTAINS` (interpolated below) and the integer-clamp const the
+ * `.dope` mapping references (passed to the loader as `MAX_CURTAINS`).
+ */
+export const MAX_CURTAINS = 7;
+
+export const AURORA_VERTEX_SRC = /* glsl */ `#version 300 es
+void main() {
+  vec2 pos = vec2(float((gl_VertexID << 1) & 2), float(gl_VertexID & 2));
+  gl_Position = vec4(pos * 2.0 - 1.0, 0.0, 1.0);
+}`;
+
+export const AURORA_FRAGMENT_SRC = /* glsl */ `#version 300 es
+precision highp float;
+out vec4 fragColor;
+
+uniform vec2  uResolution;   // device pixels
+uniform float uLife;         // whole-effect progress 0..1
+uniform float uTimeS;        // elapsed seconds
+uniform float uAmp;          // envelope amplitude (brighten -> fade; peaks > 1)
+uniform float uExposure;     // overall light gain
+uniform float uCoverage;     // 0..1 band height + ribbon count fraction (intensity)
+uniform float uBandY;        // band vertical centre as fraction of height (0=bottom,1=top)
+uniform float uBandHeight;   // band half-height as fraction of height
+uniform float uSway;         // horizontal drift amplitude (fraction of width)
+uniform float uSweep;        // global sideways sweep offset (fraction of width)
+uniform float uStriation;    // 0..1 vertical fluting strength
+uniform float uRays;         // 0..1 searchlight-pillar strength
+uniform float uSeed;         // per-fire hash offset
+uniform float uStyle;        // 0..1 photoreal volumetric -> cel posterized (whimsy)
+uniform float uShadow;       // 0 = light pass (screen), 1 = shadow pass (multiply)
+uniform vec2  uShadowOffset; // device-px offset of the cast silhouette (away from light)
+uniform float uShadowSoft;   // penumbra softness in device px (blur tap radius)
+uniform float uShadowStrength;// 0..1 max darkening of the multiply layer
+uniform vec3  uC0;           // curtain core color
+uniform vec3  uC1;           // mid
+uniform vec3  uC2;           // crown / accent
+
+#define CURTAINS ${MAX_CURTAINS}
+${GLSL_CONSTANTS}
+${GLSL_HASH}
+${GLSL_FBM}
+${GLSL_PALETTE_MIX}
+${GLSL_TONEMAP_ACES}
+${GLSL_DITHER}
+
+// Vertical envelope of the curtain band: bright high in the band, feathering to
+// nothing at the draped hem below and to a soft top above. ny is the normalized
+// vertical position WITHIN the band (0 = hem/bottom, 1 = top), so the curtains
+// hang from the top and fade downward like real sheets of light.
+float bandProfile(float ny){
+  // Feather the bottom hem (long, soft) and the top (soft, generous) so the
+  // curtain reads as a hanging SHEET — no hard edges top or bottom.
+  float hem = smoothstep(0.0, 0.45, ny);          // long fade up from the hem
+  float top = 1.0 - smoothstep(0.7, 1.0, ny);      // soft, early top falloff
+  // Bias brightness upward (the top of a curtain glows hardest).
+  float bias = mix(0.6, 1.0, smoothstep(0.1, 0.85, ny));
+  return clamp(hem * top * bias, 0.0, 1.0);
+}
+
+// One curtain ribbon's coverage at horizontal position x (fraction 0..1) for a
+// given band-vertical ny. Each ribbon has its OWN base x, sway phase and width;
+// its centre is displaced by slow layered fbm (the living drift) + the global
+// sweep, and is bowed slightly with height so the sheet drapes rather than
+// standing dead-vertical. Returns 0..1 soft horizontal coverage.
+float curtain(int i, float x, float ny, out float along){
+  float fi = float(i);
+  vec2 h = hash21(fi * 3.17 + uSeed);
+  // Base horizontal slot, spread across the frame with a little jitter.
+  float base = (fi + 0.5) / float(CURTAINS) + (h.x - 0.5) * 0.10;
+  // Slow nature-informed drift: two fbm samples at different rates, scrolled by
+  // time, so the ribbon wanders organically rather than oscillating mechanically.
+  float n1 = fbm(vec2(fi * 1.7 + uSeed, ny * 1.3 + uTimeS * 0.13)) - 0.5;
+  float n2 = fbm(vec2(fi * 0.9 + uSeed + 7.0, ny * 2.6 - uTimeS * 0.07)) - 0.5;
+  float drift = (n1 * 0.7 + n2 * 0.3) * uSway;
+  // Drape bow: the hem swings further than the top (parallax of a hanging sheet).
+  float bow = (h.y - 0.5) * uSway * 0.6 * (1.0 - ny);
+  float cx = base + drift + bow + uSweep;
+  along = x - cx;
+  // Ribbon width breathes a touch per-ribbon; soft horizontal lobe.
+  float w = mix(0.045, 0.085, h.y) * (0.85 + 0.3 * uCoverage);
+  float cov = exp(-pow(along / w, 2.0));
+  return cov;
+}
+
+// The full curtain field at fragment uv (0..1, y up): sum the ribbons (capped by
+// coverage so low intensity shows fewer sheets), shaped vertically by the band
+// profile, with vertical striations + searchlight rays riding the light. Outputs
+// total coverage 'cov' and a 0..1 hue coordinate 'hue' (left->right across the
+// band, wandering with the crown shimmer) for the palette.
+float auroraField(vec2 uv, out float cov, out float hue){
+  // Vertical position within the band.
+  float top = uBandY + uBandHeight;
+  float bot = uBandY - uBandHeight;
+  float ny = (uv.y - bot) / max(top - bot, 1e-3);     // 0 at hem, 1 at top
+  float vprof = bandProfile(ny);
+  cov = 0.0;
+  hue = 0.0;
+  if (vprof <= 0.0) return 0.0;
+
+  // How many ribbons are "lit" scales with coverage (intensity): low intensity
+  // shows a few calm sheets, high shows the full curtain.
+  float lit = mix(2.5, float(CURTAINS), clamp(uCoverage, 0.0, 1.0));
+
+  float total = 0.0;
+  float hueAccum = 0.0;
+  for (int i = 0; i < CURTAINS; i++) {
+    float gate = clamp(lit - float(i), 0.0, 1.0);       // soft last-ribbon fade-in
+    if (gate <= 0.0) break;
+    float along;
+    float c = curtain(i, uv.x, ny, along) * gate;
+    if (c <= 0.001) continue;
+    total += c;
+    // Hue coordinate: ribbon's place across the band, nudged by its own offset.
+    float hi = (float(i) + 0.5) / float(CURTAINS);
+    hueAccum += c * hi;
+  }
+  cov = total * vprof;
+  hue = total > 1e-3 ? hueAccum / total : 0.5;
+
+  // Vertical STRIATIONS: fine fluting along the curtains (the characteristic
+  // ribbon texture). A medium-frequency noise in x that gently darkens/brightens
+  // narrow vertical lanes, only inside the lit region so the background stays
+  // clean. Kept bounded so it textures the sheet without shredding its edge.
+  float flute = fbm(vec2(uv.x * 55.0 + uSeed, uv.y * 4.0 - uTimeS * 0.2));
+  float striate = 1.0 + uStriation * (flute - 0.5) * 0.7;
+  cov *= striate;
+
+  // SEARCHLIGHT RAYS: a few brighter vertical pillars that twinkle — soft, fairly
+  // wide bands in x gated by a slow noise so they come and go. Scaled by the
+  // existing coverage so rays live INSIDE the curtains, never as bare spikes.
+  float rayBand = pow(max(0.0, sin(uv.x * 60.0 + fbm(vec2(uv.x * 5.0, uTimeS * 0.3)) * 5.0)), 3.0);
+  float rayGate = smoothstep(0.5, 0.95, fbm(vec2(uv.x * 9.0 + uSeed, uTimeS * 0.25)));
+  cov += rayBand * rayGate * uRays * smoothstep(0.05, 0.5, cov) * 0.5;
+
+  return cov;
+}
+
+// SHADOW silhouette — a cheap occlusion field for the curtain mass (no striation
+// detail / rays), so the faint cast shadow tracks the hanging sheets without an
+// extra heavy pass under software WebGL.
+float auroraOcclusion(vec2 frag){
+  vec2 uv = frag / uResolution;
+  float top = uBandY + uBandHeight;
+  float bot = uBandY - uBandHeight;
+  float ny = (uv.y - bot) / max(top - bot, 1e-3);
+  float vprof = bandProfile(ny);
+  if (vprof <= 0.0) return 0.0;
+  float lit = mix(2.5, float(CURTAINS), clamp(uCoverage, 0.0, 1.0));
+  float total = 0.0;
+  for (int i = 0; i < CURTAINS; i++) {
+    float gate = clamp(lit - float(i), 0.0, 1.0);
+    if (gate <= 0.0) break;
+    float along;
+    total += curtain(i, uv.x, ny, along) * gate;
+  }
+  return clamp(total * vprof * uAmp, 0.0, 1.0);
+}
+
+vec4 auroraShadowColor(vec2 frag){
+  vec2 sp = frag - uShadowOffset;
+  float occ = auroraOcclusion(sp);
+  float soft = uShadowSoft;
+  occ += auroraOcclusion(sp + vec2( soft, 0.0));
+  occ += auroraOcclusion(sp + vec2(-soft, 0.0));
+  occ += auroraOcclusion(sp + vec2(0.0,  soft));
+  occ += auroraOcclusion(sp + vec2(0.0, -soft));
+  occ /= 5.0;
+  // A real aurora casts almost no shadow; keep it very faint.
+  float dark = clamp(occ, 0.0, 1.0) * uShadowStrength * 0.35;
+  vec3 tint = mix(vec3(1.0), 0.6 + 0.4 * normalize(uC0 + 1e-3), 0.2);
+  vec3 mul = mix(vec3(1.0), tint, dark);
+  return vec4(mul, 1.0);
+}
+
+void main(){
+  vec2 frag = gl_FragCoord.xy;
+  vec2 res = uResolution;
+
+  if (uShadow > 0.5) {
+    fragColor = auroraShadowColor(frag);
+    return;
+  }
+
+  vec2 uv = frag / res;
+  vec3 col = vec3(0.0);
+  float gain = uAmp * uExposure;
+
+  // ---- SKY WASH: a faint cool glow the curtains hang from. ----
+  // A soft horizontal band centred near the top of the curtain band, so there is
+  // a gentle ground for the light without a radial core.
+  float washY = exp(-pow((uv.y - (uBandY + uBandHeight * 0.45)) / max(uBandHeight, 1e-3), 2.0));
+  col += mix(uC0, uC2, 0.5) * washY * 0.06 * gain;
+
+  // ---- THE CURTAINS ----
+  float cov, hue;
+  auroraField(uv, cov, hue);
+
+  // CROWN SHIMMER: the aurora pulses — a slow drift of the hue coordinate and a
+  // gentle global breathing of intensity, so the colour wanders as it settles.
+  float pulse = 0.85 + 0.15 * sin(uTimeS * 0.9 + hue * 4.0 + uSeed);
+  float hueShift = hue + 0.15 * sin(uTimeS * 0.4 + uSeed * 6.28) + 0.1 * (fbm(vec2(uv.x * 3.0, uTimeS * 0.2)) - 0.5);
+
+  vec3 curtainCol = paletteMix(clamp(hueShift, 0.0, 1.0));
+  col += curtainCol * clamp(cov, 0.0, 4.0) * pulse * gain;
+
+  // A subtle brighter crown along the very top edge of each lit column (where a
+  // real curtain glows hottest), tinted toward the accent.
+  float crown = smoothstep(0.0, 0.5, cov) * smoothstep(uBandY + uBandHeight * 0.2, uBandY + uBandHeight, uv.y);
+  col += uC2 * crown * 0.4 * gain;
+
+  // ---- Tone + finishing (ACES filmic, shared look/glsl) ----
+  col = tonemapACES(col * 0.9);
+
+  // ---- Non-photoreal pass: hard CEL posterized ribbons (whimsy) ----
+  // Toward the cel end the soft volumetric curtains snap into flat posterized
+  // bands with crisp edges + a bright rim — a stylized stained-glass aurora.
+  if (uStyle > 0.001) {
+    // Posterize the curtain luminance into a few hard tones (don't quantize the
+    // dark background — that shatters the wash into camouflage blocks).
+    float lum = clamp(cov * pulse * uExposure * uAmp, 0.0, 1.5);
+    float steps = mix(6.0, 3.0, uStyle);              // fewer bands at full cel
+    float q = floor(lum * steps) / steps;
+    vec3 celCol = paletteMix(clamp(hueShift, 0.0, 1.0)) * (q * 1.15 + 0.05);
+    // Bright crisp rim at each posterized step edge.
+    float band = lum * steps;
+    float edge = abs(fract(band) - 0.5);
+    float rim = (1.0 - smoothstep(0.0, 0.12, edge)) * smoothstep(0.06, 0.2, lum);
+    celCol += clamp(uC2 * 1.5 + 0.1, 0.0, 1.4) * rim * 0.6;
+    float mask = smoothstep(0.04, 0.14, lum);          // only inside the curtains
+    vec3 styled = mix(col, celCol, mask);
+    col = mix(col, styled, uStyle);
+  }
+
+  // Ordered dither (~1/255, shared look/glsl) to kill banding the screen blend
+  // would reveal on the page beneath; faded out toward the cel end.
+  col = ditherAdd(col, frag, uTimeS, 1.0 - uStyle);
+
+  fragColor = vec4(max(col, 0.0), 1.0);
+}`;

package/src/aurora.dope.json

@@ -0,0 +1,417 @@
+{
+  "fmt": "dopamine-effect",
+  "v": "1.0.0",
+  "id": "dopamine.success.aurora",
+  "meta": {
+    "name": "Aurora",
+    "description": "Hanging curtains of polar light that drape across the upper field, sway and sweep, then gently brighten and fade.",
+    "tags": [
+      "success",
+      "ambient",
+      "aurora",
+      "directional",
+      "curtain"
+    ]
+  },
+  "controls": {
+    "mood": {
+      "type": "enum",
+      "label": "Mood",
+      "default": "serene",
+      "options": [
+        "serene",
+        "celebratory",
+        "electric"
+      ],
+      "ui": "segmented"
+    },
+    "intensity": {
+      "type": "scalar",
+      "label": "Intensity",
+      "default": 0.7,
+      "min": 0,
+      "max": 1,
+      "step": 0.01,
+      "ui": "slider",
+      "help": "Brightness, curtain coverage and band height."
+    },
+    "whimsy": {
+      "type": "scalar",
+      "label": "Whimsy",
+      "default": 0.4,
+      "min": 0,
+      "max": 1,
+      "step": 0.01,
+      "ui": "slider",
+      "help": "Photoreal soft volumetric curtains (0) to stylized hard cel / posterized ribbons (1)."
+    },
+    "seed": {
+      "type": "int",
+      "label": "Seed",
+      "default": null,
+      "nullable": true,
+      "help": "Null = unique palette per fire; pin to reproduce."
+    },
+    "target": {
+      "type": "selector",
+      "label": "Target",
+      "default": "document.body"
+    }
+  },
+  "baselines": {
+    "serene": {
+      "durationMs": 3200,
+      "lightness": 0.86,
+      "chroma": 0.1,
+      "hueCenter": 168,
+      "hueRange": 70,
+      "coverage": 0.55,
+      "bandY": 0.66,
+      "bandHeight": 0.28,
+      "sway": 0.06,
+      "striation": 0.6,
+      "rays": 0.35,
+      "overshoot": 0.4
+    },
+    "celebratory": {
+      "durationMs": 2600,
+      "lightness": 0.85,
+      "chroma": 0.16,
+      "hueCenter": 190,
+      "hueRange": 200,
+      "coverage": 0.7,
+      "bandY": 0.64,
+      "bandHeight": 0.31,
+      "sway": 0.08,
+      "striation": 0.72,
+      "rays": 0.5,
+      "overshoot": 0.7
+    },
+    "electric": {
+      "durationMs": 2100,
+      "lightness": 0.84,
+      "chroma": 0.23,
+      "hueCenter": 320,
+      "hueRange": 150,
+      "coverage": 0.85,
+      "bandY": 0.62,
+      "bandHeight": 0.34,
+      "sway": 0.11,
+      "striation": 0.88,
+      "rays": 0.7,
+      "overshoot": 1
+    }
+  },
+  "palette": {
+    "model": "oklch",
+    "space": "linear-srgb",
+    "generator": "golden-angle",
+    "goldenAngleDeg": 137.50776405003785,
+    "stops": 3,
+    "hueSpread": 0.22,
+    "lightness": {
+      "baseline": "lightness",
+      "perStop": [
+        0,
+        0.06,
+        -0.05
+      ]
+    },
+    "chroma": {
+      "from": {
+        "mul": [
+          {
+            "baseline": "chroma"
+          },
+          {
+            "lerp": [
+              "intensity",
+              0.7,
+              1.5
+            ]
+          }
+        ]
+      },
+      "perStop": [
+        0,
+        0.02,
+        -0.01
+      ]
+    },
+    "seed": {
+      "deterministic": true,
+      "source": "controls.seed",
+      "prng": "mulberry32"
+    },
+    "perMood": {
+      "serene": {
+        "hueCenter": 165,
+        "hueRange": 110,
+        "lightness": 0.84,
+        "chroma": 0.11
+      },
+      "celebratory": {
+        "hueCenter": 200,
+        "hueRange": 300,
+        "lightness": 0.83,
+        "chroma": 0.17
+      },
+      "electric": {
+        "hueCenter": 320,
+        "hueRange": 180,
+        "lightness": 0.82,
+        "chroma": 0.24
+      }
+    }
+  },
+  "tempo": {
+    "durationMs": {
+      "from": {
+        "round": {
+          "mul": [
+            {
+              "baseline": "durationMs"
+            },
+            {
+              "lerp": [
+                "intensity",
+                1.1,
+                0.9
+              ]
+            }
+          ]
+        }
+      }
+    },
+    "frame": {
+      "amp": {
+        "envelope": [
+          {
+            "input": "life"
+          },
+          {
+            "param": "overshoot"
+          }
+        ]
+      },
+      "extras": {
+        "sweep": {
+          "mul": [
+            0.02,
+            {
+              "div": [
+                {
+                  "input": "animMs"
+                },
+                1000
+              ]
+            },
+            {
+              "sub": [
+                1,
+                {
+                  "mul": [
+                    0.5,
+                    {
+                      "input": "life"
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        }
+      }
+    },
+    "reducedMotion": {
+      "peakMs": 520,
+      "holdMs": 520
+    }
+  },
+  "geometry": {
+    "kind": "directional",
+    "viewBox": [
+      0,
+      0,
+      100,
+      100
+    ]
+  },
+  "render": {
+    "params": {
+      "exposure": {
+        "type": "float",
+        "from": {
+          "lerp": [
+            "intensity",
+            0.85,
+            1.55
+          ]
+        }
+      },
+      "overshoot": {
+        "type": "float",
+        "from": {
+          "mul": [
+            {
+              "baseline": "overshoot"
+            },
+            {
+              "lerp": [
+                "intensity",
+                0.7,
+                1.2
+              ]
+            }
+          ]
+        }
+      },
+      "coverage": {
+        "type": "float",
+        "clamp01": true,
+        "from": {
+          "mul": [
+            {
+              "baseline": "coverage"
+            },
+            {
+              "lerp": [
+                "intensity",
+                0.7,
+                1.25
+              ]
+            }
+          ]
+        }
+      },
+      "bandY": {
+        "type": "float",
+        "from": {
+          "baseline": "bandY"
+        }
+      },
+      "bandHeight": {
+        "type": "float",
+        "clamp01": true,
+        "from": {
+          "mul": [
+            {
+              "baseline": "bandHeight"
+            },
+            {
+              "lerp": [
+                "intensity",
+                0.85,
+                1.15
+              ]
+            }
+          ]
+        }
+      },
+      "sway": {
+        "type": "float",
+        "from": {
+          "mul": [
+            {
+              "baseline": "sway"
+            },
+            {
+              "lerp": [
+                "intensity",
+                0.85,
+                1.2
+              ]
+            }
+          ]
+        }
+      },
+      "striation": {
+        "type": "float",
+        "clamp01": true,
+        "from": {
+          "mul": [
+            {
+              "baseline": "striation"
+            },
+            {
+              "lerp": [
+                "whimsy",
+                0.9,
+                1.1
+              ]
+            }
+          ]
+        }
+      },
+      "rays": {
+        "type": "float",
+        "clamp01": true,
+        "from": {
+          "mul": [
+            {
+              "baseline": "rays"
+            },
+            {
+              "lerp": [
+                "intensity",
+                0.8,
+                1.2
+              ]
+            }
+          ]
+        }
+      },
+      "style": {
+        "type": "float",
+        "from": {
+          "control": "whimsy"
+        }
+      }
+    },
+    "shadowHeightFrac": {
+      "mul": [
+        {
+          "param": "bandHeight"
+        },
+        0.6
+      ]
+    },
+    "consts": {
+      "MAX_CURTAINS": 7
+    },
+    "config": {
+      "usesOrigin": false
+    },
+    "backends": {
+      "webgl2": {
+        "stage": "fullscreen-triangle",
+        "blend": "screen",
+        "shader": {
+          "program": "aurora"
+        }
+      }
+    },
+    "fallbackOrder": [
+      "webgl2"
+    ]
+  },
+  "binding": {
+    "note": "CROSS-PLATFORM uniform-binding contract. Which render.params are NOT shader uniforms, the seed-keyed scatter field, the per-frame/host extras, and the texture samplers — one source of truth for the web u<Name> list, the Swift struct + packer, and the MSL struct. SHIPS in the portable .dope (the runtime derives its uniform bindings from it); the toolchain consumes it too for the Metal struct codegen. Only `x-build`, `slug` and `kind` stay toolchain-only.",
+    "excludeParams": [
+      "style",
+      "overshoot",
+      "durationMs"
+    ],
+    "scatterKey": "auroraSeed",
+    "scatterWeb": "uSeed",
+    "extras": [
+      {
+        "name": "sweep",
+        "type": "float",
+        "web": "uSweep",
+        "note": "accumulated sideways sweep (fraction of width)"
+      }
+    ],
+    "samplers": []
+  }
+}