@ansh-ui/core 0.2.0 → 0.3.1

package/dist/{chunk-R7UJ7MWP.cjs → chunk-OSNUN5JJ.cjs}

@@ -1,10 +1,10 @@
 'use strict';
 
-var chunk23GSSIMK_cjs = require('./chunk-23GSSIMK.cjs');
+var chunk4ORYTFY3_cjs = require('./chunk-4ORYTFY3.cjs');
 var chunkDXJ63QAR_cjs = require('./chunk-DXJ63QAR.cjs');
-var chunkFNR35HTL_cjs = require('./chunk-FNR35HTL.cjs');
-var chunkMMO7KO53_cjs = require('./chunk-MMO7KO53.cjs');
+var chunkFNR4B3KY_cjs = require('./chunk-FNR4B3KY.cjs');
 var chunkLGA3N3YJ_cjs = require('./chunk-LGA3N3YJ.cjs');
+var chunkFNR35HTL_cjs = require('./chunk-FNR35HTL.cjs');
 var chunkILKUL7GD_cjs = require('./chunk-ILKUL7GD.cjs');
 
 // src/render/surface.ts
@@ -73,7 +73,7 @@ function createSurface(canvas, options = {}) {
       }
     });
   };
-  const stopResizeObserver = canvas.parentElement ? chunkMMO7KO53_cjs.observeResize(canvas.parentElement, scheduleResize) : () => {
+  const stopResizeObserver = canvas.parentElement ? chunkFNR4B3KY_cjs.observeResize(canvas.parentElement, scheduleResize) : () => {
   };
   const onContextLost = (event) => {
     event.preventDefault();
@@ -184,7 +184,7 @@ function buildRadial(ctx, radius, stops) {
 }
 function drawDot(ctx, x, y, radius, color) {
   if (radius <= 0) return;
-  ctx.fillStyle = chunk23GSSIMK_cjs.toRgbString(color);
+  ctx.fillStyle = chunk4ORYTFY3_cjs.toRgbString(color);
   ctx.beginPath();
   ctx.arc(x, y, radius, 0, chunkILKUL7GD_cjs.TAU);
   ctx.fill();
@@ -289,7 +289,7 @@ var CANVAS_STYLE = {
   pointerEvents: "none"
 };
 function mountEffect(definition, host, userOptions = {}) {
-  chunkMMO7KO53_cjs.getRegistry().requireCapability(definition.capability ?? "effect:core");
+  chunkFNR4B3KY_cjs.getRegistry().requireCapability(definition.capability ?? "effect:core");
   let options = { ...definition.defaults, ...stripUndefined(userOptions) };
   const canvas = document.createElement("canvas");
   canvas.setAttribute("aria-hidden", "true");
@@ -306,9 +306,9 @@ function mountEffect(definition, host, userOptions = {}) {
   let destroyed = false;
   let userPaused = options.paused ?? false;
   let offscreen = false;
-  let motion = chunkMMO7KO53_cjs.resolveMotion(options.reducedMotion, 0.25);
+  let motion = chunkFNR4B3KY_cjs.resolveMotion(options.reducedMotion, 0.25);
   let pendingSingleFrame = false;
-  const ticker = chunkMMO7KO53_cjs.getTicker();
+  const ticker = chunkFNR4B3KY_cjs.getTicker();
   const surface = createSurface(canvas, {
     resolution: options.resolution ?? 1,
     alpha: true,
@@ -348,7 +348,7 @@ function mountEffect(definition, host, userOptions = {}) {
   function ensurePointer() {
     const wants = options.interactive !== false;
     if (wants && !pointer) {
-      pointer = chunkMMO7KO53_cjs.trackPointer(host);
+      pointer = chunkFNR4B3KY_cjs.trackPointer(host);
     } else if (!wants && pointer) {
       pointer.destroy();
       pointer = null;
@@ -392,7 +392,7 @@ function mountEffect(definition, host, userOptions = {}) {
   if (options.performance === "high") ticker.lockQuality(1);
   else if (options.performance === "low") ticker.lockQuality(0.4);
   if (options.pauseOffscreen !== false) {
-    intersectionSubscription = chunkMMO7KO53_cjs.observeIntersection(
+    intersectionSubscription = chunkFNR4B3KY_cjs.observeIntersection(
       host,
       (entry) => {
         offscreen = !entry.isIntersecting;
@@ -404,8 +404,8 @@ function mountEffect(definition, host, userOptions = {}) {
       { rootMargin: "200px" }
     );
   }
-  reducedMotionSubscription = chunkMMO7KO53_cjs.onReducedMotionChange(() => {
-    motion = chunkMMO7KO53_cjs.resolveMotion(options.reducedMotion, 0.25);
+  reducedMotionSubscription = chunkFNR4B3KY_cjs.onReducedMotionChange(() => {
+    motion = chunkFNR4B3KY_cjs.resolveMotion(options.reducedMotion, 0.25);
     if (motion.animate && !userPaused && !offscreen) {
       startTicker();
     } else {
@@ -448,7 +448,7 @@ function mountEffect(definition, host, userOptions = {}) {
       if (options.resolution !== void 0) surface.setResolution(options.resolution);
       const wasPaused = userPaused;
       userPaused = options.paused ?? false;
-      motion = chunkMMO7KO53_cjs.resolveMotion(options.reducedMotion, 0.25);
+      motion = chunkFNR4B3KY_cjs.resolveMotion(options.reducedMotion, 0.25);
       if (wasPaused && !userPaused && motion.animate && !offscreen) startTicker();
       if (!wasPaused && userPaused) stopTicker();
       if (!motion.animate && motion.renderOnce) renderSingleFrame();
@@ -491,7 +491,7 @@ function resolveResolvedColors(colors, host) {
       return chunkLGA3N3YJ_cjs.parseColor(color);
     });
   }
-  return chunk23GSSIMK_cjs.resolvePalette(colors);
+  return chunk4ORYTFY3_cjs.resolvePalette(colors);
 }
 function resolveAgainst(value, host) {
   const probe = document.createElement("span");
@@ -514,7 +514,7 @@ function stripUndefined(input) {
   return out;
 }
 function defineEffect(definition) {
-  const registry = chunkMMO7KO53_cjs.getRegistry();
+  const registry = chunkFNR4B3KY_cjs.getRegistry();
   if (!registry.has("effect", definition.name)) {
     registry.register("effect", definition.name, definition);
   }
@@ -770,7 +770,7 @@ var aurora = defineEffect({
     const flow = context.noise.fbm2D({ octaves: 2, gain: 0.5 });
     function build() {
       const count = Math.max(1, Math.floor(opts.curtains));
-      const palette = chunk23GSSIMK_cjs.expandPalette(context.colors, count);
+      const palette = chunk4ORYTFY3_cjs.expandPalette(context.colors, count);
       const rng = context.rng;
       curtains = [];
       for (let i = 0; i < count; i++) {
@@ -884,7 +884,7 @@ var meshGradient = defineEffect({
     let grainTile = null;
     function build() {
       const count = Math.max(1, Math.floor(opts.points));
-      const palette = chunk23GSSIMK_cjs.expandPalette(context.colors, count);
+      const palette = chunk4ORYTFY3_cjs.expandPalette(context.colors, count);
       const rng = context.rng;
       backdropColor = palette.reduce(
         (darkest, c) => c.r + c.g + c.b < darkest.r + darkest.g + darkest.b ? c : darkest
@@ -1051,7 +1051,7 @@ var animatedGradient = defineEffect({
     function build() {
       const count = Math.max(2, Math.floor(opts.stops));
       const doubled = [...context.colors, ...context.colors, context.colors[0]];
-      samples = chunk23GSSIMK_cjs.expandPalette(doubled, count * 2);
+      samples = chunk4ORYTFY3_cjs.expandPalette(doubled, count * 2);
     }
     build();
     return {
@@ -1420,8 +1420,447 @@ var constellation = defineEffect({
   }
 });
 
-// src/effects/atmosphere/meteors.ts
+// src/effects/particles/powder-explosion.ts
 var DEFAULTS5 = {
+  colors: ["#ff9d5c", "#ffd76f", "#ff6b8b", "#7cc4ff"],
+  speed: 1,
+  intensity: 1,
+  opacity: 1,
+  blur: 0,
+  blend: "lighter",
+  seed: 59,
+  interactive: true,
+  resolution: 1,
+  performance: "auto",
+  reducedMotion: "pause",
+  paused: false,
+  pauseOffscreen: true,
+  burstSize: 90,
+  burstRate: 0.8,
+  force: 420,
+  drag: 0.92,
+  gravity: 90,
+  life: 1.9,
+  size: 3,
+  glow: 3.2,
+  burstOnPress: true
+};
+var MAX_PARTICLES2 = 1600;
+var FADE_SHAPE = 1.4;
+var powderExplosion = defineEffect({
+  name: "powder-explosion",
+  defaults: DEFAULTS5,
+  structuralOptions: ["burstSize"],
+  setup(context, options) {
+    let opts = options;
+    const perBurst = Math.max(1, Math.floor(opts.burstSize));
+    const concurrent = Math.max(2, Math.ceil(opts.life * opts.burstRate) + 2);
+    const capacity = Math.min(MAX_PARTICLES2, perBurst * concurrent);
+    const buffer = new ParticleBuffer(capacity);
+    const gradients = new GradientCache(64);
+    let untilNextBurst = 0;
+    let wasDown = false;
+    function burst(x, y) {
+      const rng = context.rng;
+      const colorCount = Math.max(1, context.colors.length);
+      const family = rng.int(0, colorCount - 1);
+      for (let i = 0; i < perBurst; i++) {
+        const index = buffer.spawn();
+        if (index < 0) return;
+        const angle = rng.angle();
+        const t = rng.next();
+        const speed = opts.force * t * t * rng.range(0.85, 1.15);
+        buffer.x[index] = x;
+        buffer.y[index] = y;
+        buffer.vx[index] = Math.cos(angle) * speed;
+        buffer.vy[index] = Math.sin(angle) * speed;
+        buffer.size[index] = opts.size * rng.range(0.55, 1.5);
+        buffer.colorIndex[index] = rng.bool(0.75) ? family : rng.int(0, colorCount - 1);
+        buffer.maxLife[index] = opts.life * rng.range(0.6, 1.3);
+        buffer.life[index] = buffer.maxLife[index];
+        buffer.seed[index] = rng.range(0, chunkILKUL7GD_cjs.TAU);
+        buffer.extra[index] = rng.range(0.85, 1.2);
+      }
+    }
+    return {
+      frame({ delta, quality }) {
+        const { ctx, size, surface, pointer, colors } = context;
+        const { width, height } = size;
+        if (width < 1 || height < 1) return;
+        surface.clear();
+        if (colors.length === 0) return;
+        const rng = context.rng;
+        const rate = opts.burstRate * (opts.performance === "high" ? 1 : quality);
+        untilNextBurst -= delta * rate;
+        if (untilNextBurst <= 0) {
+          burst(rng.range(width * 0.15, width * 0.85), rng.range(height * 0.2, height * 0.8));
+          untilNextBurst = -Math.log(1 - rng.next());
+        }
+        const interactive = opts.interactive !== false && pointer !== null;
+        if (interactive && opts.burstOnPress) {
+          if (pointer.down && !wasDown) burst(pointer.x, pointer.y);
+          wasDown = pointer.down;
+        }
+        const retain = Math.pow(1 - chunkILKUL7GD_cjs.clamp(opts.drag, 0, 0.999), delta);
+        const gravity = opts.gravity * delta;
+        const alphaScale = chunkILKUL7GD_cjs.clamp(opts.opacity * opts.intensity, 0, 1);
+        const colorCount = Math.max(1, colors.length);
+        ctx.globalCompositeOperation = opts.blend ?? "lighter";
+        let i = 0;
+        while (i < buffer.count) {
+          buffer.life[i] -= delta;
+          if (buffer.life[i] <= 0) {
+            buffer.kill(i);
+            continue;
+          }
+          buffer.vx[i] *= retain;
+          buffer.vy[i] = buffer.vy[i] * retain + gravity;
+          buffer.x[i] += buffer.vx[i] * delta;
+          buffer.y[i] += buffer.vy[i] * delta;
+          const age = chunkILKUL7GD_cjs.clamp(1 - buffer.life[i] / buffer.maxLife[i], 0, 1);
+          const alpha = alphaScale * Math.pow(1 - age, FADE_SHAPE);
+          if (alpha > 2e-3) {
+            drawGlow(
+              ctx,
+              buffer.x[i],
+              buffer.y[i],
+              buffer.size[i] * opts.glow * buffer.extra[i],
+              colors[buffer.colorIndex[i] % colorCount],
+              alpha,
+              gradients
+            );
+          }
+          i++;
+        }
+        ctx.globalCompositeOperation = "source-over";
+      },
+      update(next) {
+        opts = {
+          ...opts,
+          ...next
+        };
+        gradients.clear();
+      },
+      destroy() {
+        buffer.clear();
+        gradients.clear();
+      }
+    };
+  }
+});
+
+// src/effects/particles/strange-attractor.ts
+var DEFAULTS6 = {
+  colors: ["#7cc4ff", "#a78bfa", "#5eead4", "#fbbf7c"],
+  speed: 1,
+  intensity: 1,
+  opacity: 1,
+  blur: 0,
+  blend: "lighter",
+  seed: 83,
+  interactive: false,
+  resolution: 1,
+  performance: "auto",
+  reducedMotion: "slow",
+  paused: false,
+  pauseOffscreen: true,
+  kind: "clifford",
+  count: 2600,
+  drift: 0.12,
+  driftSpeed: 0.05,
+  size: 0.9,
+  pointOpacity: 0.34,
+  fade: 0.12,
+  scale: 0.42
+};
+var MAX_WALKERS = 8e3;
+var PARAM_SETS = {
+  clifford: [
+    [-1.4, 1.6, 1, 0.7],
+    [1.7, 1.7, 0.06, 1.2],
+    [-1.7, 1.3, -0.1, -1.21],
+    [1.5, -1.8, 1.6, 0.9],
+    [-1.8, -2, -0.5, -0.9]
+  ],
+  dejong: [
+    [1.4, -2.3, 2.4, -2.1],
+    [2.01, -2.53, 1.61, -0.33],
+    [-2.7, -0.09, -0.86, -2.2],
+    [1.641, 1.902, 0.316, 1.525]
+  ],
+  svensson: [
+    [1.4, 1.56, 1.4, -6.56],
+    [-1.78, -1.28, -0.75, 1.34],
+    [1.94, 1.1, -1.63, 0.42]
+  ]
+};
+var strangeAttractor = defineEffect({
+  name: "strange-attractor",
+  defaults: DEFAULTS6,
+  structuralOptions: ["count", "kind"],
+  setup(context, options) {
+    let opts = options;
+    const count = Math.min(MAX_WALKERS, Math.max(1, Math.floor(opts.count)));
+    const px = new Float32Array(count);
+    const py = new Float32Array(count);
+    const colorIndex = new Uint8Array(count);
+    const rng = context.rng;
+    const sets = PARAM_SETS[opts.kind] ?? PARAM_SETS.clifford;
+    const [baseA, baseB, baseC, baseD] = sets[rng.int(0, sets.length - 1)];
+    const phaseA = rng.angle();
+    const phaseB = rng.angle();
+    const phaseC = rng.angle();
+    const phaseD = rng.angle();
+    let seeded = false;
+    function seed() {
+      const colorCount = Math.max(1, context.colors.length);
+      for (let i = 0; i < count; i++) {
+        px[i] = rng.range(-1, 1);
+        py[i] = rng.range(-1, 1);
+        colorIndex[i] = rng.int(0, colorCount - 1);
+      }
+      seeded = true;
+    }
+    return {
+      frame({ time, quality }) {
+        const { ctx, size, surface, colors } = context;
+        const { width, height } = size;
+        if (width < 1 || height < 1) return;
+        if (colors.length === 0) return;
+        if (!seeded) seed();
+        const fade = chunkILKUL7GD_cjs.clamp(opts.fade, 0, 1);
+        if (fade >= 1) {
+          surface.clear();
+        } else if (fade > 0) {
+          ctx.globalCompositeOperation = "destination-out";
+          ctx.fillStyle = `rgba(0,0,0,${fade})`;
+          ctx.fillRect(0, 0, width, height);
+        }
+        const wobble = opts.drift;
+        const rate = opts.driftSpeed * time;
+        const a = baseA + Math.sin(rate + phaseA) * wobble;
+        const b = baseB + Math.sin(rate * 1.31 + phaseB) * wobble;
+        const c = baseC + Math.sin(rate * 0.77 + phaseC) * wobble;
+        const d = baseD + Math.sin(rate * 1.13 + phaseD) * wobble;
+        const kind = opts.kind;
+        const extent = kind === "dejong" ? 2 : 1 + Math.max(Math.abs(c), Math.abs(d));
+        const span = Math.min(width, height) * opts.scale;
+        const cx = width / 2;
+        const cy = height / 2;
+        const radius = Math.max(0.35, opts.size);
+        const diameter = radius * 2;
+        const walkers = opts.performance === "high" ? count : Math.max(64, Math.round(count * quality));
+        const alpha = chunkILKUL7GD_cjs.clamp(opts.pointOpacity * opts.opacity * opts.intensity, 0, 1);
+        ctx.globalCompositeOperation = opts.blend ?? "lighter";
+        ctx.globalAlpha = alpha;
+        const colorCount = colors.length;
+        let currentColor = -1;
+        for (let i = 0; i < walkers; i++) {
+          const x = px[i];
+          const y = py[i];
+          let nx;
+          let ny;
+          if (kind === "dejong") {
+            nx = Math.sin(a * y) - Math.cos(b * x);
+            ny = Math.sin(c * x) - Math.cos(d * y);
+          } else if (kind === "svensson") {
+            nx = d * Math.sin(a * x) - Math.sin(b * y);
+            ny = c * Math.cos(a * x) + Math.cos(b * y);
+          } else {
+            nx = Math.sin(a * y) + c * Math.cos(a * x);
+            ny = Math.sin(b * x) + d * Math.cos(b * y);
+          }
+          px[i] = nx;
+          py[i] = ny;
+          const ci = colorIndex[i] % colorCount;
+          if (ci !== currentColor) {
+            const colour = colors[ci];
+            ctx.fillStyle = `rgb(${Math.round(colour.r * 255)},${Math.round(colour.g * 255)},${Math.round(colour.b * 255)})`;
+            currentColor = ci;
+          }
+          ctx.fillRect(
+            cx + nx / extent * span - radius,
+            cy + ny / extent * span - radius,
+            diameter,
+            diameter
+          );
+        }
+        ctx.globalAlpha = 1;
+        ctx.globalCompositeOperation = "source-over";
+      },
+      resize() {
+        seeded = false;
+      },
+      update(next) {
+        opts = {
+          ...opts,
+          ...next
+        };
+      }
+    };
+  }
+});
+
+// src/effects/particles/swarm.ts
+var DEFAULTS7 = {
+  colors: ["#3b82f6", "#a78bfa", "#f472b6", "#fbbf24"],
+  speed: 1,
+  intensity: 1,
+  opacity: 1,
+  blur: 0,
+  blend: "lighter",
+  seed: 89,
+  interactive: true,
+  resolution: 1,
+  performance: "auto",
+  reducedMotion: "slow",
+  paused: false,
+  pauseOffscreen: true,
+  count: 900,
+  attractors: 3,
+  gravity: 260,
+  swirl: 0.85,
+  softening: 70,
+  drag: 0.45,
+  attractorSpeed: 0.08,
+  size: 1.4,
+  fastSpeed: 320,
+  pointerGravity: 1.6
+};
+var MAX_PARTICLES3 = 4e3;
+var MAX_ATTRACTORS = 8;
+var MAX_DELTA_V = 900;
+var swarm = defineEffect({
+  name: "swarm",
+  defaults: DEFAULTS7,
+  structuralOptions: ["count", "attractors"],
+  setup(context, options) {
+    let opts = options;
+    const capacity = Math.min(MAX_PARTICLES3, Math.max(1, Math.floor(opts.count)));
+    const attractorCount = Math.min(MAX_ATTRACTORS, Math.max(1, Math.floor(opts.attractors)));
+    const buffer = new ParticleBuffer(capacity);
+    const ax = new Float32Array(attractorCount);
+    const ay = new Float32Array(attractorCount);
+    const fx = new Float32Array(attractorCount);
+    const fy = new Float32Array(attractorCount);
+    const phx = new Float32Array(attractorCount);
+    const phy = new Float32Array(attractorCount);
+    const rng = context.rng;
+    for (let a = 0; a < attractorCount; a++) {
+      ax[a] = rng.range(0.18, 0.34);
+      ay[a] = rng.range(0.18, 0.34);
+      fx[a] = rng.range(0.6, 1.4);
+      fy[a] = rng.range(0.6, 1.4);
+      phx[a] = rng.angle();
+      phy[a] = rng.angle();
+    }
+    let seeded = false;
+    function seed() {
+      const { width, height } = context.size;
+      buffer.clear();
+      for (let i = 0; i < capacity; i++) {
+        const index = buffer.spawn();
+        if (index < 0) break;
+        buffer.x[index] = rng.next() * width;
+        buffer.y[index] = rng.next() * height;
+        const angle = rng.angle();
+        const speed = rng.range(20, 90);
+        buffer.vx[index] = Math.cos(angle) * speed;
+        buffer.vy[index] = Math.sin(angle) * speed;
+        buffer.size[index] = opts.size * rng.range(0.7, 1.5);
+        buffer.life[index] = Infinity;
+        buffer.maxLife[index] = Infinity;
+      }
+      seeded = true;
+    }
+    return {
+      frame({ time, delta, quality }) {
+        const { ctx, size, surface, pointer, colors } = context;
+        const { width, height } = size;
+        if (width < 1 || height < 1) return;
+        if (!seeded || buffer.count === 0) seed();
+        surface.clear();
+        if (colors.length === 0) return;
+        const target = opts.performance === "high" ? capacity : Math.max(32, Math.floor(capacity * quality));
+        if (buffer.count > target) buffer.truncate(target);
+        const cx = width / 2;
+        const cy = height / 2;
+        const t = time * opts.attractorSpeed * chunkILKUL7GD_cjs.TAU;
+        const atx = [];
+        const aty = [];
+        for (let a = 0; a < attractorCount; a++) {
+          atx.push(cx + Math.sin(t * fx[a] + phx[a]) * width * ax[a]);
+          aty.push(cy + Math.cos(t * fy[a] + phy[a]) * height * ay[a]);
+        }
+        const interactive = opts.interactive !== false && pointer !== null && pointer.everInside;
+        if (interactive && opts.pointerGravity !== 0) {
+          atx.push(pointer.smoothX);
+          aty.push(pointer.smoothY);
+        }
+        const gravity = opts.gravity * opts.intensity;
+        const pointerBoost = opts.pointerGravity;
+        const swirl = opts.swirl;
+        const softening = Math.max(1, opts.softening);
+        const retain = Math.pow(1 - chunkILKUL7GD_cjs.clamp(opts.drag, 0, 0.999), delta);
+        const invFast = 1 / Math.max(1, opts.fastSpeed);
+        const alpha = chunkILKUL7GD_cjs.clamp(opts.opacity * opts.intensity, 0, 1);
+        const colorCount = colors.length;
+        const live = buffer.count;
+        const activeAttractors = atx.length;
+        ctx.globalCompositeOperation = opts.blend ?? "lighter";
+        ctx.globalAlpha = alpha;
+        let currentColor = -1;
+        for (let i = 0; i < live; i++) {
+          let axSum = 0;
+          let aySum = 0;
+          for (let a = 0; a < activeAttractors; a++) {
+            const dx = atx[a] - buffer.x[i];
+            const dy = aty[a] - buffer.y[i];
+            const distance = Math.hypot(dx, dy);
+            const inv = 1 / (distance + softening);
+            const peak = a === attractorCount && interactive ? gravity * pointerBoost : gravity;
+            const strength = peak * softening * inv;
+            const nx = dx * inv;
+            const ny = dy * inv;
+            axSum += nx * strength;
+            aySum += ny * strength;
+            axSum += -ny * strength * swirl;
+            aySum += nx * strength * swirl;
+          }
+          const dvx = chunkILKUL7GD_cjs.clamp(axSum * delta, -MAX_DELTA_V, MAX_DELTA_V);
+          const dvy = chunkILKUL7GD_cjs.clamp(aySum * delta, -MAX_DELTA_V, MAX_DELTA_V);
+          buffer.vx[i] = (buffer.vx[i] + dvx) * retain;
+          buffer.vy[i] = (buffer.vy[i] + dvy) * retain;
+          buffer.x[i] += buffer.vx[i] * delta;
+          buffer.y[i] += buffer.vy[i] * delta;
+          const speed = Math.hypot(buffer.vx[i], buffer.vy[i]);
+          const ci = Math.min(colorCount - 1, Math.floor(chunkILKUL7GD_cjs.clamp(speed * invFast, 0, 1) * colorCount));
+          if (ci !== currentColor) {
+            const colour = colors[ci];
+            ctx.fillStyle = `rgb(${Math.round(colour.r * 255)},${Math.round(colour.g * 255)},${Math.round(colour.b * 255)})`;
+            currentColor = ci;
+          }
+          const r = buffer.size[i];
+          ctx.fillRect(buffer.x[i] - r, buffer.y[i] - r, r * 2, r * 2);
+        }
+        ctx.globalAlpha = 1;
+        ctx.globalCompositeOperation = "source-over";
+      },
+      resize() {
+        seeded = false;
+      },
+      update(next) {
+        opts = { ...opts, ...next };
+      },
+      destroy() {
+        buffer.clear();
+      }
+    };
+  }
+});
+
+// src/effects/atmosphere/meteors.ts
+var DEFAULTS8 = {
   colors: ["#ffffff", "#a5c8ff", "#8a2be2"],
   speed: 1,
   intensity: 1,
@@ -1447,7 +1886,7 @@ var DEFAULTS5 = {
 var MAX_METEORS = 200;
 var meteors = defineEffect({
   name: "meteors",
-  defaults: DEFAULTS5,
+  defaults: DEFAULTS8,
   structuralOptions: ["count"],
   setup(context, options) {
     let opts = options;
@@ -1835,7 +2274,7 @@ var snow = defineEffect({
 });
 
 // src/effects/atmosphere/fireflies.ts
-var DEFAULTS6 = {
+var DEFAULTS9 = {
   colors: ["#ffe98a", "#c8ff8a", "#8affd4"],
   speed: 1,
   intensity: 1,
@@ -1859,7 +2298,7 @@ var DEFAULTS6 = {
 };
 var fireflies = defineEffect({
   name: "fireflies",
-  defaults: DEFAULTS6,
+  defaults: DEFAULTS9,
   structuralOptions: ["count"],
   setup(context, options) {
     let opts = options;
@@ -1966,8 +2405,591 @@ var fireflies = defineEffect({
   }
 });
 
+// src/effects/atmosphere/light-rays.ts
+var DEFAULTS10 = {
+  colors: ["#fff4d6", "#ffd9a0", "#ffb865"],
+  speed: 1,
+  intensity: 1,
+  opacity: 1,
+  blur: 0,
+  blend: "lighter",
+  seed: 41,
+  interactive: true,
+  resolution: 1,
+  performance: "auto",
+  reducedMotion: "slow",
+  paused: false,
+  pauseOffscreen: true,
+  count: 16,
+  originX: 0.5,
+  originY: -0.6,
+  angle: Math.PI / 2,
+  spread: 1.1,
+  rayWidth: 0.03,
+  length: 1.4,
+  falloff: 0.5,
+  softness: 0.65,
+  flicker: 0.55,
+  flickerSpeed: 0.35,
+  sway: 0.06,
+  swaySpeed: 0.12,
+  pointerPull: 0.25
+};
+var MAX_RAYS = 64;
+var MIN_BRIGHTNESS = 0.15;
+var MAX_SOFT_SPREAD = 2.5;
+var SOFT_LAYERS = [
+  { width: 1, alpha: 0.28 },
+  { width: 0.55, alpha: 0.32 },
+  { width: 0.28, alpha: 0.4 }
+];
+var lightRays = defineEffect({
+  name: "light-rays",
+  defaults: DEFAULTS10,
+  structuralOptions: ["count"],
+  setup(context, options) {
+    let opts = options;
+    const count = Math.min(MAX_RAYS, Math.max(1, Math.floor(opts.count)));
+    const angleJitter = new Float32Array(count);
+    const widthScale = new Float32Array(count);
+    const noiseOffset = new Float32Array(count);
+    const colorIndex = new Uint8Array(count);
+    const rng = context.rng;
+    for (let i = 0; i < count; i++) {
+      angleJitter[i] = rng.range(-0.5, 0.5);
+      widthScale[i] = rng.range(0.45, 1.55);
+      noiseOffset[i] = rng.range(0, 128);
+      colorIndex[i] = rng.int(0, 255);
+    }
+    const brightness = context.noise.fbm2D({ octaves: 2, gain: 0.55 });
+    let gradients = [];
+    let gradientLength = -1;
+    function buildGradients(rayLength) {
+      const { ctx, colors } = context;
+      gradients = colors.map((color) => {
+        const rgb = `${Math.round(color.r * 255)},${Math.round(color.g * 255)},${Math.round(color.b * 255)}`;
+        const gradient = ctx.createLinearGradient(0, 0, Math.max(1, rayLength), 0);
+        const reach = chunkILKUL7GD_cjs.clamp(opts.falloff, 0.05, 1);
+        gradient.addColorStop(0, `rgba(${rgb},${color.a * 0.7})`);
+        gradient.addColorStop(reach * 0.4, `rgba(${rgb},${color.a * 0.36})`);
+        gradient.addColorStop(reach, `rgba(${rgb},${color.a * 0.12})`);
+        gradient.addColorStop(1, `rgba(${rgb},0)`);
+        return gradient;
+      });
+      gradientLength = rayLength;
+    }
+    return {
+      frame({ time, quality }) {
+        const { ctx, size, surface, pointer, colors } = context;
+        const { width, height } = size;
+        if (width < 1 || height < 1) return;
+        surface.clear();
+        if (colors.length === 0) return;
+        const rayLength = Math.hypot(width, height) * opts.length;
+        if (rayLength !== gradientLength) buildGradients(rayLength);
+        const drawn = opts.performance === "high" ? count : Math.max(3, Math.round(count * quality));
+        let originX = opts.originX;
+        let originY = opts.originY;
+        const interactive = opts.interactive !== false && pointer !== null && pointer.everInside;
+        if (interactive) {
+          const pull = chunkILKUL7GD_cjs.clamp(opts.pointerPull, 0, 1);
+          originX += (pointer.smoothNx - originX) * pull;
+          originY += (pointer.smoothNy - originY) * pull;
+        }
+        const sourceX = originX * width;
+        const sourceY = originY * height;
+        const sway = Math.sin(time * opts.swaySpeed * chunkILKUL7GD_cjs.TAU) * opts.sway;
+        const half = opts.spread / 2;
+        const step = opts.spread / drawn;
+        const flickerDepth = chunkILKUL7GD_cjs.clamp(opts.flicker, 0, 1);
+        const alphaScale = chunkILKUL7GD_cjs.clamp(opts.opacity * opts.intensity, 0, 1);
+        ctx.save();
+        ctx.globalCompositeOperation = opts.blend ?? "lighter";
+        ctx.translate(sourceX, sourceY);
+        for (let i = 0; i < drawn; i++) {
+          const rayAngle = opts.angle - half + (i + 0.5) * step + angleJitter[i] * step + sway;
+          const n = brightness(noiseOffset[i], time * opts.flickerSpeed);
+          const varied = 1 - flickerDepth * (1 - (n * 0.5 + 0.5));
+          const alpha = chunkILKUL7GD_cjs.clamp(Math.max(MIN_BRIGHTNESS, varied) * alphaScale, 0, 1);
+          if (alpha <= 2e-3) continue;
+          const halfWidth = opts.rayWidth * widthScale[i];
+          const spreadFactor = 1 + chunkILKUL7GD_cjs.clamp(opts.softness, 0, 1) * MAX_SOFT_SPREAD;
+          ctx.save();
+          ctx.rotate(rayAngle);
+          ctx.fillStyle = gradients[colorIndex[i] % gradients.length];
+          for (const layer of SOFT_LAYERS) {
+            const hw = halfWidth * (1 + (spreadFactor - 1) * layer.width);
+            ctx.globalAlpha = alpha * layer.alpha;
+            ctx.beginPath();
+            ctx.moveTo(0, 0);
+            ctx.lineTo(Math.cos(-hw) * rayLength, Math.sin(-hw) * rayLength);
+            ctx.lineTo(Math.cos(hw) * rayLength, Math.sin(hw) * rayLength);
+            ctx.closePath();
+            ctx.fill();
+          }
+          ctx.restore();
+        }
+        ctx.restore();
+        ctx.globalAlpha = 1;
+        ctx.globalCompositeOperation = "source-over";
+      },
+      resize() {
+        gradientLength = -1;
+      },
+      update(next) {
+        opts = { ...opts, ...next };
+        gradientLength = -1;
+      },
+      destroy() {
+        gradients = [];
+      }
+    };
+  }
+});
+
+// src/effects/atmosphere/smoke.ts
+var DEFAULTS11 = {
+  colors: ["#8e9bb0", "#b9c3d1", "#6b7688"],
+  speed: 1,
+  intensity: 1,
+  opacity: 1,
+  blur: 0,
+  // `source-over`, not `lighter` — the one place this effect deliberately breaks with the other
+  // particle effects here. Smoke *occludes* light rather than emitting it, and additive blending
+  // drives overlapping puffs to pure white, which reads as a lens flare rather than a plume.
+  blend: "source-over",
+  seed: 53,
+  interactive: false,
+  resolution: 0.85,
+  performance: "auto",
+  reducedMotion: "slow",
+  paused: false,
+  pauseOffscreen: true,
+  count: 100,
+  sourceX: 0.5,
+  sourceY: 1.05,
+  // Tight at the emitter: a wide spawn scatters puffs into unrelated blobs instead of a column,
+  // and the curl field widens the plume on its own as it climbs.
+  spread: 16,
+  rise: 54,
+  turbulence: 26,
+  scale: 35e-4,
+  size: 18,
+  growth: 2.2,
+  life: 4.5,
+  drag: 0.55,
+  density: 0.16
+};
+var MAX_PUFFS = 400;
+var FADE_IN = 0.14;
+var FIELD_DRIFT = 0.12;
+var DECAY_SHAPE = 1.6;
+var smoke = defineEffect({
+  name: "smoke",
+  defaults: DEFAULTS11,
+  structuralOptions: ["count"],
+  setup(context, options) {
+    let opts = options;
+    const capacity = Math.min(MAX_PUFFS, Math.max(1, Math.floor(opts.count)));
+    const buffer = new ParticleBuffer(capacity);
+    const gradients = new GradientCache(64);
+    const curl = context.noise.curlAnimated({ octaves: 2, gain: 0.5 });
+    let seeded = false;
+    function place(index, ageOffset) {
+      const { width, height } = context.size;
+      const rng = context.rng;
+      const colorCount = Math.max(1, context.colors.length);
+      buffer.x[index] = opts.sourceX * width + rng.range(-opts.spread, opts.spread);
+      buffer.y[index] = opts.sourceY * height + rng.range(-opts.spread, opts.spread) * 0.35;
+      buffer.vx[index] = rng.range(-8, 8);
+      buffer.vy[index] = -opts.rise * rng.range(0.7, 1.3);
+      buffer.size[index] = opts.size * rng.range(0.65, 1.4);
+      buffer.colorIndex[index] = rng.int(0, colorCount - 1);
+      buffer.maxLife[index] = opts.life * rng.range(0.75, 1.25);
+      buffer.life[index] = buffer.maxLife[index] * (1 - ageOffset);
+      buffer.seed[index] = rng.range(0, 500);
+      buffer.extra[index] = rng.range(0.7, 1.35);
+    }
+    function seed() {
+      buffer.clear();
+      for (let i = 0; i < capacity; i++) {
+        const index = buffer.spawn();
+        if (index < 0) break;
+        place(index, context.rng.next());
+      }
+      seeded = true;
+    }
+    return {
+      frame({ time, delta, quality }) {
+        const { ctx, size, surface, colors } = context;
+        const { width, height } = size;
+        if (width < 1 || height < 1) return;
+        if (!seeded || buffer.count === 0) seed();
+        const target = opts.performance === "high" ? capacity : Math.max(4, Math.floor(capacity * quality));
+        if (buffer.count > target) buffer.truncate(target);
+        surface.clear();
+        if (colors.length === 0) return;
+        const count = buffer.count;
+        const colorCount = Math.max(1, colors.length);
+        const retain = Math.pow(1 - chunkILKUL7GD_cjs.clamp(opts.drag, 0, 0.999), delta);
+        const turbulence = opts.turbulence * opts.intensity;
+        const rise = opts.rise * opts.intensity;
+        const peak = chunkILKUL7GD_cjs.clamp(opts.density, 0, 1) * chunkILKUL7GD_cjs.clamp(opts.opacity, 0, 1);
+        ctx.globalCompositeOperation = opts.blend ?? "lighter";
+        for (let i = 0; i < count; i++) {
+          buffer.life[i] -= delta;
+          if (buffer.life[i] <= 0) {
+            place(i, 0);
+            continue;
+          }
+          const flow = curl(
+            (buffer.x[i] + buffer.seed[i]) * opts.scale,
+            buffer.y[i] * opts.scale,
+            time * FIELD_DRIFT
+          );
+          buffer.vx[i] = buffer.vx[i] * retain + flow.x * turbulence * delta;
+          buffer.vy[i] = buffer.vy[i] * retain + (flow.y * turbulence - rise) * delta;
+          buffer.x[i] += buffer.vx[i] * delta;
+          buffer.y[i] += buffer.vy[i] * delta;
+          const age = chunkILKUL7GD_cjs.clamp(1 - buffer.life[i] / buffer.maxLife[i], 0, 1);
+          const fadeIn = Math.min(1, age / FADE_IN);
+          const decay = Math.pow(1 - age, DECAY_SHAPE);
+          const alpha = peak * fadeIn * decay;
+          if (alpha <= 2e-3) continue;
+          const radius = buffer.size[i] * (1 + opts.growth * age) * buffer.extra[i];
+          drawGlow(
+            ctx,
+            buffer.x[i],
+            buffer.y[i],
+            radius,
+            colors[buffer.colorIndex[i] % colorCount],
+            alpha,
+            gradients
+          );
+        }
+        ctx.globalCompositeOperation = "source-over";
+      },
+      resize() {
+        seeded = false;
+      },
+      update(next) {
+        opts = { ...opts, ...next };
+        gradients.clear();
+      },
+      destroy() {
+        buffer.clear();
+        gradients.clear();
+      }
+    };
+  }
+});
+
+// src/effects/geometry/floating-geometry.ts
+var ALL_SHAPES = ["triangle", "square", "pentagon", "hexagon", "circle"];
+var DEFAULTS12 = {
+  colors: ["#7cc4ff", "#a78bfa", "#5eead4"],
+  speed: 1,
+  intensity: 1,
+  opacity: 1,
+  blur: 0,
+  blend: "lighter",
+  seed: 67,
+  interactive: false,
+  resolution: 1,
+  performance: "auto",
+  reducedMotion: "slow",
+  paused: false,
+  pauseOffscreen: true,
+  count: 18,
+  shapes: ALL_SHAPES,
+  size: 46,
+  drift: 26,
+  spin: 0.06,
+  perspective: 1,
+  depth: 2.6,
+  haze: 0.25,
+  filled: false,
+  lineWidth: 1.5
+};
+var MAX_SHAPES = 120;
+var CIRCLE = 0;
+function sidesFor(shape) {
+  switch (shape) {
+    case "triangle":
+      return 3;
+    case "square":
+      return 4;
+    case "pentagon":
+      return 5;
+    case "hexagon":
+      return 6;
+    default:
+      return CIRCLE;
+  }
+}
+var floatingGeometry = defineEffect({
+  name: "floating-geometry",
+  defaults: DEFAULTS12,
+  structuralOptions: ["count", "shapes"],
+  setup(context, options) {
+    let opts = options;
+    const count = Math.min(MAX_SHAPES, Math.max(1, Math.floor(opts.count)));
+    const x = new Float32Array(count);
+    const y = new Float32Array(count);
+    const z = new Float32Array(count);
+    const rotation = new Float32Array(count);
+    const spinRate = new Float32Array(count);
+    const radius = new Float32Array(count);
+    const driftX = new Float32Array(count);
+    const driftY = new Float32Array(count);
+    const sides = new Uint8Array(count);
+    const colorIndex = new Uint8Array(count);
+    const order = new Int32Array(count);
+    let seeded = false;
+    function seed() {
+      const { width, height } = context.size;
+      const rng = context.rng;
+      const colorCount = Math.max(1, context.colors.length);
+      const palette = opts.shapes.length > 0 ? opts.shapes : ALL_SHAPES;
+      for (let i = 0; i < count; i++) {
+        x[i] = rng.next() * width;
+        y[i] = rng.next() * height;
+        z[i] = rng.next();
+        rotation[i] = rng.angle();
+        spinRate[i] = rng.range(-1, 1) * opts.spin * chunkILKUL7GD_cjs.TAU;
+        radius[i] = opts.size * rng.range(0.55, 1.45);
+        const angle = rng.angle();
+        driftX[i] = Math.cos(angle);
+        driftY[i] = Math.sin(angle);
+        sides[i] = sidesFor(palette[rng.int(0, palette.length - 1)]);
+        colorIndex[i] = rng.int(0, colorCount - 1);
+        order[i] = i;
+      }
+      const indices = Array.from(order);
+      indices.sort((a, b) => z[b] - z[a]);
+      for (let i = 0; i < count; i++) order[i] = indices[i];
+      seeded = true;
+    }
+    return {
+      frame({ delta, quality }) {
+        const { ctx, size, surface, colors } = context;
+        const { width, height } = size;
+        if (width < 1 || height < 1) return;
+        if (!seeded) seed();
+        surface.clear();
+        if (colors.length === 0) return;
+        const drawn = opts.performance === "high" ? count : Math.max(3, Math.round(count * quality));
+        const focal = Math.max(0.05, opts.perspective);
+        const spread = Math.max(0, opts.depth);
+        const drift = opts.drift * opts.intensity;
+        const haze = chunkILKUL7GD_cjs.clamp(opts.haze, 0, 1);
+        const alphaScale = chunkILKUL7GD_cjs.clamp(opts.opacity, 0, 1);
+        const colorCount = Math.max(1, colors.length);
+        ctx.save();
+        ctx.globalCompositeOperation = opts.blend ?? "lighter";
+        const firstDrawn = count - drawn;
+        for (let k = 0; k < count; k++) {
+          const i = order[k];
+          const projected = focal / (focal + z[i] * spread);
+          x[i] += driftX[i] * drift * projected * delta;
+          y[i] += driftY[i] * drift * projected * delta;
+          rotation[i] += spinRate[i] * delta;
+          const margin = radius[i] * projected + opts.lineWidth * 2;
+          if (x[i] < -margin) x[i] = width + margin;
+          else if (x[i] > width + margin) x[i] = -margin;
+          if (y[i] < -margin) y[i] = height + margin;
+          else if (y[i] > height + margin) y[i] = -margin;
+          if (k < firstDrawn) continue;
+          const alpha = alphaScale * chunkILKUL7GD_cjs.lerp(1, haze, z[i]);
+          if (alpha <= 2e-3) continue;
+          const r = radius[i] * projected;
+          const color = colors[colorIndex[i] % colorCount];
+          ctx.save();
+          ctx.translate(x[i], y[i]);
+          ctx.rotate(rotation[i]);
+          ctx.globalAlpha = alpha;
+          ctx.beginPath();
+          if (sides[i] === CIRCLE) {
+            ctx.arc(0, 0, r, 0, chunkILKUL7GD_cjs.TAU);
+          } else {
+            const n = sides[i];
+            for (let v = 0; v < n; v++) {
+              const a = v / n * chunkILKUL7GD_cjs.TAU;
+              const px = Math.cos(a) * r;
+              const py = Math.sin(a) * r;
+              if (v === 0) ctx.moveTo(px, py);
+              else ctx.lineTo(px, py);
+            }
+            ctx.closePath();
+          }
+          if (opts.filled) {
+            ctx.fillStyle = chunk4ORYTFY3_cjs.toRgbString(color);
+            ctx.fill();
+          } else {
+            ctx.lineWidth = Math.max(0.3, opts.lineWidth * projected);
+            ctx.strokeStyle = chunk4ORYTFY3_cjs.toRgbString(color);
+            ctx.stroke();
+          }
+          ctx.restore();
+        }
+        ctx.restore();
+        ctx.globalAlpha = 1;
+        ctx.globalCompositeOperation = "source-over";
+      },
+      resize() {
+        seeded = false;
+      },
+      update(next) {
+        opts = {
+          ...opts,
+          ...next
+        };
+      }
+    };
+  }
+});
+
+// src/effects/geometry/orbit.ts
+var DEFAULTS13 = {
+  colors: ["#7cc4ff", "#a78bfa", "#5eead4", "#fbbf7c"],
+  speed: 1,
+  intensity: 1,
+  opacity: 1,
+  blur: 0,
+  blend: "lighter",
+  seed: 71,
+  interactive: false,
+  resolution: 1,
+  performance: "auto",
+  reducedMotion: "slow",
+  paused: false,
+  pauseOffscreen: true,
+  rings: 3,
+  perRing: 14,
+  radius: 0.42,
+  innerRadius: 0.45,
+  tilt: 0.34,
+  orbitSpeed: 0.05,
+  size: 3.2,
+  glow: 3,
+  counterRotate: true,
+  showOrbits: true,
+  orbitOpacity: 0.12,
+  core: 26
+};
+var MAX_RINGS = 12;
+var MAX_PER_RING = 80;
+var DEPTH_SCALE_FAR = 0.55;
+var DEPTH_SCALE_NEAR = 1.3;
+var DEPTH_ALPHA_FAR = 0.3;
+var DEPTH_ALPHA_NEAR = 1;
+var INNER_RING_SPEEDUP = 1.8;
+var orbit = defineEffect({
+  name: "orbit",
+  defaults: DEFAULTS13,
+  structuralOptions: ["rings", "perRing"],
+  setup(context, options) {
+    let opts = options;
+    const rings = Math.min(MAX_RINGS, Math.max(1, Math.floor(opts.rings)));
+    const perRing = Math.min(MAX_PER_RING, Math.max(1, Math.floor(opts.perRing)));
+    const total = rings * perRing;
+    const phase = new Float32Array(total);
+    const sizeScale = new Float32Array(total);
+    const colorIndex = new Uint8Array(total);
+    const ringPhase = new Float32Array(rings);
+    const rng = context.rng;
+    const colorCount = Math.max(1, context.colors.length);
+    for (let r = 0; r < rings; r++) {
+      ringPhase[r] = rng.angle();
+      for (let p = 0; p < perRing; p++) {
+        const i = r * perRing + p;
+        phase[i] = p / perRing * chunkILKUL7GD_cjs.TAU + rng.range(-0.12, 0.12);
+        sizeScale[i] = rng.range(0.7, 1.35);
+        colorIndex[i] = rng.int(0, colorCount - 1);
+      }
+    }
+    const gradients = new GradientCache(64);
+    return {
+      frame({ time, quality }) {
+        const { ctx, size, surface, colors } = context;
+        const { width, height } = size;
+        if (width < 1 || height < 1) return;
+        surface.clear();
+        if (colors.length === 0) return;
+        const cx = width / 2;
+        const cy = height / 2;
+        const outer = Math.min(width, height) * opts.radius;
+        const inner = outer * chunkILKUL7GD_cjs.clamp(opts.innerRadius, 0.05, 1);
+        const tilt = chunkILKUL7GD_cjs.clamp(opts.tilt, 0.02, 1);
+        const alphaScale = chunkILKUL7GD_cjs.clamp(opts.opacity * opts.intensity, 0, 1);
+        const count = colors.length;
+        const drawnPerRing = opts.performance === "high" ? perRing : Math.max(3, Math.round(perRing * quality));
+        ctx.save();
+        ctx.globalCompositeOperation = opts.blend ?? "lighter";
+        const drawPoints = (near) => {
+          for (let r = 0; r < rings; r++) {
+            const t = rings === 1 ? 1 : r / (rings - 1);
+            const ringRadius = chunkILKUL7GD_cjs.lerp(inner, outer, t);
+            const direction = opts.counterRotate && r % 2 === 1 ? -1 : 1;
+            const rate = opts.orbitSpeed * chunkILKUL7GD_cjs.TAU * direction * chunkILKUL7GD_cjs.lerp(INNER_RING_SPEEDUP, 1, t);
+            const base = ringPhase[r] + time * rate;
+            for (let p = 0; p < drawnPerRing; p++) {
+              const i = r * perRing + p;
+              const theta = base + phase[i];
+              const depth = Math.sin(theta);
+              if (near !== depth > 0) continue;
+              const d = depth * 0.5 + 0.5;
+              const alpha = alphaScale * chunkILKUL7GD_cjs.lerp(DEPTH_ALPHA_FAR, DEPTH_ALPHA_NEAR, d);
+              if (alpha <= 2e-3) continue;
+              const scale = chunkILKUL7GD_cjs.lerp(DEPTH_SCALE_FAR, DEPTH_SCALE_NEAR, d);
+              drawGlow(
+                ctx,
+                cx + Math.cos(theta) * ringRadius,
+                cy + depth * ringRadius * tilt,
+                opts.size * opts.glow * sizeScale[i] * scale,
+                colors[colorIndex[i] % count],
+                alpha,
+                gradients
+              );
+            }
+          }
+        };
+        drawPoints(false);
+        if (opts.showOrbits && opts.orbitOpacity > 0) {
+          const guide = colors[0];
+          ctx.globalAlpha = chunkILKUL7GD_cjs.clamp(opts.orbitOpacity * alphaScale, 0, 1);
+          ctx.strokeStyle = `rgb(${Math.round(guide.r * 255)},${Math.round(guide.g * 255)},${Math.round(guide.b * 255)})`;
+          ctx.lineWidth = 1;
+          for (let r = 0; r < rings; r++) {
+            const t = rings === 1 ? 1 : r / (rings - 1);
+            const ringRadius = chunkILKUL7GD_cjs.lerp(inner, outer, t);
+            ctx.beginPath();
+            ctx.ellipse(cx, cy, ringRadius, ringRadius * tilt, 0, 0, chunkILKUL7GD_cjs.TAU);
+            ctx.stroke();
+          }
+          ctx.globalAlpha = 1;
+        }
+        if (opts.core > 0) {
+          drawGlow(ctx, cx, cy, opts.core, colors[0], alphaScale, gradients);
+        }
+        drawPoints(true);
+        ctx.restore();
+        ctx.globalAlpha = 1;
+        ctx.globalCompositeOperation = "source-over";
+      },
+      update(next) {
+        opts = { ...opts, ...next };
+        gradients.clear();
+      },
+      destroy() {
+        gradients.clear();
+      }
+    };
+  }
+});
+
 // src/effects/surfaces/waves.ts
-var DEFAULTS7 = {
+var DEFAULTS14 = {
   colors: "abyss",
   speed: 1,
   intensity: 1,
@@ -1992,7 +3014,7 @@ var DEFAULTS7 = {
 };
 var waves = defineEffect({
   name: "waves",
-  defaults: DEFAULTS7,
+  defaults: DEFAULTS14,
   structuralOptions: ["layers"],
   setup(context, options) {
     let opts = options;
@@ -2001,7 +3023,7 @@ var waves = defineEffect({
     let crest = [];
     function build() {
       const count = Math.max(1, Math.floor(opts.layers));
-      const palette = chunk23GSSIMK_cjs.expandPalette(context.colors, count);
+      const palette = chunk4ORYTFY3_cjs.expandPalette(context.colors, count);
       const rng = context.rng;
       layers = [];
       for (let i = 0; i < count; i++) {
@@ -2087,7 +3109,7 @@ var waves = defineEffect({
 });
 
 // src/effects/surfaces/blob.ts
-var DEFAULTS8 = {
+var DEFAULTS15 = {
   colors: "ansh",
   speed: 1,
   intensity: 1,
@@ -2114,7 +3136,7 @@ var DEFAULTS8 = {
 };
 var blob = defineEffect({
   name: "blob",
-  defaults: DEFAULTS8,
+  defaults: DEFAULTS15,
   structuralOptions: ["count", "segments"],
   setup(context, options) {
     let opts = options;
@@ -2123,7 +3145,7 @@ var blob = defineEffect({
     let ring = [];
     function build() {
       const count = Math.max(1, Math.floor(opts.count));
-      const palette = chunk23GSSIMK_cjs.expandPalette(context.colors, count);
+      const palette = chunk4ORYTFY3_cjs.expandPalette(context.colors, count);
       const rng = context.rng;
       blobs = [];
       for (let i = 0; i < count; i++) {
@@ -2216,7 +3238,7 @@ var blob = defineEffect({
 });
 
 // src/effects/overlays/noise-layer.ts
-var DEFAULTS9 = {
+var DEFAULTS16 = {
   colors: ["#ffffff"],
   speed: 1,
   intensity: 1,
@@ -2243,7 +3265,7 @@ var DEFAULTS9 = {
 };
 var noiseLayer = defineEffect({
   name: "noise-layer",
-  defaults: DEFAULTS9,
+  defaults: DEFAULTS16,
   structuralOptions: ["tileSize", "frames", "grainSize", "monochrome"],
   setup(context, options) {
     let opts = options;
@@ -2334,7 +3356,7 @@ var noiseLayer = defineEffect({
 });
 
 // src/effects/overlays/spotlight.ts
-var DEFAULTS10 = {
+var DEFAULTS17 = {
   colors: ["#ffffff"],
   speed: 1,
   intensity: 0.35,
@@ -2361,7 +3383,7 @@ var DEFAULTS10 = {
 };
 var spotlight = defineEffect({
   name: "spotlight",
-  defaults: DEFAULTS10,
+  defaults: DEFAULTS17,
   setup(context, options) {
     let opts = options;
     let presence = opts.ambient ? 1 : 0;
@@ -2433,10 +3455,17 @@ var effects = {
   "animated-gradient": animatedGradient,
   "particle-field": particleField,
   constellation,
+  "powder-explosion": powderExplosion,
+  "strange-attractor": strangeAttractor,
+  swarm,
   meteors,
   rain,
   snow,
   fireflies,
+  "light-rays": lightRays,
+  smoke,
+  "floating-geometry": floatingGeometry,
+  orbit,
   waves,
   blob,
   "noise-layer": noiseLayer,
@@ -2457,23 +3486,30 @@ exports.drawDot = drawDot;
 exports.drawGlow = drawGlow;
 exports.effects = effects;
 exports.fireflies = fireflies;
+exports.floatingGeometry = floatingGeometry;
 exports.integrate = integrate;
+exports.lightRays = lightRays;
 exports.meshGradient = meshGradient;
 exports.meteors = meteors;
 exports.mountEffect = mountEffect;
 exports.noiseLayer = noiseLayer;
+exports.orbit = orbit;
 exports.particleField = particleField;
+exports.powderExplosion = powderExplosion;
 exports.rain = rain;
 exports.resetFilterSupport = resetFilterSupport;
+exports.smoke = smoke;
 exports.snow = snow;
 exports.spotlight = spotlight;
+exports.strangeAttractor = strangeAttractor;
 exports.supportsCanvasFilter = supportsCanvasFilter;
 exports.supportsOffscreenCanvas = supportsOffscreenCanvas;
 exports.supportsWorkerRendering = supportsWorkerRendering;
+exports.swarm = swarm;
 exports.traceClosedSpline = traceClosedSpline;
 exports.traceOpenSpline = traceOpenSpline;
 exports.traceRoundRect = traceRoundRect;
 exports.waves = waves;
 exports.wrapBounds = wrapBounds;
-//# sourceMappingURL=chunk-R7UJ7MWP.cjs.map
-//# sourceMappingURL=chunk-R7UJ7MWP.cjs.map
+//# sourceMappingURL=chunk-OSNUN5JJ.cjs.map
+//# sourceMappingURL=chunk-OSNUN5JJ.cjs.map