@adatechnology/game-destruction-three 0.11.1 → 0.12.0

package/dist/index.global.js

@@ -7727,6 +7727,11 @@ void main(){
   var MAX_CONFORM_STEPS = 48;
   var MIN_CONFORM_STEPS = 16;
   var BLOOD_GROW_RATE = 1.2;
+  var BLOOD_START_GROWTH = 0.05;
+  var DEFAULT_MAX_GROUND_MARKS = 64;
+  var DEFAULT_MAX_ROCKS = 512;
+  var DEFAULT_MAX_BLOOD = 256;
+  var MAX_SPARE_GROUND_GEOMETRIES = 16;
   function createMarkLayer(THREE, options) {
     const group = new THREE.Group();
     const textures = createMarkTextures(THREE, options.createCanvas);
@@ -7750,110 +7755,168 @@ void main(){
     const bloodMaterial = new THREE.MeshStandardMaterial({ color: 6031882, roughness: 0.15, metalness: 0.1, polygonOffset: true, polygonOffsetFactor: -3, polygonOffsetUnits: -3 });
     const bloodGeometry = new THREE.CircleGeometry(0.5, 9).rotateX(-Math.PI / 2);
     owned.push(bloodMaterial, bloodGeometry);
-    const rockMaterials = /* @__PURE__ */ new Map();
-    const blood = [];
-    let meshCount = 0;
-    function rockMaterial(color) {
-      let material = rockMaterials.get(color);
-      if (!material) {
-        material = new THREE.MeshStandardMaterial({ color, roughness: 0.9, metalness: 0, flatShading: true });
-        rockMaterials.set(color, material);
-        owned.push(material);
+    const maxGroundMarks = options.maxGroundMarks ?? DEFAULT_MAX_GROUND_MARKS;
+    const instanced = {};
+    function rockMaterial() {
+      if (!instanced.rockMaterial) {
+        instanced.rockMaterial = new THREE.MeshStandardMaterial({ color: 16777215, roughness: 0.9, metalness: 0, flatShading: true });
+        owned.push(instanced.rockMaterial);
       }
-      return material;
+      return instanced.rockMaterial;
+    }
+    function bloodMesh() {
+      return instanced.blood ?? (instanced.blood = attach(createInstanced(bloodGeometry, bloodMaterial, options.maxBlood ?? DEFAULT_MAX_BLOOD)));
+    }
+    function rockMesh() {
+      return instanced.rock ?? (instanced.rock = attach(createInstanced(options.rockGeometry, rockMaterial(), options.maxRocks ?? DEFAULT_MAX_ROCKS), true));
+    }
+    function plateMesh() {
+      return instanced.plate ?? (instanced.plate = attach(createInstanced(options.plateGeometry, rockMaterial(), options.maxRocks ?? DEFAULT_MAX_ROCKS), true));
+    }
+    function attach(mesh2, castShadow = false) {
+      mesh2.castShadow = castShadow;
+      group.add(mesh2);
+      return mesh2;
+    }
+    const groundMarks = [];
+    const spareGeometries = [];
+    const blood = [];
+    const placed = { blood: 0, rock: 0, plate: 0 };
+    const matrix = new THREE.Matrix4();
+    const position = new THREE.Vector3();
+    const quaternion = new THREE.Quaternion();
+    const euler = new THREE.Euler();
+    const scale = new THREE.Vector3();
+    const color = new THREE.Color();
+    const up = new THREE.Vector3(0, 1, 0);
+    function createInstanced(geometry, material, capacity) {
+      const mesh2 = new THREE.InstancedMesh(geometry, material, capacity);
+      mesh2.count = 0;
+      mesh2.frustumCulled = false;
+      mesh2.receiveShadow = true;
+      return mesh2;
+    }
+    function takeSpare(vertexCount) {
+      const found = spareGeometries.findIndex((geometry) => geometry.getAttribute("position").count === vertexCount);
+      return found < 0 ? void 0 : spareGeometries.splice(found, 1)[0];
+    }
+    function evictOldestGroundMark() {
+      const oldest = groundMarks.shift();
+      group.remove(oldest.mesh);
+      spareGeometries.push(oldest.mesh.geometry);
+      if (spareGeometries.length > MAX_SPARE_GROUND_GEOMETRIES) spareGeometries.shift().dispose();
     }
     function conform(mark, material) {
       const radius = mark.radius;
       const steps = Math.max(MIN_CONFORM_STEPS, Math.min(MAX_CONFORM_STEPS, Math.round(radius * 8)));
-      const geometry = new THREE.PlaneGeometry(2, 2, steps, steps).rotateX(-Math.PI / 2);
-      const position = geometry.attributes.position;
+      if (groundMarks.length >= maxGroundMarks) evictOldestGroundMark();
+      const geometry = takeSpare((steps + 1) * (steps + 1)) ?? new THREE.PlaneGeometry(2, 2, steps, steps).rotateX(-Math.PI / 2);
+      const grid = geometry.attributes.position;
+      const cell = 2 / steps;
       const cos2 = Math.cos(mark.rotation);
       const sin2 = Math.sin(mark.rotation);
-      for (let index = 0; index < position.count; index++) {
-        const localX = position.getX(index) * radius;
-        const localZ = position.getZ(index) * radius;
+      for (let index = 0; index < grid.count; index++) {
+        const localX = Math.fround(index % (steps + 1) * cell - 1) * radius;
+        const localZ = Math.fround(Math.floor(index / (steps + 1)) * cell - 1) * radius;
         const worldX = mark.x + localX * cos2 - localZ * sin2;
         const worldZ = mark.z + localX * sin2 + localZ * cos2;
-        position.setXYZ(index, worldX, (options.ground?.heightAt(worldX, worldZ) ?? 0) + mark.lift, worldZ);
+        grid.setXYZ(index, worldX, (options.ground?.heightAt(worldX, worldZ) ?? 0) + mark.lift, worldZ);
       }
+      grid.needsUpdate = true;
       geometry.computeVertexNormals();
+      geometry.attributes.normal.needsUpdate = true;
+      geometry.boundingSphere = null;
+      geometry.boundingBox = null;
       const mesh2 = new THREE.Mesh(geometry, material);
       mesh2.receiveShadow = true;
-      return mesh2;
+      group.add(mesh2);
+      groundMarks.push({ mesh: mesh2, steps });
     }
     function addRock(mark) {
-      const mesh2 = new THREE.Mesh(mark.plate ? options.plateGeometry : options.rockGeometry, rockMaterial(mark.color));
-      mesh2.position.set(mark.x, mark.y, mark.z);
-      mesh2.scale.set(mark.scale[0], mark.scale[1], mark.scale[2]);
-      mesh2.rotation.set(mark.rotation[0], mark.rotation[1], mark.rotation[2]);
-      mesh2.castShadow = true;
-      mesh2.receiveShadow = true;
-      return mesh2;
+      const mesh2 = mark.plate ? plateMesh() : rockMesh();
+      const slot = mark.plate ? "plate" : "rock";
+      const index = placed[slot]++ % mesh2.instanceMatrix.count;
+      quaternion.setFromEuler(euler.set(mark.rotation[0], mark.rotation[1], mark.rotation[2]));
+      mesh2.setMatrixAt(index, matrix.compose(position.set(mark.x, mark.y, mark.z), quaternion, scale.set(mark.scale[0], mark.scale[1], mark.scale[2])));
+      mesh2.setColorAt(index, color.set(mark.color));
+      mesh2.count = Math.min(placed[slot], mesh2.instanceMatrix.count);
+      mesh2.instanceMatrix.needsUpdate = true;
+      mesh2.instanceColor.needsUpdate = true;
+    }
+    function writeBlood(index, drawn, growth) {
+      quaternion.setFromAxisAngle(up, drawn.rotation);
+      const mesh2 = bloodMesh();
+      mesh2.setMatrixAt(index, matrix.compose(position.set(drawn.position[0], drawn.position[1], drawn.position[2]), quaternion, scale.set(drawn.scaleX * growth, 1, drawn.scaleZ * growth)));
+      mesh2.instanceMatrix.needsUpdate = true;
     }
     function addBlood(mark) {
-      const mesh2 = new THREE.Mesh(bloodGeometry, bloodMaterial);
-      mesh2.position.set(mark.x, mark.y, mark.z);
-      mesh2.scale.set(mark.scaleX, 1, mark.scaleZ);
-      mesh2.rotation.y = mark.rotation;
-      mesh2.receiveShadow = true;
-      mesh2.scale.multiplyScalar(0.05);
-      blood.push({ mesh: mesh2, scaleX: mark.scaleX, scaleZ: mark.scaleZ, age: 0 });
-      return mesh2;
+      const index = placed.blood++ % bloodMesh().instanceMatrix.count;
+      const drawn = { position: [mark.x, mark.y, mark.z], rotation: mark.rotation, scaleX: mark.scaleX, scaleZ: mark.scaleZ, age: 0 };
+      blood[index] = drawn;
+      writeBlood(index, drawn, BLOOD_START_GROWTH);
+      bloodMesh().count = Math.min(placed.blood, bloodMesh().instanceMatrix.count);
     }
     function build(mark) {
-      if (mark.kind === "scorch") return conform(mark, scorchMaterials[mark.variant]);
-      if (mark.kind === "dirt") return conform(mark, dirtMaterial);
-      if (mark.kind === "rock") return addRock(mark);
-      return addBlood(mark);
-    }
-    function clearMeshes() {
-      for (const child of [...group.children]) {
-        group.remove(child);
-        const geometry = child.geometry;
-        if (geometry !== options.rockGeometry && geometry !== options.plateGeometry && geometry !== bloodGeometry) geometry.dispose();
-      }
+      if (mark.kind === "scorch") conform(mark, scorchMaterials[mark.variant]);
+      else if (mark.kind === "dirt") conform(mark, dirtMaterial);
+      else if (mark.kind === "rock") addRock(mark);
+      else addBlood(mark);
+    }
+    function clearMarks() {
+      for (const drawn of groundMarks) group.remove(drawn.mesh);
+      for (const drawn of groundMarks) drawn.mesh.geometry.dispose();
+      groundMarks.length = 0;
+      for (const geometry of spareGeometries) geometry.dispose();
+      spareGeometries.length = 0;
       blood.length = 0;
-      meshCount = 0;
+      placed.blood = placed.rock = placed.plate = 0;
+      for (const mesh2 of [instanced.blood, instanced.rock, instanced.plate]) if (mesh2) mesh2.count = 0;
     }
     return {
       group,
       handle(event) {
-        if (event.type === "clear") {
-          clearMeshes();
-          return;
-        }
-        group.add(build(event.mark));
-        meshCount++;
+        if (event.type === "clear") clearMarks();
+        else build(event.mark);
+      },
+      prepare() {
+        bloodMesh();
+        rockMesh();
+        plateMesh();
       },
       update(dt) {
-        for (const drawn of blood) {
-          if (drawn.age > 1) continue;
+        for (let index = 0; index < blood.length; index++) {
+          const drawn = blood[index];
+          if (!drawn || drawn.age > 1) continue;
           drawn.age += dt * BLOOD_GROW_RATE;
-          const ease3 = 1 - Math.pow(1 - Math.min(1, drawn.age), 2.5);
-          drawn.mesh.scale.set(drawn.scaleX * Math.max(0.05, ease3), 1, drawn.scaleZ * Math.max(0.05, ease3));
+          writeBlood(index, drawn, Math.max(BLOOD_START_GROWTH, 1 - Math.pow(1 - Math.min(1, drawn.age), 2.5)));
         }
       },
-      count: () => meshCount,
+      count: () => groundMarks.length + [instanced.blood, instanced.rock, instanced.plate].filter((mesh2) => mesh2 && mesh2.count > 0).length,
       dispose() {
-        clearMeshes();
+        clearMarks();
+        for (const mesh2 of [instanced.blood, instanced.rock, instanced.plate]) mesh2?.dispose();
         for (const item of owned) item.dispose();
       }
     };
   }
   var SPHERE_DEFAULT_WIDTH = 8;
   var SPHERE_DEFAULT_HEIGHT = 6;
+  var MAX_PARKED_MESHES_PER_KIND = 256;
   function geometryOf(THREE, particle) {
     switch (particle.shape) {
       case "cone":
-        return new THREE.ConeGeometry(particle.radius, particle.height, particle.segments || void 0, particle.segments2 || 1, false);
+        return new THREE.ConeGeometry(1, 1, particle.segments || void 0, particle.segments2 || 1, false);
       case "cone_open":
-        return new THREE.ConeGeometry(particle.radius, particle.height, particle.segments || void 0, particle.segments2 || 1, true);
+        return new THREE.ConeGeometry(1, 1, particle.segments || void 0, particle.segments2 || 1, true);
       case "sphere":
-        return new THREE.SphereGeometry(particle.radius, particle.segments || SPHERE_DEFAULT_WIDTH, particle.segments2 || SPHERE_DEFAULT_HEIGHT);
+        return new THREE.SphereGeometry(1, particle.segments || SPHERE_DEFAULT_WIDTH, particle.segments2 || SPHERE_DEFAULT_HEIGHT);
       case "icosahedron":
-        return new THREE.IcosahedronGeometry(particle.radius, particle.segments);
+        return new THREE.IcosahedronGeometry(1, particle.segments);
     }
   }
+  function isCone(particle) {
+    return particle.shape === "cone" || particle.shape === "cone_open";
+  }
   function materialOf(THREE, particle) {
     if (particle.lit) return new THREE.MeshStandardMaterial({ color: particle.color, roughness: 1, metalness: 0, transparent: true, opacity: particle.opacity, depthWrite: false });
     return new THREE.MeshBasicMaterial({ color: particle.color, transparent: true, opacity: particle.opacity, depthWrite: false, ...particle.additive ? { blending: THREE.AdditiveBlending } : {} });
@@ -7864,51 +7927,82 @@ void main(){
       (kind) => new THREE.Mesh(geometry, materialOf(THREE, { ...kind, color: 8421504, opacity: 0.5 }))
     );
   }
+  function geometryKeyOf(particle) {
+    return `${particle.shape}:${particle.segments}:${particle.segments2}`;
+  }
   function createMeshLayer(THREE, pool) {
     const group = new THREE.Group();
     group.name = "workshop-meshes";
     const drawn = /* @__PURE__ */ new Map();
+    const geometries = /* @__PURE__ */ new Map();
+    const parked = /* @__PURE__ */ new Map();
     const frame = new THREE.Quaternion();
     const euler = new THREE.Euler();
     const turn = new THREE.Quaternion();
     const offset = new THREE.Vector3();
-    function release(mesh2) {
-      mesh2.removeFromParent();
-      mesh2.geometry.dispose();
-      mesh2.material.dispose();
+    let stamp = 0;
+    function geometryFor(particle) {
+      const key = geometryKeyOf(particle);
+      let geometry = geometries.get(key);
+      if (!geometry) {
+        geometry = geometryOf(THREE, particle);
+        geometries.set(key, geometry);
+      }
+      return geometry;
+    }
+    function acquire(particle) {
+      const parkingKey = `${geometryKeyOf(particle)}|${particle.lit}|${particle.additive}`;
+      const mesh2 = parked.get(parkingKey)?.pop() ?? new THREE.Mesh(geometryFor(particle), materialOf(THREE, particle));
+      mesh2.material.color.set(particle.color);
+      mesh2.frustumCulled = false;
+      mesh2.renderOrder = particle.additive ? 5 : 3;
+      group.add(mesh2);
+      return { mesh: mesh2, parkingKey, stamp };
+    }
+    function park(entry) {
+      entry.mesh.removeFromParent();
+      let free = parked.get(entry.parkingKey);
+      if (!free) {
+        free = [];
+        parked.set(entry.parkingKey, free);
+      }
+      if (free.length < MAX_PARKED_MESHES_PER_KIND) free.push(entry.mesh);
+      else entry.mesh.material.dispose();
     }
     return {
       group,
       sync() {
-        const live = /* @__PURE__ */ new Set();
+        stamp++;
         for (const particle of pool.particles) {
-          live.add(particle.id);
-          let mesh2 = drawn.get(particle.id);
-          if (!mesh2) {
-            mesh2 = new THREE.Mesh(geometryOf(THREE, particle), materialOf(THREE, particle));
-            mesh2.frustumCulled = false;
-            mesh2.renderOrder = particle.additive ? 5 : 3;
-            drawn.set(particle.id, mesh2);
-            group.add(mesh2);
+          let entry = drawn.get(particle.id);
+          if (!entry) {
+            entry = acquire(particle);
+            drawn.set(particle.id, entry);
           }
+          entry.stamp = stamp;
+          const mesh2 = entry.mesh;
           frame.set(particle.frame[0], particle.frame[1], particle.frame[2], particle.frame[3]);
           offset.set(particle.at[0], particle.at[1], particle.at[2]).multiplyScalar(particle.scale).applyQuaternion(frame);
           mesh2.position.set(particle.x + offset.x, particle.y + offset.y, particle.z + offset.z);
           turn.setFromEuler(euler.set(particle.rx, particle.ry, particle.rz));
           mesh2.quaternion.copy(frame).multiply(turn);
-          mesh2.scale.setScalar(particle.scale);
+          mesh2.scale.set(particle.radius * particle.scale, (isCone(particle) ? particle.height : particle.radius) * particle.scale, particle.radius * particle.scale);
           mesh2.material.opacity = particle.opacity;
         }
-        for (const [id, mesh2] of drawn) {
-          if (live.has(id)) continue;
-          release(mesh2);
+        for (const [id, entry] of drawn) {
+          if (entry.stamp === stamp) continue;
+          park(entry);
           drawn.delete(id);
         }
         return pool.count;
       },
       dispose() {
-        for (const mesh2 of drawn.values()) release(mesh2);
+        for (const entry of drawn.values()) park(entry);
         drawn.clear();
+        for (const free of parked.values()) for (const mesh2 of free) mesh2.material.dispose();
+        parked.clear();
+        for (const geometry of geometries.values()) geometry.dispose();
+        geometries.clear();
         group.removeFromParent();
       }
     };
@@ -8476,7 +8570,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     const shocks = createShockLayer(THREE, pools.shocks);
     const sprites = createSpriteLayer(THREE, world.sprites(), options.pointScale ?? 700);
     const lights = createLightLayer(THREE, pools.lights, options.lightScale ?? Math.PI);
-    const marks = createMarkLayer(THREE, { ground: pools.ground, createCanvas: options.createCanvas, rockGeometry, plateGeometry });
+    const marks = createMarkLayer(THREE, { ground: pools.ground, createCanvas: options.createCanvas, rockGeometry, plateGeometry, ...options.markLimits });
     root.add(puffs.mesh, sparks.mesh, glows.mesh, chunks.rocks, chunks.plates, shocks.group, lights.group, sprites.additive, sprites.normal, marks.group);
     const stopMarks = world.onMarks((event) => marks.handle(event));
     const overlay = options.overlay ? createScreenOverlay(options.overlay) : void 0;
@@ -8502,6 +8596,16 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       const position = options.camera.position;
       world.setCamera([position.x, position.y, position.z]);
     }
+    function attachWorkshopLayers() {
+      const engine = world.peekWorkshop();
+      if (!engine || engine === workshopEngine) return;
+      workshopLayers?.dispose();
+      if (workshopLayers) root.remove(workshopLayers.group);
+      workshopEngine = engine;
+      workshopLayers = createWorkshopLayers(THREE, engine, options.pointScale ?? 700, 1);
+      root.add(workshopLayers.group);
+      applyLayers();
+    }
     function syncAll() {
       lastDrawn.puffs = puffs.sync();
       lastDrawn.sparks = sparks.sync();
@@ -8510,15 +8614,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       lastDrawn.shocks = shocks.sync();
       lastDrawn.sprites = sprites.sync();
       lights.sync();
-      const engine = world.peekWorkshop();
-      if (engine && engine !== workshopEngine) {
-        workshopLayers?.dispose();
-        if (workshopLayers) root.remove(workshopLayers.group);
-        workshopEngine = engine;
-        workshopLayers = createWorkshopLayers(THREE, engine, options.pointScale ?? 700, 1);
-        root.add(workshopLayers.group);
-        applyLayers();
-      }
+      attachWorkshopLayers();
       const workshopCalls = workshopLayers?.sync() ?? 0;
       const glow = pools.lights.glow;
       uniforms.uGlowPos.value.set(glow.x, glow.y, glow.z);
@@ -8571,6 +8667,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       },
       warmUpProbes() {
         releaseAnchors();
+        marks.prepare();
+        world.workshop();
+        attachWorkshopLayers();
         const meshes = createMeshLayerProbes(THREE);
         for (const mesh2 of meshes) mesh2.frustumCulled = false;
         const group = new THREE.Group();
@@ -8691,6 +8790,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   var SHEET_SWAY = 3;
   var BIG_LENGTH = 0.2;
   var BIG_WIDTH = 0.03;
+  var FRAGMENT_SEED = 1374496523;
   var isBig = (size) => {
     const [, middle, longest] = [...size].sort((a, b) => a - b);
     return longest >= BIG_LENGTH && middle >= BIG_WIDTH;
@@ -8710,7 +8810,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       __publicField(this, "m");
       __publicField(this, "v");
       __publicField(this, "w");
-      __publicField(this, "rng", createRng(1374496523));
+      __publicField(this, "rng", createRng(FRAGMENT_SEED));
       /** Count of `update` calls: what makes the fragments of one burst tell apart from older ones. */
       __publicField(this, "tick", 0);
       __publicField(this, "markGeometry", null);
@@ -8811,6 +8911,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       mesh2.scale.copy(sc);
       mesh2.castShadow = true;
       mesh2.userData.destructionDebris = true;
+      mesh2.name = "fragment";
+      markKitOrigin(mesh2, { owner: "game-destruction-three", kind: "fragment", id: f.material });
       this.o.scene.add(mesh2);
       const live = {
         mesh: mesh2,
@@ -8827,7 +8929,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         dying: false,
         air: f.shape === "scrap" && sz[2] <= SHEET_MAX ? SHEET_AIR : 0,
         body: null,
-        born: this.tick
+        born: this.tick,
+        life: Math.max(0, typeof this.o.life === "function" ? this.o.life(f, home) : this.o.life)
       };
       if (f.shape !== "shard" && isBig(f.size)) {
         live.body = {
@@ -8836,8 +8939,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
             live.vel.x = x;
             live.vel.z = z;
             live.vel.y = Math.max(live.vel.y, 0.3);
-            live.asleep = false;
-            live.rest = 0;
+            this.rouse(live);
           }
         };
       }
@@ -8872,16 +8974,20 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         d.y += k * 0.4;
         f.vel.add(d);
         f.ang.add(this.w.set(this.rng() - 0.5, this.rng() - 0.5, this.rng() - 0.5).multiplyScalar(k));
-        f.asleep = false;
-        f.rest = 0;
+        this.rouse(f);
       }
     }
+    /** A fragment that came to rest stops having its matrix recomputed on every frame; whatever moves it again calls this first. */
+    rouse(f) {
+      f.asleep = false;
+      f.rest = 0;
+      f.mesh.matrixAutoUpdate = true;
+    }
     /** What lies inside the disc looks at the ground again: it was dug or heaped under it. */
     wakeRegion(x, z, radius) {
       for (const f of this.list) {
         if (!f.asleep || Math.hypot(f.mesh.position.x - x, f.mesh.position.z - z) > radius) continue;
-        f.asleep = false;
-        f.rest = 0;
+        this.rouse(f);
       }
     }
     update(dt) {
@@ -8890,6 +8996,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       for (let i = this.list.length - 1; i >= 0; i--) {
         const f = this.list[i];
         if (f.dying) {
+          f.mesh.matrixAutoUpdate = true;
           f.fade -= dt / 0.6;
           if (f.fade <= 0) {
             this.o.scene.remove(f.mesh);
@@ -8900,7 +9007,10 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         }
         if (f.asleep) {
           f.rest += dt;
-          if (this.o.life > 0 && f.rest > this.o.life && !f.body) f.dying = true;
+          if (f.life > 0 && f.rest > f.life && !f.body) {
+            f.dying = true;
+            f.mesh.matrixAutoUpdate = true;
+          }
           continue;
         }
         this.step(f, dt, g);
@@ -8949,6 +9059,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         f.still += dt;
         if (f.still > 0.4) {
           f.asleep = true;
+          f.mesh.updateMatrix();
+          f.mesh.matrixAutoUpdate = false;
           f.vel.set(0, 0, 0);
           f.ang.set(0, 0, 0);
         }
@@ -8998,6 +9110,12 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       for (const f of this.list) this.o.scene.remove(f.mesh);
       this.list.length = 0;
     }
+    /** `clear`, the random stream back to its seed and the tick to 0: what comes next flies as on a new system. */
+    reset() {
+      this.clear();
+      this.rng = createRng(FRAGMENT_SEED);
+      this.tick = 0;
+    }
     dispose() {
       this.clear();
       this.box.dispose();
@@ -9096,6 +9214,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   var SUB_DT = 1 / 120;
   var MU = 0.7;
   var SLEEP_AFTER = 0.5;
+  var CALM_DRIFT = 0.01;
+  var CALM_TURN = 0.05;
+  var CALM_SLEEP_AFTER = 1.5;
   var HARD_LANDING = 3;
   var SLOP = 2e-3;
   var NARROW = 0.3;
@@ -9104,6 +9225,10 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   var TIP_LYING = 0.25;
   var TIP_SECONDS = 3;
   var STEP = 0.03;
+  var WARM_SLOTS = 8 + 12 * 7;
+  var SOLVER_PASSES = 10;
+  var SIDE_BOUNCE = 0.1;
+  var EDGE_POINTS = [-0.75, -0.5, -0.25, 0, 0.25, 0.5, 0.75];
   var boxTopAt = (s, x, z) => {
     const e = s.e;
     const dx = x - s.c[0], dz = z - s.c[2];
@@ -9174,6 +9299,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         localCenter: [localCenter.x, localCenter.y, localCenter.z],
         centerV: localCenter.clone(),
         still: 0,
+        calmAt: null,
+        calm: 0,
         lastHit: -1,
         onGround: false
       };
@@ -9192,6 +9319,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     clear() {
       this.list.length = 0;
     }
+    /** `clear` and the clock back to 0. */
+    reset() {
+      this.clear();
+      this.time = 0;
+    }
     /** World position of the centre of mass. */
     centerOf(b, out) {
       return out.copy(b.centerV).applyQuaternion(b.root.quaternion).add(b.root.position);
@@ -9216,6 +9348,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       }
       b.sleeping = false;
       b.still = 0;
+      b.calmAt = null;
     }
     /** I^-1 * (x, y, z) in world space for a box with the body's half extents and mass (needs `this.m` to hold the body's rotation). */
     mulInvInertia(b, x, y, z) {
@@ -9233,12 +9366,51 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       const lz = (e[8] * x + e[9] * y + e[10] * z) * iz;
       return [e[0] * lx + e[4] * ly + e[8] * lz, e[1] * lx + e[5] * ly + e[9] * lz, e[2] * lx + e[6] * ly + e[10] * lz];
     }
+    /** The points of the box that touch the ground, in its own frame: the 8 corners, then (with `edges`) `EDGE_POINTS` along each of its 12 edges. */
+    samples(b, edges) {
+      const [hx, hy, hz] = b.halfExtents;
+      const out = [];
+      for (let i = 0; i < 8; i++) out.push([i & 1 ? hx : -hx, i & 2 ? hy : -hy, i & 4 ? hz : -hz]);
+      if (!edges) return out;
+      const h = [hx, hy, hz];
+      for (let axis2 = 0; axis2 < 3; axis2++) {
+        const a1 = (axis2 + 1) % 3;
+        const a2 = (axis2 + 2) % 3;
+        for (let k = 0; k < 4; k++) {
+          for (const f of EDGE_POINTS) {
+            const p = [0, 0, 0];
+            p[axis2] = f * h[axis2];
+            p[a1] = k & 1 ? h[a1] : -h[a1];
+            p[a2] = k & 2 ? h[a2] : -h[a2];
+            out.push(p);
+          }
+        }
+      }
+      return out;
+    }
+    /**
+     * An impulse along the unit normal `n` at `r` (from the centre of mass, world) that stops the point closing in along `n` (with `bounce`); `e` holds the body's rotation.
+     */
+    contactImpulse(b, e, r, n, bounce2) {
+      const v = b.velocity;
+      const w = b.angularVelocity;
+      const vn = (v[0] + w[1] * r[2] - w[2] * r[1]) * n[0] + (v[1] + w[2] * r[0] - w[0] * r[2]) * n[1] + (v[2] + w[0] * r[1] - w[1] * r[0]) * n[2];
+      if (vn >= 0) return;
+      const a = this.mulInvInertiaWith(b, e, r[1] * n[2] - r[2] * n[1], r[2] * n[0] - r[0] * n[2], r[0] * n[1] - r[1] * n[0]);
+      const k = (a[1] * r[2] - a[2] * r[1]) * n[0] + (a[2] * r[0] - a[0] * r[2]) * n[1] + (a[0] * r[1] - a[1] * r[0]) * n[2];
+      const j = -(1 + bounce2) * vn / (1 / b.mass + k);
+      for (let i = 0; i < 3; i++) {
+        v[i] += j * n[i] / b.mass;
+        w[i] += a[i] * j;
+      }
+    }
     /** What lies inside the disc looks at the ground again: it was dug or heaped under it. */
     wakeRegion(x, z, radius) {
       for (const b of this.list) {
         if (!b.sleeping || b.held || Math.hypot(b.root.position.x - x, b.root.position.z - z) > radius) continue;
         b.sleeping = false;
         b.still = 0;
+        b.calmAt = null;
       }
     }
     update(dt) {
@@ -9254,6 +9426,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           b.angularVelocity = [0, 0, 0];
           b.sleeping = false;
           b.still = 0;
+          b.calmAt = null;
           continue;
         }
         if (b.sleeping) continue;
@@ -9278,7 +9451,6 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       const q = this.q.copy(b.root.quaternion);
       const v = b.velocity;
       const w = b.angularVelocity;
-      const [hx, hy, hz] = b.halfExtents;
       const invM = 1 / b.mass;
       const steps = clamp6(Math.ceil(dt / SUB_DT), 1, 8);
       const h = dt / steps;
@@ -9287,7 +9459,30 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       let contactedLast = false;
       let touched = false;
       let unstable = false;
+      const corners = this.samples(b, false);
+      this.m.makeRotationFromQuaternion(q);
+      let gLow = Infinity;
+      let gHigh = -Infinity;
+      for (const [sx, sy, sz] of corners) {
+        const e0 = this.m.elements;
+        const y = pos[1] + e0[1] * sx + e0[5] * sy + e0[9] * sz;
+        const x = pos[0] + e0[0] * sx + e0[4] * sy + e0[8] * sz;
+        const z = pos[2] + e0[2] * sx + e0[6] * sy + e0[10] * sz;
+        const g = Math.max(this.o.groundAt(x, z), this.o.staticTopAt?.(x, z, y, STEP) ?? -Infinity);
+        gLow = Math.min(gLow, g);
+        gHigh = Math.max(gHigh, g);
+      }
+      const local2 = gHigh - gLow > STEP ? this.samples(b, true) : corners;
+      const prev = local2.map(() => [0, 0, 0]);
       for (let s = 0; s < steps; s++) {
+        this.m.makeRotationFromQuaternion(q);
+        const e0 = this.m.elements;
+        for (let i = 0; i < local2.length; i++) {
+          const [sx, sy, sz] = local2[i];
+          prev[i][0] = pos[0] + e0[0] * sx + e0[4] * sy + e0[8] * sz;
+          prev[i][1] = pos[1] + e0[1] * sx + e0[5] * sy + e0[9] * sz;
+          prev[i][2] = pos[2] + e0[2] * sx + e0[6] * sy + e0[10] * sz;
+        }
         v[1] -= this.o.gravity * h;
         pos[0] += v[0] * h;
         pos[1] += v[1] * h;
@@ -9304,20 +9499,60 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         this.m.makeRotationFromQuaternion(q);
         const e = this.m.elements;
         const rs = [];
+        const ids = [];
         let maxPen = 0;
-        for (let i = 0; i < 8; i++) {
-          const sx = i & 1 ? hx : -hx;
-          const sy = i & 2 ? hy : -hy;
-          const sz = i & 4 ? hz : -hz;
+        const rise = STEP + Math.max(0, -v[1]) * h * 2;
+        let side = null;
+        let lowest = Infinity;
+        for (let i = 0; i < local2.length; i++) {
+          const [sx, sy, sz] = local2[i];
           const r = [e[0] * sx + e[4] * sy + e[8] * sz, e[1] * sx + e[5] * sy + e[9] * sz, e[2] * sx + e[6] * sy + e[10] * sz];
+          const px = pos[0] + r[0];
+          const pz = pos[2] + r[2];
           const cy = pos[1] + r[1];
-          const gy = this.supportAt(b, pos[0] + r[0], cy, pos[2] + r[2], STEP + Math.max(0, -v[1]) * h * 2);
+          const was = prev[i];
+          const raw = this.o.groundAt(px, pz);
+          if (raw > cy - SLOP && was[1] < raw - STEP) {
+            if (this.o.groundAt(was[0], was[2]) >= raw - STEP) {
+              const floor2 = b.floor;
+              if (floor2 !== void 0 && floor2 - cy > -SLOP && floor2 < raw - STEP) {
+                rs.push(r);
+                ids.push(i);
+                maxPen = Math.max(maxPen, floor2 - cy);
+              }
+              continue;
+            }
+            const dx = px - was[0];
+            const dz = pz - was[2];
+            const len = Math.hypot(dx, dz);
+            if (len > 1e-6) {
+              let lo = 0;
+              let hi = 1;
+              for (let it = 0; it < 6; it++) {
+                const mid = (lo + hi) / 2;
+                if (this.o.groundAt(was[0] + dx * mid, was[2] + dz * mid) >= raw - STEP) hi = mid;
+                else lo = mid;
+              }
+              const back = (1 - lo) * len + 1e-3;
+              if (!side || back > side.back) side = { back, dir: [dx / len, dz / len], r };
+            }
+            continue;
+          }
+          const gy = i < 8 ? this.supportAt(b, px, cy, pz, rise) : Math.max(raw, this.o.staticTopAt?.(px, pz, cy, rise) ?? -Infinity);
           const pen = gy - cy;
           if (pen > -SLOP) {
             rs.push(r);
+            ids.push(i);
             if (pen > maxPen) maxPen = pen;
+            lowest = Math.min(lowest, gy);
           }
         }
+        if (lowest < Infinity) b.floor = lowest;
+        if (side) {
+          pos[0] -= side.dir[0] * side.back;
+          pos[2] -= side.dir[1] * side.back;
+          this.contactImpulse(b, e, side.r, [-side.dir[0], 0, -side.dir[1]], SIDE_BOUNCE);
+        }
         contactedLast = rs.length > 0;
         if (contactedLast) touched = true;
         if (!contactedLast) continue;
@@ -9337,45 +9572,88 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           const lz = pos[2] + sz / rs.length;
           landPoint = [lx, pos[1] - Math.max(...rs.map((r) => -r[1])), lz];
         }
-        for (let it = 0; it < 4; it++) {
-          for (const r of rs) {
-            let vx2 = v[0] + (w[1] * r[2] - w[2] * r[1]);
-            let vy2 = v[1] + (w[2] * r[0] - w[0] * r[2]);
-            let vz2 = v[2] + (w[0] * r[1] - w[1] * r[0]);
-            const vn = vy2;
-            if (vn >= 0) continue;
+        const goal = rs.map((r) => {
+          const vy2 = v[1] + (w[2] * r[0] - w[0] * r[2]);
+          return vy2 < 0 ? -restitution * vy2 : 0;
+        });
+        const vx0 = v[0];
+        const vz0 = v[2];
+        if (!b.warm || b.warm.length !== WARM_SLOTS * 3) b.warm = new Float64Array(WARM_SLOTS * 3);
+        const warm = b.warm;
+        const accN = ids.map((id) => id < WARM_SLOTS ? warm[id * 3] : 0);
+        const accT = ids.map((id) => id < WARM_SLOTS ? [warm[id * 3 + 1], warm[id * 3 + 2]] : [0, 0]);
+        for (let k = 0; k < rs.length; k++) {
+          const r = rs[k];
+          const jn = accN[k];
+          const [fx, fz] = accT[k];
+          if (jn === 0 && fx === 0 && fz === 0) continue;
+          v[0] += fx * invM;
+          v[1] += jn * invM;
+          v[2] += fz * invM;
+          const dw = this.mulInvInertiaWith(b, e, r[1] * fz - r[2] * jn, r[2] * fx - r[0] * fz, r[0] * jn - r[1] * fx);
+          w[0] += dw[0];
+          w[1] += dw[1];
+          w[2] += dw[2];
+        }
+        for (let it = 0; it < SOLVER_PASSES; it++) {
+          for (let k = 0; k < rs.length; k++) {
+            const r = rs[k];
+            const vy2 = v[1] + (w[2] * r[0] - w[0] * r[2]);
             const a = this.mulInvInertiaWith(b, e, -r[2], 0, r[0]);
             const denom = invM + (a[2] * r[0] - a[0] * r[2]);
-            const j = -(1 + (it === 0 ? restitution : 0)) * vn / denom;
-            v[1] += j * invM;
-            const dw = this.mulInvInertiaWith(b, e, -r[2] * j, 0, r[0] * j);
-            w[0] += dw[0];
-            w[1] += dw[1];
-            w[2] += dw[2];
-            vx2 = v[0] + (w[1] * r[2] - w[2] * r[1]);
-            vy2 = v[1] + (w[2] * r[0] - w[0] * r[2]);
-            vz2 = v[2] + (w[0] * r[1] - w[1] * r[0]);
+            const total = Math.max(0, accN[k] + (goal[k] - vy2) / denom);
+            const j = total - accN[k];
+            accN[k] = total;
+            if (j !== 0) {
+              v[1] += j * invM;
+              w[0] += a[0] * j;
+              w[1] += a[1] * j;
+              w[2] += a[2] * j;
+            }
+            const vx2 = v[0] + (w[1] * r[2] - w[2] * r[1]);
+            const vz2 = v[2] + (w[0] * r[1] - w[1] * r[0]);
             const vt = Math.hypot(vx2, vz2);
-            if (vt > 1e-5) {
+            if (vt < 1e-6 && accT[k][0] === 0 && accT[k][1] === 0) continue;
+            let fx = accT[k][0];
+            let fz = accT[k][1];
+            if (vt > 1e-6) {
               const tx = vx2 / vt;
               const tz = vz2 / vt;
-              const rx = r[1] * tz;
-              const ry = r[2] * tx - r[0] * tz;
-              const rz = -r[1] * tx;
-              const at3 = this.mulInvInertiaWith(b, e, rx, ry, rz);
+              const at3 = this.mulInvInertiaWith(b, e, r[1] * tz, r[2] * tx - r[0] * tz, -r[1] * tx);
               const cx = at3[1] * r[2] - at3[2] * r[1];
               const cz = at3[0] * r[1] - at3[1] * r[0];
-              const denomT = invM + cx * tx + cz * tz;
-              const jt = Math.min(vt / denomT, MU * j);
-              v[0] -= tx * jt * invM;
-              v[2] -= tz * jt * invM;
-              const dwt = this.mulInvInertiaWith(b, e, rx * jt, ry * jt, rz * jt);
-              w[0] -= dwt[0];
-              w[1] -= dwt[1];
-              w[2] -= dwt[2];
+              const jt = vt / (invM + cx * tx + cz * tz);
+              fx -= tx * jt;
+              fz -= tz * jt;
             }
+            const most = MU * accN[k];
+            const f = Math.hypot(fx, fz);
+            if (f > most) {
+              fx *= most / f;
+              fz *= most / f;
+            }
+            const dx = fx - accT[k][0];
+            const dz = fz - accT[k][1];
+            accT[k] = [fx, fz];
+            if (dx === 0 && dz === 0) continue;
+            v[0] += dx * invM;
+            v[2] += dz * invM;
+            const dw = this.mulInvInertiaWith(b, e, r[1] * dz, r[2] * dx - r[0] * dz, -r[1] * dx);
+            w[0] += dw[0];
+            w[1] += dw[1];
+            w[2] += dw[2];
           }
         }
+        pos[0] += (v[0] - vx0) * h;
+        pos[2] += (v[2] - vz0) * h;
+        warm.fill(0);
+        for (let k = 0; k < rs.length; k++) {
+          const id = ids[k];
+          if (id >= WARM_SLOTS) continue;
+          warm[id * 3] = accN[k];
+          warm[id * 3 + 1] = accT[k][0];
+          warm[id * 3 + 2] = accT[k][1];
+        }
         let x0 = Infinity, x1 = -Infinity, z0 = Infinity, z1 = -Infinity, low = 0;
         for (const r of rs) {
           x0 = Math.min(x0, r[0]);
@@ -9390,7 +9668,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         unstable = Math.min(wx, wz) < NARROW * height || x0 > 0 || x1 < 0 || z0 > 0 || z1 < 0;
         if (b.tipping) {
           b.tipping.seconds -= h;
-          if (height < TIP_LYING || b.tipping.seconds <= 0) b.tipping = null;
+          const [hx, hy, hz] = b.halfExtents;
+          const upHalf = Math.abs(e[1]) * hx + Math.abs(e[5]) * hy + Math.abs(e[9]) * hz;
+          if (upHalf < TIP_LYING || b.tipping.seconds <= 0) b.tipping = null;
           else {
             w[0] += b.tipping.x * TIP_ACCELERATION * h;
             w[2] += b.tipping.z * TIP_ACCELERATION * h;
@@ -9422,16 +9702,26 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         this.o.onHardLanding(b, landPoint, landing);
       }
       const still = touched && !unstable && Math.hypot(v[0], v[1], v[2]) < 0.12 && Math.hypot(w[0], w[1], w[2]) < 0.45;
-      if (still) {
-        b.still += dt;
-        if (b.still >= SLEEP_AFTER) {
-          b.sleeping = true;
-          v[0] = v[1] = v[2] = 0;
-          w[0] = w[1] = w[2] = 0;
-        }
-      } else {
-        b.still = 0;
-      }
+      if (still) b.still += dt;
+      else b.still = 0;
+      if (b.still >= SLEEP_AFTER || this.staysInPlace(b, touched && !b.tipping, pos, q, dt)) {
+        b.sleeping = true;
+        b.calmAt = null;
+        v[0] = v[1] = v[2] = 0;
+        w[0] = w[1] = w[2] = 0;
+      }
+    }
+    /** Whether the piece has kept to the same spot on the ground for `CALM_SLEEP_AFTER` (see `CALM_DRIFT`). */
+    staysInPlace(b, touched, center, q, dt) {
+      const at3 = b.calmAt;
+      const turned = at3 ? 2 * Math.acos(Math.min(1, Math.abs(at3.quaternion[0] * q.x + at3.quaternion[1] * q.y + at3.quaternion[2] * q.z + at3.quaternion[3] * q.w))) : Infinity;
+      if (!touched || !at3 || Math.hypot(center[0] - at3.center[0], center[1] - at3.center[1], center[2] - at3.center[2]) > CALM_DRIFT || turned > CALM_TURN) {
+        b.calmAt = touched ? { center: [center[0], center[1], center[2]], quaternion: [q.x, q.y, q.z, q.w] } : null;
+        b.calm = 0;
+        return false;
+      }
+      b.calm += dt;
+      return b.calm >= CALM_SLEEP_AFTER;
     }
     /** Half the height of the box of a piece as it is turned now. */
     halfHeight(b) {
@@ -9449,8 +9739,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         const a = this.list[i];
         for (let j = i + 1; j < n; j++) {
           const b = this.list[j];
-          if (a.held && b.held) continue;
-          if (a.sleeping && b.sleeping) continue;
+          const fixedA = a.held || a.sleeping;
+          const fixedB = b.held || b.sleeping;
+          if (fixedA && fixedB) continue;
           const ra = Math.hypot(a.halfExtents[0], a.halfExtents[1], a.halfExtents[2]);
           const rb = Math.hypot(b.halfExtents[0], b.halfExtents[1], b.halfExtents[2]);
           this.centerOf(a, ca);
@@ -9468,19 +9759,17 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
             d = 1;
           }
           const push = Math.min(maxMove, (rh - d) * 0.5);
-          const wa = a.held ? 0 : b.held ? 1 : b.mass / (a.mass + b.mass);
-          const wb = b.held ? 0 : a.held ? 1 : a.mass / (a.mass + b.mass);
+          const wa = fixedA ? 0 : fixedB ? 1 : b.mass / (a.mass + b.mass);
+          const wb = fixedB ? 0 : fixedA ? 1 : a.mass / (a.mass + b.mass);
           const ux = dx / (d || 1);
           const uz = dz / (d || 1);
-          if (!a.held) {
+          if (!fixedA) {
             a.root.position.x -= ux * push * 2 * wa;
             a.root.position.z -= uz * push * 2 * wa;
-            a.sleeping = false;
           }
-          if (!b.held) {
+          if (!fixedB) {
             b.root.position.x += ux * push * 2 * wb;
             b.root.position.z += uz * push * 2 * wb;
-            b.sleeping = false;
           }
         }
       }
@@ -10889,6 +11178,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     }
     return out;
   };
+  var RESTING_HOLD_COS = Math.cos(Math.PI / 6);
 
   // src/spec.ts
   function containsOf(value) {
@@ -10947,6 +11237,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           const fill = options.fillOf?.(o, material);
           const tags = Array.isArray(ud.destructionTags) ? ud.destructionTags : void 0;
           const contains = containsOf(ud.destructionContains);
+          const powder = typeof ud.destructionPowder?.color === "number" ? { color: ud.destructionPowder.color } : void 0;
           const thickness = typeof ud.destructionThickness === "number" && ud.destructionThickness > 0 ? ud.destructionThickness : void 0;
           const existing = explicit ? byKey.get(explicit) : void 0;
           if (existing) {
@@ -10960,9 +11251,10 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
             existing.skin = existing.skin && skin;
             if (fill !== void 0) existing.fill = fill;
             if (contains) existing.contains = contains;
+            if (powder) existing.powder = powder;
             if (thickness !== void 0) existing.thickness = Math.min(existing.thickness ?? thickness, thickness);
           } else {
-            const e = { key: explicit ?? `m${entries.length}`, meshes: [o], box, material, explicitId: explicit, fill, hollow, skin, tags, fixedId: !!explicit, ...contains ? { contains } : {}, ...thickness !== void 0 ? { thickness } : {}, name: o.name, parent: hint?.parent, jointKind: hint?.kind };
+            const e = { key: explicit ?? `m${entries.length}`, meshes: [o], box, material, explicitId: explicit, fill, hollow, skin, tags, fixedId: !!explicit, ...contains ? { contains } : {}, ...powder ? { powder } : {}, ...thickness !== void 0 ? { thickness } : {}, name: o.name, parent: hint?.parent, jointKind: hint?.kind };
             entries.push(e);
             if (explicit) byKey.set(explicit, e);
           }
@@ -11037,6 +11329,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       }
       if (e.tags) part.tags = [...e.tags];
       if (e.contains) part.contains = { ...e.contains };
+      if (e.powder) part.powder = { ...e.powder };
       const ao = options.anchorBelow ?? -1;
       if (ao >= 0 && e.box.min.y <= ao) part.anchored = true;
       parts.push(part);
@@ -11214,6 +11507,22 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   var SKIN_SLACK = 5e-4;
   var SKIN_LAYER_SLACK = 4;
   var NEAREST_MARGIN = 1.5;
+  var basePositions = (host) => {
+    const p0 = host.mesh.userData._p0;
+    if (p0) return p0;
+    const op = positionAttr(host.origGeometry);
+    return op ? op.array : null;
+  };
+  var collapseForeign = (mesh2, arr) => {
+    for (const [v0, v1] of mesh2.userData.collapsedRanges ?? []) {
+      for (let k = v0 + 1; k < v1; k++) {
+        arr[k * 3] = arr[v0 * 3];
+        arr[k * 3 + 1] = arr[v0 * 3 + 1];
+        arr[k * 3 + 2] = arr[v0 * 3 + 2];
+      }
+    }
+  };
+  var DECAL_SNAP = 0.03;
   var Visuals = class {
     constructor(THREE, lowQuality, decalCap) {
       __publicField(this, "THREE", THREE);
@@ -11223,6 +11532,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       __publicField(this, "a");
       __publicField(this, "b");
       __publicField(this, "m4");
+      __publicField(this, "ray");
       __publicField(this, "box");
       __publicField(this, "t");
       __publicField(this, "lbox");
@@ -11233,6 +11543,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       this.a = tmpV(THREE);
       this.b = tmpV(THREE);
       this.m4 = new THREE.Matrix4();
+      this.ray = new THREE.Raycaster();
       this.box = new THREE.Box3();
       this.t = tmpV(THREE);
       this.lbox = new THREE.Box3();
@@ -11386,7 +11697,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       host.ownGeo = true;
       const g = host.mesh.geometry.clone();
       host.mesh.geometry = g;
-      host.work = new Float32Array(positionAttr(g).array);
+      host.work = new Float32Array(basePositions(host) ?? positionAttr(g).array);
       return true;
     }
     // ------------------------------------------------------------------------------------------------------------------------------------
@@ -11556,12 +11867,38 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     // ------------------------------------------------------------------------------------------------------------------------------------
     // Decals
     // ------------------------------------------------------------------------------------------------------------------------------------
+    /**
+     * The point on the drawn face of `mesh` under a world point, within `DECAL_SNAP` metres along the normal: the world's box of a part and the face
+     * the renderer drew (a coat of plaster, a merged house mesh) can be a few millimetres apart, and a mark behind the drawn face does not show.
+     */
+    onFace(mesh2, worldPoint, worldNormal) {
+      if (!mesh2.isMesh || !mesh2.geometry?.attributes?.position) return worldPoint;
+      const n = worldNormal.clone().normalize();
+      this.ray.set(worldPoint.clone().addScaledVector(n, DECAL_SNAP), n.clone().negate());
+      this.ray.near = 0;
+      this.ray.far = 2 * DECAL_SNAP;
+      const hits = [];
+      mesh2.raycast(this.ray, hits);
+      for (const c of mesh2.parent?.children ?? []) {
+        if (c === mesh2 || c.name !== "breach-shell") continue;
+        c.raycast(this.ray, hits);
+        const behind = c.userData.behind?.();
+        if (behind) behind.raycast(this.ray, hits);
+      }
+      let best = null;
+      for (const h of hits) {
+        if (h.object.userData.cutAt?.(h.point)) continue;
+        if (h.face && h.face.normal.clone().transformDirection(h.object.matrixWorld).dot(n) <= 0.3) continue;
+        if (!best || Math.abs(h.distance - DECAL_SNAP) < Math.abs(best.distance - DECAL_SNAP)) best = h;
+      }
+      return best ? best.point : worldPoint;
+    }
     /** Decal pose in mesh space: position and a rotation taking +Z to the surface normal. */
     decalPose(mesh2, worldPoint, worldNormal, lift) {
       mesh2.updateWorldMatrix(true, false);
       const s = mesh2.matrixWorld.getMaxScaleOnAxis() || 1;
       const ln = worldNormal.clone().transformDirection(this.m4.copy(mesh2.matrixWorld).invert()).normalize();
-      const pos = mesh2.worldToLocal(worldPoint.clone()).addScaledVector(ln, lift / s);
+      const pos = mesh2.worldToLocal(this.onFace(mesh2, worldPoint, worldNormal).clone()).addScaledVector(ln, lift / s);
       const quat2 = new this.THREE.Quaternion().setFromUnitVectors(new this.THREE.Vector3(0, 0, 1), ln);
       return { s, pos, quat: quat2 };
     }
@@ -11800,6 +12137,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       if (!pos || !work) return;
       const arr = pos.array;
       arr.set(work);
+      collapseForeign(host.mesh, arr);
       for (const s of host.sharers) {
         if (s.merged && s.merged.host === host) {
           if (s.collapsed) this.collapseRange(arr, s.merged.range);
@@ -12004,9 +12342,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       mv.touched = false;
       if (!host.ownGeo) return;
       const work = host.work;
-      const op = positionAttr(host.origGeometry);
+      const op = basePositions(host);
       const [v0, v1] = merged.range;
-      if (op) work.set(op.array.subarray(v0 * 3, v1 * 3), v0 * 3);
+      if (op) work.set(op.subarray(v0 * 3, v1 * 3), v0 * 3);
       const attr = host.mesh.geometry.getAttribute("color");
       if (attr) {
         const orig = host.origGeometry.getAttribute("color");
@@ -12020,6 +12358,13 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       if (host.sharers.every((s) => !s.touched)) {
         host.mesh.geometry.dispose();
         host.mesh.geometry = host.origGeometry;
+        const base = basePositions(host), back = positionAttr(host.origGeometry);
+        if (base && back) {
+          const arr = back.array;
+          arr.set(base);
+          collapseForeign(host.mesh, arr);
+          back.needsUpdate = true;
+        }
         host.work = null;
         host.ownGeo = false;
         if (host.ownMat) {
@@ -12079,9 +12424,12 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   var rendererCount = 0;
   var COLLAPSE_CLOUD_KG = 1e3;
   var CHIP_DECAL_EDGE = 0.05;
+  var OPAQUE_CRACK = 0.1;
+  var WOOD_RIM = 1.5;
   var IMPACT_TAGS = ["metal", "glass", "wood"];
   var GLOW_FROM_C = 430;
   var QUEUE_CAP = 4e3;
+  var MIN_FRAGMENTS_PER_SLICE = 8;
   var STATIC_REFRESH = 0.5;
   var STATIC_SPAN = 3;
   var FEET_BAND = 0.03;
@@ -12157,6 +12505,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     const r = v;
     return !!r.mesh && Array.isArray(r.range);
   }
+  var RNG_SEED = 12648430;
   function createDestructionRenderer(THREE, options) {
     return new Renderer(THREE, options);
   }
@@ -12172,6 +12521,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       __publicField(this, "gravity");
       __publicField(this, "autoSplit");
       __publicField(this, "maxFragments");
+      __publicField(this, "eventBudgetMs");
       __publicField(this, "bounds", /* @__PURE__ */ new Map());
       /** World boxes (min xyz, max xyz) of the drawn meshes of the bound objects that are not pieces, for the pieces to land on. */
       __publicField(this, "staticBoxes", /* @__PURE__ */ new Map());
@@ -12182,6 +12532,10 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       __publicField(this, "pieceBoxes", /* @__PURE__ */ new WeakMap());
       __publicField(this, "staticAt", 0);
       __publicField(this, "queue", []);
+      /** Presentation work an event left for later frames (fragments still to spawn, loose groups still to split), run in order within the frame budget. */
+      __publicField(this, "slices", []);
+      /** When the work of this frame must stop; `Infinity` outside `drainQueue`, where a call finishes what it started. */
+      __publicField(this, "sliceDeadline", Infinity);
       __publicField(this, "unsubscribe");
       __publicField(this, "visuals");
       __publicField(this, "fragments");
@@ -12195,7 +12549,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       __publicField(this, "leaks", []);
       __publicField(this, "homeTags", []);
       __publicField(this, "throttles", /* @__PURE__ */ new Map());
-      __publicField(this, "rng", createRng(12648430));
+      __publicField(this, "rng", createRng(RNG_SEED));
       __publicField(this, "vfx");
       /** Names this renderer to the world's drips, so a shared world tells each renderer where its own landed. */
       __publicField(this, "owner", `destruction-${++rendererCount}`);
@@ -12219,6 +12573,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       this.gravity = o.gravity ?? 9.81;
       this.autoSplit = o.autoSplit !== false;
       this.maxFragments = o.maxFragments ?? 160;
+      this.eventBudgetMs = o.eventBudgetMs ?? Infinity;
       this.box = new THREE.Box3();
       this.tmpQ = new THREE.Quaternion();
       this.v1 = new THREE.Vector3();
@@ -12304,6 +12659,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         if (leftovers.length) this.matchByBox(objectId, root, leftovers, add2);
       }
       const bound = { id: objectId, root, sync: options.syncTransform !== false, parts: /* @__PURE__ */ new Map(), lastPos: null, lastQuat: null, piece: null, isSplit: false };
+      if (options.onFrame) bound.onFrame = options.onFrame;
       const hosts = /* @__PURE__ */ new Map();
       for (const pid of partIds) bound.parts.set(pid, this.makePartVis(objectId, pid, state?.parts.find((p) => p.id === pid)?.material ?? "", byPart.get(pid) ?? [], hosts));
       for (const [pid, meshes] of byPart) {
@@ -12463,6 +12819,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       dt = clamp6(dt, 0, 0.1);
       this.time += dt;
       this.drainQueue();
+      for (const b of this.bounds.values()) b.onFrame?.(dt);
       for (const b of this.bounds.values()) if (b.soilNode && this.world.state(b.id)?.soil?.status === "yielding") this.onSettle(b.id);
       this.updateActive(dt);
       this.updateLeaks(dt);
@@ -12474,11 +12831,32 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     }
     drainQueue() {
       const batch = this.queue.splice(0, this.queue.length);
-      for (const ev of batch) {
+      const deadline = performance.now() + this.eventBudgetMs;
+      this.sliceDeadline = deadline;
+      try {
+        this.runSlices(deadline);
+        for (let i = 0; i < batch.length; i++) {
+          if (i > 0 && performance.now() >= deadline) {
+            this.queue.unshift(...batch.slice(i));
+            return;
+          }
+          try {
+            this.apply(batch[i]);
+          } catch (err) {
+            if (typeof console !== "undefined") console.error("game-destruction-three: failed to apply", batch[i].type, err);
+          }
+        }
+      } finally {
+        this.sliceDeadline = Infinity;
+      }
+    }
+    /** Runs the work left by earlier frames until the deadline; at least one piece per frame, so it always finishes. */
+    runSlices(deadline) {
+      for (let ran = 0; this.slices.length > 0 && (ran === 0 || performance.now() < deadline); ran++) {
         try {
-          this.apply(ev);
+          this.slices.shift()();
         } catch (err) {
-          if (typeof console !== "undefined") console.error("game-destruction-three: failed to apply", ev.type, err);
+          if (typeof console !== "undefined") console.error("game-destruction-three: failed to run deferred work", err);
         }
       }
     }
@@ -12876,12 +13254,19 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           const seed = hashNumbers(ev.time, point[0], point[1], point[2]);
           this.visuals.addCrack(mv, wp, normal, 7, Math.max(0.05, ev.hole.diameter * 5), 15267071, seed);
         } else {
+          const fresh = def?.penetrationClass === "wood" ? def.visual?.innerColor : void 0;
+          if (fresh !== void 0) this.visuals.addSpall(mv, wp, normal, Math.max(6e-3, ev.hole.diameter * WOOD_RIM), fresh);
           this.visuals.addHole(mv, wp, normal, ev.hole.diameter);
         }
       };
       draw(ev.worldPoint, n);
       if (ev.hole.through && ev.exitPoint) draw(ev.exitPoint, n.clone().negate());
       if (def?.tags?.includes("metal")) this.vfx.burst("sparks", ev.worldPoint, [n.x, n.y, n.z], 6, 3.5);
+      if (ev.powder) {
+        const puff3 = { color: ev.powder.color, size: 0.6, life: 1.6, alpha: 1.3 };
+        this.vfx.burst("dust", ev.worldPoint, [n.x, n.y, n.z], this.low ? 5 : 10, 0.7, puff3);
+        if (ev.hole.through && ev.exitPoint) this.vfx.burst("dust", ev.exitPoint, [-n.x, -n.y, -n.z], this.low ? 10 : 20, 1.3, puff3);
+      }
       this.sound(impactKey(def), ev.worldPoint, 0.6);
     }
     onCrack(ev) {
@@ -12892,8 +13277,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       const wp = new this.THREE.Vector3(ev.worldPoint[0], ev.worldPoint[1], ev.worldPoint[2]);
       const mv = this.nearestMesh(pv, wp);
       if (mv) {
-        const color = def?.visual?.transparent ? 15267071 : 2762532;
-        this.visuals.addCrack(mv, wp, this.worldDir(b, ev.crack.normal), ev.crack.rays, ev.crack.length, color, hashNumbers(ev.time, ev.worldPoint[0], ev.worldPoint[1], ev.worldPoint[2]));
+        const glass = !!def?.visual?.transparent;
+        const own = this.partColor(pv, def) ?? fallbackColor(pv.material, def);
+        const color = glass ? 15267071 : new this.THREE.Color(own).multiplyScalar(0.45).getHex();
+        const length = glass ? ev.crack.length : Math.min(ev.crack.length, OPAQUE_CRACK);
+        this.visuals.addCrack(mv, wp, this.worldDir(b, ev.crack.normal), ev.crack.rays, length, color, hashNumbers(ev.time, ev.worldPoint[0], ev.worldPoint[1], ev.worldPoint[2]));
       }
       this.sound(impactKey(def), ev.worldPoint, 0.5);
     }
@@ -12931,6 +13319,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       const core = def?.visual?.innerColor;
       if (core !== void 0) this.vfx.burst("chips", ev.point, [normal.x, normal.y, normal.z], 5, 2.5, { color: core });
       else this.playEvent({ kind: "spall", material: this.impactMaterial(def) }, ev.point);
+      if (mv.mesh.userData.drawnSpalls?.includes(ev.part)) return;
       this.visuals.addSpall(mv, wp, normal, Math.sqrt(ev.area / Math.PI), core ?? fallbackColor(pv.material, def));
     }
     /**
@@ -12968,6 +13357,10 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         const tone = fr.inner && fdef?.visual?.innerColor !== void 0 ? fdef.visual.innerColor : fdef === def ? color : fallbackColor(fr.material, fdef);
         this.fragments.spawn(fr, this.fragments.materialFor(fr.material, tone, false), ev.object, maxAlive);
       }
+      if (ev.torn) {
+        this.sound(impactKey(def), ev.center, 0.5);
+        return;
+      }
       const T = this.THREE;
       const center = new T.Vector3(ev.center[0], ev.center[1], ev.center[2]);
       const half = new T.Vector3(ev.size[0] / 2 + CHIP_DECAL_EDGE, ev.size[1] / 2 + CHIP_DECAL_EDGE, ev.size[2] / 2 + CHIP_DECAL_EDGE);
@@ -12992,15 +13385,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         if (m && m.transparent) opacity = clamp6(m.opacity, 0.2, 0.8);
         this.visuals.hide(pv, "broken");
       }
-      const maxAlive = this.low ? Math.floor(this.maxFragments / 2) : this.maxFragments;
-      const step = this.low ? 2 : 1;
-      for (let i = 0; i < ev.fragments.length; i += step) {
-        const fr = ev.fragments[i];
-        const fdef = this.world.materials.get(fr.material);
-        const tone = fr.inner && fdef?.visual?.innerColor !== void 0 ? fdef.visual.innerColor : fdef === def || !fdef ? color : fallbackColor(fr.material, fdef);
-        const mat = this.fragments.materialFor(fr.material, tone, transparent || fdef?.visual?.transparent === true, opacity);
-        this.fragments.spawn(fr, mat, ev.object, maxAlive);
-      }
+      this.spawnFragments(ev, 0, { def, color, opacity, transparent });
       const up = [0, 1, 0];
       const sizeK = clamp6(ev.fragments.length / 10, 0.5, 2);
       switch (ev.style) {
@@ -13026,6 +13411,22 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       }
       this.sound(fractureKey(def, ev.style), ev.point, clamp6(0.4 + ev.fragments.length * 0.03, 0.4, 1));
     }
+    /** Spawns the fragments of a fracture from index `from`; what does not fit in this frame's budget is spawned by the next frames. */
+    spawnFragments(ev, from, look) {
+      const maxAlive = this.low ? Math.floor(this.maxFragments / 2) : this.maxFragments;
+      const step = this.low ? 2 : 1;
+      for (let i = from; i < ev.fragments.length; i += step) {
+        if (i - from >= MIN_FRAGMENTS_PER_SLICE * step && performance.now() >= this.sliceDeadline) {
+          this.slices.push(() => this.spawnFragments(ev, i, look));
+          return;
+        }
+        const fr = ev.fragments[i];
+        const fdef = this.world.materials.get(fr.material);
+        const tone = fr.inner && fdef?.visual?.innerColor !== void 0 ? fdef.visual.innerColor : fdef === look.def || !fdef ? look.color : fallbackColor(fr.material, fdef);
+        const mat = this.fragments.materialFor(fr.material, tone, look.transparent || fdef?.visual?.transparent === true, look.opacity);
+        this.fragments.spawn(fr, mat, ev.object, maxAlive);
+      }
+    }
     onDetach(ev) {
       this.sound("detach", this.rootPoint(ev.object), 0.5);
       this.splitLoose(ev.object);
@@ -13039,6 +13440,13 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       if (!st || st.groups.length < 2) return;
       const loose = st.groups.length - 1;
       for (let i = 0; i < loose; i++) {
+        if (i > 0 && performance.now() >= this.sliceDeadline) {
+          this.slices.push(() => {
+            this.staticDirty.add(objectId);
+            this.splitLoose(objectId);
+          });
+          return;
+        }
         let newId;
         try {
           newId = this.world.splitGroup(objectId, 1);
@@ -13055,8 +13463,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         old.mass = Math.max(0.05, this.massOf(objectId));
         old.sleeping = false;
       } else if (kitOriginOf(b.root)?.kind === "furniture") {
-        this.makePiece(objectId);
+        const piece = this.makePiece(objectId);
         this.tipIfTopHeavy(b);
+        this.o.onLoosened?.(objectId, piece, "apart");
       }
     }
     /** The renderer side of `splitGroup`: a new group holding the meshes of the new object, made a piece. */
@@ -13165,7 +13574,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         const piece = this.makePiece(b.id, { mass });
         const body = this.pieceSys.get(b.id);
         if (!body) continue;
-        this.o.onLoosened?.(b.id, piece);
+        this.o.onLoosened?.(b.id, piece, "blast");
         const spread = half[0];
         const momentum = hit.speed * mass;
         this.pieceSys.impulse(body, [hit.direction[0] * momentum, hit.direction[1] * momentum, hit.direction[2] * momentum], [world.x + (this.rng() - 0.5) * spread, world.y + spread * 0.5, world.z + (this.rng() - 0.5) * spread]);
@@ -13360,6 +13769,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     }
     clear() {
       this.queue.length = 0;
+      this.slices.length = 0;
       this.active.clear();
       for (const key of [...this.fires.keys()]) this.stopFire(key);
       this.leaks.length = 0;
@@ -13379,6 +13789,15 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       this.vfx.sprites().clear();
       this.ownVfx?.world.clear();
     }
+    reset() {
+      this.clear();
+      this.rng = createRng(RNG_SEED);
+      this.time = 0;
+      this.staticAt = 0;
+      this.throttles.clear();
+      this.fragments.reset();
+      this.pieceSys.reset();
+    }
     wakeRegion(x, z, radius) {
       this.fragments.wakeRegion(x, z, radius);
       this.pieceSys.wakeRegion(x, z, radius);
@@ -13683,7 +14102,18 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     drag("drag_masonry", [sceneNoise({ type: "bandpass", f: 260, q: 0.9, d: 0.3, vol: 0.62 }), ...sceneMany(3, () => sceneNoise({ type: "bandpass", f: [600, 1200], q: 2, d: 0.04, vol: 0.14, delay: [0, 0.2] }))]),
     drag("drag_soft", [sceneNoise({ type: "lowpass", f: 420, d: 0.28, vol: 0.3 })])
   ];
-  var DESTRUCTION_SOUND_BANK = { id: "destruction_three", sounds: [...SCENE_SOUNDS, ...DRAG_SOUNDS, EXPLOSION_BOOM], loops: [BURN_LOOP] };
+  var leaf = (id, layers) => ({ ...sceneRecipe(id, layers, ""), sources: ["sdk: a door, lid or drawer worked by hand"] });
+  var LEAF_SOUNDS = [
+    leaf("latch", [sceneNoise({ type: "bandpass", f: 2400, q: 4, d: 0.03, vol: 0.35 }), sceneTone({ f: 1900, f2: 1500, d: 0.025, vol: 0.06, delay: 0.035 })]),
+    leaf("creak_wood", [sceneTone({ f: [190, 240], f2: 310, d: 0.5, vol: 0.05 }), sceneNoise({ type: "bandpass", f: 520, q: 6, a: 0.05, d: 0.45, vol: 0.12 })]),
+    leaf("creak_metal", [sceneTone({ f: [620, 760], f2: 900, d: 0.35, vol: 0.035 }), sceneNoise({ type: "bandpass", f: 1400, q: 8, a: 0.04, d: 0.3, vol: 0.08 })]),
+    leaf("shut_wood", [sceneTone({ f: 120, f2: 60, d: 0.14, vol: 0.5 }), sceneNoise({ type: "bandpass", f: 600, q: 1.2, d: 0.1, vol: 0.55, wet: 0.25 }), sceneNoise({ type: "bandpass", f: 2400, q: 4, d: 0.03, vol: 0.25, delay: 0.02 })]),
+    leaf("shut_metal", [sceneTone({ f: 160, f2: 85, d: 0.18, vol: 0.55 }), sceneNoise({ type: "bandpass", f: 900, q: 1.6, d: 0.12, vol: 0.45, wet: 0.3 }), sceneTone({ f: 1250, f2: 1150, d: 0.12, vol: 0.06 })]),
+    leaf("shut_soft", [sceneTone({ f: 95, f2: 55, d: 0.12, vol: 0.35 }), sceneNoise({ type: "lowpass", f: 500, d: 0.1, vol: 0.3 })]),
+    leaf("rattle", sceneMany(5, () => sceneNoise({ type: "bandpass", f: [1600, 2600], q: 3, d: 0.035, vol: 0.32, delay: [0, 0.45] }))),
+    leaf("slide", [sceneNoise({ type: "bandpass", f: 700, q: 2, a: 0.04, d: 0.35, vol: 0.22 }), sceneNoise({ type: "bandpass", f: 2200, q: 5, d: 0.3, vol: 0.05 })])
+  ];
+  var DESTRUCTION_SOUND_BANK = { id: "destruction_three", sounds: [...SCENE_SOUNDS, ...DRAG_SOUNDS, ...LEAF_SOUNDS, EXPLOSION_BOOM], loops: [BURN_LOOP] };
 
   // src/audio/sound.ts
   var DESTRUCTION_SOUND_KEYS = {
@@ -13698,6 +14128,32 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       drag_glass: { sound: "drag_glass" },
       drag_masonry: { sound: "drag_masonry" },
       drag_soft: { sound: "drag_soft" },
+      // a leaf worked by hand (doors, lids, drawers): the latch, the hinge turning, the leaf meeting the frame, a locked one shaken
+      leaf_latch: { sound: "latch" },
+      leaf_creak_wood: { sound: "creak_wood" },
+      leaf_creak_metal: { sound: "creak_metal" },
+      leaf_shut_wood: { sound: "shut_wood" },
+      leaf_shut_metal: { sound: "shut_metal" },
+      leaf_shut_glass: { sound: "shut_metal", volumeScale: 0.6 },
+      leaf_shut_masonry: { sound: "shut_wood" },
+      leaf_shut_soft: { sound: "shut_soft" },
+      leaf_rattle: { sound: "rattle" },
+      leaf_slide: { sound: "slide" },
+      // the keys of the item clips (furniture and vehicle doors, hoods, trunks, drawers)
+      door_latch: { sound: "latch" },
+      hood_latch: { sound: "latch" },
+      trunk_latch: { sound: "latch" },
+      door_open: { sound: "latch" },
+      door_shut: { sound: "shut_metal" },
+      hood_shut: { sound: "shut_metal" },
+      trunk_shut: { sound: "shut_metal" },
+      door_close: { sound: "shut_wood", volumeScale: 0.7 },
+      drawer_open: { sound: "slide" },
+      drawer_close: { sound: "slide" },
+      lid_open: { sound: "latch" },
+      lid_close: { sound: "shut_soft" },
+      flap_open: { sound: "latch" },
+      flap_close: { sound: "shut_soft" },
       shatter_glass: { sound: "glass_shatter" },
       crumble: { sound: "crumble" },
       splinter: { sound: "crack" },