@ansh-ui/core 0.2.0 → 0.3.1

package/dist/{chunk-56NNBIAO.js → chunk-2DOA43UB.js}

@@ -1,8 +1,8 @@
-import { toRgbString, resolvePalette, expandPalette } from './chunk-KTUBCQC3.js';
+import { toRgbString, resolvePalette, expandPalette } from './chunk-YHSCAGCI.js';
 import { createNoise } from './chunk-FAVIEION.js';
-import { createRng } from './chunk-YFQXRC5R.js';
-import { getRegistry, observeResize, resolveMotion, getTicker, observeIntersection, onReducedMotionChange, trackPointer } from './chunk-BOQQHICI.js';
+import { getRegistry, observeResize, resolveMotion, getTicker, observeIntersection, onReducedMotionChange, trackPointer } from './chunk-GQH5ZHPB.js';
 import { parseColor } from './chunk-QALZKHWH.js';
+import { createRng } from './chunk-YFQXRC5R.js';
 import { clamp, TAU, lerp, radians } from './chunk-KU2C6GEA.js';
 
 // src/render/surface.ts
@@ -1418,8 +1418,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, 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 - clamp(opts.drag, 0, 0.999), delta);
+        const gravity = opts.gravity * delta;
+        const alphaScale = 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 = 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 = 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 = 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 * 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 - clamp(opts.drag, 0, 0.999), delta);
+        const invFast = 1 / Math.max(1, opts.fastSpeed);
+        const alpha = 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 = clamp(axSum * delta, -MAX_DELTA_V, MAX_DELTA_V);
+          const dvy = 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(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,
@@ -1445,7 +1884,7 @@ var DEFAULTS5 = {
 var MAX_METEORS = 200;
 var meteors = defineEffect({
   name: "meteors",
-  defaults: DEFAULTS5,
+  defaults: DEFAULTS8,
   structuralOptions: ["count"],
   setup(context, options) {
     let opts = options;
@@ -1833,7 +2272,7 @@ var snow = defineEffect({
 });
 
 // src/effects/atmosphere/fireflies.ts
-var DEFAULTS6 = {
+var DEFAULTS9 = {
   colors: ["#ffe98a", "#c8ff8a", "#8affd4"],
   speed: 1,
   intensity: 1,
@@ -1857,7 +2296,7 @@ var DEFAULTS6 = {
 };
 var fireflies = defineEffect({
   name: "fireflies",
-  defaults: DEFAULTS6,
+  defaults: DEFAULTS9,
   structuralOptions: ["count"],
   setup(context, options) {
     let opts = options;
@@ -1964,8 +2403,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 = 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 = 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 * TAU) * opts.sway;
+        const half = opts.spread / 2;
+        const step = opts.spread / drawn;
+        const flickerDepth = clamp(opts.flicker, 0, 1);
+        const alphaScale = 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 = clamp(Math.max(MIN_BRIGHTNESS, varied) * alphaScale, 0, 1);
+          if (alpha <= 2e-3) continue;
+          const halfWidth = opts.rayWidth * widthScale[i];
+          const spreadFactor = 1 + 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 - clamp(opts.drag, 0, 0.999), delta);
+        const turbulence = opts.turbulence * opts.intensity;
+        const rise = opts.rise * opts.intensity;
+        const peak = clamp(opts.density, 0, 1) * 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 = 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 * 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 = clamp(opts.haze, 0, 1);
+        const alphaScale = 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 * 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, TAU);
+          } else {
+            const n = sides[i];
+            for (let v = 0; v < n; v++) {
+              const a = v / n * 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 = toRgbString(color);
+            ctx.fill();
+          } else {
+            ctx.lineWidth = Math.max(0.3, opts.lineWidth * projected);
+            ctx.strokeStyle = 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 * 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 * clamp(opts.innerRadius, 0.05, 1);
+        const tilt = clamp(opts.tilt, 0.02, 1);
+        const alphaScale = 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 = lerp(inner, outer, t);
+            const direction = opts.counterRotate && r % 2 === 1 ? -1 : 1;
+            const rate = opts.orbitSpeed * TAU * direction * 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 * lerp(DEPTH_ALPHA_FAR, DEPTH_ALPHA_NEAR, d);
+              if (alpha <= 2e-3) continue;
+              const scale = 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 = 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 = lerp(inner, outer, t);
+            ctx.beginPath();
+            ctx.ellipse(cx, cy, ringRadius, ringRadius * tilt, 0, 0, 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,
@@ -1990,7 +3012,7 @@ var DEFAULTS7 = {
 };
 var waves = defineEffect({
   name: "waves",
-  defaults: DEFAULTS7,
+  defaults: DEFAULTS14,
   structuralOptions: ["layers"],
   setup(context, options) {
     let opts = options;
@@ -2085,7 +3107,7 @@ var waves = defineEffect({
 });
 
 // src/effects/surfaces/blob.ts
-var DEFAULTS8 = {
+var DEFAULTS15 = {
   colors: "ansh",
   speed: 1,
   intensity: 1,
@@ -2112,7 +3134,7 @@ var DEFAULTS8 = {
 };
 var blob = defineEffect({
   name: "blob",
-  defaults: DEFAULTS8,
+  defaults: DEFAULTS15,
   structuralOptions: ["count", "segments"],
   setup(context, options) {
     let opts = options;
@@ -2214,7 +3236,7 @@ var blob = defineEffect({
 });
 
 // src/effects/overlays/noise-layer.ts
-var DEFAULTS9 = {
+var DEFAULTS16 = {
   colors: ["#ffffff"],
   speed: 1,
   intensity: 1,
@@ -2241,7 +3263,7 @@ var DEFAULTS9 = {
 };
 var noiseLayer = defineEffect({
   name: "noise-layer",
-  defaults: DEFAULTS9,
+  defaults: DEFAULTS16,
   structuralOptions: ["tileSize", "frames", "grainSize", "monochrome"],
   setup(context, options) {
     let opts = options;
@@ -2332,7 +3354,7 @@ var noiseLayer = defineEffect({
 });
 
 // src/effects/overlays/spotlight.ts
-var DEFAULTS10 = {
+var DEFAULTS17 = {
   colors: ["#ffffff"],
   speed: 1,
   intensity: 0.35,
@@ -2359,7 +3381,7 @@ var DEFAULTS10 = {
 };
 var spotlight = defineEffect({
   name: "spotlight",
-  defaults: DEFAULTS10,
+  defaults: DEFAULTS17,
   setup(context, options) {
     let opts = options;
     let presence = opts.ambient ? 1 : 0;
@@ -2431,16 +3453,23 @@ 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,
   spotlight
 };
 
-export { GradientCache, ParticleBuffer, SpatialGrid, ageAndCull, animatedGradient, aurora, blob, constellation, createSurface, defineEffect, drawDot, drawGlow, effects, fireflies, integrate, meshGradient, meteors, mountEffect, noiseLayer, particleField, rain, resetFilterSupport, snow, spotlight, supportsCanvasFilter, supportsOffscreenCanvas, supportsWorkerRendering, traceClosedSpline, traceOpenSpline, traceRoundRect, waves, wrapBounds };
-//# sourceMappingURL=chunk-56NNBIAO.js.map
-//# sourceMappingURL=chunk-56NNBIAO.js.map
+export { GradientCache, ParticleBuffer, SpatialGrid, ageAndCull, animatedGradient, aurora, blob, constellation, createSurface, defineEffect, drawDot, drawGlow, effects, fireflies, floatingGeometry, integrate, lightRays, meshGradient, meteors, mountEffect, noiseLayer, orbit, particleField, powderExplosion, rain, resetFilterSupport, smoke, snow, spotlight, strangeAttractor, supportsCanvasFilter, supportsOffscreenCanvas, supportsWorkerRendering, swarm, traceClosedSpline, traceOpenSpline, traceRoundRect, waves, wrapBounds };
+//# sourceMappingURL=chunk-2DOA43UB.js.map
+//# sourceMappingURL=chunk-2DOA43UB.js.map