@adatechnology/game-destruction-three 0.11.1 → 0.12.1

package/dist/index.global.js

@@ -1357,11 +1357,231 @@ var GameDestructionThree = (() => {
       glow.outIntensity = glow.i * Math.pow(1 - age, glow.curve) * flicker;
     }
   }
+  var LEHMER_MULTIPLIER = 16807;
+  var LEHMER_MODULUS = 2147483647;
+  var HASH_MIX = 2654435761;
+  function normalizeLehmerSeed(seed) {
+    const whole = Math.floor(Math.abs(seed)) % (LEHMER_MODULUS - 1);
+    return whole === 0 ? 1 : whole;
+  }
+  function lehmer(seed) {
+    let state = normalizeLehmerSeed(seed);
+    const next = () => {
+      state = state * LEHMER_MULTIPLIER % LEHMER_MODULUS;
+      return (state - 1) / (LEHMER_MODULUS - 1);
+    };
+    return {
+      next,
+      between: (min2, max2) => min2 + (max2 - min2) * next(),
+      direction(out) {
+        const up = next() * 2 - 1;
+        const angle = next() * Math.PI * 2;
+        const ring2 = Math.sqrt(1 - up * up);
+        out.x = ring2 * Math.cos(angle);
+        out.y = up;
+        out.z = ring2 * Math.sin(angle);
+        return out;
+      },
+      get state() {
+        return state;
+      }
+    };
+  }
+  function mixEventSeed(eventSeed) {
+    let mixed = Math.imul((eventSeed | 0) ^ HASH_MIX, 2246822507);
+    mixed ^= mixed >>> 13;
+    mixed = Math.imul(mixed, 3266489909);
+    mixed ^= mixed >>> 16;
+    return (mixed >>> 0) % (LEHMER_MODULUS - 1) + 1;
+  }
+  function streamFor(eventSeed) {
+    return lehmer(mixEventSeed(eventSeed));
+  }
+  var SKIN = 5e-3;
+  var MAX_PAD = 0.45;
+  function rotation(q) {
+    const [x, y, z, w] = q ?? [0, 0, 0, 1];
+    const n = Math.hypot(x, y, z, w) || 1;
+    const qx = x / n;
+    const qy = y / n;
+    const qz = z / n;
+    const qw = w / n;
+    return new Float64Array([
+      1 - 2 * (qy * qy + qz * qz),
+      2 * (qx * qy - qz * qw),
+      2 * (qx * qz + qy * qw),
+      2 * (qx * qy + qz * qw),
+      1 - 2 * (qx * qx + qz * qz),
+      2 * (qy * qz - qx * qw),
+      2 * (qx * qz - qy * qw),
+      2 * (qy * qz + qx * qw),
+      1 - 2 * (qx * qx + qy * qy)
+    ]);
+  }
+  var Enclosures = class {
+    constructor(seed = 20973) {
+      __publicField2(this, "spaces", /* @__PURE__ */ new Map());
+      __publicField2(this, "list", []);
+      __publicField2(this, "random");
+      __publicField2(this, "out", { x: 0, y: 0, z: 0, nx: 0, ny: 0, nz: 0 });
+      __publicField2(this, "l0", new Float64Array(3));
+      __publicField2(this, "l1", new Float64Array(3));
+      __publicField2(this, "q", new Float64Array(3));
+      this.random = lehmer(seed);
+    }
+    get empty() {
+      return this.list.length === 0;
+    }
+    get size() {
+      return this.list.length;
+    }
+    /** Declares, moves or (with `null`) ends the space `id`. */
+    set(id, enclosure) {
+      if (!enclosure) {
+        if (this.spaces.delete(id)) this.list = [...this.spaces.values()];
+        return;
+      }
+      const [hx, hy, hz] = enclosure.halfSize;
+      const space = {
+        cx: enclosure.center[0],
+        cy: enclosure.center[1],
+        cz: enclosure.center[2],
+        hx: Math.abs(hx),
+        hy: Math.abs(hy),
+        hz: Math.abs(hz),
+        r: rotation(enclosure.orientation),
+        radius: Math.hypot(hx, hy, hz),
+        openings: enclosure.openings ?? [],
+        leak: Math.max(0, enclosure.leak ?? 0)
+      };
+      const old = this.spaces.get(id);
+      this.spaces.set(id, space);
+      const at3 = old ? this.list.indexOf(old) : -1;
+      if (at3 >= 0) this.list[at3] = space;
+      else this.list.push(space);
+    }
+    get(id) {
+      const s = this.spaces.get(id);
+      if (!s) return void 0;
+      return { center: [s.cx, s.cy, s.cz], halfSize: [s.hx, s.hy, s.hz], openings: s.openings, leak: s.leak };
+    }
+    ids() {
+      return [...this.spaces.keys()];
+    }
+    clear() {
+      this.spaces.clear();
+      this.list = [];
+    }
+    /** Whether a point is inside any space (on the inside of its walls). */
+    inside(x, y, z) {
+      for (const s of this.list) {
+        this.toLocal(s, x, y, z, this.l0);
+        if (Math.abs(this.l0[0]) <= s.hx && Math.abs(this.l0[1]) <= s.hy && Math.abs(this.l0[2]) <= s.hz) return true;
+      }
+      return false;
+    }
+    toLocal(s, x, y, z, out) {
+      const dx = x - s.cx;
+      const dy = y - s.cy;
+      const dz = z - s.cz;
+      const r = s.r;
+      out[0] = r[0] * dx + r[3] * dy + r[6] * dz;
+      out[1] = r[1] * dx + r[4] * dy + r[7] * dz;
+      out[2] = r[2] * dx + r[5] * dy + r[8] * dz;
+    }
+    /** Passes at `rate` per second. */
+    chance(rate, dt) {
+      return rate > 0 && this.random.next() < 1 - Math.exp(-rate * dt);
+    }
+    /** The opening the wall point `q` (local) is in lets it through now. */
+    through(s, q, dt) {
+      for (const o of s.openings) {
+        if (Math.abs(q[0] - o.center[0]) > o.halfSize[0] || Math.abs(q[1] - o.center[1]) > o.halfSize[1] || Math.abs(q[2] - o.center[2]) > o.halfSize[2]) continue;
+        if (o.rate === void 0 || this.chance(o.rate, dt)) return true;
+      }
+      return this.chance(s.leak, dt);
+    }
+    confine(x0, y0, z0, x1, y1, z1, pad, dt) {
+      const list = this.list;
+      if (list.length === 0) return false;
+      const p = Math.min(Math.max(0, pad), MAX_PAD);
+      const l0 = this.l0;
+      const l1 = this.l1;
+      const q = this.q;
+      for (const s of list) {
+        const reach = s.radius + p + 0.05;
+        const dx = x1 - s.cx;
+        const dy = y1 - s.cy;
+        const dz = z1 - s.cz;
+        if (dx * dx + dy * dy + dz * dz > reach * reach) {
+          const ex = x0 - s.cx;
+          const ey = y0 - s.cy;
+          const ez = z0 - s.cz;
+          if (ex * ex + ey * ey + ez * ez > reach * reach) continue;
+        }
+        this.toLocal(s, x0, y0, z0, l0);
+        this.toLocal(s, x1, y1, z1, l1);
+        const h = [s.hx, s.hy, s.hz];
+        const in0 = Math.abs(l0[0]) <= s.hx && Math.abs(l0[1]) <= s.hy && Math.abs(l0[2]) <= s.hz;
+        let axis2 = 0;
+        let sign = 1;
+        if (in0) {
+          if (Math.abs(l1[0]) <= s.hx && Math.abs(l1[1]) <= s.hy && Math.abs(l1[2]) <= s.hz) continue;
+          for (let a = 0; a < 3; a++) q[a] = Math.min(h[a], Math.max(-h[a], l1[a]));
+          if (this.through(s, q, dt)) continue;
+          let worst = -Infinity;
+          for (let a = 0; a < 3; a++) {
+            const over = Math.abs(l1[a]) - h[a];
+            if (over > worst) {
+              worst = over;
+              axis2 = a;
+            }
+          }
+          sign = l1[axis2] < 0 ? -1 : 1;
+          for (let a = 0; a < 3; a++) l1[a] = Math.min(h[a] - SKIN, Math.max(-(h[a] - SKIN), l1[a]));
+          sign = -sign;
+        } else {
+          const padded0 = Math.abs(l0[0]) <= s.hx + p && Math.abs(l0[1]) <= s.hy + p && Math.abs(l0[2]) <= s.hz + p;
+          const bound = padded0 ? 0 : p;
+          if (!(Math.abs(l1[0]) <= s.hx + bound && Math.abs(l1[1]) <= s.hy + bound && Math.abs(l1[2]) <= s.hz + bound)) continue;
+          for (let a = 0; a < 3; a++) q[a] = Math.min(h[a], Math.max(-h[a], l1[a]));
+          if (this.through(s, q, dt)) continue;
+          let worst = -Infinity;
+          for (let a = 0; a < 3; a++) {
+            const over = Math.abs(l0[a]) - (h[a] + bound);
+            if (over > worst) {
+              worst = over;
+              axis2 = a;
+            }
+          }
+          sign = l0[axis2] < 0 ? -1 : 1;
+          l1[axis2] = sign * (h[axis2] + bound + SKIN);
+        }
+        const r = s.r;
+        const out = this.out;
+        out.x = s.cx + r[0] * l1[0] + r[1] * l1[1] + r[2] * l1[2];
+        out.y = s.cy + r[3] * l1[0] + r[4] * l1[1] + r[5] * l1[2];
+        out.z = s.cz + r[6] * l1[0] + r[7] * l1[1] + r[8] * l1[2];
+        out.nx = r[axis2] * sign;
+        out.ny = r[3 + axis2] * sign;
+        out.nz = r[6 + axis2] * sign;
+        return true;
+      }
+      return false;
+    }
+  };
+  function slideAlong(out, vx2, vy2, vz2) {
+    const into = vx2 * out.nx + vy2 * out.ny + vz2 * out.nz;
+    if (into >= 0) return [vx2, vy2, vz2];
+    return [vx2 - into * out.nx, vy2 - into * out.ny, vz2 - into * out.nz];
+  }
   var FLOOR_FRACTION = 0.4;
   var FLOOR_BOUNCE = -0.2;
   var ARRIVAL_FRAME = 30;
   var ARRIVAL_BASE = 0.3;
   var GROWTH_CAP_SECONDS = 3.5;
+  var CARRIED_KINDS = [true, true, false, true, false];
+  var PAD_OF_SIZE = 0.35;
   function createPuffPool(capacity) {
     const placeholder = { next: () => 0, between: (min2) => min2, direction: (out) => out, state: 0 };
     return new OrderedPool(capacity, () => ({
@@ -1456,13 +1676,24 @@ var GameDestructionThree = (() => {
       if (puff3.vy < 0) puff3.vy *= FLOOR_BOUNCE;
     }
   }
-  function updatePuffs(pool, dt, wind) {
+  function updatePuffs(pool, dt, wind, confiner) {
     pool.compact(ageOrKeep2, dt);
+    const confining = confiner !== void 0 && !confiner.empty;
     for (const puff3 of pool.items) {
       const age = puff3.t / puff3.life;
       const heat = puff3.h0 > 0 ? puff3.h0 * Math.pow(Math.max(0, 1 - puff3.t / puff3.hl), 1.25) : 0;
+      const x0 = puff3.x;
+      const y0 = puff3.y;
+      const z0 = puff3.z;
       if (puff3.ring) moveOnRing(puff3, puff3.ring, wind);
       else moveFree(puff3, dt, age, heat, wind);
+      if (confining && CARRIED_KINDS[puff3.kind] && confiner.confine(x0, y0, z0, puff3.x, puff3.y, puff3.z, puff3.size * PAD_OF_SIZE, dt)) {
+        const out = confiner.out;
+        puff3.x = out.x;
+        puff3.y = out.y;
+        puff3.z = out.z;
+        [puff3.vx, puff3.vy, puff3.vz] = slideAlong(out, puff3.vx, puff3.vy, puff3.vz);
+      }
       const size = puff3.s0 + (puff3.s1 - puff3.s0) * (1 - Math.exp(-puff3.t * puff3.gk)) + puff3.sg * Math.min(puff3.t, GROWTH_CAP_SECONDS);
       puff3.size = size * Math.min(1, puff3.t * ARRIVAL_FRAME + ARRIVAL_BASE);
       puff3.age = age;
@@ -1988,10 +2219,10 @@ var GameDestructionThree = (() => {
       ])
     ]
   };
-  function localToWorld(translation, rotation, local2) {
+  function localToWorld(translation, rotation2, local2) {
     const [x, y, z] = local2;
-    const [a, c, e] = [Math.cos(rotation[0]), Math.cos(rotation[1]), Math.cos(rotation[2])];
-    const [b, d, f] = [Math.sin(rotation[0]), Math.sin(rotation[1]), Math.sin(rotation[2])];
+    const [a, c, e] = [Math.cos(rotation2[0]), Math.cos(rotation2[1]), Math.cos(rotation2[2])];
+    const [b, d, f] = [Math.sin(rotation2[0]), Math.sin(rotation2[1]), Math.sin(rotation2[2])];
     const [ae, af, be, bf] = [a * e, a * f, b * e, b * f];
     return [
       c * e * x + -c * f * y + d * z + translation[0],
@@ -3654,46 +3885,6 @@ var GameDestructionThree = (() => {
   var ALL_EFFECTS = [BLOOD_HIT, HEADSHOT, DISMEMBER, BLOATER_CLOUD, SCREAMER_SHRIEK, CORPSE_DECAY, REANIMATION, EYES_IN_FOG, MUZZLE_FLASH, IMPACT_BY_MATERIAL, PENETRATION, CASINGS_AND_MAGAZINE, MOLOTOV, GRENADE, EXPLOSIVE_BARREL, SHOPFRONT_GLASS, DOOR_STAGES, BUILDING_COLLAPSE, BLOCK_WALL, METAL_DOOR_EFFECT, IRON_RAILING, WOODEN_FENCE, HIT_POINT_BREAKAGE, PRESSURE_CYLINDERS, BUILDING_FIRE, RAIN_AND_PUDDLES, FOG_AND_ASH, SCRAPING_SPARKS, ENGINE_SMOKE, FUEL_LEAK, CAR_EXPLOSION, WINDSHIELD, HEADLIGHTS_IN_RAIN, DAMAGE_AND_BITE, INFECTION_PHASES, PANIC, BLOATER_BLINDNESS, CAMPFIRE, COUGH_AND_BREATH];
   var WORKSHOP_EFFECTS = Object.fromEntries(ALL_EFFECTS.map((effect) => [effect.id, effect]));
   var GAME_EFFECTS = { ...WORKSHOP_EFFECTS, ...Object.fromEntries([...EVENT_EFFECTS, ...VIEWMODEL_EFFECTS, ...VEHICLE_EFFECTS].map((effect) => [effect.id, effect])) };
-  var LEHMER_MULTIPLIER = 16807;
-  var LEHMER_MODULUS = 2147483647;
-  var HASH_MIX = 2654435761;
-  function normalizeLehmerSeed(seed) {
-    const whole = Math.floor(Math.abs(seed)) % (LEHMER_MODULUS - 1);
-    return whole === 0 ? 1 : whole;
-  }
-  function lehmer(seed) {
-    let state = normalizeLehmerSeed(seed);
-    const next = () => {
-      state = state * LEHMER_MULTIPLIER % LEHMER_MODULUS;
-      return (state - 1) / (LEHMER_MODULUS - 1);
-    };
-    return {
-      next,
-      between: (min2, max2) => min2 + (max2 - min2) * next(),
-      direction(out) {
-        const up = next() * 2 - 1;
-        const angle = next() * Math.PI * 2;
-        const ring2 = Math.sqrt(1 - up * up);
-        out.x = ring2 * Math.cos(angle);
-        out.y = up;
-        out.z = ring2 * Math.sin(angle);
-        return out;
-      },
-      get state() {
-        return state;
-      }
-    };
-  }
-  function mixEventSeed(eventSeed) {
-    let mixed = Math.imul((eventSeed | 0) ^ HASH_MIX, 2246822507);
-    mixed ^= mixed >>> 13;
-    mixed = Math.imul(mixed, 3266489909);
-    mixed ^= mixed >>> 16;
-    return (mixed >>> 0) % (LEHMER_MODULUS - 1) + 1;
-  }
-  function streamFor(eventSeed) {
-    return lehmer(mixEventSeed(eventSeed));
-  }
   var TABLE = {
     concrete: { dust: 9078138, chip: 7236195, spark: 2 },
     metal: { dust: 0, chip: 0, spark: 18 },
@@ -4997,8 +5188,8 @@ var GameDestructionThree = (() => {
   function addScorch(store, random, x, z, radius) {
     const variant = Math.floor(random.next() * SCORCH_VARIANTS);
     const lift = 0.03 + nextLift(store) * 1e-3;
-    const rotation = random.next() * 6;
-    store.add({ kind: "scorch", x, z, radius, variant, lift, rotation });
+    const rotation2 = random.next() * 6;
+    store.add({ kind: "scorch", x, z, radius, variant, lift, rotation: rotation2 });
   }
   function addRimRocks(store, ground, random, x, z, radius) {
     const count = Math.round(6 + radius * 7);
@@ -5027,8 +5218,8 @@ var GameDestructionThree = (() => {
   function addCrater(store, ground, random, spec) {
     ground?.dent(random, spec.x, spec.z, spec.radius, spec.depth);
     if (!spec.marks) return;
-    const rotation = random.next() * 6;
-    store.add({ kind: "dirt", x: spec.x, z: spec.z, radius: spec.radius * 1.02, lift: 0.045, rotation });
+    const rotation2 = random.next() * 6;
+    store.add({ kind: "dirt", x: spec.x, z: spec.z, radius: spec.radius * 1.02, lift: 0.045, rotation: rotation2 });
     addRimRocks(store, ground, random, spec.x, spec.z, spec.radius);
   }
   function addBloodSplat(store, ground, random, spec) {
@@ -5584,6 +5775,7 @@ var GameDestructionThree = (() => {
     state.gas = Math.max(0, state.gas - dt / DECAY.gasSeconds);
     state.beat *= Math.exp(-DECAY.beat * dt);
   }
+  var PAD_OF_SIZE2 = 0.35;
   var clamp4 = (v, lo, hi) => v < lo ? lo : v > hi ? hi : v;
   var lerp4 = (a, b, t) => a + (b - a) * t;
   function rgb(hex) {
@@ -5743,9 +5935,20 @@ var GameDestructionThree = (() => {
           vy2 *= k;
           vz2 *= k;
         }
-        const x = this.position[i3] + vx2 * dt;
+        let x = this.position[i3] + vx2 * dt;
         let y = this.position[i3 + 1] + vy2 * dt;
-        const z = this.position[i3 + 2] + vz2 * dt;
+        let z = this.position[i3 + 2] + vz2 * dt;
+        const confiner = host.confiner;
+        if (def.carried && confiner && !confiner.empty) {
+          const pad = this.size0[i] * lerp4(1, def.grow, t) * PAD_OF_SIZE2;
+          if (confiner.confine(this.position[i3], this.position[i3 + 1], this.position[i3 + 2], x, y, z, pad, dt)) {
+            const out = confiner.out;
+            x = out.x;
+            y = out.y;
+            z = out.z;
+            [vx2, vy2, vz2] = slideAlong(out, vx2, vy2, vz2);
+          }
+        }
         if (def.ground !== "none") {
           const own = this.floor[i];
           const gy = Number.isNaN(own) ? host.groundAt(x, z) + 5e-3 : own;
@@ -5831,7 +6034,8 @@ var GameDestructionThree = (() => {
       alpha: 0.35,
       fadeIn: 0.15,
       cone: 0.6,
-      ground: "none"
+      ground: "none",
+      carried: true
     },
     sparks: {
       id: "sparks",
@@ -5875,7 +6079,8 @@ var GameDestructionThree = (() => {
       alpha: 0.4,
       fadeIn: 0.1,
       cone: 0.4,
-      ground: "none"
+      ground: "none",
+      carried: true
     },
     shards: {
       id: "shards",
@@ -6033,7 +6238,8 @@ var GameDestructionThree = (() => {
       fadeIn: 0.1,
       cone: 0.5,
       ground: "stop",
-      flutter: 0.6
+      flutter: 0.6,
+      carried: true
     },
     steam: {
       id: "steam",
@@ -6055,7 +6261,8 @@ var GameDestructionThree = (() => {
       alpha: 0.35,
       fadeIn: 0.15,
       cone: 0.6,
-      ground: "none"
+      ground: "none",
+      carried: true
     },
     flash: {
       id: "flash",
@@ -6188,7 +6395,8 @@ var GameDestructionThree = (() => {
       const host = {
         groundAt: this.options.groundAt,
         gravity: this.options.gravity,
-        land: (owner, x, y, z, color, tag) => this.listeners.get(owner)?.(x, y, z, color, tag)
+        land: (owner, x, y, z, color, tag) => this.listeners.get(owner)?.(x, y, z, color, tag),
+        ...this.options.confiner ? { confiner: this.options.confiner } : {}
       };
       if (this.additive.live > 0 || this.additive.drawCount > 0) this.additive.update(dt, host);
       if (this.normal.live > 0 || this.normal.drawCount > 0) this.normal.update(dt, host);
@@ -6394,8 +6602,8 @@ var GameDestructionThree = (() => {
      * Takes away the marks inside a box: world `center`, `half` extents along the axes of the world `rotation` (a quaternion, x y z w; none means the
      * world axes). The surface they were on is gone (a brick came out of a wall with its bullet holes). Returns how many went.
      */
-    clearInside(center, half, rotation = [0, 0, 0, 1]) {
-      const qx = -rotation[0], qy = -rotation[1], qz = -rotation[2], qw = rotation[3];
+    clearInside(center, half, rotation2 = [0, 0, 0, 1]) {
+      const qx = -rotation2[0], qy = -rotation2[1], qz = -rotation2[2], qw = rotation2[3];
       let gone = 0;
       for (const decal2 of this.decals) {
         if (!decal2.on) continue;
@@ -6516,10 +6724,14 @@ var GameDestructionThree = (() => {
   var DEFAULT_FADE_IN = 0.1;
   var FLOATS_PER_VECTOR = 3;
   var BYTE_MAX2 = 255;
+  var CARRIED_GRAVITY = 3;
+  var PAD_OF_SIZE3 = 0.35;
   var SpritePool = class {
-    constructor(capacity, context) {
+    /** `carried`: the normal-blend pool (smoke, dust, steam), whose light sprites go round the closed spaces; the additive one (flames, sparks) does not. */
+    constructor(capacity, context, carried = false) {
       __publicField2(this, "capacity", capacity);
       __publicField2(this, "context", context);
+      __publicField2(this, "carried", carried);
       __publicField2(this, "count", 0);
       __publicField2(this, "position");
       __publicField2(this, "velocity");
@@ -6619,6 +6831,7 @@ var GameDestructionThree = (() => {
     }
     update(dt, leaveDecal) {
       const { position, velocity } = this;
+      const confiner = this.context.confiner;
       for (let index = this.count - 1; index >= 0; index--) {
         this.life[index] -= dt;
         if (this.life[index] <= 0) {
@@ -6632,9 +6845,25 @@ var GameDestructionThree = (() => {
         velocity[offset] *= factor;
         velocity[offset + 1] *= factor;
         velocity[offset + 2] *= factor;
+        const x0 = position[offset];
+        const y0 = position[offset + 1];
+        const z0 = position[offset + 2];
         position[offset] += velocity[offset] * dt;
         position[offset + 1] += velocity[offset + 1] * dt;
         position[offset + 2] += velocity[offset + 2] * dt;
+        if (this.carried && confiner && !confiner.empty && Math.abs(this.gravity[index]) < CARRIED_GRAVITY) {
+          const size = this.startSize[index] * (1 + (this.growth[index] - 1) * age);
+          if (confiner.confine(x0, y0, z0, position[offset], position[offset + 1], position[offset + 2], size * PAD_OF_SIZE3, dt)) {
+            const out = confiner.out;
+            position[offset] = out.x;
+            position[offset + 1] = out.y;
+            position[offset + 2] = out.z;
+            const [vx2, vy2, vz2] = slideAlong(out, velocity[offset], velocity[offset + 1], velocity[offset + 2]);
+            velocity[offset] = vx2;
+            velocity[offset + 1] = vy2;
+            velocity[offset + 2] = vz2;
+          }
+        }
         const mode = this.groundMode[index];
         if (mode) {
           const groundHeight = this.context.groundAt(position[offset], position[offset + 2]);
@@ -6911,9 +7140,9 @@ var GameDestructionThree = (() => {
       __publicField2(this, "placement");
       __publicField2(this, "accumulators", /* @__PURE__ */ new Map());
       const profile = options.profile ?? PROFILES.high;
-      this.context = { random: options.random, groundAt: options.groundAt ?? workshopGround, quality: { level: 0, mult: 1 }, trace: options.trace };
+      this.context = { random: options.random, groundAt: options.groundAt ?? workshopGround, quality: { level: 0, mult: 1 }, trace: options.trace, ...options.confiner ? { confiner: options.confiner } : {} };
       this.add = new SpritePool(profile.sprites.add, this.context);
-      this.normal = new SpritePool(profile.sprites.normal, this.context);
+      this.normal = new SpritePool(profile.sprites.normal, this.context, true);
       this.streaks = new StreakPool(profile.streaks, this.context);
       this.debris = new DebrisPool(this.context);
       this.decals = new DecalPool(this.context);
@@ -7101,12 +7330,14 @@ var GameDestructionThree = (() => {
     const groundAt = options.groundAt ?? (ground ? (x, z) => ground.heightAt(x, z) : () => 0);
     const handles = { next: 0, events: 0 };
     const low = options.profile === "low";
+    const enclosures = new Enclosures(20973 + (options.seed ?? 0));
     const spriteSystem = new SpriteKindSystem({
       capacity: options.sprites?.capacity ?? (low ? 1250 : 2500),
       density: options.sprites?.density ?? (low ? 0.6 : 1),
       seed: 2654435761 + (options.seed ?? 0),
       groundAt,
       gravity: options.gravity ?? DEFAULT_GRAVITY,
+      confiner: enclosures,
       ...options.sprites?.kinds ? { kinds: options.sprites.kinds } : {}
     });
     const core = {
@@ -7156,7 +7387,7 @@ var GameDestructionThree = (() => {
       return [camera2.x, camera2.y, camera2.z];
     }, forward: (local2) => [local2[0] ?? 0, local2[1] ?? 0, local2[2] ?? 0] };
     function workshop() {
-      return engine ?? (engine = new WorkshopEngine({ random: sharedRandom, profile, groundAt }));
+      return engine ?? (engine = new WorkshopEngine({ random: sharedRandom, profile, groundAt, confiner: enclosures }));
     }
     function effectPlayer() {
       return player ?? (player = createEffectPlayer({ engine: workshop(), effects, view }));
@@ -7215,6 +7446,10 @@ var GameDestructionThree = (() => {
           puff3.vz += dz * strength;
         }
       },
+      enclose(id, enclosure) {
+        enclosures.set(id, enclosure);
+      },
+      enclosures: () => enclosures,
       stop(handle) {
         player?.stop(handle);
         const fires = core.fires;
@@ -7242,7 +7477,7 @@ var GameDestructionThree = (() => {
         core.clock.time += dt;
         core.schedule.update(core.clock.time);
         updateRings(core.rings, dt);
-        updatePuffs(core.puffs, dt, wind);
+        updatePuffs(core.puffs, dt, wind, enclosures);
         updateSparks(core.sparks, { dt, groundAt });
         updateGlows(core.glows, dt);
         updateShocks(core.shocks, core.puffs.items, dt);
@@ -7727,6 +7962,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 +7990,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 +8162,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 +8805,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 +8831,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 +8849,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);
@@ -8546,6 +8877,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         });
       },
       stop: (handle) => world.stop(handle),
+      // a module's closed space (a shut car's cabin): the world's smoke, dust and steam go round it
+      enclose: (id, enclosure) => world.enclose(id, enclosure),
       configure(settings) {
         const band = settings.lod_band;
         if (typeof band === "string" && band in LOD_BANDS) world.forceLod(LOD_BANDS[band] ?? null);
@@ -8571,6 +8904,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 +9027,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 +9047,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 +9148,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 +9166,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 +9176,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 +9211,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 +9233,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 +9244,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 +9296,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 +9347,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 +9451,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 +9462,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 +9536,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 +9556,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 +9585,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 +9603,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 +9663,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 +9688,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 +9696,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 +9736,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 +9809,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 +9905,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 +9939,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 +9976,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 +9996,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 +11415,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 +11474,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 +11488,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 +11566,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 +11744,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 +11769,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 +11780,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 +11934,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 +12104,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 };
     }
@@ -11585,8 +12159,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
      * Takes away the decals of a mesh that sit inside a box (world `center`, `half` extents along the axes of the world `rotation`): the surface they
      * marked is gone (a unit came out of the wall with its bullet holes and spalls).
      */
-    clearDecals(mv, center, half, rotation) {
-      const inv = rotation.clone().invert();
+    clearDecals(mv, center, half, rotation2) {
+      const inv = rotation2.clone().invert();
       const p = new this.THREE.Vector3();
       for (let i = mv.decals.length - 1; i >= 0; i--) {
         const d = mv.decals[i];
@@ -11800,6 +12374,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 +12579,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 +12595,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 +12661,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 +12742,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 +12758,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 +12769,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 +12786,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 +12810,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 +12896,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 +13056,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 +13068,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 +13491,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 +13514,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 +13556,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,11 +13594,15 @@ 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);
-      const rotation = new T.Quaternion(ev.rotation[0], ev.rotation[1], ev.rotation[2], ev.rotation[3]);
-      for (const part of this.bounds.get(ev.object)?.parts.values() ?? []) for (const mv of part.meshes) this.visuals.clearDecals(mv, center, half, rotation);
+      const rotation2 = new T.Quaternion(ev.rotation[0], ev.rotation[1], ev.rotation[2], ev.rotation[3]);
+      for (const part of this.bounds.get(ev.object)?.parts.values() ?? []) for (const mv of part.meshes) this.visuals.clearDecals(mv, center, half, rotation2);
       this.vfx.peekWorkshop()?.decals.clearInside(ev.center, [half.x, half.y, half.z], ev.rotation);
       this.vfx.burst("dust", ev.center, [0, 1, 0], 8, 0.8, { color });
       this.sound(impactKey(def), ev.center, 0.7);
@@ -12992,15 +13622,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 +13648,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 +13677,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 +13700,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 +13811,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 +14006,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 +14026,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 +14339,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 +14365,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" },