@codexo/exojs-particles 0.15.3 → 0.16.0

package/dist/esm/modules/ColorOverSpeed.d.ts

@@ -1,5 +1,5 @@
-import type { ColorGradient } from "#distributions/ColorGradient";
-import type { ParticleSystem } from "#ParticleSystem";
+import type { ColorGradient } from '#distributions/ColorGradient';
+import type { ParticleBatch } from '#ParticleStorage';
 import { UpdateModule } from './UpdateModule';
 import type { WgslContribution } from './WgslContribution';
 /**
@@ -11,7 +11,7 @@ import type { WgslContribution } from './WgslContribution';
  * speed-gated highlights.
  *
  * GPU-eligible: gradient uploaded as a 256-tap 1D RGBA8 texture, sampled
- * with linear filtering. Replaces the full color word — pair with a
+ * with linear filtering. Replaces the full color word - pair with a
  * separate {@link AlphaFadeOverLifetime} after this module if you want to
  * keep alpha controlled by lifetime.
  */
@@ -20,8 +20,9 @@ export declare class ColorOverSpeed extends UpdateModule {
     minSpeed: number;
     maxSpeed: number;
     constructor(gradient: ColorGradient, minSpeed: number, maxSpeed: number);
-    apply(system: ParticleSystem, _dt: number): void;
+    apply(particles: ParticleBatch, _dt: number): void;
     wgsl(): WgslContribution;
     writeUniforms(view: DataView, offset: number): void;
     uploadTextures(device: GPUDevice, textures: ReadonlyMap<string, GPUTexture>): void;
 }
+//# sourceMappingURL=ColorOverSpeed.d.ts.map

package/dist/esm/modules/ColorOverSpeed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ColorOverSpeed.d.ts","sourceRoot":"","sources":["../../../src/modules/ColorOverSpeed.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAI3D;;;;;;;;;;;;GAYG;AACH,qBAAa,cAAe,SAAQ,YAAY;IACvC,QAAQ,EAAE,aAAa,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;gBAEL,QAAQ,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;IAO9D,KAAK,CAAC,SAAS,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI;IAkBlD,IAAI,IAAI,gBAAgB;IAqBxB,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAOnD,cAAc,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,IAAI;CA8BnG"}

package/dist/esm/modules/ColorOverSpeed.js

@@ -1,53 +1,61 @@
-import { Color } from '@codexo/exojs';
-import { UpdateModule } from './UpdateModule.js';
+import { UpdateModule } from "./UpdateModule.js";
+import { Color } from "@codexo/exojs";
 
-/// <reference types="@webgpu/types" />
+//#region src/modules/ColorOverSpeed.ts
 const lookupSize = 256;
 /**
- * Per-frame, per-particle color sampler driven by velocity magnitude rather
- * than lifetime ratio. Each live particle's tint is set to the gradient
- * evaluated at `clamp((|velocity| - minSpeed) / (maxSpeed - minSpeed), 0, 1)`.
- *
- * Use cases: heat-mapping (slow=blue, fast=red), velocity-tinted trails,
- * speed-gated highlights.
- *
- * GPU-eligible: gradient uploaded as a 256-tap 1D RGBA8 texture, sampled
- * with linear filtering. Replaces the full color word — pair with a
- * separate {@link AlphaFadeOverLifetime} after this module if you want to
- * keep alpha controlled by lifetime.
- */
-class ColorOverSpeed extends UpdateModule {
-    gradient;
-    minSpeed;
-    maxSpeed;
-    constructor(gradient, minSpeed, maxSpeed) {
-        super();
-        this.gradient = gradient;
-        this.minSpeed = minSpeed;
-        this.maxSpeed = maxSpeed;
-    }
-    apply(system, _dt) {
-        const { velX, velY, color, liveCount } = system;
-        const gradient = this.gradient;
-        const min = this.minSpeed;
-        const span = Math.max(1e-5, this.maxSpeed - this.minSpeed);
-        for (let i = 0; i < liveCount; i++) {
-            const vx = velX[i] ?? 0;
-            const vy = velY[i] ?? 0;
-            const speed = Math.sqrt(vx * vx + vy * vy);
-            const t = Math.max(0, Math.min(1, (speed - min) / span));
-            color[i] = gradient.evaluateRgba(t);
-        }
-    }
-    wgsl() {
-        return {
-            key: 'ColorOverSpeed',
-            uniforms: [
-                { name: 'minSpeed', type: 'f32' },
-                { name: 'invSpan', type: 'f32' },
-            ],
-            textures: [{ name: 'gradient', format: 'rgba8unorm' }],
-            body: `
+* Per-frame, per-particle color sampler driven by velocity magnitude rather
+* than lifetime ratio. Each live particle's tint is set to the gradient
+* evaluated at `clamp((|velocity| - minSpeed) / (maxSpeed - minSpeed), 0, 1)`.
+*
+* Use cases: heat-mapping (slow=blue, fast=red), velocity-tinted trails,
+* speed-gated highlights.
+*
+* GPU-eligible: gradient uploaded as a 256-tap 1D RGBA8 texture, sampled
+* with linear filtering. Replaces the full color word - pair with a
+* separate {@link AlphaFadeOverLifetime} after this module if you want to
+* keep alpha controlled by lifetime.
+*/
+var ColorOverSpeed = class extends UpdateModule {
+	gradient;
+	minSpeed;
+	maxSpeed;
+	constructor(gradient, minSpeed, maxSpeed) {
+		super();
+		this.gradient = gradient;
+		this.minSpeed = minSpeed;
+		this.maxSpeed = maxSpeed;
+	}
+	apply(particles, _dt) {
+		const { x: velX, y: velY } = particles.velocity;
+		const color = particles.color;
+		const liveCount = particles.count;
+		const gradient = this.gradient;
+		const min = this.minSpeed;
+		const span = Math.max(1e-5, this.maxSpeed - this.minSpeed);
+		for (let i = 0; i < liveCount; i++) {
+			const vx = velX[i] ?? 0;
+			const vy = velY[i] ?? 0;
+			const speed = Math.sqrt(vx * vx + vy * vy);
+			const t = Math.max(0, Math.min(1, (speed - min) / span));
+			color[i] = gradient.evaluateRgba(t);
+		}
+	}
+	wgsl() {
+		return {
+			key: "ColorOverSpeed",
+			uniforms: [{
+				name: "minSpeed",
+				type: "f32"
+			}, {
+				name: "invSpan",
+				type: "f32"
+			}],
+			textures: [{
+				name: "gradient",
+				format: "rgba8unorm"
+			}],
+			body: `
                 let speedMag = length(velocities[idx]);
                 let speedT = clamp((speedMag - modules.u_ColorOverSpeed.minSpeed) * modules.u_ColorOverSpeed.invSpan, 0.0, 1.0);
                 let speedSample = textureSampleLevel(u_ColorOverSpeed_gradient, u_ColorOverSpeed_gradient_sampler, speedT, 0.0);
@@ -56,33 +64,40 @@ class ColorOverSpeed extends UpdateModule {
                 let speedB = u32(speedSample.b * 255.0) & 255u;
                 let speedA = u32(speedSample.a * 255.0) & 255u;
                 color[idx] = (speedA << 24u) | (speedB << 16u) | (speedG << 8u) | speedR;
-            `,
-        };
-    }
-    writeUniforms(view, offset) {
-        const span = Math.max(1e-5, this.maxSpeed - this.minSpeed);
-        view.setFloat32(offset + 0, this.minSpeed, true);
-        view.setFloat32(offset + 4, 1 / span, true);
-    }
-    uploadTextures(device, textures) {
-        const texture = textures.get('gradient');
-        if (texture === undefined) {
-            return;
-        }
-        const data = new Uint8Array(lookupSize * 4);
-        const scratch = new Color();
-        for (let i = 0; i < lookupSize; i++) {
-            const t = i / (lookupSize - 1);
-            this.gradient.evaluate(t, scratch);
-            const o = i * 4;
-            data[o + 0] = scratch.r & 255;
-            data[o + 1] = scratch.g & 255;
-            data[o + 2] = scratch.b & 255;
-            data[o + 3] = ((scratch.a * 255) | 0) & 255;
-        }
-        device.queue.writeTexture({ texture }, data.buffer, { offset: 0, bytesPerRow: lookupSize * 4, rowsPerImage: 1 }, { width: lookupSize, height: 1, depthOrArrayLayers: 1 });
-    }
-}
+            `
+		};
+	}
+	writeUniforms(view, offset) {
+		const span = Math.max(1e-5, this.maxSpeed - this.minSpeed);
+		view.setFloat32(offset + 0, this.minSpeed, true);
+		view.setFloat32(offset + 4, 1 / span, true);
+	}
+	uploadTextures(device, textures) {
+		const texture = textures.get("gradient");
+		if (texture === void 0) return;
+		const data = new Uint8Array(lookupSize * 4);
+		const scratch = new Color();
+		for (let i = 0; i < lookupSize; i++) {
+			const t = i / 255;
+			this.gradient.evaluate(t, scratch);
+			const o = i * 4;
+			data[o + 0] = scratch.r & 255;
+			data[o + 1] = scratch.g & 255;
+			data[o + 2] = scratch.b & 255;
+			data[o + 3] = (scratch.a * 255 | 0) & 255;
+		}
+		device.queue.writeTexture({ texture }, data.buffer, {
+			offset: 0,
+			bytesPerRow: lookupSize * 4,
+			rowsPerImage: 1
+		}, {
+			width: lookupSize,
+			height: 1,
+			depthOrArrayLayers: 1
+		});
+	}
+};
 
+//#endregion
 export { ColorOverSpeed };
-//# sourceMappingURL=ColorOverSpeed.js.map
+//# sourceMappingURL=ColorOverSpeed.js.map

package/dist/esm/modules/ColorOverSpeed.js.map

@@ -1 +1 @@
-{"version":3,"file":"ColorOverSpeed.js","sources":["../../../../src/modules/ColorOverSpeed.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}
+{"version":3,"file":"ColorOverSpeed.js","names":[],"sources":["../../../src/modules/ColorOverSpeed.ts"],"sourcesContent":["/// <reference types=\"@webgpu/types\" />\n\nimport { Color } from '@codexo/exojs';\n\nimport type { ColorGradient } from '#distributions/ColorGradient';\nimport type { ParticleBatch } from '#ParticleStorage';\n\nimport { UpdateModule } from './UpdateModule';\nimport type { WgslContribution } from './WgslContribution';\n\nconst lookupSize = 256;\n\n/**\n * Per-frame, per-particle color sampler driven by velocity magnitude rather\n * than lifetime ratio. Each live particle's tint is set to the gradient\n * evaluated at `clamp((|velocity| - minSpeed) / (maxSpeed - minSpeed), 0, 1)`.\n *\n * Use cases: heat-mapping (slow=blue, fast=red), velocity-tinted trails,\n * speed-gated highlights.\n *\n * GPU-eligible: gradient uploaded as a 256-tap 1D RGBA8 texture, sampled\n * with linear filtering. Replaces the full color word - pair with a\n * separate {@link AlphaFadeOverLifetime} after this module if you want to\n * keep alpha controlled by lifetime.\n */\nexport class ColorOverSpeed extends UpdateModule {\n  public gradient: ColorGradient;\n  public minSpeed: number;\n  public maxSpeed: number;\n\n  public constructor(gradient: ColorGradient, minSpeed: number, maxSpeed: number) {\n    super();\n    this.gradient = gradient;\n    this.minSpeed = minSpeed;\n    this.maxSpeed = maxSpeed;\n  }\n\n  public override apply(particles: ParticleBatch, _dt: number): void {\n    const { x: velX, y: velY } = particles.velocity;\n    const color = particles.color;\n    const liveCount = particles.count;\n    const gradient = this.gradient;\n    const min = this.minSpeed;\n    const span = Math.max(1e-5, this.maxSpeed - this.minSpeed);\n\n    for (let i = 0; i < liveCount; i++) {\n      const vx = velX[i] ?? 0;\n      const vy = velY[i] ?? 0;\n      const speed = Math.sqrt(vx * vx + vy * vy);\n      const t = Math.max(0, Math.min(1, (speed - min) / span));\n\n      color[i] = gradient.evaluateRgba(t);\n    }\n  }\n\n  public override wgsl(): WgslContribution {\n    return {\n      key: 'ColorOverSpeed',\n      uniforms: [\n        { name: 'minSpeed', type: 'f32' },\n        { name: 'invSpan', type: 'f32' },\n      ],\n      textures: [{ name: 'gradient', format: 'rgba8unorm' }],\n      body: `\n                let speedMag = length(velocities[idx]);\n                let speedT = clamp((speedMag - modules.u_ColorOverSpeed.minSpeed) * modules.u_ColorOverSpeed.invSpan, 0.0, 1.0);\n                let speedSample = textureSampleLevel(u_ColorOverSpeed_gradient, u_ColorOverSpeed_gradient_sampler, speedT, 0.0);\n                let speedR = u32(speedSample.r * 255.0) & 255u;\n                let speedG = u32(speedSample.g * 255.0) & 255u;\n                let speedB = u32(speedSample.b * 255.0) & 255u;\n                let speedA = u32(speedSample.a * 255.0) & 255u;\n                color[idx] = (speedA << 24u) | (speedB << 16u) | (speedG << 8u) | speedR;\n            `,\n    };\n  }\n\n  public override writeUniforms(view: DataView, offset: number): void {\n    const span = Math.max(1e-5, this.maxSpeed - this.minSpeed);\n\n    view.setFloat32(offset + 0, this.minSpeed, true);\n    view.setFloat32(offset + 4, 1 / span, true);\n  }\n\n  public override uploadTextures(device: GPUDevice, textures: ReadonlyMap<string, GPUTexture>): void {\n    const texture = textures.get('gradient');\n\n    if (texture === undefined) {\n      return;\n    }\n\n    const data = new Uint8Array(lookupSize * 4);\n    const scratch = new Color();\n\n    for (let i = 0; i < lookupSize; i++) {\n      const t = i / (lookupSize - 1);\n\n      this.gradient.evaluate(t, scratch);\n\n      const o = i * 4;\n\n      data[o + 0] = scratch.r & 255;\n      data[o + 1] = scratch.g & 255;\n      data[o + 2] = scratch.b & 255;\n      data[o + 3] = ((scratch.a * 255) | 0) & 255;\n    }\n\n    device.queue.writeTexture(\n      { texture },\n      data.buffer,\n      { offset: 0, bytesPerRow: lookupSize * 4, rowsPerImage: 1 },\n      { width: lookupSize, height: 1, depthOrArrayLayers: 1 },\n    );\n  }\n}\n"],"mappings":";;;;AAUA,MAAM,aAAa;;;;;;;;;;;;;;AAenB,IAAa,iBAAb,cAAoC,aAAa;CAC/C,AAAO;CACP,AAAO;CACP,AAAO;CAEP,AAAO,YAAY,UAAyB,UAAkB,UAAkB;EAC9E,MAAM;EACN,KAAK,WAAW;EAChB,KAAK,WAAW;EAChB,KAAK,WAAW;CAClB;CAEA,AAAgB,MAAM,WAA0B,KAAmB;EACjE,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,UAAU;EACvC,MAAM,QAAQ,UAAU;EACxB,MAAM,YAAY,UAAU;EAC5B,MAAM,WAAW,KAAK;EACtB,MAAM,MAAM,KAAK;EACjB,MAAM,OAAO,KAAK,IAAI,MAAM,KAAK,WAAW,KAAK,QAAQ;EAEzD,KAAK,IAAI,IAAI,GAAG,IAAI,WAAW,KAAK;GAClC,MAAM,KAAK,KAAK,MAAM;GACtB,MAAM,KAAK,KAAK,MAAM;GACtB,MAAM,QAAQ,KAAK,KAAK,KAAK,KAAK,KAAK,EAAE;GACzC,MAAM,IAAI,KAAK,IAAI,GAAG,KAAK,IAAI,IAAI,QAAQ,OAAO,IAAI,CAAC;GAEvD,MAAM,KAAK,SAAS,aAAa,CAAC;EACpC;CACF;CAEA,AAAgB,OAAyB;EACvC,OAAO;GACL,KAAK;GACL,UAAU,CACR;IAAE,MAAM;IAAY,MAAM;GAAM,GAChC;IAAE,MAAM;IAAW,MAAM;GAAM,CACjC;GACA,UAAU,CAAC;IAAE,MAAM;IAAY,QAAQ;GAAa,CAAC;GACrD,MAAM;;;;;;;;;;EAUR;CACF;CAEA,AAAgB,cAAc,MAAgB,QAAsB;EAClE,MAAM,OAAO,KAAK,IAAI,MAAM,KAAK,WAAW,KAAK,QAAQ;EAEzD,KAAK,WAAW,SAAS,GAAG,KAAK,UAAU,IAAI;EAC/C,KAAK,WAAW,SAAS,GAAG,IAAI,MAAM,IAAI;CAC5C;CAEA,AAAgB,eAAe,QAAmB,UAAiD;EACjG,MAAM,UAAU,SAAS,IAAI,UAAU;EAEvC,IAAI,YAAY,QACd;EAGF,MAAM,OAAO,IAAI,WAAW,aAAa,CAAC;EAC1C,MAAM,UAAU,IAAI,MAAM;EAE1B,KAAK,IAAI,IAAI,GAAG,IAAI,YAAY,KAAK;GACnC,MAAM,IAAI,IAAK;GAEf,KAAK,SAAS,SAAS,GAAG,OAAO;GAEjC,MAAM,IAAI,IAAI;GAEd,KAAK,IAAI,KAAK,QAAQ,IAAI;GAC1B,KAAK,IAAI,KAAK,QAAQ,IAAI;GAC1B,KAAK,IAAI,KAAK,QAAQ,IAAI;GAC1B,KAAK,IAAI,MAAO,QAAQ,IAAI,MAAO,KAAK;EAC1C;EAEA,OAAO,MAAM,aACX,EAAE,QAAQ,GACV,KAAK,QACL;GAAE,QAAQ;GAAG,aAAa,aAAa;GAAG,cAAc;EAAE,GAC1D;GAAE,OAAO;GAAY,QAAQ;GAAG,oBAAoB;EAAE,CACxD;CACF;AACF"}

package/dist/esm/modules/DeathModule.d.ts

@@ -1,24 +1,40 @@
-import type { ParticleSystem } from "#ParticleSystem";
+import type { ParticleDeathContext } from '#ParticleStorage';
+import type { ParticleSystem } from '#ParticleSystem';
 /**
- * Per-particle hook invoked exactly once when a particle expires, before
- * its slot is recycled by the compaction pass. The dying particle's data
- * is still readable at `system.posX[slot]` etc.
+ * Per-particle hook invoked exactly once after a particle expires, carrying its
+ * state at the moment it died.
  *
  * Use for sub-emitters (spawn child particles where this one died), event
- * dispatch (trigger an audio cue, score event), or trail termination.
+ * dispatch (trigger an audio cue, a score event), or trail termination.
+ *
+ * The callback receives a snapshot rather than a slot, and for a reason: on the
+ * GPU path the simulation runs on the device and a death is reported once its
+ * state has been read back, by which time the slot may already hold a different
+ * particle. The snapshot is therefore the same on both backends, while a slot
+ * would not be.
+ *
+ * Delivery is exactly once per expired particle, but not necessarily in the
+ * frame the particle expired: a GPU-simulated death arrives as soon as its
+ * readback lands, typically the next frame. Deaths from one readback are
+ * delivered in slot order, and readbacks in the order they were submitted.
+ *
+ * Exactly-once holds while the deaths waiting on a readback fit the system's
+ * capacity. Beyond that the excess is dropped rather than stalling the frame
+ * loop, and a development build reports it once per system. Reaching that point
+ * takes a device that falls many frames behind while slots are recycled and die
+ * again, so a system sized for its emission rate does not see it.
  *
  * Implementation pattern:
  *
  * ```ts
- * onDeath(system, slot) {
- *     const x = system.posX[slot];
- *     const y = system.posY[slot];
- *     this._childSystem.spawnBurstAt(x, y, 8);
+ * onDeath(system, death) {
+ *     this._childSystem.burstAt(death.x, death.y, 8);
  * }
  * ```
  */
 export declare abstract class DeathModule {
-    abstract onDeath(system: ParticleSystem, slot: number): void;
+    abstract onDeath(system: ParticleSystem, death: ParticleDeathContext): void;
     /** Optional cleanup hook called from `ParticleSystem.destroy`. */
     destroy(): void;
 }
+//# sourceMappingURL=DeathModule.d.ts.map

package/dist/esm/modules/DeathModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeathModule.d.ts","sourceRoot":"","sources":["../../../src/modules/DeathModule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,8BAAsB,WAAW;aACf,OAAO,CAAC,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,oBAAoB,GAAG,IAAI;IAClF,kEAAkE;IAC3D,OAAO,IAAI,IAAI;CACvB"}

package/dist/esm/modules/DeathModule.js

@@ -1,25 +1,41 @@
+//#region src/modules/DeathModule.ts
 /**
- * Per-particle hook invoked exactly once when a particle expires, before
- * its slot is recycled by the compaction pass. The dying particle's data
- * is still readable at `system.posX[slot]` etc.
- *
- * Use for sub-emitters (spawn child particles where this one died), event
- * dispatch (trigger an audio cue, score event), or trail termination.
- *
- * Implementation pattern:
- *
- * ```ts
- * onDeath(system, slot) {
- *     const x = system.posX[slot];
- *     const y = system.posY[slot];
- *     this._childSystem.spawnBurstAt(x, y, 8);
- * }
- * ```
- */
-class DeathModule {
-    /** Optional cleanup hook called from `ParticleSystem.destroy`. */
-    destroy() { }
-}
+* Per-particle hook invoked exactly once after a particle expires, carrying its
+* state at the moment it died.
+*
+* Use for sub-emitters (spawn child particles where this one died), event
+* dispatch (trigger an audio cue, a score event), or trail termination.
+*
+* The callback receives a snapshot rather than a slot, and for a reason: on the
+* GPU path the simulation runs on the device and a death is reported once its
+* state has been read back, by which time the slot may already hold a different
+* particle. The snapshot is therefore the same on both backends, while a slot
+* would not be.
+*
+* Delivery is exactly once per expired particle, but not necessarily in the
+* frame the particle expired: a GPU-simulated death arrives as soon as its
+* readback lands, typically the next frame. Deaths from one readback are
+* delivered in slot order, and readbacks in the order they were submitted.
+*
+* Exactly-once holds while the deaths waiting on a readback fit the system's
+* capacity. Beyond that the excess is dropped rather than stalling the frame
+* loop, and a development build reports it once per system. Reaching that point
+* takes a device that falls many frames behind while slots are recycled and die
+* again, so a system sized for its emission rate does not see it.
+*
+* Implementation pattern:
+*
+* ```ts
+* onDeath(system, death) {
+*     this._childSystem.burstAt(death.x, death.y, 8);
+* }
+* ```
+*/
+var DeathModule = class {
+	/** Optional cleanup hook called from `ParticleSystem.destroy`. */
+	destroy() {}
+};
 
+//#endregion
 export { DeathModule };
-//# sourceMappingURL=DeathModule.js.map
+//# sourceMappingURL=DeathModule.js.map

package/dist/esm/modules/DeathModule.js.map

@@ -1 +1 @@
-{"version":3,"file":"DeathModule.js","sources":["../../../../src/modules/DeathModule.ts"],"sourcesContent":[null],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;AAiBG;MACmB,WAAW,CAAA;;AAGxB,IAAA,OAAO,KAAU;AACzB;;;;"}
+{"version":3,"file":"DeathModule.js","names":[],"sources":["../../../src/modules/DeathModule.ts"],"sourcesContent":["import type { ParticleDeathContext } from '#ParticleStorage';\nimport type { ParticleSystem } from '#ParticleSystem';\n\n/**\n * Per-particle hook invoked exactly once after a particle expires, carrying its\n * state at the moment it died.\n *\n * Use for sub-emitters (spawn child particles where this one died), event\n * dispatch (trigger an audio cue, a score event), or trail termination.\n *\n * The callback receives a snapshot rather than a slot, and for a reason: on the\n * GPU path the simulation runs on the device and a death is reported once its\n * state has been read back, by which time the slot may already hold a different\n * particle. The snapshot is therefore the same on both backends, while a slot\n * would not be.\n *\n * Delivery is exactly once per expired particle, but not necessarily in the\n * frame the particle expired: a GPU-simulated death arrives as soon as its\n * readback lands, typically the next frame. Deaths from one readback are\n * delivered in slot order, and readbacks in the order they were submitted.\n *\n * Exactly-once holds while the deaths waiting on a readback fit the system's\n * capacity. Beyond that the excess is dropped rather than stalling the frame\n * loop, and a development build reports it once per system. Reaching that point\n * takes a device that falls many frames behind while slots are recycled and die\n * again, so a system sized for its emission rate does not see it.\n *\n * Implementation pattern:\n *\n * ```ts\n * onDeath(system, death) {\n *     this._childSystem.burstAt(death.x, death.y, 8);\n * }\n * ```\n */\nexport abstract class DeathModule {\n  public abstract onDeath(system: ParticleSystem, death: ParticleDeathContext): void;\n  /** Optional cleanup hook called from `ParticleSystem.destroy`. */\n  public destroy(): void {}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,IAAsB,cAAtB,MAAkC;;CAGhC,AAAO,UAAgB,CAAC;AAC1B"}

package/dist/esm/modules/Drag.d.ts

@@ -1,4 +1,4 @@
-import type { ParticleSystem } from "#ParticleSystem";
+import type { ParticleBatch } from '#ParticleStorage';
 import { UpdateModule } from './UpdateModule';
 import type { WgslContribution } from './WgslContribution';
 /**
@@ -14,7 +14,8 @@ import type { WgslContribution } from './WgslContribution';
 export declare class Drag extends UpdateModule {
     drag: number;
     constructor(drag: number);
-    apply(system: ParticleSystem, dt: number): void;
+    apply(particles: ParticleBatch, dt: number): void;
     wgsl(): WgslContribution;
     writeUniforms(view: DataView, offset: number): void;
 }
+//# sourceMappingURL=Drag.d.ts.map

package/dist/esm/modules/Drag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Drag.d.ts","sourceRoot":"","sources":["../../../src/modules/Drag.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D;;;;;;;;;GASG;AACH,qBAAa,IAAK,SAAQ,YAAY;IAC7B,IAAI,EAAE,MAAM,CAAC;gBAED,IAAI,EAAE,MAAM;IAKf,KAAK,CAAC,SAAS,EAAE,aAAa,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;IAWjD,IAAI,IAAI,gBAAgB;IAWxB,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;CAGpE"}

package/dist/esm/modules/Drag.js

@@ -1,43 +1,49 @@
-import { UpdateModule } from './UpdateModule.js';
+import { UpdateModule } from "./UpdateModule.js";
 
+//#region src/modules/Drag.ts
 /**
- * Exponential velocity damping. Each frame multiplies every live particle's
- * velocity by `(1 - drag * dt)`, simulating linear air resistance.
- *
- * `drag = 0` is no damping; `drag = 1` halves velocity in ~1 second; higher
- * values slow particles faster. Negative values accelerate (don't do that
- * unless you mean it).
- *
- * GPU-eligible.
- */
-class Drag extends UpdateModule {
-    drag;
-    constructor(drag) {
-        super();
-        this.drag = drag;
-    }
-    apply(system, dt) {
-        const { velX, velY, liveCount } = system;
-        const factor = 1 - this.drag * dt;
-        for (let i = 0; i < liveCount; i++) {
-            velX[i] = (velX[i] ?? 0) * factor;
-            velY[i] = (velY[i] ?? 0) * factor;
-        }
-    }
-    wgsl() {
-        return {
-            key: 'Drag',
-            uniforms: [{ name: 'drag', type: 'f32' }],
-            body: `
+* Exponential velocity damping. Each frame multiplies every live particle's
+* velocity by `(1 - drag * dt)`, simulating linear air resistance.
+*
+* `drag = 0` is no damping; `drag = 1` halves velocity in ~1 second; higher
+* values slow particles faster. Negative values accelerate (don't do that
+* unless you mean it).
+*
+* GPU-eligible.
+*/
+var Drag = class extends UpdateModule {
+	drag;
+	constructor(drag) {
+		super();
+		this.drag = drag;
+	}
+	apply(particles, dt) {
+		const { x: velX, y: velY } = particles.velocity;
+		const liveCount = particles.count;
+		const factor = 1 - this.drag * dt;
+		for (let i = 0; i < liveCount; i++) {
+			velX[i] = (velX[i] ?? 0) * factor;
+			velY[i] = (velY[i] ?? 0) * factor;
+		}
+	}
+	wgsl() {
+		return {
+			key: "Drag",
+			uniforms: [{
+				name: "drag",
+				type: "f32"
+			}],
+			body: `
                 let dragFactor = 1.0 - modules.u_Drag.drag * dt;
                 velocities[idx] = velocities[idx] * dragFactor;
-            `,
-        };
-    }
-    writeUniforms(view, offset) {
-        view.setFloat32(offset + 0, this.drag, true);
-    }
-}
+            `
+		};
+	}
+	writeUniforms(view, offset) {
+		view.setFloat32(offset + 0, this.drag, true);
+	}
+};
 
+//#endregion
 export { Drag };
-//# sourceMappingURL=Drag.js.map
+//# sourceMappingURL=Drag.js.map

package/dist/esm/modules/Drag.js.map

@@ -1 +1 @@
-{"version":3,"file":"Drag.js","sources":["../../../../src/modules/Drag.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA;;;;;;;;;AASG;AACG,MAAO,IAAK,SAAQ,YAAY,CAAA;AAC7B,IAAA,IAAI;AAEX,IAAA,WAAA,CAAmB,IAAY,EAAA;AAC7B,QAAA,KAAK,EAAE;AACP,QAAA,IAAI,CAAC,IAAI,GAAG,IAAI;IAClB;IAEgB,KAAK,CAAC,MAAsB,EAAE,EAAU,EAAA;QACtD,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,MAAM;QACxC,MAAM,MAAM,GAAG,CAAC,GAAG,IAAI,CAAC,IAAI,GAAG,EAAE;AAEjC,QAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC,EAAE,EAAE;AAClC,YAAA,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,MAAM;AACjC,YAAA,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,MAAM;QACnC;IACF;IAEgB,IAAI,GAAA;QAClB,OAAO;AACL,YAAA,GAAG,EAAE,MAAM;YACX,QAAQ,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;AACzC,YAAA,IAAI,EAAE;;;AAGC,YAAA,CAAA;SACR;IACH;IAEgB,aAAa,CAAC,IAAc,EAAE,MAAc,EAAA;AAC1D,QAAA,IAAI,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC;IAC9C;AACD;;;;"}
+{"version":3,"file":"Drag.js","names":[],"sources":["../../../src/modules/Drag.ts"],"sourcesContent":["import type { ParticleBatch } from '#ParticleStorage';\n\nimport { UpdateModule } from './UpdateModule';\nimport type { WgslContribution } from './WgslContribution';\n\n/**\n * Exponential velocity damping. Each frame multiplies every live particle's\n * velocity by `(1 - drag * dt)`, simulating linear air resistance.\n *\n * `drag = 0` is no damping; `drag = 1` halves velocity in ~1 second; higher\n * values slow particles faster. Negative values accelerate (don't do that\n * unless you mean it).\n *\n * GPU-eligible.\n */\nexport class Drag extends UpdateModule {\n  public drag: number;\n\n  public constructor(drag: number) {\n    super();\n    this.drag = drag;\n  }\n\n  public override apply(particles: ParticleBatch, dt: number): void {\n    const { x: velX, y: velY } = particles.velocity;\n    const liveCount = particles.count;\n    const factor = 1 - this.drag * dt;\n\n    for (let i = 0; i < liveCount; i++) {\n      velX[i] = (velX[i] ?? 0) * factor;\n      velY[i] = (velY[i] ?? 0) * factor;\n    }\n  }\n\n  public override wgsl(): WgslContribution {\n    return {\n      key: 'Drag',\n      uniforms: [{ name: 'drag', type: 'f32' }],\n      body: `\n                let dragFactor = 1.0 - modules.u_Drag.drag * dt;\n                velocities[idx] = velocities[idx] * dragFactor;\n            `,\n    };\n  }\n\n  public override writeUniforms(view: DataView, offset: number): void {\n    view.setFloat32(offset + 0, this.drag, true);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAeA,IAAa,OAAb,cAA0B,aAAa;CACrC,AAAO;CAEP,AAAO,YAAY,MAAc;EAC/B,MAAM;EACN,KAAK,OAAO;CACd;CAEA,AAAgB,MAAM,WAA0B,IAAkB;EAChE,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,UAAU;EACvC,MAAM,YAAY,UAAU;EAC5B,MAAM,SAAS,IAAI,KAAK,OAAO;EAE/B,KAAK,IAAI,IAAI,GAAG,IAAI,WAAW,KAAK;GAClC,KAAK,MAAM,KAAK,MAAM,KAAK;GAC3B,KAAK,MAAM,KAAK,MAAM,KAAK;EAC7B;CACF;CAEA,AAAgB,OAAyB;EACvC,OAAO;GACL,KAAK;GACL,UAAU,CAAC;IAAE,MAAM;IAAQ,MAAM;GAAM,CAAC;GACxC,MAAM;;;;EAIR;CACF;CAEA,AAAgB,cAAc,MAAgB,QAAsB;EAClE,KAAK,WAAW,SAAS,GAAG,KAAK,MAAM,IAAI;CAC7C;AACF"}

package/dist/esm/modules/OrbitalForce.d.ts

@@ -1,8 +1,8 @@
-import type { ParticleSystem } from "#ParticleSystem";
+import type { ParticleBatch } from '#ParticleStorage';
 import { UpdateModule } from './UpdateModule';
 import type { WgslContribution } from './WgslContribution';
 /**
- * Applies a tangential acceleration around a center point — perpendicular
+ * Applies a tangential acceleration around a center point - perpendicular
  * to the radial vector `(particle − center)`. Combined with an attract /
  * repel module that controls the radial distance, this produces orbital,
  * spiral, or vortex motion.
@@ -22,7 +22,8 @@ export declare class OrbitalForce extends UpdateModule {
     y: number;
     angularSpeed: number;
     constructor(x: number, y: number, angularSpeed: number);
-    apply(system: ParticleSystem, dt: number): void;
+    apply(particles: ParticleBatch, dt: number): void;
     wgsl(): WgslContribution;
     writeUniforms(view: DataView, offset: number): void;
 }
+//# sourceMappingURL=OrbitalForce.d.ts.map

package/dist/esm/modules/OrbitalForce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OrbitalForce.d.ts","sourceRoot":"","sources":["../../../src/modules/OrbitalForce.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,YAAa,SAAQ,YAAY;IACrC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,YAAY,EAAE,MAAM,CAAC;gBAET,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM;IAO7C,KAAK,CAAC,SAAS,EAAE,aAAa,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;IAgBjD,IAAI,IAAI,gBAAgB;IAgBxB,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;CAMpE"}