@cazala/party 0.2.1 → 0.4.0

package/dist/index.js

@@ -399,6 +399,33 @@ class GPUResources {
             stagingBuffer.destroy();
         }
     }
+    /**
+     * Read an arbitrary GPUBuffer (storage/uniform) into an ArrayBuffer.
+     * Caller is responsible for interpreting the bytes.
+     */
+    async readBuffer(buffer, sizeBytes) {
+        const bytes = Math.max(0, Math.floor(sizeBytes));
+        if (bytes === 0)
+            return new ArrayBuffer(0);
+        const stagingBuffer = this.getDevice().createBuffer({
+            size: bytes,
+            usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+        });
+        try {
+            const encoder = this.getDevice().createCommandEncoder();
+            encoder.copyBufferToBuffer(buffer, 0, stagingBuffer, 0, bytes);
+            this.getDevice().queue.submit([encoder.finish()]);
+            await this.getDevice().queue.onSubmittedWorkDone();
+            await stagingBuffer.mapAsync(GPUMapMode.READ);
+            const mapped = stagingBuffer.getMappedRange();
+            const out = mapped.slice(0);
+            stagingBuffer.unmap();
+            return out;
+        }
+        finally {
+            stagingBuffer.destroy();
+        }
+    }
     createModuleUniformBuffers(layouts) {
         // Destroy old
         this.moduleUniformBuffers.forEach(({ buffer }) => buffer.destroy());
@@ -1160,9 +1187,22 @@ class ParticleStore {
     }
     addParticle(p) {
         if (this.count >= this.maxParticles)
-            return;
-        this.writeAtIndex(this.count, p);
+            return -1;
+        const index = this.count;
+        this.writeAtIndex(index, p);
         this.count++;
+        return index;
+    }
+    setParticle(index, p) {
+        if (index < 0 || index >= this.count)
+            return;
+        this.writeAtIndex(index, p);
+    }
+    setParticleMass(index, mass) {
+        if (index < 0 || index >= this.count)
+            return;
+        const base = index * this.floatsPerParticle;
+        this.data[base + 7] = mass;
     }
     clear() {
         this.count = 0;
@@ -1192,6 +1232,28 @@ class ParticleStore {
             },
         };
     }
+    getFloatsPerParticle() {
+        return this.floatsPerParticle;
+    }
+    /**
+     * Write a full particle record at index into GPU storage.
+     */
+    syncParticleToGPU(resources, index) {
+        if (index < 0 || index >= this.count)
+            return;
+        const base = index * this.floatsPerParticle;
+        const slice = this.data.subarray(base, base + this.floatsPerParticle);
+        resources.writeParticleSlice(base, slice);
+    }
+    /**
+     * Write a single mass value at index into GPU storage.
+     */
+    syncParticleMassToGPU(resources, index) {
+        if (index < 0 || index >= this.count)
+            return;
+        const offset = index * this.floatsPerParticle + 7;
+        resources.writeParticleSlice(offset, new Float32Array([this.data[offset]]));
+    }
     /**
      * Writes the currently active particle slice to the GPU particle buffer.
      * Assumes the GPU storage buffer has already been created with matching capacity.
@@ -3437,6 +3499,219 @@ class RenderPipeline {
     }
 }
 
+/**
+ * LocalQuery
+ *
+ * A small WebGPU compute pipeline used to query a bounded set of particles
+ * in a region without doing a full GPU→CPU readback of the entire particle buffer.
+ *
+ * This is used by tool-like features (brush/pin/remove) that need local occupancy.
+ */
+class LocalQuery {
+    constructor() {
+        Object.defineProperty(this, "pipeline", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "uniform", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "count", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "out", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "outIdx", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "capacity", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "device", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    dispose() {
+        this.pipeline = null;
+        this.uniform?.destroy();
+        this.count?.destroy();
+        this.out?.destroy();
+        this.outIdx?.destroy();
+        this.uniform = null;
+        this.count = null;
+        this.out = null;
+        this.outIdx = null;
+        this.capacity = 0;
+        this.device = null;
+    }
+    ensure(resources, maxResults) {
+        const device = resources.getDevice();
+        // If device changed (runtime toggle / recreate), rebuild everything.
+        if (this.device && this.device !== device) {
+            this.dispose();
+        }
+        this.device = device;
+        // (Re)allocate buffers if capacity changed
+        if (this.capacity !== maxResults) {
+            this.capacity = maxResults;
+            this.uniform?.destroy();
+            this.count?.destroy();
+            this.out?.destroy();
+            this.outIdx?.destroy();
+            this.uniform = device.createBuffer({
+                size: 8 * 4,
+                usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+            });
+            this.count = device.createBuffer({
+                size: 4,
+                usage: GPUBufferUsage.STORAGE |
+                    GPUBufferUsage.COPY_DST |
+                    GPUBufferUsage.COPY_SRC,
+            });
+            this.out = device.createBuffer({
+                size: maxResults * 16,
+                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
+            });
+            this.outIdx = device.createBuffer({
+                size: maxResults * 4,
+                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
+            });
+        }
+        if (this.pipeline)
+            return;
+        const code = `
+struct Particle {
+  position: vec2<f32>,
+  velocity: vec2<f32>,
+  acceleration: vec2<f32>,
+  size: f32,
+  mass: f32,
+  color: vec4<f32>,
+};
+
+struct QueryUniforms {
+  v0: vec4<f32>, // center.x, center.y, radius, maxResults (as f32)
+  v1: vec4<f32>, // particleCount, 0,0,0
+};
+
+@group(0) @binding(0) var<storage, read> particles: array<Particle>;
+@group(0) @binding(1) var<uniform> query: QueryUniforms;
+@group(0) @binding(2) var<storage, read_write> outCount: atomic<u32>;
+@group(0) @binding(3) var<storage, read_write> outData: array<vec4<f32>>;
+@group(0) @binding(4) var<storage, read_write> outIndex: array<u32>;
+
+@compute @workgroup_size(256)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let i = gid.x;
+  let count = u32(query.v1.x);
+  if (i >= count) { return; }
+
+  let p = particles[i];
+  if (p.mass == 0.0) { return; }
+
+  let cx = query.v0.x;
+  let cy = query.v0.y;
+  let radius = query.v0.z;
+  let maxResults = u32(query.v0.w);
+
+  // Disc-intersection semantics: dist <= radius + p.size
+  let dx = p.position.x - cx;
+  let dy = p.position.y - cy;
+  let rr = radius + p.size;
+  if (dx * dx + dy * dy > rr * rr) { return; }
+
+  let outIdx = atomicAdd(&outCount, 1u);
+  if (outIdx >= maxResults) { return; }
+  outData[outIdx] = vec4<f32>(p.position.x, p.position.y, p.size, p.mass);
+  outIndex[outIdx] = i;
+}
+`;
+        this.pipeline = device.createComputePipeline({
+            layout: "auto",
+            compute: { module: device.createShaderModule({ code }), entryPoint: "main" },
+        });
+    }
+    async getParticlesInRadius(resources, center, radius, particleCount, opts) {
+        const maxResults = Math.max(1, Math.floor(opts?.maxResults ?? 20000));
+        this.ensure(resources, maxResults);
+        const device = resources.getDevice();
+        const particleBuffer = resources.getParticleBuffer();
+        if (!particleBuffer)
+            return { particles: [], truncated: false };
+        // Reset atomic counter
+        device.queue.writeBuffer(this.count, 0, new Uint32Array([0]));
+        // Uniform: v0 = [cx, cy, radius, maxResults], v1 = [particleCount, 0, 0, 0]
+        const u = new Float32Array(8);
+        u[0] = center.x;
+        u[1] = center.y;
+        u[2] = radius;
+        u[3] = maxResults;
+        u[4] = particleCount;
+        device.queue.writeBuffer(this.uniform, 0, u);
+        const bindGroup = device.createBindGroup({
+            layout: this.pipeline.getBindGroupLayout(0),
+            entries: [
+                { binding: 0, resource: { buffer: particleBuffer } },
+                { binding: 1, resource: { buffer: this.uniform } },
+                { binding: 2, resource: { buffer: this.count } },
+                { binding: 3, resource: { buffer: this.out } },
+                { binding: 4, resource: { buffer: this.outIdx } },
+            ],
+        });
+        const encoder = device.createCommandEncoder();
+        const pass = encoder.beginComputePass();
+        pass.setPipeline(this.pipeline);
+        pass.setBindGroup(0, bindGroup);
+        const wg = 256;
+        const n = Math.max(0, Math.floor(particleCount));
+        pass.dispatchWorkgroups(Math.ceil(n / wg));
+        pass.end();
+        device.queue.submit([encoder.finish()]);
+        const countBuf = await resources.readBuffer(this.count, 4);
+        const found = new Uint32Array(countBuf)[0] ?? 0;
+        const truncated = found > maxResults;
+        const readCount = Math.min(found, maxResults);
+        if (readCount === 0)
+            return { particles: [], truncated };
+        const idxBuf = await resources.readBuffer(this.outIdx, readCount * 4);
+        const indices = new Uint32Array(idxBuf);
+        const outBuf = await resources.readBuffer(this.out, readCount * 16);
+        const outFloats = new Float32Array(outBuf);
+        const particles = [];
+        for (let i = 0; i < readCount; i++) {
+            const base = i * 4;
+            particles.push({
+                index: indices[i] ?? 0,
+                position: { x: outFloats[base + 0], y: outFloats[base + 1] },
+                size: outFloats[base + 2],
+                mass: outFloats[base + 3],
+            });
+        }
+        return { particles, truncated };
+    }
+}
+
 class WebGPUEngine extends AbstractEngine {
     constructor(options) {
         super({
@@ -3515,6 +3790,12 @@ class WebGPUEngine extends AbstractEngine {
             writable: true,
             value: false
         });
+        Object.defineProperty(this, "localQuery", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "animate", {
             enumerable: true,
             configurable: true,
@@ -3584,6 +3865,7 @@ class WebGPUEngine extends AbstractEngine {
         this.sim = new SimulationPipeline();
         this.render = new RenderPipeline();
         this.grid = new SpacialGrid(this.cellSize);
+        this.localQuery = new LocalQuery();
     }
     async initialize() {
         await this.resources.initialize();
@@ -3640,6 +3922,7 @@ class WebGPUEngine extends AbstractEngine {
             cancelAnimationFrame(this.animationId);
             this.animationId = null;
         }
+        this.localQuery.dispose();
         await this.resources.dispose();
     }
     // Override setSize to also update WebGPU-specific resources
@@ -3663,12 +3946,24 @@ class WebGPUEngine extends AbstractEngine {
             this.updateMaxSize(particle.size);
         }
     }
-    async addParticle(p) {
-        await this.particles.syncFromGPU(this.resources);
-        this.particles.addParticle(p);
-        this.particles.syncToGPU(this.resources);
+    addParticle(p) {
+        const index = this.particles.addParticle(p);
+        if (index < 0)
+            return -1;
+        // Push only the new particle record to GPU (no full-scene readback).
+        this.particles.syncParticleToGPU(this.resources, index);
         // Update maxSize tracking
         this.updateMaxSize(p.size);
+        return index;
+    }
+    setParticle(index, p) {
+        this.particles.setParticle(index, p);
+        this.particles.syncParticleToGPU(this.resources, index);
+        this.updateMaxSize(p.size);
+    }
+    setParticleMass(index, mass) {
+        this.particles.setParticleMass(index, mass);
+        this.particles.syncParticleMassToGPU(this.resources, index);
     }
     /**
      * Forces GPU-to-CPU synchronization and returns current particle data.
@@ -3682,6 +3977,9 @@ class WebGPUEngine extends AbstractEngine {
         await this.particles.syncFromGPU(this.resources);
         return this.particles.getParticle(index);
     }
+    async getParticlesInRadius(center, radius, opts) {
+        return await this.localQuery.getParticlesInRadius(this.resources, center, radius, this.getCount(), opts);
+    }
     getCount() {
         const actualCount = this.particles.getCount();
         if (this.maxParticles === null) {
@@ -4298,6 +4596,12 @@ class CPUEngine extends AbstractEngine {
             writable: true,
             value: null
         });
+        Object.defineProperty(this, "particleIdToIndex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
         Object.defineProperty(this, "animate", {
             enumerable: true,
             configurable: true,
@@ -4372,6 +4676,7 @@ class CPUEngine extends AbstractEngine {
         this.fpsEstimate = 60;
         // Reset maxSize tracking
         this.resetMaxSize();
+        this.particleIdToIndex.clear();
     }
     getCount() {
         const actualCount = this.particles.length;
@@ -4395,11 +4700,33 @@ class CPUEngine extends AbstractEngine {
         for (const p of particle) {
             this.updateMaxSize(p.size);
         }
+        this.particleIdToIndex.clear();
     }
     addParticle(particle) {
+        const index = this.particles.length;
         this.particles.push(new Particle(particle));
         // Update maxSize tracking
         this.updateMaxSize(particle.size);
+        const created = this.particles[index];
+        if (created)
+            this.particleIdToIndex.set(created.id, index);
+        return index;
+    }
+    setParticle(index, p) {
+        if (index < 0)
+            return;
+        if (index >= this.particles.length)
+            return;
+        this.particles[index] = new Particle(p);
+        // Best-effort maxSize tracking (monotonic)
+        this.updateMaxSize(p.size);
+    }
+    setParticleMass(index, mass) {
+        if (index < 0)
+            return;
+        if (index >= this.particles.length)
+            return;
+        this.particles[index].mass = mass;
     }
     getParticles() {
         return Promise.resolve(this.particles.map((p) => p.toJSON()));
@@ -4407,10 +4734,47 @@ class CPUEngine extends AbstractEngine {
     getParticle(index) {
         return Promise.resolve(this.particles[index]);
     }
+    async getParticlesInRadius(center, radius, opts) {
+        const maxResults = Math.max(1, Math.floor(opts?.maxResults ?? 20000));
+        // Expand search radius to ensure we can find large particles whose discs
+        // intersect the query circle: dist <= radius + p.size.
+        const searchRadius = Math.max(0, radius) + this.getMaxSize();
+        // Use the existing spatial grid (built during the last simulation tick).
+        // Snapshot semantics: this is "as of last grid build" which is good enough
+        // for tool usage and avoids global scans.
+        const neighbors = this.grid.getParticles(new Vector(center.x, center.y), searchRadius, 
+        // Ask for up to maxResults+1 so we can mark truncated more reliably.
+        maxResults + 1);
+        const out = [];
+        const r = Math.max(0, radius);
+        for (const p of neighbors) {
+            if (p.mass === 0)
+                continue;
+            const index = this.particleIdToIndex.get(p.id);
+            if (index === undefined)
+                continue;
+            const dx = p.position.x - center.x;
+            const dy = p.position.y - center.y;
+            const rr = r + p.size;
+            if (dx * dx + dy * dy <= rr * rr) {
+                out.push({
+                    index,
+                    position: { x: p.position.x, y: p.position.y },
+                    size: p.size,
+                    mass: p.mass,
+                });
+                if (out.length >= maxResults + 1)
+                    break;
+            }
+        }
+        const truncated = out.length > maxResults;
+        return { particles: truncated ? out.slice(0, maxResults) : out, truncated };
+    }
     destroy() {
         this.pause();
         this.particles = [];
         this.grid.clear();
+        this.particleIdToIndex.clear();
         return Promise.resolve();
     }
     // Handle configuration changes
@@ -4457,8 +4821,10 @@ class CPUEngine extends AbstractEngine {
         // Update spatial grid with current particle positions and camera
         this.grid.setCamera(this.view.getCamera().x, this.view.getCamera().y, this.view.getZoom());
         this.grid.clear();
+        this.particleIdToIndex.clear();
         for (let i = 0; i < effectiveCount; i++) {
             this.grid.insert(this.particles[i]);
+            this.particleIdToIndex.set(this.particles[i].id, i);
         }
         // Global state for modules that need it
         const globalState = {};
@@ -4948,7 +5314,13 @@ class Engine {
         this.engine.setParticles(p);
     }
     addParticle(p) {
-        this.engine.addParticle(p);
+        return this.engine.addParticle(p);
+    }
+    setParticle(index, p) {
+        this.engine.setParticle(index, p);
+    }
+    setParticleMass(index, mass) {
+        this.engine.setParticleMass(index, mass);
     }
     getParticles() {
         return this.engine.getParticles();
@@ -4956,6 +5328,9 @@ class Engine {
     getParticle(index) {
         return this.engine.getParticle(index);
     }
+    getParticlesInRadius(center, radius, opts) {
+        return this.engine.getParticlesInRadius(center, radius, opts);
+    }
     // Helpers for pinning/unpinning
     async pinParticles(indexes) {
         const particles = await this.getParticles();
@@ -5056,6 +5431,7 @@ class Engine {
     }
 }
 
+const TEXT_SPAWNER_FONTS = ["sans-serif", "serif", "monospace"];
 function calculateVelocity(position, center, cfg) {
     if (!cfg || cfg.speed === 0)
         return { vx: 0, vy: 0 };
@@ -5097,7 +5473,7 @@ function calculateVelocity(position, center, cfg) {
 }
 class Spawner {
     initParticles(options) {
-        const { count, shape, center, spacing = 25, radius = 100, innerRadius = 50, squareSize = 200, cornerRadius = 0, size = 5, mass = 1, bounds, velocity, colors, } = options;
+        const { count, shape, center, spacing = 25, radius = 100, innerRadius = 50, squareSize = 200, cornerRadius = 0, size = 5, mass = 1, bounds, velocity, colors, text = "Party", font = "sans-serif", textSize = 64, position, align, } = options;
         const particles = [];
         if (count <= 0)
             return particles;
@@ -5124,6 +5500,93 @@ class Spawner {
                 return { r: 1, g: 1, b: 1, a: 1 };
             return toColor(colors[Math.floor(Math.random() * colors.length)]);
         };
+        if (shape === "text") {
+            const textValue = text.trim();
+            if (!textValue)
+                return particles;
+            const createCanvas = () => {
+                if (typeof OffscreenCanvas !== "undefined") {
+                    return new OffscreenCanvas(1, 1);
+                }
+                if (typeof document !== "undefined") {
+                    return document.createElement("canvas");
+                }
+                return null;
+            };
+            const canvas = createCanvas();
+            if (!canvas)
+                return particles;
+            const ctx = canvas.getContext("2d");
+            if (!ctx)
+                return particles;
+            const fontSize = Math.max(1, Math.floor(textSize));
+            const fontSpec = `${fontSize}px ${font}`;
+            ctx.font = fontSpec;
+            ctx.textBaseline = "alphabetic";
+            ctx.textAlign = "left";
+            const metrics = ctx.measureText(textValue);
+            const ascent = metrics.actualBoundingBoxAscent || fontSize;
+            const descent = metrics.actualBoundingBoxDescent || fontSize * 0.25;
+            const left = metrics.actualBoundingBoxLeft || 0;
+            const right = metrics.actualBoundingBoxRight || metrics.width;
+            const textWidth = Math.max(1, Math.ceil(left + right));
+            const textHeight = Math.max(1, Math.ceil(ascent + descent));
+            const padding = Math.ceil(fontSize * 0.25);
+            canvas.width = textWidth + padding * 2;
+            canvas.height = textHeight + padding * 2;
+            ctx.clearRect(0, 0, canvas.width, canvas.height);
+            ctx.font = fontSpec;
+            ctx.textBaseline = "alphabetic";
+            ctx.textAlign = "left";
+            ctx.fillStyle = "#ffffff";
+            ctx.fillText(textValue, padding + left, padding + ascent);
+            const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+            const data = imageData.data;
+            const sampleStep = Math.max(1, Math.round(size));
+            const points = [];
+            for (let y = 0; y < canvas.height; y += sampleStep) {
+                for (let x = 0; x < canvas.width; x += sampleStep) {
+                    const idx = (y * canvas.width + x) * 4 + 3;
+                    if (data[idx] > 0) {
+                        points.push({ x, y });
+                    }
+                }
+            }
+            const maxCount = Math.min(count, points.length);
+            if (maxCount <= 0)
+                return particles;
+            const textPosition = position ?? center;
+            const horizontal = align?.horizontal ?? "center";
+            const vertical = align?.vertical ?? "center";
+            const originX = horizontal === "left"
+                ? textPosition.x
+                : horizontal === "right"
+                    ? textPosition.x - textWidth
+                    : textPosition.x - textWidth / 2;
+            const originY = vertical === "top"
+                ? textPosition.y
+                : vertical === "bottom"
+                    ? textPosition.y - textHeight
+                    : textPosition.y - textHeight / 2;
+            const stride = points.length / maxCount;
+            for (let i = 0; i < maxCount; i++) {
+                const idx = Math.floor(i * stride);
+                const point = points[idx];
+                if (!point)
+                    continue;
+                const x = originX + (point.x - padding);
+                const y = originY + (point.y - padding);
+                const { vx, vy } = calculateVelocity({ x, y }, textPosition, velocity);
+                particles.push({
+                    position: { x, y },
+                    velocity: { x: vx, y: vy },
+                    size,
+                    mass,
+                    color: getColor(),
+                });
+            }
+            return particles;
+        }
         if (shape === "grid") {
             const cols = Math.ceil(Math.sqrt(count));
             const rows = Math.ceil(count / cols);
@@ -5720,15 +6183,11 @@ class Boundary extends Module {
     webgpu() {
         return {
             apply: ({ particleVar, getUniform }) => `{
-  // Bounce using global grid extents
   let halfSize = ${particleVar}.size;
   let minX = GRID_MINX();
   let maxX = GRID_MAXX();
   let minY = GRID_MINY();
   let maxY = GRID_MAXY();
-  let bounce = ${getUniform("restitution")};
-  let friction = ${getUniform("friction")};
-  let mode = ${getUniform("mode")};
   let repelDist = ${getUniform("repelDistance")};
   let repelStrength = ${getUniform("repelStrength")};
 
@@ -5773,34 +6232,54 @@ class Boundary extends Module {
     }
     ${particleVar}.acceleration += vec2<f32>(fx, fy);
   }
+}`,
+            correct: ({ particleVar, prevPosVar, postPosVar, getUniform }) => `{
+  // Resolve boundaries post-integration to reduce dt-dependent jitter.
+  // We use prev/post integration positions (SIM_STATE) to detect crossings.
+  let halfSize = ${particleVar}.size;
+  let minX = GRID_MINX();
+  let maxX = GRID_MAXX();
+  let minY = GRID_MINY();
+  let maxY = GRID_MAXY();
+  let bounce = ${getUniform("restitution")};
+  let friction = ${getUniform("friction")};
+  let mode = ${getUniform("mode")};
+
+  let prevPos = ${prevPosVar};
+  let postPos = ${postPosVar};
+  var vel = ${particleVar}.velocity;
 
   if (mode == 0.0) {
-    // bounce
-    // X axis
-    if (${particleVar}.position.x - halfSize < minX) {
+    // bounce (CCD-ish using prev/post)
+    // Left wall
+    if (postPos.x - halfSize < minX) {
       ${particleVar}.position.x = minX + halfSize;
-      ${particleVar}.velocity.x = -${particleVar}.velocity.x * bounce;
-      ${particleVar}.velocity.y *= max(0.0, 1.0 - friction);
-    } else if (${particleVar}.position.x + halfSize > maxX) {
+      if (vel.x < 0.0) { vel.x = -vel.x * bounce; }
+      vel.y = vel.y * max(0.0, 1.0 - friction);
+    }
+    // Right wall
+    else if (postPos.x + halfSize > maxX) {
       ${particleVar}.position.x = maxX - halfSize;
-      ${particleVar}.velocity.x = -${particleVar}.velocity.x * bounce;
-      ${particleVar}.velocity.y *= max(0.0, 1.0 - friction);
+      if (vel.x > 0.0) { vel.x = -vel.x * bounce; }
+      vel.y = vel.y * max(0.0, 1.0 - friction);
     }
 
-    // Y axis
-    if (${particleVar}.position.y - halfSize < minY) {
+    // Top
+    if (postPos.y - halfSize < minY) {
       ${particleVar}.position.y = minY + halfSize;
-      ${particleVar}.velocity.y = -${particleVar}.velocity.y * bounce;
-      ${particleVar}.velocity.x *= max(0.0, 1.0 - friction);
-    } else if (${particleVar}.position.y + halfSize > maxY) {
+      if (vel.y < 0.0) { vel.y = -vel.y * bounce; }
+      vel.x = vel.x * max(0.0, 1.0 - friction);
+    }
+    // Bottom (floor)
+    else if (postPos.y + halfSize > maxY) {
       ${particleVar}.position.y = maxY - halfSize;
-      ${particleVar}.velocity.y = -${particleVar}.velocity.y * bounce;
-      ${particleVar}.velocity.x *= max(0.0, 1.0 - friction);
+      if (vel.y > 0.0) { vel.y = -vel.y * bounce; }
+      vel.x = vel.x * max(0.0, 1.0 - friction);
     }
+    ${particleVar}.velocity = vel;
   } else if (mode == 1.0) {
-    // warp
-    // Only warp once the particle is fully outside the bounds
-    let eps = 1.0; // spawn just outside the opposite edge so it slides in
+    // warp (post-integration)
+    let eps = 1.0;
     if (${particleVar}.position.x + halfSize < minX) {
       ${particleVar}.position.x = maxX + halfSize + eps;
     } else if (${particleVar}.position.x - halfSize > maxX) {
@@ -5812,24 +6291,15 @@ class Boundary extends Module {
       ${particleVar}.position.y = minY - halfSize - eps;
     }
   } else if (mode == 2.0) {
-    // kill
-    // Only kill once the particle is fully outside the bounds
-    if (${particleVar}.position.x - halfSize < minX) {
-      ${particleVar}.position.x = minX - halfSize * 4;
-      ${particleVar}.mass = 0.0;
-    } else if (${particleVar}.position.x + halfSize > maxX) {
-      ${particleVar}.position.x = maxX + halfSize * 4;
+    // kill (post-integration)
+    if (${particleVar}.position.x + halfSize < minX ||
+        ${particleVar}.position.x - halfSize > maxX ||
+        ${particleVar}.position.y + halfSize < minY ||
+        ${particleVar}.position.y - halfSize > maxY) {
       ${particleVar}.mass = 0.0;
     }
-    if (${particleVar}.position.y - halfSize < minY) {
-      ${particleVar}.position.y = minY - halfSize * 4;
-      ${particleVar}.mass = 0.0;
-    } else if (${particleVar}.position.y + halfSize > maxY) {
-      ${particleVar}.position.y = maxY + halfSize * 4;
-      ${particleVar}.mass = 0.0;
-    } 
   } else if (mode == 3.0) {
-    // none: no boundary constraints; repel force above still applies
+    // none
   }
 }`,
         };
@@ -5848,9 +6318,6 @@ class Boundary extends Module {
                 const minY = camera.y - halfH;
                 const maxY = camera.y + halfH;
                 const halfSize = particle.size;
-                const bounce = input.restitution;
-                const friction = input.friction;
-                const mode = input.mode;
                 const repelDist = input.repelDistance;
                 const repelStrength = input.repelStrength;
                 // Repel force applied for all modes
@@ -5901,35 +6368,52 @@ class Boundary extends Module {
                     }
                     particle.acceleration.add(new Vector(fx, fy));
                 }
+            },
+            correct: ({ particle, input, view }) => {
+                // Resolve boundaries post-integration to reduce dt-dependent jitter.
+                const camera = view.getCamera();
+                const zoom = Math.max(view.getZoom(), 0.0001);
+                const size = view.getSize();
+                const halfW = size.width / (2 * zoom);
+                const halfH = size.height / (2 * zoom);
+                const minX = camera.x - halfW;
+                const maxX = camera.x + halfW;
+                const minY = camera.y - halfH;
+                const maxY = camera.y + halfH;
+                const halfSize = particle.size;
+                const bounce = input.restitution;
+                const friction = input.friction;
+                const mode = input.mode;
                 if (mode === 0) {
                     // bounce
-                    // X axis
                     if (particle.position.x - halfSize < minX) {
                         particle.position.x = minX + halfSize;
-                        particle.velocity.x = -particle.velocity.x * bounce;
+                        if (particle.velocity.x < 0)
+                            particle.velocity.x = -particle.velocity.x * bounce;
                         particle.velocity.y *= Math.max(0, 1 - friction);
                     }
                     else if (particle.position.x + halfSize > maxX) {
                         particle.position.x = maxX - halfSize;
-                        particle.velocity.x = -particle.velocity.x * bounce;
+                        if (particle.velocity.x > 0)
+                            particle.velocity.x = -particle.velocity.x * bounce;
                         particle.velocity.y *= Math.max(0, 1 - friction);
                     }
-                    // Y axis
                     if (particle.position.y - halfSize < minY) {
                         particle.position.y = minY + halfSize;
-                        particle.velocity.y = -particle.velocity.y * bounce;
+                        if (particle.velocity.y < 0)
+                            particle.velocity.y = -particle.velocity.y * bounce;
                         particle.velocity.x *= Math.max(0, 1 - friction);
                     }
                     else if (particle.position.y + halfSize > maxY) {
                         particle.position.y = maxY - halfSize;
-                        particle.velocity.y = -particle.velocity.y * bounce;
+                        if (particle.velocity.y > 0)
+                            particle.velocity.y = -particle.velocity.y * bounce;
                         particle.velocity.x *= Math.max(0, 1 - friction);
                     }
                 }
                 else if (mode === 1) {
                     // warp
-                    // Only warp once the particle is fully outside the bounds
-                    const eps = 1; // spawn just outside the opposite edge so it slides in
+                    const eps = 1;
                     if (particle.position.x + halfSize < minX) {
                         particle.position.x = maxX + halfSize + eps;
                     }
@@ -5945,7 +6429,6 @@ class Boundary extends Module {
                 }
                 else if (mode === 2) {
                     // kill
-                    // Only kill once the particle is fully outside the bounds
                     if (particle.position.x + halfSize < minX ||
                         particle.position.x - halfSize > maxX ||
                         particle.position.y + halfSize < minY ||
@@ -5953,7 +6436,6 @@ class Boundary extends Module {
                         particle.mass = 0;
                     }
                 }
-                else ;
             },
         };
     }
@@ -9998,5 +10480,5 @@ class Particles extends Module {
     }
 }
 
-export { AbstractEngine, Behavior, Boundary, CanvasComposition, Collisions, DEFAULT_BEHAVIOR_ALIGNMENT, DEFAULT_BEHAVIOR_AVOID, DEFAULT_BEHAVIOR_CHASE, DEFAULT_BEHAVIOR_COHESION, DEFAULT_BEHAVIOR_REPULSION, DEFAULT_BEHAVIOR_SEPARATION, DEFAULT_BEHAVIOR_VIEW_ANGLE, DEFAULT_BEHAVIOR_VIEW_RADIUS, DEFAULT_BEHAVIOR_WANDER, DEFAULT_BOUNDARY_FRICTION, DEFAULT_BOUNDARY_MODE, DEFAULT_BOUNDARY_REPEL_DISTANCE, DEFAULT_BOUNDARY_REPEL_STRENGTH, DEFAULT_BOUNDARY_RESTITUTION, DEFAULT_COLLISIONS_RESTITUTION, DEFAULT_ENVIRONMENT_DAMPING, DEFAULT_ENVIRONMENT_FRICTION, DEFAULT_ENVIRONMENT_GRAVITY_ANGLE, DEFAULT_ENVIRONMENT_GRAVITY_DIRECTION, DEFAULT_ENVIRONMENT_GRAVITY_STRENGTH, DEFAULT_ENVIRONMENT_INERTIA, DEFAULT_FLUIDS_ENABLE_NEAR_PRESSURE, DEFAULT_FLUIDS_INFLUENCE_RADIUS, DEFAULT_FLUIDS_MAX_ACCELERATION, DEFAULT_FLUIDS_NEAR_PRESSURE_MULTIPLIER, DEFAULT_FLUIDS_NEAR_THRESHOLD, DEFAULT_FLUIDS_PRESSURE_MULTIPLIER, DEFAULT_FLUIDS_TARGET_DENSITY, DEFAULT_FLUIDS_VISCOSITY, DEFAULT_GRAB_GRABBED_INDEX, DEFAULT_GRAB_POSITION_X, DEFAULT_GRAB_POSITION_Y, DEFAULT_INTERACTION_MODE, DEFAULT_INTERACTION_RADIUS, DEFAULT_INTERACTION_STRENGTH, DEFAULT_JOINTS_ENABLE_JOINT_COLLISIONS, DEFAULT_JOINTS_ENABLE_PARTICLE_COLLISIONS, DEFAULT_JOINTS_FRICTION, DEFAULT_JOINTS_MOMENTUM, DEFAULT_JOINTS_RESTITUTION, DEFAULT_JOINTS_SEPARATION, DEFAULT_JOINTS_STEPS, DEFAULT_PICFLIP_DENSITY, DEFAULT_PICFLIP_FLIP_RATIO, DEFAULT_PICFLIP_INFLUENCE_RADIUS, DEFAULT_PICFLIP_INTERNAL_MAX_ACCELERATION, DEFAULT_PICFLIP_PRESSURE, DEFAULT_PICFLIP_PRESSURE_MULTIPLIER, DEFAULT_PICFLIP_RADIUS, DEFAULT_PICFLIP_TARGET_DENSITY, DEFAULT_SENSORS_COLOR_SIMILARITY_THRESHOLD, DEFAULT_SENSORS_FLEE_ANGLE, DEFAULT_SENSORS_FLEE_BEHAVIOR, DEFAULT_SENSORS_FOLLOW_BEHAVIOR, DEFAULT_SENSORS_SENSOR_ANGLE, DEFAULT_SENSORS_SENSOR_DISTANCE, DEFAULT_SENSORS_SENSOR_RADIUS, DEFAULT_SENSORS_SENSOR_STRENGTH, DEFAULT_SENSORS_SENSOR_THRESHOLD, DEFAULT_TRAILS_TRAIL_DECAY, DEFAULT_TRAILS_TRAIL_DIFFUSE, DataType, Engine, Environment, Fluids, FluidsMethod, Grab, Interaction, Joints, Lines, Module, ModuleRole, OscillatorManager, Particles, ParticlesColorType, RenderPassKind, Sensors, Spawner, Trails, Vector, degToRad, radToDeg };
+export { AbstractEngine, Behavior, Boundary, CanvasComposition, Collisions, DEFAULT_BEHAVIOR_ALIGNMENT, DEFAULT_BEHAVIOR_AVOID, DEFAULT_BEHAVIOR_CHASE, DEFAULT_BEHAVIOR_COHESION, DEFAULT_BEHAVIOR_REPULSION, DEFAULT_BEHAVIOR_SEPARATION, DEFAULT_BEHAVIOR_VIEW_ANGLE, DEFAULT_BEHAVIOR_VIEW_RADIUS, DEFAULT_BEHAVIOR_WANDER, DEFAULT_BOUNDARY_FRICTION, DEFAULT_BOUNDARY_MODE, DEFAULT_BOUNDARY_REPEL_DISTANCE, DEFAULT_BOUNDARY_REPEL_STRENGTH, DEFAULT_BOUNDARY_RESTITUTION, DEFAULT_COLLISIONS_RESTITUTION, DEFAULT_ENVIRONMENT_DAMPING, DEFAULT_ENVIRONMENT_FRICTION, DEFAULT_ENVIRONMENT_GRAVITY_ANGLE, DEFAULT_ENVIRONMENT_GRAVITY_DIRECTION, DEFAULT_ENVIRONMENT_GRAVITY_STRENGTH, DEFAULT_ENVIRONMENT_INERTIA, DEFAULT_FLUIDS_ENABLE_NEAR_PRESSURE, DEFAULT_FLUIDS_INFLUENCE_RADIUS, DEFAULT_FLUIDS_MAX_ACCELERATION, DEFAULT_FLUIDS_NEAR_PRESSURE_MULTIPLIER, DEFAULT_FLUIDS_NEAR_THRESHOLD, DEFAULT_FLUIDS_PRESSURE_MULTIPLIER, DEFAULT_FLUIDS_TARGET_DENSITY, DEFAULT_FLUIDS_VISCOSITY, DEFAULT_GRAB_GRABBED_INDEX, DEFAULT_GRAB_POSITION_X, DEFAULT_GRAB_POSITION_Y, DEFAULT_INTERACTION_MODE, DEFAULT_INTERACTION_RADIUS, DEFAULT_INTERACTION_STRENGTH, DEFAULT_JOINTS_ENABLE_JOINT_COLLISIONS, DEFAULT_JOINTS_ENABLE_PARTICLE_COLLISIONS, DEFAULT_JOINTS_FRICTION, DEFAULT_JOINTS_MOMENTUM, DEFAULT_JOINTS_RESTITUTION, DEFAULT_JOINTS_SEPARATION, DEFAULT_JOINTS_STEPS, DEFAULT_PICFLIP_DENSITY, DEFAULT_PICFLIP_FLIP_RATIO, DEFAULT_PICFLIP_INFLUENCE_RADIUS, DEFAULT_PICFLIP_INTERNAL_MAX_ACCELERATION, DEFAULT_PICFLIP_PRESSURE, DEFAULT_PICFLIP_PRESSURE_MULTIPLIER, DEFAULT_PICFLIP_RADIUS, DEFAULT_PICFLIP_TARGET_DENSITY, DEFAULT_SENSORS_COLOR_SIMILARITY_THRESHOLD, DEFAULT_SENSORS_FLEE_ANGLE, DEFAULT_SENSORS_FLEE_BEHAVIOR, DEFAULT_SENSORS_FOLLOW_BEHAVIOR, DEFAULT_SENSORS_SENSOR_ANGLE, DEFAULT_SENSORS_SENSOR_DISTANCE, DEFAULT_SENSORS_SENSOR_RADIUS, DEFAULT_SENSORS_SENSOR_STRENGTH, DEFAULT_SENSORS_SENSOR_THRESHOLD, DEFAULT_TRAILS_TRAIL_DECAY, DEFAULT_TRAILS_TRAIL_DIFFUSE, DataType, Engine, Environment, Fluids, FluidsMethod, Grab, Interaction, Joints, Lines, Module, ModuleRole, OscillatorManager, Particles, ParticlesColorType, RenderPassKind, Sensors, Spawner, TEXT_SPAWNER_FONTS, Trails, Vector, degToRad, radToDeg };
 //# sourceMappingURL=index.js.map