@adatechnology/game-destruction-three 0.12.1 → 0.13.0

package/dist/index.global.js

@@ -55,6 +55,39 @@ var GameDestructionThree = (() => {
     const length = Math.hypot(direction[0], direction[1], direction[2]);
     return { speed, direction: [direction[0] / length, direction[1] / length, direction[2] / length], distance, falloff };
   }
+  var DEFAULT_COST_ALLOCATION_BYTES = 1024 * 1024;
+  var DEFERRED_QUEUE_ID = {
+    DESTRUCTION_EVENTS: "destruction.events",
+    BREACH_PAINT: "floorplan.breach-paint",
+    AUDIO_VOICES: "audio.voices",
+    VEHICLE_CREASE: "vehicles.crease"
+  };
+  var DEFERRED_PRIORITY = {
+    [DEFERRED_QUEUE_ID.DESTRUCTION_EVENTS]: { priority: 300, phase: "present" },
+    [DEFERRED_QUEUE_ID.BREACH_PAINT]: { priority: 250, phase: "present" },
+    [DEFERRED_QUEUE_ID.AUDIO_VOICES]: { priority: 200, phase: "idle", reserveMs: 1 },
+    [DEFERRED_QUEUE_ID.VEHICLE_CREASE]: { priority: 100, phase: "idle" }
+  };
+  var WARNED_KEY = /* @__PURE__ */ Symbol.for("@adatechnology/game-contracts.warned");
+  var warnedKeys = () => {
+    const holder = globalThis;
+    return holder[WARNED_KEY] ?? (holder[WARNED_KEY] = /* @__PURE__ */ new Set());
+  };
+  var isProduction = () => {
+    try {
+      return process.env.NODE_ENV === "production";
+    } catch {
+      return false;
+    }
+  };
+  var isQuiet = () => globalThis.__GAME_KIT_QUIET__ === true;
+  var warnOnce = (key, message) => {
+    if (isQuiet() || isProduction()) return;
+    const seen = warnedKeys();
+    if (seen.has(key)) return;
+    seen.add(key);
+    console.warn(`[game-kit] ${message}`);
+  };
   var KIT_ORIGIN_KEY = "kitOrigin";
   function markKitOrigin(object, origin) {
     const node = object;
@@ -69,6 +102,43 @@ var GameDestructionThree = (() => {
     }
     return null;
   }
+  var SURFACE_IDS = ["concrete", "asphalt", "wood", "tile", "dirt", "grass", "gravel", "sand", "metal", "water", "glass", "carpet"];
+  var GAIT_IDS = ["walk", "run"];
+  var LANDING_IDS = ["light", "heavy"];
+  var BODY_SOUND_IDS = [
+    "jump",
+    "cloth_rustle",
+    "body_fall",
+    "fall_damage",
+    "player_hurt",
+    "player_breath_run",
+    "player_death",
+    "bite",
+    "grab",
+    "punch_swing",
+    "punch_hit_body",
+    "punch_hit_face",
+    "punch_hit_object",
+    "kick_swing",
+    "kick_hit",
+    "kick_hit_object",
+    "shove_two_hands",
+    "knife_swing",
+    "knife_stab",
+    "knife_slash",
+    "knife_hit_object",
+    "blunt_swing",
+    "blunt_hit",
+    "blunt_hit_object",
+    "axe_swing",
+    "axe_chop",
+    "axe_hit_object"
+  ];
+  var footstepSoundId = (surface, gait) => `footstep_${surface}_${gait}`;
+  var FOOTSTEP_SOUND_IDS = SURFACE_IDS.flatMap((surface) => GAIT_IDS.map((gait) => footstepSoundId(surface, gait)));
+  var LAND_SOUND_IDS = SURFACE_IDS.flatMap((surface) => LANDING_IDS.map((landing2) => `land_${surface}_${landing2}`));
+  var BODY_FOLEY_IDS = [...FOOTSTEP_SOUND_IDS, ...LAND_SOUND_IDS, ...BODY_SOUND_IDS];
+  var SWING_LEAD_SECONDS = { punch: 0.07, kick: 0.09, shove: 0, blade: 0.05, blunt: 0.1, chop: 0.11 };
 
   // ../game-vfx/dist/index.js
   var __defProp2 = Object.defineProperty;
@@ -2564,22 +2634,22 @@ var GameDestructionThree = (() => {
       )
     ]
   };
-  function normalized(vector) {
-    const length = Math.sqrt(vector[0] * vector[0] + vector[1] * vector[1] + vector[2] * vector[2]) || 1;
+  function normalized(vector2) {
+    const length = Math.sqrt(vector2[0] * vector2[0] + vector2[1] * vector2[1] + vector2[2] * vector2[2]) || 1;
     const inverse = 1 / length;
-    return [vector[0] * inverse, vector[1] * inverse, vector[2] * inverse];
+    return [vector2[0] * inverse, vector2[1] * inverse, vector2[2] * inverse];
   }
-  function plus(vector, x, y, z) {
-    return [vector[0] + x, vector[1] + y, vector[2] + z];
+  function plus(vector2, x, y, z) {
+    return [vector2[0] + x, vector2[1] + y, vector2[2] + z];
   }
-  function scaledBy(vector, factor) {
-    return [vector[0] * factor, vector[1] * factor, vector[2] * factor];
+  function scaledBy(vector2, factor) {
+    return [vector2[0] * factor, vector2[1] * factor, vector2[2] * factor];
   }
-  function plusScaled(vector, direction, factor) {
-    return [vector[0] + direction[0] * factor, vector[1] + direction[1] * factor, vector[2] + direction[2] * factor];
+  function plusScaled(vector2, direction, factor) {
+    return [vector2[0] + direction[0] * factor, vector2[1] + direction[1] * factor, vector2[2] + direction[2] * factor];
   }
-  function negated(vector) {
-    return [-vector[0], -vector[1], -vector[2]];
+  function negated(vector2) {
+    return [-vector2[0], -vector2[1], -vector2[2]];
   }
   var FRAME_DUST = normalized([0, -0.3, 1]);
   var SPLINTER_DIRECTION = normalized([0, 0.3, 1]);
@@ -3882,9 +3952,32 @@ var GameDestructionThree = (() => {
     /** The leak caught fire (an incendiary or tracer round, a spark, a fire near): the page's whole sequence, the fire running along the pool to the tank and the blast. */
     aliasOf(FUEL_LEAK, "vehicle_leak_ignited", {})
   ];
+  var vector = [variable("vx"), variable("vy"), variable("vz")];
+  var range = (name) => [variable(name), variable(name)];
+  var singleParticle = (id, system) => ({
+    id,
+    pageId: `particle:${id}`,
+    team: "world",
+    budget: { particles: 1, lights: 0 },
+    loop: 1e-3,
+    timeline: [
+      spawn(system, {
+        p: [0, 0, 0],
+        v: vector,
+        life: range("life"),
+        size: range("size"),
+        grow: variable("grow"),
+        c0: variable("color"),
+        a: variable("alpha"),
+        g: variable("gravity"),
+        drag: variable("drag")
+      })
+    ]
+  });
+  var SINGLE_PARTICLE_EFFECTS = [singleParticle("particle_puff", "normal"), singleParticle("particle_glow", "add"), singleParticle("particle_streak", "streak")];
   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 GAME_EFFECTS = { ...WORKSHOP_EFFECTS, ...Object.fromEntries([...EVENT_EFFECTS, ...VIEWMODEL_EFFECTS, ...VEHICLE_EFFECTS, ...SINGLE_PARTICLE_EFFECTS].map((effect) => [effect.id, effect])) };
   var TABLE = {
     concrete: { dust: 9078138, chip: 7236195, spark: 2 },
     metal: { dust: 0, chip: 0, spark: 18 },
@@ -4554,8 +4647,8 @@ var GameDestructionThree = (() => {
   var UP12 = [0, 1, 0];
   var ZERO = [0, 0, 0];
   var FULL_TURN_DRAWN = 6.283;
-  function scaledSizes(range, factor) {
-    return [range[0] * Math.sqrt(factor), range[1] * Math.sqrt(factor)];
+  function scaledSizes(range2, factor) {
+    return [range2[0] * Math.sqrt(factor), range2[1] * Math.sqrt(factor)];
   }
   function fireEmit(engine, key, dt, centre, radius, factor, options = {}) {
     const wind = options.wind ?? ZERO;
@@ -6409,9 +6502,9 @@ var GameDestructionThree = (() => {
   var TWO_PI_ROUNDED = 6.2832;
   var WIDE_CONE = 3.1;
   var UP13 = [0, 1, 0];
-  function drawRange(random, range) {
-    if (Array.isArray(range)) return random.between(range[0], range[1]);
-    return range || 0;
+  function drawRange(random, range2) {
+    if (Array.isArray(range2)) return random.between(range2[0], range2[1]);
+    return range2 || 0;
   }
   function randomUnit(random, out) {
     const up = random.next() * 2 - 1;
@@ -7178,20 +7271,20 @@ var GameDestructionThree = (() => {
       return [origin[0] + cos2 * x + sin2 * z, origin[1] + point[1] - anchor[1], origin[2] - sin2 * x + cos2 * z];
     }
     /** A direction or velocity of the recipe's space in the world. */
-    turn(vector) {
+    turn(vector2) {
       const placement = this.placement;
-      if (!placement) return vector;
-      if (placement.orientation) return rotate(placement.orientation, vector);
+      if (!placement) return vector2;
+      if (placement.orientation) return rotate(placement.orientation, vector2);
       const cos2 = Math.cos(placement.yaw);
       const sin2 = Math.sin(placement.yaw);
-      return [cos2 * vector[0] + sin2 * vector[2], vector[1], -sin2 * vector[0] + cos2 * vector[2]];
+      return [cos2 * vector2[0] + sin2 * vector2[2], vector2[1], -sin2 * vector2[0] + cos2 * vector2[2]];
     }
     placed(options) {
       if (!this.placement) return options;
       return { ...options, p: this.place(options.p), ...options.dir ? { dir: this.turn(options.dir) } : {}, ...options.v ? { v: this.turn(options.v) } : {} };
     }
-    spawn(system, recipe) {
-      const options = this.placed(recipe);
+    spawn(system, recipe2) {
+      const options = this.placed(recipe2);
       this.context.trace?.(system, [options]);
       if (system === "add") this.add.spawn(options);
       else if (system === "normal") this.normal.spawn(options);
@@ -7211,43 +7304,43 @@ var GameDestructionThree = (() => {
       this.accumulators.set(key, carried);
     }
     /** A solid particle (a cone, a sphere): the group sits at `p` turned by the placement, `v` is turned with it and `wv` is not. */
-    mesh(recipe) {
+    mesh(recipe2) {
       const placement = this.placement;
-      const options = placement ? { ...recipe, p: this.place(recipe.p), ...recipe.v ? { v: this.turn(recipe.v) } : {} } : recipe;
+      const options = placement ? { ...recipe2, p: this.place(recipe2.p), ...recipe2.v ? { v: this.turn(recipe2.v) } : {} } : recipe2;
       this.context.trace?.("mesh", [options]);
-      const grouped = recipe.at !== void 0 || recipe.roll !== void 0;
+      const grouped = recipe2.at !== void 0 || recipe2.roll !== void 0;
       return this.meshes.spawn(options, placement && grouped ? placement.orientation ?? [0, Math.sin(placement.yaw / 2), 0, Math.cos(placement.yaw / 2)] : void 0);
     }
-    debrisPiece(recipe) {
-      const options = this.placed(recipe);
+    debrisPiece(recipe2) {
+      const options = this.placed(recipe2);
       this.context.trace?.("debris", [options]);
       this.debris.spawn(options);
     }
-    decal(recipe) {
-      let args = recipe;
+    decal(recipe2) {
+      let args = recipe2;
       if (this.placement) {
-        const [x, y, z] = this.place([recipe[0], recipe[1], recipe[2]]);
-        const options = recipe[5];
-        args = [x, y, z, recipe[3], recipe[4], options?.n ? { ...options, n: this.turn(options.n) } : options];
+        const [x, y, z] = this.place([recipe2[0], recipe2[1], recipe2[2]]);
+        const options = recipe2[5];
+        args = [x, y, z, recipe2[3], recipe2[4], options?.n ? { ...options, n: this.turn(options.n) } : options];
       }
       this.context.trace?.("decal", args);
       this.decals.add(args[0], args[1], args[2], args[3], args[4], args[5]);
     }
-    ring(recipe) {
-      const args = this.placement ? [this.place(recipe[0]), recipe[1], recipe[2], recipe[3], recipe[4], recipe[5] && this.turn(recipe[5]), recipe[6]] : recipe;
+    ring(recipe2) {
+      const args = this.placement ? [this.place(recipe2[0]), recipe2[1], recipe2[2], recipe2[3], recipe2[4], recipe2[5] && this.turn(recipe2[5]), recipe2[6]] : recipe2;
       this.context.trace?.("ring", args);
       this.rings.add(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
     }
     /** `steady` (a seventh number): the light holds its intensity for its duration and goes out, where the Workshop's fades with the square of its age. */
-    flash(recipe) {
-      const args = this.placement ? [this.place(recipe[0]), recipe[1], recipe[2], recipe[3], recipe[4], recipe[5], recipe[6]] : recipe;
+    flash(recipe2) {
+      const args = this.placement ? [this.place(recipe2[0]), recipe2[1], recipe2[2], recipe2[3], recipe2[4], recipe2[5], recipe2[6]] : recipe2;
       this.context.trace?.("flash", args.slice(0, 6));
       this.lights.flash(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
     }
     /** `fireLight` (W400): sways with the clock and flickers with one draw. */
-    fireLight(slot, recipe, intensity, time) {
+    fireLight(slot, recipe2, intensity, time) {
       const light = this.lights.fire[slot];
-      const point = this.place(recipe);
+      const point = this.place(recipe2);
       light.x = point[0];
       light.y = point[1];
       light.z = point[2];
@@ -7561,7 +7654,22 @@ var GameDestructionThree = (() => {
     return key === void 0 ? void 0 : entry[key];
   }
 
-  // ../game-vfx-three/dist/index.js
+  // ../game-render-three/dist/index.js
+  var DEFAULT_ANGLE = Math.PI / 3;
+  var LIGHT_PRIORITY = {
+    blast: 900,
+    rocket: 800,
+    muzzle: 750,
+    fire: 600,
+    flare: 500,
+    headlight: 400,
+    weaponLight: 400,
+    lamp: 200,
+    street: 150
+  };
+  var EFFECT_STEP_SECONDS = 1 / 50;
+
+  // ../game-vfx-three/dist/chunk-ALDCQ5RH.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.);}`;
@@ -7840,8 +7948,26 @@ void main(){
       }
     };
   }
-  function createLightLayer(THREE, pool, scale) {
+  var LIGHT_ON_THRESHOLD = 0.05;
+  var FIRE_COLOR = 16742954;
+  var FIRE_DECAY = 2;
+  var BLAST_DECAY = 2;
+  function followEntry(budget, handles, index, entry, request) {
+    const handle = handles[index] ?? null;
+    if (entry.intensity <= LIGHT_ON_THRESHOLD) {
+      handle?.release({ fadeMs: 0 });
+      handles[index] = null;
+      return;
+    }
+    if (handle?.alive) {
+      handle.update({ color: request.color, intensity: request.intensity, distance: request.distance, position: request.position });
+      return;
+    }
+    handles[index] = budget.acquire(request);
+  }
+  function createLightLayer(THREE, pool, scale, budget) {
     const group = new THREE.Group();
+    if (budget) return createBudgetedLightLayer(group, pool, scale, budget);
     const blast = pool.blast.map(() => {
       const light = new THREE.PointLight(16752720, 0, 30, 2);
       light.position.set(0, -50, 0);
@@ -7880,6 +8006,30 @@ void main(){
       }
     };
   }
+  function createBudgetedLightLayer(group, pool, scale, budget) {
+    const blast = pool.blast.map(() => null);
+    const fire = pool.fire.map(() => null);
+    return {
+      group,
+      sync() {
+        let lit = 0;
+        pool.blast.forEach((entry, index) => {
+          const request = { owner: "vfx.blast", priority: LIGHT_PRIORITY.blast, urgent: true, color: entry.color, intensity: entry.intensity * scale, distance: entry.distance, decay: BLAST_DECAY, position: [entry.x, entry.y, entry.z] };
+          followEntry(budget, blast, index, entry, request);
+          if (entry.intensity > LIGHT_ON_THRESHOLD) lit++;
+        });
+        pool.fire.forEach((entry, index) => {
+          const request = { owner: "vfx.fire", priority: LIGHT_PRIORITY.fire, color: FIRE_COLOR, intensity: entry.intensity * scale, distance: entry.distance, decay: FIRE_DECAY, position: [entry.x, entry.y, entry.z] };
+          followEntry(budget, fire, index, entry, request);
+          if (entry.intensity > LIGHT_ON_THRESHOLD) lit++;
+        });
+        return lit;
+      },
+      dispose() {
+        for (const handle of [...blast, ...fire]) handle?.release({ fadeMs: 0 });
+      }
+    };
+  }
   var SCORCH_SEED = 5;
   var TEXTURE_SIZE = 256;
   var FULL_TURN = Math.PI * 2;
@@ -8013,6 +8163,7 @@ void main(){
       group.add(mesh2);
       return mesh2;
     }
+    let probeGeometry;
     const groundMarks = [];
     const spareGeometries = [];
     const blood = [];
@@ -8118,6 +8269,15 @@ void main(){
         rockMesh();
         plateMesh();
       },
+      probes() {
+        probeGeometry ?? (probeGeometry = new THREE.PlaneGeometry(1e-3, 1e-3).rotateX(-Math.PI / 2));
+        return [...scorchMaterials, dirtMaterial].map((material) => {
+          const mesh2 = new THREE.Mesh(probeGeometry, material);
+          mesh2.receiveShadow = true;
+          mesh2.frustumCulled = false;
+          return mesh2;
+        });
+      },
       update(dt) {
         for (let index = 0; index < blood.length; index++) {
           const drawn = blood[index];
@@ -8130,6 +8290,7 @@ void main(){
       dispose() {
         clearMarks();
         for (const mesh2 of [instanced.blood, instanced.rock, instanced.plate]) mesh2?.dispose();
+        probeGeometry?.dispose();
         for (const item of owned) item.dispose();
       }
     };
@@ -8705,7 +8866,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       }
     };
   }
-  function createWorkshopLayers(THREE, engine, pointScale, lightScale) {
+  function createWorkshopLayers(THREE, engine, pointScale, lightScale, budget) {
     const group = new THREE.Group();
     group.name = "workshop";
     const layers = [
@@ -8720,15 +8881,30 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     for (const layer2 of layers) group.add(layer2.object);
     const meshes = createMeshLayer(THREE, engine.meshes);
     group.add(meshes.group);
-    const flashLights = engine.lights.lights.map(() => new THREE.PointLight(16760944, 0, 14));
-    const fireLights = engine.lights.fire.map(() => new THREE.PointLight(FIRE_LIGHT_COLOR, 0, FIRE_LIGHT_DISTANCE));
-    for (const light of [...flashLights, ...fireLights]) group.add(light);
+    const lights = budget ? budgetedLights(engine, lightScale, budget) : legacyLights(THREE, engine, lightScale, group);
     return {
       group,
       sync() {
         let drawCalls = 0;
         for (const layer2 of layers) if (layer2.sync()) drawCalls++;
         drawCalls += meshes.sync();
+        lights.sync();
+        return drawCalls;
+      },
+      dispose() {
+        for (const layer2 of layers) layer2.dispose();
+        meshes.dispose();
+        lights.dispose();
+        group.clear();
+      }
+    };
+  }
+  function legacyLights(THREE, engine, lightScale, group) {
+    const flashLights = engine.lights.lights.map(() => new THREE.PointLight(16760944, 0, 14));
+    const fireLights = engine.lights.fire.map(() => new THREE.PointLight(FIRE_LIGHT_COLOR, 0, FIRE_LIGHT_DISTANCE));
+    for (const light of [...flashLights, ...fireLights]) group.add(light);
+    return {
+      sync() {
         engine.lights.lights.forEach((source, index) => {
           const light = flashLights[index];
           light.position.set(source.x, source.y, source.z);
@@ -8741,12 +8917,27 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           light.position.set(source.x, source.y, source.z);
           light.intensity = source.intensity * lightScale;
         });
-        return drawCalls;
       },
       dispose() {
-        for (const layer2 of layers) layer2.dispose();
-        meshes.dispose();
-        group.clear();
+      }
+    };
+  }
+  function budgetedLights(engine, lightScale, budget) {
+    const flash2 = engine.lights.lights.map(() => null);
+    const fire = engine.lights.fire.map(() => null);
+    return {
+      sync() {
+        engine.lights.lights.forEach((source, index) => {
+          const request = { owner: "vfx.workshop", priority: LIGHT_PRIORITY.blast, urgent: true, color: source.color, intensity: source.intensity * lightScale, distance: source.distance, position: [source.x, source.y, source.z] };
+          followEntry(budget, flash2, index, source, request);
+        });
+        engine.lights.fire.forEach((source, index) => {
+          const request = { owner: "vfx.workshop", priority: LIGHT_PRIORITY.fire, color: FIRE_LIGHT_COLOR, intensity: source.intensity * lightScale, distance: FIRE_LIGHT_DISTANCE, position: [source.x, source.y, source.z] };
+          followEntry(budget, fire, index, source, request);
+        });
+      },
+      dispose() {
+        for (const handle of [...flash2, ...fire]) handle?.release({ fadeMs: 0 });
       }
     };
   }
@@ -8804,7 +8995,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     const chunks = createChunkLayer(THREE, pools.chunks, { rock: rockGeometry, plate: plateGeometry }, colorOfChunk);
     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 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 });
     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));
@@ -8837,7 +9028,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       workshopLayers?.dispose();
       if (workshopLayers) root.remove(workshopLayers.group);
       workshopEngine = engine;
-      workshopLayers = createWorkshopLayers(THREE, engine, options.pointScale ?? 700, 1);
+      workshopLayers = createWorkshopLayers(THREE, engine, options.pointScale ?? 700, 1, options.lights);
       root.add(workshopLayers.group);
       applyLayers();
     }
@@ -8910,7 +9101,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         const meshes = createMeshLayerProbes(THREE);
         for (const mesh2 of meshes) mesh2.frustumCulled = false;
         const group = new THREE.Group();
-        group.add(...meshes);
+        group.add(...meshes, ...marks.probes());
         anchors = { meshes, group };
         return { group, dispose: () => {
         } };
@@ -9028,6 +9219,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   var BIG_LENGTH = 0.2;
   var BIG_WIDTH = 0.03;
   var FRAGMENT_SEED = 1374496523;
+  var SHARD_SHAPES = 6;
   var isBig = (size) => {
     const [, middle, longest] = [...size].sort((a, b) => a - b);
     return longest >= BIG_LENGTH && middle >= BIG_WIDTH;
@@ -9077,7 +9269,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       return m;
     }
     shardGeometry(seed) {
-      const idx = seed % 6;
+      const idx = seed % SHARD_SHAPES;
       let g = this.shardGeos[idx];
       if (!g) {
         const r = createRng(1e3 + idx);
@@ -9098,17 +9290,32 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       }
       return g;
     }
+    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
+     * 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 glass = this.materialFor("warm", 8421504, true);
+      const geometries = [this.box, ...Array.from({ length: SHARD_SHAPES }, (_, index) => this.shardGeometry(index))];
+      const { geometry, material } = this.markParts();
+      return [...geometries.flatMap((shared) => [new this.THREE.Mesh(shared, opaque), new this.THREE.Mesh(shared, glass)]), 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
      * a unit box scaled to the fragment, so each disc is scaled back; exact for a mark on a face, which is where a bullet hole is.
      */
     addMarks(mesh2, f) {
       if (!f.marks?.length) return;
-      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 }));
+      const { geometry, material } = this.markParts();
       const sc = mesh2.scale;
       for (const mark of f.marks) {
-        const disc = new this.THREE.Mesh(this.markGeometry, this.markMaterial);
+        const disc = new this.THREE.Mesh(geometry, material);
         const radius = Math.max(4e-3, mark.diameter) * 0.6;
         const n = this.v.set(mark.normal[0], mark.normal[1], mark.normal[2]).normalize();
         disc.position.set(mark.point[0] / sc.x + n.x * 2e-3 / sc.x, mark.point[1] / sc.y + n.y * 2e-3 / sc.y, mark.point[2] / sc.z + n.z * 2e-3 / sc.z);
@@ -9691,7 +9898,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       const invM = 1 / b.mass;
       const steps = clamp6(Math.ceil(dt / SUB_DT), 1, 8);
       const h = dt / steps;
-      let landing = 0;
+      let landing2 = 0;
       let landPoint = [pos[0], pos[1], pos[2]];
       let contactedLast = false;
       let touched = false;
@@ -9797,8 +10004,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         let impact2 = 0;
         for (const r of rs) impact2 = Math.max(impact2, -(v[1] + w[2] * r[0] - w[0] * r[2]));
         const restitution = impact2 > 2 ? 0.25 : 0;
-        if (impact2 > landing) {
-          landing = impact2;
+        if (impact2 > landing2) {
+          landing2 = impact2;
           let sx = 0;
           let sz = 0;
           for (const r of rs) {
@@ -9934,9 +10141,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       b.root.position.set(pos[0] - off.x, pos[1] - off.y, pos[2] - off.z);
       b.root.updateMatrixWorld(true);
       b.onGround = contactedLast;
-      if (landing > HARD_LANDING && this.time - b.lastHit > 0.15) {
+      if (landing2 > HARD_LANDING && this.time - b.lastHit > 0.15) {
         b.lastHit = this.time;
-        this.o.onHardLanding(b, landPoint, landing);
+        this.o.onHardLanding(b, landPoint, landing2);
       }
       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;
@@ -11416,6 +11623,69 @@ 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 assemblies_default = [
+    {
+      id: "brick_wall_plastered",
+      name: "Plastered brick wall",
+      core: { material: "brick", thickness: 0.09 },
+      layers: [{ material: "plaster", thickness: 0.02, faces: "both" }],
+      units: { size: [0.23, 0.075, 0.11], bond: "running", mortar: "plaster" },
+      breach: { area: 0.25 }
+    },
+    {
+      id: "concrete_block_wall",
+      name: "Concrete block wall",
+      core: { material: "concrete", thickness: 0.14 },
+      fill: 0.55,
+      units: { size: [0.39, 0.19, 0.14], bond: "running", mortar: "plaster" },
+      breach: { area: 0.25 }
+    },
+    {
+      id: "reinforced_concrete",
+      name: "Reinforced concrete wall",
+      core: { material: "concrete", thickness: 0.2 },
+      reinforcement: { material: "steel", spacing: 0.18, diameter: 8e-3, residualCapacity: 0.15 },
+      units: { size: [0.6, 0.42, 0.2], bond: "stack", mortar: "concrete" },
+      breach: { area: 0.25 }
+    },
+    {
+      id: "drywall",
+      name: "Drywall partition on steel studs",
+      core: { material: "plaster", thickness: 0.0125 },
+      layers: [{ material: "plaster", thickness: 0.0125, faces: "+" }],
+      depth: 0.095,
+      breach: { area: 0.25 }
+    },
+    {
+      id: "wood_frame_wall",
+      name: "Wood frame wall",
+      core: { material: "plywood", thickness: 0.012 },
+      layers: [{ material: "plaster", thickness: 0.0125, faces: "-" }],
+      depth: 0.1135,
+      breach: { area: 0.25 }
+    },
+    {
+      id: "log_wall",
+      name: "Log wall",
+      core: { material: "wood_soft", thickness: 0.2 },
+      fill: 0.785,
+      breach: { area: 0.25 }
+    },
+    {
+      id: "sheet_metal_shack",
+      name: "Corrugated sheet metal wall",
+      core: { material: "steel", thickness: 6e-4 },
+      depth: 0.02,
+      breach: { area: 0.25 }
+    },
+    {
+      id: "glass_pane",
+      name: "Glass pane",
+      core: { material: "glass", thickness: 6e-3 },
+      breach: { area: 0.1 }
+    }
+  ];
+  var SHIPPED = structuredClone(assemblies_default);
 
   // src/spec.ts
   function containsOf(value) {
@@ -11781,6 +12051,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       this.b = tmpV(THREE);
       this.m4 = new THREE.Matrix4();
       this.ray = new THREE.Raycaster();
+      this.ray.layers.enableAll();
       this.box = new THREE.Box3();
       this.t = tmpV(THREE);
       this.lbox = new THREE.Box3();
@@ -11788,9 +12059,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     /**
      * @param range vertex range `[v0, v1)` of a merged mesh this part is drawn by (see `MeshRange`); `hosts` caches the shared state per mesh for one `bind`.
      */
-    makeMeshVis(mesh2, home, range, hosts) {
+    makeMeshVis(mesh2, home, range2, hosts) {
       let host = null;
-      if (range) {
+      if (range2) {
         host = hosts?.get(mesh2) ?? null;
         if (!host) {
           host = { mesh: mesh2, origGeometry: mesh2.geometry, origMaterial: mesh2.material, ownGeo: false, work: null, ownMat: false, sharers: [] };
@@ -11816,8 +12087,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         bottomY: 0,
         moved: false,
         host,
-        range: range ? [range[0], range[1]] : null,
-        merged: host && range ? { host, range: [range[0], range[1]] } : null,
+        range: range2 ? [range2[0], range2[1]] : null,
+        merged: host && range2 ? { host, range: [range2[0], range2[1]] } : null,
         loose: false,
         collapsed: false,
         hidden: false,
@@ -12386,24 +12657,24 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       geo.boundingBox = null;
       geo.boundingSphere = null;
     }
-    collapseRange(arr, range) {
-      const x = arr[range[0] * 3];
-      const y = arr[range[0] * 3 + 1];
-      const z = arr[range[0] * 3 + 2];
-      for (let i = range[0] * 3; i < range[1] * 3; i += 3) {
+    collapseRange(arr, range2) {
+      const x = arr[range2[0] * 3];
+      const y = arr[range2[0] * 3 + 1];
+      const z = arr[range2[0] * 3 + 2];
+      for (let i = range2[0] * 3; i < range2[1] * 3; i += 3) {
         arr[i] = x;
         arr[i + 1] = y;
         arr[i + 2] = z;
       }
     }
     /** Melt of one range: shorter in Y (down to 25 %) with the bottom fixed, a bit wider around its centre, with the same noise as a whole mesh. */
-    meltRange(arr, work, range, melt) {
+    meltRange(arr, work, range2, melt) {
       let minY = Infinity;
       let maxY = -Infinity;
       let cx = 0;
       let cz = 0;
-      const n = Math.max(1, range[1] - range[0]);
-      for (let i = range[0] * 3; i < range[1] * 3; i += 3) {
+      const n = Math.max(1, range2[1] - range2[0]);
+      for (let i = range2[0] * 3; i < range2[1] * 3; i += 3) {
         minY = Math.min(minY, work[i + 1]);
         maxY = Math.max(maxY, work[i + 1]);
         cx += work[i];
@@ -12414,7 +12685,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       const h = Math.max(1e-4, maxY - minY);
       const sy = lerp5(1, 0.25, melt);
       const sxz = 1 + 0.18 * melt;
-      for (let i = range[0] * 3, v = 0; i < range[1] * 3; i += 3, v++) {
+      for (let i = range2[0] * 3, v = 0; i < range2[1] * 3; i += 3, v++) {
         const noise = (Math.imul(v + 1, 2654435761) >>> 0) % 1e3 / 1e3;
         arr[i] = cx + (work[i] - cx) * sxz;
         arr[i + 2] = cz + (work[i + 2] - cz) * sxz;
@@ -12771,8 +13042,26 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       __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. */
+      /** When the work of this frame must stop; `Infinity` outside a drain, where a call finishes what it started. */
       __publicField(this, "sliceDeadline", Infinity);
+      /** The clock the drain reads; a budget lends its own while it runs the queue. */
+      __publicField(this, "drainClock", () => performance.now());
+      /** true once a frame budget owns the draining: `update` no longer drains by itself. */
+      __publicField(this, "attached", false);
+      __publicField(this, "eventQueue", {
+        id: DEFERRED_QUEUE_ID.DESTRUCTION_EVENTS,
+        pending: () => this.queue.length + this.slices.length,
+        run: (deadline, clock) => this.runBudgeted(deadline, clock),
+        flush: () => {
+          for (let guard = 0; guard < 16 && this.queue.length + this.slices.length > 0; guard++) this.runBudgeted(Infinity, () => 0);
+        },
+        attach: () => {
+          this.attached = true;
+        },
+        detach: () => {
+          this.attached = false;
+        }
+      });
       __publicField(this, "unsubscribe");
       __publicField(this, "visuals");
       __publicField(this, "fragments");
@@ -12818,6 +13107,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       const maxParticles = Math.max(8, Math.floor((o.maxParticles ?? 2500) * (this.low ? 0.5 : 1)));
       this.visuals = new Visuals(THREE, this.low, 600);
       this.ground = new GroundSpots(THREE, o.scene, this.groundAt, 48);
+      if (!o.vfx) warnOnce("game-destruction-three.own-effects-world", "game-destruction-three made an effects world of its own because the host lent none (options.vfx); pass the host effects so the effects share one budget");
       this.vfx = o.vfx ?? createVfx({ profile: this.quality, gravity: this.gravity, groundAt: this.groundAt, sprites: { capacity: maxParticles, density: this.low ? 0.6 : 1 } });
       this.ownVfx = o.vfx ? void 0 : createVfxRenderer(THREE, { scene: o.scene, camera: o.camera ?? new THREE.PerspectiveCamera(), vfx: this.vfx, pointScale: o.pointScale ?? 700 });
       this.stopLanding = this.vfx.onLand(this.owner, (x, _y, z, color, tag) => {
@@ -13055,7 +13345,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       if (this.disposed) return;
       dt = clamp6(dt, 0, 0.1);
       this.time += dt;
-      this.drainQueue();
+      if (!this.attached) 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);
@@ -13066,36 +13356,50 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       this.ownVfx?.update(dt);
       this.syncTransforms();
     }
+    deferredQueue() {
+      return this.eventQueue;
+    }
     drainQueue() {
+      this.runBudgeted(performance.now() + this.eventBudgetMs, () => performance.now());
+    }
+    /** Applies the waiting events in order until the deadline, after the slices earlier events left; always at least one unit when something waits. Returns the units run. */
+    runBudgeted(deadline, clock) {
       const batch = this.queue.splice(0, this.queue.length);
-      const deadline = performance.now() + this.eventBudgetMs;
+      const outerClock = this.drainClock;
+      this.drainClock = clock;
       this.sliceDeadline = deadline;
+      let ran = 0;
       try {
-        this.runSlices(deadline);
+        ran = this.runSlices(deadline);
         for (let i = 0; i < batch.length; i++) {
-          if (i > 0 && performance.now() >= deadline) {
+          if ((i > 0 || ran > 0 && this.attached) && clock() >= deadline) {
             this.queue.unshift(...batch.slice(i));
-            return;
+            return ran;
           }
           try {
             this.apply(batch[i]);
           } catch (err) {
             if (typeof console !== "undefined") console.error("game-destruction-three: failed to apply", batch[i].type, err);
           }
+          ran++;
         }
       } finally {
         this.sliceDeadline = Infinity;
+        this.drainClock = outerClock;
       }
+      return ran;
     }
     /** 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++) {
+      let ran = 0;
+      for (; this.slices.length > 0 && (ran === 0 || this.drainClock() < deadline); ran++) {
         try {
           this.slices.shift()();
         } catch (err) {
           if (typeof console !== "undefined") console.error("game-destruction-three: failed to run deferred work", err);
         }
       }
+      return ran;
     }
     /**
      * The ground under an object settled or tilted: its parts are drawn under a node with the soil's offset (`ObjectState.soil.offset`), so the host's
@@ -13653,7 +13957,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       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) {
+        if (i - from >= MIN_FRAGMENTS_PER_SLICE * step && this.drainClock() >= this.sliceDeadline) {
           this.slices.push(() => this.spawnFragments(ev, i, look));
           return;
         }
@@ -13677,7 +13981,7 @@ 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) {
+        if (i > 0 && this.drainClock() >= this.sliceDeadline) {
           this.slices.push(() => {
             this.staticDirty.add(objectId);
             this.splitLoose(objectId);
@@ -14056,6 +14360,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       const materials = [kit.discMaterial().clone(), kit.patchMaterial(8421504).clone(), kit.lineMaterial(0).clone()];
       const group = new T.Group();
       group.add(new T.Mesh(kit.discGeometry(), materials[0]), new T.Mesh(kit.discGeometry(), materials[1]), new T.LineSegments(geometry, materials[2]));
+      group.add(...this.fragments.warmMeshes());
       for (const probe of group.children) probe.frustumCulled = false;
       this.warmProbes = { group, geometry, materials };
       return { group, dispose: () => {
@@ -14086,7 +14391,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     }
   };
 
-  // ../game-audio/dist/index.js
+  // ../game-audio/dist/chunk-DZITVFMJ.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 },
@@ -14101,31 +14406,6 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     /** The game's animal calls: `max(0, 1 − d / 70) × 0.25`, silent at or below 0.005 (jogo L66627–66628). */
     animals: { model: "linear", range: 70, scale: 0.25, minGain: 5e-3 }
   };
-  var mix_profiles_default = [
-    {
-      id: "game",
-      master: 0.5,
-      noise: { seconds: 1.5, create: "lazy" },
-      sources: ["jogo:L62077-62081 master 0.5 to the output", "jogo:L62082-62088 noise 1.5 s made by the first sound that needs it"]
-    },
-    {
-      id: "art_scene",
-      master: 0.85,
-      compressor: { threshold: -12, ratio: 5 },
-      reverb: { seconds: 2.2, decay: 3.4, wet: 0.4 },
-      noise: { seconds: 2, create: "eager" },
-      sources: [
-        "cena:L1308 compressor -12 dB, ratio 5",
-        "cena:L1309 master 0.85",
-        "cena:L1310 convolver, impulse 2.2 s of (1 - i/len)^3.4",
-        "cena:L1311 wet 0.4",
-        "cena:L1312 noise 2 s made with the chain"
-      ]
-    }
-  ];
-  var MIX_PROFILES = Object.fromEntries(
-    mix_profiles_default.map((profile) => [profile.id, profile])
-  );
   var game_sfx_default = {
     sources: ["jogo:L62089-62107"],
     note: "The game's sfx table P: [lowpass cutoff Hz, peak gain, seconds]. Played as a noise burst with the game's distance curve (falloff game_sfx) and a 0.05 s tail. Team names in `team`.",
@@ -14170,6 +14450,78 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     };
   }
   var GAME_SFX_BANK = { id: "game_sfx", sounds: [...GAME_SFX_CLASSES, GAME_SFX_FALLBACK].map((row) => noiseClassRecipe(row)) };
+  var mix_profiles_default = [
+    {
+      id: "game",
+      master: 0.5,
+      noise: { seconds: 1.5, create: "lazy" },
+      sources: ["jogo:L62077-62081 master 0.5 to the output", "jogo:L62082-62088 noise 1.5 s made by the first sound that needs it"]
+    },
+    {
+      id: "art_scene",
+      master: 0.85,
+      compressor: { threshold: -12, ratio: 5 },
+      reverb: { seconds: 2.2, decay: 3.4, wet: 0.4 },
+      noise: { seconds: 2, create: "eager" },
+      sources: [
+        "cena:L1308 compressor -12 dB, ratio 5",
+        "cena:L1309 master 0.85",
+        "cena:L1310 convolver, impulse 2.2 s of (1 - i/len)^3.4",
+        "cena:L1311 wet 0.4",
+        "cena:L1312 noise 2 s made with the chain"
+      ]
+    }
+  ];
+  var MIX_PROFILES = Object.fromEntries(
+    mix_profiles_default.map((profile) => [profile.id, profile])
+  );
+  var BENCH_BANK = {
+    id: "audio_bench",
+    sounds: [
+      {
+        id: "bench_ping",
+        bus: "ui",
+        pan: true,
+        duration: 0.25,
+        layers: [
+          {
+            gain: 0.5,
+            wet: 0.3,
+            source: { kind: "osc", wave: "sine", frequency: { from: 880 } },
+            envelope: [
+              [0, 1e-4, "set", "fixed"],
+              [2e-3, 1, "exp"],
+              ["1d", 1e-4, "exp", "fixed"]
+            ]
+          }
+        ],
+        falloff: DISTANCE_CURVES.art_scene,
+        sources: ["sdk: bench probe, a 880 Hz ping through the art scene output stage"]
+      },
+      {
+        id: "bench_hiss",
+        bus: "ui",
+        pan: true,
+        duration: [0.3, 0.9],
+        layers: [
+          {
+            gain: 0.4,
+            source: { kind: "noise", offset: "random", offsetScale: 1.5, loop: true },
+            filters: { mode: "serial", bank: [{ type: "highpass", frequency: { set: 3e3 }, q: 0.7 }] },
+            envelope: [
+              [0, 1e-4, "set", "fixed"],
+              [2e-3, 1, "exp"],
+              ["1d", 1e-4, "exp", "fixed"]
+            ]
+          }
+        ],
+        falloff: DISTANCE_CURVES.art_scene,
+        sources: ["sdk: bench probe, a highpass hiss of random length"]
+      }
+    ]
+  };
+
+  // ../game-audio/dist/index.js
   var ATTACK = 2e-3;
   function lengthOf(d, attack) {
     if (typeof d === "number") return attack + d;
@@ -14207,6 +14559,31 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       envelope: envelope(ATTACK)
     };
   }
+  function sceneVoice(o) {
+    return {
+      duration: lengthOf(o.d, 0),
+      gain: o.vol,
+      wet: 0.45,
+      source: {
+        kind: "formant_voice",
+        wave: o.wave ?? "sawtooth",
+        frequency: { from: o.f0, to: o.f1, curve: "linear", over: "duration" },
+        vibrato: { rate: [4, 10], depth: 0.08 },
+        formants: [
+          { frequency: o.fA, q: 4 },
+          { frequency: o.fB, q: 6 }
+        ],
+        breath: { frequency: o.fB, q: 1.1, gain: o.noise },
+        mix: 3.2
+      },
+      envelope: [
+        [0, 1e-4, "set", "fixed"],
+        [0.1, 1, "exp"],
+        ["0.6d", 1, "set"],
+        ["1d", 1e-4, "exp", "fixed"]
+      ]
+    };
+  }
   var sceneMany = (count, make) => Array.from({ length: count }, make);
   function sceneRecipe(id, layers, line, options = {}) {
     return {
@@ -14220,51 +14597,172 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       sources: [`cena:${line}`]
     };
   }
-  var BENCH_BANK = {
-    id: "audio_bench",
-    sounds: [
-      {
-        id: "bench_ping",
-        bus: "ui",
-        pan: true,
-        duration: 0.25,
-        layers: [
-          {
-            gain: 0.5,
-            wet: 0.3,
-            source: { kind: "osc", wave: "sine", frequency: { from: 880 } },
-            envelope: [
-              [0, 1e-4, "set", "fixed"],
-              [2e-3, 1, "exp"],
-              ["1d", 1e-4, "exp", "fixed"]
-            ]
-          }
-        ],
-        falloff: DISTANCE_CURVES.art_scene,
-        sources: ["sdk: bench probe, a 880 Hz ping through the art scene output stage"]
-      },
-      {
-        id: "bench_hiss",
-        bus: "ui",
-        pan: true,
-        duration: [0.3, 0.9],
-        layers: [
-          {
-            gain: 0.4,
-            source: { kind: "noise", offset: "random", offsetScale: 1.5, loop: true },
-            filters: { mode: "serial", bank: [{ type: "highpass", frequency: { set: 3e3 }, q: 0.7 }] },
-            envelope: [
-              [0, 1e-4, "set", "fixed"],
-              [2e-3, 1, "exp"],
-              ["1d", 1e-4, "exp", "fixed"]
-            ]
-          }
-        ],
-        falloff: DISTANCE_CURVES.art_scene,
-        sources: ["sdk: bench probe, a highpass hiss of random length"]
-      }
-    ]
+  var TAKES = [
+    { f: 1, t: 1, v: 1 },
+    { f: 1.08, t: 0.9, v: 0.92 },
+    { f: 0.93, t: 1.12, v: 1.05 },
+    { f: 1.03, t: 1.05, v: 0.88 }
+  ];
+  var FOOTSTEP_FALLOFF = { model: "inverse_square", k: 0.03, cutoffK: 0.03, minGain: 4e-3 };
+  var BODY_FALLOFF = { model: "inverse_square", k: 0.012, cutoffK: 0.015, minGain: 4e-3 };
+  var SURFACES = {
+    concrete: { heel: { f: 95, d: 0.05, vol: 0.55 }, roll: { type: "bandpass", f: 2300, q: 1.1, d: 0.05, vol: 0.38 }, grains: { count: 2, f: 4200, q: 2, spread: 0.04, vol: 0.08 } },
+    asphalt: { heel: { f: 90, d: 0.05, vol: 0.5 }, roll: { type: "bandpass", f: 1700, q: 0.9, d: 0.06, vol: 0.36 }, grains: { count: 4, f: 3600, q: 2.5, spread: 0.06, vol: 0.1 } },
+    wood: { heel: { f: 130, d: 0.08, vol: 0.55 }, roll: { type: "lowpass", f: 1300, q: 0.8, d: 0.06, vol: 0.3 }, ring: [{ f: 210, d: 0.1, vol: 0.18 }, { f: 470, d: 0.06, vol: 0.06 }] },
+    tile: { heel: { f: 110, d: 0.04, vol: 0.45 }, roll: { type: "bandpass", f: 3600, q: 2, d: 0.03, vol: 0.42 }, ring: [{ f: 1900, d: 0.03, vol: 0.05 }] },
+    dirt: { heel: { f: 75, d: 0.06, vol: 0.45 }, roll: { type: "lowpass", f: 750, q: 0.7, d: 0.09, vol: 0.4 }, grains: { count: 3, f: 1800, q: 1.5, spread: 0.07, vol: 0.06 } },
+    grass: { heel: { f: 70, d: 0.05, vol: 0.32 }, roll: { type: "highpass", f: 2600, q: 0.7, d: 0.13, vol: 0.28 }, grains: { count: 4, f: 5200, q: 1.2, spread: 0.1, vol: 0.07 } },
+    gravel: { heel: { f: 80, d: 0.05, vol: 0.4 }, roll: { type: "lowpass", f: 950, q: 0.8, d: 0.1, vol: 0.3 }, grains: { count: 8, f: 2600, q: 3, spread: 0.13, vol: 0.2 } },
+    sand: { heel: { f: 65, d: 0.06, vol: 0.3 }, roll: { type: "bandpass", f: 1500, q: 0.6, d: 0.16, vol: 0.3 }, grains: { count: 5, f: 4800, q: 1.5, spread: 0.12, vol: 0.05 } },
+    metal: { heel: { f: 120, d: 0.05, vol: 0.5 }, roll: { type: "bandpass", f: 2800, q: 1.5, d: 0.03, vol: 0.25 }, ring: [{ f: 420, d: 0.25, vol: 0.16 }, { f: 1130, d: 0.18, vol: 0.09 }, { f: 2470, d: 0.1, vol: 0.04 }] },
+    water: { heel: { f: 70, d: 0.04, vol: 0.25 }, roll: { type: "bandpass", f: 3e3, q: 1.2, d: 0.1, vol: 0.18 }, splash: { f: 1100, f2: 380, d: 0.22, vol: 0.55 }, grains: { count: 4, f: 2400, q: 6, spread: 0.18, vol: 0.12 } },
+    glass: { heel: { f: 90, d: 0.04, vol: 0.4 }, roll: { type: "highpass", f: 4500, q: 0.8, d: 0.06, vol: 0.2 }, grains: { count: 9, f: 6200, q: 5, spread: 0.12, vol: 0.22 }, ring: [{ f: 3900, d: 0.04, vol: 0.04 }, { f: 5300, d: 0.03, vol: 0.03 }] },
+    carpet: { heel: { f: 70, d: 0.05, vol: 0.32 }, roll: { type: "lowpass", f: 420, q: 0.7, d: 0.07, vol: 0.3 } }
+  };
+  var GAITS = {
+    walk: { vol: 1, bright: 1, toe: 0.075, short: 1 },
+    run: { vol: 1.35, bright: 1.25, toe: 0.035, short: 0.75 }
+  };
+  var grainLayers = (g, take, start, scale) => Array.from(
+    { length: g.count },
+    (_, i) => sceneNoise({ type: "bandpass", f: [g.f * take.f * 0.85, g.f * take.f * 1.15], q: g.q, d: [8e-3, 0.02], vol: g.vol * scale * take.v, delay: start + (i + 0.5) / g.count * g.spread * take.t })
+  );
+  var ringLayers = (rings, take, scale, at3 = 0) => rings.map((r) => sceneTone({ f: r.f * take.f, d: r.d * take.t, vol: r.vol * scale * take.v, delay: at3 }));
+  function footLayers(surface, take, gait, weight = 1) {
+    const s = SURFACES[surface];
+    const toe = gait.toe * take.t;
+    return [
+      sceneTone({ f: s.heel.f * take.f * weight ** -0.3, f2: s.heel.f * take.f * 0.6, d: s.heel.d * gait.short * take.t * weight ** 0.5, vol: s.heel.vol * gait.vol * take.v * weight ** 0.5 }),
+      sceneNoise({ type: "lowpass", f: 500 * gait.bright, d: 0.02 * take.t, vol: 0.18 * gait.vol * take.v * weight ** 0.5 }),
+      sceneNoise({ type: s.roll.type, f: [s.roll.f * take.f * gait.bright * 0.92, s.roll.f * take.f * gait.bright * 1.08], q: s.roll.q, d: s.roll.d * gait.short * take.t * weight ** 0.3, vol: s.roll.vol * gait.vol * take.v, delay: toe }),
+      ...s.grains ? grainLayers(s.grains, take, toe * 0.5, gait.vol * weight ** 0.5) : [],
+      ...s.ring ? ringLayers(s.ring, take, gait.vol * weight ** 0.5) : [],
+      ...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 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")}`;
+  function takes(id, layersOf, falloff, rate = [0.96, 1.04], bus) {
+    const sounds = TAKES.map((take, index) => recipe(takeId(id, index), layersOf(take, index), falloff, bus));
+    return { sounds, set: { id, variants: sounds.map((sound) => sound.id), rate } };
+  }
+  var footstep = (surface, gait) => takes(footstepSoundId(surface, gait), (take) => footLayers(surface, take, GAITS[gait]), FOOTSTEP_FALLOFF);
+  var LANDINGS = { light: { weight: 1.4, cloth: 0.12 }, heavy: { weight: 2.4, cloth: 0.22 } };
+  var LANDING_LEVEL = 0.65;
+  var landing = (surface, landing2) => takes(
+    `land_${surface}_${landing2}`,
+    (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 })),
+      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 })
+    ]),
+    FOOTSTEP_FALLOFF
+  );
+  var whoosh = (blow3, from, to, d, vol, q = 1.6) => (take) => [
+    // the air: a band sweeping up as the limb speeds up; it peaks `SWING_LEAD_SECONDS` in, the moment before the contact, then dies away
+    sceneNoise({ type: "bandpass", f: from * take.f, f2: to * take.f, q, a: SWING_LEAD_SECONDS[blow3], d: d * take.t, vol: vol * take.v }),
+    sceneNoise({ type: "lowpass", f: 600 * take.f, a: SWING_LEAD_SECONDS[blow3], d: d * take.t * 0.8, vol: vol * 0.35 * take.v })
+  ];
+  var fleshHit = (o) => (take) => [
+    sceneNoise({ type: "bandpass", f: o.slapF * take.f, q: 1.2, d: 0.03 * take.t, vol: o.slap * take.v }),
+    sceneNoise({ type: "highpass", f: 3500 * take.f, d: 0.012, vol: o.slap * 0.4 * take.v }),
+    sceneTone({ f: o.thudF * take.f, f2: o.thudF * 0.5, d: o.thudD * take.t, vol: o.thud * take.v }),
+    sceneNoise({ type: "lowpass", f: 600 * take.f, d: o.thudD * 1.2 * take.t, vol: o.thud * 0.5 * take.v }),
+    ...o.crack ? [sceneNoise({ type: "highpass", f: 2500, d: 0.015, vol: o.crack * take.v, delay: 6e-3 }), sceneTone({ wave: "square", f: 900 * take.f, f2: 300, d: 0.02, vol: o.crack * 0.15 * take.v, delay: 6e-3 })] : [],
+    ...o.wet ? [sceneNoise({ type: "bandpass", f: 1400 * take.f, f2: 500, q: 2.5, d: 0.12 * take.t, vol: o.wet * take.v, delay: 0.01 })] : []
+  ];
+  var knock = (o) => (take) => [
+    sceneNoise({ type: "bandpass", f: o.clickF * take.f, q: 1.5, d: 0.018, vol: o.click * take.v }),
+    ...o.tones.map(([f, d, vol]) => sceneTone({ f: f * take.f, d: d * take.t, vol: vol * take.v }))
+  ];
+  var voice = (o) => (take) => [
+    sceneVoice({ f0: o.f0 * take.f, f1: o.f1 * take.f, d: o.d * take.t, fA: o.fA * take.f, fB: o.fB * take.f, noise: o.noise, vol: o.vol * take.v })
+  ];
+  var BODY = {
+    jump: (take) => [
+      sceneNoise({ type: "bandpass", f: 900 * take.f, f2: 1700 * take.f, q: 1, a: 0.03, d: 0.12, vol: 0.18 * take.v }),
+      sceneNoise({ type: "bandpass", f: 2200 * take.f, q: 0.8, d: 0.04, vol: 0.12 * take.v }),
+      sceneTone({ f: 85 * take.f, f2: 60, d: 0.04, vol: 0.2 * take.v })
+    ],
+    cloth_rustle: (take) => [
+      { ...sceneNoise({ type: "bandpass", f: 2400 * take.f, q: 0.8, a: 0.06, d: 0.22 * take.t, vol: 0.12 * take.v }), modulators: [{ target: "gain", wave: "triangle", rate: [9, 14], depth: 0.5 }] }
+    ],
+    body_fall: (take) => [
+      sceneTone({ f: 58 * take.f, f2: 35, d: 0.28 * take.t, vol: 0.9 * take.v }),
+      sceneNoise({ type: "lowpass", f: 480 * take.f, d: 0.3 * take.t, vol: 0.55 * take.v }),
+      sceneNoise({ type: "bandpass", f: 1300 * take.f, q: 1, d: 0.05, vol: 0.3 * take.v }),
+      // the limbs a moment later, and the clothes
+      sceneTone({ f: 75 * take.f, f2: 45, d: 0.12, vol: 0.4 * take.v, delay: 0.13 * take.t }),
+      sceneNoise({ type: "bandpass", f: 2200, q: 0.8, d: 0.2, vol: 0.12 * take.v, delay: 0.05 })
+    ],
+    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 }))
+    ],
+    player_hurt: voice({ f0: 150, f1: 105, d: 0.26, fA: 620, fB: 1100, noise: 0.3, vol: 0.35 }),
+    player_breath_run: (take) => [
+      sceneNoise({ type: "bandpass", f: 1200 * take.f, q: 1, a: 0.08, d: 0.22 * take.t, vol: 0.25 * take.v }),
+      sceneNoise({ type: "bandpass", f: 900 * take.f, q: 1, a: 0.06, d: 0.26 * take.t, vol: 0.3 * take.v, delay: 0.3 * take.t })
+    ],
+    player_death: voice({ f0: 135, f1: 68, d: 1, fA: 560, fB: 980, noise: 0.35, vol: 0.4 }),
+    bite: (take) => [
+      sceneNoise({ type: "highpass", f: 2600, d: 0.015, vol: 0.4 * take.v }),
+      sceneNoise({ type: "bandpass", f: 1600 * take.f, f2: 450, q: 2.2, d: 0.16 * take.t, vol: 0.55 * take.v, delay: 0.01 }),
+      sceneNoise({ type: "bandpass", f: 3200 * take.f, f2: 1800, q: 1.2, d: 0.22 * take.t, vol: 0.25 * take.v, delay: 0.09 }),
+      sceneTone({ f: 120 * take.f, f2: 70, d: 0.06, vol: 0.3 * take.v })
+    ],
+    grab: (take) => [
+      sceneNoise({ type: "bandpass", f: 1900 * take.f, q: 0.9, a: 4e-3, d: 0.13 * take.t, vol: 0.32 * take.v }),
+      sceneTone({ f: 95 * take.f, f2: 60, d: 0.07, vol: 0.3 * take.v }),
+      sceneNoise({ type: "lowpass", f: 700, d: 0.08, vol: 0.2 * take.v })
+    ],
+    punch_swing: whoosh("punch", 450, 1500, 0.16, 0.9),
+    punch_hit_body: fleshHit({ slap: 0.55, slapF: 1500, thud: 0.6, thudF: 115, thudD: 0.09 }),
+    punch_hit_face: fleshHit({ slap: 0.75, slapF: 2300, thud: 0.45, thudF: 150, thudD: 0.07, crack: 0.25 }),
+    punch_hit_object: knock({ clickF: 1800, click: 0.3, tones: [[210, 0.04, 0.25]] }),
+    kick_swing: whoosh("kick", 280, 950, 0.22, 1, 1.3),
+    kick_hit: fleshHit({ slap: 0.45, slapF: 1100, thud: 0.85, thudF: 82, thudD: 0.14 }),
+    kick_hit_object: knock({ clickF: 1e3, click: 0.3, tones: [[92, 0.08, 0.5]] }),
+    shove_two_hands: (take) => [
+      sceneNoise({ type: "bandpass", f: 950 * take.f, q: 0.9, a: 0.01, d: 0.13 * take.t, vol: 0.38 * take.v }),
+      sceneTone({ f: 100 * take.f, f2: 60, d: 0.1 * take.t, vol: 0.45 * take.v }),
+      sceneNoise({ type: "bandpass", f: 2300, q: 0.8, d: 0.16, vol: 0.12 * take.v, delay: 0.03 })
+    ],
+    knife_swing: whoosh("blade", 1900, 4600, 0.12, 1.1, 2.2),
+    knife_stab: fleshHit({ slap: 0.2, slapF: 1200, thud: 0.4, thudF: 160, thudD: 0.06, wet: 0.5 }),
+    knife_slash: (take) => [
+      sceneNoise({ type: "highpass", f: 3200 * take.f, f2: 1800, d: 0.13 * take.t, vol: 0.35 * take.v }),
+      sceneNoise({ type: "bandpass", f: 1300 * take.f, f2: 600, q: 2.5, d: 0.12 * take.t, vol: 0.35 * take.v, delay: 0.02 })
+    ],
+    knife_hit_object: knock({ clickF: 3200, click: 0.25, tones: [[2800, 0.08, 0.07], [4150, 0.06, 0.05]] }),
+    blunt_swing: whoosh("blunt", 220, 760, 0.28, 1.1, 1.5),
+    blunt_hit: fleshHit({ slap: 0.35, slapF: 900, thud: 1, thudF: 70, thudD: 0.18, crack: 0.3 }),
+    blunt_hit_object: knock({ clickF: 1400, click: 0.35, tones: [[300, 0.12, 0.25], [760, 0.08, 0.12]] }),
+    axe_swing: whoosh("chop", 190, 620, 0.3, 1.2, 1.4),
+    axe_chop: fleshHit({ slap: 0.3, slapF: 1400, thud: 0.75, thudF: 140, thudD: 0.1, crack: 0.35, wet: 0.45 }),
+    axe_hit_object: knock({ clickF: 2200, click: 0.4, tones: [[1500, 0.15, 0.1], [2300, 0.1, 0.06], [140, 0.1, 0.35]] })
+  };
+  var BODY_BUS = { player_hurt: "voices", player_death: "voices", player_breath_run: "voices", fall_damage: "voices" };
+  var built = [
+    ...SURFACE_IDS.flatMap((surface) => GAIT_IDS.map((gait) => footstep(surface, gait))),
+    ...SURFACE_IDS.flatMap((surface) => LANDING_IDS.map((l) => landing(surface, l))),
+    ...BODY_SOUND_IDS.map((id) => takes(id, BODY[id], BODY_FALLOFF, id.endsWith("_swing") ? [0.94, 1.06] : [0.96, 1.04], BODY_BUS[id]))
+  ];
+  var BODY_FOLEY_BANK = {
+    id: "body_foley",
+    sounds: built.flatMap((entry) => entry.sounds),
+    sets: built.map((entry) => entry.set)
   };
+  var BODY_FOLEY_SET_IDS = [...FOOTSTEP_SOUND_IDS, ...LAND_SOUND_IDS, ...BODY_SOUND_IDS];
 
   // src/audio/recipes.ts
   var scene = (id, layers, line, vars) => sceneRecipe(id, layers, line, vars ? { vars } : {});