@cazala/party 0.1.0-next.43.f9fb257 → 0.1.0-next.46.59ce407

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();
@@ -5720,15 +6095,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 +6144,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 +6203,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 +6230,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 +6280,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 +6341,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 +6348,6 @@ class Boundary extends Module {
                         particle.mass = 0;
                     }
                 }
-                else ;
             },
         };
     }