@ansh-ui/core 0.2.0 → 0.3.1

package/dist/effects.cjs

@@ -1,99 +1,127 @@
 'use strict';
 
-var chunkR7UJ7MWP_cjs = require('./chunk-R7UJ7MWP.cjs');
-require('./chunk-23GSSIMK.cjs');
+var chunkOSNUN5JJ_cjs = require('./chunk-OSNUN5JJ.cjs');
+require('./chunk-4ORYTFY3.cjs');
 require('./chunk-DXJ63QAR.cjs');
-require('./chunk-FNR35HTL.cjs');
-require('./chunk-MMO7KO53.cjs');
+require('./chunk-FNR4B3KY.cjs');
 require('./chunk-LGA3N3YJ.cjs');
 require('./chunk-GJRIHN76.cjs');
+require('./chunk-FNR35HTL.cjs');
 require('./chunk-ILKUL7GD.cjs');
 
 
 
 Object.defineProperty(exports, "ParticleBuffer", {
   enumerable: true,
-  get: function () { return chunkR7UJ7MWP_cjs.ParticleBuffer; }
+  get: function () { return chunkOSNUN5JJ_cjs.ParticleBuffer; }
 });
 Object.defineProperty(exports, "SpatialGrid", {
   enumerable: true,
-  get: function () { return chunkR7UJ7MWP_cjs.SpatialGrid; }
+  get: function () { return chunkOSNUN5JJ_cjs.SpatialGrid; }
 });
 Object.defineProperty(exports, "ageAndCull", {
   enumerable: true,
-  get: function () { return chunkR7UJ7MWP_cjs.ageAndCull; }
+  get: function () { return chunkOSNUN5JJ_cjs.ageAndCull; }
 });
 Object.defineProperty(exports, "animatedGradient", {
   enumerable: true,
-  get: function () { return chunkR7UJ7MWP_cjs.animatedGradient; }
+  get: function () { return chunkOSNUN5JJ_cjs.animatedGradient; }
 });
 Object.defineProperty(exports, "aurora", {
   enumerable: true,
-  get: function () { return chunkR7UJ7MWP_cjs.aurora; }
+  get: function () { return chunkOSNUN5JJ_cjs.aurora; }
 });
 Object.defineProperty(exports, "blob", {
   enumerable: true,
-  get: function () { return chunkR7UJ7MWP_cjs.blob; }
+  get: function () { return chunkOSNUN5JJ_cjs.blob; }
 });
 Object.defineProperty(exports, "constellation", {
   enumerable: true,
-  get: function () { return chunkR7UJ7MWP_cjs.constellation; }
+  get: function () { return chunkOSNUN5JJ_cjs.constellation; }
 });
 Object.defineProperty(exports, "defineEffect", {
   enumerable: true,
-  get: function () { return chunkR7UJ7MWP_cjs.defineEffect; }
+  get: function () { return chunkOSNUN5JJ_cjs.defineEffect; }
 });
 Object.defineProperty(exports, "effects", {
   enumerable: true,
-  get: function () { return chunkR7UJ7MWP_cjs.effects; }
+  get: function () { return chunkOSNUN5JJ_cjs.effects; }
 });
 Object.defineProperty(exports, "fireflies", {
   enumerable: true,
-  get: function () { return chunkR7UJ7MWP_cjs.fireflies; }
+  get: function () { return chunkOSNUN5JJ_cjs.fireflies; }
+});
+Object.defineProperty(exports, "floatingGeometry", {
+  enumerable: true,
+  get: function () { return chunkOSNUN5JJ_cjs.floatingGeometry; }
 });
 Object.defineProperty(exports, "integrate", {
   enumerable: true,
-  get: function () { return chunkR7UJ7MWP_cjs.integrate; }
+  get: function () { return chunkOSNUN5JJ_cjs.integrate; }
+});
+Object.defineProperty(exports, "lightRays", {
+  enumerable: true,
+  get: function () { return chunkOSNUN5JJ_cjs.lightRays; }
 });
 Object.defineProperty(exports, "meshGradient", {
   enumerable: true,
-  get: function () { return chunkR7UJ7MWP_cjs.meshGradient; }
+  get: function () { return chunkOSNUN5JJ_cjs.meshGradient; }
 });
 Object.defineProperty(exports, "meteors", {
   enumerable: true,
-  get: function () { return chunkR7UJ7MWP_cjs.meteors; }
+  get: function () { return chunkOSNUN5JJ_cjs.meteors; }
 });
 Object.defineProperty(exports, "mountEffect", {
   enumerable: true,
-  get: function () { return chunkR7UJ7MWP_cjs.mountEffect; }
+  get: function () { return chunkOSNUN5JJ_cjs.mountEffect; }
 });
 Object.defineProperty(exports, "noiseLayer", {
   enumerable: true,
-  get: function () { return chunkR7UJ7MWP_cjs.noiseLayer; }
+  get: function () { return chunkOSNUN5JJ_cjs.noiseLayer; }
+});
+Object.defineProperty(exports, "orbit", {
+  enumerable: true,
+  get: function () { return chunkOSNUN5JJ_cjs.orbit; }
 });
 Object.defineProperty(exports, "particleField", {
   enumerable: true,
-  get: function () { return chunkR7UJ7MWP_cjs.particleField; }
+  get: function () { return chunkOSNUN5JJ_cjs.particleField; }
+});
+Object.defineProperty(exports, "powderExplosion", {
+  enumerable: true,
+  get: function () { return chunkOSNUN5JJ_cjs.powderExplosion; }
 });
 Object.defineProperty(exports, "rain", {
   enumerable: true,
-  get: function () { return chunkR7UJ7MWP_cjs.rain; }
+  get: function () { return chunkOSNUN5JJ_cjs.rain; }
+});
+Object.defineProperty(exports, "smoke", {
+  enumerable: true,
+  get: function () { return chunkOSNUN5JJ_cjs.smoke; }
 });
 Object.defineProperty(exports, "snow", {
   enumerable: true,
-  get: function () { return chunkR7UJ7MWP_cjs.snow; }
+  get: function () { return chunkOSNUN5JJ_cjs.snow; }
 });
 Object.defineProperty(exports, "spotlight", {
   enumerable: true,
-  get: function () { return chunkR7UJ7MWP_cjs.spotlight; }
+  get: function () { return chunkOSNUN5JJ_cjs.spotlight; }
+});
+Object.defineProperty(exports, "strangeAttractor", {
+  enumerable: true,
+  get: function () { return chunkOSNUN5JJ_cjs.strangeAttractor; }
+});
+Object.defineProperty(exports, "swarm", {
+  enumerable: true,
+  get: function () { return chunkOSNUN5JJ_cjs.swarm; }
 });
 Object.defineProperty(exports, "waves", {
   enumerable: true,
-  get: function () { return chunkR7UJ7MWP_cjs.waves; }
+  get: function () { return chunkOSNUN5JJ_cjs.waves; }
 });
 Object.defineProperty(exports, "wrapBounds", {
   enumerable: true,
-  get: function () { return chunkR7UJ7MWP_cjs.wrapBounds; }
+  get: function () { return chunkOSNUN5JJ_cjs.wrapBounds; }
 });
 //# sourceMappingURL=effects.cjs.map
 //# sourceMappingURL=effects.cjs.map

package/dist/effects.d.cts

@@ -1,5 +1,5 @@
-export { A as AnimatedGradientOptions, a as AuroraOptions, B as BaseEffectOptions, c as BlobOptions, C as ConstellationOptions, E as EffectContext, d as EffectDefinition, e as EffectFrame, f as EffectHandle, g as EffectInstance, h as EffectName, F as FirefliesOptions, M as MeshGradientOptions, i as MeteorsOptions, N as NoiseLayerOptions, P as ParticleBuffer, j as ParticleFieldOptions, R as RainOptions, n as SnowOptions, o as SpatialGrid, p as SpotlightOptions, W as WavesOptions, s as ageAndCull, t as animatedGradient, u as aurora, v as blob, w as constellation, y as defineEffect, H as effects, I as fireflies, J as integrate, K as meshGradient, L as meteors, O as mountEffect, Q as noiseLayer, T as particleField, V as rain, Y as snow, Z as spotlight, a5 as waves, a6 as wrapBounds } from './index-DHOfsEIn.cjs';
-import './reduced-motion-D0LUgZle.cjs';
-import './random--4mSc5Lp.cjs';
+export { A as AnimatedGradientOptions, a as AttractorKind, b as AuroraOptions, B as BaseEffectOptions, d as BlobOptions, C as ConstellationOptions, E as EffectContext, e as EffectDefinition, f as EffectFrame, g as EffectHandle, h as EffectInstance, i as EffectName, F as FirefliesOptions, j as FloatingGeometryOptions, G as GeometryShape, L as LightRaysOptions, M as MeshGradientOptions, l as MeteorsOptions, N as NoiseLayerOptions, O as OrbitOptions, P as ParticleBuffer, m as ParticleFieldOptions, q as PowderExplosionOptions, R as RainOptions, r as SmokeOptions, s as SnowOptions, t as SpatialGrid, u as SpotlightOptions, v as StrangeAttractorOptions, y as SwarmOptions, W as WavesOptions, z as ageAndCull, D as animatedGradient, H as aurora, I as blob, J as constellation, Q as defineEffect, X as effects, Y as fireflies, Z as floatingGeometry, _ as integrate, $ as lightRays, a0 as meshGradient, a1 as meteors, a2 as mountEffect, a3 as noiseLayer, a4 as orbit, a5 as particleField, a6 as powderExplosion, a7 as rain, a9 as smoke, aa as snow, ab as spotlight, ac as strangeAttractor, ag as swarm, al as waves, am as wrapBounds } from './index-DmJ3i1Tr.cjs';
+import './reduced-motion-DaeXwgzb.cjs';
+import './random-YnhdaiIx.cjs';
 import './noise.cjs';
-import './palette-6HkVltYU.cjs';
+import './palette-Dcomsp9R.cjs';

package/dist/effects.d.ts

@@ -1,5 +1,5 @@
-export { A as AnimatedGradientOptions, a as AuroraOptions, B as BaseEffectOptions, c as BlobOptions, C as ConstellationOptions, E as EffectContext, d as EffectDefinition, e as EffectFrame, f as EffectHandle, g as EffectInstance, h as EffectName, F as FirefliesOptions, M as MeshGradientOptions, i as MeteorsOptions, N as NoiseLayerOptions, P as ParticleBuffer, j as ParticleFieldOptions, R as RainOptions, n as SnowOptions, o as SpatialGrid, p as SpotlightOptions, W as WavesOptions, s as ageAndCull, t as animatedGradient, u as aurora, v as blob, w as constellation, y as defineEffect, H as effects, I as fireflies, J as integrate, K as meshGradient, L as meteors, O as mountEffect, Q as noiseLayer, T as particleField, V as rain, Y as snow, Z as spotlight, a5 as waves, a6 as wrapBounds } from './index-CCdpefMp.js';
-import './reduced-motion-D0LUgZle.js';
-import './random--4mSc5Lp.js';
+export { A as AnimatedGradientOptions, a as AttractorKind, b as AuroraOptions, B as BaseEffectOptions, d as BlobOptions, C as ConstellationOptions, E as EffectContext, e as EffectDefinition, f as EffectFrame, g as EffectHandle, h as EffectInstance, i as EffectName, F as FirefliesOptions, j as FloatingGeometryOptions, G as GeometryShape, L as LightRaysOptions, M as MeshGradientOptions, l as MeteorsOptions, N as NoiseLayerOptions, O as OrbitOptions, P as ParticleBuffer, m as ParticleFieldOptions, q as PowderExplosionOptions, R as RainOptions, r as SmokeOptions, s as SnowOptions, t as SpatialGrid, u as SpotlightOptions, v as StrangeAttractorOptions, y as SwarmOptions, W as WavesOptions, z as ageAndCull, D as animatedGradient, H as aurora, I as blob, J as constellation, Q as defineEffect, X as effects, Y as fireflies, Z as floatingGeometry, _ as integrate, $ as lightRays, a0 as meshGradient, a1 as meteors, a2 as mountEffect, a3 as noiseLayer, a4 as orbit, a5 as particleField, a6 as powderExplosion, a7 as rain, a9 as smoke, aa as snow, ab as spotlight, ac as strangeAttractor, ag as swarm, al as waves, am as wrapBounds } from './index-SO8zHlVo.js';
+import './reduced-motion-DaeXwgzb.js';
+import './random-YnhdaiIx.js';
 import './noise.js';
-import './palette-6HkVltYU.js';
+import './palette-Dcomsp9R.js';

package/dist/effects.js

@@ -1,10 +1,10 @@
-export { ParticleBuffer, SpatialGrid, ageAndCull, animatedGradient, aurora, blob, constellation, defineEffect, effects, fireflies, integrate, meshGradient, meteors, mountEffect, noiseLayer, particleField, rain, snow, spotlight, waves, wrapBounds } from './chunk-56NNBIAO.js';
-import './chunk-KTUBCQC3.js';
+export { ParticleBuffer, SpatialGrid, ageAndCull, animatedGradient, aurora, blob, constellation, defineEffect, effects, fireflies, floatingGeometry, integrate, lightRays, meshGradient, meteors, mountEffect, noiseLayer, orbit, particleField, powderExplosion, rain, smoke, snow, spotlight, strangeAttractor, swarm, waves, wrapBounds } from './chunk-2DOA43UB.js';
+import './chunk-YHSCAGCI.js';
 import './chunk-FAVIEION.js';
-import './chunk-YFQXRC5R.js';
-import './chunk-BOQQHICI.js';
+import './chunk-GQH5ZHPB.js';
 import './chunk-QALZKHWH.js';
 import './chunk-7MEIXWPH.js';
+import './chunk-YFQXRC5R.js';
 import './chunk-KU2C6GEA.js';
 //# sourceMappingURL=effects.js.map
 //# sourceMappingURL=effects.js.map

package/dist/{index-CQEEPu-D.d.ts → index-DN0bQII7.d.ts}

@@ -1,4 +1,4 @@
-import { R as ReducedMotionStrategy } from './reduced-motion-D0LUgZle.js';
+import { R as ReducedMotionStrategy } from './reduced-motion-DaeXwgzb.js';
 import { E as EasingInput } from './types-B1FLLf3-.js';
 
 /**
@@ -61,6 +61,49 @@ declare function defineBehaviour<Options extends BaseBehaviourOptions, El extend
  */
 declare function captureStyles<K extends keyof CSSStyleDeclaration & string>(element: HTMLElement, properties: readonly K[]): () => void;
 
+/**
+ * Text Scramble — text that resolves out of noise, character by character.
+ *
+ * **The real text is the source, never the destination.** The element's existing `textContent` is
+ * captured on setup and scrambled *from*, rather than the element starting empty and being filled
+ * in. This is the same no-JS safety property `scrollReveal` is built around: if this script fails
+ * to load, is blocked, or throws, the reader sees the finished text rather than an empty element.
+ * An implementation that types into an empty node has shipped blank headlines to a lot of sites.
+ *
+ * **Whitespace never scrambles.** Spaces and newlines are passed through untouched, so the word
+ * shape and line breaks hold still while the glyphs churn. Scrambling spaces makes the text
+ * visibly reflow on every frame, which is both uglier and far more expensive.
+ *
+ * **Glyphs change on their own clock, not per frame.** Swapping every unsettled character every
+ * frame ties the churn rate to the refresh rate — unreadably fast at 120 Hz, sluggish at 30. A
+ * separate `cycleSpeed` in changes-per-second keeps the texture identical on any display.
+ *
+ * **Settling is staggered, not simultaneous.** Each character settles at `index × stagger`, so the
+ * text resolves as a wave. Settling everything at once is just a cross-fade with extra steps.
+ *
+ * Operates on the element's text content, so it expects a text-only element — a `<span>` or
+ * heading, not a container with child elements, which would be replaced.
+ */
+interface TextScrambleOptions extends BaseBehaviourOptions {
+    /** Glyph pool sampled while a character is unsettled. */
+    chars?: string;
+    /** Seconds a single character churns before settling. Default `0.55`. */
+    duration?: number;
+    /** Seconds between one character settling and the next. Default `0.035`. */
+    stagger?: number;
+    /** Glyph changes per second, independent of frame rate. Default `26`. */
+    cycleSpeed?: number;
+    /** What starts it. Default `'view'`. */
+    trigger?: 'mount' | 'view' | 'hover';
+    /** Re-run on every re-entry or re-hover rather than only the first. Default `false`. */
+    repeat?: boolean;
+    /** How much of the element must be visible for the `'view'` trigger, in `[0, 1]`. Default `0.3`. */
+    threshold?: number;
+    /** Seed for the glyph choices. Default `1`. */
+    seed?: number | string;
+}
+declare const textScramble: BehaviourDefinition<TextScrambleOptions, HTMLElement>;
+
 /**
  * Ripple — a wave that expands from the point of contact.
  *
@@ -429,7 +472,9 @@ declare const behaviours: {
     readonly 'scroll-reveal': BehaviourDefinition<ScrollRevealOptions, HTMLElement>;
     readonly parallax: BehaviourDefinition<ParallaxOptions, HTMLElement>;
     readonly ripple: BehaviourDefinition<RippleOptions, HTMLElement>;
+    readonly 'text-scramble': BehaviourDefinition<TextScrambleOptions, HTMLElement>;
 };
 type BehaviourName = keyof typeof behaviours;
 
-export { type BaseBehaviourOptions as B, type MagneticOptions as M, type ParallaxOptions as P, type RippleOptions as R, type StaggerOptions as S, type TiltOptions as T, type BehaviourDefinition as a, type BehaviourHandle as b, type BehaviourInstance as c, type BehaviourName as d, type MarqueeOptions as e, type ScrollRevealOptions as f, type SplitTextOptions as g, type SplitTextResult as h, type SplitUnit as i, type StaggerFrom as j, behaviours as k, captureStyles as l, defineBehaviour as m, getSplitResult as n, magnetic as o, marquee as p, mountBehaviour as q, parallax as r, ripple as s, scrollReveal as t, split as u, splitText as v, stagger as w, staggerDuration as x, tilt as y };
+export { tilt as A, behaviours as l, captureStyles as m, defineBehaviour as n, getSplitResult as o, magnetic as p, marquee as q, mountBehaviour as r, parallax as s, ripple as t, scrollReveal as u, split as v, splitText as w, stagger as x, staggerDuration as y, textScramble as z };
+export type { BaseBehaviourOptions as B, MagneticOptions as M, ParallaxOptions as P, RippleOptions as R, StaggerOptions as S, TextScrambleOptions as T, BehaviourDefinition as a, BehaviourHandle as b, BehaviourInstance as c, BehaviourName as d, MarqueeOptions as e, ScrollRevealOptions as f, SplitTextOptions as g, SplitTextResult as h, SplitUnit as i, StaggerFrom as j, TiltOptions as k };

package/dist/{index-DHOfsEIn.d.cts → index-DmJ3i1Tr.d.cts}

@@ -1,7 +1,7 @@
-import { U as Unsubscribe, R as ReducedMotionStrategy, a as FrameState } from './reduced-motion-D0LUgZle.cjs';
-import { R as Rng } from './random--4mSc5Lp.cjs';
+import { U as Unsubscribe, R as ReducedMotionStrategy, a as FrameState } from './reduced-motion-DaeXwgzb.cjs';
+import { R as Rng } from './random-YnhdaiIx.cjs';
 import { Noise } from './noise.cjs';
-import { R as Rgb, a as ColorInput, P as PaletteName } from './palette-6HkVltYU.cjs';
+import { R as Rgb, a as ColorInput, P as PaletteName } from './palette-Dcomsp9R.cjs';
 
 /**
  * Unified pointer tracking.
@@ -689,6 +689,138 @@ interface ConstellationOptions extends BaseEffectOptions {
 }
 declare const constellation: EffectDefinition<ConstellationOptions>;
 
+/**
+ * Powder explosion — bursts of fine particles that decelerate hard and settle.
+ *
+ * **Drag is what makes it powder.** Fireworks and powder differ almost entirely in how fast the
+ * ejecta lose speed. With low drag, particles travel in near-straight lines and the burst reads as
+ * a firework; with drag high enough that most of the speed is gone within a few hundred
+ * milliseconds, the same particles bloom outward and then hang, which is what powder does. The
+ * default sits deliberately in the second regime.
+ *
+ * **Ejection speed is skewed, not uniform.** Sampling speed uniformly puts a hard edge on the
+ * expanding shell, because every particle reaches its maximum radius at the same moment. Squaring
+ * a uniform sample biases toward the slower end, so the burst has a dense core and a sparse
+ * fringe — the distribution real ejecta have.
+ *
+ * **Bursts arrive as a Poisson process.** Fixed intervals read as a machine. Exponential
+ * inter-arrival times give the clustering and lulls that make repeated bursts feel incidental,
+ * the same reasoning `meteors` uses.
+ */
+interface PowderExplosionOptions extends BaseEffectOptions {
+    /** Particles per burst. Default `70`. */
+    burstSize?: number;
+    /** Average bursts per second. Default `0.8`. */
+    burstRate?: number;
+    /** Peak ejection speed in pixels per second. Default `420`. */
+    force?: number;
+    /** Velocity retained per second, in `[0, 1)`. High values are what make it read as powder. Default `0.92`. */
+    drag?: number;
+    /** Downward acceleration in pixels per second squared. Default `90`. */
+    gravity?: number;
+    /** Particle lifetime in seconds. Default `1.9`. */
+    life?: number;
+    /** Particle radius in pixels. Default `2.6`. */
+    size?: number;
+    /** Glow radius as a multiple of `size`. Default `2.8`. */
+    glow?: number;
+    /** Burst at the pointer when it is pressed. Default `true`. */
+    burstOnPress?: boolean;
+}
+declare const powderExplosion: EffectDefinition<PowderExplosionOptions>;
+
+/**
+ * Strange attractor — a chaotic map plotted as a drifting cloud of points.
+ *
+ * The classic 2D attractors (Clifford, de Jong, Svensson) are four-parameter iterated maps. Feed a
+ * point back through one repeatedly and it never repeats and never escapes; it wanders forever
+ * across a fixed, intricate shape. Plotting many such points at once draws that shape out of noise.
+ *
+ * **Many walkers, one step each — not one walker, many steps.** The textbook renderer iterates a
+ * single point thousands of times per frame and plots every position, which produces a *static*
+ * picture drawn progressively. Stepping a few thousand independent walkers once per frame instead
+ * gives the same structure while every point is genuinely in motion, which is what makes this work
+ * as a background rather than a plot.
+ *
+ * **Trails come from erasing, not from painting over.** Fading the canvas by drawing a translucent
+ * background rectangle would need to know the page's background colour, and would be wrong on any
+ * other. Compositing with `destination-out` lowers the alpha of what is already there, so trails
+ * fade to *transparent* and the effect stays composable over anything.
+ *
+ * **The parameters drift.** Held constant, the attractor is a fixed shape with points crawling
+ * over it. Moving `a`–`d` slowly on incommensurable sines makes the shape itself breathe and turn
+ * inside out, which is where almost all of the visual interest is.
+ */
+/** Which iterated map to plot. All four take the same `a`–`d` parameters. */
+type AttractorKind = 'clifford' | 'dejong' | 'svensson';
+interface StrangeAttractorOptions extends BaseEffectOptions {
+    /** Which map to iterate. Default `'clifford'`. */
+    kind?: AttractorKind;
+    /** Walkers stepped and plotted each frame. Default `2600`. */
+    count?: number;
+    /** How far the parameters wander from their seeded base. `0` freezes the shape. Default `0.12`. */
+    drift?: number;
+    /** How fast the parameters wander. Default `0.05`. */
+    driftSpeed?: number;
+    /** Plotted point radius in pixels. Default `0.9`. */
+    size?: number;
+    /** Per-point alpha, in `[0, 1]`. Low values are what let density build up. Default `0.34`. */
+    pointOpacity?: number;
+    /** How quickly trails fade, in `[0, 1]`. `0` leaves permanent trails, `1` clears each frame. Default `0.12`. */
+    fade?: number;
+    /** Fraction of the smaller canvas dimension the attractor spans. Default `0.42`. */
+    scale?: number;
+}
+declare const strangeAttractor: EffectDefinition<StrangeAttractorOptions>;
+
+/**
+ * Swarm — particles bound to moving attractors, orbiting rather than collapsing.
+ *
+ * **Pure attraction does not work.** Accelerate particles straight at a point and they all arrive,
+ * overshoot, and oscillate through it — within a couple of seconds the field is a flickering line
+ * through the centre. Adding a force *perpendicular* to the pull gives each particle angular
+ * momentum, so it falls into an orbit instead of a collision. `swirl` is that tangential term, and
+ * it is the whole difference between a swarm and a drain.
+ *
+ * **The force is softened, not inverse-square.** Real gravity goes to infinity at zero distance,
+ * which in a fixed timestep means a particle that passes close to an attractor is flung out at
+ * enormous speed and never returns. Dividing by `distance + softening` bounds the force, which is
+ * the standard fix in n-body simulation and is what keeps the swarm stable indefinitely.
+ *
+ * **Attractors move on incommensurable Lissajous paths**, so the swarm never settles into a
+ * repeating figure — the same reasoning `mesh-gradient` uses for its control points.
+ *
+ * **Speed drives colour.** Each particle picks its colour from where its speed sits in the palette,
+ * so the fast inner orbits and the slow outer ones separate visually. Colouring by index instead
+ * would scatter the palette evenly and hide the structure the physics is producing.
+ */
+interface SwarmOptions extends BaseEffectOptions {
+    /** Particles. Default `900`. */
+    count?: number;
+    /** Moving attractors. Default `3`. */
+    attractors?: number;
+    /**
+     * Peak pull, in pixels per second squared — the acceleration a particle feels *at* an
+     * attractor. Halves at `softening` pixels away.
+     */
+    gravity?: number;
+    /** Tangential force as a fraction of the pull. `0` collapses the swarm into the centre. Default `0.85`. */
+    swirl?: number;
+    /** Distance added to the denominator, bounding the force near an attractor. Default `70`. */
+    softening?: number;
+    /** Velocity retained per second, in `[0, 1)`. Default `0.45`. */
+    drag?: number;
+    /** How fast the attractors travel their paths. Default `0.08`. */
+    attractorSpeed?: number;
+    /** Particle radius in pixels. Default `1.4`. */
+    size?: number;
+    /** Speed, in pixels per second, treated as the top of the colour ramp. Default `320`. */
+    fastSpeed?: number;
+    /** Pull toward the pointer, as a multiple of `gravity`. `0` ignores it. Default `1.6`. */
+    pointerGravity?: number;
+}
+declare const swarm: EffectDefinition<SwarmOptions>;
+
 /**
  * Meteor Shower — streaks that fall across the canvas and fade.
  *
@@ -802,6 +934,192 @@ interface FirefliesOptions extends BaseEffectOptions {
 }
 declare const fireflies: EffectDefinition<FirefliesOptions>;
 
+/**
+ * Light rays — volumetric shafts fanning from a source point.
+ *
+ * Three details separate this from a starburst clip-art:
+ *
+ * **The fan is uneven.** Rays are spaced evenly and then jittered by a fixed per-ray offset drawn
+ * once from the seeded RNG. Perfectly even spacing reads as a sunburst *graphic*; real shafts are
+ * gaps between whatever is occluding the light, and occluders are not evenly spaced.
+ *
+ * **Brightness is noise-driven, not sinusoidal.** Each ray samples an fBm field at its own offset,
+ * so shafts brighten and fade independently and never fall into a visible collective rhythm — the
+ * look of light through moving foliage or drifting dust rather than a pulsing lamp.
+ *
+ * **One gradient per colour, alpha via `globalAlpha`.** The obvious implementation rebuilds a
+ * linear gradient per ray per frame because the brightness changes every frame. Baking brightness
+ * into the stops would make the cache key change constantly and defeat it entirely, so the stops
+ * are built once at full alpha and the per-ray brightness is applied with `globalAlpha` instead.
+ */
+interface LightRaysOptions extends BaseEffectOptions {
+    /** Number of shafts. Default `14`. */
+    count?: number;
+    /** Source X as a fraction of width. Values outside `[0, 1]` put it off-canvas. Default `0.5`. */
+    originX?: number;
+    /** Source Y as a fraction of height. Default `-0.25` — above the canvas, so shafts angle down. */
+    originY?: number;
+    /** Direction the fan points, in radians. `Math.PI / 2` is straight down. Default `1.5708`. */
+    angle?: number;
+    /** Total angular width of the fan, in radians. Default `1.5`. */
+    spread?: number;
+    /** Angular half-width of a single shaft, in radians. Default `0.045`. */
+    rayWidth?: number;
+    /** Shaft length as a multiple of the canvas diagonal. Default `1.4` — always exits the frame. */
+    length?: number;
+    /** How far along a shaft the light survives, in `[0, 1]`. Higher reaches further. Default `0.5`. */
+    falloff?: number;
+    /** Lateral edge softness, in `[0, 1]`. `0` gives hard-edged wedges. Default `0.65`. */
+    softness?: number;
+    /** Depth of the brightness variation, in `[0, 1]`. `0` is a steady fan. Default `0.55`. */
+    flicker?: number;
+    /** How fast brightness varies. Default `0.35`. */
+    flickerSpeed?: number;
+    /** Angular sway of the whole fan, in radians. Default `0.06`. */
+    sway?: number;
+    /** Sway frequency. Default `0.12`. */
+    swaySpeed?: number;
+    /** How far the source follows the pointer, in `[0, 1]`. Default `0.25`. */
+    pointerPull?: number;
+}
+declare const lightRays: EffectDefinition<LightRaysOptions>;
+
+/**
+ * Smoke — a rising, dissipating plume.
+ *
+ * **Recycled, never respawned.** A continuous emitter that kills and spawns particles churns the
+ * buffer every frame and makes the live count sawtooth. Here a puff that reaches the end of its
+ * life is reset in place instead, so the count is constant, the swap-remove path is never taken,
+ * and density stays even — which is what a plume actually looks like.
+ *
+ * **Curl turbulence, not random jitter.** Lateral motion comes from a divergence-free curl field,
+ * the same reason `particle-field` uses one: raw noise has sources and sinks, so puffs pool into
+ * clumps and leave gaps. Curl preserves density, so the plume stays coherent as it climbs.
+ *
+ * **The opacity envelope is asymmetric.** A puff reaches full opacity in the first fraction of its
+ * life and then decays slowly over the rest. Smoke becomes visible almost immediately and takes a
+ * long time to disperse; a symmetric fade reads as a light being dimmed up and down.
+ *
+ * **Growth is tied to age, not to velocity.** Real smoke expands as it entrains surrounding air,
+ * which happens on a clock rather than in proportion to how fast it is moving.
+ */
+interface SmokeOptions extends BaseEffectOptions {
+    /** Puffs held live at full quality. Default `90`. */
+    count?: number;
+    /** Emitter X as a fraction of width. Default `0.5`. */
+    sourceX?: number;
+    /** Emitter Y as a fraction of height. Default `1.05` — just below frame, so the plume enters. */
+    sourceY?: number;
+    /** Horizontal spawn jitter, in pixels. Default `28`. */
+    spread?: number;
+    /** Buoyancy in pixels per second. Default `54`. */
+    rise?: number;
+    /** Strength of the curl-driven lateral swirl. Default `40`. */
+    turbulence?: number;
+    /** Spatial frequency of the curl field. Higher is more chaotic. Default `0.0035`. */
+    scale?: number;
+    /** Starting puff radius in pixels. Default `16`. */
+    size?: number;
+    /** How much a puff expands over its life, as a multiplier. Default `2.6`. */
+    growth?: number;
+    /** Puff lifetime in seconds. Default `4.5`. */
+    life?: number;
+    /** Velocity retained per second, in `[0, 1)`. Higher slows puffs faster. Default `0.55`. */
+    drag?: number;
+    /** Peak opacity of an individual puff, in `[0, 1]`. Default `0.32`. */
+    density?: number;
+}
+declare const smoke: EffectDefinition<SmokeOptions>;
+
+/**
+ * Floating geometry — polygons drifting in depth.
+ *
+ * **A real perspective divide, not a linear scale.** Depth is projected as
+ * `focal / (focal + z)` rather than lerped between a near and a far size. The difference is
+ * visible: linear scaling spaces the depth planes evenly, so the field reads as flat cut-outs at
+ * different sizes, while the perspective divide compresses the far planes together the way an
+ * actual lens does.
+ *
+ * **Every depth cue moves together.** Size, opacity and drift speed are all derived from the same
+ * projected scale. Depth is only convincing when the cues agree — a shape that is small but moves
+ * as fast as a near one immediately reads as small rather than as distant.
+ *
+ * **Shape names resolve to side counts once, at setup.** The frame loop reads a `Uint8Array`, so
+ * no string comparison happens per shape per frame.
+ */
+/** Shapes a field can be built from. `'circle'` is drawn as an arc rather than an n-gon. */
+type GeometryShape = 'triangle' | 'square' | 'pentagon' | 'hexagon' | 'circle';
+interface FloatingGeometryOptions extends BaseEffectOptions {
+    /** Number of shapes. Default `18`. */
+    count?: number;
+    /** Which shapes to draw, sampled per instance. Default all five. */
+    shapes?: readonly GeometryShape[];
+    /** Base radius in pixels, before the depth projection. Default `46`. */
+    size?: number;
+    /** Drift speed in pixels per second at the nearest depth. Default `26`. */
+    drift?: number;
+    /** Rotations per second at the fastest. Default `0.06`. */
+    spin?: number;
+    /** Focal length for the projection. Lower exaggerates the depth. Default `1`. */
+    perspective?: number;
+    /** How far back the field extends. Higher means more size falloff. Default `2.6`. */
+    depth?: number;
+    /** Opacity of the furthest shapes relative to the nearest, in `[0, 1]`. Default `0.25`. */
+    haze?: number;
+    /** Fill the shapes instead of stroking them. Default `false`. */
+    filled?: boolean;
+    /** Stroke width in pixels at the nearest depth. Default `1.5`. */
+    lineWidth?: number;
+}
+declare const floatingGeometry: EffectDefinition<FloatingGeometryOptions>;
+
+/**
+ * Orbit — nested rings of points circling a common centre.
+ *
+ * **The 3D read comes from squashing, not from a 3D engine.** Each ring is an ellipse whose
+ * vertical radius is scaled by `tilt`, which is exactly what a circle viewed at an angle projects
+ * to. No matrix maths is needed for a convincing result.
+ *
+ * **Depth is split, not sorted.** The points are drawn in two passes — the far half of every orbit
+ * first, the near half last — with the orbit guides laid down between them. Sorting every point by
+ * depth each frame would be correct too, but the ring geometry already says which half a point is
+ * on (`sin(θ)` *is* the depth), so the split buys the same occlusion for none of the sort cost.
+ *
+ * **Near points are larger *and* brighter.** Scaling alone reads as points of different sizes on a
+ * flat plane; brightness alone reads as a flicker. Moving both together is what makes the ring
+ * read as tilted in space.
+ *
+ * **Adjacent rings counter-rotate by default.** Rings all turning the same way look like one rigid
+ * object spinning; alternating the direction makes them read as independent shells.
+ */
+interface OrbitOptions extends BaseEffectOptions {
+    /** Number of concentric rings. Default `3`. */
+    rings?: number;
+    /** Points on each ring. Default `14`. */
+    perRing?: number;
+    /** Outer ring radius as a fraction of the smaller canvas dimension. Default `0.42`. */
+    radius?: number;
+    /** Radius of the innermost ring relative to the outer, in `(0, 1]`. Default `0.45`. */
+    innerRadius?: number;
+    /** Vertical squash of every ring, in `(0, 1]`. `1` is head-on, lower is more tilted. Default `0.34`. */
+    tilt?: number;
+    /** Revolutions per second of the outer ring. Default `0.05`. */
+    orbitSpeed?: number;
+    /** Point radius in pixels. Default `3.2`. */
+    size?: number;
+    /** Glow radius as a multiple of `size`. Default `3`. */
+    glow?: number;
+    /** Reverse every other ring. Default `true`. */
+    counterRotate?: boolean;
+    /** Draw the elliptical orbit paths. Default `true`. */
+    showOrbits?: boolean;
+    /** Opacity of the orbit paths, in `[0, 1]`. Default `0.12`. */
+    orbitOpacity?: number;
+    /** Radius of the glow at the centre, in pixels. `0` omits it. Default `26`. */
+    core?: number;
+}
+declare const orbit: EffectDefinition<OrbitOptions>;
+
 /**
  * Waves — layered undulating bands.
  *
@@ -953,10 +1271,17 @@ declare const effects: {
     readonly 'animated-gradient': EffectDefinition<AnimatedGradientOptions>;
     readonly 'particle-field': EffectDefinition<ParticleFieldOptions>;
     readonly constellation: EffectDefinition<ConstellationOptions>;
+    readonly 'powder-explosion': EffectDefinition<PowderExplosionOptions>;
+    readonly 'strange-attractor': EffectDefinition<StrangeAttractorOptions>;
+    readonly swarm: EffectDefinition<SwarmOptions>;
     readonly meteors: EffectDefinition<MeteorsOptions>;
     readonly rain: EffectDefinition<RainOptions>;
     readonly snow: EffectDefinition<SnowOptions>;
     readonly fireflies: EffectDefinition<FirefliesOptions>;
+    readonly 'light-rays': EffectDefinition<LightRaysOptions>;
+    readonly smoke: EffectDefinition<SmokeOptions>;
+    readonly 'floating-geometry': EffectDefinition<FloatingGeometryOptions>;
+    readonly orbit: EffectDefinition<OrbitOptions>;
     readonly waves: EffectDefinition<WavesOptions>;
     readonly blob: EffectDefinition<BlobOptions>;
     readonly 'noise-layer': EffectDefinition<NoiseLayerOptions>;
@@ -964,4 +1289,5 @@ declare const effects: {
 };
 type EffectName = keyof typeof effects;
 
-export { supportsOffscreenCanvas as $, type AnimatedGradientOptions as A, type BaseEffectOptions as B, type ConstellationOptions as C, drawGlow as D, type EffectContext as E, type FirefliesOptions as F, GradientCache as G, effects as H, fireflies as I, integrate as J, meshGradient as K, meteors as L, type MeshGradientOptions as M, type NoiseLayerOptions as N, mountEffect as O, ParticleBuffer as P, noiseLayer as Q, type RainOptions as R, type Size as S, particleField as T, type Unsub as U, rain as V, type WavesOptions as W, resetFilterSupport as X, snow as Y, spotlight as Z, supportsCanvasFilter as _, type AuroraOptions as a, supportsWorkerRendering as a0, traceClosedSpline as a1, traceOpenSpline as a2, traceRoundRect as a3, trackPointer as a4, waves as a5, wrapBounds as a6, type BlendMode as b, type BlobOptions as c, type EffectDefinition as d, type EffectFrame as e, type EffectHandle as f, type EffectInstance as g, type EffectName as h, type MeteorsOptions as i, type ParticleFieldOptions as j, type PointerOptions as k, type PointerState as l, type PointerTracker as m, type SnowOptions as n, SpatialGrid as o, type SpotlightOptions as p, type Surface as q, type SurfaceOptions as r, ageAndCull as s, animatedGradient as t, aurora as u, blob as v, constellation as w, createSurface as x, defineEffect as y, drawDot as z };
+export { lightRays as $, animatedGradient as D, aurora as H, blob as I, constellation as J, createSurface as K, ParticleBuffer as P, defineEffect as Q, drawDot as T, drawGlow as V, effects as X, fireflies as Y, floatingGeometry as Z, integrate as _, meshGradient as a0, meteors as a1, mountEffect as a2, noiseLayer as a3, orbit as a4, particleField as a5, powderExplosion as a6, rain as a7, resetFilterSupport as a8, smoke as a9, snow as aa, spotlight as ab, strangeAttractor as ac, supportsCanvasFilter as ad, supportsOffscreenCanvas as ae, supportsWorkerRendering as af, swarm as ag, traceClosedSpline as ah, traceOpenSpline as ai, traceRoundRect as aj, trackPointer as ak, waves as al, wrapBounds as am, GradientCache as k, SpatialGrid as t, ageAndCull as z };
+export type { AnimatedGradientOptions as A, BaseEffectOptions as B, ConstellationOptions as C, EffectContext as E, FirefliesOptions as F, GeometryShape as G, LightRaysOptions as L, MeshGradientOptions as M, NoiseLayerOptions as N, OrbitOptions as O, RainOptions as R, Size as S, Unsub as U, WavesOptions as W, AttractorKind as a, AuroraOptions as b, BlendMode as c, BlobOptions as d, EffectDefinition as e, EffectFrame as f, EffectHandle as g, EffectInstance as h, EffectName as i, FloatingGeometryOptions as j, MeteorsOptions as l, ParticleFieldOptions as m, PointerOptions as n, PointerState as o, PointerTracker as p, PowderExplosionOptions as q, SmokeOptions as r, SnowOptions as s, SpotlightOptions as u, StrangeAttractorOptions as v, Surface as w, SurfaceOptions as x, SwarmOptions as y };