@adatechnology/game-destruction-three 0.15.3 → 0.16.0

package/dist/index.global.js

@@ -100,6 +100,7 @@ var GameDestructionThree = (() => {
 
   // ../game-contracts/dist/index.js
   var DEFAULT_BLAST_SHOVE = { coupling: 0.02, maxSpeed: 20, lift: 0.3, minSpeed: 0.3, falloffPower: 2 };
+  var clampShare = (share) => Math.min(1, Math.max(0, share));
   function blastShove(blast3, target, options = {}) {
     const o = { ...DEFAULT_BLAST_SHOVE, ...options };
     const dx = target.position[0] - blast3.point[0];
@@ -109,7 +110,8 @@ var GameDestructionThree = (() => {
     if (!(blast3.radius > 0) || distance > blast3.radius) return void 0;
     const falloff = (1 - distance / blast3.radius) ** o.falloffPower;
     const mass = Math.max(target.mass, 0.05);
-    const speed = Math.min(o.maxSpeed, Math.sqrt(2 * blast3.energy * (blast3.reach ?? 1) * o.coupling / mass)) * falloff;
+    const reach = clampShare(blast3.reach ?? 1);
+    const speed = Math.sqrt(reach) * Math.min(o.maxSpeed, Math.sqrt(2 * blast3.energy * o.coupling / mass)) * falloff;
     if (!(speed >= o.minSpeed)) return void 0;
     const direction = distance > 1e-4 ? [dx / distance, dy / distance + o.lift, dz / distance] : [0, 1, 0];
     const length = Math.hypot(direction[0], direction[1], direction[2]);
@@ -1572,16 +1574,16 @@ var GameDestructionThree = (() => {
         if (this.spaces.delete(id)) this.list = [...this.spaces.values()];
         return;
       }
-      const [hx, hy, hz] = enclosure.halfSize;
+      const [hx, hy, hz2] = 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),
+        hz: Math.abs(hz2),
         r: rotation(enclosure.orientation),
-        radius: Math.hypot(hx, hy, hz),
+        radius: Math.hypot(hx, hy, hz2),
         openings: enclosure.openings ?? [],
         leak: Math.max(0, enclosure.leak ?? 0)
       };
@@ -5764,13 +5766,14 @@ var GameDestructionThree = (() => {
   function composeAfterEffects(context) {
     const { core, def, random, x, y, z } = context;
     const mark = def.mark;
-    if (mark.crater && mark.dent && y < 1.2) {
+    const keepsMarks = !core.marklessAt?.(x, z);
+    if (keepsMarks && mark.crater && mark.dent && y < 1.2) {
       core.emit({ type: "crater", x, z, radius: mark.crater, depth: mark.dent });
       core.trace?.crater?.(x, z, mark.crater, mark.dent);
       addCrater(core.marks, core.ground, random, { x, z, radius: mark.crater, depth: mark.dent, marks: core.layers.mark });
       if (core.layers.shrapnel) composeRimDebris(context);
     }
-    if (mark.scorch && y < 1.2 && core.layers.mark) {
+    if (keepsMarks && mark.scorch && y < 1.2 && core.layers.mark) {
       core.trace?.scorch?.(x, z, mark.scorch);
       addScorch(core.marks, random, x, z, mark.scorch);
     }
@@ -7479,7 +7482,7 @@ var GameDestructionThree = (() => {
     const wind = { x: DEFAULT_WIND.x, y: DEFAULT_WIND.y, z: DEFAULT_WIND.z };
     if (options.wind) [wind.x, wind.y, wind.z] = options.wind;
     const camera2 = { x: 0, y: 1.6, z: 0 };
-    const layers = Object.fromEntries(VFX_LAYERS.map((layer2) => [layer2, true]));
+    const layers = Object.fromEntries(VFX_LAYERS.map((layer3) => [layer3, true]));
     const ground = options.ground;
     const groundAt = options.groundAt ?? (ground ? (x, z) => ground.heightAt(x, z) : () => 0);
     const handles = { next: 0, events: 0 };
@@ -7521,6 +7524,7 @@ var GameDestructionThree = (() => {
       spawned: { puffs: 0, sparks: 0, chunks: 0, lights: 0 },
       clock: { time: 0, lastBlast: -1, lod: 1, forcedLod: null },
       groundAt,
+      ...options.marklessAt ? { marklessAt: options.marklessAt } : {},
       emit: (request) => options.onRequest?.(request)
     };
     function definitionOf(id) {
@@ -7547,6 +7551,7 @@ var GameDestructionThree = (() => {
       return player ?? (player = createEffectPlayer({ engine: workshop(), effects, view }));
     }
     return {
+      hostGroundAt: options.groundAt,
       play(id, point, playOptions = {}) {
         if (!(id in effects)) return null;
         const seed = playOptions.seed ?? (randomMode === "shared" ? void 0 : Math.imul(++handles.events, AUTO_SEED) + (options.seed ?? 0));
@@ -7609,10 +7614,10 @@ var GameDestructionThree = (() => {
         const fires = core.fires;
         for (let index = fires.items.length - 1; index >= 0; index--) if (fires.items[index].handle === handle) fires.removeAt(index);
       },
-      setLayer(layer2, on) {
-        layers[layer2] = on;
+      setLayer(layer3, on) {
+        layers[layer3] = on;
       },
-      layer: (layer2) => layers[layer2],
+      layer: (layer3) => layers[layer3],
       setCamera(position) {
         camera2.x = position[0];
         camera2.y = position[1];
@@ -7730,7 +7735,7 @@ var GameDestructionThree = (() => {
   };
   var EFFECT_STEP_SECONDS = 1 / 50;
 
-  // ../game-vfx-three/dist/chunk-2MZDWTHX.js
+  // ../game-vfx-three/dist/chunk-CPRCWTSQ.js
   var GLOW_VERTEX = `attribute vec4 aP;attribute vec4 aC;varying vec2 vU;varying vec4 vC;
 void main(){vec3 R=vec3(viewMatrix[0][0],viewMatrix[1][0],viewMatrix[2][0]);vec3 Up=vec3(viewMatrix[0][1],viewMatrix[1][1],viewMatrix[2][1]);
 vec3 wp=aP.xyz+(R*position.x+Up*position.y)*aP.w;vU=position.xy;vC=aC;gl_Position=projectionMatrix*viewMatrix*vec4(wp,1.);}`;
@@ -8170,7 +8175,11 @@ void main(){
     const dirt = texture(paint(make, (context, size) => drawDirt(context, size, random)));
     return { scorch, dirt };
   }
-  var MAX_CONFORM_STEPS = 48;
+  var FLAT_STEPS_PER_METRE = 8;
+  var MAX_FLAT_STEPS = 48;
+  var DUG_STEPS_PER_METRE = 20;
+  var MAX_DUG_STEPS = 64;
+  var FLAT_TOLERANCE = 2e-3;
   var MIN_CONFORM_STEPS = 16;
   var BLOOD_GROW_RATE = 1.2;
   var BLOOD_START_GROWTH = 0.05;
@@ -8253,9 +8262,21 @@ void main(){
       spareGeometries.push(oldest.mesh.geometry);
       if (spareGeometries.length > MAX_SPARE_GROUND_GEOMETRIES) spareGeometries.shift().dispose();
     }
+    const heightAt = options.heightAt ?? ((x, z) => options.ground?.heightAt(x, z) ?? 0);
+    function groundDipsUnder(x, z, radius) {
+      const centre = heightAt(x, z);
+      for (const share of [0.25, 0.5, 0.75]) {
+        for (let ray = 0; ray < 8; ray++) {
+          const angle = ray / 8 * Math.PI * 2;
+          if (Math.abs(heightAt(x + Math.cos(angle) * radius * share, z + Math.sin(angle) * radius * share) - centre) > FLAT_TOLERANCE) return true;
+        }
+      }
+      return false;
+    }
     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 dug = options.heightAt !== void 0 && groundDipsUnder(mark.x, mark.z, radius);
+      const steps = Math.max(MIN_CONFORM_STEPS, Math.min(dug ? MAX_DUG_STEPS : MAX_FLAT_STEPS, Math.round(radius * (dug ? DUG_STEPS_PER_METRE : FLAT_STEPS_PER_METRE))));
       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;
@@ -8267,7 +8288,7 @@ void main(){
         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;
-        grid.setXYZ(index, worldX, (options.ground?.heightAt(worldX, worldZ) ?? 0) + mark.lift, worldZ);
+        grid.setXYZ(index, worldX, heightAt(worldX, worldZ) + mark.lift, worldZ);
       }
       grid.needsUpdate = true;
       geometry.computeVertexNormals();
@@ -8939,7 +8960,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       decalLayer(THREE, engine.decals),
       ringLayer(THREE, engine.rings)
     ];
-    for (const layer2 of layers) group.add(layer2.object);
+    for (const layer22 of layers) group.add(layer22.object);
     const meshes = createMeshLayer(THREE, engine.meshes);
     group.add(meshes.group);
     const lights = budget ? budgetedLights(engine, lightScale, budget) : legacyLights(THREE, engine, lightScale, group);
@@ -8947,13 +8968,13 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       group,
       sync() {
         let drawCalls = 0;
-        for (const layer2 of layers) if (layer2.sync()) drawCalls++;
+        for (const layer22 of layers) if (layer22.sync()) drawCalls++;
         drawCalls += meshes.sync();
         lights.sync();
         return drawCalls;
       },
       dispose() {
-        for (const layer2 of layers) layer2.dispose();
+        for (const layer22 of layers) layer22.dispose();
         meshes.dispose();
         lights.dispose();
         group.clear();
@@ -9057,7 +9078,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, options.lights);
-    const marks = createMarkLayer(THREE, { ground: pools.ground, createCanvas: options.createCanvas, rockGeometry, plateGeometry, ...options.markLimits });
+    const marks = createMarkLayer(THREE, { ground: pools.ground, ...world.hostGroundAt ? { heightAt: world.hostGroundAt } : {}, 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;
@@ -9190,7 +9211,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         stopMarks();
         overlay?.dispose();
         workshopLayers?.dispose();
-        for (const layer2 of [puffs, sparks, glows, chunks, shocks, lights, marks, sprites]) layer2.dispose();
+        for (const layer22 of [puffs, sparks, glows, chunks, shocks, lights, marks, sprites]) layer22.dispose();
         rockGeometry.dispose();
         plateGeometry.dispose();
         options.scene.remove(root);
@@ -9274,13 +9295,154 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     return r << 16 | g << 8 | bl;
   }
 
+  // src/fragment-shapes.ts
+  var FRAGMENT_SHAPE_VARIANTS = 6;
+  var SLIVER_STATIONS = 6;
+  var SLIVER_FRAY = 0.3;
+  var SLIVER_SECTION = [[0.5, 0.5], [0, 0.5], [-0.5, 0.5], [-0.5, -0.5], [0, -0.5], [0.5, -0.5]];
+  var sliverWidth = (t) => t < 0.25 ? 0.6 + 1.6 * t : t > 0.5 ? Math.max(0, (1 - t) / 0.5) ** 0.85 : 1;
+  var pushTriangle = (out, a, b, c) => {
+    out.push(a[0], a[1], a[2], b[0], b[1], b[2], c[0], c[1], c[2]);
+  };
+  var faceted = (THREE, positions) => {
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute("position", new THREE.Float32BufferAttribute(positions, 3));
+    geometry.computeVertexNormals();
+    return geometry;
+  };
+  function buildSliverGeometry(THREE, seed) {
+    const rnd2 = createRng(7e3 + seed);
+    const rings = [];
+    const bendY = (rnd2() - 0.5) * 0.3;
+    const bendZ = (rnd2() - 0.5) * 0.3;
+    for (let i = 0; i < SLIVER_STATIONS - 1; i++) {
+      const t = i / (SLIVER_STATIONS - 1);
+      const x = -0.5 + t + (i > 0 ? (rnd2() - 0.5) * 0.08 : 0);
+      const width = sliverWidth(t);
+      const lift = Math.sin(t * Math.PI);
+      rings.push(SLIVER_SECTION.map(([y, z]) => {
+        const fray = 1 - SLIVER_FRAY + SLIVER_FRAY * 1.4 * rnd2();
+        return [x, Math.max(-0.5, Math.min(0.5, y * width * fray + bendY * lift)), Math.max(-0.5, Math.min(0.5, z * width * fray + bendZ * lift))];
+      }));
+    }
+    const tip = [0.5, (rnd2() - 0.5) * 0.5, (rnd2() - 0.5) * 0.3];
+    const torn = [-0.5 + rnd2() * 0.12, (rnd2() - 0.5) * 0.2, (rnd2() - 0.5) * 0.2];
+    const sides = SLIVER_SECTION.length;
+    const positions = [];
+    for (let k = 0; k < sides; k++) {
+      const next = (k + 1) % sides;
+      pushTriangle(positions, torn, rings[0][next], rings[0][k]);
+      for (let i = 0; i < rings.length - 1; i++) {
+        const a = rings[i][k], b = rings[i][next], c = rings[i + 1][next], d = rings[i + 1][k];
+        pushTriangle(positions, a, b, c);
+        pushTriangle(positions, a, c, d);
+      }
+      const last = rings[rings.length - 1];
+      pushTriangle(positions, last[k], last[next], tip);
+    }
+    return faceted(THREE, positions);
+  }
+  function buildLumpGeometry(THREE, seed) {
+    const rnd2 = createRng(8e3 + seed);
+    const base = new THREE.IcosahedronGeometry(0.5, 0);
+    const source = base.getAttribute("position");
+    const pushOf = /* @__PURE__ */ new Map();
+    const positions = [];
+    for (let i = 0; i < source.count; i++) {
+      const x = source.getX(i), y = source.getY(i), z = source.getZ(i);
+      const key = `${x.toFixed(3)},${y.toFixed(3)},${z.toFixed(3)}`;
+      let push = pushOf.get(key);
+      if (push === void 0) {
+        push = 0.6 + 0.55 * rnd2();
+        pushOf.set(key, push);
+      }
+      positions.push(x * push, y * push, z * push);
+    }
+    base.dispose();
+    const extent = [0, 0, 0];
+    for (let i = 0; i < positions.length; i++) extent[i % 3] = Math.max(extent[i % 3], Math.abs(positions[i]));
+    for (let i = 0; i < positions.length; i++) positions[i] *= 0.5 / Math.max(extent[i % 3], 1e-3);
+    return faceted(THREE, positions);
+  }
+  var VENEER_EDGE = 11;
+  function buildVeneerGeometry(THREE, seed) {
+    const rnd2 = createRng(9e3 + seed);
+    const shape = new THREE.Shape();
+    const outline = [];
+    const edge = (y, inward) => y - inward * (rnd2() * 0.16 + (rnd2() < 0.15 ? 0.12 : 0));
+    for (let i = 0; i <= VENEER_EDGE; i++) outline.push([-0.5 + i / VENEER_EDGE, edge(0.5, 1)]);
+    outline.push([0.5 - rnd2() * 0.12, 0.2 * rnd2()], [0.5, -0.1 + 0.2 * rnd2()], [0.5 - rnd2() * 0.12, -0.25 * rnd2()]);
+    for (let i = VENEER_EDGE; i >= 0; i--) outline.push([-0.5 + i / VENEER_EDGE, edge(-0.5, -1)]);
+    outline.push([-0.5 + rnd2() * 0.12, -0.2 * rnd2()], [-0.5, 0.1 * rnd2()], [-0.5 + rnd2() * 0.12, 0.25 * rnd2()]);
+    shape.moveTo(outline[0][0], outline[0][1]);
+    for (let i = 1; i < outline.length; i++) shape.lineTo(outline[i][0], outline[i][1]);
+    shape.closePath();
+    const geometry = new THREE.ExtrudeGeometry(shape, { depth: 1, bevelEnabled: false });
+    geometry.translate(0, 0, -0.5);
+    return geometry;
+  }
+  var TORN_END = 0.24;
+  var TORN_STRANDS = [4, 7];
+  var pushQuad = (out, quad) => {
+    pushTriangle(out, quad[0], quad[1], quad[2]);
+    pushTriangle(out, quad[0], quad[2], quad[3]);
+  };
+  var unevenCuts = (count, rnd2) => {
+    const shares = Array.from({ length: count }, () => 0.35 + 1.65 * rnd2());
+    const total = shares.reduce((sum, share) => sum + share, 0);
+    const cuts = [-0.5];
+    for (const share of shares) cuts.push(cuts[cuts.length - 1] + share / total);
+    cuts[cuts.length - 1] = 0.5;
+    return cuts;
+  };
+  function buildBrokenBoardGeometry(THREE, seed) {
+    const rnd2 = createRng(1e4 + seed);
+    const end = 0.5 - TORN_END;
+    const positions = [];
+    const lo = -0.5, hi = 0.5;
+    pushQuad(positions, [[lo, lo, hi], [end, lo, hi], [end, hi, hi], [lo, hi, hi]]);
+    pushQuad(positions, [[lo, hi, lo], [end, hi, lo], [end, lo, lo], [lo, lo, lo]]);
+    pushQuad(positions, [[lo, hi, hi], [end, hi, hi], [end, hi, lo], [lo, hi, lo]]);
+    pushQuad(positions, [[lo, lo, lo], [end, lo, lo], [end, lo, hi], [lo, lo, hi]]);
+    pushQuad(positions, [[lo, lo, lo], [lo, lo, hi], [lo, hi, hi], [lo, hi, lo]]);
+    const count = TORN_STRANDS[0] + Math.floor(rnd2() * (TORN_STRANDS[1] - TORN_STRANDS[0] + 1));
+    const cuts = unevenCuts(count, rnd2);
+    for (let k = 0; k < count; k++) {
+      const y0 = cuts[k], y1 = cuts[k + 1];
+      const length = TORN_END * (0.15 + 0.85 * rnd2());
+      const midX = end + length * (0.35 + 0.3 * rnd2());
+      const narrow = 0.55 + 0.35 * rnd2();
+      const shiftY = (rnd2() - 0.5) * (y1 - y0) * 0.6;
+      const shiftZ = (rnd2() - 0.5) * 0.5;
+      const cy = (y0 + y1) / 2 + shiftY, hy = (y1 - y0) / 2 * narrow, hz2 = 0.5 * (0.4 + 0.5 * rnd2());
+      const base = [[end, y0, lo], [end, y1, lo], [end, y1, hi], [end, y0, hi]];
+      const clampZ = (z) => Math.max(lo, Math.min(hi, z));
+      const mid = [[midX, cy - hy, clampZ(shiftZ - hz2)], [midX, cy + hy, clampZ(shiftZ - hz2)], [midX, cy + hy, clampZ(shiftZ + hz2)], [midX, cy - hy, clampZ(shiftZ + hz2)]];
+      const tip = [end + length, y0 + (y1 - y0) * rnd2(), clampZ(shiftZ + (rnd2() - 0.5) * 0.4)];
+      for (let i = 0; i < 4; i++) {
+        const next = (i + 1) % 4;
+        pushQuad(positions, [base[i], base[next], mid[next], mid[i]]);
+        pushTriangle(positions, mid[i], mid[next], tip);
+      }
+    }
+    return faceted(THREE, positions);
+  }
+
   // src/fragments.ts
+  var BUILDERS = {
+    sliver: buildSliverGeometry,
+    lump: buildLumpGeometry,
+    veneer: buildVeneerGeometry,
+    board: buildBrokenBoardGeometry
+  };
   var SHEET_MAX = 4e-3;
   var SHEET_AIR = 2.5;
   var SHEET_SWAY = 3;
   var BIG_LENGTH = 0.2;
   var BIG_WIDTH = 0.03;
   var FRAGMENT_SEED = 1374496523;
+  var SUPPORT_CHECKS = 32;
+  var SUPPORT_GAP = 0.02;
   var SHARD_SHAPES = 6;
   var isBig = (size) => {
     const [, middle, longest] = [...size].sort((a, b) => a - b);
@@ -9295,6 +9457,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       /** The mesh box of a fragment before its scale. */
       __publicField(this, "unitBox", { min: { x: -0.5, y: -0.5, z: -0.5 }, max: { x: 0.5, y: 0.5, z: 0.5 } });
       __publicField(this, "shardGeos", []);
+      __publicField(this, "shapeGeos", /* @__PURE__ */ new Map());
       __publicField(this, "materials", /* @__PURE__ */ new Map());
       __publicField(this, "q");
       __publicField(this, "dq");
@@ -9304,6 +9467,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       __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, "supportTurn", 0);
       __publicField(this, "markGeometry", null);
       __publicField(this, "markMaterial", null);
       this.box = new THREE.BoxGeometry(1, 1, 1);
@@ -9352,21 +9516,54 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       }
       return g;
     }
+    sharedGeometry(shape, seed) {
+      const idx = seed % FRAGMENT_SHAPE_VARIANTS;
+      let variants = this.shapeGeos.get(shape);
+      if (!variants) {
+        variants = [];
+        this.shapeGeos.set(shape, variants);
+      }
+      let g = variants[idx];
+      if (!g) {
+        g = BUILDERS[shape](this.THREE, idx);
+        variants[idx] = g;
+      }
+      return g;
+    }
+    /**
+     * The geometry a fragment is drawn with: a splinter is a pointed, frayed sliver; MDF breaks in lumps, plywood peels in ragged veneer, the stub of a broken
+     * board ends in torn strands at +x; the rest are boxes.
+     */
+    geometryOf(f) {
+      const seed = hashString(f.id);
+      if (f.shape === "shard") return this.shardGeometry(seed);
+      if (f.shape === "splinter") return this.sharedGeometry("sliver", seed);
+      const form = this.o.formOf?.(f.material);
+      if (f.shape === "chunk" && form === "granules") return this.sharedGeometry("lump", seed);
+      if (f.shape === "scrap" && form === "plies") return this.sharedGeometry("veneer", seed);
+      if (f.shape === "slab" && (form === "slivers" || form === "plies")) return this.sharedGeometry("board", seed);
+      return this.box;
+    }
     markParts() {
       this.markGeometry ?? (this.markGeometry = new this.THREE.CircleGeometry(1, 10));
       this.markMaterial ?? (this.markMaterial = new this.THREE.MeshBasicMaterial({ color: 723465, depthWrite: false, polygonOffset: true, polygonOffsetFactor: -4, polygonOffsetUnits: -4 }));
       return { geometry: this.markGeometry, material: this.markMaterial };
     }
     /**
-     * Meshes, never put in a scene by this class, that draw every shared piece of a fragment once: the box, the six shards, the bullet-hole disc, and the opaque and
+     * Meshes, never put in a scene by this class, that draw every shared piece of a fragment once: the box, the six shards, the wood splinters, MDF lumps and plywood veneer, the bullet-hole disc, and the opaque and
      * glass materials. A host draws them at load so the first blast does not upload these buffers in the middle of a frame.
      */
     warmMeshes() {
       const opaque = this.materialFor("warm", 8421504, false);
       const glass2 = this.materialFor("warm", 8421504, true);
       const geometries = [this.box, ...Array.from({ length: SHARD_SHAPES }, (_, index) => this.shardGeometry(index))];
+      const wood = ["sliver", "lump", "veneer", "board"].flatMap((shape) => Array.from({ length: FRAGMENT_SHAPE_VARIANTS }, (_, index) => this.sharedGeometry(shape, index)));
       const { geometry, material } = this.markParts();
-      return [...geometries.flatMap((shared) => [new this.THREE.Mesh(shared, opaque), new this.THREE.Mesh(shared, glass2)]), new this.THREE.Mesh(geometry, material)];
+      return [
+        ...geometries.flatMap((shared) => [new this.THREE.Mesh(shared, opaque), new this.THREE.Mesh(shared, glass2)]),
+        ...wood.map((shared) => new this.THREE.Mesh(shared, opaque)),
+        new this.THREE.Mesh(geometry, material)
+      ];
     }
     /**
      * Bullet holes that stay on a fragment (`Fragment.marks`): dark discs that are children of its mesh, so they fall, spin and settle with it. The mesh is
@@ -9391,7 +9588,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
      * bigger than the budget (every live fragment was made in this same frame) does not make the rest at all, so a blast never builds a thousand meshes only to fade them
      * out. Returns null when the fragment was not made.
      */
-    spawn(f, material, home, maxAllowed) {
+    /**
+     * Throws `f` into the scene, within `maxAllowed` live fragments (the oldest small ones make room first). A `lasting` fragment (a steel bar) is debris that
+     * stays: it has a body the player and the pieces run into, however thin it is, and it never fades.
+     */
+    spawn(f, material, home, maxAllowed, lasting = false) {
       if (this.list.length >= maxAllowed) {
         let alive = 0;
         let oldest;
@@ -9408,7 +9609,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           oldest.dying = true;
         }
       }
-      const geo = f.shape === "shard" ? this.shardGeometry(hashString(f.id)) : this.box;
+      const geo = this.geometryOf(f);
       const mesh2 = new this.THREE.Mesh(geo, material);
       mesh2.position.set(f.center[0], f.center[1], f.center[2]);
       mesh2.quaternion.set(f.rotation[0], f.rotation[1], f.rotation[2], f.rotation[3]).normalize();
@@ -9436,9 +9637,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         air: f.shape === "scrap" && sz[2] <= SHEET_MAX ? SHEET_AIR : 0,
         body: null,
         born: this.tick,
-        life: Math.max(0, typeof this.o.life === "function" ? this.o.life(f, home) : this.o.life)
+        life: lasting ? 0 : Math.max(0, typeof this.o.life === "function" ? this.o.life(f, home) : this.o.life)
       };
-      if (f.shape !== "shard" && isBig(f.size)) {
+      if (lasting || f.shape !== "shard" && isBig(f.size)) {
         live.body = {
           mass: f.mass,
           push: (x, z) => {
@@ -9498,6 +9699,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     }
     update(dt) {
       this.tick++;
+      this.wakeUnsupported();
       const g = this.o.gravity;
       for (let i = this.list.length - 1; i >= 0; i--) {
         const f = this.list[i];
@@ -9522,6 +9724,18 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         this.step(f, dt, g);
       }
     }
+    /** A few fragments asleep each update (`SUPPORT_CHECKS`, in turn) look at the ground under them again: one left over air falls. */
+    wakeUnsupported() {
+      const n = this.list.length;
+      for (let k = 0; k < Math.min(SUPPORT_CHECKS, n); k++) {
+        this.supportTurn = (this.supportTurn + 1) % n;
+        const f = this.list[this.supportTurn];
+        if (!f.asleep || f.dying) continue;
+        const e = this.m.makeRotationFromQuaternion(f.mesh.quaternion).elements;
+        const ext = Math.abs(e[1]) * f.half.x + Math.abs(e[5]) * f.half.y + Math.abs(e[9]) * f.half.z;
+        if (f.mesh.position.y - ext > this.o.groundAt(f.mesh.position.x, f.mesh.position.z) + SUPPORT_GAP) this.rouse(f);
+      }
+    }
     step(f, dt, g) {
       const mesh2 = f.mesh;
       f.vel.y -= g * dt;
@@ -9629,6 +9843,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       this.markMaterial?.dispose();
       for (const g of this.shardGeos) g?.dispose();
       this.shardGeos = [];
+      for (const variants of this.shapeGeos.values()) for (const g of variants) g?.dispose();
+      this.shapeGeos.clear();
       for (const m of this.materials.values()) m.dispose();
       this.materials.clear();
     }
@@ -9738,6 +9954,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   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 SUPPORT_CHECKS2 = 16;
+  var SUPPORT_GAP2 = 0.02;
   var boxTopAt = (s, x, z) => {
     const e = s.e;
     const dx = x - s.c[0], dz = z - s.c[2];
@@ -9770,6 +9988,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       __publicField(this, "m");
       __publicField(this, "ax");
       __publicField(this, "solids", []);
+      __publicField(this, "supportTurn", 0);
       this.p = new THREE.Vector3();
       this.q = new THREE.Quaternion();
       this.dq = new THREE.Quaternion();
@@ -9865,10 +10084,10 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       return this.mulInvInertiaWith(b, this.m.elements, x, y, z);
     }
     mulInvInertiaWith(b, e, x, y, z) {
-      const [hx, hy, hz] = b.halfExtents;
+      const [hx, hy, hz2] = b.halfExtents;
       const k = 3 / b.mass;
-      const ix = k / (hy * hy + hz * hz);
-      const iy = k / (hx * hx + hz * hz);
+      const ix = k / (hy * hy + hz2 * hz2);
+      const iy = k / (hx * hx + hz2 * hz2);
       const iz = k / (hx * hx + hy * hy);
       const lx = (e[0] * x + e[1] * y + e[2] * z) * ix;
       const ly = (e[4] * x + e[5] * y + e[6] * z) * iy;
@@ -9877,11 +10096,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     }
     /** 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 [hx, hy, hz2] = 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]);
+      for (let i = 0; i < 8; i++) out.push([i & 1 ? hx : -hx, i & 2 ? hy : -hy, i & 4 ? hz2 : -hz2]);
       if (!edges) return out;
-      const h = [hx, hy, hz];
+      const h = [hx, hy, hz2];
       for (let axis2 = 0; axis2 < 3; axis2++) {
         const a1 = (axis2 + 1) % 3;
         const a2 = (axis2 + 2) % 3;
@@ -9929,6 +10148,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         const h = body.halfExtents;
         return { body, c: [c.x, c.y, c.z], e: [...new this.THREE.Matrix4().makeRotationFromQuaternion(body.root.quaternion).elements], half: h, r: Math.hypot(h[0], h[1], h[2]) };
       });
+      this.wakeUnsupported();
       for (const b of this.list) {
         if (b.held) {
           b.velocity = [0, 0, 0];
@@ -9943,6 +10163,33 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       }
       this.separate(dt);
     }
+    /** A few sleeping pieces each update (`SUPPORT_CHECKS`, in turn) look under them again: one whose table broke, or whose shelf fell over, falls. */
+    wakeUnsupported() {
+      const n = this.list.length;
+      for (let k = 0; k < Math.min(SUPPORT_CHECKS2, n); k++) {
+        this.supportTurn = (this.supportTurn + 1) % n;
+        const b = this.list[this.supportTurn];
+        if (!b.sleeping || b.held || this.supported(b, false) || this.supported(b, true)) continue;
+        b.sleeping = false;
+        b.still = 0;
+        b.calmAt = null;
+      }
+    }
+    /**
+     * Whether a point of `b` (its corners, or with `edges` the points along its edges too) has the ground, a piece or a fixed top under it. Any point, not only the lowest:
+     * a book propped on a fallen case rests by a corner high on it while its lowest one hangs beside it.
+     */
+    supported(b, edges) {
+      const c = this.centerOf(b, this.p);
+      const e = this.m.makeRotationFromQuaternion(b.root.quaternion).elements;
+      for (const [sx, sy, sz] of this.samples(b, edges)) {
+        const y = c.y + e[1] * sx + e[5] * sy + e[9] * sz;
+        const x = c.x + e[0] * sx + e[4] * sy + e[8] * sz;
+        const z = c.z + e[2] * sx + e[6] * sy + e[10] * sz;
+        if (this.supportAt(b, x, y, z, STEP) >= y - SUPPORT_GAP2) return true;
+      }
+      return false;
+    }
     /** Where a corner of `self` at `(x, y, z)` lands: the ground, the top of another piece or of something fixed under it. */
     supportAt(self, x, y, z, step) {
       let top = this.o.groundAt(x, z);
@@ -10202,8 +10449,8 @@ 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;
-          const [hx, hy, hz] = b.halfExtents;
-          const upHalf = Math.abs(e[1]) * hx + Math.abs(e[5]) * hy + Math.abs(e[9]) * hz;
+          const [hx, hy, hz2] = b.halfExtents;
+          const upHalf = Math.abs(e[1]) * hx + Math.abs(e[5]) * hy + Math.abs(e[9]) * hz2;
           if (upHalf < TIP_LYING || b.tipping.seconds <= 0) b.tipping = null;
           else {
             w[0] += b.tipping.x * TIP_ACCELERATION * h;
@@ -10316,6 +10563,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     constructor(THREE, scene2, radius = 4e-3) {
       __publicField(this, "THREE", THREE);
       __publicField(this, "scene", scene2);
+      __publicField(this, "radius", radius);
       __publicField(this, "cages", /* @__PURE__ */ new Map());
       __publicField(this, "geometry");
       __publicField(this, "material");
@@ -10344,28 +10592,62 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     meshes() {
       return [...this.cages.values()];
     }
-    /** Draw `bars` (world space) as the cage of `key`; an empty list removes it. */
-    set(key, bars) {
+    /**
+     * Draw `bars` (world space) as the cage of `key`; an empty list removes it. The cage is a child of `holder` (the drawing of the part's object, the scene
+     * by default), so it goes where the part goes: a beam that comes down takes its bare bars with it.
+     */
+    set(key, bars, holder) {
       this.remove(key);
       if (bars.length === 0) return;
+      const parent = holder ?? this.scene;
+      parent.updateWorldMatrix(true, false);
+      const toParent = new this.THREE.Matrix4().copy(parent.matrixWorld).invert();
       const mesh2 = new this.THREE.InstancedMesh(this.geometry, this.material, bars.length);
       bars.forEach(([a, b], i) => {
         this.dir.set(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
         const length = this.dir.length();
         this.mid.set((a[0] + b[0]) / 2, (a[1] + b[1]) / 2, (a[2] + b[2]) / 2);
         this.q.setFromUnitVectors(this.up, length > 1e-9 ? this.dir.divideScalar(length) : this.up);
-        this.m.compose(this.mid, this.q, this.scale.set(1, Math.max(length, 1e-4), 1));
+        this.m.compose(this.mid, this.q, this.scale.set(1, Math.max(length, 1e-4), 1)).premultiply(toParent);
         mesh2.setMatrixAt(i, this.m);
       });
       mesh2.instanceMatrix.needsUpdate = true;
       mesh2.castShadow = true;
-      this.scene.add(mesh2);
+      mesh2.name = "rebar-cage";
+      parent.add(mesh2);
       this.cages.set(key, mesh2);
     }
+    /** The cage of `from` now belongs to `to` (a part that left its object for one of its own) and hangs from `holder`, where it is in the world now. */
+    move(from, to, holder) {
+      const mesh2 = this.cages.get(from);
+      if (!mesh2) return;
+      this.cages.delete(from);
+      this.remove(to);
+      holder.attach(mesh2);
+      this.cages.set(to, mesh2);
+    }
+    /** Takes the cage of `key` away and gives its bars, where they are in the world now: centre, turn (the bar along its y) and length. */
+    take(key) {
+      const mesh2 = this.cages.get(key);
+      if (!mesh2) return [];
+      mesh2.updateWorldMatrix(true, false);
+      const bars = [];
+      for (let i = 0; i < mesh2.count; i++) {
+        mesh2.getMatrixAt(i, this.m);
+        this.m.premultiply(mesh2.matrixWorld).decompose(this.mid, this.q, this.scale);
+        bars.push({ center: [this.mid.x, this.mid.y, this.mid.z], rotation: [this.q.x, this.q.y, this.q.z, this.q.w], length: this.scale.y });
+      }
+      this.remove(key);
+      return bars;
+    }
+    /** Radius of the bars drawn, metres. */
+    get barRadius() {
+      return this.radius;
+    }
     remove(key) {
       const mesh2 = this.cages.get(key);
       if (!mesh2) return;
-      this.scene.remove(mesh2);
+      mesh2.removeFromParent();
       mesh2.dispose();
       this.cages.delete(key);
     }
@@ -10445,26 +10727,26 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     return [s.radius * 2, s.radius * 2, s.radius * 2];
   };
   var aabbOf = (s, center, q) => {
-    let hx, hy, hz;
+    let hx, hy, hz2;
     if (s.kind === "sphere") {
-      hx = hy = hz = s.radius;
+      hx = hy = hz2 = s.radius;
     } else {
       const m = quat.toMatrix(q);
       if (s.kind === "box") {
         const a = s.size[0] / 2, b = s.size[1] / 2, c = s.size[2] / 2;
         hx = Math.abs(m[0]) * a + Math.abs(m[1]) * b + Math.abs(m[2]) * c;
         hy = Math.abs(m[3]) * a + Math.abs(m[4]) * b + Math.abs(m[5]) * c;
-        hz = Math.abs(m[6]) * a + Math.abs(m[7]) * b + Math.abs(m[8]) * c;
+        hz2 = Math.abs(m[6]) * a + Math.abs(m[7]) * b + Math.abs(m[8]) * c;
       } else {
         const ax = [m[1], m[4], m[7]];
         const hh = s.height / 2;
         const e = (i) => s.radius * Math.sqrt(Math.max(0, 1 - ax[i] * ax[i])) + hh * Math.abs(ax[i]);
         hx = e(0);
         hy = e(1);
-        hz = e(2);
+        hz2 = e(2);
       }
     }
-    return { min: [center[0] - hx, center[1] - hy, center[2] - hz], max: [center[0] + hx, center[1] + hy, center[2] + hz] };
+    return { min: [center[0] - hx, center[1] - hy, center[2] - hz2], max: [center[0] + hx, center[1] + hy, center[2] + hz2] };
   };
   var FLEXURE_DEFAULTS = {
     enabled: true,
@@ -10649,6 +10931,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     },
     {
       id: "wood_soft",
+      splitForm: "slivers",
       density: 500,
       hpPerKg: 90,
       penetration: 9,
@@ -10694,6 +10977,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     },
     {
       id: "wood_hard",
+      splitForm: "slivers",
       density: 750,
       hpPerKg: 140,
       penetration: 14,
@@ -10738,6 +11022,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     },
     {
       id: "plywood",
+      splitForm: "plies",
       density: 600,
       hpPerKg: 70,
       penetration: 7,
@@ -10785,6 +11070,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     },
     {
       id: "mdf",
+      splitForm: "granules",
       density: 750,
       hpPerKg: 45,
       penetration: 6,
@@ -11296,6 +11582,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     },
     {
       id: "green_wood",
+      splitForm: "slivers",
       density: 650,
       hpPerKg: 5,
       penetration: 10,
@@ -11576,6 +11863,125 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         "brittle"
       ],
       compressive: 1e5
+    },
+    {
+      id: "mud",
+      density: 1700,
+      hpPerKg: 1,
+      penetration: 5,
+      ductility: 0.8,
+      fracture: "crumble",
+      fragmentSize: [
+        0.02,
+        0.08
+      ],
+      hitDebris: "dust",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.5,
+        heatCapacity: 3.2
+      },
+      tags: [
+        "soil",
+        "wet"
+      ],
+      compressive: 5e3
+    },
+    {
+      id: "clay",
+      density: 1800,
+      hpPerKg: 5,
+      penetration: 7,
+      ductility: 0.05,
+      fracture: "crumble",
+      fragmentSize: [
+        0.02,
+        0.1
+      ],
+      hitDebris: "chips",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.15,
+        heatCapacity: 2.2
+      },
+      tags: [
+        "soil",
+        "brittle"
+      ],
+      compressive: 6e4
+    },
+    {
+      id: "snow",
+      density: 300,
+      hpPerKg: 1,
+      penetration: 3,
+      ductility: 0.6,
+      fracture: "crumble",
+      fragmentSize: [
+        0.01,
+        0.05
+      ],
+      hitDebris: "dust",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.1,
+        heatCapacity: 2.1
+      },
+      tags: [
+        "soil",
+        "frozen"
+      ],
+      compressive: 1e3
+    },
+    {
+      id: "cobble",
+      density: 2650,
+      hpPerKg: 25,
+      penetration: 25,
+      penetrationClass: "concrete",
+      penetrationScale: 0.9,
+      ductility: 0.03,
+      fracture: "crumble",
+      fragmentSize: [
+        0.05,
+        0.15
+      ],
+      hitDebris: "chips",
+      breakDebris: "chips",
+      thermal: {
+        conductivity: 0.2,
+        heatCapacity: 2.5
+      },
+      tags: [
+        "masonry",
+        "brittle"
+      ],
+      compressive: 3e5
+    },
+    {
+      id: "paver",
+      density: 2300,
+      hpPerKg: 14,
+      penetration: 18,
+      penetrationClass: "concrete",
+      penetrationScale: 1,
+      ductility: 0.03,
+      fracture: "crumble",
+      fragmentSize: [
+        0.04,
+        0.12
+      ],
+      hitDebris: "chips",
+      breakDebris: "chips",
+      thermal: {
+        conductivity: 0.15,
+        heatCapacity: 2.5
+      },
+      tags: [
+        "masonry",
+        "brittle"
+      ],
+      compressive: 35e4
     }
   ];
   var material_hints_default = {
@@ -11714,6 +12120,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);
+  var BLAST_REFERENCE_RESISTANCE = 200 * 1900 * 0.13;
   var assemblies_default = [
     {
       id: "brick_wall_plastered",
@@ -12099,6 +12506,23 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     }
   };
   var tmpV = (THREE) => new THREE.Vector3();
+  function plainPositions(mesh2, v0, v1) {
+    const { collapsedRanges, plainPositions: plain } = mesh2.userData;
+    if (!plain || !collapsedRanges?.some(([a, b]) => a < v1 && b > v0)) return null;
+    return plain;
+  }
+  function showCollapsedRanges(mesh2) {
+    const data = mesh2.userData;
+    const plain = data.plainPositions;
+    const position = mesh2.geometry?.getAttribute(POS_ATTR);
+    if (!plain || !data.collapsedRanges?.length || !position) return;
+    const array = position.array;
+    for (const [v0, v1] of data.collapsedRanges) array.set(plain.subarray(v0 * 3, v1 * 3), v0 * 3);
+    data.collapsedRanges = [];
+    position.needsUpdate = true;
+    mesh2.geometry.computeBoundingBox();
+    mesh2.geometry.computeBoundingSphere();
+  }
   var MIN_DENT_VERTICES = 10;
   var WIDEN_MARGIN = 1.1;
   var SKIN_FOLLOW = 0.85;
@@ -12864,7 +13288,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         const a = src.getAttribute(name);
         if (a.isInterleavedBufferAttribute) continue;
         const size = a.itemSize;
-        const from = (name === POS_ATTR ? host.work : null) ?? a.array;
+        const from = (name === POS_ATTR ? plainPositions(host.mesh, v0, v1) ?? host.work : null) ?? a.array;
         const slice = from.slice(v0 * size, v1 * size);
         const Ctor = a.array.constructor;
         geo.setAttribute(name, new this.THREE.BufferAttribute(new Ctor(slice), size, a.normalized));
@@ -13022,11 +13446,29 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   // src/renderer.ts
   var rendererCount = 0;
   var COLLAPSE_CLOUD_KG = 1e3;
+  var REBAR_COLOR = 7628380;
+  var STEEL_DENSITY = 7850;
   var CHIP_DECAL_EDGE = 0.05;
   var WOOD_RIM = 1.5;
   var IMPACT_TAGS = ["metal", "glass", "wood"];
   var GLOW_FROM_C = 430;
   var QUEUE_CAP = 4e3;
+  var STRUCTURAL_EVENTS = /* @__PURE__ */ new Set([
+    "fracture",
+    "detach",
+    "collapse",
+    "settle",
+    "destroyed",
+    "expose",
+    "stage",
+    "hole",
+    "ignite",
+    "primed",
+    "extinguish",
+    "burnout",
+    "leak",
+    "explode"
+  ]);
   var MIN_FRAGMENTS_PER_SLICE = 8;
   var STATIC_REFRESH = 0.5;
   var STATIC_REFRESH_SLICE_MS = 1;
@@ -13135,6 +13577,8 @@ 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", []);
+      /** The cover of each body around a part of the world that went off, read as the event is emitted: before the blast tore or moved anything. */
+      __publicField(this, "coverWhenWentOff", /* @__PURE__ */ new WeakMap());
       /** 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 a drain, where a call finishes what it started. */
@@ -13214,7 +13658,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         groundAt: this.groundAt,
         gravity: this.gravity,
         max: this.maxFragments,
-        life: o.fragmentLife ?? 12
+        life: o.fragmentLife ?? 12,
+        formOf: (id) => this.world.materials.get(id)?.splitForm
       });
       this.cages = new RebarCages(THREE, o.scene);
       this.pieceSys = new PieceSystem(THREE, {
@@ -13227,7 +13672,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         onSlam: (p, hit, speed) => this.slam(p, hit, speed)
       });
       this.unsubscribe = this.world.on("*", (ev) => {
-        if (this.queue.length < QUEUE_CAP) this.queue.push(ev);
+        if (ev.type === "explode") this.coverWhenWentOff.set(ev, this.coverAround(ev));
+        if (this.queue.length < QUEUE_CAP || STRUCTURAL_EVENTS.has(ev.type)) this.queue.push(ev);
       });
     }
     // ----------------------------------------------------------------------------------------------------------------------------------
@@ -13750,7 +14196,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           this.onChip(ev);
           break;
         case "expose":
-          this.cages.set(`${ev.object}|${ev.part}`, ev.bars);
+          if (ev.bars.length > 0) this.cages.set(`${ev.object}|${ev.part}`, ev.bars, this.bounds.get(ev.object)?.root);
+          else this.dropCage(ev.object, ev.part);
           if (ev.bars.length > 0) {
             const [a, b] = ev.bars[0];
             this.playEvent({ kind: "expose" }, [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2, (a[2] + b[2]) / 2]);
@@ -14048,7 +14495,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       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.vfx.burst("dust", ev.center, [0, 1, 0], ev.units ? Math.min(40, 8 + ev.units.length) : 8, ev.units ? 1.6 : 0.8, { color });
       this.impactSound(pv?.material ?? "", ev.center, 0.7, ev.blow);
     }
     onFracture(ev) {
@@ -14067,6 +14514,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         this.visuals.hide(pv, "broken");
       }
       this.spawnFragments(ev, 0, { def, color, opacity, transparent });
+      this.loosenIfFootless(ev.object);
       const up = [0, 1, 0];
       const sizeK = clamp6(ev.fragments.length / 10, 0.5, 2);
       switch (ev.style) {
@@ -14112,6 +14560,33 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       this.sound("detach", this.rootPoint(ev.object), 0.5);
       this.splitLoose(ev.object);
     }
+    /**
+     * The cage of a part gave way (`expose` with no bars): nothing holds its bars any more, so each comes down where it is, as steel debris that stays on the
+     * ground with a body (`FragmentSystem.spawn` with `lasting`), not as bars left standing in the air.
+     */
+    dropCage(objectId, partId) {
+      const bars = this.cages.take(`${objectId}|${partId}`);
+      if (bars.length === 0) return;
+      const radius = this.cages.barRadius;
+      const density = this.world.materials.get("steel")?.density ?? STEEL_DENSITY;
+      const material = this.fragments.materialFor("steel", REBAR_COLOR, false);
+      const rnd2 = createRng(hashString(`${objectId}|${partId}`));
+      bars.forEach((bar, i) => {
+        const fragment = {
+          id: `${partId}#bar${i}`,
+          part: partId,
+          material: "steel",
+          shape: "chunk",
+          center: bar.center,
+          size: [2 * radius, bar.length, 2 * radius],
+          rotation: bar.rotation,
+          velocity: [(rnd2() - 0.5) * 0.4, 0, (rnd2() - 0.5) * 0.4],
+          angularVelocity: [(rnd2() - 0.5) * 1.5, (rnd2() - 0.5) * 0.5, (rnd2() - 0.5) * 1.5],
+          mass: density * Math.PI * radius * radius * bar.length
+        };
+        this.fragments.spawn(fragment, material, objectId, this.maxFragments, true);
+      });
+    }
     /** Turn every loose group of the object (a detach, a collapse) into a piece of its own. */
     splitLoose(objectId) {
       if (!this.autoSplit) return;
@@ -14166,10 +14641,12 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         if (!pv) continue;
         from.parts.delete(p.id);
         nb.parts.set(p.id, pv);
+        this.cages.move(`${from.id}|${p.id}`, `${newId}|${p.id}`, group);
         for (const mv of pv.meshes) {
           if (mv.host && !mv.loose) this.visuals.extract(mv, group);
           else {
             group.attach(mv.mesh);
+            showCollapsedRanges(mv.mesh);
             mv.moved = true;
           }
         }
@@ -14196,6 +14673,45 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       if (kitOriginOf(from.root)?.kind === "furniture") this.tipIfTopHeavy(nb);
       this.o.onPiece?.(piece);
     }
+    /**
+     * Furniture that lost what it stood on falls: with every leg of a table broken the top is loose, and with the legs of one side gone what is left topples. Feet are the
+     * meshes at the bottom of the object as it was whole; while the ones left still span the same floor (a cupboard with a broken door, a table missing one leg) it stands.
+     */
+    loosenIfFootless(objectId) {
+      const b = this.bounds.get(objectId);
+      if (!b || !this.autoSplit) return;
+      const left = this.meshesOf(b).filter((mv) => this.visuals.shown(mv));
+      if (left.length === 0) return;
+      const body = b.piece ?? this.pieceSys.get(objectId);
+      if (body) {
+        const { half, center } = this.measure(b.root, left);
+        body.halfExtents = half;
+        this.pieceSys.setCenter(body, center);
+        body.mass = Math.max(0.05, this.massOf(objectId));
+        body.sleeping = false;
+        return;
+      }
+      if (kitOriginOf(b.root)?.kind !== "furniture") return;
+      const boxOf = (mv) => this.visuals.worldBox(mv, new this.THREE.Box3());
+      const whole = [...b.parts.values()].flatMap((pv) => pv.meshes).map(boxOf).filter((one) => !one.isEmpty());
+      const floor2 = Math.min(...whole.map((one) => one.min.y));
+      const feetOf = (boxes) => boxes.filter((one) => one.min.y < floor2 + FEET_BAND).reduce((feet, one) => feet.union(one), new this.THREE.Box3());
+      const was = feetOf(whole);
+      const now = feetOf(left.map(boxOf).filter((one) => !one.isEmpty()));
+      const same = !now.isEmpty() && now.min.x <= was.min.x + FEET_BAND && now.max.x >= was.max.x - FEET_BAND && now.min.z <= was.min.z + FEET_BAND && now.max.z >= was.max.z - FEET_BAND;
+      if (same) return;
+      if (!now.isEmpty()) {
+        const box = left.map(boxOf).reduce((all, one) => all.union(one), new this.THREE.Box3());
+        const centreX = (box.min.x + box.max.x) / 2;
+        const centreZ = (box.min.z + box.max.z) / 2;
+        const height = box.max.y - box.min.y;
+        const narrow = height >= TIP_MIN_HEIGHT && Math.min(now.max.x - now.min.x, now.max.z - now.min.z) < TIP_NARROW * height;
+        if (!narrow && centreX > now.min.x && centreX < now.max.x && centreZ > now.min.z && centreZ < now.max.z) return;
+      }
+      const piece = this.makePiece(objectId);
+      this.tipIfTopHeavy(b);
+      this.o.onLoosened?.(objectId, piece, "apart");
+    }
     /**
      * A piece of furniture standing on feet too close for its height (a board on two legs in a line, a lone leg) does not stay up: the box of a piece hides that its weight is up
      * high and its feet are thin, so it gets the start of the fall, across the line of its feet.
@@ -14227,7 +14743,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       const report = options.report;
       const confinement = report?.find((r) => r.blast !== void 0)?.blast?.confinement ?? 1;
       const energy = ev.energy * confinement;
-      const reachOf = (objectId, at3) => report?.find((r) => r.object === objectId)?.blast?.shelter ?? this.world.blastReach?.(p, at3, { ignore: ev.object ? [ev.object, objectId] : [objectId] }) ?? 1;
+      const wentOff = this.coverWhenWentOff.get(ev);
+      const reachOf = (objectId, at3) => report?.find((r) => r.object === objectId)?.blast?.shelter ?? wentOff?.get(objectId) ?? this.world.blastReach?.(p, at3, { ignore: ev.object ? [ev.object, objectId] : [objectId] }) ?? 1;
       const shove = (pc) => {
         this.pieceSys.centerOf(pc, c);
         if (c.distanceTo(this.v2.set(p[0], p[1], p[2])) > ev.radius) return;
@@ -14247,6 +14764,29 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         ...report ? { confinement } : {}
       });
     }
+    /** The cover between a part of the world that goes off and the centre of each piece and each shoveable body within its radius, as the world stands at that moment. */
+    coverAround(ev) {
+      const cover = /* @__PURE__ */ new Map();
+      const reach = this.world.blastReach;
+      if (!reach) return cover;
+      const point = new this.THREE.Vector3(ev.point[0], ev.point[1], ev.point[2]);
+      const centre = new this.THREE.Vector3();
+      const read = (objectId) => {
+        if (centre.distanceTo(point) <= ev.radius) cover.set(objectId, reach.call(this.world, ev.point, [centre.x, centre.y, centre.z], { ignore: [ev.object, objectId] }));
+      };
+      for (const pc of this.pieceSys.list) {
+        this.pieceSys.centerOf(pc, centre);
+        read(pc.objectId);
+      }
+      const shoveable = this.o.shoveable;
+      if (!shoveable) return cover;
+      for (const b of this.bounds.values()) {
+        if (b.piece || cover.has(b.id) || !shoveable(b.id) || !this.world.has(b.id)) continue;
+        centre.copy(this.measure(b.root, this.meshesOf(b)).center).applyQuaternion(b.root.quaternion).add(b.root.position);
+        read(b.id);
+      }
+      return cover;
+    }
     /** The bound objects without a piece that the host lets a blast move (`shoveable`): the ones it reaches with enough speed become pieces and get the shove. */
     loosen(point, radius, energy, reachOf) {
       const shoveable = this.o.shoveable;
@@ -14542,7 +15082,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     }
   };
 
-  // ../game-audio/dist/chunk-KBTUANNG.js
+  // ../game-audio/dist/chunk-C2K7XN2K.js
   var DISTANCE_CURVES = {
     /** The game's `sfx`: `vol / (1 + d² × 0.004)`, cutoff `/ (1 + d × 0.01)`, silent below 0.01 (jogo L62091–62092, L62101). */
     game_sfx: { model: "inverse_square", k: 4e-3, cutoffK: 0.01, minGain: 0.01 },
@@ -14759,7 +15299,22 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       ["smg_45_auto", 2, "sfx_pistol"],
       ["weapon_draw", 2],
       ["suppressor_attach", 3],
-      ["suppressor_detach", 3]
+      ["suppressor_detach", 3],
+      ["minigun_loop", 3],
+      ["smg_5_7x28", 3],
+      ["mg_belt_adjust", 3],
+      ["mg_belt_box_attach", 3],
+      ["mg_cover_open", 3],
+      ["mg_cover_close", 3],
+      ["weapon_holster", 3],
+      ["scope_zoom", 3]
+    ]),
+    ...entries("impactos", [
+      ["knife_hit_wall", 3],
+      ["helmet_hit", 3],
+      ["vest_hit", 3],
+      ["headshot", 3],
+      ["blood_squirt", 3]
     ]),
     ...entries("explosoes-fogo", [
       ["explosion_grenade", 1, "boom"],
@@ -14777,7 +15332,13 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       ["grenade_bounce", 1],
       ["c4_plant", 2],
       ["c4_beep", 2],
-      ["c4_disarm", 2]
+      ["c4_disarm", 2],
+      ["c4_disarming_loop", 3],
+      ["c4_remote_detonate", 3],
+      ["smoke_grenade_hiss", 3],
+      ["grenade_pin_pull", 3],
+      ["electric_shock", 3],
+      ["electric_spark", 3]
     ]),
     ...entries("personagem", [
       ["footstep_concrete_walk", 1, "sfx_step"],
@@ -14805,7 +15366,13 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       ["zombie_attack", 1],
       ["zombie_pain", 1],
       ["zombie_claw_hit", 1, "sfx_flesh"],
-      ["zombie_claw_miss", 2]
+      ["zombie_claw_miss", 2],
+      ["swing_whoosh", 3],
+      ["heartbeat_critical", 3],
+      ["fall_water", 3],
+      ["fall_damage", 3],
+      ["fall_scream", 3],
+      ["footstep_glass_walk", 3]
     ]),
     ...entries("veiculos", [
       ["engine_loop_car", 1],
@@ -14815,7 +15382,12 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       ["car_door_open", 1, "latch"],
       ["car_door_close", 1, "shut_metal"],
       ["horn_car", 2, "horn"],
-      ["tire_skid_asphalt", 2]
+      ["tire_skid_asphalt", 2],
+      ["jet_flyby", 3],
+      ["helicopter_turbine", 3],
+      ["tire_burnout", 3],
+      ["handbrake_turn", 3],
+      ["siren_police", 3]
     ]),
     ...entries("itens-portas", [
       ["item_pickup_metal", 1],
@@ -14826,7 +15398,27 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       ["door_creak", 1, "creak_wood"],
       ["door_locked_rattle", 1, "rattle"],
       ["drawer_open", 2, "slide"],
-      ["fridge_close", 2, "shut_metal"]
+      ["fridge_close", 2, "shut_metal"],
+      ["inventory_open", 3],
+      ["inventory_close", 3],
+      ["inventory_select", 3],
+      ["inventory_place", 3],
+      ["pickup_chime", 3],
+      ["item_pickup_coins", 3],
+      ["bandage_use", 3],
+      ["bandage_refuse", 3],
+      ["flashlight_toggle", 3],
+      ["gear_draw", 3],
+      ["gear_holster", 3],
+      ["button_press", 3],
+      ["lock_desk_open", 3],
+      ["elevator_move_loop", 3],
+      ["elevator_stop", 3],
+      ["door_sliding", 3],
+      ["door_kick", 3],
+      ["door_wood_break", 3],
+      ["gate_iron_open", 3],
+      ["gate_iron_close", 3]
     ]),
     ...entries("ambiente", [
       ["rain_loop", 2],
@@ -14834,7 +15426,16 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       ["thunder_near", 2],
       ["thunder_far", 2],
       ["water_splash", 2],
-      ["helicopter_loop", 3]
+      ["helicopter_loop", 3],
+      ["bird_flush", 3],
+      ["dog_growl", 3],
+      ["dog_whimper", 3],
+      ["dog_howl", 3],
+      ["zombie_dog_bark", 3],
+      ["zombie_dog_howl_far", 3],
+      ["insect_squash", 3],
+      ["insect_crawl", 3],
+      ["fan_loop", 3]
     ])
   ];
   var SFX_MATERIALS = [
@@ -14970,6 +15571,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     }
     return { id: options.id, samples };
   }
+  var CATALOG = new Map([...SFX_CATALOG, ...SFX_IMPACTS].map((entry) => [entry.id, entry]));
   var PT = {
     group: "Som",
     name: "Painel de som (arquivos e C1\u2013C10)",
@@ -15044,9 +15646,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     strengths: { light: "leve", medium: "m\xE9dio", heavy: "forte" },
     states: { file: "A", synth: "S", missing: "F" },
     criteria: { C1: "C1 Sincronia", C2: "C2 Certo p/ a\xE7\xE3o", C3: "C3 Dist\xE2ncia", C4: "C4 Posi\xE7\xE3o", C5: "C5 Varia\xE7\xE3o", C6: "C6 Volume", C7: "C7 Intensidade", C8: "C8 Cauda", C9: "C9 Rajada", C10: "C10 Escuta" },
-    metrics: { source: "1 \xB7 Fonte do que tocou", chosen: "1 \xB7 Escolhido", matrix: "2 \xB7 Matriz", last: "\xDAltimo tocado", ab: "4 \xB7 A \xD7 B", blind: "4 \xB7 X", verdicts: "4 \xB7 Prefer\xEAncias", state: "5 \xB7 Medi\xE7\xE3o", count: "1 \xB7 Cat\xE1logo" },
+    metrics: { source: "1 \xB7 Fonte do que tocou", chosen: "1 \xB7 Escolhido", matrix: "2 \xB7 Matriz", last: "\xDAltimo tocado", ab: "4 \xB7 A \xD7 B", blind: "4 \xB7 X", verdicts: "4 \xB7 Prefer\xEAncias", state: "5 \xB7 Medi\xE7\xE3o", count: "1 \xB7 Cat\xE1logo", unlicensed: "1 \xB7 Arquivo sem licen\xE7a" },
     run: { idle: "parada", measuring: "medindo\u2026", done: "pronta", failed: "falhou", recording: "gravando\u2026", recorded: "grava\xE7\xE3o baixada" },
-    words: { none: "\u2014", hidden: "? (revele)", prefers: "prefere", approved: "aprovado pelo dono" },
+    words: { none: "\u2014", hidden: "? (revele)", prefers: "prefere", approved: "aprovado pelo dono", local_file: "arquivo do pacote local", sdk_file: "grava\xE7\xE3o do SDK", synth: "s\xEDntese do SDK" },
     sources: { sdk: "SDK", user: "seu som", synth: "sintetizado" },
     probe: "Fonte do som",
     wall: "Parede (oclus\xE3o)",
@@ -15117,9 +15719,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     environments: { indoor: "indoor", outdoor: "outdoor" },
     strengths: { light: "light", medium: "medium", heavy: "heavy" },
     criteria: { C1: "C1 Sync", C2: "C2 Right sound", C3: "C3 Distance", C4: "C4 Position", C5: "C5 Variation", C6: "C6 Level", C7: "C7 Strength", C8: "C8 Tail", C9: "C9 Burst", C10: "C10 Listening" },
-    metrics: { source: "1 \xB7 Source of what played", chosen: "1 \xB7 Chosen", matrix: "2 \xB7 Matrix", last: "Last played", ab: "4 \xB7 A \xD7 B", blind: "4 \xB7 X", verdicts: "4 \xB7 Preferences", state: "5 \xB7 Measurement", count: "1 \xB7 Catalogue" },
+    metrics: { source: "1 \xB7 Source of what played", chosen: "1 \xB7 Chosen", matrix: "2 \xB7 Matrix", last: "Last played", ab: "4 \xB7 A \xD7 B", blind: "4 \xB7 X", verdicts: "4 \xB7 Preferences", state: "5 \xB7 Measurement", count: "1 \xB7 Catalogue", unlicensed: "1 \xB7 File without licence" },
     run: { idle: "idle", measuring: "measuring\u2026", done: "done", failed: "failed", recording: "recording\u2026", recorded: "recording downloaded" },
-    words: { none: "\u2014", hidden: "? (reveal)", prefers: "prefers", approved: "approved by the owner" },
+    words: { none: "\u2014", hidden: "? (reveal)", prefers: "prefers", approved: "approved by the owner", local_file: "local pack file", sdk_file: "SDK recording", synth: "SDK synthesis" },
     sources: { sdk: "SDK", user: "your sound", synth: "synthesized" },
     probe: "Sound source",
     wall: "Wall (occlusion)",
@@ -15202,6 +15804,66 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       sources: [`cena:${line}`]
     };
   }
+  var hz = (midi) => 440 * 2 ** ((midi - 69) / 12);
+  var layer2 = (note, beat, wave, level) => {
+    const [at3, midi, beats] = note;
+    const length = beats * beat;
+    return {
+      at: at3 * beat,
+      duration: length,
+      source: { kind: "osc", wave, frequency: { set: hz(midi) } },
+      envelope: [[0, 1e-4, "set"], [0.01, level, "linear"], [Math.max(0.02, length * 0.9), level * 0.35, "linear"], [length, 1e-4, "exp", "fixed"]]
+    };
+  };
+  function radioTrack(spec) {
+    const beat = 60 / spec.bpm;
+    const recipes = Array.from({ length: spec.bars }, (_, bar) => {
+      const inBar = (notes) => notes.filter((n) => n[0] >= bar * 4 && n[0] < bar * 4 + 4).map((n) => [n[0] - bar * 4, n[1], n[2]]);
+      const layers = [
+        ...inBar(spec.bass).map((n) => layer2(n, beat, "triangle", 0.16)),
+        ...inBar(spec.chords).map((n) => layer2(n, beat, "sine", 0.05)),
+        ...inBar(spec.melody).map((n) => layer2(n, beat, spec.wave, 0.07))
+      ];
+      return { id: `${spec.id}_${bar}`, bus: "world", duration: 4 * beat, layers, falloff: { model: "none" } };
+    });
+    return { song: { id: spec.id, barSeconds: 4 * beat, bars: recipes.map((r) => r.id) }, recipes };
+  }
+  var chord = (bar, root, minor = false) => [[bar * 4, root, 4], [bar * 4, root + (minor ? 3 : 4), 4], [bar * 4, root + 7, 4]];
+  var bassLine = (roots, pattern) => roots.flatMap((root, bar) => pattern.map((b) => [bar * 4 + b, root - 12, 0.9]));
+  var TRACKS = [
+    // a bright pop loop: I–V–vi–IV in C
+    radioTrack({
+      id: "radio_track_pop",
+      bpm: 112,
+      bars: 4,
+      wave: "square",
+      bass: bassLine([48, 55, 57, 53], [0, 1.5, 2, 3]),
+      chords: [...chord(0, 60), ...chord(1, 55), ...chord(2, 57, true), ...chord(3, 53)],
+      melody: [[0, 76, 1], [1, 74, 0.5], [1.5, 72, 1.5], [4, 74, 1], [5, 76, 1], [6, 79, 2], [8, 76, 1], [9, 74, 1], [10, 72, 2], [12, 72, 1], [13, 74, 1], [14, 72, 2]]
+    }),
+    // a syncopated loop in A minor, the bass on the off-beats
+    radioTrack({
+      id: "radio_track_groove",
+      bpm: 100,
+      bars: 4,
+      wave: "triangle",
+      bass: bassLine([57, 62, 64, 57], [0, 0.75, 1.5, 2.5, 3.25]),
+      chords: [...chord(0, 57, true), ...chord(1, 62, true), ...chord(2, 64), ...chord(3, 57, true)],
+      melody: [[0.5, 72, 0.5], [1.25, 76, 0.75], [2.5, 74, 1], [4.5, 77, 0.5], [5.25, 74, 0.75], [6.5, 72, 1.5], [8.5, 71, 0.5], [9.25, 74, 0.75], [10.5, 76, 1.5], [12.5, 72, 0.5], [13.25, 69, 2]]
+    }),
+    // a slow blues-like loop in F with a swung melody
+    radioTrack({
+      id: "radio_track_slow",
+      bpm: 76,
+      bars: 4,
+      wave: "sine",
+      bass: bassLine([53, 58, 53, 60], [0, 2]),
+      chords: [...chord(0, 65), ...chord(1, 58), ...chord(2, 65), ...chord(3, 60)],
+      melody: [[0, 72, 1.5], [1.67, 75, 0.33], [2, 77, 2], [4, 74, 1], [5, 72, 1], [6, 70, 2], [8, 72, 1.5], [9.67, 69, 0.33], [10, 65, 2], [12, 67, 1], [13, 70, 1], [14, 72, 2]]
+    })
+  ];
+  var RADIO_TRACKS = TRACKS.map((t) => t.song);
+  var RADIO_BANK = { id: "vehicle_radio", sounds: TRACKS.flatMap((t) => t.recipes), loops: [] };
   var FOLEY_FALLOFF = {
     model: "inverse_square",
     k: 0.02,
@@ -15808,11 +16470,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       ...s.splash ? [sceneNoise({ type: "bandpass", f: s.splash.f * take.f, f2: s.splash.f2 * take.f, q: 1.4, d: s.splash.d * take.t * weight ** 0.4, vol: s.splash.vol * gait.vol * take.v * weight ** 0.5 })] : []
     ];
   }
-  var quieter = (level, layers) => layers.map((layer2) => {
-    const gain = layer2.gain ?? 1;
-    if (typeof gain === "number") return { ...layer2, gain: gain * level };
-    if (Array.isArray(gain)) return { ...layer2, gain: [gain[0] * level, gain[1] * level] };
-    return layer2;
+  var quieter = (level, layers) => layers.map((layer22) => {
+    const gain = layer22.gain ?? 1;
+    if (typeof gain === "number") return { ...layer22, gain: gain * level };
+    if (Array.isArray(gain)) return { ...layer22, gain: [gain[0] * level, gain[1] * level] };
+    return layer22;
   });
   var recipe = (id, layers, falloff, bus = "world") => ({ id, bus, pan: true, layers, falloff, sources: ["sdk"] });
   var takeId = (id, index) => `${id}_${String(index + 1).padStart(2, "0")}`;
@@ -15828,7 +16490,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     (take) => quieter(LANDING_LEVEL, [
       // both feet, a hair apart, then the knees taking the weight (a low body thump) and the clothes settling
       ...footLayers(surface, take, GAITS.run, LANDINGS[landing2].weight),
-      ...footLayers(surface, { ...take, v: take.v * 0.6 }, GAITS.run, LANDINGS[landing2].weight * 0.6).map((layer2) => ({ ...layer2, at: (typeof layer2.at === "number" ? layer2.at : 0) + 0.018 * take.t })),
+      ...footLayers(surface, { ...take, v: take.v * 0.6 }, GAITS.run, LANDINGS[landing2].weight * 0.6).map((layer22) => ({ ...layer22, at: (typeof layer22.at === "number" ? layer22.at : 0) + 0.018 * take.t })),
       sceneTone({ f: 60 * take.f, f2: 38, d: 0.14 * LANDINGS[landing2].weight * take.t, vol: 0.22 * LANDINGS[landing2].weight ** 0.7 * take.v, delay: 0.02 }),
       sceneNoise({ type: "bandpass", f: [1800, 2600], q: 0.8, d: 0.18, vol: LANDINGS[landing2].cloth * take.v, delay: 0.04 })
     ]),
@@ -15874,7 +16536,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     fall_damage: (take) => [
       ...BODY.body_fall(take),
       sceneNoise({ type: "highpass", f: 2800, d: 0.02, vol: 0.35 * take.v, delay: 0.01 }),
-      ...voice({ f0: 170, f1: 110, d: 0.32, fA: 650, fB: 1150, noise: 0.25, vol: 0.32 })(take).map((layer2) => ({ ...layer2, at: 0.08 }))
+      ...voice({ f0: 170, f1: 110, d: 0.32, fA: 650, fB: 1150, noise: 0.25, vol: 0.32 })(take).map((layer22) => ({ ...layer22, at: 0.08 }))
     ],
     player_hurt: voice({ f0: 150, f1: 105, d: 0.26, fA: 620, fB: 1100, noise: 0.3, vol: 0.35 }),
     player_breath_run: (take) => [